Swing JTable + JScrollPane (Breite und Höhenproblem)

[martram]

Hallo zusammen,

im Grunde habe ich 2 Probleme mit einer JTable und einem umgebenden JScrollPane.

Problem 1 - Höhenproblem: die JTable wird im Regelfall relativ wenige Zeilen haben. Dennoch sorgt das Scrollpane dafür, dass enorm viel MEhr-Platz geblockt wird. Mit der preferedSize könnte ich sicher etwas machen - nur weiß ich nicht, wie breit und hoch das Fenster ist. (soll erst bei Überschreiten der Fenstergröße mit Scrollbar sein).
Das ganze ist auch in einer etwas komplexeren Applikation verbaut, weshalb es sich sogar in dem Fall nur um ein panel handelt - das die max. Größe eigentlich automatisch bestimmen sollte...

Siehe Bild: http://666kb.com/i/b9zuy9mo8daqc169e.png

Problem 2 - die Breite: Ich möchte das autoResizen eigentlich nicht deaktivieren - es soll solange genutzt werden, wie noch alle Spalteninhalte angezeigt werden können. DANACH soll dann aber die Scrollbar anspringen und nicht weiter verkleinert werden. Problem ist: entweder kommt die horizontale Scrollbar gar nicht, oder die Spalten sind immer zu breit...

Einfaches Testprogramm:

import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;

public class TestFrame extends JFrame{
	
