source: josm/trunk/src/org/openstreetmap/josm/tools/Shortcut.java@ 19050

Last change on this file since 19050 was 19050, checked in by taylor.smock, 4 weeks ago

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.
  • Property svn:eol-style set to native
File size: 26.7 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.tools;
3
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.awt.event.InputEvent;
7import java.awt.event.KeyEvent;
8import java.util.ArrayList;
9import java.util.Arrays;
10import java.util.Comparator;
11import java.util.HashMap;
12import java.util.List;
13import java.util.Map;
14import java.util.Optional;
15import java.util.concurrent.CopyOnWriteArrayList;
16import java.util.function.Predicate;
17import java.util.stream.Collectors;
18
19import javax.swing.AbstractAction;
20import javax.swing.AbstractButton;
21import javax.swing.Action;
22import javax.swing.JMenu;
23import javax.swing.KeyStroke;
24import javax.swing.text.JTextComponent;
25
26import org.openstreetmap.josm.data.Preferences;
27import org.openstreetmap.josm.spi.preferences.Config;
28
29/**
30 * Global shortcut class.
31 * <p>
32 * Note: This class represents a single shortcut, contains the factory to obtain
33 * shortcut objects from, manages shortcuts and shortcut collisions, and
34 * finally manages loading and saving shortcuts to/from the preferences.
35 * <p>
36 * Action authors: You only need the {@link #registerShortcut} factory. Ignore everything else.
37 * <p>
38 * All: Use only public methods that are also marked to be used. The others are
39 * public so the shortcut preferences can use them.
40 * @since 1084
41 */
42public final class Shortcut {
43 /** the unique ID of the shortcut */
44 private final String shortText;
45 /** a human readable description that will be shown in the preferences */
46 private String longText;
47 /** the key, the caller requested */
48 private final int requestedKey;
49 /** the group, the caller requested */
50 private final int requestedGroup;
51 /** the key that actually is used */
52 private int assignedKey;
53 /** the modifiers that are used */
54 private int assignedModifier;
55 /** true if it got assigned what was requested.
56 * (Note: modifiers will be ignored in favour of group when loading it from the preferences then.) */
57 private boolean assignedDefault;
58 /** true if the user changed this shortcut */
59 private boolean assignedUser;
60 /** true if the user cannot change this shortcut (Note: it also will not be saved into the preferences) */
61 private boolean automatic;
62 /** true if the user requested this shortcut to be set to its default value
63 * (will happen on next restart, as this shortcut will not be saved to the preferences) */
64 private boolean reset;
65
66 // simple constructor
67 private Shortcut(String shortText, String longText, int requestedKey, int requestedGroup, int assignedKey, int assignedModifier,
68 boolean assignedDefault, boolean assignedUser) {
69 this.shortText = shortText;
70 this.longText = longText;
71 this.requestedKey = requestedKey;
72 this.requestedGroup = requestedGroup;
73 this.assignedKey = assignedKey;
74 this.assignedModifier = assignedModifier;
75 this.assignedDefault = assignedDefault;
76 this.assignedUser = assignedUser;
77 this.automatic = false;
78 this.reset = false;
79 }
80
81 public String getShortText() {
82 return shortText;
83 }
84
85 public String getLongText() {
86 return longText;
87 }
88
89 // a shortcut will be renamed when it is handed out again, because the original name may be a dummy
90 private void setLongText(String longText) {
91 this.longText = longText;
92 }
93
94 public int getAssignedKey() {
95 return assignedKey;
96 }
97
98 public int getAssignedModifier() {
99 return assignedModifier;
100 }
101
102 public boolean isAssignedDefault() {
103 return assignedDefault;
104 }
105
106 public boolean isAssignedUser() {
107 return assignedUser;
108 }
109
110 public boolean isAutomatic() {
111 return automatic;
112 }
113
114 public boolean isChangeable() {
115 return !automatic && !"core:none".equals(shortText);
116 }
117
118 private boolean isReset() {
119 return reset;
120 }
121
122 /**
123 * FOR PREF PANE ONLY
124 */
125 public void setAutomatic() {
126 automatic = true;
127 }
128
129 /**
130 * FOR PREF PANE ONLY.<p>
131 * Sets the modifiers that are used.
132 * @param assignedModifier assigned modifier
133 */
134 public void setAssignedModifier(int assignedModifier) {
135 this.assignedModifier = assignedModifier;
136 }
137
138 /**
139 * FOR PREF PANE ONLY.<p>
140 * Sets the key that actually is used.
141 * @param assignedKey assigned key
142 */
143 public void setAssignedKey(int assignedKey) {
144 this.assignedKey = assignedKey;
145 }
146
147 /**
148 * FOR PREF PANE ONLY.<p>
149 * Sets whether the user has changed this shortcut.
150 * @param assignedUser {@code true} if the user has changed this shortcut
151 */
152 public void setAssignedUser(boolean assignedUser) {
153 this.reset = (this.assignedUser || reset) && !assignedUser;
154 if (assignedUser) {
155 assignedDefault = false;
156 } else if (reset) {
157 assignedKey = requestedKey;
158 assignedModifier = findModifier(requestedGroup, null);
159 }
160 this.assignedUser = assignedUser;
161 }
162
163 /**
164 * Use this to register the shortcut with Swing
165 * @return the key stroke
166 */
167 public KeyStroke getKeyStroke() {
168 if (assignedModifier != -1)
169 return KeyStroke.getKeyStroke(assignedKey, assignedModifier);
170 return null;
171 }
172
173 // create a shortcut object from an string as saved in the preferences
174 private Shortcut(String prefString) {
175 List<String> s = new ArrayList<>(Config.getPref().getList(prefString));
176 this.shortText = prefString.substring(15);
177 this.longText = s.get(0);
178 this.requestedKey = Integer.parseInt(s.get(1));
179 this.requestedGroup = Integer.parseInt(s.get(2));
180 this.assignedKey = Integer.parseInt(s.get(3));
181 this.assignedModifier = Integer.parseInt(s.get(4));
182 this.assignedDefault = Boolean.parseBoolean(s.get(5));
183 this.assignedUser = Boolean.parseBoolean(s.get(6));
184 }
185
186 private void saveDefault() {
187 Config.getPref().getList("shortcut.entry."+shortText, Arrays.asList(longText,
188 String.valueOf(requestedKey), String.valueOf(requestedGroup), String.valueOf(requestedKey),
189 String.valueOf(getGroupModifier(requestedGroup)), String.valueOf(true), String.valueOf(false)));
190 }
191
192 // get a string that can be put into the preferences
193 private boolean save() {
194 if (isAutomatic() || isReset() || !isAssignedUser()) {
195 return Config.getPref().putList("shortcut.entry."+shortText, null);
196 } else {
197 return Config.getPref().putList("shortcut.entry."+shortText, Arrays.asList(longText,
198 String.valueOf(requestedKey), String.valueOf(requestedGroup), String.valueOf(assignedKey),
199 String.valueOf(assignedModifier), String.valueOf(assignedDefault), String.valueOf(assignedUser)));
200 }
201 }
202
203 private boolean isSame(int isKey, int isModifier) {
204 // an unassigned shortcut is different from any other shortcut
205 return isKey == assignedKey && isModifier == assignedModifier && assignedModifier != getGroupModifier(NONE);
206 }
207
208 public boolean isEvent(KeyEvent e) {
209 KeyStroke ks = getKeyStroke();
210 return ks != null && ks.equals(KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiersEx()));
211 }
212
213 /**
214 * use this to set a menu's mnemonic
215 * @param menu menu
216 */
217 public void setMnemonic(JMenu menu) {
218 if (assignedModifier == getGroupModifier(MNEMONIC) && getKeyStroke() != null && KeyEvent.getKeyText(assignedKey).length() == 1) {
219 menu.setMnemonic(KeyEvent.getKeyText(assignedKey).charAt(0)); //getKeyStroke().getKeyChar() seems not to work here
220 }
221 }
222
223 /**
224 * use this to set a buttons's mnemonic
225 * @param button button
226 */
227 public void setMnemonic(AbstractButton button) {
228 if (assignedModifier == getGroupModifier(MNEMONIC) && getKeyStroke() != null && KeyEvent.getKeyText(assignedKey).length() == 1) {
229 button.setMnemonic(KeyEvent.getKeyText(assignedKey).charAt(0)); //getKeyStroke().getKeyChar() seems not to work here
230 }
231 }
232
233 /**
234 * Sets the mnemonic key on a text component.
235 * @param component component
236 */
237 public void setFocusAccelerator(JTextComponent component) {
238 if (assignedModifier == getGroupModifier(MNEMONIC) && getKeyStroke() != null && KeyEvent.getKeyText(assignedKey).length() == 1) {
239 component.setFocusAccelerator(KeyEvent.getKeyText(assignedKey).charAt(0));
240 }
241 }
242
243 /**
244 * use this to set a actions's accelerator
245 * @param action action
246 */
247 public void setAccelerator(AbstractAction action) {
248 if (getKeyStroke() != null) {
249 action.putValue(Action.ACCELERATOR_KEY, getKeyStroke());
250 }
251 }
252
253 /**
254 * Returns a human readable text for the shortcut.
255 * @return a human readable text for the shortcut
256 */
257 public String getKeyText() {
258 return getKeyText(getKeyStroke());
259 }
260
261 /**
262 * Returns a human readable text for the key stroke.
263 * @param keyStroke key stroke to convert to human readable text
264 * @return a human readable text for the key stroke
265 * @since 12520
266 */
267 public static String getKeyText(KeyStroke keyStroke) {
268 if (keyStroke == null) return "";
269 String modifText = InputEvent.getModifiersExText(keyStroke.getModifiers());
270 if (modifText.isEmpty()) return KeyEvent.getKeyText(keyStroke.getKeyCode());
271 return modifText + '+' + KeyEvent.getKeyText(keyStroke.getKeyCode());
272 }
273
274 /**
275 * Sets the action tooltip to the tooltip text plus the {@linkplain #getKeyText(KeyStroke) key stroke text}
276 * this shortcut represents.
277 *
278 * @param action action
279 * @param tooltip Tooltip text to display
280 * @since 14689
281 */
282 public void setTooltip(Action action, String tooltip) {
283 setTooltip(action, tooltip, getKeyStroke());
284 }
285
286 /**
287 * Sets the action tooltip to the tooltip text plus the {@linkplain #getKeyText(KeyStroke) key stroke text}.
288 *
289 * @param action action
290 * @param tooltip Tooltip text to display
291 * @param keyStroke Key stroke associated (to display accelerator between parenthesis)
292 * @since 14689
293 */
294 public static void setTooltip(Action action, String tooltip, KeyStroke keyStroke) {
295 action.putValue(Action.SHORT_DESCRIPTION, makeTooltip(tooltip, keyStroke));
296 }
297
298 @Override
299 public String toString() {
300 return getKeyText();
301 }
302
303 ///////////////////////////////
304 // everything's static below //
305 ///////////////////////////////
306
307 // here we store our shortcuts
308 private static final ShortcutCollection shortcuts = new ShortcutCollection();
309
310 private static final class ShortcutCollection extends CopyOnWriteArrayList<Shortcut> {
311 private static final long serialVersionUID = 1L;
312 @Override
313 public boolean add(Shortcut shortcut) {
314 // expensive consistency check only in debug mode
315 if (Logging.isDebugEnabled()
316 && stream().map(Shortcut::getShortText).anyMatch(shortcut.getShortText()::equals)) {
317 Logging.warn(new AssertionError(shortcut.getShortText() + " already added"));
318 }
319 return super.add(shortcut);
320 }
321
322 void replace(Shortcut newShortcut) {
323 final Optional<Shortcut> existing = findShortcutByKeyOrShortText(-1, NONE, newShortcut.shortText);
324 if (existing.isPresent()) {
325 replaceAll(sc -> existing.get() == sc ? newShortcut : sc);
326 } else {
327 add(newShortcut);
328 }
329 }
330 }
331
332 // and here our modifier groups
333 private static final Map<Integer, Integer> groups = new HashMap<>();
334
335 // check if something collides with an existing shortcut
336
337 /**
338 * Returns the registered shortcut fot the key and modifier
339 * @param requestedKey the requested key
340 * @param modifier the modifier
341 * @return an {@link Optional} registered shortcut, never {@code null}
342 */
343 public static Optional<Shortcut> findShortcut(int requestedKey, int modifier) {
344 return findShortcutByKeyOrShortText(requestedKey, modifier, null);
345 }
346
347 private static Optional<Shortcut> findShortcutByKeyOrShortText(int requestedKey, int modifier, String shortText) {
348 final Predicate<Shortcut> sameKey = sc -> modifier != getGroupModifier(NONE) && sc.isSame(requestedKey, modifier);
349 final Predicate<Shortcut> sameShortText = sc -> sc.getShortText().equals(shortText);
350 return shortcuts.stream()
351 .filter(sameKey.or(sameShortText))
352 .sorted(Comparator.comparingInt(sc -> sameShortText.test(sc) ? 0 : 1))
353 .findAny();
354 }
355
356 /**
357 * Returns a list of all shortcuts.
358 * @return a list of all shortcuts
359 */
360 public static List<Shortcut> listAll() {
361 return shortcuts.stream()
362 .filter(c -> !"core:none".equals(c.shortText))
363 .collect(Collectors.toList());
364 }
365
366 /** None group: used with KeyEvent.CHAR_UNDEFINED if no shortcut is defined */
367 public static final int NONE = 5000;
368 public static final int MNEMONIC = 5001;
369 /** Reserved group: for system shortcuts only */
370 public static final int RESERVED = 5002;
371 /** Direct group: no modifier */
372 public static final int DIRECT = 5003;
373 /** Alt group */
374 public static final int ALT = 5004;
375 /** Shift group */
376 public static final int SHIFT = 5005;
377 /** Command group. Matches CTRL modifier on Windows/Linux but META modifier on OS X */
378 public static final int CTRL = 5006;
379 /** Alt-Shift group */
380 public static final int ALT_SHIFT = 5007;
381 /** Alt-Command group. Matches ALT-CTRL modifier on Windows/Linux but ALT-META modifier on OS X */
382 public static final int ALT_CTRL = 5008;
383 /** Command-Shift group. Matches CTRL-SHIFT modifier on Windows/Linux but META-SHIFT modifier on OS X */
384 public static final int CTRL_SHIFT = 5009;
385 /** Alt-Command-Shift group. Matches ALT-CTRL-SHIFT modifier on Windows/Linux but ALT-META-SHIFT modifier on OS X */
386 public static final int ALT_CTRL_SHIFT = 5010;
387
388 /* for reassignment */
389 private static final int[] mods = {ALT_CTRL, ALT_SHIFT, CTRL_SHIFT, ALT_CTRL_SHIFT};
390 private static final int[] keys = {KeyEvent.VK_F1, KeyEvent.VK_F2, KeyEvent.VK_F3, KeyEvent.VK_F4,
391 KeyEvent.VK_F5, KeyEvent.VK_F6, KeyEvent.VK_F7, KeyEvent.VK_F8,
392 KeyEvent.VK_F9, KeyEvent.VK_F10, KeyEvent.VK_F11, KeyEvent.VK_F12};
393
394 // bootstrap
395 private static boolean initdone;
396 private static void doInit() {
397 if (initdone) return;
398 initdone = true;
399 int commandDownMask = PlatformManager.getPlatform().getMenuShortcutKeyMaskEx();
400 groups.put(NONE, -1);
401 groups.put(MNEMONIC, InputEvent.ALT_DOWN_MASK);
402 groups.put(DIRECT, 0);
403 groups.put(ALT, InputEvent.ALT_DOWN_MASK);
404 groups.put(SHIFT, InputEvent.SHIFT_DOWN_MASK);
405 groups.put(CTRL, commandDownMask);
406 groups.put(ALT_SHIFT, InputEvent.ALT_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK);
407 groups.put(ALT_CTRL, InputEvent.ALT_DOWN_MASK | commandDownMask);
408 groups.put(CTRL_SHIFT, commandDownMask | InputEvent.SHIFT_DOWN_MASK);
409 groups.put(ALT_CTRL_SHIFT, InputEvent.ALT_DOWN_MASK | commandDownMask | InputEvent.SHIFT_DOWN_MASK);
410
411 // (1) System reserved shortcuts
412 PlatformManager.getPlatform().initSystemShortcuts();
413 // (2) User defined shortcuts
414 Preferences.main().getAllPrefixCollectionKeys("shortcut.entry.").stream()
415 .map(Shortcut::new)
416 .filter(sc -> !findShortcut(sc.getAssignedKey(), sc.getAssignedModifier()).isPresent())
417 .sorted(Comparator.comparing(sc -> sc.isAssignedUser() ? 1 : sc.isAssignedDefault() ? 2 : 3))
418 .forEachOrdered(shortcuts::replace);
419 }
420
421 private static int getGroupModifier(int group) {
422 return Optional.ofNullable(groups.get(group)).orElse(-1);
423 }
424
425 private static int findModifier(int group, Integer modifier) {
426 if (modifier == null) {
427 modifier = getGroupModifier(group);
428 if (modifier == null) { // garbage in, no shortcut out
429 modifier = getGroupModifier(NONE);
430 }
431 }
432 return modifier;
433 }
434
435 // shutdown handling
436
437 /**
438 * Save shortcuts to preferences
439 * @return {@code true} if preferences were changed
440 */
441 public static boolean savePrefs() {
442 return shortcuts.stream()
443 .map(Shortcut::save)
444 .reduce(Boolean.FALSE, Boolean::logicalOr); // has changed
445 }
446
447 /**
448 * FOR PLATFORMHOOK USE ONLY.
449 * <p>
450 * This registers a system shortcut. See PlatformHook for details.
451 * @param shortText an ID. re-use a {@code "system:*"} ID if possible, else use something unique.
452 * @param longText this will be displayed in the shortcut preferences dialog. Better
453 * use something the user will recognize...
454 * @param key the key. Use a {@link KeyEvent KeyEvent.VK_*} constant here.
455 * @param modifier the modifier. Use a {@link KeyEvent KeyEvent.*_MASK} constant here.
456 * @return the system shortcut
457 */
458 public static Shortcut registerSystemShortcut(String shortText, String longText, int key, int modifier) {
459 final Optional<Shortcut> existing = findShortcutByKeyOrShortText(key, modifier, shortText);
460 if (existing.isPresent() && shortText.equals(existing.get().getShortText())) {
461 return existing.get();
462 } else if (existing.isPresent()) {
463 // this always is a logic error in the hook
464 Logging.error("CONFLICT WITH SYSTEM KEY " + shortText + ": " + existing.get());
465 return null;
466 }
467 final Shortcut shortcut = new Shortcut(shortText, longText, key, RESERVED, key, modifier, true, false);
468 shortcuts.add(shortcut);
469 return shortcut;
470 }
471
472 /**
473 * Register a shortcut linked to several characters.
474 *
475 * @param shortText an ID. re-use a {@code "system:*"} ID if possible, else use something unique.
476 * {@code "menu:*"} is reserved for menu mnemonics, {@code "core:*"} is reserved for
477 * actions that are part of JOSM's core. Use something like
478 * {@code <pluginname>+":"+<actionname>}.
479 * @param longText this will be displayed in the shortcut preferences dialog. Better
480 * use something the user will recognize...
481 * @param characters the characters you'd prefer
482 * @param requestedGroup the group this shortcut fits best. This will determine the
483 * modifiers your shortcut will get assigned. Use the constants defined above.
484 * @return the shortcut
485 */
486 public static List<Shortcut> registerMultiShortcuts(String shortText, String longText, List<Character> characters, int requestedGroup) {
487 List<Shortcut> result = new ArrayList<>();
488 int i = 1;
489 Map<Integer, Integer> regularKeyCodes = KeyboardUtils.getRegularKeyCodesMap();
490 for (Character c : characters) {
491 Integer code = (int) c;
492 result.add(registerShortcut(
493 shortText + " (" + i + ')', longText,
494 // Add extended keyCode if not a regular one
495 regularKeyCodes.containsKey(code) ? regularKeyCodes.get(code) :
496 isDeadKey(code) ? code : c | KeyboardUtils.EXTENDED_KEYCODE_FLAG,
497 requestedGroup));
498 i++;
499 }
500 return result;
501 }
502
503 static boolean isDeadKey(int keyCode) {
504 return KeyEvent.VK_DEAD_GRAVE <= keyCode && keyCode <= KeyEvent.VK_DEAD_SEMIVOICED_SOUND;
505 }
506
507 /**
508 * Register a shortcut.
509 * <p>
510 * Here you get your shortcuts from. The parameters are:
511 *
512 * @param shortText an ID. re-use a {@code "system:*"} ID if possible, else use something unique.
513 * {@code "menu:*"} is reserved for menu mnemonics, {@code "core:*"} is reserved for
514 * actions that are part of JOSM's core. Use something like
515 * {@code <pluginname>+":"+<actionname>}.
516 * @param longText this will be displayed in the shortcut preferences dialog. Better
517 * use something the user will recognize...
518 * @param requestedKey the key you'd prefer. Use a {@link KeyEvent KeyEvent.VK_*} constant here.
519 * @param requestedGroup the group this shortcut fits best. This will determine the
520 * modifiers your shortcut will get assigned. Use the constants defined above.
521 * @return the shortcut
522 */
523 public static Shortcut registerShortcut(String shortText, String longText, int requestedKey, int requestedGroup) {
524 return registerShortcut(shortText, longText, requestedKey, requestedGroup, null);
525 }
526
527 // and now the workhorse. same parameters as above, just one more
528 private static Shortcut registerShortcut(String shortText, String longText, int requestedKey, int requestedGroup, Integer modifier) {
529 doInit();
530 int defaultModifier = findModifier(requestedGroup, modifier);
531 final Optional<Shortcut> existing = findShortcutByKeyOrShortText(requestedKey, defaultModifier, shortText);
532 if (existing.isPresent() && shortText.equals(existing.get().getShortText())) {
533 // a re-register? maybe a sc already read from the preferences?
534 final Shortcut sc = existing.get();
535 sc.setLongText(longText); // or set by the platformHook, in this case the original longText doesn't match the real action
536 sc.saveDefault();
537 return sc;
538 } else if (existing.isPresent()) {
539 final Shortcut conflict = existing.get();
540 if (PlatformManager.isPlatformOsx()) {
541 // Try to reassign Meta to Ctrl
542 int newmodifier = findNewOsxModifier(requestedGroup);
543 if (!findShortcut(requestedKey, newmodifier).isPresent()) {
544 Logging.info("Reassigning macOS shortcut '" + shortText + "' from Meta to Ctrl because of conflict with " + conflict);
545 return reassignShortcut(shortText, longText, requestedKey, conflict, requestedGroup, requestedKey, newmodifier);
546 }
547 }
548 for (int m : mods) {
549 for (int k : keys) {
550 int newmodifier = getGroupModifier(m);
551 if (!findShortcut(k, newmodifier).isPresent()) {
552 Logging.info("Reassigning shortcut '" + shortText + "' from " + modifier + " to " + newmodifier +
553 " because of conflict with " + conflict);
554 return reassignShortcut(shortText, longText, requestedKey, conflict, m, k, newmodifier);
555 }
556 }
557 }
558 } else {
559 Shortcut newsc = new Shortcut(shortText, longText, requestedKey, requestedGroup, requestedKey, defaultModifier, true, false);
560 newsc.saveDefault();
561 shortcuts.add(newsc);
562 return newsc;
563 }
564
565 return null;
566 }
567
568 private static int findNewOsxModifier(int requestedGroup) {
569 switch (requestedGroup) {
570 case CTRL: return InputEvent.CTRL_DOWN_MASK;
571 case ALT_CTRL: return InputEvent.ALT_DOWN_MASK | InputEvent.CTRL_DOWN_MASK;
572 case CTRL_SHIFT: return InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK;
573 case ALT_CTRL_SHIFT: return InputEvent.ALT_DOWN_MASK | InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK;
574 default: return 0;
575 }
576 }
577
578 private static Shortcut reassignShortcut(String shortText, String longText, int requestedKey, Shortcut conflict,
579 int m, int k, int newmodifier) {
580 Shortcut newsc = new Shortcut(shortText, longText, requestedKey, m, k, newmodifier, false, false);
581 Logging.info(tr("Silent shortcut conflict: ''{0}'' moved by ''{1}'' to ''{2}''.",
582 shortText, conflict.getShortText(), newsc.getKeyText()));
583 newsc.saveDefault();
584 shortcuts.add(newsc);
585 return newsc;
586 }
587
588 /**
589 * Replies the platform specific key stroke for the 'Copy' command, i.e.
590 * 'Ctrl-C' on windows or 'Meta-C' on a Mac. null, if the platform specific
591 * copy command isn't known.
592 *
593 * @return the platform specific key stroke for the 'Copy' command
594 */
595 public static KeyStroke getCopyKeyStroke() {
596 return getKeyStrokeForShortKey("system:copy");
597 }
598
599 /**
600 * Replies the platform specific key stroke for the 'Paste' command, i.e.
601 * 'Ctrl-V' on windows or 'Meta-V' on a Mac. null, if the platform specific
602 * paste command isn't known.
603 *
604 * @return the platform specific key stroke for the 'Paste' command
605 */
606 public static KeyStroke getPasteKeyStroke() {
607 return getKeyStrokeForShortKey("system:paste");
608 }
609
610 /**
611 * Replies the platform specific key stroke for the 'Cut' command, i.e.
612 * 'Ctrl-X' on windows or 'Meta-X' on a Mac. null, if the platform specific
613 * 'Cut' command isn't known.
614 *
615 * @return the platform specific key stroke for the 'Cut' command
616 */
617 public static KeyStroke getCutKeyStroke() {
618 return getKeyStrokeForShortKey("system:cut");
619 }
620
621 private static KeyStroke getKeyStrokeForShortKey(String shortKey) {
622 return shortcuts.stream()
623 .filter(sc -> shortKey.equals(sc.getShortText()))
624 .findAny()
625 .map(Shortcut::getKeyStroke)
626 .orElse(null);
627 }
628
629 /**
630 * Returns the tooltip text plus the {@linkplain #getKeyText(KeyStroke) key stroke text}.
631 * <p>
632 * Tooltips are usually not system dependent, unless the
633 * JVM is too dumb to provide correct names for all the keys.
634 * <p>
635 * Some LAFs don't understand HTML, such as the OSX LAFs.
636 *
637 * @param tooltip Tooltip text to display
638 * @param keyStroke Key stroke associated (to display accelerator between parenthesis)
639 * @return Full tooltip text (tooltip + accelerator)
640 * @since 14689
641 */
642 public static String makeTooltip(String tooltip, KeyStroke keyStroke) {
643 final Optional<String> keyStrokeText = Optional.ofNullable(keyStroke)
644 .map(Shortcut::getKeyText)
645 .filter(text -> !text.isEmpty());
646
647 final boolean canHtml = PlatformManager.getPlatform().isHtmlSupportedInMenuTooltips();
648
649 StringBuilder result = new StringBuilder(48);
650 if (canHtml) {
651 result.append("<html>");
652 }
653 result.append(tooltip);
654 if (keyStrokeText.isPresent()) {
655 result.append(' ');
656 if (canHtml) {
657 result.append("<font size='-2'>");
658 }
659 result.append('(').append(keyStrokeText.get()).append(')');
660 if (canHtml) {
661 result.append("</font>");
662 }
663 }
664 if (canHtml) {
665 result.append("&nbsp;</html>");
666 }
667 return result.toString();
668 }
669}
Note: See TracBrowser for help on using the repository browser.