| /* |
| * Copyright 2000-2014 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. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * 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.dnd.FileCopyPasteUtil; |
| import com.intellij.ide.dnd.TransferableWrapper; |
| import com.intellij.ide.projectView.impl.nodes.DropTargetNode; |
| import com.intellij.openapi.actionSystem.DataContext; |
| import com.intellij.openapi.actionSystem.LangDataKeys; |
| import com.intellij.openapi.module.Module; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.util.SystemInfo; |
| import com.intellij.openapi.vfs.LocalFileSystem; |
| import com.intellij.openapi.vfs.VirtualFile; |
| import com.intellij.psi.*; |
| import com.intellij.psi.util.PsiUtilCore; |
| import com.intellij.refactoring.RefactoringActionHandler; |
| 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 com.intellij.util.ArrayUtilRt; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import javax.swing.*; |
| import javax.swing.tree.DefaultMutableTreeNode; |
| import javax.swing.tree.TreeNode; |
| import javax.swing.tree.TreePath; |
| import java.awt.*; |
| import java.awt.dnd.DnDConstants; |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * @author Anna |
| * @author Konstantin Bulenkov |
| */ |
| class ProjectViewDropTarget implements DnDNativeTarget { |
| |
| private final JTree myTree; |
| private final Retriever myRetriever; |
| private final Project myProject; |
| |
| ProjectViewDropTarget(JTree tree, Retriever retriever, Project project) { |
| myTree = tree; |
| myRetriever = retriever; |
| myProject = project; |
| } |
| |
| @Override |
| public boolean update(DnDEvent event) { |
| event.setDropPossible(false, ""); |
| |
| final Object attached = event.getAttachedObject(); |
| final int dropAction = event.getAction().getActionId(); |
| final DropHandler dropHandler = getDropHandler(dropAction); |
| final TreeNode[] sourceNodes = getSourceNodes(attached); |
| final Point point = event.getPoint(); |
| final TreeNode targetNode = getTargetNode(point); |
| |
| if (targetNode == null || (dropAction & DnDConstants.ACTION_COPY_OR_MOVE) == 0) { |
| return false; |
| } |
| else if (sourceNodes == null && !FileCopyPasteUtil.isFileListFlavorAvailable(event)) { |
| return false; |
| } |
| else if (sourceNodes != null && ArrayUtilRt.find(sourceNodes, targetNode) != -1) { |
| return false; |
| } |
| else if (sourceNodes != null && !dropHandler.isValidSource(sourceNodes, targetNode)) { |
| return false; |
| } |
| |
| if (sourceNodes != null) { |
| boolean redundant = true; |
| for (TreeNode sourceNode : sourceNodes) { |
| if (!dropHandler.isDropRedundant(sourceNode, targetNode)) { |
| redundant = false; |
| break; |
| } |
| } |
| if (redundant) return false; |
| } |
| else { |
| // it seems like it's not possible to obtain dragged items _before_ accepting _drop_ on Macs, so just skip this check |
| if (!SystemInfo.isMac) { |
| final PsiFileSystemItem[] psiFiles = getPsiFiles(FileCopyPasteUtil.getFileListFromAttachedObject(attached)); |
| if (psiFiles == null || psiFiles.length == 0) return false; |
| if (!MoveHandler.isValidTarget(getPsiElement(targetNode), psiFiles)) return false; |
| } |
| } |
| |
| final Rectangle pathBounds = myTree.getPathBounds(myTree.getClosestPathForLocation(point.x, point.y)); |
| event.setHighlighting(new RelativeRectangle(myTree, pathBounds), DnDEvent.DropTargetHighlightingType.RECTANGLE); |
| event.setDropPossible(true); |
| return false; |
| } |
| |
| @Override |
| public void drop(DnDEvent event) { |
| final Object attached = event.getAttachedObject(); |
| final TreeNode[] sourceNodes = getSourceNodes(attached); |
| final TreeNode targetNode = getTargetNode(event.getPoint()); |
| assert targetNode != null; |
| final int dropAction = event.getAction().getActionId(); |
| if (sourceNodes == null) { |
| if (FileCopyPasteUtil.isFileListFlavorAvailable(event)) { |
| List<File> fileList = FileCopyPasteUtil.getFileListFromAttachedObject(attached); |
| if (!fileList.isEmpty()) { |
| getDropHandler(dropAction).doDropFiles(fileList, targetNode); |
| } |
| } |
| } |
| else { |
| doDrop(sourceNodes, targetNode, dropAction); |
| } |
| } |
| |
| @Override |
| public void cleanUpOnLeave() { |
| } |
| |
| @Override |
| public void updateDraggedImage(Image image, Point dropPoint, Point imageOffset) { |
| } |
| |
| @Nullable |
| private static TreeNode[] getSourceNodes(final Object transferData) { |
| if (transferData instanceof TransferableWrapper) { |
| return ((TransferableWrapper)transferData).getTreeNodes(); |
| } |
| return null; |
| } |
| |
| @Nullable |
| private TreeNode getTargetNode(final Point location) { |
| final TreePath path = myTree.getClosestPathForLocation(location.x, location.y); |
| return path == null ? null : (TreeNode)path.getLastPathComponent(); |
| } |
| |
| private boolean doDrop(@NotNull final TreeNode[] sourceNodes, |
| @NotNull final TreeNode targetNode, |
| final int dropAction) { |
| TreeNode validTargetNode = getValidTargetNode(sourceNodes, targetNode, dropAction); |
| if (validTargetNode != null) { |
| final TreeNode[] filteredSourceNodes = removeRedundantSourceNodes(sourceNodes, validTargetNode, dropAction); |
| if (filteredSourceNodes.length != 0) { |
| getDropHandler(dropAction).doDrop(filteredSourceNodes, validTargetNode); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| @Nullable |
| private TreeNode getValidTargetNode(final @NotNull TreeNode[] sourceNodes, final @NotNull TreeNode targetNode, final int dropAction) { |
| final DropHandler dropHandler = getDropHandler(dropAction); |
| TreeNode currentNode = targetNode; |
| while (true) { |
| if (dropHandler.isValidTarget(sourceNodes, currentNode)) { |
| return currentNode; |
| } |
| if (!dropHandler.shouldDelegateToParent(sourceNodes, currentNode)) return null; |
| currentNode = currentNode.getParent(); |
| if (currentNode == null) return null; |
| } |
| } |
| |
| private TreeNode[] removeRedundantSourceNodes(@NotNull final TreeNode[] sourceNodes, |
| @NotNull final TreeNode targetNode, |
| final int dropAction) { |
| final DropHandler dropHandler = getDropHandler(dropAction); |
| List<TreeNode> result = new ArrayList<TreeNode>(sourceNodes.length); |
| for (TreeNode sourceNode : sourceNodes) { |
| if (!dropHandler.isDropRedundant(sourceNode, targetNode)) { |
| result.add(sourceNode); |
| } |
| } |
| return result.toArray(new TreeNode[result.size()]); |
| } |
| |
| public DropHandler getDropHandler(final int dropAction) { |
| return (dropAction == DnDConstants.ACTION_COPY) ? new CopyDropHandler() : new MoveDropHandler(); |
| } |
| |
| private interface DropHandler { |
| boolean isValidSource(@NotNull TreeNode[] sourceNodes, TreeNode targetNode); |
| |
| boolean isValidTarget(@NotNull TreeNode[] sourceNodes, @NotNull TreeNode targetNode); |
| |
| boolean shouldDelegateToParent(TreeNode[] sourceNodes, @NotNull TreeNode targetNode); |
| |
| boolean isDropRedundant(@NotNull TreeNode sourceNode, @NotNull TreeNode targetNode); |
| |
| void doDrop(@NotNull TreeNode[] sourceNodes, @NotNull TreeNode targetNode); |
| |
| void doDropFiles(List<File> fileList, TreeNode targetNode); |
| } |
| |
| @Nullable |
| protected PsiElement getPsiElement(@Nullable final TreeNode treeNode) { |
| return myRetriever.getPsiElement(treeNode); |
| } |
| |
| protected Module getModule(@Nullable final TreeNode treeNode) { |
| return myRetriever.getModule(treeNode); |
| } |
| |
| public abstract class MoveCopyDropHandler implements DropHandler { |
| @Override |
| public boolean isValidSource(@NotNull final TreeNode[] sourceNodes, TreeNode targetNode) { |
| return canDrop(sourceNodes, targetNode); |
| } |
| |
| @Override |
| public boolean isValidTarget(@NotNull final TreeNode[] sourceNodes, final @NotNull TreeNode targetNode) { |
| return canDrop(sourceNodes, targetNode); |
| } |
| |
| protected abstract boolean canDrop(@NotNull TreeNode[] sourceNodes, @Nullable TreeNode targetNode); |
| |
| @NotNull |
| protected PsiElement[] getPsiElements(@NotNull TreeNode[] nodes) { |
| List<PsiElement> psiElements = new ArrayList<PsiElement>(nodes.length); |
| for (TreeNode node : nodes) { |
| PsiElement psiElement = getPsiElement(node); |
| if (psiElement != null) { |
| psiElements.add(psiElement); |
| } |
| } |
| if (psiElements.size() != 0) { |
| return PsiUtilCore.toPsiElementArray(psiElements); |
| } |
| else { |
| return BaseRefactoringAction.getPsiElementArray(DataManager.getInstance().getDataContext(myTree)); |
| } |
| } |
| } |
| |
| @Nullable |
| protected PsiFileSystemItem[] getPsiFiles(@Nullable List<File> fileList) { |
| if (fileList == null) return null; |
| List<PsiFileSystemItem> sourceFiles = new ArrayList<PsiFileSystemItem>(); |
| for (File file : fileList) { |
| final VirtualFile vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file); |
| if (vFile != null) { |
| final PsiFileSystemItem psiFile = vFile.isDirectory() |
| ? PsiManager.getInstance(myProject).findDirectory(vFile) |
| : PsiManager.getInstance(myProject).findFile(vFile); |
| if (psiFile != null) { |
| sourceFiles.add(psiFile); |
| } |
| } |
| } |
| return sourceFiles.toArray(new PsiFileSystemItem[sourceFiles.size()]); |
| } |
| |
| private class MoveDropHandler extends MoveCopyDropHandler { |
| @Override |
| protected boolean canDrop(@NotNull final TreeNode[] sourceNodes, @Nullable final TreeNode targetNode) { |
| if (targetNode instanceof DefaultMutableTreeNode) { |
| final Object userObject = ((DefaultMutableTreeNode)targetNode).getUserObject(); |
| if (userObject instanceof DropTargetNode && ((DropTargetNode)userObject).canDrop(sourceNodes)) { |
| return true; |
| } |
| } |
| final PsiElement[] sourceElements = getPsiElements(sourceNodes); |
| final PsiElement targetElement = getPsiElement(targetNode); |
| return sourceElements.length == 0 || |
| ((targetNode == null || targetElement != null) && |
| MoveHandler.canMove(sourceElements, targetElement)); |
| } |
| |
| @Override |
| public void doDrop(@NotNull final TreeNode[] sourceNodes, @NotNull final TreeNode targetNode) { |
| if (targetNode instanceof DefaultMutableTreeNode) { |
| final Object userObject = ((DefaultMutableTreeNode)targetNode).getUserObject(); |
| if (userObject instanceof DropTargetNode && ((DropTargetNode)userObject).canDrop(sourceNodes)) { |
| final DataContext dataContext = DataManager.getInstance().getDataContext(myTree); |
| ((DropTargetNode)userObject).drop(sourceNodes, dataContext); |
| } |
| } |
| final PsiElement[] sourceElements = getPsiElements(sourceNodes); |
| doDrop(targetNode, sourceElements, false); |
| } |
| |
| private void doDrop(TreeNode targetNode, PsiElement[] sourceElements, final boolean externalDrop) { |
| final PsiElement targetElement = getPsiElement(targetNode); |
| if (targetElement == null) return; |
| final Module module = getModule(targetNode); |
| final DataContext dataContext = DataManager.getInstance().getDataContext(myTree); |
| getActionHandler().invoke(myProject, sourceElements, new DataContext() { |
| @Override |
| @Nullable |
| public Object getData(@NonNls String dataId) { |
| if (LangDataKeys.TARGET_MODULE.is(dataId)) { |
| if (module != null) return module; |
| } |
| if (LangDataKeys.TARGET_PSI_ELEMENT.is(dataId)) { |
| return targetElement; |
| } |
| else { |
| return externalDrop ? null : dataContext.getData(dataId); |
| } |
| } |
| }); |
| } |
| |
| private RefactoringActionHandler getActionHandler() { |
| return RefactoringActionHandlerFactory.getInstance().createMoveHandler(); |
| } |
| |
| @Override |
| public boolean isDropRedundant(@NotNull TreeNode sourceNode, @NotNull TreeNode targetNode) { |
| return sourceNode.getParent() == targetNode || MoveHandler.isMoveRedundant(getPsiElement(sourceNode), getPsiElement(targetNode)); |
| } |
| |
| @Override |
| public boolean shouldDelegateToParent(TreeNode[] sourceNodes, @NotNull final TreeNode targetNode) { |
| final PsiElement psiElement = getPsiElement(targetNode); |
| return !MoveHandler.isValidTarget(psiElement, getPsiElements(sourceNodes)); |
| } |
| |
| @Override |
| public void doDropFiles(List<File> fileList, TreeNode targetNode) { |
| final PsiFileSystemItem[] sourceFileArray = getPsiFiles(fileList); |
| |
| if (targetNode instanceof DefaultMutableTreeNode) { |
| final Object userObject = ((DefaultMutableTreeNode)targetNode).getUserObject(); |
| if (userObject instanceof DropTargetNode) { |
| final DataContext dataContext = DataManager.getInstance().getDataContext(myTree); |
| ((DropTargetNode)userObject).dropExternalFiles(sourceFileArray, dataContext); |
| return; |
| } |
| } |
| doDrop(targetNode, sourceFileArray, true); |
| } |
| } |
| |
| private class CopyDropHandler extends MoveCopyDropHandler { |
| @Override |
| protected boolean canDrop(@NotNull final TreeNode[] sourceNodes, @Nullable final TreeNode targetNode) { |
| final PsiElement[] sourceElements = getPsiElements(sourceNodes); |
| final PsiElement targetElement = getPsiElement(targetNode); |
| if (targetElement == null) return false; |
| final PsiFile containingFile = targetElement.getContainingFile(); |
| final boolean isTargetAcceptable = targetElement instanceof PsiDirectoryContainer || |
| targetElement instanceof PsiDirectory || |
| (containingFile != null && containingFile.getContainingDirectory() != null); |
| return isTargetAcceptable && CopyHandler.canCopy(sourceElements); |
| } |
| |
| @Override |
| public void doDrop(@NotNull final TreeNode[] sourceNodes, @NotNull final TreeNode targetNode) { |
| final PsiElement[] sourceElements = getPsiElements(sourceNodes); |
| doDrop(targetNode, sourceElements); |
| } |
| |
| private void doDrop(TreeNode targetNode, PsiElement[] sourceElements) { |
| final PsiElement targetElement = getPsiElement(targetNode); |
| if (targetElement == null) return; |
| final PsiDirectory psiDirectory; |
| if (targetElement instanceof PsiDirectoryContainer) { |
| final PsiDirectoryContainer directoryContainer = (PsiDirectoryContainer)targetElement; |
| final PsiDirectory[] psiDirectories = directoryContainer.getDirectories(); |
| psiDirectory = psiDirectories.length != 0 ? psiDirectories[0] : null; |
| } |
| else if (targetElement instanceof PsiDirectory) { |
| psiDirectory = (PsiDirectory)targetElement; |
| } |
| else { |
| final PsiFile containingFile = targetElement.getContainingFile(); |
| LOG.assertTrue(containingFile != null); |
| psiDirectory = containingFile.getContainingDirectory(); |
| } |
| CopyHandler.doCopy(sourceElements, psiDirectory); |
| } |
| |
| @Override |
| public boolean isDropRedundant(@NotNull TreeNode sourceNode, @NotNull TreeNode targetNode) { |
| return false; |
| } |
| |
| @Override |
| public boolean shouldDelegateToParent(TreeNode[] sourceNodes, @NotNull final TreeNode targetNode) { |
| final PsiElement psiElement = getPsiElement(targetNode); |
| return psiElement == null || (!(psiElement instanceof PsiDirectoryContainer) && !(psiElement instanceof PsiDirectory)); |
| } |
| |
| @Override |
| public void doDropFiles(List<File> fileList, TreeNode targetNode) { |
| final PsiFileSystemItem[] sourceFileArray = getPsiFiles(fileList); |
| doDrop(targetNode, sourceFileArray); |
| } |
| } |
| } |
