Mehrere TableModels zu einem einzigen zusammenfügen

RangeTableModel

Mit folgendem Code kann man mehrere TableModels zu einem zusammenfügen, oder bestimmte Zeilen/Spaltenmengen aus einem bestehenden TableModel als ein neues, eigenständiges TableModel anbieten.
Trivialkram, aber immerhin braucht jemand, der das braucht, diesen Trivialkram dann nicht mehr selbst zu schreiben.

<code=java> import java.util.*; import javax.swing.event.*; import javax.swing.table.*;

/**

* This class provides utility methods to create special TableModels
* that are composed of other TableModels, or consist of selected
* subsets of rows and columns of other TableModels
*/

class TableModelUtils {

   /**
    * Creates a TableModel that composes the given TableModels into
    * one. The number of rows of the resulting TableModel will be
    * the maximum of all row counts of the given TableModels
    *
    * @param tableModels The TableModels to combine
    * @return A TableModel combining the given TableModels
    */
   public static TableModel createCompoundTableModel(TableModel ... tableModels)
   {
       return new CompoundTableModel(tableModels);
   }

   /**
    * Creates a new TableModel which represents the "sub-table" that is
    * described by the given row- and column indices
    *
    * @param tableModel The TableModel from which the given sub-table
    * should be taken
    * @param col0 The first column of the sub-table, i.e. index of the
    * column in the given TableModel that should be the column with
    * index 0 in the returned model
    * @param row0 The first row of the sub-table, i.e. index of the
    * row in the given TableModel that should be the row with
    * index 0 in the returned model
    * @param col1 The column index where the sub-table should end
    * @param row1 The row index where the sub-table should end
    * @return A sub-table of the given TableModel
    */
   public static RangeTableModel createSubTableModel(TableModel tableModel, int row0, int col0, int row1, int col1)
   {
       return new RangeTableModel(tableModel, row0, col0, row1, col1);
   }

   /**
    * Creates a TableModel that consists of the rows with the
    * given indices of the given TableModel
    *
    * @param tableModel The TableModel from which the rows
    * will be taken
    * @param indices The indices of the rows that should be
    * contained in the resulting TableModel
    * @return
    */
   public static TableModel createRowSelectionTableModel(TableModel tableModel, int ... indices)
   {
       return new SelectionTableModel(tableModel, indices, null);
   }

   /**
    * Creates a TableModel that consists of the columns with the
    * given indices of the given TableModel
    *
    * @param tableModel The TableModel from which the columns
    * will be taken
    * @param indices The indices of the columns that should be
    * contained in the resulting TableModel
    * @return
    */
   public static TableModel createColumnSelectionTableModel(TableModel tableModel, int ... indices)
   {
       return new SelectionTableModel(tableModel, null, indices);
   }

   /**
    * This class is a TableModel that combines several other TableModels
    */
   private static class CompoundTableModel implements TableModel
   {
       /**
        * The TableModels that are combined in this TableModel
        */
       private List<TableModel> tableModels;

       /**
        * Create a new CompoundTableModel, combining the given TableModels
        *
        * @param tableModels The TableModels to combine
        */
       public CompoundTableModel(TableModel ... tableModels)
       {
           this.tableModels = new ArrayList<TableModel>(Arrays.asList(tableModels));
       }

       /**
        * {@inheritDoc}
        */
       public void addTableModelListener(TableModelListener tableModelListener)
       {
           for (TableModel tableModel : tableModels)
           {
               tableModel.addTableModelListener(tableModelListener);
           }
       }

       /**
        * {@inheritDoc}
        */
       public void removeTableModelListener(TableModelListener tableModelListener)
       {
           for (TableModel tableModel : tableModels)
           {
               tableModel.removeTableModelListener(tableModelListener);
           }
       }

       /**
        * {@inheritDoc}
        */
       public Class getColumnClass(int columnIndex)
       {
           for (TableModel tableModel : tableModels)
           {
               if (tableModel.getColumnCount() > columnIndex)
               {
                   return tableModel.getColumnClass(columnIndex);
               }
               columnIndex -= tableModel.getColumnCount();
           }
           throw new IllegalArgumentException("No column found for the given index");
       }

