Как установить RowHeight динамически в JTable

Я хочу поместить строку в JTable это больше, чем заданная ширина ячейки. Как я могу установить rowHeight динамически, чтобы я мог прочитать всю строку? Вот пример:

import javax.swing.*;

public class ExampleTable {

public JPanel createTable() {               
    JPanel totalGUI = new JPanel();

    //define titles for table
    String[] title = {"TITLE1", "TITLE2", "TITLE3"};

    //table data
    Object[][] playerdata = {       
    {new Integer(34), "Steve", "test test test"},
    {new Integer(32), "Patrick", "dumdi dumdi dummdi dumm di di didumm"},
    {new Integer(10), "Sarah", "blabla bla bla blabla bla bla blabla"},};

    //create object 'textTable'
    JTable textTable = new JTable(playerdata,title);

    //set column width
    textTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); 
    textTable.getColumnModel().getColumn(0).setPreferredWidth(60);
    textTable.getColumnModel().getColumn(1).setPreferredWidth(60);
    textTable.setDefaultRenderer(String.class, new RowHeightCellRenderer());

    //scrollbar
    JScrollPane scrollPane = new JScrollPane(textTable);

    totalGUI.add(scrollPane);               
    return totalGUI;
}

private static void createAndShowGUI() {

    //create main frame
    JFrame mainFrame = new JFrame("");
    ExampleTable test = new ExampleTable();

    JPanel totalGUI = new JPanel();
    totalGUI = test.createTable();

    //visible mode
    mainFrame.add(totalGUI); //integrate main panel to main frame
    mainFrame.pack();
    mainFrame.setVisible(true);     
}


public static void main (String[] args) {               

    createAndShowGUI();     

}//main
}

и здесь вы увидите код, который разрывает строки каждого текста, который должен долго для данной ячейки

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


    public class RowHeightCellRenderer extends JTextArea implements TableCellRenderer
    {
      /**
         * 
         */
        private static final long serialVersionUID = 1L;

    public Component getTableCellRendererComponent (JTable table, 
                                                    Object value, 
                                                    boolean isSelected, 
                                                    boolean hasFocus, 
                                                    int row, 
                                                    int column )  {
        setText( value.toString() );    
        return this;
      }
    }

спасибо, но я хочу реализовать RowHeight динамически, в зависимости от длины строки... Я хочу прочитать всю строку/текст в ячейке. любой предложения?

Я начинающий java, и это мой первый вопрос. Я был бы рад получить ответ.

8
java jtable swing

5 ответов

есть несколько проблем при использовании jtextarea в качестве компонента рендеринга (и большинство, если не все из них уже объяснены в нескольких QA на этом сайте). Пытаясь подвести итог:--3-->

настройки индивидуальных высоту строки, размер компонента рендеринга

в принципе, путь - это петля через ячейки по мере необходимости, затем

  • настройте свой рендерер с данными
  • задать компонент рендеринга для его предпочтительного размера
  • установите высоту строки таблицы в pref height

метод updateRowHeight в отредактированном вопросе OP просто прекрасен.

расчет jtextarea его preferredSize

чтобы получить разумную подсказку размера для одного измерения, его нужно "засеять" с некоторым разумным размером в другом измерении. То есть, если мы хотим высоту, ей нужна ширина, и это должно быть сделано в каждом вызове. В контекст таблицы, разумной шириной является текущая ширина столбца:

public Component getTableCellRendererComponent(JTable table,
        Object value, boolean isSelected, boolean hasFocus, int row,
        int column) {
    ... // configure visuals
    setText((String) value);
    setSize(table.getColumnModel().getColumn(column).getWidth(),
            Short.MAX_VALUE);
    return this;
}// getTableCellRendererComponent

динамическая регулировка высоты

высота строки полностью определяется в некотором устойчивом состоянии таблицы / столбца / модели. Таким образом, вы устанавливаете его (вызов updateRowHeight) один раз после завершения инициализации и всякий раз, когда любое из состояний, от которых оно зависит, изменяется. 

// TableModelListener
@Override
public void tableChanged(TableModelEvent e) {
    updateRowHeights();
}

// TableColumnModelListener
@Override
public void columnMarginChanged(ChangeEvent e) {
    updateRowHeights();
}

Примечание

Как правило, все параметры в getXXRendererComponent строго только для чтения, реализации не должен изменить любое состояние вызывающего абонента. Обновление rowHeight из рендерера является неправильно.

