Application: gvSIG desktop

 */

package com.iver.cit.gvsig.project.documents.view.toc;

/*

**  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

**  "CHANGED" comments will show where the code has changed.

**

**  Credit for finding this shortcoming in my code goes Laurent Hubert.

import com.iver.cit.gvsig.project.documents.view.gui.View;

public class DnDJTree extends JTree

                  DragGestureListener, DropTargetListener,

                  DragSourceListener {

  protected ArrayList m_Listeners = new ArrayList();

  private static DnDJTree oDnDtocOrigin = null;

  private static DnDJTree oDnDtocDestination = null;

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

  //private ArrayList treeListeners=new ArrayList();

  //private ArrayList dropListeners=new ArrayList();

 // private TreeModel model1;

  @param root The root node of the tree

  @param parent Parent JFrame of the JTree */

  public DnDJTree(TreeModel treeModel) {

		/* ********************** CHANGED ********************** */

    dragSource = DragSource.getDefaultDragSource() ;

		/* ****************** END OF CHANGE ******************** */

      dragSource.createDefaultDragGestureRecognizer(

        this,                             //DragSource

        DnDConstants.ACTION_COPY_OR_MOVE, //specifies valid actions

    dgr.setSourceActions(dgr.getSourceActions() & ~InputEvent.BUTTON3_MASK);

    /* First argument:  Component to associate the target with

    */

    //DropTarget dropTarget = new DropTarget(this, this);

    setDropTarget();

	  removeTreeListener();

  }

  private void addDropListener(){

  }

  private void removeDropListener(){

	  dropTarget=null;

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

        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.

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

      oDnDtocOrigin = this;

      dragSource.startDrag(e, null, transferable, this);

  public void dragEnter(DragSourceDragEvent dsde) {

		/* ********************** CHANGED ********************** */

      // System.err.println("dragOver" + dsde.getDragSourceContext().getComponent());

		/* ****************** END OF CHANGE ******************** */

  }

  /** DragSourceListener interface method */

  public void dragExit(DragSourceEvent dsde) {

  }

  /** DropTargetListener interface method - What we do when drag is released */

  public void drop(DropTargetDropEvent e) {

    try {

      //flavor not supported, reject drop

      if (!tr.isDataFlavorSupported( TocItemBranch.INFO_FLAVOR)) e.rejectDrop();

      //cast into appropriate data type

      //get new parent node

      Point loc = e.getLocation();

      TreePath destinationPath = getPathForLocation(loc.x, loc.y);

                  public void run() {

                      System.err.println(msg);

                  }

              return;

          /* }

          else

	  //boolean isContainer=false;

	  DefaultMutableTreeNode nodoTocado =

	  //	get old parent node

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

      if (nodoTocado.getParent().equals(getSelectedNode())){

      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= (DefaultMutableTreeNode)nodoTocado.getParent();

        newPos=destParent.getIndex(nodoTocado);

      }

      int action = e.getDropAction();

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

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

		  }

	  }

        if (!copyAction){

        	oldParent.remove(getSelectedNode());

            destParent.insert(newChild,newPos);

      catch (java.lang.IllegalStateException ils) {

        e.rejectDrop();

      }

      e.getDropTargetContext().dropComplete(true);

      //expand nodes appropriately - this probably isnt the best way...

      // TODO: COMENTADO POR FJP

      /* com.iver.andami.ui.mdiManager.View[] views=PluginServices.getMDIManager().getAllViews();

	  for(int i=0;i<views.length;i++){

			  ((DefaultTreeModel)((View)views[i]).getTOC().getTree().getModel()).reload(oldParent);

		  }

	  } */

     // ((DefaultTreeModel)model1).reload(oldParent);

      DefaultTreeModel model = (DefaultTreeModel) getModel();

	  model.reload(destParent);

	  FLayers lpo=null;

	  FLayers lpd=null;

	  if (oldParent.getUserObject() instanceof TocItemBranch){

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

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

		  }else{

		  lpd=((TocItemBranch)nodoTocado.getUserObject()).getLayer().getParentLayer();

		  }

	  if (destParent.equals(oldParent)){

		  callListeners(oldPos,newPos,lpd);

	  }else{

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

	  }

	  }

    catch (IOException io) { e.rejectDrop(); }

    catch (UnsupportedFlavorException ufe) {e.rejectDrop();}

  } //end of method

public void dropRoot(TreeNode tn){

	int oldPos,newPos;

	DefaultMutableTreeNode nodoTocado =

		  //	get old parent node

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

		  if (oldParent!=null){

	      oldPos = oldParent.getIndex(getSelectedNode());

		  DefaultMutableTreeNode destParent=null;

		  newPos=0;

		  destParent=nodoTocado;

	      //make new child node

	      DefaultMutableTreeNode newChild = (DefaultMutableTreeNode)getSelectedNode().clone();

	      oldParent.remove(getSelectedNode());

	      destParent.insert(newChild,newPos);

	      com.iver.andami.ui.mdiManager.IWindow[] views=PluginServices.getMDIManager().getAllWindows();

		  for(int i=0;i<views.length;i++){

			  if (views[i] instanceof View){

		  model.reload(destParent);

		  FLayers lpo=null;

		  FLayers lpd=null;

		  lpo=(FLayers)((TocItemBranch)getSelectedNode().getUserObject()).getLayer().getParentLayer();

		  for(int i=0;i<views.length;i++){

			  if (views[i] instanceof View){

  }

  /** DropTaregetListener interface method */

  }

  /** DropTaregetListener interface method */

		/* ********************** CHANGED ********************** */

    //set cursor location. Needed in setCursor method

    Point cursorLocationBis = e.getLocation();

      getPathForLocation(cursorLocationBis.x, cursorLocationBis.y);

    // if destination path is okay accept drop...

    if (testSameComponent(e))

    {

        String msg = testDropTarget(destinationPath, SelectedTreePath);

            e.acceptDrag(DnDConstants.ACTION_MOVE) ;

            return;

        }

    }

    // ...otherwise reject drop

    // else {

        // System.err.println(e.getDropTargetContext().getComponent());

        // if (testSameComponent(e))

            e.rejectDrag() ;

            e.acceptDrag(DnDConstants.ACTION_MOVE); */

    // }

		/* ****************** END OF CHANGE ******************** */

  }

  /** Convenience method to test whether drop location is valid

  @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;

      return "Invalid drop location.";

    //Test 2.

      return "Destination cannot be same as source";

    //Test 3.

       return "Destination node cannot be a descendant.";

    //Test 4.

       return "Destination node cannot be a parent."; */

    return null;

	}

	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