Package com.arsdigita.bebop.table

Contains the supporting classes for the Table component.

See:
          Description

Interface Summary
TableCellRenderer Render one cell in a table.
TableColumnModel Describe interface TableColumnModel here.
TableModel The TableModel is the abstraction a Table uses to access the data it displays.
TableModelBuilder Builds the request-specific table models.
 

Class Summary
AbstractTableModelBuilder A convenience for implementing TableModelBuilders.
DefaultTableCellRenderer The default renderer for table cells.
DefaultTableColumnModel Describe interface TableColumnModel here.
TableColumn One column in a table.
TableHeader This class is used by Table in order to maintain its headers.
 

Package com.arsdigita.bebop.table Description

Contains the supporting classes for the Table component. The Table component itself is part of the com.arsdigita.bebop package, but all its parts are contained in this package.

A gentle introduction to tables

The simplest way to construct a table is from static data contained in two arrays, one for the data and one for the header of the table:

      String[] headers = { "Fruit", "Color" };
      String[][] data = {
        { "banana", "yellow" },
        { "orange", "orange" },
        { "strawberry", "red" }
      };
      Table table = new Table(data, headers);
    

This table can now be added to a Page and will produce output similar to this table every time the page is rendered:

Fruit Color
bananayellow
orangeorange
strawberryred

Of course, the table component wouldn't be very useful if it could only display static data in this manner. A table can also be used to display data that is dynamically generated from database query. For this, a TableModelBuilder needs to be implemented. The TableModelBuilder's getModel method is called by the table every time it needs to render itself. For database-backed tables, the table model builder will usually run a query and wrap the result of the query in a TableModel. The table then uses this table model as the source for its data during rendering. It is very important to note that the table does not cache the table model in any way - this automatically ensures that the table always displays the latest data available. If caching is needed for performance reasons, the table model builder is responsible for implementing its own caching strategy.

Another important feature of tables is that they make it easy to react with the user's interaction with the table data. By default, a table displays all its data by wrapping it in a Label, leading to the data being displayed as a string on the resulting HTML page. But many tables contain links in each row, as the following table shows (the links are non-functional):

Fruit Color Action
bananayellow ( peel )
orangeorange ( peel )
strawberryred ( eat )

The code to set this table up from static data is not much more complicated than for the first table:

      String[] headers = { "Fruit", "Color", "Action" };
      String[][] data = {
        { "banana", "yellow", "peel" },
        { "orange", "orange", "peel" },
        { "strawberry", "red", "eat" }
      };
      Table table = new Table(data, headers);
      table.getColumn(2).setCellRenderer(new DefaultTableCellRenderer(true));
    

All that has changed is that we added more entries to headers and data and that we changed the renderer for the last column (column number 2) of the table. We can now add a TableActionListener to the table and perform the necessary actions whenever the user clicks on peel or eat:

      table.addTableActionListener(
        new TableActionAdapter() {
          public void cellSelected(TableActionEvent e) {
            Object row = e.getRowKey();
            if ( "2".equals(row) ) {
              System.out.println("User wants to eat a strawberry.");
            } else {
              System.out.print("User wants to peel");
              if ( "0".equals(row) ) {
                System.out.println(" a banana.");
              } else {
                System.out.println(" a banana.");
              }
            }
          }
        }); 
    

Anatomy of a table

A table consists of many parts. By default they are set to "reasonable" values that make the table behave in very simple ways. As the last example shows, small modifications to those defaults makes it possible to give a table more complex layout and/or behavior.

At a high level, a table consists of a header and some columns. Each Table maintains a list of its columns in a TableColumnModel and uses an implicit TableHeader object for rendering and receiving header-related events.

The columns are represented by a list of TableColumn objects. This list of columns is stored in the table's TableColumnModel. Each TableColumn object stores important display-related information about a table column, such as the column header, the renderers for the column header and ordinary cells in this column and from which column in the table model values should be taken when rendering table cells.

FIXME: ... to be continued ...


Last modified: 2001-06-22



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