dnd: use common dnd manager in project view

2026-09-27 10:03:11 +07:00 · 2010-10-08 15:30:18 +04:00
parent 2895c13657
commit ca99ae848e
7 changed files with 213 additions and 212 deletions
@@ -24,6 +24,7 @@ import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
+import com.intellij.psi.impl.PsiCachedValue;
 import com.intellij.psi.impl.file.JavaDirectoryServiceImpl;
 import com.intellij.psi.impl.source.jsp.jspJava.JspClass;
 import com.intellij.refactoring.JavaRefactoringSettings;
@@ -307,6 +308,10 @@ public class MoveClassesOrPackagesHandlerBase extends MoveHandlerDelegate {
        return true;
      }
    }
+    if (target instanceof PsiDirectory && source instanceof PsiDirectory) {
+      final PsiPackage aPackage = JavaDirectoryServiceImpl.getInstance().getPackage((PsiDirectory)source);
+      if (aPackage != null && !MoveClassesOrPackagesImpl.checkNesting(target.getProject(), aPackage, target, false)) return true;
+    }
    return super.isMoveRedundant(source, target);
  }
 }
@@ -98,13 +98,13 @@ public class MoveClassesOrPackagesImpl {
          CommonRefactoringUtil.showErrorMessage(RefactoringBundle.message("move.title"), message, HelpID.getMoveHelpID(element), project);
          return null;
        }
-        if (!checkNesting(project, aPackage, targetElement)) return null;
+        if (!checkNesting(project, aPackage, targetElement, true)) return null;
        if (!checkMovePackage(project, aPackage)) return null;
        element = aPackage;
      }
      else if (element instanceof PsiPackage) {
        final PsiPackage psiPackage = (PsiPackage)element;
-        if (!checkNesting(project, psiPackage, targetElement)) return null;
+        if (!checkNesting(project, psiPackage, targetElement, true)) return null;
        if (!checkMovePackage(project, psiPackage)) return null;
      }
      else if (element instanceof PsiClass) {
@@ -166,16 +166,18 @@ public class MoveClassesOrPackagesImpl {
    return true;
  }

-  private static boolean checkNesting(final Project project, final PsiPackage srcPackage, final PsiElement targetElement) {
+  static boolean checkNesting(final Project project, final PsiPackage srcPackage, final PsiElement targetElement, boolean showError) {
    final PsiPackage targetPackage = targetElement instanceof PsiPackage
                                     ? (PsiPackage)targetElement
                                     : targetElement instanceof PsiDirectory ? JavaDirectoryService.getInstance()
                                       .getPackage((PsiDirectory)targetElement) : null;
    for (PsiPackage curPackage = targetPackage; curPackage != null; curPackage = curPackage.getParentPackage()) {
      if (curPackage.equals(srcPackage)) {
-        CommonRefactoringUtil.showErrorMessage(RefactoringBundle.message("move.title"),
-                                               RefactoringBundle.message("cannot.move.package.into.itself"),
-                                               HelpID.getMoveHelpID(srcPackage), project);
+        if (showError) {
+          CommonRefactoringUtil.showErrorMessage(RefactoringBundle.message("move.title"),
+                                                 RefactoringBundle.message("cannot.move.package.into.itself"),
+                                                 HelpID.getMoveHelpID(srcPackage), project);
+        }
        return false;
      }
    }
@@ -19,6 +19,7 @@ package com.intellij.ide.hierarchy;
 import com.intellij.ide.IdeBundle;
 import com.intellij.ide.OccurenceNavigator;
 import com.intellij.ide.OccurenceNavigatorSupport;
+import com.intellij.ide.PsiCopyPasteManager;
 import com.intellij.ide.dnd.DnDAction;
 import com.intellij.ide.dnd.DnDDragStartBean;
 import com.intellij.ide.dnd.DnDManager;
@@ -54,6 +55,7 @@ import javax.swing.tree.DefaultMutableTreeNode;
 import javax.swing.tree.DefaultTreeModel;
 import javax.swing.tree.TreeNode;
 import java.awt.*;
+import java.io.File;
 import java.text.MessageFormat;
 import java.util.*;
 import java.util.List;
@@ -216,6 +218,11 @@ public abstract class HierarchyBrowserBaseEx extends HierarchyBrowserBase implem
              public PsiElement[] getPsiElements() {
                return getSelectedElements();
              }
+
+              @Override
+              public List<File> asFileList() {
+                return PsiCopyPasteManager.asFileList(getPsiElements());
+              }
            });
          }