13

многие хорошие идеи связаны в других ответах, а также в связанных с ними вопросах.

Итак, вот как я изменил вам классы, чтобы получить таблицу с полностью работающей автоматической линией высоты:

import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableModel;
import java.awt.*;

public class ExampleTable implements TableModelListener {
    JTable textTable;

    public JPanel createTable() {
        JPanel totalGUI = new JPanel();

        //define titles for table
        String[] title = {"TITLE1", "TITLE2", "TITLE3"};

        //table data
        Object[][] playerdata = {
                {new Integer(3), "Steve", "test test test"},
                {new Integer(32), "Patrick", "du hu hu hu hu hu hu hu uh u kkkkkk oooo pppp"},
                {new Integer(10), "Sarah", "xxxxxxxxxxxxx aaaaaaaaaa bbbbbbbbbbbb dddddddddddd xxxxxxx gggewr  eeeeeeeeee22 ddd g fffffff zzzzzzz"},};

        //define tablemodel
        TableModel model = new DefaultTableModel(playerdata, title);

        //create object 'textTable'
        textTable = new JTable(model);

        //set column width
        textTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        textTable.getColumnModel().getColumn(0).setPreferredWidth(17);
        textTable.getColumnModel().getColumn(1).setPreferredWidth(45);
        textTable.getColumnModel().getColumn(2).setPreferredWidth(200);

        //put line breaks if string is longer than cell-width
        RowHeightCellRenderer dynRow = new RowHeightCellRenderer();
        textTable.getColumnModel().getColumn(2).setCellRenderer(dynRow);

        // No more data changes; install listeners
        textTable.getModel().addTableModelListener(this);
        textTable.getColumnModel().addColumnModelListener(new TableColumnModelListener() {
            /**
             * We only need to recalculate once; so track if we are already going to do it.
             */
            boolean columnHeightWillBeCalculated = false;

            @Override
            public void columnAdded(TableColumnModelEvent e) {
            }

            @Override
            public void columnRemoved(TableColumnModelEvent e) {
            }

            @Override
            public void columnMoved(TableColumnModelEvent e) {
            }

            @Override
            public void columnMarginChanged(ChangeEvent e) {
                if (!columnHeightWillBeCalculated && textTable.getTableHeader().getResizingColumn() != null) {
                    columnHeightWillBeCalculated = true;
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            // textTable.getTableHeader().getResizingColumn() is != null as long as the user still is holding the mouse down
                            // To avoid going over all data every few milliseconds wait for user to release
                            if (textTable.getTableHeader().getResizingColumn() != null) {
                                SwingUtilities.invokeLater(this);
                            } else {
                                tableChanged(null);
                                columnHeightWillBeCalculated = false;
                            }
                        }
                    });
                }
            }

            @Override
            public void columnSelectionChanged(ListSelectionEvent e) {
            }
        });

        //scrollbar
        JScrollPane scrollPane = new JScrollPane(textTable);
        totalGUI.add(scrollPane);
        return totalGUI;
    }

    public void tableChanged(TableModelEvent e) {
        final int first;
        final int last;
        if (e == null || e.getFirstRow() == TableModelEvent.HEADER_ROW) {
            // assume everything changed
            first = 0;
            last = textTable.getModel().getRowCount();
        } else {
            first = e.getFirstRow();
            last = e.getLastRow() + 1;
        }
        // GUI-Changes should be done through the EventDispatchThread which ensures all pending events were processed
        // Also this way nobody will change the text of our RowHeightCellRenderer because a cell is to be rendered
        if(SwingUtilities.isEventDispatchThread()) {
            updateRowHeights(first, last);
        } else {
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    updateRowHeights(first, last);
                }
            });
        }
    }

    private void updateRowHeights(final int first, final int last) {
    /*
     * Auto adjust the height of rows in a JTable.
     * The only way to know the row height for sure is to render each cell
     * to determine the rendered height. After your table is populated with
     * data you can do:
     *
     */
        for (int row = first; row < last; row++) {
            int rowHeight = 20;
            for (int column = 0; column < textTable.getColumnCount(); column++) {
                Component comp = textTable.prepareRenderer(textTable.getCellRenderer(row, column), row, column);
                rowHeight = Math.max(rowHeight, comp.getPreferredSize().height);
            }
            if(rowHeight != textTable.getRowHeight(row)) {
                textTable.setRowHeight(row, rowHeight);
                System.out.println("neue Zeilenhöhe: "+rowHeight+" bei Zeile: "+row);
            }
        }
    }

    private static void createAndShowGUI() {

        //create main frame
        JFrame mainFrame = new JFrame("");
        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        ExampleTable test = new ExampleTable();
        JPanel totalGUI = new JPanel();
        totalGUI = test.createTable();

        //visible mode
        mainFrame.add(totalGUI); //integrate main panel to main frame
        mainFrame.pack();
        mainFrame.setVisible(true);

        //adjust dynamically the Row height of each cell
        test.tableChanged(null);
    }


    public static void main (String[] args) {
        createAndShowGUI();
    }//main
}

