Issues with JTextArea as cellEditor of JTable Column.

[nirvan bud]

I am trying to use JTextArea as a cellEditor for a JTextArea column. I created a custom CellEditor for the purpose. But when I use the JTextArea component I get a few issues.

1. The JTextArea default "Tab" key operation does not take the cursor out of the textarea. To avoid this I used
textArea.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,new Tab Key). This solved my problem.

2. To come out of the textArea column into the next column, I have to press the "Tab" key twice. I have not been able to solve this problem.

3. Since I am using JTextArea, I want to use JScrollPane with JTextArea in it instead. But when I use JScrollPane with JTextArea in it pressing the "Tab" key takes focus out of the JTable, instead of traversing to the next column. I haven't been able to solve this problem too.

Here is the custom CellEditor code.

    public class DescColCellEditor extends AbstractCellEditor implements TableCellEditor {

        JTextArea comp;

        public DescColCellEditor () {
            comp = new JTextArea();
        }

        public Component getTableCellEditorComponent(JTable table, Object value,
                boolean isSelected, int rowIndex, int vColIndex) {

                comp.setLineWrap(true);
                comp.setText((String)value);

            CustomUtilities.setTabAsForwardKey(comp); //set "Tab" as forward traversal keys.

            return comp;
        }

        public Object getCellEditorValue() {
            return ((JTextArea)comp).getText();
        }
    } // inner class

regards,
nirvan

[Rob Camick]

BeForthrightWhenCrossPostingToOtherSites

OP has been asked to provide a SSCCE in the other forum but has yet to do so.

[nirvan bud]

Rob,
Sorry about cross-posting. Here is the SSCCE that shows the problem. Please note following.

1. In the SSCCE, I have used JTextArea inside the JTable column without JScrollPane holding it. This will show that you will have to press "Tab" key twice in order to get out of JTable column.

2. If you change the SSCCE to use JScrollPane as container for JTextArea, you will see that pressing the "Tab" key takes the cursor out of the JTable instead of to the next column.


The main JFrame that contains JTable

 
package com.ns;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.KeyboardFocusManager;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.swing.AbstractCellEditor;
import javax.swing.Action;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.KeyStroke;
import javax.swing.WindowConstants;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableColumn;

public class JTableSSCCE extends javax.swing.JFrame {

    /** Creates new form JTableSSCCE */
    public JTableSSCCE() {
        initComponents();
        setNewTabKeyAction();
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    private void initComponents() {

        scrTablePane = new JScrollPane();
        tableModel = new ProfileTableModel();
        tblMemProfile = new JTable();

        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        tblMemProfile.setModel(tableModel);
        tblMemProfile.setRowHeight(52);
        tblMemProfile.getTableHeader().setFont(tblMemProfile.getTableHeader().getFont().deriveFont(Font.BOLD));

        if (!tableModel.hasEmptyRow()) {
            tableModel.addEmptyRow();
        }
        tblMemProfile.setSurrendersFocusOnKeystroke(true);
        TableColumn profIdCol = tblMemProfile.getColumnModel().getColumn(ProfileTableModel.ID_INDEX);
        profIdCol.setPreferredWidth(40);

        TableColumn lastEditDateCol = tblMemProfile.getColumnModel().getColumn(ProfileTableModel.DATE_INDEX);
        lastEditDateCol.setPreferredWidth(50);
        TableColumn descCol = tblMemProfile.getColumnModel().getColumn(ProfileTableModel.DESC_INDEX);
        descCol.setCellEditor(new DescColCellEditor());
        descCol.setPreferredWidth(325);
        scrTablePane.setViewportView(tblMemProfile);

        getContentPane().add(scrTablePane, BorderLayout.CENTER);

        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setBounds((screenSize.width-600)/2, (screenSize.height-400)/2, 600, 400);
    }// </editor-fold>


//Set custom action for tab key pressed.
    public void setNewTabKeyAction () {
//forward Navigation.
        KeyStroke tab = KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0); //forward
        KeyStroke shiftTab = KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_MASK); //backward

