Application: gvSIG desktop

/*

 * Created on 02-jun-2004

 *

 */

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.gui.toc;

/*

**  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. [ rkenworthy@hotmail.com ]

*/

import java.awt.Cursor;

import java.awt.Point;

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.DragSourceContext;

import java.awt.dnd.DragSourceDragEvent;

import java.awt.dnd.DragSourceDropEvent;

import java.awt.dnd.DragSourceEvent;

import java.awt.dnd.DragSourceListener;

import java.awt.dnd.DropTarget;

import java.awt.dnd.DropTargetDragEvent;

import java.awt.dnd.DropTargetDropEvent;

import java.awt.dnd.DropTargetEvent;

import java.awt.dnd.DropTargetListener;

import java.awt.event.InputEvent;

import java.io.IOException;

import java.util.ArrayList;

import javax.swing.JTree;

import javax.swing.SwingUtilities;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.MutableTreeNode;

import javax.swing.tree.TreeModel;

import javax.swing.tree.TreePath;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

public class DnDJTree extends JTree

                  implements TreeSelectionListener, 

                  DragGestureListener, DropTargetListener,

                  DragSourceListener {

  protected ArrayList m_Listeners = new ArrayList();

  /** Stores the parent Frame of the component */

  // private Frame Parent = null;

  /** Stores the selected node info */

  protected TreePath SelectedTreePath = null;

  protected DefaultMutableTreeNode 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(TreeModel treeModel) {

    super(treeModel);

    // 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);

  }

  /** Returns The selected node */

  public DefaultMutableTreeNode getSelectedNode() {

    return SelectedNode;

  }

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

  /** DragGestureListener interface method */

  public void dragGestureRecognized(DragGestureEvent e) {

    //Get the selected node

    DefaultMutableTreeNode dragNode = getSelectedNode();

    if (dragNode != null) {

      if (!(dragNode.getUserObject() instanceof Transferable)) return;

//    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.DefaultMoveDrop;

      //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( TocItemBranch.INFO_FLAVOR)) e.rejectDrop();

      //cast into appropriate data type

      TocItemBranch childInfo = 

        (TocItemBranch) tr.getTransferData( TocItemBranch.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() {

                 System.err.println(msg);

          }

        });

        return;

      }

      int oldPos,newPos;

          boolean isContainer=false;

          DefaultMutableTreeNode nodoTocado =

        (DefaultMutableTreeNode) destinationPath.getLastPathComponent(); 

          //        get old parent node

      DefaultMutableTreeNode oldParent = (DefaultMutableTreeNode) getSelectedNode().getParent();

          oldPos = oldParent.getIndex(getSelectedNode());

          // Para no tener en cuenta los nodos de s?mbolos:

      if (!(nodoTocado.getUserObject() instanceof TocItemBranch)){

                      nodoTocado = (DefaultMutableTreeNode) nodoTocado.getParent();

      }

      ///posActual = oldParent.getIndex(getSelectedNode());

      //Destino

          DefaultMutableTreeNode destParent=null;

          if (((TocItemBranch)nodoTocado.getUserObject()).getLayer() instanceof FLayers){

                 isContainer=true;

                  newPos=0;

                  destParent=nodoTocado;

      }else{//Si donde se deja la capa seleccionada no es un contenedor de capas.

                destParent= (DefaultMutableTreeNode)nodoTocado.getParent();

        newPos=destParent.getIndex(nodoTocado);

      }

      int action = e.getDropAction();

      boolean copyAction = (action == DnDConstants.ACTION_COPY);

      //make new child node

      DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(childInfo);

          if (getSelectedNode().getAllowsChildren()){

                  int childs=getSelectedNode().getChildCount();

                  for (int i=0;i<childs;i++){

                          newChild.add((MutableTreeNode)getSelectedNode().getChildAt(0));

                  }

          }

          try { 

        if (!copyAction) oldParent.remove(getSelectedNode());

        destParent.insert(newChild,newPos);

        // 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(destParent);

          if (oldParent.getUserObject() instanceof TocItemBranch){

          FLayers lpo=(FLayers)((TocItemBranch)oldParent.getUserObject()).getLayer();

          FLayers lpd=(FLayers)((TocItemBranch)destParent.getUserObject()).getLayer();

          if (destParent.equals(oldParent)){

                  callListeners(oldPos,newPos,lpd);

                  ///callListeners((FLayers)((TocItemBranch)oldParent.getUserObject()).getLayer(),(FLayers)((TocItemBranch)destParent.getUserObject()).getLayer(),((TocItemBranch)newChild.getUserObject()).getLayer(),newPos);

          }else{

                  callListeners(lpo,lpd,((TocItemBranch)newChild.getUserObject()).getLayer());

                ///  callListeners(newPos,newPos+1);

          }

          }

          ///callListeners(posActual, newPos);

      /* 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_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 = 

      (DefaultMutableTreeNode)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.

    DefaultMutableTreeNode node = (DefaultMutableTreeNode) 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;

  }

        /**

         * @param arg0

         * @return

         */

        public boolean addOrderListener(ITocOrderListener arg0) {

                return m_Listeners.add(arg0);

        }

        /**

         * @param arg0

         * @return

         */

        public boolean removeOrderListener(ITocOrderListener arg0) {

                return m_Listeners.remove(arg0);

        }

        private void callListeners(int oldPos, int newPos,FLayers lpd)

        {

                for (int i=0; i < m_Listeners.size(); i++)

                {

                        ITocOrderListener listener = (ITocOrderListener) m_Listeners.get(i);

                        listener.orderChanged(oldPos, newPos,lpd);

                }

        }

  private void callListeners(FLayers lpo,FLayers lpd,FLayer ls){

          for (int i=0; i < m_Listeners.size(); i++)

                {

                        ITocOrderListener listener = (ITocOrderListener) m_Listeners.get(i);

                        listener.parentChanged(lpo,lpd,ls);

                }

  }

} //end of DnDJTree