/* * Copyright (c) 1998, 2008, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package javax.swing.tree; import javax.swing.event.TreeModelEvent;import java.awt.Dimension;import java.awt.Rectangle;import java.util.Enumeration;import java.util.Hashtable;import java.util.NoSuchElementException;import java.util.Stack; /** * NOTE: This will become more open in a future release. * <p> * <strong>Warning:</strong> * Serialized objects of this class will not be compatible with * future Swing releases. The current serialization support is * appropriate for short term storage or RMI between applications running * the same version of Swing. As of 1.4, support for long term storage * of all JavaBeans<sup><font size="-2">TM</font></sup> * has been added to the <code>java.beans</code> package. * Please see {@link java.beans.XMLEncoder}. * * @author Scott Violet */ public class FixedHeightLayoutCache extends AbstractLayoutCache { /** Root node. */ private FHTreeStateNode root; /** Number of rows currently visible. */ private int rowCount; /** * Used in getting sizes for nodes to avoid creating a new Rectangle * every time a size is needed. */ private Rectangle boundsBuffer; /** * Maps from TreePath to a FHTreeStateNode. */ private Hashtable<TreePath, FHTreeStateNode> treePathMapping; /** * Used for getting path/row information. */ private SearchInfo info; private Stack<Stack<TreePath>> tempStacks; public FixedHeightLayoutCache() { super(); tempStacks = new Stack<Stack<TreePath>>(); boundsBuffer = new Rectangle(); treePathMapping = new Hashtable<TreePath, FHTreeStateNode>(); info = new SearchInfo(); setRowHeight(1); } /** * Sets the TreeModel that will provide the data. * * @param newModel the TreeModel that is to provide the data */ public void setModel(TreeModel newModel) { super.setModel(newModel); rebuild(false); } /** * Determines whether or not the root node from * the TreeModel is visible. * * @param rootVisible true if the root node of the tree is to be displayed * @see #rootVisible */ public void setRootVisible(boolean rootVisible) { if(isRootVisible() != rootVisible) { super.setRootVisible(rootVisible); if(root != null) { if(rootVisible) { rowCount++; root.adjustRowBy(1); } else { rowCount--; root.adjustRowBy(-1); } visibleNodesChanged(); } } } /** * Sets the height of each cell. If rowHeight is less than or equal to * 0 this will throw an IllegalArgumentException. * * @param rowHeight the height of each cell, in pixels */ public void setRowHeight(int rowHeight) { if(rowHeight <= 0) throw new IllegalArgumentException("FixedHeightLayoutCache only supports row heights greater than 0"); if(getRowHeight() != rowHeight) { super.setRowHeight(rowHeight); visibleNodesChanged(); } } /** * Returns the number of visible rows. */ public int getRowCount() { return rowCount; } /** * Does nothing, FixedHeightLayoutCache doesn't cache width, and that * is all that could change. */ public void invalidatePathBounds(TreePath path) { } /** * Informs the TreeState that it needs to recalculate all the sizes * it is referencing. */ public void invalidateSizes() { // Nothing to do here, rowHeight still same, which is all // this is interested in, visible region may have changed though. visibleNodesChanged(); } /** * Returns true if the value identified by row is currently expanded. */ public boolean isExpanded(TreePath path) { if(path != null) { FHTreeStateNode lastNode = getNodeForPath(path, true, false); return (lastNode != null && lastNode.isExpanded()); } return false; } /** * Returns a rectangle giving the bounds needed to draw path. * * @param path a TreePath specifying a node * @param placeIn a Rectangle object giving the available space * @return a Rectangle object specifying the space to be used */ public Rectangle getBounds(TreePath path, Rectangle placeIn) { if(path == null) return null; FHTreeStateNode node = getNodeForPath(path, true, false); if(node != null) return getBounds(node, -1, placeIn); // node hasn't been created yet. TreePath parentPath = path.getParentPath(); node = getNodeForPath(parentPath, true, false); if (node != null && node.isExpanded()) { int childIndex = treeModel.getIndexOfChild (parentPath.getLastPathComponent(), path.getLastPathComponent()); if(childIndex != -1) return getBounds(node, childIndex, placeIn); } return null; } /** * Returns the path for passed in row. If row is not visible * null is returned. */ public TreePath getPathForRow(int row) { if(row >= 0 && row < getRowCount()) { if(root.getPathForRow(row, getRowCount(), info)) { return info.getPath(); } } return null; } /** * Returns the row that the last item identified in path is visible * at. Will return -1 if any of the elements in path are not * currently visible. */ public int getRowForPath(TreePath path) { if(path == null || root == null) return -1; FHTreeStateNode node = getNodeForPath(path, true, false); if(node != null) return node.getRow(); TreePath parentPath = path.getParentPath(); node = getNodeForPath(parentPath, true, false); if(node != null && node.isExpanded()) { return node.getRowToModelIndex(treeModel.getIndexOfChild (parentPath.getLastPathComponent(), path.getLastPathComponent())); } return -1; } /** * Returns the path to the node that is closest to x,y. If * there is nothing currently visible this will return null, otherwise * it'll always return a valid path. If you need to test if the * returned object is exactly at x, y you should get the bounds for * the returned path and test x, y against that. */ public TreePath getPathClosestTo(int x, int y) { if(getRowCount() == 0) return null; int row = getRowContainingYLocation(y); return getPathForRow(row); } /** * Returns the number of visible children for row. */ public int getVisibleChildCount(TreePath path) { FHTreeStateNode node = getNodeForPath(path, true, false); if(node == null) return 0; return node.getTotalChildCount(); } /** * Returns an Enumerator that increments over the visible paths * starting at the passed in location. The ordering of the enumeration * is based on how the paths are displayed. */ public Enumeration<TreePath> getVisiblePathsFrom(TreePath path) { if(path == null) return null; FHTreeStateNode node = getNodeForPath(path, true, false); if(node != null) { return new VisibleFHTreeStateNodeEnumeration(node); } TreePath parentPath = path.getParentPath(); node = getNodeForPath(parentPath, true, false); if(node != null && node.isExpanded()) { return new VisibleFHTreeStateNodeEnumeration(node, treeModel.getIndexOfChild(parentPath.getLastPathComponent(), path.getLastPathComponent())); } return null; } /** * Marks the path <code>path</code> expanded state to * <code>isExpanded</code>. */ public void setExpandedState(TreePath path, boolean isExpanded) { if(isExpanded) ensurePathIsExpanded(path, true); else if(path != null) { TreePath parentPath = path.getParentPath(); // YECK! Make the parent expanded. if(parentPath != null) { FHTreeStateNode parentNode = getNodeForPath(parentPath, false, true); if(parentNode != null) parentNode.makeVisible(); } // And collapse the child. FHTreeStateNode childNode = getNodeForPath(path, true, false); if(childNode != null) childNode.collapse(true); } } /** * Returns true if the path is expanded, and visible. */ public boolean getExpandedState(TreePath path) { FHTreeStateNode node = getNodeForPath(path, true, false); return (node != null) ? (node.isVisible() && node.isExpanded()) : false; } // // TreeModelListener methods // /** * <p>Invoked after a node (or a set of siblings) has changed in some * way. The node(s) have not changed locations in the tree or * altered their children arrays, but other attributes have * changed and may affect presentation. Example: the name of a * file has changed, but it is in the same location in the file * system.</p> * * <p>e.path() returns the path the parent of the changed node(s).</p> * * <p>e.childIndices() returns the index(es) of the changed node(s).</p> */ public void treeNodesChanged(TreeModelEvent e) { if(e != null) { int changedIndexs[]; FHTreeStateNode changedParent = getNodeForPath (e.getTreePath(), false, false); int maxCounter; changedIndexs = e.getChildIndices(); /* Only need to update the children if the node has been expanded once. */ // PENDING(scott): make sure childIndexs is sorted! if (changedParent != null) { if (changedIndexs != null && (maxCounter = changedIndexs.length) > 0) { Object parentValue = changedParent.getUserObject(); for(int counter = 0; counter < maxCounter; counter++) { FHTreeStateNode child = changedParent. getChildAtModelIndex(changedIndexs[counter]); if(child != null) { child.setUserObject(treeModel.getChild(parentValue, changedIndexs[counter])); } } if(changedParent.isVisible() && changedParent.isExpanded()) visibleNodesChanged(); } // Null for root indicates it changed. else if (changedParent == root && changedParent.isVisible() && changedParent.isExpanded()) { visibleNodesChanged(); } } } } /** * <p>Invoked after nodes have been inserted into the tree.</p> * * <p>e.path() returns the parent of the new nodes * <p>e.childIndices() returns the indices of the new nodes in * ascending order. */ public void treeNodesInserted(TreeModelEvent e) { if(e != null) { int changedIndexs[]; FHTreeStateNode changedParent = getNodeForPath (e.getTreePath(), false, false); int maxCounter; changedIndexs = e.getChildIndices(); /* Only need to update the children if the node has been expanded once. */ // PENDING(scott): make sure childIndexs is sorted! if(changedParent != null && changedIndexs != null && (maxCounter = changedIndexs.length) > 0) { boolean isVisible = (changedParent.isVisible() && changedParent.isExpanded()); for(int counter = 0; counter < maxCounter; counter++) { changedParent.childInsertedAtModelIndex (changedIndexs[counter], isVisible); } if(isVisible && treeSelectionModel != null) treeSelectionModel.resetRowSelection(); if(changedParent.isVisible()) this.visibleNodesChanged(); } } } /** * <p>Invoked after nodes have been removed from the tree. Note that * if a subtree is removed from the tree, this method may only be * invoked once for the root of the removed subtree, not once for * each individual set of siblings removed.</p> * * <p>e.path() returns the former parent of the deleted nodes.</p> * * <p>e.childIndices() returns the indices the nodes had before they were deleted in ascending order.</p> */ public void treeNodesRemoved(TreeModelEvent e) { if(e != null) { int changedIndexs[]; int maxCounter; TreePath parentPath = e.getTreePath(); FHTreeStateNode changedParentNode = getNodeForPath (parentPath, false, false); changedIndexs = e.getChildIndices(); // PENDING(scott): make sure that changedIndexs are sorted in // ascending order. if(changedParentNode != null && changedIndexs != null && (maxCounter = changedIndexs.length) > 0) { Object[] children = e.getChildren(); boolean isVisible = (changedParentNode.isVisible() && changedParentNode.isExpanded()); for(int counter = maxCounter - 1; counter >= 0; counter--) { changedParentNode.removeChildAtModelIndex (changedIndexs[counter], isVisible); } if(isVisible) { if(treeSelectionModel != null) treeSelectionModel.resetRowSelection(); if (treeModel.getChildCount(changedParentNode. getUserObject()) == 0 && changedParentNode.isLeaf()) { // Node has become a leaf, collapse it. changedParentNode.collapse(false); } visibleNodesChanged(); } else if(changedParentNode.isVisible()) visibleNodesChanged(); } } } /** * <p>Invoked after the tree has drastically changed structure from a * given node down. If the path returned by e.getPath() is of length * one and the first element does not identify the current root node * the first element should become the new root of the tree.<p> * * <p>e.path() holds the path to the node.</p> * <p>e.childIndices() returns null.</p> */ public void treeStructureChanged(TreeModelEvent e) { if(e != null) { TreePath changedPath = e.getTreePath(); FHTreeStateNode changedNode = getNodeForPath (changedPath, false, false); // Check if root has changed, either to a null root, or // to an entirely new root. if (changedNode == root || (changedNode == null && ((changedPath == null && treeModel != null && treeModel.getRoot() == null) || (changedPath != null && changedPath.getPathCount() <= 1)))) { rebuild(true); } else if(changedNode != null) { boolean wasExpanded, wasVisible; FHTreeStateNode parent = (FHTreeStateNode) changedNode.getParent(); wasExpanded = changedNode.isExpanded(); wasVisible = changedNode.isVisible(); int index = parent.getIndex(changedNode); changedNode.collapse(false);Lines 1–500 of 1601. Load more
/* * Copyright (c) 1998, 2008, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package javax.swing.tree; import javax.swing.event.TreeModelEvent; import java.awt.Dimension; import java.awt.Rectangle; import java.util.Enumeration; import java.util.Hashtable; import java.util.NoSuchElementException; import java.util.Stack; /** * NOTE: This will become more open in a future release. * <p> * <strong>Warning:</strong> * Serialized objects of this class will not be compatible with * future Swing releases. The current serialization support is * appropriate for short term storage or RMI between applications running * the same version of Swing. As of 1.4, support for long term storage * of all JavaBeans<sup><font size="-2">TM</font></sup> * has been added to the <code>java.beans</code> package. * Please see {@link java.beans.XMLEncoder}. * * @author Scott Violet */ public class FixedHeightLayoutCache extends AbstractLayoutCache { /** Root node. */ private FHTreeStateNode root; /** Number of rows currently visible. */ private int rowCount; /** * Used in getting sizes for nodes to avoid creating a new Rectangle * every time a size is needed. */ private Rectangle boundsBuffer; /** * Maps from TreePath to a FHTreeStateNode. */ private Hashtable<TreePath, FHTreeStateNode> treePathMapping; /** * Used for getting path/row information. */ private SearchInfo info; private Stack<Stack<TreePath>> tempStacks; public FixedHeightLayoutCache() { super(); tempStacks = new Stack<Stack<TreePath>>(); boundsBuffer = new Rectangle(); treePathMapping = new Hashtable<TreePath, FHTreeStateNode>(); info = new SearchInfo(); setRowHeight(1); } /** * Sets the TreeModel that will provide the data. * * @param newModel the TreeModel that is to provide the data */ public void setModel(TreeModel newModel) { super.setModel(newModel); rebuild(false); } /** * Determines whether or not the root node from * the TreeModel is visible. * * @param rootVisible true if the root node of the tree is to be displayed * @see #rootVisible */ public void setRootVisible(boolean rootVisible) { if(isRootVisible() != rootVisible) { super.setRootVisible(rootVisible); if(root != null) { if(rootVisible) { rowCount++; root.adjustRowBy(1); } else { rowCount--; root.adjustRowBy(-1); } visibleNodesChanged(); } } } /** * Sets the height of each cell. If rowHeight is less than or equal to * 0 this will throw an IllegalArgumentException. * * @param rowHeight the height of each cell, in pixels */ public void setRowHeight(int rowHeight) { if(rowHeight <= 0) throw new IllegalArgumentException("FixedHeightLayoutCache only supports row heights greater than 0"); if(getRowHeight() != rowHeight) { super.setRowHeight(rowHeight); visibleNodesChanged(); } } /** * Returns the number of visible rows. */ public int getRowCount() { return rowCount; } /** * Does nothing, FixedHeightLayoutCache doesn't cache width, and that * is all that could change. */ public void invalidatePathBounds(TreePath path) { } /** * Informs the TreeState that it needs to recalculate all the sizes * it is referencing. */ public void invalidateSizes() { // Nothing to do here, rowHeight still same, which is all // this is interested in, visible region may have changed though. visibleNodesChanged(); } /** * Returns true if the value identified by row is currently expanded. */ public boolean isExpanded(TreePath path) { if(path != null) { FHTreeStateNode lastNode = getNodeForPath(path, true, false); return (lastNode != null && lastNode.isExpanded()); } return false; } /** * Returns a rectangle giving the bounds needed to draw path. * * @param path a TreePath specifying a node * @param placeIn a Rectangle object giving the available space * @return a Rectangle object specifying the space to be used */ public Rectangle getBounds(TreePath path, Rectangle placeIn) { if(path == null) return null; FHTreeStateNode node = getNodeForPath(path, true, false); if(node != null) return getBounds(node, -1, placeIn); // node hasn't been created yet. TreePath parentPath = path.getParentPath(); node = getNodeForPath(parentPath, true, false); if (node != null && node.isExpanded()) { int childIndex = treeModel.getIndexOfChild (parentPath.getLastPathComponent(), path.getLastPathComponent()); if(childIndex != -1) return getBounds(node, childIndex, placeIn); } return null; } /** * Returns the path for passed in row. If row is not visible * null is returned. */ public TreePath getPathForRow(int row) { if(row >= 0 && row < getRowCount()) { if(root.getPathForRow(row, getRowCount(), info)) { return info.getPath(); } } return null; } /** * Returns the row that the last item identified in path is visible * at. Will return -1 if any of the elements in path are not * currently visible. */ public int getRowForPath(TreePath path) { if(path == null || root == null) return -1; FHTreeStateNode node = getNodeForPath(path, true, false); if(node != null) return node.getRow(); TreePath parentPath = path.getParentPath(); node = getNodeForPath(parentPath, true, false); if(node != null && node.isExpanded()) { return node.getRowToModelIndex(treeModel.getIndexOfChild (parentPath.getLastPathComponent(), path.getLastPathComponent())); } return -1; } /** * Returns the path to the node that is closest to x,y. If * there is nothing currently visible this will return null, otherwise * it'll always return a valid path. If you need to test if the * returned object is exactly at x, y you should get the bounds for * the returned path and test x, y against that. */ public TreePath getPathClosestTo(int x, int y) { if(getRowCount() == 0) return null; int row = getRowContainingYLocation(y); return getPathForRow(row); } /** * Returns the number of visible children for row. */ public int getVisibleChildCount(TreePath path) { FHTreeStateNode node = getNodeForPath(path, true, false); if(node == null) return 0; return node.getTotalChildCount(); } /** * Returns an Enumerator that increments over the visible paths * starting at the passed in location. The ordering of the enumeration * is based on how the paths are displayed. */ public Enumeration<TreePath> getVisiblePathsFrom(TreePath path) { if(path == null) return null; FHTreeStateNode node = getNodeForPath(path, true, false); if(node != null) { return new VisibleFHTreeStateNodeEnumeration(node); } TreePath parentPath = path.getParentPath(); node = getNodeForPath(parentPath, true, false); if(node != null && node.isExpanded()) { return new VisibleFHTreeStateNodeEnumeration(node, treeModel.getIndexOfChild(parentPath.getLastPathComponent(), path.getLastPathComponent())); } return null; } /** * Marks the path <code>path</code> expanded state to * <code>isExpanded</code>. */ public void setExpandedState(TreePath path, boolean isExpanded) { if(isExpanded) ensurePathIsExpanded(path, true); else if(path != null) { TreePath parentPath = path.getParentPath(); // YECK! Make the parent expanded. if(parentPath != null) { FHTreeStateNode parentNode = getNodeForPath(parentPath, false, true); if(parentNode != null) parentNode.makeVisible(); } // And collapse the child. FHTreeStateNode childNode = getNodeForPath(path, true, false); if(childNode != null) childNode.collapse(true); } } /** * Returns true if the path is expanded, and visible. */ public boolean getExpandedState(TreePath path) { FHTreeStateNode node = getNodeForPath(path, true, false); return (node != null) ? (node.isVisible() && node.isExpanded()) : false; } // // TreeModelListener methods // /** * <p>Invoked after a node (or a set of siblings) has changed in some * way. The node(s) have not changed locations in the tree or * altered their children arrays, but other attributes have * changed and may affect presentation. Example: the name of a * file has changed, but it is in the same location in the file * system.</p> * * <p>e.path() returns the path the parent of the changed node(s).</p> * * <p>e.childIndices() returns the index(es) of the changed node(s).</p> */ public void treeNodesChanged(TreeModelEvent e) { if(e != null) { int changedIndexs[]; FHTreeStateNode changedParent = getNodeForPath (e.getTreePath(), false, false); int maxCounter; changedIndexs = e.getChildIndices(); /* Only need to update the children if the node has been expanded once. */ // PENDING(scott): make sure childIndexs is sorted! if (changedParent != null) { if (changedIndexs != null && (maxCounter = changedIndexs.length) > 0) { Object parentValue = changedParent.getUserObject(); for(int counter = 0; counter < maxCounter; counter++) { FHTreeStateNode child = changedParent. getChildAtModelIndex(changedIndexs[counter]); if(child != null) { child.setUserObject(treeModel.getChild(parentValue, changedIndexs[counter])); } } if(changedParent.isVisible() && changedParent.isExpanded()) visibleNodesChanged(); } // Null for root indicates it changed. else if (changedParent == root && changedParent.isVisible() && changedParent.isExpanded()) { visibleNodesChanged(); } } } } /** * <p>Invoked after nodes have been inserted into the tree.</p> * * <p>e.path() returns the parent of the new nodes * <p>e.childIndices() returns the indices of the new nodes in * ascending order. */ public void treeNodesInserted(TreeModelEvent e) { if(e != null) { int changedIndexs[]; FHTreeStateNode changedParent = getNodeForPath (e.getTreePath(), false, false); int maxCounter; changedIndexs = e.getChildIndices(); /* Only need to update the children if the node has been expanded once. */ // PENDING(scott): make sure childIndexs is sorted! if(changedParent != null && changedIndexs != null && (maxCounter = changedIndexs.length) > 0) { boolean isVisible = (changedParent.isVisible() && changedParent.isExpanded()); for(int counter = 0; counter < maxCounter; counter++) { changedParent.childInsertedAtModelIndex (changedIndexs[counter], isVisible); } if(isVisible && treeSelectionModel != null) treeSelectionModel.resetRowSelection(); if(changedParent.isVisible()) this.visibleNodesChanged(); } } } /** * <p>Invoked after nodes have been removed from the tree. Note that * if a subtree is removed from the tree, this method may only be * invoked once for the root of the removed subtree, not once for * each individual set of siblings removed.</p> * * <p>e.path() returns the former parent of the deleted nodes.</p> * * <p>e.childIndices() returns the indices the nodes had before they were deleted in ascending order.</p> */ public void treeNodesRemoved(TreeModelEvent e) { if(e != null) { int changedIndexs[]; int maxCounter; TreePath parentPath = e.getTreePath(); FHTreeStateNode changedParentNode = getNodeForPath (parentPath, false, false); changedIndexs = e.getChildIndices(); // PENDING(scott): make sure that changedIndexs are sorted in // ascending order. if(changedParentNode != null && changedIndexs != null && (maxCounter = changedIndexs.length) > 0) { Object[] children = e.getChildren(); boolean isVisible = (changedParentNode.isVisible() && changedParentNode.isExpanded()); for(int counter = maxCounter - 1; counter >= 0; counter--) { changedParentNode.removeChildAtModelIndex (changedIndexs[counter], isVisible); } if(isVisible) { if(treeSelectionModel != null) treeSelectionModel.resetRowSelection(); if (treeModel.getChildCount(changedParentNode. getUserObject()) == 0 && changedParentNode.isLeaf()) { // Node has become a leaf, collapse it. changedParentNode.collapse(false); } visibleNodesChanged(); } else if(changedParentNode.isVisible()) visibleNodesChanged(); } } } /** * <p>Invoked after the tree has drastically changed structure from a * given node down. If the path returned by e.getPath() is of length * one and the first element does not identify the current root node * the first element should become the new root of the tree.<p> * * <p>e.path() holds the path to the node.</p> * <p>e.childIndices() returns null.</p> */ public void treeStructureChanged(TreeModelEvent e) { if(e != null) { TreePath changedPath = e.getTreePath(); FHTreeStateNode changedNode = getNodeForPath (changedPath, false, false); // Check if root has changed, either to a null root, or // to an entirely new root. if (changedNode == root || (changedNode == null && ((changedPath == null && treeModel != null && treeModel.getRoot() == null) || (changedPath != null && changedPath.getPathCount() <= 1)))) { rebuild(true); } else if(changedNode != null) { boolean wasExpanded, wasVisible; FHTreeStateNode parent = (FHTreeStateNode) changedNode.getParent(); wasExpanded = changedNode.isExpanded(); wasVisible = changedNode.isVisible(); int index = parent.getIndex(changedNode); changedNode.collapse(false);