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

Question

Я хочу поместить строку в 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, и это мой первый вопрос. Я был бы рад получить ответ.

Answer 1

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

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

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

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

Метод 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 внутри рендеринга неверно.

Answer 2

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

table.setRowHeight(40); 

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

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

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

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

---

Выход

Answer 3

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

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

1. Добавить пользовательский TableCellRenderer в таблицу, которая возвращает JTextArea в TableCellRenderer # getTableCellRendererComponent()
2. Слушайте изменения размера столбцов, как описано здесь: Java JTable detect Column re-sized by user
3. Обновить высоту строк столбцов, как описано здесь: Auto adjust the height of rows in a JTable
4. Во время обновления высоты строки, один calcula TES требуемый размер 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); 
    } 
} 

При таком подходе, дальнейшие вычисления количеств или строк не требуются.

Вот полный код примера примера 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 detect Column re-sized by user и Auto adjust the height of rows in a JTable.

Answer 4

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

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

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 в то время как мы находимся в середине расчета высоты
• инициализировать rowHeight до 20, так что мы можем сжать снова
• TableColumnModelListener поэтому мы знаем, когда пользователь изменяет столбец и сжиматься или расти rowHeight s (вы можете безопасно удалить прослушиватель, если это нежелательно)

Кроме того, теперь я только измененные строки оценивать для 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 в соответствии с положением последнего символа

Answer 5

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

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.