1 21 22 package org.armedbear.j; 23 24 import java.awt.event.KeyEvent ; 25 import java.io.BufferedReader ; 26 import java.io.IOException ; 27 import java.io.InputStreamReader ; 28 import java.io.PrintWriter ; 29 import java.util.ArrayList ; 30 import java.util.Iterator ; 31 import java.util.List ; 32 import javax.swing.KeyStroke ; 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 mappings = new ArrayList (); 41 42 public KeyMap() 43 { 44 } 45 46 public static synchronized KeyMap getGlobalKeyMap() 47 { 48 if (globalKeyMap == null) { 49 String 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 message = null; 86 if (!file.isRemote() && file.isFile()) { 87 int lineNumber = 0; 88 try { 89 BufferedReader in = 90 new BufferedReader (new InputStreamReader (file.getInputStream())); 91 while (true) { 92 String s = in.readLine(); 93 if (s == null) { 94 break; 96 } 97 ++lineNumber; 98 s = s.trim(); 99 if (s.trim().length() == 0) 101 continue; 102 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 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 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 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 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 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 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 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 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 mapKey(0xffc9, 0, "wrapParagraph"); mapKey(0xffc9, SHIFT_MASK, "unwrapParagraph"); mapKey(0xffc9, CTRL_MASK, "toggleWrap"); 313 mapKey(KeyEvent.VK_T, CTRL_MASK | ALT_MASK, "visibleTabs"); 314 315 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 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 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 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 mapKey(KeyEvent.VK_TAB, 0, "insertTab"); 367 368 if (Platform.isPlatformLinux()) { 369 mapKey(0x2d, CTRL_MASK, "toCenter"); mapKey(0x5f, CTRL_MASK | SHIFT_MASK, "toTop"); 373 mapKey(0x2d, CTRL_MASK | SHIFT_MASK, "toTop"); } else if (Platform.isPlatformWindows()) { 376 mapKey(0x2d, CTRL_MASK, "toCenter"); mapKey(0x2d, CTRL_MASK | SHIFT_MASK, "toTop"); } 379 } 380 381 public synchronized final KeyMapping lookup(char keyChar, int keyCode, 382 int modifiers) 383 { 384 modifiers &= 0x0f; 386 if (keyCode == 0 && modifiers == 0) { 387 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 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 keyStroke) 410 { 411 return lookup(keyStroke.getKeyChar(), keyStroke.getKeyCode(), 412 keyStroke.getModifiers()); 413 } 414 415 public synchronized final KeyMapping getKeyMapping(String 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 listKeys(String command) 427 { 428 command = command.intern(); 429 ArrayList list = new ArrayList (); 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 public synchronized void addMappingsForCommand(String 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 command) 452 { 453 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 mappings.add(new KeyMapping(keyCode, modifiers, command)); 463 } 464 465 public synchronized void mapKey(char keyChar, String command) 466 { 467 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 mappings.add(new KeyMapping(keyChar, command)); 477 } 478 479 private boolean mapKey(String 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 public synchronized boolean mapKey(String keyText, Object command) 492 { 493 KeyStroke keyStroke = Utilities.getKeyStroke(keyText); 494 if (keyStroke == null) 495 return false; 496 char keyChar = keyStroke.getKeyChar(); 497 int keyCode = keyStroke.getKeyCode(); 498 int modifiers = keyStroke.getModifiers() & 0x0f; 500 if (keyCode == 0 && modifiers == 0) { 501 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 mappings.add(new KeyMapping(keyChar, command)); 512 } else { 513 for (int i = mappings.size(); i-- > 0;) { 514 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 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 public synchronized boolean unmapKey(String keyText) 556 { 557 KeyStroke keyStroke = Utilities.getKeyStroke(keyText); 558 if (keyStroke != null) { 559 char keyChar = keyStroke.getKeyChar(); 560 int keyCode = keyStroke.getKeyCode(); 561 int modifiers = keyStroke.getModifiers() & 0x0f; 563 if (keyCode == 0 && modifiers == 0) { 564 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 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 out = new PrintWriter (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 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 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 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 |