Package com.arsdigita.bebop

A set of server-side user interface components for web applications.

See:
          Description

Interface Summary
Component The common interface implemented by all Bebop components.
ComponentSelectionModel Encapsulates the selection of a single object from many possibilities.
Container The common interface that is implemented by all Bebop containers.
ExcursionComponent ExcursionComponent
PaginationModelBuilder A model builder for the Paginator component.
Portlet An interface specifying Component-like behavior for a Portlet, insofar as XML generation is concerned.
PropertyEditorModel Provides properties for the PropertyEditor during each request.
PropertyEditorModelBuilder Generates a PropertyEditorModel for the PropertyEditor during each request.
PropertySheetModel An abstraction that the PropertySheet class uses to display a 2-column table of label-value pairs.
PropertySheetModelBuilder Constructs a new PropertySheetModel for the PropertySheet.
Resettable Interface that should be implemented by components that have state parameters that need to be reset when the component is shown to the user.
RowSequenceBuilder  
SingleSelectionModel Encapsulates the selection of a single object from many possibilities.
 

Class Summary
AbstractPortlet An abstract implementation of Portlet that captures default behavior for portlets defined by users of the Portal component.
AbstractSingleSelectionModel A standard implementation of SingleSelectionModel and Lockable.
ActionLink A link that runs its action listeners when it is clicked.
BaseLink The parent of all Bebop Link classes, this class represents a URL on a page.
BasePage The base page class for use with the PageFactory class.
Bebop  
BebopApplicationServlet Deprecated. Use BebopApplicationServlet instead
BebopConfig  
BebopMapDispatcher Deprecated. Use BebopMapDispatcher instead
BlockStylable Abstract class that contain the CSS-like Block Stylable attributes.
BoxPanel A container that prints its components in one row, either horizontally or vertically.
Column A column in a Multiple.
ColumnPanel A container that prints its components in a table.
Completable Completable
ComponentPool Component pool for recycling component instances.
CompoundComponent Provides a convenient method of creating components that are an aggregation of other components and that should have the public interface of a component (rather than that of a container, form, and so on).
ConfirmPage A Bebop Confirmation Page which should be mounted at ConfirmPage.CONFIRM_URL by the BebopMapDispatcher.
ControlLink A link back to the page in which it is contained.
DefaultSingleSelectionModel  
DimensionalNavbar Delimited dimensional navbar.
DynamicListWizard A SplitWizard that can be used to maintain a list of items.
ElementComponent A component that gets its text entirely from a single XSL element.
ExternalLink A link to an external (non-ACS) site.
Form Represents the visual structure of an HTML form.
FormData Manages the data associated with forms and other remote sources.
FormModel A container for two classes of objects: ParameterModels and ValidationListeners.
FormSection A standalone section of a Form.
FormStep The FormStep class modifies the behavior of FormSection with respect to listener firing.
Grid Displays a ListModel as a grid (that is, a Table) of given width.
GridPanel A container that prints its components in a table.
GridTableModel Converts a linear ListModel to a grid of items.
HorizontalLine A solid, horizontal line.
Image A simple wrapper class for images.
Label A text label.
Link A URL on a page.
List A List, similar to a javax.swing.JList, that keeps track of a sequence of items and selections of one or more of these items.
ListPanel A container that outputs its components in a <list>.
MapComponentSelectionModel A simple implementation of a ComponentSelectionModel.
MapWizard A SplitWizard that can be used to implement the classic, static wizard.
MetaForm A form that is instantiated on a per-request basis.
ModalContainer A modal container is a container that manages visibility for a set of components.
Multiple .
MultiStepForm The MultiStepForm class is a simple extension to Form that modifies the behavior of Form with respect to widgets that are not visible.
Page The top-level container for all Bebop components and containers.
PageDispatcher Deprecated. Use PageDispatcher instead.
PageErrorDisplay Displays validation errors for the page.
PageErrorDisplay.StringIteratorModel  
PageFactory The PageFactory provides a framework for instantiating instances of the Bebop Page class in a project- and application-independant manner.
PageState The request-specific data (state) for a Page.
Paginator A pagination component used to select different page views from a list of items.
ParameterSingleSelectionModel An implementation of SingleSelectionModel that uses a state parameter for managing the currently selected key.
PropertyEditor Maintains a set of forms that are used when editing the properties of some object.
PropertyEditor.DefaultModel Default implementation of the PropertyEditorModel.
PropertyEditor.DefaultModelBuilder Default implementation of the PropertyEditorModelBuilder.
PropertyEditor.IdentityCellRenderer Renders the components generated by the model directly
PropertySheet Displays a list of label-value pairs that represent the properties of some object.
PropertySheet.GlobalizedLabelCellRenderer  
PropertySheet.StringLabelCellRenderer  
RequestLocal A variable whose value is local to each request.
SaveCancelSection A form section with two buttons (Save and Cancel) aligned to the right.
SegmentedPanel Generates a list of segments.
SegmentedPanel.Segment A single Segment within this container
SimpleComponent A simple implementation of the Component interface.
SimpleContainer A basic implementation of the Container interface.
SlaveComponent Demarcates the position of a slave page subtree inside another page's component tree.
SplitPanel Consists of two table cells with a dividing bar in the middle.
SplitWizard A wizard that associates links with components.
SplitWizard.HeaderPanel A simple class which displays a label above some component.
TabbedPane A tabbed pane that lets the user switch between components by clicking on a given title in the tab strip.
Table Displays statically or dynamically generated data in tabular form.
Table.MatrixTableModelBuilder An internal class that creates a table model around a set of data given as a Object[][].
TextStylable Encapsulates standard methods to style text in a Bebop component.
ToggleLink A component that is either selected or not.
Tree Used to print a tree structure.
Tree.TreeSingleSelectionModel Deprecated. The ParameterSingleSelectionModel contains all the functionality of this class
Wizard The Wizard class can be used in conjunction with FormStep to build a series of forms that gather information from the user in several stages.
YesNoSection  
 