		Action tabAction = new WrappedAction (tblMemProfile, tab) {

			public void actionPerformed(ActionEvent e) {
                int row = tblMemProfile.getSelectedRow();
                int col = tblMemProfile.getSelectedColumn();

				invokeOriginalAction( e );
                if (col == 2) {
    				invokeOriginalAction( e );
                }
                if (row == tableModel.getLastRow() && col == ProfileTableModel.DESC_INDEX) {
                    if (!tableModel.hasEmptyRow()) {
                        tableModel.addEmptyRow();
                    }
                }
			}
		};

//backward tab
		Action shiftTabAction = new WrappedAction (tblMemProfile, shiftTab) {

            public void actionPerformed(ActionEvent e) {
                int row = tblMemProfile.getSelectedRow();
                int col = tblMemProfile.getSelectedColumn();
				invokeOriginalAction( e );
                if (col == 1) {
    				invokeOriginalAction( e );
                    if (tableModel.hasEmptyRow()) {
                        tableModel.deleteEmptyRow();
                    }
                }
            }
		};
    }


    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new JTableSSCCE().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify
    private JScrollPane scrTablePane;
    private JTable tblMemProfile;
    // End of variables declaration
    
    private ProfileTableModel tableModel;
    SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");

    public class ProfileTableModel extends AbstractTableModel {

        private static final int ID_INDEX = 0;
        private static final int DATE_INDEX = 1;
        private static final int DESC_INDEX = 2;

        private SimpleDateFormat sdf;

        private final String [] colNames = {"Profile Id",
                                            "Date Edited",
                                            "Profile Description"};


        private final Class [] colClass = {Integer.class,
                                           String.class,
                                           String.class};

        private ArrayList <MemberProfileDO> dataList;

        ProfileTableModel () {
            sdf = new SimpleDateFormat("dd-MM-yyyy");
            sdf.setLenient(false);
            dataList = new ArrayList <MemberProfileDO> ();
        }

        public List <MemberProfileDO> getDataList (){
            return dataList;
        }
        public void setDataList (ArrayList <MemberProfileDO> newDataList) {
            this.dataList = newDataList;
        }
//  Implements methodsd of AbstractTableModel plus other utility methods.
        public int getColumnCount () {
            return colNames.length;
        }

        public String getColumnName (int col) {
            return colNames [col];
        }

        public Class getColumnClass (int col) {
            return colClass [col];
        }

        public int getRowCount () {
            return dataList.size();
        }

        public Object getValueAt (int row, int col) {
            MemberProfileDO memProf = dataList.get(row);
            switch (col) {
                case ID_INDEX:
                    if (memProf.getProfId() == 0)
                        return null;
                    else
                        return memProf.getProfId();
                case DATE_INDEX:
                    if ((memProf.getDateLastEdit()) == null) {
                        return "";
                    }
                    else {
                        return sdf.format(memProf.getDateLastEdit());
                    }
                case DESC_INDEX:
                    return memProf.getProfDesc();
                default:
                    return null;
            }
        }

        public void setValueAt(Object value, int row, int col) {
            MemberProfileDO memProf = dataList.get(row);
            switch (col) {
                case ID_INDEX:
                    break;
                case DATE_INDEX:
                    try {
                        memProf.setDateLastEdit(sdf.parse((String) value));
                    }
                    catch (ParseException pe) {
                        memProf.setDateLastEdit(null);
                    }
                    break;
                case DESC_INDEX:
                    memProf.setProfDesc((String) value);
                    break;
                default:
                   System.out.println("Invalid Index");
            }
            fireTableCellUpdated(row, col);
        }

        public boolean hasEmptyRow() {
            if (dataList.size() == 0) {
                return false;
            }
            MemberProfileDO memProf = dataList.get(dataList.size() - 1);
            if ((memProf.getProfDesc() == null) || memProf.getProfDesc().equals("")) {
                return true;
            }
            else {
                return false;
            }
        }

        public void addEmptyRow() {
            dataList.add(new MemberProfileDO());
            fireTableRowsInserted(dataList.size() -1, dataList.size() -1);
            tblMemProfile.setRowSelectionInterval(dataList.size() -1, dataList.size() -1);
        }

        public void deleteEmptyRow() {
            if (hasEmptyRow()) {
                int row = dataList.size() -1;
                dataList.remove(dataList.size() - 1);
                fireTableRowsDeleted(row, row);
            }
        }

        public boolean isCellEditable(int row, int col) {
            if ((col == ID_INDEX)) {
                return false;
            }
            else {
                return true;
            }
        }

//required for focussing
        public int getLastRow (){
            return (dataList.size() - 1);
        }
    } //close inner ProfileTableModel


    public class DescColCellEditor extends AbstractCellEditor implements TableCellEditor {

        JTextArea comp;

        public DescColCellEditor () {
            comp = new JTextArea();
        }

        public Component getTableCellEditorComponent(JTable table, Object value,
                boolean isSelected, int rowIndex, int vColIndex) {

            comp.setLineWrap(true);
            comp.setText((String)value);


            comp.getInputMap().getParent().remove(
                        KeyStroke.getKeyStroke(KeyEvent.VK_TAB,0));
            comp.getInputMap().remove(
                        KeyStroke.getKeyStroke(KeyEvent.VK_TAB,0));

    //set Tab as forward key instead of ctrl + tab.

        Set newForwardKeys = new HashSet();
        newForwardKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
        comp.setFocusTraversalKeys(
                    KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,newForwardKeys);

        Set newBackwardKeys = new HashSet();
        newBackwardKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_MASK));

        comp.setFocusTraversalKeys(
                    KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,newBackwardKeys);
    //

            return comp;
        }

        // This method is called when editing is completed.
        // It must return the new value to be stored in the cell.
        public Object getCellEditorValue() {
            return ((JTextArea)comp).getText();
        }
    } // inner class

}

