Action Sets

This extension point is deprecated



WARNING: This extension point is DEPRECATED.
Do not use this extension point, it will be removed in future versions of this product. Instead, use the extension point org.eclipse.ui.commands

This extension point is used to add menus, menu items and toolbar buttons to the common areas in the Workbench window. These contributions are collectively known as an action set and appear within the Workbench window by the user customizing a perspective.

You can now use org.eclipse.ui.menus to place commands in menus and toolbars as well.

There is an implementation limitation which currently affects action sets. It is important to define the entire menu structure that is to be referenced within the action set. So, for example, if another action set defines a menu called "example", it is not possible to rely on "example" existing. It is necessary to redefine the "example" menu in every action set that wishes to use it.

An action's enablement and/or visibility can be defined using the elements enablement and visibility respectively, if the extension point supports it. These two elements contain a boolean expression that is evaluated to determine the enablement and/or visibility.

The syntax is the same for the enablement and visibility elements. Both contain only one boolean expression sub-element. In the simplest case, this will be an objectClass, objectState, pluginState, or systemProperty element. In the more complex case, the and, or, and not elements can be combined to form a boolean expression. Both the and, and or elements must contain 2 sub-elements. The not element must contain only 1 sub-element.

Configuration Markup:

<!ELEMENT extension (actionSet+)>

<!ATTLIST extension




The actionSet element is deprecated

<!ELEMENT actionSet (menu* , action*)>

<!ATTLIST actionSet

id          CDATA #REQUIRED

label       CDATA #REQUIRED

visible     (true | false)

description CDATA #IMPLIED>

This element is used to define a group of actions and/or menus.

The action element is deprecated

<!ELEMENT action ((selection* | enablement?) , class?)>

<!ATTLIST action

id               CDATA #REQUIRED

label            CDATA #REQUIRED

accelerator      CDATA #IMPLIED

definitionId     IDREF #IMPLIED

menubarPath      CDATA #IMPLIED

toolbarPath      CDATA #IMPLIED

icon             CDATA #IMPLIED

disabledIcon     CDATA #IMPLIED

hoverIcon        CDATA #IMPLIED

tooltip          CDATA #IMPLIED

helpContextId    CDATA #IMPLIED

style            (push|radio|toggle|pulldown) "push"

state            (true | false)

pulldown         (true | false)

class            CDATA #IMPLIED

retarget         (true | false)

allowLabelUpdate (true | false)

enablesFor       CDATA #IMPLIED

mode             (FORCE_TEXT)

initialEnabled   (true | false) >

This element defines an action that the user can invoke in the UI.

The parameter element is deprecated

<!ELEMENT parameter EMPTY>

<!ATTLIST parameter



A parameter element to be used within an IExecutableExtension element. This will be passed as initialization data to the instantiated class.

The class element is deprecated

<!ELEMENT class (parameter*)>

<!ATTLIST class


The element version of the class attribute. This is used when the class implements org.eclipse.core.runtime.IExecutableExtension and there is parameterized data that you wish used in its initialization.

<!ELEMENT menu (separator* , groupMarker*)>

<!ATTLIST menu





This element is used to defined a new menu.

<!ELEMENT separator EMPTY>

<!ATTLIST separator


This element is used to create a menu separator in the new menu.

<!ELEMENT groupMarker EMPTY>

<!ATTLIST groupMarker


This element is used to create a named group in the new menu. It has no visual representation in the new menu, unlike the separator element.

<!ELEMENT selection EMPTY>

<!ATTLIST selection



This element is used to help determine the action enablement based on the current selection. Ignored if the enablement element is specified.

<!ELEMENT enablement (and | or | not | objectClass | objectState | pluginState | systemProperty)>

This element is used to define the enablement for the extension.

<!ELEMENT visibility (and | or | not | objectClass | objectState | pluginState | systemProperty)>

This element is used to define the visibility for the extension.

<!ELEMENT and (and | or | not | objectClass | objectState | pluginState | systemProperty)>

This element represent a boolean AND operation on the result of evaluating its two sub-element expressions.

<!ELEMENT or (and | or | not | objectClass | objectState | pluginState | systemProperty)>

This element represent a boolean OR operation on the result of evaluating its two sub-element expressions.

<!ELEMENT not (and | or | not | objectClass | objectState | pluginState | systemProperty)>

This element represent a boolean NOT operation on the result of evaluating its sub-element expressions.

<!ELEMENT objectClass EMPTY>

<!ATTLIST objectClass


This element is used to evaluate the class or interface of each object in the current selection. If each object in the selection implements the specified class or interface, the expression is evaluated as true.

