dndjtree.java

鼠标拖拽的例子

/*
**  This is version II of DnDJTree. The first version allowed for what I 
**  thought was a JDK oversight. However, we can set the cursor appropriately,
**  relative to whether the current cursor location is a valid drop target.
**
**  If this is your first time reading the source code. Just ignore the above
**  comment and ignore the "CHANGED" comments below. Otherwise, the 
**  "CHANGED" comments will show where the code has changed.
**
**  Credit for finding this shortcoming in my code goes Laurent Hubert.
**  Thanks Laurent.
**
**  Rob. [ [e-mail] ]
*/


import javax.swing.*;
import javax.swing.event.*;
import javax.swing.plaf.metal.*;
import javax.swing.tree.*;

import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import java.awt.dnd.peer.*;
import java.awt.event.*;
import java.io.*;

public class DnDJTree extends JTree
                  implements TreeSelectionListener, 
                  DragGestureListener, DropTargetListener,
                  DragSourceListener {


  /** Stores the parent Frame of the component */
  private Frame Parent = null;

  /** Stores the selected node info */
  protected TreePath SelectedTreePath = null;
  protected PersonNode SelectedNode = null;

  /** Variables needed for DnD */
  private DragSource dragSource = null;
  private DragSourceContext dragSourceContext = null;


  /** Constructor 
  @param root The root node of the tree
  @param parent Parent JFrame of the JTree */
  public DnDJTree(PersonNode root, Frame parent) {
    super(root);
    Parent = parent;

    addTreeSelectionListener(this);

		/* ********************** CHANGED ********************** */
    dragSource = DragSource.getDefaultDragSource() ;
		/* ****************** END OF CHANGE ******************** */
    
    DragGestureRecognizer dgr = 
      dragSource.createDefaultDragGestureRecognizer(
        this,                             //DragSource
        DnDConstants.ACTION_COPY_OR_MOVE, //specifies valid actions
        this                              //DragGestureListener
      );


    /* Eliminates right mouse clicks as valid actions - useful especially
     * if you implement a JPopupMenu for the JTree
     */
    dgr.setSourceActions(dgr.getSourceActions() & ~InputEvent.BUTTON3_MASK);

    /* First argument:  Component to associate the target with
     * Second argument: DropTargetListener 
    */
    DropTarget dropTarget = new DropTarget(this, this);

    //unnecessary, but gives FileManager look
    putClientProperty("JTree.lineStyle", "Angled");
    MetalTreeUI ui = (MetalTreeUI) getUI();
  }

  /** Returns The selected node */
  public PersonNode getSelectedNode() {
    return SelectedNode;
  }

  ///////////////////////// Interface stuff ////////////////////


  /** DragGestureListener interface method */
  public void dragGestureRecognized(DragGestureEvent e) {
    //Get the selected node
    PersonNode dragNode = getSelectedNode();
    if (dragNode != null) {

      //Get the Transferable Object
      Transferable transferable = (Transferable) dragNode.getUserObject();
			/* ********************** CHANGED ********************** */

      //Select the appropriate cursor;
      Cursor cursor = DragSource.DefaultCopyNoDrop;
      int action = e.getDragAction();
      if (action == DnDConstants.ACTION_MOVE) 
        cursor = DragSource.DefaultMoveNoDrop;
        
        
      //In fact the cursor is set to NoDrop because once an action is rejected
      // by a dropTarget, the dragSourceListener are no more invoked.
      // Setting the cursor to no drop by default is so more logical, because 
      // when the drop is accepted by a component, then the cursor is changed by the
      // dropActionChanged of the default DragSource.
			/* ****************** END OF CHANGE ******************** */
   
      //begin the drag
      dragSource.startDrag(e, cursor, transferable, this);
    }
  }

  /** DragSourceListener interface method */
  public void dragDropEnd(DragSourceDropEvent dsde) {
  }

  /** DragSourceListener interface method */
  public void dragEnter(DragSourceDragEvent dsde) {
		/* ********************** CHANGED ********************** */
		/* ****************** END OF CHANGE ******************** */
  }

  /** DragSourceListener interface method */
  public void dragOver(DragSourceDragEvent dsde) {
		/* ********************** CHANGED ********************** */
		/* ****************** END OF CHANGE ******************** */
  }

  /** DragSourceListener interface method */
  public void dropActionChanged(DragSourceDragEvent dsde) {
  }

  /** DragSourceListener interface method */
  public void dragExit(DragSourceEvent dsde) {
  }

  
  
  
  /** DropTargetListener interface method - What we do when drag is released */
  public void drop(DropTargetDropEvent e) {
    try {
      Transferable tr = e.getTransferable();

      //flavor not supported, reject drop
      if (!tr.isDataFlavorSupported( PersonalInfo.INFO_FLAVOR)) e.rejectDrop();

      //cast into appropriate data type
      PersonalInfo childInfo = 
        (PersonalInfo) tr.getTransferData( PersonalInfo.INFO_FLAVOR );

      //get new parent node
      Point loc = e.getLocation();
      TreePath destinationPath = getPathForLocation(loc.x, loc.y);

      final String msg = testDropTarget(destinationPath, SelectedTreePath);
      if (msg != null) {
        e.rejectDrop();

        SwingUtilities.invokeLater(new Runnable() {
          public void run() {
            JOptionPane.showMessageDialog(
                 Parent, msg, "Error Dialog", JOptionPane.ERROR_MESSAGE
            );
          }
        });
        return;
      }


      PersonNode newParent =
        (PersonNode) destinationPath.getLastPathComponent();

      //get old parent node
      PersonNode oldParent = (PersonNode) getSelectedNode().getParent();

      int action = e.getDropAction();
      boolean copyAction = (action == DnDConstants.ACTION_COPY);

      //make new child node
      PersonNode newChild = new PersonNode(childInfo);

      try { 
        if (!copyAction) oldParent.remove(getSelectedNode());
        newParent.add(newChild);
          
        if (copyAction) e.acceptDrop (DnDConstants.ACTION_COPY);
        else e.acceptDrop (DnDConstants.ACTION_MOVE);
      }
      catch (java.lang.IllegalStateException ils) {
        e.rejectDrop();
      }

      e.getDropTargetContext().dropComplete(true);

      //expand nodes appropriately - this probably isnt the best way...
      DefaultTreeModel model = (DefaultTreeModel) getModel();
      model.reload(oldParent);
      model.reload(newParent);
      TreePath parentPath = new TreePath(newParent.getPath());
      expandPath(parentPath);
    }
    catch (IOException io) { e.rejectDrop(); }
    catch (UnsupportedFlavorException ufe) {e.rejectDrop();}
  } //end of method


  /** DropTaregetListener interface method */
  public void dragEnter(DropTargetDragEvent e) {
  }

  /** DropTaregetListener interface method */
  public void dragExit(DropTargetEvent e) { 
  }

  /** DropTaregetListener interface method */
  public void dragOver(DropTargetDragEvent e) {
		/* ********************** CHANGED ********************** */
    //set cursor location. Needed in setCursor method
    Point cursorLocationBis = e.getLocation();
        TreePath destinationPath = 
      getPathForLocation(cursorLocationBis.x, cursorLocationBis.y);


    // if destination path is okay accept drop...
    if (testDropTarget(destinationPath, SelectedTreePath) == null){
    	e.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE ) ;
    }
    // ...otherwise reject drop
    else {
    	e.rejectDrag() ;
    }
		/* ****************** END OF CHANGE ******************** */
  }

  /** DropTaregetListener interface method */
  public void dropActionChanged(DropTargetDragEvent e) {
  }


  /** TreeSelectionListener - sets selected node */
  public void valueChanged(TreeSelectionEvent evt) {
    SelectedTreePath = evt.getNewLeadSelectionPath();
    if (SelectedTreePath == null) {
      SelectedNode = null;
      return;
    }
    SelectedNode = 
      (PersonNode)SelectedTreePath.getLastPathComponent();
  }

  /** Convenience method to test whether drop location is valid
  @param destination The destination path 
  @param dropper The path for the node to be dropped
  @return null if no problems, otherwise an explanation
  */
  private String testDropTarget(TreePath destination, TreePath dropper) {
    //Typical Tests for dropping
 
    //Test 1.
    boolean destinationPathIsNull = destination == null;
    if (destinationPathIsNull) 
      return "Invalid drop location.";

    //Test 2.
    PersonNode node = (PersonNode) destination.getLastPathComponent();
    if ( !node.getAllowsChildren() )
      return "This node does not allow children";

    if (destination.equals(dropper))
      return "Destination cannot be same as source";

    //Test 3.
    if ( dropper.isDescendant(destination)) 
       return "Destination node cannot be a descendant.";

    //Test 4.
    if ( dropper.getParentPath().equals(destination)) 
       return "Destination node cannot be a parent.";

    return null;
  }

  //program entry point
  public static final void main(String args[]) {

    JFrame f = new JFrame();
    Container c = f.getContentPane();

    //Generate your family "tree"
    PersonalInfo pi = 
      new PersonalInfo("GrandMother", PersonalInfo.FEMALE);
    PersonNode grandmother = 
      new PersonNode(pi);

    pi = new PersonalInfo("Mother", PersonalInfo.FEMALE);
    PersonNode mother = new PersonNode(pi);

    pi = new PersonalInfo("Daughter", PersonalInfo.FEMALE);
    PersonNode daughter = new PersonNode(pi);

    pi = new PersonalInfo("Baby", PersonalInfo.FEMALE);
    PersonNode baby = new PersonNode(pi);

    pi = new PersonalInfo("Son", PersonalInfo.MALE);
    PersonNode son = new PersonNode(pi);

    grandmother.add(mother);
    mother.add(daughter);
    mother.add(son);
    daughter.add(baby);

    //add the tree to the frame and display the frame.
    c.add(new DnDJTree(grandmother, f));
    f.pack();
    f.show();
  }

} //end of DnDJTree