/*
 * Copyright (c) 1998, 2000, Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 */

import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.tree.*;
import javax.swing.undo.*;
import java.awt.*;
import java.beans.*;
import java.util.*;

/**
 * Displays a tree showing all the elements in a text Document. Selecting
 * a node will result in reseting the selection of the JTextComponent.
 * This also becomes a CaretListener to know when the selection has changed
 * in the text to update the selected item in the tree.
 *
 * @author Scott Violet
 */
public class ElementTreePanel extends JPanel implements CaretListener, DocumentListener, PropertyChangeListener, TreeSelectionListener {
    /** Tree showing the documents element structure. */
    protected JTree             tree;
    /** Text component showing elemenst for. */
    protected JTextComponent    editor;
    /** Model for the tree. */
    protected ElementTreeModel  treeModel;
    /** Set to true when updatin the selection. */
    protected boolean           updatingSelection;

    public ElementTreePanel(JTextComponent editor) {
        this.editor = editor;

        Document document = editor.getDocument();

        // Create the tree.
        treeModel = new ElementTreeModel(document);
        tree = new JTree(treeModel) {
            public String convertValueToText(Object value, boolean selected,
                                             boolean expanded, boolean leaf,
                                             int row, boolean hasFocus) {
                // Should only happen for the root
                if(!(value instanceof Element))
                    return value.toString();

                Element        e = (Element)value;
                AttributeSet   as = e.getAttributes().copyAttributes();
                String         asString;

                if(as != null) {
                    StringBuffer       retBuffer = new StringBuffer("[");
                    Enumeration        names = as.getAttributeNames();

                    while(names.hasMoreElements()) {
                        Object        nextName = names.nextElement();

                        if(nextName != StyleConstants.ResolveAttribute) {
                            retBuffer.append(" ");
                            retBuffer.append(nextName);
                            retBuffer.append("=");
                            retBuffer.append(as.getAttribute(nextName));
                        }
                    }
                    retBuffer.append(" ]");
                    asString = retBuffer.toString();
                }
                else
                    asString = "[ ]";

                if(e.isLeaf())
                    return e.getName() + " [" + e.getStartOffset() +
                        ", " + e.getEndOffset() +"] Attributes: " + asString;
                return e.getName() + " [" + e.getStartOffset() +
                    ", " + e.getEndOffset() + "] Attributes: " +
                        asString;
            }
        };
        tree.addTreeSelectionListener(this);
        tree.setDragEnabled(true);
        // Don't show the root, it is fake.
        tree.setRootVisible(false);
        // Since the display value of every node after the insertion point
        // changes every time the text changes and we don't generate a change
        // event for all those nodes the display value can become off.
        // This can be seen as '...' instead of the complete string value.
        // This is a temporary workaround, increase the needed size by 15,
        // hoping that will be enough.
        tree.setCellRenderer(new DefaultTreeCellRenderer() {
            public Dimension getPreferredSize() {
                Dimension retValue = super.getPreferredSize();
                if(retValue != null)
                    retValue.width += 15;
                return retValue;
            }
        });
        // become a listener on the document to update the tree.
        document.addDocumentListener(this);

        // become a PropertyChangeListener to know when the Document has
        // changed.
        editor.addPropertyChangeListener(this);

        // Become a CaretListener
        editor.addCaretListener(this);

        // configure the panel and frame containing it.
        setLayout(new BorderLayout());
        add(new JScrollPane(tree), BorderLayout.CENTER);

        // Add a label above tree to describe what is being shown
        JLabel     label = new JLabel("Elements that make up the current document", SwingConstants.CENTER);

        label.setFont(new Font("Dialog", Font.BOLD, 14));
        add(label, BorderLayout.NORTH);

        setPreferredSize(new Dimension(400, 400));
    }