The Data Oboject that ArrayList needs to back the JTable

    
package com.ns;

import java.util.Date;

public class MemberProfileDO {
    private int profId;
    private int memId;
    private Date dateLastEdit;
    private String profDesc;

    public void setProfId(int profId) {
        this.profId = profId;
    }
    public int getProfId(){
        return this.profId;
    }

    public void setMemId(int memId) {
        this.memId = memId;
    }
    public int getMemId () {
        return this.memId;
    }
    
    public void setDateLastEdit (Date dateLastEdit) {
        this.dateLastEdit = dateLastEdit;
    }
    public Date getDateLastEdit () {
        return dateLastEdit;
    }

    public void setProfDesc (String profDesc) {
        this.profDesc = profDesc;
    }
    public String getProfDesc () {
        return profDesc;
    }
}

The WrappedAction class for setting new action to TAB key (Written by you).

 
package com.ns;

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

/*
 *  The WrappedAction class is a convenience class that allows you to replace
 *  an installed Action with a custom Action of your own. There are two
 *  benefits to using this class:
 *
 *  a) Key Bindings of the original Action are retained for the custom Action.
 *  b) the original Action is retained so your custom Action can invoke the
 *     original Action.
 *
 *  This class is abstract so your custom Action must extend this class and
 *  implement the actionPerformed() method.
 */
public abstract class WrappedAction implements Action
{
	private Action originalAction;
	private JComponent component;
	private Object actionKey;

	/*
	 *  Replace the default Action for the given KeyStroke with a custom Action
	 */
	public WrappedAction(JComponent component, KeyStroke keyStroke)
	{
		this.component = component;
		Object actionKey = getKeyForActionMap(component, keyStroke);

		if (actionKey == null)
		{
			String message = "no input mapping for KeyStroke: " + keyStroke;
			throw new IllegalArgumentException(message);
		}

		setActionForKey( actionKey );
	}

	/*
	 *  Replace the default Action with a custom Action
	 */
	public WrappedAction(JComponent component, Object actionKey)
	{
		this.component = component;
		setActionForKey( actionKey );
	}

	/*
	 *  Search the 3 InputMaps to find the KeyStroke binding
	 */
	private Object getKeyForActionMap(JComponent component, KeyStroke keyStroke)
	{
		for (int i = 0; i < 3; i++)
		{
	    	InputMap inputMap = component.getInputMap(i);

		    if (inputMap != null)
		    {
				Object key = inputMap.get(keyStroke);

				if (key != null)
					return key;
			}
	    }

		return null;
	}

	/*
	 *  Replace the existing Action for the given action key with a
	 *  wrapped custom Action
	 */
	private void setActionForKey(Object actionKey)
	{
		//  Save the original Action

		this.actionKey = actionKey;
		originalAction = component.getActionMap().get(actionKey);

		if (originalAction == null)
		{
			String message = "no Action for action key: " + actionKey;
			throw new IllegalArgumentException(message);
		}

		//  Replace the existing Action with this class

		install();
	}

