bundles/org.eclipse.jface/src/org/eclipse/jface/dialogs/ProgressMonitorDialog.java - platform/eclipse.platform.ui - Git at Google

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

 import java.lang.reflect.InvocationTargetException;

 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IProgressMonitorWithBlocking;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jface.operation.IRunnableContext;
 import org.eclipse.jface.operation.IRunnableWithProgress;
 import org.eclipse.jface.operation.ModalContext;
 import org.eclipse.jface.resource.JFaceResources;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.graphics.Cursor;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.graphics.Point;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Shell;

 /**
  * A modal dialog that displays progress during a long running operation.
  * <p>
  * This concrete dialog class can be instantiated as is, or further subclassed
  * as required.
  * </p>
  * <p>
  * Typical usage is:
  *
  * <pre>
  *
  *
  *   try {
  *      IRunnableWithProgress op = ...;
  *      new ProgressMonitorDialog(activeShell).run(true, true, op);
  *   } catch (InvocationTargetException e) {
  *      // handle exception
  *   } catch (InterruptedException e) {
  *      // handle cancelation
  *   }
  *
  *
  * </pre>
  *
  * </p>
  * <p>
  * Note that the ProgressMonitorDialog is not intended to be used with multiple
  * runnables - this dialog should be discarded after completion of one
  * IRunnableWithProgress and a new one instantiated for use by a second or
  * sebsequent IRunnableWithProgress to ensure proper initialization.
  * </p>
  * <p>
  * Note that not forking the process will result in it running in the UI which
  * may starve the UI. The most obvious symptom of this problem is non
  * responsiveness of the cancel button. If you are running within the UI Thread
  * you should do the bulk of your work in another Thread to prevent starvation.
  * It is recommended that fork is set to true in most cases.
  * </p>
  */
 public class ProgressMonitorDialog extends IconAndMessageDialog implements
         IRunnableContext {
     /**
      * Name to use for task when normal task name is empty string.
      */
     private static String DEFAULT_TASKNAME = JFaceResources
             .getString("ProgressMonitorDialog.message"); //$NON-NLS-1$

     /**
      * Constants for label and monitor size
      */
     private static int LABEL_DLUS = 21;

     private static int BAR_DLUS = 9;

     /**
      * The progress indicator control.
      */
     protected ProgressIndicator progressIndicator;

     /**
      * The label control for the task. Kept for backwards compatibility.
      */
     protected Label taskLabel;

     /**
      * The label control for the subtask.
      */
     protected Label subTaskLabel;

     /**
      * The Cancel button control.
      */
     protected Button cancel;

     /**
      * Indicates whether the Cancel button is to be shown.
      */
     protected boolean operationCancelableState = false;

     /**
      * Indicates whether the Cancel button is to be enabled.
      */
     protected boolean enableCancelButton;

     /**
      * The progress monitor.
      */
     private ProgressMonitor progressMonitor = new ProgressMonitor();

     /**
      * The name of the current task (used by ProgressMonitor).
      */
     private String task;

     /**
      * The nesting depth of currently running runnables.
      */
     private int nestingDepth;

     /**
      * The cursor used in the cancel button;
      */
     protected Cursor arrowCursor;

     /**
      * The cursor used in the shell;
      */
     private Cursor waitCursor;

     /**
      * Flag indicating whether to open or merely create the dialog before run.
      */
     private boolean openOnRun = true;

     /**
      * Internal progress monitor implementation.
      */
     private class ProgressMonitor implements IProgressMonitorWithBlocking {
         private String fSubTask = "";//$NON-NLS-1$

         private boolean fIsCanceled;

         protected boolean forked = false;

         protected boolean locked = false;

         public void beginTask(String name, int totalWork) {
             if (progressIndicator.isDisposed())
                 return;
             if (name == null)
                 task = "";//$NON-NLS-1$
             else
                 task = name;
             String s = task;
             if (s.length() <= 0)
                 s = DEFAULT_TASKNAME;
             setMessage(s);
             if (!forked)
                 update();
             if (totalWork == UNKNOWN) {
                 progressIndicator.beginAnimatedTask();
             } else {
                 progressIndicator.beginTask(totalWork);
             }
         }

         public void done() {
             if (!progressIndicator.isDisposed()) {
                 progressIndicator.sendRemainingWork();
                 progressIndicator.done();
             }
         }

         public void setTaskName(String name) {
             if (name == null)
                 task = "";//$NON-NLS-1$
             else
                 task = name;
             String s = task;
             if (s.length() <= 0)
                 s = DEFAULT_TASKNAME;
             setMessage(s);
             if (!forked)
                 update();
         }

         public boolean isCanceled() {
             return fIsCanceled;
         }

         public void setCanceled(boolean b) {
             fIsCanceled = b;
             if (locked)
                 clearBlocked();
         }

         public void subTask(String name) {
             if (subTaskLabel.isDisposed())
                 return;
             if (name == null)
                 fSubTask = "";//$NON-NLS-1$
             else
                 fSubTask = name;
             subTaskLabel.setText(shortenText(fSubTask,subTaskLabel));
             if (!forked)
                 subTaskLabel.update();
         }

         public void worked(int work) {
             internalWorked(work);
         }

         public void internalWorked(double work) {
             if (!progressIndicator.isDisposed())
                 progressIndicator.worked(work);
         }

         /*
          * (non-Javadoc)
          *
          * @see org.eclipse.core.runtime.IProgressMonitorWithBlocking#clearBlocked()
          */
         public void clearBlocked() {
             locked = false;
             updateForClearBlocked();
         }

         /*
          * (non-Javadoc)
          *
          * @see org.eclipse.core.runtime.IProgressMonitorWithBlocking#setBlocked(org.eclipse.core.runtime.IStatus)
          */
         public void setBlocked(IStatus reason) {
             locked = true;
             updateForSetBlocked(reason);
         }
     }

     /**
      * Clear blocked state from the receiver.
      */
     protected void updateForClearBlocked() {
         setMessage(task);
         imageLabel.setImage(getImage());
     }

     /**
      * Set blocked state from the receiver.
      *
      * @param reason
      *            IStatus that gives the details
      */
     protected void updateForSetBlocked(IStatus reason) {
         setMessage(reason.getMessage());
         imageLabel.setImage(getImage());
     }

     /**
      * Creates a progress monitor dialog under the given shell. The dialog has a
      * standard title and no image. <code>open</code> is non-blocking.
      *
      * @param parent
      *            the parent shell, or <code>null</code> to create a top-level
      *            shell
      */
     public ProgressMonitorDialog(Shell parent) {
         super(parent);
         setShellStyle(getDefaultOrientation() | SWT.BORDER | SWT.TITLE | SWT.APPLICATION_MODAL); // no
         // close
         // button
         setBlockOnOpen(false);
     }

     /**
      * Enables the cancel button (asynchronously).
      * @param b The state to set the button to.
      */
     private void asyncSetOperationCancelButtonEnabled(final boolean b) {
         if (getShell() != null) {
             getShell().getDisplay().asyncExec(new Runnable() {
                 public void run() {
                     setOperationCancelButtonEnabled(b);
                 }
             });
         }
     }

     /**
      * The cancel button has been pressed.
      *
      * @since 3.0
      */
     protected void cancelPressed() {
         // NOTE: this was previously done from a listener installed on the
         // cancel button. On GTK, the listener installed by
         // Dialog.createButton is called first and this was throwing an
         // exception because the cancel button was already disposed
         cancel.setEnabled(false);
         progressMonitor.setCanceled(true);
         super.cancelPressed();
     }

     /*
      * (non-Javadoc) Method declared on Window.
      */
     /**
      * The <code>ProgressMonitorDialog</code> implementation of this method
      * only closes the dialog if there are no currently running runnables.
      */
     public boolean close() {
         if (getNestingDepth() <= 0) {
             clearCursors();
             return super.close();
         }
         return false;
     }

     /**
      * Clear the cursors in the dialog.
      *
      * @since 3.0
      */
     protected void clearCursors() {
         if (cancel != null && !cancel.isDisposed()) {
             cancel.setCursor(null);
         }
         Shell shell = getShell();
         if (shell != null && !shell.isDisposed()) {
             shell.setCursor(null);
         }
         if (arrowCursor != null)
             arrowCursor.dispose();
         if (waitCursor != null)
             waitCursor.dispose();
         arrowCursor = null;
         waitCursor = null;
     }

     /*
      * (non-Javadoc) Method declared in Window.
      */
     protected void configureShell(Shell shell) {
         super.configureShell(shell);
         shell.setText(JFaceResources.getString("ProgressMonitorDialog.title")); //$NON-NLS-1$
         if (waitCursor == null)
             waitCursor = new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT);
         shell.setCursor(waitCursor);
     }

     /*
      * (non-Javadoc) Method declared on Dialog.
      */
     protected void createButtonsForButtonBar(Composite parent) {
         // cancel button
         createCancelButton(parent);
     }

     /**
      * Creates the cancel button.
      *
      * @param parent
      *            the parent composite
      * @since 3.0
      */
     protected void createCancelButton(Composite parent) {
         cancel = createButton(parent, IDialogConstants.CANCEL_ID,
                 IDialogConstants.CANCEL_LABEL, true);
         if (arrowCursor == null)
             arrowCursor = new Cursor(cancel.getDisplay(), SWT.CURSOR_ARROW);
         cancel.setCursor(arrowCursor);
         setOperationCancelButtonEnabled(enableCancelButton);
     }

     /*
      * (non-Javadoc) Method declared on Dialog.
      */
     protected Control createDialogArea(Composite parent) {
         setMessage(DEFAULT_TASKNAME);
         createMessageArea(parent);
         //Only set for backwards compatibility
         taskLabel = messageLabel;
         // progress indicator
         progressIndicator = new ProgressIndicator(parent);
         GridData gd = new GridData();
         gd.heightHint = convertVerticalDLUsToPixels(BAR_DLUS);
         gd.horizontalAlignment = GridData.FILL;
         gd.grabExcessHorizontalSpace = true;
         gd.horizontalSpan = 2;
         progressIndicator.setLayoutData(gd);
         // label showing current task
         subTaskLabel = new Label(parent, SWT.LEFT | SWT.WRAP);
         gd = new GridData(GridData.FILL_HORIZONTAL);
         gd.heightHint = convertVerticalDLUsToPixels(LABEL_DLUS);
         gd.horizontalSpan = 2;
         subTaskLabel.setLayoutData(gd);
         subTaskLabel.setFont(parent.getFont());
         return parent;
     }

     /*
      *  (non-Javadoc)
      * @see org.eclipse.jface.window.Window#getInitialSize()
      */
     protected Point getInitialSize() {
         Point calculatedSize = super.getInitialSize();
         if (calculatedSize.x < 450)
             calculatedSize.x = 450;
         return calculatedSize;
     }

     /**
      * Returns the progress monitor to use for operations run in this progress
      * dialog.
      *
      * @return the progress monitor
      */
     public IProgressMonitor getProgressMonitor() {
         return progressMonitor;
     }

     /**
      * This implementation of IRunnableContext#run(boolean, boolean,
      * IRunnableWithProgress) runs the given <code>IRunnableWithProgress</code>
      * using the progress monitor for this progress dialog and blocks until
      * the runnable has been run, regardless of the value of <code>fork</code>.
      * The dialog is opened before the runnable is run, and closed after
      * it completes. It is recommended that <code>fork</code> is set to
      * true in most cases. If <code>fork</code> is set to <code>false</code>,
      * the runnable will run in the UI thread and it is the runnable's
      * responsibility to call <code>Display.readAndDispatch()</code>
      * to ensure UI responsiveness.
      */
     public void run(boolean fork, boolean cancelable,
             IRunnableWithProgress runnable) throws InvocationTargetException,
             InterruptedException {
         setCancelable(cancelable);
         try {
             aboutToRun();
             //Let the progress monitor know if they need to update in UI Thread
             progressMonitor.forked = fork;
             ModalContext.run(runnable, fork, getProgressMonitor(), getShell()
                     .getDisplay());
         } finally {
             finishedRun();
         }
     }

     /**
      * Returns whether the dialog should be opened before the operation is run.
      * Defaults to <code>true</code>
      *
      * @return <code>true</code> to open the dialog before run,
      *         <code>false</code> to only create the dialog, but not open it
      * @since 3.0
      */
     public boolean getOpenOnRun() {
         return openOnRun;
     }

     /**
      * Sets whether the dialog should be opened before the operation is run.
      * NOTE: Setting this to false and not forking a process may starve any
      * asyncExec that tries to open the dialog later.
      *
      * @param openOnRun
      *            <code>true</code> to open the dialog before run,
      *            <code>false</code> to only create the dialog, but not open
      *            it
      * @since 3.0
      */
     public void setOpenOnRun(boolean openOnRun) {
         this.openOnRun = openOnRun;
     }

     /**
      * Returns the nesting depth of running operations.
      *
      * @return the nesting depth of running operations
      * @since 3.0
      */
     protected int getNestingDepth() {
         return nestingDepth;
     }

     /**
      * Increments the nesting depth of running operations.
      *
      * @since 3.0
      */
     protected void incrementNestingDepth() {
         nestingDepth++;
     }

     /**
      * Decrements the nesting depth of running operations.
      *
      * @since 3.0
      *
      */
     protected void decrementNestingDepth() {
         nestingDepth--;
     }

     /**
      * Called just before the operation is run. Default behaviour is to open or
      * create the dialog, based on the setting of <code>getOpenOnRun</code>,
      * and increment the nesting depth.
      *
      * @since 3.0
      */
     protected void aboutToRun() {
         if (getOpenOnRun()) {
             open();
         } else {
             create();
         }
         incrementNestingDepth();
     }

     /**
      * Called just after the operation is run. Default behaviour is to decrement
      * the nesting depth, and close the dialog.
      *
      * @since 3.0
      */
     protected void finishedRun() {
         decrementNestingDepth();
         close();
     }

     /**
      * Sets whether the progress dialog is cancelable or not.
      *
      * @param cancelable
      *            <code>true</code> if the end user can cancel this progress
      *            dialog, and <code>false</code> if it cannot be canceled
      */
     public void setCancelable(boolean cancelable) {
         if (cancel == null)
             enableCancelButton = cancelable;
         else
             asyncSetOperationCancelButtonEnabled(cancelable);
     }

     /**
      * Helper to enable/disable Cancel button for this dialog.
      *
      * @param b
      *            <code>true</code> to enable the cancel button, and
      *            <code>false</code> to disable it
      * @since 3.0
      */
     protected void setOperationCancelButtonEnabled(boolean b) {
         operationCancelableState = b;
         cancel.setEnabled(b);
     }

     /*
      *  (non-Javadoc)
      * @see org.eclipse.jface.dialogs.IconAndMessageDialog#getImage()
      */
     protected Image getImage() {
         return getInfoImage();
     }

     /**
      * Set the message in the message label.
      * @param messageString The string for the new message.
      */
     private void setMessage(String messageString) {
         //must not set null text in a label
         message = messageString == null ? "" : messageString; //$NON-NLS-1$
         if (messageLabel == null || messageLabel.isDisposed())
             return;
         messageLabel.setToolTipText(messageString);
         messageLabel.setText(shortenText(message,messageLabel));
     }

     /**
      * Update the message label. Required if the monitor is forked.
      */
     private void update() {
         if (messageLabel == null || messageLabel.isDisposed())
             return;
         messageLabel.update();
     }

     /*
      *  (non-Javadoc)
      * @see org.eclipse.jface.window.Window#open()
      */
     public int open() {
         //Check to be sure it is not already done. If it is just return OK.
         if (!getOpenOnRun()) {
             if (getNestingDepth() == 0)
                 return OK;
         }
         return super.open();
     }
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2004 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jface.dialogs;

	import java.lang.reflect.InvocationTargetException;

	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IProgressMonitorWithBlocking;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.jface.operation.IRunnableContext;
	import org.eclipse.jface.operation.IRunnableWithProgress;
	import org.eclipse.jface.operation.ModalContext;
	import org.eclipse.jface.resource.JFaceResources;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.graphics.Cursor;
	import org.eclipse.swt.graphics.Image;
	import org.eclipse.swt.graphics.Point;
	import org.eclipse.swt.layout.GridData;
	import org.eclipse.swt.widgets.Button;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Label;
	import org.eclipse.swt.widgets.Shell;

	/**
	* A modal dialog that displays progress during a long running operation.
	* <p>
	* This concrete dialog class can be instantiated as is, or further subclassed
	* as required.
	* </p>
	* <p>
	* Typical usage is:
	*
	* <pre>
	*
	*
	* try {
	* IRunnableWithProgress op = ...;
	* new ProgressMonitorDialog(activeShell).run(true, true, op);
	* } catch (InvocationTargetException e) {
	* // handle exception
	* } catch (InterruptedException e) {
	* // handle cancelation
	* }
	*
	*
	* </pre>
	*
	* </p>
	* <p>
	* Note that the ProgressMonitorDialog is not intended to be used with multiple
	* runnables - this dialog should be discarded after completion of one
	* IRunnableWithProgress and a new one instantiated for use by a second or
	* sebsequent IRunnableWithProgress to ensure proper initialization.
	* </p>
	* <p>
	* Note that not forking the process will result in it running in the UI which
	* may starve the UI. The most obvious symptom of this problem is non
	* responsiveness of the cancel button. If you are running within the UI Thread
	* you should do the bulk of your work in another Thread to prevent starvation.
	* It is recommended that fork is set to true in most cases.
	* </p>
	*/
	public class ProgressMonitorDialog extends IconAndMessageDialog implements
	IRunnableContext {
	/**
	* Name to use for task when normal task name is empty string.
	*/
	private static String DEFAULT_TASKNAME = JFaceResources
	.getString("ProgressMonitorDialog.message"); //$NON-NLS-1$

	/**
	* Constants for label and monitor size
	*/
	private static int LABEL_DLUS = 21;

	private static int BAR_DLUS = 9;

	/**
	* The progress indicator control.
	*/
	protected ProgressIndicator progressIndicator;

	/**
	* The label control for the task. Kept for backwards compatibility.
	*/
	protected Label taskLabel;

	/**
	* The label control for the subtask.
	*/
	protected Label subTaskLabel;

	/**
	* The Cancel button control.
	*/
	protected Button cancel;

	/**
	* Indicates whether the Cancel button is to be shown.
	*/
	protected boolean operationCancelableState = false;

	/**
	* Indicates whether the Cancel button is to be enabled.
	*/
	protected boolean enableCancelButton;

	/**
	* The progress monitor.
	*/
	private ProgressMonitor progressMonitor = new ProgressMonitor();

	/**
	* The name of the current task (used by ProgressMonitor).
	*/
	private String task;

	/**
	* The nesting depth of currently running runnables.
	*/
	private int nestingDepth;

	/**
	* The cursor used in the cancel button;
	*/
	protected Cursor arrowCursor;

	/**
	* The cursor used in the shell;
	*/
	private Cursor waitCursor;

	/**
	* Flag indicating whether to open or merely create the dialog before run.
	*/
	private boolean openOnRun = true;

	/**
	* Internal progress monitor implementation.
	*/
	private class ProgressMonitor implements IProgressMonitorWithBlocking {
	private String fSubTask = "";//$NON-NLS-1$

	private boolean fIsCanceled;

	protected boolean forked = false;

	protected boolean locked = false;

	public void beginTask(String name, int totalWork) {
	if (progressIndicator.isDisposed())
	return;
	if (name == null)
	task = "";//$NON-NLS-1$
	else
	task = name;
	String s = task;
	if (s.length() <= 0)
	s = DEFAULT_TASKNAME;
	setMessage(s);
	if (!forked)
	update();
	if (totalWork == UNKNOWN) {
	progressIndicator.beginAnimatedTask();
	} else {
	progressIndicator.beginTask(totalWork);
	}
	}

	public void done() {
	if (!progressIndicator.isDisposed()) {
	progressIndicator.sendRemainingWork();
	progressIndicator.done();
	}
	}

	public void setTaskName(String name) {
	if (name == null)
	task = "";//$NON-NLS-1$
	else
	task = name;
	String s = task;
	if (s.length() <= 0)
	s = DEFAULT_TASKNAME;
	setMessage(s);
	if (!forked)
	update();
	}

	public boolean isCanceled() {
	return fIsCanceled;
	}

	public void setCanceled(boolean b) {
	fIsCanceled = b;
	if (locked)
	clearBlocked();
	}

	public void subTask(String name) {
	if (subTaskLabel.isDisposed())
	return;
	if (name == null)
	fSubTask = "";//$NON-NLS-1$
	else
	fSubTask = name;
	subTaskLabel.setText(shortenText(fSubTask,subTaskLabel));
	if (!forked)
	subTaskLabel.update();
	}

	public void worked(int work) {
	internalWorked(work);
	}

	public void internalWorked(double work) {
	if (!progressIndicator.isDisposed())
	progressIndicator.worked(work);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.runtime.IProgressMonitorWithBlocking#clearBlocked()
	*/
	public void clearBlocked() {
	locked = false;
	updateForClearBlocked();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.runtime.IProgressMonitorWithBlocking#setBlocked(org.eclipse.core.runtime.IStatus)
	*/
	public void setBlocked(IStatus reason) {
	locked = true;
	updateForSetBlocked(reason);
	}
	}

	/**
	* Clear blocked state from the receiver.
	*/
	protected void updateForClearBlocked() {
	setMessage(task);
	imageLabel.setImage(getImage());
	}

	/**
	* Set blocked state from the receiver.
	*
	* @param reason
	* IStatus that gives the details
	*/
	protected void updateForSetBlocked(IStatus reason) {
	setMessage(reason.getMessage());
	imageLabel.setImage(getImage());
	}

	/**
	* Creates a progress monitor dialog under the given shell. The dialog has a
	* standard title and no image. <code>open</code> is non-blocking.
	*
	* @param parent
	* the parent shell, or <code>null</code> to create a top-level
	* shell
	*/
	public ProgressMonitorDialog(Shell parent) {
	super(parent);
	setShellStyle(getDefaultOrientation() \| SWT.BORDER \| SWT.TITLE \| SWT.APPLICATION_MODAL); // no
	// close
	// button
	setBlockOnOpen(false);
	}

	/**
	* Enables the cancel button (asynchronously).
	* @param b The state to set the button to.
	*/
	private void asyncSetOperationCancelButtonEnabled(final boolean b) {
	if (getShell() != null) {
	getShell().getDisplay().asyncExec(new Runnable() {
	public void run() {
	setOperationCancelButtonEnabled(b);
	}
	});
	}
	}

	/**
	* The cancel button has been pressed.
	*
	* @since 3.0
	*/
	protected void cancelPressed() {
	// NOTE: this was previously done from a listener installed on the
	// cancel button. On GTK, the listener installed by
	// Dialog.createButton is called first and this was throwing an
	// exception because the cancel button was already disposed
	cancel.setEnabled(false);
	progressMonitor.setCanceled(true);
	super.cancelPressed();
	}

	/*
	* (non-Javadoc) Method declared on Window.
	*/
	/**
	* The <code>ProgressMonitorDialog</code> implementation of this method
	* only closes the dialog if there are no currently running runnables.
	*/
	public boolean close() {
	if (getNestingDepth() <= 0) {
	clearCursors();
	return super.close();
	}
	return false;
	}

	/**
	* Clear the cursors in the dialog.
	*
	* @since 3.0
	*/
	protected void clearCursors() {
	if (cancel != null && !cancel.isDisposed()) {
	cancel.setCursor(null);
	}
	Shell shell = getShell();
	if (shell != null && !shell.isDisposed()) {
	shell.setCursor(null);
	}
	if (arrowCursor != null)
	arrowCursor.dispose();
	if (waitCursor != null)
	waitCursor.dispose();
	arrowCursor = null;
	waitCursor = null;
	}

	/*
	* (non-Javadoc) Method declared in Window.
	*/
	protected void configureShell(Shell shell) {
	super.configureShell(shell);
	shell.setText(JFaceResources.getString("ProgressMonitorDialog.title")); //$NON-NLS-1$
	if (waitCursor == null)
	waitCursor = new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT);
	shell.setCursor(waitCursor);
	}

	/*
	* (non-Javadoc) Method declared on Dialog.
	*/
	protected void createButtonsForButtonBar(Composite parent) {
	// cancel button
	createCancelButton(parent);
	}

	/**
	* Creates the cancel button.
	*
	* @param parent
	* the parent composite
	* @since 3.0
	*/
	protected void createCancelButton(Composite parent) {
	cancel = createButton(parent, IDialogConstants.CANCEL_ID,
	IDialogConstants.CANCEL_LABEL, true);
	if (arrowCursor == null)
	arrowCursor = new Cursor(cancel.getDisplay(), SWT.CURSOR_ARROW);
	cancel.setCursor(arrowCursor);
	setOperationCancelButtonEnabled(enableCancelButton);
	}

	/*
	* (non-Javadoc) Method declared on Dialog.
	*/
	protected Control createDialogArea(Composite parent) {
	setMessage(DEFAULT_TASKNAME);
	createMessageArea(parent);
	//Only set for backwards compatibility
	taskLabel = messageLabel;
	// progress indicator
	progressIndicator = new ProgressIndicator(parent);
	GridData gd = new GridData();
	gd.heightHint = convertVerticalDLUsToPixels(BAR_DLUS);
	gd.horizontalAlignment = GridData.FILL;
	gd.grabExcessHorizontalSpace = true;
	gd.horizontalSpan = 2;
	progressIndicator.setLayoutData(gd);
	// label showing current task
	subTaskLabel = new Label(parent, SWT.LEFT \| SWT.WRAP);
	gd = new GridData(GridData.FILL_HORIZONTAL);
	gd.heightHint = convertVerticalDLUsToPixels(LABEL_DLUS);
	gd.horizontalSpan = 2;
	subTaskLabel.setLayoutData(gd);
	subTaskLabel.setFont(parent.getFont());
	return parent;
	}

	/*
	* (non-Javadoc)
	* @see org.eclipse.jface.window.Window#getInitialSize()
	*/
	protected Point getInitialSize() {
	Point calculatedSize = super.getInitialSize();
	if (calculatedSize.x < 450)
	calculatedSize.x = 450;
	return calculatedSize;
	}

	/**
	* Returns the progress monitor to use for operations run in this progress
	* dialog.
	*
	* @return the progress monitor
	*/
	public IProgressMonitor getProgressMonitor() {
	return progressMonitor;
	}

	/**
	* This implementation of IRunnableContext#run(boolean, boolean,
	* IRunnableWithProgress) runs the given <code>IRunnableWithProgress</code>
	* using the progress monitor for this progress dialog and blocks until
	* the runnable has been run, regardless of the value of <code>fork</code>.
	* The dialog is opened before the runnable is run, and closed after
	* it completes. It is recommended that <code>fork</code> is set to
	* true in most cases. If <code>fork</code> is set to <code>false</code>,
	* the runnable will run in the UI thread and it is the runnable's
	* responsibility to call <code>Display.readAndDispatch()</code>
	* to ensure UI responsiveness.
	*/
	public void run(boolean fork, boolean cancelable,
	IRunnableWithProgress runnable) throws InvocationTargetException,
	InterruptedException {
	setCancelable(cancelable);
	try {
	aboutToRun();
	//Let the progress monitor know if they need to update in UI Thread
	progressMonitor.forked = fork;
	ModalContext.run(runnable, fork, getProgressMonitor(), getShell()
	.getDisplay());
	} finally {
	finishedRun();
	}
	}

	/**
	* Returns whether the dialog should be opened before the operation is run.
	* Defaults to <code>true</code>
	*
	* @return <code>true</code> to open the dialog before run,
	* <code>false</code> to only create the dialog, but not open it
	* @since 3.0
	*/
	public boolean getOpenOnRun() {
	return openOnRun;
	}

	/**
	* Sets whether the dialog should be opened before the operation is run.
	* NOTE: Setting this to false and not forking a process may starve any
	* asyncExec that tries to open the dialog later.
	*
	* @param openOnRun
	* <code>true</code> to open the dialog before run,
	* <code>false</code> to only create the dialog, but not open
	* it
	* @since 3.0
	*/
	public void setOpenOnRun(boolean openOnRun) {
	this.openOnRun = openOnRun;
	}

	/**
	* Returns the nesting depth of running operations.
	*
	* @return the nesting depth of running operations
	* @since 3.0
	*/
	protected int getNestingDepth() {
	return nestingDepth;
	}

	/**
	* Increments the nesting depth of running operations.
	*
	* @since 3.0
	*/
	protected void incrementNestingDepth() {
	nestingDepth++;
	}

	/**
	* Decrements the nesting depth of running operations.
	*
	* @since 3.0
	*
	*/
	protected void decrementNestingDepth() {
	nestingDepth--;
	}

	/**
	* Called just before the operation is run. Default behaviour is to open or
	* create the dialog, based on the setting of <code>getOpenOnRun</code>,
	* and increment the nesting depth.
	*
	* @since 3.0
	*/
	protected void aboutToRun() {
	if (getOpenOnRun()) {
	open();
	} else {
	create();
	}
	incrementNestingDepth();
	}

	/**
	* Called just after the operation is run. Default behaviour is to decrement
	* the nesting depth, and close the dialog.
	*
	* @since 3.0
	*/
	protected void finishedRun() {
	decrementNestingDepth();
	close();
	}

	/**
	* Sets whether the progress dialog is cancelable or not.
	*
	* @param cancelable
	* <code>true</code> if the end user can cancel this progress
	* dialog, and <code>false</code> if it cannot be canceled
	*/
	public void setCancelable(boolean cancelable) {
	if (cancel == null)
	enableCancelButton = cancelable;
	else
	asyncSetOperationCancelButtonEnabled(cancelable);
	}

	/**
	* Helper to enable/disable Cancel button for this dialog.
	*
	* @param b
	* <code>true</code> to enable the cancel button, and
	* <code>false</code> to disable it
	* @since 3.0
	*/
	protected void setOperationCancelButtonEnabled(boolean b) {
	operationCancelableState = b;
	cancel.setEnabled(b);
	}

	/*
	* (non-Javadoc)
	* @see org.eclipse.jface.dialogs.IconAndMessageDialog#getImage()
	*/
	protected Image getImage() {
	return getInfoImage();
	}

	/**
	* Set the message in the message label.
	* @param messageString The string for the new message.
	*/
	private void setMessage(String messageString) {
	//must not set null text in a label
	message = messageString == null ? "" : messageString; //$NON-NLS-1$
	if (messageLabel == null \|\| messageLabel.isDisposed())
	return;
	messageLabel.setToolTipText(messageString);
	messageLabel.setText(shortenText(message,messageLabel));
	}

	/**
	* Update the message label. Required if the monitor is forked.
	*/
	private void update() {
	if (messageLabel == null \|\| messageLabel.isDisposed())
	return;
	messageLabel.update();
	}

	/*
	* (non-Javadoc)
	* @see org.eclipse.jface.window.Window#open()
	*/
	public int open() {
	//Check to be sure it is not already done. If it is just return OK.
	if (!getOpenOnRun()) {
	if (getNestingDepth() == 0)
	return OK;
	}
	return super.open();
	}
	}