/*******************************************************************************

 * 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()) {}

	}

}