@Override
	public boolean dispatchKeyEvent(KeyEvent event) {

		if (blockKeyInput(event)) {
			return true; // let NO events through!
		}

		// always let Ghidra finish processing key events that it started
		if (actionInProgress(event)) {
			return true;
		}

		// Special case for when we use one of our built-in menu navigation actions. We ignore 
		// docking actions if a menu is open (this is done in action.getEnabledState()).
		if (MenuKeyProcessor.processMenuKeyEvent(event)) {
			return true;
		}

		DockingKeyBindingAction action = getActionForEvent(event);
		if (action == null) {
			return false; // let the normal event flow continue
		}

		// *Special*, System key bindings--these can always be processed and are a higher priority
		Component focusOwner = focusProvider.getFocusOwner();
		ExecutableAction executableAction = action.getExecutableAction(focusOwner);
		if (processSystemActionPrecedence(executableAction, event)) {
			return true;
		}

		if (willBeHandledByTextComponent(event)) {
			return false;
		}

		// Let client programming have the first chance to process the event.  Any key listeners and 
		// actions registered on the focused component are allowed to process the event before our
		// action system.  This allows clients to perform custom event processing without the action
		// system interfering.
		if (processComponentKeyListeners(event)) {
			return true;
		}

		// If there is a registered Java action, let the normal Java event flow process the event.
		// (This will only work as expected if the Java action is registered for key pressed events.
		// If it is registered for released events, and we have a valid and enabled docking action,
		// then the docking action will take precedence, since docking actions are always registered
		// for key pressed events.)
		if (hasJavaAction(event)) {
			return false;
		}

		if (!executableAction.isValid()) {
			// The action is not currently valid for the given focus owner.  Let all key strokes go
			// to Java when we have no valid context.  This allows keys like Escape to work on Java
			// widgets.
			return false;
		}

		if (!executableAction.isEnabled()) {
			// The action is valid, but is not enabled.  At this point we know that the focused 
			// component has no key listeners interested in this event and that the focused 
			// component has no action bindings either.   Stop all further processing for this 
			// event to maintain predictable behavior.
			executableAction.reportNotEnabled(focusOwner);
			return true;
		}

		// Process the key event in precedence order.
		// If it processes the event at any given level, the short-circuit operator will kick out.
		// Finally, if the exception statement is reached, then someone has added a new level
		// of precedence that this algorithm has not taken into account!
		// @formatter:off
		return processActionAtPrecedence(KeyListenerLevel, executableAction, event) ||
			   processActionAtPrecedence(ActionMapLevel, executableAction, event) ||
			   processActionAtPrecedence(DefaultLevel, executableAction, event) ||
			   throwAssertException();
		// @formatter:on
	}
Overridden to change the Java's key event processing to insert Ghidra's top level tool
key bindings into the event processing.  Java's normal key event processing is:
<ol>
    <li>KeyListeners on the focused Component</li>
    <li>InputMap and ActionMap actions for the Component</li>
    <li>InputMap and ActionMap actions for the Component's parent, and so on up the
        Swing hierarchy</li>
</ol>
Ghidra has altered this flow to be:
<ol>
    <li><b>Reserved keybinding actions</b></li>
    <li>KeyListeners on the focused Component</li>
    <li>InputMap and ActionMap actions for the Component</li>
    <li><b>Ghidra tool-level actions</b></li>
    <li>InputMap and ActionMap actions for the Component's parent, and so on up the
        Swing hierarchy</li>
</ol>
This updated key event processing allows individual components to handle key events first,
but then allows global Ghidra key bindings to be processed, allowing normal Java processing
after Ghidra has had its chance to process the event.
<P>
There are some exceptions to this processing chain:
<ol>
     <li>We don't do any processing when the focused component is an instance of
         <code>JTextComponent</code>.</li>
     <li>We don't do any processing if the active window is an instance of
         <code>DockingDialog</code>.</li>
</ol>

@see java.awt.KeyEventDispatcher#dispatchKeyEvent(java.awt.event.KeyEvent)
Ghidra/Framework/Docking/src/main/java/docking/KeyBindingOverrideKeyEventDispatcher.java