Package com.intellij.openapi.progress.impl

Class CoreProgressManager

java.lang.Object

com.intellij.openapi.progress.ProgressIndicatorProvider

com.intellij.openapi.progress.ProgressManager

com.intellij.openapi.progress.impl.CoreProgressManager

All Implemented Interfaces:

Disposable

Direct Known Subclasses:

ProgressManagerImpl

public class CoreProgressManager
extends ProgressManager
implements Disposable

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	CoreProgressManager.TaskContainer
protected static class	CoreProgressManager.TaskRunnable Deprecated.

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

Disposable.Parent

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	ENABLED

Constructor Summary

Constructors

Constructor and Description
CoreProgressManager()

Method Summary

Modifier and Type	Method and Description
static void	assertUnderProgress(ProgressIndicator indicator)
<T,E extends java.lang.Exception> T	computeInNonCancelableSection(ThrowableComputable<T,E> computable) Runs the specified operation and return its result in non-cancellable manner synchronously on the same thread were it was called.
<T,E extends java.lang.Throwable> T	computePrioritized(ThrowableComputable<T,E> computable) Performs the given computation while giving more priority to the current thread (by forcing all other non-prioritized threads to sleep a bit whenever they call ProgressManager.checkCanceled().
protected com.intellij.openapi.progress.impl.CoreProgressManager.CheckCanceledHook	createCheckCanceledHook()
protected CoreProgressManager.TaskRunnable	createTaskRunnable(Task task, ProgressIndicator indicator, java.lang.Runnable continuation) Deprecated.
void	dispose() Usually not invoked directly, see class javadoc.
protected void	doCheckCanceled()
void	executeNonCancelableSection(java.lang.Runnable runnable) Runs the specified operation in non-cancellable manner synchronously on the same thread were it was called.
void	executeProcessUnderProgress(java.lang.Runnable process, ProgressIndicator progress)
protected void	finishTask(Task task, boolean canceled, java.lang.Throwable error)
static ModalityState	getCurrentThreadProgressModality()
ProgressIndicator	getProgressIndicator()
boolean	hasModalProgressIndicator()
boolean	hasProgressIndicator()
boolean	hasUnsafeProgressIndicator()
protected void	indicatorCanceled(ProgressIndicator indicator)
static boolean	isCanceledThread(java.lang.Thread thread)
boolean	isInNonCancelableSection()
boolean	isPrioritizedThread(java.lang.Thread from)
protected void	prioritizingFinished()
protected void	prioritizingStarted()
void	restorePrioritizing()
void	run(Task task) Runs a specified task in either background/foreground thread and shows a progress dialog.
static boolean	runCheckCanceledHooks(ProgressIndicator indicator)
boolean	runInReadActionWithWriteActionPriority(java.lang.Runnable action, ProgressIndicator indicator) This method attempts to run provided action synchronously in a read action, so that, if possible, it wouldn't impact any pending, executing or future write actions (for this to work effectively the action should invoke ProgressManager.checkCanceled() or ProgressIndicator.checkCanceled() often enough).
void	runProcess(java.lang.Runnable process, ProgressIndicator progress) Runs the given process synchronously in calling thread, associating this thread with the specified progress indicator.
protected java.util.concurrent.Future<?>	runProcessWithProgressAsync(Task.Backgroundable task, java.util.concurrent.CompletableFuture<? extends ProgressIndicator> progressIndicator, java.lang.Runnable continuation, com.intellij.openapi.progress.impl.CoreProgressManager.IndicatorDisposable indicatorDisposable, ModalityState modalityState)
void	runProcessWithProgressAsynchronously(Project project, java.lang.String progressTitle, java.lang.Runnable process, java.lang.Runnable successRunnable, java.lang.Runnable canceledRunnable) Runs a specified process in a background thread and shows a progress dialog, which can be made non-modal by pressing background button.
void	runProcessWithProgressAsynchronously(Project project, java.lang.String progressTitle, java.lang.Runnable process, java.lang.Runnable successRunnable, java.lang.Runnable canceledRunnable, PerformInBackgroundOption option) Runs a specified process in a background thread and shows a progress dialog, which can be made non-modal by pressing background button.
java.util.concurrent.Future<?>	runProcessWithProgressAsynchronously(Task.Backgroundable task)
void	runProcessWithProgressAsynchronously(Task.Backgroundable task, ProgressIndicator progressIndicator)
java.util.concurrent.Future<?>	runProcessWithProgressAsynchronously(Task.Backgroundable task, ProgressIndicator progressIndicator, java.lang.Runnable continuation)
java.util.concurrent.Future<?>	runProcessWithProgressAsynchronously(Task.Backgroundable task, ProgressIndicator progressIndicator, java.lang.Runnable continuation, ModalityState modalityState)
void	runProcessWithProgressInCurrentThread(Task task, ProgressIndicator progressIndicator, ModalityState modalityState)
boolean	runProcessWithProgressSynchronously(java.lang.Runnable process, java.lang.String progressTitle, boolean canBeCanceled, Project project) Runs the specified operation in a background thread and shows a modal progress dialog in the main thread while the operation is executing.
boolean	runProcessWithProgressSynchronously(java.lang.Runnable process, java.lang.String progressTitle, boolean canBeCanceled, Project project, javax.swing.JComponent parentComponent) Runs the specified operation in a background thread and shows a modal progress dialog in the main thread while the operation is executing.
boolean	runProcessWithProgressSynchronously(Task task, javax.swing.JComponent parentComponent)
<T,E extends java.lang.Exception> T	runProcessWithProgressSynchronously(ThrowableComputable<T,E> process, java.lang.String progressTitle, boolean canBeCanceled, Project project) Runs the specified operation in a background thread and shows a modal progress dialog in the main thread while the operation is executing.
protected boolean	sleepIfNeededToGivePriorityToAnotherThread()
void	suppressPrioritizing()

Methods inherited from class com.intellij.openapi.progress.ProgressManager

assertNotCircular, canceled, checkCanceled, getInstance, progress, progress, progress2, run, runProcess

Methods inherited from class com.intellij.openapi.progress.ProgressIndicatorProvider

getGlobalProgressIndicator, startNonCancelableSectionIfSupported

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ENABLED

public static final boolean ENABLED

Constructor Detail

CoreProgressManager

public CoreProgressManager()

Method Detail

dispose

public void dispose()

Description copied from interface: Disposable

Usually not invoked directly, see class javadoc.

Specified by:

dispose in interface Disposable

runCheckCanceledHooks

public static boolean runCheckCanceledHooks(ProgressIndicator indicator)

doCheckCanceled

protected void doCheckCanceled()
                        throws ProcessCanceledException

Specified by:

doCheckCanceled in class ProgressIndicatorProvider

Throws:

ProcessCanceledException

hasProgressIndicator

public boolean hasProgressIndicator()

Specified by:

hasProgressIndicator in class ProgressManager

hasUnsafeProgressIndicator

public boolean hasUnsafeProgressIndicator()

Specified by:

hasUnsafeProgressIndicator in class ProgressManager

hasModalProgressIndicator

public boolean hasModalProgressIndicator()

Specified by:

hasModalProgressIndicator in class ProgressManager

runProcess

public void runProcess(java.lang.Runnable process,
                       ProgressIndicator progress)

Description copied from class: ProgressManager

Runs the given process synchronously in calling thread, associating this thread with the specified progress indicator. This means that it'll be returned by ProgressManager.getProgressIndicator() inside the process, and ProgressManager.checkCanceled() will throw a ProcessCanceledException if the progress indicator is canceled.

Specified by:

runProcess in class ProgressManager

progress - an indicator to use, null means reuse current progress

executeNonCancelableSection

public void executeNonCancelableSection(java.lang.Runnable runnable)

Description copied from class: ProgressManager

Runs the specified operation in non-cancellable manner synchronously on the same thread were it was called.

Specified by:

executeNonCancelableSection in class ProgressManager

Parameters:

runnable - the operation to execute

See Also:

ProgressManager.computeInNonCancelableSection(ThrowableComputable)

computeInNonCancelableSection

public <T,E extends java.lang.Exception> T computeInNonCancelableSection(ThrowableComputable<T,E> computable)
                                                                  throws E extends java.lang.Exception

Description copied from class: ProgressManager

Runs the specified operation and return its result in non-cancellable manner synchronously on the same thread were it was called.

Specified by:

computeInNonCancelableSection in class ProgressManager

Parameters:

computable - the operation to execute

Throws:

E extends java.lang.Exception

See Also:

ProgressManager.executeNonCancelableSection(Runnable)

runProcessWithProgressSynchronously

public boolean runProcessWithProgressSynchronously(java.lang.Runnable process,
                                                   java.lang.String progressTitle,
                                                   boolean canBeCanceled,
                                                   Project project)

Description copied from class: ProgressManager

Runs the specified operation in a background thread and shows a modal progress dialog in the main thread while the operation is executing. If a dialog can't be shown (e.g. under write action or in headless environment), runs the given operation synchronously in the calling thread.

Specified by:

runProcessWithProgressSynchronously in class ProgressManager

Parameters:

process - the operation to execute.

progressTitle - the title of the progress window.

canBeCanceled - whether "Cancel" button is shown on the progress window.

project - the project in the context of which the operation is executed.

Returns:

true if the operation completed successfully, false if it was cancelled.

runProcessWithProgressSynchronously

public <T,E extends java.lang.Exception> T runProcessWithProgressSynchronously(ThrowableComputable<T,E> process,
                                                                               java.lang.String progressTitle,
                                                                               boolean canBeCanceled,
                                                                               Project project)
                                                                        throws E extends java.lang.Exception

Description copied from class: ProgressManager

Runs the specified operation in a background thread and shows a modal progress dialog in the main thread while the operation is executing. If a dialog can't be shown (e.g. under write action or in headless environment), runs the given operation synchronously in the calling thread.

Specified by:

runProcessWithProgressSynchronously in class ProgressManager

Parameters:

process - the operation to execute.

progressTitle - the title of the progress window.

canBeCanceled - whether "Cancel" button is shown on the progress window.

project - the project in the context of which the operation is executed.

Returns:

true result of operation

Throws:

E - exception thrown by process

E extends java.lang.Exception

runProcessWithProgressSynchronously

public boolean runProcessWithProgressSynchronously(java.lang.Runnable process,
                                                   java.lang.String progressTitle,
                                                   boolean canBeCanceled,
                                                   Project project,
                                                   javax.swing.JComponent parentComponent)

Description copied from class: ProgressManager

Runs the specified operation in a background thread and shows a modal progress dialog in the main thread while the operation is executing. If a dialog can't be shown (e.g. under write action or in headless environment), runs the given operation synchronously in the calling thread.

Specified by:

runProcessWithProgressSynchronously in class ProgressManager

Parameters:

process - the operation to execute.

progressTitle - the title of the progress window.

canBeCanceled - whether "Cancel" button is shown on the progress window.

project - the project in the context of which the operation is executed.

parentComponent - the component which will be used to calculate the progress window ancestor

Returns:

true if the operation completed successfully, false if it was cancelled.

runProcessWithProgressAsynchronously

public void runProcessWithProgressAsynchronously(Project project,
                                                 java.lang.String progressTitle,
                                                 java.lang.Runnable process,
                                                 java.lang.Runnable successRunnable,
                                                 java.lang.Runnable canceledRunnable)

Description copied from class: ProgressManager

Runs a specified process in a background thread and shows a progress dialog, which can be made non-modal by pressing background button. Upon successful termination of the process a successRunnable will be called in Swing UI thread and canceledRunnable will be called if terminated on behalf of the user by pressing either cancel button, while running in a modal state or stop button if running in background.

Specified by:

runProcessWithProgressAsynchronously in class ProgressManager

Parameters:

project - the project in the context of which the operation is executed.

progressTitle - the title of the progress window.

process - the operation to execute.

successRunnable - a callback to be called in Swing UI thread upon normal termination of the process.

canceledRunnable - a callback to be called in Swing UI thread if the process have been canceled by the user.

runProcessWithProgressAsynchronously

public void runProcessWithProgressAsynchronously(Project project,
                                                 java.lang.String progressTitle,
                                                 java.lang.Runnable process,
                                                 java.lang.Runnable successRunnable,
                                                 java.lang.Runnable canceledRunnable,
                                                 PerformInBackgroundOption option)

Description copied from class: ProgressManager

Runs a specified process in a background thread and shows a progress dialog, which can be made non-modal by pressing background button. Upon successful termination of the process a successRunnable will be called in Swing UI thread and canceledRunnable will be called if terminated on behalf of the user by pressing either cancel button, while running in a modal state or stop button if running in background.

Specified by:

runProcessWithProgressAsynchronously in class ProgressManager

Parameters:

project - the project in the context of which the operation is executed.

progressTitle - the title of the progress window.

process - the operation to execute.

successRunnable - a callback to be called in Swing UI thread upon normal termination of the process.

canceledRunnable - a callback to be called in Swing UI thread if the process have been canceled by the user.

option - progress indicator behavior controller.

run

public void run(Task task)

Description copied from class: ProgressManager

Runs a specified task in either background/foreground thread and shows a progress dialog.

Specified by:

run in class ProgressManager

Parameters:

task - task to run (either Task.Modal or Task.Backgroundable).

runProcessWithProgressAsynchronously

public java.util.concurrent.Future<?> runProcessWithProgressAsynchronously(Task.Backgroundable task)

runProcessWithProgressAsynchronously

public java.util.concurrent.Future<?> runProcessWithProgressAsynchronously(Task.Backgroundable task,
                                                                           ProgressIndicator progressIndicator,
                                                                           java.lang.Runnable continuation)

createTaskRunnable

@Deprecated
protected CoreProgressManager.TaskRunnable createTaskRunnable(Task task,
                                                              ProgressIndicator indicator,
                                                              java.lang.Runnable continuation)

Deprecated.

runProcessWithProgressAsynchronously

public java.util.concurrent.Future<?> runProcessWithProgressAsynchronously(Task.Backgroundable task,
                                                                           ProgressIndicator progressIndicator,
                                                                           java.lang.Runnable continuation,
                                                                           ModalityState modalityState)

runProcessWithProgressAsync

protected java.util.concurrent.Future<?> runProcessWithProgressAsync(Task.Backgroundable task,
                                                                     java.util.concurrent.CompletableFuture<? extends ProgressIndicator> progressIndicator,
                                                                     java.lang.Runnable continuation,
                                                                     com.intellij.openapi.progress.impl.CoreProgressManager.IndicatorDisposable indicatorDisposable,
                                                                     ModalityState modalityState)

runProcessWithProgressSynchronously

public boolean runProcessWithProgressSynchronously(Task task,
                                                   javax.swing.JComponent parentComponent)

runProcessWithProgressInCurrentThread

public void runProcessWithProgressInCurrentThread(Task task,
                                                  ProgressIndicator progressIndicator,
                                                  ModalityState modalityState)

finishTask

protected void finishTask(Task task,
                          boolean canceled,
                          java.lang.Throwable error)

runProcessWithProgressAsynchronously

public void runProcessWithProgressAsynchronously(Task.Backgroundable task,
                                                 ProgressIndicator progressIndicator)

Specified by:

runProcessWithProgressAsynchronously in class ProgressManager

getProgressIndicator

public ProgressIndicator getProgressIndicator()

Specified by:

getProgressIndicator in class ProgressManager

executeProcessUnderProgress

public void executeProcessUnderProgress(java.lang.Runnable process,
                                        ProgressIndicator progress)
                                 throws ProcessCanceledException

Specified by:

executeProcessUnderProgress in class ProgressManager

progress - an indicator to use, null means reuse current progress

Throws:

ProcessCanceledException

runInReadActionWithWriteActionPriority

public boolean runInReadActionWithWriteActionPriority(java.lang.Runnable action,
                                                      ProgressIndicator indicator)

Description copied from class: ProgressManager

This method attempts to run provided action synchronously in a read action, so that, if possible, it wouldn't impact any pending, executing or future write actions (for this to work effectively the action should invoke ProgressManager.checkCanceled() or ProgressIndicator.checkCanceled() often enough). It returns true if action was executed successfully. It returns false if the action was not executed successfully, i.e. if:

• write action was in progress when the method was called
• write action was pending when the method was called
• action started to execute, but was aborted using ProcessCanceledException when some other thread initiated write action

Specified by:

runInReadActionWithWriteActionPriority in class ProgressManager

Parameters:

action - the code to execute under read action

indicator - progress indicator that should be cancelled if a write action is about to start. Can be null.

createCheckCanceledHook

protected com.intellij.openapi.progress.impl.CoreProgressManager.CheckCanceledHook createCheckCanceledHook()

indicatorCanceled

protected void indicatorCanceled(ProgressIndicator indicator)

Overrides:

indicatorCanceled in class ProgressManager

isCanceledThread

public static boolean isCanceledThread(java.lang.Thread thread)

isInNonCancelableSection

public boolean isInNonCancelableSection()

Specified by:

isInNonCancelableSection in class ProgressManager

computePrioritized

public <T,E extends java.lang.Throwable> T computePrioritized(ThrowableComputable<T,E> computable)
                                                       throws E extends java.lang.Throwable

Description copied from class: ProgressManager

Performs the given computation while giving more priority to the current thread (by forcing all other non-prioritized threads to sleep a bit whenever they call ProgressManager.checkCanceled().

This is intended for relatively short (expected to be under 10 seconds) background activities that the user is waiting for (e.g. code navigation), and which shouldn't be slowed down by CPU-intensive background tasks like highlighting or indexing.

Specified by:

computePrioritized in class ProgressManager

Throws:

E extends java.lang.Throwable

prioritizingStarted

protected void prioritizingStarted()

prioritizingFinished

protected void prioritizingFinished()

isPrioritizedThread

public boolean isPrioritizedThread(java.lang.Thread from)

suppressPrioritizing

public void suppressPrioritizing()

restorePrioritizing

public void restorePrioritizing()

sleepIfNeededToGivePriorityToAnotherThread

protected boolean sleepIfNeededToGivePriorityToAnotherThread()

getCurrentThreadProgressModality

public static ModalityState getCurrentThreadProgressModality()

assertUnderProgress

public static void assertUnderProgress(ProgressIndicator indicator)