# Handlers

###### Identifier:

org.eclipse.ui.handlers

###### Since:

3.1

###### 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>

Associated a command with a handler implementation.

- commandId -

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

- class -

  The handler class that imlements `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)>

Contains a core expression used by the `IHandlerService` to determine when this handler is active.

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

Contains a core expression used by the workbench handler proxy to determine when this handler is enabled without loading it.

<!ELEMENT class (parameter*)>

<!ATTLIST class

class CDATA #IMPLIED>

Used when creating an `IExecutableExtension` with a named parameter, or more than one.

- class -

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

<!ELEMENT parameter EMPTY>

<!ATTLIST parameter

name CDATA #REQUIRED

value CDATA #REQUIRED>

A parameter for an `IExecutableExtension`.

- 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.
All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html