platform/platform-impl/src/com/intellij/ide/CopyPasteManagerEx.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.ide;
  17
  18 import com.intellij.Patches;
  19 import com.intellij.ide.ui.UISettings;
  20 import com.intellij.openapi.Disposable;
  21 import com.intellij.openapi.application.ApplicationManager;
  22 import com.intellij.openapi.application.ApplicationNamesInfo;
  23 import com.intellij.openapi.diagnostic.Logger;
  24 import com.intellij.openapi.extensions.Extensions;
  25 import com.intellij.openapi.ide.CopyPasteManager;
  26 import com.intellij.openapi.ide.CutElementMarker;
  27 import com.intellij.openapi.ui.Messages;
  28 import com.intellij.openapi.util.Comparing;
  29 import com.intellij.util.EventDispatcher;
  30
  31 import java.awt.*;
  32 import java.awt.datatransfer.*;
  33 import java.io.IOException;
  34 import java.util.ArrayList;
  35 import java.util.concurrent.ExecutionException;
  36 import java.util.concurrent.Future;
  37 import java.util.concurrent.TimeUnit;
  38 import java.util.concurrent.TimeoutException;
  39
  40 public class CopyPasteManagerEx extends CopyPasteManager implements ClipboardOwner {
  41   private static final Logger LOG = Logger.getInstance("#com.intellij.ide.CopyPasteManagerEx");
  42
  43   private final ArrayList<Transferable> myDatas;
  44
  45 //  private static long ourWastedMemory = 0;
  46 //  private static long ourLastPrintedMemory = 0;
  47 //  private static long ourLastPrintTime = 0;
  48 //  private static long ourInvokationCounter = 0;
  49
  50   private final EventDispatcher<ContentChangedListener> myDispatcher = EventDispatcher.create(ContentChangedListener.class);
  51   private static final int DELAY_UNTIL_ABORT_CLIPBOARD_ACCESS = 2000;
  52   private boolean myIsWarningShown = false;
  53
  54   public CopyPasteManagerEx() {
  55     myDatas = new ArrayList<Transferable>();
  56   }
  57
  58   public Transferable getSystemClipboardContents() {
  59     final Transferable[] contents = new Transferable[] {null};
  60     final boolean[] success = new boolean[] {false};
  61     Runnable accessor = new Runnable() {
  62       public void run() {
  63         try {
  64           for (int i = 0; i < 3; i++) {
  65             try {
  66               contents[0] = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(CopyPasteManagerEx.this);
  67             }
  68             catch (IllegalStateException e) {
  69               try {
  70                 Thread.sleep(50);
  71               }
  72               catch (InterruptedException e1) {
  73               }
  74               continue;
  75             }
  76             break;
  77           }
  78
  79           success[0] = true;
  80         }
  81         catch (Throwable e) {
  82           // No luck
  83         }
  84         finally {
  85           Thread.interrupted(); // reset interrupted status
  86         }
  87       }
  88     };
  89
  90     if (Patches.SUN_BUG_ID_4818143) {
  91       final Future<?> accessorFuture = ApplicationManager.getApplication().executeOnPooledThread(accessor);
  92
  93       try {
  94         accessorFuture.get(DELAY_UNTIL_ABORT_CLIPBOARD_ACCESS, TimeUnit.MILLISECONDS);
  95       }
  96       catch (InterruptedException e) {
  97         // {no luck}
  98       }
  99       catch (TimeoutException e) {
 100         // {no luck}
 101       }
 102       catch (ExecutionException e) {
 103         LOG.error(e);
 104       }
 105
 106       if (success[0]) return contents[0];
 107       accessorFuture.cancel(true);
 108       showWorkaroundMessage();
 109
 110       return null;
 111     }
 112     else {
 113       accessor.run();
 114       return contents[0];
 115     }
 116   }
 117
 118   private void showWorkaroundMessage() {
 119     if (myIsWarningShown) return;
 120     final String productName = ApplicationNamesInfo.getInstance().getProductName();
 121     Messages.showErrorDialog(IdeBundle.message("error.paste.bug.workaround", productName, productName), IdeBundle.message("title.system.error"));
 122     myIsWarningShown = true;
 123   }
 124
 125 //  private long getUsedMemory() {
 126 //    Runtime runtime = Runtime.getRuntime();
 127 //    long usedMemory = runtime.totalMemory() - runtime.freeMemory();
 128 //    return usedMemory;
 129 //  }
 130 //
 131   public void lostOwnership(Clipboard clipboard, Transferable contents) {
 132     fireContentChanged(null);
 133   }
 134
 135   void fireContentChanged(final Transferable oldTransferable) {
 136     myDispatcher.getMulticaster().contentChanged(oldTransferable, getContents());
 137   }
 138
 139   public void addContentChangedListener(ContentChangedListener listener) {
 140     myDispatcher.addListener(listener);
 141   }
 142
 143   public void addContentChangedListener(final ContentChangedListener listener, Disposable parentDisposable) {
 144     myDispatcher.addListener(listener, parentDisposable);
 145   }
 146
 147   public void removeContentChangedListener(ContentChangedListener listener) {
 148     myDispatcher.removeListener(listener);
 149   }
 150
 151   public void setContents(Transferable content) {
 152     Transferable old = getContents();
 153     addNewContentToStack(content);
 154
 155     setSystemClipboardContent(content);
 156
 157     fireContentChanged(old);
 158   }
 159
 160   public boolean isCutElement(final Object element) {
 161     for(CutElementMarker marker: Extensions.getExtensions(CutElementMarker.EP_NAME)) {
 162       if (marker.isCutElement(element)) return true;
 163     }
 164     return false;
 165   }
 166
 167   void setSystemClipboardContent(final Transferable content) {
 168     final boolean[] success = new boolean[]{false};
 169     final Runnable accessor = new Runnable() {
 170       public void run() {
 171         try {
 172           for (int i = 0; i < 3; i++) {
 173             try {
 174               Toolkit.getDefaultToolkit().getSystemClipboard().setContents(content, CopyPasteManagerEx.this);
 175             }
 176             catch (IllegalStateException e) {
 177               try {
 178                 Thread.sleep(50);
 179               }
 180               catch (InterruptedException e1) {
 181               }
 182               continue;
 183             }
 184             break;
 185           }
 186           success[0] = true;
 187         }
 188         finally {
 189           Thread.interrupted(); // reset interrupted status
 190         }
 191       }
 192     };
 193
 194     if (Patches.SUN_BUG_ID_4818143) {
 195       Future<?> accessorFuture = ApplicationManager.getApplication().executeOnPooledThread(accessor);
 196
 197       try {
 198         accessorFuture.get(DELAY_UNTIL_ABORT_CLIPBOARD_ACCESS, TimeUnit.MILLISECONDS);
 199       }
 200       catch (Exception e) { /* no luck */ }
 201
 202       if (!success[0]) {
 203         showWorkaroundMessage();
 204         accessorFuture.cancel(true);
 205       }
 206     }
 207     else {
 208       accessor.run();
 209     }
 210   }
 211
 212   private void addNewContentToStack(Transferable content) {
 213     try {
 214       String clipString = getStringContent(content);
 215       if (clipString != null) {
 216         Transferable same = null;
 217         for (Transferable old : myDatas) {
 218           if (clipString.equals(getStringContent(old))) {
 219             same = old;
 220             break;
 221           }
 222         }
 223
 224         if (same == null) {
 225           myDatas.add(0, content);
 226           deleteAfterAllowedMaximum();
 227         }
 228         else {
 229           moveContentTopStackTop(same);
 230         }
 231       }
 232     } catch (UnsupportedFlavorException e) {
 233     } catch (IOException e) {
 234     }
 235   }
 236
 237   private static String getStringContent(Transferable content) throws UnsupportedFlavorException, IOException {
 238     return (String) content.getTransferData(DataFlavor.stringFlavor);
 239   }
 240
 241   private void deleteAfterAllowedMaximum() {
 242     int max = UISettings.getInstance().MAX_CLIPBOARD_CONTENTS;
 243     for (int i = myDatas.size() - 1; i >= max; i--) {
 244       myDatas.remove(i);
 245     }
 246   }
 247
 248   public Transferable getContents() {
 249     return getSystemClipboardContents();
 250   }
 251
 252   public Transferable[] getAllContents() {
 253     deleteAfterAllowedMaximum();
 254
 255     Transferable content = getSystemClipboardContents();
 256     if (content != null) {
 257       try {
 258         String clipString = getStringContent(content);
 259         String datasString = null;
 260
 261         if (!myDatas.isEmpty()) {
 262           datasString = getStringContent(myDatas.get(0));
 263         }
 264
 265         if (clipString != null && clipString.length() > 0 && !Comparing.equal(clipString, datasString)) {
 266           myDatas.add(0, content);
 267         }
 268       } catch (UnsupportedFlavorException e) {
 269       } catch (IOException e) {
 270       }
 271     }
 272
 273     return myDatas.toArray(new Transferable[myDatas.size()]);
 274   }
 275
 276   public void removeContent(Transferable t) {
 277     Transferable old = getContents();
 278     boolean isCurrentClipboardContent = myDatas.indexOf(t) == 0;
 279     myDatas.remove(t);
 280     if (isCurrentClipboardContent) {
 281       if (!myDatas.isEmpty()) {
 282         setSystemClipboardContent(myDatas.get(0));
 283       }
 284       else {
 285         setSystemClipboardContent(new StringSelection(""));
 286       }
 287     }
 288     fireContentChanged(old);
 289   }
 290
 291   public void moveContentTopStackTop(Transferable t) {
 292     setSystemClipboardContent(t);
 293     myDatas.remove(t);
 294     myDatas.add(0, t);
 295   }
 296 }