Ticket #254: menu.diff

File menu.diff, 16.0 KB (added by aldeck, 12 months ago)

Menu preflet should behave correctly with this.

  • src/preferences/menu/ColorWindow.cpp

     
    99 
    1010 
    1111#include "ColorWindow.h" 
     12#include "MenuSettings.h" 
    1213#include "msg.h" 
    1314 
    1415#include <Application.h> 
    … …  
    2223                B_NOT_ZOOMABLE | B_NOT_RESIZABLE), 
    2324        fOwner(owner) 
    2425{ 
    25         // Set and collect the variables for revert 
    26         get_menu_info(&fInfo); 
    27         get_menu_info(&fRevertInfo); 
     26        fCurrentColor = MenuSettings::GetInstance()->BackgroundColor(); 
     27        fPreviousColor = MenuSettings::GetInstance()->PreviousBackgroundColor(); 
     28        fDefaultColor = MenuSettings::GetInstance()->DefaultBackgroundColor(); 
    2829 
    2930        BView *topView = new BView(Bounds(), "topView", B_FOLLOW_ALL_SIDES, 0); 
    3031        topView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); 
    … …  
    3233 
    3334        fColorControl = new BColorControl(BPoint(10, 10), B_CELLS_32x8,  
    3435                9, "COLOR", new BMessage(MENU_COLOR), true); 
    35         fColorControl->SetValue(fInfo.background_color); 
     36        fColorControl->SetValue(fCurrentColor); 
    3637        fColorControl->ResizeToPreferred(); 
    3738        topView->AddChild(fColorControl); 
    3839 
    … …  
    4445                new BMessage(MENU_COLOR_DEFAULT), B_FOLLOW_LEFT | B_FOLLOW_TOP,  
    4546                B_WILL_DRAW | B_NAVIGABLE); 
    4647        fDefaultButton->ResizeToPreferred(); 
    47         fDefaultButton->SetEnabled(false); 
     48        fDefaultButton->SetEnabled(fCurrentColor != fDefaultColor); 
    4849        topView->AddChild(fDefaultButton); 
    4950 
    5051        rect.OffsetBy(fDefaultButton->Bounds().Width() + 10, 0); 
    … …  
    5253                new BMessage(MENU_REVERT), B_FOLLOW_LEFT | B_FOLLOW_TOP,  
    5354                B_WILL_DRAW | B_NAVIGABLE); 
    5455        fRevertButton->ResizeToPreferred(); 
    55         fRevertButton->SetEnabled(false); 
     56        fRevertButton->SetEnabled(fCurrentColor != fPreviousColor); 
    5657        topView->AddChild(fRevertButton); 
    5758 
    5859        ResizeTo(fColorControl->Bounds().Width() + 20, fRevertButton->Frame().bottom + 10); 
    … …  
    6869 
    6970 
    7071void 
     72ColorWindow::_UpdateAndPost() 
     73{ 
     74        fDefaultButton->SetEnabled(fCurrentColor != fDefaultColor); 
     75        fRevertButton->SetEnabled(fCurrentColor != fPreviousColor); 
     76         
     77        fCurrentColor = fColorControl->ValueAsColor(); 
     78                 
     79        menu_info info; 
     80        get_menu_info(&info); 
     81        info.background_color = fCurrentColor; 
     82        set_menu_info(&info); 
     83         
     84        be_app->PostMessage(MENU_COLOR);         
     85} 
     86 
     87 
     88void 
    7189ColorWindow::MessageReceived(BMessage *msg) 
    7290{ 
    7391        switch (msg->what) { 
    7492                case MENU_REVERT: 
    75                         fColorControl->SetValue(fRevertInfo.background_color); 
    76                         fInfo.background_color = fColorControl->ValueAsColor(); 
    77                         set_menu_info(&fInfo); 
    78                         be_app->PostMessage(UPDATE_WINDOW); 
    79                         fRevertButton->SetEnabled(false); 
     93                        fColorControl->SetValue(fPreviousColor); 
     94                        _UpdateAndPost(); 
    8095                        break; 
    8196 
    82                 case MENU_COLOR_DEFAULT: 
    83                         // change to system color for system wide 
    84                         // compatability 
    85                         rgb_color color; 
    86                         color.red = 216; 
    87                         color.blue = 216; 
    88                         color.green = 216; 
    89                         color.alpha = 255; 
    90                         fColorControl->SetValue(color); 
    91                         fDefaultButton->SetEnabled(false); 
    92                         get_menu_info(&fInfo); 
    93                         fInfo.background_color = fColorControl->ValueAsColor(); 
    94                         set_menu_info(&fInfo); 
    95                         be_app->PostMessage(MENU_COLOR); 
     97                case MENU_COLOR_DEFAULT:                         
     98                        fColorControl->SetValue(fDefaultColor); 
     99                        _UpdateAndPost(); 
    96100                        break; 
    97101 
    98102                case MENU_COLOR: 
    99                         get_menu_info(&fInfo); 
    100                         fRevertInfo.background_color = fInfo.background_color; 
    101                         fInfo.background_color = fColorControl->ValueAsColor(); 
    102                         set_menu_info(&fInfo); 
    103                         be_app->PostMessage(MENU_COLOR); 
    104                         fDefaultButton->SetEnabled(true); 
    105                         fRevertButton->SetEnabled(true); 
     103                        _UpdateAndPost();                        
    106104                        break; 
    107105 
    108106                default: 
    109                         be_app->PostMessage(UPDATE_WINDOW); 
    110107                        BWindow::MessageReceived(msg); 
    111108                        break; 
    112109        } 

  • src/preferences/menu/ColorWindow.h

     
    2727                virtual void Quit(); 
    2828                virtual void MessageReceived(BMessage* message); 
    2929 
     30        private: 
     31                void            _UpdateAndPost(); 
     32 
    3033        private:         
    31                 BColorControl*          fColorControl; 
     34                BColorControl*  fColorControl; 
    3235                BButton*                fDefaultButton; 
    33                 BButton*                fRevertButton; 
    34                 menu_info               fRevertInfo; 
    35                 menu_info               fInfo; 
     36                BButton*                fRevertButton;           
     37                rgb_color               fCurrentColor; 
     38                rgb_color               fPreviousColor; 
     39                rgb_color               fDefaultColor;   
    3640                BMessenger              fOwner; 
    3741}; 
    3842 

  • src/preferences/menu/MenuBar.cpp

     
    2020#include <TranslationUtils.h>    
    2121#include <Window.h> 
    2222 
    23 #include <stdio.h> 
    24 #include <stdlib.h> 
    2523 
    26  
    2724MenuBar::MenuBar() 
    2825        : BMenuBar(BRect(40, 10, 10, 10), "menu", B_FOLLOW_TOP | B_FRAME_EVENTS, 
    2926                B_ITEMS_IN_COLUMN, true) 
    3027{ 
    31         _BuildMenu(); 
    32         UpdateMenu(); 
     28        _BuildMenu();    
    3329        SetItemMargins(14.0, 2.0, 20.0, 0.0); 
    3430} 
    3531 
    … …  
    8177 
    8278 
    8379void 
    84 MenuBar::UpdateMenu() 
     80MenuBar::Update() 
    8581{ 
    8682        menu_info info; 
    8783        MenuSettings::GetInstance()->Get(info); 
    8884 
    8985        fAlwaysShowTriggersItem->SetMarked(info.triggers_always_shown); 
    9086 
    91         key_map *keys;  
    92         char* chars;  
    93         get_key_map(&keys, &chars);  
    94  
    95         bool altAsShortcut = (keys->left_command_key == 0x5d)  
    96                 && (keys->right_command_key == 0x5f);  
    97  
    98         free(chars);  
    99         free(keys); 
    100  
     87        bool altAsShortcut = MenuSettings::GetInstance()->AltAsShortcut(); 
    10188        fAltAsShortcutItem->SetMarked(altAsShortcut);  
    10289        fControlAsShortcutItem->SetMarked(!altAsShortcut);  
    103 } 
    10490 
    105  
    106 void 
    107 MenuBar::Update() 
    108 { 
    109         UpdateMenu(); 
    110  
    11191        BFont font; 
    11292        if (LockLooper()) { 
    113                 menu_info info; 
    114                 MenuSettings::GetInstance()->Get(info); 
    115  
    11693                font.SetFamilyAndStyle(info.f_family, info.f_style); 
    11794                font.SetSize(info.font_size); 
    11895                SetFont(&font); 

  • src/preferences/menu/MenuBar.h

     
    1818                MenuBar(); 
    1919 
    2020                virtual void AttachedToWindow(); 
    21  
    22                 void UpdateMenu(); 
     21                                 
    2322                void Update(); 
    2423                virtual void FrameResized(float width, float height); 
    2524 

  • src/preferences/menu/MenuSettings.cpp

     
    99 
    1010 
    1111#include "MenuSettings.h" 
     12#include <Roster.h> 
     13#include <Errors.h> 
     14#include <stdio.h> 
     15#include <stdlib.h> 
    1216 
    1317  
    1418MenuSettings::MenuSettings() 
    … …  
    1721        // would provide and execute this information, as it does 
    1822        // for get_menu_info and set_menu_info (or is this information 
    1923        // coming from libbe.so? or else where?).  
    20         fDefaultSettings.font_size = 12; 
    21         //info.f_family = "test"; 
    22         //info.f_style = "test"; 
    23         fDefaultSettings.background_color = ui_color(B_MENU_BACKGROUND_COLOR); 
     24        fDefaultSettings.font_size = 12;         
     25        sprintf(fDefaultSettings.f_family,"%s","Bitstream Vera Sans"); 
     26        sprintf(fDefaultSettings.f_style,"%s","Roman"); 
     27        rgb_color color; 
     28        color.red = 216; 
     29        color.blue = 216; 
     30        color.green = 216; 
     31        color.alpha = 255; 
     32        fDefaultSettings.background_color = color;//ui_color(B_MENU_BACKGROUND_COLOR); 
    2433        fDefaultSettings.separator = 0; 
    2534        fDefaultSettings.click_to_open = true; 
    2635        fDefaultSettings.triggers_always_shown = false; 
    27  
    28         fPreviousSettings = fDefaultSettings; 
     36        fDefaultAltAsShortcut = true; 
     37         
     38        get_menu_info(&fPreviousSettings); 
     39        fPreviousAltAsShortcut = AltAsShortcut(); 
    2940} 
    3041 
    3142 
    … …  
    5566void 
    5667MenuSettings::Set(menu_info &info) 
    5768{ 
    58         get_menu_info(&fPreviousSettings); 
    5969        set_menu_info(&info); 
    6070} 
    6171 
    6272 
     73bool 
     74MenuSettings::AltAsShortcut() const 
     75{ 
     76        key_map *keys;  
     77        char* chars;  
     78         
     79        get_key_map(&keys, &chars); 
     80        bool altAsShortcut = (keys->left_command_key == 0x5d)  
     81                && (keys->right_command_key == 0x5f);  
     82 
     83        free(chars); 
     84        free(keys); 
     85         
     86        return altAsShortcut;    
     87} 
     88 
     89 
    6390void 
     91MenuSettings::SetAltAsShortcut(bool altAsShortcut) 
     92{ 
     93        if (altAsShortcut) { 
     94                // This might not be the same for all keyboards 
     95                set_modifier_key(B_LEFT_COMMAND_KEY, 0x5d); 
     96                set_modifier_key(B_RIGHT_COMMAND_KEY, 0x5f); 
     97                set_modifier_key(B_LEFT_CONTROL_KEY, 0x5c); 
     98                set_modifier_key(B_RIGHT_OPTION_KEY, 0x60); 
     99        } else { 
     100                // This might not be the same for all keyboards 
     101                set_modifier_key(B_LEFT_COMMAND_KEY, 0x5c); 
     102                set_modifier_key(B_RIGHT_COMMAND_KEY, 0x60); 
     103                set_modifier_key(B_LEFT_CONTROL_KEY, 0x5d); 
     104                set_modifier_key(B_RIGHT_OPTION_KEY, 0x5f); 
     105        } 
     106        be_roster->Broadcast(new BMessage(B_MODIFIERS_CHANGED));         
     107} 
     108 
     109 
     110void 
    64111MenuSettings::Revert() 
    65112{ 
    66113        set_menu_info(&fPreviousSettings); 
     114        SetAltAsShortcut(fPreviousAltAsShortcut); 
    67115} 
    68116 
    69117 
    70118void 
    71119MenuSettings::ResetToDefaults() 
    72120{ 
    73         get_menu_info(&fPreviousSettings); 
    74121        set_menu_info(&fDefaultSettings); 
     122        SetAltAsShortcut(fDefaultAltAsShortcut); 
    75123} 
    76124 
    77125 
     126rgb_color 
     127MenuSettings::BackgroundColor() const 
     128{ 
     129        menu_info info; 
     130        get_menu_info(&info);    
     131        return info.background_color; 
     132} 
     133 
     134 
     135rgb_color 
     136MenuSettings::PreviousBackgroundColor() const 
     137{ 
     138        return fPreviousSettings.background_color; 
     139} 
     140 
     141 
     142rgb_color 
     143MenuSettings::DefaultBackgroundColor() const 
     144{ 
     145        return fDefaultSettings.background_color; 
     146} 
     147 
     148 
    78149bool 
    79150MenuSettings::IsDefaultable() 
    80151{ 
    … …  
    82153        get_menu_info(&info); 
    83154 
    84155        return info.font_size !=  fDefaultSettings.font_size 
     156                || strcmp(info.f_family, fDefaultSettings.f_family) != 0 
     157                || strcmp(info.f_style, fDefaultSettings.f_style) != 0 
    85158                || info.background_color != fDefaultSettings.background_color 
    86159                || info.separator != fDefaultSettings.separator 
    87160                || info.click_to_open != fDefaultSettings.click_to_open 
    88                 || info.triggers_always_shown != fDefaultSettings.triggers_always_shown; 
     161                || info.triggers_always_shown != fDefaultSettings.triggers_always_shown 
     162                || AltAsShortcut() != fDefaultAltAsShortcut; 
    89163} 
    90164 
     165 
     166bool 
     167MenuSettings::IsRevertable() 
     168{ 
     169        menu_info info; 
     170        get_menu_info(&info); 
     171 
     172        return info.font_size !=  fPreviousSettings.font_size 
     173                || strcmp(info.f_family, fPreviousSettings.f_family) != 0 
     174                || strcmp(info.f_style, fPreviousSettings.f_style) != 0 
     175                || info.background_color != fPreviousSettings.background_color 
     176                || info.separator != fPreviousSettings.separator 
     177                || info.click_to_open != fPreviousSettings.click_to_open 
     178                || info.triggers_always_shown != fPreviousSettings.triggers_always_shown 
     179                || AltAsShortcut() != fPreviousAltAsShortcut; 
     180} 
     181 

  • src/preferences/menu/MenuSettings.h

     
    1818 
    1919                void Get(menu_info &info) const; 
    2020                void Set(menu_info &info); 
     21                 
     22                bool            AltAsShortcut() const; 
     23                void            SetAltAsShortcut(bool altAsShortcut);    
     24                 
     25                rgb_color       BackgroundColor() const;                 
     26                rgb_color       PreviousBackgroundColor() const; 
     27                rgb_color       DefaultBackgroundColor() const; 
     28         
    2129 
    2230                void Revert(); 
    2331                void ResetToDefaults(); 
    2432                bool IsDefaultable(); 
    25  
     33                bool IsRevertable(); 
     34                                 
    2635        private: 
    2736                MenuSettings(); 
    2837                ~MenuSettings(); 
    2938 
    3039                menu_info fPreviousSettings; 
    31                 menu_info fDefaultSettings;      
     40                menu_info fDefaultSettings; 
     41                bool      fPreviousAltAsShortcut; 
     42                bool      fDefaultAltAsShortcut; 
    3243}; 
    3344 
    3445#endif  // MENU_SETTINGS_H 

  • src/preferences/menu/MenuWindow.cpp

     
    2020#include <Box.h> 
    2121#include <Button.h> 
    2222#include <MenuItem.h> 
    23 #include <Roster.h> 
    2423 
    2524#include <stdio.h> 
    2625#include <string.h> 
    … …  
    3130                B_NOT_ZOOMABLE | B_NOT_RESIZABLE | B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE) 
    3231{ 
    3332        fColorWindow = NULL; 
     33         
     34        fSettings = MenuSettings::GetInstance(); 
    3435 
    3536        BView* topView = new BView(Bounds(), "menuView", B_FOLLOW_ALL_SIDES, 
    3637                B_WILL_DRAW); 
    … …  
    6061        topView->AddChild(fRevertButton); 
    6162 
    6263        topView->MakeFocus(); 
    63         fMenuBar->Update(); 
     64         
     65        _UpdateAll(); 
    6466} 
    6567 
    6668 
    6769void 
    6870MenuWindow::MessageReceived(BMessage *msg) 
    6971{ 
    70         MenuSettings *settings = MenuSettings::GetInstance(); 
    7172        menu_info info; 
    7273 
    7374        switch (msg->what) { 
    7475                case MENU_REVERT: 
    75                         settings->Revert(); 
    76  
    77                         fRevertButton->SetEnabled(false); 
    78                         fDefaultsButton->SetEnabled(settings->IsDefaultable()); 
    79                         fMenuBar->Update(); 
     76                        fSettings->Revert(); 
     77                        _UpdateAll(); 
    8078                        break; 
    8179 
    8280                case MENU_DEFAULT: 
    83                         settings->ResetToDefaults(); 
    84  
    85                         fDefaultsButton->SetEnabled(false); 
    86                         fMenuBar->Update(); 
     81                        fSettings->ResetToDefaults(); 
     82                        _UpdateAll(); 
    8783                        break; 
    8884 
    8985                case UPDATE_WINDOW: 
    90                         fMenuBar->Update(); 
     86                        _UpdateAll(); 
    9187                        break; 
    9288 
    9389                case MENU_FONT_FAMILY: 
    … …  
    9894                        const font_style *style; 
    9995                        msg->FindString("style", (const char **)&style); 
    10096 
    101                         settings->Get(info); 
     97                        fSettings->Get(info); 
    10298                        strlcpy(info.f_family, (const char *)family, B_FONT_FAMILY_LENGTH); 
    10399                        strlcpy(info.f_style, (const char *)style, B_FONT_STYLE_LENGTH); 
    104                         settings->Set(info); 
     100                        fSettings->Set(info); 
    105101 
    106                         fRevertButton->SetEnabled(true); 
    107                         fDefaultsButton->SetEnabled(settings->IsDefaultable()); 
    108                         fMenuBar->Update(); 
     102                        _UpdateAll(); 
    109103                        break; 
    110104                } 
    111105 
    112106                case MENU_FONT_SIZE: 
    113                         settings->Get(info); 
     107                        fSettings->Get(info); 
    114108                        msg->FindFloat("size", &info.font_size); 
    115                         settings->Set(info); 
     109                        fSettings->Set(info); 
    116110 
    117                         fRevertButton->SetEnabled(true); 
    118                         fDefaultsButton->SetEnabled(settings->IsDefaultable()); 
    119                         fMenuBar->Update(); 
     111                        _UpdateAll(); 
    120112                        break; 
    121113 
    122114                case ALLWAYS_TRIGGERS_MSG: 
    123                         settings->Get(info); 
     115                        fSettings->Get(info); 
    124116                        info.triggers_always_shown = !info.triggers_always_shown; 
    125                         settings->Set(info); 
     117                        fSettings->Set(info); 
    126118 
    127                         fRevertButton->SetEnabled(true); 
    128                         fDefaultsButton->SetEnabled(settings->IsDefaultable()); 
    129                         fMenuBar->UpdateMenu(); 
    130                         fMenuBar->Update(); 
     119                        _UpdateAll(); 
    131120                        break; 
    132121 
    133                 case CTL_MARKED_MSG: 
    134                         // This might not be the same for all keyboards 
    135                         set_modifier_key(B_LEFT_COMMAND_KEY, 0x5c); 
    136                         set_modifier_key(B_RIGHT_COMMAND_KEY, 0x60); 
    137                         set_modifier_key(B_LEFT_CONTROL_KEY, 0x5d); 
    138                         set_modifier_key(B_RIGHT_OPTION_KEY, 0x5f); 
    139                         be_roster->Broadcast(new BMessage(B_MODIFIERS_CHANGED)); 
    140  
    141                         fRevertButton->SetEnabled(true); 
    142                         fDefaultsButton->SetEnabled(settings->IsDefaultable()); 
    143                         fMenuBar->Update(); 
     122                case CTL_MARKED_MSG:                     
     123                        fSettings->SetAltAsShortcut(false); 
     124                        _UpdateAll(); 
    144125                        break; 
    145126 
    146127                case ALT_MARKED_MSG: 
    147  
    148                         // This might not be the same for all keyboards 
    149                         set_modifier_key(B_LEFT_COMMAND_KEY, 0x5d); 
    150                         set_modifier_key(B_RIGHT_COMMAND_KEY, 0x5f); 
    151                         set_modifier_key(B_LEFT_CONTROL_KEY, 0x5c); 
    152                         set_modifier_key(B_RIGHT_OPTION_KEY, 0x60); 
    153  
    154                         be_roster->Broadcast(new BMessage(B_MODIFIERS_CHANGED)); 
    155  
    156                         fRevertButton->SetEnabled(true); 
    157                         fDefaultsButton->SetEnabled(settings->IsDefaultable()); 
    158                         fMenuBar->Update(); 
     128                        fSettings->SetAltAsShortcut(true);                       
     129                        _UpdateAll(); 
    159130                        break; 
    160131 
    161132                case COLOR_SCHEME_OPEN_MSG: 
    … …  
    170141                        fColorWindow = NULL; 
    171142                        break; 
    172143 
    173                 case MENU_COLOR: 
    174                         fRevertButton->SetEnabled(true); 
    175                         fDefaultsButton->SetEnabled(settings->IsDefaultable()); 
    176                         fMenuBar->Update(); 
     144                case MENU_COLOR:                         
     145                        _UpdateAll(); 
    177146                        break; 
    178147 
    179148                default: 
    … …  
    183152} 
    184153 
    185154 
     155void 
     156MenuWindow::_UpdateAll() 
     157{ 
     158        fRevertButton->SetEnabled(fSettings->IsRevertable()); 
     159        fDefaultsButton->SetEnabled(fSettings->IsDefaultable()); 
     160        fMenuBar->Update(); 
     161} 
     162 
     163 
    186164bool 
    187165MenuWindow::QuitRequested() 
    188166{ 

  • src/preferences/menu/MenuWindow.h

     
    1010#ifndef MENU_WINDOW_H 
    1111#define MENU_WINDOW_H 
    1212 
    13  
     13#include "MenuSettings.h" 
    1414#include <Menu.h> 
    1515#include <Window.h> 
    1616 
    … …  
    2020class MenuBar; 
    2121class MenuWindow : public BWindow { 
    2222        public: 
    23                 MenuWindow(BRect frame); 
     23                MenuWindow(BRect frame);                 
    2424                 
    2525                virtual void MessageReceived(BMessage *message); 
    2626                virtual bool QuitRequested(); 
    27  
     27                 
     28        private:                 
     29                void _UpdateAll(); 
     30                 
    2831        private:         
    2932                ColorWindow*    fColorWindow; 
    3033                MenuBar*                fMenuBar; 
    3134                BButton*                fDefaultsButton; 
    3235                BButton*                fRevertButton; 
     36                MenuSettings*   fSettings; 
    3337}; 
    3438 
    3539#endif  // MENU_WINDOW_H