/*

 * Copyright (c) 1998, 2014, 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.Rectangle;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.NoSuchElementException;

import java.util.Stack;

import sun.swing.SwingUtilities2;

/**

 * 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™

 * has been added to the <code>java.beans</code> package.

 * Please see {@link java.beans.XMLEncoder}.

 *

 * @author Scott Violet

 */

@SuppressWarnings("serial") // Same-version serialization only

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

                                  (SwingUtilities2.getTreePath(e, getModel()), 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

                                  (SwingUtilities2.getTreePath(e, getModel()), 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 = SwingUtilities2.getTreePath(e, getModel());

            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>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 = SwingUtilities2.getTreePath(e, getModel());

            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);

                parent.remove(index);

                if(wasVisible && wasExpanded) {

                    int row = changedNode.getRow();

                    parent.resetChildrenRowsFrom(row, index,

                                                 changedNode.getChildIndex());

                    changedNode = getNodeForPath(changedPath, false, true);

                    changedNode.expand();

                }

                if(treeSelectionModel != null && wasVisible && wasExpanded)

                    treeSelectionModel.resetRowSelection();

                if(wasVisible)

                    this.visibleNodesChanged();

            }

        }

    }

    //

    // Local methods

    //

    private void visibleNodesChanged() {

    }