       /**
        * {@inheritDoc}
        */
       public int getColumnCount()
       {
           int columnCount = 0;
           for (TableModel tableModel : tableModels)
           {
               columnCount += tableModel.getColumnCount();
           }
           return columnCount;
       }

       /**
        * {@inheritDoc}
        */
       public String getColumnName(int columnIndex)
       {
           for (TableModel tableModel : tableModels)
           {
               if (tableModel.getColumnCount() > columnIndex)
               {
                   return tableModel.getColumnName(columnIndex);
               }
               columnIndex -= tableModel.getColumnCount();
           }
           throw new IllegalArgumentException("No column found for the given index");
       }

       /**
        * {@inheritDoc}
        */
       public int getRowCount()
       {
           int maxRowCount = -1;
           for (TableModel tableModel : tableModels)
           {
               maxRowCount = Math.max(maxRowCount, tableModel.getRowCount());
           }
           return maxRowCount;
       }

       /**
        * {@inheritDoc}
        */
       public Object getValueAt(int rowIndex, int columnIndex)
       {
           for (TableModel tableModel : tableModels)
           {
               if (tableModel.getColumnCount() > columnIndex)
               {
                   if (rowIndex < tableModel.getRowCount())
                   {
                       return tableModel.getValueAt(rowIndex, columnIndex);
                   }
                   else
                   {
                       return null;
                   }
               }
               columnIndex -= tableModel.getColumnCount();
           }
           throw new IllegalArgumentException("No column found for the given index");
       }

       /**
        * {@inheritDoc}
        */
       public void setValueAt(Object aValue, int rowIndex, int columnIndex)
       {
           for (TableModel tableModel : tableModels)
           {
               if (tableModel.getColumnCount() > columnIndex)
               {
                   if (rowIndex < tableModel.getRowCount())
                   {
                       tableModel.setValueAt(aValue, rowIndex, columnIndex);
                   }
                   else
                   {
                       throw new IllegalArgumentException("No cell found for the given row index");
                   }
               }
               columnIndex -= tableModel.getColumnCount();
           }
           throw new IllegalArgumentException("No column found for the given index");
       }

       /**
        * {@inheritDoc}
        */
       public boolean isCellEditable(int rowIndex, int columnIndex)
       {
           for (TableModel tableModel : tableModels)
           {
               if (tableModel.getColumnCount() > columnIndex)
               {
                   if (rowIndex < tableModel.getRowCount())
                   {
                       return tableModel.isCellEditable(rowIndex, columnIndex);
                   }
                   else
                   {
                       return false;
                   }
               }
               columnIndex -= tableModel.getColumnCount();
           }
           throw new IllegalArgumentException("No column found for the given index");
       }
   }

   /**
    * This class describes a TableModel which represents a selection
    * of rows and columns of another TableModel
    */
   private static class SelectionTableModel implements TableModel
   {
       /**
        * The TableModel from which the rows and columns are selected
        */
       private TableModel tableModel;

       /**
        * The selection of rows
        */
       private int rowSelection[];

       /**
        * The selection of columns
        */
       private int columnSelection[];

       /**
        * Creates a new SelectionTableModel, which selects the specified rows
        * and columns from the given TableModel. The selections may be null.
        * Then all rows/columns will be selected, respectively
        *
        * @param tableModel The TableModel from which the rows and columns are selected
        * @param rowSelection The selection of rows
        * @param columnSelection The selection of columns
        */
       public SelectionTableModel(TableModel tableModel, int rowSelection[], int columnSelection[])
       {
           this.tableModel = tableModel;
           if (rowSelection != null)
           {
               this.rowSelection = rowSelection.clone();
           }
           else
           {
               this.rowSelection = createSelectionFromSize(tableModel.getRowCount());
           }
           if (columnSelection != null)
           {
               this.columnSelection = columnSelection.clone();
           }
           else
           {
               this.columnSelection = createSelectionFromSize(tableModel.getColumnCount());
           }
       }

       /**
        * Creates a selection containing all indices from 0 to size-1
        *
        * @param size The size of the selection
        * @return The selection array
        */
       static int[] createSelectionFromSize(int size)
       {
           int selected[] = new int[size];
           for (int i=0; i<selected.length; i++)
           {
               selected[i] = i;
           }
           return selected;
       }

