treewrapper.java

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

      // Ask the listeners to handle this drop
      boolean doItOurselves = true;
      EventListener[] listeners =
        TreeWrapper.this.listeners.getListeners( StringTreeDnDListener.class );
      if( listeners != null && listeners.length > 0 )
      {
        try
        {
          StringTreeDnDEvent event = new StringTreeDnDEvent( droppedString, tree, dropNode );
          for( int i=0; i<listeners.length; i++ )
          {
            ((StringTreeDnDListener)listeners[i]).drop( event );
          }
        }
        catch( DnDVetoException exception )
        {
          doItOurselves = true;
        }
      }
      if ( doItOurselves )
      {
        DefaultMutableTreeNode newNode = new DefaultMutableTreeNode( droppedString );
        
        MutableTreeNode parent = (MutableTreeNode) dropNode.getParent();
        if ( dropNode.isLeaf() )
        {
          int index = parent.getIndex( dropNode );
          model.insertNodeInto( newNode , parent, index+1 );
        }
        else
        {
          model.insertNodeInto( newNode, dropNode, 0 ); //dropNode.getChildCount() );
        }
      }
      return true;
    }
    
    private boolean dropNodes( JTree aSourceTree, MutableTreeNode aSourceNode,
      JTree aTargetTree, MutableTreeNode aDropNode, boolean move )
    {
      // Get the mutable TreeModel
      DefaultTreeModel sourceModel = (DefaultTreeModel) aSourceTree.getModel();
      DefaultTreeModel targetModel = (DefaultTreeModel) aTargetTree.getModel();
      
      boolean doItOurselves = true;
      EventListener[] listeners =
        TreeWrapper.this.listeners.getListeners( TreeTreeDnDListener.class );
      if( listeners != null && listeners.length > 0 )
      {
        try
        {
          TreeTreeDnDEvent event = new TreeTreeDnDEvent( aSourceTree, aSourceNode,
            aTargetTree, aDropNode );
          for( int i=0; i<listeners.length; i++ )
          {
            ((TreeTreeDnDListener)listeners[i]).drop( event );
          }
        }
        catch( DnDVetoException exception )
        {
          doItOurselves = false;
        }
      }
      if ( doItOurselves )
      {
        MutableTreeNode sourceNodeCopy = aSourceNode;
        if ( move )
        {
          sourceModel.removeNodeFromParent( aSourceNode );
        }
        else
        {
          sourceNodeCopy = recursivelyCopyNodes( targetModel, aSourceNode );
        }
        // Attach the draggedNode into the new parent
        MutableTreeNode parent = (MutableTreeNode) aDropNode.getParent();
        if ( aDropNode.isLeaf() && parent != null )
        {
          int index = parent.getIndex( aDropNode );
          targetModel.insertNodeInto( sourceNodeCopy, parent, index+1 );
        }
        else
        {
          targetModel.insertNodeInto( sourceNodeCopy, aDropNode, 0 );//aDropNode.getChildCount() );
        }
      }
      return true;
    }
    
    private DefaultMutableTreeNode recursivelyCopyNodes( DefaultTreeModel aModel, TreeNode aNode )
    {
      DefaultMutableTreeNode copy = new DefaultMutableTreeNode( aNode.toString() );
      copy.setAllowsChildren( aNode.getAllowsChildren() );
      if( aNode.getChildCount() != 0 )
      {
        Enumeration children = aNode.children();
        while( children.hasMoreElements() )
        {
          TreeNode child = (TreeNode) children.nextElement();
          DefaultMutableTreeNode childCopy = recursivelyCopyNodes( aModel, child );
          aModel.insertNodeInto( childCopy, copy, copy.getChildCount() );
          childCopy.setParent( copy );
        }
      }
      return copy;
    }
    
    public void dragExit(DropTargetEvent dte)
    {
      dropNode = null;
      rendererProxy.setDropNode( null );
      tree.repaint();
    }
    
    public void dropActionChanged(DropTargetDragEvent dtde)
    {
    }
    
    
    private Transferable getTransferable( DropTargetDragEvent dtde )
    {
      try
      {
        DropTargetContext context = dtde.getDropTargetContext();
        if ( getTransferableMethod == null )
        {
          getTransferableMethod = context.getClass().getDeclaredMethod( "getTransferable", EMPTY_CLASS_ARRAY );
          getTransferableMethod.setAccessible( true );
        }
        return (Transferable) getTransferableMethod.invoke( context, EMPTY_OBJECT_ARRAY );
      }
      catch( Exception e )
      {
        e.printStackTrace( System.err );
        return null;
      }
    }
    
    /** This node to avoid too many invocations to dragOver */
    private TreeNode lastDragOverNode = null;
    
    public void dragOver(DropTargetDragEvent dtde)
    {
      if ( ! tree.isEnabled() )
      {
        dtde.rejectDrag();
        return;
      }
      
      // Is this a valid node for dropping?
      TreePath dropPath = tree.getClosestPathForLocation( dtde.getLocation().x,
        dtde.getLocation().y );
      
      TreeNode currentDropNode = (TreeNode) dropPath.getLastPathComponent();
      
      if ( dropPath == null || currentDropNode == null || currentDropNode.equals( lastDragOverNode ) )
      {
        return;
      }
      else
      {
        lastDragOverNode = currentDropNode;
      }
      
      Transferable transferable = getTransferable( dtde ); //dtde.getTransferable();
      
      boolean mayDropHere = false;
      
      try
      {
        // WARNING: getTransferable available only on JDK 1.5
        TransferableTreeNode transferredNode = (TransferableTreeNode) transferable.getTransferData( TransferableTreeNode.getJavaJVMLocalObjectFlavor() );
        JTree sourceTree = transferredNode.getSourceTree();
        MutableTreeNode sourceNode = transferredNode.getSourceNode();
        if ( mayDropHere( sourceTree, sourceNode, dropPath ) )
        {
          dropNode = (MutableTreeNode) dropPath.getLastPathComponent();
          if ( ! tree.isExpanded( dropPath ) )
            tree.expandPath( dropPath );
          mayDropHere = true;
        }
        else
        {
          dropNode = null;
        }
      }
      catch( UnsupportedFlavorException ufe )
      {
        // Oh, this is not a TransferableTreeNode, so maybe is a String, maybe?
        try
        {
          String sourceText = (String) transferable.getTransferData( DataFlavor.stringFlavor );
          if ( mayDropHere( sourceText, tree, dropPath ) )
          {
            dropNode = (MutableTreeNode) dropPath.getLastPathComponent();
            if ( ! tree.isExpanded( dropPath ) )
              tree.expandPath( dropPath );
            mayDropHere = true;
          }
          else
          {
            dropNode = null;
          }
        }
        catch( Exception e )
        {
          // Well, whatever, just discard
          dropNode = null;
        }
      }
      catch( Exception e )
      {
        // IOException: Oh, there's a problem with serialization. Maybe a classloader issue? Well, ummm... just discard this and say no
        // ClassCastException: Oh, user is transferring a JVM object but not a TransferableTreeNode, well, umm... just discard and say no
        dropNode = null;
      }
      rendererProxy.setDropAllowed( mayDropHere );
      rendererProxy.setDropNode( (TreeNode) dropPath.getLastPathComponent() );
      tree.repaint();
      if ( ! mayDropHere )
      {
        dtde.rejectDrag();
      }
      else
      {
        dtde.acceptDrag( dtde.getDropAction() );
      }
      tree.repaint();
    }
    
    public void dragEnter(DropTargetDragEvent dtde)
    {
      dragOver( dtde );
      // dtde.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE );
    }
  }
  
  /**
   * Invoked to decide if a given String can be dropped in the last path
   *  component of the given path.
   * @param aSourceString the String being dragged.
   * @param aPath the path to drop into.
   * @return true to allow the drop operation, false otherwise.
   */
  private boolean mayDropHere( String aSourceString, JTree aTargetTree, TreePath aPath )
  {
    return mayDropHere( aSourceString, aTargetTree, (TreeNode) aPath.getLastPathComponent() );
  }
  
  /**
   * Invoked to decide if a given String can be dropped in the last path
   *  component of the given path.
   * @param aSourceString the String being dragged.
   * @param aPath the path to drop into.
   * @return true to allow the drop operation, false otherwise.
   */
  private boolean mayDropHere( String aSourceString, JTree aTargetTree, TreeNode aNode )
  {
    EventListener[] listeners =
      this.listeners.getListeners( StringTreeDnDListener.class );
    if ( listeners != null && listeners.length > 0 )
    {
      try
      {
        StringTreeDnDEvent event =
          new StringTreeDnDEvent( aSourceString, aTargetTree, aNode );
        for( int i=0; i<listeners.length; i++ )
        {
          ((StringTreeDnDListener)listeners[i]).mayDrop( event );
        }
      }
      catch( DnDVetoException exception )
      {
        return false;
      }
    }
    return true;
  }
  
  /**
   * Invoked to decide if draggedNode can be dropped in the last path
   *  component of the given path.
   * @param aSourceTree the source tree.
   * @param aSourceNode the source node.
   * @param aPath the path to drop into.
   * @return true to allow the drop operation, false otherwise.
   */
  private boolean mayDropHere( JTree aSourceTree, MutableTreeNode aSourceNode, TreePath aPath )
  {
    if ( aPath == null )
      return false;
    return mayDropHere( aSourceTree, aSourceNode, (TreeNode) aPath.getLastPathComponent() );
  }
  
  /**
   * Invoked to decide if draggedNode can be dropped into aNode.
   * @param aSourceTree the source tree.
   * @param aSourceNode the source node.
   * @param aNode the node to drop into.
   * @return true to allow the drop operation, false to avoid it.
   */
  private boolean mayDropHere( JTree aSourceTree, MutableTreeNode aSourceNode, TreeNode aNode )
  {
    boolean mayDropHere =
      ( aNode != aSourceNode )
      &&
      ( aNode instanceof MutableTreeNode )
      &&
      (
      ( aNode.getParent() == null )
      ||
      ( aNode.getParent() instanceof MutableTreeNode )
      )
      &&
      ( tree.getModel() instanceof DefaultTreeModel )
      &&
      ! ( (tree == aSourceTree) && isAncestorOf( aSourceNode, aNode ) );
    
    if ( mayDropHere )
    {
      // Ask listeners
      EventListener [] listeners =
        this.listeners.getListeners( TreeTreeDnDListener.class );
      if ( listeners != null && listeners.length > 0 )
      {
        try
        {
          TreeTreeDnDEvent event = new TreeTreeDnDEvent( aSourceTree, aSourceNode, tree, aNode );
          for( int i=0; i<listeners.length; i++ )
          {
            ((TreeTreeDnDListener)listeners[i]).mayDrop( event );
          }
        }
        catch( DnDVetoException exception )
        {
          mayDropHere = false;
        }
      }
    }
    
    return mayDropHere;
  }
  
  /**
   * See if aPossibleParent is ancestor of aNode
   */
  private static boolean isAncestorOf( TreeNode aPossibleParent, TreeNode aNode )
  {
    if ( aPossibleParent == null || aNode.getParent() == null )
      return false;
    else if ( aNode.getParent() == aPossibleParent )
      return true;
    else return isAncestorOf( aPossibleParent, aNode.getParent() );
  }
  
  private void resetDragAndDrop()
  {
    dropNode = null;
    rendererProxy.setDraggedNode( null );
    rendererProxy.setDropAllowed( false );
    rendererProxy.setDropNode( null );
    tree.repaint();
  }
  
  /**
   * Returns the current CustomPopupHandler being used to handle
   *   popup gestures.
   * @return the current CustomPopupHandler or null if there's no popup menu
   *   handler.
   */
  public CustomPopupHandler getCustomPopupHandler()
  {
    return this.customPopupHandler;
  }
  
  /**
   * Setter for property customPopupHandler.
   * @param customPopupHandler New value of property customPopupHandler.
   */
  public void setCustomPopupHandler(CustomPopupHandler customPopupHandler)
  {
    this.customPopupHandler = customPopupHandler;
  }
  
  
}