Alle Klassen und Schnittstellen
Klasse
Beschreibung
An abstract base class for tag handler classes that need to deal with action
objects and their properties.
An abstract base class for tag handler implementations that create bean
providers.
An abstract base class for concrete implementations of the
CompositeComponentHandler interface.
A base class for number transformers that operate on floating point numbers.
An abstract base class for action tasks that perform a desktop operation with
the currently selected file.
An abstract base class for options classes for standard dialogs.
An abstract base class for event filters.
An abstract base class for the options of file chooser dialogs.
A base class for number transformers that operate on integer numbers.
An adapter class for implementing concrete
Locator classes.
An abstract base class for implementations of the
PopupMenuBuilder
interface.
A base class for
ComponentHandler implementations for radio buttons.
An abstract base class for
Locator implementations that mainly
operate on streams.
A class that represents an accelerator for invoking an action.
An extended version of the
Composite interface which also allows
access to the data passed via the mutating methods.
A central data class used during the action builder process.
The tag library for the action builder tags.
Definition of an interface for objects with container facilities.
Definition of an abstract base class for tag handler classes that create
controls, which can be associated with actions.
Definition of an interface for describing properties of an action.
A straight forward implementation of the
ActionData interface.
A simple tag for creating objects of type
ActionData.
A specialized implementation of the
ElementEnabler interface that can
change the enabled state of actions.
A specialized implementation of the
ElementEnabler interface that can
change the enabled state of action groups.
A helper class for dealing with actions.
A class that allows to combine actions with event listeners.
A specific form event listener tag implementation that deals with action
listeners.
Definition of an interface for a component that creates GUI library specific
action objects and related classes.
A base class for wrapper implementations of the
ActionManager
interface.
A class for maintaining action objects.
A tag handler class for creating action objects.
Definition of an interface for the task of an action.
A simple tag for specifying task objects for actions.
A specialized chained filter implementation that provides an AND or ALL
semantics.
A specialized
ChainedEventFilter implementation that creates
an
AndEventFilter
A task for an action that appends a configurable text to a text component.
The main startup class of the GUI application framework.
The application specific default implementation of the
BuilderData
interface.
Definition of an interface for objects that need a reference to the central
Application object.
Definition of an interface for accessing application global information.
A default implementation of the
ApplicationContext interface.
An exception class that indicates error conditions related to the
Application class.
A class defining constants for default resources provided by the application
framework.
An enumeration class defining the keys of all resources contained within
the application default resource bundle.
An exception class for reporting runtime exceptions that are related to
Application
A specialized action task for exiting the current application.
Definition of an interface for listeners that want to be notified when the
application terminates.
A specialized
WindowListener implementation for implementing the
auto release mechanism supported by builders.
An implementation of the
BindingStrategy interface that operates on
Java beans.
Definition of an interface for processing scripts with bean definitions.
Definition of an interface for querying new
BeanBuilder
Definition of an interface for accessing the results of a
BeanBuilder.
Definition of an interface that allows access to the beans managed by the
dependency injection framework.
Definition of an interface to be implemented by beans that need a reference
to the current
BeanContext.
A simple wrapper implementation of the
BeanContext interface.
An event class for reporting the creation of a bean by the dependency
injection framework.
Definition of an interface for objects that are interested in the creation of
beans by a
BeanContext.
Definition of an interface for objects that perform some kind of
initialization on beans that are managed by a
BeanContext
Definition of an interface for objects that provide access to beans.
Definition of an interface for objects that provide access to bean
definitions.
A tag handler class for creating new
BeanStore instances.
The main tag of the tag library for the dependency injection
framework: with this tag bean definitions can be created.
A command class for executing the background task.
A data class that stores all information required by the background task.
Definition of an interface for objects that are responsible of the binding of
form fields to model objects.
A specialized
ComponentHandler implementation for a radio button
group with only two elements.
A special tag handler implementation for creating constraints object for a
BorderLayout
A GUI library independent implementation of the AWT layout manager
BorderLayout.
A special layout tag that creates a
BorderLayout object.
The main builder interface.
Definition of an interface that describes the parameters of a builder
operation.
The base class of events used in the form and form builder framework.
An exception class for reporting error conditions related to the GUI builder.
A specialized implementation of the
ResourceLoader interface that
make use of the default Java resource bundles.
A layout manager that deals with button bars for dialogs.
An enumeration class for the alignment of a
ButtonLayout.
A specialized layout tag that creates a
ButtonLayout
A specific tag handler class for creating command button components.
A specialized
Locator implementation that provides access to data
stored in memory as a byte array.
An enumeration class that defines the possible alignments of components in
the cells of a percent layout.
A class for describing column and row constraints for the
PercentLayout layout manager.
A builder class for creating instances of
CellConstraints.
A simple helper class to define columns and rows with identical size in
PercentLayout.
An enumeration class that defines possible sizes for the cells of a
percent layout.
An abstract base class for filters that operate on multiple filters.
A specialized event filter class that deals with chained filters, i.e. event
filters that can child event filters.
A special implementation of the
Invokable interface that
allows aggregating an arbitrary number of Invokable objects to
a kind of script.
A specialized implementation of the
ElementEnabler interface that
maintains an arbitrary number of other ElementEnabler objects.
A special
Validator implementation that allows combining multiple
primitive validators.
Definition of an interface for receiving notifactions about changes at Swing
components.
A specific form event listener tag implementation that deals with change
listeners.
A specific input component tag for creating a checkbox.
An implementation of the
Dependency interface that allows to
define a dependency based on a bean class.
A simple data class for managing the components needed for a class
description.
A helper class for defining references to classes.
A specialized
EventFilter implementation that filters by an
event class.
Definition of an interface for objects that act as a registry for class
loaders.
A specific
Locator implementation that can obtain resources from
the class path.
A task for an action that clears the content of a text component.
An abstract base class for
BeanProvider implementations that
create beans derived from collections.
A base tag handler class for defining collections in bean builder scripts.
A simple class representing a color in a platform-independent way.
A specialized
FormControllerValidationListener implementation that
can change the colors of fields depending on their validation status.
A helper class for dealing with colors.
An enumeration with predefined color constants.
A
ListModel implementation for combo boxes that allow the user to
choose a color.
An enumeration class that defines logic column classes.
An abstract base class for tags that define renderers or editors for the
columns of a table.
A tag for defining the editor of a column within a table.
A tag for defining the renderer of a column within a table.
A specialized implementation of the
BeanStore interface that combines
multiple physical BeanStore objects to a single logic view.
A specific input component tag that creates a combo box component.
Definition of an interface for command objects.
A specialized action task that executes a
Command object.
An abstract base class for implementations of the
Command
interface.
Definition of an interface that describes a command queue.
An event class for notifying listeners about the state of a
CommandQueue.
An enumeration for the types supported by the
CommandQueueEvent class.
A command queue implementation for GUI applications.
Definition of an interface for listeners that want to be notified about
changes in the state of a
CommandQueue
A wrapper implementation of the
Command interface.
An abstract base class for tags that create GUI components.
An interface for describing call back operations that can be registered at
the central builder data object.
A class for storing temporary data and the results of a form builder
operation.
A specialized implementation of the
ElementEnabler interface that can
change the enabled state of components.
This class represents a group of components.
A tag for constructing (logic) groups of components.
Definition of an interface for accessing GUI components independently from
their type.
A simple default implementation of the
ComponentHandler
interface.
A tag handler class that allows constructing custom
ComponentHandler
objects.
Definition of an interface to a concrete GUI manager.
A base class for wrapper implementations of the
ComponentManager
interface.
Definition of an interface for objects that are able to manage entities
related to a
Form object.
A fully functional default implementation of the
ComponentStore
interface.
Definition of an interface for components that can contain other components.
Definition of an interface for complex component handlers that can contain
other component handlers.
A straight-forward implementation of the
Composite interface.
Definition of an interface for tags that are only executed for certain
builders.
A concrete implementation of the
BeanProvider interface that
will always return the same bean instance.
A specialized tag handler implementation for resolving values of constant
fields.
An abstract base class for creating layout constraints objects.
A simple bean provider that creates new bean instances by invoking a
constructor.
A class that represents a constructor invocation.
A specialized
InvocationTag implementation that deals with
ConstructorInvocation
A specialized constructor invocation tag that is intended to be used inside a
<bean> tag for defining the BeanProvider
for creating the managed bean.
An interface for a component responsible for obtaining a container object.
A specific tag handler implementation for creating container tags.
A specialized tag for the creation of beans from objects stored in the Jelly
context.
A helper class providing functionality related to data type conversion and
registration of custom converters.
A specialized tag handler class for adding custom data type converters in a
builder script.
A command class for creating a new file.
A data class that stores all information for the creation of a new file.
A command class for storing view settings for a given directory.
A specialized transformer that transforms strings into date objects with both
a date and time component.
A specialized transformer that transforms strings into date objects.
An abstract base class for date transformer objects.
A default implementation of the
BeanContext interface.
A simple yet fully functional default implementation of the
BeanStore interface.
A default implementation of the
ClassLoaderProvider interface.
A default implementation of the
ContainerSelector interface.
A default implementation of the
FieldHandler interface.
A default implementation of the
FieldHandlerFactory interface.
Default implementation of the
FormValidatorResults interface.
A concrete default implementation of a
CompositeComponentHandler for
a group of radio buttons.
A default implementation of the
TableEditorValidationHandler
interface.
A default implementation of the
ToolTipManager interface.
A default implementation of the
TransformerWrapper interface.
A default implementation of the
ValidationMessageHandler interface.
A default implementation of the
ValidationResult interface.
A builder class for creating instances of
DefaultValidationResult.
A default implementation of the
ValidatorWrapper interface.
Definition of an interface for describing a dependency to another
BeanProvider
Definition of an interface that provides access to dependencies defined by a
BeanProvider.
A base class for tag handler classes that support the definition of a
dependency.
A specific container tag implementation that creates a desktop panel.
Enumeration class that defines the allowed values for the
dragmode attribute.
A callback interface to notify a client that the user has canceled a standard
dialog.
A callback interface for handling the result of a standard dialog.
A factory interface for the creation of a dialog service.
A tag handler class for creating dialogs.
A data class for maintaining all information required for a DI builder
operation.
A class for defining the options of a directory chooser dialog.
A data class for storing information about a directory.
The tag library for the tags of the dependency injection framework.
A specialized number transformer implementation that deals with numbers of
type
java.lang.Double.
A dummy task class that is associated with actions for which no
implementation is provided.
A dummy implementation of the
BindingStrategy interface.
This class provides dummy implementations for the
Transformer
and the Validator interfaces.
A dummy implementation of the
TransformerWrapper and the
ValidatorWrapper interfaces.
Definition of a specialized
ListModel extension interface to be used
by editable combo boxes.
A specialized action task for editing a selected file.
Definition of an interface to be implemented by components that can change
the enabled state of specific elements.
A tag handler class that allows adding elements to collections.
A helper class for the convenient creation of standard
ElementEnabler
objects.
A specialized converter implementation for
ElementEnabler objects.
A tag handler class for defining the key of an
EntryTag
A tag handler implementation for populating a map.
A specialized
Converter implementation dealing with all types of
enumeration classes.
Definition of an interface for filtering events.
A specialized tag handler class for creating event filters.
A base class for event listener tags.
A specialized tag handler implementation that allows adding another event
listener type to a
FormEventListenerTag.
A tag handler class for registering an event listener at a single or multiple
components.
A specialized life-cycle supporting
BeanProvider
A tag for defining a bean factory that is used as creation
BeanProvider for a BeanTag.
Definition of an interface for accessing fields of a form.
Definition of an interface for objects that are able to create
FieldHandler
A specific input component tag that allows to make use of custom input
components.
An enumeration class describing the possible validation status values of a
form field.
An interface for a service that allows the creation of standard dialogs for
choosing files and directories.
A class for defining the options of a file chooser dialog.
A simple data class representing a file (or sub directory) in a directory.
A class representing an extension filter that can be used together with the
file chooser service.
A concrete
Locator class that represents files.
A specialized transformer for formatting file sizes.
An event listener for change events fired by the combobox with the file
systems.
A
ListModel implementation for the roots of the available file
systems.
A specialized number transformer implementation that deals with numbers of
type
java.lang.Float.
A specific form event listener tag implementation that deals with focus
listeners.
A specialized tag handler class for creating fonts.
This class represents a form.
An interface describing an action.
A specific event class for dealing with action events.
An exception class indicating a problem with the form action framework.
Definition of an interface for action listeners.
A base class for tags of the form builder framework.
An exception class for reporting errors of the form builder framework.
An exception class for reporting runtime errors of the form builder
framework.
The tag library for the form builder tags.
A specific event class for change events.
Definition of an interface for change listeners.
An event listener interface to be implemented by components that are
interested in the creation of new form contexts during a builder operation.
A base class for form controllers.
A base class for events generated by
FormController.
A specialized
FormControllerEvent class that is generated whenever a
form field changes its visited status.
A specialized event listener interface to be implemented by objects that are
interested in status updates of form fields.
A specialized
FormControllerEvent class for events related to the
form associated with a FormController.An enumeration class defining the possible types of
FormControllerFormEvent events.
An event listener for processing events of type
FormControllerFormEvent.
A specialized tag handler class that can be used to register listeners at a
FormController.
A specialized tag handler implementation for creating form controllers.
A specialized
FormControllerEvent class that is generated when the
controller performs a validation.
Definition of an interface to be implemented by objects that are interested
in validation operations performed by a
FormController.
An event class used in the form and form builder framework to deliver event
information related to form elements (controls or input components).
Base interface for listeners for form events.
A base class for event listener tag handler classes that deal with event
listeners for form events.
The main class for event handling in the form framework.
A specific event class dealing with focus events.
An enumeration class defining the different types of focus events.
Definition of an interface for focus listeners.
An enumeration class describing the supported event listener types.
A specialized event class for reporting events related to mouse actions.
An enumeration class defining constants for the possible mouse actions
that can trigger a
FormMouseEvent.
Definition of interface for mouse listeners.
An exception class for reporting runtime exceptions related to the form
framework.
A class for converting a
FormValidatorResults object to text.
Definition of an interface for objects that can trigger the validation of a
form.
A specialized
FormValidationTrigger implementation that triggers a
validation operation whenever the user leaves an input field.
A specialized implementation of a
FormValidationTrigger that
does no triggering at all.
Definition of an interface for objects that can validate forms.
Definition of an interface for describing results of a form validation.
A tag handler class for creating (main) frame windows.
An exception class for reporting GUI related runtime errors.
Definition of an interface that supports updating GUI components from
different threads.
An enumeration class defining some simple helper
Invokable
implementations.
Definition of an interface for GUI components that support icons.
A tag for adding an icon to a component.
An exception class for reporting exceptions related to dependency injection.
A base class for tag handler classes that create input components.
A specialized number transformer implementation that deals with numbers of
type
java.lang.Integer.
A window adapter implementation for Swing internal frames.
A tag handler class for creating internal frames.
A very simple implementation of the
WindowClosingStrategy
interface.
A specialized implementation of the
ElementEnabler interface that
wraps another ElementEnabler and inverses the
setEnabledState() implementation of this wrapped enabler.
A base class for (method or constructor) invocations.
A helper class providing some more complex functionality related to
reflection.
A base class for tag handler classes defining invocation objects.
A specialized tag handler implementation for defining the target object of a
method invocation.
Definition of an interface for objects that perform some kind of method
invocation.
An implementation of the
BeanBuilder interface that is able to
process bean definitions defined in a Apache Commons Jelly script.
An implementation of the
BeanBuilderFactory interface that
returns JellyBeanBuilder
An implementation of the
Builder interface that uses Commons Jelly for processing build
scripts and creating GUI components.
A specialized implementation of the
BeanStore interface that
is backed by a Jelly context.
A helper class with functionality that can be used by test classes.
An enumeration class defining constants for special keys on a standard
keyboard.
A tag class for creating labels.
A base tag handler class for layout tags.
An abstract base class for
BeanProvider implementations with
life-cycle support.
A specific
CollectionBeanProvider implementation that creates
a list bean.
A specific input component tag that creates a list box component.
A specialized component handler interface for components with list-like
structures.
Definition of an interface that is used to obtain the content of a list box
or combo box component.
A tag handler class that creates an item for a list model.
Definition of an interface for tags that support a list model.
A helper class for dealing with model objects.
A specialized
CollectionTag implementation for creating lists.
A specialized tag handler class for loading localized texts and passing them
to tags implementing the
ValueSupport interface.
Definition of the base
Locator interface.
A specialized
Converter implementation dealing with Locator
objects.
An exception class for reporting error conditions related to
Locator
A helper class for locating resources.
A wrapper implementation for locators.
A specialized number transformer implementation that deals with numbers of
type
java.lang.Long.The main application class of the JGUIraffe tutorial application.
The controller class for the main window.
A specialized
BeanProvider implementation for creating beans of
type java.util.Map.
A specialized
BeanTag implementation for creating maps.
A tag handler class for creating menu bars.
A tag handler class that creates menu items.
A tag handler class for defining menus.
A convenience class for dealing with localized messages that can have
parameters.
Definition of an interface for creating message boxes in a platform
independent way.
A class that represents a method invocation.
A specialized
BeanProvider that creates beans by invoking a
method.
A specialized
InvocationTag implementation that deals with
MethodInvocation objects.
An enumeration class representing special modifier keys.
A specific Swing event adapter implementation that deals with mouse events.
A specialized event listener tag that deals with mouse events.
A class for defining the options of a multi file chooser dialog.
Definition of an interface for a
BeanStore that can be
manipulated.
An implementation of the
Dependency interface that allows to
define a dependency based on the name of a bean.
A trivial implementation of the
ElementEnabler interface that does
nothing.Veraltet.
An implementation of the
MessageOutput interface that does not output
a message.
A tag handler class for specifying null values.
An abstract base class for transformers and validators for numbers.
A class that combines a value with a unit.
A specialized action task for opening a file or directory.
A specialized command class for opening the dialog with the view settings.
A specialized
Command implementation for opening a sub window.
A specialized chained filter implementation that provides a OR or ANY
semantics.
A specialized
ChainedEventFilter implementation that creates
an
OrEventFilter
An enumeration class that defines allowed values for the orientation of
components.
A specific container tag implementation that creates a panel.
A tag handler class for defining the parameters of a method or constructor
invocation.
A specialized tag handler implementation for creating password text fields.
An abstract base class for tags that define cell constraints of a percent
layout.
A tag handler base class for tags that define cell groups for a percent
layout.
A concrete cell constraints tag implementation.
A concrete cell group tag that creates a column group for a percent layout.
A specific layout constraints tag that creates a
PercentDataPercentLayout class.
A constraints class used by
PercentLayout.
A builder implementation for creating instances of
PercentData.
The concrete percent layout implementation.
The main class of the percent layout manager.
Definition of an interface that encapsulates platform (library) specific
access to GUI components that are managed by a percent layout manager.
A specific layout tag that creates a Percent Layout manager.
A concrete cell constraints tag implementation.
A concrete cell group tag that creates a row group for a percent layout.
A test bean class that can be used by tests which need to access bean properties..
Definition of an interface for dealing with platform (i.e. a specific GUI
library) specific events.
A tag handler class that allows registering a handler for a popup menu at a
component.
A builder interface for creating popup menus.
Definition of an interface for controlling popup menus that can be associated
with GUI components.
A specialized action task for printing a file.
A specialized component handler that represents a progress bar component.
A special input component tag that defines a progress bar.
A specialized
BeanProvider implementation for creating a
java.util.Properties object.
Definition of an interface to be implemented by tags that support a
properties object.
A tag for creating a map with properties and passing it to a target tag.
A specialized
MapTag implementation for creating a
java.util.Properties object.
Definition of an interface to be implemented by tags that support setting of
properties.
A tag for setting a property.
An abstract base class for tag handler classes that implement push buttons
like checkboxes or radio buttons.
A specific input component tag for creating a radio button.
A tag for creating a radio group.
A specialized
WidgetHandler implementation for radio groups.
A tag handler class that can be used to define references to other components
or groups in the body of a
ComponentHandlerTag.
An utility class that provides some functionality related to reflection and
dependency injection.
The task of the refresh action.
A specialized
Validator implementation that uses regular expressions
to validate user input.
A specialized
Validator implementation that checks
whether data was entered in mandatory fields.
Definition of an interface for resource groups.
Definition of an interface for objects that are able to load resource groups.
Definition of an interface for accessing resources in a generic way.
A default implementation of the
ResourceManager interface.
A tag for resolving resources on the class path and creating corresponding
URI strings.
An implementation of the
DependencyProvider interface, which does not
support external dependencies.
Definition of an interface to be implemented by
Command objects that
are interested in the point of time they are passed to a CommandQueue
.
Definition of an interface to be implemented by tags that allow the
specification of a preferred scroll width and height.
A task class for selecting a file and opening it.
A simple tag handler class for creating a separator for menus, toolbars, and
related components.
A specialized
CollectionBeanProvider implementation that
creates a java.util.Set bean.
A special
Invocation implementation for setting properties.
A tag handler class that creates a
SetPropertyInvocation
A specialized
CollectionTag implementation for creating sets.
A tag handler class that defines a shutdown script for a
BeanProvider
.
A base class for simple bean providers.
A helper class that simplifies implementations of the
BeanStore
interface.
Definition of an interface for objects that can contribute beans for a
SimpleBeanStoreImpl object.
An abstract base class for tags that create simple GUI components.
A specialized implementation of a
PopupMenuHandler,
which can be used out of the box for creating not too complex, mostly static
popup menus.
A specialized life-cycle supporting
BeanProvider implementation for
creating singleton beans.
A specialized input component tag that defines a slider component.
A tag for implementing a splitter component.
Definition of an interface for describing the properties of a static
text element.
A default implementation of the
StaticTextData interface.
A special implementation of the
Transformer interface for converting
data to StaticTextData objects.
Definition of an interface for a handler that represents a static text
component.
A tag handler class for creating a static text component.
The Swing specific implementation of the
ActionManager
interface.
A specific Swing component handler implementation that deals with several
kinds of button like components.
The Swing specific implementation of the
ComponentManager
interface.
A specialized implementation of
TreeModel that obtains its data
from a Configuration object.
The base class for Swing event adapters.
An utility class for converting Swing-specific constants related to events to
the toolkit-independent constants used by the JGUIraffe library.
Swing specific implementation of the
PlatformEventManager
interface.
Definition of an interface for registering and unregistering Swing event
listeners.
The Swing-specific implementation of the file chooser dialog service.
The dialog service factory provided by Swing to create instances of the
FileChooserDialogService.
A Swing specific implementation of the
FormAction interface.
The Swing specific implementation of the
GUISynchronizer
interface.
A Swing specific implementation of the
MessageOutput
interface.
Implementation of a Swing-specific adapter class for the percent layout
manager.
A specialized implementation of the
PopupMenuBuilder interface
for constructing Swing popup menus.
Swing specific implementation of the
SizeHandler interface.
A specialized event listener class for keeping track of and resizing the
columns of a table.
Veraltet.
The functionality provided by this class was not Swing-specific,
but could be used for other UI tool kits as well.
A table model implementation for tables defined by the
TableTag tag
handler class.
A helper class for setting the correct row heights for a Swing table.
A Swing-specific default implementation of the
TableSelectionHandler interface.
Definition of an extended window interface implemented by Swing window
implementations.
The Swing specific implementation of the
WindowManager
interface.
A specialized tag handler implementation for creating a tabbed pane.
An enumeration class that defines the valid values for the
placement attribute.A data class that holds all properties of a register that can be added to
a tabbed pane.
An event listener for change events fired by the table with the directory
content.
Definition of an interface for a component which can recalibrate itself based
on the column widths of a table.
A tag handler class for defining columns of a table component.
Definition of an interface for a component which can calculate the widths of
a table's columns given the total width of the table.
A helper class that provides functionality for managing the widths of the
columns of a table.
Definition of an interface to be implemented by objects interested in
validation events triggered by a column editor.
A tag handler class for defining the
TableEditorValidationHandler
A helper class for dealing with
Form objects related to table
components.
A specialized
ComponentHandler interface dealing with specific
functionality provided by tables.
A
PopupMenuHandler implementation for creating the popup menu of the
directory table.
Definition of an interface that allows changing the way a selected or focused
cell in the table is displayed.
A tag handler class for defining selection handlers for a table component.
A tag that creates a table component.
A tag handler class for creating register tab pages of a tabbed pane.
A specific component tag that constructs a text area component.
A helper class that provides some functionality for components that can
display an internationalized text.
A specific input component tag that constructs a text field component.
A specialized
ComponentHandler implementation for text components.
An enumeration class that defines the alignment of the text and the icon of a
label or button-like component.
A helper class that provides some functionality for components that can
display both a text and an icon.
A base class for simple components that support a display text and an icon.
A tag handler class that creates a text based
ListModel.A simple implementation of the
ListModel interface that
maintains a list of display texts and a list with the corresponding
values.
A class representing a textual resource.
A specialized transformer that transforms strings into date objects, taking
only the time portion into account.
A specific tag handler class for creating toggle buttons.
A specialized tag handler class for creating a toolbar component.
A specific tag handler class for creating toolbar buttons.
A specialized
FormControllerValidationListener implementation that is
able to adapt the tool tips of input elements for which validation messages
are available.
Definition of an interface for a component that manages the tool tips of UI
elements.
A generic
Transformer implementation that transforms arbitrary
objects into formatted strings.
Definition of the
Transformer interface.
A base class for tags that create transformers or validators.
Definition of an interface for accessing data needed by transformers.
A specialized implementation of the
TransformerContext
interface that allows wrapping an existing context and extending its
properties.
A tag handler class for creating
Transformer objects and passing them
to input component tags.An enumeration for the possible types of a transformer.
Definition of an interface for objects that wrap a transformer.
An event listener for change events fired by the tree view.
A helper class for concrete tree view implementations that supports the
processing of change events fired by a configuration serving as tree model.
An exception class to be thrown to prevent a tree from expanding or
collapsing a tree node.
An event class reporting a change in the expanded state of a tree's node.
An enumeration class defining the different types of a
TreeExpansionEvent.
An event listener interface to be implemented by objects that are interested
in changes of the expansion state of tree nodes.
A specialized
ComponentHandler interface for dealing with tree
components.
Definition of an interface for components that determine the icons displayed
by a tree component.
A tag for defining icons for tree components.
Definition of an interface to be implemented by components interested in
changes on a tree model.
A class that represents a path in a tree component.
An event listener interface to be implemented by objects that need to be
notified before the expansion state of a tree's node changes.
A tag that creates a tree component.
A specialized
EventFilter implementation that filters by an event
type.
A specialized
Validator implementations for checking whether the name
entered for a new file does not exist in the current directory.
An enumeration class for defining units.
Definition of an interface for performing size calculations in a manner
independent of a certain component model.
A specialized
Locator implementation that operates on URLs.
A tag handler base class for tags that deal with the creation of service
beans.
Definition of an interface describing a validation message.
This class defines constants for the keys of validation messages.
Definition of an interface for a central instance that manages validation
messages.
An enumeration class that defines possible levels for validation messages.
An enumeration class that describes the different validation phases.
An interface that defines the results of a validation process.
Definition of a validator interface.
A base class for tag handler implementations that create validators for input
components.
A tag handler class for combining multiple validators to be assigned to an
input component.
A tag handler class for creating
Ungültige Referenz
Validator
objects and
associating them with input components.
Definition of an interface for objects that wrap a
Validator
A data class for holding all information required for creating a value.
Definition of an interface for tag handler classes that can be assigned a
value.
A tag handler class for defining a value.
A data class for storing a view definition.
A specialized
FormController class for the view settings dialog.
A
FormValidator implementation for validating the dialog with view
settings.
Definition of an interface for dealing with widgets.
Definition of an interface for describing windows in a platform independent
way.
Abstract base class for Swing
Window implementations that are
based on java.awt.Window.
A base class for all tag handler classes that create windows.
A data class that stores important information needed during a window builder
process.
A specialized exception class used for reporting error conditions related to
the window builder.
The tag library with the window builder tags.
Definition of an interface used to control whether a window can be closed.
A tag handler class that allows the creation of window controllers.
Definition of an interface for providing (platform-independent) information
about a window to be created.
An event class used by the window builder framework to deliver event
information related to windows.
An enumeration for the different types of window events.
Definition of an interface that must be implemented by objects that are
interested in window related events.
A specialized event listener tag that can be used to register window
listeners.
Definition of an interface for platform (or GUI library) specific window
manager implementations.
A base class for wrapper implementations of the
WindowManager
interface.
A static utility class providing useful functionality for dealing with
Window objects.
Definition of an interface for objects that wrap "real" windows.
HelperInvocationsinstead; it provides some dummy implementations of theInvokableinterface which are useful in some situations where a full-blown implementation is not required.