    /**
     * Resets the JTextComponent to <code>editor</code>. This will update
     * the tree accordingly.
     */
    public void setEditor(JTextComponent editor) {
        if (this.editor == editor) {
            return;
        }

        if (this.editor != null) {
            Document      oldDoc = this.editor.getDocument();

            oldDoc.removeDocumentListener(this);
            this.editor.removePropertyChangeListener(this);
            this.editor.removeCaretListener(this);
        }
        this.editor = editor;
        if (editor == null) {
            treeModel = null;
            tree.setModel(null);
        }
        else {
            Document   newDoc = editor.getDocument();

            newDoc.addDocumentListener(this);
            editor.addPropertyChangeListener(this);
            editor.addCaretListener(this);
            treeModel = new ElementTreeModel(newDoc);
            tree.setModel(treeModel);
        }
    }

    // PropertyChangeListener

    /**
     * Invoked when a property changes. We are only interested in when the
     * Document changes to reset the DocumentListener.
     */
    public void propertyChange(PropertyChangeEvent e) {
        if (e.getSource() == getEditor() &&
            e.getPropertyName().equals("document")) {
            JTextComponent      editor = getEditor();
            Document            oldDoc = (Document)e.getOldValue();
            Document            newDoc = (Document)e.getNewValue();

            // Reset the DocumentListener
            oldDoc.removeDocumentListener(this);
            newDoc.addDocumentListener(this);

            // Recreate the TreeModel.
            treeModel = new ElementTreeModel(newDoc);
            tree.setModel(treeModel);
        }
    }


    // DocumentListener

    /**
     * Gives notification that there was an insert into the document.  The
     * given range bounds the freshly inserted region.
     *
     * @param e the document event
     */
    public void insertUpdate(DocumentEvent e) {
        updateTree(e);
    }

    /**
     * Gives notification that a portion of the document has been
     * removed.  The range is given in terms of what the view last
     * saw (that is, before updating sticky positions).
     *
     * @param e the document event
     */
    public void removeUpdate(DocumentEvent e) {
        updateTree(e);
    }

    /**
     * Gives notification that an attribute or set of attributes changed.
     *
     * @param e the document event
     */
    public void changedUpdate(DocumentEvent e) {
        updateTree(e);
    }

    // CaretListener

    /**
     * Messaged when the selection in the editor has changed. Will update
     * the selection in the tree.
     */
    public void caretUpdate(CaretEvent e) {
        if(!updatingSelection) {
            JTextComponent     editor = getEditor();
            int                selBegin = Math.min(e.getDot(), e.getMark());
            int                end = Math.max(e.getDot(), e.getMark());
            Vector             paths = new Vector();
            TreeModel          model = getTreeModel();
            Object             root = model.getRoot();
            int                rootCount = model.getChildCount(root);

            // Build an array of all the paths to all the character elements
            // in the selection.
            for(int counter = 0; counter < rootCount; counter++) {
                int            start = selBegin;

                while(start <= end) {
                    TreePath    path = getPathForIndex(start, root,
                                       (Element)model.getChild(root, counter));
                    Element     charElement = (Element)path.
                                               getLastPathComponent();

                    paths.addElement(path);
                    if(start >= charElement.getEndOffset())
                        start++;
                    else
                        start = charElement.getEndOffset();
                }
            }

            // If a path was found, select it (them).
            int               numPaths = paths.size();

            if(numPaths > 0) {
                TreePath[]    pathArray = new TreePath[numPaths];

                paths.copyInto(pathArray);
                updatingSelection = true;
                try {
                    getTree().setSelectionPaths(pathArray);
                    getTree().scrollPathToVisible(pathArray[0]);
                }
                finally {
                    updatingSelection = false;
                }
            }
        }
    }

    // TreeSelectionListener

    /**
      * Called whenever the value of the selection changes.
      * @param e the event that characterizes the change.
      */
    public void valueChanged(TreeSelectionEvent e) {
        JTree       tree = getTree();

        if(!updatingSelection && tree.getSelectionCount() == 1) {
            TreePath      selPath = tree.getSelectionPath();
            Object        lastPathComponent = selPath.getLastPathComponent();

            if(!(lastPathComponent instanceof DefaultMutableTreeNode)) {
                Element       selElement = (Element)lastPathComponent;

                updatingSelection = true;
                try {
                    getEditor().select(selElement.getStartOffset(),
                                       selElement.getEndOffset());
                }
                finally {
                    updatingSelection = false;
                }
            }
        }
    }

