xref: /haiku/src/preferences/shortcuts/ShortcutsWindow.cpp (revision 6aff37d1c79e20748c683ae224bd629f88a5b0be) 
1 /*
2  * Copyright 1999-2009 Jeremy Friesner
3  * Copyright 2009-2010 Haiku, Inc. All rights reserved.
4  * Distributed under the terms of the MIT License.
5  *
6  * Authors:
7  *		Jeremy Friesner
8  *		Fredrik Modéen
9  */
10 
11 
12 #include "ShortcutsWindow.h"
13 
14 #include <math.h>
15 #include <stdio.h>
16 
17 #include <Alert.h>
18 #include <Application.h>
19 #include <Button.h>
20 #include <Catalog.h>
21 #include <Clipboard.h>
22 #include <ColumnListView.h>
23 #include <ColumnTypes.h>
24 #include <ControlLook.h>
25 #include <File.h>
26 #include <FilePanel.h>
27 #include <FindDirectory.h>
28 #include <Input.h>
29 #include <LayoutBuilder.h>
30 #include <Locale.h>
31 #include <Message.h>
32 #include <Menu.h>
33 #include <MenuBar.h>
34 #include <MenuItem.h>
35 #include <MessageFilter.h>
36 #include <Path.h>
37 #include <PopUpMenu.h>
38 #include <Screen.h>
39 #include <ScrollBar.h>
40 #include <ScrollView.h>
41 #include <String.h>
42 #include <SupportDefs.h>
43 
44 #include "EditWindow.h"
45 #include "KeyInfos.h"
46 #include "MetaKeyStateMap.h"
47 #include "ParseCommandLine.h"
48 #include "PopUpColumn.h"
49 #include "ShortcutsFilterConstants.h"
50 #include "ShortcutsSpec.h"
51 
52 
53 // Window sizing constraints
54 #define MAX_WIDTH 10000
55 #define MAX_HEIGHT 10000
56 	// SetSizeLimits does not provide a mechanism for specifying an
57 	// unrestricted maximum. 10,000 seems to be the most common value used
58 	// in other Haiku system applications.
59 
60 #define WINDOW_SETTINGS_FILE_NAME "Shortcuts_window_settings"
61 	// Because the "shortcuts_settings" file (SHORTCUTS_SETTING_FILE_NAME) is
62 	// already used as a communications method between this configurator and
63 	// the "shortcut_catcher" input_server filter, it should not be overloaded
64 	// with window position information, instead, a separate file is used.
65 
66 #undef B_TRANSLATION_CONTEXT
67 #define B_TRANSLATION_CONTEXT "ShortcutsWindow"
68 
69 #define ERROR "Shortcuts error"
70 #define WARNING "Shortcuts warning"
71 
72 
73 // Creates a pop-up-menu that reflects the possible states of the specified
74 // meta-key.
75 static BPopUpMenu*
76 CreateMetaPopUp(int column)
77 {
78 	MetaKeyStateMap& map = GetNthKeyMap(column);
79 	BPopUpMenu* popup = new BPopUpMenu(NULL, false);
80 	int stateCount = map.GetNumStates();
81 
82 	for (int i = 0; i < stateCount; i++)
83 		popup->AddItem(new BMenuItem(map.GetNthStateDesc(i), NULL));
84 
85 	return popup;
86 }
87 
88 
89 // Creates a pop-up that allows the user to choose a key-cap visually
90 static BPopUpMenu*
91 CreateKeysPopUp()
92 {
93 	BPopUpMenu* popup = new BPopUpMenu(NULL, false);
94 	int numKeys = GetNumKeyIndices();
95 	for (int i = 0; i < numKeys; i++) {
96 		const char* next = GetKeyName(i);
97 		if (next != NULL)
98 			popup->AddItem(new BMenuItem(next, NULL));
99 	}
100 
101 	return popup;
102 }
103 
104 
105 ShortcutsWindow::ShortcutsWindow()
106 	:
107 	BWindow(BRect(0, 0, 0, 0), B_TRANSLATE_SYSTEM_NAME("Shortcuts"),
108 		B_TITLED_WINDOW, B_AUTO_UPDATE_SIZE_LIMITS),
109 	fSavePanel(NULL),
110 	fOpenPanel(NULL),
111 	fSelectPanel(NULL),
112 	fKeySetModified(false),
113 	fLastOpenWasAppend(false)
114 {
115 	ShortcutsSpec::InitializeMetaMaps();
116 
117 	BMenuBar* menuBar = new BMenuBar("Menu Bar");
118 
119 	BMenu* fileMenu = new BMenu(B_TRANSLATE("File"));
120 	fileMenu->AddItem(new BMenuItem(B_TRANSLATE("Open KeySet" B_UTF8_ELLIPSIS),
121 		new BMessage(OPEN_KEYSET), 'O'));
122 	fileMenu->AddItem(new BMenuItem(
123 		B_TRANSLATE("Append KeySet" B_UTF8_ELLIPSIS),
124 		new BMessage(APPEND_KEYSET), 'A'));
125 	fileMenu->AddItem(new BMenuItem(B_TRANSLATE("Revert to saved"),
126 		new BMessage(REVERT_KEYSET), 'A'));
127 	fileMenu->AddItem(new BSeparatorItem);
128 	fileMenu->AddItem(new BMenuItem(
129 		B_TRANSLATE("Save KeySet as" B_UTF8_ELLIPSIS),
130 		new BMessage(SAVE_KEYSET_AS), 'S'));
131 	fileMenu->AddItem(new BSeparatorItem);
132 	fileMenu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
133 		new BMessage(B_QUIT_REQUESTED), 'Q'));
134 	menuBar->AddItem(fileMenu);
135 
136 	BRect tableBounds = Bounds();
137 	tableBounds.top = menuBar->Bounds().bottom + 1;
138 	tableBounds.right -= B_V_SCROLL_BAR_WIDTH;
139 	tableBounds.bottom -= B_H_SCROLL_BAR_HEIGHT;
140 
141 	fColumnListView = new BColumnListView(NULL,
142 		B_WILL_DRAW | B_FRAME_EVENTS, B_FANCY_BORDER);
143 
144 	float cellWidth = be_plain_font->StringWidth("Either") + 20;
145 		// ShortcutsSpec does not seem to translate the string "Either".
146 
147 	for (int i = 0; i < ShortcutsSpec::NUM_META_COLUMNS; i++) {
148 		const char* name = ShortcutsSpec::GetColumnName(i);
149 		float headerWidth = be_plain_font->StringWidth(name) + 20;
150 		float width = max_c(headerWidth, cellWidth);
151 
152 		fColumnListView->AddColumn(new PopUpColumn(CreateMetaPopUp(i), name,
153 				width, width - 1, width * 1.5, B_TRUNCATE_END, false, true, 1),
154 			fColumnListView->CountColumns());
155 	}
156 
157 	float keyCellWidth = be_plain_font->StringWidth("Caps Lock") + 20;
158 	fColumnListView->AddColumn(new PopUpColumn(CreateKeysPopUp(),
159 			B_TRANSLATE("Key"), keyCellWidth, keyCellWidth - 10,
160 			keyCellWidth + 30, B_TRUNCATE_END),
161 		fColumnListView->CountColumns());
162 	BPopUpMenu* popup = new BPopUpMenu(NULL, false);
163 	popup->AddItem(new BMenuItem(
164 		B_TRANSLATE("(Choose application with file requester)"), NULL));
165 	popup->AddItem(new BMenuItem(
166 		B_TRANSLATE("*InsertString \"Your Text Here\""), NULL));
167 	popup->AddItem(new BMenuItem(
168 		B_TRANSLATE("*MoveMouse +20 +0"), NULL));
169 	popup->AddItem(new BMenuItem(B_TRANSLATE("*MoveMouseTo 50% 50%"), NULL));
170 	popup->AddItem(new BMenuItem(B_TRANSLATE("*MouseButton 1"), NULL));
171 	popup->AddItem(new BMenuItem(
172 		B_TRANSLATE("*LaunchHandler text/html"), NULL));
173 	popup->AddItem(new BMenuItem(
174 		B_TRANSLATE("*Multi \"*MoveMouseTo 100% 0\" \"*MouseButton 1\""),
175 		NULL));
176 	popup->AddItem(new BMenuItem(B_TRANSLATE("*MouseDown"), NULL));
177 	popup->AddItem(new BMenuItem(B_TRANSLATE("*MouseUp"), NULL));
178 	popup->AddItem(new BMenuItem(
179 		B_TRANSLATE("*SendMessage application/x-vnd.Be-TRAK 'Tfnd'"), NULL));
180 	popup->AddItem(new BMenuItem(B_TRANSLATE("*Beep"), NULL));
181 	fColumnListView->AddColumn(new PopUpColumn(popup, B_TRANSLATE("Application"),
182 			300.0, 223.0, 324.0, B_TRUNCATE_END, true),
183 		fColumnListView->CountColumns());
184 
185 	fColumnListView->SetSelectionMessage(new BMessage(HOTKEY_ITEM_SELECTED));
186 	fColumnListView->SetSelectionMode(B_SINGLE_SELECTION_LIST);
187 	fColumnListView->SetTarget(this);
188 
189 	fAddButton = new BButton("add", B_TRANSLATE("Add new shortcut"),
190 		new BMessage(ADD_HOTKEY_ITEM), B_FOLLOW_BOTTOM);
191 
192 	fRemoveButton = new BButton("remove",
193 		B_TRANSLATE("Remove selected shortcut"),
194 		new BMessage(REMOVE_HOTKEY_ITEM), B_FOLLOW_BOTTOM);
195 	fRemoveButton->SetEnabled(false);
196 
197 	fSaveButton = new BButton("save", B_TRANSLATE("Save & apply"),
198 		new BMessage(SAVE_KEYSET), B_FOLLOW_BOTTOM | B_FOLLOW_RIGHT);
199 	fSaveButton->SetEnabled(false);
200 
201 	CenterOnScreen();
202 
203 	entry_ref windowSettingsRef;
204 	if (_GetWindowSettingsFile(&windowSettingsRef)) {
205 		// The window settings file is not accepted via B_REFS_RECEIVED; this
206 		// is a behind-the-scenes file that the user will never see or
207 		// interact with.
208 		BFile windowSettingsFile(&windowSettingsRef, B_READ_ONLY);
209 		BMessage loadMessage;
210 		if (loadMessage.Unflatten(&windowSettingsFile) == B_OK)
211 			_LoadWindowSettings(loadMessage);
212 	}
213 
214 	entry_ref keySetRef;
215 	if (_GetSettingsFile(&keySetRef)) {
216 		BMessage message(B_REFS_RECEIVED);
217 		message.AddRef("refs", &keySetRef);
218 		message.AddString("startupRef", "please");
219 		PostMessage(&message);
220 			// tell ourselves to load this file if it exists
221 	}
222 
223 	fColumnListView->ResizeAllColumnsToPreferred();
224 
225 	BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
226 		.Add(menuBar)
227 		.AddGroup(B_VERTICAL)
228 			.SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET))
229 			.SetInsets(B_USE_WINDOW_SPACING)
230 			.Add(fColumnListView)
231 			.AddGroup(B_HORIZONTAL)
232 				.AddGroup(B_HORIZONTAL)
233 				.SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_TOP))
234 				.Add(fAddButton)
235 				.Add(fRemoveButton)
236 				.End()
237 				.AddGroup(B_HORIZONTAL)
238 					.SetExplicitAlignment(BAlignment(B_ALIGN_RIGHT, B_ALIGN_TOP))
239 					.Add(fSaveButton)
240 				.End()
241 			.End()
242 		.End();
243 
244 	Show();
245 }
246 
247 
248 ShortcutsWindow::~ShortcutsWindow()
249 {
250 	delete fSavePanel;
251 	delete fOpenPanel;
252 	delete fSelectPanel;
253 	be_app->PostMessage(B_QUIT_REQUESTED);
254 }
255 
256 
257 bool
258 ShortcutsWindow::QuitRequested()
259 {
260 	bool result = true;
261 
262 	if (fKeySetModified) {
263 		BAlert* alert = new BAlert(WARNING,
264 			B_TRANSLATE("Save changes before closing?"),
265 			B_TRANSLATE("Cancel"), B_TRANSLATE("Don't save"),
266 			B_TRANSLATE("Save"));
267 		alert->SetShortcut(0, B_ESCAPE);
268 		alert->SetShortcut(1, 'd');
269 		alert->SetShortcut(2, 's');
270 		switch (alert->Go()) {
271 			case 0:
272 				result = false;
273 				break;
274 
275 			case 1:
276 				result = true;
277 				break;
278 
279 			case 2:
280 				// Save: automatically if possible, otherwise go back and open
281 				// up the file requester
282 				if (fLastSaved.InitCheck() == B_OK) {
283 					if (_SaveKeySet(fLastSaved) == false) {
284 						BAlert* alert = new BAlert(ERROR,
285 							B_TRANSLATE("Shortcuts was unable to save your "
286 								"KeySet file!"),
287 							B_TRANSLATE("Oh no"));
288 						alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
289 						alert->Go();
290 						result = true; // quit anyway
291 					}
292 				} else {
293 					PostMessage(SAVE_KEYSET);
294 					result = false;
295 				}
296 				break;
297 		}
298 	}
299 
300 	if (result) {
301 		fColumnListView->DeselectAll();
302 
303 		// Save the window position.
304 		entry_ref ref;
305 		if (_GetWindowSettingsFile(&ref)) {
306 			BEntry entry(&ref);
307 			_SaveWindowSettings(entry);
308 		}
309 	}
310 
311 	return result;
312 }
313 
314 
315 bool
316 ShortcutsWindow::_GetSettingsFile(entry_ref* eref)
317 {
318 	BPath path;
319 	if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
320 		return false;
321 	else
322 		path.Append(SHORTCUTS_SETTING_FILE_NAME);
323 
324 	if (BEntry(path.Path(), true).GetRef(eref) == B_OK)
325 		return true;
326 	else
327 		return false;
328 }
329 
330 
331 // Saves a settings file to (saveEntry). Returns true iff successful.
332 bool
333 ShortcutsWindow::_SaveKeySet(BEntry& saveEntry)
334 {
335 	BFile saveTo(&saveEntry, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
336 	if (saveTo.InitCheck() != B_OK)
337 		return false;
338 
339 	BMessage saveMessage;
340 	for (int i = 0; i < fColumnListView->CountRows(); i++) {
341 		BMessage next;
342 		if (((ShortcutsSpec*)fColumnListView->RowAt(i))->Archive(&next)
343 				== B_OK) {
344 			saveMessage.AddMessage("spec", &next);
345 		} else
346 			printf("Error archiving ShortcutsSpec #%i!\n", i);
347 	}
348 
349 	bool result = (saveMessage.Flatten(&saveTo) == B_OK);
350 
351 	if (result) {
352 		fKeySetModified = false;
353 		fSaveButton->SetEnabled(false);
354 	}
355 
356 	return result;
357 }
358 
359 
360 // Appends new entries from the file specified in the "spec" entry of
361 // (loadMessage). Returns true iff successful.
362 bool
363 ShortcutsWindow::_LoadKeySet(const BMessage& loadMessage)
364 {
365 	int i = 0;
366 	BMessage message;
367 	while (loadMessage.FindMessage("spec", i++, &message) == B_OK) {
368 		ShortcutsSpec* spec
369 			= (ShortcutsSpec*)ShortcutsSpec::Instantiate(&message);
370 		if (spec != NULL)
371 			fColumnListView->AddRow(spec);
372 		else
373 			printf("_LoadKeySet: Error parsing spec!\n");
374 	}
375 
376 	return true;
377 }
378 
379 
380 // Gets the filesystem location of the "Shortcuts_window_settings" file.
381 bool
382 ShortcutsWindow::_GetWindowSettingsFile(entry_ref* eref)
383 {
384 	BPath path;
385 	if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
386 		return false;
387 	else
388 		path.Append(WINDOW_SETTINGS_FILE_NAME);
389 
390 	return BEntry(path.Path(), true).GetRef(eref) == B_OK;
391 }
392 
393 
394 // Saves the application settings file to (saveEntry).  Because this is a
395 // non-essential file, errors are ignored when writing the settings.
396 void
397 ShortcutsWindow::_SaveWindowSettings(BEntry& saveEntry)
398 {
399 	BFile saveTo(&saveEntry, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
400 	if (saveTo.InitCheck() != B_OK)
401 		return;
402 
403 	BMessage saveMsg;
404 	saveMsg.AddRect("window frame", Frame());
405 
406 	for (int i = 0; i < fColumnListView->CountColumns(); i++) {
407 		BColumn* column = fColumnListView->ColumnAt(i);
408 		saveMsg.AddFloat("column width", column->Width());
409 	}
410 
411 	saveMsg.Flatten(&saveTo);
412 }
413 
414 
415 // Loads the application settings file from (loadMessage) and resizes
416 // the interface to match the previously saved settings. Because this
417 // is a non-essential file, errors are ignored when loading the settings.
418 void
419 ShortcutsWindow::_LoadWindowSettings(const BMessage& loadMessage)
420 {
421 	BRect frame;
422 	if (loadMessage.FindRect("window frame", &frame) == B_OK) {
423 		// ensure the frame does not resize below the computed minimum.
424 		float width = max_c(Bounds().right, frame.right - frame.left);
425 		float height = max_c(Bounds().bottom, frame.bottom - frame.top);
426 		ResizeTo(width, height);
427 
428 		// ensure the frame is not placed outside of the screen.
429 		BScreen screen(this);
430 		float left = min_c(screen.Frame().right - width, frame.left);
431 		float top = min_c(screen.Frame().bottom - height, frame.top);
432 		MoveTo(left, top);
433 	}
434 
435 	for (int i = 0; i < fColumnListView->CountColumns(); i++) {
436 		BColumn* column = fColumnListView->ColumnAt(i);
437 		float columnWidth;
438 		if (loadMessage.FindFloat("column width", i, &columnWidth) == B_OK)
439 			column->SetWidth(max_c(column->Width(), columnWidth));
440 	}
441 }
442 
443 
444 // Creates a new entry and adds it to the GUI. (defaultCommand) will be the
445 // text in the entry, or NULL if no text is desired.
446 void
447 ShortcutsWindow::_AddNewSpec(const char* defaultCommand)
448 {
449 	_MarkKeySetModified();
450 
451 	ShortcutsSpec* spec;
452 	BRow* curSel = fColumnListView->CurrentSelection();
453 	if (curSel)
454 		spec = new ShortcutsSpec(*((ShortcutsSpec*)curSel));
455 	else {
456 		spec = new ShortcutsSpec("");
457 		for (int i = 0; i < fColumnListView->CountColumns(); i++)
458 			spec->SetField(new BStringField(""), i);
459 	}
460 
461 	fColumnListView->AddRow(spec);
462 	fColumnListView->AddToSelection(spec);
463 	fColumnListView->ScrollTo(spec);
464 	if (defaultCommand)
465 		spec->SetCommand(defaultCommand);
466 }
467 
468 
469 void
470 ShortcutsWindow::MessageReceived(BMessage* message)
471 {
472 	switch (message->what) {
473 		case OPEN_KEYSET:
474 		case APPEND_KEYSET:
475 			fLastOpenWasAppend = (message->what == APPEND_KEYSET);
476 			if (fOpenPanel)
477 				fOpenPanel->Show();
478 			else {
479 				BMessenger messenger(this);
480 				fOpenPanel = new BFilePanel(B_OPEN_PANEL, &messenger, NULL,
481 					0, false);
482 				fOpenPanel->Show();
483 			}
484 			fOpenPanel->SetButtonLabel(B_DEFAULT_BUTTON, fLastOpenWasAppend ?
485 				B_TRANSLATE("Append") : B_TRANSLATE("Open"));
486 			break;
487 
488 		// send a message to myself, to get me to reload the settings file
489 		case REVERT_KEYSET:
490 		{
491 			fLastOpenWasAppend = false;
492 			BMessage reload(B_REFS_RECEIVED);
493 			entry_ref eref;
494 			_GetSettingsFile(&eref);
495 			reload.AddRef("refs", &eref);
496 			reload.AddString("startupRef", "yeah");
497 			PostMessage(&reload);
498 			break;
499 		}
500 
501 		// respond to drag-and-drop messages here
502 		case B_SIMPLE_DATA:
503 		{
504 			int i = 0;
505 
506 			entry_ref ref;
507 			while (message->FindRef("refs", i++, &ref) == B_OK) {
508 				BEntry entry(&ref);
509 				if (entry.InitCheck() == B_OK) {
510 					BPath path(&entry);
511 
512 					if (path.InitCheck() == B_OK) {
513 						// Add a new item with the given path.
514 						BString str(path.Path());
515 						DoStandardEscapes(str);
516 						_AddNewSpec(str.String());
517 					}
518 				}
519 			}
520 			break;
521 		}
522 
523 		// respond to FileRequester's messages here
524 		case B_REFS_RECEIVED:
525 		{
526 			// Find file ref
527 			entry_ref ref;
528 			bool isStartMsg = message->HasString("startupRef");
529 			if (message->FindRef("refs", &ref) == B_OK) {
530 				// load the file into (fileMsg)
531 				BMessage fileMsg;
532 				{
533 					BFile file(&ref, B_READ_ONLY);
534 					if ((file.InitCheck() != B_OK)
535 						|| (fileMsg.Unflatten(&file) != B_OK)) {
536 						if (isStartMsg) {
537 							// use this to save to anyway
538 							fLastSaved = BEntry(&ref);
539 							break;
540 						} else {
541 							BAlert* alert = new BAlert(ERROR,
542 								B_TRANSLATE("Shortcuts was couldn't open your "
543 								"KeySet file!"), B_TRANSLATE("OK"));
544 							alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
545 							alert->Go(NULL);
546 							break;
547 						}
548 					}
549 				}
550 
551 				if (fLastOpenWasAppend == false) {
552 					// Clear the menu...
553 					while (fColumnListView->CountRows()) {
554 						ShortcutsSpec* row =
555 							static_cast<ShortcutsSpec*>(fColumnListView->RowAt(0));
556 						fColumnListView->RemoveRow(row);
557 						delete row;
558 					}
559 				}
560 
561 				if (_LoadKeySet(fileMsg)) {
562 					if (isStartMsg) fLastSaved = BEntry(&ref);
563 					fSaveButton->SetEnabled(isStartMsg == false);
564 
565 					// If we just loaded in the Shortcuts settings file, then
566 					// no need to tell the user to save on exit.
567 					entry_ref eref;
568 					_GetSettingsFile(&eref);
569 					if (ref == eref) fKeySetModified = false;
570 				} else {
571 					BAlert* alert = new BAlert(ERROR,
572 						B_TRANSLATE("Shortcuts was unable to parse your "
573 						"KeySet file!"), B_TRANSLATE("OK"));
574 					alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
575 					alert->Go(NULL);
576 					break;
577 				}
578 			}
579 			break;
580 		}
581 
582 		// these messages come from the pop-up menu of the Applications column
583 		case SELECT_APPLICATION:
584 		{
585 			ShortcutsSpec* row =
586 				static_cast<ShortcutsSpec*>(fColumnListView->CurrentSelection());
587 			if (row != NULL) {
588 				entry_ref aref;
589 				if (message->FindRef("refs", &aref) == B_OK) {
590 					BEntry ent(&aref);
591 					if (ent.InitCheck() == B_OK) {
592 						BPath path;
593 						if ((ent.GetPath(&path) == B_OK)
594 							&& (row->
595 								ProcessColumnTextString(ShortcutsSpec::STRING_COLUMN_INDEX,
596 									path.Path()))) {
597 							_MarkKeySetModified();
598 						}
599 					}
600 				}
601 			}
602 			break;
603 		}
604 
605 		case SAVE_KEYSET:
606 		{
607 			bool showSaveError = false;
608 
609 			const char* name;
610 			entry_ref entry;
611 			if ((message->FindString("name", &name) == B_OK)
612 				&& (message->FindRef("directory", &entry) == B_OK)) {
613 				BDirectory dir(&entry);
614 				BEntry saveTo(&dir, name, true);
615 				showSaveError = ((saveTo.InitCheck() != B_OK)
616 					|| (_SaveKeySet(saveTo) == false));
617 			} else if (fLastSaved.InitCheck() == B_OK) {
618 				// We've saved this before, save over previous file.
619 				showSaveError = (_SaveKeySet(fLastSaved) == false);
620 			} else
621 				PostMessage(SAVE_KEYSET_AS);
622 					// open the save requester...
623 
624 			if (showSaveError) {
625 				BAlert* alert = new BAlert(ERROR,
626 					B_TRANSLATE("Shortcuts wasn't able to save your keyset."),
627 					B_TRANSLATE("OK"));
628 				alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
629 				alert->Go(NULL);
630 			}
631 			break;
632 		}
633 
634 		case SAVE_KEYSET_AS:
635 		{
636 			if (fSavePanel)
637 				fSavePanel->Show();
638 			else {
639 				BMessage message(SAVE_KEYSET);
640 				BMessenger messenger(this);
641 				fSavePanel = new BFilePanel(B_SAVE_PANEL, &messenger, NULL, 0,
642 					false, &message);
643 				fSavePanel->Show();
644 			}
645 			break;
646 		}
647 
648 		case ADD_HOTKEY_ITEM:
649 			_AddNewSpec(NULL);
650 			break;
651 
652 		case REMOVE_HOTKEY_ITEM:
653 		{
654 			BRow* item = fColumnListView->CurrentSelection();
655 			if (item) {
656 				int index = fColumnListView->IndexOf(item);
657 				fColumnListView->RemoveRow(item);
658 				delete item;
659 				_MarkKeySetModified();
660 
661 				// Rules for new selection: If there is an item at (index),
662 				// select it. Otherwise, if there is an item at (index-1),
663 				// select it. Otherwise, select nothing.
664 				int num = fColumnListView->CountRows();
665 				if (num > 0) {
666 					if (index < num)
667 						fColumnListView->AddToSelection(
668 							fColumnListView->RowAt(index));
669 					else {
670 						if (index > 0)
671 							index--;
672 						if (index < num)
673 							fColumnListView->AddToSelection(
674 								fColumnListView->RowAt(index));
675 					}
676 				}
677 			}
678 			break;
679 		}
680 
681 		// Received when the user clicks on the ColumnListView
682 		case HOTKEY_ITEM_SELECTED:
683 		{
684 			if (fColumnListView->CountRows() > 0)
685 				fRemoveButton->SetEnabled(true);
686 			else
687 				fRemoveButton->SetEnabled(false);
688 			break;
689 		}
690 
691 		// Received when an entry is to be modified in response to GUI activity
692 		case HOTKEY_ITEM_MODIFIED:
693 		{
694 			int32 row, column;
695 
696 			if ((message->FindInt32("row", &row) == B_OK)
697 				&& (message->FindInt32("column", &column) == B_OK)) {
698 				int32 key;
699 				const char* bytes;
700 
701 				if (row >= 0) {
702 					ShortcutsSpec* item = (ShortcutsSpec*)
703 						fColumnListView->RowAt(row);
704 					bool repaintNeeded = false; // default
705 
706 					if (message->HasInt32("mouseClick")) {
707 						repaintNeeded = item->ProcessColumnMouseClick(column);
708 					} else if ((message->FindString("bytes", &bytes) == B_OK)
709 						&& (message->FindInt32("key", &key) == B_OK)) {
710 						repaintNeeded = item->ProcessColumnKeyStroke(column,
711 							bytes, key);
712 					} else if (message->FindInt32("unmappedkey", &key) ==
713 						B_OK) {
714 						repaintNeeded = ((column == item->KEY_COLUMN_INDEX)
715 							&& ((key > 0xFF) || (GetKeyName(key) != NULL))
716 							&& (item->ProcessColumnKeyStroke(column, NULL,
717 							key)));
718 					} else if (message->FindString("text", &bytes) == B_OK) {
719 						if ((bytes[0] == '(')&&(bytes[1] == 'C')) {
720 							if (fSelectPanel)
721 								fSelectPanel->Show();
722 							else {
723 								BMessage message(SELECT_APPLICATION);
724 								BMessenger m(this);
725 								fSelectPanel = new BFilePanel(B_OPEN_PANEL, &m,
726 									NULL, 0, false, &message);
727 								fSelectPanel->Show();
728 							}
729 							fSelectPanel->SetButtonLabel(B_DEFAULT_BUTTON,
730 								B_TRANSLATE("Select"));
731 						} else
732 							repaintNeeded = item->ProcessColumnTextString(
733 								column, bytes);
734 					}
735 
736 					if (repaintNeeded) {
737 						fColumnListView->Invalidate(row);
738 						_MarkKeySetModified();
739 					}
740 				}
741 			}
742 			break;
743 		}
744 
745 		default:
746 			BWindow::MessageReceived(message);
747 			break;
748 	}
749 }
750 
751 
752 void
753 ShortcutsWindow::_MarkKeySetModified()
754 {
755 	if (fKeySetModified == false) {
756 		fKeySetModified = true;
757 		fSaveButton->SetEnabled(true);
758 	}
759 }
760 
761 
762 void
763 ShortcutsWindow::Quit()
764 {
765 	BWindow::Quit();
766 }
767 
768 
769 void
770 ShortcutsWindow::DispatchMessage(BMessage* message, BHandler* handler)
771 {
772 	switch (message->what) {
773 		case B_SIMPLE_DATA:
774 			MessageReceived(message);
775 			break;
776 
777 		case B_COPY:
778 		case B_CUT:
779 			if (be_clipboard->Lock()) {
780 				ShortcutsSpec* row =
781 					static_cast<ShortcutsSpec*>(fColumnListView->CurrentSelection());
782 				if (row) {
783 					BMessage* data = be_clipboard->Data();
784 					data->RemoveName("text/plain");
785 					data->AddData("text/plain", B_MIME_TYPE,
786 						row->GetCellText(ShortcutsSpec::STRING_COLUMN_INDEX),
787 						strlen(row->GetCellText(ShortcutsSpec::STRING_COLUMN_INDEX)));
788 					be_clipboard->Commit();
789 
790 					if (message->what == B_CUT) {
791 						row->ProcessColumnTextString(
792 							ShortcutsSpec::STRING_COLUMN_INDEX, "");
793 						_MarkKeySetModified();
794 					}
795 				}
796 				be_clipboard->Unlock();
797 			}
798 			break;
799 
800 		case B_PASTE:
801 			if (be_clipboard->Lock()) {
802 				BMessage* data = be_clipboard->Data();
803 				const char* text;
804 				ssize_t textLen;
805 				if (data->FindData("text/plain", B_MIME_TYPE, (const void**)
806 					&text, &textLen) == B_OK) {
807 					ShortcutsSpec* row =
808 					static_cast<ShortcutsSpec*>(fColumnListView->CurrentSelection());
809 					if (row) {
810 						for (ssize_t i = 0; i < textLen; i++) {
811 							char buf[2] = {text[i], 0x00};
812 							row->ProcessColumnKeyStroke(
813 								ShortcutsSpec::STRING_COLUMN_INDEX, buf, 0);
814 						}
815 					}
816 					_MarkKeySetModified();
817 				}
818 				be_clipboard->Unlock();
819 			}
820 			break;
821 
822 		case B_KEY_DOWN:
823 			ShortcutsSpec* selected;
824 			if (message->GetInt32("modifiers", 0) != 0)
825 				BWindow::DispatchMessage(message, handler);
826 			else if (handler == fColumnListView
827 				&& (selected =
828 					static_cast<ShortcutsSpec*>(fColumnListView->CurrentSelection()))) {
829 				selected->ProcessColumnTextString(
830 						ShortcutsSpec::KEY_COLUMN_INDEX,
831 						GetKeyName(message->GetInt32("key", 0)));
832 				_MarkKeySetModified();
833 			}
834 			break;
835 
836 		default:
837 			BWindow::DispatchMessage(message, handler);
838 			break;
839 	}
840 }
841