	/*
	 *  Child classes should use this method to invoke the original Action
	 */
	public void invokeOriginalAction(ActionEvent e)
	{
		originalAction.actionPerformed(e);
	}

	/*
	 *  Install this class as the default Action
	 */
	public void install()
	{
		component.getActionMap().put(actionKey, this);
	}

	/*
	 *	Restore the original Action as the default Action
	 */
	public void unInstall()
	{
		component.getActionMap().put(actionKey, originalAction);
	}
//
//  Delegate the Action interface methods to the original Action
//
	public void addPropertyChangeListener(PropertyChangeListener listener)
	{
		originalAction.addPropertyChangeListener(listener);
	}

	public Object getValue(String key)
	{
		return originalAction.getValue(key);
	}

	public boolean isEnabled()
	{
		return originalAction.isEnabled();
	}

	public void putValue(String key, Object newValue)
	{
		originalAction.putValue(key, newValue);
	}

	public void removePropertyChangeListener(PropertyChangeListener listener)
	{
		originalAction.removePropertyChangeListener(listener);
	}

	public void setEnabled(boolean newValue)
	{
		originalAction.setEnabled(newValue);
	}
//
//  Implement some AbstractAction methods
//
	public Object[] getKeys()
	{
		if (originalAction instanceof AbstractAction)
		{
			AbstractAction abstractAction = (AbstractAction)originalAction;
			return abstractAction.getKeys();
		}

		return null;
	}

	public PropertyChangeListener[] getPropertyChangeListeners()
	{
		if (originalAction instanceof AbstractAction)
		{
			AbstractAction abstractAction = (AbstractAction)originalAction;
			return abstractAction.getPropertyChangeListeners();
		}

		return null;
	}
}

regards,
nirvan

[Rob Camick]

That is NOT a SSCCE.

Your question is about a custom cell editor. Your code includes a custom TableModel and custom data class. Those are irrelevant for testing a cell editor. Maybe the model or data class is causing the problem so get rid of them. It takes one line of code to create a JTable:

JTable table = new JTable(10, 5);

Then you add you custom editor to it and start testing. We don't want (or have time) to look at code that is not related to the problem.

[Campbell Ritchie]

And can I remind you of what the other Rob told you. Private message to follow in case you can't remember.

[nirvan bud]

Sorry once again Rob. This time I am sure it is an SSCCE.

Issue Once again:

1. If the column editor is JTextArea, then after editing the column, it requires two "Tab" key presses to come out of it.

2. If the column editor is JScrollPane with JTextArea inside, then it is not possible to start it editing using the keyboard. It requires use of mouse to start editing.

Here is the code.

    

package com.ns;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.KeyboardFocusManager;
import java.awt.event.KeyEvent;
import java.util.HashSet;
import java.util.Set;
import javax.swing.AbstractCellEditor;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.KeyStroke;
import javax.swing.WindowConstants;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellEditor;

public class JTableSSCCE2 extends javax.swing.JFrame {

    public JTableSSCCE2() {
        initComponents();
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    private void initComponents() {

        jScrollPane1 = new JScrollPane();
        jTable1 = new JTable();

        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        jTable1.setModel(new DefaultTableModel(
            new Object [][] {
                {null, null, null, null},
                {null, null, null, null},
                {null, null, null, null},
                {null, null, null, null}
            },
            new String [] {
                "Title 1", "Title 2", "Title 3", "Title 4"
            }
        ));
        jTable1.setRowHeight(36);
        jTable1.getColumnModel().getColumn(0).setCellEditor(new DescColCellEditor());
        jTable1.getColumnModel().getColumn(1).setCellEditor(new DescColScrollCellEditor ());
        jScrollPane1.setViewportView(jTable1);

        getContentPane().add(jScrollPane1, BorderLayout.CENTER);

        pack();
    }// </editor-fold>

    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new JTableSSCCE2().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify
    private JScrollPane jScrollPane1;
    private JTable jTable1;
    // End of variables declaration

    public class DescColCellEditor extends AbstractCellEditor implements TableCellEditor {

        JTextArea comp;

        public DescColCellEditor () {
            comp = new JTextArea();
        }

        public Component getTableCellEditorComponent(JTable table, Object value,
                boolean isSelected, int rowIndex, int vColIndex) {

            comp.setLineWrap(true);
            comp.setText((String)value);


            comp.getInputMap().getParent().remove(
                        KeyStroke.getKeyStroke(KeyEvent.VK_TAB,0));
            comp.getInputMap().remove(
                        KeyStroke.getKeyStroke(KeyEvent.VK_TAB,0));

    //set Tab as forward key instead of ctrl + tab.

        Set newForwardKeys = new HashSet();
        newForwardKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
        comp.setFocusTraversalKeys(
                    KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,newForwardKeys);

        Set newBackwardKeys = new HashSet();
        newBackwardKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_MASK));

        comp.setFocusTraversalKeys(
                    KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,newBackwardKeys);
    //

            return comp;
        }

