531 lines · 18.3 KB · Java
RawDownload
/* * Copyright (c) 1998, 2004, 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; /** * <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 abstract class AbstractLayoutCache implements RowMapper {    /** Object responsible for getting the size of a node. */    protected NodeDimensions     nodeDimensions;     /** Model providing information. */    protected TreeModel          treeModel;     /** Selection model. */    protected TreeSelectionModel treeSelectionModel;     /**     * True if the root node is displayed, false if its children are     * the highest visible nodes.     */    protected boolean            rootVisible;     /**      * Height to use for each row.  If this is <= 0 the renderer will be      * used to determine the height for each row.      */    protected int                rowHeight;      /**     * Sets the renderer that is responsible for drawing nodes in the tree     * and which is threfore responsible for calculating the dimensions of     * individual nodes.     *     * @param nd a <code>NodeDimensions</code> object     */    public void setNodeDimensions(NodeDimensions nd) {        this.nodeDimensions = nd;    }     /**     * Returns the object that renders nodes in the tree, and which is     * responsible for calculating the dimensions of individual nodes.     *     * @return the <code>NodeDimensions</code> object     */    public NodeDimensions getNodeDimensions() {        return nodeDimensions;    }     /**     * Sets the <code>TreeModel</code> that will provide the data.     *     * @param newModel the <code>TreeModel</code> that is to     *          provide the data     */    public void setModel(TreeModel newModel) {        treeModel = newModel;    }     /**     * Returns the <code>TreeModel</code> that is providing the data.     *     * @return the <code>TreeModel</code> that is providing the data     */    public TreeModel getModel() {        return treeModel;    }     /**     * Determines whether or not the root node from     * the <code>TreeModel</code> is visible.     *     * @param rootVisible true if the root node of the tree is to be displayed     * @see #rootVisible     * @beaninfo     *        bound: true     *  description: Whether or not the root node     *               from the TreeModel is visible.     */    public void setRootVisible(boolean rootVisible) {        this.rootVisible = rootVisible;    }     /**     * Returns true if the root node of the tree is displayed.     *     * @return true if the root node of the tree is displayed     * @see #rootVisible     */    public boolean isRootVisible() {        return rootVisible;    }     /**     * Sets the height of each cell.  If the specified value     * is less than or equal to zero the current cell renderer is     * queried for each row's height.     *     * @param rowHeight the height of each cell, in pixels     * @beaninfo     *        bound: true     *  description: The height of each cell.     */    public void setRowHeight(int rowHeight) {        this.rowHeight = rowHeight;    }     /**     * Returns the height of each row.  If the returned value is less than     * or equal to 0 the height for each row is determined by the     * renderer.     */    public int getRowHeight() {        return rowHeight;    }     /**     * Sets the <code>TreeSelectionModel</code> used to manage the     * selection to new LSM.     *     * @param newLSM  the new <code>TreeSelectionModel</code>     */    public void setSelectionModel(TreeSelectionModel newLSM) {        if(treeSelectionModel != null)            treeSelectionModel.setRowMapper(null);        treeSelectionModel = newLSM;        if(treeSelectionModel != null)            treeSelectionModel.setRowMapper(this);    }     /**     * Returns the model used to maintain the selection.     *     * @return the <code>treeSelectionModel</code>     */    public TreeSelectionModel getSelectionModel() {        return treeSelectionModel;    }     /**     * Returns the preferred height.     *     * @return the preferred height     */    public int getPreferredHeight() {        // Get the height        int           rowCount = getRowCount();         if(rowCount > 0) {            Rectangle     bounds = getBounds(getPathForRow(rowCount - 1),                                             null);             if(bounds != null)                return bounds.y + bounds.height;        }        return 0;    }     /**     * Returns the preferred width for the passed in region.     * The region is defined by the path closest to     * <code>(bounds.x, bounds.y)</code> and     * ends at <code>bounds.height + bounds.y</code>.     * If <code>bounds</code> is <code>null</code>,     * the preferred width for all the nodes     * will be returned (and this may be a VERY expensive     * computation).     *     * @param bounds the region being queried     * @return the preferred width for the passed in region     */    public int getPreferredWidth(Rectangle bounds) {        int           rowCount = getRowCount();         if(rowCount > 0) {            // Get the width            TreePath      firstPath;            int           endY;             if(bounds == null) {                firstPath = getPathForRow(0);                endY = Integer.MAX_VALUE;            }            else {                firstPath = getPathClosestTo(bounds.x, bounds.y);                endY = bounds.height + bounds.y;            }             Enumeration   paths = getVisiblePathsFrom(firstPath);             if(paths != null && paths.hasMoreElements()) {                Rectangle   pBounds = getBounds((TreePath)paths.nextElement(),                                                null);                int         width;                 if(pBounds != null) {                    width = pBounds.x + pBounds.width;                    if (pBounds.y >= endY) {                        return width;                    }                }                else                    width = 0;                while (pBounds != null && paths.hasMoreElements()) {                    pBounds = getBounds((TreePath)paths.nextElement(),                                        pBounds);                    if (pBounds != null && pBounds.y < endY) {                        width = Math.max(width, pBounds.x + pBounds.width);                    }                    else {                        pBounds = null;                    }                }                return width;            }        }        return 0;    }     //    // Abstract methods that must be implemented to be concrete.    //     /**      * Returns true if the value identified by row is currently expanded.      */    public abstract boolean isExpanded(TreePath path);     /**     * Returns a rectangle giving the bounds needed to draw path.     *     * @param path     a <code>TreePath</code> specifying a node     * @param placeIn  a <code>Rectangle</code> object giving the     *          available space     * @return a <code>Rectangle</code> object specifying the space to be used     */    public abstract Rectangle getBounds(TreePath path, Rectangle placeIn);     /**      * Returns the path for passed in row.  If row is not visible      * <code>null</code> is returned.      *      * @param row  the row being queried      * @return the <code>TreePath</code> for the given row      */    public abstract TreePath getPathForRow(int row);     /**      * 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.      *      * @param path the <code>TreePath</code> being queried      * @return the row where the last item in path is visible or -1      *         if any elements in path aren't currently visible      */    public abstract int getRowForPath(TreePath path);     /**      * Returns the path to the node that is closest to x,y.  If      * there is nothing currently visible this will return <code>null</code>,      * 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.      *      * @param x the horizontal component of the desired location      * @param y the vertical component of the desired location      * @return the <code>TreePath</code> closest to the specified point      */    public abstract TreePath getPathClosestTo(int x, int y);     /**     * Returns an <code>Enumerator</code> 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.     * The first element of the returned enumeration will be path,     * unless it isn't visible,     * in which case <code>null</code> will be returned.     *     * @param path the starting location for the enumeration     * @return the <code>Enumerator</code> starting at the desired location     */    public abstract Enumeration<TreePath> getVisiblePathsFrom(TreePath path);     /**     * Returns the number of visible children for row.     *     * @param path  the path being queried     * @return the number of visible children for the specified path     */    public abstract int getVisibleChildCount(TreePath path);     /**     * Marks the path <code>path</code> expanded state to     * <code>isExpanded</code>.     *     * @param path  the path being expanded or collapsed     * @param isExpanded true if the path should be expanded, false otherwise     */    public abstract void setExpandedState(TreePath path, boolean isExpanded);     /**     * Returns true if the path is expanded, and visible.     *     * @param path  the path being queried     * @return true if the path is expanded and visible, false otherwise     */    public abstract boolean getExpandedState(TreePath path);     /**     * Number of rows being displayed.     *     * @return the number of rows being displayed     */    public abstract int getRowCount();     /**     * Informs the <code>TreeState</code> that it needs to recalculate     * all the sizes it is referencing.     */    public abstract void invalidateSizes();     /**     * Instructs the <code>LayoutCache</code> that the bounds for     * <code>path</code> are invalid, and need to be updated.     *     * @param path the path being updated     */    public abstract void invalidatePathBounds(TreePath path);     //    // TreeModelListener methods    // AbstractTreeState does not directly become a TreeModelListener on    // the model, it is up to some other object to forward these 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>     *     * @param e  the <code>TreeModelEvent</code>     */    public abstract void treeNodesChanged(TreeModelEvent e);     /**     * <p>Invoked after nodes have been inserted into the tree.</p>     *     * <p>e.path() returns the parent of the new nodes</p>     * <p>e.childIndices() returns the indices of the new nodes in     * ascending order.</p>     *     * @param e the <code>TreeModelEvent</code>     */    public abstract void treeNodesInserted(TreeModelEvent e);     /**     * <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>     *     * @param e the <code>TreeModelEvent</code>     */    public abstract void treeNodesRemoved(TreeModelEvent e);     /**     * <p>Invoked after the tree has drastically changed structure from a     * given node down.  If the path returned by <code>e.getPath()</code>     * 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>     *     * @param e the <code>TreeModelEvent</code>     */    public abstract void treeStructureChanged(TreeModelEvent e);     //    // RowMapper    //     /**     * Returns the rows that the <code>TreePath</code> instances in     * <code>path</code> are being displayed at.     * This method should return an array of the same length as that passed     * in, and if one of the <code>TreePaths</code>     * in <code>path</code> is not valid its entry in the array should     * be set to -1.     *     * @param paths the array of <code>TreePath</code>s being queried     * @return an array of the same length that is passed in containing     *          the rows that each corresponding where each     *          <code>TreePath</code> is displayed; if <code>paths</code>     *          is <code>null</code>, <code>null</code> is returned     */    public int[] getRowsForPaths(TreePath[] paths) {        if(paths == null)            return null;         int               numPaths = paths.length;        int[]             rows = new int[numPaths];         for(int counter = 0; counter < numPaths; counter++)            rows[counter] = getRowForPath(paths[counter]);        return rows;    }     //    // Local methods that subclassers may wish to use that are primarly    // convenience methods.    //     /**     * Returns, by reference in <code>placeIn</code>,     * the size needed to represent <code>value</code>.     * If <code>inPlace</code> is <code>null</code>, a newly created     * <code>Rectangle</code> should be returned, otherwise the value     * should be placed in <code>inPlace</code> and returned. This will     * return <code>null</code> if there is no renderer.     *     * @param value the <code>value</code> to be represented     * @param row  row being queried     * @param depth the depth of the row     * @param expanded true if row is expanded, false otherwise     * @param placeIn  a <code>Rectangle</code> containing the size needed     *          to represent <code>value</code>     * @return a <code>Rectangle</code> containing the node dimensions,     *          or <code>null</code> if node has no dimension     */    protected Rectangle getNodeDimensions(Object value, int row, int depth,                                          boolean expanded,                                          Rectangle placeIn) {        NodeDimensions            nd = getNodeDimensions();         if(nd != null) {            return nd.getNodeDimensions(value, row, depth, expanded, placeIn);        }        return null;    }     /**      * Returns true if the height of each row is a fixed size.      */    protected boolean isFixedRowHeight() {

Lines 1–500 of 531.

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