<!ELEMENT objectState EMPTY>

<!ATTLIST objectState



This element is used to evaluate the attribute state of each object in the current selection. If each object in the selection has the specified attribute state, the expression is evaluated as true. To evaluate this type of expression, each object in the selection must implement, or adapt to, org.eclipse.ui.IActionFilter interface.

<!ELEMENT pluginState EMPTY>

<!ATTLIST pluginState


value (installed|activated) "installed">

This element is used to evaluate the state of a plug-in. The state of the plug-in may be one of the following: installed (equivalent to the OSGi concept of "resolved") or activated (equivalent to the OSGi concept of "active").

<!ELEMENT systemProperty EMPTY>

<!ATTLIST systemProperty



This element is used to evaluate the state of some system property. The property value is retrieved from the java.lang.System.

The following is an example of an action set (note the sub-elements and the way attributes are used):

    <extension point = "org.eclipse.ui.actionSets"> 
            label="My Actions"> 
               label="XYZ Menu"
               <separator name="group1"/>
               <separator name="option1"/>
               label="&amp;Run XYZ Tool"
               tooltip="Run XYZ Tool" 
               <selection class="org.eclipse.core.resources.IFile" name="*.java"/> 
               label="&amp;Run ABC Tool"
               tooltip="Run ABC Tool"
                     <objectClass name="org.eclipse.core.resources.IFile"/>
                        <objectState name="extension" value="java"/>

               label="&amp;Run DEF Tool"
               tooltip="Run DEF Tool"
               label="&amp;Run GHI Tool"
               tooltip="Run GHI Tool"
               label="&amp;Run JKL Tool"
               tooltip="Run JKL Tool"

In the example above, the specified action set, named "My Actions", is not initially visible within each perspective because the visible attribute is not specified.

The XYZ action will appear as a check box menu item, initially not checked. It is enabled only if the selection count is 1 and if the selection contains a Java file resource.

The ABC action will appear both in the menu and on the toolbar. It is enabled only if the selection does not contain any Java file resources. Note also this is a label retarget action therefore it does not supply a class attribute.

The actions DEF, GHI, and JKL appear as radio button menu items. They are enabled all the time, independent of the current selection state.

API Information:
The value of the class attribute must be the fully qualified name of a class that implements org.eclipse.ui.IWorkbenchWindowActionDelegate or org.eclipse.ui.IWorkbenchWindowPulldownDelegate. The latter should be implemented in cases where the style attribute has the value pulldown. This class is the handler responsible for performing the action. If the retarget attribute is true, this attribute is ignored and should not be supplied. This class is loaded as late as possible to avoid loading the entire plug-in before it is really needed.

The enablement criteria for an action extension is initially defined by enablesFor, and also either selection or enablement. However, once the action delegate has been instantiated, it may control the action enable state directly within its selectionChanged method.

It is important to note that the workbench does not generate menus on a plug-in's behalf. Menu paths must reference menus that already exist.

Action and menu labels may contain special characters that encode mnemonics using the following rules:

  1. Mnemonics are specified using the ampersand ('&') character in front of a selected character in the translated text. Since ampersand is not allowed in XML strings, use &amp; character entity.
If two or more actions are contributed to a menu or toolbar by a single extension the actions will appear in the reverse order of how they are listed in the plugin.xml file. This behavior is admittedly unintuitive. However, it was discovered after the Eclipse Platform API was frozen. Changing the behavior now would break every plug-in which relies upon the existing behavior.

The selection and enablement elements are mutually exclusive. The enablement element can replace the selection element using the sub-elements objectClass and objectState. For example, the following:

can be expressed using:

   <objectClass name="org.eclipse.core.resources.IFile"/>
   <objectState name="extension" value="java"/>

Supplied Implementation:
Plug-ins may use this extension point to add new top level menus. Plug-ins can also define named groups which allow other plug-ins to contribute their actions into them.

Top level menus are created by using the following values for the path attribute:

Omitting the path attribute will result in adding the new menu into the additions menu bar group.

The default groups in a workbench window are defined in the IWorkbenchActionConstants interface. These constants can be used in code for dynamic contribution. The values can also be copied into an XML file for fine grained integration with the existing workbench menus and toolbar.

Various menu and toolbar items within the workbench window are defined algorithmically. In these cases a separate mechanism must be used to extend the window. For example, adding a new workbench view results in a new menu item appearing in the Perspective menu. Import, Export, and New Wizards extensions are also added automatically to the window.

Copyright (c) 2000, 2019 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 SPDX-License-Identifier: EPL-2.0