        public Object getCellEditorValue() {
            return ((JTextArea)comp).getText();
        }
    } // inner class

    public class DescColScrollCellEditor extends AbstractCellEditor implements TableCellEditor {

        JScrollPane scrPane;
        JTextArea comp;

        public DescColScrollCellEditor () {
            comp = new JTextArea();
            scrPane = new JScrollPane();
        }

        public Component getTableCellEditorComponent(JTable table, Object value,
                boolean isSelected, int rowIndex, int vColIndex) {

            comp.setLineWrap(true);
            comp.setText((String)value);

/*
            comp.getInputMap().getParent().remove(
                        KeyStroke.getKeyStroke(KeyEvent.VK_TAB,0));
            comp.getInputMap().remove(
                        KeyStroke.getKeyStroke(KeyEvent.VK_TAB,0));
*/
    //set Tab as forward key instead of ctrl + tab.

            Set newForwardKeys = new HashSet();
            newForwardKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
            comp.setFocusTraversalKeys(
                        KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,newForwardKeys);

            Set newBackwardKeys = new HashSet();
            newBackwardKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_MASK));

            comp.setFocusTraversalKeys(
                        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,newBackwardKeys);
    //
            scrPane.add(comp);
            scrPane.setViewportView(comp);
            return scrPane;
        }

        public Object getCellEditorValue() {
            return ((JTextArea)comp).getText();
        }
    } // inner class

}

regards,
nirvan.

[Rob Spoor]

Please read your private messages. This is not optional.

[Rob Camick]

Well, there are actually more than 2 InputMaps for the text area so you need to loop through all of them to make sure the binding is removed.

public class DescColCellEditor extends AbstractCellEditor implements TableCellEditor
{
    JTextArea comp;

    public DescColCellEditor ()
    {
        comp = new JTextArea();
        comp.setLineWrap(true);

        KeyStroke keyStroke = KeyStroke.getKeyStroke("TAB");
        InputMap im = comp.getInputMap();

        while (im != null)
        {
            im.remove(keyStroke);
            im = im.getParent();
        }
    }

    public Component getTableCellEditorComponent(JTable table, Object value,
        boolean isSelected, int rowIndex, int vColIndex)
    {

         comp.setText((String)value);
         return comp;
    }

    public Object getCellEditorValue()
    {
         return ((JTextArea)comp).getText();
    }
}

[nirvan bud]

I have resolved the problem no 1 presented in the last SSCCE post. Now the only problem is (problem no 2) that when I add scrollPane (with JTextArea in it), instead of directly adding JTextArea to the JTable, the column cannot be edited by keyboard i.e. it requires a mouse click.

regards,
nirvan.

[nirvan bud]

I implemented focus listener on the Custom cell editor class to find where exactly the focus is going when using keyboard. When scrollPane is used instead of directly adding JTextarea, the focus goes to scrollPane and not the JTextArea and hence I am not able to edit the cell. Surprisingly, when mouse is directly used over the cell to gain focus, the Jtextarea gets the focus !.

I tried to use table.setSurrendersFocusOnKeystroke(true) but that doesn't solve the problem.

If anyone knows how to set focus to the child component of jscrollpane preferrably without using Focus Traversal Policy, please let me know.


regards,
nirvan.

[mark goking]

this thread is not that very old so i will reply. in case you are interested nirvan bud, i created a TextAreaCellEditor class that traps the TAB key event and transfers focus to the next cell of the JTable.

in this case, the TAB key will loop through all cells of the JTable endlessly, meaning, if it is at the last column and last row of the JTable, the TAB key will then focus the 1st row and 1st column.

http://tech.chitgoks.com/2010/01/28/jtextarea-cell-editor-tab-key-traversal-to-next-cell-in-jtable/