development/ghidra
development/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra synced 2024-08-27 21:10:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

GP-4317 - Removing the 'reserved' concept

Browse source
This commit is contained in:
dragonmacher 2024-02-17 11:21:31 -05:00
parent 52e6360d96
commit e44daf55aa
40 changed files with 1143 additions and 834 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
Ghidra/Extensions/bundle_examples/scripts_with_activator/ActivatorExampleScript.java
View file

@ -17,7 +17,8 @@
//@category Examples.Bundle
import docking.ActionContext;
import docking.action.*;
import docking.action.DockingAction;
import docking.action.ToolBarData;
import ghidra.app.script.GhidraScript;
import ghidra.app.services.CodeViewerService;
import ghidra.app.services.ConsoleService;
@ -40,7 +41,7 @@ public class ActivatorExampleScript extends GhidraScript {
println("The activator will remove the action if this bundle is deactivated,");
println(" e.g. if this script is modified and the bundle needs to be reloaded.");
DockingAction action = new DockingAction("Added by script!!", null, false) {
DockingAction action = new DockingAction("Added by script!!", null) {
@Override
public void actionPerformed(ActionContext context) {
ConsoleService console = tool.getService(ConsoleService.class);

9
Ghidra/Features/Base/src/main/help/help/topics/Tool/ToolOptions_Dialog.htm
View file

@ -59,9 +59,12 @@
the tool options. For example, the following keys cannot be changed:</P>
<UL>
<LI><TT><B>F1, Help, Ctrl-F1, F4</B></TT> (this bindings are reserved and cannot be used
when assigning key bindings to actions)</LI>
<LI>System Action Keybindings - System action default key bindings can be changed, with
added restrictions: 1) The binding for a System action cannot be used by any other action,
2) A key stroke bound to a System action cannot be used by another action until that
key stroke is cleared from the System action. The UI will show a message when these
restrictions are triggered.
</LI>
<LI>Menu Navigation Actions: <TT><B>1-9, Page Up/Down, End, Home</B></TT> (these key
bindings are usable with a menu or popup menu open and are otherwise available for
assignment to key bindings).</LI>

15
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/script/KeyBindingInputDialog.java
View file

@ -21,24 +21,28 @@ import java.awt.Component;
import javax.swing.*;
import docking.*;
import docking.actions.KeyBindingUtils;
import docking.actions.ToolActions;
import docking.widgets.label.GLabel;
import generic.util.action.ReservedKeyBindings;
import ghidra.framework.plugintool.Plugin;
import ghidra.framework.plugintool.PluginTool;
import ghidra.util.HelpLocation;
class KeyBindingInputDialog extends DialogComponentProvider implements KeyEntryListener {
private KeyEntryTextField kbField;
private KeyStroke ks;
private boolean isCancelled;
private Plugin plugin;
KeyBindingInputDialog(Component parent, String scriptName, KeyStroke currentKeyStroke,
Plugin plugin, HelpLocation help) {
super("Assign Script Key Binding", true, true, true, false);
this.plugin = plugin;
kbField = new KeyEntryTextField(20, this);
kbField.setName("KEY_BINDING");
kbField.setText(
currentKeyStroke == null ? "" : KeyEntryTextField.parseKeyStroke(currentKeyStroke));
currentKeyStroke == null ? "" : KeyBindingUtils.parseKeyStroke(currentKeyStroke));
JPanel panel = new JPanel(new BorderLayout(10, 10));
panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
@ -55,8 +59,11 @@ class KeyBindingInputDialog extends DialogComponentProvider implements KeyEntryL
@Override
protected void okCallback() {
if (ks != null && ReservedKeyBindings.isReservedKeystroke(ks)) {
setStatusText(kbField.getText() + " is a reserved keystroke");
PluginTool tool = plugin.getTool();
ToolActions toolActions = (ToolActions) tool.getToolActions();
String errorMessage = toolActions.validateActionKeyBinding(null, ks);
if (errorMessage != null) {
setStatusText(errorMessage);
return;
}

2
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/ComponentInfoPlugin.java
View file

@ -47,7 +47,7 @@ public class ComponentInfoPlugin extends Plugin {
//@formatter:off
DockingAction action =
new ActionBuilder("Component Display", getName())
.menuPath("Help", "Show Diagnostic Component Information")
.menuPath("Help", "Component Diagnostics")
.onAction(e -> showComponentDialog())
.buildAndInstall(tool);
//@formatter:on

13
Ghidra/Features/Base/src/test.slow/java/ghidra/framework/plugintool/dialog/KeyBindingUtilsTest.java
View file

@ -235,7 +235,7 @@ public class KeyBindingUtilsTest extends AbstractGhidraHeadedIntegrationTest {
debug("a");
// get current options
ToolOptions toolKeyBindingOptions = (ToolOptions) getInstanceField("options", panel);
ToolOptions toolKeyBindingOptions = tool.getOptions(DockingToolConstants.KEY_BINDINGS);
debug("b");
@ -289,7 +289,8 @@ public class KeyBindingUtilsTest extends AbstractGhidraHeadedIntegrationTest {
debug("i");
ToolOptions newlyLoadedDefaultOptions = (ToolOptions) getInstanceField("options", panel);
ToolOptions newlyLoadedDefaultOptions = tool.getOptions(DockingToolConstants.KEY_BINDINGS);
assertOptionsMatch(
"The options from the first tool instance have changed " +
"in the second tool instance even though the testing changes were not applied.",
@ -328,7 +329,7 @@ public class KeyBindingUtilsTest extends AbstractGhidraHeadedIntegrationTest {
setKeyBindingsUpDialog(tool);
newlyLoadedDefaultOptions = (ToolOptions) getInstanceField("options", panel);
newlyLoadedDefaultOptions = tool.getOptions(DockingToolConstants.KEY_BINDINGS);
assertOptionsDontMatch(
"The options are the same after making changes, applying, closing and reloading.",
originalOptions, newlyLoadedDefaultOptions);
@ -364,7 +365,7 @@ public class KeyBindingUtilsTest extends AbstractGhidraHeadedIntegrationTest {
assertEquals(newBinding, restoredBinding);
setKeyBindingsUpDialog(tool);
ToolOptions options = (ToolOptions) getInstanceField("options", panel);
ToolOptions options = tool.getOptions(DockingToolConstants.KEY_BINDINGS);
KeyStroke optionBinding = options.getKeyStroke(action.getFullName(), null);
assertEquals(appliedBinding, optionBinding);
@ -457,7 +458,7 @@ public class KeyBindingUtilsTest extends AbstractGhidraHeadedIntegrationTest {
}
private void setSelectionPath(final GTree tree, final TreePath path) throws Exception {
SwingUtilities.invokeAndWait(() -> tree.setSelectionPath(path));
runSwing(() -> tree.setSelectionPath(path));
}
private GTreeNode getGTreeNode(GTreeNode parent, String nodeName) throws Exception {
@ -520,7 +521,7 @@ public class KeyBindingUtilsTest extends AbstractGhidraHeadedIntegrationTest {
if (actionName.equals(model.getValueAt(i, 0)) &&
owner.equals(model.getValueAt(i, 2))) {
final int idx = i;
SwingUtilities.invokeAndWait(() -> {
runSwing(() -> {
table.setRowSelectionInterval(idx, idx);
Rectangle rect = table.getCellRect(idx, idx, true);
table.scrollRectToVisible(rect);

302
Ghidra/Features/Base/src/test.slow/java/ghidra/framework/plugintool/dialog/KeyBindingsTest.java
View file

@ -20,6 +20,7 @@ import static org.junit.Assert.*;
import java.awt.Rectangle;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.util.List;
import java.util.Set;
import javax.swing.*;
@ -28,16 +29,17 @@ import javax.swing.table.*;
import org.junit.*;
import docking.DockingWindowManager;
import docking.KeyEntryTextField;
import docking.action.DockingActionIf;
import docking.tool.util.DockingToolConstants;
import docking.action.*;
import docking.actions.KeyBindingUtils;
import docking.actions.ToolActions;
import docking.widgets.MultiLineLabel;
import generic.test.TestUtils;
import generic.util.action.SystemKeyBindings;
import ghidra.app.plugin.core.codebrowser.CodeBrowserPlugin;
import ghidra.app.plugin.core.navigation.GoToAddressLabelPlugin;
import ghidra.framework.plugintool.PluginTool;
import ghidra.test.AbstractGhidraHeadedIntegrationTest;
import ghidra.test.TestEnv;
import ghidra.util.Msg;
/**
* Tests for key bindings option panel
@ -62,6 +64,7 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
tool = env.getTool();
tool.addPlugin(CodeBrowserPlugin.class.getName());
tool.addPlugin(GoToAddressLabelPlugin.class.getName());
env.showTool();
@ -123,14 +126,6 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
}
}
private boolean ignoreAction(DockingActionIf action) {
if (!action.getKeyBindingType().isManaged()) {
return true;
}
return action.getFullName().contains("Table Data");
}
@Test
public void testEditKeyBinding() throws Exception {
// find action that has a keystroke assigned
@ -139,7 +134,7 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
selectRowForAction(action);
triggerText(keyField, "z");
assertEquals("Z", keyField.getText());
assertKeyFieldText("Z");
apply();
assertEquals(KeyStroke.getKeyStroke(KeyEvent.VK_Z, 0), getKeyStroke(action));
@ -157,24 +152,19 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
}
triggerText(keyField, "z");
assertTrue(statusPane.getText().indexOf("No action is selected.") != -1);
assertMessage("No action is selected.");
}
@Test
public void testSetKeyBinding() throws Exception {
// set a key binding on an action that does not have a key binding
selectRowForAction(action1);
triggerActionKey(keyField, InputEvent.CTRL_DOWN_MASK, KeyEvent.VK_X);
assertEquals(
KeyEntryTextField.parseKeyStroke(
KeyStroke.getKeyStroke(KeyEvent.VK_X, InputEvent.CTRL_DOWN_MASK)),
keyField.getText());
KeyStroke ks = KeyStroke.getKeyStroke(KeyEvent.VK_X, InputEvent.CTRL_DOWN_MASK);
assertKeyFieldText(KeyBindingUtils.parseKeyStroke(ks));
apply();
assertEquals(KeyStroke.getKeyStroke(KeyEvent.VK_X, InputEvent.CTRL_DOWN_MASK),
getKeyStroke(action1));
assertEquals(ks, getKeyStroke(action1));
}
@Test
@ -182,57 +172,34 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
selectRowForAction(action1);
triggerText(keyField, "x");
assertEquals("X", keyField.getText());
assertKeyFieldText("X");
apply();
assertEquals(KeyStroke.getKeyStroke(KeyEvent.VK_X, 0), getKeyStroke(action1));
}
@Test
public void testSetKeyBindingNotAllowed() throws Exception {
selectRowForAction(action1);
triggerActionKey(keyField, 0, KeyEvent.VK_F1);
// F1 is the help key and cannot be used
assertEquals("", keyField.getText());
triggerActionKey(keyField, 0, KeyEvent.VK_HELP);
assertEquals("", keyField.getText());
triggerActionKey(keyField, 0, KeyEvent.VK_SHIFT);
assertEquals("", keyField.getText());
triggerActionKey(keyField, 0, KeyEvent.VK_ENTER);
assertEquals("", keyField.getText());
}
@Test
public void testSetKeyBinding3() throws Exception {
selectRowForAction(action1);
triggerActionKey(keyField, InputEvent.CTRL_DOWN_MASK, KeyEvent.VK_HOME);
assertEquals(
KeyEntryTextField.parseKeyStroke(
KeyStroke.getKeyStroke(KeyEvent.VK_HOME, InputEvent.CTRL_DOWN_MASK)),
keyField.getText());
typeKeyStroke(InputEvent.CTRL_DOWN_MASK, KeyEvent.VK_HOME);
KeyStroke ks = KeyStroke.getKeyStroke(KeyEvent.VK_HOME, InputEvent.CTRL_DOWN_MASK);
assertKeyFieldText(ks);
apply();
assertEquals(KeyStroke.getKeyStroke(KeyEvent.VK_HOME, InputEvent.CTRL_DOWN_MASK),
getKeyStroke(action1));
assertEquals(ks, getKeyStroke(action1));
}
@Test
public void testSetKeyBinding4() throws Exception {
selectRowForAction(action1);
triggerActionKey(keyField, 0, KeyEvent.VK_PAGE_UP);
assertEquals(
KeyEntryTextField.parseKeyStroke(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, 0)),
keyField.getText());
typeKeyStroke(KeyEvent.VK_PAGE_UP);
KeyStroke ks = KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, 0);
assertKeyFieldText(ks);
apply();
assertEquals(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, 0), getKeyStroke(action1));
assertEquals(ks, getKeyStroke(action1));
}
@Test
@ -259,13 +226,11 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
// set the new binding that uses the 'Alt' key
selectRowForAction(action1);
triggerActionKey(keyField, InputEvent.ALT_DOWN_MASK, keyCode);
String keyStrokeString = KeyEntryTextField.parseKeyStroke(
KeyStroke.getKeyStroke(keyCode, InputEvent.ALT_DOWN_MASK));
assertEquals(keyStrokeString, keyField.getText());
typeKeyStroke(InputEvent.ALT_DOWN_MASK, keyCode);
KeyStroke ks = KeyStroke.getKeyStroke(keyCode, InputEvent.ALT_DOWN_MASK);
assertKeyFieldText(ks);
apply();
assertEquals(KeyStroke.getKeyStroke(keyCode, InputEvent.ALT_DOWN_MASK),
getKeyStroke(action1));
assertEquals(ks, getKeyStroke(action1));
// verify the additional binding for 'Alt Graph'
action =
@ -278,8 +243,8 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
selectRowForAction(action1);
triggerActionKey(keyField, 0, KeyEvent.VK_ENTER);
assertEquals("", keyField.getText());
typeKeyStroke(KeyEvent.VK_ENTER);
assertNoKeyStrokeText();
apply();
assertNull(getKeyStroke(action1));
@ -289,8 +254,8 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
public void testClearKeyBinding2() throws Exception {
selectRowForAction(action1);
triggerText(keyField, "\b");
assertEquals("", keyField.getText());
typeBackspace();
assertNoKeyStrokeText();
apply();
assertNull(getKeyStroke(action1));
@ -302,31 +267,36 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
// verify that a list of collisions show up
selectRowForAction(action1);
triggerActionKey(keyField, 0, KeyEvent.VK_OPEN_BRACKET);
typeKeyStroke(KeyEvent.VK_OPEN_BRACKET);
apply();
// set same binding on a different action, which will trigger the collisions list
selectRowForAction(action2);
triggerActionKey(keyField, 0, KeyEvent.VK_OPEN_BRACKET);
typeKeyStroke(KeyEvent.VK_OPEN_BRACKET);
MultiLineLabel label = (MultiLineLabel) findComponentByName(panel, "CollisionLabel");
String msg = label.getLabel();
String[] lines = msg.split("\n");
assertEquals(3, lines.length);
assertTrue(lines[1].contains(action1.getName()));
assertTrue(lines[2].contains(action2.getName()));
boolean success = msg.contains(action1.getName()) && msg.contains(action2.getName());
assertTrue("In-use action message incorrect.\n\tIt should contain these 2 actions:\n\t\t" +
action1.getName() + "\n\t\t" + action2.getName() + ".\nActual message:\n" +
msg + "\n", success);
}
@Test
public void testSetReservedKeybinding() throws Exception {
// try to set a reserved keybinding
KeyStroke reservedKeystroke = KeyStroke.getKeyStroke(KeyEvent.VK_F4, 0);
KeyStroke reservedKeystroke = SystemKeyBindings.UPDATE_KEY_BINDINGS_KEY; // F4
selectRowForAction(action1);
triggerActionKey(keyField, 0, reservedKeystroke.getKeyCode());
typeKeyStroke(reservedKeystroke);
assertEquals("", keyField.getText());
assertNoKeyStrokeText();
assertMessage("F4 in use by System action 'Set KeyBinding'");
apply();
assertEquals(null, getKeyStroke(action1));
@ -336,8 +306,8 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
selectRowForAction(action1);
KeyStroke validKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_X, InputEvent.CTRL_DOWN_MASK);
triggerActionKey(keyField, InputEvent.CTRL_DOWN_MASK, validKeyStroke.getKeyCode());
assertEquals(KeyEntryTextField.parseKeyStroke(validKeyStroke), keyField.getText());
typeKeyStroke(validKeyStroke);
assertKeyFieldText(validKeyStroke);
apply();
assertEquals(validKeyStroke, getKeyStroke(action1));
@ -345,22 +315,172 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
// try again to set a reserved binding
setUpDialog();
selectRowForAction(action1);
assertEquals(validKeyStroke, getKeyStroke(action1));
String originalText = keyField.getText();
triggerActionKey(keyField, 0, reservedKeystroke.getKeyCode());
assertEquals(originalText, keyField.getText());
typeKeyStroke(reservedKeystroke.getKeyCode());
assertNoKeyStrokeText();
assertMessage("F4 in use by System action 'Set KeyBinding'");
apply();
assertEquals(validKeyStroke, getKeyStroke(action1));
}
@Test
public void testSetKeyBindingOnSystemAction() throws Exception {
//
// Test that users can change the keybinding for a System action. The new binding cannot
// be in use by any other action.
//
DockingActionIf goToAction = getAction(tool, "Go To Address/Label"); // arbitrary plugin action
KeyStroke goToKs = goToAction.getKeyBinding();
assertNotNull(goToKs);
DockingActionIf systemAction = getAction("Show Context Menu"); // arbitrary system action
KeyStroke systemKs = systemAction.getKeyBinding();
assertNotNull(systemKs);
selectRowForAction(systemAction);
typeKeyStroke(goToKs);
assertNoKeyStrokeText();
assertMessage("System action cannot be set to in-use key stroke");
apply();
assertEquals(systemKs, getKeyStroke(systemAction)); // unchanged
// clear the in-use binding and then try again
clearKeyBinding(goToKs);
setUpDialog();
selectRowForAction(systemAction);
typeKeyStroke(goToKs);
assertKeyFieldText("G");
apply();
assertEquals(goToKs, getKeyStroke(systemAction));
}
@Test
public void testSetKeybindingUsingSystemDefaultBinding_InUse() throws Exception {
//
// Test that users can change the keybinding for a non-System action to use a pre-defined
// System key stroke only if the binding is not in-use by a System action.
//
// This test will clear the system key binding in the UI by using the backspace key.
// Note: The 'Apply' button must be pressed before the system key stroke can be reused.
//
DockingActionIf systemAction = getAction("Show Context Menu"); // arbitrary system action
KeyStroke systemKs = systemAction.getKeyBinding();
String systemKsText = KeyBindingUtils.parseKeyStroke(systemKs);
assertEquals(SystemKeyBindings.CONTEXT_MENU_KEY1, systemKs);
assertNotNull(systemKs);
DockingActionIf goToAction = getAction(tool, "Go To Address/Label"); // arbitrary plugin action
KeyStroke goToKs = goToAction.getKeyBinding();
assertNotNull(goToKs);
setUpDialog();
selectRowForAction(action1);
typeKeyStroke(systemKs);
assertNoKeyStrokeText();
assertMessage(systemKsText + " in use by System action 'Show Context Menu'");
selectRowForAction(systemAction);
typeBackspace();
apply();
assertEquals(null, getKeyStroke(systemAction));
selectRowForAction(action1);
typeKeyStroke(systemKs);
assertKeyFieldText(systemKsText);
assertNoErrorMessage();
}
//==================================================================================================
// Private Methods
//==================================================================================================
private boolean ignoreAction(DockingActionIf action) {
if (!action.getKeyBindingType().isManaged()) {
return true;
}
return action.getFullName().contains("Table Data");
}
private void assertNoKeyStrokeText() {
assertEquals("", keyField.getText());
}
private void assertKeyFieldText(KeyStroke ks) {
assertKeyFieldText(KeyBindingUtils.parseKeyStroke(ks));
}
private void assertKeyFieldText(String s) {
assertEquals(s, runSwing(() -> keyField.getText()));
}
private void assertNoErrorMessage() {
assertMessage("");
}
private void typeBackspace() {
triggerBackspaceKey(keyField);
waitForSwing();
}
private void typeKeyStroke(KeyStroke ks) {
triggerKey(keyField, ks);
waitForSwing();
}
private void typeKeyStroke(int keyCode) {
typeKeyStroke(0, keyCode);
}
private void typeKeyStroke(int modifiers, int keyCode) {
triggerKey(keyField, modifiers, keyCode, KeyEvent.CHAR_UNDEFINED);
waitForSwing();
}
private void clearKeyBinding(KeyStroke ks) {
ToolActions toolActions = (ToolActions) tool.getToolActions();
Action action = toolActions.getAction(ks);
if (action instanceof MultipleKeyAction multiAction) {
List<DockingActionIf> actions = multiAction.getActions();
for (DockingActionIf dockingAction : actions) {
runSwing(() -> dockingAction.setKeyBindingData(null));
}
}
else if (action instanceof SystemKeyBindingAction systemAction) {
DockingActionIf dockingAction = systemAction.getAction();
runSwing(() -> dockingAction.setKeyBindingData(null));
}
}
private DockingActionIf getAction(String name) {
Set<DockingActionIf> actions = tool.getAllActions();
for (DockingActionIf action : actions) {
if (action.getName().equals(name)) {
return action;
}
}
fail("Unable to find System action '%s'".formatted(name));
return null;
}
private void assertMessage(String text) {
String kbStatusMessage = runSwing(panel::getStatusText);
if (!kbStatusMessage.contains(text)) {
fail("Expected message: " + text + ". Found message: " + kbStatusMessage);
}
}
private void apply() {
runSwing(() -> panel.apply());
waitForSwing();
@ -374,7 +494,7 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
Set<DockingActionIf> list = tool.getAllActions();
for (DockingActionIf action : list) {
KeyStroke ks = action.getKeyBinding();
if (ignoreAction(action) && ks != null &&
if (!ignoreAction(action) && ks != null &&
ks != KeyStroke.getKeyStroke(KeyEvent.VK_Z, 0)) {
return action;
}
@ -390,7 +510,7 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
if (actionName.equals(model.getValueAt(i, 0))) {
if (ks != null) {
String ksStr = (String) model.getValueAt(i, 1);
return ksStr.equals(KeyEntryTextField.parseKeyStroke(ks));
return ksStr.equals(KeyBindingUtils.parseKeyStroke(ks));
}
return true;
}
@ -398,24 +518,22 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
return false;
}
private void selectRowForAction(DockingActionIf action) throws Exception {
private void selectRowForAction(DockingActionIf action) {
String actionName = action.getName();
Msg.debug(this, "Keybinding Action: " + action.getFullName());
for (int i = 0; i < model.getRowCount(); i++) {
if (actionName.equals(model.getValueAt(i, 0))) {
final int idx = i;
Msg.debug(this, "\tselection row for action: " + i);
int idx = i;
runSwing(() -> {
table.setRowSelectionInterval(idx, idx);
Rectangle rect = table.getCellRect(idx, idx, true);
table.scrollRectToVisible(rect);
});
waitForSwing();
return;
}
}
waitForSwing();
fail("Could not find action to select: " + action);
}
private KeyStroke getKeyStroke(DockingActionIf action) {
@ -423,8 +541,15 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
}
private void setUpDialog() throws Exception {
if (panel != null) {
runSwing(() -> {
dialog.setVisible(false);
});
}
runSwing(() -> {
panel = new KeyBindingsPanel(tool, tool.getOptions(DockingToolConstants.KEY_BINDINGS));
panel = new KeyBindingsPanel(tool);
panel.setOptionsPropertyChangeListener(evt -> {
// stub
});
@ -439,6 +564,7 @@ public class KeyBindingsTest extends AbstractGhidraHeadedIntegrationTest {
keyField = (JTextField) getInstanceField("ksField", panel);
statusPane = findComponent(panel, JTextPane.class);
model = table.getModel();
waitForSwing();
}
// find 2 actions that do not have key bindings so that we can add and change the values

27
Ghidra/Features/Base/src/test.slow/java/ghidra/util/bean/opteditor/OptionsDialogTest.java
View file

@ -38,6 +38,7 @@ import docking.action.DockingActionIf;
import docking.actions.KeyBindingUtils;
import docking.options.editor.*;
import docking.tool.ToolConstants;
import docking.tool.util.DockingToolConstants;
import docking.widgets.MultiLineLabel;
import docking.widgets.OptionDialog;
import docking.widgets.filechooser.GhidraFileChooser;
@ -51,6 +52,7 @@ import ghidra.app.plugin.core.console.ConsolePlugin;
import ghidra.app.util.viewer.options.OptionsGui;
import ghidra.app.util.viewer.options.ScreenElement;
import ghidra.framework.main.ConsoleTextPane;
import ghidra.framework.main.FrontEndTool;
import ghidra.framework.options.*;
import ghidra.framework.plugintool.PluginTool;
import ghidra.framework.plugintool.dialog.KeyBindingsPanel;
@ -422,47 +424,48 @@ public class OptionsDialogTest extends AbstractGhidraHeadedIntegrationTest {
String actionName = "Clear Cut";
String pluginName = "DataTypeManagerPlugin";
KeyStroke defaultKeyStroke = getKeyBinding(actionName);
assertOptionsKeyStroke(actionName, pluginName, defaultKeyStroke);
assertOptionsKeyStroke(tool, actionName, pluginName, defaultKeyStroke);
int keyCode = KeyEvent.VK_Q;
int modifiers = InputEvent.CTRL_DOWN_MASK | InputEvent.ALT_DOWN_MASK;
KeyStroke newKeyStroke = setKeyBinding(actionName, modifiers, keyCode, 'Q');
apply();
assertOptionsKeyStroke(actionName, pluginName, newKeyStroke);
assertOptionsKeyStroke(tool, actionName, pluginName, newKeyStroke);
restoreDefaults();
KeyStroke currentBinding = getKeyBinding(actionName);
assertEquals("Key binding not restored after a call to restore defautls", defaultKeyStroke,
currentBinding);
assertOptionsKeyStroke(actionName, pluginName, defaultKeyStroke);
assertOptionsKeyStroke(tool, actionName, pluginName, defaultKeyStroke);
}
@Test
public void testRestoreDefaultsForFrontEndKeybindings() throws Exception {
runSwing(() -> dialog.close());
setUpDialog(env.getFrontEndTool());
FrontEndTool frontEndTool = env.getFrontEndTool();
setUpDialog(frontEndTool);
String actionName = "Archive Project";
String pluginName = "ArchivePlugin";
KeyStroke defaultKeyStroke = getKeyBinding(actionName);
assertOptionsKeyStroke(actionName, pluginName, defaultKeyStroke);
assertOptionsKeyStroke(frontEndTool, actionName, pluginName, defaultKeyStroke);
int keyCode = KeyEvent.VK_Q;
int modifiers = InputEvent.CTRL_DOWN_MASK | InputEvent.ALT_DOWN_MASK;
KeyStroke newKeyStroke = setKeyBinding(actionName, modifiers, keyCode, 'Q');
apply();
assertOptionsKeyStroke(actionName, pluginName, newKeyStroke);
assertOptionsKeyStroke(frontEndTool, actionName, pluginName, newKeyStroke);
restoreDefaults();
KeyStroke currentBinding = getKeyBinding(actionName);
assertEquals("Key binding not restored after a call to restore defautls", defaultKeyStroke,
currentBinding);
assertOptionsKeyStroke(actionName, pluginName, defaultKeyStroke);
assertOptionsKeyStroke(frontEndTool, actionName, pluginName, defaultKeyStroke);
}
@Test
@ -763,12 +766,9 @@ public class OptionsDialogTest extends AbstractGhidraHeadedIntegrationTest {
return KeyBindingUtils.parseKeyStroke(keyBindingColumnValue);
}
private void assertOptionsKeyStroke(String actionName, String pluginName, KeyStroke value)
throws Exception {
OptionsEditor editor = seleNodeWithCustomEditor("Key Bindings");
KeyBindingsPanel panel = (KeyBindingsPanel) getInstanceField("panel", editor);
Options options = (Options) getInstanceField("options", panel);
private void assertOptionsKeyStroke(PluginTool pluginTool, String actionName, String pluginName,
KeyStroke value) throws Exception {
Options options = pluginTool.getOptions(DockingToolConstants.KEY_BINDINGS);
KeyStroke optionsKeyStroke =
options.getKeyStroke(actionName + " (" + pluginName + ")", null);
assertEquals("The options keystroke does not match the value in keybinding options table",
@ -784,6 +784,7 @@ public class OptionsDialogTest extends AbstractGhidraHeadedIntegrationTest {
JTextField textField = (JTextField) getInstanceField("ksField", panel);
triggerKey(textField, modifiers, keyCode, keyChar);
waitForSwing();
KeyStroke expectedKeyStroke = KeyStroke.getKeyStroke(keyCode, modifiers, false);
KeyStroke currentBinding = getKeyBinding(actionName);

4
Ghidra/Framework/Docking/src/main/java/docking/DockingKeyBindingAction.java
View file

@ -30,7 +30,7 @@ import docking.actions.KeyBindingUtils;
*/
public abstract class DockingKeyBindingAction extends AbstractAction {
private DockingActionIf dockingAction;
protected DockingActionIf dockingAction;
protected final KeyStroke keyStroke;
protected final Tool tool;
@ -54,7 +54,7 @@ public abstract class DockingKeyBindingAction extends AbstractAction {
public abstract KeyBindingPrecedence getKeyBindingPrecedence();
public boolean isReservedKeybindingPrecedence() {
public boolean isSystemKeybindingPrecedence() {
return false;
}

24
Ghidra/Framework/Docking/src/main/java/docking/KeyBindingOverrideKeyEventDispatcher.java
View file

@ -127,8 +127,8 @@ public class KeyBindingOverrideKeyEventDispatcher implements KeyEventDispatcher
return false; // let the normal event flow continue
}
// *Special*, reserved key bindings--these can always be processed
if (processReservedKeyActionsPrecedence(action, event)) {
// *Special*, System key bindings--these can always be processed and are a higher priority
if (processSystemActionPrecedence(action, event)) {
return true;
}
@ -245,6 +245,16 @@ public class KeyBindingOverrideKeyEventDispatcher implements KeyEventDispatcher
return true; // default case; allow it through
}
private boolean isSettingKeyBindings(KeyEvent event) {
Component destination = event.getComponent();
if (destination == null) {
Component focusOwner = focusProvider.getFocusOwner();
destination = focusOwner;
}
return destination instanceof KeyEntryTextField;
}
private boolean willBeHandledByTextComponent(KeyEvent event) {
Component destination = event.getComponent();
@ -301,10 +311,16 @@ public class KeyBindingOverrideKeyEventDispatcher implements KeyEventDispatcher
throw new AssertException("New precedence added to KeyBindingPrecedence?");
}
private boolean processReservedKeyActionsPrecedence(DockingKeyBindingAction action,
private boolean processSystemActionPrecedence(DockingKeyBindingAction action,
KeyEvent event) {
if (!action.isReservedKeybindingPrecedence()) {
if (isSettingKeyBindings(event)) {
// This means the user is setting keybindings. Do not process System actions during
// this operation so that the user can assign those keybindings.
return false;
}
if (!action.isSystemKeybindingPrecedence()) {
return false;
}

12
Ghidra/Framework/Docking/src/main/java/docking/KeyBindingPrecedence.java
View file

@ -23,16 +23,16 @@ import java.awt.event.KeyEvent;
* key events see {@link KeyBindingOverrideKeyEventDispatcher#dispatchKeyEvent(KeyEvent)}.
*/
public enum KeyBindingPrecedence {
/** Actions at this level will be processed before all others, including Java components'. */
ReservedActionsLevel,
/** Actions at this level will be processed before all others, including Java components'. */
SystemActionsLevel,
/** Actions with this precedence will be processed before key listener on Java components. */
KeyListenerLevel,
/** Actions with this precedence will be processed before actions on Java components. */
ActionMapLevel,
/** This level of precedence is the default level of precedence and gets processed after
* Java components' key listeners and actions. */
DefaultLevel

22
Ghidra/Framework/Docking/src/main/java/docking/KeyEntryTextField.java
View file

@ -57,18 +57,7 @@ public class KeyEntryTextField extends JTextField {
*/
public void setKeyStroke(KeyStroke ks) {
processEntry(ks);
setText(parseKeyStroke(ks));
}
/**
* Converts the toString() form of the keyStroke, e.g., Ctrl-M is returned as
* "keyCode CtrlM-P" and we want it to look like: "Ctrl-M"
*
* @param ks the keystroke to parse
* @return the parse string for the keystroke
*/
public static String parseKeyStroke(KeyStroke ks) {
return KeyBindingUtils.parseKeyStroke(ks);
setText(KeyBindingUtils.parseKeyStroke(ks));
}
public void clearField() {
@ -114,23 +103,14 @@ public class KeyEntryTextField extends JTextField {
@Override
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode();
if (isHelpKey(keyCode)) {
return;
}
KeyStroke keyStroke = null;
if (!isClearKey(keyCode) && !isModifiersOnly(e)) {
keyStroke = KeyStroke.getKeyStroke(keyCode, e.getModifiersEx());
}
processEntry(keyStroke);
e.consume();
}
private boolean isHelpKey(int keyCode) {
return keyCode == KeyEvent.VK_F1 || keyCode == KeyEvent.VK_HELP;
}
private boolean isClearKey(int keyCode) {
return keyCode == KeyEvent.VK_BACK_SPACE || keyCode == KeyEvent.VK_ENTER;
}

156
Ghidra/Framework/Docking/src/main/java/docking/action/AbstractHelpAction.java Normal file
View file

@ -0,0 +1,156 @@
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package docking.action;
import java.awt.*;
import javax.swing.KeyStroke;
import docking.*;
import ghidra.util.HelpLocation;
import ghidra.util.SystemUtilities;
import help.HelpService;
/**
* A base system action used for actions that show help information.
*/
public abstract class AbstractHelpAction extends DockingAction {
public AbstractHelpAction(String name, KeyStroke keyStroke, boolean isPrimary) {
super(name, DockingWindowManager.DOCKING_WINDOWS_OWNER, isPrimary);
// Only the primary action will appear in the tool' key binding settings UI. The primary
// action can be managed by the users. The secondary action is not managed at this time.
if (isPrimary) {
setKeyBindingData(new KeyBindingData(keyStroke));
}
else {
createSystemKeyBinding(keyStroke);
}
setEnabled(true);
// Help actions don't have help
DockingWindowManager.getHelpService().excludeFromHelp(this);
}
protected abstract boolean isInfo();
@Override
public boolean isEnabledForContext(ActionContext context) {
return true;
}
@Override
public void actionPerformed(ActionContext context) {
DockingActionIf mouseOverAction = DockingWindowManager.getMouseOverAction();
if (mouseOverAction != null) {
showHelp(mouseOverAction);
return;
}
Object mouseOverObject = DockingWindowManager.getMouseOverObject();
Object helpObject = getFirstAvailableObjectThatHasHelp(mouseOverObject);
if (helpObject != null) {
showHelp(helpObject);
return;
}
// some components are special in that they have help registered just for them
Object eventSource = context.getSourceObject();
helpObject = getFirstAvailableObjectThatHasHelp(eventSource);
if (helpObject != null) {
showHelp(helpObject);
return;
}
// dialogs help is handled differently than core Ghidra components
DialogComponentProvider dialogProvider = findDialogComponentProvider();
if (dialogProvider != null) {
showHelp(dialogProvider.getComponent());
return;
}
// handle our 'normal' CompentProviders...just use the focused provider
DockingWindowManager windowManager = DockingWindowManager.getActiveInstance();
ComponentPlaceholder info = windowManager.getFocusedComponent();
if (info != null) {
ComponentProvider componentProvider = info.getProvider();
showHelp(componentProvider);
return;
}
}
private void showHelp(Object helpObject) {
SystemUtilities.runSwingLater(() -> {
DockingWindowManager windowManager = DockingWindowManager.getActiveInstance();
Component component = windowManager.getActiveComponent();
DockingWindowManager.getHelpService().showHelp(helpObject, isInfo(), component);
});
}
private DialogComponentProvider findDialogComponentProvider() {
KeyboardFocusManager keyboardFocusManager =
KeyboardFocusManager.getCurrentKeyboardFocusManager();
Window activeWindow = keyboardFocusManager.getActiveWindow();
if (activeWindow instanceof DockingDialog) {
DockingDialog dockingDialog = (DockingDialog) activeWindow;
return dockingDialog.getDialogComponent();
}
return null;
}
private Object getFirstAvailableObjectThatHasHelp(Object startingHelpObject) {
if (startingHelpObject == null) {
return null;
}
// First see if help exists for the given component directly...
HelpService helpService = DockingWindowManager.getHelpService();
HelpLocation helpLocation = helpService.getHelpLocation(startingHelpObject);
if (helpLocation != null) {
return startingHelpObject;
}
// Second, with no help registered for the starting component, start looking for a suitable
// help proxy.
//
// For Components, we can walk their containment hierarchy to find a potential help object
if (!(startingHelpObject instanceof Component)) {
// not a Component; don't know how to find a better help object
return null;
}
return getFirstAvailableComponentThatHasHelp((Component) startingHelpObject);
}
private Component getFirstAvailableComponentThatHasHelp(Component component) {
HelpService helpService = DockingWindowManager.getHelpService();
HelpLocation helpLocation = helpService.getHelpLocation(component);
if (helpLocation != null) {
return component;
}
Container parent = component.getParent();
if (parent == null) {
// nothing else to check
return null;
}
return getFirstAvailableComponentThatHasHelp(parent);
}
}

10
Ghidra/Framework/Docking/src/main/java/docking/action/ComponentThemeInspectorAction.java
View file

@ -29,14 +29,14 @@ import org.apache.commons.lang3.StringUtils;
import docking.ActionContext;
import docking.DockingWindowManager;
import generic.theme.GColor;
import generic.util.action.ReservedKeyBindings;
import generic.util.action.SystemKeyBindings;
import ghidra.util.Msg;
public class ComponentThemeInspectorAction extends DockingAction {
public ComponentThemeInspectorAction() {
super("Component Theme Inspector", DockingWindowManager.DOCKING_WINDOWS_OWNER, false);
createReservedKeyBinding(ReservedKeyBindings.COMPONENT_THEME_INFO_KEY);
super("Component Theme Inspector", DockingWindowManager.DOCKING_WINDOWS_OWNER, true);
createSystemKeyBinding(SystemKeyBindings.COMPONENT_THEME_INFO_KEY);
// System action; no help needed
DockingWindowManager.getHelpService().excludeFromHelp(this);
@ -99,9 +99,6 @@ public class ComponentThemeInspectorAction extends DockingAction {
next = new Entry(component);
}
if (entry != null) {
entry.parent = next;
}
entry = next;
tree.add(entry);
@ -199,7 +196,6 @@ public class ComponentThemeInspectorAction extends DockingAction {
private class Entry {
private Entry parent;
protected Component component;
protected Point mouseLocation;

8
Ghidra/Framework/Docking/src/main/java/docking/action/DockingAction.java
View file

@ -372,8 +372,8 @@ public abstract class DockingAction implements DockingActionIf {
precedence = kbData.getKeyBindingPrecedence();
}
if (precedence == KeyBindingPrecedence.ReservedActionsLevel) {
return true; // reserved actions are special
if (precedence == KeyBindingPrecedence.SystemActionsLevel) {
return true; // system actions are special
}
// log a trace message instead of throwing an exception, as to not break any legacy code
@ -453,8 +453,8 @@ public abstract class DockingAction implements DockingActionIf {
* other actions are prevented from using the same KeyStroke as a reserved keybinding.
* @param keyStroke the keystroke to be used for the keybinding
*/
void createReservedKeyBinding(KeyStroke keyStroke) {
KeyBindingData data = KeyBindingData.createReservedKeyBindingData(keyStroke);
void createSystemKeyBinding(KeyStroke keyStroke) {
KeyBindingData data = KeyBindingData.createSystemKeyBindingData(keyStroke);
setKeyBindingData(data);
}

2
Ghidra/Framework/Docking/src/main/java/docking/action/GlobalFocusTraversalAction.java
View file

@ -53,7 +53,7 @@ public class GlobalFocusTraversalAction extends DockingAction {
DockingWindowManager.DOCKING_WINDOWS_OWNER);
this.forward = forward;
createReservedKeyBinding(keybinding);
createSystemKeyBinding(keybinding);
setEnabled(isGlobalFocusTraversalEnabled());
}

125
Ghidra/Framework/Docking/src/main/java/docking/action/HelpAction.java
View file

@ -15,131 +15,16 @@
*/
package docking.action;
import java.awt.*;
import javax.swing.KeyStroke;
import docking.*;
import ghidra.util.HelpLocation;
import ghidra.util.SystemUtilities;
import help.HelpService;
public class HelpAction extends AbstractHelpAction {
public class HelpAction extends DockingAction {
private boolean infoOnly;
public HelpAction(boolean infoOnly, KeyStroke keybinding) {
super(infoOnly ? "HelpInfo" : "Help", DockingWindowManager.DOCKING_WINDOWS_OWNER, false);
createReservedKeyBinding(keybinding);
setEnabled(true);
this.infoOnly = infoOnly;
// Help actions don't have help
DockingWindowManager.getHelpService().excludeFromHelp(this);
public HelpAction(KeyStroke keyStroke, boolean isPrimary) {
super("Context Help", keyStroke, isPrimary);
}
@Override
public boolean isEnabledForContext(ActionContext context) {
return true;
}
@Override
public void actionPerformed(ActionContext context) {
DockingActionIf mouseOverAction = DockingWindowManager.getMouseOverAction();
if (mouseOverAction != null) {
showHelp(mouseOverAction);
return;
}
Object mouseOverObject = DockingWindowManager.getMouseOverObject();
Object helpObject = getFirstAvailableObjectThatHasHelp(mouseOverObject);
if (helpObject != null) {
showHelp(helpObject);
return;
}
// some components are special in that they have help registered just for them
Object eventSource = context.getSourceObject();
helpObject = getFirstAvailableObjectThatHasHelp(eventSource);
if (helpObject != null) {
showHelp(helpObject);
return;
}
// dialogs help is handled differently than core Ghidra components
DialogComponentProvider dialogProvider = findDialogComponentProvider();
if (dialogProvider != null) {
showHelp(dialogProvider.getComponent());
return;
}
// handle our 'normal' CompentProviders...just use the focused provider
DockingWindowManager windowManager = DockingWindowManager.getActiveInstance();
ComponentPlaceholder info = windowManager.getFocusedComponent();
if (info != null) {
ComponentProvider componentProvider = info.getProvider();
showHelp(componentProvider);
return;
}
}
private void showHelp(final Object helpObject) {
SystemUtilities.runSwingLater(() -> {
DockingWindowManager windowManager = DockingWindowManager.getActiveInstance();
Component component = windowManager.getActiveComponent();
DockingWindowManager.getHelpService().showHelp(helpObject, infoOnly, component);
});
}
private DialogComponentProvider findDialogComponentProvider() {
KeyboardFocusManager keyboardFocusManager =
KeyboardFocusManager.getCurrentKeyboardFocusManager();
Window activeWindow = keyboardFocusManager.getActiveWindow();
if (activeWindow instanceof DockingDialog) {
DockingDialog dockingDialog = (DockingDialog) activeWindow;
return dockingDialog.getDialogComponent();
}
return null;
}
private Object getFirstAvailableObjectThatHasHelp(Object startingHelpObject) {
if (startingHelpObject == null) {
return null;
}
// First see if help exists for the given component directly...
HelpService helpService = DockingWindowManager.getHelpService();
HelpLocation helpLocation = helpService.getHelpLocation(startingHelpObject);
if (helpLocation != null) {
return startingHelpObject;
}
// Second, with no help registered for the starting component, start looking for a suitable
// help proxy.
//
// For Components, we can walk their containment hierarchy to find a potential help object
if (!(startingHelpObject instanceof Component)) {
// not a Component; don't know how to find a better help object
return null;
}
return getFirstAvailableComponentThatHasHelp((Component) startingHelpObject);
}
private Component getFirstAvailableComponentThatHasHelp(Component component) {
HelpService helpService = DockingWindowManager.getHelpService();
HelpLocation helpLocation = helpService.getHelpLocation(component);
if (helpLocation != null) {
return component;
}
Container parent = component.getParent();
if (parent == null) {
// nothing else to check
return null;
}
return getFirstAvailableComponentThatHasHelp(parent);
public boolean isInfo() {
return false;
}
}

15
Ghidra/Framework/Docking/src/main/java/docking/action/ReservedKeyBindingAction.java → Ghidra/Framework/Docking/src/main/java/docking/action/HelpInfoAction.java
View file

@ -17,21 +17,14 @@ package docking.action;
import javax.swing.KeyStroke;
import docking.*;
public class HelpInfoAction extends AbstractHelpAction {
class ReservedKeyBindingAction extends DockingKeyBindingAction {
ReservedKeyBindingAction(Tool tool, DockingActionIf action, KeyStroke keyStroke) {
super(tool, action, keyStroke);
public HelpInfoAction(KeyStroke keybinding) {
super("Help Info", keybinding, true);
}
@Override
public boolean isReservedKeybindingPrecedence() {
public boolean isInfo() {
return true;
}
@Override
public KeyBindingPrecedence getKeyBindingPrecedence() {
return KeyBindingPrecedence.ReservedActionsLevel;
}
}

14
Ghidra/Framework/Docking/src/main/java/docking/action/KeyBindingData.java
View file

@ -63,9 +63,9 @@ public class KeyBindingData {
}
public KeyBindingData(KeyStroke keyStroke, KeyBindingPrecedence precedence) {
if (precedence == KeyBindingPrecedence.ReservedActionsLevel) {
if (precedence == KeyBindingPrecedence.SystemActionsLevel) {
throw new IllegalArgumentException(
"Can't set precedence to Reserved KeyBindingPrecedence");
"Can't set precedence to System KeyBindingPrecedence");
}
this.keyStroke = keyStroke;
this.keyBindingPrecedence = precedence;
@ -93,9 +93,9 @@ public class KeyBindingData {
keyBindingPrecedence + "]";
}
static KeyBindingData createReservedKeyBindingData(KeyStroke keyStroke) {
static KeyBindingData createSystemKeyBindingData(KeyStroke keyStroke) {
KeyBindingData keyBindingData = new KeyBindingData(keyStroke);
keyBindingData.keyBindingPrecedence = KeyBindingPrecedence.ReservedActionsLevel;
keyBindingData.keyBindingPrecedence = KeyBindingPrecedence.SystemActionsLevel;
return keyBindingData;
}
@ -105,7 +105,7 @@ public class KeyBindingData {
* @param newKeyBindingData the data to validate
* @return the potentially changed data
*/
public static KeyBindingData validateKeyBindingData(KeyBindingData newKeyBindingData) {
static KeyBindingData validateKeyBindingData(KeyBindingData newKeyBindingData) {
if (newKeyBindingData == null) {
return null;
}
@ -117,8 +117,8 @@ public class KeyBindingData {
}
KeyBindingPrecedence precedence = newKeyBindingData.getKeyBindingPrecedence();
if (precedence == KeyBindingPrecedence.ReservedActionsLevel) {
return createReservedKeyBindingData(KeyBindingUtils.validateKeyStroke(keyBinding));
if (precedence == KeyBindingPrecedence.SystemActionsLevel) {
return createSystemKeyBindingData(KeyBindingUtils.validateKeyStroke(keyBinding));
}
return new KeyBindingData(KeyBindingUtils.validateKeyStroke(keyBinding), precedence);
}

141
Ghidra/Framework/Docking/src/main/java/docking/action/KeyBindingsManager.java
View file

@ -24,7 +24,8 @@ import javax.swing.Action;
import javax.swing.KeyStroke;
import docking.*;
import generic.util.action.ReservedKeyBindings;
import docking.actions.KeyBindingUtils;
import ghidra.util.Msg;
import ghidra.util.exception.AssertException;
/**
@ -36,14 +37,14 @@ import ghidra.util.exception.AssertException;
public class KeyBindingsManager implements PropertyChangeListener {
// this map exists to update the MultiKeyBindingAction when the key binding changes
private Map<DockingActionIf, ComponentProvider> actionToProviderMap;
private Map<KeyStroke, DockingKeyBindingAction> dockingKeyMap;
private Map<DockingActionIf, ComponentProvider> actionToProviderMap = new HashMap<>();
private Map<KeyStroke, DockingKeyBindingAction> dockingKeyMap = new HashMap<>();
private Map<DockingActionIf, SystemKeyBindingAction> dockingActionToSystemActionMap =
new HashMap<>();
private Tool tool;
public KeyBindingsManager(Tool tool) {
this.tool = tool;
dockingKeyMap = new HashMap<>();
actionToProviderMap = new HashMap<>();
}
public void addAction(ComponentProvider optionalProvider, DockingActionIf action) {
@ -59,14 +60,17 @@ public class KeyBindingsManager implements PropertyChangeListener {
}
}
public void addReservedAction(DockingActionIf action) {
KeyStroke keyBinding = action.getKeyBinding();
Objects.requireNonNull(keyBinding);
addReservedKeyBinding(action, keyBinding);
}
public void addSystemAction(DockingActionIf action) {
KeyStroke keyStroke = action.getKeyBinding();
Objects.requireNonNull(keyStroke);
DockingKeyBindingAction existingAction = dockingKeyMap.get(keyStroke);
if (existingAction != null) {
throw new AssertException("Attempting to add more than one reserved " +
"action to a given keystroke: " + keyStroke);
}
public void addReservedAction(DockingActionIf action, KeyStroke ks) {
addReservedKeyBinding(action, ks);
addSystemKeyBinding(action, keyStroke);
action.addPropertyChangeListener(this);
}
public void removeAction(DockingActionIf action) {
@ -78,17 +82,54 @@ public class KeyBindingsManager implements PropertyChangeListener {
private void addKeyBinding(ComponentProvider provider, DockingActionIf action,
KeyStroke keyStroke) {
if (ReservedKeyBindings.isReservedKeystroke(keyStroke)) {
throw new AssertException("Cannot assign action to a reserved keystroke. " +
"Action: " + action.getName() + " - Keystroke: " + keyStroke);
String errorMessage = validateActionKeyBinding(action, keyStroke);
if (errorMessage != null) {
// Getting here should not be possible from the UI, but may happen if a developer sets
// an incorrect keybinding
Msg.error(this, errorMessage);
return;
}
// map standard keybinding to action
// map standard keystroke to action
doAddKeyBinding(provider, action, keyStroke);
// map workaround keystroke to action
fixupAltGraphKeyStrokeMapping(provider, action, keyStroke);
}
public String validateActionKeyBinding(DockingActionIf dockingAction, KeyStroke ks) {
if (ks == null) {
return null; // clearing the key stroke
}
//
// 1) Handle case with given key stroke already in use by a system action
//
Action existingAction = dockingKeyMap.get(ks);
if (existingAction instanceof SystemKeyBindingAction systemAction) {
DockingActionIf systemDockingAction = systemAction.getAction();
if (dockingAction == systemDockingAction) {
return null; // same key stroke; not sure if this can happen
}
String ksString = KeyBindingUtils.parseKeyStroke(ks);
return ksString + " in use by System action '" + systemDockingAction.getName() + "'";
}
//
// 2) Handle the case where a system action key stroke is being set to something that is
// already in-use by some other action
//
SystemKeyBindingAction systemAction = dockingActionToSystemActionMap.get(dockingAction);
if (systemAction != null && existingAction != null) {
return "System action cannot be set to in-use key stroke";
}
return null;
}
private void fixupAltGraphKeyStrokeMapping(ComponentProvider provider, DockingActionIf action,
KeyStroke keyStroke) {
@ -116,55 +157,64 @@ public class KeyBindingsManager implements PropertyChangeListener {
KeyStroke mappingKeyStroke, KeyStroke actionKeyStroke) {
DockingKeyBindingAction existingAction = dockingKeyMap.get(mappingKeyStroke);
if (existingAction == null) {
dockingKeyMap.put(mappingKeyStroke,
new MultipleKeyAction(tool, provider, action, actionKeyStroke));
if (existingAction instanceof MultipleKeyAction) {
MultipleKeyAction multipleKeyction = (MultipleKeyAction) existingAction;
multipleKeyction.addAction(provider, action);
return;
}
if (!(existingAction instanceof MultipleKeyAction)) {
return; // reserved binding; nothing to do
if (existingAction instanceof SystemKeyBindingAction) {
// This should not happen due to protections in the UI
Msg.error(this, "Attempted to use the same keybinding for an existing System action: " +
existingAction + ". Keystroke: " + mappingKeyStroke);
return;
}
MultipleKeyAction multipleKeyction = (MultipleKeyAction) existingAction;
multipleKeyction.addAction(provider, action);
SystemKeyBindingAction systemAction = dockingActionToSystemActionMap.get(action);
if (systemAction != null) {
// the user has updated the binding for a System action; re-install it
registerSystemKeyBinding(action, mappingKeyStroke);
return;
}
// assume existingAction == null
dockingKeyMap.put(mappingKeyStroke,
new MultipleKeyAction(tool, provider, action, actionKeyStroke));
}
private void addReservedKeyBinding(DockingActionIf action, KeyStroke keyStroke) {
DockingKeyBindingAction existingAction = dockingKeyMap.get(keyStroke);
if (existingAction != null) {
throw new AssertException("Attempting to add more than one reserved " +
"action to a given keystroke: " + keyStroke);
}
KeyBindingData binding = KeyBindingData.createReservedKeyBindingData(keyStroke);
private void addSystemKeyBinding(DockingActionIf action, KeyStroke keyStroke) {
KeyBindingData binding = KeyBindingData.createSystemKeyBindingData(keyStroke);
action.setKeyBindingData(binding);
dockingKeyMap.put(keyStroke, new ReservedKeyBindingAction(tool, action, keyStroke));
registerSystemKeyBinding(action, keyStroke);
}
private void registerSystemKeyBinding(DockingActionIf action, KeyStroke keyStroke) {
SystemKeyBindingAction systemAction = new SystemKeyBindingAction(tool, action, keyStroke);
dockingKeyMap.put(keyStroke, systemAction);
dockingActionToSystemActionMap.put(action, systemAction);
}
/**
* Remove the keystroke binding from the root pane's input map
* using keystroke specified instead of that specified by the action
*/
private void removeKeyBinding(KeyStroke keyStroke, DockingActionIf action) {
if (keyStroke == null) {
return;
}
if (ReservedKeyBindings.isReservedKeystroke(keyStroke)) {
return;
}
DockingKeyBindingAction existingAction = dockingKeyMap.get(keyStroke);
if (existingAction == null) {
return;
}
MultipleKeyAction mkAction = (MultipleKeyAction) existingAction;
mkAction.removeAction(action);
if (mkAction.isEmpty()) {
if (existingAction instanceof SystemKeyBindingAction) {
dockingKeyMap.remove(keyStroke);
}
else if (existingAction instanceof MultipleKeyAction) {
MultipleKeyAction mkAction = (MultipleKeyAction) existingAction;
mkAction.removeAction(action);
if (mkAction.isEmpty()) {
dockingKeyMap.remove(keyStroke);
}
}
}
@Override
@ -196,8 +246,13 @@ public class KeyBindingsManager implements PropertyChangeListener {
return dockingKeyMap.get(keyStroke);
}
public Set<DockingActionIf> getSystemActions() {
return new HashSet<>(dockingActionToSystemActionMap.keySet());
}
public void dispose() {
dockingKeyMap.clear();
actionToProviderMap.clear();
dockingActionToSystemActionMap.clear();
}
}

8
Ghidra/Framework/Docking/src/main/java/docking/action/MultipleKeyAction.java
View file

@ -142,8 +142,8 @@ public class MultipleKeyAction extends DockingKeyBindingAction {
}
private boolean ignoreActionWhileMenuShowing() {
if (getKeyBindingPrecedence() == KeyBindingPrecedence.ReservedActionsLevel) {
return false; // allow reserved bindings through "no matter what!"
if (getKeyBindingPrecedence() == KeyBindingPrecedence.SystemActionsLevel) {
return false; // allow system bindings through "no matter what!"
}
MenuSelectionManager menuManager = MenuSelectionManager.defaultManager();
@ -238,8 +238,8 @@ public class MultipleKeyAction extends DockingKeyBindingAction {
}
@Override
public boolean isReservedKeybindingPrecedence() {
return false; // MultipleKeyActions can never be reserved
public boolean isSystemKeybindingPrecedence() {
return false; // MultipleKeyActions can never be 'system'
}
@Override

2
Ghidra/Framework/Docking/src/main/java/docking/action/NextPreviousWindowAction.java
View file

@ -35,7 +35,7 @@ public class NextPreviousWindowAction extends DockingAction {
DockingWindowManager.DOCKING_WINDOWS_OWNER);
this.forward = forward;
createReservedKeyBinding(keybinding);
createSystemKeyBinding(keybinding);
setEnabled(true);
}

15
Ghidra/Framework/Docking/src/main/java/docking/action/ShowContextMenuAction.java
View file

@ -29,9 +29,18 @@ import ghidra.util.Swing;
*/
public class ShowContextMenuAction extends DockingAction {
public ShowContextMenuAction(KeyStroke keyStroke) {
super("Show Context Menu", DockingWindowManager.DOCKING_WINDOWS_OWNER);
setKeyBindingData(new KeyBindingData(keyStroke));
public ShowContextMenuAction(KeyStroke keyStroke, boolean isPrimary) {
super(isPrimary ? "Show Context Menu" : "Show Context Menu Alternate",
DockingWindowManager.DOCKING_WINDOWS_OWNER, isPrimary);
// Only the primary action will appear in the tool' key binding settings UI. The primary
// action can be managed by the users. The secondary action is not managed at this time.
if (isPrimary) {
setKeyBindingData(new KeyBindingData(keyStroke));
}
else {
createSystemKeyBinding(keyStroke);
}
}
@Override

6
Ghidra/Framework/Docking/src/main/java/docking/action/ShowFocusCycleAction.java
View file

@ -24,14 +24,14 @@ import org.apache.logging.log4j.Logger;
import docking.ActionContext;
import docking.DockingWindowManager;
import generic.util.action.ReservedKeyBindings;
import generic.util.action.SystemKeyBindings;
public class ShowFocusCycleAction extends DockingAction {
static final Logger log = LogManager.getLogger(ShowFocusCycleAction.class);
public ShowFocusCycleAction() {
super("Show Focus Cycle", DockingWindowManager.DOCKING_WINDOWS_OWNER, false);
createReservedKeyBinding(ReservedKeyBindings.FOCUS_CYCLE_INFO_KEY);
super("Show Focus Cycle", DockingWindowManager.DOCKING_WINDOWS_OWNER);
createSystemKeyBinding(SystemKeyBindings.FOCUS_CYCLE_INFO_KEY);
setEnabled(true);
// System action; no help needed

6
Ghidra/Framework/Docking/src/main/java/docking/action/ShowFocusInfoAction.java
View file

@ -25,14 +25,14 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import docking.*;
import generic.util.action.ReservedKeyBindings;
import generic.util.action.SystemKeyBindings;
public class ShowFocusInfoAction extends DockingAction {
static final Logger log = LogManager.getLogger(ShowFocusInfoAction.class);
public ShowFocusInfoAction() {
super("Show Focus Info", DockingWindowManager.DOCKING_WINDOWS_OWNER, false);
createReservedKeyBinding(ReservedKeyBindings.FOCUS_INFO_KEY);
super("Show Focus Info", DockingWindowManager.DOCKING_WINDOWS_OWNER);
createSystemKeyBinding(SystemKeyBindings.FOCUS_INFO_KEY);
setEnabled(true);
// System action; no help needed

45
Ghidra/Framework/Docking/src/main/java/docking/action/SystemKeyBindingAction.java Normal file
View file

@ -0,0 +1,45 @@
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package docking.action;
import javax.swing.KeyStroke;
import docking.*;
/**
* An {@link DockingKeyBindingAction} to signal that the given {@link DockingAction} gets priority
* over all other non-system actions in the system.
*/
public class SystemKeyBindingAction extends DockingKeyBindingAction {
SystemKeyBindingAction(Tool tool, DockingActionIf action, KeyStroke keyStroke) {
super(tool, action, keyStroke);
}
public DockingActionIf getAction() {
return dockingAction;
}
@Override
public boolean isSystemKeybindingPrecedence() {
return true;
}
@Override
public KeyBindingPrecedence getKeyBindingPrecedence() {
return KeyBindingPrecedence.SystemActionsLevel;
}
}

3
Ghidra/Framework/Docking/src/main/java/docking/actions/DockingToolActions.java
View file

@ -87,7 +87,7 @@ public interface DockingToolActions {
public Set<DockingActionIf> getActions(String owner);
/**
* Returns all actions known to the tool
* Returns all actions known to the tool.
* @return the actions
*/
public Set<DockingActionIf> getAllActions();
@ -103,4 +103,5 @@ public interface DockingToolActions {
* @param placeholder the placeholder containing information related to the action it represents
*/
public void registerSharedActionPlaceholder(SharedDockingActionPlaceholder placeholder);
}

262
Ghidra/Framework/Docking/src/main/java/docking/actions/KeyBindings.java Normal file
View file

@ -0,0 +1,262 @@
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package docking.actions;
import java.util.*;
import java.util.Map.Entry;
import javax.swing.KeyStroke;
import docking.Tool;
import docking.action.DockingActionIf;
import docking.action.KeyBindingData;
import docking.tool.util.DockingToolConstants;
import ghidra.framework.options.ToolOptions;
import util.CollectionUtils;
/**
* An object that maps actions to key strokes.
* <p>
* This class knows how to load all system actions and how to load any key bindings for those
* actions from the tool's options. Clients can make changes to the state of this class that can
* then be applied to the system by calling {@link #applyChanges()}.
*/
public class KeyBindings {
private Tool tool;
private Map<String, List<DockingActionIf>> actionsByFullName;
private Map<String, List<String>> actionNamesByKeyStroke = new HashMap<>();
private Map<String, KeyStroke> keyStrokesByFullName = new HashMap<>();
private List<DockingActionIf> uniqueActions = new ArrayList<>();
// to know what has been changed
private Map<String, KeyStroke> originalKeyStrokesByFullName = new HashMap<>();
private String longestActionName = "";
private ToolOptions options;
public KeyBindings(Tool tool) {
this.tool = tool;
options = tool.getOptions(DockingToolConstants.KEY_BINDINGS);
init();
}
public List<DockingActionIf> getUniqueActions() {
return Collections.unmodifiableList(uniqueActions);
}
public Map<String, KeyStroke> getKeyStrokesByFullActionName() {
return Collections.unmodifiableMap(keyStrokesByFullName);
}
public boolean containsAction(String fullName) {
return actionsByFullName.containsKey(fullName);
}
public KeyStroke getKeyStroke(String fullName) {
return keyStrokesByFullName.get(fullName);
}
public String getActionsForKeyStrokeText(String keyStrokeText) {
StringBuffer sb = new StringBuffer();
List<String> names = actionNamesByKeyStroke.get(keyStrokeText);
if (CollectionUtils.isBlank(names)) {
return sb.toString();
}
names.sort((n1, n2) -> {
return n1.compareToIgnoreCase(n2);
});
sb.append("Actions mapped to key " + keyStrokeText + ":\n");
for (int i = 0; i < names.size(); i++) {
sb.append(" ");
String name = names.get(i);
List<DockingActionIf> actions = actionsByFullName.get(name);
DockingActionIf action = actions.get(0);
sb.append(action.getName());
sb.append(" (").append(action.getOwnerDescription()).append(')');
if (i < names.size() - 1) {
sb.append("\n");
}
}
return sb.toString();
}
public String getLongestActionName() {
return longestActionName;
}
public boolean setActionKeyStroke(String actionName, KeyStroke keyStroke) {
String ksName = KeyBindingUtils.parseKeyStroke(keyStroke);
// remove old keystroke for action name
KeyStroke oldKs = keyStrokesByFullName.get(actionName);
if (oldKs != null) {
String oldName = KeyBindingUtils.parseKeyStroke(oldKs);
if (oldName.equals(ksName)) {
return false;
}
removeFromKeyMap(oldKs, actionName);
}
addActionKeyStroke(keyStroke, actionName);
keyStrokesByFullName.put(actionName, keyStroke);
return true;
}
public boolean removeKeyStroke(String actionName) {
if (keyStrokesByFullName.containsKey(actionName)) {
KeyStroke stroke = keyStrokesByFullName.get(actionName);
if (stroke == null) {
// nothing to remove; nothing has changed
return false;
}
removeFromKeyMap(stroke, actionName);
keyStrokesByFullName.put(actionName, null);
return true;
}
return false;
}
/**
* Restores the tool options key bindings to the default values originally loaded when the
* system started.
*/
public void restoreOptions() {
Set<Entry<String, List<DockingActionIf>>> entries = actionsByFullName.entrySet();
for (Entry<String, List<DockingActionIf>> entry : entries) {
List<DockingActionIf> actions = entry.getValue();
// pick one action, they are all conceptually the same
DockingActionIf action = actions.get(0);
String actionName = entry.getKey();
KeyStroke currentKeyStroke = keyStrokesByFullName.get(actionName);
KeyBindingData defaultBinding = action.getDefaultKeyBindingData();
KeyStroke newKeyStroke =
(defaultBinding == null) ? null : defaultBinding.getKeyBinding();
updateOptions(actionName, currentKeyStroke, newKeyStroke);
}
}
/**
* Cancels any pending changes that have not yet been applied.
*/
public void cancelChanges() {
Iterator<String> iter = originalKeyStrokesByFullName.keySet().iterator();
while (iter.hasNext()) {
String actionName = iter.next();
KeyStroke originalKS = originalKeyStrokesByFullName.get(actionName);
KeyStroke modifiedKS = keyStrokesByFullName.get(actionName);
if (modifiedKS != null && !modifiedKS.equals(originalKS)) {
keyStrokesByFullName.put(actionName, originalKS);
}
}
}
/**
* Applies any pending changes.
*/
public void applyChanges() {
Iterator<String> iter = keyStrokesByFullName.keySet().iterator();
while (iter.hasNext()) {
String actionName = iter.next();
KeyStroke currentKeyStroke = keyStrokesByFullName.get(actionName);
KeyStroke originalKeyStroke = originalKeyStrokesByFullName.get(actionName);
updateOptions(actionName, originalKeyStroke, currentKeyStroke);
}
}
private void removeFromKeyMap(KeyStroke ks, String actionName) {
if (ks == null) {
return;
}
String ksName = KeyBindingUtils.parseKeyStroke(ks);
List<String> list = actionNamesByKeyStroke.get(ksName);
if (list != null) {
list.remove(actionName);
if (list.isEmpty()) {
actionNamesByKeyStroke.remove(ksName);
}
}
}
private void updateOptions(String fullActionName, KeyStroke currentKeyStroke,
KeyStroke newKeyStroke) {
if (Objects.equals(currentKeyStroke, newKeyStroke)) {
return;
}
options.setKeyStroke(fullActionName, newKeyStroke);
originalKeyStrokesByFullName.put(fullActionName, newKeyStroke);
keyStrokesByFullName.put(fullActionName, newKeyStroke);
List<DockingActionIf> actions = actionsByFullName.get(fullActionName);
for (DockingActionIf action : actions) {
action.setUnvalidatedKeyBindingData(new KeyBindingData(newKeyStroke));
}
}
private void init() {
actionsByFullName = KeyBindingUtils.getAllActionsByFullName(tool);
Set<Entry<String, List<DockingActionIf>>> entries = actionsByFullName.entrySet();
for (Entry<String, List<DockingActionIf>> entry : entries) {
// pick one action, they are all conceptually the same
List<DockingActionIf> actions = entry.getValue();
DockingActionIf action = actions.get(0);
uniqueActions.add(action);
String actionName = entry.getKey();
KeyStroke ks = options.getKeyStroke(actionName, null);
keyStrokesByFullName.put(actionName, ks);
addActionKeyStroke(ks, actionName);
originalKeyStrokesByFullName.put(actionName, ks);
String shortName = action.getName();
if (shortName.length() > longestActionName.length()) {
longestActionName = shortName;
}
}
}
private void addActionKeyStroke(KeyStroke ks, String actionName) {
if (ks == null) {
return;
}
String ksName = KeyBindingUtils.parseKeyStroke(ks);
List<String> list = actionNamesByKeyStroke.get(ksName);
if (list == null) {
list = new ArrayList<>();
actionNamesByKeyStroke.put(ksName, list);
}
if (!list.contains(actionName)) {
list.add(actionName);
}
}
}

91
Ghidra/Framework/Docking/src/main/java/docking/actions/KeyEntryDialog.java
View file

@ -16,42 +16,43 @@
package docking.actions;
import java.awt.*;
import java.util.*;
import java.util.List;
import java.util.Objects;
import javax.swing.*;
import javax.swing.text.*;
import docking.DialogComponentProvider;
import docking.KeyEntryTextField;
import docking.action.*;
import docking.*;
import docking.action.DockingActionIf;
import docking.action.KeyBindingData;
import docking.tool.ToolConstants;
import docking.widgets.label.GIconLabel;
import generic.theme.GThemeDefaults.Colors.Messages;
import generic.util.action.ReservedKeyBindings;
import ghidra.util.HelpLocation;
import resources.Icons;
/**
* Dialog to set the key binding on an action; it is popped up when the F4 key
* is hit.
* Dialog to set the key binding on an action. It is triggered by the F4 key.
*/
public class KeyEntryDialog extends DialogComponentProvider {
private KeyBindings keyBindings;
private ToolActions toolActions;
private DockingActionIf action;
private JPanel defaultPanel;
private KeyEntryTextField keyEntryField;
private JTextPane collisionPane;
private StyledDocument doc;
private SimpleAttributeSet tabAttrSet;
private SimpleAttributeSet textAttrSet;
private Color bgColor;
public KeyEntryDialog(DockingActionIf action, ToolActions actions) {
public KeyEntryDialog(Tool tool, DockingActionIf action) {
super("Set Key Binding for " + action.getName(), true);
this.action = action;
this.toolActions = actions;
this.toolActions = (ToolActions) tool.getToolActions();
this.keyBindings = new KeyBindings(tool);
setUpAttributes();
createPanel();
KeyStroke keyBinding = action.getKeyBinding();
@ -150,21 +151,22 @@ public class KeyEntryDialog extends DialogComponentProvider {
@Override
protected void okCallback() {
KeyStroke newKeyStroke = keyEntryField.getKeyStroke();
if (newKeyStroke != null && ReservedKeyBindings.isReservedKeystroke(newKeyStroke)) {
setStatusText(keyEntryField.getText() + " is a reserved keystroke");
KeyStroke newKs = keyEntryField.getKeyStroke();
String errorMessage = toolActions.validateActionKeyBinding(action, newKs);
if (errorMessage != null) {
setStatusText(errorMessage);
return;
}
clearStatusText();
KeyStroke existingKeyStroke = action.getKeyBinding();
if (Objects.equals(existingKeyStroke, newKeyStroke)) {
if (Objects.equals(existingKeyStroke, newKs)) {
setStatusText("Key binding unchanged");
return;
}
action.setUnvalidatedKeyBindingData(new KeyBindingData(newKeyStroke));
action.setUnvalidatedKeyBindingData(new KeyBindingData(newKs));
close();
}
@ -174,10 +176,6 @@ public class KeyEntryDialog extends DialogComponentProvider {
textAttrSet.addAttribute(StyleConstants.FontFamily, "Tahoma");
textAttrSet.addAttribute(StyleConstants.FontSize, Integer.valueOf(11));
textAttrSet.addAttribute(StyleConstants.Foreground, Messages.NORMAL);
tabAttrSet = new SimpleAttributeSet();
TabStop tabs = new TabStop(20, StyleConstants.ALIGN_LEFT, TabStop.LEAD_NONE);
StyleConstants.setTabSet(tabAttrSet, new TabSet(new TabStop[] { tabs }));
}
private void updateCollisionPane(KeyStroke ks) {
@ -193,26 +191,10 @@ public class KeyEntryDialog extends DialogComponentProvider {
return;
}
List<DockingActionIf> list = getManagedActionsForKeyStroke(ks);
if (list.size() == 0) {
return;
}
list.sort((a1, a2) -> {
String s1 = a1.getName() + a1.getOwnerDescription();
String s2 = a2.getName() + a2.getOwnerDescription();
return s1.compareToIgnoreCase(s2);
});
String ksName = KeyBindingUtils.parseKeyStroke(ks);
String text = keyBindings.getActionsForKeyStrokeText(ksName);
try {
doc.insertString(0, "Actions mapped to " + ksName + "\n\n", textAttrSet);
for (DockingActionIf a : list) {
String collisionStr = "\t" + a.getName() + " (" + a.getOwnerDescription() + ")\n";
int offset = doc.getLength();
doc.insertString(offset, collisionStr, textAttrSet);
doc.setParagraphAttributes(offset, 1, tabAttrSet, false);
}
doc.insertString(0, text, textAttrSet);
collisionPane.setCaretPosition(0);
}
catch (BadLocationException e) {
@ -220,37 +202,4 @@ public class KeyEntryDialog extends DialogComponentProvider {
}
}
private List<DockingActionIf> getManagedActionsForKeyStroke(KeyStroke keyStroke) {
MultipleKeyAction multiAction = getMultipleKeyAction(keyStroke);
if (multiAction == null) {
return Collections.emptyList();
}
List<DockingActionIf> list = multiAction.getActions();
Map<String, DockingActionIf> nameMap = new HashMap<>(list.size());
// the list may have multiple matches for a single owner, which we do not want (see
// SharedStubKeyBindingAction)
for (DockingActionIf dockableAction : list) {
if (shouldAddAction(dockableAction)) {
// this overwrites same named actions
nameMap.put(dockableAction.getName() + dockableAction.getOwner(), dockableAction);
}
}
return new ArrayList<>(nameMap.values());
}
private MultipleKeyAction getMultipleKeyAction(KeyStroke ks) {
Action keyAction = toolActions.getAction(ks);
if (keyAction instanceof MultipleKeyAction) {
return (MultipleKeyAction) keyAction;
}
return null;
}
private boolean shouldAddAction(DockingActionIf dockableAction) {
return dockableAction.getKeyBindingType().isManaged();
}
}

18
Ghidra/Framework/Docking/src/main/java/docking/actions/KeyBindingAction.java → Ghidra/Framework/Docking/src/main/java/docking/actions/SetKeyBindingAction.java
View file

@ -17,19 +17,22 @@ package docking.actions;
import java.awt.Component;
import docking.ActionContext;
import docking.DockingWindowManager;
import javax.swing.KeyStroke;
import docking.*;
import docking.action.*;
import ghidra.util.Msg;
public class KeyBindingAction extends DockingAction {
public class SetKeyBindingAction extends DockingAction {
public static String NAME = "Set KeyBinding";
private ToolActions toolActions;
private Tool tool;
public KeyBindingAction(ToolActions toolActions) {
public SetKeyBindingAction(Tool tool, KeyStroke keyStroke) {
super(NAME, DockingWindowManager.DOCKING_WINDOWS_OWNER);
this.toolActions = toolActions;
this.tool = tool;
setKeyBindingData(new KeyBindingData(keyStroke));
// Help actions don't have help
DockingWindowManager.getHelpService().excludeFromHelp(this);
@ -56,7 +59,7 @@ public class KeyBindingAction extends DockingAction {
return;
}
KeyEntryDialog d = new KeyEntryDialog(action, toolActions);
KeyEntryDialog d = new KeyEntryDialog(tool, action);
DockingWindowManager.showDialog(d);
}
@ -72,6 +75,7 @@ public class KeyBindingAction extends DockingAction {
// It is not key binding managed, which means that it may be a shared key binding
String actionName = dockingAction.getName();
ToolActions toolActions = (ToolActions) tool.getToolActions();
DockingActionIf sharedAction = toolActions.getSharedStubKeyBindingAction(actionName);
if (sharedAction != null) {
return sharedAction;

82
Ghidra/Framework/Docking/src/main/java/docking/actions/ToolActions.java
View file

@ -15,6 +15,8 @@
*/
package docking.actions;
import static generic.util.action.SystemKeyBindings.*;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.*;
@ -32,7 +34,6 @@ import org.apache.commons.collections4.map.LazyMap;
import docking.*;
import docking.action.*;
import docking.tool.util.DockingToolConstants;
import generic.util.action.ReservedKeyBindings;
import ghidra.framework.options.*;
import ghidra.util.Msg;
import ghidra.util.exception.AssertException;
@ -60,7 +61,7 @@ public class ToolActions implements DockingToolActions, PropertyChangeListener {
private Map<String, SharedStubKeyBindingAction> sharedActionMap = new HashMap<>();
private ToolOptions keyBindingOptions;
private Tool dockingTool;
private Tool tool;
private KeyBindingsManager keyBindingsManager;
private OptionsChangeListener optionChangeListener = (options, optionName, oldValue,
newValue) -> updateKeyBindingsFromOptions(options, optionName, (KeyStroke) newValue);
@ -72,45 +73,49 @@ public class ToolActions implements DockingToolActions, PropertyChangeListener {
* @param actionToGuiHelper the class that takes actions and maps them to GUI widgets
*/
public ToolActions(Tool tool, ActionToGuiHelper actionToGuiHelper) {
this.dockingTool = tool;
this.tool = tool;
this.actionGuiHelper = actionToGuiHelper;
this.keyBindingsManager = new KeyBindingsManager(tool);
this.keyBindingOptions = tool.getOptions(DockingToolConstants.KEY_BINDINGS);
this.keyBindingOptions.addOptionsChangeListener(optionChangeListener);
createReservedKeyBindings();
createSystemActions();
SharedActionRegistry.installSharedActions(tool, this);
}
private void createReservedKeyBindings() {
KeyBindingAction keyBindingAction = new KeyBindingAction(this);
keyBindingsManager.addReservedAction(keyBindingAction,
ReservedKeyBindings.UPDATE_KEY_BINDINGS_KEY);
private void createSystemActions() {
keyBindingsManager.addReservedAction(new HelpAction(false, ReservedKeyBindings.HELP_KEY1));
keyBindingsManager.addReservedAction(new HelpAction(false, ReservedKeyBindings.HELP_KEY2));
keyBindingsManager
.addReservedAction(new HelpAction(true, ReservedKeyBindings.HELP_INFO_KEY));
keyBindingsManager.addReservedAction(
new ShowContextMenuAction(ReservedKeyBindings.CONTEXT_MENU_KEY1));
keyBindingsManager.addReservedAction(
new ShowContextMenuAction(ReservedKeyBindings.CONTEXT_MENU_KEY2));
addSystemAction(new SetKeyBindingAction(tool, UPDATE_KEY_BINDINGS_KEY));
keyBindingsManager.addReservedAction(
new NextPreviousWindowAction(ReservedKeyBindings.FOCUS_NEXT_WINDOW_KEY, true));
keyBindingsManager.addReservedAction(
new NextPreviousWindowAction(ReservedKeyBindings.FOCUS_PREVIOUS_WINDOW_KEY, false));
addSystemAction(new HelpAction(HELP_KEY1, false));
addSystemAction(new HelpAction(HELP_KEY2, true));
addSystemAction(new HelpInfoAction(HELP_INFO_KEY));
addSystemAction(new ShowContextMenuAction(CONTEXT_MENU_KEY1, true));
addSystemAction(new ShowContextMenuAction(CONTEXT_MENU_KEY2, false));
keyBindingsManager.addReservedAction(
new GlobalFocusTraversalAction(ReservedKeyBindings.FOCUS_NEXT_COMPONENT_KEY, true));
keyBindingsManager.addReservedAction(
new GlobalFocusTraversalAction(ReservedKeyBindings.FOCUS_PREVIOUS_COMPONENT_KEY,
false));
addSystemAction(new NextPreviousWindowAction(FOCUS_NEXT_WINDOW_KEY, true));
addSystemAction(new NextPreviousWindowAction(FOCUS_PREVIOUS_WINDOW_KEY, false));
addSystemAction(new GlobalFocusTraversalAction(FOCUS_NEXT_COMPONENT_KEY, true));
addSystemAction(new GlobalFocusTraversalAction(FOCUS_PREVIOUS_COMPONENT_KEY, false));
// helpful debugging actions
keyBindingsManager.addReservedAction(new ShowFocusInfoAction());
keyBindingsManager.addReservedAction(new ShowFocusCycleAction());
keyBindingsManager.addReservedAction(new ComponentThemeInspectorAction());
addSystemAction(new ShowFocusInfoAction());
addSystemAction(new ShowFocusCycleAction());
addSystemAction(new ComponentThemeInspectorAction());
}
private void addSystemAction(DockingAction action) {
// Some System actions support changing the keybinding. In the future, all System actions
// may support this.
if (action.getKeyBindingType().isManaged()) {
KeyBindingData kbd = action.getKeyBindingData();
KeyStroke ks = kbd.getKeyBinding();
loadKeyBindingFromOptions(action, ks);
}
keyBindingsManager.addSystemAction(action);
}
public void dispose() {
@ -170,7 +175,6 @@ public class ToolActions implements DockingToolActions, PropertyChangeListener {
}
private void loadKeyBindingFromOptions(DockingActionIf action, KeyStroke ks) {
String description = "Keybinding for " + action.getFullName();
keyBindingOptions.registerOption(action.getFullName(), OptionType.KEYSTROKE_TYPE, ks, null,
description);
@ -288,6 +292,8 @@ public class ToolActions implements DockingToolActions, PropertyChangeListener {
result.addAll(sharedActionMap.values());
result.addAll(keyBindingsManager.getSystemActions());
return result;
}
@ -311,7 +317,7 @@ public class ToolActions implements DockingToolActions, PropertyChangeListener {
* otherwise the options will be removed because they are noted as not being used.
*/
public synchronized void restoreKeyBindings() {
keyBindingOptions = dockingTool.getOptions(DockingToolConstants.KEY_BINDINGS);
keyBindingOptions = tool.getOptions(DockingToolConstants.KEY_BINDINGS);
Iterator<DockingActionIf> it = getKeyBindingActionsIterator();
for (DockingActionIf action : CollectionUtils.asIterable(it)) {
@ -406,8 +412,7 @@ public class ToolActions implements DockingToolActions, PropertyChangeListener {
}
DockingActionIf action = (DockingActionIf) evt.getSource();
if (!action.getKeyBindingType()
.isManaged()) {
if (!action.getKeyBindingType().isManaged()) {
// this reads unusually, but we need to notify the tool to rebuild its 'Window' menu
// in the case that this action is one of the tool's special actions
keyBindingsChanged();
@ -429,7 +434,7 @@ public class ToolActions implements DockingToolActions, PropertyChangeListener {
// triggered by a user-initiated action; called by propertyChange()
private void keyBindingsChanged() {
dockingTool.setConfigChanged(true);
tool.setConfigChanged(true);
actionGuiHelper.keyBindingsChanged();
}
@ -447,6 +452,17 @@ public class ToolActions implements DockingToolActions, PropertyChangeListener {
return null;
}
/**
* Checks whether the given key stroke can be used for the given action for restrictions such as
* those for System level actions.
* @param action the action; may be null
* @param ks the key stroke
* @return A null value if valid; a non-null error message if invalid
*/
public String validateActionKeyBinding(DockingActionIf action, KeyStroke ks) {
return keyBindingsManager.validateActionKeyBinding(action, ks);
}
public Action getAction(KeyStroke ks) {
return keyBindingsManager.getDockingKeyAction(ks);
}

94
Ghidra/Framework/Generic/src/main/java/generic/util/action/ReservedKeyBindings.java
View file

@ -1,94 +0,0 @@
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package generic.util.action;
import java.awt.Toolkit;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import javax.swing.KeyStroke;
public class ReservedKeyBindings {
private static final int CONTROL_KEY_MODIFIER_MASK =
Toolkit.getDefaultToolkit()
.getMenuShortcutKeyMaskEx();
private ReservedKeyBindings() {
// utils class
}
public static final KeyStroke HELP_KEY1 = KeyStroke.getKeyStroke(KeyEvent.VK_HELP, 0);
public static final KeyStroke HELP_KEY2 = KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0);
public static final KeyStroke HELP_INFO_KEY =
KeyStroke.getKeyStroke(KeyEvent.VK_F1, CONTROL_KEY_MODIFIER_MASK);
public static final KeyStroke CONTEXT_MENU_KEY1 =
KeyStroke.getKeyStroke(KeyEvent.VK_F10, InputEvent.SHIFT_DOWN_MASK);
public static final KeyStroke CONTEXT_MENU_KEY2 =
KeyStroke.getKeyStroke(KeyEvent.VK_CONTEXT_MENU, 0);
public static final KeyStroke FOCUS_NEXT_WINDOW_KEY =
KeyStroke.getKeyStroke(KeyEvent.VK_F3, InputEvent.CTRL_DOWN_MASK);
public static final KeyStroke FOCUS_PREVIOUS_WINDOW_KEY =
KeyStroke.getKeyStroke(KeyEvent.VK_F3,
InputEvent.SHIFT_DOWN_MASK | InputEvent.CTRL_DOWN_MASK);
public static final KeyStroke FOCUS_NEXT_COMPONENT_KEY =
KeyStroke.getKeyStroke(KeyEvent.VK_TAB, InputEvent.CTRL_DOWN_MASK);
public static final KeyStroke FOCUS_PREVIOUS_COMPONENT_KEY =
KeyStroke.getKeyStroke(KeyEvent.VK_TAB,
InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK);
public static final KeyStroke FOCUS_INFO_KEY = KeyStroke.getKeyStroke(KeyEvent.VK_F2,
CONTROL_KEY_MODIFIER_MASK | InputEvent.ALT_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK);
public static final KeyStroke FOCUS_CYCLE_INFO_KEY = KeyStroke.getKeyStroke(KeyEvent.VK_F3,
CONTROL_KEY_MODIFIER_MASK | InputEvent.ALT_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK);
public static final KeyStroke UPDATE_KEY_BINDINGS_KEY =
KeyStroke.getKeyStroke(KeyEvent.VK_F4, 0);
public static final KeyStroke COMPONENT_THEME_INFO_KEY = KeyStroke.getKeyStroke(KeyEvent.VK_F9,
CONTROL_KEY_MODIFIER_MASK | InputEvent.ALT_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK);
// @formatter:off
public static boolean isReservedKeystroke(KeyStroke keyStroke) {
int code = keyStroke.getKeyCode();
if (code == KeyEvent.VK_SHIFT ||
code == KeyEvent.VK_ALT ||
code == KeyEvent.VK_CONTROL ||
code == KeyEvent.VK_CAPS_LOCK ||
code == KeyEvent.VK_TAB ||
HELP_KEY1.equals(keyStroke) ||
HELP_KEY2.equals(keyStroke) ||
HELP_INFO_KEY.equals(keyStroke) ||
UPDATE_KEY_BINDINGS_KEY.equals(keyStroke) ||
FOCUS_INFO_KEY.equals(keyStroke) ||
FOCUS_CYCLE_INFO_KEY.equals(keyStroke) ||
COMPONENT_THEME_INFO_KEY.equals(keyStroke) ||
CONTEXT_MENU_KEY1.equals(keyStroke) ||
CONTEXT_MENU_KEY2.equals(keyStroke) ||
FOCUS_NEXT_WINDOW_KEY.equals(keyStroke) ||
FOCUS_PREVIOUS_WINDOW_KEY.equals(keyStroke) ||
FOCUS_NEXT_COMPONENT_KEY.equals(keyStroke) ||
FOCUS_PREVIOUS_COMPONENT_KEY.equals(keyStroke)) {
return true;
}
// @formatter:on
return false;
}
}

58
Ghidra/Framework/Generic/src/main/java/generic/util/action/SystemKeyBindings.java Normal file
View file

@ -0,0 +1,58 @@
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package generic.util.action;
import static java.awt.event.InputEvent.*;
import static java.awt.event.KeyEvent.*;
import static javax.swing.KeyStroke.*;
import java.awt.Toolkit;
import javax.swing.KeyStroke;
/**
* Default key strokes for System actions.
*/
public class SystemKeyBindings {
private static final int CTRL = Toolkit.getDefaultToolkit().getMenuShortcutKeyMaskEx();
private static final int CTRL_SHIFT = CTRL | SHIFT_DOWN_MASK;
private static final int CTRL_ALT_SHIFT = CTRL_SHIFT | ALT_DOWN_MASK;
public static final KeyStroke HELP_KEY1 = KeyStroke.getKeyStroke(VK_HELP, 0);
public static final KeyStroke HELP_KEY2 = KeyStroke.getKeyStroke(VK_F1, 0);
public static final KeyStroke HELP_INFO_KEY = getKeyStroke(VK_F1, CTRL);
public static final KeyStroke CONTEXT_MENU_KEY1 = getKeyStroke(VK_F10, SHIFT_DOWN_MASK);
public static final KeyStroke CONTEXT_MENU_KEY2 = getKeyStroke(VK_CONTEXT_MENU, 0);
public static final KeyStroke FOCUS_NEXT_WINDOW_KEY = getKeyStroke(VK_F3, CTRL);
public static final KeyStroke FOCUS_PREVIOUS_WINDOW_KEY = getKeyStroke(VK_F3, CTRL_SHIFT);
public static final KeyStroke FOCUS_NEXT_COMPONENT_KEY = getKeyStroke(VK_TAB, CTRL);
public static final KeyStroke FOCUS_PREVIOUS_COMPONENT_KEY = getKeyStroke(VK_TAB, CTRL_SHIFT);
public static final KeyStroke FOCUS_INFO_KEY = getKeyStroke(VK_F2, CTRL_ALT_SHIFT);
public static final KeyStroke FOCUS_CYCLE_INFO_KEY = getKeyStroke(VK_F3, CTRL_ALT_SHIFT);
public static final KeyStroke UPDATE_KEY_BINDINGS_KEY = getKeyStroke(VK_F4, 0);
public static final KeyStroke COMPONENT_THEME_INFO_KEY = getKeyStroke(VK_F9, CTRL_ALT_SHIFT);
private SystemKeyBindings() {
// utils class
}
}

5
Ghidra/Framework/Generic/src/main/resources/generic.log4jdev.xml
View file

@ -53,7 +53,10 @@
<logger name="ghidra.framework.project" level="DEBUG"/>
<logger name="ghidra.framework.project.DefaultProject" level="WARN"/>
<logger name="ghidra.framework.project.DefaultProjectManager" level="INFO"/>
<!-- Ignore warnings about missing content classes in test env -->
<logger name="ghidra.framework.project.tool.GhidraToolTemplate" level="ERROR"/>
<logger name="functioncalls" level="DEBUG" />
<logger name="generic.random" level="WARN"/>
<logger name="ghidra.app.plugin.core.progmgr.ProgramManagerPlugin" level="WARN"/>

3
Ghidra/Framework/Generic/src/main/resources/generic.log4jtest.xml
View file

@ -53,6 +53,9 @@
<logger name="ghidra.framework.project.DefaultProject" level="WARN"/>
<logger name="ghidra.framework.project.DefaultProjectManager" level="INFO"/>
<!-- Ignore warnings about missing content classes in test env -->
<logger name="ghidra.framework.project.tool.GhidraToolTemplate" level="ERROR"/>
<logger name="functioncalls" level="DEBUG" />
<logger name="generic.random" level="WARN"/>
<logger name="ghidra.app.plugin.core.progmgr.ProgramManagerPlugin" level="WARN"/>

16
Ghidra/Framework/Gui/src/main/java/generic/test/AbstractGuiTest.java
View file

@ -660,12 +660,26 @@ public class AbstractGuiTest extends AbstractGenericTest {
* @param s the supplier
* @return the value returned by the supplier
*/
public static <T> T runSwing(Supplier<T> s) {
public static <T> T getSwing(Supplier<T> s) {
AtomicReference<T> ref = new AtomicReference<>();
runSwing(() -> ref.set(s.get()));
return ref.get();
}
/**
* Returns the value from the given {@link Supplier}, invoking the call in
* the Swing thread. This is useful when you may have values that are being
* changed on the Swing thread and you need the test thread to see the
* changes.
*
* @param s the supplier
* @return the value returned by the supplier
* @see #getSwing(Supplier)
*/
public static <T> T runSwing(Supplier<T> s) {
return getSwing(s);
}
/**
* Run the given code snippet on the Swing thread and wait for it to finish
* @param r the runnable code snippet

3
Ghidra/Framework/Project/src/main/java/ghidra/framework/data/DefaultProjectData.java
View file

@ -1260,7 +1260,6 @@ public class DefaultProjectData implements ProjectData {
public void close() {
synchronized (this) {
if (!closed) {
Msg.debug(this, "Closing ProjectData: " + projectDir);
closed = true;
}
if (inUseCount != 0) {
@ -1301,8 +1300,6 @@ public class DefaultProjectData implements ProjectData {
return;
}
Msg.debug(this, "Disposing ProjectData: " + projectDir);
closed = true;
disposed = true;

330
Ghidra/Framework/Project/src/main/java/ghidra/framework/plugintool/dialog/KeyBindingsPanel.java
View file

@ -20,30 +20,28 @@ import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.*;
import java.util.List;
import java.util.Map.Entry;
import javax.swing.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.TableColumn;
import org.apache.commons.lang3.StringUtils;
import docking.DockingUtils;
import docking.KeyEntryTextField;
import docking.action.DockingActionIf;
import docking.action.KeyBindingData;
import docking.actions.KeyBindingUtils;
import docking.actions.*;
import docking.tool.util.DockingToolConstants;
import docking.widgets.*;
import docking.widgets.label.GIconLabel;
import docking.widgets.table.*;
import generic.theme.Gui;
import generic.util.action.ReservedKeyBindings;
import ghidra.framework.options.Options;
import ghidra.framework.options.ToolOptions;
import ghidra.framework.plugintool.PluginTool;
import ghidra.util.HTMLUtilities;
import ghidra.util.Swing;
import ghidra.util.exception.AssertException;
import ghidra.util.layout.PairLayout;
import ghidra.util.layout.VerticalLayout;
import help.Help;
@ -68,31 +66,25 @@ public class KeyBindingsPanel extends JPanel {
private JPanel infoPanel;
private MultiLineLabel collisionLabel;
private KeyBindingsTableModel tableModel;
private ListSelectionModel selectionModel;
private Options options;
private Map<String, List<DockingActionIf>> actionsByFullName;
private Map<String, List<String>> actionNamesByKeyStroke = new HashMap<>();
private Map<String, KeyStroke> keyStrokesByFullName = new HashMap<>();
private Map<String, KeyStroke> originalValues = new HashMap<>(); // to know what has been changed
private List<DockingActionIf> tableActions = new ArrayList<>();
private KeyEntryTextField ksField;
private GTableFilterPanel<DockingActionIf> tableFilterPanel;
private EmptyBorderButton helpButton;
private KeyBindings keyBindings;
private boolean unappliedChanges;
private PluginTool tool;
private boolean firingTableDataChanged;
private PropertyChangeListener propertyChangeListener;
private GTableFilterPanel<DockingActionIf> tableFilterPanel;
private EmptyBorderButton helpButton;
public KeyBindingsPanel(PluginTool tool, Options options) {
public KeyBindingsPanel(PluginTool tool) {
this.tool = tool;
this.options = options;
this.keyBindings = new KeyBindings(tool);
createPanelComponents();
createActionMap();
addListeners();
initializeTableWidth();
}
public void setOptionsPropertyChangeListener(PropertyChangeListener listener) {
@ -105,82 +97,31 @@ public class KeyBindingsPanel extends JPanel {
}
public void apply() {
Iterator<String> iter = keyStrokesByFullName.keySet().iterator();
while (iter.hasNext()) {
String actionName = iter.next();
KeyStroke currentKeyStroke = keyStrokesByFullName.get(actionName);
KeyStroke originalKeyStroke = originalValues.get(actionName);
updateOptions(actionName, originalKeyStroke, currentKeyStroke);
}
keyBindings.applyChanges();
changesMade(false);
}
private void updateOptions(String fullActionName, KeyStroke currentKeyStroke,
KeyStroke newKeyStroke) {
if (Objects.equals(currentKeyStroke, newKeyStroke)) {
return;
}
options.setKeyStroke(fullActionName, newKeyStroke);
originalValues.put(fullActionName, newKeyStroke);
keyStrokesByFullName.put(fullActionName, newKeyStroke);
List<DockingActionIf> actions = actionsByFullName.get(fullActionName);
for (DockingActionIf action : actions) {
action.setUnvalidatedKeyBindingData(new KeyBindingData(newKeyStroke));
}
}
public void cancel() {
Iterator<String> iter = originalValues.keySet().iterator();
while (iter.hasNext()) {
String actionName = iter.next();
KeyStroke originalKS = originalValues.get(actionName);
KeyStroke modifiedKS = keyStrokesByFullName.get(actionName);
if (modifiedKS != null && !modifiedKS.equals(originalKS)) {
keyStrokesByFullName.put(actionName, originalKS);
}
}
keyBindings.cancelChanges();
tableModel.fireTableDataChanged();
}
public void reload() {
Swing.runLater(() -> {
// clear the current user key stroke so that it does not appear as though the
// user is editing while restoring
// clear the action to avoid the appearance of editing while restoring
actionTable.clearSelection();
restoreDefaultKeybindings();
});
}
private void createActionMap() {
public String getStatusText() {
return statusLabel.getText();
}
String longestName = "";
private void initializeTableWidth() {
actionsByFullName = KeyBindingUtils.getAllActionsByFullName(tool);
Set<Entry<String, List<DockingActionIf>>> entries = actionsByFullName.entrySet();
for (Entry<String, List<DockingActionIf>> entry : entries) {
// pick one action, they are all conceptually the same
List<DockingActionIf> actions = entry.getValue();
DockingActionIf action = actions.get(0);
tableActions.add(action);
String actionName = entry.getKey();
KeyStroke ks = options.getKeyStroke(actionName, null);
keyStrokesByFullName.put(actionName, ks);
addToKeyMap(ks, actionName);
originalValues.put(actionName, ks);
String shortName = action.getName();
if (shortName.length() > longestName.length()) {
longestName = shortName;
}
}
String longestName = keyBindings.getLongestActionName();
Font f = actionTable.getFont();
FontMetrics fm = actionTable.getFontMetrics(f);
@ -197,7 +138,7 @@ public class KeyBindingsPanel extends JPanel {
private void createPanelComponents() {
setLayout(new BorderLayout(10, 10));
tableModel = new KeyBindingsTableModel();
tableModel = new KeyBindingsTableModel(new ArrayList<>(keyBindings.getUniqueActions()));
actionTable = new GTable(tableModel);
JScrollPane sp = new JScrollPane(actionTable);
@ -225,6 +166,8 @@ public class KeyBindingsPanel extends JPanel {
add(centerPanel, BorderLayout.CENTER);
add(statusPanel, BorderLayout.SOUTH);
actionTable.getSelectionModel().addListSelectionListener(new TableSelectionListener());
}
private JPanel createStatusPanel(JPanel keyPanel) {
@ -264,7 +207,7 @@ public class KeyBindingsPanel extends JPanel {
}
private JPanel createKeyEntryPanel() {
ksField = new KeyEntryTextField(20, keyStroke -> processKeyStrokeEntry(keyStroke));
ksField = new KeyEntryTextField(20, keyStroke -> keyStrokeChanged(keyStroke));
// this is the lower panel that holds the key entry text field
JPanel p = new JPanel(new FlowLayout(FlowLayout.LEFT));
@ -326,10 +269,9 @@ public class KeyBindingsPanel extends JPanel {
// give Swing a chance to repaint
Swing.runLater(() -> {
// clear the current user key stroke so that it does not appear as though the
// user is editing while importing
// clear the action to avoid the appearance of editing while restoring
actionTable.clearSelection();
processKeyBindingsFromOptions(KeyBindingUtils.importKeyBindings());
loadKeyBindingsFromImportedOptions(KeyBindingUtils.importKeyBindings());
});
});
@ -338,7 +280,7 @@ public class KeyBindingsPanel extends JPanel {
exportButton.addActionListener(event -> {
// prompt user to apply changes before exporting
boolean continueExport = showExportPrompt();
boolean continueExport = showApplyPrompt();
if (!continueExport) {
return;
@ -358,7 +300,7 @@ public class KeyBindingsPanel extends JPanel {
return containerPanel;
}
private boolean showExportPrompt() {
private boolean showApplyPrompt() {
boolean continueOperation = true;
if (unappliedChanges) {
int userChoice = OptionDialog.showYesNoCancelDialog(KeyBindingsPanel.this,
@ -390,14 +332,11 @@ public class KeyBindingsPanel extends JPanel {
private Map<String, KeyStroke> createActionNameToKeyStrokeMap(Options keyBindingOptions) {
Map<String, KeyStroke> localActionMap = new HashMap<>();
List<String> optionNames = keyBindingOptions.getOptionNames();
for (String element : optionNames) {
KeyStroke newKeyStroke = keyBindingOptions.getKeyStroke(element, null);
localActionMap.put(element, newKeyStroke);
for (String name : optionNames) {
KeyStroke newKeyStroke = keyBindingOptions.getKeyStroke(name, null);
localActionMap.put(name, newKeyStroke);
}
return localActionMap;
}
@ -415,52 +354,12 @@ public class KeyBindingsPanel extends JPanel {
}
private void restoreDefaultKeybindings() {
Iterator<String> iter = keyStrokesByFullName.keySet().iterator();
while (iter.hasNext()) {
String actionName = iter.next();
List<DockingActionIf> actions = actionsByFullName.get(actionName);
if (actions.isEmpty()) {
throw new AssertException("No actions defined for " + actionName);
}
// pick one action, they are all conceptually the same
DockingActionIf action = actions.get(0);
KeyStroke currentKeyStroke = keyStrokesByFullName.get(actionName);
KeyBindingData defaultBinding = action.getDefaultKeyBindingData();
KeyStroke newKeyStroke =
(defaultBinding == null) ? null : defaultBinding.getKeyBinding();
updateOptions(actionName, currentKeyStroke, newKeyStroke);
}
keyBindings.restoreOptions();
// let the table know that changes may have been made
tableModel.fireTableDataChanged();
}
private void addListeners() {
selectionModel = actionTable.getSelectionModel();
selectionModel.addListSelectionListener(new TableSelectionListener());
}
private boolean checkAction(String actionName, KeyStroke keyStroke) {
String ksName = KeyEntryTextField.parseKeyStroke(keyStroke);
// remove old keystroke for action name
KeyStroke oldKs = keyStrokesByFullName.get(actionName);
if (oldKs != null) {
String oldName = KeyEntryTextField.parseKeyStroke(oldKs);
if (oldName.equals(ksName)) {
return false;
}
removeFromKeyMap(oldKs, actionName);
}
addToKeyMap(keyStroke, actionName);
keyStrokesByFullName.put(actionName, keyStroke);
changesMade(true);
return true;
}
// signals that there are unapplied changes
private void changesMade(boolean changes) {
propertyChangeListener.propertyChange(
@ -469,12 +368,11 @@ public class KeyBindingsPanel extends JPanel {
}
private DockingActionIf getSelectedAction() {
if (selectionModel.isSelectionEmpty()) {
if (actionTable.getSelectedRowCount() == 0) {
return null;
}
int selectedRow = actionTable.getSelectedRow();
int modelRow = tableFilterPanel.getModelRow(selectedRow);
return tableActions.get(modelRow);
return tableFilterPanel.getRowObject(selectedRow);
}
private String getSelectedActionName() {
@ -485,62 +383,20 @@ public class KeyBindingsPanel extends JPanel {
return action.getFullName();
}
private void addToKeyMap(KeyStroke ks, String actionName) {
if (ks == null) {
return;
}
String ksName = KeyEntryTextField.parseKeyStroke(ks);
List<String> list = actionNamesByKeyStroke.get(ksName);
if (list == null) {
list = new ArrayList<>();
actionNamesByKeyStroke.put(ksName, list);
}
if (!list.contains(actionName)) {
list.add(actionName);
}
}
private void removeFromKeyMap(KeyStroke ks, String actionName) {
if (ks == null) {
return;
}
String ksName = KeyEntryTextField.parseKeyStroke(ks);
List<String> list = actionNamesByKeyStroke.get(ksName);
if (list != null) {
list.remove(actionName);
if (list.isEmpty()) {
actionNamesByKeyStroke.remove(ksName);
}
}
}
private void showActionsMappedToKeyStroke(String ksName) {
List<String> list = actionNamesByKeyStroke.get(ksName);
if (list == null) {
return;
}
if (list.size() > 0) {
StringBuffer sb = new StringBuffer();
sb.append("Actions mapped to key " + ksName + ":\n");
for (int i = 0; i < list.size(); i++) {
sb.append(" ");
sb.append(list.get(i));
if (i < list.size() - 1) {
sb.append("\n");
}
}
updateInfoPanel(sb.toString());
}
else {
clearInfoPanel();
String text = keyBindings.getActionsForKeyStrokeText(ksName);
if (StringUtils.isBlank(text)) {
text = " ";
}
updateCollisionPanel(text);
}
private void clearInfoPanel() {
updateInfoPanel(" ");
updateCollisionPanel(" ");
}
private void updateInfoPanel(String text) {
private void updateCollisionPanel(String text) {
infoPanel.removeAll();
infoPanel.repaint();
collisionLabel = new MultiLineLabel(text);
@ -550,111 +406,94 @@ public class KeyBindingsPanel extends JPanel {
validate();
}
private void processKeyBindingsFromOptions(Options keyBindingOptions) {
private void loadKeyBindingsFromImportedOptions(Options keyBindingOptions) {
if (keyBindingOptions == null) {
return;
}
Map<String, KeyStroke> keyBindingsMap = createActionNameToKeyStrokeMap(keyBindingOptions);
if (keyBindingsMap == null) {
Map<String, KeyStroke> keyStrokesByActionName =
createActionNameToKeyStrokeMap(keyBindingOptions);
if (keyStrokesByActionName == null) {
return;
}
boolean changes = false;
// add each new key stroke mapping
Iterator<String> iterator = keyBindingsMap.keySet().iterator();
while (iterator.hasNext()) {
for (String name : keyStrokesByActionName.keySet()) {
String name = iterator.next();
KeyStroke keyStroke = keyBindingsMap.get(name);
KeyStroke keyStroke = keyStrokesByActionName.get(name);
keyStroke = KeyBindingUtils.validateKeyStroke(keyStroke);
// prevent non-existing keybindings from being added to Ghidra (this can happen
// when actions exist in the imported bindings, but have been removed from
// Ghidra
if (!keyStrokesByFullName.containsKey(name)) {
// prevent non-existing keybindings from being added (this can happen when actions exist
// in the imported bindings, but have been removed from the tool
if (!keyBindings.containsAction(name)) {
continue;
}
// check to see if the key stroke results in a change and
// record that value
changes |= processKeyStroke(name, keyStroke);
changes |= setActionKeyStroke(name, keyStroke);
}
if (changes) {
changesMade(true);
tableModel.fireTableDataChanged();
}
}
/**
* Processes KeyStroke entry from the text field.
*/
private void processKeyStrokeEntry(KeyStroke ks) {
private void keyStrokeChanged(KeyStroke ks) {
clearInfoPanel();
// An action must be selected
if (selectionModel.isSelectionEmpty()) {
DockingActionIf action = getSelectedAction();
if (action == null) {
statusLabel.setText("No action is selected.");
return;
}
if (ks != null && ReservedKeyBindings.isReservedKeystroke(ks)) {
statusLabel.setText(KeyEntryTextField.parseKeyStroke(ks) + " is a reserved keystroke");
ToolActions toolActions = (ToolActions) tool.getToolActions();
String errorMessage = toolActions.validateActionKeyBinding(action, ks);
if (errorMessage != null) {
statusLabel.setText(errorMessage);
ksField.clearField();
return;
}
String selectedActionName = getSelectedActionName();
if (selectedActionName != null) {
if (processKeyStroke(selectedActionName, ks)) {
String keyStrokeText = KeyEntryTextField.parseKeyStroke(ks);
if (setActionKeyStroke(selectedActionName, ks)) {
String keyStrokeText = KeyBindingUtils.parseKeyStroke(ks);
showActionsMappedToKeyStroke(keyStrokeText);
tableModel.fireTableDataChanged();
changesMade(true);
}
}
}
// returns true if the key stroke is a new value
private boolean processKeyStroke(String actionName, KeyStroke keyStroke) {
// Clear entry if enter or backspace
if (keyStroke == null) {
removeKeystroke(actionName);
}
else {
char keyChar = keyStroke.getKeyChar();
if (Character.isWhitespace(keyChar) ||
Character.getType(keyChar) == Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE) {
removeKeystroke(actionName);
}
else {
// check the action to see if is different than the current value
return checkAction(actionName, keyStroke);
}
private boolean setActionKeyStroke(String actionName, KeyStroke keyStroke) {
if (!isValidKeyStroke(keyStroke)) {
ksField.setText("");
return keyBindings.removeKeyStroke(actionName);
}
return false;
return keyBindings.setActionKeyStroke(actionName, keyStroke);
}
private void removeKeystroke(String selectedActionName) {
ksField.setText("");
if (keyStrokesByFullName.containsKey(selectedActionName)) {
KeyStroke stroke = keyStrokesByFullName.get(selectedActionName);
if (stroke == null) {
// nothing to remove; nothing has changed
return;
}
removeFromKeyMap(stroke, selectedActionName);
keyStrokesByFullName.put(selectedActionName, null);
tableModel.fireTableDataChanged();
changesMade(true);
private boolean isValidKeyStroke(KeyStroke ks) {
if (ks == null) {
return false;
}
char keyChar = ks.getKeyChar();
return !Character.isWhitespace(keyChar) &&
Character.getType(keyChar) != Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE;
}
Map<String, KeyStroke> getKeyStrokeMap() {
return keyStrokesByFullName;
return keyBindings.getKeyStrokesByFullActionName();
}
//==================================================================================================
@ -678,12 +517,12 @@ public class KeyBindingsPanel extends JPanel {
}
helpButton.setEnabled(true);
KeyStroke ks = keyStrokesByFullName.get(fullActionName);
KeyStroke ks = keyBindings.getKeyStroke(fullActionName);
String ksName = "";
clearInfoPanel();
if (ks != null) {
ksName = KeyEntryTextField.parseKeyStroke(ks);
ksName = KeyBindingUtils.parseKeyStroke(ks);
showActionsMappedToKeyStroke(ksName);
}
@ -693,9 +532,7 @@ public class KeyBindingsPanel extends JPanel {
statusLabel.setPreferredSize(
new Dimension(statusLabel.getPreferredSize().width, STATUS_LABEL_HEIGHT));
// pick one action, they are all conceptually the same
List<DockingActionIf> actions = actionsByFullName.get(fullActionName);
DockingActionIf action = actions.get(0);
DockingActionIf action = getSelectedAction();
String description = action.getDescription();
if (description == null || description.trim().isEmpty()) {
description = action.getName();
@ -709,8 +546,11 @@ public class KeyBindingsPanel extends JPanel {
private final String[] columnNames =
{ "Action Name", "KeyBinding", "Plugin Name" };
KeyBindingsTableModel() {
private List<DockingActionIf> actions;
KeyBindingsTableModel(List<DockingActionIf> actions) {
super(0);
this.actions = actions;
}
@Override
@ -725,9 +565,9 @@ public class KeyBindingsPanel extends JPanel {
case ACTION_NAME:
return action.getName();
case KEY_BINDING:
KeyStroke ks = keyStrokesByFullName.get(action.getFullName());
KeyStroke ks = keyBindings.getKeyStroke(action.getFullName());
if (ks != null) {
return KeyEntryTextField.parseKeyStroke(ks);
return KeyBindingUtils.parseKeyStroke(ks);
}
return "";
case PLUGIN_NAME:
@ -738,7 +578,7 @@ public class KeyBindingsPanel extends JPanel {
@Override
public List<DockingActionIf> getModelData() {
return tableActions;
return actions;
}
@Override
@ -758,7 +598,7 @@ public class KeyBindingsPanel extends JPanel {
@Override
public int getRowCount() {
return tableActions.size();
return actions.size();
}
@Override

2
Ghidra/Framework/Project/src/main/java/ghidra/framework/plugintool/mgr/OptionsManager.java
View file

@ -271,7 +271,7 @@ public class OptionsManager implements OptionsService, OptionsChangeListener {
private KeyBindingsPanel panel;
KeyBindingOptionsEditor() {
panel = new KeyBindingsPanel(tool, getOptions(DockingToolConstants.KEY_BINDINGS));
panel = new KeyBindingsPanel(tool);
}
@Override

17
Ghidra/Framework/Project/src/main/java/ghidra/framework/project/tool/GhidraToolTemplate.java
View file

@ -95,19 +95,11 @@ public class GhidraToolTemplate implements ToolTemplate {
return iconURL;
}
/**
* Returns a hash code value for the object. This method is
* supported for the benefit of hashtables such as those provided by
* <code>java.util.Hashtable</code>.
*/
@Override
public int hashCode() {
return getName().hashCode();
}
/**
* Indicates whether some other object is "equal to" this one.
*/
@Override
public boolean equals(Object obj) {
if (obj == null) {
@ -129,13 +121,6 @@ public class GhidraToolTemplate implements ToolTemplate {
return getName().equals(otherTemplate.getName());
}
/**
* Returns a string representation of the object. In general, the
* <code>toString</code> method returns a string that
* "textually represents" this object. The result should
* be a concise but informative representation that is easy for a
* person to read.
*/
@Override
public String toString() {
return getName() + " - " + path;
@ -154,7 +139,7 @@ public class GhidraToolTemplate implements ToolTemplate {
catch (ClassNotFoundException e) {
Msg.warn(this, "Tool supported content class not found: " + className);
}
catch (Exception exc) {//TODO
catch (Exception exc) {
Msg.error(this, "Unexpected Exception: " + exc.getMessage(), exc);
}
}

5
Ghidra/Test/IntegrationTest/src/screen/java/help/screenshot/ToolScreenShots.java
View file

@ -31,7 +31,6 @@ import docking.DialogComponentProvider;
import docking.StatusBar;
import docking.action.DockingActionIf;
import docking.actions.KeyEntryDialog;
import docking.actions.ToolActions;
import docking.options.OptionsService;
import docking.tool.ToolConstants;
import docking.widgets.OptionDialog;
@ -288,10 +287,8 @@ public class ToolScreenShots extends GhidraScreenShotGenerator {
public void testSetKeyBindings() {
tool = env.launchDefaultTool();
ToolActions toolActions = (ToolActions) getInstanceField("toolActions", tool);
DockingActionIf action = getAction(tool, "FunctionPlugin", "Delete Function");
final KeyEntryDialog keyEntryDialog = new KeyEntryDialog(action, toolActions);
final KeyEntryDialog keyEntryDialog = new KeyEntryDialog(tool, action);
runSwing(() -> tool.showDialog(keyEntryDialog), false);
captureDialog();