Bearbeiten von „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.<br>
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;

    }
}
</code=java>
[[Kategorie:Java]]
[[Kategorie:Swing]]
[[Kategorie:JTable]]

--[[Benutzer:Marco13|Marco13]] 27.08.2008, 19:39