diff --git a/src/preferences/keymap/Jamfile b/src/preferences/keymap/Jamfile index 1fde8ed9d8..9d1165b62c 100644 --- a/src/preferences/keymap/Jamfile +++ b/src/preferences/keymap/Jamfile @@ -11,6 +11,7 @@ Preference Keymap : KeymapApplication.cpp KeymapListItem.cpp KeymapWindow.cpp + ModifierKeysWindow.cpp : be tracker $(HAIKU_LOCALE_LIBS) libshared.a $(TARGET_LIBSTDC++) : Keymap.rdef diff --git a/src/preferences/keymap/KeymapApplication.cpp b/src/preferences/keymap/KeymapApplication.cpp index 502fb0c517..7d5f1bc33d 100644 --- a/src/preferences/keymap/KeymapApplication.cpp +++ b/src/preferences/keymap/KeymapApplication.cpp @@ -7,11 +7,13 @@ * Jérôme Duval */ + #include "KeymapApplication.h" KeymapApplication::KeymapApplication() - : BApplication("application/x-vnd.Haiku-Keymap") + : BApplication("application/x-vnd.Haiku-Keymap"), + fModifierKeysWindow(NULL) { // create the window fWindow = new KeymapWindow(); @@ -22,10 +24,34 @@ KeymapApplication::KeymapApplication() void KeymapApplication::MessageReceived(BMessage* message) { + switch (message->what) { + case kMsgShowModifierKeysWindow: + _ShowModifierKeysWindow(); + break; + case kMsgCloseModifierKeysWindow: + fModifierKeysWindow = NULL; + break; + case kMsgUpdateModifiers: + fWindow->PostMessage(message); + break; + } + BApplication::MessageReceived(message); } +void +KeymapApplication::_ShowModifierKeysWindow() +{ + if (fModifierKeysWindow) + fModifierKeysWindow->Activate(); + else { + fModifierKeysWindow = new ModifierKeysWindow(); + fModifierKeysWindow->Show(); + } +} + + // #pragma mark - diff --git a/src/preferences/keymap/KeymapApplication.h b/src/preferences/keymap/KeymapApplication.h index 5e63315289..7b00638ff0 100644 --- a/src/preferences/keymap/KeymapApplication.h +++ b/src/preferences/keymap/KeymapApplication.h @@ -12,6 +12,7 @@ #include "KeymapWindow.h" +#include "ModifierKeysWindow.h" #include #include @@ -19,15 +20,24 @@ #include +static const uint32 kMsgShowModifierKeysWindow = 'smkw'; +static const uint32 kMsgCloseModifierKeysWindow = 'hmkw'; +static const uint32 kMsgUpdateModifiers = 'upmd'; + + class KeymapApplication : public BApplication { - public: +public: KeymapApplication(); - void MessageReceived(BMessage* message); - bool UseKeymap(BEntry* keymap); + void MessageReceived(BMessage* message); + bool UseKeymap(BEntry* keymap); - private: - KeymapWindow* fWindow; +protected: + void _ShowModifierKeysWindow(); + +private: + KeymapWindow* fWindow; + ModifierKeysWindow* fModifierKeysWindow; }; #endif // KEYMAP_APPLICATION_H diff --git a/src/preferences/keymap/KeymapWindow.cpp b/src/preferences/keymap/KeymapWindow.cpp index daa368c921..fccf5bfc26 100644 --- a/src/preferences/keymap/KeymapWindow.cpp +++ b/src/preferences/keymap/KeymapWindow.cpp @@ -39,6 +39,7 @@ #include "KeymapListItem.h" +#undef B_TRANSLATE_CONTEXT #define B_TRANSLATE_CONTEXT "Keymap window" @@ -55,7 +56,7 @@ static const uint32 kMsgSystemMapSelected = 'SmST'; static const uint32 kMsgUserMapSelected = 'UmST'; static const uint32 kMsgRevertKeymap = 'Rvrt'; -static const uint32 kMsgKeymapUpdated = 'upkM'; +static const uint32 kMsgKeymapUpdated = 'kMup'; static const uint32 kMsgDeadKeyAcuteChanged = 'dkAc'; static const uint32 kMsgDeadKeyCircumflexChanged = 'dkCc'; @@ -222,6 +223,9 @@ KeymapWindow::MessageReceived(BMessage* message) case kMsgMenuFileSaveAs: fSavePanel->Show(); break; + case kMsgShowModifierKeysWindow: + be_app->PostMessage(kMsgShowModifierKeysWindow); + break; case kChangeKeyboardLayout: { @@ -293,6 +297,36 @@ KeymapWindow::MessageReceived(BMessage* message) _UpdateButtons(); break; + case kMsgUpdateModifiers: + { + uint32 keycode; + + if (message->FindUInt32("caps_key", &keycode) == B_OK) + fCurrentMap.Map().caps_key = keycode; + + if (message->FindUInt32("left_control_key", &keycode) == B_OK) + fCurrentMap.Map().left_control_key = keycode; + + if (message->FindUInt32("right_control_key", &keycode) == B_OK) + fCurrentMap.Map().right_control_key = keycode; + + if (message->FindUInt32("left_option_key", &keycode) == B_OK) + fCurrentMap.Map().left_option_key = keycode; + + if (message->FindUInt32("right_option_key", &keycode) == B_OK) + fCurrentMap.Map().right_option_key = keycode; + + if (message->FindUInt32("left_command_key", &keycode) == B_OK) + fCurrentMap.Map().left_command_key = keycode; + + if (message->FindUInt32("right_command_key", &keycode) == B_OK) + fCurrentMap.Map().right_command_key = keycode; + + _UpdateButtons(); + fKeyboardLayoutView->SetKeymap(&fCurrentMap); + break; + } + case kMsgKeymapUpdated: _UpdateButtons(); fSystemListView->DeselectAll(); @@ -380,10 +414,13 @@ KeymapWindow::_CreateMenu() BMenu* menu = new BMenu(B_TRANSLATE("File")); menu->AddItem(new BMenuItem(B_TRANSLATE("Open" B_UTF8_ELLIPSIS), new BMessage(kMsgMenuFileOpen), 'O')); - menu->AddSeparatorItem(); menu->AddItem(new BMenuItem(B_TRANSLATE("Save as" B_UTF8_ELLIPSIS), new BMessage(kMsgMenuFileSaveAs))); menu->AddSeparatorItem(); + menu->AddItem(new BMenuItem( + B_TRANSLATE("Set Modifiers Keys" B_UTF8_ELLIPSIS), + new BMessage(kMsgShowModifierKeysWindow))); + menu->AddSeparatorItem(); menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"), new BMessage(B_QUIT_REQUESTED), 'Q')); menuBar->AddItem(menu); diff --git a/src/preferences/keymap/KeymapWindow.h b/src/preferences/keymap/KeymapWindow.h index acb0305455..a61f23b6a5 100644 --- a/src/preferences/keymap/KeymapWindow.h +++ b/src/preferences/keymap/KeymapWindow.h @@ -31,7 +31,7 @@ class KeymapListItem; class KeymapWindow : public BWindow { public: KeymapWindow(); - ~KeymapWindow(); + virtual ~KeymapWindow(); virtual bool QuitRequested(); virtual void MessageReceived(BMessage* message); diff --git a/src/preferences/keymap/ModifierKeysWindow.cpp b/src/preferences/keymap/ModifierKeysWindow.cpp new file mode 100644 index 0000000000..ac0b74242b --- /dev/null +++ b/src/preferences/keymap/ModifierKeysWindow.cpp @@ -0,0 +1,496 @@ +/* + * Copyright 2011 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Authors: + * John Scipione, jscipione@gmail.com + */ + +#include "ModifierKeysWindow.h" + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "KeymapApplication.h" + +enum { + MENU_ITEM_CAPS_LOCK, + MENU_ITEM_CONTROL, + MENU_ITEM_OPTION, + MENU_ITEM_COMMAND, + MENU_ITEM_SEPERATOR, + MENU_ITEM_DISABLED +}; + +#undef B_TRANSLATE_CONTEXT +#define B_TRANSLATE_CONTEXT "Modifier keys window" + + +static const uint32 kMsgCapsLockCapsLock = 'clcl'; +static const uint32 kMsgCapsLockControl = 'clct'; +static const uint32 kMsgCapsLockOption = 'clop'; +static const uint32 kMsgCapsLockCommand = 'clcm'; +static const uint32 kMsgCapsLockDisabled = 'clds'; + +static const uint32 kMsgControlCapsLock = 'ctcl'; +static const uint32 kMsgControlControl = 'ctct'; +static const uint32 kMsgControlOption = 'ctop'; +static const uint32 kMsgControlCommand = 'ctcm'; + +static const uint32 kMsgOptionCapsLock = 'opcl'; +static const uint32 kMsgOptionControl = 'opct'; +static const uint32 kMsgOptionOption = 'opop'; +static const uint32 kMsgOptionCommand = 'opcm'; + +static const uint32 kMsgCommmandCapsLock = 'cmcl'; +static const uint32 kMsgCommmandControl = 'cmct'; +static const uint32 kMsgCommmandOption = 'cmop'; +static const uint32 kMsgCommmandCommand = 'cmcm'; + +static const uint32 kMsgApplyModifiers = 'apmd'; +static const uint32 kMsgRevertModifiers = 'rvmd'; + + +ModifierKeysWindow::ModifierKeysWindow() + : + BWindow(BRect(80, 50, 400, 260), B_TRANSLATE("Modifiers Keys"), + B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE + | B_AUTO_UPDATE_SIZE_LIMITS) +{ + get_key_map(&fCurrentMap, &fCurrentBuffer); + get_key_map(&fSavedMap, &fSavedBuffer); + + BStringView* capsLockStringView + = new BStringView("caps", B_TRANSLATE("Caps Lock:")); + capsLockStringView->SetExplicitMaxSize( + BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET)); + + BStringView* controlStringView + = new BStringView("control", B_TRANSLATE("Control:")); + controlStringView->SetExplicitMaxSize( + BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET)); + + BStringView* optionStringView + = new BStringView("option", B_TRANSLATE("Option:")); + optionStringView->SetExplicitMaxSize( + BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET)); + + BStringView* commandStringView + = new BStringView("command", B_TRANSLATE("Command:")); + commandStringView->SetExplicitMaxSize( + BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET)); + + fCancelButton = new BButton("CancelButton", B_TRANSLATE("Cancel"), + new BMessage(B_QUIT_REQUESTED)); + + fRevertButton = new BButton("revertButton", B_TRANSLATE("Revert"), + new BMessage(kMsgRevertModifiers)); + fRevertButton->SetEnabled(false); + + fOkButton = new BButton("OkButton", B_TRANSLATE("Ok"), + new BMessage(kMsgApplyModifiers)); + fOkButton->MakeDefault(true); + + // Build the layout + SetLayout(new BGroupLayout(B_VERTICAL)); + + AddChild(BGroupLayoutBuilder(B_VERTICAL, 10) + .Add(BGridLayoutBuilder(10, 10) + .Add(capsLockStringView, 0, 0) + .Add(_CreateCapsLockMenuField(), 1, 0) + + .Add(controlStringView, 0, 1) + .Add(_CreateControlMenuField(), 1, 1) + + .Add(optionStringView, 0, 2) + .Add(_CreateOptionMenuField(), 1, 2) + + .Add(commandStringView, 0, 3) + .Add(_CreateCommandMenuField(), 1, 3) + ) + .AddGlue() + .AddGroup(B_HORIZONTAL, 10) + .Add(fCancelButton) + .AddGlue() + .Add(fRevertButton) + .Add(fOkButton) + .End() + .SetInsets(10, 10, 10, 10) + ); + + _MarkMenuItems(); + + CenterOnScreen(); +} + + +ModifierKeysWindow::~ModifierKeysWindow() +{ + be_app->PostMessage(kMsgCloseModifierKeysWindow); +} + + +void +ModifierKeysWindow::MessageReceived(BMessage* message) +{ + switch (message->what) { + // Caps Lock + case kMsgCapsLockCapsLock: + fCurrentMap->caps_key = 0x3b; + fCapsLockMenu->ItemAt(MENU_ITEM_CAPS_LOCK)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgCapsLockControl: + fCurrentMap->caps_key = 0x5c; + fCapsLockMenu->ItemAt(MENU_ITEM_CONTROL)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgCapsLockOption: + fCurrentMap->caps_key = 0x66; + fCapsLockMenu->ItemAt(MENU_ITEM_OPTION)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgCapsLockCommand: + fCurrentMap->caps_key = 0x5d; + fCapsLockMenu->ItemAt(MENU_ITEM_COMMAND)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgCapsLockDisabled: + fCurrentMap->caps_key = 0; + fCapsLockMenu->ItemAt(MENU_ITEM_DISABLED)->SetMarked(true); + _EnableRevertButton(); + break; + + // Control + case kMsgControlCapsLock: + fCurrentMap->left_control_key = 0x3b; + fControlMenu->ItemAt(MENU_ITEM_CAPS_LOCK)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgControlControl: + fCurrentMap->left_control_key = 0x5c; + fCurrentMap->right_control_key = 0x60; + fControlMenu->ItemAt(MENU_ITEM_CONTROL)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgControlOption: + fCurrentMap->left_control_key = 0x66; + fCurrentMap->right_control_key = 0x67; + fControlMenu->ItemAt(MENU_ITEM_OPTION)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgControlCommand: + fCurrentMap->left_control_key = 0x5d; + fCurrentMap->right_control_key = 0x5f; + fControlMenu->ItemAt(MENU_ITEM_COMMAND)->SetMarked(true); + _EnableRevertButton(); + break; + + // Option + case kMsgOptionCapsLock: + fCurrentMap->left_option_key = 0x3b; + fOptionMenu->ItemAt(MENU_ITEM_CAPS_LOCK)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgOptionControl: + fCurrentMap->left_option_key = 0x5c; + fCurrentMap->right_option_key = 0x60; + fOptionMenu->ItemAt(MENU_ITEM_CONTROL)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgOptionOption: + fCurrentMap->left_option_key = 0x66; + fCurrentMap->right_option_key = 0x67; + fOptionMenu->ItemAt(MENU_ITEM_OPTION)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgOptionCommand: + fCurrentMap->left_option_key = 0x5d; + fCurrentMap->right_option_key = 0x5f; + fOptionMenu->ItemAt(MENU_ITEM_COMMAND)->SetMarked(true); + _EnableRevertButton(); + break; + + // Command + case kMsgCommmandCapsLock: + fCurrentMap->left_command_key = 0x3b; + fCommandMenu->ItemAt(MENU_ITEM_CAPS_LOCK)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgCommmandControl: + fCurrentMap->left_command_key = 0x5c; + fCurrentMap->right_command_key = 0x60; + fCommandMenu->ItemAt(MENU_ITEM_CONTROL)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgCommmandOption: + fCurrentMap->left_command_key = 0x66; + fCurrentMap->right_command_key = 0x67; + fCommandMenu->ItemAt(MENU_ITEM_OPTION)->SetMarked(true); + _EnableRevertButton(); + break; + + case kMsgCommmandCommand: + fCurrentMap->left_command_key = 0x5d; + fCurrentMap->right_command_key = 0x5f; + fCommandMenu->ItemAt(MENU_ITEM_COMMAND)->SetMarked(true); + _EnableRevertButton(); + break; + + // Ok button + case kMsgApplyModifiers: + { + BMessage* updateModifiers = new BMessage(kMsgUpdateModifiers); + + if (fCurrentMap->caps_key != fSavedMap->caps_key) + updateModifiers->AddUInt32("caps_key", fCurrentMap->caps_key); + + if (fCurrentMap->left_control_key != fSavedMap->left_control_key) { + updateModifiers->AddUInt32("left_control_key", + fCurrentMap->left_control_key); + } + + if (fCurrentMap->right_control_key + != fSavedMap->right_control_key) { + updateModifiers->AddUInt32("right_control_key", + fCurrentMap->right_control_key); + } + + if (fCurrentMap->left_option_key != fSavedMap->left_option_key) { + updateModifiers->AddUInt32("left_option_key", + fCurrentMap->left_option_key); + } + + if (fCurrentMap->right_option_key != fSavedMap->right_option_key) { + updateModifiers->AddUInt32("right_option_key", + fCurrentMap->right_option_key); + } + + if (fCurrentMap->left_command_key != fSavedMap->left_command_key) { + updateModifiers->AddUInt32("left_command_key", + fCurrentMap->left_command_key); + } + + if (fCurrentMap->right_command_key + != fSavedMap->right_command_key) { + updateModifiers->AddUInt32("right_command_key", + fCurrentMap->right_command_key); + } + + be_app->PostMessage(updateModifiers); + this->PostMessage(B_QUIT_REQUESTED); + break; + } + + // Revert button + case kMsgRevertModifiers: + fCurrentMap->caps_key = fSavedMap->caps_key; + fCurrentMap->left_control_key = fSavedMap->left_control_key; + fCurrentMap->right_control_key = fSavedMap->right_control_key; + fCurrentMap->left_option_key = fSavedMap->left_option_key; + fCurrentMap->right_option_key = fSavedMap->right_option_key; + fCurrentMap->left_command_key = fSavedMap->left_command_key; + fCurrentMap->right_command_key = fSavedMap->right_command_key; + + _MarkMenuItems(); + fRevertButton->SetEnabled(false); + break; + + default: + BWindow::MessageReceived(message); + } +} + + +BMenuField* +ModifierKeysWindow::_CreateCapsLockMenuField() +{ + fCapsLockMenu = new BPopUpMenu(B_TRANSLATE("Caps Lock"), true, true); + + BMenuItem* capsLock = new BMenuItem(B_TRANSLATE("Caps Lock"), + new BMessage(kMsgCapsLockCapsLock)); + fCapsLockMenu->AddItem(capsLock, MENU_ITEM_CAPS_LOCK); + + BMenuItem* control = new BMenuItem(B_TRANSLATE("Control"), + new BMessage(kMsgCapsLockControl)); + fCapsLockMenu->AddItem(control, MENU_ITEM_CONTROL); + + BMenuItem* option = new BMenuItem(B_TRANSLATE("Option"), + new BMessage(kMsgCapsLockOption)); + fCapsLockMenu->AddItem(option, MENU_ITEM_OPTION); + + BMenuItem* command = new BMenuItem(B_TRANSLATE("Command"), + new BMessage(kMsgCapsLockCommand)); + fCapsLockMenu->AddItem(command, MENU_ITEM_COMMAND); + + BSeparatorItem* separator = new BSeparatorItem; + fCapsLockMenu->AddItem(separator, MENU_ITEM_SEPERATOR); + + BMenuItem* disabled = new BMenuItem(B_TRANSLATE("Disabled"), + new BMessage(kMsgCapsLockDisabled)); + fCapsLockMenu->AddItem(disabled, MENU_ITEM_DISABLED); + + return new BMenuField(NULL, fCapsLockMenu); +} + + +BMenuField* +ModifierKeysWindow::_CreateControlMenuField() +{ + fControlMenu = new BPopUpMenu(B_TRANSLATE("Control"), true, true); + + BMenuItem* capsLock = new BMenuItem(B_TRANSLATE("Caps Lock"), + new BMessage(kMsgControlCapsLock)); + fControlMenu->AddItem(capsLock, MENU_ITEM_CAPS_LOCK); + + BMenuItem* control = new BMenuItem(B_TRANSLATE("Control"), + new BMessage(kMsgControlControl)); + fControlMenu->AddItem(control, MENU_ITEM_CONTROL); + + BMenuItem* option = new BMenuItem(B_TRANSLATE("Option"), + new BMessage(kMsgControlOption)); + fControlMenu->AddItem(option, MENU_ITEM_OPTION); + + BMenuItem* command = new BMenuItem(B_TRANSLATE("Command"), + new BMessage(kMsgControlCommand)); + fControlMenu->AddItem(command, MENU_ITEM_COMMAND); + + return new BMenuField(NULL, fControlMenu); +} + + +BMenuField* +ModifierKeysWindow::_CreateOptionMenuField() +{ + fOptionMenu = new BPopUpMenu(B_TRANSLATE("Option"), true, true); + + BMenuItem* capsLock = new BMenuItem(B_TRANSLATE("Caps Lock"), + new BMessage(kMsgOptionCapsLock)); + fOptionMenu->AddItem(capsLock, MENU_ITEM_CAPS_LOCK); + + BMenuItem* control = new BMenuItem(B_TRANSLATE("Control"), + new BMessage(kMsgOptionControl)); + fOptionMenu->AddItem(control, MENU_ITEM_CONTROL); + + BMenuItem* option = new BMenuItem(B_TRANSLATE("Option"), + new BMessage(kMsgOptionOption)); + fOptionMenu->AddItem(option, MENU_ITEM_OPTION); + + BMenuItem* command = new BMenuItem(B_TRANSLATE("Command"), + new BMessage(kMsgOptionCommand)); + fOptionMenu->AddItem(command, MENU_ITEM_COMMAND); + + return new BMenuField(NULL, fOptionMenu); +} + + +BMenuField* +ModifierKeysWindow::_CreateCommandMenuField() +{ + fCommandMenu = new BPopUpMenu(B_TRANSLATE("Command"), true, true); + + BMenuItem* capsLock = new BMenuItem(B_TRANSLATE("Caps Lock"), + new BMessage(kMsgCommmandCapsLock)); + fCommandMenu->AddItem(capsLock, MENU_ITEM_CAPS_LOCK); + + BMenuItem* control = new BMenuItem(B_TRANSLATE("Control"), + new BMessage(kMsgCommmandControl)); + fCommandMenu->AddItem(control, MENU_ITEM_CONTROL); + + BMenuItem* option = new BMenuItem(B_TRANSLATE("Option"), + new BMessage(kMsgCommmandOption)); + fCommandMenu->AddItem(option, MENU_ITEM_OPTION); + + BMenuItem* command = new BMenuItem(B_TRANSLATE("Command"), + new BMessage(kMsgCommmandCommand)); + fCommandMenu->AddItem(command, MENU_ITEM_COMMAND); + + return new BMenuField(NULL, fCommandMenu); +} + + +void +ModifierKeysWindow::_MarkMenuItems() +{ + // Caps Lock Menu + if (fCurrentMap->caps_key == 0x3b) + fCapsLockMenu->ItemAt(MENU_ITEM_CAPS_LOCK)->SetMarked(true); + else if (fCurrentMap->caps_key == 0x5c) + fCapsLockMenu->ItemAt(MENU_ITEM_CONTROL)->SetMarked(true); + else if (fCurrentMap->caps_key == 0x66) + fCapsLockMenu->ItemAt(MENU_ITEM_OPTION)->SetMarked(true); + else if (fCurrentMap->caps_key == 0x5d) + fCapsLockMenu->ItemAt(MENU_ITEM_COMMAND)->SetMarked(true); + else if (fCurrentMap->caps_key == 0) + fCapsLockMenu->ItemAt(MENU_ITEM_DISABLED)->SetMarked(true); + + // Control Menu + if (fCurrentMap->left_control_key == 0x3b) + fControlMenu->ItemAt(MENU_ITEM_CAPS_LOCK)->SetMarked(true); + else if (fCurrentMap->left_control_key == 0x5c) + fControlMenu->ItemAt(MENU_ITEM_CONTROL)->SetMarked(true); + else if (fCurrentMap->left_control_key == 0x66) + fControlMenu->ItemAt(MENU_ITEM_OPTION)->SetMarked(true); + else if (fCurrentMap->left_control_key == 0x5d) + fControlMenu->ItemAt(MENU_ITEM_COMMAND)->SetMarked(true); + + // Option Menu + if (fCurrentMap->left_option_key == 0x3b) + fOptionMenu->ItemAt(MENU_ITEM_CAPS_LOCK)->SetMarked(true); + else if (fCurrentMap->left_option_key == 0x5c) + fOptionMenu->ItemAt(MENU_ITEM_CONTROL)->SetMarked(true); + else if (fCurrentMap->left_option_key == 0x66) + fOptionMenu->ItemAt(MENU_ITEM_OPTION)->SetMarked(true); + else if (fCurrentMap->left_option_key == 0x5d) + fOptionMenu->ItemAt(MENU_ITEM_COMMAND)->SetMarked(true); + + // Command menu + if (fCurrentMap->left_command_key == 0x3b) + fCommandMenu->ItemAt(MENU_ITEM_CAPS_LOCK)->SetMarked(true); + else if (fCurrentMap->left_command_key == 0x5c) + fCommandMenu->ItemAt(MENU_ITEM_CONTROL)->SetMarked(true); + else if (fCurrentMap->left_command_key == 0x66) + fCommandMenu->ItemAt(MENU_ITEM_OPTION)->SetMarked(true); + else if (fCurrentMap->left_command_key == 0x5d) + fCommandMenu->ItemAt(MENU_ITEM_COMMAND)->SetMarked(true); +} + + +void +ModifierKeysWindow::_EnableRevertButton() +{ + if (fCurrentMap->caps_key != fSavedMap->caps_key + || fCurrentMap->left_control_key != fSavedMap->left_control_key + || fCurrentMap->right_control_key != fSavedMap->right_control_key + || fCurrentMap->left_option_key != fSavedMap->left_option_key + || fCurrentMap->right_option_key != fSavedMap->right_option_key + || fCurrentMap->left_command_key != fSavedMap->left_command_key + || fCurrentMap->right_command_key != fSavedMap->right_command_key) + fRevertButton->SetEnabled(true); + else + fRevertButton->SetEnabled(false); +} diff --git a/src/preferences/keymap/ModifierKeysWindow.h b/src/preferences/keymap/ModifierKeysWindow.h new file mode 100644 index 0000000000..8326deebce --- /dev/null +++ b/src/preferences/keymap/ModifierKeysWindow.h @@ -0,0 +1,52 @@ +/* + * Copyright 2011 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Authors: + * John Scipione, jscipione@gmail.com + */ +#ifndef MODIFIER_KEYS_WINDOW_H +#define MODIFIER_KEYS_WINDOW_H + + +#include +#include +#include +#include +#include + + +class ModifierKeysWindow : public BWindow { +public: + ModifierKeysWindow(); + virtual ~ModifierKeysWindow(); + + virtual void MessageReceived(BMessage* message); + +protected: + BMenuField* _CreateCapsLockMenuField(); + BMenuField* _CreateControlMenuField(); + BMenuField* _CreateOptionMenuField(); + BMenuField* _CreateCommandMenuField(); + + void _MarkMenuItems(); + void _EnableRevertButton(); + +private: + BPopUpMenu* fCapsLockMenu; + BPopUpMenu* fControlMenu; + BPopUpMenu* fOptionMenu; + BPopUpMenu* fCommandMenu; + + BButton* fRevertButton; + BButton* fCancelButton; + BButton* fOkButton; + + key_map* fCurrentMap; + key_map* fSavedMap; + + char* fCurrentBuffer; + char* fSavedBuffer; +}; + +#endif // MODIFIER_KEYS_WINDOW_H