Pop-up Menus

This extension point is deprecated

Identifier:

org.eclipse.ui.popupMenus

Description:

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 new actions to context menus owned by other plug-ins. Action contributions may be made against a specific object type (objectContribution) or against a specific context menu of a view or editor part (viewerContribution). When using objectContribution, the contribution will appear in all view or editor part context menus where objects of the specified type are selected. In contrast, using viewerContribution, the contribution will only appear in the specified context menu of a view or editor, regardless of the selection.

You can now use org.eclipse.ui.menus to place commands editor or view contexts menus as well.

When the selection is heterogeneous, the contribution will be applied if registered against a common type of the selection, if possible. If a direct match is not possible, matching against superclasses and superinterfaces will be attempted.

Selection can be further constrained through the use of a name filter. If used, all the objects in the selection must match the filter in order to apply the contribution.

Individual actions in an object contribution can use the attribute enablesFor to specify if it should only apply for a single, multiple, or any other selection type.

If these filtering mechanisms are inadequate an action contribution may use the filter mechanism. In this case the attributes of the target object are described in a series of name-value pairs. The attributes which apply to the selection are type-specific and beyond the domain of the workbench itself, so the workbench will delegate filtering at this level to the actual selection.

The objectContribution element uses the core expression enablement, as defined in org.eclipse.core.expressions.definitions.

Configuration Markup:

<!ELEMENT extension (objectContribution* , viewerContribution*)>

<!ATTLIST extension

point CDATA #REQUIRED

id CDATA #IMPLIED

name CDATA #IMPLIED>

point - a fully qualified identifier of the target extension point
id - an optional identifier of the extension instance
name - an optional name of the extension instance

The objectContribution element is deprecated

<!ELEMENT objectContribution (filter* , visibility? , enablement? , menu* , action*)>

<!ATTLIST objectContribution

id CDATA #REQUIRED

objectClass CDATA #REQUIRED

nameFilter CDATA #IMPLIED

adaptable (true | false) "false">

This element is used to define a group of actions and/or menus for any viewer context menus for which the objects of the specified type are selected. enablement in this element refers to core expression enablement, as defined in org.eclipse.core.expressions.definitions, and affects the enablement of the objectContribution not the contained actions.

id - a unique identifier used to reference this contribution
objectClass - a fully qualified name of the class or interface that all objects in the selection must subclass or implement.
nameFilter - an optional wild card filter for the name that can be applied to all objects in the selection. No contribution will take place if there is no match.
adaptable - a flag that indicates if types that adapt to IResource should use this object contribution. This flag is used only if objectClass adapts to IResource. Default value is false.

The viewerContribution element is deprecated

<!ELEMENT viewerContribution (visibility? , menu* , action*)>

<!ATTLIST viewerContribution

id CDATA #REQUIRED

targetID CDATA #REQUIRED>

This element is used to define a group of actions and/or menus for a specific view or editor part context menu.

id - a unique identifier used to reference this contribution
targetID - the unique identifier of a context menu inside a view or editor part. The ID is defined in the call to getSite().registerContextMenu(*). If not specified when registered, it defaults to the view or editor ID.

The action element is deprecated

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

<!ATTLIST action

id CDATA #REQUIRED

label CDATA #REQUIRED

definitionId IDREF #IMPLIED

menubarPath CDATA #IMPLIED

icon CDATA #IMPLIED

helpContextId CDATA #IMPLIED

style (push|radio|toggle|pulldown)

state (true | false)

class CDATA #REQUIRED

enablesFor CDATA #IMPLIED

overrideActionId IDREF #IMPLIED

tooltip CDATA #IMPLIED>

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

id - a unique identifier used as a reference for this action.
label - a translatable name used as the menu item text. The name can include mnenomic information.
definitionId - This specifies the command that this action is handling. This is used to decide which key binding to display in the pop-up menu.
menubarPath - a slash-delimited path ('/') used to specify the location of this action in the context menu. Each token in the path, except the last one, must represent a valid identifier of an existing menu in the hierarchy. The last token represents the named group into which this action will be added. If the path is omitted, this action will be added to the standard additions group defined by IWorkbenchActionConstants.MB_ADDITIONS.
icon - a relative path of an icon used to visually represent the action in its context. The path is relative to the location of the plugin.xml file of the contributing plug-in.
helpContextId - a unique identifier indicating the help context for this action. On some platforms, if the action appears as a menu item, then pressing the appropriate help key while the menu item is highlighted will display help. Not all platforms support this behaviour.