    // Local methods

    /**
     * @return tree showing elements.
     */
    protected JTree getTree() {
        return tree;
    }

    /**
     * @return JTextComponent showing elements for.
     */
    protected JTextComponent getEditor() {
        return editor;
    }

    /**
     * @return TreeModel implementation used to represent the elements.
     */
    public DefaultTreeModel getTreeModel() {
        return treeModel;
    }

    /**
     * Updates the tree based on the event type. This will invoke either
     * updateTree with the root element, or handleChange.
     */
    protected void updateTree(DocumentEvent event) {
        updatingSelection = true;
        try {
            TreeModel        model = getTreeModel();
            Object           root = model.getRoot();

            for(int counter = model.getChildCount(root) - 1; counter >= 0;
                counter--) {
                updateTree(event, (Element)model.getChild(root, counter));
            }
        }
        finally {
            updatingSelection = false;
        }
    }

    /**
     * Creates TreeModelEvents based on the DocumentEvent and messages
     * the treemodel. This recursively invokes this method with children
     * elements.
     * @param event indicates what elements in the tree hierarchy have
     * changed.
     * @param element Current element to check for changes against.
     */
    protected void updateTree(DocumentEvent event, Element element) {
        DocumentEvent.ElementChange ec = event.getChange(element);

        if (ec != null) {
            Element[]       removed = ec.getChildrenRemoved();
            Element[]       added = ec.getChildrenAdded();
            int             startIndex = ec.getIndex();

            // Check for removed.
            if(removed != null && removed.length > 0) {
                int[]            indices = new int[removed.length];

                for(int counter = 0; counter < removed.length; counter++) {
                    indices[counter] = startIndex + counter;
                }
                getTreeModel().nodesWereRemoved((TreeNode)element, indices,
                                                removed);
            }
            // check for added
            if(added != null && added.length > 0) {
                int[]            indices = new int[added.length];

                for(int counter = 0; counter < added.length; counter++) {
                    indices[counter] = startIndex + counter;
                }
                getTreeModel().nodesWereInserted((TreeNode)element, indices);
            }
        }
        if(!element.isLeaf()) {
            int        startIndex = element.getElementIndex
                                       (event.getOffset());
            int        elementCount = element.getElementCount();
            int        endIndex = Math.min(elementCount - 1,
                                           element.getElementIndex
                                     (event.getOffset() + event.getLength()));

            if(startIndex > 0 && startIndex < elementCount &&
               element.getElement(startIndex).getStartOffset() ==
               event.getOffset()) {
                // Force checking the previous element.
                startIndex--;
            }
            if(startIndex != -1 && endIndex != -1) {
                for(int counter = startIndex; counter <= endIndex; counter++) {
                    updateTree(event, element.getElement(counter));
                }
            }
        }
        else {
            // Element is a leaf, assume it changed
            getTreeModel().nodeChanged((TreeNode)element);
        }
    }

    /**
     * Returns a TreePath to the element at <code>position</code>.
     */
    protected TreePath getPathForIndex(int position, Object root,
                                       Element rootElement) {
        TreePath         path = new TreePath(root);
        Element          child = rootElement.getElement
                                    (rootElement.getElementIndex(position));

        path = path.pathByAddingChild(rootElement);
        path = path.pathByAddingChild(child);
        while(!child.isLeaf()) {
            child = child.getElement(child.getElementIndex(position));
            path = path.pathByAddingChild(child);
        }
        return path;
    }


