Floating Height of JTextArea (as Renderer/Editor) in a JTable Cell

Question

Hey Folks,
I'm kinda struggling with JTextAreas...
There is this JTable, which consists of three colums (practically there are two - the other one's an ID-Field...) and only one
of them ist editable für users.
Left column is a commentary column which has a max of 150 characters - Right column fills automaticly with a user/date stamp.                                                                                                                                                                                    
The main function is that on showing the table, old comments will be retrieved from database and new ones can be entered.
This works all fine and is no matter of subject...
The core of my problem is that there seems to be no straigh-forward way of determine a proper linecount from (a wordwrapped!) JTextArea.
After a long search in the net, i found this approach:
    private static ArrayList<String> getWrappedLines(JTextArea myTextArea) {
        ArrayList<String> linesList = new ArrayList<String>();
        int length = myTextArea.getDocument().getLength();
        int offset = 0;
        try {
            while (offset < length) {
                int end = Utilities.getRowEnd(myTextArea, offset);
                if (end < 0) {
                    break;
                // Include the last character on the line
                end = Math.min(end + 1, length);
                String line =
                    myTextArea.getDocument().getText(offset, end - offset);
                // Remove the line break character
                if (line.endsWith("\n")) {
                    line = line.substring(0, line.length() - 1);
                linesList.add(line);
                offset = end;
        } catch (BadLocationException e) {
            System.err.println("Bad Location at TextArea");
        return linesList;
    }    This code reads the content of a JTextArea an separates wrapped lines in an array.
With manual line breaks ("\n") I get Exceptions (Bad Location) which isn't too bad, because
I was trying to ban manual line breaks anyway...
The above given method retrieves the lines, while the next sets the new Height (line count multiplied by Font Height) to the row.
    public static void setOptimalRowHeight(JTable table, JTextArea textArea, int row, int column) {
        if (
            row >= 0 &&
            column == VerwaltungsnotizController.IND_VNO_NOTIZ   
            int fontHeight =
                textArea.getFontMetrics(textArea.getFont()).getHeight();
            ArrayList<String> wrappedLines = getWrappedLines(textArea);
            int nrOfLines = wrappedLines.size();
            int oldSize = table.getRowHeight(row);
            int newSize = (fontHeight * nrOfLines) + 5;
            if (newSize != oldSize) {
                table.setRowHeight(row, newSize);
     public static void setOptimalRowHeight(JTable table, JTextArea textArea) {
     int row = table.getSelectedRow();
     int column = table.getSelectedColumn();
     if (
          row >= 0 &&
          column == VerwaltungsnotizController.IND_VNO_NOTIZ   
          setOptimalRowHeight(table, textArea, row, column);
     }The above combined Sources are used by two classes, which are "tied" to the table.
One is the CellEditor (which works almost fine); the other one is the CellRenderer (which fails miserably!)
CellEditor (with Listener):
public class VnoCellEditor extends AbstractCellEditor implements TableCellEditor {
    private VnoTextArea textArea;
    private JTable table;
    public VnoCellEditor (JTable table) {
        this.table = table;
        textArea = new VnoTextArea(table);
        textArea.setMaximumInputLength(VerwaltungsnotizController.MAX_INPUT_VNO);
        textArea.addKeyListener(new TextAreaEnterAdapter());
        textArea.setLineWrap(true);
        textArea.setWrapStyleWord(true);
        Document document = textArea.getDocument();
        document.addDocumentListener(new VnoTextAreaDocListener(table, textArea));
    public Component getTableCellEditorComponent(JTable table, Object value,
                                                 boolean isSelected, int row,
                                                 int column) {
        if (value instanceof String) {
            textArea.setText((String)value);
        } else if (value instanceof Integer) {
            Integer intValue = (Integer)value;
            textArea.setText(intValue.toString());
        } else {
            Object objValue = value;
            textArea.setText(objValue.toString());
        System.err.println("Editor - get Component");
        return textArea;
    public Object getCellEditorValue() {
        return textArea.getText();
public class VnoTextAreaDocListener implements DocumentListener {
    private JTable table;
    private JTextArea textArea;
    public VnoTextAreaDocListener(JTable table, JTextArea textArea) {
        this.table = table;
        this.textArea = textArea;
    public void insertUpdate(DocumentEvent e) {
        VnoTableRowHeightHelper.setOptimalRowHeight(table, textArea);
    public void removeUpdate(DocumentEvent e) {
        VnoTableRowHeightHelper.setOptimalRowHeight(table, textArea);
    public void changedUpdate(DocumentEvent e) {
        //Plain text components don't fire these events
}As said the editor works almost as planned. On every Keystroke made in Edit-Mode of the table, insertUpdate() or removeUpdate()
is being called, corresponding to the type of Keystroke ... (duh!)
The Helpers method is called and the row-height is set real nicely.
!But!
when i navigate into an other row, a removeUpdate()-event is beeing thrown and due to the mechanism the cell selection
gets somehow mixed around and row-heights get switched.
Maybe this could get improved, but i don't se my error - which wouldn't be nescessary if this event wasn't thrown.
(for what I don't see a reason anyway ... !)
CellRenderer:
public class VnoCellRenderer implements TableCellRenderer {
    private VnoTextArea textArea;
    private int Row = -1;
    private int Column = -1;
    private VnoTableModel jtmVno;
    public VnoCellRenderer(JTable table) {
        this.jtmVno = (VnoTableModel)table.getModel();
        textArea = new VnoTextArea(table);
        textArea.setLayout(new BorderLayout());
        textArea.setLineWrap(true);
        textArea.setWrapStyleWord(true);
    public VnoTextArea getTextArea() {
        return textArea;
    public Component getTableCellRendererComponent(JTable table, Object value,
                                                   boolean isSelected,
                                                   boolean hasFocus, int row,
                                                   int column) {
        Row = row;
        Column = column;
        String tmpValue = null;
        if (value instanceof String) {
            tmpValue = (String)value;
        } else if (value instanceof Integer) {
            tmpValue = ((Integer)value).toString();
        } else {
            tmpValue = value.toString();
        // FARBEN:
        // Normalmodus
        if (jtmVno == null) {
            System.err.println("Table Model noch nicht initialisiert!");
            textArea.setBackground(Color.LIGHT_GRAY);
        } else {
            if (jtmVno.isCellEditable(Row, Column)) {
                textArea.setBackground(Color.WHITE);
            } else {
                textArea.setBackground(Color.LIGHT_GRAY);
        textArea.setForeground(Color.BLACK);
        // Für ausgewählte Zeile
        if (isSelected && !hasFocus) {
            textArea.setBackground(CommonConstants.SELECTION_COLOR_BLUE);
            textArea.setForeground(Color.WHITE);
        textArea.setText(tmpValue);
        textArea.setEditable(true);
        if (Column == VerwaltungsnotizController.IND_VNO_NOTIZ) {
            VnoTableRowHeightHelper.setOptimalRowHeight(table, textArea, row, column);
        return textArea;
}Okay, this is where the shit hits the fan!
Since with renderers there is no manual content mutation, row-height-settings are not done with listeners.
I put this at the very end of the getTableCellRendererComponent(), which is called every time a cell gets rendered.
The main problem here is that at this point my methods can't determine any linewraps at all!
getWrappedLines() always returns an empty Array (since Utilities.getRowEnd() returns "-1" beforehand...).
I'm afraid that my methods are called way too early - at a point were the rendering is not completed or has not even started.
And to accomplish my desired tasks the fully rendered JTextArea would be needed ... ?!
I have very limited swing experience, so I can only guess about this core features ...
But i this is the case - my methods should be called later on the rendered cell. But how? from which component?
Btw: I have written my own JTextArea to limit the input size
public class VnoTextArea extends JTextArea {
    private JTable table;
    private int _maximumInputLength = 0;
    public VnoTextArea(JTable table) {
        this.table = table;
    public void setMaximumInputLength(int maximumInputLength) {
      if (maximumInputLength != 0) {
        _maximumInputLength = maximumInputLength;
        super.setDocument(new PlainDocument() {
            public void insertString(int offset, String string, AttributeSet attributeSet) throws BadLocationException {
              StringBuffer buffer = new StringBuffer(string);
              int size = VnoTextArea.this.getText().length();
              int bufferSize = buffer.length();
              if ((size + bufferSize) > _maximumInputLength) {
                buffer.delete((_maximumInputLength - size), bufferSize);
              if (size < _maximumInputLength) {
                super.insertString(offset, buffer.toString(), attributeSet);
              } else {
                Toolkit.getDefaultToolkit().beep();
}I'm sorry for not providing a running example, but it's a pretty huge project...
Providing all dependencies would go far beyond the scope.
(and there are many sources which I'm not allowed to post)
But I hope my examples get down to the core of my problem!
I also tried different approaches:
- using getPreferredSize() of the JTextArea (seemed to do nothing useful at all?!)
- using getLineCount/() of the TextArea (only counts "\n" ...)
- guessing that every row consist of an average of 20 characters cumpute by myself (low-tech, buggy but fast - unsatisfying)
With my above mentioned approach I got by far the best results (partially) - but I'm at my wits' end.
I don't know it any better... And i have tried for days without improvement.
What would you do?
vielen Dank im Voraus schon mal für eventuelle Mühen,
Haye

Answer 1

no solution - just a couple of comments:
- never ever change the calling table in a renderer, I mean really NEVER
- instead, listen to table events and resize the row height as appropriate
- JTextArea has a somehow weird prefSize calculation (forgot the details, so don't nail me :), so you have to manually set one dimension and then ask the area to calculate the other. In your renderer, you can do something like:
Component getTableCellRendererComponent(....) {
    int columnWidth = table.getColumnModel().getColumn(column).getWidth();
    textArea.setSize(columnWidth, Short.MAX_VALUE);
    ... here do the normal config
// then somewhere else, triggered by appropriate change events
void updateRowHeight(JTable table, int row) {
   int height = table.getRowHeight();
   foreach column {
         TableCellRenderer r = table.getCellRenderer(row, column);
         Component c = table.prepareCellRenderer(r, row, column);
         height = Math.max(height, c.getPreferredSize().height);
   table.setRowHeight(row, height);
} HTH - ein bißchen wenigstens :-)
Jeanette