RCP：解决Navigator快捷键不生效的问题

自己扩展CNF之后，导航栏的删除、复制、黏贴等快捷键失效了，在网上搜索了半天，结果最终不如自己看源码。

本篇文章的主要目的不止于解决快捷键失效，更在于如何处理类似的问题，如何利用debug快速定位。这种解决问题的思路能帮助我们更加理解他人的代码，快速熟悉一套陌生的框架。

1、理解问题的本质，为什么按键不生效？

在解决快捷键失效问题之前，我们需要理解快捷键是如何生效的。

为了更直观的理解，请使用debug模式打开一个新的Eclipse IDE，然后，对org.eclipse.jdt.internal.ui.refactoring.reorg.CopyToClipboardAction这个类的run方法加上断点。在新的EclipseIDE的Package Explorer上选中一个节点，按CTRL+C

在DEBUG视图中显示如下图所示：

我们过一眼这些类名和方法名，如果你是个有经验的程序员，那么，你应当能敏感的发现WorkbenchKeyboard就是是你需要的那个类。

我们看看executeCommand方法，关键代码标记上了红色。

    final boolean executeCommand(final Binding binding, final Event trigger)
            throws CommandException {
        final ParameterizedCommand parameterizedCommand = binding
                .getParameterizedCommand();

        if (DEBUG) {
            Tracing.printTrace("KEYS", //$NON-NLS-1$
                    "WorkbenchKeyboard.executeCommand(commandId = '" //$NON-NLS-1$
                            + parameterizedCommand.getId() + "', parameters = " //$NON-NLS-1$
                            + parameterizedCommand.getParameterMap() + ')');
        }

        // Reset the key binding state (close window, clear status line, etc.)
        resetState(false);

        // Dispatch to the handler.
        final IHandlerService handlerService = (IHandlerService) workbench
                .getService(IHandlerService.class);
        final Command command = parameterizedCommand.getCommand();
        final boolean commandDefined = command.isDefined();
        final boolean commandHandled = command.isHandled();
        command.setEnabled(handlerService.getCurrentState());
        final boolean commandEnabled = command.isEnabled();

        if (DEBUG && DEBUG_VERBOSE) {
            if (!commandDefined) {
                Tracing.printTrace("KEYS", "    not defined"); //$NON-NLS-1$ //$NON-NLS-2$
            } else if (!commandHandled) {
                Tracing.printTrace("KEYS", "    not handled"); //$NON-NLS-1$ //$NON-NLS-2$
            } else if (!commandEnabled) {
                Tracing.printTrace("KEYS", "    not enabled"); //$NON-NLS-1$ //$NON-NLS-2$
            }
        }

        try {
            handlerService.executeCommand(parameterizedCommand, trigger);
        } catch (final NotDefinedException e) {
            // The command is not defined. Forwarded to the IExecutionListener.
        } catch (final NotEnabledException e) {
            // The command is not enabled. Forwarded to the IExecutionListener.
        } catch (final NotHandledException e) {
            // There is no handler. Forwarded to the IExecutionListener.
        }

        /*
         * Now that the command has executed (and had the opportunity to use the
         * remembered state of the dialog), it is safe to delete that
         * information.
         */
        if (keyAssistDialog != null) {
            keyAssistDialog.clearRememberedState();
        }

        return (commandDefined && commandHandled);
    }

我们发现了binding这个对象。binding的注释如下：

org.eclipse.jface.bindings.Binding

A binding is a link between user input and the triggering of a particular command. The most common example of a binding is a keyboard shortcut, but there are also mouse and gesture bindings. 

看第一段，就能明白，binding是用来做按键和command绑定的，command是最终的执行。

在debug模式下把鼠标放在binding对象上按F2，如下图所示：

相信你已经看到了关键部分，ActionHandler(CopyToClipAction);

是的，只要这里出现了ActionHandler和你的事件，就说明，绑定成功了。反之，则没有。

2、如何建立绑定关系？

通过上面的debug追溯过程，我们发现绑定服务源自org.eclipse.ui.internal.keys.WorkbenchKeyboard.isPartialMatch方法。代码如下：

    /**
     * Determines whether the key sequence partially matches on of the active
     * key bindings.
     *
     * @param keySequence
     *            The key sequence to check for a partial match; must never be
     *            <code>null</code>.
     * @return <code>true</code> if there is a partial match;
     *         <code>false</code> otherwise.
     */
    private boolean isPartialMatch(KeySequence keySequence) {
        return getBindingService().isPartialMatch(keySequence);
    }

getBindingService()方法返回一个IBindingService对象，注释如下，关键部分红色粗体字标注：

Provides services related to the binding architecture (e.g., keyboard shortcuts) within the workbench. This service can be used to access the currently active bindings, as well as the current state of the binding architecture. 

This service can be acquired from your service locator: 

     IBindingService service = (IBindingService) getSite().getService(IBindingService.class);

This service is available globally. 

getSite()指的是workbenchPart.getSite()，返回的是org.eclipse.ui.IWorkbenchPartSite对象。它是视图、编辑器（工作区部件）和工作区的原生接口，用于它们之间的交互协同。

你可以在任何地方得到它。

所以，你只需要使用它来注册你需要绑定的command，即可。

常用command譬如"org.eclipse.ui.edit.delete"，"org.eclipse.ui.edit.copy"

3、更加推荐的方式

很多人为导航器提供了ActionProvider，在默认情况下复制、删除、黏贴等action都会被正确的触发。

如果不行，则需要理解以下几个对象：

a、org.eclipse.jface.action.Action.getActionDefinitionId()

用于匹配commandId，该ID如果和注册了快捷键的commandId匹配，该action的run会被调用。