    /**
     * ElementTreeModel is an implementation of TreeModel to handle displaying
     * the Elements from a Document. AbstractDocument.AbstractElement is
     * the default implementation used by the swing text package to implement
     * Element, and it implements TreeNode. This makes it trivial to create
     * a DefaultTreeModel rooted at a particular Element from the Document.
     * Unfortunately each Document can have more than one root Element.
     * Implying that to display all the root elements as a child of another
     * root a fake node has be created. This class creates a fake node as
     * the root with the children being the root elements of the Document
     * (getRootElements).
     * <p>This subclasses DefaultTreeModel. The majority of the TreeModel
     * methods have been subclassed, primarily to special case the root.
     */
    public static class ElementTreeModel extends DefaultTreeModel {
        protected Element[]         rootElements;

        public ElementTreeModel(Document document) {
            super(new DefaultMutableTreeNode("root"), false);
            rootElements = document.getRootElements();
        }

        /**
         * Returns the child of <I>parent</I> at index <I>index</I> in
         * the parent's child array.  <I>parent</I> must be a node
         * previously obtained from this data source. This should
         * not return null if <i>index</i> is a valid index for
         * <i>parent</i> (that is <i>index</i> >= 0 && <i>index</i>
         * < getChildCount(<i>parent</i>)).
         *
         * @param   parent  a node in the tree, obtained from this data source
         * @return  the child of <I>parent</I> at index <I>index</I>
         */
        public Object getChild(Object parent, int index) {
            if(parent == root)
                return rootElements[index];
            return super.getChild(parent, index);
        }


        /**
         * Returns the number of children of <I>parent</I>.  Returns 0
         * if the node is a leaf or if it has no children.
         * <I>parent</I> must be a node previously obtained from this
         * data source.
         *
         * @param   parent  a node in the tree, obtained from this data source
         * @return  the number of children of the node <I>parent</I>
         */
        public int getChildCount(Object parent) {
            if(parent == root)
                return rootElements.length;
            return super.getChildCount(parent);
        }


        /**
         * Returns true if <I>node</I> is a leaf.  It is possible for
         * this method to return false even if <I>node</I> has no
         * children.  A directory in a filesystem, for example, may
         * contain no files; the node representing the directory is
         * not a leaf, but it also has no children.
         *
         * @param   node    a node in the tree, obtained from this data source
         * @return  true if <I>node</I> is a leaf
         */
        public boolean isLeaf(Object node) {
            if(node == root)
                return false;
            return super.isLeaf(node);
        }

        /**
         * Returns the index of child in parent.
         */
        public int getIndexOfChild(Object parent, Object child) {
            if(parent == root) {
                for(int counter = rootElements.length - 1; counter >= 0;
                    counter--) {
                    if(rootElements[counter] == child)
                        return counter;
                }
                return -1;
            }
            return super.getIndexOfChild(parent, child);
        }

        /**
         * Invoke this method after you've changed how node is to be
         * represented in the tree.
         */
        public void nodeChanged(TreeNode node) {
            if(listenerList != null && node != null) {
                TreeNode         parent = node.getParent();

                if(parent == null && node != root) {
                    parent = root;
                }
                if(parent != null) {
                    int        anIndex = getIndexOfChild(parent, node);

                    if(anIndex != -1) {
                        int[]        cIndexs = new int[1];

                        cIndexs[0] = anIndex;
                        nodesChanged(parent, cIndexs);
                    }
                }
            }
        }

        /**
         * Returns the path to a particluar node. This is recursive.
         */
        protected TreeNode[] getPathToRoot(TreeNode aNode, int depth) {
            TreeNode[]              retNodes;

            /* Check for null, in case someone passed in a null node, or
               they passed in an element that isn't rooted at root. */
            if(aNode == null) {
                if(depth == 0)
                    return null;
                else
                    retNodes = new TreeNode[depth];
            }
            else {
                depth++;
                if(aNode == root)
                    retNodes = new TreeNode[depth];
                else {
                    TreeNode parent = aNode.getParent();

                    if(parent == null)
                        parent = root;
                    retNodes = getPathToRoot(parent, depth);
                }
                retNodes[retNodes.length - depth] = aNode;
            }
            return retNodes;
        }
    }
}