/*******************************************************************************
 * Copyright (c) 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.internal.progress;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IProgressMonitorWithBlocking;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.core.runtime.jobs.ProgressProvider;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.Workbench;
import org.eclipse.ui.progress.IProgressService;
import org.eclipse.ui.progress.UIJob;

/**
 * JobProgressManager provides the progress monitor to the job manager and
 * informs any ProgressContentProviders of changes.
 */
public class ProgressManager extends ProgressProvider implements IProgressService {

	private static ProgressManager singleton;
	private Map jobs = Collections.synchronizedMap(new HashMap());
	private Collection listeners = Collections.synchronizedList(new ArrayList());
	Object listenerKey = new Object();
	private WorkbenchMonitorProvider monitorProvider;
	private ProgressFeedbackManager feedbackManager = new ProgressFeedbackManager();
	IJobChangeListener changeListener;

	static final String PROGRESS_VIEW_NAME = "org.eclipse.ui.views.ProgressView"; //$NON-NLS-1$
	static final String PROGRESS_FOLDER = "icons/full/progress/"; //$NON-NLS-1$

	private static final String PROGRESS_20 = "progress20.gif"; //$NON-NLS-1$
	private static final String PROGRESS_40 = "progress40.gif"; //$NON-NLS-1$
	private static final String PROGRESS_60 = "progress60.gif"; //$NON-NLS-1$
	private static final String PROGRESS_80 = "progress80.gif"; //$NON-NLS-1$
	private static final String PROGRESS_100 = "progress100.gif"; //$NON-NLS-1$

	private static final String SLEEPING_JOB = "sleeping.gif"; //$NON-NLS-1$
	private static final String WAITING_JOB = "waiting.gif"; //$NON-NLS-1$
	private static final String ERROR_JOB = "errorstate.gif"; //$NON-NLS-1$
	private static final String BLOCKED_JOB = "lockedstate.gif"; //$NON-NLS-1$

	private static final String PROGRESS_20_KEY = "PROGRESS_20"; //$NON-NLS-1$
	private static final String PROGRESS_40_KEY = "PROGRESS_40"; //$NON-NLS-1$
	private static final String PROGRESS_60_KEY = "PROGRESS_60"; //$NON-NLS-1$
	private static final String PROGRESS_80_KEY = "PROGRESS_80"; //$NON-NLS-1$
	private static final String PROGRESS_100_KEY = "PROGRESS_100"; //$NON-NLS-1$

	private static final String SLEEPING_JOB_KEY = "SLEEPING_JOB"; //$NON-NLS-1$
	private static final String WAITING_JOB_KEY = "WAITING_JOB"; //$NON-NLS-1$
	private static final String ERROR_JOB_KEY = "ERROR_JOB"; //$NON-NLS-1$
	private static final String BLOCKED_JOB_KEY = "LOCKED_JOB"; //$NON-NLS-1$

	//A list of keys for looking up the images in the image registry
	static String[] keys = new String[] { PROGRESS_20_KEY, PROGRESS_40_KEY, PROGRESS_60_KEY, PROGRESS_80_KEY, PROGRESS_100_KEY };

	Hashtable runnableMonitors = new Hashtable();
	

	/**
	 * Get the progress manager currently in use.
	 * 
	 * @return JobProgressManager
	 */
	public static ProgressManager getInstance() {
		if (singleton == null)
			singleton = new ProgressManager();
		return singleton;
	}

	/**
	 * The JobMonitor is the inner class that handles the IProgressMonitor
	 * integration with the ProgressMonitor.
	 */
	private class JobMonitor implements IProgressMonitorWithBlocking {
		Job job;
		IProgressMonitor workbenchMonitor;
		String currentTaskName;

