bookmarkpanel.java

JGraph扩展应用。自定义Renderer,自定义视图View实现自定义工作流控件

package flow.graph.test.test;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.Point;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.DragGestureListener;
import java.awt.dnd.DragGestureRecognizer;
import java.awt.dnd.DragSource;
import java.awt.dnd.DragSourceAdapter;
import java.awt.dnd.DragSourceDropEvent;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetAdapter;
import java.awt.dnd.DropTargetDropEvent;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

public class BookmarkPanel extends JPanel implements ActionListener {
    JPanel header = new JPanel();
    //JPanel inner = new JPanel();
    JScrollPane content = new JScrollPane();
    JTree tree;
    DefaultMutableTreeNode oldNode;
    DefaultTreeModel treeModel;
    TransferableTreeNode transferable;
    TreeDragSource ds;
    TreeDropTarget dt;

    public BookmarkPanel() {
        this.setSize(200,400);
        this.setBackground(Color.WHITE);
        this.setLayout(new BorderLayout());

        initHeader();
        initContent();
        
        treeModel = ((DefaultTreeModel)tree.getModel());
        ds = new TreeDragSource();
        dt = new TreeDropTarget();
        
        this.add(header,BorderLayout.NORTH);
        this.add(content,BorderLayout.CENTER);
    }

    public void initHeader(){
        header.setLayout(new BorderLayout());


        JPanel upPanel = new JPanel();
        upPanel.setBackground(new Color(90,70,145));
        JPanel downPanel = new JPanel();

        JLabel label = new JLabel("aaa");
        label.setForeground(Color.WHITE);
        label.setFont(new Font("MS UI Gothic",Font.BOLD,12));
        upPanel.add(label);

        JButton btn1 = new JButton("add");
        JButton btn2 = new JButton("delete");
        btn1.setActionCommand("add");
        btn2.setActionCommand("delete");
        btn1.addActionListener(this);
        btn2.addActionListener(this);
        downPanel.add(btn1);
        downPanel.add(btn2);
        header.add(upPanel,BorderLayout.NORTH);
        header.add(downPanel,BorderLayout.CENTER);
    }

    public void initContent(){
      // inner.setBackground(Color.WHITE);
      // inner.setLayout(new BorderLayout());
        initTree();
      // inner.add(tree);
        content.getViewport().add(tree);
    }

    public void initTree(){
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
        DefaultMutableTreeNode bookmarkNode = new DefaultMutableTreeNode("aaa");
        root.add(bookmarkNode);
        DefaultMutableTreeNode test = new DefaultMutableTreeNode("bbb");
        root.add(test);
        DefaultMutableTreeNode node = new DefaultMutableTreeNode("111");
        bookmarkNode.add(node);
        node = new DefaultMutableTreeNode("222");
        bookmarkNode.add(node);
        node = new DefaultMutableTreeNode("333");
        bookmarkNode.add(node);
        node = new DefaultMutableTreeNode("444");
        bookmarkNode.add(node);
        node = new DefaultMutableTreeNode("xxx");
        test.add(node);

        tree = new JTree(root);
        tree.setRootVisible(false);
        tree.setShowsRootHandles(true);
        tree.setEditable(true);
        tree.setDragEnabled(true);
        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        tree.putClientProperty("JTree.lineStyle", "Angled");
        DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
        renderer.setOpenIcon(null);
        renderer.setLeafIcon(null);
        renderer.setClosedIcon(null);
        renderer.setTextSelectionColor(Color.red);
        renderer.setBackgroundSelectionColor(tree.getBackground());
        renderer.setBorderSelectionColor(tree.getBackground());
        tree.setCellRenderer(renderer);

    }

    public static void main(String[] args) {
        try {
            javax.swing.UIManager
                    .setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
        } catch (Exception e) {
        }

        BookmarkPanel bookmarkpanel = new BookmarkPanel();
        JFrame jf = new JFrame();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.getContentPane().add(bookmarkpanel);
        jf.setLocation(750,100);
        jf.setSize(160,350);
        jf.show();
    }

    public void actionPerformed(ActionEvent e) {
        String strCmd = e.getActionCommand();
        if(strCmd.equals("add")){
            
        }else if(strCmd.equals("delete")){
            DefaultMutableTreeNode node = (DefaultMutableTreeNode)
                                          tree.getLastSelectedPathComponent();
            if(node == null || !node.isLeaf()){
                return;
            }
            treeModel.removeNodeFromParent(node);
        }
    }

    class TransferableTreeNode implements Transferable {
        public DataFlavor TREE_PATH_FLAVOR = new DataFlavor(TreePath.class,"Tree Path");
    
        DataFlavor flavors[] = {TREE_PATH_FLAVOR};
    
        TreePath path;
    
        public TransferableTreeNode(TreePath tp) {
            path = tp;
        }
    
        public synchronized DataFlavor[] getTransferDataFlavors() {
            return flavors;
        }
    
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            return (flavor.getRepresentationClass() == TreePath.class);
        }
    
        public synchronized Object getTransferData(DataFlavor flavor) throws
                UnsupportedFlavorException, IOException {
            if (isDataFlavorSupported(flavor)) {
                return (Object) path;
            } else {
                throw new UnsupportedFlavorException(flavor);
            }
        }
    }
    
    class TreeDragSource extends DragSourceAdapter implements DragGestureListener {
        DragSource source;
        DragGestureRecognizer recognizer;
        
        public TreeDragSource() {
            source = new DragSource();
            recognizer = source.createDefaultDragGestureRecognizer(tree, DnDConstants.ACTION_MOVE, this);
        }
        
        public void dragGestureRecognized(DragGestureEvent dge) {
            TreePath path = tree.getSelectionPath();
            if (path == null || path.getPathCount() <= 1) {
                return;
            }
            oldNode = (DefaultMutableTreeNode) path.getLastPathComponent();
    
            transferable = new TransferableTreeNode(path);
    
            source.startDrag(dge, DragSource.DefaultMoveNoDrop, transferable, this);
        }

        public void dragDropEnd(DragSourceDropEvent dsde) {
            if (dsde.getDropSuccess()) {
                treeModel.removeNodeFromParent(oldNode);
            }
        }
    }
    
    class TreeDropTarget extends DropTargetAdapter {
        DropTarget target;
        public TreeDropTarget(){
            target = new DropTarget(tree,this);
        }
        
        public void drop(DropTargetDropEvent dtde) {
            Point pt = dtde.getLocation();
            TreePath parentPath = tree.getClosestPathForLocation(pt.x, pt.y);
            
            DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode)parentPath
                                                .getLastPathComponent();
            System.out.println(parentNode);
            if(parentNode.isLeaf()) {
                dtde.rejectDrop();
                return;
            }

            try {
                Transferable tf = dtde.getTransferable();
                DataFlavor[]flavors = tf.getTransferDataFlavors();
                for(int i = 0; i < flavors.length; i++) {
                    if(tf.isDataFlavorSupported(flavors[i])) {
                        dtde.acceptDrop(DnDConstants.ACTION_MOVE);
                        TreePath path = (TreePath)tf.getTransferData(flavors[i]);
                        DefaultMutableTreeNode node = (DefaultMutableTreeNode)
                                path.getLastPathComponent();
                        treeModel.insertNodeInto(node, parentNode, 0);
                        dtde.dropComplete(true);
                        return;
                    }
                }
                dtde.rejectDrop();
            } catch (Exception e) {
                e.printStackTrace();
                dtde.rejectDrop();
            }        }    }}