platform/platform-impl/src/com/intellij/ide/IdeEventQueue.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
  19 import com.intellij.Patches;
  20 import com.intellij.concurrency.JobSchedulerImpl;
  21 import com.intellij.ide.dnd.DnDManager;
  22 import com.intellij.ide.dnd.DnDManagerImpl;
  23 import com.intellij.openapi.Disposable;
  24 import com.intellij.openapi.application.Application;
  25 import com.intellij.openapi.application.ApplicationManager;
  26 import com.intellij.openapi.application.ModalityState;
  27 import com.intellij.openapi.application.impl.ApplicationImpl;
  28 import com.intellij.openapi.diagnostic.Logger;
  29 import com.intellij.openapi.keymap.impl.IdeKeyEventDispatcher;
  30 import com.intellij.openapi.keymap.impl.IdeMouseEventDispatcher;
  31 import com.intellij.openapi.progress.ProcessCanceledException;
  32 import com.intellij.openapi.util.Condition;
  33 import com.intellij.openapi.util.Disposer;
  34 import com.intellij.openapi.util.SystemInfo;
  35 import com.intellij.openapi.util.registry.Registry;
  36 import com.intellij.openapi.wm.IdeFocusManager;
  37 import com.intellij.openapi.wm.ex.WindowManagerEx;
  38 import com.intellij.util.Alarm;
  39 import com.intellij.util.ReflectionUtil;
  40 import com.intellij.util.containers.ContainerUtil;
  41 import com.intellij.util.containers.HashMap;
  42 import org.jetbrains.annotations.NotNull;
  43
  44 import javax.swing.*;
  45 import java.awt.*;
  46 import java.awt.event.*;
  47 import java.beans.PropertyChangeEvent;
  48 import java.beans.PropertyChangeListener;
  49 import java.lang.reflect.Field;
  50 import java.lang.reflect.Method;
  51 import java.util.*;
  52
  53
  54 /**
  55  * @author Vladimir Kondratyev
  56  * @author Anton Katilin
  57  */
  58
  59 public class IdeEventQueue extends EventQueue {
  60   private static final Logger LOG = Logger.getInstance("#com.intellij.ide.IdeEventQueue");
  61
  62   /**
  63    * Adding/Removing of "idle" listeners should be thread safe.
  64    */
  65   private final Object myLock = new Object();
  66
  67   private final ArrayList<Runnable> myIdleListeners = new ArrayList<Runnable>(2);
  68
  69   private final ArrayList<Runnable> myActivityListeners = new ArrayList<Runnable>(2);
  70
  71   private final Alarm myIdleRequestsAlarm = new Alarm();
  72
  73   private final Alarm myIdleTimeCounterAlarm = new Alarm(Alarm.ThreadToUse.SWING_THREAD);
  74
  75   private long myIdleTime;
  76
  77   private final Map<Runnable, MyFireIdleRequest> myListener2Request = new HashMap<Runnable, MyFireIdleRequest>();
  78   // IdleListener -> MyFireIdleRequest
  79
  80   private final IdeKeyEventDispatcher myKeyEventDispatcher = new IdeKeyEventDispatcher(this);
  81
  82   private final IdeMouseEventDispatcher myMouseEventDispatcher = new IdeMouseEventDispatcher();
  83
  84   private final IdePopupManager myPopupManager = new IdePopupManager();
  85
  86
  87   private final ToolkitBugsProcessor myToolkitBugsProcessor = new ToolkitBugsProcessor();
  88
  89   private boolean mySuspendMode;
  90
  91   /**
  92    * We exit from suspend mode when focus owner changes and no more WindowEvent.WINDOW_OPENED events
  93    * <p/>
  94    * in the queue. If WINDOW_OPENED event does exists in the queus then we restart the alarm.
  95    */
  96
  97   private Component myFocusOwner;
  98
  99   private final Runnable myExitSuspendModeRunnable = new ExitSuspendModeRunnable();
 100
 101   /**
 102    * We exit from suspend mode when this alarm is triggered and no mode WindowEvent.WINDOW_OPENED
 103    * <p/>
 104    * events in the queue. If WINDOW_OPENED event does exist then we restart the alarm.
 105    */
 106   private final Alarm mySuspendModeAlarm = new Alarm();
 107
 108   /**
 109    * Counter of processed events. It is used to assert that data context lives only inside single
 110    * <p/>
 111    * Swing event.
 112    */
 113
 114   private int myEventCount;
 115
 116
 117   private boolean myIsInInputEvent = false;
 118
 119   private AWTEvent myCurrentEvent = null;
 120
 121   private long myLastActiveTime;
 122
 123   private WindowManagerEx myWindowManager;
 124
 125
 126   private final Set<EventDispatcher> myDispatchers = new LinkedHashSet<EventDispatcher>();
 127   private final Set<EventDispatcher> myPostprocessors = new LinkedHashSet<EventDispatcher>();
 128
 129   private final Set<Runnable> myReady = new HashSet<Runnable>();
 130   private boolean myKeyboardBusy;
 131
 132   private static class IdeEventQueueHolder {
 133     private static final IdeEventQueue INSTANCE = new IdeEventQueue();
 134   }
 135
 136   public static IdeEventQueue getInstance() {
 137     return IdeEventQueueHolder.INSTANCE;
 138   }
 139
 140   private IdeEventQueue() {
 141     addIdleTimeCounterRequest();
 142     final KeyboardFocusManager keyboardFocusManager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
 143
 144     //noinspection HardCodedStringLiteral
 145     keyboardFocusManager.addPropertyChangeListener("permanentFocusOwner", new PropertyChangeListener() {
 146
 147       public void propertyChange(final PropertyChangeEvent e) {
 148         final Application application = ApplicationManager.getApplication();
 149         if (application == null) {
 150
 151           // We can get focus event before application is initialized
 152           return;
 153         }
 154         application.assertIsDispatchThread();
 155         final Window focusedWindow = keyboardFocusManager.getFocusedWindow();
 156         final Component focusOwner = keyboardFocusManager.getFocusOwner();
 157         if (mySuspendMode && focusedWindow != null && focusOwner != null && focusOwner != myFocusOwner && !(focusOwner instanceof Window)) {
 158           exitSuspendMode();
 159         }
 160       }
 161     });
 162   }
 163
 164
 165   public void setWindowManager(final WindowManagerEx windowManager) {
 166     myWindowManager = windowManager;
 167   }
 168
 169
 170   private void addIdleTimeCounterRequest() {
 171     Application application = ApplicationManager.getApplication();
 172     if (application != null && application.isUnitTestMode()) return;
 173
 174     myIdleTimeCounterAlarm.cancelAllRequests();
 175     myLastActiveTime = System.currentTimeMillis();
 176     myIdleTimeCounterAlarm.addRequest(new Runnable() {
 177       public void run() {
 178         myIdleTime += System.currentTimeMillis() - myLastActiveTime;
 179         addIdleTimeCounterRequest();
 180       }
 181     }, 20000, ModalityState.NON_MODAL);
 182   }
 183
 184
 185   public boolean shouldNotTypeInEditor() {
 186     return myKeyEventDispatcher.isWaitingForSecondKeyStroke() || mySuspendMode;
 187   }
 188
 189
 190   private void enterSuspendMode() {
 191     mySuspendMode = true;
 192     myFocusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
 193     mySuspendModeAlarm.cancelAllRequests();
 194     mySuspendModeAlarm.addRequest(myExitSuspendModeRunnable, 750);
 195   }
 196
 197
 198   /**
 199    * Exits supend mode and pumps all suspended events.
 200    */
 201
 202   private void exitSuspendMode() {
 203     if (shallEnterSuspendMode()) {
 204
 205       // We have to exit from suspend mode (focus owner changes or alarm is triggered) but
 206
 207       // WINDOW_OPENED isn't dispatched yet. In this case we have to restart the alarm until
 208
 209       // all WINDOW_OPENED event will be processed.
 210       mySuspendModeAlarm.cancelAllRequests();
 211       mySuspendModeAlarm.addRequest(myExitSuspendModeRunnable, 250);
 212     }
 213     else {
 214
 215       // Now we can pump all suspended events.
 216       mySuspendMode = false;
 217       myFocusOwner = null; // to prevent memory leaks
 218     }
 219   }
 220
 221
 222   public void addIdleListener(@NotNull final Runnable runnable, final int timeout) {
 223     LOG.assertTrue(timeout > 0);
 224     synchronized (myLock) {
 225       myIdleListeners.add(runnable);
 226       final MyFireIdleRequest request = new MyFireIdleRequest(runnable, timeout);
 227       myListener2Request.put(runnable, request);
 228       myIdleRequestsAlarm.addRequest(request, timeout);
 229     }
 230   }
 231
 232
 233   public void removeIdleListener(@NotNull final Runnable runnable) {
 234     synchronized (myLock) {
 235       final boolean wasRemoved = myIdleListeners.remove(runnable);
 236       if (!wasRemoved) {
 237         LOG.assertTrue(false, "unknown runnable: " + runnable);
 238       }
 239       final MyFireIdleRequest request = myListener2Request.remove(runnable);
 240       LOG.assertTrue(request != null);
 241       myIdleRequestsAlarm.cancelRequest(request);
 242     }
 243   }
 244
 245
 246   public void addActivityListener(@NotNull final Runnable runnable) {
 247     synchronized (myLock) {
 248       myActivityListeners.add(runnable);
 249     }
 250   }
 251
 252   public void addActivityListener(@NotNull final Runnable runnable, Disposable parentDisposable) {
 253     synchronized (myLock) {
 254       ContainerUtil.add(runnable, myActivityListeners, parentDisposable);
 255     }
 256   }
 257
 258
 259   public void removeActivityListener(@NotNull final Runnable runnable) {
 260     synchronized (myLock) {
 261       final boolean wasRemoved = myActivityListeners.remove(runnable);
 262       if (!wasRemoved) {
 263         LOG.assertTrue(false, "unknown runnable: " + runnable);
 264       }
 265     }
 266   }
 267
 268
 269   public void addDispatcher(final EventDispatcher dispatcher, Disposable parent) {
 270     _addProcessor(dispatcher, parent, myDispatchers);
 271   }
 272
 273   public void removeDispatcher(EventDispatcher dispatcher) {
 274     myDispatchers.remove(dispatcher);
 275   }
 276
 277   public boolean containsDispatcher(EventDispatcher dispatcher) {
 278     return myDispatchers.contains(dispatcher);
 279   }
 280
 281   public void addPostprocessor(EventDispatcher dispatcher, Disposable parent) {
 282     _addProcessor(dispatcher, parent, myPostprocessors);
 283   }
 284
 285   public void removePostprocessor(EventDispatcher dispatcher) {
 286     myPostprocessors.remove(dispatcher);
 287   }
 288
 289   private void _addProcessor(final EventDispatcher dispatcher, Disposable parent, Set<EventDispatcher> set) {
 290     set.add(dispatcher);
 291     if (parent != null) {
 292       Disposer.register(parent, new Disposable() {
 293         public void dispose() {
 294           removeDispatcher(dispatcher);
 295         }
 296       });
 297     }
 298   }
 299
 300   public int getEventCount() {
 301     return myEventCount;
 302   }
 303
 304
 305   public void setEventCount(int evCount) {
 306     myEventCount = evCount;
 307   }
 308
 309
 310   public AWTEvent getTrueCurrentEvent() {
 311     return myCurrentEvent;
 312   }
 313
 314   //[jeka] commented for performance reasons
 315
 316   /*
 317
 318   public void postEvent(final AWTEvent e) {
 319
 320     // [vova] sometime people call SwingUtilities.invokeLater(null). To
 321
 322     // find such situations we will specially check InvokationEvents
 323
 324     try {
 325
 326       if (e instanceof InvocationEvent) {
 327
 328         //noinspection HardCodedStringLiteral
 329
 330         final Field field = InvocationEvent.class.getDeclaredField("runnable");
 331
 332         field.setAccessible(true);
 333
 334         final Object runnable = field.get(e);
 335
 336         if (runnable == null) {
 337
 338           //noinspection HardCodedStringLiteral
 339
 340           throw new IllegalStateException("InvocationEvent contains null runnable: " + e);
 341
 342         }
 343
 344       }
 345
 346     }
 347
 348     catch (final Exception exc) {
 349
 350       throw new Error(exc);
 351
 352     }
 353
 354     super.postEvent(e);
 355
 356   }
 357
 358   */
 359
 360   public void dispatchEvent(final AWTEvent e) {
 361     boolean wasInputEvent = myIsInInputEvent;
 362     myIsInInputEvent = e instanceof InputEvent || e instanceof InputMethodEvent || e instanceof WindowEvent || e instanceof ActionEvent;
 363     AWTEvent oldEvent = myCurrentEvent;
 364     myCurrentEvent = e;
 365
 366     JobSchedulerImpl.suspend();
 367     try {
 368       _dispatchEvent(e);
 369     }
 370     finally {
 371       myIsInInputEvent = wasInputEvent;
 372       myCurrentEvent = oldEvent;
 373       JobSchedulerImpl.resume();
 374
 375       for (EventDispatcher each : myPostprocessors) {
 376         each.dispatch(e);
 377       }
 378
 379       if (e instanceof KeyEvent) {
 380         maybeReady();
 381       }
 382     }
 383   }
 384
 385   @SuppressWarnings({"ALL"})
 386   private static String toDebugString(final AWTEvent e) {
 387     if (e instanceof InvocationEvent) {
 388       try {
 389         final Field f = InvocationEvent.class.getDeclaredField("runnable");
 390         f.setAccessible(true);
 391         Object runnable = f.get(e);
 392
 393         return "Invoke Later[" + runnable.toString() + "]";
 394       }
 395       catch (NoSuchFieldException e1) {
 396       }
 397       catch (IllegalAccessException e1) {
 398       }
 399     }
 400     return e.toString();
 401   }
 402
 403
 404   private void _dispatchEvent(final AWTEvent e) {
 405     if (e.getID() == MouseEvent.MOUSE_DRAGGED) {
 406       DnDManagerImpl dndManager = (DnDManagerImpl)DnDManager.getInstance();
 407       if (dndManager != null) {
 408         dndManager.setLastDropHandler(null);
 409       }
 410     }
 411
 412
 413     myEventCount++;
 414
 415
 416     if (processAppActivationEvents(e)) return;
 417
 418     fixStickyFocusedComponents(e);
 419
 420     if (!myPopupManager.isPopupActive()) {
 421       enterSuspendModeIfNeeded(e);
 422     }
 423
 424     if (e instanceof KeyEvent) {
 425       myKeyboardBusy = e.getID() != KeyEvent.KEY_RELEASED || ((KeyEvent)e).getModifiers() != 0;
 426     }
 427
 428     if (typeAheadDispatchToFocusManager(e)) return;
 429
 430     if (e instanceof WindowEvent) {
 431       ActivityTracker.getInstance().inc();
 432     }
 433
 434
 435     // Process "idle" and "activity" listeners
 436     if (e instanceof KeyEvent || e instanceof MouseEvent) {
 437       ActivityTracker.getInstance().inc();
 438
 439       synchronized (myLock) {
 440         myIdleRequestsAlarm.cancelAllRequests();
 441         for (Runnable idleListener : myIdleListeners) {
 442           final MyFireIdleRequest request = myListener2Request.get(idleListener);
 443           if (request == null) {
 444             LOG.error("There is no request for " + idleListener);
 445           }
 446           int timeout = request.getTimeout();
 447           myIdleRequestsAlarm.addRequest(request, timeout, ModalityState.NON_MODAL);
 448         }
 449         if (KeyEvent.KEY_PRESSED == e.getID() ||
 450             KeyEvent.KEY_TYPED == e.getID() ||
 451             MouseEvent.MOUSE_PRESSED == e.getID() ||
 452             MouseEvent.MOUSE_RELEASED == e.getID() ||
 453             MouseEvent.MOUSE_CLICKED == e.getID()) {
 454           addIdleTimeCounterRequest();
 455           for (Runnable activityListener : myActivityListeners) {
 456             activityListener.run();
 457           }
 458         }
 459       }
 460     }
 461     if (myPopupManager.isPopupActive() && myPopupManager.dispatch(e)) {
 462       return;
 463     }
 464
 465     for (EventDispatcher eachDispatcher : myDispatchers) {
 466       if (eachDispatcher.dispatch(e)) {
 467         return;
 468       }
 469     }
 470
 471     if (e instanceof InputMethodEvent) {
 472       if (SystemInfo.isMac && myKeyEventDispatcher.isWaitingForSecondKeyStroke()) {
 473         return;
 474       }
 475     }
 476     if (e instanceof InputEvent && Patches.SPECIAL_WINPUT_METHOD_PROCESSING) {
 477       final InputEvent inputEvent = (InputEvent)e;
 478       if (!inputEvent.getComponent().isShowing()) {
 479         return;
 480       }
 481     }
 482     if (e instanceof ComponentEvent && myWindowManager != null) {
 483       myWindowManager.dispatchComponentEvent((ComponentEvent)e);
 484     }
 485     if (e instanceof KeyEvent) {
 486       if (mySuspendMode || !myKeyEventDispatcher.dispatchKeyEvent((KeyEvent)e)) {
 487         defaultDispatchEvent(e);
 488       }
 489       else {
 490         ((KeyEvent)e).consume();
 491         defaultDispatchEvent(e);
 492       }
 493     }
 494     else if (e instanceof MouseEvent) {
 495       if (!myMouseEventDispatcher.dispatchMouseEvent((MouseEvent)e)) {
 496         defaultDispatchEvent(e);
 497       }
 498     }
 499     else {
 500       defaultDispatchEvent(e);
 501     }
 502   }
 503
 504   private static void fixStickyWindow(KeyboardFocusManager mgr, Window wnd, String resetMethod) {
 505     Window showingWindow = wnd;
 506
 507     if (wnd != null && !wnd.isShowing()) {
 508       while (showingWindow != null) {
 509         if (showingWindow.isShowing()) break;
 510         showingWindow = (Window)showingWindow.getParent();
 511       }
 512
 513       if (showingWindow == null) {
 514         final Frame[] allFrames = Frame.getFrames();
 515         for (Frame each : allFrames) {
 516           if (each.isShowing()) {
 517             showingWindow = each;
 518             break;
 519           }
 520         }
 521       }
 522
 523
 524       if (showingWindow != null && showingWindow != wnd) {
 525         final Method setActive =
 526           ReflectionUtil.findMethod(KeyboardFocusManager.class.getDeclaredMethods(), resetMethod, Window.class);
 527         if (setActive != null) {
 528           try {
 529             setActive.setAccessible(true);
 530             setActive.invoke(mgr, (Window)showingWindow);
 531           }
 532           catch (Exception exc) {
 533             LOG.info(exc);
 534           }
 535         }
 536       }
 537     }
 538   }
 539
 540   private static void fixStickyFocusedComponents(AWTEvent e) {
 541     if (!(e instanceof InputEvent)) return;
 542
 543     final KeyboardFocusManager mgr = KeyboardFocusManager.getCurrentKeyboardFocusManager();
 544
 545     if (Registry.is("actionSystem.fixStickyFocusedWindows")) {
 546       fixStickyWindow(mgr, mgr.getActiveWindow(), "setGlobalActiveWindow");
 547       fixStickyWindow(mgr, mgr.getFocusedWindow(), "setGlobalFocusedWindow");
 548     }
 549
 550     if (Registry.is("actionSystem.fixNullFocusedComponent")) {
 551       final Component focusOwner = mgr.getFocusOwner();
 552       if (focusOwner == null) {
 553         Window showingWindow = mgr.getActiveWindow();
 554         if (showingWindow != null) {
 555           final IdeFocusManager fm = IdeFocusManager.findInstanceByComponent(showingWindow);
 556           fm.doWhenFocusSettlesDown(new Runnable() {
 557             public void run() {
 558               if (mgr.getFocusOwner() == null) {
 559                 final Application app = ApplicationManager.getApplication();
 560                 if (app != null && app.isActive()) {
 561                   fm.requestDefaultFocus(false);
 562                 }
 563               }
 564             }
 565           });
 566         }
 567       }
 568     }
 569   }
 570
 571   private void enterSuspendModeIfNeeded(AWTEvent e) {
 572     if (e instanceof KeyEvent) {
 573       if (!mySuspendMode && shallEnterSuspendMode()) {
 574         enterSuspendMode();
 575       }
 576     }
 577   }
 578
 579   private boolean shallEnterSuspendMode() {
 580     return peekEvent(WindowEvent.WINDOW_OPENED) != null;
 581   }
 582
 583   private static boolean processAppActivationEvents(AWTEvent e) {
 584     final Application app = ApplicationManager.getApplication();
 585     if (!(app instanceof ApplicationImpl)) return false;
 586
 587     ApplicationImpl appImpl = (ApplicationImpl)app;
 588
 589     boolean consumed = false;
 590     if (e instanceof WindowEvent) {
 591       WindowEvent we = (WindowEvent)e;
 592       if (we.getID() == WindowEvent.WINDOW_GAINED_FOCUS && we.getWindow() != null) {
 593         if (we.getOppositeWindow() == null && !appImpl.isActive()) {
 594           consumed = appImpl.tryToApplyActivationState(true, we.getWindow());
 595         }
 596       }
 597       else if (we.getID() == WindowEvent.WINDOW_LOST_FOCUS && we.getWindow() != null) {
 598         if (we.getOppositeWindow() == null && appImpl.isActive()) {
 599           consumed = appImpl.tryToApplyActivationState(false, we.getWindow());
 600         }
 601       }
 602     }
 603
 604     return false;
 605   }
 606
 607
 608   private void defaultDispatchEvent(final AWTEvent e) {
 609     try {
 610       super.dispatchEvent(e);
 611     }
 612     catch (ProcessCanceledException pce) {
 613       throw pce;
 614     }
 615     catch (Throwable exc) {
 616       if (!myToolkitBugsProcessor.process(exc)) {
 617         LOG.error("Error during dispatching of " + e, exc);
 618       }
 619     }
 620   }
 621
 622   private static boolean typeAheadDispatchToFocusManager(AWTEvent e) {
 623     if (e instanceof KeyEvent) {
 624       final KeyEvent event = (KeyEvent)e;
 625       if (!event.isConsumed()) {
 626         final IdeFocusManager focusManager = IdeFocusManager.findInstanceByComponent(event.getComponent());
 627         return focusManager.dispatch(event);
 628       }
 629     }
 630
 631     return false;
 632   }
 633
 634
 635   public void flushQueue() {
 636     while (true) {
 637       AWTEvent event = peekEvent();
 638       if (event == null) return;
 639       try {
 640         AWTEvent event1 = getNextEvent();
 641         dispatchEvent(event1);
 642       }
 643       catch (Exception e) {
 644         LOG.error(e); //?
 645       }
 646     }
 647   }
 648
 649   public void pumpEventsForHierarchy(Component modalComponent, Condition<AWTEvent> exitCondition) {
 650     AWTEvent event;
 651     do {
 652       try {
 653         event = getNextEvent();
 654         boolean eventOk = true;
 655         if (event instanceof InputEvent) {
 656           final Object s = event.getSource();
 657           if (s instanceof Component) {
 658             Component c = (Component)s;
 659             Window modalWindow = SwingUtilities.windowForComponent(modalComponent);
 660             while (c != null && c != modalWindow) c = c.getParent();
 661             if (c == null) {
 662               eventOk = false;
 663               ((InputEvent)event).consume();
 664             }
 665           }
 666         }
 667
 668         if (eventOk) {
 669           dispatchEvent(event);
 670         }
 671       }
 672       catch (Throwable e) {
 673         LOG.error(e);
 674         event = null;
 675       }
 676     }
 677     while (!exitCondition.value(event));
 678   }
 679
 680
 681   public interface EventDispatcher {
 682     boolean dispatch(AWTEvent e);
 683   }
 684
 685
 686   private final class MyFireIdleRequest implements Runnable {
 687     private final Runnable myRunnable;
 688     private final int myTimeout;
 689
 690
 691     public MyFireIdleRequest(final Runnable runnable, final int timeout) {
 692       myTimeout = timeout;
 693       myRunnable = runnable;
 694     }
 695
 696
 697     public void run() {
 698       myRunnable.run();
 699       synchronized (myLock) {
 700         myIdleRequestsAlarm.addRequest(this, myTimeout, ModalityState.NON_MODAL);
 701       }
 702     }
 703
 704     public int getTimeout() {
 705       return myTimeout;
 706     }
 707   }
 708
 709
 710   private final class ExitSuspendModeRunnable implements Runnable {
 711
 712     public void run() {
 713       if (mySuspendMode) {
 714         exitSuspendMode();
 715       }
 716     }
 717   }
 718
 719
 720   public long getIdleTime() {
 721     return myIdleTime;
 722   }
 723
 724
 725   public IdePopupManager getPopupManager() {
 726     return myPopupManager;
 727   }
 728
 729   public IdeKeyEventDispatcher getKeyEventDispatcher() {
 730     return myKeyEventDispatcher;
 731   }
 732
 733   public void blockNextEvents(final MouseEvent e) {
 734     myMouseEventDispatcher.blockNextEvents(e);
 735   }
 736
 737   public boolean isSuspendMode() {
 738     return mySuspendMode;
 739   }
 740
 741   public boolean hasFocusEventsPending() {
 742     return peekEvent(FocusEvent.FOCUS_GAINED) != null || peekEvent(FocusEvent.FOCUS_LOST) != null;
 743   }
 744
 745   private boolean isReady() {
 746     return !myKeyboardBusy && myKeyEventDispatcher.isReady();
 747   }
 748
 749   public void maybeReady() {
 750     flushReady();
 751   }
 752
 753   private void flushReady() {
 754     if (myReady.isEmpty() || !isReady()) return;
 755
 756     Runnable[] ready = myReady.toArray(new Runnable[myReady.size()]);
 757     myReady.clear();
 758
 759     for (Runnable each : ready) {
 760       each.run();
 761     }
 762   }
 763
 764   public void doWhenReady(final Runnable runnable) {
 765     if (EventQueue.isDispatchThread()) {
 766       myReady.add(runnable);
 767       maybeReady();
 768     } else {
 769       SwingUtilities.invokeLater(new Runnable() {
 770         public void run() {
 771           myReady.add(runnable);
 772           maybeReady();
 773         }
 774       });
 775     }
 776   }
 777 }