Package org.jdesktop.swingx.action

Contains classes related to the JDNC actions architecture.

See:
Description

Interface Summary

Targetable

An interface which exposes the allowable actions to a TargetManager.

Class Summary

AbstractActionExt	Extends the concept of the Action to include toggle or group states.
ActionContainerFactory	Creates user interface elements based on action ids and lists of action ids.
ActionFactory	A collection of static methods to make it easier to construct Actions.
ActionManager	The ActionManager manages sets of javax.swing.Actions for an application.
BoundAction	A class that represents the many type of actions that this framework supports.
CompositeAction	A class that represents an action which will fire a sequence of actions.
OpenBrowserAction
ServerAction	An action which will invoke an http POST operation.
TargetableAction	A class that represents a dynamically targetable action.
TargetableSupport
TargetManager	The target manager dispatches commands to Targetable objects that it manages.

Package org.jdesktop.swingx.action Description

Contains classes related to the JDNC actions architecture. The Actions architecture maintains the set of user initiated commands (referred to as user actions) in an application. These commands are represented as an Action and have properties like name and icon. The user actions are represented in the user interface by controls like menu items and toolbar buttons.

The other type of actions used by the architecture are the internal swing Actions (refered to as behaviour actions) that are embedded within the ActionMap of a JComponent.

These two types of actions are distinct from each other: user actions have a lot of properties but very little semantics by default (unless explicity bound). Behavior actions have no properties but have semantics. These two types of actions are linked by the action id which is the value of the Action.ACTION_COMMAND_KEY

The AbstractActionExt class extends the Swing concept of the Action by adding support for toggle or two state actions. Toggle type actions may be grouped into a set of mutually exclusive actions. This binary actions are represented in the user interface as JToggleButtons, JCheckBoxMenuItems or JRadioButtonMenuItems.

There are two types of user actions: A BoundAction is an action that will invoke a specific method. It may be bound to an explict component, a callback method on an object instance or one or more listeners. A TargetableAction is an action that doesn't have an explicit binding and the invocation will be sent to an arbitrator (the TargetManager) which dispatches the Action to the "current component" - represented by a Targetable instance. The current component may be explictly set by some programmatic policy (for example, changes in state).

By defalt, the current component will be driven by the focus policy as dictated by the current FocusManager. If the current component cannot handle the action then the action will be dispatched up the containment hierarchy until the action is consumed. If the action is not consumed then it will be dispatched to the Application instance which manages an application global set of actions.

These are the key classes or the actions architecture:

ActionManager

A repository of all shared actions in the application. There will be one instance per application which can be accessed via the Application object (was ClientApp)

ActionContainerFactory

Constructs JMenuBars, JMenus, JPopupMenus and JToolBars using lists of action ids. This functionality may be migrated into ActionManager.

TargetableAction

Represents an unbound Action. The invocation of this action will be dispatched to the TargetManager.

BoundAction

Represents an action which has an exclicit binding.

TargetManager

Manages the targetable policy for actions which have no explicit binding. The policy can be set by changes in application state, event based criteria or whatever. If the policy has not been set then it will dispatch the action to the current focusable component.

Targetable

An interface that contains a few methods which expose actions to the TargetManager. Targetable objects don't have to be visual components they only have to be able to handle action invocations.

Richard Bair