bundles/org.eclipse.jface/src/org/eclipse/jface/operation/ModalContext.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 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.jface.operation;

 import java.lang.reflect.InvocationTargetException;

 import org.eclipse.core.runtime.*;
 import org.eclipse.jface.util.Assert;
 import org.eclipse.swt.widgets.Display;

 /**
  * Utility class for supporting modal operations.
  * The runnable passed to the <code>run</code> method is executed in a
  * separate thread, depending on the value of the passed fork argument.
  * If the runnable is executed in a separate thread then the current thread
  * either waits until the new thread ends or, if the current thread is the
  * UI thread, it polls the SWT event queue and dispatches each event.
  * <p>
  * This class is not intended to be subclassed.
  * </p>
  */
 public class ModalContext {

 	/**
 	 * Indicated whether ModalContext is in debug mode;
 	 * <code>false</code> by default.
 	 */
 	private static boolean debug = false;

 	/**
 	 * The number of nested modal runs, or 0 if not inside a modal run.
 	 * This is global state.
 	 */
 	private static int modalLevel = 0;

 	/**
 	 * Indicates whether operations should be run in a separate thread.
 	 * Defaults to true.
 	 * For internal debugging use, set to false to run operations in the calling thread.
 	 */
 	private static boolean runInSeparateThread = true;

 	/**
 	 * Thread which runs the modal context.
 	 */
 	private static class ModalContextThread extends Thread {
 		/**
 		 * The operation to be run.
 		 */
 		private IRunnableWithProgress runnable;

 		/**
 		 * The exception thrown by the operation starter.
 		 */
 		private Throwable throwable;

 		/**
 		 * The progress monitor used for progress and cancelation.
 		 */
 		private IProgressMonitor progressMonitor;

 		/**
 		 * The display used for event dispatching.
 		 */
 		private Display display;

 		/**
 		 * Indicates whether to continue event queue dispatching.
 		 */
 		private volatile boolean continueEventDispatching = true;

 		/**
 		 * Creates a new modal context.
 		 *
 		 * @param operation the runnable to run
 		 * @param monitor the progress monitor to use to display progress and receive
 		 *   requests for cancelation
 		 * @param display the display to be used to read and dispatch events
 		 */
 		private ModalContextThread(IRunnableWithProgress operation, IProgressMonitor monitor, Display display) {
 			super("ModalContext"); //$NON-NLS-1$
 			Assert.isTrue(monitor != null && display != null);
 			runnable = operation;
 			progressMonitor = new AccumulatingProgressMonitor(monitor, display);
 			this.display = display;
 		}
 		/* (non-Javadoc)
 		 * Method declared on Thread.
 		 */
 		public void run() {
 			try {
 				if (runnable != null)
 					runnable.run(progressMonitor);
 			} catch (InvocationTargetException e) {
 				throwable= e;
 			} catch (InterruptedException e) {
 				throwable= e;
 			} catch (RuntimeException e) {
 				throwable= e;
 			} catch (ThreadDeath e) {
 				// Make sure to propagate ThreadDeath, or threads will never fully terminate
 				throw e;
 			} catch (Error e) {
 				throwable= e;
 			} finally {
 				// Make sure that all events in the asynchronous event queue
 				// are dispatched.
 				display.syncExec(new Runnable() {
 					public void run() {
 						// do nothing
 					}
 				});

 				// Stop event dispatching
 				continueEventDispatching= false;

 				// Force the event loop to return from sleep () so that
 				// it stops event dispatching.
 				display.asyncExec(null);
 			}
 		}
 		/**
 		 * Processes events or waits until this modal context thread terminates.
 		 */
 		public void block() {
 			if (display == Display.getCurrent()) {
 				while (continueEventDispatching) {
 					if (!display.readAndDispatch())
 						display.sleep();
 				}
 			} else {
 				try {
 					join();
 				} catch (InterruptedException e) {
 				}
 			}
 		}
 	}
 /**
  * Returns whether the first progress monitor is the same as, or
  * a wrapper around, the second progress monitor.
  *
  * @param monitor1 the first progress monitor
  * @param monitor2 the second progress monitor
  * @return <code>true</code> if the first is the same as, or
  *   a wrapper around, the second
  * @see ProgressMonitorWrapper
  */
 public static boolean canProgressMonitorBeUsed(IProgressMonitor monitor1, IProgressMonitor monitor2) {
 	if (monitor1 == monitor2)
 		return true;

 	while (monitor1 instanceof ProgressMonitorWrapper) {
 		monitor1= ((ProgressMonitorWrapper)monitor1).getWrappedProgressMonitor();
 		if (monitor1 == monitor2)
 			return true;
 	}
 	return false;
 }
 /**
  * Checks with the given progress monitor and throws
  * <code>InterruptedException</code> if it has been canceled.
  * <p>
  * Code in a long-running operation should call this method
  * regularly so that a request to cancel will be honored.
  * </p>
  * <p>
  * Convenience for:
  * <pre>
  * if (monitor.isCanceled())
  *    throw new InterruptedException();
  * </pre>
  * </p>
  *
  * @param monitor the progress monitor
  * @exception InterruptedException if cancelling the operation has been requested
  * @see IProgressMonitor#isCanceled()
  */
 public static void checkCanceled(IProgressMonitor monitor) throws InterruptedException {
 	if (monitor.isCanceled())
 		throw new InterruptedException();
 }
 /**
  * Returns the currently active modal context thread, or null if no modal context is active.
  */
 private static ModalContextThread getCurrentModalContextThread() {
 	Thread t = Thread.currentThread();
 	if (t instanceof ModalContextThread)
 		return (ModalContextThread) t;
 	return null;
 }
 /**
  * Returns the modal nesting level.
  * <p>
  * The modal nesting level increases by one each time the
  * <code>ModalContext.run</code> method is called within the
  * dynamic scope of another call to <code>ModalContext.run</code>.
  * </p>
  *
  * @return the modal nesting level, or <code>0</code> if
  *  this method is called outside the dynamic scope of any
  *  invocation of <code>ModalContext.run</code>
  */
 public static int getModalLevel() {
 	return modalLevel;
 }
 /**
  * Returns whether the given thread is running a modal context.
  *
  * @return <code>true</code> if the given thread is running a modal context, <code>false</code> if not
  */
 public static boolean isModalContextThread(Thread thread) {
 	return thread instanceof ModalContextThread;
 }
 /**
  * Runs the given runnable in a modal context, passing it a progress monitor.
  * <p>
  * The modal nesting level is increased by one from the perspective
  * of the given runnable.
  * </p>
  *
  * @param operation the runnable to run
  * @param fork <code>true</code> if the runnable should run in a separate thread,
  *   and <code>false</code> if in the same thread
  * @param monitor the progress monitor to use to display progress and receive
  *   requests for cancelation
  * @param display the display to be used to read and dispatch events
  * @exception InvocationTargetException if the run method must propagate a checked exception,
  * 	it should wrap it inside an <code>InvocationTargetException</code>; runtime exceptions and errors are automatically
  *  wrapped in an <code>InvocationTargetException</code> by this method
  * @exception InterruptedException if the operation detects a request to cancel,
  *  using <code>IProgressMonitor.isCanceled()</code>, it should exit by throwing
  *  <code>InterruptedException</code>; this method propagates the exception
  */
 public static void run(IRunnableWithProgress operation, boolean fork, IProgressMonitor monitor, Display display) throws InvocationTargetException, InterruptedException {
 	Assert.isTrue(operation != null && monitor != null);

 	modalLevel++;
 	try {
 		if (monitor != null)
 			monitor.setCanceled(false);
 		// Is the runnable supposed to be execute in the same thread.
 		if (!fork || !runInSeparateThread) {
 			runInCurrentThread(operation, monitor);
 		} else {
 			ModalContextThread t = getCurrentModalContextThread();
 			if (t != null) {
 				Assert.isTrue(canProgressMonitorBeUsed(monitor, t.progressMonitor));
 				runInCurrentThread(operation, monitor);
 			} else {
 				t = new ModalContextThread(operation, monitor, display);
 				t.start();
 				t.block();
 				Throwable throwable= t.throwable;
 				if (throwable != null) {
 					if (debug
 						&& !(throwable instanceof InterruptedException)
 						&& !(throwable instanceof OperationCanceledException)) {
 						System.err.println("Exception in modal context operation:"); //$NON-NLS-1$
 						throwable.printStackTrace();
 						System.err.println("Called from:"); //$NON-NLS-1$
 						// Don't create the InvocationTargetException on the throwable,
 						// otherwise it will print its stack trace (from the other thread).
 						new InvocationTargetException(null).printStackTrace();
 					}
 					if (throwable instanceof InvocationTargetException) {
 						throw (InvocationTargetException) throwable;
 					} else if (throwable instanceof InterruptedException) {
 						throw (InterruptedException) throwable;
 					} else if (
 						throwable instanceof OperationCanceledException) {
 						// See 1GAN3L5: ITPUI:WIN2000 - ModalContext converts OperationCancelException into InvocationTargetException
 						throw new InterruptedException(throwable.getMessage());
 					} else {
 						throw new InvocationTargetException(throwable);
 					}
 				}
 			}
 		}
 	}
 	finally {
 		modalLevel--;
 	}
 }
 /**
  * Run a runnable.  Convert all thrown exceptions to
  * either InterruptedException or InvocationTargetException
  */
 private static void runInCurrentThread(IRunnableWithProgress runnable, IProgressMonitor progressMonitor)
 	throws InterruptedException, InvocationTargetException
 {
 	try {
 		if (runnable != null)
 			runnable.run(progressMonitor);
 	} catch (InvocationTargetException e) {
 		throw e;
 	} catch (InterruptedException e) {
 		throw e;
 	} catch (OperationCanceledException e) {
 		throw new InterruptedException();
 	} catch (ThreadDeath e) {
 		// Make sure to propagate ThreadDeath, or threads will never fully terminate
 		throw e;
 	} catch (RuntimeException e) {
 		throw new InvocationTargetException(e);
 	} catch (Error e) {
 		throw new InvocationTargetException(e);
 	}
 }
 /**
  * Sets whether ModalContext is running in debug mode.
  *
  * @param debugMode <code>true</code> for debug mode,
  *  and <code>false</code> for normal mode (the default)
  */
 public static void setDebugMode(boolean debugMode) {
 	debug = debugMode;
 }
 }
	/*******************************************************************************
	* Copyright (c) 2000, 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.jface.operation;

	import java.lang.reflect.InvocationTargetException;

	import org.eclipse.core.runtime.*;
	import org.eclipse.jface.util.Assert;
	import org.eclipse.swt.widgets.Display;

	/**
	* Utility class for supporting modal operations.
	* The runnable passed to the <code>run</code> method is executed in a
	* separate thread, depending on the value of the passed fork argument.
	* If the runnable is executed in a separate thread then the current thread
	* either waits until the new thread ends or, if the current thread is the
	* UI thread, it polls the SWT event queue and dispatches each event.
	* <p>
	* This class is not intended to be subclassed.
	* </p>
	*/
	public class ModalContext {

	/**
	* Indicated whether ModalContext is in debug mode;
	* <code>false</code> by default.
	*/
	private static boolean debug = false;

	/**
	* The number of nested modal runs, or 0 if not inside a modal run.
	* This is global state.
	*/
	private static int modalLevel = 0;

	/**
	* Indicates whether operations should be run in a separate thread.
	* Defaults to true.
	* For internal debugging use, set to false to run operations in the calling thread.
	*/
	private static boolean runInSeparateThread = true;

	/**
	* Thread which runs the modal context.
	*/
	private static class ModalContextThread extends Thread {
	/**
	* The operation to be run.
	*/
	private IRunnableWithProgress runnable;

	/**
	* The exception thrown by the operation starter.
	*/
	private Throwable throwable;

	/**
	* The progress monitor used for progress and cancelation.
	*/
	private IProgressMonitor progressMonitor;

	/**
	* The display used for event dispatching.
	*/
	private Display display;

	/**
	* Indicates whether to continue event queue dispatching.
	*/
	private volatile boolean continueEventDispatching = true;

	/**
	* Creates a new modal context.
	*
	* @param operation the runnable to run
	* @param monitor the progress monitor to use to display progress and receive
	* requests for cancelation
	* @param display the display to be used to read and dispatch events
	*/
	private ModalContextThread(IRunnableWithProgress operation, IProgressMonitor monitor, Display display) {
	super("ModalContext"); //$NON-NLS-1$
	Assert.isTrue(monitor != null && display != null);
	runnable = operation;
	progressMonitor = new AccumulatingProgressMonitor(monitor, display);
	this.display = display;
	}
	/* (non-Javadoc)
	* Method declared on Thread.
	*/
	public void run() {
	try {
	if (runnable != null)
	runnable.run(progressMonitor);
	} catch (InvocationTargetException e) {
	throwable= e;
	} catch (InterruptedException e) {
	throwable= e;
	} catch (RuntimeException e) {
	throwable= e;
	} catch (ThreadDeath e) {
	// Make sure to propagate ThreadDeath, or threads will never fully terminate
	throw e;
	} catch (Error e) {
	throwable= e;
	} finally {
	// Make sure that all events in the asynchronous event queue
	// are dispatched.
	display.syncExec(new Runnable() {
	public void run() {
	// do nothing
	}
	});

	// Stop event dispatching
	continueEventDispatching= false;

	// Force the event loop to return from sleep () so that
	// it stops event dispatching.
	display.asyncExec(null);
	}
	}
	/**
	* Processes events or waits until this modal context thread terminates.
	*/
	public void block() {
	if (display == Display.getCurrent()) {
	while (continueEventDispatching) {
	if (!display.readAndDispatch())
	display.sleep();
	}
	} else {
	try {
	join();
	} catch (InterruptedException e) {
	}
	}
	}
	}
	/**
	* Returns whether the first progress monitor is the same as, or
	* a wrapper around, the second progress monitor.
	*
	* @param monitor1 the first progress monitor
	* @param monitor2 the second progress monitor
	* @return <code>true</code> if the first is the same as, or
	* a wrapper around, the second
	* @see ProgressMonitorWrapper
	*/
	public static boolean canProgressMonitorBeUsed(IProgressMonitor monitor1, IProgressMonitor monitor2) {
	if (monitor1 == monitor2)
	return true;

	while (monitor1 instanceof ProgressMonitorWrapper) {
	monitor1= ((ProgressMonitorWrapper)monitor1).getWrappedProgressMonitor();
	if (monitor1 == monitor2)
	return true;
	}
	return false;
	}
	/**
	* Checks with the given progress monitor and throws
	* <code>InterruptedException</code> if it has been canceled.
	* <p>
	* Code in a long-running operation should call this method
	* regularly so that a request to cancel will be honored.
	* </p>
	* <p>
	* Convenience for:
	* <pre>
	* if (monitor.isCanceled())
	* throw new InterruptedException();
	* </pre>
	* </p>
	*
	* @param monitor the progress monitor
	* @exception InterruptedException if cancelling the operation has been requested
	* @see IProgressMonitor#isCanceled()
	*/
	public static void checkCanceled(IProgressMonitor monitor) throws InterruptedException {
	if (monitor.isCanceled())
	throw new InterruptedException();
	}
	/**
	* Returns the currently active modal context thread, or null if no modal context is active.
	*/
	private static ModalContextThread getCurrentModalContextThread() {
	Thread t = Thread.currentThread();
	if (t instanceof ModalContextThread)
	return (ModalContextThread) t;
	return null;
	}
	/**
	* Returns the modal nesting level.
	* <p>
	* The modal nesting level increases by one each time the
	* <code>ModalContext.run</code> method is called within the
	* dynamic scope of another call to <code>ModalContext.run</code>.
	* </p>
	*
	* @return the modal nesting level, or <code>0</code> if
	* this method is called outside the dynamic scope of any
	* invocation of <code>ModalContext.run</code>
	*/
	public static int getModalLevel() {
	return modalLevel;
	}
	/**
	* Returns whether the given thread is running a modal context.
	*
	* @return <code>true</code> if the given thread is running a modal context, <code>false</code> if not
	*/
	public static boolean isModalContextThread(Thread thread) {
	return thread instanceof ModalContextThread;
	}
	/**
	* Runs the given runnable in a modal context, passing it a progress monitor.
	* <p>
	* The modal nesting level is increased by one from the perspective
	* of the given runnable.
	* </p>
	*
	* @param operation the runnable to run
	* @param fork <code>true</code> if the runnable should run in a separate thread,
	* and <code>false</code> if in the same thread
	* @param monitor the progress monitor to use to display progress and receive
	* requests for cancelation
	* @param display the display to be used to read and dispatch events
	* @exception InvocationTargetException if the run method must propagate a checked exception,
	* it should wrap it inside an <code>InvocationTargetException</code>; runtime exceptions and errors are automatically
	* wrapped in an <code>InvocationTargetException</code> by this method
	* @exception InterruptedException if the operation detects a request to cancel,
	* using <code>IProgressMonitor.isCanceled()</code>, it should exit by throwing
	* <code>InterruptedException</code>; this method propagates the exception
	*/
	public static void run(IRunnableWithProgress operation, boolean fork, IProgressMonitor monitor, Display display) throws InvocationTargetException, InterruptedException {
	Assert.isTrue(operation != null && monitor != null);

	modalLevel++;
	try {
	if (monitor != null)
	monitor.setCanceled(false);
	// Is the runnable supposed to be execute in the same thread.
	if (!fork \|\| !runInSeparateThread) {
	runInCurrentThread(operation, monitor);
	} else {
	ModalContextThread t = getCurrentModalContextThread();
	if (t != null) {
	Assert.isTrue(canProgressMonitorBeUsed(monitor, t.progressMonitor));
	runInCurrentThread(operation, monitor);
	} else {
	t = new ModalContextThread(operation, monitor, display);
	t.start();
	t.block();
	Throwable throwable= t.throwable;
	if (throwable != null) {
	if (debug
	&& !(throwable instanceof InterruptedException)
	&& !(throwable instanceof OperationCanceledException)) {
	System.err.println("Exception in modal context operation:"); //$NON-NLS-1$
	throwable.printStackTrace();
	System.err.println("Called from:"); //$NON-NLS-1$
	// Don't create the InvocationTargetException on the throwable,
	// otherwise it will print its stack trace (from the other thread).
	new InvocationTargetException(null).printStackTrace();
	}
	if (throwable instanceof InvocationTargetException) {
	throw (InvocationTargetException) throwable;
	} else if (throwable instanceof InterruptedException) {
	throw (InterruptedException) throwable;
	} else if (
	throwable instanceof OperationCanceledException) {
	// See 1GAN3L5: ITPUI:WIN2000 - ModalContext converts OperationCancelException into InvocationTargetException
	throw new InterruptedException(throwable.getMessage());
	} else {
	throw new InvocationTargetException(throwable);
	}
	}
	}
	}
	}
	finally {
	modalLevel--;
	}
	}
	/**
	* Run a runnable. Convert all thrown exceptions to
	* either InterruptedException or InvocationTargetException
	*/
	private static void runInCurrentThread(IRunnableWithProgress runnable, IProgressMonitor progressMonitor)
	throws InterruptedException, InvocationTargetException
	{
	try {
	if (runnable != null)
	runnable.run(progressMonitor);
	} catch (InvocationTargetException e) {
	throw e;
	} catch (InterruptedException e) {
	throw e;
	} catch (OperationCanceledException e) {
	throw new InterruptedException();
	} catch (ThreadDeath e) {
	// Make sure to propagate ThreadDeath, or threads will never fully terminate
	throw e;
	} catch (RuntimeException e) {
	throw new InvocationTargetException(e);
	} catch (Error e) {
	throw new InvocationTargetException(e);
	}
	}
	/**
	* Sets whether ModalContext is running in debug mode.
	*
	* @param debugMode <code>true</code> for debug mode,
	* and <code>false</code> for normal mode (the default)
	*/
	public static void setDebugMode(boolean debugMode) {
	debug = debugMode;
	}
	}