infopanel.java

主要为一个空间信息管理系统

package edu.whu.gui;

import java.util.Hashtable;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseAdapter;
import java.util.Enumeration;

import javax.swing.tree.TreePath;
import javax.swing.tree.TreeNode;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeModel;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeSelectionModel;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;

import javax.swing.plaf.ColorUIResource;
import javax.swing.*;
import java.awt.*;

/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author not attributable
 * @version 1.0
 */

public class InfoPanel
    extends JPanel
{
    JScrollPane scrollPanel = new JScrollPane();
    BorderLayout borderLayout = new BorderLayout();
    JTree infoTree = new JTree();
    //BorderLayout borderLayout1 = new BorderLayout();

    /**
     * Root check Node.
     */
    protected CheckNode rootNode;

    /**
     * Tree model.
     */
    protected DefaultTreeModel treeModel;

    /**
     * rNode value.
     */
    Hashtable rNode;

    /**
     * root size.
     */
    //int root;
    String superRootName = "默认";



    public InfoPanel()
    {
        try
        {
            jbInit();
            testAdd();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }

    void jbInit()
        throws Exception
    {
        //this.setLayout(borderLayout1);
        this.setLayout(borderLayout);
        scrollPanel.setBorder(null);
        this.add(scrollPanel, BorderLayout.CENTER);
        scrollPanel.getViewport().add(infoTree, null);

        rootNode = new CheckNode(superRootName);
        rootNode.setType(CheckNode.SUPER_ROOT);

        //rootNode = new DefaultMutableTreeNode("Root Node");
        treeModel = new DefaultTreeModel(rootNode);
        infoTree = new JTree(treeModel);

        //Action listener.
        NodeSelectionListener listener = new NodeSelectionListener(infoTree);
        //treeModel.addTreeModelListener(listener);
        infoTree.addMouseListener(listener);

        TreeCellRenderer renderer = new CheckRenderer();
        infoTree.setCellRenderer(renderer);

        infoTree.setEditable(false);

        infoTree.getSelectionModel().setSelectionMode(TreeSelectionModel.
            SINGLE_TREE_SELECTION);
        infoTree.setShowsRootHandles(true);

        JScrollPane scrollPane = new JScrollPane(infoTree);
        add(scrollPane);

        rNode = new Hashtable();
    }

    public void testAdd()
    {
        //addObject(superRootName, "Test");
        addObject("Test", "Test00");
        addObject("Test", "Test01");
        addObject("Test", "Test02");

        //addObject("Test1");
        addObject("Test1", "Test10");
        addObject("Test1", "Test11");
        addObject("Test1", "Test12");
        addObject("Test1", "Test13");

        //addObject("Test2");
        addObject("Test2", "Test20");
        addObject("Test2", "Test21");
        addObject("Test2", "Test22");
        addObject("Test2", "Test23");
        addObject("Test2", "Test24");

        //addObject("Test3");
        addObject("Test3", "Test30");
    }

    /**
     * Add the TreeModelListener.
     * @param listener TreeModelListener.
     */
    public void addTreeModelListener(TreeModelListener listener)
    {
        treeModel.addTreeModelListener(listener);
    }

    /** Remove all nodes except the root node. */
    public void clear()
    {
        rootNode.removeAllChildren();
        treeModel.reload();
    }

    /** Remove the currently selected node. */
    public void removeCurrentNode()
    {
        TreePath currentSelection = infoTree.getSelectionPath();
        if (currentSelection != null)
        {
            DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode)
                (currentSelection.getLastPathComponent());

            MutableTreeNode parent = (MutableTreeNode) (currentNode.getParent());
            if (parent != null)
            {
                treeModel.removeNodeFromParent(currentNode);
                return;
            }
        }
    }

    /**
     * Remove the child node from the root node.
     * @param root
     */
    public void removeChildNode(String root)
    {
        CheckNode parent = (CheckNode) rNode.get(root);
        if (parent != null)
        {
            int size = parent.getChildCount();
            for (int i = size - 1; i >= 0; i--)
            {
                treeModel.removeNodeFromParent( (MutableTreeNode) parent.
                                               getChildAt(i));
            }
        }
    }

    /** Add child to the currently selected node. */
    public DefaultMutableTreeNode addObject(Object child)
    {
        DefaultMutableTreeNode parentNode = null;
        TreePath parentPath = infoTree.getSelectionPath();

        if (parentPath == null)
        {
            parentNode = rootNode;
        }
        else
        {
            parentNode = (DefaultMutableTreeNode)
                (parentPath.getLastPathComponent());
        }

        return addObject(parentNode, child, true);
    }

    /**
     * Add object.
     * @param parent
     * @param child
     * @return
     */
    public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,
                                            Object child)
    {
        return addObject(parent, child, false);
    }

    /**
     * Add object.
     * @param parent Parent node name.
     * @param child Child node name.
     * @return Tree Node.
     */
    public DefaultMutableTreeNode addObject(String p, Object child)
    {
        CheckNode parent = (CheckNode) rNode.get(p);
        if (parent == null)
        {
            parent = new CheckNode(p);
            rootNode.add(parent);
            rNode.put(p, parent);
        }
        return addObject(parent, child, false);
    }

    /**
     * Add object.
     * @param parent Parent node name.
     * @param child Child node name.
     * @return Tree Node.
         public DefaultMutableTreeNode addObject(String p, Object child, int type, boolean visible)
         {
        CheckNode parent = (CheckNode)rNode.get(p);
        if(parent == null)
        {
            parent = new ThemeManagerNode(p);
            rootNode.add(parent);
            rNode.put(p, parent);
        }
        return addObject(parent, child, false, type, visible);
         }*/

    /**
     * Add a object to the tree.
     * @param parent
     * @param child
     * @param shouldBeVisible
     * @return
     */
    public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,
                                            Object child,
                                            boolean shouldBeVisible)
    {
        DefaultMutableTreeNode childNode = new CheckNode(child);

        if (parent == null)
        {
            parent = rootNode;
        }
        /*if(parent.isLeaf())
        {
            //parent
        }
         */
        //System.out.println(parent.toString());
        //System.out.println("Parent count = " + parent.getChildCount());
        treeModel.insertNodeInto(childNode, parent,
                                 parent.getChildCount());

        //Make sure the user can see the lovely new node.
        if (shouldBeVisible)
        {
            infoTree.scrollPathToVisible(new TreePath(childNode.getPath()));
        }
        return childNode;
    }

    /**
     * Add a object to the tree.
     * @param parent
     * @param child
     * @param shouldBeVisible
     * @return
     */
    public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,
                                            Object child,
                                            boolean shouldBeVisible, int type,
                                            boolean visible)
    {
        if (parent == null)
        {
            parent = rootNode;

        }

        CheckNode childNode = new CheckNode(child);
        childNode.setThemeType(type);
        childNode.setSelected(visible);
        treeModel.insertNodeInto(childNode, parent, parent.getChildCount());

        //Make sure the user can see the lovely new node.
        if (shouldBeVisible)
        {
            infoTree.scrollPathToVisible(new TreePath(childNode.getPath()));
        }
        infoTree.expandPath(new TreePath(parent.getPath()));
        return childNode;
    }

    /**
     * Remove all ChildTree.
     * @param root
     */
    public void removeChildTree(String root)
    {
        CheckNode rootNode = (CheckNode) rNode.get(root);
        if (rootNode != null)
        {
            rootNode.removeAllChildren();
        }
    }

    class NodeSelectionListener
        extends MouseAdapter
        implements TreeModelListener
    {
        /**
         * Tree listener.
         */
        JTree tree;

        /**
         * Node Selection listener.
         * @param tree
         */
        NodeSelectionListener(JTree tree)
        {
            this.tree = tree;
        }

        /*
         * If the event lists children, then the changed
         * node is the child of the node we've already
         * gotten.  Otherwise, the changed node and the
         * specified node are the same.
         */
        public void treeNodesChanged(TreeModelEvent e)
        {
            DefaultMutableTreeNode node;
            node = (DefaultMutableTreeNode)
                (e.getTreePath().getLastPathComponent());

            try
            {
                int index = e.getChildIndices()[0];
                node = (DefaultMutableTreeNode) (node.getChildAt(index));
            }
            catch (NullPointerException exc)
            {}

            System.out.println("CheckTree --> node select changed");
            System.out.println("The user has finished editing the node.");
            System.out.println("New value: " + node.getUserObject());
        }

        public void treeNodesInserted(TreeModelEvent e)
        {
        }

        public void treeNodesRemoved(TreeModelEvent e)
        {
        }

        public void treeStructureChanged(TreeModelEvent e)
        {
        }

        /**
         * Mouse clicked event.
         * @param e
         */
        public void mouseClicked(MouseEvent e)
        {
            int x = e.getX();
            int y = e.getY();
            int row = tree.getRowForLocation(x, y);
            TreePath path = tree.getPathForRow(row);
            //TreePath  path = tree.getSelectionPath();

            if (path == null)
            {
                return;
            }

            CheckNode node = (CheckNode) path.getLastPathComponent();
            boolean isSelected = ! (node.isSelected());
            node.setSelected(isSelected);

            if (node.getSelectionMode() == CheckNode.DIG_IN_SELECTION)
            {
                System.out.println("CheckTree -- > Node changed event");
                if (isSelected)
                {
                    tree.expandPath(path);
                }
                else
                {
                    tree.collapsePath(path);
                }
            }

            ( (DefaultTreeModel) tree.getModel()).nodeChanged(node);

        }
    }

}

class CheckNode
    extends DefaultMutableTreeNode
{
    /**
     * Selection mode.
     */
    public final static int SINGLE_SELECTION = 0;