platform-impl/src/com/intellij/openapi/editor/impl/ContextMenuImpl.java

   1 package com.intellij.openapi.editor.impl;
   2
   3 import com.intellij.ide.DataManager;
   4 import com.intellij.openapi.Disposable;
   5 import com.intellij.openapi.fileEditor.FileDocumentManager;
   6 import com.intellij.openapi.actionSystem.*;
   7 import com.intellij.openapi.actionSystem.ex.ActionButtonLook;
   8 import com.intellij.openapi.actionSystem.ex.ActionManagerEx;
   9 import com.intellij.openapi.actionSystem.impl.ActionButton;
  10 import com.intellij.openapi.actionSystem.impl.ActionToolbarImpl;
  11 import com.intellij.openapi.editor.Document;
  12 import com.intellij.openapi.editor.event.EditorMouseAdapter;
  13 import com.intellij.openapi.editor.event.EditorMouseEvent;
  14 import com.intellij.openapi.editor.event.EditorMouseMotionAdapter;
  15 import com.intellij.openapi.keymap.ex.KeymapManagerEx;
  16 import com.intellij.openapi.vfs.LocalFileSystem;
  17 import com.intellij.openapi.vfs.VirtualFile;
  18 import org.jetbrains.annotations.NonNls;
  19 import org.jetbrains.annotations.NotNull;
  20 import org.jetbrains.annotations.Nullable;
  21
  22 import javax.swing.*;
  23 import java.awt.*;
  24 import java.awt.event.ActionEvent;
  25 import java.awt.event.ActionListener;
  26 import java.awt.image.BufferedImage;
  27
  28 /**
  29  * @author spleaner
  30  */
  31 public class ContextMenuImpl extends JPanel implements Disposable {
  32   @NonNls
  33   public static final String ACTION_GROUP = "EditorContextBarMenu";
  34
  35   private ActionGroup myActionGroup;
  36   private final JComponent myComponent;
  37   private boolean myShowing = false;
  38   private int myCurrentOpacity;
  39   private Timer myShowTimer;
  40   private Timer myHideTimer;
  41   private EditorImpl myEditor;
  42   private ContextMenuPanel myContextMenuPanel;
  43   private boolean myDisposed;
  44
  45   public ContextMenuImpl(@NotNull final JScrollPane container, @NotNull final EditorImpl editor) {
  46     setLayout(new BorderLayout(0, 0));
  47     myEditor = editor;
  48
  49     final ActionManager actionManager = ActionManager.getInstance();
  50
  51     editor.addEditorMouseListener(new EditorMouseAdapter() {
  52       @Override
  53       public void mouseExited(final EditorMouseEvent e) {
  54         if (!isInsideActivationArea(container, e.getMouseEvent().getPoint())) {
  55           toggleContextToolbar(false);
  56         }
  57       }
  58     });
  59
  60     editor.addEditorMouseMotionListener(new EditorMouseMotionAdapter() {
  61       @Override
  62       public void mouseMoved(final EditorMouseEvent e) {
  63         toggleContextToolbar(isInsideActivationArea(container, e.getMouseEvent().getPoint()));
  64       }
  65     });
  66
  67     AnAction action = actionManager.getAction("EditorContextBarMenu");
  68     if (action == null) {
  69       action = new DefaultActionGroup();
  70       actionManager.registerAction(ACTION_GROUP, action);
  71     }
  72
  73     if (action instanceof ActionGroup) {
  74       myActionGroup = (ActionGroup)action;
  75     }
  76
  77     myComponent = createComponent();
  78     add(myComponent);
  79
  80     setVisible(false);
  81     setOpaque(false);
  82   }
  83
  84   private static boolean isInsideActivationArea(JScrollPane container, Point p) {
  85     final JViewport viewport = container.getViewport();
  86     final Rectangle r = viewport.getBounds();
  87     final Point viewPosition = viewport.getViewPosition();
  88
  89     final Rectangle activationArea = new Rectangle(0, 0, r.width, 150);
  90     return activationArea.contains(p.x, p.y - viewPosition.y);
  91   }
  92
  93   private void toggleContextToolbar(final boolean show) {
  94     if (show) {
  95       show();
  96     }
  97     else {
  98       hide();
  99     }
 100   }
 101
 102   public void dispose() {
 103     myDisposed = true;
 104     myEditor = null;
 105
 106     if (myHideTimer != null) {
 107       myHideTimer.stop();
 108       myHideTimer = null;
 109     }
 110
 111     if (myShowTimer != null) {
 112       myShowTimer.stop();
 113       myShowTimer = null;
 114     }
 115
 116   }
 117
 118   public static boolean mayShowToolbar(@Nullable final Document document) {
 119     if (document == null) {
 120       return false;
 121     }
 122
 123     final VirtualFile file = FileDocumentManager.getInstance().getFile(document);
 124     return file != null && file.isValid() && file.getFileSystem() == LocalFileSystem.getInstance();
 125   }
 126
 127   @SuppressWarnings({"deprecation"})
 128   @Override
 129   public void show() {
 130     final Component toolbar = myComponent.getComponent(0);
 131     final int count = ((Container)toolbar).getComponentCount();
 132     if (count == 0) {
 133       return;
 134     }
 135
 136     if (!myShowing) {
 137       //myCurrentOpacity = 0;
 138
 139       if (myHideTimer != null && myHideTimer.isRunning()) {
 140         myHideTimer.stop();
 141         myHideTimer = null;
 142       }
 143
 144       super.show();
 145       setOpaque(false);
 146
 147       if (myShowTimer == null || !myShowTimer.isRunning()) {
 148         myShowing = true;
 149
 150         myShowTimer = new Timer(500, new ActionListener() {
 151           public void actionPerformed(final ActionEvent e) {
 152             if (myDisposed || myShowTimer == null) return;
 153             myShowTimer.stop();
 154
 155             myShowTimer = new Timer(50, new ActionListener() {
 156               public void actionPerformed(final ActionEvent e) {
 157                 if (myDisposed) return;
 158
 159                 myCurrentOpacity += 20;
 160                 if (myCurrentOpacity > 100) {
 161                   myCurrentOpacity = 100;
 162                   myShowTimer.stop();
 163
 164                   scheduleHide();
 165                 }
 166
 167                 repaint();
 168               }
 169             });
 170
 171             myShowTimer.setRepeats(true);
 172             myShowTimer.start();
 173           }
 174         });
 175
 176         myShowTimer.setRepeats(false);
 177         myShowTimer.start();
 178
 179       }
 180     }
 181     else {
 182       scheduleHide();
 183       super.show();
 184     }
 185   }
 186
 187   private void scheduleHide() {
 188     if (myHideTimer != null && myHideTimer.isRunning()) {
 189       return;
 190     }
 191
 192     myHideTimer = new Timer(1500, new ActionListener() {
 193       public void actionPerformed(final ActionEvent e) {
 194         if (myDisposed) return;
 195
 196         if (myComponent.isVisible()) {
 197           final PointerInfo pointerInfo = MouseInfo.getPointerInfo();
 198           if (pointerInfo != null) {
 199             final Point location = pointerInfo.getLocation();
 200             SwingUtilities.convertPointFromScreen(location, myComponent);
 201             if (!myComponent.getBounds().contains(location)) {
 202               toggleContextToolbar(false);
 203             }
 204           }
 205         }
 206       }
 207     });
 208
 209     myHideTimer.setRepeats(false);
 210     myHideTimer.start();
 211   }
 212
 213   @SuppressWarnings({"deprecation"})
 214   @Override
 215   public void hide() {
 216     if (myShowing) {
 217       if (myShowTimer != null && myShowTimer.isRunning()) {
 218         myShowTimer.stop();
 219         myShowTimer = null;
 220       }
 221
 222       if (myHideTimer == null || !myHideTimer.isRunning()) {
 223         myShowing = false;
 224
 225         myHideTimer = new Timer(700, new ActionListener() {
 226           public void actionPerformed(final ActionEvent e) {
 227             if (myDisposed || myHideTimer == null) return;
 228             myHideTimer.stop();
 229
 230             myHideTimer = new Timer(50, new ActionListener() {
 231               public void actionPerformed(final ActionEvent e) {
 232                 myCurrentOpacity -= 20;
 233                 if (myCurrentOpacity < 0) {
 234                   myCurrentOpacity = 0;
 235                   myHideTimer.stop();
 236                   //ContextMenuImpl.super.hide();
 237                 }
 238
 239                 repaint();
 240               }
 241             });
 242
 243             myHideTimer.setRepeats(true);
 244             myHideTimer.start();
 245           }
 246         });
 247
 248         myHideTimer.setRepeats(false);
 249         myHideTimer.start();
 250       }
 251     }
 252     else {
 253       //super.hide();
 254     }
 255   }
 256
 257   private ActionToolbar createToolbar(final ActionGroup group) {
 258     final ActionToolbarImpl actionToolbar =
 259       new ActionToolbarImpl(ActionPlaces.CONTEXT_TOOLBAR, group, true, DataManager.getInstance(), ActionManagerEx.getInstanceEx(),
 260                             KeymapManagerEx.getInstanceEx()) {
 261
 262         @Override
 263         public void paint(final Graphics g) {
 264           if (myContextMenuPanel.isPaintChildren()) {
 265             paintChildren(g);
 266           }
 267         }
 268
 269         @Override
 270         protected void paintChildren(final Graphics g) {
 271           if (myContextMenuPanel.isPaintChildren()) {
 272             super.paintChildren(g);
 273           }
 274         }
 275
 276         @Override
 277         public boolean isOpaque() {
 278           return myContextMenuPanel.isPaintChildren();
 279         }
 280
 281         @Override
 282         public ActionButton createToolbarButton(final AnAction action,
 283                                                 final ActionButtonLook look,
 284                                                 final String place,
 285                                                 final Presentation presentation,
 286                                                 final Dimension minimumSize) {
 287           final ActionButton result = new ActionButton(action, presentation, place, minimumSize) {
 288             @Override
 289             public void paintComponent(final Graphics g) {
 290               if (myContextMenuPanel.isPaintChildren()) {
 291                 final ActionButtonLook look = getButtonLook();
 292                 look.paintIcon(g, this, getIcon());
 293               }
 294
 295               if (myContextMenuPanel.isShown() && getPopState() == ActionButton.POPPED) {
 296                 final ActionButtonLook look = getButtonLook();
 297                 look.paintBackground(g, this);
 298                 look.paintIcon(g, this, getIcon());
 299               }
 300             }
 301
 302             @Override
 303             public boolean isOpaque() {
 304               return myContextMenuPanel.isPaintChildren() || getPopState() == ActionButton.POPPED;
 305             }
 306
 307             @Override
 308             public void paint(final Graphics g) {
 309               final Graphics2D g2 = (Graphics2D)g;
 310               paintComponent(g2);
 311             }
 312           };
 313
 314           result.setLook(look);
 315           return result;
 316         }
 317       };
 318
 319     actionToolbar.setTargetComponent(myEditor.getContentComponent());
 320
 321     return actionToolbar;
 322   }
 323
 324   private JComponent createComponent() {
 325     final ActionToolbar toolbar = createToolbar(myActionGroup);
 326     toolbar.setMinimumButtonSize(new Dimension(20, 20));
 327     toolbar.setReservePlaceAutoPopupIcon(false);
 328
 329     myContextMenuPanel = new ContextMenuPanel(this);
 330     myContextMenuPanel.setLayout(new BorderLayout(0, 0));
 331     myContextMenuPanel.add(toolbar.getComponent());
 332
 333     return myContextMenuPanel;
 334   }
 335
 336   private static class ContextMenuPanel extends JPanel {
 337     private final ContextMenuImpl myContextMenu;
 338     private BufferedImage myBufferedImage;
 339     private boolean myPaintChildren = false;
 340
 341     private ContextMenuPanel(final ContextMenuImpl contextMenu) {
 342       myContextMenu = contextMenu;
 343       setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
 344       setOpaque(false);
 345     }
 346
 347     @Override
 348     public void invalidate() {
 349       super.invalidate();
 350
 351       myBufferedImage = null;
 352     }
 353
 354     @Override
 355     public void revalidate() {
 356       super.revalidate();
 357
 358       myBufferedImage = null;
 359     }
 360
 361     @Override
 362     protected void paintChildren(final Graphics g) {
 363       if (myPaintChildren) {
 364         super.paintChildren(g);
 365       }
 366     }
 367
 368     public boolean isPaintChildren() {
 369       return myPaintChildren;
 370     }
 371
 372     @Override
 373     public void paint(final Graphics g) {
 374       final Rectangle r = getBounds();
 375       if (myBufferedImage == null) {
 376         myBufferedImage = new BufferedImage(r.width, r.height, BufferedImage.TYPE_INT_ARGB);
 377
 378         final Graphics graphics = myBufferedImage.getGraphics();
 379         final Graphics2D g2d2 = (Graphics2D)graphics;
 380         final Composite old = g2d2.getComposite();
 381
 382         g2d2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.2f));
 383
 384         g2d2.setColor(Color.GRAY);
 385         g2d2.fillRoundRect(0, 0, r.width - 1, r.height - 1, 6, 6);
 386
 387         g2d2.setComposite(old);
 388
 389         myPaintChildren = true;
 390         paintChildren(g2d2);
 391         myPaintChildren = false;
 392       }
 393
 394       final Graphics2D g2 = (Graphics2D)g;
 395       final Composite old = g2.getComposite();
 396
 397       g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, myContextMenu.myCurrentOpacity / 100.0f));
 398       g2.drawImage(myBufferedImage, 0, 0, myBufferedImage.getWidth(null), myBufferedImage.getHeight(null), null);
 399
 400       g2.setComposite(old);
 401     }
 402
 403     public boolean isShown() {
 404       return myContextMenu.myCurrentOpacity == 100;
 405     }
 406   }
 407 }