KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > armedbear > j > KeyMap


1 /*
2  * KeyMap.java
3  *
4  * Copyright (C) 1998-2003 Peter Graves
5  * $Id: KeyMap.java,v 1.20 2004/09/13 02:03:08 piso Exp $
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20  */

21
22 package org.armedbear.j;
23
24 import java.awt.event.KeyEvent JavaDoc;
25 import java.io.BufferedReader JavaDoc;
26 import java.io.IOException JavaDoc;
27 import java.io.InputStreamReader JavaDoc;
28 import java.io.PrintWriter JavaDoc;
29 import java.util.ArrayList JavaDoc;
30 import java.util.Iterator JavaDoc;
31 import java.util.List JavaDoc;
32 import javax.swing.KeyStroke JavaDoc;
33
34 public final class KeyMap implements Constants
35 {
36     private static KeyMap globalKeyMap;
37     private static KeyMap globalOverrides;
38     private static File globalKeyMapFile;
39
40     private ArrayList JavaDoc mappings = new ArrayList JavaDoc();
41
42     public KeyMap()
43     {
44     }
45
46     public static synchronized KeyMap getGlobalKeyMap()
47     {
48         if (globalKeyMap == null) {
49             String JavaDoc filename =
50                 Editor.preferences().getStringProperty(Property.GLOBAL_KEY_MAP);
51             if (filename != null) {
52                 globalKeyMapFile = File.getInstance(filename);
53                 if (globalKeyMapFile != null) {
54                     globalKeyMap = new KeyMap();
55                     if (globalKeyMap.load(globalKeyMapFile))
56                         return globalKeyMap;
57                     globalKeyMapFile = null;
58                 }
59             }
60             globalKeyMap = new KeyMap();
61             globalKeyMap.setGlobalDefaults();
62         }
63         return globalKeyMap;
64     }
65
66     public static synchronized final File getGlobalKeyMapFile()
67     {
68         return globalKeyMapFile;
69     }
70
71     public static synchronized final void deleteGlobalKeyMap()
72     {
73         globalKeyMap = null;
74     }
75
76     public synchronized KeyMapping[] getMappings()
77     {
78         KeyMapping[] array = new KeyMapping[mappings.size()];
79         return (KeyMapping[]) mappings.toArray(array);
80     }
81
82     public synchronized boolean load(File file)
83     {
84         boolean error = false;
85         String JavaDoc message = null;
86         if (!file.isRemote() && file.isFile()) {
87             int lineNumber = 0;
88             try {
89                 BufferedReader JavaDoc in =
90                     new BufferedReader JavaDoc(new InputStreamReader JavaDoc(file.getInputStream()));
91                 while (true) {
92                     String JavaDoc s = in.readLine();
93                     if (s == null) {
94                         // Reached end of file.
95
break;
96                     }
97                     ++lineNumber;
98                     s = s.trim();
99                     // Ignore blank lines.
100
if (s.trim().length() == 0)
101                         continue;
102                     // Ignore comment lines.
103
if (s.charAt(0) == '#')
104                         continue;
105                     if (!mapKey(s)) {
106                         error = true;
107                         message = "Error loading key map from " +
108                             file.canonicalPath() +
109                             " (line " + lineNumber + "); will use defaults.";
110                         break;
111                     }
112                 }
113             }
114             catch (IOException JavaDoc e) {
115                 Log.error(e);
116                 message = "Error loading key map from " +
117                     file.canonicalPath() + "; will use defaults.";
118             }
119         } else {
120             error = true;
121             message = "Error loading key map from " + file.canonicalPath() +
122                 " (file not found); will use defaults.";
123         }
124         if (error)
125             MessageDialog.showMessageDialog(message, "Error");
126         return !error;
127     }
128
129     private void setGlobalDefaults()
130     {
131         // File menu.
132
mapKey(KeyEvent.VK_O, CTRL_MASK, "openFile");
133         mapKey(KeyEvent.VK_O, CTRL_MASK | ALT_MASK, "openFileInOtherWindow");
134         mapKey(KeyEvent.VK_O, CTRL_MASK | SHIFT_MASK, "openFileInOtherFrame");
135         mapKey(KeyEvent.VK_N, CTRL_MASK, "newBuffer");
136         mapKey(KeyEvent.VK_R, ALT_MASK, "recentFiles");
137         mapKey(KeyEvent.VK_S, CTRL_MASK, "save");
138         mapKey(KeyEvent.VK_S, CTRL_MASK | SHIFT_MASK, "saveAs");
139         mapKey(KeyEvent.VK_S, CTRL_MASK | ALT_MASK, "saveCopy");
140         mapKey(KeyEvent.VK_F2, 0, "saveAll");
141         mapKey(KeyEvent.VK_F4, CTRL_MASK, "killBuffer");
142         mapKey(KeyEvent.VK_W, CTRL_MASK, "killBuffer");
143         mapKey(KeyEvent.VK_P, ALT_MASK, "properties");
144         mapKey(KeyEvent.VK_RIGHT, ALT_MASK, "nextBuffer");
145         mapKey(KeyEvent.VK_KP_RIGHT, ALT_MASK, "nextBuffer");
146         mapKey(KeyEvent.VK_LEFT, ALT_MASK, "prevBuffer");
147         mapKey(KeyEvent.VK_KP_LEFT, ALT_MASK, "prevBuffer");
148         mapKey(KeyEvent.VK_N, CTRL_MASK | SHIFT_MASK, "newFrame");
149         mapKey(KeyEvent.VK_X, ALT_MASK, "executeCommand");
150         mapKey(KeyEvent.VK_P, CTRL_MASK, "print");
151         mapKey(KeyEvent.VK_Q, CTRL_MASK | SHIFT_MASK, "saveAllExit");
152         mapKey(KeyEvent.VK_Q, CTRL_MASK, "quit");
153
154         // Edit menu.
155
mapKey(KeyEvent.VK_BACK_SPACE, ALT_MASK, "undo");
156         mapKey(KeyEvent.VK_Z, CTRL_MASK, "undo");
157         mapKey(KeyEvent.VK_Y, CTRL_MASK, "redo");
158         mapKey(KeyEvent.VK_DELETE, SHIFT_MASK, "killRegion");
159         mapKey(KeyEvent.VK_X, CTRL_MASK, "killRegion");
160         mapKey(KeyEvent.VK_X, CTRL_MASK | SHIFT_MASK, "killAppend");
161         mapKey(KeyEvent.VK_C, CTRL_MASK, "copyRegion");
162         mapKey(KeyEvent.VK_C, CTRL_MASK | SHIFT_MASK, "copyAppend");
163         mapKey(KeyEvent.VK_V, CTRL_MASK, "paste");
164         mapKey(KeyEvent.VK_V, CTRL_MASK | SHIFT_MASK, "cyclePaste");
165         mapKey(KeyEvent.VK_T, ALT_MASK, "cycleTabWidth");
166
167         // Goto menu.
168
mapKey(KeyEvent.VK_J, CTRL_MASK, "jumpToLine");
169         mapKey(KeyEvent.VK_J, CTRL_MASK | SHIFT_MASK, "jumpToColumn");
170         mapKey(KeyEvent.VK_M, CTRL_MASK, "findMatchingChar");
171         mapKey(KeyEvent.VK_M, CTRL_MASK | SHIFT_MASK, "selectSyntax");
172         mapKey(KeyEvent.VK_UP, CTRL_MASK | ALT_MASK, "findFirstOccurrence");
173         mapKey(KeyEvent.VK_KP_UP, CTRL_MASK | ALT_MASK, "findFirstOccurrence");
174         mapKey(KeyEvent.VK_UP, ALT_MASK, "findPrevWord");
175         mapKey(KeyEvent.VK_KP_UP, ALT_MASK, "findPrevWord");
176         mapKey(KeyEvent.VK_DOWN, ALT_MASK, "findNextWord");
177         mapKey(KeyEvent.VK_KP_DOWN, ALT_MASK, "findNextWord");
178         mapKey(KeyEvent.VK_N, CTRL_MASK | ALT_MASK, "nextChange");
179         mapKey(KeyEvent.VK_P, CTRL_MASK | ALT_MASK, "previousChange");
180         mapKey(KeyEvent.VK_F5, 0, "pushPosition");
181         mapKey(KeyEvent.VK_F5, SHIFT_MASK, "popPosition");
182
183         // Search menu.
184
if (Editor.preferences().getBooleanProperty(Property.USE_INCREMENTAL_FIND))
185             mapKey(KeyEvent.VK_F, CTRL_MASK, "incrementalFind");
186         else
187             mapKey(KeyEvent.VK_F, CTRL_MASK, "find");
188         mapKey(KeyEvent.VK_F3, ALT_MASK, "find");
189
190         mapKey(KeyEvent.VK_L, CTRL_MASK | ALT_MASK, "listOccurrencesOfPatternAtDot");
191
192         mapKey(KeyEvent.VK_F3, 0, "findNext");
193         mapKey(KeyEvent.VK_G, CTRL_MASK, "findNext");
194         mapKey(KeyEvent.VK_F3, SHIFT_MASK, "findPrev");
195         mapKey(KeyEvent.VK_H, CTRL_MASK, "findPrev");
196         mapKey(KeyEvent.VK_F6, 0, "findInFiles");
197         mapKey(KeyEvent.VK_F, CTRL_MASK | SHIFT_MASK, "findInFiles");
198         mapKey(KeyEvent.VK_L, CTRL_MASK, "listOccurrences");
199         mapKey(KeyEvent.VK_L, CTRL_MASK | SHIFT_MASK, "listFiles");
200         mapKey(KeyEvent.VK_R, CTRL_MASK, "replace");
201         mapKey(KeyEvent.VK_R, CTRL_MASK | SHIFT_MASK, "replaceInFiles");
202
203         mapKey(KeyEvent.VK_K, CTRL_MASK, "killLine");
204         mapKey(KeyEvent.VK_DELETE, CTRL_MASK, "deleteWordRight");
205
206         mapKey(KeyEvent.VK_HOME, 0, "home");
207         mapKey(KeyEvent.VK_END, 0, "end");
208         mapKey(KeyEvent.VK_HOME, SHIFT_MASK, "selectHome");
209         mapKey(KeyEvent.VK_END, SHIFT_MASK, "selectEnd");
210         mapKey(KeyEvent.VK_HOME, CTRL_MASK, "bob");
211         mapKey(KeyEvent.VK_HOME, CTRL_MASK | SHIFT_MASK, "selectBob");
212         mapKey(KeyEvent.VK_END, CTRL_MASK, "eob");
213         mapKey(KeyEvent.VK_END, CTRL_MASK | SHIFT_MASK, "selectEob");
214         mapKey(KeyEvent.VK_UP, 0, "up");
215         mapKey(KeyEvent.VK_KP_UP, 0, "up");
216         mapKey(KeyEvent.VK_DOWN, 0, "down");
217         mapKey(KeyEvent.VK_KP_DOWN, 0, "down");
218         mapKey(KeyEvent.VK_UP, SHIFT_MASK, "selectUp");
219         mapKey(KeyEvent.VK_KP_UP, SHIFT_MASK, "selectUp");
220         mapKey(KeyEvent.VK_DOWN, SHIFT_MASK, "selectDown");
221         mapKey(KeyEvent.VK_KP_DOWN, SHIFT_MASK, "selectDown");
222         mapKey(KeyEvent.VK_LEFT, 0, "left");
223         mapKey(KeyEvent.VK_KP_LEFT, 0, "left");
224         mapKey(KeyEvent.VK_RIGHT, 0, "right");
225         mapKey(KeyEvent.VK_KP_RIGHT, 0, "right");
226         mapKey(KeyEvent.VK_LEFT, SHIFT_MASK, "selectLeft");
227         mapKey(KeyEvent.VK_KP_LEFT, SHIFT_MASK, "selectLeft");
228         mapKey(KeyEvent.VK_RIGHT, SHIFT_MASK, "selectRight");
229         mapKey(KeyEvent.VK_KP_RIGHT, SHIFT_MASK, "selectRight");
230         mapKey(KeyEvent.VK_UP, CTRL_MASK, "windowUp");
231         mapKey(KeyEvent.VK_KP_UP, CTRL_MASK, "windowUp");
232         mapKey(KeyEvent.VK_DOWN, CTRL_MASK, "windowDown");
233         mapKey(KeyEvent.VK_KP_DOWN, CTRL_MASK, "windowDown");
234         mapKey(KeyEvent.VK_PAGE_UP, 0, "pageUp");
235         mapKey(KeyEvent.VK_PAGE_UP, ALT_MASK, "pageUpOtherWindow");
236         mapKey(KeyEvent.VK_PAGE_UP, SHIFT_MASK, "selectPageUp");
237         mapKey(KeyEvent.VK_PAGE_DOWN, 0, "pageDown");
238         mapKey(KeyEvent.VK_PAGE_DOWN, ALT_MASK, "pageDownOtherWindow");
239         mapKey(KeyEvent.VK_PAGE_DOWN, SHIFT_MASK, "selectPageDown");
240         mapKey(KeyEvent.VK_PAGE_UP, CTRL_MASK, "top");
241         mapKey(KeyEvent.VK_PAGE_DOWN, CTRL_MASK, "bottom");
242         mapKey(KeyEvent.VK_LEFT, CTRL_MASK, "wordLeft");
243         mapKey(KeyEvent.VK_KP_LEFT, CTRL_MASK, "wordLeft");
244         mapKey(KeyEvent.VK_RIGHT, CTRL_MASK, "wordRight");
245         mapKey(KeyEvent.VK_KP_RIGHT, CTRL_MASK, "wordRight");
246         mapKey(KeyEvent.VK_LEFT, CTRL_MASK | SHIFT_MASK, "selectWordLeft");
247         mapKey(KeyEvent.VK_KP_LEFT, CTRL_MASK | SHIFT_MASK, "selectWordLeft");
248         mapKey(KeyEvent.VK_RIGHT, CTRL_MASK | SHIFT_MASK, "selectWordRight");
249         mapKey(KeyEvent.VK_KP_RIGHT, CTRL_MASK | SHIFT_MASK, "selectWordRight");
250         mapKey(KeyEvent.VK_DELETE, 0, "delete");
251         mapKey(KeyEvent.VK_BACK_SPACE, 0, "backspace");
252         mapKey(KeyEvent.VK_BACK_SPACE, SHIFT_MASK, "backspace");
253         mapKey(KeyEvent.VK_BACK_SPACE, CTRL_MASK, "deleteWordLeft");
254         mapKey(KeyEvent.VK_ENTER, 0, "newline");
255
256         mapKey(KeyEvent.VK_ESCAPE, 0, "escape");
257
258         mapKey(KeyEvent.VK_G, CTRL_MASK | SHIFT_MASK, "gotoFile");
259         mapKey(KeyEvent.VK_B, CTRL_MASK | SHIFT_MASK, "browseFileAtDot");
260
261         mapKey(KeyEvent.VK_D, CTRL_MASK, "dir");
262
263         mapKey(KeyEvent.VK_F2, SHIFT_MASK, "stamp");
264
265         mapKey(KeyEvent.VK_A, CTRL_MASK, "selectAll");
266
267         mapKey(KeyEvent.VK_OPEN_BRACKET, ALT_MASK, "slideOut");
268         mapKey(KeyEvent.VK_CLOSE_BRACKET, ALT_MASK, "slideIn");
269
270         // Bookmarks MUST be mapped like this!
271
mapKey(KeyEvent.VK_0, ALT_MASK, "dropBookmark");
272         mapKey(KeyEvent.VK_1, ALT_MASK, "dropBookmark");
273         mapKey(KeyEvent.VK_2, ALT_MASK, "dropBookmark");
274         mapKey(KeyEvent.VK_3, ALT_MASK, "dropBookmark");
275         mapKey(KeyEvent.VK_4, ALT_MASK, "dropBookmark");
276         mapKey(KeyEvent.VK_5, ALT_MASK, "dropBookmark");
277         mapKey(KeyEvent.VK_6, ALT_MASK, "dropBookmark");
278         mapKey(KeyEvent.VK_7, ALT_MASK, "dropBookmark");
279         mapKey(KeyEvent.VK_8, ALT_MASK, "dropBookmark");
280         mapKey(KeyEvent.VK_9, ALT_MASK, "dropBookmark");
281         mapKey(KeyEvent.VK_0, CTRL_MASK, "gotoBookmark");
282         mapKey(KeyEvent.VK_1, CTRL_MASK, "gotoBookmark");
283         mapKey(KeyEvent.VK_2, CTRL_MASK, "gotoBookmark");
284         mapKey(KeyEvent.VK_3, CTRL_MASK, "gotoBookmark");
285         mapKey(KeyEvent.VK_4, CTRL_MASK, "gotoBookmark");
286         mapKey(KeyEvent.VK_5, CTRL_MASK, "gotoBookmark");
287         mapKey(KeyEvent.VK_6, CTRL_MASK, "gotoBookmark");
288         mapKey(KeyEvent.VK_7, CTRL_MASK, "gotoBookmark");
289         mapKey(KeyEvent.VK_8, CTRL_MASK, "gotoBookmark");
290         mapKey(KeyEvent.VK_9, CTRL_MASK, "gotoBookmark");
291
292         // Temporary marker commands.
293
mapKey(KeyEvent.VK_BACK_SLASH, ALT_MASK, "dropTemporaryMarker");
294         mapKey(KeyEvent.VK_BACK_SLASH, CTRL_MASK, "gotoTemporaryMarker");
295         mapKey(KeyEvent.VK_BACK_SLASH, CTRL_MASK | SHIFT_MASK, "selectToTemporaryMarker");
296
297         mapKey(KeyEvent.VK_F11, 0, "commentRegion");
298         mapKey(KeyEvent.VK_F11, SHIFT_MASK, "uncommentRegion");
299
300         // Duplicate mappings to support IBM 1.3 for Linux.
301
mapKey(0xffc8, 0, "commentRegion");
302         mapKey(0xffc8, SHIFT_MASK, "uncommentRegion");
303
304         mapKey(KeyEvent.VK_F12, 0, "wrapParagraph");
305         mapKey(KeyEvent.VK_F12, SHIFT_MASK, "unwrapParagraph");
306         mapKey(KeyEvent.VK_F12, CTRL_MASK, "toggleWrap");
307
308         // Duplicate mappings to support IBM 1.3 for Linux.
309
mapKey(0xffc9, 0, "wrapParagraph"); // F12
310
mapKey(0xffc9, SHIFT_MASK, "unwrapParagraph"); // Shift F12
311
mapKey(0xffc9, CTRL_MASK, "toggleWrap"); // Ctrl F12
312

313         mapKey(KeyEvent.VK_T, CTRL_MASK | ALT_MASK, "visibleTabs");
314
315         // Help menu.
316
mapKey(KeyEvent.VK_F1, 0, "help");
317         mapKey(KeyEvent.VK_K, ALT_MASK, "describeKey");
318
319         mapKey(KeyEvent.VK_SLASH, ALT_MASK, "expand");
320
321         // On Windows, Alt Space drops down the window menu.
322
if (!Platform.isPlatformWindows())
323             mapKey(KeyEvent.VK_SPACE, ALT_MASK, "expand");
324
325         mapKey(KeyEvent.VK_N, ALT_MASK, "nextFrame");
326
327         mapKey(KeyEvent.VK_W, ALT_MASK, "selectWord");
328
329         mapKey(VK_MOUSE_1, 0, "mouseMoveDotToPoint");
330         mapKey(VK_MOUSE_1, SHIFT_MASK, "mouseSelect");
331         mapKey(VK_MOUSE_1, CTRL_MASK | SHIFT_MASK, "mouseSelectColumn");
332         mapKey(VK_DOUBLE_MOUSE_1, 0, "selectWord");
333
334         if (Platform.isPlatformUnix()) {
335             mapKey(VK_MOUSE_2, 0, "pastePrimarySelection");
336             mapKey(KeyEvent.VK_INSERT, SHIFT_MASK, "pastePrimarySelection");
337         }
338
339         mapKey(VK_MOUSE_3, 0, "mouseShowContextMenu");
340
341         mapKey(KeyEvent.VK_F7, 0, "recordMacro");
342         mapKey(KeyEvent.VK_F8, 0, "playbackMacro");
343
344         mapKey(KeyEvent.VK_W, CTRL_MASK | SHIFT_MASK, "killFrame");
345
346         // Sidebar.
347
mapKey(KeyEvent.VK_EQUALS, ALT_MASK, "toggleSidebar");
348         mapKey(KeyEvent.VK_B, ALT_MASK, "sidebarListBuffers");
349         mapKey(KeyEvent.VK_T, CTRL_MASK | SHIFT_MASK, "sidebarListTags");
350
351         mapKey(KeyEvent.VK_F10, 0, "splitWindow");
352         mapKey(KeyEvent.VK_F10, SHIFT_MASK, "unsplitWindow");
353         mapKey(KeyEvent.VK_F10, CTRL_MASK | SHIFT_MASK, "killWindow");
354         mapKey(KeyEvent.VK_O, ALT_MASK, "otherWindow");
355
356         if (Editor.preferences().getBooleanProperty(Property.ENABLE_EXPERIMENTAL_FEATURES))
357             mapKey(KeyEvent.VK_F9, ALT_MASK, "shell");
358
359         // Map these globally so they're available in the compilation buffer too.
360
mapKey(KeyEvent.VK_F4, 0, "nextError");
361         mapKey(KeyEvent.VK_F4, SHIFT_MASK, "previousError");
362         mapKey(KeyEvent.VK_M, CTRL_MASK | ALT_MASK, "showMessage");
363
364         // Windows VM seems to need this mapping for the tab key to work properly.
365
// There's also code in Dispatcher.dispatchKeyTyped to handle the tab key.
366
mapKey(KeyEvent.VK_TAB, 0, "insertTab");
367
368         if (Platform.isPlatformLinux()) {
369             // These mappings work with Blackdown 1.2.2 (and 1.2 pre-release v2).
370
mapKey(0x2d, CTRL_MASK, "toCenter"); // Ctrl -
371
mapKey(0x5f, CTRL_MASK | SHIFT_MASK, "toTop"); // Ctrl Shift -
372

373             // IBM 1.3, Sun 1.4.0 beta 2.
374
mapKey(0x2d, CTRL_MASK | SHIFT_MASK, "toTop"); // Ctrl Shift -
375
} else if (Platform.isPlatformWindows()) {
376             mapKey(0x2d, CTRL_MASK, "toCenter"); // Ctrl -
377
mapKey(0x2d, CTRL_MASK | SHIFT_MASK, "toTop"); // Ctrl Shift -
378
}
379     }
380
381     public synchronized final KeyMapping lookup(char keyChar, int keyCode,
382         int modifiers)
383     {
384         // Mask off the bits we don't care about (Java 1.4).
385
modifiers &= 0x0f;
386         if (keyCode == 0 && modifiers == 0) {
387             // This is the keyTyped() case. Ignore keyCode and modifiers;
388
// keyChar must match the mapping.
389
for (int i = mappings.size(); i-- > 0;) {
390                 KeyMapping mapping = (KeyMapping) mappings.get(i);
391                 if (keyChar == mapping.getKeyChar())
392                     return mapping;
393             }
394         } else {
395             for (int i = mappings.size(); i-- > 0;) {
396                 // This is the keyPressed() case. keyCode and modifiers must
397
// match the mapping. mapping.getKeyChar() must be zero, but
398
// we ignore the keyChar argument.
399
KeyMapping mapping = (KeyMapping) mappings.get(i);
400                 if (mapping.getKeyChar() == 0 &&
401                     keyCode == mapping.getKeyCode() &&
402                     modifiers == mapping.getModifiers())
403                     return mapping;
404             }
405         }
406         return null;
407     }
408
409     public synchronized final KeyMapping lookup(KeyStroke JavaDoc keyStroke)
410     {
411         return lookup(keyStroke.getKeyChar(), keyStroke.getKeyCode(),
412             keyStroke.getModifiers());
413     }
414
415     public synchronized final KeyMapping getKeyMapping(String JavaDoc command)
416     {
417         command = command.intern();
418         for (int i = 0, limit = mappings.size(); i < limit; i++) {
419             KeyMapping mapping = (KeyMapping) mappings.get(i);
420             if (command == mapping.getCommand())
421                 return mapping;
422         }
423         return null;
424     }
425
426     public synchronized List JavaDoc listKeys(String JavaDoc command)
427     {
428         command = command.intern();
429         ArrayList JavaDoc list = new ArrayList JavaDoc();
430         for (int i = mappings.size(); i-- > 0;) {
431             KeyMapping mapping = (KeyMapping) mappings.get(i);
432             if (command == mapping.getCommand())
433                 list.add(mapping.getKeyText());
434         }
435         return list;
436     }
437
438     // Add all mappings for command from source key map.
439
public synchronized void addMappingsForCommand(String JavaDoc command, KeyMap source)
440     {
441         command = command.intern();
442         final KeyMapping[] sourceMappings = source.getMappings();
443         final int limit = sourceMappings.length;
444         for (int i = 0; i < limit; i++) {
445             KeyMapping mapping = sourceMappings[i];
446             if (command == mapping.getCommand())
447                 mappings.add(mapping);
448         }
449     }
450
451     public synchronized void mapKey(int keyCode, int modifiers, String JavaDoc command)
452     {
453         // See if we already have a mapping for this keystroke.
454
for (int i = 0; i < mappings.size(); i++) {
455             KeyMapping mapping = (KeyMapping) mappings.get(i);
456             if (keyCode == mapping.getKeyCode() && modifiers == mapping.getModifiers()) {
457                 mappings.set(i, new KeyMapping(keyCode, modifiers, command));
458                 return;
459             }
460         }
461         // No mapping found.
462
mappings.add(new KeyMapping(keyCode, modifiers, command));
463     }
464
465     public synchronized void mapKey(char keyChar, String JavaDoc command)
466     {
467         // See if we already have a mapping for this keystroke.
468
for (int i = 0; i < mappings.size(); i++) {
469             KeyMapping mapping = (KeyMapping) mappings.get(i);
470             if (keyChar == mapping.getKeyChar()) {
471                 mappings.set(i, new KeyMapping(keyChar, command));
472                 return;
473             }
474         }
475         // No mapping found.
476
mappings.add(new KeyMapping(keyChar, command));
477     }
478
479     // Only called from synchronized methods.
480
private boolean mapKey(String JavaDoc s)
481     {
482         KeyMapping mapping = KeyMapping.createKeyMapping(s);
483         if (mapping != null) {
484             mappings.add(mapping);
485             return true;
486         }
487         return false;
488     }
489
490     // For Lisp API.
491
public synchronized boolean mapKey(String JavaDoc keyText, Object JavaDoc command)
492     {
493         KeyStroke JavaDoc keyStroke = Utilities.getKeyStroke(keyText);
494         if (keyStroke == null)
495             return false;
496         char keyChar = keyStroke.getKeyChar();
497         int keyCode = keyStroke.getKeyCode();
498         // Mask off the bits we don't care about (Java 1.4).
499
int modifiers = keyStroke.getModifiers() & 0x0f;
500         if (keyCode == 0 && modifiers == 0) {
501             // This is the keyTyped() case. Ignore keyCode and modifiers;
502
// keyChar must match the mapping.
503
for (int i = mappings.size(); i-- > 0;) {
504                 KeyMapping mapping = (KeyMapping) mappings.get(i);
505                 if (keyChar == mapping.getKeyChar()) {
506                     mappings.set(i, new KeyMapping(keyChar, command));
507                     return true;
508                 }
509             }
510             // Not found.
511
mappings.add(new KeyMapping(keyChar, command));
512         } else {
513             for (int i = mappings.size(); i-- > 0;) {
514                 // This is the keyPressed() case. keyCode and modifiers must
515
// match the mapping. mapping.getKeyChar() must be zero, but
516
// we ignore the keyChar argument.
517
KeyMapping mapping = (KeyMapping) mappings.get(i);
518                 if (mapping.getKeyChar() == 0 &&
519                     keyCode == mapping.getKeyCode() &&
520                     modifiers == mapping.getModifiers()) {
521                     mappings.set(i,
522                         new KeyMapping(keyCode, modifiers, command));
523                     return true;
524                 }
525             }
526             // Not found.
527
mappings.add(new KeyMapping(keyCode, modifiers, command));
528         }
529         return true;
530     }
531
532     public synchronized void unmapKey(char keyChar)
533     {
534         for (int i = 0; i < mappings.size(); i++) {
535             KeyMapping mapping = (KeyMapping) mappings.get(i);
536             if (keyChar == mapping.getKeyChar()) {
537                 mappings.remove(i);
538                 return;
539             }
540         }
541     }
542
543     public synchronized void unmapKey(int keyCode, int modifiers)
544     {
545         for (int i = 0; i < mappings.size(); i++) {
546             KeyMapping mapping = (KeyMapping) mappings.get(i);
547             if (keyCode == mapping.getKeyCode() && modifiers == mapping.getModifiers()) {
548                 mappings.remove(i);
549                 return;
550             }
551         }
552     }
553
554     // For Lisp API.
555
public synchronized boolean unmapKey(String JavaDoc keyText)
556     {
557         KeyStroke JavaDoc keyStroke = Utilities.getKeyStroke(keyText);
558         if (keyStroke != null) {
559             char keyChar = keyStroke.getKeyChar();
560             int keyCode = keyStroke.getKeyCode();
561             // Mask off the bits we don't care about (Java 1.4).
562
int modifiers = keyStroke.getModifiers() & 0x0f;
563             if (keyCode == 0 && modifiers == 0) {
564                 // This is the keyTyped() case. Ignore keyCode and modifiers;
565
// keyChar must match the mapping.
566
for (int i = mappings.size(); i-- > 0;) {
567                     KeyMapping mapping = (KeyMapping) mappings.get(i);
568                     if (keyChar == mapping.getKeyChar()) {
569                         mappings.remove(i);
570                         return true;
571                     }
572                 }
573             } else {
574                 for (int i = mappings.size(); i-- > 0;) {
575                     // This is the keyPressed() case. keyCode and modifiers must
576
// match the mapping. mapping.getKeyChar() must be zero, but
577
// we ignore the keyChar argument.
578
KeyMapping mapping = (KeyMapping) mappings.get(i);
579                     if (mapping.getKeyChar() == 0 &&
580                         keyCode == mapping.getKeyCode() &&
581                         modifiers == mapping.getModifiers()) {
582                         mappings.remove(i);
583                         return true;
584                     }
585                 }
586             }
587         }
588         return false;
589     }
590
591     public synchronized void writeKeyMap(File file)
592     {
593         try {
594             PrintWriter JavaDoc out = new PrintWriter JavaDoc(file.getOutputStream());
595             for (int i = 0; i < mappings.size(); i++)
596                 out.println(mappings.get(i).toString());
597             out.close();
598         }
599         catch (IOException JavaDoc e) {
600             Log.error(e);
601         }
602     }
603
604     private static synchronized void useGlobalDefaults()
605     {
606         globalKeyMap = new KeyMap();
607         globalKeyMap.setGlobalDefaults();
608     }
609
610     public static void defaultKeyMaps()
611     {
612         useGlobalDefaults();
613         for (Iterator JavaDoc it = Editor.getModeList().iterator(); it.hasNext();) {
614             ModeListEntry entry = (ModeListEntry) it.next();
615             Mode mode = entry.getMode(false);
616             if (mode != null)
617                 mode.useDefaultKeyMap();
618         }
619     }
620
621     public static void reloadKeyMaps()
622     {
623         deleteGlobalKeyMap();
624         for (Iterator JavaDoc it = Editor.getModeList().iterator(); it.hasNext();) {
625             ModeListEntry entry = (ModeListEntry) it.next();
626             Mode mode = entry.getMode(false);
627             if (mode != null)
628                 mode.deleteKeyMap();
629         }
630     }
631 }
632
Popular Tags