       /**
        * Creates a selection containing all indices from min to max-1
        *
        * @param min The minimum value to be selected
        * @param max The maximum value to be selected
        * @return The selection array
        */
       static int[] createSelectionFromRange(int min, int max)
       {
           int selected[] = new int[max-min];
           for (int i=0; i<selected.length; i++)
           {
               selected[i] = i + min;
           }
           return selected;
       }

       /**
        * {@inheritDoc}
        */
       public void addTableModelListener(TableModelListener tableModelListener)
       {
           tableModel.addTableModelListener(tableModelListener);
       }

       /**
        * {@inheritDoc}
        */
       public void removeTableModelListener(TableModelListener tableModelListener)
       {
           tableModel.removeTableModelListener(tableModelListener);
       }

       /**
        * {@inheritDoc}
        */
       public Class getColumnClass(int columnIndex)
       {
           return tableModel.getColumnClass(columnSelection[columnIndex]);
       }

       /**
        * {@inheritDoc}
        */
       public int getColumnCount()
       {
           return columnSelection.length;
       }

       /**
        * {@inheritDoc}
        */
       public String getColumnName(int columnIndex)
       {
           return tableModel.getColumnName(columnSelection[columnIndex]);
       }

       /**
        * {@inheritDoc}
        */
       public int getRowCount()
       {
           return rowSelection.length;
       }

       /**
        * {@inheritDoc}
        */
       public Object getValueAt(int rowIndex, int columnIndex)
       {
           return tableModel.getValueAt(rowSelection[rowIndex], columnSelection[columnIndex]);
       }

       /**
        * {@inheritDoc}
        */
       public void setValueAt(Object aValue, int rowIndex, int columnIndex)
       {
           tableModel.setValueAt(aValue, rowSelection[rowIndex], columnSelection[columnIndex]);
       }

       /**
        * {@inheritDoc}
        */
       public boolean isCellEditable(int rowIndex, int columnIndex)
       {
           return tableModel.isCellEditable(rowSelection[rowIndex], columnSelection[columnIndex]);
       }

   }

   /**
    * This class describes a TableModel which represents a range
    * of rows and columns of another TableModel
    */
   public static class RangeTableModel implements TableModel
   {
       /**
        * The TableModel from which the rows and columns are selected
        */
       private TableModel tableModel;

       /**
        * The TableModelListeners that have been added to this TableModel
        */
       private List<TableModelListener> tableModelListeners = new ArrayList<TableModelListener>();

       /**
        * The minimum row
        */
       private int minRow;

       /**
        * The maximum row
        */
       private int maxRow;

       /**
        * The minimum column
        */
       private int minColumn;

       /**
        * The maximum column
        */
       private int maxColumn;

       /**
        * Creates a new SelectionTableModel, which selects the specified rows
        * and columns from the given TableModel.
        *
        * @param tableModel The TableModel from which the rows and columns are selected
        * @param minRow The row of the given model which will be row 0 in this model
        * @param minColumn The column of the given model which will be column 0 in this model
        * @param maxRow The row of the given model which will be the last row in this model
        * @param maxColumn The column of the given model which will be the last column in this model
        */
       public RangeTableModel(TableModel tableModel, int minRow, int minColumn, int maxRow, int maxColumn)
       {
           this.tableModel = tableModel;
           this.minRow = minRow;
           this.maxRow = maxRow;
           this.minColumn = minColumn;
           this.maxColumn = maxColumn;
       }

       /**
        * Set the range that is displayed by this RangeTableModel.
        *
        * @param minRow The row of the given model which will be row 0 in this model
        * @param minColumn The column of the given model which will be column 0 in this model
        * @param maxRow The row of the given model which will be the last row in this model
        * @param maxColumn The column of the given model which will be the last column in this model
        */
       public void setRange(int minRow, int minColumn, int maxRow, int maxColumn)
       {
           this.minRow = minRow;
           this.maxRow = maxRow;
           this.minColumn = minColumn;
           this.maxColumn = maxColumn;
           if (tableModelListeners.size() > 0)
           {
               TableModelEvent tableModelEvent = new TableModelEvent(this, TableModelEvent.HEADER_ROW);
               for (TableModelListener tableModelListener : tableModelListeners)
               {
                   tableModelListener.tableChanged(tableModelEvent);
               }
           }
       }