основные изменения:

  • рассчитать высоту только после JFrame видно, потому что у нас может не быть правильного шрифта до этого
  • изменить rowHeight только из event-dispatch-thread (SwingUtilities.isEventDispatchThread()/SwingUtilities.invokeLater()); в противном случае таблица может назначить различные значения для нашего RowHeightCellRenderer в то время как мы находимся в середине из расчета высоты
  • initalize rowHeight до 20, так что мы можем снова сожмите
  • TableColumnModelListener таким образом, мы знаем, когда пользователь изменяет размер столбца и сжимается или растет rowHeights (Вы можете безопасно удалить слушателя, если это нежелательно)

также теперь я оцениваю только измененные строки для TableModel изменения

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

public class RowHeightCellRenderer extends JTextArea implements TableCellRenderer {

    private static final long serialVersionUID = 1L;


    public RowHeightCellRenderer() {
        setLineWrap(true);
        setWrapStyleWord(true);
    }//constructor

    public Component getTableCellRendererComponent (JTable table,
                                                    Object value,
                                                    boolean isSelected,
                                                    boolean hasFocus,
                                                    int row,
                                                    int column ) {
        this.setText((String) value);

        if(isSelected) {
            this.setBackground(table.getSelectionBackground());
            this.setForeground(table.getSelectionForeground());
        } else {
            this.setBackground(table.getBackground());
            this.setForeground(table.getForeground());
        }

        final int columnWidth = table.getColumnModel().getColumn(column).getWidth();
        final int rowHeight = table.getRowHeight(row);
        this.setSize(columnWidth, rowHeight);

        this.validate();
        return this;
    }//getTableCellRendererComponent

    @Override
    public Dimension getPreferredSize() {
        try {
            // Get Rectangle for position after last text-character
            final Rectangle rectangle = this.modelToView(getDocument().getLength());
            if(rectangle != null) {
                return new Dimension(this.getWidth(),
                                     this.getInsets().top + rectangle.y + rectangle.height +
                                                                  this.getInsets().bottom);
            }
        } catch (BadLocationException e) {
            e.printStackTrace();  // TODO: implement catch
        }

        return super.getPreferredSize();
    }
}//RowHeightCellRenderer

изменения:

  • setSize() на getTableCellRendererComponent() как иначе объект не может правильно обернуть
  • вычислить preferedSize в соответствии с положением последнего символа
5

На самом деле JTextArea уже реализует все функции, необходимые для динамического изменения его высоты в зависимости от его ширины. Эту функциональность можно увидеть в действии, когда JTextArea используется внутри полосы прокрутки, где ее высота автоматически настраивается в соответствии с шириной полосы прокрутки. Чтобы использовать эту функцию, необходимо сначала установить размер JTextArea на некоторую ширину, а затем jtextarea#getPreferredSize () вернет необходимую высоту для отображения текста (если для переноса строки установлено значение истинный.)

таким образом, чтобы динамически изменять высоту строки JTable на основе его ширины, можно сделать следующее:

  1. добавьте пользовательский TableCellRenderer в таблицу, которая возвращает JTextArea в TableCellRenderer#getTableCellRendererComponent ()
  2. слушать изменение размера столбцов, как описано здесь: Java jtable обнаруживает столбец повторного размера пользователем
  3. обновить высоты строк столбцов, как описано здесь: авторегулировка высота строк в JTable
  4. во время обновления высоты строки вычисляется необходимый размер JTextArea, сначала устанавливая новую ширину, а затем получая предпочтительную высоту, как показано в следующем фрагменте кода

функция обновления высот строк:

public static void updateRowHeights(int column, int width, JTable table){
    for (int row = 0; row < table.getRowCount(); row++) {
        int rowHeight = table.getRowHeight();
        Component comp = table.prepareRenderer(table.getCellRenderer(row, column), row, column);
        Dimension d = comp.getPreferredSize();
            // first set the size to the new width
        comp.setSize(new Dimension(width, d.height));
            // then get the preferred size
        d = comp.getPreferredSize();
        rowHeight = Math.max(rowHeight, d.height);
            // finally set the height of the table
        table.setRowHeight(row, rowHeight);
    }
}

С таким подходом, никаких дальнейших расчетов столбцы или строки не надо.

вот полный код ExampleTable OP, скорректированный к этой реализации.

import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.TableColumnModelEvent;
import javax.swing.event.TableColumnModelListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;

public class ExampleTable {

    public class RowHeightCellRenderer extends JTextArea implements TableCellRenderer {

        public Component getTableCellRendererComponent(
                JTable table, Object value,
                boolean isSelected, boolean hasFocus,
                int row, int column) {

            setEditable(false);
            setLineWrap(true);
            setWrapStyleWord(true);

            if (isSelected) {
                setBackground(table.getSelectionBackground());
                setForeground(table.getSelectionForeground());
            } else {
                setBackground(table.getBackground());
                setForeground(table.getForeground());
            }

            setText(value.toString());
            return this;
        }
    }

    public static void updateRowHeights(int column, int width, JTable table){
        for (int row = 0; row < table.getRowCount(); row++) {
            int rowHeight = table.getRowHeight();
            Component comp = table.prepareRenderer(table.getCellRenderer(row, column), row, column);
            Dimension d = comp.getPreferredSize();
            comp.setSize(new Dimension(width, d.height));
            d = comp.getPreferredSize();
            rowHeight = Math.max(rowHeight, d.height);
            table.setRowHeight(row, rowHeight);
        }
    }

    public JPanel createTable() {

        JPanel totalGUI = new JPanel();

        //define titles for table
        final String[] columnNames = {"TITLE1", "TITLE2", "TITLE3"};

        //table data
        final Object[][] rowData = {       
                {new Integer(34), "Steve", "test test test"},
                {new Integer(32), "Patrick", "dumdi dumdi dummdi dumm di di didumm"},
                {new Integer(10), "Sarah", "blabla bla bla blabla bla bla blabla"},};

        AbstractTableModel model = new AbstractTableModel() {
            @Override
            public Class<?> getColumnClass(int columnIndex) {
                return String.class;
            }

            public String getColumnName(int column) { return columnNames[column].toString(); }
            public int getRowCount() { return rowData.length; }
            public int getColumnCount() { return columnNames.length; }
            public Object getValueAt(int row, int col) { return rowData[row][col]; }
            public boolean isCellEditable(int row, int column) { return true; }
            public void setValueAt(Object value, int row, int col) {
                rowData[row][col] = value;
                fireTableCellUpdated(row, col);
            }
        };

        //create object 'textTable'
        final JTable textTable = new JTable();

        textTable.setDefaultRenderer(String.class, new RowHeightCellRenderer());
        textTable.setModel(model);

        //set column width
        textTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); 
        textTable.getColumnModel().getColumn(0).setPreferredWidth(60);
        textTable.getColumnModel().getColumn(1).setPreferredWidth(60);

        ColumnListener cl = new ColumnListener(){

            @Override
            public void columnMoved(int oldLocation, int newLocation) {
            }

            @Override
            public void columnResized(int column, int newWidth) {
                updateRowHeights(column, newWidth, textTable);
            }

        };

        textTable.getColumnModel().addColumnModelListener(cl);
        textTable.getTableHeader().addMouseListener(cl);

        // initial update of row heights
        TableColumn c = textTable.getColumnModel().getColumn(2);
        updateRowHeights(2, c.getWidth(), textTable);

        //scrollbar
        JScrollPane scrollPane = new JScrollPane(textTable);

