focus stealing issue: isActive() is more accurate + removed direct call to requestFoc...
[idea/community.git] / platform / platform-impl / src / com / intellij / openapi / application / impl / ApplicationImpl.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.openapi.application.impl;
17
18 import com.intellij.CommonBundle;
19 import com.intellij.Patches;
20 import com.intellij.diagnostic.PluginException;
21 import com.intellij.ide.ActivityTracker;
22 import com.intellij.ide.ApplicationLoadListener;
23 import com.intellij.ide.IdeEventQueue;
24 import com.intellij.ide.IdeRepaintManager;
25 import com.intellij.ide.impl.ProjectUtil;
26 import com.intellij.ide.plugins.IdeaPluginDescriptor;
27 import com.intellij.ide.plugins.PluginManager;
28 import com.intellij.openapi.Disposable;
29 import com.intellij.openapi.application.*;
30 import com.intellij.openapi.application.ex.ApplicationEx;
31 import com.intellij.openapi.application.ex.ApplicationManagerEx;
32 import com.intellij.openapi.command.CommandProcessor;
33 import com.intellij.openapi.components.RoamingType;
34 import com.intellij.openapi.components.StateStorage;
35 import com.intellij.openapi.components.impl.ApplicationPathMacroManager;
36 import com.intellij.openapi.components.impl.ComponentManagerImpl;
37 import com.intellij.openapi.components.impl.stores.*;
38 import com.intellij.openapi.diagnostic.Logger;
39 import com.intellij.openapi.extensions.ExtensionPoint;
40 import com.intellij.openapi.extensions.ExtensionPointName;
41 import com.intellij.openapi.extensions.Extensions;
42 import com.intellij.openapi.extensions.PluginId;
43 import com.intellij.openapi.fileEditor.FileDocumentManager;
44 import com.intellij.openapi.progress.EmptyProgressIndicator;
45 import com.intellij.openapi.progress.ProcessCanceledException;
46 import com.intellij.openapi.progress.ProgressIndicator;
47 import com.intellij.openapi.progress.ProgressManager;
48 import com.intellij.openapi.progress.util.ProgressWindow;
49 import com.intellij.openapi.project.Project;
50 import com.intellij.openapi.project.ProjectManager;
51 import com.intellij.openapi.project.ex.ProjectEx;
52 import com.intellij.openapi.project.ex.ProjectManagerEx;
53 import com.intellij.openapi.ui.Messages;
54 import com.intellij.openapi.util.*;
55 import com.intellij.openapi.wm.IdeFrame;
56 import com.intellij.openapi.wm.ex.ProgressIndicatorEx;
57 import com.intellij.psi.PsiLock;
58 import com.intellij.util.ConcurrencyUtil;
59 import com.intellij.util.EventDispatcher;
60 import com.intellij.util.ReflectionCache;
61 import com.intellij.util.concurrency.ReentrantWriterPreferenceReadWriteLock;
62 import com.intellij.util.containers.Stack;
63 import com.intellij.util.ui.UIUtil;
64 import org.jetbrains.annotations.NonNls;
65 import org.jetbrains.annotations.NotNull;
66 import org.jetbrains.annotations.Nullable;
67 import org.picocontainer.MutablePicoContainer;
68
69 import javax.swing.*;
70 import java.awt.*;
71 import java.io.IOException;
72 import java.lang.reflect.InvocationTargetException;
73 import java.lang.reflect.Method;
74 import java.util.ArrayList;
75 import java.util.Collection;
76 import java.util.List;
77 import java.util.concurrent.*;
78 import java.util.concurrent.atomic.AtomicBoolean;
79
80 @SuppressWarnings({"AssignmentToStaticFieldFromInstanceMethod"})
81 public class ApplicationImpl extends ComponentManagerImpl implements ApplicationEx {
82   private static final Logger LOG = Logger.getInstance("#com.intellij.application.impl.ApplicationImpl");
83   private final ModalityState MODALITY_STATE_NONE = ModalityState.NON_MODAL;
84   private final ModalityInvokator myInvokator = new ModalityInvokatorImpl();
85
86   private final EventDispatcher<ApplicationListener> myDispatcher = EventDispatcher.create(ApplicationListener.class);
87
88   private boolean myTestModeFlag = false;
89   private boolean myHeadlessMode = false;
90   private boolean myCommandLineMode = false;
91
92   private boolean myIsInternal = false;
93   private final String myName;
94
95   private final ReentrantWriterPreferenceReadWriteLock myActionsLock = new ReentrantWriterPreferenceReadWriteLock();
96   private final Stack<Runnable> myWriteActionsStack = new Stack<Runnable>();
97
98   private volatile Runnable myExceptionalThreadWithReadAccessRunnable;
99
100   private int myInEditorPaintCounter = 0;
101   private long myStartTime = 0;
102   private boolean myDoNotSave = false;
103   private volatile boolean myDisposeInProgress = false;
104
105   private final AtomicBoolean mySaveSettingsIsInProgress = new AtomicBoolean(false);
106
107   private final ExecutorService ourThreadExecutorsService = new ThreadPoolExecutor(
108     3,
109     Integer.MAX_VALUE,
110     30 * 60L,
111     TimeUnit.SECONDS,
112     new SynchronousQueue<Runnable>(),
113     new ThreadFactory() {
114       public Thread newThread(Runnable r) {
115         final Thread thread = new Thread(r, "ApplicationImpl pooled thread") {
116           public void interrupt() {
117             if (LOG.isDebugEnabled()) {
118               LOG.debug("Interrupted worker, will remove from pool");
119             }
120             super.interrupt();
121           }
122
123           public void run() {
124             try {
125               super.run();
126             }
127             catch (Throwable t) {
128               if (LOG.isDebugEnabled()) {
129                 LOG.debug("Worker exits due to exception", t);
130               }
131             }
132           }
133         };
134         thread.setPriority(Thread.NORM_PRIORITY - 1);
135         return thread;
136       }
137     }
138   );
139   private boolean myIsFiringLoadingEvent = false;
140   @NonNls private static final String WAS_EVER_SHOWN = "was.ever.shown";
141
142   private Boolean myActive;
143
144   protected void boostrapPicoContainer() {
145     super.boostrapPicoContainer();
146     getPicoContainer().registerComponentImplementation(IComponentStore.class, StoresFactory.getApplicationStoreClass());
147     getPicoContainer().registerComponentImplementation(ApplicationPathMacroManager.class);
148   }
149
150   @Override
151   @NotNull
152   public synchronized IApplicationStore getStateStore() {
153     return (IApplicationStore)super.getStateStore();
154   }
155
156   public ApplicationImpl(boolean isInternal, boolean isUnitTestMode, boolean isHeadless, boolean isCommandLine, String appName) {
157     super(null);
158
159     getPicoContainer().registerComponentInstance(Application.class, this);
160
161     CommonBundle.assertKeyIsFound = isUnitTestMode;
162
163     if ((isInternal || isUnitTestMode) && !Comparing.equal("off", System.getProperty("idea.disposer.debug"))) {
164       Disposer.setDebugMode(true);
165     }
166     myStartTime = System.currentTimeMillis();
167     myName = appName;
168     ApplicationManagerEx.setApplication(this);
169
170     PluginsFacade.INSTANCE = new PluginsFacade() {
171       public IdeaPluginDescriptor getPlugin(PluginId id) {
172         return PluginManager.getPlugin(id);
173       }
174
175       public IdeaPluginDescriptor[] getPlugins() {
176         return PluginManager.getPlugins();
177       }
178     };
179
180     if (!isUnitTestMode && !isHeadless) {
181       Toolkit.getDefaultToolkit().getSystemEventQueue().push(IdeEventQueue.getInstance());
182       if (Patches.SUN_BUG_ID_6209673) {
183         RepaintManager.setCurrentManager(new IdeRepaintManager());
184       }
185       IconLoader.activate();
186     }
187
188     myIsInternal = isInternal;
189     myTestModeFlag = isUnitTestMode;
190     myHeadlessMode = isHeadless;
191     myCommandLineMode = isCommandLine;
192
193     loadApplicationComponents();
194
195     if (myTestModeFlag) {
196       registerShutdownHook();
197     }
198
199     if (!isUnitTestMode && !isHeadless) {
200       Disposer.register(this, Disposer.newDisposable(), "ui");
201     }
202   }
203
204   private void registerShutdownHook() {
205     ShutDownTracker.getInstance(); // Necessary to avoid creating an instance while already shutting down.
206
207     ShutDownTracker.getInstance().registerShutdownTask(new Runnable() {
208       public void run() {
209         if (isDisposed() || isDisposeInProgress()) return;
210         try {
211           SwingUtilities.invokeAndWait(new Runnable() {
212             public void run() {
213               ApplicationManagerEx.setApplication(ApplicationImpl.this);
214               saveAll();
215               disposeSelf();
216             }
217           });
218         }
219         catch (InterruptedException e) {
220           LOG.error(e);
221         }
222         catch (InvocationTargetException e) {
223           LOG.error(e);
224         }
225       }
226     });
227   }
228
229   private boolean disposeSelf() {
230     Project[] openProjects = ProjectManagerEx.getInstanceEx().getOpenProjects();
231     final boolean[] canClose = {true};
232     for (final Project project : openProjects) {
233       CommandProcessor commandProcessor = CommandProcessor.getInstance();
234       commandProcessor.executeCommand(project, new Runnable() {
235         public void run() {
236           canClose[0] = ProjectUtil.closeProject(project);
237         }
238       }, ApplicationBundle.message("command.exit"), null);
239       if (!canClose[0]) return false;
240     }
241     myDisposeInProgress = true;
242     Disposer.dispose(this);
243
244     Disposer.assertIsEmpty();
245     return true;
246   }
247
248   public String getName() {
249     return myName;
250   }
251
252   public boolean holdsReadLock() {
253     return myActionsLock.isReadLockAcquired();
254   }
255
256   @Override
257   protected void handleInitComponentError(final Throwable ex, final boolean fatal, final String componentClassName) {
258     if (PluginManager.isPluginClass(componentClassName)) {
259       LOG.error(ex);
260       PluginId pluginId = PluginManager.getPluginByClassName(componentClassName);
261       @NonNls final String errorMessage = "Plugin " + pluginId.getIdString() + " failed to initialize and will be disabled:\n" + ex.getMessage() +
262                                           "\nPlease restart " + ApplicationNamesInfo.getInstance().getFullProductName() + ".";
263       PluginManager.disablePlugin(pluginId.getIdString());
264       if (!myHeadlessMode) {
265         JOptionPane.showMessageDialog(null, errorMessage);
266       }
267       else {
268         //noinspection UseOfSystemOutOrSystemErr
269         System.out.println(errorMessage);
270       }
271       System.exit(1);
272     }
273     else if (fatal) {
274       LOG.error(ex);
275       @NonNls final String errorMessage = "Fatal error initializing class " + componentClassName + ":\n" +
276                                           ex.toString() +
277                                           "\nComplete error stacktrace was written to idea.log";
278       if (!myHeadlessMode) {
279         JOptionPane.showMessageDialog(null, errorMessage);
280       }
281       else {
282         //noinspection UseOfSystemOutOrSystemErr
283         System.out.println(errorMessage);
284       }
285     }
286     super.handleInitComponentError(ex, fatal, componentClassName);
287   }
288
289   private void loadApplicationComponents() {
290     final IdeaPluginDescriptor[] plugins = PluginManager.getPlugins();
291     for (IdeaPluginDescriptor plugin : plugins) {
292       if (PluginManager.shouldSkipPlugin(plugin)) continue;
293       loadComponentsConfiguration(plugin.getAppComponents(), plugin, false);
294     }
295   }
296
297   protected MutablePicoContainer createPicoContainer() {
298     return Extensions.getRootArea().getPicoContainer();
299   }
300
301   public boolean isInternal() {
302     return myIsInternal;
303   }
304
305   public boolean isUnitTestMode() {
306     return myTestModeFlag;
307   }
308
309   public boolean isHeadlessEnvironment() {
310     return myHeadlessMode;
311   }
312
313   public boolean isCommandLine() {
314     return myCommandLineMode;
315   }
316
317   public IdeaPluginDescriptor getPlugin(PluginId id) {
318     return PluginsFacade.INSTANCE.getPlugin(id);
319   }
320
321   public IdeaPluginDescriptor[] getPlugins() {
322     return PluginsFacade.INSTANCE.getPlugins();
323   }
324
325   public Future<?> executeOnPooledThread(final Runnable action) {
326     return ourThreadExecutorsService.submit(new Runnable() {
327       public void run() {
328         try {
329           action.run();
330         }
331         catch (Throwable t) {
332           LOG.error(t);
333         }
334         finally {
335           Thread.interrupted(); // reset interrupted status
336         }
337       }
338     });
339   }
340
341   private static Thread ourDispatchThread = null;
342
343   public boolean isDispatchThread() {
344     return EventQueue.isDispatchThread();
345   }
346
347   @NotNull
348   public ModalityInvokator getInvokator() {
349     return myInvokator;
350   }
351
352
353   public void invokeLater(final Runnable runnable) {
354     myInvokator.invokeLater(runnable);
355   }
356
357   public void invokeLater(final Runnable runnable, @NotNull final Condition expired) {
358     myInvokator.invokeLater(runnable, expired);
359   }
360
361   public void invokeLater(final Runnable runnable, @NotNull final ModalityState state) {
362     myInvokator.invokeLater(runnable, state);
363   }
364
365   public void invokeLater(final Runnable runnable, @NotNull final ModalityState state, @NotNull final Condition expired) {
366     myInvokator.invokeLater(runnable, state, expired);
367   }
368
369   public void load(String path) throws IOException, InvalidDataException {
370     getStateStore().setOptionsPath(path);
371     getStateStore().setConfigPath(PathManager.getConfigPath());
372     myIsFiringLoadingEvent = true;
373     try {
374       fireBeforeApplicationLoaded();
375     }
376     finally {
377       myIsFiringLoadingEvent = false;
378     }
379
380     loadComponentRoamingTypes();
381
382     try {
383       getStateStore().load();
384     }
385     catch (StateStorage.StateStorageException e) {
386       throw new IOException(e.getMessage());
387     }
388
389   }
390
391   @Override
392   protected <T> T getComponentFromContainer(final Class<T> interfaceClass) {
393     if (myIsFiringLoadingEvent) {
394       return null;
395     }
396     return super.getComponentFromContainer(interfaceClass);
397   }
398
399   private static void loadComponentRoamingTypes() {
400     ExtensionPoint<RoamingTypeExtensionPointBean> point = Extensions.getRootArea().getExtensionPoint("com.intellij.ComponentRoamingType");
401     final RoamingTypeExtensionPointBean[] componentRoamingTypes = point.getExtensions();
402
403     for (RoamingTypeExtensionPointBean object : componentRoamingTypes) {
404
405       assert object.componentName != null;
406       assert object.roamingType != null;
407
408       final RoamingType type = RoamingType.valueOf(object.roamingType);
409
410       assert type != null;
411
412       ComponentRoamingManager.getInstance().setRoamingType(object.componentName, type);
413     }
414   }
415
416   private void fireBeforeApplicationLoaded() {
417     ExtensionPoint<ApplicationLoadListener> point = Extensions.getRootArea().getExtensionPoint("com.intellij.ApplicationLoadListener");
418     final ApplicationLoadListener[] objects = point.getExtensions();
419     for (ApplicationLoadListener object : objects) {
420       object.beforeApplicationLoaded(this);
421     }
422   }
423
424
425   public void dispose() {
426     fireApplicationExiting();
427     disposeComponents();
428
429     ourThreadExecutorsService.shutdownNow();
430     super.dispose();
431   }
432
433   private final Object lock = new Object();
434   private void makeChangesVisibleToEDT() {
435     synchronized (lock) {
436       lock.hashCode();
437     }
438   }
439
440   public boolean runProcessWithProgressSynchronously(final Runnable process, String progressTitle, boolean canBeCanceled, Project project) {
441     return runProcessWithProgressSynchronously(process, progressTitle, canBeCanceled, project, null);
442   }
443
444   public boolean runProcessWithProgressSynchronously(final Runnable process, final String progressTitle, final boolean canBeCanceled, @Nullable final Project project,
445                                                      final JComponent parentComponent) {
446     return runProcessWithProgressSynchronously(process, progressTitle, canBeCanceled, project, parentComponent, null);
447   }
448
449   public boolean runProcessWithProgressSynchronously(final Runnable process, final String progressTitle, final boolean canBeCanceled, @Nullable final Project project,
450                                                        final JComponent parentComponent, final String cancelText) {
451     assertIsDispatchThread();
452
453     if (myExceptionalThreadWithReadAccessRunnable != null ||
454         ApplicationManager.getApplication().isUnitTestMode() ||
455         ApplicationManager.getApplication().isHeadlessEnvironment()) {
456       try {
457         ProgressManager.getInstance().runProcess(process, new EmptyProgressIndicator());
458       }
459       catch (ProcessCanceledException e) {
460         // ok to ignore.
461         return false;
462       }
463       return true;
464     }
465
466     final ProgressWindow progress = new ProgressWindow(canBeCanceled, false, project, parentComponent, cancelText);
467     progress.setTitle(progressTitle);
468
469     try {
470       myExceptionalThreadWithReadAccessRunnable = process;
471       final boolean[] threadStarted = {false};
472       SwingUtilities.invokeLater(new Runnable() {
473         public void run() {
474           if (myExceptionalThreadWithReadAccessRunnable != process) {
475               LOG.error("myExceptionalThreadWithReadAccessRunnable != process, process = " + myExceptionalThreadWithReadAccessRunnable);
476           }
477
478           executeOnPooledThread(new Runnable() {
479             public void run() {
480               if (myExceptionalThreadWithReadAccessRunnable != process) {
481                 LOG.error("myExceptionalThreadWithReadAccessRunnable != process, process = " + myExceptionalThreadWithReadAccessRunnable);
482               }
483
484               final boolean old = setExceptionalThreadWithReadAccessFlag(true);
485               LOG.assertTrue(isReadAccessAllowed());
486               try {
487                 ProgressManager.getInstance().runProcess(process, progress);
488               }
489               catch (ProcessCanceledException e) {
490                 progress.cancel();
491                 // ok to ignore.
492               }
493               finally {
494                 setExceptionalThreadWithReadAccessFlag(old);
495                 makeChangesVisibleToEDT();
496               }
497             }
498           });
499           threadStarted[0] = true;
500         }
501       });
502
503       progress.startBlocking();
504
505       LOG.assertTrue(threadStarted[0]);
506       LOG.assertTrue(!progress.isRunning());
507     }
508     finally {
509       myExceptionalThreadWithReadAccessRunnable = null;
510       makeChangesVisibleToEDT();
511     }
512
513     return !progress.isCanceled();
514   }
515
516   public boolean isInModalProgressThread() {
517     if (myExceptionalThreadWithReadAccessRunnable == null || !isExceptionalThreadWithReadAccess()) {
518       return false;
519     }
520     ProgressIndicator progressIndicator = ProgressManager.getInstance().getProgressIndicator();
521     return progressIndicator.isModal() && ((ProgressIndicatorEx)progressIndicator).isModalityEntered();
522   }
523
524   public <T> List<Future<T>> invokeAllUnderReadAction(@NotNull Collection<Callable<T>> tasks, final ExecutorService executorService) throws Throwable {
525     final List<Callable<T>> newCallables = new ArrayList<Callable<T>>(tasks.size());
526     for (final Callable<T> task : tasks) {
527       Callable<T> newCallable = new Callable<T>() {
528         public T call() throws Exception {
529           boolean old = setExceptionalThreadWithReadAccessFlag(true);
530           try {
531             LOG.assertTrue(isReadAccessAllowed());
532             return task.call();
533           }
534           finally {
535             setExceptionalThreadWithReadAccessFlag(old);
536           }
537         }
538       };
539       newCallables.add(newCallable);
540     }
541     final Ref<Throwable> exception = new Ref<Throwable>();
542     List<Future<T>> result = runReadAction(new Computable<List<Future<T>>>() {
543       public List<Future<T>> compute() {
544         try {
545           return ConcurrencyUtil.invokeAll(newCallables, executorService);
546         }
547         catch (Throwable throwable) {
548           exception.set(throwable);
549           return null;
550         }
551       }
552     });
553     Throwable throwable = exception.get();
554     if (throwable != null) throw throwable;
555     return result;
556   }
557
558   public void invokeAndWait(Runnable runnable, @NotNull ModalityState modalityState) {
559     if (isDispatchThread()) {
560       LOG.error("invokeAndWait must not be called from event queue thread");
561       runnable.run();
562       return;
563     }
564
565     if (isExceptionalThreadWithReadAccess()) { //OK if we're in exceptional thread.
566       LaterInvocator.invokeAndWait(runnable, modalityState);
567       return;
568     }
569
570     if (myActionsLock.isReadLockAcquired()) {
571       LOG.error("Calling invokeAndWait from read-action leads to possible deadlock.");
572     }
573
574     LaterInvocator.invokeAndWait(runnable, modalityState);
575   }
576
577   public ModalityState getCurrentModalityState() {
578     Object[] entities = LaterInvocator.getCurrentModalEntities();
579     return entities.length > 0 ? new ModalityStateEx(entities) : getNoneModalityState();
580   }
581
582   public ModalityState getModalityStateForComponent(Component c) {
583     Window window = c instanceof Window ? (Window)c : SwingUtilities.windowForComponent(c);
584     if (window == null) return getNoneModalityState(); //?
585     return LaterInvocator.modalityStateForWindow(window);
586   }
587
588   public ModalityState getDefaultModalityState() {
589     if (EventQueue.isDispatchThread()) {
590       return getCurrentModalityState();
591     }
592     else {
593       ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
594       return progress == null ? getNoneModalityState() : progress.getModalityState();
595     }
596   }
597
598   public ModalityState getNoneModalityState() {
599     return MODALITY_STATE_NONE;
600   }
601
602   public long getStartTime() {
603     return myStartTime;
604   }
605
606   public long getIdleTime() {
607     return IdeEventQueue.getInstance().getIdleTime();
608   }
609
610   public void exit() {
611     exit(false);
612   }
613
614   public void exit(final boolean force) {
615     if (!force && getDefaultModalityState() != ModalityState.NON_MODAL) {
616       return;
617     }
618
619     Runnable runnable = new Runnable() {
620       public void run() {
621         if (!force) {
622           if (!showConfirmation()) {
623             saveAll();
624             return;
625           }
626         }
627
628         FileDocumentManager.getInstance().saveAllDocuments();
629
630         saveSettings();
631
632         if (!canExit()) return;
633
634         if (disposeSelf()) System.exit(0);
635       }
636     };
637     
638     if (!isDispatchThread()) {
639       invokeLater(runnable, ModalityState.NON_MODAL);
640     }
641     else {
642       runnable.run();
643     }
644   }
645
646   private static boolean showConfirmation() {
647     final boolean hasUnsafeBgTasks = ProgressManager.getInstance().hasUnsafeProgressIndicator();
648     final ConfirmExitDialog confirmExitDialog = new ConfirmExitDialog(hasUnsafeBgTasks);
649     if (confirmExitDialog.isToBeShown()) {
650       confirmExitDialog.show();
651       if (!confirmExitDialog.isOK()) {
652         return false;
653       }
654     }
655     return true;
656   }
657
658   private boolean canExit() {
659     for (ApplicationListener applicationListener : myDispatcher.getListeners()) {
660       if (!applicationListener.canExitApplication()) {
661         return false;
662       }
663     }
664
665     ProjectManagerEx projectManager = (ProjectManagerEx)ProjectManager.getInstance();
666     Project[] projects = projectManager.getOpenProjects();
667     for (Project project : projects) {
668       if (!projectManager.canClose(project)) {
669         return false;
670       }
671     }
672
673     return true;
674   }
675
676   public void runReadAction(final Runnable action) {
677     /** if we are inside read action, do not try to acquire read lock again since it will deadlock if there is a pending writeAction
678      * see {@link com.intellij.util.concurrency.ReentrantWriterPreferenceReadWriteLock#allowReader()} */
679     boolean mustAcquire = !isReadAccessAllowed();
680
681     if (mustAcquire) {
682       LOG.assertTrue(myTestModeFlag || !Thread.holdsLock(PsiLock.LOCK), "Thread must not hold PsiLock while performing readAction");
683       try {
684         myActionsLock.readLock().acquire();
685       }
686       catch (InterruptedException e) {
687         throw new RuntimeInterruptedException(e);
688       }
689     }
690
691     try {
692       action.run();
693     }
694     finally {
695       if (mustAcquire) {
696         myActionsLock.readLock().release();
697       }
698     }
699   }
700
701   private static final ThreadLocal<Boolean> exceptionalThreadWithReadAccessFlag = new ThreadLocal<Boolean>();
702   private static boolean isExceptionalThreadWithReadAccess() {
703     Boolean flag = exceptionalThreadWithReadAccessFlag.get();
704     return flag == Boolean.TRUE;
705   }
706
707   public static boolean setExceptionalThreadWithReadAccessFlag(boolean flag) {
708     boolean old = isExceptionalThreadWithReadAccess();
709     if (flag) {
710       exceptionalThreadWithReadAccessFlag.set(Boolean.TRUE);
711     }
712     else {
713       exceptionalThreadWithReadAccessFlag.remove();
714     }
715     return old;
716   }
717
718   public <T> T runReadAction(final Computable<T> computation) {
719     final Ref<T> ref = Ref.create(null);
720     runReadAction(new Runnable() {
721       public void run() {
722         ref.set(computation.compute());
723       }
724     });
725     return ref.get();
726   }
727
728   public void runWriteAction(final Runnable action) {
729     assertCanRunWriteAction();
730
731     ActivityTracker.getInstance().inc();
732     fireBeforeWriteActionStart(action);
733
734     LOG.assertTrue(myActionsLock.isWriteLockAcquired(Thread.currentThread()) || !Thread.holdsLock(PsiLock.LOCK), "Thread must not hold PsiLock while performing writeAction");
735     try {
736       myActionsLock.writeLock().acquire();
737     }
738     catch (InterruptedException e) {
739       throw new RuntimeInterruptedException(e);
740     }
741
742     try {
743       synchronized (myWriteActionsStack) {
744         myWriteActionsStack.push(action);
745       }
746
747       fireWriteActionStarted(action);
748
749       action.run();
750     }
751     finally {
752       try {
753         fireWriteActionFinished(action);
754         
755         synchronized (myWriteActionsStack) {
756           myWriteActionsStack.pop();
757         }
758       }
759       finally {
760         myActionsLock.writeLock().release();
761       }
762     }
763   }
764
765   public <T> T runWriteAction(final Computable<T> computation) {
766     final Ref<T> ref = Ref.create(null);
767     runWriteAction(new Runnable() {
768       public void run() {
769         ref.set(computation.compute());
770       }
771     });
772     return ref.get();
773   }
774
775   public Object getCurrentWriteAction(Class actionClass) {
776     synchronized (myWriteActionsStack) {
777       for (int i = myWriteActionsStack.size() - 1; i >= 0; i--) {
778         Runnable action = myWriteActionsStack.get(i);
779         if (actionClass == null || ReflectionCache.isAssignable(actionClass, action.getClass())) return action;
780       }
781     }
782     return null;
783   }
784
785   public void assertReadAccessAllowed() {
786     if (myTestModeFlag || myHeadlessMode) return;
787     if (!isReadAccessAllowed()) {
788       LOG.error(
789         "Read access is allowed from event dispatch thread or inside read-action only (see com.intellij.openapi.application.Application.runReadAction())",
790         "Current thread: " + describe(Thread.currentThread()), "Our dispatch thread:" + describe(ourDispatchThread),
791         "SystemEventQueueThread: " + describe(getEventQueueThread()));
792     }
793   }
794
795   @NonNls
796   private static String describe(Thread o) {
797     if (o == null) return "null";
798     return o.toString() + " " + System.identityHashCode(o);
799   }
800
801   @Nullable
802   private static Thread getEventQueueThread() {
803     EventQueue eventQueue = Toolkit.getDefaultToolkit().getSystemEventQueue();
804     try {
805       Method method = EventQueue.class.getDeclaredMethod("getDispatchThread");
806       method.setAccessible(true);
807       return (Thread)method.invoke(eventQueue);
808     }
809     catch (Exception e1) {
810       // ok
811     }
812     return null;
813   }
814
815   public boolean isReadAccessAllowed() {
816     Thread currentThread = Thread.currentThread();
817     return ourDispatchThread == currentThread ||
818            isExceptionalThreadWithReadAccess() ||
819            myActionsLock.isReadLockAcquired() ||
820            myActionsLock.isWriteLockAcquired() ||
821            isDispatchThread();
822   }
823
824   public void assertReadAccessToDocumentsAllowed() {
825     /* TODO
826     Thread currentThread = Thread.currentThread();
827     if (ourDispatchThread != currentThread) {
828       if (myExceptionalThreadWithReadAccess == currentThread) return;
829       if (myActionsLock.isReadLockAcquired(currentThread)) return;
830       if (myActionsLock.isWriteLockAcquired(currentThread)) return;
831       if (isDispatchThread(currentThread)) return;
832       LOG.error(
833         "Read access is allowed from event dispatch thread or inside read-action only (see com.intellij.openapi.application.Application.runReadAction())");
834     }
835     */
836   }
837
838   private void assertCanRunWriteAction() {
839     assertIsDispatchThread("Write access is allowed from event dispatch thread only");
840
841   }
842
843   public void assertIsDispatchThread() {
844     assertIsDispatchThread("Access is allowed from event dispatch thread only.");
845   }
846
847   private void assertIsDispatchThread(String message) {
848     if (myTestModeFlag || myHeadlessMode || ShutDownTracker.isShutdownHookRunning()) return;
849     final Thread currentThread = Thread.currentThread();
850     if (ourDispatchThread == currentThread) return;
851
852     if (EventQueue.isDispatchThread()) {
853       ourDispatchThread = currentThread;
854     }
855     if (ourDispatchThread == currentThread) return;
856
857     LOG.error(message,
858               "Current thread: " + describe(Thread.currentThread()),
859               "Our dispatch thread:" + describe(ourDispatchThread),
860               "SystemEventQueueThread: " + describe(getEventQueueThread()));
861   }
862
863   public void assertIsDispatchThread(@Nullable final JComponent component) {
864     if (component == null) return;
865
866     Thread curThread = Thread.currentThread();
867     if (ourDispatchThread == curThread) {
868       return;
869     }
870
871     if (Boolean.TRUE.equals(component.getClientProperty(WAS_EVER_SHOWN))) {
872       assertIsDispatchThread();
873     }
874     else {
875       final JRootPane root = component.getRootPane();
876       if (root != null) {
877         component.putClientProperty(WAS_EVER_SHOWN, Boolean.TRUE);
878         assertIsDispatchThread();
879       } 
880     }
881   }
882
883   public boolean tryRunReadAction(@NotNull Runnable action) {
884     /** if we are inside read action, do not try to acquire read lock again since it will deadlock if there is a pending writeAction
885      * see {@link com.intellij.util.concurrency.ReentrantWriterPreferenceReadWriteLock#allowReader()} */
886     boolean mustAcquire = !isReadAccessAllowed();
887
888     if (mustAcquire) {
889       LOG.assertTrue(myTestModeFlag || !Thread.holdsLock(PsiLock.LOCK), "Thread must not hold PsiLock while performing readAction");
890       try {
891         if (!myActionsLock.readLock().attempt(0)) return false;
892       }
893       catch (InterruptedException e) {
894         throw new RuntimeInterruptedException(e);
895       }
896     }
897
898     try {
899       action.run();
900     }
901     finally {
902       if (mustAcquire) {
903         myActionsLock.readLock().release();
904       }
905     }
906     return true;
907   }
908
909   public boolean tryToApplyActivationState(boolean active, Window window) {
910     final Component frame = UIUtil.findUltimateParent(window);
911
912     if (frame instanceof IdeFrame) {
913       final IdeFrame ideFrame = (IdeFrame)frame;
914       if (isActive() != active) {
915         myActive = Boolean.valueOf(active);
916         System.setProperty("idea.active", Boolean.valueOf(myActive).toString());
917         if (active) {
918           myDispatcher.getMulticaster().applicationActivated(ideFrame);
919         }
920         else {
921           myDispatcher.getMulticaster().applicationDeactivated(ideFrame);
922         }
923         return true;
924       }
925     }
926
927     return false;
928   }
929
930   public boolean isActive() {
931     if (isUnitTestMode()) return true;
932
933     if (myActive == null) {
934       Window active = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
935       return active != null;
936     }
937
938     return myActive;
939   }
940
941   public void assertWriteAccessAllowed() {
942     LOG.assertTrue(isWriteAccessAllowed(),
943                    "Write access is allowed inside write-action only (see com.intellij.openapi.application.Application.runWriteAction())");
944   }
945
946   public boolean isWriteAccessAllowed() {
947     return myActionsLock.isWriteLockAcquired(Thread.currentThread());
948   }
949
950   public void editorPaintStart() {
951     myInEditorPaintCounter++;
952   }
953
954   public void editorPaintFinish() {
955     myInEditorPaintCounter--;
956     LOG.assertTrue(myInEditorPaintCounter >= 0);
957   }
958
959   public void addApplicationListener(ApplicationListener l) {
960     myDispatcher.addListener(l);
961   }
962
963   public void addApplicationListener(ApplicationListener l, Disposable parent) {
964     myDispatcher.addListener(l, parent);
965   }
966
967   public void removeApplicationListener(ApplicationListener l) {
968     myDispatcher.removeListener(l);
969   }
970
971   private void fireApplicationExiting() {
972     myDispatcher.getMulticaster().applicationExiting();
973   }
974
975   private void fireBeforeWriteActionStart(Runnable action) {
976     myDispatcher.getMulticaster().beforeWriteActionStart(action);
977   }
978
979   private void fireWriteActionStarted(Runnable action) {
980     myDispatcher.getMulticaster().writeActionStarted(action);
981   }
982
983   private void fireWriteActionFinished(Runnable action) {
984     myDispatcher.getMulticaster().writeActionFinished(action);
985   }
986
987   public void _saveSettings() { // for testing purposes
988     if (mySaveSettingsIsInProgress.compareAndSet(false, true)) {
989       try {
990         doSave();
991       }
992       catch (final Throwable ex) {
993         if (isUnitTestMode()) {
994           System.out.println("Saving application settings failed");
995           ex.printStackTrace();
996         }
997         else {
998           LOG.info("Saving application settings failed", ex);
999           invokeLater(new Runnable() {
1000             public void run() {
1001               if (ex instanceof PluginException) {
1002                 final PluginException pluginException = (PluginException)ex;
1003                 PluginManager.disablePlugin(pluginException.getPluginId().getIdString());
1004                 Messages.showMessageDialog("The plugin " +
1005                                            pluginException.getPluginId() +
1006                                            " failed to save settings and has been disabled. Please restart " +
1007                                            ApplicationNamesInfo.getInstance().getFullProductName(), CommonBundle.getErrorTitle(),
1008                                            Messages.getErrorIcon());
1009               }
1010               else {
1011                 Messages.showMessageDialog(ApplicationBundle.message("application.save.settings.error", ex.getLocalizedMessage()),
1012                                            CommonBundle.getErrorTitle(), Messages.getErrorIcon());
1013
1014               }
1015             }
1016           });
1017         }
1018       }
1019       finally {
1020         mySaveSettingsIsInProgress.set(false);
1021       }
1022     }
1023   }
1024
1025   public void saveSettings() {
1026     if (myDoNotSave || isUnitTestMode() || isHeadlessEnvironment()) return;
1027     _saveSettings();
1028   }
1029
1030   public void saveAll() {
1031     if (myDoNotSave || isUnitTestMode() || isHeadlessEnvironment()) return;
1032
1033     FileDocumentManager.getInstance().saveAllDocuments();
1034
1035     Project[] openProjects = ProjectManager.getInstance().getOpenProjects();
1036     for (Project openProject : openProjects) {
1037       ProjectEx project = (ProjectEx)openProject;
1038       project.save();
1039     }
1040
1041     saveSettings();
1042   }
1043
1044   public void doNotSave() {
1045     myDoNotSave = true;
1046   }
1047
1048
1049   public boolean isDoNotSave() {
1050     return myDoNotSave;
1051   }
1052
1053   public <T> T[] getExtensions(final ExtensionPointName<T> extensionPointName) {
1054     return Extensions.getRootArea().getExtensionPoint(extensionPointName).getExtensions();
1055   }
1056
1057   public boolean isDisposeInProgress() {
1058     return myDisposeInProgress;
1059   }
1060
1061   public boolean isRestartCapable() {
1062     return SystemInfo.isWindows;
1063   }
1064
1065   public void restart() {
1066    if (SystemInfo.isWindows) {
1067      Win32Restarter.restart();
1068     }
1069     else {
1070      exit();
1071    }
1072   }
1073
1074   public boolean isSaving() {
1075     if (getStateStore().isSaving()) return true;
1076     Project[] openProjects = ProjectManager.getInstance().getOpenProjects();
1077     for (Project openProject : openProjects) {
1078       ProjectEx project = (ProjectEx)openProject;
1079       if (project.getStateStore().isSaving()) return true;
1080     }
1081
1082     return false;
1083   }
1084 }