       /**
        * {@inheritDoc}
        */
       public void addTableModelListener(TableModelListener tableModelListener)
       {
           tableModel.addTableModelListener(tableModelListener);
           tableModelListeners.add(tableModelListener);
       }

       /**
        * {@inheritDoc}
        */
       public void removeTableModelListener(TableModelListener tableModelListener)
       {
           tableModel.removeTableModelListener(tableModelListener);
           tableModelListeners.remove(tableModelListener);
       }

       /**
        * {@inheritDoc}
        */
       public Class getColumnClass(int columnIndex)
       {
           return tableModel.getColumnClass(columnIndex+minColumn);
       }

       /**
        * {@inheritDoc}
        */
       public int getColumnCount()
       {
           return maxColumn - minColumn + 1;
       }

       /**
        * {@inheritDoc}
        */
       public String getColumnName(int columnIndex)
       {
           return tableModel.getColumnName(columnIndex+minColumn);
       }

       /**
        * {@inheritDoc}
        */
       public int getRowCount()
       {
           return maxRow - minRow + 1;
       }

       /**
        * {@inheritDoc}
        */
       public Object getValueAt(int rowIndex, int columnIndex)
       {
           return tableModel.getValueAt(rowIndex + minRow, columnIndex + minColumn);
       }

       /**
        * {@inheritDoc}
        */
       public void setValueAt(Object aValue, int rowIndex, int columnIndex)
       {
           tableModel.setValueAt(aValue, rowIndex + minRow, columnIndex + minColumn);
       }

       /**
        * {@inheritDoc}
        */
       public boolean isCellEditable(int rowIndex, int columnIndex)
       {
           return tableModel.isCellEditable(rowIndex + minRow, columnIndex + minColumn);
       }

   }

} </code=java>

Und noch ein kleines Testprogram... <code=java> import java.util.*; import java.util.List;

import javax.swing.event.*; import javax.swing.table.TableModel;

import java.awt.*; import javax.swing.*; import javax.swing.table.*;

/**

* Test class for the TableModelUtils
*/

class TableModelUtilsTest extends JFrame {

   public static void main(String args[])
   {
       new TableModelUtilsTest();
   }

