ApplicationImpl (Unofficial IntelliJ Community Edition API docs)

java.lang.Object
- ComponentManagerImpl
- - com.intellij.openapi.application.impl.ApplicationImpl

All Implemented Interfaces:

Application, ApplicationEx, ComponentManager, Disposable, AreaInstance, UserDataHolder
```
public class ApplicationImpl
extends ComponentManagerImpl
implements ApplicationEx
```

Nested Class Summary
- Nested classes/interfaces inherited from interface com.intellij.openapi.Disposable
  Disposable.Parent

Field Summary

Fields
Modifier and Type Field and Description

static boolean USE_SEPARATE_WRITE_THREAD
This boolean controls whether to use thread(s) other than EDT for acquiring IW lock (i.e.
- Fields inherited from interface com.intellij.openapi.application.ex.ApplicationEx
  ELEVATE, EXIT_CONFIRMED, FORCE_EXIT, LOCATOR_FILE_NAME, SAVE

Fields
Modifier and Type	Field and Description
`static boolean`	`USE_SEPARATE_WRITE_THREAD` This boolean controls whether to use thread(s) other than EDT for acquiring IW lock (i.e.

Constructor Summary

Constructors
Constructor and Description
`ApplicationImpl(boolean isInternal, boolean isUnitTestMode, boolean isHeadless, boolean isCommandLine)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`AccessToken`	`acquireReadActionLock()`
`AccessToken`	`acquireWriteActionLock(java.lang.Class<?> clazz)`
`boolean`	`acquireWriteIntentLockIfNeeded()` Private API to use in instrumented code.
`java.lang.String`	`activityNamePrefix()`
`void`	`addApplicationListener(ApplicationListener l)`
`void`	`addApplicationListener(ApplicationListener l, Disposable parent)` Adds an `ApplicationListener`.
`void`	`assertIsDispatchThread()` Asserts whether the method is being called from the event dispatch thread.
`void`	`assertIsDispatchThread(javax.swing.JComponent component)`
`void`	`assertIsWriteThread()` Asserts whether the method is being called from under the Write Intent lock
`void`	`assertReadAccessAllowed()` Asserts whether the read access is allowed.
`void`	`assertTimeConsuming()`
`void`	`assertWriteAccessAllowed()` Asserts whether the write access is allowed.
`void`	`dispose()` Usually not invoked directly, see class javadoc.
`void`	`disposeContainer()`
`void`	`executeByImpatientReader(java.lang.Runnable runnable)` Executes a `runnable` in an "impatient" mode.
`<T> java.util.concurrent.Future<T>`	`executeOnPooledThread(java.util.concurrent.Callable<T> action)` Requests pooled thread to execute the action.
`java.util.concurrent.Future<?>`	`executeOnPooledThread(java.lang.Runnable action)` Requests pooled thread to execute the action.
`void`	`executeSuspendingWriteAction(Project project, java.lang.String title, java.lang.Runnable runnable)` If called inside a write action, executes the given code under a modal progress with write lock released (e.g.
`void`	`exit(boolean force, boolean exitConfirmed, boolean restart)` There are two ways we can get an exit notification.
`void`	`exit(int flags)`
`ModalityState`	`getAnyModalityState()` Please use `ModalityState.any()` instead, and only if you absolutely must, after carefully reading its documentation.
`protected ContainerDescriptor`	`getContainerDescriptor(IdeaPluginDescriptorImpl pluginDescriptor)`
`ModalityState`	`getCurrentModalityState()` Please use `ModalityState.current()` instead.
`ModalityState`	`getDefaultModalityState()` Please use `ModalityState.defaultModalityState()` instead.
`long`	`getIdleTime()` Returns the time in milliseconds during which IDE received no input events.
`ModalityInvokator`	`getInvokator()`
`ModalityState`	`getModalityStateForComponent(java.awt.Component c)` Please use `ModalityState.stateForComponent(Component)` instead.
`ModalityState`	`getNoneModalityState()` Please use `ModalityState.NON_MODAL` instead.
`long`	`getStartTime()` Returns the time of IDE start, in milliseconds since midnight, January 1, 1970 UTC.
`boolean`	`hasWriteAction(java.lang.Class<?> actionClass)` Returns `true` if there is currently executing write action of the specified class.
`boolean`	`holdsReadLock()`
`void`	`invokeAndWait(java.lang.Runnable runnable)` Same as `Application.invokeAndWait(Runnable, ModalityState)`, using `ModalityState.defaultModalityState()`.
`void`	`invokeAndWait(java.lang.Runnable runnable, ModalityState modalityState)` Causes `runnable.run()` to be executed synchronously on the AWT event dispatching thread under Write Intent lock, when the IDE is in the specified modality state (or a state with less modal dialogs open).
`void`	`invokeLater(java.lang.Runnable runnable)` Causes `runnable.run()` to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, with `ModalityState.defaultModalityState()` modality state.
`void`	`invokeLater(java.lang.Runnable runnable, Condition<?> expired)` Causes `runnable.run()` to be executed asynchronously on the AWT event dispatching thread under Write Intent lock - unless the expiration condition is fulfilled.
`void`	`invokeLater(java.lang.Runnable runnable, ModalityState state)` Causes `runnable.run()` to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, when IDE is in the specified modality state (or a state with less modal dialogs open).
`void`	`invokeLater(java.lang.Runnable runnable, ModalityState state, Condition<?> expired)` Causes `runnable.run()` to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, when IDE is in the specified modality state(or a state with less modal dialogs open) - unless the expiration condition is fulfilled.
`void`	`invokeLaterOnWriteThread(java.lang.Runnable action)` Causes `runnable` to be executed asynchronously under Write Intent lock on some thread, with `ModalityState.defaultModalityState()` modality state.
`void`	`invokeLaterOnWriteThread(java.lang.Runnable action, ModalityState modal)` Causes `runnable` to be executed asynchronously under Write Intent lock on some thread, when IDE is in the specified modality state (or a state with less modal dialogs open).
`void`	`invokeLaterOnWriteThread(java.lang.Runnable action, ModalityState modal, Condition<?> expired)` Causes `runnable` to be executed asynchronously under Write Intent lock on some thread, when IDE is in the specified modality state (or a state with less modal dialogs open) - unless the expiration condition is fulfilled.
`boolean`	`isActive()` Checks if the application is active.
`boolean`	`isCommandLine()` Checks if IDE is running as a command line applet or in unit test mode.
`ThreeState`	`isCurrentWriteOnEdt()`
`boolean`	`isDispatchThread()` Checks if the current thread is the Swing dispatch thread and has IW lock acquired.
`boolean`	`isEAP()`
`boolean`	`isHeadlessEnvironment()` Checks if IDE is running as a command line applet or in unit test mode.
`boolean`	`isInImpatientReader()` DO NOT USE
`boolean`	`isInternal()` Checks if IDE is running in Internal Mode to enable additional features for plugin development.
`boolean`	`isLightEditMode()`
`boolean`	`isReadAccessAllowed()` Checks if the read access is currently allowed.
`boolean`	`isRestartCapable()` Checks if IDE is capable of restarting itself on the current platform and with the current execution mode.
`boolean`	`isSaveAllowed()`
`boolean`	`isUnitTestMode()` Checks if IDE is currently running unit tests.
`boolean`	`isWriteAccessAllowed()` Checks if the write access is currently allowed.
`boolean`	`isWriteActionInProgress()`
`boolean`	`isWriteActionPending()`
`boolean`	`isWriteThread()` Checks if the current thread has IW lock acquired, which grants read access and the ability to run write actions.
`void`	`load(java.lang.String configPath)` Loads the application configuration from the specified path
`void`	`loadComponents(ProgressIndicator indicator)`
`protected void`	`logMessageBusDelivery(Topic<?> topic, java.lang.String messageName, java.lang.Object handler, long duration)`
`void`	`releaseWriteIntentLockIfNeeded(boolean needed)` Private API to use in instrumented code.
`void`	`removeApplicationListener(ApplicationListener l)`
`void`	`restart(boolean exitConfirmed)`
`void`	`restart(boolean exitConfirmed, boolean elevate)` Restarts the IDE with optional process elevation (on Windows).
`void`	`restart(int flags, java.lang.String [] beforeRestart)`
`void`	`runIntendedWriteActionOnCurrentThread(java.lang.Runnable action)` Runs the specified action under Write Intent lock.
`boolean`	`runProcessWithProgressSynchronously(java.lang.Runnable process, java.lang.String progressTitle, boolean canBeCanceled, Project project)` Runs modal process.
`boolean`	`runProcessWithProgressSynchronously(java.lang.Runnable process, java.lang.String progressTitle, boolean canBeCanceled, Project project, javax.swing.JComponent parentComponent)` Runs modal process.
`boolean`	`runProcessWithProgressSynchronously(java.lang.Runnable process, java.lang.String progressTitle, boolean canBeCanceled, Project project, javax.swing.JComponent parentComponent, java.lang.String cancelText)` Runs modal process.
`boolean`	`runProcessWithProgressSynchronouslyInReadAction(Project project, java.lang.String progressTitle, boolean canBeCanceled, java.lang.String cancelText, javax.swing.JComponent parentComponent, java.lang.Runnable process)` Executes `process` in a separate thread in the application thread pool (see `Application.executeOnPooledThread(Runnable)`).
`<T> T`	`runReadAction(Computable<T> computation)` Runs the specified computation in a read action.
`void`	`runReadAction(java.lang.Runnable action)` Runs the specified read action.
`<T,E extends java.lang.Throwable> T`	`runReadAction(ThrowableComputable<T,E> computation)` Runs the specified computation in a read action.
`<T,E extends java.lang.Throwable> T`	`runUnlockingIntendedWrite(ThrowableComputable<T,E> action)` Runs the specified action, releasing Write Intent lock if it is acquired at the moment of the call.
`<T> T`	`runWriteAction(Computable<T> computation)` Runs the specified computation in a write action.
`void`	`runWriteAction(java.lang.Runnable action)` Runs the specified write action.
`<T,E extends java.lang.Throwable> T`	`runWriteAction(ThrowableComputable<T,E> computation)` Runs the specified computation in a write action.
`boolean`	`runWriteActionWithCancellableProgressInDispatchThread(java.lang.String title, Project project, javax.swing.JComponent parentComponent, Consumer<? super ProgressIndicator> action)`
`boolean`	`runWriteActionWithNonCancellableProgressInDispatchThread(java.lang.String title, Project project, javax.swing.JComponent parentComponent, Consumer<? super ProgressIndicator> action)`
`void`	`saveAll()` Saves all open documents and projects.
`void`	`saveSettings()` Saves application settings.
`void`	`setSaveAllowed(boolean value)`
`java.lang.String`	`toString()`
`boolean`	`tryRunReadAction(java.lang.Runnable action)` Tries to acquire the read lock and run the `action`
`java.lang.String`	`writeActionStatistics()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.intellij.openapi.application.ex.ApplicationEx
doNotSave, exit, exit, load, restart

Methods inherited from interface com.intellij.openapi.application.Application
isDisposeInProgress

Methods inherited from interface com.intellij.openapi.components.ComponentManager
createError, createError, getComponent, getComponent, getComponent, getComponentInstancesOfType, getComponentInstancesOfType, getComponents, getDisposed, getExtensionArea, getExtensions, getMessageBus, getPicoContainer, getService, getService, getServiceIfCreated, hasComponent, instantiateClass, instantiateClassWithConstructorInjection, instantiateExtensionWithPicoContainerOnlyIfNeeded, isDisposed, isDisposedOrDisposeInProgress, logError

Methods inherited from interface com.intellij.openapi.util.UserDataHolder
getUserData, putUserData

- Field Detail
  - USE_SEPARATE_WRITE_THREAD
```
public static final boolean USE_SEPARATE_WRITE_THREAD
```
    This boolean controls whether to use thread(s) other than EDT for acquiring IW lock (i.e. running write actions) or not. If value is false, IW lock will be granted on EDT at all times, guaranteeing the same execution model as before IW lock introduction.
- Constructor Detail
  - ApplicationImpl
```
public ApplicationImpl(boolean isInternal,
                       boolean isUnitTestMode,
                       boolean isHeadless,
                       boolean isCommandLine)
```
- Method Detail
  - executeByImpatientReader
```
public void executeByImpatientReader(java.lang.Runnable runnable)
                              throws ApplicationUtil.CannotRunReadActionException
```
    Executes a runnable in an "impatient" mode. In this mode any attempt to call runReadAction(Runnable) would fail (i.e. throw ApplicationUtil.CannotRunReadActionException) if there is a pending write action.
    
    Specified by:
    
    executeByImpatientReader in interface ApplicationEx
    
    Throws:
    
    ApplicationUtil.CannotRunReadActionException
  - isInImpatientReader
```
public boolean isInImpatientReader()
```
    Description copied from interface: ApplicationEx
    
    DO NOT USE
    
    Specified by:
    
    isInImpatientReader in interface ApplicationEx
  - disposeContainer
```
public void disposeContainer()
```
  - holdsReadLock
```
public boolean holdsReadLock()
```
    Specified by:
    
    holdsReadLock in interface ApplicationEx
    
    Returns:
    
    true if this thread is inside read action.
    
    See Also:
    
    Application.runReadAction(Runnable)
  - isInternal
```
public boolean isInternal()
```
    Description copied from interface: Application
    
    Checks if IDE is running in Internal Mode to enable additional features for plugin development.
    
    Specified by:
    
    isInternal in interface Application
  - isEAP
```
public boolean isEAP()
```
    Specified by:
    
    isEAP in interface Application
  - isUnitTestMode
```
public boolean isUnitTestMode()
```
    Description copied from interface: Application
    Checks if IDE is currently running unit tests. No UI should be shown when unit tests are being executed. This method may also be used for additional debug checks or logging in test mode.
    Please avoid doing things differently depending on the result of this method, because this leads to testing something synthetic instead of what really happens in production. So you'll be able to catch less of production bugs and might instead lose your time on debugging test-only issues. It's more robust to write a bit more code in tests to accommodate for production behavior than vice versa. For example:
    - To wait for an invokeLater in tests, you can call PlatformTestUtil.dispatchAllInvocationEventsInIdeEventQueue()
    - To wait for asynchronous non-blocking read operations, you can call NonBlockingReadActionImpl.waitForAsyncTaskCompletion()
    - To wait for other asynchronous operations, you can track their Future/Promise/etc callbacks and call PlatformTestUtil.waitFor*
    - To emulate user interaction with a simple yes/no dialog, use Messages.setTestDialog(...)
    - For other UI interaction, try UiInterceptors
    Specified by:
    
    isUnitTestMode in interface Application
    
    Returns:
    
    true if IDE is running unit tests, false otherwise
  - isHeadlessEnvironment
```
public boolean isHeadlessEnvironment()
```
    Description copied from interface: Application
    
    Checks if IDE is running as a command line applet or in unit test mode. No UI should be shown when IDE is running in this mode.
    
    Specified by:
    
    isHeadlessEnvironment in interface Application
    
    Returns:
    
    true if IDE is running in UI-less mode, false otherwise
  - isCommandLine
```
public boolean isCommandLine()
```
    Description copied from interface: Application
    
    Checks if IDE is running as a command line applet or in unit test mode. UI can be shown (e.g. diff frame)
    
    Specified by:
    
    isCommandLine in interface Application
    
    Returns:
    
    true if IDE is running in command line mode, false otherwise
  - isLightEditMode
```
public boolean isLightEditMode()
```
  - executeOnPooledThread
```
public java.util.concurrent.Future<?> executeOnPooledThread(java.lang.Runnable action)
```
    Description copied from interface: Application
    Requests pooled thread to execute the action.
    This pool is an
    - Unbounded.
    - Application-wide, always active, non-shutdownable singleton.
    You can use this pool for long-running and/or IO-bound tasks.
    Specified by:
    
    executeOnPooledThread in interface Application
    
    Parameters:
    
    action - to be executed
    
    Returns:
    
    future result
  - executeOnPooledThread
```
public <T> java.util.concurrent.Future<T> executeOnPooledThread(java.util.concurrent.Callable<T> action)
```
    Description copied from interface: Application
    Requests pooled thread to execute the action.
    This pool is an
    - Unbounded.
    - Application-wide, always active, non-shutdownable singleton.
    You can use this pool for long-running and/or IO-bound tasks.
    Specified by:
    
    executeOnPooledThread in interface Application
    
    Parameters:
    
    action - to be executed
    
    Returns:
    
    future result
  - isDispatchThread
```
public boolean isDispatchThread()
```
    Description copied from interface: Application
    
    Checks if the current thread is the Swing dispatch thread and has IW lock acquired.
    
    Specified by:
    
    isDispatchThread in interface Application
    
    Returns:
    
    true if the current thread is the Swing dispatch thread with IW lock, false otherwise.
    
    See Also:
    
    Application.isWriteThread()
  - isWriteThread
```
public boolean isWriteThread()
```
    Description copied from interface: Application
    
    Checks if the current thread has IW lock acquired, which grants read access and the ability to run write actions.
    
    Specified by:
    
    isWriteThread in interface Application
    
    Returns:
    
    true if the current thread has IW lock acquired, false otherwise.
  - getInvokator
```
public ModalityInvokator getInvokator()
```
    Specified by:
    
    getInvokator in interface Application
    
    Returns:
    
    a facade, which lets to call all those invokeLater() with a ActionCallback handle returned.
  - invokeLater
```
public void invokeLater(java.lang.Runnable runnable)
```
    Description copied from interface: Application
    
    Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, with ModalityState.defaultModalityState() modality state. This will happen after all pending AWT events have been processed.
    
    Please use this method instead of SwingUtilities.invokeLater(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.
    
    Specified by:
    
    invokeLater in interface Application
    
    Parameters:
    
    runnable - the runnable to execute.
  - invokeLater
```
public void invokeLater(java.lang.Runnable runnable,
                        Condition<?> expired)
```
    Description copied from interface: Application
    
    Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock - unless the expiration condition is fulfilled. This will happen after all pending AWT events have been processed and in ModalityState.defaultModalityState() modality state (or a state with less modal dialogs open).
    
    Please use this method instead of SwingUtilities.invokeLater(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.
    
    Specified by:
    
    invokeLater in interface Application
    
    Parameters:
    
    runnable - the runnable to execute.
    
    expired - condition to check before execution.
  - invokeLater
```
public void invokeLater(java.lang.Runnable runnable,
                        ModalityState state)
```
    Description copied from interface: Application
    
    Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, when IDE is in the specified modality state (or a state with less modal dialogs open).
    Please use this method instead of SwingUtilities.invokeLater(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.
    
    Specified by:
    
    invokeLater in interface Application
    
    Parameters:
    
    runnable - the runnable to execute.
    
    state - the state in which the runnable will be executed.
  - invokeLater
```
public void invokeLater(java.lang.Runnable runnable,
                        ModalityState state,
                        Condition<?> expired)
```
    Description copied from interface: Application
    
    Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, when IDE is in the specified modality state(or a state with less modal dialogs open) - unless the expiration condition is fulfilled. This will happen after all pending AWT events have been processed.
    Please use this method instead of SwingUtilities.invokeLater(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.
    
    Specified by:
    
    invokeLater in interface Application
    
    Parameters:
    
    runnable - the runnable to execute.
    
    state - the state in which the runnable will be executed.
    
    expired - condition to check before execution.
  - load
```
public final void load(java.lang.String configPath)
```
    Description copied from interface: ApplicationEx
    
    Loads the application configuration from the specified path
    
    Specified by:
    
    load in interface ApplicationEx
    
    Parameters:
    
    configPath - Path to /config folder
  - loadComponents
```
public final void loadComponents(ProgressIndicator indicator)
```
  - dispose
```
public void dispose()
```
    Description copied from interface: Disposable
    
    Usually not invoked directly, see class javadoc.
    
    Specified by:
    
    dispose in interface Disposable
  - writeActionStatistics
```
public java.lang.String writeActionStatistics()
```
  - runProcessWithProgressSynchronously
```
public boolean runProcessWithProgressSynchronously(java.lang.Runnable process,
                                                   java.lang.String progressTitle,
                                                   boolean canBeCanceled,
                                                   Project project)
```
    Description copied from interface: ApplicationEx
    
    Runs modal process. For internal use only, see Task
    
    Specified by:
    
    runProcessWithProgressSynchronously in interface ApplicationEx
  - runProcessWithProgressSynchronously
```
public boolean runProcessWithProgressSynchronously(java.lang.Runnable process,
                                                   java.lang.String progressTitle,
                                                   boolean canBeCanceled,
                                                   Project project,
                                                   javax.swing.JComponent parentComponent)
```
    Description copied from interface: ApplicationEx
    
    Runs modal process. For internal use only, see Task
    
    Specified by:
    
    runProcessWithProgressSynchronously in interface ApplicationEx
  - runProcessWithProgressSynchronously
```
public boolean runProcessWithProgressSynchronously(java.lang.Runnable process,
                                                   java.lang.String progressTitle,
                                                   boolean canBeCanceled,
                                                   Project project,
                                                   javax.swing.JComponent parentComponent,
                                                   java.lang.String cancelText)
```
    Description copied from interface: ApplicationEx
    
    Runs modal process. For internal use only, see Task
    
    Specified by:
    
    runProcessWithProgressSynchronously in interface ApplicationEx
  - runProcessWithProgressSynchronouslyInReadAction
```
public boolean runProcessWithProgressSynchronouslyInReadAction(Project project,
                                                               java.lang.String progressTitle,
                                                               boolean canBeCanceled,
                                                               java.lang.String cancelText,
                                                               javax.swing.JComponent parentComponent,
                                                               java.lang.Runnable process)
```
    Description copied from interface: ApplicationEx
    
    Executes process in a separate thread in the application thread pool (see Application.executeOnPooledThread(Runnable)). The process is run inside read action (see Application.runReadAction(Runnable)) If run from EDT, it is guaranteed that no other read or write action is run before the process start running. If the process is running for too long, a progress window shown with progressTitle and a button with cancelText.
    
    Specified by:
    
    runProcessWithProgressSynchronouslyInReadAction in interface ApplicationEx
    
    Returns:
    
    true if process run successfully and was not canceled.
  - invokeAndWait
```
public void invokeAndWait(java.lang.Runnable runnable,
                          ModalityState modalityState)
```
    Description copied from interface: Application
    
    Causes runnable.run() to be executed synchronously on the AWT event dispatching thread under Write Intent lock, when the IDE is in the specified modality state (or a state with less modal dialogs open). This call blocks until all pending AWT events have been processed and (then) runnable.run() returns.
    
    If current thread is an event dispatch thread then runnable.run() is executed immediately regardless of the modality state.
    
    Please use this method instead of SwingUtilities.invokeAndWait(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.
    
    Specified by:
    
    invokeAndWait in interface Application
    
    Parameters:
    
    runnable - the runnable to execute.
    
    modalityState - the state in which the runnable will be executed.
  - invokeAndWait
```
public void invokeAndWait(java.lang.Runnable runnable)
                   throws ProcessCanceledException
```
    Description copied from interface: Application
    
    Same as Application.invokeAndWait(Runnable, ModalityState), using ModalityState.defaultModalityState().
    
    Specified by:
    
    invokeAndWait in interface Application
    
    Throws:
    
    ProcessCanceledException
  - getCurrentModalityState
```
public ModalityState getCurrentModalityState()
```
    Description copied from interface: Application
    
    Please use ModalityState.current() instead.
    
    Specified by:
    
    getCurrentModalityState in interface Application
    
    Returns:
    
    the current modality state.
  - getModalityStateForComponent
```
public ModalityState getModalityStateForComponent(java.awt.Component c)
```
    Description copied from interface: Application
    
    Please use ModalityState.stateForComponent(Component) instead.
    
    Specified by:
    
    getModalityStateForComponent in interface Application
    
    Returns:
    
    the modality state for the dialog to which the specified component belongs.
  - getAnyModalityState
```
public ModalityState getAnyModalityState()
```
    Description copied from interface: Application
    
    Please use ModalityState.any() instead, and only if you absolutely must, after carefully reading its documentation.
    
    Specified by:
    
    getAnyModalityState in interface Application
    
    Returns:
    
    modality state which is always applicable
  - getDefaultModalityState
```
public ModalityState getDefaultModalityState()
```
    Description copied from interface: Application
    
    Please use ModalityState.defaultModalityState() instead.
    
    Specified by:
    
    getDefaultModalityState in interface Application
    
    Returns:
    
    the modality state for the current thread.
  - getNoneModalityState
```
public ModalityState getNoneModalityState()
```
    Description copied from interface: Application
    
    Please use ModalityState.NON_MODAL instead.
    
    Specified by:
    
    getNoneModalityState in interface Application
    
    Returns:
    
    the modality state for no modal dialogs.
  - getStartTime
```
public long getStartTime()
```
    Description copied from interface: Application
    
    Returns the time of IDE start, in milliseconds since midnight, January 1, 1970 UTC.
    
    Specified by:
    
    getStartTime in interface Application
    
    Returns:
    
    the IDE's start time.
  - getIdleTime
```
public long getIdleTime()
```
    Description copied from interface: Application
    
    Returns the time in milliseconds during which IDE received no input events.
    
    Specified by:
    
    getIdleTime in interface Application
    
    Returns:
    
    the idle time of IDE.
  - restart
```
public final void restart(boolean exitConfirmed)
```
    Specified by:
    
    restart in interface ApplicationEx
    
    Parameters:
    
    exitConfirmed - if true, suppresses any shutdown confirmation. However, if there are any background processes or tasks running, a corresponding confirmation will be shown with the possibility to cancel the operation
  - restart
```
public final void restart(boolean exitConfirmed,
                          boolean elevate)
```
    Description copied from interface: ApplicationEx
    
    Restarts the IDE with optional process elevation (on Windows).
    
    Specified by:
    
    restart in interface ApplicationEx
    
    Parameters:
    
    exitConfirmed - if true, the IDE does not ask for exit confirmation.
    
    elevate - if true and the IDE is running on Windows, the IDE is restarted in elevated mode (with admin privileges)
  - exit
```
public final void exit(boolean force,
                       boolean exitConfirmed,
                       boolean restart)
```
    There are two ways we can get an exit notification. 1. From user input i.e. ExitAction 2. From the native system. We should not process any quit notifications if we are handling another one Note: there are possible scenarios when we get a quit notification at a moment when another quit message is shown. In that case, showing multiple messages sounds contra-intuitive as well
    
    Specified by:
    
    exit in interface Application
  - restart
```
public void restart(int flags,
                    java.lang.String [] beforeRestart)
```
  - exit
```
public final void exit(int flags)
```
    Specified by:
    
    exit in interface ApplicationEx
  - isCurrentWriteOnEdt
```
public ThreeState isCurrentWriteOnEdt()
```
  - invokeLaterOnWriteThread
```
public void invokeLaterOnWriteThread(java.lang.Runnable action,
                                     ModalityState modal)
```
    Description copied from interface: Application
    
    Causes runnable to be executed asynchronously under Write Intent lock on some thread, when IDE is in the specified modality state (or a state with less modal dialogs open).
    
    Specified by:
    
    invokeLaterOnWriteThread in interface Application
    
    Parameters:
    
    action - the runnable to execute.
    
    modal - the state in which action will be executed
  - invokeLaterOnWriteThread
```
public void invokeLaterOnWriteThread(java.lang.Runnable action,
                                     ModalityState modal,
                                     Condition<?> expired)
```
    Description copied from interface: Application
    
    Causes runnable to be executed asynchronously under Write Intent lock on some thread, when IDE is in the specified modality state (or a state with less modal dialogs open) - unless the expiration condition is fulfilled.
    
    Specified by:
    
    invokeLaterOnWriteThread in interface Application
    
    Parameters:
    
    action - the runnable to execute.
    
    modal - the state in which action will be executed
    
    expired - condition to check before execution.
  - invokeLaterOnWriteThread
```
public void invokeLaterOnWriteThread(java.lang.Runnable action)
```
    Description copied from interface: Application
    
    Causes runnable to be executed asynchronously under Write Intent lock on some thread, with ModalityState.defaultModalityState() modality state.
    
    Specified by:
    
    invokeLaterOnWriteThread in interface Application
    
    Parameters:
    
    action - the runnable to execute.
  - acquireWriteIntentLockIfNeeded
```
public boolean acquireWriteIntentLockIfNeeded()
```
    Description copied from interface: Application
    
    Private API to use in instrumented code.
    Acquires IW lock if it's not acquired by the current thread.
    
    Specified by:
    
    acquireWriteIntentLockIfNeeded in interface Application
    
    Returns:
    
    true if IW lock was acquired, or false if it is held by the current thread already.
  - releaseWriteIntentLockIfNeeded
```
public void releaseWriteIntentLockIfNeeded(boolean needed)
```
    Description copied from interface: Application
    
    Private API to use in instrumented code.
    Releases IW lock if the parameter is true.
    
    Specified by:
    
    releaseWriteIntentLockIfNeeded in interface Application
    
    Parameters:
    
    needed - whether IW lock should be released or not
  - runIntendedWriteActionOnCurrentThread
```
public void runIntendedWriteActionOnCurrentThread(java.lang.Runnable action)
```
    Description copied from interface: Application
    
    Runs the specified action under Write Intent lock. Can be called from any thread. The action is executed immediately if no write intent action is currently running, or blocked until the currently running write intent action completes.
    This method is used to implement higher-level API, please do not use it directly. Use Application.invokeLaterOnWriteThread(java.lang.Runnable), WriteThread or AppUIExecutor.onWriteThread() to run code under Write Intent lock asynchronously.
    
    Specified by:
    
    runIntendedWriteActionOnCurrentThread in interface Application
    
    Parameters:
    
    action - the action to run
  - runUnlockingIntendedWrite
```
public <T,E extends java.lang.Throwable> T runUnlockingIntendedWrite(ThrowableComputable<T,E> action)
                                                              throws E extends java.lang.Throwable
```
    Description copied from interface: Application
    
    Runs the specified action, releasing Write Intent lock if it is acquired at the moment of the call.
    This method is used to implement higher-level API, please do not use it directly.
    
    Specified by:
    
    runUnlockingIntendedWrite in interface Application
    
    Throws:
    
    E extends java.lang.Throwable
  - runReadAction
```
public void runReadAction(java.lang.Runnable action)
```
    Description copied from interface: Application
    
    Runs the specified read action. Can be called from any thread. The action is executed immediately if no write action is currently running, or blocked until the currently running write action completes.
    
    See also ReadAction.run(com.intellij.openapi.application.Result<T>) for a more lambda-friendly version.
    
    Specified by:
    
    runReadAction in interface Application
    
    Parameters:
    
    action - the action to run.
  - runReadAction
```
public <T> T runReadAction(Computable<T> computation)
```
    Description copied from interface: Application
    
    Runs the specified computation in a read action. Can be called from any thread. The action is executed immediately if no write action is currently running, or blocked until the currently running write action completes.
    
    See also ReadAction.compute(com.intellij.openapi.util.ThrowableComputable<T, E>) for a more lambda-friendly version.
    
    Specified by:
    
    runReadAction in interface Application
    
    Parameters:
    
    computation - the computation to perform.
    
    Returns:
    
    the result returned by the computation.
  - runReadAction
```
public <T,E extends java.lang.Throwable> T runReadAction(ThrowableComputable<T,E> computation)
                                                  throws E extends java.lang.Throwable
```
    Description copied from interface: Application
    
    Runs the specified computation in a read action. Can be called from any thread. The action is executed immediately if no write action is currently running, or blocked until the currently running write action completes.
    
    See also ReadAction.compute(com.intellij.openapi.util.ThrowableComputable<T, E>) for a more lambda-friendly version.
    
    Specified by:
    
    runReadAction in interface Application
    
    Parameters:
    
    computation - the computation to perform.
    
    Returns:
    
    the result returned by the computation.
    
    Throws:
    
    E - re-frown from ThrowableComputable
    
    E extends java.lang.Throwable
  - runWriteActionWithNonCancellableProgressInDispatchThread
```
public boolean runWriteActionWithNonCancellableProgressInDispatchThread(java.lang.String title,
                                                                        Project project,
                                                                        javax.swing.JComponent parentComponent,
                                                                        Consumer<? super ProgressIndicator> action)
```
    Specified by:
    
    runWriteActionWithNonCancellableProgressInDispatchThread in interface ApplicationEx
  - runWriteActionWithCancellableProgressInDispatchThread
```
public boolean runWriteActionWithCancellableProgressInDispatchThread(java.lang.String title,
                                                                     Project project,
                                                                     javax.swing.JComponent parentComponent,
                                                                     Consumer<? super ProgressIndicator> action)
```
    Specified by:
    
    runWriteActionWithCancellableProgressInDispatchThread in interface ApplicationEx
  - runWriteAction
```
public void runWriteAction(java.lang.Runnable action)
```
    Description copied from interface: Application
    
    Runs the specified write action. Must be called from the Swing dispatch thread. The action is executed immediately if no read actions are currently running, or blocked until all read actions complete.
    
    See also WriteAction.run(com.intellij.util.ThrowableRunnable<E>) for a more lambda-friendly version.
    
    Specified by:
    
    runWriteAction in interface Application
    
    Parameters:
    
    action - the action to run
  - runWriteAction
```
public <T> T runWriteAction(Computable<T> computation)
```
    Description copied from interface: Application
    
    Runs the specified computation in a write action. Must be called from the Swing dispatch thread. The action is executed immediately if no read actions or write actions are currently running, or blocked until all read actions and write actions complete.
    
    See also WriteAction.compute(com.intellij.openapi.util.ThrowableComputable<T, E>) for a more lambda-friendly version.
    
    Specified by:
    
    runWriteAction in interface Application
    
    Parameters:
    
    computation - the computation to run
    
    Returns:
    
    the result returned by the computation.
  - runWriteAction
```
public <T,E extends java.lang.Throwable> T runWriteAction(ThrowableComputable<T,E> computation)
                                                   throws E extends java.lang.Throwable
```
    Description copied from interface: Application
    
    Runs the specified computation in a write action. Must be called from the Swing dispatch thread. The action is executed immediately if no read actions or write actions are currently running, or blocked until all read actions and write actions complete.
    
    See also WriteAction.compute(com.intellij.openapi.util.ThrowableComputable<T, E>) for a more lambda-friendly version.
    
    Specified by:
    
    runWriteAction in interface Application
    
    Parameters:
    
    computation - the computation to run
    
    Returns:
    
    the result returned by the computation.
    
    Throws:
    
    E - re-frown from ThrowableComputable
    
    E extends java.lang.Throwable
  - hasWriteAction
```
public boolean hasWriteAction(java.lang.Class<?> actionClass)
```
    Description copied from interface: Application
    
    Returns true if there is currently executing write action of the specified class.
    
    Specified by:
    
    hasWriteAction in interface Application
    
    Parameters:
    
    actionClass - the class of the write action to return.
    
    Returns:
    
    true if the action is running, or false if no action of the specified class is currently executing.
  - assertReadAccessAllowed
```
public void assertReadAccessAllowed()
```
    Description copied from interface: Application
    
    Asserts whether the read access is allowed.
    
    Specified by:
    
    assertReadAccessAllowed in interface Application
  - isReadAccessAllowed
```
public boolean isReadAccessAllowed()
```
    Description copied from interface: Application
    
    Checks if the read access is currently allowed.
    
    Specified by:
    
    isReadAccessAllowed in interface Application
    
    Returns:
    
    true if the read access is currently allowed, false otherwise.
    
    See Also:
    
    Application.assertReadAccessAllowed(), Application.runReadAction(Runnable)
  - assertIsDispatchThread
```
public void assertIsDispatchThread()
```
    Description copied from interface: Application
    
    Asserts whether the method is being called from the event dispatch thread.
    
    Specified by:
    
    assertIsDispatchThread in interface Application
  - assertIsWriteThread
```
public void assertIsWriteThread()
```
    Description copied from interface: Application
    
    Asserts whether the method is being called from under the Write Intent lock
    
    Specified by:
    
    assertIsWriteThread in interface Application
  - assertIsDispatchThread
```
public void assertIsDispatchThread(javax.swing.JComponent component)
```
    Specified by:
    
    assertIsDispatchThread in interface ApplicationEx
  - assertTimeConsuming
```
public void assertTimeConsuming()
```
    Specified by:
    
    assertTimeConsuming in interface ApplicationEx
  - tryRunReadAction
```
public boolean tryRunReadAction(java.lang.Runnable action)
```
    Description copied from interface: ApplicationEx
    
    Tries to acquire the read lock and run the action
    
    Specified by:
    
    tryRunReadAction in interface ApplicationEx
    
    Returns:
    
    true if action was run while holding the lock, false if was unable to get the lock and action was not run
  - isActive
```
public boolean isActive()
```
    Description copied from interface: Application
    
    Checks if the application is active.
    
    Specified by:
    
    isActive in interface Application
    
    Returns:
    
    true if one of application windows is focused, false otherwise
  - acquireReadActionLock
```
public AccessToken acquireReadActionLock()
```
    Specified by:
    
    acquireReadActionLock in interface Application
  - isWriteActionPending
```
public boolean isWriteActionPending()
```
    Specified by:
    
    isWriteActionPending in interface ApplicationEx
    
    Returns:
    
    true if the EDT started to acquire write action but has not acquired it yet.
    
    See Also:
    
    Application.runWriteAction(Runnable)
  - acquireWriteActionLock
```
public AccessToken acquireWriteActionLock(java.lang.Class<?> clazz)
```
    Specified by:
    
    acquireWriteActionLock in interface Application
  - assertWriteAccessAllowed
```
public void assertWriteAccessAllowed()
```
    Description copied from interface: Application
    
    Asserts whether the write access is allowed.
    
    Specified by:
    
    assertWriteAccessAllowed in interface Application
  - isWriteAccessAllowed
```
public boolean isWriteAccessAllowed()
```
    Description copied from interface: Application
    
    Checks if the write access is currently allowed.
    
    Specified by:
    
    isWriteAccessAllowed in interface Application
    
    Returns:
    
    true if the write access is currently allowed, false otherwise.
    
    See Also:
    
    Application.assertWriteAccessAllowed(), Application.runWriteAction(Runnable)
  - isWriteActionInProgress
```
public boolean isWriteActionInProgress()
```
    Specified by:
    
    isWriteActionInProgress in interface ApplicationEx
    
    Returns:
    
    true if the EDT is performing write action right now.
    
    See Also:
    
    Application.runWriteAction(Runnable)
  - executeSuspendingWriteAction
```
public void executeSuspendingWriteAction(Project project,
                                         java.lang.String title,
                                         java.lang.Runnable runnable)
```
    If called inside a write action, executes the given code under a modal progress with write lock released (e.g. to allow for read-action parallelization). It's the caller's responsibility to invoke this method only when the model is in internally consistent state, so that background threads with read actions don't see half-baked PSI/VFS/etc. The runnable may perform write actions itself, callers should be ready for those.
  - addApplicationListener
```
public void addApplicationListener(ApplicationListener l)
```
    Specified by:
    
    addApplicationListener in interface Application
    
    Parameters:
    
    l - the listener to add
  - addApplicationListener
```
public void addApplicationListener(ApplicationListener l,
                                   Disposable parent)
```
    Description copied from interface: Application
    
    Adds an ApplicationListener.
    
    Specified by:
    
    addApplicationListener in interface Application
    
    Parameters:
    
    l - the listener to add
    
    parent - the parent disposable which dispose will trigger this listener removal
  - removeApplicationListener
```
public void removeApplicationListener(ApplicationListener l)
```
    Specified by:
    
    removeApplicationListener in interface Application
    
    Parameters:
    
    l - the listener to remove
  - saveSettings
```
public void saveSettings()
```
    Description copied from interface: Application
    
    Saves application settings.
    
    Specified by:
    
    saveSettings in interface Application
  - saveAll
```
public void saveAll()
```
    Description copied from interface: Application
    
    Saves all open documents and projects.
    
    Specified by:
    
    saveAll in interface Application
  - setSaveAllowed
```
public void setSaveAllowed(boolean value)
```
    Specified by:
    
    setSaveAllowed in interface ApplicationEx
  - isSaveAllowed
```
public boolean isSaveAllowed()
```
    Specified by:
    
    isSaveAllowed in interface ApplicationEx
  - isRestartCapable
```
public boolean isRestartCapable()
```
    Description copied from interface: Application
    
    Checks if IDE is capable of restarting itself on the current platform and with the current execution mode.
    
    Specified by:
    
    isRestartCapable in interface Application
    
    Returns:
    
    true if IDE can restart itself, false otherwise.
  - toString
```
public java.lang.String toString()
```
  - activityNamePrefix
```
public java.lang.String activityNamePrefix()
```
  - getContainerDescriptor
```
protected ContainerDescriptor getContainerDescriptor(IdeaPluginDescriptorImpl pluginDescriptor)
```
  - logMessageBusDelivery
```
protected void logMessageBusDelivery(Topic<?> topic,
                                     java.lang.String messageName,
                                     java.lang.Object handler,
                                     long duration)
```

Class ApplicationImpl

Nested Class Summary

Nested classes/interfaces inherited from interface com.intellij.openapi.Disposable

Field Summary

Fields inherited from interface com.intellij.openapi.application.ex.ApplicationEx

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.intellij.openapi.application.ex.ApplicationEx

Methods inherited from interface com.intellij.openapi.application.Application

Methods inherited from interface com.intellij.openapi.components.ComponentManager

Methods inherited from interface com.intellij.openapi.util.UserDataHolder

Field Detail

USE_SEPARATE_WRITE_THREAD

Constructor Detail

ApplicationImpl

Method Detail

executeByImpatientReader

isInImpatientReader

disposeContainer

holdsReadLock

isInternal

isEAP

isUnitTestMode

isHeadlessEnvironment

isCommandLine

isLightEditMode

executeOnPooledThread

executeOnPooledThread

isDispatchThread

isWriteThread

getInvokator

invokeLater

invokeLater

invokeLater

invokeLater

load

loadComponents

dispose

writeActionStatistics

runProcessWithProgressSynchronously

runProcessWithProgressSynchronously

runProcessWithProgressSynchronously

runProcessWithProgressSynchronouslyInReadAction

invokeAndWait

invokeAndWait

getCurrentModalityState

getModalityStateForComponent

getAnyModalityState

getDefaultModalityState

getNoneModalityState

getStartTime

getIdleTime

restart

restart

exit

restart

exit

isCurrentWriteOnEdt

invokeLaterOnWriteThread

invokeLaterOnWriteThread

invokeLaterOnWriteThread

acquireWriteIntentLockIfNeeded

releaseWriteIntentLockIfNeeded

runIntendedWriteActionOnCurrentThread

runUnlockingIntendedWrite

runReadAction

runReadAction

runReadAction

runWriteActionWithNonCancellableProgressInDispatchThread

runWriteActionWithCancellableProgressInDispatchThread

runWriteAction

runWriteAction

runWriteAction

hasWriteAction

assertReadAccessAllowed

isReadAccessAllowed

assertIsDispatchThread

assertIsWriteThread

assertIsDispatchThread