@@ -22,6 +22,7 @@ package com.intellij.ide.projectView.impl;
 import com.intellij.ide.DataManager;
 import com.intellij.ide.PsiCopyPasteManager;
 import com.intellij.ide.SelectInTarget;
+import com.intellij.ide.dnd.*;
 import com.intellij.ide.dnd.aware.DnDAwareTree;
 import com.intellij.ide.favoritesTreeView.FavoritesTreeViewPanel;
 import com.intellij.ide.projectView.BaseProjectTreeBuilder;
@@ -61,9 +62,13 @@ import javax.swing.*;
 import javax.swing.tree.DefaultMutableTreeNode;
 import javax.swing.tree.TreeNode;
 import javax.swing.tree.TreePath;
+import java.awt.*;
 import java.awt.datatransfer.DataFlavor;
 import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
 import java.awt.dnd.*;
+import java.io.File;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -84,6 +89,10 @@ public abstract class AbstractProjectViewPane implements DataProvider, Disposabl
  @NonNls private static final String ELEMENT_SUBPANE = "subPane";
  @NonNls private static final String ATTRIBUTE_SUBID = "subId";

+  private DnDTarget myDropTarget;
+  private DnDSource myDragSource;
+  private DnDManager myDndManager;
+
  protected AbstractProjectViewPane(Project project) {
    myProject = project;
  }