   public TableModelUtilsTest()
   {
       super("TableModelUtils test");
       setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

       TableModel tm0 = new DefaultTableModel(
           new Object[][] {
               { "tm0 c00", "tm0 c01", "tm0 c02" },
               { "tm0 c10", "tm0 c11", "tm0 c12" },
               { "tm0 c20", "tm0 c21", "tm0 c22" } },
           new Object[]
               { "tm0 h0", "tm0 h1", "tm0 h2" });

       TableModel tm1 = new DefaultTableModel(
           new Object[][] {
               { "tm1 c00", "tm1 c01", "tm1 c02", "tm1 c03", "tm1 c04" },
               { "tm1 c10", "tm1 c11", "tm1 c12", "tm1 c13", "tm1 c14" },
               { "tm1 c20", "tm1 c21", "tm1 c22", "tm1 c23", "tm1 c24" },
               { "tm1 c30", "tm1 c31", "tm1 c32", "tm1 c33", "tm1 c34" },
               { "tm1 c40", "tm1 c41", "tm1 c42", "tm1 c43", "tm1 c44" } },
           new Object[]
               { "tm1 h0", "tm1 h1", "tm1 h2", "tm1 h3" , "tm1 h4" });

       JPanel p = new JPanel();
       p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));

       p.add(createPanel("Input model 0", tm0));
       p.add(createPanel("Input model 1", tm1));

       p.add(createRangePanel(TableModelUtils.createSubTableModel(tm1, 0,0,4,4)));

       p.add(createPanel("Compound of model 0 and model 1",
                         TableModelUtils.createCompoundTableModel(tm0, tm1)));
       p.add(createPanel("Sub(1,1,4,4) of model 1",
                         TableModelUtils.createSubTableModel(tm1, 1,1,4,4)));
       p.add(createPanel("RowSelection(0,2,4) of model 1",
                         TableModelUtils.createRowSelectionTableModel(tm1, 0,2,4)));
       p.add(createPanel("ColumnSelection(0,2,4) of model 1",
                         TableModelUtils.createColumnSelectionTableModel(tm1, 0,2,4)));

       TableModel tableModel = null;
       tableModel = TableModelUtils.createCompoundTableModel(tm0, tm1);
       tableModel = TableModelUtils.createSubTableModel(tableModel, 1,1,4,5);
       tableModel = TableModelUtils.createRowSelectionTableModel(tableModel, 0,2);
       tableModel = TableModelUtils.createColumnSelectionTableModel(tableModel, 0,2,4);
       p.add(createPanel("<html>ColumnSelection(0,2,4) of "+"RowSelection(0,2) of " +
                         "Sub(1,1,4,4) of " + "Compound of model 0 and model 1",tableModel));

       getContentPane().add(new JScrollPane(p));
       setSize(800,300);
       setVisible(true);
   }

   private JPanel createPanel(String infoString, TableModel tableModel)
   {
       JPanel panel = new JPanel(new BorderLayout());
       JLabel label = new JLabel(infoString);
       panel.add(label, BorderLayout.NORTH);
       panel.add(new JScrollPane(new JTable(tableModel)), BorderLayout.CENTER);
       return panel;
   }

   private JPanel createRangePanel(final TableModelUtils.RangeTableModel tableModel)
   {
       JPanel panel = new JPanel(new BorderLayout());

       JPanel p = new JPanel(new BorderLayout());
       p.add(new JLabel("Selection of range"), BorderLayout.NORTH);

       JPanel controlPanel = new JPanel(new GridLayout(2,0));

       final JSpinner minRow = createSpinner(0, 0, tableModel.getRowCount()-1);
       final JSpinner minCol = createSpinner(0, 0, tableModel.getColumnCount()-1);
       final JSpinner maxRow = createSpinner(tableModel.getRowCount()-1, 0, tableModel.getRowCount()-1);
       final JSpinner maxCol = createSpinner(tableModel.getColumnCount()-1, 0, tableModel.getColumnCount()-1);

       ChangeListener changeListener = new ChangeListener()
       {
           public void stateChanged(ChangeEvent e)
           {
               int minR = (Integer)minRow.getValue();
               int minC = (Integer)minCol.getValue();
               int maxR = (Integer)maxRow.getValue();
               int maxC = (Integer)maxCol.getValue();
               tableModel.setRange(minR, minC, maxR, maxC);
           }
       };

       minRow.addChangeListener(changeListener);
       minCol.addChangeListener(changeListener);
       maxRow.addChangeListener(changeListener);
       maxCol.addChangeListener(changeListener);

       controlPanel.add(new JLabel("Min. row", JLabel.CENTER));
       controlPanel.add(minRow);

       controlPanel.add(new JLabel("Min. col", JLabel.CENTER));
       controlPanel.add(minCol);

       controlPanel.add(new JLabel("Max. row", JLabel.CENTER));
       controlPanel.add(maxRow);

       controlPanel.add(new JLabel("Max. col", JLabel.CENTER));
       controlPanel.add(maxCol);

       p.add(controlPanel, BorderLayout.CENTER);
       panel.add(p, BorderLayout.NORTH);

       panel.add(new JScrollPane(new JTable(tableModel)), BorderLayout.CENTER);

       return panel;
   }

   private JSpinner createSpinner(int initial, int min, int max)
   {
       SpinnerModel model = new SpinnerNumberModel(initial, min, max, 1);
       JSpinner spinner = new JSpinner(model);
       return spinner;

   }

}

Nachbetrachtung

Eigentlich wär's ja noch schick, das ganze in dem Sinne "mächtiger" zu machen, dass man sowas wie die hintereinanderschaltbaren {JAPI|RowFilter} (und entsprechende {JAPI|ColumnFilter}) einbaut, aber ... da das ja keiner braucht.... </code=java> --Marco13 27.08.2008, 19:39