platform/platform-impl/src/com/intellij/ui/popup/StackingPopupDispatcherImpl.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
  17 package com.intellij.ui.popup;
  18
  19 import com.intellij.ide.IdeEventQueue;
  20 import com.intellij.openapi.application.ApplicationManager;
  21 import com.intellij.openapi.ui.popup.JBPopup;
  22 import com.intellij.openapi.ui.popup.StackingPopupDispatcher;
  23 import com.intellij.util.containers.WeakList;
  24 import org.jetbrains.annotations.Nullable;
  25
  26 import javax.swing.*;
  27 import java.awt.*;
  28 import java.awt.event.AWTEventListener;
  29 import java.awt.event.KeyEvent;
  30 import java.awt.event.MouseEvent;
  31 import java.util.Stack;
  32
  33 public class StackingPopupDispatcherImpl extends StackingPopupDispatcher implements AWTEventListener, KeyEventDispatcher {
  34
  35   private final Stack<JBPopup> myStack = new Stack<JBPopup>();
  36   private final WeakList<JBPopup> myPersistentPopups = new WeakList<JBPopup>();
  37
  38   private final WeakList<JBPopup> myAllPopups = new WeakList<JBPopup>();
  39
  40
  41   private StackingPopupDispatcherImpl() {
  42   }
  43
  44   public void onPopupShown(JBPopup popup, boolean inStack) {
  45     if (inStack) {
  46       myStack.push(popup);
  47       if (ApplicationManager.getApplication() != null) {
  48         IdeEventQueue.getInstance().getPopupManager().push(getInstance());
  49       }
  50     } else if (popup.isPersistent()) {
  51       myPersistentPopups.add(popup);
  52     }
  53
  54     myAllPopups.add(popup);
  55   }
  56
  57   public void onPopupHidden(JBPopup popup) {
  58     boolean wasInStack = myStack.remove(popup);
  59     myPersistentPopups.remove(popup);
  60
  61     if (wasInStack && myStack.isEmpty()) {
  62       if (ApplicationManager.getApplication() != null) {
  63         IdeEventQueue.getInstance().getPopupManager().remove(this);
  64       }
  65     }
  66
  67     myAllPopups.remove(popup);
  68   }
  69
  70   public void hidePersistentPopups() {
  71     final WeakList<JBPopup> list = myPersistentPopups;
  72     for (JBPopup each : list) {
  73       if (each.isNativePopup()) {
  74         each.setUiVisible(false);
  75       }
  76     }
  77   }
  78
  79   public void restorePersistentPopups() {
  80     final WeakList<JBPopup> list = myPersistentPopups;
  81     for (JBPopup each : list) {
  82       if (each.isNativePopup()) {
  83         each.setUiVisible(true);
  84       }
  85     }
  86   }
  87
  88   public void eventDispatched(AWTEvent event) {
  89     dispatchMouseEvent(event);
  90   }
  91
  92   protected boolean dispatchMouseEvent(AWTEvent event) {
  93     if (event.getID() != MouseEvent.MOUSE_PRESSED) {
  94       return false;
  95     }
  96
  97     if (myStack.isEmpty()) {
  98       return false;
  99     }
 100
 101     AbstractPopup popup = (AbstractPopup)findPopup();
 102
 103     final MouseEvent mouseEvent = ((MouseEvent) event);
 104
 105     Point point = (Point) mouseEvent.getPoint().clone();
 106     SwingUtilities.convertPointToScreen(point, mouseEvent.getComponent());
 107
 108     while (true) {
 109       if (popup != null && !popup.isDisposed()) {
 110         final Component content = popup.getContent();
 111         if (!content.isShowing()) {
 112           popup.cancel();
 113           return false;
 114         }
 115
 116         final Rectangle bounds = new Rectangle(content.getLocationOnScreen(), content.getSize());
 117         if (bounds.contains(point) || !popup.isCancelOnClickOutside()) {
 118           return false;
 119         }
 120
 121         if (!popup.canClose()){
 122           return false;
 123         }
 124         popup.cancel(mouseEvent);
 125       }
 126
 127       if (myStack.isEmpty()) {
 128         return false;
 129       }
 130
 131       popup = (AbstractPopup)myStack.peek();
 132       if (popup == null || popup.isDisposed()) {
 133         myStack.pop();
 134       }
 135     }
 136   }
 137
 138   protected JBPopup findPopup() {
 139     while(true) {
 140       if (myStack.isEmpty()) break;
 141       final AbstractPopup each = (AbstractPopup)myStack.peek();
 142       if (each == null || each.isDisposed()) {
 143         myStack.pop();
 144       } else {
 145         return each;
 146       }
 147     }
 148
 149     return null;
 150   }
 151
 152   public boolean dispatchKeyEvent(final KeyEvent e) {
 153     final boolean closeRequest = e.getID() == KeyEvent.KEY_PRESSED && e.getKeyCode() == KeyEvent.VK_ESCAPE && e.getModifiers() == 0;
 154
 155     JBPopup popup;
 156
 157     if (closeRequest) {
 158       popup = findPopup();
 159     } else {
 160       popup = getFocusedPopup();
 161     }
 162
 163     if (popup == null) return false;
 164
 165
 166     if (closeRequest) {
 167       if (popup.isCancelKeyEnabled()) {
 168         popup.cancel();
 169         return true;
 170       }
 171     }
 172
 173     return false;
 174   }
 175
 176
 177   @Nullable
 178   public Component getComponent() {
 179     return myStack.size() > 0 ?myStack.peek().getContent() : null;
 180   }
 181
 182   public boolean dispatch(AWTEvent event) {
 183    if (event instanceof KeyEvent) {
 184       return dispatchKeyEvent(((KeyEvent) event));
 185    } else if (event instanceof MouseEvent) {
 186      return dispatchMouseEvent(event);
 187    } else {
 188      return false;
 189    }
 190   }
 191
 192   public void requestFocus() {
 193     if (myStack.isEmpty()) return;
 194
 195     final AbstractPopup popup = (AbstractPopup)myStack.peek();
 196     popup.requestFocus();
 197
 198   }
 199
 200   public boolean close() {
 201     return closeActivePopup();
 202   }
 203
 204   public boolean closeActivePopup() {
 205     if (myStack.isEmpty()) return false;
 206
 207     final AbstractPopup popup = (AbstractPopup)myStack.pop();
 208     if (popup != null && popup.isVisible()){
 209       popup.cancel();
 210       return true;
 211     }
 212     return false;
 213   }
 214
 215   public boolean isPopupFocused() {
 216     return getFocusedPopup() != null;
 217   }
 218
 219   private JBPopup getFocusedPopup() {
 220     for (JBPopup each : myAllPopups) {
 221       if (each != null && each.isFocused()) return each;
 222     }
 223     return null;
 224   }
 225 }