@@ -148,6 +157,17 @@ public abstract class AbstractProjectViewPane implements DataProvider, Disposabl
  }

  public void dispose() {
+    if (myDndManager != null) {
+      if (myDropTarget != null) {
+        myDndManager.unregisterTarget(myDropTarget, myTree);
+        myDropTarget = null;
+      }
+      if (myDragSource != null) {
+        myDndManager.unregisterSource(myDragSource, myTree);
+        myDragSource = null;
+      }
+      myDndManager = null;
+    }
    setTreeBuilder(null);
    myTree = null;
    myTreeStructure = null;
@@ -465,36 +485,50 @@ public abstract class AbstractProjectViewPane implements DataProvider, Disposabl

  // Drag'n'Drop stuff

-  public static final DataFlavor[] FLAVORS;
  private static final Logger LOG = Logger.getInstance("com.intellij.ide.projectView.ProjectViewImpl");
-  private final MyDragSourceListener myDragSourceListener = new MyDragSourceListener();

-  static {
-    DataFlavor[] flavors;
+
+
+  @Nullable
+  public static PsiElement[] getTransferedPsiElements(Transferable transferable) {
    try {
-      final Class aClass = MyTransferable.class;
-      flavors = new DataFlavor[]{new DataFlavor(
-                      DataFlavor.javaJVMLocalObjectMimeType + ";class=" + aClass.getName(),
-                      FavoritesTreeViewPanel.ABSTRACT_TREE_NODE_TRANSFERABLE,
-                      aClass.getClassLoader()
-                    )};
+      final Object transferData = transferable.getTransferData(DnDEventImpl.ourDataFlavor);
+      if (transferData instanceof TransferableWrapper) {
+        return ((TransferableWrapper)transferData).getPsiElements();
+      }
+      return null;
    }
-    catch (ClassNotFoundException e) {
-      LOG.error(e);  // should not happen
-      flavors = new DataFlavor[0];
+    catch (Exception e) {
+      return null;
+    }
+  }
+
+   @Nullable
+  public static TreeNode[] getTransferedTreeNodes(Transferable transferable) {
+    try {
+      final Object transferData = transferable.getTransferData(DnDEventImpl.ourDataFlavor);
+      if (transferData instanceof TransferableWrapper) {
+        return ((TransferableWrapper)transferData).getTreeNodes();
+      }
+      return null;
+    }
+    catch (Exception e) {
+      return null;
    }
-    FLAVORS = flavors;
  }

  protected void enableDnD() {
    if (!ApplicationManager.getApplication().isHeadlessEnvironment()) {
-      DragSource.getDefaultDragSource().createDefaultDragGestureRecognizer(myTree, DnDConstants.ACTION_COPY_OR_MOVE, new MyDragGestureListener());
-      new DropTarget(myTree, new MoveDropTargetListener(new PsiRetriever() {
-        @Nullable
-        public PsiElement getPsiElement(@Nullable final TreeNode node) {
+      myDropTarget = new ProjectViewDropTarget(myTree, new PsiRetriever(){
+        @Override
+        public PsiElement getPsiElement(@Nullable TreeNode node) {
          return getPSIElement(getElement(node));
        }
-      }, myTree, myProject, FLAVORS[0]));
+      }, myProject);
+      myDragSource = new MyDragSource();
+      myDndManager = DnDManager.getInstance();
+      myDndManager.registerSource(myDragSource, myTree);
+      myDndManager.registerTarget(myDropTarget, myTree);
    }
  }

@@ -507,99 +541,67 @@ public abstract class AbstractProjectViewPane implements DataProvider, Disposabl
    myTreeBuilder = treeBuilder;
  }

-  private static class MyTransferable implements Transferable {
-    private final Object myTransferable;
-
-    public MyTransferable(Object transferable) {
-      myTransferable = transferable;
-    }
-
-    public DataFlavor[] getTransferDataFlavors() {
-      DataFlavor[] flavors = new DataFlavor[2];
-      flavors [0] = FLAVORS [0];
-      flavors [1] = DataFlavor.javaFileListFlavor;
-      return flavors;
-    }
-
-    public boolean isDataFlavorSupported(DataFlavor flavor) {
-      DataFlavor[] flavors = getTransferDataFlavors();
-      return ArrayUtil.find(flavors, flavor) != -1;
-    }
-
-    public Object getTransferData(DataFlavor flavor) {
-      if (flavor == DataFlavor.javaFileListFlavor) {
-        TransferableWrapper wrapper = (TransferableWrapper) myTransferable;
-        return PsiCopyPasteManager.asFileList(wrapper.getPsiElements());
-      }
-      return myTransferable;
-    }
-  }
-
-  public interface TransferableWrapper {
+  public interface TransferableWrapper extends DnDEventImpl.FileFlavorProvider{
    TreeNode[] getTreeNodes();
    @Nullable PsiElement[] getPsiElements();
  }

-  private class MyDragGestureListener implements DragGestureListener {
-    public void dragGestureRecognized(DragGestureEvent dge) {
-      if ((dge.getDragAction() & DnDConstants.ACTION_COPY_OR_MOVE) == 0) return;
-      DataContext dataContext = DataManager.getInstance().getDataContext();
-      ProjectView projectView = ProjectViewImpl.DATA_KEY.getData(dataContext);
-      if (projectView == null) return;
-
-      final AbstractProjectViewPane currentPane = projectView.getCurrentProjectViewPane();
-      final TreeNode[] nodes = currentPane.getSelectedTreeNodes();
-      if (nodes != null) {
-        final Object[] elements = currentPane.getSelectedElements();
-        final PsiElement[] psiElements = currentPane.getSelectedPSIElements();
-        try {
-          Object transferableWrapper = new TransferableWrapper() {
-            public TreeNode[] getTreeNodes() {
-              return nodes;
-            }
-            public PsiElement[] getPsiElements() {
-              return psiElements;
-            }
-          };
-
-          //FavoritesManager.getInstance(myProject).getCurrentTreeViewPanel().setDraggableObject(draggableObject.getClass(), draggableObject.getValue());
-          if ((psiElements != null && psiElements.length > 0) || canDragElements(elements, dataContext, dge.getDragAction())) {
-            dge.startDrag(DragSource.DefaultMoveNoDrop, new MyTransferable(transferableWrapper), myDragSourceListener);
-          }
-        }
-        catch (InvalidDnDOperationException idoe) {
-          // ignore
-        }
-      }
+  private class MyDragSource implements DnDSource {
+    @Override
+    public boolean canStartDragging(DnDAction action, Point dragOrigin) {
+      if ((action.getActionId() & DnDConstants.ACTION_COPY_OR_MOVE) == 0) return false;
+      final Object[] elements = getSelectedElements();
+      final PsiElement[] psiElements = getSelectedPSIElements();
+      DataContext dataContext = DataManager.getInstance().getDataContext(myTree);
+      return (psiElements.length > 0) || canDragElements(elements, dataContext, action.getActionId());
    }

-    private boolean canDragElements(Object[] elements, DataContext dataContext, int dragAction) {
-      for (Object element : elements) {
-        if (element instanceof Module) {
-          return true;
+    @Override
+    public DnDDragStartBean startDragging(DnDAction action, Point dragOrigin) {
+      final PsiElement[] psiElements = getSelectedPSIElements();
+      final TreeNode[] nodes = getSelectedTreeNodes();
+      return new DnDDragStartBean(new TransferableWrapper(){
+
+        @Override
+        public List<File> asFileList() {
+          return PsiCopyPasteManager.asFileList(psiElements);
        }
-      }
-      if (dragAction == DnDConstants.ACTION_MOVE) {
-        return MoveHandler.canMove(dataContext);
-      }
-      return false;
+
+        @Override
+        public TreeNode[] getTreeNodes() {
+          return nodes;
+        }
+
+        @Override
+        public PsiElement[] getPsiElements() {
+          return psiElements;
+        }
+      });
+    }
+
+    @Override
+    public Pair<Image, Point> createDraggedImage(DnDAction action, Point dragOrigin) {
+      return null;
+    }
+
+    @Override
+    public void dragDropEnd() {
+    }
+
+    @Override
+    public void dropActionChanged(int gestureModifiers) {
    }
  }

-  private static class MyDragSourceListener implements DragSourceListener {
-
-    public void dragEnter(DragSourceDragEvent dsde) {
-      dsde.getDragSourceContext().setCursor(null);
+  private static boolean canDragElements(Object[] elements, DataContext dataContext, int dragAction) {
+    for (Object element : elements) {
+      if (element instanceof Module) {
+        return true;
+      }
    }
-
-    public void dragOver(DragSourceDragEvent dsde) {}
-
-    public void dropActionChanged(DragSourceDragEvent dsde) {
-      dsde.getDragSourceContext().setCursor(null);
+    if (dragAction == DnDConstants.ACTION_MOVE) {
+      return MoveHandler.canMove(dataContext);
    }
-
-    public void dragDropEnd(DragSourceDropEvent dsde) { }
-
-    public void dragExit(DragSourceEvent dse) { }
+    return false;
  }
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2010 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -13,10 +13,11 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-
 package com.intellij.ide.projectView.impl;

 import com.intellij.ide.DataManager;
+import com.intellij.ide.dnd.DnDEvent;
+import com.intellij.ide.dnd.DnDNativeTarget;
 import com.intellij.ide.projectView.impl.nodes.DropTargetNode;
 import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.actionSystem.LangDataKeys;
@@ -29,6 +30,7 @@ import com.intellij.refactoring.RefactoringActionHandlerFactory;
 import com.intellij.refactoring.actions.BaseRefactoringAction;
 import com.intellij.refactoring.copy.CopyHandler;
 import com.intellij.refactoring.move.MoveHandler;
+import com.intellij.ui.awt.RelativeRectangle;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -39,116 +41,90 @@ import javax.swing.tree.TreeNode;
 import javax.swing.tree.TreePath;
 import java.awt.*;
 import java.awt.datatransfer.DataFlavor;
-import java.awt.datatransfer.Transferable;
-import java.awt.datatransfer.UnsupportedFlavorException;
-import java.awt.dnd.*;
+import java.awt.dnd.DnDConstants;
 import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
+import java.util.*;
 import java.util.List;

 /**
- * @author vladk
- */
-class MoveDropTargetListener implements DropTargetListener {
-  final private DataFlavor dataFlavor;
-  final private Project myProject;
-  final private JTree myTree;
-  final private PsiRetriever myPsiRetriever;
+* User: anna
+* Date: 10/7/10
+*/
+class ProjectViewDropTarget implements DnDNativeTarget {

-  public interface ModifierSource {
-    int getModifiers();
-  }
+  private JTree myTree;
+  private final PsiRetriever myPsiRetriever;
+  private final Project myProject;

-  public MoveDropTargetListener(final PsiRetriever psiRetriever, final JTree tree, final Project project, final DataFlavor flavor) {
+  ProjectViewDropTarget(JTree tree, PsiRetriever psiRetriever, Project project) {
+    myTree = tree;
    myPsiRetriever = psiRetriever;
    myProject = project;
-    myTree = tree;
-    dataFlavor = flavor;
  }

-  public void dragEnter(DropTargetDragEvent dtde) {
-    final DropHandler dropHandler = getDropHandler(dtde.getDropAction());
-    final TreeNode[] sourceNodes = getSourceNodes(dtde.getTransferable());
-    if (sourceNodes != null && dropHandler.isValidSource(sourceNodes)) {
-      dtde.acceptDrag(dtde.getDropAction());
+  @Override
+  public boolean update(DnDEvent aEvent) {
+    final Object attached = aEvent.getAttachedObject();
+    aEvent.setDropPossible(false, "");
+    final int dropAction = aEvent.getAction().getActionId();
+    final DropHandler dropHandler = getDropHandler(dropAction);
+    final TreeNode[] sourceNodes = getSourceNodes(attached);
+    final Point point = aEvent.getPoint();
+    final TreeNode targetNode = getTargetNode(point);
+
+    if (targetNode == null || (dropAction & DnDConstants.ACTION_COPY_OR_MOVE) == 0 ) {
+      return false;
    }
-    else if (dtde.getTransferable().isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
-      dtde.acceptDrag(dtde.getDropAction());
+    else if (sourceNodes == null && !aEvent.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
+      return false;
    }
-    else {
-      dtde.rejectDrag();
+    else if (sourceNodes != null && !dropHandler.isValidSource(sourceNodes, targetNode)) {
+      return false;
    }
+    final Rectangle pathBounds = myTree.getPathBounds(myTree.getPathForLocation(point.x, point.y));
+    aEvent.setHighlighting(new RelativeRectangle(myTree, pathBounds), DnDEvent.DropTargetHighlightingType.RECTANGLE );
+    aEvent.setDropPossible(true, null);
+    return false;
  }

-  public void dragOver(DropTargetDragEvent dtde) {
-    final TreeNode[] sourceNodes = getSourceNodes(dtde.getTransferable());
-    final TreeNode targetNode = getTargetNode(dtde.getLocation());
-    final int dropAction = dtde.getDropAction();
-    if (sourceNodes != null && targetNode != null && canDrop(sourceNodes, targetNode, dropAction)) {
-      dtde.acceptDrag(dropAction);
-    }
-    else if (targetNode != null && dtde.getTransferable().isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
-      dtde.acceptDrag(dropAction);
-    }
-    else {
-      dtde.rejectDrag();
-    }
-  }
-
-  public void dropActionChanged(DropTargetDragEvent dtde) {
-  }
-
-  public void dragExit(DropTargetEvent dte) {
-  }
-
-  public void drop(DropTargetDropEvent dtde) {
-    final TreeNode[] sourceNodes = getSourceNodes(dtde.getTransferable());
-    final TreeNode targetNode = getTargetNode(dtde.getLocation());
-    final int dropAction = dtde.getDropAction();
-    if (targetNode == null || (dropAction & DnDConstants.ACTION_COPY_OR_MOVE) == 0) {
-      dtde.rejectDrop();
-    }
-    else if (sourceNodes == null) {
-      if (dtde.getTransferable().isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
-        dtde.acceptDrop(dropAction);
+  @Override
+  public void drop(DnDEvent aEvent) {
+    Object attached = aEvent.getAttachedObject();
+    final TreeNode[] sourceNodes = getSourceNodes(attached);
+    final TreeNode targetNode = getTargetNode(aEvent.getPoint());
+    assert targetNode != null;
+    final int dropAction = aEvent.getAction().getActionId();
+    if (sourceNodes == null) {
+      if (aEvent.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
        List<File> fileList;
        try {
-          fileList = (List<File>)dtde.getTransferable().getTransferData(DataFlavor.javaFileListFlavor);
+          fileList = (List<File>)aEvent.getTransferData(DataFlavor.javaFileListFlavor);
        }
        catch (Exception e) {
-          dtde.rejectDrop();
          return;
        }
        getDropHandler(dropAction).doDropFiles(fileList, targetNode);
      }
-      else {
-        dtde.rejectDrop();
-      }
    }
-    else if (!doDrop(sourceNodes, targetNode, dropAction, dtde)) {
-      dtde.rejectDrop();
+    else {
+      doDrop(sourceNodes, targetNode, dropAction);
    }
  }

+  @Override
+  public void cleanUpOnLeave() {
+  }
+
+  @Override
+  public void updateDraggedImage(Image image, Point dropPoint, Point imageOffset) {
+  }
+
  @Nullable
-  private TreeNode[] getSourceNodes(final Transferable transferable) {
-    if (!transferable.isDataFlavorSupported(dataFlavor)) {
-      return null;
-    }
-    try {
-      Object transferData = transferable.getTransferData(dataFlavor);
-      if (transferData instanceof AbstractProjectViewPSIPane.TransferableWrapper) {
-        return ((AbstractProjectViewPSIPane.TransferableWrapper)transferData).getTreeNodes();
-      }
-      return null;
-    }
-    catch (UnsupportedFlavorException e) {
-      return null;
-    }
-    catch (IOException e) {
-      return null;
+  private static TreeNode[] getSourceNodes(final Object transferData) {
+    if (transferData instanceof AbstractProjectViewPSIPane.TransferableWrapper) {
+      return ((AbstractProjectViewPSIPane.TransferableWrapper)transferData).getTreeNodes();
    }
+    return null;
  }

  @Nullable
@@ -157,22 +133,14 @@ class MoveDropTargetListener implements DropTargetListener {
    return path == null ? null : (TreeNode)path.getLastPathComponent();
  }

-  private boolean canDrop(@NotNull final TreeNode[] sourceNodes, @NotNull final TreeNode targetNode, final int dropAction) {
-    return doDrop(sourceNodes, targetNode, dropAction, null);
-  }
-
  private boolean doDrop(@NotNull final TreeNode[] sourceNodes,
                         @NotNull final TreeNode targetNode,
-                         final int dropAction,
-                         @Nullable final DropTargetDropEvent dtde) {
+                         final int dropAction) {
    TreeNode validTargetNode = getValidTargetNode(sourceNodes, targetNode, dropAction);
    if (validTargetNode != null) {
      final TreeNode[] filteredSourceNodes = removeRedundantSourceNodes(sourceNodes, validTargetNode, dropAction);
      if (filteredSourceNodes.length != 0) {
-        if (dtde != null) {
-          dtde.dropComplete(true);
-          getDropHandler(dropAction).doDrop(filteredSourceNodes, validTargetNode);
-        }
+        getDropHandler(dropAction).doDrop(filteredSourceNodes, validTargetNode);
        return true;
      }
    }
@@ -209,7 +177,7 @@ class MoveDropTargetListener implements DropTargetListener {
  }

  private interface DropHandler {
-    boolean isValidSource(@NotNull TreeNode[] sourceNodes);
+    boolean isValidSource(@NotNull TreeNode[] sourceNodes, TreeNode targetNode);

    boolean isValidTarget(@NotNull TreeNode[] sourceNodes, @NotNull TreeNode targetNode);

@@ -224,8 +192,8 @@ class MoveDropTargetListener implements DropTargetListener {

  public abstract class MoveCopyDropHandler implements DropHandler {

-    public boolean isValidSource(@NotNull final TreeNode[] sourceNodes) {
-      return canDrop(sourceNodes, null);
+    public boolean isValidSource(@NotNull final TreeNode[] sourceNodes, TreeNode targetNode) {
+      return canDrop(sourceNodes, targetNode);
    }

    public boolean isValidTarget(@NotNull final TreeNode[] sourceNodes, final @NotNull TreeNode targetNode) {
@@ -234,11 +202,11 @@ class MoveDropTargetListener implements DropTargetListener {

    protected abstract boolean canDrop(@NotNull TreeNode[] sourceNodes, @Nullable TreeNode targetNode);

-    @Nullable
    protected PsiElement getPsiElement(@Nullable final TreeNode treeNode) {
      return myPsiRetriever.getPsiElement(treeNode);
    }

+
    @NotNull protected PsiElement[] getPsiElements(@NotNull TreeNode[] nodes) {
      List<PsiElement> psiElements = new ArrayList<PsiElement>(nodes.length);
      for (TreeNode node : nodes) {
@@ -307,7 +275,7 @@ class MoveDropTargetListener implements DropTargetListener {
      final PsiElement targetElement = getPsiElement(targetNode);
      if (targetElement == null) return;
      final DataContext dataContext = DataManager.getInstance().getDataContext(myTree);
-      getActionHandler(dataContext).invoke(myProject, sourceElements, new DataContext() {
+      getActionHandler().invoke(myProject, sourceElements, new DataContext() {
        @Nullable
        public Object getData(@NonNls String dataId) {
          if (LangDataKeys.TARGET_PSI_ELEMENT.is(dataId)) {
@@ -320,7 +288,7 @@ class MoveDropTargetListener implements DropTargetListener {
      });
    }

-    private RefactoringActionHandler getActionHandler(final DataContext dataContext) {
+    private RefactoringActionHandler getActionHandler() {
      return RefactoringActionHandlerFactory.getInstance().createMoveHandler();
    }

@@ -21,6 +21,8 @@ import com.intellij.history.LocalHistory;
 import com.intellij.history.LocalHistoryAction;
 import com.intellij.ide.*;
 import com.intellij.ide.FileEditorProvider;
+import com.intellij.ide.dnd.DnDManager;
+import com.intellij.ide.dnd.DnDTarget;
 import com.intellij.ide.impl.ProjectViewSelectInTarget;
 import com.intellij.ide.projectView.HelpID;
 import com.intellij.ide.projectView.ProjectView;
@@ -17,20 +17,24 @@ package com.intellij.ide.dnd;

 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.UserDataHolderBase;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.ui.awt.RelativePoint;
 import com.intellij.ui.awt.RelativeRectangle;
+import com.intellij.util.ArrayUtil;

 import javax.swing.*;
 import java.awt.*;
 import java.awt.datatransfer.DataFlavor;
 import java.awt.datatransfer.Transferable;
 import java.awt.datatransfer.UnsupportedFlavorException;
+import java.io.File;
 import java.io.IOException;
+import java.util.*;

 public class DnDEventImpl extends UserDataHolderBase implements Transferable, DnDEvent {
  private static final Logger LOG = Logger.getInstance("com.intellij.ide.dnd.DnDEventImpl");

-  private static DataFlavor ourDataFlavor;
+  public static DataFlavor ourDataFlavor;
  private DnDTarget myDelegatedTarget;

  static {
@@ -93,17 +97,24 @@ public class DnDEventImpl extends UserDataHolderBase implements Transferable, Dn
  }

  public DataFlavor[] getTransferDataFlavors() {
-    return new DataFlavor[]{ourDataFlavor};
-  }
-
-  public boolean isDataFlavorSupported(DataFlavor flavor) {
-    return flavor.equals(ourDataFlavor);
+    return new DataFlavor[]{ourDataFlavor, DataFlavor.javaFileListFlavor};
  }

  public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+    if (flavor == DataFlavor.javaFileListFlavor) {
+      if (myAttachedObject instanceof FileFlavorProvider) {
+        return ((FileFlavorProvider)myAttachedObject).asFileList();
+      }
+    }
    return getAttachedObject();
  }

+
+  public boolean isDataFlavorSupported(DataFlavor flavor) {
+    DataFlavor[] flavors = getTransferDataFlavors();
+    return ArrayUtil.find(flavors, flavor) != -1;
+  }
+
  public boolean isDropPossible() {
    return myDropPossible;
  }
@@ -285,4 +296,8 @@ public class DnDEventImpl extends UserDataHolderBase implements Transferable, Dn
    myHandlerComponent = null;
    myManager = null;
  }
+
+  public interface FileFlavorProvider {
+    java.util.List<File> asFileList();
+  }
 }