sets the optimal column width for the given JTable column - Java Swing

Java examples for Swing:JTable Column

  1. HOME
  2. Java
  3. Swing
  4. JTable Column

Description

sets the optimal column width for the given JTable column

Demo Code

/*/*from  w w  w .j a  v  a2s . com*/
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
import java.awt.Component;
import java.awt.Point;
import java.awt.Rectangle;
import javax.swing.JTable;
import javax.swing.JViewport;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;

public class Main{
    /**
     * sets the optimal column width for the given column
     */
    public void setOptimalColumnWidth(int col) {
        setOptimalColumnWidth(getJTable(), col);
    }
    /**
     * sets the optimal column width for the given column
     */
    public static void setOptimalColumnWidth(JTable jtable, int col) {
        int width;
        TableColumn column;
        JTableHeader header;

        if ((col >= 0) && (col < jtable.getColumnModel().getColumnCount())) {
            width = calcColumnWidth(jtable, col);

            if (width >= 0) {
                header = jtable.getTableHeader();
                column = jtable.getColumnModel().getColumn(col);
                column.setPreferredWidth(width);
                jtable.sizeColumnsToFit(-1);
                header.repaint();
            }
        }
    }
    /**
     * sets the optimal column width for all columns
     */
    public void setOptimalColumnWidth() {
        setOptimalColumnWidth(getJTable());
    }
    /**
     * sets the optimal column width for alls column if the given table
     */
    public static void setOptimalColumnWidth(JTable jtable) {
        int i;

        for (i = 0; i < jtable.getColumnModel().getColumnCount(); i++) {
            setOptimalColumnWidth(jtable, i);
        }
    }
    /**
     * returns the JTable
     */
    public JTable getJTable() {
        return jtable;
    }
    /**
     * calcs the optimal column width of the given column
     */
    public int calcColumnWidth(int col) {
        return calcColumnWidth(getJTable(), col);
    }
    /**
     * Calculates the optimal width for the column of the given table. The
     * calculation is based on the preferred width of the header and cell
     * renderer. <br>
     * Taken from the newsgoup de.comp.lang.java with some modifications.<br>
     * Taken from FOPPS/EnhancedTable - http://fopps.sourceforge.net/<br>
     * 
     * @param table the table to calculate the column width
     * @param col the column to calculate the widths
     * @return the width, -1 if error
     */
    public static int calcColumnWidth(JTable table, int col) {
        int width = calcHeaderWidth(table, col);
        if (width == -1) {
            return width;
        }

        TableColumnModel columns = table.getColumnModel();
        TableModel data = table.getModel();
        int rowCount = data.getRowCount();
        columns.getColumn(col);
        try {
            for (int row = rowCount - 1; row >= 0; --row) {
                Component c = table.prepareRenderer(
                        table.getCellRenderer(row, col), row, col);
                width = Math.max(width, c.getPreferredSize().width + 10);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return width;
    }
    /**
     * calcs the optimal header width of the given column
     */
    public int calcHeaderWidth(int col) {
        return calcHeaderWidth(getJTable(), col);
    }
    /**
     * Calculates the optimal width for the header of the given table. The
     * calculation is based on the preferred width of the header renderer.
     * 
     * @param table the table to calculate the column width
     * @param col the column to calculate the widths
     * @return the width, -1 if error
     */
    public static int calcHeaderWidth(JTable table, int col) {
        if (table == null) {
            return -1;
        }

        if (col < 0 || col > table.getColumnCount()) {
            System.out.println("invalid col " + col);
            return -1;
        }

        JTableHeader header = table.getTableHeader();
        TableCellRenderer defaultHeaderRenderer = null;
        if (header != null) {
            defaultHeaderRenderer = header.getDefaultRenderer();
        }
        TableColumnModel columns = table.getColumnModel();
        table.getModel();
        TableColumn column = columns.getColumn(col);
        int width = -1;
        TableCellRenderer h = column.getHeaderRenderer();
        if (h == null) {
            h = defaultHeaderRenderer;
        }
        if (h != null) {
            // Not explicitly impossible
            Component c = h.getTableCellRendererComponent(table,
                    column.getHeaderValue(), false, false, -1, col);
            width = c.getPreferredSize().width + 5;
        }

        return width;
    }
}

Related Tutorials