From f5ac2da0a80a5c1075cfb06747c58a5f95ea124a Mon Sep 17 00:00:00 2001 From: John Scipione Date: Mon, 7 Nov 2011 13:49:56 +0000 Subject: [PATCH] Adds a dialog to the Keymap preference app to more easily and reliably change your modifier keys. The dialog box is shown by selecting the new 'Set Modifier Keys...' option under the File menu. This brings up a window which contains 4 dialog boxes labeled: Caps Lock, Control, Option, and Command. Each of the labels in followed by a drop down box which allows you to select from one of the other keys listed. So for instance you could switch the Caps Lock and Control keys but selecting the 'Control' option next to Caps Lock and the 'Caps Lock' option next to Control. The Caps Lock menu has an additional option which I find appealing... 'Disable' which, as it sounds, disables your Caps Lock key. At the bottom of the dialog there are 3 buttons, 'Cancel', 'Revert', and 'Ok'. 'Cancel' and 'Ok' are self explanatory. The 'Revert' button, which is initially disabled, puts you back into the state that you were when you first opened the dialog. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@43210 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/preferences/keymap/Jamfile | 1 + src/preferences/keymap/KeymapApplication.cpp | 28 +- src/preferences/keymap/KeymapApplication.h | 20 +- src/preferences/keymap/KeymapWindow.cpp | 41 +- src/preferences/keymap/KeymapWindow.h | 2 +- src/preferences/keymap/ModifierKeysWindow.cpp | 496 ++++++++++++++++++ src/preferences/keymap/ModifierKeysWindow.h | 52 ++ 7 files changed, 631 insertions(+), 9 deletions(-) create mode 100644 src/preferences/keymap/ModifierKeysWindow.cpp create mode 100644 src/preferences/keymap/ModifierKeysWindow.h 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