1601 lines · 56.4 KB · Java
RawDownload
/* * 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.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t