	public TestFrame(){
		super("test");
		setLayout(new BorderLayout(10,10));
		
		String[][] data = {{"3","1","0","0","0","0","0","12","546"},
				{"test","test","1","2","3","4","5","",""},
				{"0","4","5","2","3","7","1","30","90"},
				{"1","10","2","4","2","7","1","14","100"},
				{"0","6","0","2","2","7","1","12","15"},
				{ "test","","2","4","5","7","1","14","157"}};
        
		String[] cols = {"1","2","3","4","5","6","7","8","9"};
		JTable table = new JTable(data, cols);
		table.setShowGrid(false);		
		JScrollPane pane = new JScrollPane();
		
		pane.setViewportView(table);
		pane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
		add(pane,BorderLayout.CENTER);
		
		add(new JLabel("test"), BorderLayout.SOUTH);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
	
	public static void main(String[] args) {
		TestFrame t=  new TestFrame();
		t.pack();
		t.setVisible(true);
	}

}

PS: die Suche habe ich benutzt. Zumindest für die Breite soll man wohl das resize-Verhalten deaktiveren. Genau das möchte ich ja nicht. :-(

 

[André Uhres]

Problem 1 - Höhenproblem: die JTable wird im Regelfall relativ wenige Zeilen haben. Dennoch sorgt das Scrollpane dafür, dass enorm viel MEhr-Platz geblockt wird.
Problem 2 - die Breite: Ich möchte das autoResizen eigentlich nicht deaktivieren - es soll solange genutzt werden, wie noch alle Spalteninhalte angezeigt werden können. DANACH soll dann aber die Scrollbar anspringen und nicht weiter verkleinert werden.

Versuch's mal hiermit:

import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;

public class TestFrame extends JFrame {

    private JTable table;

    public TestFrame() {
        super("test");
        setLayout(new BorderLayout(10, 10));
        String[][] data = {{"3", "1", "0", "0", "0", "0", "0", "12", "546"},
            {"test", "test", "1", "2", "3", "4", "5", "", ""},
            {"0", "4", "5", "2", "3", "7", "1", "30", "90"},
            {"1", "10", "2", "4", "2", "7", "1", "14", "100"},
            {"0", "6", "0", "2", "2", "7", "1", "12", "15"},
            {"test", "", "2", "4", "5", "7", "1", "14", "157"}};

        String[] cols = {"1", "2", "3", "4", "5", "6", "7", "8", "9"};
        table = new JTable(data, cols);
        addComponentListener(new ComponentAdapter() {

            @Override
            public void componentResized(final ComponentEvent e) {
                table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
                final TableColumnAdjuster tca = new TableColumnAdjuster(table);
                tca.setColumnDataIncluded(true);
                tca.setColumnHeaderIncluded(true);
                tca.setDynamicAdjustment(true);
                tca.setOnlyAdjustLarger(false);
                tca.adjustColumns();
                Runnable resizeMode = new Runnable() {

                    public void run() {
                        if (table.getWidth() < getWidth()) {
                            table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
                        }
                        Runnable viewportSize = new Runnable() {

                            public void run() {
                                Rectangle r = table.getVisibleRect();
                                int h = table.getHeight();
                                Dimension d = new Dimension(r.width, h);
                                table.setPreferredScrollableViewportSize(d);
                                pack();
                                setVisible(true);
                            }
                        };
                        SwingUtilities.invokeLater(viewportSize);
                    }
                };
                SwingUtilities.invokeLater(resizeMode);
            }
        });
        table.setShowGrid(false);
        JScrollPane pane = new JScrollPane();
        pane.setViewportView(table);
        add(pane, BorderLayout.CENTER);
        add(new JLabel("test"), BorderLayout.SOUTH);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        pack();
    }

    public static void main(final String[] args) {
        Runnable gui = new Runnable() {

            @Override
            public void run() {
                new TestFrame();
            }
        };
        //GUI must start on EventDispatchThread:
        SwingUtilities.invokeLater(gui);
    }
}
/*  [url=http://tips4java.wordpress.com/2008/11/10/table-column-adjuster/]Table Column Adjuster  Java Tips Weblog[/url]
 * 
 *	Class to manage the widths of colunmns in a table.
 *
 *  Various properties control how the width of the column is calculated.
 *  Another property controls whether column width calculation should be dynamic.
 *  Finally, various Actions will be added to the table to allow the user
 *  to customize the functionality.
 *
 *  This class was designed to be used with tables that use an auto resize mode
 *  of AUTO_RESIZE_OFF. With all other modes you are constrained as the width
 *  of the columns must fit inside the table. So if you increase one column, one
 *  or more of the other columns must decrease. Because of this the resize mode
 *  of RESIZE_ALL_COLUMNS will work the best.
 */

class TableColumnAdjuster implements PropertyChangeListener, TableModelListener {

    private JTable table;
    private int spacing;
    private boolean isColumnHeaderIncluded;
    private boolean isColumnDataIncluded;
    private boolean isOnlyAdjustLarger;
    private boolean isDynamicAdjustment;
    private Map<TableColumn, Integer> columnSizes = new HashMap<TableColumn, Integer>();

    /*
     *  Specify the table and use default spacing
     */
    public TableColumnAdjuster(JTable table) {
        this(table, 6);
    }

    /*
     *  Specify the table and spacing
     */
    public TableColumnAdjuster(JTable table, int spacing) {
        this.table = table;
        this.spacing = spacing;
        setColumnHeaderIncluded(true);
        setColumnDataIncluded(true);
        setOnlyAdjustLarger(true);
        setDynamicAdjustment(false);
        installActions();
    }

    /*
     *  Adjust the widths of all the columns in the table
     */
    public void adjustColumns() {
        TableColumnModel tcm = table.getColumnModel();

        for (int i = 0; i < tcm.getColumnCount(); i++) {
            adjustColumn(i);
        }
    }

    /*
     *  Adjust the width of the specified column in the table
     */
    public void adjustColumn(final int column) {
        TableColumn tableColumn = table.getColumnModel().getColumn(column);

        if (!tableColumn.getResizable()) {
            return;
        }

        int columnHeaderWidth = getColumnHeaderWidth(column);
        int columnDataWidth = getColumnDataWidth(column);
        int preferredWidth = Math.max(columnHeaderWidth, columnDataWidth);

        updateTableColumn(column, preferredWidth);
    }

    /*
     *  Calculated the width based on the column name
     */
    private int getColumnHeaderWidth(int column) {
        if (!isColumnHeaderIncluded) {
            return 0;
        }

        TableColumn tableColumn = table.getColumnModel().getColumn(column);
        Object value = tableColumn.getHeaderValue();
        TableCellRenderer renderer = tableColumn.getHeaderRenderer();

        if (renderer == null) {
            renderer = table.getTableHeader().getDefaultRenderer();
        }

        Component c = renderer.getTableCellRendererComponent(table, value, false, false, -1, column);
        return c.getPreferredSize().width;
    }

    /*
     *  Calculate the width based on the widest cell renderer for the
     *  given column.
     */
    private int getColumnDataWidth(int column) {
        if (!isColumnDataIncluded) {
            return 0;
        }

        int preferredWidth = 0;
        int maxWidth = table.getColumnModel().getColumn(column).getMaxWidth();

        for (int row = 0; row < table.getRowCount(); row++) {
            preferredWidth = Math.max(preferredWidth, getCellDataWidth(row, column));

            //  We've exceeded the maximum width, no need to check other rows

            if (preferredWidth >= maxWidth) {
                break;
            }
        }

        return preferredWidth;
    }

    /*
     *  Get the preferred width for the specified cell
     */
    private int getCellDataWidth(int row, int column) {
        //  Inovke the renderer for the cell to calculate the preferred width

        TableCellRenderer cellRenderer = table.getCellRenderer(row, column);
        Object value = table.getValueAt(row, column);
        Component c = cellRenderer.getTableCellRendererComponent(table, value, false, false, row, column);
        int width = c.getPreferredSize().width + table.getIntercellSpacing().width;

        return width;
    }

    /*
     *  Update the TableColumn with the newly calculated width
     */
    private void updateTableColumn(int column, int width) {
        final TableColumn tableColumn = table.getColumnModel().getColumn(column);

        if (!tableColumn.getResizable()) {
            return;
        }

        width += spacing;

        //  Don't shrink the column width

        if (isOnlyAdjustLarger) {
            width = Math.max(width, tableColumn.getPreferredWidth());
        }

        columnSizes.put(tableColumn, new Integer(tableColumn.getWidth()));
        table.getTableHeader().setResizingColumn(tableColumn);
        tableColumn.setWidth(width);
    }

    /*
     *  Restore the widths of the columns in the table to its previous width
     */
    public void restoreColumns() {
        TableColumnModel tcm = table.getColumnModel();

        for (int i = 0; i < tcm.getColumnCount(); i++) {
            restoreColumn(i);
        }
    }

    /*
     *  Restore the width of the specified column to its previous width
     */
    private void restoreColumn(int column) {
        TableColumn tableColumn = table.getColumnModel().getColumn(column);
        Integer width = columnSizes.get(tableColumn);

        if (width != null) {
            table.getTableHeader().setResizingColumn(tableColumn);
            tableColumn.setWidth(width.intValue());
        }
    }

    /*
     *	Indicates whether to include the header in the width calculation
     */
    public void setColumnHeaderIncluded(boolean isColumnHeaderIncluded) {
        this.isColumnHeaderIncluded = isColumnHeaderIncluded;
    }

    /*
     *	Indicates whether to include the model data in the width calculation
     */
    public void setColumnDataIncluded(boolean isColumnDataIncluded) {
        this.isColumnDataIncluded = isColumnDataIncluded;
    }

    /*
     *	Indicates whether columns can only be increased in size
     */
    public void setOnlyAdjustLarger(boolean isOnlyAdjustLarger) {
        this.isOnlyAdjustLarger = isOnlyAdjustLarger;
    }

    /*
     *  Indicate whether changes to the model should cause the width to be
     *  dynamically recalculated.
     */
    public void setDynamicAdjustment(boolean isDynamicAdjustment) {
        //  May need to add or remove the TableModelListener when changed

        if (this.isDynamicAdjustment != isDynamicAdjustment) {
            if (isDynamicAdjustment) {
                table.addPropertyChangeListener(this);
                table.getModel().addTableModelListener(this);
            } else {
                table.removePropertyChangeListener(this);
                table.getModel().removeTableModelListener(this);
            }
        }

        this.isDynamicAdjustment = isDynamicAdjustment;
    }
//
//  Implement the PropertyChangeListener
//

    public void propertyChange(PropertyChangeEvent e) {
        //  When the TableModel changes we need to update the listeners
        //  and column widths

        if ("model".equals(e.getPropertyName())) {
            TableModel model = (TableModel) e.getOldValue();
            model.removeTableModelListener(this);

            model = (TableModel) e.getNewValue();
            model.addTableModelListener(this);
            adjustColumns();
        }
    }
//
//  Implement the TableModelListener
//

    public void tableChanged(TableModelEvent e) {
        //  A cell has been updated

        if (e.getType() == TableModelEvent.UPDATE) {
            int column = table.convertColumnIndexToView(e.getColumn());

            //  Only need to worry about an increase in width for this cell

            if (isOnlyAdjustLarger) {
                int row = e.getFirstRow();
                TableColumn tableColumn = table.getColumnModel().getColumn(column);

                if (tableColumn.getResizable()) {
                    int width = getCellDataWidth(row, column);
                    updateTableColumn(column, width);
                }
            } //	Could be an increase of decrease so check all rows
            else {
                adjustColumn(column);
            }
        } //  The update affected more than one column so adjust all columns
        else {
            adjustColumns();
        }
    }

    /*
     *  Install Actions to give user control of certain functionality.
     */
    private void installActions() {
        installColumnAction(true, true, "adjustColumn", "control ADD");
        installColumnAction(false, true, "adjustColumns", "control shift ADD");
        installColumnAction(true, false, "restoreColumn", "control SUBTRACT");
        installColumnAction(false, false, "restoreColumns", "control shift SUBTRACT");

        installToggleAction(true, false, "toggleDynamic", "control MULTIPLY");
        installToggleAction(false, true, "toggleLarger", "control DIVIDE");
    }

    /*
     *  Update the input and action maps with a new ColumnAction
     */
    private void installColumnAction(
            boolean isSelectedColumn, boolean isAdjust, String key, String keyStroke) {
        Action action = new ColumnAction(isSelectedColumn, isAdjust);
        KeyStroke ks = KeyStroke.getKeyStroke(keyStroke);
        table.getInputMap().put(ks, key);
        table.getActionMap().put(key, action);
    }

    /*
     *  Update the input and action maps with new ToggleAction
     */
    private void installToggleAction(
            boolean isToggleDynamic, boolean isToggleLarger, String key, String keyStroke) {
        Action action = new ToggleAction(isToggleDynamic, isToggleLarger);
        KeyStroke ks = KeyStroke.getKeyStroke(keyStroke);
        table.getInputMap().put(ks, key);
        table.getActionMap().put(key, action);
    }

    /*
     *  Action to adjust or restore the width of a single column or all columns
     */
    class ColumnAction extends AbstractAction {

        private boolean isSelectedColumn;
        private boolean isAdjust;

        public ColumnAction(boolean isSelectedColumn, boolean isAdjust) {
            this.isSelectedColumn = isSelectedColumn;
            this.isAdjust = isAdjust;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            //  Handle selected column(s) width change actions

            if (isSelectedColumn) {
                int[] columns = table.getSelectedColumns();

                for (int i = 0; i < columns.length; i++) {
                    if (isAdjust) {
                        adjustColumn(columns[i]);
                    } else {
                        restoreColumn(columns[i]);
                    }
                }
            } else {
                if (isAdjust) {
                    adjustColumns();
                } else {
                    restoreColumns();
                }
            }
        }
    }

    /*
     *  Toggle properties of the TableColumnAdjuster so the user can
     *  customize the functionality to their preferences
     */
    class ToggleAction extends AbstractAction {

        private boolean isToggleDynamic;
        private boolean isToggleLarger;

        public ToggleAction(boolean isToggleDynamic, boolean isToggleLarger) {
            this.isToggleDynamic = isToggleDynamic;
            this.isToggleLarger = isToggleLarger;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            if (isToggleDynamic) {
                setDynamicAdjustment(!isDynamicAdjustment);
                return;
            }

            if (isToggleLarger) {
                setOnlyAdjustLarger(!isOnlyAdjustLarger);
                return;
            }
        }
    }
}