All Classes

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>	An abstract base class for concrete implementations of the CompositeComponentHandler interface.
AbstractDecimalTransformer<T extends Number>	A base class for number transformers that operate on floating point numbers.
AbstractDesktopTask	An abstract base class for action tasks that perform a desktop operation with the currently selected file.
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.
AppendTextActionTask	A task for an action that appends a configurable text to a text component.
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.
BgTaskCommand	A command class for executing the background task.
BgTaskData	A data class that stores all information required by the background task.
BindingStrategy	Definition of an interface for objects that are responsible of the binding of form fields to model objects.
BooleanRadioButtonHandler	A specialized ComponentHandler implementation for a radio button group with only two elements.
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	A special layout tag that creates a BorderLayout object.
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	A specialized layout tag that creates a ButtonLayout.
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.
ChangeListener	Definition of an interface for receiving notifactions about changes at Swing components.
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.
ClearTextActionTask	A task for an action that clears the content of a text component.
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	A specialized FormControllerValidationListener implementation that can change the colors of fields depending on their validation status.
ColorHelper	A helper class for dealing with colors.
ColorHelper.NamedColor	An enumeration with predefined color constants.
ColorListModel	A ListModel implementation for combo boxes that allow the user to choose a color.
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	A tag handler class that allows constructing custom ComponentHandler objects.
ComponentManager	Definition of an interface to a concrete GUI manager.
ComponentManagerWrapper	A base class for wrapper implementations of the ComponentManager interface.
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	A specialized InvocationTag implementation that deals with ConstructorInvocation objects.
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.
CreateFileCommand	A command class for creating a new file.
CreateFileData	A data class that stores all information for the creation of a new file.
CreateViewSettingsCommand	A command class for storing view settings for a given directory.
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.
DirectoryData	A data class for storing information about a directory.
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.
DummyActionTask	A dummy task class that is associated with actions for which no implementation is provided.
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.
EditDesktopTask	A specialized action task for editing a selected file.
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	A specialized converter implementation for ElementEnabler objects.
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.
FileData	A simple data class representing a file (or sub directory) in a directory.
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.
FileSizeTransformer	A specialized transformer for formatting file sizes.
FileSystemChangeListener	An event listener for change events fired by the combobox with the file systems.
FileSystemListModel	A ListModel implementation for the roots of the available file systems.
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	A base class for events generated by FormController.
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	An event listener for processing events of type FormControllerFormEvent.
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	A class for converting a FormValidatorResults object to text.
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.
InternalFrameAdapter	A window adapter implementation for Swing internal frames.
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.
JGuiraffeTestHelper	A helper class with functionality that can be used by test classes.
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.
Main	The main application class of the JGUIraffe tutorial application.
MainWndController	The controller class for the main window.
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.
MouseEventAdapter	A specific Swing event adapter implementation that deals with mouse events.
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. Use HelperInvocations instead; it provides some dummy implementations of the Invokable interface which are useful in some situations where a full-blown implementation is not required.
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.
OpenDesktopTask	A specialized action task for opening a file or directory.
OpenViewSettingsDlgCommand	A specialized command class for opening the dialog with the view settings.
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	A constraints class used by PercentLayout.
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.
PersonBean	A test bean class that can be used by tests which need to access bean properties..
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.
PrintDesktopTask	A specialized action task for printing a file.
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	A specialized WidgetHandler implementation for radio groups.
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.
RefreshActionTask	The task of the refresh action.
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.
SelectAndOpenFileTask	A task class for selecting a file and opening it.
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	A tag handler class that creates a SetPropertyInvocation object.
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.
SwingActionManager	The Swing specific implementation of the ActionManager interface.
SwingButtonHandler	A specific Swing component handler implementation that deals with several kinds of button like components.
SwingComponentManager	The Swing specific implementation of the ComponentManager interface.
SwingConfigurationTreeModel	A specialized implementation of TreeModel that obtains its data from a Configuration object.
SwingEventAdapter	The base class for Swing event adapters.
SwingEventConstantMapper	An utility class for converting Swing-specific constants related to events to the toolkit-independent constants used by the JGUIraffe library.
SwingEventManager	Swing specific implementation of the PlatformEventManager interface.
SwingEventSource	Definition of an interface for registering and unregistering Swing event listeners.
SwingFileChooserDialogService	The Swing-specific implementation of the file chooser dialog service.
SwingFileChooserDialogServiceFactory	The dialog service factory provided by Swing to create instances of the FileChooserDialogService.
SwingFormAction	A Swing specific implementation of the FormAction interface.
SwingGUISynchronizer	The Swing specific implementation of the GUISynchronizer interface.
SwingMessageOutput	A Swing specific implementation of the MessageOutput interface.
SwingPercentLayoutAdapter	Implementation of a Swing-specific adapter class for the percent layout manager.
SwingPopupMenuBuilder	A specialized implementation of the PopupMenuBuilder interface for constructing Swing popup menus.
SwingSizeHandler	Swing specific implementation of the SizeHandler interface.
SwingTableColumnWidthListener	A specialized event listener class for keeping track of and resizing the columns of a table.
SwingTableEditorValidationHandler	Deprecated. The functionality provided by this class was not Swing-specific, but could be used for other UI tool kits as well.
SwingTableModel	A table model implementation for tables defined by the TableTag tag handler class.
SwingTableRowHeightUpdater	A helper class for setting the correct row heights for a Swing table.
SwingTableSelectionHandler	A Swing-specific default implementation of the TableSelectionHandler interface.
SwingWindow	Definition of an extended window interface implemented by Swing window implementations.
SwingWindowManager	The Swing specific implementation of the WindowManager interface.
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.
TableChangeListener	An event listener for change events fired by the table with the directory content.
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	A tag handler class for defining the TableEditorValidationHandler to be used for a table component.
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.
TablePopupHandler	A PopupMenuHandler implementation for creating the popup menu of the directory table.
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.
TreeChangeListener	An event listener for change events fired by the tree view.
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.
UniqueFileNameValidator	A specialized Validator implementations for checking whether the name entered for a new file does not exist in the current directory.
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.
ViewSettings	A data class for storing a view definition.
ViewSettingsFormController	A specialized FormController class for the view settings dialog.
ViewSettingsFormValidator	A FormValidator implementation for validating the dialog with view settings.
WidgetHandler	Definition of an interface for dealing with widgets.
Window	Definition of an interface for describing windows in a platform independent way.
WindowAdapter	Abstract base class for Swing Window implementations that are based on java.awt.Window.
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.