b、org.eclipse.ui.internal.handlers.IActionCommandMappingService

如果你使用了TextActionHandler之类的工具，你会发现上述内容失效了。

这是因为TextActionHandler对CopyAction等做了多一层封装，这时，你需要使用该类，对actionId和commandId多一次处理。

用于actionId和commandId的绑定，可以通过getSite().getService(IActionCommandMappingService.class)获取

我们可以看以下代码，org.eclipse.ui.SubActionBars.setGlobalActionHandler(String actionID, IAction handler)，关键部分已标注红色：

    public void setGlobalActionHandler(String actionID, IAction handler) {
        if (actionID == null) {
            /*
             * Bug 124061. It used to be invalid to pass null as an action id,
             * but some people still did it. Handle this case by trapping the
             * exception and logging it.
             */
            WorkbenchPlugin
                    .log("Cannot set the global action handler for a null action id"); //$NON-NLS-1$
            return;
        }

        if (handler instanceof CommandLegacyActionWrapper) {
            // this is a registration of a fake action for an already
            // registered handler
            WorkbenchPlugin
                    .log("Cannot feed a CommandLegacyActionWrapper back into the system"); //$NON-NLS-1$
            return;
        }

        if (handler instanceof CommandAction) {
            // we unfortunately had to allow these out into the wild, but they
            // still must not feed back into the system
            return;
        }

        if (handler != null) {
            // Update the action handlers.
            if (actionHandlers == null) {
                actionHandlers = new HashMap(11);
            }
            actionHandlers.put(actionID, handler);

            // Add a mapping from this action id to the command id.
            if (serviceLocator != null) {
                String commandId = null;
                final IActionCommandMappingService mappingService = (IActionCommandMappingService) serviceLocator
                        .getService(IActionCommandMappingService.class);
                if (mappingService != null) {
                    commandId = mappingService.getCommandId(actionID);
                }
                if (commandId == null) {
                    commandId = handler.getActionDefinitionId();
                }

                // Update the handler activations.
                final IHandlerService service = (IHandlerService) serviceLocator
                        .getService(IHandlerService.class);
                Map activationsByActionId = null;
                if (activationsByActionIdByServiceLocator == null) {
                    activationsByActionIdByServiceLocator = new WeakHashMap();
                    activationsByActionId = new HashMap();
                    activationsByActionIdByServiceLocator.put(serviceLocator,
                            activationsByActionId);
                } else {
                    activationsByActionId = (Map) activationsByActionIdByServiceLocator
                            .get(serviceLocator);
                    if (activationsByActionId == null) {
                        activationsByActionId = new HashMap();
                        activationsByActionIdByServiceLocator.put(
                                serviceLocator, activationsByActionId);
                    } else if (activationsByActionId.containsKey(actionID)) {
                        final Object value = activationsByActionId
                                .remove(actionID);
                        if (value instanceof IHandlerActivation) {
                            final IHandlerActivation activation = (IHandlerActivation) value;
                            actionIdByCommandId.remove(activation.getCommandId());
                            if (service != null) {
                                service.deactivateHandler(activation);
                            }
                            activation.getHandler().dispose();
                        }
                    } else if (commandId != null
                            && actionIdByCommandId.containsKey(commandId)) {
                        final Object value = activationsByActionId
                                .remove(actionIdByCommandId.remove(commandId));
                        if (value instanceof IHandlerActivation) {
                            final IHandlerActivation activation = (IHandlerActivation) value;
                            if (service != null) {
                                service.deactivateHandler(activation);
                            }
                            activation.getHandler().dispose();
                        }
                    }
                }

                if (commandId != null) {
                    actionIdByCommandId.put(commandId, actionID);
                    // Register this as a handler with the given definition id.
                    // the expression gives the setGlobalActionHandler() a
                    // priority.
                    final IHandler actionHandler = new ActionHandler(handler);
                    Expression handlerExpression = EXPRESSION;
                    //XXX add new API in next release to avoid down-casting (bug 137091)
                    if (this instanceof EditorActionBars) {
                        handlerExpression = ((EditorActionBars)this).getHandlerExpression();
                    }
                    if (service != null) {
                        final IHandlerActivation activation = service
                                .activateHandler(commandId, actionHandler,
                                        handlerExpression);
                        activationsByActionId.put(actionID, activation);
                    }
                }
            }

        } else {
            if (actionHandlers != null) {
                actionHandlers.remove(actionID);
            }

            // Remove the handler activation.
            if (serviceLocator != null) {
                final IHandlerService service = (IHandlerService) serviceLocator
                        .getService(IHandlerService.class);
                if (activationsByActionIdByServiceLocator != null) {
                    final Map activationsByActionId = (Map) activationsByActionIdByServiceLocator
                            .get(serviceLocator);
                    if ((activationsByActionId != null)
                            && (activationsByActionId.containsKey(actionID))) {
                        final Object value = activationsByActionId
                                .remove(actionID);
                        if (value instanceof IHandlerActivation) {
                            final IHandlerActivation activation = (IHandlerActivation) value;
                            actionIdByCommandId.remove(activation.getCommandId());
                            service.deactivateHandler(activation);
                            activation.getHandler().dispose();
                        }
                    }
                }
            }
        }
        actionHandlersChanged = true;
    }

可以看到，commandId的来源，一是从IActionCommandMappingService，再是从action的getActionDefinitionId()。

如果都不行，再是其他处理（暂不表）。

该方式代码示例如下：

IActionCommandMappingService acms = (IActionCommandMappingService) getViewSite()
                .getWorkbenchWindow().getService(
                        IActionCommandMappingService.class);
        String deleteId = acms.getCommandId("delete");
        if (deleteId == null)
            acms.map("delete", "org.eclipse.ui.edit.delete");