All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| AbstractActionDataTag |
An abstract base class for tag handler classes that need to deal with action
objects and their properties.
|
| AbstractBeanTag |
An abstract base class for tag handler implementations that create bean
providers.
|
| AbstractCompositeComponentHandler<T,S> |
|
| AbstractDecimalTransformer<T extends Number> |
A base class for number transformers that operate on floating point numbers.
|
| AbstractDialogOptions<T,S extends AbstractDialogOptions<T,S>> |
An abstract base class for options classes for standard dialogs.
|
| AbstractEventFilter |
An abstract base class for event filters.
|
| AbstractFileChooserOptions<T,S extends AbstractFileChooserOptions<T,S>> |
An abstract base class for the options of file chooser dialogs.
|
| AbstractIntegerTransformer<T extends Number> |
A base class for number transformers that operate on integer numbers.
|
| AbstractLocator |
An adapter class for implementing concrete Locator classes.
|
| AbstractPopupMenuBuilder |
An abstract base class for implementations of the PopupMenuBuilder
interface.
|
| AbstractRadioButtonHandler<T> |
A base class for ComponentHandler implementations for radio buttons.
|
| AbstractStreamLocator |
An abstract base class for Locator implementations that mainly
operate on streams.
|
| Accelerator |
A class that represents an accelerator for invoking an action.
|
| AccessibleComposite |
An extended version of the Composite interface which also allows
access to the data passed via the mutating methods.
|
| ActionBuilder |
A central data class used during the action builder process.
|
| ActionBuilderTagLibrary |
The tag library for the action builder tags.
|
| ActionContainer |
Definition of an interface for objects with container facilities.
|
| ActionControlTag |
Definition of an abstract base class for tag handler classes that create
controls, which can be associated with actions.
|
| ActionData |
Definition of an interface for describing properties of an action.
|
| ActionDataImpl |
A straight forward implementation of the ActionData interface.
|
| ActionDataTag |
A simple tag for creating objects of type
ActionData.
|
| ActionEnabler |
A specialized implementation of the ElementEnabler interface that can
change the enabled state of actions.
|
| ActionGroupEnabler |
A specialized implementation of the ElementEnabler interface that can
change the enabled state of action groups.
|
| ActionHelper |
A helper class for dealing with actions.
|
| ActionInvoker |
A class that allows to combine actions with event listeners.
|
| ActionListenerTag |
A specific form event listener tag implementation that deals with action
listeners.
|
| ActionManager |
Definition of an interface for a component that creates GUI library specific
action objects and related classes.
|
| ActionManagerWrapper |
A base class for wrapper implementations of the ActionManager
interface.
|
| ActionStore |
A class for maintaining action objects.
|
| ActionTag |
A tag handler class for creating action objects.
|
| ActionTask |
Definition of an interface for the task of an action.
|
| ActionTaskTag |
A simple tag for specifying task objects for actions.
|
| AndEventFilter |
A specialized chained filter implementation that provides an AND or ALL
semantics.
|
| AndEventFilterTag |
A specialized ChainedEventFilter implementation that creates
an
AndEventFilter.
|
| Application |
The main startup class of the GUI application framework.
|
| ApplicationBuilderData |
The application specific default implementation of the BuilderData
interface.
|
| ApplicationClient |
Definition of an interface for objects that need a reference to the central
Application object.
|
| ApplicationContext |
Definition of an interface for accessing application global information.
|
| ApplicationContextImpl |
A default implementation of the ApplicationContext interface.
|
| ApplicationException |
An exception class that indicates error conditions related to the
Application class.
|
| ApplicationResources |
A class defining constants for default resources provided by the application
framework.
|
| ApplicationResources.Keys |
An enumeration class defining the keys of all resources contained within
the application default resource bundle.
|
| ApplicationRuntimeException |
An exception class for reporting runtime exceptions that are related to
Application objects or operations invoked on them.
|
| ApplicationShutdownActionTask |
A specialized action task for exiting the current application.
|
| ApplicationShutdownListener |
Definition of an interface for listeners that want to be notified when the
application terminates.
|
| AutoReleaseListener |
A specialized WindowListener implementation for implementing the
auto release mechanism supported by builders.
|
| BeanBindingStrategy |
An implementation of the BindingStrategy interface that operates on
Java beans.
|
| BeanBuilder |
Definition of an interface for processing scripts with bean definitions.
|
| BeanBuilderFactory |
Definition of an interface for querying new BeanBuilder
objects.
|
| BeanBuilderResult |
Definition of an interface for accessing the results of a BeanBuilder.
|
| BeanContext |
Definition of an interface that allows access to the beans managed by the
dependency injection framework.
|
| BeanContextClient |
Definition of an interface to be implemented by beans that need a reference
to the current BeanContext.
|
| BeanContextWrapper |
A simple wrapper implementation of the BeanContext interface.
|
| BeanCreationEvent |
An event class for reporting the creation of a bean by the dependency
injection framework.
|
| BeanCreationListener |
Definition of an interface for objects that are interested in the creation of
beans by a BeanContext.
|
| BeanInitializer |
Definition of an interface for objects that perform some kind of
initialization on beans that are managed by a
BeanContext.
|
| BeanProvider |
Definition of an interface for objects that provide access to beans.
|
| BeanStore |
Definition of an interface for objects that provide access to bean
definitions.
|
| BeanStoreTag |
A tag handler class for creating new BeanStore instances.
|
| BeanTag |
The main tag of the tag library for the dependency injection
framework: with this tag bean definitions can be created.
|
| BindingStrategy |
Definition of an interface for objects that are responsible of the binding of
form fields to model objects.
|
| BorderConstraintsTag |
A special tag handler implementation for creating constraints object for a
BorderLayout.
|
| BorderLayout |
A GUI library independent implementation of the AWT layout manager
BorderLayout.
|
| BorderLayoutTag |
|
| Builder |
The main builder interface.
|
| BuilderData |
Definition of an interface that describes the parameters of a builder
operation.
|
| BuilderEvent |
The base class of events used in the form and form builder framework.
|
| BuilderException |
An exception class for reporting error conditions related to the GUI builder.
|
| BundleResourceLoader |
A specialized implementation of the ResourceLoader interface that
make use of the default Java resource bundles.
|
| ButtonLayout |
A layout manager that deals with button bars for dialogs.
|
| ButtonLayout.Alignment |
An enumeration class for the alignment of a ButtonLayout.
|
| ButtonLayoutTag |
|
| ButtonTag |
A specific tag handler class for creating command button components.
|
| ByteArrayLocator |
A specialized Locator implementation that provides access to data
stored in memory as a byte array.
|
| CellAlignment |
An enumeration class that defines the possible alignments of components in
the cells of a percent layout.
|
| CellConstraints |
A class for describing column and row constraints for the
PercentLayout layout manager.
|
| CellConstraints.Builder |
A builder class for creating instances of
CellConstraints.
|
| CellGroup |
A simple helper class to define columns and rows with identical size in
PercentLayout.
|
| CellSize |
An enumeration class that defines possible sizes for the cells of a
percent layout.
|
| ChainedEventFilter |
An abstract base class for filters that operate on multiple filters.
|
| ChainedEventFilterTag |
A specialized event filter class that deals with chained filters, i.e. event
filters that can child event filters.
|
| ChainedInvocation |
A special implementation of the Invokable interface that
allows aggregating an arbitrary number of Invokable objects to
a kind of script.
|
| ChainElementEnabler |
A specialized implementation of the ElementEnabler interface that
maintains an arbitrary number of other ElementEnabler objects.
|
| ChainValidator |
A special Validator implementation that allows combining multiple
primitive validators.
|
| ChangeListenerTag |
A specific form event listener tag implementation that deals with change
listeners.
|
| CheckboxTag |
A specific input component tag for creating a checkbox.
|
| ClassDependency |
An implementation of the Dependency interface that allows to
define a dependency based on a bean class.
|
| ClassDescData |
A simple data class for managing the components needed for a class
description.
|
| ClassDescription |
A helper class for defining references to classes.
|
| ClassEventFilter |
A specialized EventFilter implementation that filters by an
event class.
|
| ClassLoaderProvider |
Definition of an interface for objects that act as a registry for class
loaders.
|
| ClassPathLocator |
A specific Locator implementation that can obtain resources from
the class path.
|
| CollectionBeanProvider |
An abstract base class for BeanProvider implementations that
create beans derived from collections.
|
| CollectionTag |
A base tag handler class for defining collections in bean builder scripts.
|
| Color |
A simple class representing a color in a platform-independent way.
|
| ColorFieldMarker |
|
| ColorHelper |
A helper class for dealing with colors.
|
| ColorHelper.NamedColor |
An enumeration with predefined color constants.
|
| ColumnClass |
An enumeration class that defines logic column classes.
|
| ColumnComponentTag |
An abstract base class for tags that define renderers or editors for the
columns of a table.
|
| ColumnEditorTag |
A tag for defining the editor of a column within a table.
|
| ColumnRendererTag |
A tag for defining the renderer of a column within a table.
|
| CombinedBeanStore |
A specialized implementation of the BeanStore interface that combines
multiple physical BeanStore objects to a single logic view.
|
| ComboBoxTag |
A specific input component tag that creates a combo box component.
|
| Command |
Definition of an interface for command objects.
|
| CommandActionTask |
A specialized action task that executes a Command object.
|
| CommandBase |
An abstract base class for implementations of the Command
interface.
|
| CommandQueue |
Definition of an interface that describes a command queue.
|
| CommandQueueEvent |
An event class for notifying listeners about the state of a
CommandQueue.
|
| CommandQueueEvent.Type |
An enumeration for the types supported by the
CommandQueueEvent class.
|
| CommandQueueImpl |
A command queue implementation for GUI applications.
|
| CommandQueueListener |
Definition of an interface for listeners that want to be notified about
changes in the state of a CommandQueue object.
|
| CommandWrapper |
A wrapper implementation of the Command interface.
|
| ComponentBaseTag |
An abstract base class for tags that create GUI components.
|
| ComponentBuilderCallBack |
An interface for describing call back operations that can be registered at
the central builder data object.
|
| ComponentBuilderData |
A class for storing temporary data and the results of a form builder
operation.
|
| ComponentEnabler |
A specialized implementation of the ElementEnabler interface that can
change the enabled state of components.
|
| ComponentGroup |
This class represents a group of components.
|
| ComponentGroupTag |
A tag for constructing (logic) groups of components.
|
| ComponentHandler<T> |
Definition of an interface for accessing GUI components independently from
their type.
|
| ComponentHandlerImpl |
A simple default implementation of the ComponentHandler
interface.
|
| ComponentHandlerTag |
|
| ComponentManager |
Definition of an interface to a concrete GUI manager.
|
| ComponentManagerWrapper |
|
| ComponentStore |
Definition of an interface for objects that are able to manage entities
related to a Form object.
|
| ComponentStoreImpl |
A fully functional default implementation of the ComponentStore
interface.
|
| Composite |
Definition of an interface for components that can contain other components.
|
| CompositeComponentHandler<T,S> |
Definition of an interface for complex component handlers that can contain
other component handlers.
|
| CompositeImpl |
A straight-forward implementation of the Composite interface.
|
| ConditionalTag |
Definition of an interface for tags that are only executed for certain
builders.
|
| ConstantBeanProvider |
A concrete implementation of the BeanProvider interface that
will always return the same bean instance.
|
| ConstantValueTag |
A specialized tag handler implementation for resolving values of constant
fields.
|
| ConstraintsTag |
An abstract base class for creating layout constraints objects.
|
| ConstructorBeanProvider |
A simple bean provider that creates new bean instances by invoking a
constructor.
|
| ConstructorInvocation |
A class that represents a constructor invocation.
|
| ConstructorInvocationTag |
|
| ConstructorTag |
A specialized constructor invocation tag that is intended to be used inside a
<bean> tag for defining the BeanProvider
for creating the managed bean.
|
| ContainerSelector |
An interface for a component responsible for obtaining a container object.
|
| ContainerTag |
A specific tag handler implementation for creating container tags.
|
| ContextBeanTag |
A specialized tag for the creation of beans from objects stored in the Jelly
context.
|
| ConversionHelper |
A helper class providing functionality related to data type conversion and
registration of custom converters.
|
| ConverterTag |
A specialized tag handler class for adding custom data type converters in a
builder script.
|
| DateTimeTransformer |
A specialized transformer that transforms strings into date objects with both
a date and time component.
|
| DateTransformer |
A specialized transformer that transforms strings into date objects.
|
| DateTransformerBase |
An abstract base class for date transformer objects.
|
| DefaultBeanContext |
A default implementation of the BeanContext interface.
|
| DefaultBeanStore |
A simple yet fully functional default implementation of the
BeanStore interface.
|
| DefaultClassLoaderProvider |
A default implementation of the ClassLoaderProvider interface.
|
| DefaultContainerSelector |
A default implementation of the ContainerSelector interface.
|
| DefaultFieldHandler |
A default implementation of the FieldHandler interface.
|
| DefaultFieldHandlerFactory |
A default implementation of the FieldHandlerFactory interface.
|
| DefaultFormValidatorResults |
Default implementation of the FormValidatorResults interface.
|
| DefaultRadioButtonHandler |
A concrete default implementation of a CompositeComponentHandler for
a group of radio buttons.
|
| DefaultTableEditorValidationHandler |
A default implementation of the TableEditorValidationHandler
interface.
|
| DefaultToolTipManager |
A default implementation of the ToolTipManager interface.
|
| DefaultTransformerWrapper |
A default implementation of the TransformerWrapper interface.
|
| DefaultValidationMessageHandler |
A default implementation of the ValidationMessageHandler interface.
|
| DefaultValidationResult |
A default implementation of the ValidationResult interface.
|
| DefaultValidationResult.Builder |
A builder class for creating instances of
DefaultValidationResult.
|
| DefaultValidatorWrapper |
A default implementation of the ValidatorWrapper interface.
|
| Dependency |
Definition of an interface for describing a dependency to another
BeanProvider in an abstract way.
|
| DependencyProvider |
Definition of an interface that provides access to dependencies defined by a
BeanProvider.
|
| DependencyTag |
A base class for tag handler classes that support the definition of a
dependency.
|
| DesktopPanelTag |
A specific container tag implementation that creates a desktop panel.
|
| DesktopPanelTag.DragMode |
Enumeration class that defines the allowed values for the
dragmode attribute.
|
| DialogCanceledCallback<D> |
A callback interface to notify a client that the user has canceled a standard
dialog.
|
| DialogResultCallback<T,D> |
A callback interface for handling the result of a standard dialog.
|
| DialogServiceFactory<T> |
A factory interface for the creation of a dialog service.
|
| DialogTag |
A tag handler class for creating dialogs.
|
| DIBuilderData |
A data class for maintaining all information required for a DI builder
operation.
|
| DirectoryChooserOptions |
A class for defining the options of a directory chooser dialog.
|
| DITagLibrary |
The tag library for the tags of the dependency injection framework.
|
| DoubleTransformer |
A specialized number transformer implementation that deals with numbers of
type java.lang.Double.
|
| DummyBindingStrategy |
A dummy implementation of the BindingStrategy interface.
|
| DummyTransformer |
This class provides dummy implementations for the Transformer
and the Validator interfaces.
|
| DummyWrapper |
A dummy implementation of the TransformerWrapper and the
ValidatorWrapper interfaces.
|
| EditableComboBoxModel |
Definition of a specialized ListModel extension interface to be used
by editable combo boxes.
|
| ElementEnabler |
Definition of an interface to be implemented by components that can change
the enabled state of specific elements.
|
| ElementTag |
A tag handler class that allows adding elements to collections.
|
| EnablerBuilder |
A helper class for the convenient creation of standard ElementEnabler
objects.
|
| EnablerConverter |
|
| EntryKeyTag |
A tag handler class for defining the key of an EntryTag.
|
| EntryTag |
A tag handler implementation for populating a map.
|
| EnumConverter |
A specialized Converter implementation dealing with all types of
enumeration classes.
|
| EventFilter |
Definition of an interface for filtering events.
|
| EventFilterTag |
A specialized tag handler class for creating event filters.
|
| EventListenerTag |
A base class for event listener tags.
|
| EventListenerTypeTag |
A specialized tag handler implementation that allows adding another event
listener type to a FormEventListenerTag.
|
| EventRegistrationTag |
A tag handler class for registering an event listener at a single or multiple
components.
|
| FactoryBeanProvider |
A specialized life-cycle supporting BeanProvider
implementation for creating new bean instances on each invocation.
|
| FactoryTag |
A tag for defining a bean factory that is used as creation
BeanProvider for a BeanTag.
|
| FieldHandler |
Definition of an interface for accessing fields of a form.
|
| FieldHandlerFactory |
Definition of an interface for objects that are able to create
FieldHandler
objects.
|
| FieldTag |
A specific input component tag that allows to make use of custom input
components.
|
| FieldValidationStatus |
An enumeration class describing the possible validation status values of a
form field.
|
| FileChooserDialogService |
An interface for a service that allows the creation of standard dialogs for
choosing files and directories.
|
| FileChooserOptions |
A class for defining the options of a file chooser dialog.
|
| FileExtensionFilter |
A class representing an extension filter that can be used together with the
file chooser service.
|
| FileLocator |
A concrete Locator class that represents files.
|
| FloatTransformer |
A specialized number transformer implementation that deals with numbers of
type java.lang.Float.
|
| FocusListenerTag |
A specific form event listener tag implementation that deals with focus
listeners.
|
| FontTag |
A specialized tag handler class for creating fonts.
|
| Form |
This class represents a form.
|
| FormAction |
An interface describing an action.
|
| FormActionEvent |
A specific event class for dealing with action events.
|
| FormActionException |
An exception class indicating a problem with the form action framework.
|
| FormActionListener |
Definition of an interface for action listeners.
|
| FormBaseTag |
A base class for tags of the form builder framework.
|
| FormBuilderException |
An exception class for reporting errors of the form builder framework.
|
| FormBuilderRuntimeException |
An exception class for reporting runtime errors of the form builder
framework.
|
| FormBuilderTagLibrary |
The tag library for the form builder tags.
|
| FormChangeEvent |
A specific event class for change events.
|
| FormChangeListener |
Definition of an interface for change listeners.
|
| FormContextListener |
An event listener interface to be implemented by components that are
interested in the creation of new form contexts during a builder operation.
|
| FormController |
A base class for form controllers.
|
| FormControllerEvent |
|
| FormControllerFieldStatusEvent |
A specialized FormControllerEvent class that is generated whenever a
form field changes its visited status.
|
| FormControllerFieldStatusListener |
A specialized event listener interface to be implemented by objects that are
interested in status updates of form fields.
|
| FormControllerFormEvent |
A specialized FormControllerEvent class for events related to the
form associated with a FormController.
|
| FormControllerFormEvent.Type |
An enumeration class defining the possible types of
FormControllerFormEvent events.
|
| FormControllerFormListener |
|
| FormControllerListenerTag |
A specialized tag handler class that can be used to register listeners at a
FormController.
|
| FormControllerTag |
A specialized tag handler implementation for creating form controllers.
|
| FormControllerValidationEvent |
A specialized FormControllerEvent class that is generated when the
controller performs a validation.
|
| FormControllerValidationListener |
Definition of an interface to be implemented by objects that are interested
in validation operations performed by a FormController.
|
| FormEvent |
An event class used in the form and form builder framework to deliver event
information related to form elements (controls or input components).
|
| FormEventListener |
Base interface for listeners for form events.
|
| FormEventListenerTag |
A base class for event listener tag handler classes that deal with event
listeners for form events.
|
| FormEventManager |
The main class for event handling in the form framework.
|
| FormFocusEvent |
A specific event class dealing with focus events.
|
| FormFocusEvent.Type |
An enumeration class defining the different types of focus events.
|
| FormFocusListener |
Definition of an interface for focus listeners.
|
| FormListenerType |
An enumeration class describing the supported event listener types.
|
| FormMouseEvent |
A specialized event class for reporting events related to mouse actions.
|
| FormMouseEvent.Type |
An enumeration class defining constants for the possible mouse actions
that can trigger a FormMouseEvent.
|
| FormMouseListener |
Definition of interface for mouse listeners.
|
| FormRuntimeException |
An exception class for reporting runtime exceptions related to the form
framework.
|
| FormValidationMessageFormat |
|
| FormValidationTrigger |
Definition of an interface for objects that can trigger the validation of a
form.
|
| FormValidationTriggerFocus |
A specialized FormValidationTrigger implementation that triggers a
validation operation whenever the user leaves an input field.
|
| FormValidationTriggerNone |
A specialized implementation of a FormValidationTrigger that
does no triggering at all.
|
| FormValidator |
Definition of an interface for objects that can validate forms.
|
| FormValidatorResults |
Definition of an interface for describing results of a form validation.
|
| FrameTag |
A tag handler class for creating (main) frame windows.
|
| GUIRuntimeException |
An exception class for reporting GUI related runtime errors.
|
| GUISynchronizer |
Definition of an interface that supports updating GUI components from
different threads.
|
| HelperInvocations |
An enumeration class defining some simple helper Invokable
implementations.
|
| IconSupport |
Definition of an interface for GUI components that support icons.
|
| IconTag |
A tag for adding an icon to a component.
|
| InjectionException |
An exception class for reporting exceptions related to dependency injection.
|
| InputComponentTag |
A base class for tag handler classes that create input components.
|
| IntegerTransformer |
A specialized number transformer implementation that deals with numbers of
type java.lang.Integer.
|
| InternalFrameTag |
A tag handler class for creating internal frames.
|
| InvariantWindowClosingStrategy |
A very simple implementation of the WindowClosingStrategy
interface.
|
| InverseEnabler |
A specialized implementation of the ElementEnabler interface that
wraps another ElementEnabler and inverses the
setEnabledState() implementation of this wrapped enabler.
|
| Invocation |
A base class for (method or constructor) invocations.
|
| InvocationHelper |
A helper class providing some more complex functionality related to
reflection.
|
| InvocationTag |
A base class for tag handler classes defining invocation objects.
|
| InvocationTargetTag |
A specialized tag handler implementation for defining the target object of a
method invocation.
|
| Invokable |
Definition of an interface for objects that perform some kind of method
invocation.
|
| JellyBeanBuilder |
An implementation of the BeanBuilder interface that is able to
process bean definitions defined in a Apache Commons Jelly script.
|
| JellyBeanBuilderFactory |
An implementation of the BeanBuilderFactory interface that
returns JellyBeanBuilder instances.
|
| JellyBuilder |
An implementation of the Builder interface that uses Commons Jelly for processing build
scripts and creating GUI components.
|
| JellyContextBeanStore |
A specialized implementation of the BeanStore interface that
is backed by a Jelly context.
|
| Keys |
An enumeration class defining constants for special keys on a standard
keyboard.
|
| LabelTag |
A tag class for creating labels.
|
| LayoutTag |
A base tag handler class for layout tags.
|
| LifeCycleBeanProvider |
An abstract base class for BeanProvider implementations with
life-cycle support.
|
| ListBeanProvider |
A specific CollectionBeanProvider implementation that creates
a list bean.
|
| ListBoxTag |
A specific input component tag that creates a list box component.
|
| ListComponentHandler |
A specialized component handler interface for components with list-like
structures.
|
| ListModel |
Definition of an interface that is used to obtain the content of a list box
or combo box component.
|
| ListModelItemTag |
A tag handler class that creates an item for a list model.
|
| ListModelSupport |
Definition of an interface for tags that support a list model.
|
| ListModelUtils |
A helper class for dealing with model objects.
|
| ListTag |
A specialized CollectionTag implementation for creating lists.
|
| LocalizedTag |
A specialized tag handler class for loading localized texts and passing them
to tags implementing the ValueSupport interface.
|
| Locator |
Definition of the base Locator interface.
|
| LocatorConverter |
A specialized Converter implementation dealing with Locator
objects.
|
| LocatorException |
An exception class for reporting error conditions related to
Locator objects.
|
| LocatorUtils |
A helper class for locating resources.
|
| LocatorWrapper |
A wrapper implementation for locators.
|
| LongTransformer |
A specialized number transformer implementation that deals with numbers of
type java.lang.Long.
|
| MapBeanProvider |
A specialized BeanProvider implementation for creating beans of
type java.util.Map.
|
| MapTag |
A specialized BeanTag implementation for creating maps.
|
| MenuBarTag |
A tag handler class for creating menu bars.
|
| MenuItemTag |
A tag handler class that creates menu items.
|
| MenuTag |
A tag handler class for defining menus.
|
| Message |
A convenience class for dealing with localized messages that can have
parameters.
|
| MessageOutput |
Definition of an interface for creating message boxes in a platform
independent way.
|
| MethodInvocation |
A class that represents a method invocation.
|
| MethodInvocationBeanProvider |
A specialized BeanProvider that creates beans by invoking a
method.
|
| MethodInvocationTag |
A specialized InvocationTag implementation that deals with
MethodInvocation objects.
|
| Modifiers |
An enumeration class representing special modifier keys.
|
| MouseListenerTag |
A specialized event listener tag that deals with mouse events.
|
| MultiFileChooserOptions |
A class for defining the options of a multi file chooser dialog.
|
| MutableBeanStore |
Definition of an interface for a BeanStore that can be
manipulated.
|
| NameDependency |
An implementation of the Dependency interface that allows to
define a dependency based on the name of a bean.
|
| NullEnabler |
A trivial implementation of the ElementEnabler interface that does
nothing.
|
| NullInvocation |
Deprecated.
|
| NullMessageOutput |
An implementation of the MessageOutput interface that does not output
a message.
|
| NullTag |
A tag handler class for specifying null values.
|
| NumberTransformerBase<T extends Number> |
An abstract base class for transformers and validators for numbers.
|
| NumberWithUnit |
A class that combines a value with a unit.
|
| OpenWindowCommand |
A specialized Command implementation for opening a sub window.
|
| OrEventFilter |
A specialized chained filter implementation that provides a OR or ANY
semantics.
|
| OrEventFilterTag |
A specialized ChainedEventFilter implementation that creates
an
OrEventFilter.
|
| Orientation |
An enumeration class that defines allowed values for the orientation of
components.
|
| PanelTag |
A specific container tag implementation that creates a panel.
|
| ParameterTag |
A tag handler class for defining the parameters of a method or constructor
invocation.
|
| PasswordFieldTag |
A specialized tag handler implementation for creating password text fields.
|
| PercentCellConstraintsTag |
An abstract base class for tags that define cell constraints of a percent
layout.
|
| PercentCellGroupTag |
A tag handler base class for tags that define cell groups for a percent
layout.
|
| PercentColConstraintsTag |
A concrete cell constraints tag implementation.
|
| PercentColGroupTag |
A concrete cell group tag that creates a column group for a percent layout.
|
| PercentConstraintsTag |
A specific layout constraints tag that creates a
PercentData
object, i.e. layout constraints for the PercentLayout class.
|
| PercentData |
|
| PercentData.Builder |
A builder implementation for creating instances of
PercentData.
|
| PercentLayout |
The concrete percent layout implementation.
|
| PercentLayoutBase |
The main class of the percent layout manager.
|
| PercentLayoutPlatformAdapter |
Definition of an interface that encapsulates platform (library) specific
access to GUI components that are managed by a percent layout manager.
|
| PercentLayoutTag |
A specific layout tag that creates a Percent Layout manager.
|
| PercentRowConstraintsTag |
A concrete cell constraints tag implementation.
|
| PercentRowGroupTag |
A concrete cell group tag that creates a row group for a percent layout.
|
| PlatformEventManager |
Definition of an interface for dealing with platform (i.e. a specific GUI
library) specific events.
|
| PopupHandlerTag |
A tag handler class that allows registering a handler for a popup menu at a
component.
|
| PopupMenuBuilder |
A builder interface for creating popup menus.
|
| PopupMenuHandler |
Definition of an interface for controlling popup menus that can be associated
with GUI components.
|
| ProgressBarHandler |
A specialized component handler that represents a progress bar component.
|
| ProgressBarTag |
A special input component tag that defines a progress bar.
|
| PropertiesBeanProvider |
A specialized BeanProvider implementation for creating a
java.util.Properties object.
|
| PropertiesSupport |
Definition of an interface to be implemented by tags that support a
properties object.
|
| PropertiesTag |
A tag for creating a map with properties and passing it to a target tag.
|
| PropertiesTag |
A specialized MapTag implementation for creating a
java.util.Properties object.
|
| PropertySupport |
Definition of an interface to be implemented by tags that support setting of
properties.
|
| PropertyTag |
A tag for setting a property.
|
| PushButtonTag |
An abstract base class for tag handler classes that implement push buttons
like checkboxes or radio buttons.
|
| RadioButtonTag |
A specific input component tag for creating a radio button.
|
| RadioGroupTag |
A tag for creating a radio group.
|
| RadioGroupWidgetHandler |
|
| ReferenceTag |
A tag handler class that can be used to define references to other components
or groups in the body of a ComponentHandlerTag.
|
| ReflectionUtils |
An utility class that provides some functionality related to reflection and
dependency injection.
|
| RegexValidator |
A specialized Validator implementation that uses regular expressions
to validate user input.
|
| RequiredValidator |
A specialized Validator implementation that checks
whether data was entered in mandatory fields.
|
| ResourceGroup |
Definition of an interface for resource groups.
|
| ResourceLoader |
Definition of an interface for objects that are able to load resource groups.
|
| ResourceManager |
Definition of an interface for accessing resources in a generic way.
|
| ResourceManagerImpl |
A default implementation of the ResourceManager interface.
|
| ResourceTag |
A tag for resolving resources on the class path and creating corresponding
URI strings.
|
| RestrictedDependencyProvider |
An implementation of the DependencyProvider interface, which does not
support external dependencies.
|
| ScheduleAware |
Definition of an interface to be implemented by Command objects that
are interested in the point of time they are passed to a CommandQueue
.
|
| ScrollSizeSupport |
Definition of an interface to be implemented by tags that allow the
specification of a preferred scroll width and height.
|
| SeparatorTag |
A simple tag handler class for creating a separator for menus, toolbars, and
related components.
|
| SetBeanProvider |
A specialized CollectionBeanProvider implementation that
creates a java.util.Set bean.
|
| SetPropertyInvocation |
A special Invocation implementation for setting properties.
|
| SetPropertyTag |
|
| SetTag |
A specialized CollectionTag implementation for creating sets.
|
| ShutdownHandlerTag |
A tag handler class that defines a shutdown script for a BeanProvider
.
|
| SimpleBeanProvider |
A base class for simple bean providers.
|
| SimpleBeanStoreImpl |
A helper class that simplifies implementations of the BeanStore
interface.
|
| SimpleBeanStoreImpl.BeanContributor |
Definition of an interface for objects that can contribute beans for a
SimpleBeanStoreImpl object.
|
| SimpleComponentTag |
An abstract base class for tags that create simple GUI components.
|
| SimplePopupMenuHandler |
A specialized implementation of a PopupMenuHandler,
which can be used out of the box for creating not too complex, mostly static
popup menus.
|
| SingletonBeanProvider |
A specialized life-cycle supporting BeanProvider implementation for
creating singleton beans.
|
| SliderTag |
A specialized input component tag that defines a slider component.
|
| SplitterTag |
A tag for implementing a splitter component.
|
| StaticTextData |
Definition of an interface for describing the properties of a static
text element.
|
| StaticTextDataImpl |
A default implementation of the StaticTextData interface.
|
| StaticTextDataTransformer |
A special implementation of the Transformer interface for converting
data to StaticTextData objects.
|
| StaticTextHandler |
Definition of an interface for a handler that represents a static text
component.
|
| StaticTextTag |
A tag handler class for creating a static text component.
|
| TabbedPaneTag |
A specialized tag handler implementation for creating a tabbed pane.
|
| TabbedPaneTag.Placement |
An enumeration class that defines the valid values for the
placement attribute.
|
| TabbedPaneTag.TabData |
A data class that holds all properties of a register that can be added to
a tabbed pane.
|
| TableColumnRecalibrator |
Definition of an interface for a component which can recalibrate itself based
on the column widths of a table.
|
| TableColumnTag |
A tag handler class for defining columns of a table component.
|
| TableColumnWidthCalculator |
Definition of an interface for a component which can calculate the widths of
a table's columns given the total width of the table.
|
| TableColumnWidthController |
A helper class that provides functionality for managing the widths of the
columns of a table.
|
| TableEditorValidationHandler |
Definition of an interface to be implemented by objects interested in
validation events triggered by a column editor.
|
| TableEditorValidationHandlerTag |
|
| TableFormController |
A helper class for dealing with Form objects related to table
components.
|
| TableHandler |
A specialized ComponentHandler interface dealing with specific
functionality provided by tables.
|
| TableSelectionHandler |
Definition of an interface that allows changing the way a selected or focused
cell in the table is displayed.
|
| TableSelectionHandlerTag |
A tag handler class for defining selection handlers for a table component.
|
| TableTag |
A tag that creates a table component.
|
| TabTag |
A tag handler class for creating register tab pages of a tabbed pane.
|
| TextAreaTag |
A specific component tag that constructs a text area component.
|
| TextData |
A helper class that provides some functionality for components that can
display an internationalized text.
|
| TextFieldTag |
A specific input component tag that constructs a text field component.
|
| TextHandler |
A specialized ComponentHandler implementation for text components.
|
| TextIconAlignment |
An enumeration class that defines the alignment of the text and the icon of a
label or button-like component.
|
| TextIconData |
A helper class that provides some functionality for components that can
display both a text and an icon.
|
| TextIconTag |
A base class for simple components that support a display text and an icon.
|
| TextListModelTag |
A tag handler class that creates a text based ListModel.
|
| TextListModelTag.TextListModel |
A simple implementation of the ListModel interface that
maintains a list of display texts and a list with the corresponding
values.
|
| TextResource |
A class representing a textual resource.
|
| TimeTransformer |
A specialized transformer that transforms strings into date objects, taking
only the time portion into account.
|
| ToggleButtonTag |
A specific tag handler class for creating toggle buttons.
|
| ToolbarTag |
A specialized tag handler class for creating a toolbar component.
|
| ToolButtonTag |
A specific tag handler class for creating toolbar buttons.
|
| ToolTipFieldMarker |
A specialized FormControllerValidationListener implementation that is
able to adapt the tool tips of input elements for which validation messages
are available.
|
| ToolTipManager |
Definition of an interface for a component that manages the tool tips of UI
elements.
|
| ToStringTransformer |
A generic Transformer implementation that transforms arbitrary
objects into formatted strings.
|
| Transformer |
Definition of the Transformer interface.
|
| TransformerBaseTag<T> |
A base class for tags that create transformers or validators.
|
| TransformerContext |
Definition of an interface for accessing data needed by transformers.
|
| TransformerContextPropertiesWrapper |
A specialized implementation of the TransformerContext
interface that allows wrapping an existing context and extending its
properties.
|
| TransformerTag |
A tag handler class for creating Transformer objects and passing them
to input component tags.
|
| TransformerTag.Type |
An enumeration for the possible types of a transformer.
|
| TransformerWrapper |
Definition of an interface for objects that wrap a transformer.
|
| TreeConfigurationChangeHandler |
A helper class for concrete tree view implementations that supports the
processing of change events fired by a configuration serving as tree model.
|
| TreeExpandVetoException |
An exception class to be thrown to prevent a tree from expanding or
collapsing a tree node.
|
| TreeExpansionEvent |
An event class reporting a change in the expanded state of a tree's node.
|
| TreeExpansionEvent.Type |
An enumeration class defining the different types of a
TreeExpansionEvent.
|
| TreeExpansionListener |
An event listener interface to be implemented by objects that are interested
in changes of the expansion state of tree nodes.
|
| TreeHandler |
A specialized ComponentHandler interface for dealing with tree
components.
|
| TreeIconHandler |
Definition of an interface for components that determine the icons displayed
by a tree component.
|
| TreeIconTag |
A tag for defining icons for tree components.
|
| TreeModelChangeListener |
Definition of an interface to be implemented by components interested in
changes on a tree model.
|
| TreeNodePath |
A class that represents a path in a tree component.
|
| TreePreExpansionListener |
An event listener interface to be implemented by objects that need to be
notified before the expansion state of a tree's node changes.
|
| TreeTag |
A tag that creates a tree component.
|
| TypeEventFilter |
A specialized EventFilter implementation that filters by an event
type.
|
| Unit |
An enumeration class for defining units.
|
| UnitSizeHandler |
Definition of an interface for performing size calculations in a manner
independent of a certain component model.
|
| URLLocator |
A specialized Locator implementation that operates on URLs.
|
| UseBeanBaseTag |
A tag handler base class for tags that deal with the creation of service
beans.
|
| ValidationMessage |
Definition of an interface describing a validation message.
|
| ValidationMessageConstants |
This class defines constants for the keys of validation messages.
|
| ValidationMessageHandler |
Definition of an interface for a central instance that manages validation
messages.
|
| ValidationMessageLevel |
An enumeration class that defines possible levels for validation messages.
|
| ValidationPhase |
An enumeration class that describes the different validation phases.
|
| ValidationResult |
An interface that defines the results of a validation process.
|
| Validator |
Definition of a validator interface.
|
| ValidatorBaseTag<T extends Validator> |
A base class for tag handler implementations that create validators for input
components.
|
| ValidatorsTag |
A tag handler class for combining multiple validators to be assigned to an
input component.
|
| ValidatorTag |
A tag handler class for creating
Validator objects and
associating them with input components.
|
| ValidatorWrapper |
Definition of an interface for objects that wrap a
Validator.
|
| ValueData |
A data class for holding all information required for creating a value.
|
| ValueSupport |
Definition of an interface for tag handler classes that can be assigned a
value.
|
| ValueTag |
A tag handler class for defining a value.
|
| WidgetHandler |
Definition of an interface for dealing with widgets.
|
| Window |
Definition of an interface for describing windows in a platform independent
way.
|
| WindowBaseTag |
A base class for all tag handler classes that create windows.
|
| WindowBuilderData |
A data class that stores important information needed during a window builder
process.
|
| WindowBuilderException |
A specialized exception class used for reporting error conditions related to
the window builder.
|
| WindowBuilderTagLibrary |
The tag library with the window builder tags.
|
| WindowClosingStrategy |
Definition of an interface used to control whether a window can be closed.
|
| WindowControllerTag |
A tag handler class that allows the creation of window controllers.
|
| WindowData |
Definition of an interface for providing (platform-independent) information
about a window to be created.
|
| WindowEvent |
An event class used by the window builder framework to deliver event
information related to windows.
|
| WindowEvent.Type |
An enumeration for the different types of window events.
|
| WindowListener |
Definition of an interface that must be implemented by objects that are
interested in window related events.
|
| WindowListenerTag |
A specialized event listener tag that can be used to register window
listeners.
|
| WindowManager |
Definition of an interface for platform (or GUI library) specific window
manager implementations.
|
| WindowManagerWrapper |
A base class for wrapper implementations of the WindowManager
interface.
|
| WindowUtils |
A static utility class providing useful functionality for dealing with
Window objects.
|
| WindowWrapper |
Definition of an interface for objects that wrap "real" windows.
|