src/preferences/keymap/KeymapWindow.cpp

   1 /*
   2  * Copyright 2004-2015 Haiku, Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Alexandre Deckner, alex@zappotek.com
   7  *              Axel Dörfler, axeld@pinc-software.de
   8  *              Jérôme Duval
   9  *              John Scipione, jscipione@gmai.com
  10  *              Sandor Vroemisse
  11  */
  12
  13
  14 #include "KeymapWindow.h"
  15
  16 #include <string.h>
  17 #include <stdio.h>
  18
  19 #include <Alert.h>
  20 #include <Button.h>
  21 #include <Catalog.h>
  22 #include <Directory.h>
  23 #include <File.h>
  24 #include <FindDirectory.h>
  25 #include <LayoutBuilder.h>
  26 #include <ListView.h>
  27 #include <Locale.h>
  28 #include <MenuBar.h>
  29 #include <MenuField.h>
  30 #include <MenuItem.h>
  31 #include <Path.h>
  32 #include <PopUpMenu.h>
  33 #include <Screen.h>
  34 #include <ScrollView.h>
  35 #include <StringView.h>
  36 #include <TextControl.h>
  37
  38 #include "KeyboardLayoutView.h"
  39 #include "KeymapApplication.h"
  40 #include "KeymapListItem.h"
  41 #include "KeymapNames.h"
  42
  43
  44 #undef B_TRANSLATION_CONTEXT
  45 #define B_TRANSLATION_CONTEXT "Keymap window"
  46
  47
  48 static const uint32 kMsgMenuFileOpen = 'mMFO';
  49 static const uint32 kMsgMenuFileSaveAs = 'mMFA';
  50
  51 static const uint32 kChangeKeyboardLayout = 'cKyL';
  52
  53 static const uint32 kMsgSwitchShortcuts = 'swSc';
  54
  55 static const uint32 kMsgMenuFontChanged = 'mMFC';
  56
  57 static const uint32 kMsgSystemMapSelected = 'SmST';
  58 static const uint32 kMsgUserMapSelected = 'UmST';
  59
  60 static const uint32 kMsgDefaultKeymap = 'Dflt';
  61 static const uint32 kMsgRevertKeymap = 'Rvrt';
  62 static const uint32 kMsgKeymapUpdated = 'kMup';
  63
  64 static const uint32 kMsgDeadKeyAcuteChanged = 'dkAc';
  65 static const uint32 kMsgDeadKeyCircumflexChanged = 'dkCc';
  66 static const uint32 kMsgDeadKeyDiaeresisChanged = 'dkDc';
  67 static const uint32 kMsgDeadKeyGraveChanged = 'dkGc';
  68 static const uint32 kMsgDeadKeyTildeChanged = 'dkTc';
  69
  70 static const char* kDeadKeyTriggerNone = "<none>";
  71
  72 static const char* kCurrentKeymapName = "(Current)";
  73 static const char* kDefaultKeymapName = "US-International";
  74
  75
  76 static int
  77 compare_key_list_items(const void* a, const void* b)
  78 {
  79         KeymapListItem* item1 = *(KeymapListItem**)a;
  80         KeymapListItem* item2 = *(KeymapListItem**)b;
  81         return BLocale::Default()->StringCompare(item1->Text(), item2->Text());
  82 }
  83
  84
  85 KeymapWindow::KeymapWindow()
  86         :
  87         BWindow(BRect(80, 50, 650, 300), B_TRANSLATE_SYSTEM_NAME("Keymap"),
  88                 B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS)
  89 {
  90         fKeyboardLayoutView = new KeyboardLayoutView("layout");
  91         fKeyboardLayoutView->SetKeymap(&fCurrentMap);
  92         fKeyboardLayoutView->SetExplicitMinSize(BSize(B_SIZE_UNSET, 192));
  93
  94         fTextControl = new BTextControl(B_TRANSLATE("Sample and clipboard:"),
  95                 "", NULL);
  96
  97         fSwitchShortcutsButton = new BButton("switch", "",
  98                 new BMessage(kMsgSwitchShortcuts));
  99
 100         // controls pane
 101         BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
 102                 .Add(_CreateMenu())
 103                 .AddGroup(B_HORIZONTAL)
 104                         .SetInsets(B_USE_WINDOW_SPACING)
 105                         .Add(_CreateMapLists(), 0.25)
 106                         .AddGroup(B_VERTICAL)
 107                                 .Add(fKeyboardLayoutView)
 108                                 .AddGroup(B_HORIZONTAL)
 109                                         .Add(_CreateDeadKeyMenuField(), 0.0)
 110                                         .AddGlue()
 111                                         .Add(fSwitchShortcutsButton)
 112                                         .End()
 113                                 .Add(fTextControl)
 114                                 .AddGlue(0.0)
 115                                 .AddGroup(B_HORIZONTAL)
 116                                         .AddGlue()
 117                                         .Add(fDefaultsButton = new BButton("defaultsButton",
 118                                                 B_TRANSLATE("Defaults"),
 119                                                         new BMessage(kMsgDefaultKeymap)))
 120                                         .Add(fRevertButton = new BButton("revertButton",
 121                                                 B_TRANSLATE("Revert"), new BMessage(kMsgRevertKeymap)))
 122                                         .End()
 123                                 .End()
 124                         .End()
 125                 .End();
 126
 127         fKeyboardLayoutView->SetTarget(fTextControl->TextView());
 128         fTextControl->MakeFocus();
 129
 130         // Make sure the user keymap directory exists
 131         BPath path;
 132         find_directory(B_USER_SETTINGS_DIRECTORY, &path);
 133         path.Append("Keymap");
 134
 135         entry_ref ref;
 136         BEntry entry(path.Path(), true); // follow symlink
 137         BDirectory userKeymapsDir(&entry);
 138         if (userKeymapsDir.InitCheck() != B_OK
 139                 && create_directory(path.Path(), S_IRWXU | S_IRWXG | S_IRWXO)
 140                         == B_OK) {
 141                 get_ref_for_path(path.Path(), &ref);
 142         } else if (entry.InitCheck() == B_OK)
 143                 entry.GetRef(&ref);
 144         else
 145                 get_ref_for_path(path.Path(), &ref);
 146
 147         BMessenger messenger(this);
 148         fOpenPanel = new BFilePanel(B_OPEN_PANEL, &messenger, &ref,
 149                 B_FILE_NODE, false, NULL);
 150         fSavePanel = new BFilePanel(B_SAVE_PANEL, &messenger, &ref,
 151                 B_FILE_NODE, false, NULL);
 152
 153         BRect windowFrame;
 154         if (_LoadSettings(windowFrame) == B_OK) {
 155                 ResizeTo(windowFrame.Width(), windowFrame.Height());
 156                 MoveTo(windowFrame.LeftTop());
 157                 MoveOnScreen();
 158         } else
 159                 CenterOnScreen();
 160
 161         // TODO: this might be a bug in the interface kit, but scrolling to
 162         // selection does not correctly work unless the window is shown.
 163         Show();
 164         Lock();
 165
 166         // Try and find the current map name in the two list views (if the name
 167         // was read at all)
 168         _SelectCurrentMap();
 169
 170         KeymapListItem* current
 171                 = static_cast<KeymapListItem*>(fUserListView->FirstItem());
 172
 173         fCurrentMap.Load(current->EntryRef());
 174         fPreviousMap = fCurrentMap;
 175         fAppliedMap = fCurrentMap;
 176         fCurrentMap.SetTarget(this, new BMessage(kMsgKeymapUpdated));
 177
 178         _UpdateButtons();
 179
 180         _UpdateDeadKeyMenu();
 181         _UpdateSwitchShortcutButton();
 182
 183         Unlock();
 184 }
 185
 186
 187 KeymapWindow::~KeymapWindow()
 188 {
 189         delete fOpenPanel;
 190         delete fSavePanel;
 191 }
 192
 193
 194 bool
 195 KeymapWindow::QuitRequested()
 196 {
 197         _SaveSettings();
 198
 199         be_app->PostMessage(B_QUIT_REQUESTED);
 200         return true;
 201 }
 202
 203
 204 void
 205 KeymapWindow::MessageReceived(BMessage* message)
 206 {
 207         switch (message->what) {
 208                 case B_SIMPLE_DATA:
 209                 case B_REFS_RECEIVED:
 210                 {
 211                         entry_ref ref;
 212                         int32 i = 0;
 213                         while (message->FindRef("refs", i++, &ref) == B_OK) {
 214                                 fCurrentMap.Load(ref);
 215                                 fAppliedMap = fCurrentMap;
 216                         }
 217                         fKeyboardLayoutView->SetKeymap(&fCurrentMap);
 218                         fSystemListView->DeselectAll();
 219                         fUserListView->DeselectAll();
 220                         break;
 221                 }
 222
 223                 case B_SAVE_REQUESTED:
 224                 {
 225                         entry_ref ref;
 226                         const char* name;
 227                         if (message->FindRef("directory", &ref) == B_OK
 228                                 && message->FindString("name", &name) == B_OK) {
 229                                 BDirectory directory(&ref);
 230                                 BEntry entry(&directory, name);
 231                                 entry.GetRef(&ref);
 232                                 fCurrentMap.SetName(name);
 233                                 fCurrentMap.Save(ref);
 234                                 fAppliedMap = fCurrentMap;
 235                                 _FillUserMaps();
 236                                 fCurrentMapName = name;
 237                                 _SelectCurrentMap();
 238                         }
 239                         break;
 240                 }
 241
 242                 case kMsgMenuFileOpen:
 243                         fOpenPanel->Show();
 244                         break;
 245                 case kMsgMenuFileSaveAs:
 246                         fSavePanel->Show();
 247                         break;
 248                 case kMsgShowModifierKeysWindow:
 249                         be_app->PostMessage(kMsgShowModifierKeysWindow);
 250                         break;
 251
 252                 case kChangeKeyboardLayout:
 253                 {
 254                         entry_ref ref;
 255                         BPath path;
 256                         if (message->FindRef("ref", &ref) == B_OK)
 257                                 path.SetTo(&ref);
 258
 259                         _SetKeyboardLayout(path.Path());
 260                         break;
 261                 }
 262
 263                 case kMsgSwitchShortcuts:
 264                         _SwitchShortcutKeys();
 265                         break;
 266
 267                 case kMsgMenuFontChanged:
 268                 {
 269                         BMenuItem* item = fFontMenu->FindMarked();
 270                         if (item != NULL) {
 271                                 BFont font;
 272                                 font.SetFamilyAndStyle(item->Label(), NULL);
 273                                 fKeyboardLayoutView->SetBaseFont(font);
 274                                 fTextControl->TextView()->SetFontAndColor(&font);
 275                         }
 276                         break;
 277                 }
 278
 279                 case kMsgSystemMapSelected:
 280                 case kMsgUserMapSelected:
 281                 {
 282                         BListView* listView;
 283                         BListView* otherListView;
 284
 285                         if (message->what == kMsgSystemMapSelected) {
 286                                 listView = fSystemListView;
 287                                 otherListView = fUserListView;
 288                         } else {
 289                                 listView = fUserListView;
 290                                 otherListView = fSystemListView;
 291                         }
 292
 293                         int32 index = listView->CurrentSelection();
 294                         if (index < 0)
 295                                 break;
 296
 297                         // Deselect item in other BListView
 298                         otherListView->DeselectAll();
 299
 300                         if (index == 0 && listView == fUserListView) {
 301                                 // we can safely ignore the "(Current)" item
 302                                 break;
 303                         }
 304
 305                         KeymapListItem* item
 306                                 = static_cast<KeymapListItem*>(listView->ItemAt(index));
 307                         if (item != NULL) {
 308                                 fCurrentMap.Load(item->EntryRef());
 309                                 fAppliedMap = fCurrentMap;
 310                                 fKeyboardLayoutView->SetKeymap(&fCurrentMap);
 311                                 _UseKeymap();
 312                                 _UpdateButtons();
 313                         }
 314                         break;
 315                 }
 316
 317                 case kMsgDefaultKeymap:
 318                         _DefaultKeymap();
 319                         _UpdateButtons();
 320                         break;
 321
 322                 case kMsgRevertKeymap:
 323                         _RevertKeymap();
 324                         _UpdateButtons();
 325                         break;
 326
 327                 case kMsgUpdateNormalKeys:
 328                 {
 329                         uint32 keyCode;
 330                         if (message->FindUInt32("keyCode", &keyCode) != B_OK)
 331                                 break;
 332
 333                         bool unset;
 334                         if (message->FindBool("unset", &unset) == B_OK && unset) {
 335                                 fCurrentMap.SetKey(keyCode, modifiers(), 0, "", 0);
 336                                 _UpdateButtons();
 337                                 fKeyboardLayoutView->SetKeymap(&fCurrentMap);
 338                         }
 339                         break;
 340                 }
 341
 342                 case kMsgUpdateModifierKeys:
 343                 {
 344                         uint32 keyCode;
 345                         bool unset;
 346                         if (message->FindBool("unset", &unset) != B_OK)
 347                                 unset = false;
 348
 349                         if (message->FindUInt32("left_shift_key", &keyCode) == B_OK) {
 350                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode,
 351                                         B_LEFT_SHIFT_KEY);
 352                         }
 353
 354                         if (message->FindUInt32("right_shift_key", &keyCode) == B_OK) {
 355                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode,
 356                                         B_RIGHT_SHIFT_KEY);
 357                         }
 358
 359                         if (message->FindUInt32("left_control_key", &keyCode) == B_OK) {
 360                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode,
 361                                         B_LEFT_CONTROL_KEY);
 362                         }
 363
 364                         if (message->FindUInt32("right_control_key", &keyCode) == B_OK) {
 365                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode,
 366                                         B_RIGHT_CONTROL_KEY);
 367                         }
 368
 369                         if (message->FindUInt32("left_option_key", &keyCode) == B_OK) {
 370                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode,
 371                                         B_LEFT_OPTION_KEY);
 372                         }
 373
 374                         if (message->FindUInt32("right_option_key", &keyCode) == B_OK) {
 375                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode,
 376                                         B_RIGHT_OPTION_KEY);
 377                         }
 378
 379                         if (message->FindUInt32("left_command_key", &keyCode) == B_OK) {
 380                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode,
 381                                         B_LEFT_COMMAND_KEY);
 382                         }
 383
 384                         if (message->FindUInt32("right_command_key", &keyCode) == B_OK) {
 385                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode,
 386                                         B_RIGHT_COMMAND_KEY);
 387                         }
 388
 389                         if (message->FindUInt32("menu_key", &keyCode) == B_OK)
 390                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode, B_MENU_KEY);
 391
 392                         if (message->FindUInt32("caps_key", &keyCode) == B_OK)
 393                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode, B_CAPS_LOCK);
 394
 395                         if (message->FindUInt32("num_key", &keyCode) == B_OK)
 396                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode, B_NUM_LOCK);
 397
 398                         if (message->FindUInt32("scroll_key", &keyCode) == B_OK)
 399                                 fCurrentMap.SetModifier(unset ? 0x00 : keyCode, B_SCROLL_LOCK);
 400
 401                         _UpdateButtons();
 402                         fKeyboardLayoutView->SetKeymap(&fCurrentMap);
 403                         break;
 404                 }
 405
 406                 case kMsgKeymapUpdated:
 407                         _UpdateButtons();
 408                         fSystemListView->DeselectAll();
 409                         fUserListView->Select(0L);
 410                         break;
 411
 412                 case kMsgDeadKeyAcuteChanged:
 413                 {
 414                         BMenuItem* item = fAcuteMenu->FindMarked();
 415                         if (item != NULL) {
 416                                 const char* trigger = item->Label();
 417                                 if (strcmp(trigger, kDeadKeyTriggerNone) == 0)
 418                                         trigger = NULL;
 419                                 fCurrentMap.SetDeadKeyTrigger(kDeadKeyAcute, trigger);
 420                                 fKeyboardLayoutView->Invalidate();
 421                         }
 422                         break;
 423                 }
 424
 425                 case kMsgDeadKeyCircumflexChanged:
 426                 {
 427                         BMenuItem* item = fCircumflexMenu->FindMarked();
 428                         if (item != NULL) {
 429                                 const char* trigger = item->Label();
 430                                 if (strcmp(trigger, kDeadKeyTriggerNone) == 0)
 431                                         trigger = NULL;
 432                                 fCurrentMap.SetDeadKeyTrigger(kDeadKeyCircumflex, trigger);
 433                                 fKeyboardLayoutView->Invalidate();
 434                         }
 435                         break;
 436                 }
 437
 438                 case kMsgDeadKeyDiaeresisChanged:
 439                 {
 440                         BMenuItem* item = fDiaeresisMenu->FindMarked();
 441                         if (item != NULL) {
 442                                 const char* trigger = item->Label();
 443                                 if (strcmp(trigger, kDeadKeyTriggerNone) == 0)
 444                                         trigger = NULL;
 445                                 fCurrentMap.SetDeadKeyTrigger(kDeadKeyDiaeresis, trigger);
 446                                 fKeyboardLayoutView->Invalidate();
 447                         }
 448                         break;
 449                 }
 450
 451                 case kMsgDeadKeyGraveChanged:
 452                 {
 453                         BMenuItem* item = fGraveMenu->FindMarked();
 454                         if (item != NULL) {
 455                                 const char* trigger = item->Label();
 456                                 if (strcmp(trigger, kDeadKeyTriggerNone) == 0)
 457                                         trigger = NULL;
 458                                 fCurrentMap.SetDeadKeyTrigger(kDeadKeyGrave, trigger);
 459                                 fKeyboardLayoutView->Invalidate();
 460                         }
 461                         break;
 462                 }
 463
 464                 case kMsgDeadKeyTildeChanged:
 465                 {
 466                         BMenuItem* item = fTildeMenu->FindMarked();
 467                         if (item != NULL) {
 468                                 const char* trigger = item->Label();
 469                                 if (strcmp(trigger, kDeadKeyTriggerNone) == 0)
 470                                         trigger = NULL;
 471                                 fCurrentMap.SetDeadKeyTrigger(kDeadKeyTilde, trigger);
 472                                 fKeyboardLayoutView->Invalidate();
 473                         }
 474                         break;
 475                 }
 476
 477                 default:
 478                         BWindow::MessageReceived(message);
 479                         break;
 480         }
 481 }
 482
 483
 484 BMenuBar*
 485 KeymapWindow::_CreateMenu()
 486 {
 487         BMenuBar* menuBar = new BMenuBar(Bounds(), "menubar");
 488
 489         // Create the File menu
 490         BMenu* menu = new BMenu(B_TRANSLATE("File"));
 491         menu->AddItem(new BMenuItem(B_TRANSLATE("Open" B_UTF8_ELLIPSIS),
 492                 new BMessage(kMsgMenuFileOpen), 'O'));
 493         menu->AddItem(new BMenuItem(B_TRANSLATE("Save as" B_UTF8_ELLIPSIS),
 494                 new BMessage(kMsgMenuFileSaveAs)));
 495         menu->AddSeparatorItem();
 496         menu->AddItem(new BMenuItem(
 497                 B_TRANSLATE("Set modifier keys" B_UTF8_ELLIPSIS),
 498                 new BMessage(kMsgShowModifierKeysWindow)));
 499         menu->AddSeparatorItem();
 500         menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
 501                 new BMessage(B_QUIT_REQUESTED), 'Q'));
 502         menuBar->AddItem(menu);
 503
 504         // Create keyboard layout menu
 505         fLayoutMenu = new BMenu(B_TRANSLATE("Layout"));
 506         _AddKeyboardLayouts(fLayoutMenu);
 507         menuBar->AddItem(fLayoutMenu);
 508
 509         // Create the Font menu
 510         fFontMenu = new BMenu(B_TRANSLATE("Font"));
 511         fFontMenu->SetRadioMode(true);
 512         int32 numFamilies = count_font_families();
 513         font_family family, currentFamily;
 514         font_style currentStyle;
 515         uint32 flags;
 516
 517         be_plain_font->GetFamilyAndStyle(&currentFamily, &currentStyle);
 518
 519         for (int32 i = 0; i < numFamilies; i++) {
 520                 if (get_font_family(i, &family, &flags) == B_OK) {
 521                         BMenuItem* item
 522                                 = new BMenuItem(family, new BMessage(kMsgMenuFontChanged));
 523                         fFontMenu->AddItem(item);
 524
 525                         if (!strcmp(family, currentFamily))
 526                                 item->SetMarked(true);
 527                 }
 528         }
 529         menuBar->AddItem(fFontMenu);
 530
 531         return menuBar;
 532 }
 533
 534
 535 BMenuField*
 536 KeymapWindow::_CreateDeadKeyMenuField()
 537 {
 538         BPopUpMenu* deadKeyMenu = new BPopUpMenu(B_TRANSLATE("Select dead keys"),
 539                 false, false);
 540
 541         fAcuteMenu = new BMenu(B_TRANSLATE("Acute trigger"));
 542         fAcuteMenu->SetRadioMode(true);
 543         fAcuteMenu->AddItem(new BMenuItem("\xC2\xB4",
 544                 new BMessage(kMsgDeadKeyAcuteChanged)));
 545         fAcuteMenu->AddItem(new BMenuItem("'",
 546                 new BMessage(kMsgDeadKeyAcuteChanged)));
 547         fAcuteMenu->AddItem(new BMenuItem(kDeadKeyTriggerNone,
 548                 new BMessage(kMsgDeadKeyAcuteChanged)));
 549         deadKeyMenu->AddItem(fAcuteMenu);
 550
 551         fCircumflexMenu = new BMenu(B_TRANSLATE("Circumflex trigger"));
 552         fCircumflexMenu->SetRadioMode(true);
 553         fCircumflexMenu->AddItem(new BMenuItem("^",
 554                 new BMessage(kMsgDeadKeyCircumflexChanged)));
 555         fCircumflexMenu->AddItem(new BMenuItem(kDeadKeyTriggerNone,
 556                 new BMessage(kMsgDeadKeyCircumflexChanged)));
 557         deadKeyMenu->AddItem(fCircumflexMenu);
 558
 559         fDiaeresisMenu = new BMenu(B_TRANSLATE("Diaeresis trigger"));
 560         fDiaeresisMenu->SetRadioMode(true);
 561         fDiaeresisMenu->AddItem(new BMenuItem("\xC2\xA8",
 562                 new BMessage(kMsgDeadKeyDiaeresisChanged)));
 563         fDiaeresisMenu->AddItem(new BMenuItem("\"",
 564                 new BMessage(kMsgDeadKeyDiaeresisChanged)));
 565         fDiaeresisMenu->AddItem(new BMenuItem(kDeadKeyTriggerNone,
 566                 new BMessage(kMsgDeadKeyDiaeresisChanged)));
 567         deadKeyMenu->AddItem(fDiaeresisMenu);
 568
 569         fGraveMenu = new BMenu(B_TRANSLATE("Grave trigger"));
 570         fGraveMenu->SetRadioMode(true);
 571         fGraveMenu->AddItem(new BMenuItem("`",
 572                 new BMessage(kMsgDeadKeyGraveChanged)));
 573         fGraveMenu->AddItem(new BMenuItem(kDeadKeyTriggerNone,
 574                 new BMessage(kMsgDeadKeyGraveChanged)));
 575         deadKeyMenu->AddItem(fGraveMenu);
 576
 577         fTildeMenu = new BMenu(B_TRANSLATE("Tilde trigger"));
 578         fTildeMenu->SetRadioMode(true);
 579         fTildeMenu->AddItem(new BMenuItem("~",
 580                 new BMessage(kMsgDeadKeyTildeChanged)));
 581         fTildeMenu->AddItem(new BMenuItem(kDeadKeyTriggerNone,
 582                 new BMessage(kMsgDeadKeyTildeChanged)));
 583         deadKeyMenu->AddItem(fTildeMenu);
 584
 585         return new BMenuField(NULL, deadKeyMenu);
 586 }
 587
 588
 589 BView*
 590 KeymapWindow::_CreateMapLists()
 591 {
 592         // The System list
 593         fSystemListView = new BListView("systemList");
 594         fSystemListView->SetSelectionMessage(new BMessage(kMsgSystemMapSelected));
 595
 596         BScrollView* systemScroller = new BScrollView("systemScrollList",
 597                 fSystemListView, 0, false, true);
 598
 599         // The User list
 600         fUserListView = new BListView("userList");
 601         fUserListView->SetSelectionMessage(new BMessage(kMsgUserMapSelected));
 602         BScrollView* userScroller = new BScrollView("userScrollList",
 603                 fUserListView, 0, false, true);
 604
 605         // Saved keymaps
 606
 607         _FillSystemMaps();
 608         _FillUserMaps();
 609
 610         _SetListViewSize(fSystemListView);
 611         _SetListViewSize(fUserListView);
 612
 613         return BLayoutBuilder::Group<>(B_VERTICAL)
 614                 .Add(new BStringView("system", B_TRANSLATE("System:")))
 615                 .Add(systemScroller, 3)
 616                 .Add(new BStringView("user", B_TRANSLATE("User:")))
 617                 .Add(userScroller)
 618                 .View();
 619 }
 620
 621
 622 void
 623 KeymapWindow::_AddKeyboardLayouts(BMenu* menu)
 624 {
 625         directory_which dataDirectories[] = {
 626                 B_USER_NONPACKAGED_DATA_DIRECTORY,
 627                 B_USER_DATA_DIRECTORY,
 628                 B_SYSTEM_NONPACKAGED_DATA_DIRECTORY,
 629                 B_SYSTEM_DATA_DIRECTORY,
 630         };
 631
 632         for (uint32 i = 0;
 633                         i < sizeof(dataDirectories) / sizeof(dataDirectories[0]); i++) {
 634                 BPath path;
 635                 if (find_directory(dataDirectories[i], &path) != B_OK)
 636                         continue;
 637
 638                 if (path.Append("KeyboardLayouts") != B_OK)
 639                         continue;
 640
 641                 BDirectory directory;
 642                 if (directory.SetTo(path.Path()) == B_OK)
 643                         _AddKeyboardLayoutMenu(menu, directory);
 644         }
 645 }
 646
 647
 648 /*!     Adds a menu populated with the keyboard layouts found in the passed
 649         in directory to the passed in menu. Each subdirectory in the passed
 650         in directory is added as a submenu recursively.
 651 */
 652 void
 653 KeymapWindow::_AddKeyboardLayoutMenu(BMenu* menu, BDirectory directory)
 654 {
 655         entry_ref ref;
 656
 657         while (directory.GetNextRef(&ref) == B_OK) {
 658                 if (menu->FindItem(ref.name) != NULL)
 659                         continue;
 660
 661                 BDirectory subdirectory;
 662                 subdirectory.SetTo(&ref);
 663                 if (subdirectory.InitCheck() == B_OK) {
 664                         BMenu* submenu = new BMenu(B_TRANSLATE_NOCOLLECT(ref.name));
 665
 666                         _AddKeyboardLayoutMenu(submenu, subdirectory);
 667                         menu->AddItem(submenu, (int32)0);
 668                 } else {
 669                         BMessage* message = new BMessage(kChangeKeyboardLayout);
 670
 671                         message->AddRef("ref", &ref);
 672                         menu->AddItem(new BMenuItem(B_TRANSLATE_NOCOLLECT(ref.name),
 673                                 message), (int32)0);
 674                 }
 675         }
 676 }
 677
 678
 679 /*!     Sets the keyboard layout with the passed in path and marks the
 680         corresponding menu item. If the path is not found in the menu this method
 681         sets the default keyboard layout and marks the corresponding menu item.
 682 */
 683 status_t
 684 KeymapWindow::_SetKeyboardLayout(const char* path)
 685 {
 686         status_t status = fKeyboardLayoutView->GetKeyboardLayout()->Load(path);
 687
 688         // mark a menu item (unmarking all others)
 689         _MarkKeyboardLayoutItem(path, fLayoutMenu);
 690
 691         if (path == NULL || path[0] == '\0' || status != B_OK) {
 692                 fKeyboardLayoutView->GetKeyboardLayout()->SetDefault();
 693                 BMenuItem* item = fLayoutMenu->FindItem(
 694                         fKeyboardLayoutView->GetKeyboardLayout()->Name());
 695                 if (item != NULL)
 696                         item->SetMarked(true);
 697         }
 698
 699         // Refresh currently set layout
 700         fKeyboardLayoutView->SetKeyboardLayout(
 701                 fKeyboardLayoutView->GetKeyboardLayout());
 702
 703         return status;
 704 }
 705
 706
 707 /*!     Marks a keyboard layout item by iterating through the menus recursively
 708         searching for the menu item with the passed in path. This method always
 709         iterates through all menu items and unmarks them. If no item with the
 710         passed in path is found it is up to the caller to set the default keyboard
 711         layout and mark item corresponding to the default keyboard layout path.
 712 */
 713 void
 714 KeymapWindow::_MarkKeyboardLayoutItem(const char* path, BMenu* menu)
 715 {
 716         BMenuItem* item = NULL;
 717         entry_ref ref;
 718
 719         for (int32 i = 0; i < menu->CountItems(); i++) {
 720                 item = menu->ItemAt(i);
 721                 if (item == NULL)
 722                         continue;
 723
 724                 // Unmark each item initially
 725                 item->SetMarked(false);
 726
 727                 BMenu* submenu = item->Submenu();
 728                 if (submenu != NULL)
 729                         _MarkKeyboardLayoutItem(path, submenu);
 730                 else {
 731                         if (item->Message()->FindRef("ref", &ref) == B_OK) {
 732                                 BPath layoutPath(&ref);
 733                                 if (path != NULL && path[0] != '\0' && layoutPath == path) {
 734                                         // Found it, mark the item
 735                                         item->SetMarked(true);
 736                                 }
 737                         }
 738                 }
 739         }
 740 }
 741
 742
 743 /*!     Sets the label of the "Switch Shorcuts" button to make it more
 744         descriptive what will happen when you press that button.
 745 */
 746 void
 747 KeymapWindow::_UpdateSwitchShortcutButton()
 748 {
 749         const char* label = B_TRANSLATE("Switch shortcut keys");
 750         if (fCurrentMap.KeyForModifier(B_LEFT_COMMAND_KEY) == 0x5d
 751                 && fCurrentMap.KeyForModifier(B_LEFT_CONTROL_KEY) == 0x5c) {
 752                 label = B_TRANSLATE("Switch shortcut keys to Windows/Linux mode");
 753         } else if (fCurrentMap.KeyForModifier(B_LEFT_COMMAND_KEY) == 0x5c
 754                 && fCurrentMap.KeyForModifier(B_LEFT_CONTROL_KEY) == 0x5d) {
 755                 label = B_TRANSLATE("Switch shortcut keys to Haiku mode");
 756         }
 757
 758         fSwitchShortcutsButton->SetLabel(label);
 759 }
 760
 761
 762 /*!     Marks the menu items corresponding to the dead key state of the current
 763         key map.
 764 */
 765 void
 766 KeymapWindow::_UpdateDeadKeyMenu()
 767 {
 768         BString trigger;
 769         fCurrentMap.GetDeadKeyTrigger(kDeadKeyAcute, trigger);
 770         if (!trigger.Length())
 771                 trigger = kDeadKeyTriggerNone;
 772         BMenuItem* menuItem = fAcuteMenu->FindItem(trigger.String());
 773         if (menuItem)
 774                 menuItem->SetMarked(true);
 775
 776         fCurrentMap.GetDeadKeyTrigger(kDeadKeyCircumflex, trigger);
 777         if (!trigger.Length())
 778                 trigger = kDeadKeyTriggerNone;
 779         menuItem = fCircumflexMenu->FindItem(trigger.String());
 780         if (menuItem)
 781                 menuItem->SetMarked(true);
 782
 783         fCurrentMap.GetDeadKeyTrigger(kDeadKeyDiaeresis, trigger);
 784         if (!trigger.Length())
 785                 trigger = kDeadKeyTriggerNone;
 786         menuItem = fDiaeresisMenu->FindItem(trigger.String());
 787         if (menuItem)
 788                 menuItem->SetMarked(true);
 789
 790         fCurrentMap.GetDeadKeyTrigger(kDeadKeyGrave, trigger);
 791         if (!trigger.Length())
 792                 trigger = kDeadKeyTriggerNone;
 793         menuItem = fGraveMenu->FindItem(trigger.String());
 794         if (menuItem)
 795                 menuItem->SetMarked(true);
 796
 797         fCurrentMap.GetDeadKeyTrigger(kDeadKeyTilde, trigger);
 798         if (!trigger.Length())
 799                 trigger = kDeadKeyTriggerNone;
 800         menuItem = fTildeMenu->FindItem(trigger.String());
 801         if (menuItem)
 802                 menuItem->SetMarked(true);
 803 }
 804
 805
 806 void
 807 KeymapWindow::_UpdateButtons()
 808 {
 809         if (fCurrentMap != fAppliedMap) {
 810                 fCurrentMap.SetName(kCurrentKeymapName);
 811                 _UseKeymap();
 812         }
 813
 814         fDefaultsButton->SetEnabled(
 815                 fCurrentMapName.ICompare(kDefaultKeymapName) != 0);
 816         fRevertButton->SetEnabled(fCurrentMap != fPreviousMap);
 817
 818         _UpdateDeadKeyMenu();
 819         _UpdateSwitchShortcutButton();
 820 }
 821
 822
 823 void
 824 KeymapWindow::_SwitchShortcutKeys()
 825 {
 826         uint32 leftCommand = fCurrentMap.Map().left_command_key;
 827         uint32 leftControl = fCurrentMap.Map().left_control_key;
 828         uint32 rightCommand = fCurrentMap.Map().right_command_key;
 829         uint32 rightControl = fCurrentMap.Map().right_control_key;
 830
 831         // switch left side
 832         fCurrentMap.Map().left_command_key = leftControl;
 833         fCurrentMap.Map().left_control_key = leftCommand;
 834
 835         // switch right side
 836         fCurrentMap.Map().right_command_key = rightControl;
 837         fCurrentMap.Map().right_control_key = rightCommand;
 838
 839         fKeyboardLayoutView->SetKeymap(&fCurrentMap);
 840         _UpdateButtons();
 841 }
 842
 843
 844 //!     Restores the default keymap.
 845 void
 846 KeymapWindow::_DefaultKeymap()
 847 {
 848         fCurrentMap.RestoreSystemDefault();
 849         fAppliedMap = fCurrentMap;
 850
 851         fKeyboardLayoutView->SetKeymap(&fCurrentMap);
 852
 853         fCurrentMapName = _GetActiveKeymapName();
 854         _SelectCurrentMap();
 855 }
 856
 857
 858 //!     Saves previous map to the "Key_map" file.
 859 void
 860 KeymapWindow::_RevertKeymap()
 861 {
 862         entry_ref ref;
 863         _GetCurrentKeymap(ref);
 864
 865         status_t status = fPreviousMap.Save(ref);
 866         if (status != B_OK) {
 867                 printf("error when saving keymap: %s", strerror(status));
 868                 return;
 869         }
 870
 871         fPreviousMap.Use();
 872         fCurrentMap.Load(ref);
 873         fAppliedMap = fCurrentMap;
 874
 875         fKeyboardLayoutView->SetKeymap(&fCurrentMap);
 876
 877         fCurrentMapName = _GetActiveKeymapName();
 878         _SelectCurrentMap();
 879 }
 880
 881
 882 //!     Saves current map to the "Key_map" file.
 883 void
 884 KeymapWindow::_UseKeymap()
 885 {
 886         entry_ref ref;
 887         _GetCurrentKeymap(ref);
 888
 889         status_t status = fCurrentMap.Save(ref);
 890         if (status != B_OK) {
 891                 printf("error when saving : %s", strerror(status));
 892                 return;
 893         }
 894
 895         fCurrentMap.Use();
 896         fAppliedMap.Load(ref);
 897
 898         fCurrentMapName = _GetActiveKeymapName();
 899         _SelectCurrentMap();
 900 }
 901
 902
 903 void
 904 KeymapWindow::_FillSystemMaps()
 905 {
 906         BListItem* item;
 907         while ((item = fSystemListView->RemoveItem(static_cast<int32>(0))))
 908                 delete item;
 909
 910         // TODO: common keymaps!
 911         BPath path;
 912         if (find_directory(B_SYSTEM_DATA_DIRECTORY, &path) != B_OK)
 913                 return;
 914
 915         path.Append("Keymaps");
 916
 917         BDirectory directory;
 918         entry_ref ref;
 919
 920         if (directory.SetTo(path.Path()) == B_OK) {
 921                 while (directory.GetNextRef(&ref) == B_OK) {
 922                         fSystemListView->AddItem(
 923                                 new KeymapListItem(ref, B_TRANSLATE_NOCOLLECT(ref.name)));
 924                 }
 925         }
 926
 927         fSystemListView->SortItems(&compare_key_list_items);
 928 }
 929
 930
 931 void
 932 KeymapWindow::_FillUserMaps()
 933 {
 934         BListItem* item;
 935         while ((item = fUserListView->RemoveItem(static_cast<int32>(0))))
 936                 delete item;
 937
 938         entry_ref ref;
 939         _GetCurrentKeymap(ref);
 940
 941         fUserListView->AddItem(new KeymapListItem(ref, B_TRANSLATE("(Current)")));
 942
 943         fCurrentMapName = _GetActiveKeymapName();
 944
 945         BPath path;
 946         if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
 947                 return;
 948
 949         path.Append("Keymap");
 950
 951         BDirectory directory;
 952         if (directory.SetTo(path.Path()) == B_OK) {
 953                 while (directory.GetNextRef(&ref) == B_OK) {
 954                         fUserListView->AddItem(new KeymapListItem(ref));
 955                 }
 956         }
 957
 958         fUserListView->SortItems(&compare_key_list_items);
 959 }
 960
 961
 962 void
 963 KeymapWindow::_SetListViewSize(BListView* listView)
 964 {
 965         float minWidth = 0;
 966         for (int32 i = 0; i < listView->CountItems(); i++) {
 967                 BStringItem* item = (BStringItem*)listView->ItemAt(i);
 968                 float width = listView->StringWidth(item->Text());
 969                 if (width > minWidth)
 970                         minWidth = width;
 971         }
 972
 973         listView->SetExplicitMinSize(BSize(minWidth + 8, 32));
 974 }
 975
 976
 977 status_t
 978 KeymapWindow::_GetCurrentKeymap(entry_ref& ref)
 979 {
 980         BPath path;
 981         if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
 982                 return B_ERROR;
 983
 984         path.Append("Key_map");
 985
 986         return get_ref_for_path(path.Path(), &ref);
 987 }
 988
 989
 990 BString
 991 KeymapWindow::_GetActiveKeymapName()
 992 {
 993         BString mapName = kCurrentKeymapName;
 994                 // safe default
 995
 996         entry_ref ref;
 997         _GetCurrentKeymap(ref);
 998
 999         BNode node(&ref);
1000
1001         if (node.InitCheck() == B_OK)
1002                 node.ReadAttrString("keymap:name", &mapName);
1003
1004         return mapName;
1005 }
1006
1007
1008 bool
1009 KeymapWindow::_SelectCurrentMap(BListView* view)
1010 {
1011         if (fCurrentMapName.Length() <= 0)
1012                 return false;
1013
1014         for (int32 i = 0; i < view->CountItems(); i++) {
1015                 BStringItem* current = dynamic_cast<BStringItem *>(view->ItemAt(i));
1016                 if (current != NULL && fCurrentMapName == current->Text()) {
1017                         view->Select(i);
1018                         view->ScrollToSelection();
1019                         return true;
1020                 }
1021         }
1022
1023         return false;
1024 }
1025
1026
1027 void
1028 KeymapWindow::_SelectCurrentMap()
1029 {
1030         if (!_SelectCurrentMap(fSystemListView)
1031                 && !_SelectCurrentMap(fUserListView)) {
1032                 // Select the "(Current)" entry if no name matches
1033                 fUserListView->Select(0L);
1034         }
1035 }
1036
1037
1038 status_t
1039 KeymapWindow::_GetSettings(BFile& file, int mode) const
1040 {
1041         BPath path;
1042         status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path,
1043                 (mode & O_ACCMODE) != O_RDONLY);
1044         if (status != B_OK)
1045                 return status;
1046
1047         path.Append("Keymap settings");
1048
1049         return file.SetTo(path.Path(), mode);
1050 }
1051
1052
1053 status_t
1054 KeymapWindow::_LoadSettings(BRect& windowFrame)
1055 {
1056         BScreen screen(this);
1057
1058         windowFrame.Set(-1, -1, 669, 357);
1059         // See if we can use a larger default size
1060         if (screen.Frame().Width() > 1200) {
1061                 windowFrame.right = 899;
1062                 windowFrame.bottom = 349;
1063         }
1064         float scaling = be_plain_font->Size() / 12.0f;
1065         windowFrame.right *= scaling;
1066         windowFrame.bottom *= scaling;
1067
1068         BFile file;
1069         status_t status = _GetSettings(file, B_READ_ONLY);
1070         if (status == B_OK) {
1071                 BMessage settings;
1072                 status = settings.Unflatten(&file);
1073                 if (status == B_OK) {
1074                         BRect frame;
1075                         status = settings.FindRect("window frame", &frame);
1076                         if (status == B_OK)
1077                                 windowFrame = frame;
1078
1079                         const char* layoutPath;
1080                         if (settings.FindString("keyboard layout", &layoutPath) == B_OK)
1081                                 _SetKeyboardLayout(layoutPath);
1082                 }
1083         }
1084
1085         return status;
1086 }
1087
1088
1089 status_t
1090 KeymapWindow::_SaveSettings()
1091 {
1092         BFile file;
1093         status_t status
1094                 = _GetSettings(file, B_WRITE_ONLY | B_ERASE_FILE | B_CREATE_FILE);
1095         if (status != B_OK)
1096                 return status;
1097
1098         BMessage settings('keym');
1099         settings.AddRect("window frame", Frame());
1100
1101         BPath path = _GetMarkedKeyboardLayoutPath(fLayoutMenu);
1102         if (path.InitCheck() == B_OK)
1103                 settings.AddString("keyboard layout", path.Path());
1104
1105         return settings.Flatten(&file);
1106 }
1107
1108
1109 /*!     Gets the path of the currently marked keyboard layout item
1110         by searching through each of the menus recursively until
1111         a marked item is found.
1112 */
1113 BPath
1114 KeymapWindow::_GetMarkedKeyboardLayoutPath(BMenu* menu)
1115 {
1116         BPath path;
1117         BMenuItem* item = NULL;
1118         entry_ref ref;
1119
1120         for (int32 i = 0; i < menu->CountItems(); i++) {
1121                 item = menu->ItemAt(i);
1122                 if (item == NULL)
1123                         continue;
1124
1125                 BMenu* submenu = item->Submenu();
1126                 if (submenu != NULL) {
1127                         path = _GetMarkedKeyboardLayoutPath(submenu);
1128                         if (path.InitCheck() == B_OK)
1129                                 return path;
1130                 } else {
1131                         if (item->IsMarked()
1132                                 && item->Message()->FindRef("ref", &ref) == B_OK) {
1133                                 path.SetTo(&ref);
1134                                 return path;
1135                         }
1136                 }
1137         }
1138
1139         return path;
1140 }