Executing and Updating Actions
The system of actions allows plugins to add their own items to IDEA menus and toolbars. An action is a class, derived from the AnAction class, whose actionPerformed method is called when the menu item or toolbar button is selected. For example, one of the action classes is responsible for the "File | Open File..." menu item and for the "Open File" toolbar button.
Actions are organized into groups, which, in turn, can contain other groups. A group of actions can form a toolbar or a menu. Subgroups of the group can form submenus of the menu.
Every action and action group has an unique identifier. Identifiers of many of the standard IDEA actions are defined in the IdeActions class.
Every action can be included in multiple groups, and thus appear in multiple places within the IDEA user interface. Different places where actions can appear are defined by constants in the ActionPlaces interface. For every place where the action appears, a new
Presentation is created. Thus, the same action can have different text or icons when it appears in different places of the user interface. Different presentations for the action are created by copying the presentation returned by the
To update the state of the action, the method
AnAction.update() is periodically called by IDEA. The object of type
AnActionEvent passed to this method carries the information about the current context for the action, and in particular, the specific presentation which needs to be updated.
To retrieve the information about the current state of the IDE, including the active project, the selected file, the selection in the editor and so on, the method
AnActionEvent.getData() can be used. Different data keys that can be passed to that method are defined in the
AnActionEvent instance is also passed to the
There are two main ways to register an action: either by listing it in the <actions> section of the plugin.xml file, or through Java code.
Registering Actions in plugin.xml
Registering actions in plugin.xml is demonstrated in the following example. The example section of plugin.xml demonstrates all elements which can be used in the <actions> section, and describes the meaning of each element.
Registering Actions from Code
To register an action from code, two steps are required. First, an instance of the class derived from
AnAction must be passed to the
registerAction method of the ActionManager class, to associate the action with an ID. Second, the action needs to be added to one or more groups. To get an instance of an action group by ID, it is necessary to call
ActionManager.getAction() and cast the returned value to the DefaultActionGroup class.
You can create a plugin that registers actions on IDEA startup using the following procedure.
To register an action on IDEA startup
- Create a new class that implements the
- In this class, override the
- Register this class in the <application-components> section of the plugin.xml file.
To clarify the above procedure, consider the following sample Java class
MyPluginRegistration that registers an action defined in a custom
TextBoxes class and adds a new menu command to the Window menu group on the main menu:
Note, that the sample
TextBoxes class is described here .
To ensure that your plugin is initialized on IDEA start-up, make the following changes to the <application-components> section of the plugin.xml file:
Building UI from Actions
If a plugin needs to include a toolbar or popup menu built from a group of actions in its own user interface, that can be accomplished through the
ActionToolbar classes. These objects can be created through calls to
ActionManager.createActionToolbar. To get a Swing component from such an object, simply call the getComponent() method.
If your action toolbar is attached to a specific component (for example, a panel in a toolwindow), you usually need to call
ActionToolbar.setTargetComponent() and pass the instance of the related component as a parameter. This ensures that the state of the toolbar buttons depends on the state of the related component, and not on the current focus location within the IDE frame.