State class represents the state of the simulator, including the contents of registers and memory.
@author Ben L. Titzer
Since this state machine can be used in OpenMap, the Mouse/MouseMotion Listeners are MapMouseListeners. This is to let OpenMap know not to send the result on to other layers that like to hear about events. This State class has a setting on how you want the unused MapMouseListener functions to respond to events. The default is false, and this means that other layers will have a chance to respond to events. If you want other layer's event reception to pause a little, set the mapMouseListenerResponse to true.
Represents a built in, or custom, state in Sea Glass.
Synth provides several built in states, which are:
However, there are many more states that could be described in a LookAndFeel, and it would be nice to style components differently based on these different states. For example, a progress bar could be "indeterminate". It would be very convenient to allow this to be defined as a "state".
This class, State, is intended to be used for such situations. Simply implement the abstract #isInState method. It returns true if the given JComponent is "in this state", false otherwise. This method will be called many times in performance sensitive loops. It must execute very quickly.
For example, the following might be an implementation of a custom "Indeterminate" state for JProgressBars:
<code> public final class IndeterminateState extends State<JProgressBar> { public IndeterminateState() { super("Indeterminate"); } @Override protected boolean isInState(JProgressBar c) { return c.isIndeterminate(); } } </code> Based on Nimbus's State class, which has too much package local stuff.
Each State-derived class is responsible for a particular type of declaration of the grammar. For example, SequenceState is responsible for parsing <sequence> element of RELAX module.
State objects interact each other. There are two ways of interaction.
In this level of inheritance, contract is somewhat abstract.
this class also provides:
Activity-bearing state in the process graph. A State contains a Activity and a sequence of one-or-more Transitions denoting guarded exit paths.
A state can be internal or leaf. @author chato
State as in "State Transition" holds a set of possible future states to transition. It also holds a map of [field name = integer "mask"] to represent permissions (view or edit) that the {@link Role} owning thisstate has for each field for an item which is in this particular state.
For example, consider a state FOO and a role BAR.
When a {@link User} with {@link Role} BAR views an item that is having thestatus FOO: ie. when item.status == FOO.status, the fields that can be viewed on screen will be the entries in FOO.fields where the value == {@link #MASK_READONLY} (1)
NB:This class is parameterised with a generic parameter type only to satisfy the java compiler. The type passed to this generic type MUST be JFrame
The following features are supported:
{@link State}s inherits {@link Transition}s from their parent. A {@link State} can override any of the parents {@link Transition}s. When an {@link Event} is processed the {@link Transition}s of the current {@link State} will be searched for a {@link Transition} whichcan handle the event. If none is found the {@link State}'s parent will be searched and so on.
@author The Apache MINA Project (dev@mina.apache.org) @version $Rev: 586108 $, $Date: 2007-10-18 22:05:07 +0200 (Thu, 18 Oct 2007) $A {@link State} is an executable entity, within the scope of anowning {@link Dialog}. Execution of a {@link State} returns a logicaloutcome (represented as a String), which is used to select the next {@link State} to be executed, via a {@link Transition}.
Specialized subinterfaces of {@link State} are defined for thestandard execution entity types that are supported, including:
view, and returning the logical outcome returned by the action method that processes the subsequent submit.A piece of state information that can be shared between objects, and might be persisted between sessions. This can be used for commands that toggle between two states and wish to pass this state information between different handlers.
This state object can either be used as a single state object shared between several commands, or one state object per command -- depending on the needs of the application.
Clients may instantiate or extend this class.
@since 3.2This interface is not intended to be implemented by clients. The {@link StateObjectFactory} should be used to construct instances.
@since 3.1 @noimplement This interface is not intended to be implemented by clients.A WorkflowWizardPage delegates workflow decisions to a State; we can actually go through the State's without user interaction during a DnD operation; and only pop open the correct WizardPage when interaction is required. @author jesse @since 1.1.0
Each state is associated with exactly one owning flow definition. Specializations of this class capture all the configuration information needed for a specific kind of state.
Subclasses should implement the doEnter method to execute the processing that should occur when this state is entered, acting on its configuration information. The ability to plug-in custom state types that execute different behaviors is the classic GoF state pattern.
Equality: Two states are equal if they have the same id and are part of the same flow. @see org.springframework.webflow.engine.TransitionableState @see org.springframework.webflow.engine.ActionState @see org.springframework.webflow.engine.ViewState @see org.springframework.webflow.engine.SubflowState @see org.springframework.webflow.engine.EndState @see org.springframework.webflow.engine.DecisionState @author Keith Donald @author Erwin Vervaet
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |