Eclipse RCP menus & actions: Configure or code?

Question

This is a general question but my current problem revolves around menu handling.

In a normal plugin with contributes menu actions you would configure ActionSets etc in the plugin.xml configuration. This is obviously sensible.

I am working on a RCP application (actually RAP) and I'm wondering if it's worth the effort to configure everything via plugin.xml. My plugin does not have to interact with an other unknown plugins so, theoretically, I have control. I can add menus and actions programmatically.

I have been trying to configure a menu which contains a submenu. I have tried defining ActionSets and linking one inside the other but without success. Some items need to be disabled depending on the user role.

I figure I could have coded the whole lot in a few minutes but I'm not sure if that fits with the eclipse 'ethos'.

What opinions are out there? The application will get fairly big so I'd like to get the approach right from the start. Perhaps someone can point me at an example for configuring a nested menu :-)

Answer 1

My opinion is that the plugin.xml implementation is the way to go.

My main two reasons for using this method:

• It's really easy to reconfigure and reorganize the menus and buttons without writing java code.
• Very clear hierarchical visualization of the menu trees.

Here is a code snippet that implements menus and submenus. In this example, they are added to the main menu.

You can paste this into your plugin.xml:

<extension
         name="Main Menu Contributions"
         point="org.eclipse.ui.menus">
 <menuContribution
        allPopups="false"
        locationURI="menu:org.eclipse.ui.main.menu">
     <menu
           id="fileMenu"
           label="File">
        <command
              commandId="org.eclipse.ui.file.exit"
              label="Exit"
              style="push">
        </command>
     </menu>
     <menu
           label="Edit">
        <command
              commandId="org.eclipse.ui.edit.selectAll"
              label="Select All"
              style="push">
        </command>
        <menu
              label="Submenu">
           <command
                 commandId="org.eclipse.ui.edit.selectAll"
                 label="Select All Submenu"
                 style="push">
           </command>
           <command
                 commandId="org.eclipse.ui.edit.delete"
                 label="Delete submenu"
                 style="push">
           </command>
        </menu>
     </menu>
  </menuContribution>
</extension>

For activating/deactivating a menu, you have to use Core Expressions to enable/disable command handlers. If a command doesn't have any active handlers attached, it will be disabled. So, the menu item that calls that command will also be disabled.

The following code snippets show how to create a button on the toolbar of a view and have it be enabled/disabled depending of a variable's value. Bare in mind that you will have to change some things in this code to make it work. Most of the changes are for reference names and class implementation.

Create the button in the toolbar (plugin.xml):

   <extension
         name="View Toolbar Contributions"
         point="org.eclipse.ui.menus">
      <menuContribution
            allPopups="false"
            locationURI="toolbar:myapp.views.MyView">
       <command
             commandId="myapp.commands.PauseSound"
             icon=""
             label="Pause Playback Sound"
             style="push"
             tooltip="Pause">
       </command>
     </menuContribution>
</extension>

Create the command (plugin.xml):

<extension
         id="myapp.commands.PauseSound"
         name="Pause sound command"
         point="org.eclipse.ui.commands">
      <command
            id="myapp.commands.PauseSound"
            name="Pause Sound">
      </command>
</extension> 

Create the command handler (plugin.xml):

<extension
         point="org.eclipse.ui.handlers">
      <handler
            commandId="myapp.commands.PauseSound">
         <activeWhen>
            <with
                  variable="myapp.commands.sourceprovider.active">
               <or>
                  <equals
                        value="PLAYING">
                  </equals>
                  <equals
                        value="PAUSED">
                  </equals>
               </or>
            </with>
         </activeWhen>
         <class
               class="myapp.rcp.commands.toolbar.PausePlayback">
         </class>
      </handler>
</extension> 

Create the state variable for the command (plugin.xml):

   <extension
         point="org.eclipse.ui.services">
      <sourceProvider
            provider="myapp.commands.sourceprovider.CommandState">
         <variable
               name="myapp.commands.sourceprovider.active"
               priorityLevel="workbench">
         </variable>
      </sourceProvider>
   </extension>

Implement the class that changes the variable's state:

public class CommandState extends AbstractSourceProvider {
    public final static String STATE = "myapp.commands.sourceprovider.active";
    public final static String STOPPED = "STOPPED";
    public final static String PLAYING = "PLAYING";
    public final static String PAUSED = "PAUSED";
    public final static String NOT_LOADED = "NOT_LOADED";

enum State {
        NOT_LOADED, PLAYING, PAUSED, STOPPED
    };
    private State curState = State.NOT_LOADED;

    @Override
    public void dispose() {
    }

    @Override
    public String[] getProvidedSourceNames() {
        return new String[] { STATE };
    }

    // You cannot return NULL
    @SuppressWarnings("unchecked")
    @Override
    public Map getCurrentState() {
        Map map = new HashMap(1);
        if (curState == State.PLAYING)
            map.put(STATE, PLAYING);
        else if (curState == State.STOPPED)
            map.put(STATE, STOPPED);
        else if (curState == State.PAUSED)
            map.put(STATE, PAUSED);

        return map;
    }

    public void setPlaying() {
        fireSourceChanged(ISources.WORKBENCH, STATE, PLAYING);
    }

    public void setPaused() {
        fireSourceChanged(ISources.WORKBENCH, STATE, PAUSED);
    }

    public void setStopped() {
        fireSourceChanged(ISources.WORKBENCH, STATE, STOPPED);
    }

    public void setNotLoaded() {
        fireSourceChanged(ISources.WORKBENCH, STATE, NOT_LOADED);
    }

}

More details on how to implement these features can be found at these locations:

• Eclipse Commands Tutorial
• Limiting Visibility of Commands

Answer 2

For Eclipse there are two different ways to contributing to the Workbench: Actions and Commands.

I definitely recommend the Commands as the newer and more advanced than Actions. The drawbacks of Actions as specified here (1):

• The UI and handling are always tied. There is no way you can separate each other

• While Actions can be contributed to different parts of the workbench (popup menu/tool bar), all of them were different extension points and so you end up duplicating the XML in multiple places. The worst of it is that not all the extension points expect the same configuration.

• Specifying Actions in multiple places is a maintenance nightmare. If you have to change the icon of an action, you need to change in all the places.

• Another issue with duplicating Actions in plugin.xml is that multiple instance of the same Actions will be created in the memory

  (1) Actions vs Commands