		/**
		 * Create a monitor on the supplied job.
		 * 
		 * @param newJob
		 */
		JobMonitor(Job newJob) {
			job = newJob;
			workbenchMonitor = monitorProvider.getMonitor(job);
		}
		
		
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#beginTask(java.lang.String,
		 *      int)
		 */
		public void beginTask(String taskName, int totalWork) {
			JobInfo info = getJobInfo(job);
			info.beginTask(taskName, totalWork);
			refresh(info);
			currentTaskName = taskName;
			workbenchMonitor.beginTask(taskName, totalWork);
		}
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#done()
		 */
		public void done() {
			JobInfo info = getJobInfo(job);
			info.clearTaskInfo();
			info.clearChildren();
			workbenchMonitor.done();
			runnableMonitors.remove(this);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#internalWorked(double)
		 */
		public void internalWorked(double work) {
			JobInfo info = getJobInfo(job);
			if (info.hasTaskInfo()) {
				info.addWork(work);
				refresh(info);
			}
			workbenchMonitor.internalWorked(work);
		}
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#isCanceled()
		 */
		public boolean isCanceled() {
			JobInfo info = getJobInfo(job);
			return info.isCanceled();
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#setCanceled(boolean)
		 */
		public void setCanceled(boolean value) {
			workbenchMonitor.setCanceled(value);
			JobInfo info = getJobInfo(job);

			//Don't bother cancelling twice
			if (value && !info.isCanceled())
				info.cancel();
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#setTaskName(java.lang.String)
		 */
		public void setTaskName(String taskName) {

			JobInfo info = getJobInfo(job);
			if (info.hasTaskInfo())
				info.setTaskName(taskName);
			else {
				beginTask(taskName, 100);
				return;
			}

			info.clearChildren();
			refresh(info);
			currentTaskName = taskName;
			workbenchMonitor.setTaskName(taskName);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#subTask(java.lang.String)
		 */
		public void subTask(String name) {

			if (name.length() == 0)
				return;
			JobInfo info = getJobInfo(job);

			info.clearChildren();
			info.addSubTask(name);
			refresh(info);
			workbenchMonitor.subTask(name);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#worked(int)
		 */
		public void worked(int work) {
			internalWorked(work);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitorWithBlocking#clearBlocked()
		 */
		public void clearBlocked() {
			JobInfo info = getJobInfo(job);
			info.setBlockedStatus(null);
			refresh(info);

		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitorWithBlocking#setBlocked(org.eclipse.core.runtime.IStatus)
		 */
		public void setBlocked(IStatus reason) {
			JobInfo info = getJobInfo(job);
			info.setBlockedStatus(null);
			refresh(info);
		}
	}

	/**
	 * Create a new instance of the receiver.
	 */
	ProgressManager() {
		Platform.getJobManager().setProgressProvider(this);
		createChangeListener();
		Platform.getJobManager().addJobChangeListener(this.changeListener);
		monitorProvider = new WorkbenchMonitorProvider();
		URL iconsRoot = Platform.getPlugin(PlatformUI.PLUGIN_ID).find(new Path(ProgressManager.PROGRESS_FOLDER));

		try {
			setUpImage(iconsRoot, PROGRESS_20, PROGRESS_20_KEY);
			setUpImage(iconsRoot, PROGRESS_40, PROGRESS_40_KEY);
			setUpImage(iconsRoot, PROGRESS_60, PROGRESS_60_KEY);
			setUpImage(iconsRoot, PROGRESS_80, PROGRESS_80_KEY);
			setUpImage(iconsRoot, PROGRESS_100, PROGRESS_100_KEY);

			setUpImage(iconsRoot, SLEEPING_JOB, SLEEPING_JOB_KEY);
			setUpImage(iconsRoot, WAITING_JOB, WAITING_JOB_KEY);
			setUpImage(iconsRoot, ERROR_JOB, ERROR_JOB_KEY);
			setUpImage(iconsRoot, BLOCKED_JOB, BLOCKED_JOB_KEY);

		} catch (MalformedURLException e) {
			ProgressManagerUtil.logException(e);
		}

	}
	
	/**
	 * Return the IJobChangeListener registered with the Job manager. 
	 * @return IJobChangeListener
	 */
	private void createChangeListener(){
		
		changeListener =
			new JobChangeAdapter(){				
				/*
				 * (non-Javadoc)
				 * 
				 * @see org.eclipse.core.runtime.jobs.JobChangeAdapter#aboutToRun(org.eclipse.core.runtime.jobs.IJobChangeEvent)
				 */
				public void aboutToRun(IJobChangeEvent event) {
					JobInfo info = getJobInfo(event.getJob());
					refresh(info);
				}
	
				/*
				 * (non-Javadoc)
				 * 
				 * @see org.eclipse.core.runtime.jobs.JobChangeAdapter#done(org.eclipse.core.runtime.jobs.IJobChangeEvent)
				 */
				public void done(IJobChangeEvent event) {
					if(!PlatformUI.isWorkbenchRunning())
						return;
					JobInfo info = getJobInfo(event.getJob());
					if (event.getResult().getSeverity() == IStatus.ERROR) {
						info.setError(event.getResult());
							UIJob job = new UIJob(ProgressMessages.getString("JobProgressManager.OpenProgressJob")) {//$NON-NLS-1$
							/*
							 * (non-Javadoc)
							 * 
							 * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)
							 */
							public IStatus runInUIThread(IProgressMonitor monitor) {
	
								IWorkbench workbench = PlatformUI.getWorkbench();
	
								//Abort on shutdown
								if (workbench instanceof Workbench && ((Workbench) workbench).isClosing())
									return Status.CANCEL_STATUS;
								IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
	
								if (window == null)
									return Status.CANCEL_STATUS;
								ProgressManagerUtil.openProgressView(window);
								return Status.OK_STATUS;
							}
						};
						job.schedule();
						refresh(info);
	
					} else {
						jobs.remove(event.getJob());
						//Only refresh if we are showing it
						remove(info);
	
						//If there are no more left then refresh all on the last displayed one
						if (hasNoRegularJobInfos() 
								&& !isNonDisplayableJob(event.getJob(),false))
							refreshAll();
					}
				}
				
				/*
				 * (non-Javadoc)
				 * 
				 * @see org.eclipse.core.runtime.jobs.JobChangeAdapter#scheduled(org.eclipse.core.runtime.jobs.IJobChangeEvent)
				 */
				public void scheduled(IJobChangeEvent event) {
					if (isNeverDisplayedJob(event.getJob()))
						return;
	
					if (jobs.containsKey(event.getJob()))
						refresh(getJobInfo(event.getJob()));
					else {
						JobInfo info = new JobInfo(event.getJob());
						jobs.put(event.getJob(), info);
						add(info);
					}
				}			
			
			};
	}

	/**
	 * Set up the image in the image regsitry.
	 * 
	 * @param iconsRoot
	 * @param fileName
	 * @param key
	 * @throws MalformedURLException
	 */
	private void setUpImage(URL iconsRoot, String fileName, String key) throws MalformedURLException {
		JFaceResources.getImageRegistry().put(key, ImageDescriptor.createFromURL(new URL(iconsRoot, fileName)));

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.runtime.jobs.IProgressProvider#createMonitor(org.eclipse.core.runtime.jobs.Job)
	 */
	public IProgressMonitor createMonitor(Job job) {
		return progressFor(job);
	}

	/**
	 * Return a monitor for the job. Check if we cached a monitor for this job
	 * previously for a long operation timeout check.
	 * 
	 * @param job
	 * @return IProgressMonitor
	 */
	private JobMonitor progressFor(Job job) {
		if (runnableMonitors.containsKey(job))
			return (JobMonitor) runnableMonitors.get(job);
		else
			return new JobMonitor(job);
	}

	/**
	 * Add an IJobProgressManagerListener to listen to the changes.
	 * 
	 * @param listener
	 */
	void addListener(IJobProgressManagerListener listener) {
		synchronized (listenerKey) {
			listeners.add(listener);
		}
	}

	/**
	 * Remove the supplied IJobProgressManagerListener from the list of
	 * listeners.
	 * 
	 * @param listener
	 */
	void removeListener(IJobProgressManagerListener listener) {
		synchronized (listenerKey) {
			listeners.remove(listener);
		}

	}
	

	/**
	 * Get the JobInfo for the job. If it does not exist create it.
	 * 
	 * @param job
	 * @return
	 */
	JobInfo getJobInfo(Job job) {
		JobInfo info = (JobInfo) jobs.get(job);
		if (info == null) {
			info = new JobInfo(job);
			jobs.put(job, info);
		}
		return info;
	}

	/**
	 * Refresh the IJobProgressManagerListeners as a result of a change in
	 * info.
	 * 
	 * @param info
	 */
	public void refresh(JobInfo info) {

		synchronized (listenerKey) {
			Iterator iterator = listeners.iterator();
			while (iterator.hasNext()) {
				IJobProgressManagerListener listener = (IJobProgressManagerListener) iterator.next();
				if (!isNonDisplayableJob(info.getJob(), listener.showsDebug()))
					listener.refresh(info);
			}
		}
	}

	/**
	 * Refresh all the IJobProgressManagerListener as a result of a change in
	 * the whole model.
	 * 
	 * @param info
	 */
	public void refreshAll() {
		synchronized (listenerKey) {
			Iterator iterator = listeners.iterator();
			while (iterator.hasNext()) {
				IJobProgressManagerListener listener = (IJobProgressManagerListener) iterator.next();
				listener.refreshAll();
			}
		}

	}

	/**
	 * Refresh the content providers as a result of a deletion of info.
	 * 
	 * @param info
	 */
	public void remove(JobInfo info) {

		synchronized (listenerKey) {
			Iterator iterator = listeners.iterator();
			while (iterator.hasNext()) {
				IJobProgressManagerListener listener = (IJobProgressManagerListener) iterator.next();
				if (!isNonDisplayableJob(info.getJob(), listener.showsDebug()))
					listener.remove(info);
			}
		}
	}

	/**
	 * Refresh the content providers as a result of an addition of info.
	 * 
	 * @param info
	 */
	public void add(JobInfo info) {
		synchronized (listenerKey) {
			Iterator iterator = listeners.iterator();
			while (iterator.hasNext()) {
				IJobProgressManagerListener listener = (IJobProgressManagerListener) iterator.next();
				if (!isNonDisplayableJob(info.getJob(), listener.showsDebug()))
					listener.add(info);
			}
		}

	}

	/**
	 * Return whether or not this job is currently displayable.
	 * 
	 * @param job
	 * @param debug
	 *            If the listener is in debug mode.
	 * @return
	 */
	boolean isNonDisplayableJob(Job job, boolean debug) {
		if (isNeverDisplayedJob(job))
			return true;
		if (debug) //Always display in debug mode
			return false;
		else
			return job.isSystem() || job.getState() == Job.SLEEPING;
	}

	/**
	 * Return whether or not this job is ever displayable.
	 * 
	 * @param job
	 * @return
	 */
	private boolean isNeverDisplayedJob(Job job) {
		return job == null;
	}

	/**
	 * Return the current job infos filtered on debug mode.
	 * @param debug
	 * @return
	 */
	public JobInfo[] getJobInfos(boolean debug) {
		synchronized (jobs) {
			Iterator iterator = jobs.keySet().iterator();
			Collection result = new ArrayList();
			while (iterator.hasNext()) {
				Job next = (Job) iterator.next();
				if(!isNonDisplayableJob(next,debug))
					result.add(jobs.get(next));
			}
			JobInfo[] infos = new JobInfo[result.size()];
			result.toArray(infos);
			return infos;
		}
	}

	/**
	 * Return whether or not there are any jobs being displayed.
	 * 
	 * @return boolean
	 */
	public boolean hasJobInfos() {
		synchronized (jobs) {
			Iterator iterator = jobs.keySet().iterator();
			while (iterator.hasNext()) {
				return true;
			}
			return false;
		}
	}

	/**
	 * Return true if there are no jobs or they are all debug.
	 * 
	 * @return boolean
	 */
	private boolean hasNoRegularJobInfos() {
		synchronized (jobs) {

			Iterator iterator = jobs.keySet().iterator();
			while (iterator.hasNext()) {
				Job next = (Job) iterator.next();
				if (!isNonDisplayableJob(next, false))
					return false;
			}
			return true;
		}
	}

	/**
	 * Clear the job out of the list of those being displayed. Only do this for
	 * jobs that are an error.
	 * 
	 * @param job
	 */
	void clearJob(Job job) {
		JobInfo info = (JobInfo) jobs.get(job);
		if (info != null && info.getErrorStatus() != null) {
			jobs.remove(job);
			remove(info);
		}
	}

	/**
	 * Clear all of the errors from the list.
	 */
	void clearAllErrors() {
		Collection jobsToDelete = new ArrayList();
		synchronized (jobs) {
			Iterator keySet = jobs.keySet().iterator();
			while (keySet.hasNext()) {
				Object job = keySet.next();
				JobInfo info = (JobInfo) jobs.get(job);
				if (info.getErrorStatus() != null)
					jobsToDelete.add(job);
			}
		}

		Iterator deleteSet = jobsToDelete.iterator();
		while (deleteSet.hasNext()) {
			jobs.remove(deleteSet.next());
		}
		refreshAll();
	}

	/**
	 * Return whether or not there are any errors displayed.
	 * 
	 * @return
	 */
	boolean hasErrorsDisplayed() {

		synchronized (jobs) {
			Iterator keySet = jobs.keySet().iterator();
			while (keySet.hasNext()) {
				Object job = keySet.next();
				JobInfo info = (JobInfo) jobs.get(job);
				if (info.getErrorStatus() != null)
					return true;
			}
		}

		return false;
	}

	/**
	 * Returns the image descriptor with the given relative path.
	 * 
	 * @param source
	 * @return Image
	 */
	Image getImage(ImageData source) {
		ImageData mask = source.getTransparencyMask();
		return new Image(null, source, mask);
	}

	/**
	 * Returns the image descriptor with the given relative path.
	 * 
	 * @param fileSystemPath
	 *            The URL for the file system to the image.
	 * @param loader -
	 *            the loader used to get this data
	 * @return ImageData[]
	 */
	ImageData[] getImageData(URL fileSystemPath, ImageLoader loader) {
		try {
			InputStream stream = fileSystemPath.openStream();
			ImageData[] result = loader.load(stream);
			stream.close();
			return result;
		} catch (FileNotFoundException exception) {
			ProgressManagerUtil.logException(exception);
			return null;
		} catch (IOException exception) {
			ProgressManagerUtil.logException(exception);
			return null;
		}
	}

	/**
	 * Get the current image for the receiver. If there is no progress yet
	 * return null.
	 * 
	 * @param element
	 * @return
	 */
	Image getDisplayImage(JobTreeElement element) {
		if (element.isJobInfo()) {
			JobInfo info = (JobInfo) element;
			int done = info.getPercentDone();
			if (done > 0) {
				int index = Math.min(4, (done / 20));
				return JFaceResources.getImage(keys[index]);
			} else {
				if (info.isBlocked())
					return JFaceResources.getImage(BLOCKED_JOB_KEY);
				if (info.getErrorStatus() != null)
					return JFaceResources.getImage(ERROR_JOB_KEY);
				int state = info.getJob().getState();
				if (state == Job.SLEEPING)
					return JFaceResources.getImage(SLEEPING_JOB_KEY);
				if (state == Job.WAITING)
					return JFaceResources.getImage(WAITING_JOB_KEY);

				//By default return the 0 progress image
				return JFaceResources.getImage(keys[0]);
			}
		}
		return null;
	}

	/**
	 * Block the current thread until UIJob is served. The message is used to
	 * announce to the user a pending UI Job.
	 * 
	 * Note: This is experimental API and subject to change at any time.
	 * 
	 * @param job
	 * @param message
	 * @return IStatus
	 * @since 3.0
	 */
	public IStatus requestInUI(UIJob job, String message) {
		return feedbackManager.requestInUI(job, message);
	}

	/**
	 * Return the ProgressFeedbackManager for the receiver.
	 * 
	 * @return ProgressFeedbackManager
	 */
	ProgressFeedbackManager getFeedbackManager() {
		return feedbackManager;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.progress.IProgressManager#busyCursorWhile(org.eclipse.jface.operation.IRunnableWithProgress)
	 */
	public void busyCursorWhile(final IRunnableWithProgress runnable) throws InvocationTargetException, InterruptedException {

		final ProgressMonitorJobsDialog dialog = new ProgressMonitorJobsDialog(null);
		dialog.setOpenOnRun(false);
		final boolean[] busy = { true };

		scheduleProgressMonitorJob(dialog,busy);

		final InvocationTargetException[] invokes = new InvocationTargetException[1];
		final InterruptedException[] interrupt = new InterruptedException[1];

		invokes[0] = null;
		interrupt[0] = null;

		BusyIndicator.showWhile(Display.getCurrent(), new Runnable() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see java.lang.Runnable#run()
			 */
			public void run() {
				try {
					dialog.setOpenOnRun(false);
					dialog.run(true /* fork */
					, true /* cancelable */
					, runnable);

					//Run the event loop until the progress job wakes up
					Display display = Display.getCurrent();
					while (busy[0]) {
						if (!display.readAndDispatch())
							display.sleep();
					}

				} catch (InvocationTargetException e) {
					invokes[0] = e;
				} catch (InterruptedException e) {
					interrupt[0] = e;
				}
			}
		});

		if (invokes[0] != null)
			throw invokes[0];

		if (interrupt[0] != null)
			throw interrupt[0];

	}

	/**
	 * Schedule the job that starts the progress monitor.
	 * @param dialog
	 * @param busy
	 */
	private void scheduleProgressMonitorJob(final ProgressMonitorJobsDialog dialog, final boolean[] busy) {
		
		final boolean [] defer = new boolean[1];
		defer[0] = false;
		final UIJob updateJob = new UIJob(ProgressMessages.getString("ProgressManager.openJobName")) {//$NON-NLS-1$
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)
			 */
			public IStatus runInUIThread(IProgressMonitor monitor) {
				
				//If there is a modal shell open then wait
				Shell[] shells = getDisplay().getShells();
				for(int i = 0; i < shells.length; i ++){
					
					//Do not stop for shells that will not
					//block the user.
					if(shells[i].isVisible()){
						int style = shells[i].getStyle();
						if((style & SWT.APPLICATION_MODAL
							| style & SWT.SYSTEM_MODAL
								| style & SWT.PRIMARY_MODAL) > 0){
								defer[0] = true;
								return Status.CANCEL_STATUS;
						}
					}
				}
				
				busy[0] = false;

				dialog.open();
				if (monitor.isCanceled())
					return Status.CANCEL_STATUS;
				else
					return Status.OK_STATUS;
			}
		};
		
		updateJob.addJobChangeListener(new JobChangeAdapter(){
			/* (non-Javadoc)
			 * @see org.eclipse.core.runtime.jobs.JobChangeAdapter#done(org.eclipse.core.runtime.jobs.IJobChangeEvent)
			 */
			public void done(IJobChangeEvent event) {
				
				//If the platform is not runnin exit
				if(!PlatformUI.isWorkbenchRunning())
					return;
				//If we are deferring try again.
				if(defer[0]){
					defer[0] = false;
					updateJob.schedule(LONG_OPERATION_MILLISECONDS);
				}
			}
		});

		updateJob.schedule(LONG_OPERATION_MILLISECONDS);
	}
	
	/**
	 * Shutdown the receiver.
	 */
	
	public void shutdown(){
		this.listeners.clear();
		Platform.getJobManager().setProgressProvider(null);
		Platform.getJobManager().removeJobChangeListener(this.changeListener);
	}
}