How to Use Tables

1. How to Use Tables The practice of JTable in swing

2. The JTable component • In many applications a Table is a natural representation to use: • Displays a grid of data consisting of rows and columns similar to a spreadsheet. • The JTableclass is NOT a spreadsheet, but it supports many features that make it superior to a simple spreadsheet component. • The JTable component that provides the power to present large amounts of data in a simple 2D display • it supports custom data modeling and display rendering

3. A Simple Table Example

4. A Simple table Example • Clicking the left mouse button on an individual cell will highlight the entire row and select the individual cell • Initially the select rectangle is surrounding the 89.2 value. • If you reduce the height of the window, the vertical scroll bar appears by default. • Resizing the frame in the horizontal direction automatically adds the horizontal scroll bar. • The application also inherits is the ability to reorganize and resize the columns: • Placing the mouse over a column name and dragging it (with the left mouse button pressed) allows the entire column to be moved to a new position. • When the mouse button is released, the selected column is dropped into its new location and the entire table is repainted to accommodate the adjustment. • Placing the mouse on the vertical separator between two column headers causes the pointer to change to a resize indicator. Holding down the left mouse button while dragging resizes the columns.

5. // Constructor of main frame public SimpleTableExample() { // Set the frame characteristics setTitle( "Simple Table Application" ); setSize( 300, 200 ); setBackground( Color.gray ); // Create a panel to hold all other components topPanel = new JPanel(); topPanel.setLayout( new BorderLayout() ); getContentPane().add( topPanel ); // Create columns names String columnNames[] = { "Column 1", "Column 2", "Column 3" }; // Create some data String dataValues[][] = { { "12", "234", "67" }, { "-123", "43", "853" }, { "93", "89.2", "109" }, { "279", "9033", "3092" } }; // Create a new table instance table = new JTable( dataValues, columnNames ); // Add the table to a scrolling pane scrollPane = new JScrollPane( table ); topPanel.add( scrollPane, BorderLayout.CENTER ); }

6. A More Complex Example

7. More complex example • Uses loader methods to load an array of eight columns by one hundred rows. • Additionally, the table is configured to show only the vertical grid lines and to allow simultaneous row and column selection. • Notice that with this example, when an individual cell is selected, a cross-hair selection pattern is formed, centered around the selected cell. • Also the foreground and background colours for the selection region have been altered for effect (since JTable supports colour changes for the selection area).

