Resizing Columns in Tree Table

Question

hi all!
Iam using TreeTable's in my application. It is already developed by somebody. Now what is my problem is when I try to resize the column the subsequent columns are not resizing.
Can any body help me out to fix this issue
Thanks in Advance

Answer 1

I think you got this code from site na?
I have already seen this code in the net. But I didn't found mistake in our code. What actually is it was developed by somebody.
If you don't mind I will send that code can you please observe it for the mistake.
Here is my code:
Here all the things beginning:
private void configureForm()
setBorder(editor.buildBorder(presenter
.doGetProperty("vmtp.info.testCaseSelector.title")));
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
tree = new TestCaseTree(presenter, testCaseIn, testCaseOut);
ActionTreeTablePanel actionTreeTablePanel = new ActionTreeTablePanel(tree, presenter);
this.add(actionTreeTablePanel);
Here is the TestCaseTree.java file:
public class TestCaseTree extends ActionTreeTable implements TreeExpansionListener
public TestCaseTree(Presenter presenter, TestCaseTO testCaseIn, TestCaseTO testCaseOut)
super(presenter, testCaseOut, testCaseOut.getActions(), new TestCaseTreeToolbar(presenter));
addTreeExpansionListener(this);
ActionBaseTO.enumerateActions(testCaseOut.getActions());
* This statement causes tooltip to display for child nodes
setToolTipText(testCaseIn.getName());
/* (non-Javadoc)
* @see javax.swing.JTree#isPathEditable()
@Override
public boolean isPathEditable(TreePath path)
DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
DefaultMutableTreeNode parent = (DefaultMutableTreeNode)node.getParent().getParent();
* Commenting out below lines to enable editing of parameter values for
* action groups in a test case
//if(parent != null && parent.getUserObject() instanceof ActionTreeTableNode)
//if(((ActionTreeTableNode)parent.getUserObject()).getAction().isGroup())
// return false;
return super.isPathEditable(path);
public void setVecTreeStateBookmark(Vector treeState) {
     BookmarkTO bookmark = VmtpSession.getVmtpSession().getBookmark();
     BookmarkItemTO bookmarkItem = bookmark.getLastMarkedItem();
     if (bookmarkItem != null && parentObject != null
     && bookmarkItem.getObjectId() == ((TestCaseTO)parentObject).getId()
     && bookmarkItem.getObjectType() == BookmarkItemType.TESTCASE) {
     bookmarkItem.setTreeState(treeState);
public void updateVecTreeStateBookmark() {
          BookmarkTO bookmark = VmtpSession.getVmtpSession().getBookmark();
          BookmarkItemTO bookmarkItem = bookmark.getLastMarkedItem();
          Vector rowVec = currentExpandedPath();
          if (bookmarkItem != null
                    && parentObject != null
                    && bookmarkItem.getObjectId() == ((TestCaseTO) parentObject)
                              .getId()
                    && bookmarkItem.getObjectType() == BookmarkItemType.TESTCASE) {
               bookmarkItem.setTreeState(rowVec);
private Vector currentExpandedPath() {
          Vector rowVec = new Vector();
          for (int i = 0; i < getRowCount(); i++) {
               String expandedPath = null;
               String currPathExpanded = getPathExpanded(i);
               if (!currPathExpanded.equals("")) {
                    expandedPath = i + getPathExpanded(i);
                    rowVec.add(expandedPath);
          return rowVec;
private String getPathExpanded(int row) {
     String str = "";
     TreePath path = getPathForRow(row);
     int noofrows = this.getRowCount();
     for(int i = row; i < noofrows; i++) {
          TreePath currPath = this.getPathForRow(i);
          if(i==row || currPath.isDescendant(path)) {
               if(this.isExpanded(currPath)) {
                    str = str + "," + (i - row);
     return str;
public Vector getVecTreeStateBookmark() {
     BookmarkTO bookmark = VmtpSession.getVmtpSession().getBookmark();
     BookmarkItemTO bookmarkItem = bookmark.getLastMarkedItem();
     if (bookmarkItem != null && parentObject != null
     && bookmarkItem.getObjectId() == ((TestCaseTO)parentObject).getId()
     && bookmarkItem.getObjectType() == BookmarkItemType.TESTCASE)
     return bookmarkItem.getTreeState();
     return null;
     public void treeCollapsed(TreeExpansionEvent event) {
          updateVecTreeStateBookmark();
          // TODO Auto-generated method stub
     public void treeExpanded(TreeExpansionEvent event) {
          updateVecTreeStateBookmark();
          // TODO Auto-generated method stub
Here is ActionTreeTable.java
public abstract class ActionTreeTable extends JTree
protected Presenter presenter;
protected DefaultMutableTreeNode top;
private ActionTreeTableModel treeModel;
protected List<ActionTO> actions;
private ParameterTO selectedParameter;
private JScrollPane scrollPane;
protected ActionTreeTableToolbar toolbar;
protected AbstractToolbarTable selectedTable;
//A jtableheader to be propogated to the parametertablemodel
protected JTableHeader                    header;
* The parent object to actions, such as test case, action group etc.
protected AbstractTO parentObject;
private Collection<ParameterTable> tables = new ArrayList<ParameterTable>();
private int tableWidth = 100;
public ActionTreeTable(Presenter presenter, AbstractTO parentObject,
          Collection<ActionTO> actions, ActionTreeTableToolbar toolbar)
super();
this.parentObject = parentObject;
this.actions = (List<ActionTO>)actions;
this.toolbar = toolbar;
this.presenter = presenter;
toolbar.setTree(this);
configureTreeTable();
* bad programming but needs to be done to adhere to the existing design of the table
* header and the tree tables
* @param tableHeader
public void setHeader(JTableHeader tableHeader) {
     this.header = tableHeader;
     if(header != null && tables.size() >= 1) {
          Object[] currTables = tables.toArray();
          for(int i = 0; i < currTables.length; i++) {
               ParameterTableLite currLiteTable = (ParameterTableLite)currTables;
               ParameterTableModel model = currLiteTable.getParameterModel();
               model.setTableHeader(tableHeader);
     // adding a mouse listener to the header that updates the tree when the
          // mouse is clicked on the header and all the table models are sorted
          // according to the desired column
          tableHeader.addMouseListener(new MouseListener() {
               public void mouseClicked(MouseEvent e) {
                    repaint();
               public void mouseEntered(MouseEvent e) {
                    // ignored
               public void mouseExited(MouseEvent e) {
                    // ignored
               public void mousePressed(MouseEvent e) {
                    // ignored
               public void mouseReleased(MouseEvent e) {
                    // ignored
public JTableHeader getHeader() {
     return header;
private void configureTreeTable()
this.setRootVisible(false);
this.setShowsRootHandles(true);
this.setMaximumSize(new Dimension(2000, 2000));
buildTree();
//expandTreePerBookmark();
public synchronized boolean buildTree()
boolean outcome = false;
addMouseListener(new ActionTreeTableMouseListener(this));
try {
top = new DefaultMutableTreeNode(null);
treeModel = new ActionTreeTableModel(top, actions);
setModel(treeModel);
addActionsToRoot(actions);
if (this.getRowHeight() <= 0)
// Temporary change to non-zero height
this.setRowHeight(1);
this.setRowHeight(0);
//ActionTreeTableCellRenderer renderer=new ActionTreeTableCellRenderer();
//System.out.println(renderer.getComponent(1));
this.setCellRenderer(new ActionTreeTableCellRenderer());
this.setCellEditor(new ActionTreeTableCellEditor(this));
this.setEditable(true);
this.validateTree();
outcome = true;
} catch (Exception e) {
// log.log(Level.SEVERE, "Can't load data", e);
} finally {
return outcome;
* Set the expanded nodes in the tree in the bookmark
* @param treeExpanded true if tree is expanded, false if tree is collapsed
public abstract void setVecTreeStateBookmark(Vector treeState);
* Get tree's previous state from bookmark
* @return true if tree was previously expanded, false if collpased
public abstract Vector getVecTreeStateBookmark();
public void addActionsToRoot(Collection<ActionTO> newActions)
this.addActionsToTree(newActions, top, false);
public void addActionsToTree(Collection<ActionTO> newActions, DefaultMutableTreeNode parent, boolean groupActions)
Iterator iterator = newActions.iterator();
ActionTO actionTO;
DefaultMutableTreeNode node;
ParameterTable parameterTable = null;
while (iterator.hasNext())
actionTO = (ActionTO)iterator.next();
node = new DefaultMutableTreeNode(new ActionTreeTableNode(actionTO));
if(actionTO.isGroup())
this.addActionsToTree(actionTO.getActionGroup().getActions(), node, true);
else
JPanel tablePanel = new JPanel();
ParameterTableModel model =
new ParameterTableModel(actionTO, actionTO,
          ParameterTableModel.MODE_IMPLEMENTATION, presenter);
if(groupActions)
model.setGroupAction(true);
parameterTable = new ParameterTableLite(tablePanel, presenter, model, this);
parameterTable.setToolbar(toolbar);
tables.add(parameterTable);
parameterTable.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
parameterTable.setAutoscrolls(true);
node.add(new DefaultMutableTreeNode(parameterTable));
* When creating ActionGroups this will be executed when we are adding new
* actions to the tree.
if(newActions != actions && parent == top)
actions.add(actionTO);
* Passing -1 as index means that the underlying collection of ActionTOs
* won't be affected. This has already been taken care of above.
// treeModel.insertNodeInto(node, parent, parent.getChildCount());
treeModel.insertNodeInto(node, parent, -1);
treeModel.reload();
public void removeActionFromTree(MutableTreeNode node)
treeModel.removeNodeFromParent(node);
public void moveActionUp(TreePath path)
DefaultMutableTreeNode nodeToMove = (DefaultMutableTreeNode)path.getLastPathComponent();
this.moveAction(nodeToMove, -1);
public void moveActionDown(TreePath path)
DefaultMutableTreeNode nodeToMove = (DefaultMutableTreeNode)path.getLastPathComponent();
this.moveAction(nodeToMove, 1);
public void moveAction(DefaultMutableTreeNode nodeToMove, int offset)
treeModel.moveAction(nodeToMove, offset);
setSelectionRow(treeModel.getIndexOfChild(top, nodeToMove));
* @param selectedParameter The selectedParameter to set.
public void setSelectedParameter(ParameterTO selectedParameter)
this.selectedParameter = selectedParameter;
public AbstractToolbarTable getSelectedTable()
TreePath path = this.getSelectionPath();
if(path != null)
DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
if(node.getUserObject() instanceof JTable)
return (AbstractToolbarTable)node.getUserObject();
return null;
public ParameterTO getSelectedParameter()
TreePath path = this.getSelectionPath();
if(path != null)
DefaultMutableTreeNode node =
(DefaultMutableTreeNode)path.getLastPathComponent();
if(node.getUserObject() instanceof AbstractToolbarTable)
AbstractToolbarTable table =
(AbstractToolbarTable)node.getUserObject();
if(table.getSelectedRow() != -1)
return (ParameterTO)table.getTableModel().getRowData(table.getSelectedRow());
return null;
public void collapseTree()
int row = getRowCount() - 1;
while (row >= 0)
collapseRow(row);
row--;
public void expandTree()
int row = 0;
while (row < getRowCount())
expandRow(row);
row++;
* @return Returns the scrollPane.
public JScrollPane getScrollPane()
return scrollPane;
* @param scrollPane The scrollPane to set.
public void setScrollPane(JScrollPane scrollPane)
this.scrollPane = scrollPane;
public void setEnabled(boolean isEnabled)
// super.setEnabled(isEnabled);
setEditable(isEnabled);
ParameterTable tmpTable;
for(Iterator i = tables.iterator() ; i.hasNext() ;)
tmpTable = (ParameterTable)i.next();
* Commented out below lines to enable editing of parameter values
* for action groups in a test case
//if(tmpTable.isGroupAction())
// tmpTable.setEnabled(false);
//else
// tmpTable.setEnabled(isEnabled);
tmpTable.setEnabled(isEnabled);
toolbar.setToolbarEnabled(isEnabled);
public void setBounds(int x, int y, int w, int h)
clearSelection();
super.setBounds(x, y, w, h);
private int calculateTableWidth(JTable table)
JViewport viewPort = getScrollPane().getViewport();
int vpW = viewPort.getWidth();
int tableX = table.getLocation().x;
return getScrollPane().getWidth() - 80;
* @return Returns the toolbar.
public AbstractTableToolbar getToolbar()
return toolbar;
* @param selectedTable The selectedTable to set.
public void setSelectedTable(AbstractToolbarTable selectedTable)
this.selectedTable = selectedTable;
/* (non-Javadoc)
* @see javax.swing.JTree#fireValueChanged(javax.swing.event.TreeSelectionEvent)
@Override
protected void fireValueChanged(TreeSelectionEvent event)
if(getSelectionPath() != null && ((DefaultMutableTreeNode)getSelectionPath().
getLastPathComponent()).getUserObject()
instanceof ActionTreeNode && isEditable())
toolbar.setNodeToolsEnabled(true);
else
toolbar.setNodeToolsEnabled(false);
if(selectedTable != null)
this.selectedTable.clearSelection();
super.fireValueChanged(event);
/* (non-Javadoc)
* @see javax.swing.JTree#isPathEditable()
@Override
public boolean isPathEditable(TreePath path)
DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
if(node.getUserObject() instanceof ActionTreeNode)
return false;
return super.isPathEditable(path);
And finally here is ActionTreeTablePanel.java
public class ActionTreeTablePanel extends JPanel
* Width and height is set based on the BoxLayout used by
* the parent container. This might need to be modified
* if the parent container layout is changed.
private final int HEADER_WIDTH = 3000;
private final int HEADER_HEIGHT = 18;
private final int FIRST_COLUMN_WIDTH = 41;
private final int LAST_COLUMN_WIDTH = 60;
private ActionTreeTable tree;
private JTable defaultTable = null;
private Presenter     presenter;
//a variable to give the reference of the tableheader of the main scrollPane to the
//parametertablemodel to enable sorting
//the parametertablemodel implements the view to model technique and makes
//the necessary changes to the model and captures events for the tableheader
private JTableHeader header = null;
* Constructs an <code>ActionTreeTable</code> as a ready component
* to be used in an application.
* @param tree
public ActionTreeTablePanel(ActionTreeTable tree, Presenter presenter)
this.tree = tree;
this.presenter = presenter;
this.buildPanel();
* Called from the constructor to build the component.
private void buildPanel()
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
JScrollPane scrollPane = new JScrollPane(tree);
scrollPane.setVerticalScrollBarPolicy(
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
scrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
tree.setScrollPane(scrollPane);
this.add(getDefaultTableInScrollPane());
//header needs to be the same as the
tree.setHeader(header);
this.add(scrollPane);
if(tree.getToolbar() != null)
this.add(tree.getToolbar());
* Helper method to build the header for the <code>ActionTreeTable</code>
* @return
private JScrollPane getDefaultTableInScrollPane()
if(defaultTable == null)
defaultTable = new JTable();
final JTableHeader tableHeader = defaultTable.getTableHeader();
TableColumn column = new TableColumn();
defaultTable.setMaximumSize(new Dimension(HEADER_WIDTH, HEADER_HEIGHT));
defaultTable.setPreferredSize(new Dimension(HEADER_WIDTH, HEADER_HEIGHT));
defaultTable.setSize(new Dimension(HEADER_WIDTH, HEADER_HEIGHT));
// defaultTable.setAutoResizeMode(4);
column.setHeaderValue(" ");
column.setWidth(FIRST_COLUMN_WIDTH);
column.setMaxWidth(FIRST_COLUMN_WIDTH);
tableHeader.setAlignmentX(FIRST_COLUMN_WIDTH);
// tableHeader.set;
// tableHeader.getColumnModel().addColumn(column);
for(int i=0 ; i < ParameterTableModel.columnNamesImpl.length ; i++)
column = new TableColumn(i);
column.setHeaderValue(presenter.doGetProperty(ParameterTableModel.columnNamesImpl[i]));
tableHeader.getColumnModel().addColumn(column);
column = new TableColumn();
column.setHeaderValue(" ");
column.setWidth(LAST_COLUMN_WIDTH);
column.setMaxWidth(LAST_COLUMN_WIDTH);
// tableHeader.getColumnModel().addColumn(column);
tableHeader.setResizingAllowed(true);
tableHeader.setReorderingAllowed(false);
header = defaultTable.getTableHeader();
//doing the same changes as before and adjusted the size of the columns manually
//and the size of the columns do not change by listening to user events.
TableColumn typeColumn = defaultTable.getColumnModel().getColumn(
ParameterTableModel.TYPE_COL_ID ); // Empty col
typeColumn.setWidth(ParameterTable.WIDTH_TYPE_COLUMN );
typeColumn.setMaxWidth(ParameterTable.WIDTH_TYPE_COLUMN);
TableColumn requiredColumn = defaultTable.getColumnModel().getColumn(
ParameterTableModel.REQUIRED_COL_ID); // Empty col
requiredColumn.setWidth(ParameterTable.WIDTH_REQURIED_COLUMN + FIRST_COLUMN_WIDTH);
requiredColumn.setPreferredWidth(ParameterTable.WIDTH_REQURIED_COLUMN + FIRST_COLUMN_WIDTH);
requiredColumn.setMaxWidth(ParameterTable.WIDTH_REQURIED_COLUMN + FIRST_COLUMN_WIDTH);
TableColumn valueColumn = defaultTable.getColumnModel().getColumn(
ParameterTableModel.VALUE_COL_ID); // Empty col
valueColumn.setWidth(ParameterTable.WIDTH_VALUE_COLUMN + LAST_COLUMN_WIDTH);
valueColumn.setPreferredWidth(ParameterTable.WIDTH_VALUE_COLUMN + LAST_COLUMN_WIDTH);
valueColumn.setMaxWidth(ParameterTable.WIDTH_VALUE_COLUMN + LAST_COLUMN_WIDTH);
JScrollPane scrollPane = new JScrollPane(defaultTable);
scrollPane.setMaximumSize(new Dimension(HEADER_WIDTH, HEADER_HEIGHT));
scrollPane.setPreferredSize(new Dimension(HEADER_WIDTH, HEADER_HEIGHT));
scrollPane.setSize(new Dimension(HEADER_WIDTH, HEADER_HEIGHT));
return scrollPane;
Please guys help me out. My boss is angry upon me..