Ticket #254: menu.diff

File menu.diff, 16.0 KB (added by aldeck, 16 years 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