--- a/javauis/eswt_qt/org.eclipse.swt/Eclipse_SWT_PI/qt/org/eclipse/swt/internal/qt/UIThreadManager.java	Fri Sep 17 16:44:34 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,184 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
- * 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:
- *     Nokia Corporation - initial implementation
- *******************************************************************************/
-
-package org.eclipse.swt.internal.qt;
-
-import org.eclipse.swt.internal.qt.ApplicationUIListener;
-import org.eclipse.swt.internal.qt.midp.UIThreadLauncher;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Internal_PackageSupport;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- * A class that manages the UI thread hand-over from the internal UI event loop
- * to the application.
- */
-public final class UIThreadManager {
-	private static Object lock = new Object();
-	private static boolean threadWaitingForApplication;
-	private static Runnable applicationRunnable;
-	private static ApplicationUIListener applicationUIListener;
-		
-	/**
-	 * Pass the control of the thread to the application by calling a Runnable
-	 * provided by the application. If the Runnable has not yet been provided
-	 * then the thread waits until it becomes available, or the wait is aborted
-	 * by calling <code>abortWait()</code>. 
-	 */
-	public static void runApplicationUI() {
-		synchronized(lock) {
-			if(!applicationWaiting()) {
-				waitForApplication();
-			}
-			callback();
-		}
-	}
-
-	/**
-	 * If the UI thread is waiting for the application to request the callback
-	 * in the UI thread then calling this will abort the wait and make the UI
-	 * thread to return back from the <code>runApplicationUI()</code>.
-	 */
-	public static void abortWait() {
-		synchronized(lock) {
-			lock.notify();
-		}
-	}
-
-	/**
-	 * Called indirectly by the application when it's requesting the UI thread. 
-	 * Application will pass a Runnable as a parameter and expects it to get called
-	 * in the UI thread. 
-	 * 
-	 * @param runnable
-	 *            The Runnable to call in the UI thread.
-	 * @return True if obtaining the UI thread was successful and the runnable
-	 *         will be called.
-	 */
-	public static boolean startInUIThread(Runnable runnable) {
-		synchronized(lock) {
-			applicationRunnable = runnable;
-			if(threadWaitingForApplication) {
-				lock.notify();
-			} else {
-				if(!waitForUIThread()) {
-					// If the internal UI has not been created then it can't be
-					// signaled and we can't wait for it. This must mean there's
-					// no UI thread yet in the process and we can create it here.
-					if(!UIThreadLauncher.startInUIThread(runnable)) {
-				    	return false;
-				    }	
-				}
-			}
-		}
-		return true;
-	}
-	
-	/**
-	 * Sets the listener that will be notified of the state of the UI during its
-	 * life-time.
-	 */
-	public static void setApplicationUIListener(ApplicationUIListener listener) {
-		synchronized(lock) {
-			applicationUIListener = listener;
-		}
-	}
-	
-	/*
-	 * Signal the internal UI loop and wait until it passes the control of the
-	 * UI thread into runApplicationUI(). Return false if the internal UI can't
-	 * be signaled. 
-	 */
-	private static boolean waitForUIThread() {
-		if(signalUIThreadRequest()) {
-			try {
-				lock.wait();
-			} catch(InterruptedException e) {
-				// Nothing to do
-			}
-			return true;
-		}
-		return false;
-	}
-
-	/*
-	 * Wait until signaled by the application requesting the callback to its
-	 * Runnable, or by abortWait().
-	 */
-	private static void waitForApplication() {
-		threadWaitingForApplication = true;
-		try {
-			lock.wait();
-		} catch(InterruptedException e) {
-			// Nothing to do
-		} finally {
-			threadWaitingForApplication = false;
-		}		
-	}
-	
-	/*
-	 * Returns true if application has provided the Runnable and is thus waiting
-	 * for the callback.
-	 */
-	private static boolean applicationWaiting() {
-		return (applicationRunnable != null);
-	}
-	
-	/*
-	 * Post an event to the internal Display to request the control of the UI
-	 * thread. After this runApplication() should get called in the UI thread.
-	 */
-	private static boolean signalUIThreadRequest() {
-		Display internalDisplay = Internal_PackageSupport.getInternalDisplayInstance();
-		if(internalDisplay != null) {
-			if(applicationUIListener != null) {
-				applicationUIListener.applicationUIThreadRequest();
-			}
-			return true;
-		}
-		return false;
-	}
-
-	/*
-	 * Call back the application's runnable
-	 */
-	private static void callback() {
-		try {
-			if(applicationRunnable != null) {
-				flushInternals();
-				applicationRunnable.run();
-			}
-		} finally {
-			applicationRunnable = null;
-		}
-	}
-	
-	/*
-	 * Clear any events or other items possibly left over by any previous usage
-	 * of the UI resources. There must not be anything that can interfere with
-	 * the application. It must appear as the application starts with an
-	 * uninitialized UI.
-	 */
-	private static void flushInternals() {
-		Display internalDisplay = Internal_PackageSupport.getInternalDisplayInstance();
-		
-		// Dispose all widgets
-		Shell[] shells = internalDisplay.getShells();
-		for(int i = 0; i < shells.length; ++i) {
-			if(shells[i] != null && !shells[i].isDisposed()) {
-				shells[i].dispose();
-			}
-		}
-		
-		// Flush the event queue
-		while(internalDisplay.readAndDispatch()) {}
-	}
-}