8. public AdvancedTableExample() { // Set the frame characteristics setTitle( "Advanced Table Application" ); setSize( 300, 200 ); setBackground( Color.gray ); // Create a panel to hold all other components topPanel = new JPanel(); topPanel.setLayout( new BorderLayout() ); getContentPane().add( topPanel ); // Create columns CreateColumns(); CreateData(); // Create a new table instance table = new JTable( dataValues, columnNames ); // Configure some of JTable's paramters table.setShowHorizontalLines( false ); table.setRowSelectionAllowed( true ); table.setColumnSelectionAllowed( true ); // Change the selection colour table.setSelectionForeground( Color.white ); table.setSelectionBackground( Color.red ); // Add the table to a scrolling pane scrollPane = table.createScrollPaneForTable( table ); topPanel.add( scrollPane, BorderLayout.CENTER ); }

9. Adding a Custom Data Model • The JTable supports the replacement of its data model in order to improve performance or to help reduce the size of the code required for a given application. • The custom data model feature used in JTable is actually simpler than the one used for (for example) the JTree class: • JTable only has to manage a simple 2D matrix of data • Re-engineer the code from the previous example. This example, • build a new application that uses a custom data model but • produces exactly the same results the previous example. • Though the output looks the same as the one shown previously, it offers much better performance, particularly as the size of the data set grows.

10. CustomDataTableExample • Contains the code for the main frame class, which is a modified version of the previous example: • the CreateData() method has been removed -- it is no longer required because the custom data model generates the data set. • the CreateColumns() method has been changed -- the code no longer uses an instance of the DefaultDataModel class (instantiated automatically by JTable in the previous example). • the application is now required to create its own columns -- the CreateColumns() method reverts to first principles by creating an instance of a TableColumn object and populating it with the appropriate text before adding it to the table. • the example now generates its own column data therefore it notifies the table not to attempt to determine this information from the data. It does this by calling JTable's setAutoCreateColumnsFromModel() method.

11. CustomDataModel • Thee custom data model, which extends the AbstractTableModel class and provides four methods called by the JTable code when data is accessed. • Since the data model is now synthesized, the getValueAt() method simply determines the row and column being accessed and generates a string representing the cell data. • The getColumnCount() method returns a value of zero, which may not be what you expected. Remember, though, that this method returns the number of columns managed by the table code. In the CreateColumns() method in the main CustomDataTableExample class, we informed the table that it should not attempt to generate any of its own columns. As a result, the value of getColumnCount() is zero. • Explore the full listings via the course web site

12. Custom Table Rendering • As in other components can alter the display by developing custom rendering classes. • Modify the initial example to implement a custom rendered JTable: • implements the custom rendering on top of the modified code from the first example • Instead of displaying numerical (X, Y) data, the code displays a card deck in tabular form • Each column represents a suit in the deck, with each cell drawn as a graphical suit and a card number.

13. CustomRenderTableExample • contains the code for the main frame of the application. The only significant notable in this file is the call the JTable's setCellRenderer() method, which informs the table object that all of its drawing will be handled by an external rendering class. • CustomCellRenderer • contains the code for the custom table cell renderer, implementing a method named getTableCellRendererComponent() to handle the drawing of individual cells. This method determines if the item it is drawing is selected or has the focus, and uses this information to control the foreground colour. Because of the restrictions with regards to painting the background colour, this class also provides a paint() method, which uses the selection and focus flags as well. • CustomDataModel • includes a custom data model, which is similar to previous examples. The only difference is in the number of rows in the model

15. Listening for Table Actions • Many situations demand that the application immediately detect changes initiated by the user. • These events can be sorted into two basic categories: • cell selections made by the user, and • user-invoked changes to the table itself.

16. Detecting Table Selections • The type of action usually involves a mouse click to select a single cell or a drag operation to select a range of values from the table. • JTable implements selection listeners in exactly the same way as the JList -- ListSelectionListener. • To enable selection events, the code adds a ListSelectionListener to the table's selection model. • valueChanged() method is required in order to implement ListSelectionListener.

17. public void valueChanged( ListSelectionEvent event ) { // See if this is a valid table selection if( event.getSource() == table.getSelectionModel() && event.getFirstIndex() >= 0 ) { // Get the data model for this table TableModel model = (TableModel)table.getModel(); // Determine the selected item String string = (String)model.getValueAt( table.getSelectedRow(), table.getSelectedColumn() ); // Display the selected item System.out.println( "Value selected = " + string ); } } • this method first determines if the event originates from our JTable instance's selection model, and then it ensures that the event references a valid selection. To access the selected cell, the code references the table's data model and simply extracts the data based on the selected row and column.

18. Detecting Column Property Changes • Second significant series of events produced by table activity relate to manipulations of the column presentation: • Any time the user moves a column from one place to another, or adds a new column, the table generates an event -- a column model change event. • To intercept these events, a listener must be associated with the table's column model. This is done using the following code: • // Handle the listener DefaultTableColumnModel columnModel = (DefaultTableColumnModel)table.getColumnModel(); columnModel.addColumnModelListener( this );

19. TableColumnModelListener Interface Methods called whenever the column model changes public void columnAdded( TableColumnModelEvent event ) public void columnRemoved( TableColumnModelEvent event ) public void columnMoved( TableColumnModelEvent event ) public void columnMarginChanged( ChangeEvent event ) public void columnSelectionChanged( ListSelectionEvent event ) • constants used as flags to control the resize state of columns in the table. These constants are used as parameters to the setAutoResizeMode() method. public static final int AUTO_RESIZE_LAST_COLUMN public static final int AUTO_RESIZE_OFF public static final int AUTO_RESIZE_ALL_COLUMNS

20. Key Variables • The following variables hold instances of the various models associated with a JTable object: • protected TableModel dataModel protected TableColumnModel columnModel protected ListSelectionModel selectionModel • The protected JTableHeader tableHeader variable holds the instance of the table headers for this JTable object. The header holds particulars, such as, the column object. • The following variables contain information to manage the attributes of a table row: • protected int rowHeight protected int rowMargin • The colour of the grid lines drawn in the table is stored in the protected Color gridColor variable.

21. More key variables • The following boolean flags contain information about the states of particular modes within the JTable object: • protected boolean showHorizontalLines protected boolean showVerticalLines protected boolean autoCreateColumnsFromModel protected boolean rowSelectionAllowed • The value of the protected int autoResizeMode variable determines if the table object automatically resizes the width the columns to occupy the entire width of the table. It is also used to decide how the resizing is done. • The protected Dimension preferredViewportSize variable is used by the scrolling pane instance associated with the table object. It determines the initial visible area for the table. • When the table is performing a cell editing operation, the protected transient Component editorComp variable holds an instance of the component used to handle the editing operation.

22. JTable variables • The protected transient TableCellEditor cellEditor variable holds an instance of the cell editor used by this table object. • When editing table cells, the following variables contain the row and column address of the cell being edited. • protected transient int editingRow protected transient int editingColumn • The following variables are used to keep track of the default cell editors and renderers known to this table object: • protected Hashtable defaultRenderersByColumnClass protected Hashtable defaultEditorsByColumnClass • These variables contain the colours of the foreground and background used to draw selected text. These values are overridden by any custom cell render code: • protected Color selectionForeground protected Color selectionBackground

23. Summary • Presented an Overview of JTree • Should read these notes alongside the example code available on the web site • Down run compile and run the code • Supplement by looking at the Sun tutorials on Jtree (be award of the1.6 dependency) • Next • Consider how the different components can best be put together by looking at the graphical design and interface principles