Exception Summary
FormProcessException This class represents exceptions that occur within the processing methods of any of the form event listeners.
FormValidationException FormValidationException
SessionExpiredException  
 

Package com.arsdigita.bebop Description

A set of server-side user interface components for web applications. The user interface components are similar to those of traditional GUIs, such as Sun's Swing.

To learn how Bebop works, start with the documentation for the class Page, the top level container of all Bebop components.

State management

Bebop makes the creation and use of stateful user interface components easy. It helps developers of such components manage the state of one component (for example, a tabbed pane) in a transparent and isolated way.

Nested Containers

Bebop components and containers can be nested arbitrarily deep. For example, it is possible to build a page that contains a TabbedPane that contains a Form that contains a Table that contains a checkbox widget in every row.

Static and request-specific objects

Every Bebop component lets you split the underlying data structures into two parts:

The static part of a page can be built once and then be reused for all the requests to the page. This initialization is typically done in the init method of a servlet. Classes that contain only static information implement the interface Lockable.

Request-specific data structures are built within the doPost or doGet methods of a servlet. Corresponding to the static Page, there is a PageState class that will carry all the request-specific information connected to the Page. If your application needs to modify parts of a Page during a request, you need to build the page in the servlet's doPost or doGet methods.

As a simple example, consider a page that displays a login screen. The login screen is a form that accepts a screen_name and a password. The static part of the page consists of building up the component hierarchy and locking it. This code would typically be in the init method of a servlet:

    // Create a text widget for screen_name which can not be empty.
    Text screenName = new Text("screen_name");
    screenName.addValidationListener(new NotNullValidationListener());
    // Create a text widget for the password which can not be empty.
    Password password = new Password("password");
    password.addValidationListener(new NotNullValidationListener());
    // Set up the form
    Form form = new Form("aForm");
    form.add(screenName);
    form.add(password);
    // Add a (hypothetical) custom password checker
    form.addValidationListener(new PasswordChecker(screenName, password));
    // Add a listener that forwards the user to his workspace
    form.addProcessListener(new SendUserToWorkspace());
    // Add the form to the page and signal that its building is finished:
    Page page = new Page();
    page.add(f);
    page.lock();

The last line of the above example is very important:

The call to Page.lock() locks the page and guarantees that no further modification to its structure is possible.

Example

The simplest use of this page in the doPost or doGet method of the servlet consists of a single call:

    page.service(request, response)
  

The Page.process method will initiate all the steps that are necessary to process the request. It notifies the form that a request has been made and prints the page that results from the form that processes the request.

To process the request, the form extracts the parameter values from the request, runs validation listeners, and either runs process listeners (if the request was a valid submission) or displays the form together with error messages (if the request was not a valid submission).

Related Documentation


Last modified: 2001-06-22



Copyright (c) 2004 Red Hat, Inc. Corporation. All Rights Reserved. Generated at July 20 2004:2337 UTC