Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions
Privacy Policy

  




 

 


Eclipse Platform
Release 3.5

org.eclipse.ui.progress
Interface IProgressService

All Superinterfaces:
IRunnableContext
All Known Subinterfaces:
IWorkbenchSiteProgressService

public interface IProgressService
extends IRunnableContext

The progress service is the primary interface to the workbench progress support. It can be obtained from the workbench and then used to show progress for both background operations and operations that run in the UI thread.

All methods on the progress service must be called from the UI thread.

This service can be acquired from your service locator:

        IProgressService service = (IProgressService) getSite().getService(IProgressService.class);
 
  • This service is available globally.

NOTE The progress service must be referenced at least once before it will become the progress provider for the IJobManager in the workbench. This connection is done lazily so that RCP applications will not have to use the IProgressService as the ProgressProvider to the jobs framework if they do not wish to reference it.

Since:
3.0
See Also:
IWorkbench.getProgressService(), IJobManager.setProgressProvider(org.eclipse.core.runtime.jobs.ProgressProvider), IServiceLocator.getService(Class)
Restriction:
This interface is not intended to be implemented by clients.

Method Summary
 void busyCursorWhile ( IRunnableWithProgress runnable)
          Set the cursor to busy and run the runnable in a non-UI Thread.
  Image getIconFor ( Job job)
          Get the icon that has been registered for a Job by checking if the job belongs to any of the registered families.
 int getLongOperationTime ()
          The time at which an operation becomes considered a long operation.
 void registerIconForFamily ( ImageDescriptor icon, Object family)
          Register the ImageDescriptor to be the icon used for all jobs that belong to family within the workbench.
 void run (boolean fork, boolean cancelable, IRunnableWithProgress runnable)
          This specialization of IRunnableContext#run(boolean, boolean, IRunnableWithProgress) might run the runnable asynchronously if fork is true.
 void runInUI ( IRunnableContext context, IRunnableWithProgress runnable, ISchedulingRule rule)
          Runs the given operation in the UI thread using the given runnable context.
 void showInDialog ( Shell shell, Job job)
          Open a dialog on job when it starts to run and close it when the job is finished.
 

Method Detail

getLongOperationTime

int getLongOperationTime()
The time at which an operation becomes considered a long operation. Used to determine when the busy cursor will be replaced with a progress monitor.

Returns:
int
See Also:
busyCursorWhile(IRunnableWithProgress)

registerIconForFamily

void registerIconForFamily(
ImageDescriptor icon,
                           
Object family)
Register the ImageDescriptor to be the icon used for all jobs that belong to family within the workbench.

Parameters:
icon - ImageDescriptor that will be used when the job is being displayed
family - The family to associate with
See Also:
Job.belongsTo(Object)

runInUI

void runInUI(
IRunnableContext context,
             
IRunnableWithProgress runnable,
             
ISchedulingRule rule)
             throws 
InvocationTargetException,
                    
InterruptedException
Runs the given operation in the UI thread using the given runnable context. The given scheduling rule, if any, will be acquired for the duration of the operation. If the rule is not available when this method is called, a progress dialog will be displayed that gives users control over the background processes that may be blocking the runnable from proceeding.

This method can act as a wrapper for uses of IRunnableContext where the fork parameter was false.

Note: Running long operations in the UI thread is generally not recommended. This can result in the UI becoming unresponsive for the duration of the operation. Where possible, busyCursorWhile should be used instead.

Modal dialogs should also be avoided in the runnable as there will already be a modal progress dialog open when this operation runs.

Parameters:
context - The runnable context to run the operation in
runnable - The operation to run
rule - A scheduling rule, or null
Throws:
InvocationTargetException - wraps any exception or error which occurs while running the runnable
InterruptedException - propagated by the context if the runnable acknowledges cancelation by throwing this exception.
See Also:
Dialog, SWT.APPLICATION_MODAL

getIconFor

Image getIconFor(
Job job)
Get the icon that has been registered for a Job by checking if the job belongs to any of the registered families.

Parameters:
job -
Returns:
Icon or null if there isn't one.
See Also:
registerIconForFamily(ImageDescriptor,Object)

busyCursorWhile

void busyCursorWhile(
IRunnableWithProgress runnable)
                     throws 
InvocationTargetException,
                            
InterruptedException
Set the cursor to busy and run the runnable in a non-UI Thread. The calling thread will be blocked for the duration of the execution of the supplied runnable. After the cursor has been running for getLongOperationTime() replace it with a ProgressMonitorDialog so that the user may cancel. Do not open the ProgressMonitorDialog if there is already a modal dialog open.

Parameters:
runnable - The runnable to execute and show the progress for.
Throws:
InvocationTargetException
InterruptedException
See Also:
getLongOperationTime()

run

void run(boolean fork,
         boolean cancelable,
         
IRunnableWithProgress runnable)
         throws 
InvocationTargetException,
                
InterruptedException
This specialization of IRunnableContext#run(boolean, boolean, IRunnableWithProgress) might run the runnable asynchronously if fork is true.

Specified by:
run in interface IRunnableContext
Parameters:
fork - true if the runnable should be run in a separate thread, and false to run in the same thread
cancelable - true to enable the cancelation, and false to make the operation uncancellable
runnable - the runnable to run
Throws:
InvocationTargetException - wraps any exception or error which occurs while running the runnable
InterruptedException - propagated by the context if the runnable acknowledges cancelation by throwing this exception. This should not be thrown if cancelable is false.
Since:
3.2

showInDialog

void showInDialog(
Shell shell,
                  
Job job)
Open a dialog on job when it starts to run and close it when the job is finished. Wait for ProgressManagerUtil#SHORT_OPERATION_TIME before opening the dialog. Do not open if it is already done or if the user has set a preference to always run in the background. Parent the dialog from the shell.

Parameters:
shell - The Shell to parent the dialog from or null if the active shell is to be used.
job - The Job that will be reported in the dialog. job must not be null.

Eclipse Platform
Release 3.5

Guidelines for using Eclipse APIs.

Copyright (c) Eclipse contributors and others 2000, 2008. All rights reserved.


 
 
  Published under the terms of the Eclipse Public License Version 1.0 ("EPL") Design by Interspire