Package com.intellij.openapi.progress.impl

Class ProgressManagerImpl

java.lang.Object

com.intellij.openapi.progress.ProgressIndicatorProvider

com.intellij.openapi.progress.ProgressManager

com.intellij.openapi.progress.impl.CoreProgressManager

com.intellij.openapi.progress.impl.ProgressManagerImpl

All Implemented Interfaces:

Disposable

public class ProgressManagerImpl
extends CoreProgressManager
implements Disposable

Nested Class Summary

Nested classes/interfaces inherited from class com.intellij.openapi.progress.impl.CoreProgressManager

CoreProgressManager.TaskContainer, CoreProgressManager.TaskRunnable

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

Disposable.Parent

Field Summary

Fields inherited from class com.intellij.openapi.progress.impl.CoreProgressManager

ENABLED

Constructor Summary

Constructors

Constructor and Description
ProgressManagerImpl()

Method Summary

Modifier and Type	Method and Description
static void	__testWhileAlwaysCheckingCanceled(java.lang.Runnable runnable)
protected com.intellij.openapi.progress.impl.CoreProgressManager.CheckCanceledHook	createCheckCanceledHook()
void	executeProcessUnderProgress(java.lang.Runnable process, ProgressIndicator progress)
boolean	hasUnsafeProgressIndicator()
void	markProgressSafe(ProgressWindow progress) The passes progress won't count in hasUnsafeProgressIndicator() and won't stop from application exiting.
protected void	prioritizingFinished()
protected void	prioritizingStarted()
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).
java.util.concurrent.Future<?>	runProcessWithProgressAsynchronously(Task.Backgroundable task)
boolean	runProcessWithProgressSynchronously(Task task, javax.swing.JComponent parentComponent)

Methods inherited from class com.intellij.openapi.progress.impl.CoreProgressManager

assertUnderProgress, computeInNonCancelableSection, computePrioritized, createTaskRunnable, dispose, doCheckCanceled, executeNonCancelableSection, finishTask, getCurrentThreadProgressModality, getProgressIndicator, hasModalProgressIndicator, hasProgressIndicator, indicatorCanceled, isCanceledThread, isInNonCancelableSection, isPrioritizedThread, restorePrioritizing, run, runCheckCanceledHooks, runProcess, runProcessWithProgressAsync, runProcessWithProgressAsynchronously, runProcessWithProgressAsynchronously, runProcessWithProgressAsynchronously, runProcessWithProgressAsynchronously, runProcessWithProgressAsynchronously, runProcessWithProgressInCurrentThread, runProcessWithProgressSynchronously, runProcessWithProgressSynchronously, runProcessWithProgressSynchronously, sleepIfNeededToGivePriorityToAnotherThread, 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

Methods inherited from interface com.intellij.openapi.Disposable

dispose

Constructor Detail

ProgressManagerImpl

public ProgressManagerImpl()

Method Detail

hasUnsafeProgressIndicator

public boolean hasUnsafeProgressIndicator()

Overrides:

hasUnsafeProgressIndicator in class CoreProgressManager

markProgressSafe

public void markProgressSafe(ProgressWindow progress)

The passes progress won't count in hasUnsafeProgressIndicator() and won't stop from application exiting.

executeProcessUnderProgress

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

Overrides:

executeProcessUnderProgress in class CoreProgressManager

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

Throws:

ProcessCanceledException

__testWhileAlwaysCheckingCanceled

public static void __testWhileAlwaysCheckingCanceled(java.lang.Runnable runnable)

runProcessWithProgressSynchronously

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

Overrides:

runProcessWithProgressSynchronously in class CoreProgressManager

runProcessWithProgressAsynchronously

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

Overrides:

runProcessWithProgressAsynchronously in class CoreProgressManager

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

Overrides:

runInReadActionWithWriteActionPriority in class CoreProgressManager

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()

Overrides:

createCheckCanceledHook in class CoreProgressManager

prioritizingStarted

protected void prioritizingStarted()

Overrides:

prioritizingStarted in class CoreProgressManager

prioritizingFinished

protected void prioritizingFinished()

Overrides:

prioritizingFinished in class CoreProgressManager