style - an optional attribute to define the user interface style type for the action. If defined, the attribute value will be one of the following:

	push	- as a regular menu item or tool item.
	radio	- as a radio style menu item or tool item. Actions with the radio style within the same menu or toolbar group behave as a radio set. The initial value is specified by the `state` attribute.
	toggle	- as a checked style menu item or as a toggle tool item. The initial value is specified by the `state` attribute.
	pulldown	- as a cascading style menu item.

state - an optional attribute indicating the initial state (either true or false), used when the style attribute has the value radio or toggle.
class - a name of the fully qualified class that implements org.eclipse.ui.IObjectActionDelegate (for object contributions), org.eclipse.ui.IViewActionDelegate (for viewer contributions to a view part), or org.eclipse.ui.IEditorActionDelegate (for viewer contributions to an editor part). For backwards compatibility, org.eclipse.ui.IActionDelegate may be implemented for object contributions.

enablesFor - a value indicating the selection count which must be met to enable the action. If this attribute is specified and the condition is met, the action is enabled. If the condition is not met, the action is disabled. If no attribute is specified, the action is enabled for any number of items selected. The following attribute formats are supported:

	!	- 0 items selected
	?	- 0 or 1 items selected
	+	- 1 or more items selected
	multiple, 2+	- 2 or more items selected
	n	- a precise number of items selected.a precise number of items selected. For example: enablesFor=" 4" enables the action only when 4 items are selected
	*	- any number of items selected

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

overrideActionId - an optional attribute that specifies the identifier of an action which this action overrides. The action represented by this identifier will not be contributed to the context menu. The action identifier must be from a prerequisite plug-in only. This attribute is only applicable to action elements of an object contribution.
tooltip - a translatable text representing the action's tool tip. Only used if the action appears in the toolbar.

The filter element is deprecated

<!ELEMENT filter EMPTY>

<!ATTLIST filter

name CDATA #REQUIRED

value CDATA #REQUIRED>

This element is used to evaluate the attribute state of each object in the current selection. A match only if each object in the selection has the specified attribute state. Each object in the selection must implement, or adapt to, org.eclipse.ui.IActionFilter.

name - the name of an object's attribute. Acceptable names reflect the object type, and should be publicly declared by the plug-in where the object type is declared.
value - the required value of the object's attribute. The acceptable values for the object's attribute should be publicly declared.

The parameter element is deprecated

<!ELEMENT parameter EMPTY>

<!ATTLIST parameter

name CDATA #REQUIRED

value CDATA #REQUIRED>

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

name - the parameter name
value - the parameter value

The class element is deprecated

<!ELEMENT class (parameter*)>

<!ATTLIST class

class CDATA #IMPLIED>

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.

class - A class that implements one of the interfaces listed for the class attribute. It may also implement org.eclipse.core.runtime.IExecutableExtension.

Examples:

The following is an example of a pop-up menu extension point:


   <extension point="org.eclipse.ui.popupMenus"> 
      <objectContribution 
         id="com.xyz.C1" 
         objectClass="org.eclipse.core.resources.IFile" 
         nameFilter="*.java"> 
         <menu
            id="com.xyz.xyzMenu" 
            path="additions" 
            label="&amp;XYZ Java Tools"> 
            <separator name="group1"/> 
         </menu> 
         <action
            id="com.xyz.runXYZ" 
            label="&amp;Run XYZ Tool"
            style="push"
            menubarPath="com.xyz.xyzMenu/group1" 
            icon="icons/runXYZ.png"
            helpContextId="com.xyz.run_action_context" 
            class="com.xyz.actions.XYZToolActionDelegate" 
            enablesFor="1" /> 
      </objectContribution> 
      <viewerContribution 
         id="com.xyz.C2" 
         targetID="org.eclipse.ui.views.TaskList"> 
         <action
            id="com.xyz.showXYZ" 
            label="&amp;Show XYZ"
            style="toggle"
            state="true"
            menubarPath="additions" 
            icon="icons/showXYZ.png"
            helpContextId="com.xyz.show_action_context" 
            class="com.xyz.actions.XYZShowActionDelegate" /> 
      </viewerContribution> 
   </extension>

