Handlers

Identifier:

Since:

Description:

The handlers extension point is an elaboration of the experimental handlerSubmission element defined in Eclipse 3.0. A handler is the behaviour of a command at a particular point in time. A command can have zero or more handlers associated with it. At any one point in time, however, a command will either have no active handler or one active handler. The active handler is the one which is currently responsible for carrying out the behaviour of the command. This is very similar to the concept of an action handler and a retargettable action.

The handlers extension point allows a plug-in developer to specify a handler that should become active and/or enabled under certain conditions. If a handler is inactive, then no command will delegate its behaviour to the handler. If a handler is disabled, then the handler will not be asked to execute; execution of the handler is blocked. The conditions are defined using the expression language facility added during 3.0. They are expressed using activeWhen and enabledWhen clauses.

The workbench provides some variables that these expressions can rely on. Variables that are valid in activeWhen and enabledWhen expressions can be found in org.eclipse.ui.ISources. The types of the variables are determined by the org.eclipse.ui.ISourceProvider that provides them.

A handler that specifies no conditions is a default handler. A default handler is only active if no other handler has all of its conditions satisfied. If two handlers still have conditions that are satisfied, then the conditions are compared. The idea is to select a handler whose condition is more specific or more local. To do this, the variables referred to by the condition are looked at. The condition that refers to the most specific variable "wins". The order of specificity (from least specific to most specific) is suggested in org.eclipse.ui.ISources.

If this still doesn't resolve the conflict, then no handler is active. If a particular tracing option is turned on, then this leads to a message in the log. A conflict can also occur if there are two default handlers. It is the responsibility of the plug-in developers and integration testers to ensure that this does not happen.

These conditions are used to avoid unnecessary plug-in loading. These handler definitions are wrapped in a proxy. For a proxy to load its underlying handler, two things must happen: the conditions for the proxy must be met so that it becomes active, and the command must be asked to do something which it must delegate (e.g., execute(), isEnabled()).

Configuration Markup:

<!ELEMENT extension (handler*)>

<!ATTLIST extension

point CDATA #REQUIRED

id    CDATA #IMPLIED

name  CDATA #IMPLIED>

<!ELEMENT handler (activeWhen? , class? , enabledWhen?)>

<!ATTLIST handler

commandId     IDREF #REQUIRED

class         CDATA #IMPLIED

helpContextId CDATA #IMPLIED>

• commandId -

  The id of the command to associate with this handler implementation.

• class -

  The handler class that implements org.eclipse.core.commands.IHandler or extends org.eclipse.core.commands.AbstractHandler.

• helpContextId -

  The identifier of the help context that relates to this specific handler. While a command can provide a general description of a command's behaviour, it is sometimes appropriate for a handler to provide help more specific to their implementation.

  Since: 3.2

<!ELEMENT activeWhen (not | and | or | instanceof | test | systemTest | equals | count | with | resolve | adapt | iterate | reference)>

<!ELEMENT enabledWhen (not | and | or | instanceof | test | systemTest | equals | count | with | resolve | adapt | iterate | reference)>

<!ELEMENT class (parameter*)>

<!ATTLIST class

class CDATA #IMPLIED>

• class -

  The handler class that implements org.eclipse.core.commands.IHandler or extends org.eclipse.core.commands.AbstractHandler.

<!ELEMENT parameter EMPTY>

<!ATTLIST parameter

name  CDATA #REQUIRED

value CDATA #REQUIRED>

• name -

  The parameter name.

• value -

  The parameter value.

Examples:

Variables that are valid in activeWhen and enabledWhen expressions can be found in org.eclipse.ui.ISources. The types of the variables are determined by the org.eclipse.ui.ISourceProvider that provides them.

<extension
 point="org.eclipse.ui.handlers">
 <handler
  commandId="commandId"
  class="org.eclipse.compare.Command">
  <activeWhen>
   <with variable="selection">
    <count value="1" />
    <iterate operator="and">
     <adapt type="org.eclipse.core.resources.IResource" />
    </iterate>
   </with>
  </activeWhen>
 </handler>
 <handler
  commandId="other.commandId"
  class="org.eclipse.ui.TalkToMe">
  <activeWhen>
   <with variable="activePartId">
    <equals value="org.eclipse.ui.views.SampleView"/>
   </with>
  </activeWhen>
 </handler>
</extension>

To further avoid plug-in loading, it is possible to specify when the handler is enabled. If the proxy has not yet loaded the handler, then only the expressions syntax is used to decide if the handler is enabled. If the proxy has loaded the handler, then the expressions syntax is consulted first. If the expressions syntax evaluates to true, then the handler is asked if it is enabled. (This is a short-circuit Boolean "and" operation between the expressions syntax and the handler's enabled state.)

<extension
 point="org.eclipse.ui.handlers">
 <handler
  commandId="commandId"
  class="org.eclipse.Handler">
  <enabledWhen>
   <with variable="activeContexts">
     <iterator operator="or">
       <equals value="org.eclipse.ui.contexts.window"/>
     </iterator>
   </with>
  </enabledWhen>
 </handler>
</extension>

API Information:

All handlers implement org.eclipse.core.commands.IHandler, and can use org.eclipse.core.commands.AbstractHandler as a base class. Within the workbench, it is possible to activate and deactivate handlers using the org.eclipse.ui.handlers.IHandlerService interface. This interface can be retrieved from supporting workbench objects, such as IWorkbench itself, a workbench window, or a part site. To retrieve the service, you would make a call like IWorkbench.getService(IHandlerService.class).

It is also possible to activate and deactive handlers using legacy code in the workbench. This can be done through the legacy mechanism shown below. This mechanism is useful to clients who are using actions to contribute to menus or toolbars. This is deprecated and not recommended.

 IWorkbenchPartSite mySite;
 IAction myAction;
 
 myAction.setActionDefinitionId(commandId);
 IKeyBindingService service = mySite.getKeyBindingService();
 service.registerAction(myAction);

Copyright (c) 2005, 2007 IBM Corporation and others.
This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0 which accompanies this distribution, and is available at https://www.eclipse.org/legal/epl-v20.html/ SPDX-License-Identifier: EPL-2.0