#
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. The variables supported are: the active contexts, the active editor, the active part and the current selection. While not supported in this initial design, it is easy to see how it would be possible to add other variables or even allow plug-in developers to contribute other variables.

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 defined 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()).

###### Configuration Markup:

<!ELEMENT extension (handler)>

<!ATTLIST extension

point CDATA #REQUIRED

id CDATA #IMPLIED

name CDATA #IMPLIED>

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

<!ATTLIST handler

commandId CDATA #REQUIRED

class CDATA #IMPLIED>

- commandId -
- class -

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

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

<!ELEMENT class (parameter)>

<!ATTLIST class

class CDATA #IMPLIED>

- class -

<!ELEMENT parameter EMPTY>

<!ATTLIST parameter

name CDATA #REQUIRED

value CDATA #REQUIRED>

- name -
- value -

###### Examples:

    <code>
    &lt;extension
     point="org.eclipse.ui.handlers"&gt;
     &lt;handler
      commandId="commandId"
      class="org.eclipse.compare.Command"&gt;
      &lt;activeWhen&gt;
       &lt;with variable="selection"&gt;
        &lt;count value="1" /&gt;
        &lt;iterate operator="and"&gt;
         &lt;adapt type="IResource" /&gt;
        &lt;/iterate&gt;
       &lt;/with&gt;
      &lt;/activeWhen&gt;
     &lt;/handler&gt;
    &lt;/extension&gt;
    </code>

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.)

`

    &lt;extension
     point="org.eclipse.ui.handlers"&gt;
     &lt;handler
      commandId="commandId"
      class="org.eclipse.Handler"&gt;
      &lt;enabledWhen&gt;
       &lt;with variable="context"&gt;
        &lt;property
         id="id"
         value="debugging" /&gt;
       &lt;/with&gt;
      &lt;/enabledWhen&gt;
     &lt;/handler&gt;
    &lt;/extension&gt;

`

###### API Information:

All handlers implement `org.eclipse.core.commands.IHandler`. 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. To retrieve the service, you would make a call like `IWorkbench.getAdapter(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.

    <code>
     IWorkbenchPartSite mySite;
     IAction myAction;

     myAction.setActionDefinitionId(commandId);
     IKeyBindingService service = mySite.getKeyBindingService();
     service.registerAction(myAction);
    </code>

Copyright (c) 2005 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