        totalGUI.add(scrollPane);               
        return totalGUI;
    }

    private static void createAndShowGUI() {

        //create main frame
        JFrame mainFrame = new JFrame("");
        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        ExampleTable test = new ExampleTable();

        JPanel totalGUI = new JPanel();
        totalGUI = test.createTable();

        //visible mode
        mainFrame.add(totalGUI); //integrate main panel to main frame
        mainFrame.pack();
        mainFrame.setVisible(true);     
    }


    public static void main (String[] args) {               

        createAndShowGUI();     

    }//main


    abstract class ColumnListener extends MouseAdapter implements TableColumnModelListener {

        private int oldIndex = -1;
        private int newIndex = -1;
        private boolean dragging = false;

        private boolean resizing = false;
        private int resizingColumn = -1;
        private int oldWidth = -1;

        @Override
        public void mousePressed(MouseEvent e) {
            // capture start of resize
            if(e.getSource() instanceof JTableHeader) {
                JTableHeader header = (JTableHeader)e.getSource();
                TableColumn tc = header.getResizingColumn();
                if(tc != null) {
                    resizing = true;
                    JTable table = header.getTable();
                    resizingColumn = table.convertColumnIndexToView( tc.getModelIndex());
                    oldWidth = tc.getPreferredWidth();
                } else {
                    resizingColumn = -1;
                    oldWidth = -1;
                }
            }   
        }

        @Override
        public void mouseReleased(MouseEvent e) {
            // column moved
            if(dragging && oldIndex != newIndex) {
                columnMoved(oldIndex, newIndex);
            }
            dragging = false;
            oldIndex = -1;
            newIndex = -1;

            // column resized
            if(resizing) {
                if(e.getSource() instanceof JTableHeader) {
                    JTableHeader header = (JTableHeader)e.getSource();
                    TableColumn tc = header.getColumnModel().getColumn(resizingColumn);
                    if(tc != null) {
                        int newWidth = tc.getPreferredWidth();
                        if(newWidth != oldWidth) {
                            columnResized(resizingColumn, newWidth);
                        }
                    }
                }   
            }
            resizing = false;
            resizingColumn = -1;
            oldWidth = -1;
        }

        @Override
        public void columnAdded(TableColumnModelEvent e) {      
        }

        @Override
        public void columnRemoved(TableColumnModelEvent e) {        
        }

        @Override
        public void columnMoved(TableColumnModelEvent e) {
            // capture dragging
            dragging = true;
            if(oldIndex == -1){
                oldIndex = e.getFromIndex();
            }

            newIndex = e.getToIndex();  
        }

        @Override
        public void columnMarginChanged(ChangeEvent e) {
        }

        @Override
        public void columnSelectionChanged(ListSelectionEvent e) {
        }

        public abstract void columnMoved(int oldLocation, int newLocation);
        public abstract void columnResized(int column, int newWidth);
    }
}

обратите внимание, что я повторно и изменил часть кода Java jtable обнаруживает столбец повторного размера пользователем и автоматическая регулировка высоты строк в JTable.

2

обычно мы ставим RowHeight когда текст в row выходит за рамки height строки, чтобы установить высоту строки, мы делаем так:

table.setRowHeight(40);

Я хочу поместить строку в JTable, которая является длиннее заданной ширины ячейки. Как я могу установить rowHeight динамически, чтобы я могу прочитать строку?

чтобы прочитать полную строку из строки jtable, вам не нужно устанавливать RowHeight вам нужно установить the PreferredWidth of a column как вы уже это делаете. Просто добавьте строку типа:

textTable.getColumnModel().getColumn(2).setPreferredWidth(300);

и вы сможете прочитать всю строку.

выход

output

0

Я считаю, что проще всего настроить высоту строки изнутри рендерера компонентов, например:

public class RowHeightCellRenderer extends JTextArea implements TableCellRenderer
{
    public Component getTableCellRendererComponent(JTable table, Object 
            value, boolean isSelected, boolean hasFocus,
            int row, int column) {

        setText(value.toString());

        // Set the component width to match the width of its table cell
        // and make the height arbitrarily large to accomodate all the contents
        setSize(table.getColumnModel().getColumn(column).getWidth(), Short.MAX_VALUE);

        // Now get the fitted height for the given width
        int rowHeight = this.getPreferredSize().height;

        // Get the current table row height
        int actualRowHeight = table.getRowHeight(row);

        // Set table row height to fitted height.
        // Important to check if this has been done already
        // to prevent a never-ending loop.
        if (rowHeight != actualRowHeight) {
           table.setRowHeight(row, rowHeight);
        }

        return this;
    }
}

Это также будет работать для рендерера, который возвращает JTextPane.

0