platform/lang-impl/src/com/intellij/ide/CopyPasteDelegator.java

   1 package com.intellij.ide;
   2
   3 import com.intellij.openapi.actionSystem.DataContext;
   4 import com.intellij.openapi.actionSystem.PlatformDataKeys;
   5 import com.intellij.openapi.actionSystem.ex.DataConstantsEx;
   6 import com.intellij.openapi.extensions.ExtensionPointName;
   7 import com.intellij.openapi.extensions.Extensions;
   8 import com.intellij.openapi.project.Project;
   9 import com.intellij.psi.PsiDirectory;
  10 import com.intellij.psi.PsiDirectoryContainer;
  11 import com.intellij.psi.PsiElement;
  12 import com.intellij.psi.PsiManager;
  13 import com.intellij.refactoring.copy.CopyHandler;
  14 import com.intellij.refactoring.move.MoveCallback;
  15 import com.intellij.refactoring.move.MoveHandler;
  16 import org.jetbrains.annotations.NotNull;
  17
  18 import javax.swing.*;
  19
  20 public abstract class CopyPasteDelegator implements CopyPasteSupport {
  21   private static final ExtensionPointName<PasteProvider> EP_NAME = ExtensionPointName.create("com.intellij.filePasteProvider");
  22
  23   private final Project myProject;
  24   private final JComponent myKeyReceiver;
  25   private final MyEditable myEditable;
  26
  27   public CopyPasteDelegator(Project project, JComponent keyReceiver) {
  28     myProject = project;
  29     myKeyReceiver = keyReceiver;
  30     myEditable = new MyEditable();
  31   }
  32
  33   @NotNull
  34   protected abstract PsiElement[] getSelectedElements();
  35
  36   @NotNull
  37   private PsiElement[] getValidSelectedElements() {
  38     PsiElement[] selectedElements = getSelectedElements();
  39     for (PsiElement element : selectedElements) {
  40       if (element == null || !element.isValid()) {
  41         return PsiElement.EMPTY_ARRAY;
  42       }
  43     }
  44     return selectedElements;
  45   }
  46
  47   private void updateView() {
  48     myKeyReceiver.repaint();
  49   }
  50
  51   public CopyProvider getCopyProvider() {
  52     return myEditable;
  53   }
  54
  55   public CutProvider getCutProvider() {
  56     return myEditable;
  57   }
  58
  59   public PasteProvider getPasteProvider() {
  60     return myEditable;
  61   }
  62
  63   private class MyEditable implements CutProvider, CopyProvider, PasteProvider {
  64     public void performCopy(DataContext dataContext) {
  65       PsiElement[] elements = getValidSelectedElements();
  66       PsiCopyPasteManager.getInstance().setElements(elements, true);
  67       updateView();
  68     }
  69
  70     public boolean isCopyEnabled(DataContext dataContext) {
  71       PsiElement[] elements = getValidSelectedElements();
  72       return CopyHandler.canCopy(elements);
  73     }
  74
  75     public boolean isCopyVisible(DataContext dataContext) {
  76       return true;
  77     }
  78
  79     public void performCut(DataContext dataContext) {
  80       PsiElement[] elements = getValidSelectedElements();
  81       if (MoveHandler.adjustForMove(myProject, elements, null) == null) {
  82         return;
  83       }
  84       // 'elements' passed instead of result of 'adjustForMove' because otherwise ProjectView would
  85       // not recognize adjusted elements when graying them
  86       PsiCopyPasteManager.getInstance().setElements(elements, false);
  87       updateView();
  88     }
  89
  90     public boolean isCutEnabled(DataContext dataContext) {
  91       final PsiElement[] elements = getValidSelectedElements();
  92       return elements.length != 0 && MoveHandler.canMove(elements, null);
  93     }
  94
  95     public boolean isCutVisible(DataContext dataContext) {
  96       return true;
  97     }
  98
  99     public void performPaste(DataContext dataContext) {
 100       if (!performDefaultPaste(dataContext)) {
 101         for(PasteProvider provider: Extensions.getExtensions(EP_NAME)) {
 102           if (provider.isPasteEnabled(dataContext)) {
 103             provider.performPaste(dataContext);
 104           }
 105         }
 106       }
 107     }
 108
 109     private boolean performDefaultPaste(final DataContext dataContext) {
 110       final boolean[] isCopied = new boolean[1];
 111       final PsiElement[] elements = PsiCopyPasteManager.getInstance().getElements(isCopied);
 112       if (elements == null) return false;
 113       try {
 114         PsiElement target = (PsiElement)dataContext.getData(DataConstantsEx.PASTE_TARGET_PSI_ELEMENT);
 115         if (isCopied[0]) {
 116           PsiDirectory targetDirectory = target instanceof PsiDirectory ? (PsiDirectory)target : null;
 117           if (targetDirectory == null && target instanceof PsiDirectoryContainer) {
 118             final PsiDirectory[] directories = ((PsiDirectoryContainer)target).getDirectories();
 119             if (directories.length > 0) {
 120               targetDirectory = directories[0];
 121             }
 122           }
 123           if (CopyHandler.canCopy(elements)) {
 124             CopyHandler.doCopy(elements, targetDirectory);
 125           }
 126         }
 127         else if (MoveHandler.canMove(elements, target)) {
 128           MoveHandler.doMove(myProject, elements, target, new MoveCallback() {
 129             public void refactoringCompleted() {
 130               PsiCopyPasteManager.getInstance().clear();
 131             }
 132           });
 133         }
 134         else {
 135           return false;
 136         }
 137       }
 138       finally {
 139         updateView();
 140       }
 141       return true;
 142     }
 143
 144     public boolean isPastePossible(DataContext dataContext) {
 145       return true;
 146     }
 147
 148     public boolean isPasteEnabled(DataContext dataContext){
 149       if (isDefaultPasteEnabled(dataContext)) {
 150         return true;
 151       }
 152       for(PasteProvider provider: Extensions.getExtensions(EP_NAME)) {
 153         if (provider.isPasteEnabled(dataContext)) {
 154           return true;
 155         }
 156       }
 157       return false;
 158     }
 159
 160     private boolean isDefaultPasteEnabled(final DataContext dataContext) {
 161       Project project = PlatformDataKeys.PROJECT.getData(dataContext);
 162       if (project == null) {
 163         return false;
 164       }
 165
 166       Object target = dataContext.getData(DataConstantsEx.PASTE_TARGET_PSI_ELEMENT);
 167       if (target == null) {
 168         return false;
 169       }
 170       PsiElement[] elements = PsiCopyPasteManager.getInstance().getElements(new boolean[]{false});
 171       if (elements == null) {
 172         return false;
 173       }
 174
 175       // disable cross-project paste
 176       for (PsiElement element : elements) {
 177         PsiManager manager = element.getManager();
 178         if (manager == null || manager.getProject() != project) {
 179           return false;
 180         }
 181       }
 182
 183       return true;
 184     }
 185   }
 186 }