In the example above, the specified object contribution action will only enable for a single selection (enablesFor attribute). In addition, each object in the selection must implement the specified interface (IFile) and must be a Java file. This action will be added into a submenu previously created. This contribution will be effective in any view that has the required selection.

In contrast, the viewer contribution above will only appear in the Tasks view context menu, and will not be affected by the selection in the view.

The following is an example of the filter mechanism. In this case the action will only appear for IMarkers which are completed and have high priority.


   <extension point="org.eclipse.ui.popupMenus"> 
      <objectContribution 
         id="com.xyz.C3" 
         objectClass="org.eclipse.core.resources.IMarker"> 
         <filter name="done" value="true"/> 
         <filter name="priority" value="2"/> 
         <action
            id="com.xyz.runXYZ" 
            label="High Priority Completed Action Tool" 
            icon="icons/runXYZ.png"
            class="com.xyz.actions.MarkerActionDelegate"> 
         </action> 
      </objectContribution> 
   </extension>

The following is an other example of using the visibility element:


   <extension point="org.eclipse.ui.popupMenus"> 
      <viewerContribution 
         id="com.xyz.C4" 
         targetID="org.eclipse.ui.views.TaskList">
         <visibility>
            <and>
               <pluginState id="com.xyz" value="activated"/>
               <systemProperty name="ADVANCED_MODE" value="true"/>
            </and>
         </visibility>
         <action
            id="com.xyz.showXYZ" 
            label="&amp;Show XYZ"
            style="push"
            menubarPath="additions" 
            icon="icons/showXYZ.png"
            helpContextId="com.xyz.show_action_context" 
            class="com.xyz.actions.XYZShowActionDelegate"> 
         </action> 
      </viewerContribution> 
   </extension>

In the example above, the specified action will appear as a menu item in the Task view context menu, but only if the "com.xyz" plug-in is active and the specified system property is set to true.

API Information:

The value of the action attribute class must be a fully qualified class name of a Java class that implements org.eclipse.ui.IObjectActionDelegate in the case of object contributions, org.eclipse.ui.IViewActionDelegate for contributions to context menus that belong to views, or org.eclipse.ui.IEditorActionDelegate for contributions to context menus that belong to editors. In all cases, the implementing class is loaded as late as possible to avoid loading the entire plug-in before it is really needed.

Note: For backwards compatibility, org.eclipse.ui.IActionDelegate may be implemented for object contributions.

Conext menu extension within a part is only possible when the target part publishes a menu for extension. This is strongly encouraged, as it improves the extensibility of the product. To accomplish this each part should publish any context menus which are defined by calling IWorkbenchPartSite.registerContextMenu. Once this has been done the workbench will automatically insert any action extensions which exist.

A menu id must be provided for each registered menu. For consistency across parts the following strategy should be adopted by all part implementors.

If the target part has only one context menu it should be registered with id == part id. This can be done easily by calling registerContextMenu(MenuManager, ISelectionProvider). Extenders may use the part id itself as the targetID for the action extension.
If the target part has more than one context menu a unique id should be defined for each. Prefix each id with the part id and publish these id's within the javadoc for the target part. Register each menu at runtime by calling registerContextMenu(String, MenuManager, ISelectionProvider). Extenders will use the unique menu id as the targetID for the action extension.

Any context menu which is registered with the workbench also should contain a standard insertion point with id IWorkbenchActionConstants.MB_ADDITIONS. Other plug-ins will use this value as a reference point for insertion. The insertion point may be defined by adding a GroupMarker to the menu at an appropriate location for insertion.

An object in the workbench which is the selection in a context menu may define an org.eclipse.ui.IActionFilter. This is a filtering strategy which can perform type specific filtering. The workbench will retrieve the filter for the selection by testing to see if it implements IActionFilter. If that fails, the workbench will ask for a filter through the IAdaptable mechanism.

Action and menu labels may contain special characters that encode mnemonics which 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 & character entity.

If two or more actions are contributed to a menu 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:


 <selection
  class="org.eclipse.core.resources.IFile"
  name="*.java">
 </selection>

can be expressed using:


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

Supplied Implementation:

The workbench views have built-in context menus that already come loaded with a number of actions. Plug-ins can contribute to these menus. If a viewer has reserved slots for these contributions and they are made public, slot names can be used as paths. Otherwise, actions and submenus will be added at the end of the pop-up menu.

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