To create the filter based on the Auction status use the following:

class StatusFilter extends FilterSpec
{
private String status;
public StatusFilter (String s)
{
status = s;
}
public boolean evaluate(Object o)
{
return (((Auction)
o).status.equals(status));
}
public String getName()
{
return status;
}
}

The code for creating the sort by ItemNo, Name of the Auction is as follows.

class IDSort extends SortSpec
{
public String
getSortString(Object o)
{
return ((Auction) o).itemNo;
}
public String getName()
{
return ("Item No");
}
}

class NameSort extends SortSpec
{
publicString
getSortString(Object o)
{
return ((Auction) o).name;
}
public String getName()
{
return ("Name");
}
}

Another Example
The ListPanel is a flexible component. Figure 2 shows another list created on a totally different object, User. This list has three filters (active, inactive, all) and two sorts (ID, LastnameFirstname). This entire GUI is created in one routine, createListPane() shown in Listing 3.

Figure 2

In Listing 3, you can see that because the FilterSpec and SortSpec are all small classes, I've made them all inner classes. In situations where I have a lot of little classes used in one place, inner classes are useful to avoid proliferation of classes.

ListTabPanel
ListTabPanel contains a ListPanel and a TabPanel. It provides a structure that you can add tabs to to perform different actions on a particular selected object from the list. The implementation uses the Mediator pattern, where the ListTabPanel is a mediator that takes care of the communication between the ListPanel and the TabPanel.

Using the same Auction class I discussed earlier and the AuctionList, I create the AuctionPanel shown in Figure 3.

Figure 3

Creating the AuctionPanel involves three simple steps:

1. Create the Auction ListPanel defined in the previous section.
2. Create a TabPanel that contains three different tabs.
3. Call the constructor, passing it the ListPanel and the TabPanel.

ListPanel l = AuctionList.createListPanel();
TabPanel t = createTabPanel();
ListTabPanel p = new ListTabPanel (l, t);

TabPanel t = new TabPanel();
t.addTab(new AuctionTab());
t.addTab(new MinimalTab("Seller"));
t.addTab(new
MinimalTab("Buyer"));

public class AuctionTab extends TabObject
{
public AuctionTab()
{
// ... Create the GUI here
}

public void setData(Object o)
{
// ... populate the data to the GUI
}
}

1.   Creates the GUI in the constructor

2.   Implements the method setData to populate the GUI with an object

3.   Manipulates the object in its own way and updates it as appropriate (e.g., save to database, etc.); when manipulated, an object should call the appropriate methods notifyAdd(), notifyDelete, or notifyUpdate() to let its listener know of the change

Listing 4 provides the code for AuctionPanel.

Implementation of the ListPanel
The ListPanel component provides a GUI that can filter, sort, display, and search any kind of object. The component has no idea what kind of objects are in the list and how it should filter or sort; it's up to the developer to define this information by calling:

• setData (List data)
• addFilterSpec (FilterSpec f)
• addSortSpec (SortSpec s)

• Creating JComboBox to allow the user to choose the methods to sort and filter
• Filtering the data according to the filter the user selected
• Sorting the data according to the sort the user selected
• Displaying the data according to the sort the user selected
• Implementing the search according to the sort the user selected

• Filter from a list based on some condition and return a filtered list
• Search from a list based on some condition and return the first object that matches

The Jakarta Commons Collections (http://jakarta.apache.org/commons/index.html) is a set of reusable components related to collections. It strives to provide some features that were left unfilled by Sun's implementations in the Collection class.

Using Jakarta Commons Collections you can search and filter a collection of data based on a Predicate using the method search and find in the CollectionsUtil class. Predicate is an abstract class with a method evaluate(Object o) that performs some Predicate that returns true or false based on the input object. In addition, the CollectionUtils class provides set theory methods like intersection and union if you want to operate the filter on more than one condition.

Implementation Details
The ListPanel has three pieces of information after the developer creates an instance of it: dataList (a list of all objects), filterList (a list of all filters), and sortList (a list of all sorts).

Using filterList and sortList, ListPanel creates combo boxes that contain lists of all available filters and sorts. When the user selects a sort or a filter, the currentFilter or currentSort object is updated, and the method refresh is called. In refresh, the data is first filtered as follows:

// Filter the data according to currentFilter
filteredData = CollectionUtils.select(data, currentFilter);
displayModel.clear();
Iterator i = filteredData.iterator();
while (i.hasNext())
displayModel.addElement(i.next());

After the data is filtered, it's sorted as follows:

// Sort the data according to currentSort
displayModel.sort(currentSort);
displayList.setModel (displayModel);

// Display the data according to currentSort
displayList.setCellRenderer(currentSort);

Next, I display the data in the JList by setting the cellRenderer. Again you can see that SortSpec extends DefaultListCellRenderer, which means you can just pass currentSort to the setCellRenderer(ListCellRenderer) method.

Last, when the user types something in the text field and hits the search button, the method search does the following:

currentSort.setSearch(searchTF.getText());
Object o = CollectionUtils.find
(filteredData,currentSort);
displayList.setSelectedValue(o, true);

Listing 5 provides the code for the ListPanel.

Implementation of ListTabPanel
To understand how the ListTabPanel is implemented, you first need to understand the Mediator pattern. Mediator is a pattern that promotes loose coupling between classes. It accomplishes this by being the only class with detailed knowledge of the methods of other classes. Classes inform the Mediator when changes occur, and the Mediator then passes them on to any other classes that need to be informed.

The ListTabPanel (which contains the ListPanel and the TabPanel) is the Mediator here. The ListPanel and TabPanel don't know about each other. They notify only the ListTabPanel of changes in themselves, or get notified by the ListTabPanel when changes come in. Clearly defining the tasks of each component will make coding easy and clear. Let's now look at the tasks of each component:

Tasks of the ListPanel

Tasks of the TabPanel

Tasks of the ListTabPanel