org.eclipse.xwt/src/org/eclipse/xwt/XWT.java

/*******************************************************************************
 * Copyright (c) 2006, 2010 Soyatec (http://www.soyatec.com) 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:
 *     Soyatec - initial API and implementation
 *     Anyware-tech - add multiple loaders
 *******************************************************************************/
package org.eclipse.xwt;

import java.io.InputStream;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.xwt.callback.IBeforeParsingCallback;
import org.eclipse.xwt.core.IBinding;
import org.eclipse.xwt.core.TriggerBase;
import org.eclipse.xwt.databinding.BindingContext;
import org.eclipse.xwt.databinding.IBindingContext;
import org.eclipse.xwt.input.ICommand;
import org.eclipse.xwt.internal.core.UpdateSourceTrigger;
import org.eclipse.xwt.internal.utils.UserData;
import org.eclipse.xwt.metadata.IEvent;
import org.eclipse.xwt.metadata.IMetaclass;
import org.eclipse.xwt.metadata.IProperty;

/**
 * XWT is the main class of the XWT framework. It provides most of the services
 * in API.
 * 
 * @author yyang
 */
public class XWT {

	private static List<IXWTInitializer> initializers = new ArrayList<IXWTInitializer>();
	private static Thread displayThread;
	private static final Object displayLock = new Object();

	/**
	 * Get the system logger.
	 * 
	 * @returnF
	 */
	public static ILogger getLogger() {
		return XWTLoaderManager.getActive().getLogger();
	}

	/**
	 * Create a UI Profile with the provide data and apply it immediately.
	 * 
	 * @param profileData
	 * @return
	 */
	public static Object createUIProfile() {
		return XWTLoaderManager.getActive().createUIProfile();
	}

	/**
	 * Put the Profile in place
	 * 
	 * @param profile
	 * @return
	 */
	public static boolean applyProfile(Object profile) {
		return XWTLoaderManager.getActive().applyProfile(profile);
	}

	/**
	 * Restore the previous profile
	 * 
	 * @return
	 */
	public static Object restoreProfile() {
		return XWTLoaderManager.getActive().restoreProfile();
	}

	/**
	 * 
	 * @param nsmapace
	 * @param handler
	 */
	public static void registerNamespaceHandler(String nsmapace,
			INamespaceHandler handler) {
		XWTLoaderManager.getActive()
				.registerNamespaceHandler(nsmapace, handler);
	}

	/**
	 * 
	 * @param nsmapace
	 */
	public static void unregisterNamespaceHandler(String nsmapace) {
		XWTLoaderManager.getActive().unregisterNamespaceHandler(nsmapace);
	}

	/**
	 * 
	 * @param nsmapace
	 * @return
	 */
	public static INamespaceHandler getNamespaceHandler(String nsmapace) {
		return XWTLoaderManager.getActive().getNamespaceHandler(nsmapace);
	}

	/**
	 * Register an Observable IChangeListener for a given UI element. The second
	 * registration of the same listener on the same UI Element has no effect.
	 * 
	 * @param context
	 * @param listener
	 * @return
	 */
	public static boolean addObservableChangeListener(Object context,
			IChangeListener listener) {
		return XWTLoaderManager.getActive().addObservableChangeListener(
				context, listener);
	}

	/**
	 * Undo the registration of the Observable IChangeListener for a given UI
	 * element.
	 * 
	 * @param context
	 * @param listener
	 */
	public static void removeObservableChangeListener(Object context,
			IChangeListener listener) {
		XWTLoaderManager.getActive().removeObservableChangeListener(context,
				listener);
	}

	/**
	 * Find an existing IObservableValue
	 * 
	 * @param nsmapace
	 * @return null if it doesn't exist.
	 */
	public static IObservableValue findObservableValue(Object context,
			Object data, String propertyName) {
		return XWTLoaderManager.getActive().findObservableValue(context, data,
				propertyName);
	}

	/**
	 * Find an existing IObservableValue
	 * 
	 * @param nsmapace
	 * @return null if it doesn't exist.
	 */
	public static IObservableList findObservableList(Object context,
			Object data, String propertyName) {
		return XWTLoaderManager.getActive().findObservableList(context, data,
				propertyName);
	}

	/**
	 * Find an existing IObservableValue
	 * 
	 * @param nsmapace
	 * @return null if it doesn't exist.
	 */
	public static IObservableSet findObservableSet(Object context, Object data,
			String propertyName) {
		return XWTLoaderManager.getActive().findObservableSet(context, data,
				propertyName);
	}

	/**
	 * get or create a IObservableValue
	 * 
	 * @param nsmapace
	 * @return return null or raises an exception XWTException if fails
	 */
	public static IObservableValue observableValue(Object context, Object data,
			String propertyName, UpdateSourceTrigger updateSourceTrigger) {
		return XWTLoaderManager.getActive().observableValue(context, data,
				propertyName, updateSourceTrigger);
	}

	/**
	 * get or create a IObservable
	 * 
	 * @param nsmapace
	 * @return return null or raises an exception XWTException if fails
	 */
	public static IObservable observe(Object context, Object data,
			String propertyName, UpdateSourceTrigger updateSourceTrigger) {
		return XWTLoaderManager.getActive().observe(context, data,
				propertyName, updateSourceTrigger);
	}

	/**
	 * get or create a IObservable
	 * 
	 * @param nsmapace
	 * @return return null or raises an exception XWTException if fails
	 */
	public static IObservableFactory observableFactory(Object context,
			String propertyName, UpdateSourceTrigger updateSourceTrigger) {
		return XWTLoaderManager.getActive().observableFactory(context,
				propertyName, updateSourceTrigger);
	}

	/**
	 * get or create a IObservableValue
	 * 
	 * @param nsmapace
	 * @return return null or raises an exception XWTException if fails
	 */
	public static IObservableValue observableValue(Object context, Object data,
			String propertyName) {
		return XWTLoaderManager.getActive().observableValue(context, data,
				propertyName, UpdateSourceTrigger.Default);
	}

	/**
	 * Change the system logger
	 * 
	 * @param logger
	 */
	public static void setLogger(ILogger log) {
		XWTLoaderManager.getActive().setLogger(log);
	}

	/**
	 * Get the name of the element, which is defined by <code>Name</code> or
	 * <code>x:Name</code>. Return <code>null</code>
	 * 
	 * @param object
	 * @return
	 */
	public static String getElementName(Object object) {
		return XWTLoaderManager.getActive().getElementName(object);
	}

	/**
	 * Find a named UI element.
	 * 
	 * @param context
	 *            the start point of research.
	 * @param name
	 * @return
	 */
	public static Object findElementByName(Object context, String name) {
		return XWTLoaderManager.getActive().findElementByName(context, name);
	}

	/**
	 * Get the DataContext of given element
	 * 
	 * @param context
	 * @return
	 */
	public static Object getDataContext(Object element, Class<?> targetType) {
		Object value = XWTLoaderManager.getActive().getDataContext(element);
		if (targetType == null || !targetType.isInstance(value)) {
			if (value instanceof IBinding) {
				return ((IBinding) value).getValue(targetType);
			}
			if (value instanceof IObservableValue) {
				return ((IObservableValue) value).getValue();
			}
		}
		return value;
	}

	/**
	 * Returns the {@link BindingContext} within the upper scope of the control.
	 * <p>
	 * Each UI Element may have a local DataBindingContext property. While
	 * locating DataBindingContext, if the current UI Element has not the
	 * property, the parent's will be used.
	 * <p>
	 * If none is found, a default one will be created as default for the
	 * current scope
	 * <p>
	 * If still not found {@link XWTException} thrown...
	 * 
	 * @param element
	 * @return
	 */
	public static IBindingContext getBindingContext(Object element) {
		return (IBindingContext) XWTLoaderManager.getActive()
				.getBindingContext(element);
	}

	/**
	 * Get the DataContext of given element
	 * 
	 * @param context
	 * @return
	 */
	public static Object getDataContext(Object element) {
		return getDataContext(element, null);
	}

	/**
	 * Set the DataContext of given element
	 * 
	 * @param context
	 * @return
	 */
	public static void setDataContext(Object element, Object dataContext) {
		XWTLoaderManager.getActive().setDataContext(UserData.getWidget(element), dataContext);
	}

	/**
	 * Get the Triggers of given element
	 * 
	 * @param context
	 * @return
	 */
	public static TriggerBase[] getTriggers(Widget element) {
		return XWTLoaderManager.getActive().getTriggers(element);
	}

	/**
	 * Get the Triggers of given element
	 * 
	 * @param context
	 * @return
	 */
	public static void setTriggers(Widget element, TriggerBase[] triggers) {
		XWTLoaderManager.getActive().setTriggers(element, triggers);
	}

	/**
	 * Get the CLR (Common Language Runtime) object. If no CLR object is found
	 * in this element, the research will be propagated in it parent.
	 * 
	 * @param widget
	 * @return
	 */
	public static Object getCLR(Object widget) {
		return UserData.getCLR(widget);
	}

	/**
	 * Find the root shell
	 * 
	 * @param context
	 * @return
	 */
	public static Shell findShell(Object context) {
		return UserData.findShell(context);
	}

	public static IProperty findProperty(Object object, String name) {
		IMetaclass metaclass = XWTLoaderManager.getActive()
				.getMetaclass(object);
		return metaclass.findProperty(name);
	}

	public static Object findResource(Object object, String name) {
		return XWTLoaderManager.getActive().findResource(object, name);
	}

	public static Map<String, Object> getResources(Object object) {
		return XWTLoaderManager.getActive().getResources(object);
	}

	public static IEvent findEvent(Object object, String name) {
		IMetaclass metaclass = XWTLoaderManager.getActive()
				.getMetaclass(object);
		return metaclass.findEvent(name);
	}

	public static IMetaclass getMetaclass(Object object) {
		return XWTLoaderManager.getActive().getMetaclass(object);
	}

	/**
	 * Load the file content. All widget will be created but they are showed.
	 * This method return the root element.
	 * 
	 */
	static public Object load(URL file) throws Exception {
		XWT.checkInitialization();
		return XWTLoaderManager.getActive().load(file);
	}

	/**
	 * Load the content from IUIResource. All widget will be created but they
	 * are showed. This method return the root element.
	 * 
	 */
	static public Object load(IUIResource resource) throws Exception {
		XWT.checkInitialization();
		return XWTLoaderManager.getActive().load(resource);
	}

	/**
	 * Load the file content. All widget will be created but they are showed.
	 * This method return the root element.
	 * 
	 */
	static public Object load(URL file, Object dataContext) throws Exception {
		XWT.checkInitialization();
		return XWTLoaderManager.getActive().load(file, dataContext);
	}

	/**
	 * Load the content from IUIResource. All widget will be created but they
	 * are showed. This method return the root element.
	 * 
	 */
	static public Object load(IUIResource resource, Object dataContext)
			throws Exception {
		XWT.checkInitialization();
		return XWTLoaderManager.getActive().load(resource, dataContext);
	}

	/**
	 * Load the file content under a UI Object. All widget will be created. This
	 * method returns the root element. The DataContext will be associated to
	 * the root element.
	 */
	static public Object load(Object parent, URL file) throws Exception {
		return XWTLoaderManager.getActive().load(parent, file);
	}

	/**
	 * Load the file content under a UI Object. All widget will be created. This
	 * method returns the root element. The DataContext will be associated to
	 * the root element.
	 * 
	 */
	static public Object load(Object parent, IUIResource resource)
			throws Exception {
		return XWTLoaderManager.getActive().load(parent, resource);
	}

	/**
	 * Load the file content under a UI Object with a DataContext. All widget
	 * will be created. This method returns the root element. The DataContext
	 * will be associated to the root element.
	 */
	static public Object load(Object parent, URL file, Object dataContext)
			throws Exception {
		return XWTLoaderManager.getActive().load(parent, file, dataContext);
	}

	/**
	 * Load the content from IUIResource.
	 * 
	 * @param stream
	 * @param input
	 * @param parsingCallback
	 *            null if the callback is not necessary
	 * @return
	 * @throws Exception
	 */
	static public IUIResource loadAsResource(InputStream stream, URL input,
			IBeforeParsingCallback parsingCallback) throws Exception {
		return XWTLoaderManager.getActive().loadAsResource(stream, input,
				parsingCallback);
	}

	/**
	 * Load the content from IUIResource.
	 * 
	 * @param stream
	 * @param input
	 * @param parsingCallback
	 *            null if the callback is not necessary
	 * @return
	 * @throws Exception
	 */
	static public IUIResource loadAsResource(InputStream stream, URL input)
			throws Exception {
		return XWTLoaderManager.getActive().loadAsResource(stream, input);
	}

	/**
	 * Load the content from IUIResource.
	 * 
	 * @param input
	 * @param parsingCallback
	 *            null if the callback is not necessary
	 * @return
	 * @throws Exception
	 */
	static public IUIResource loadAsResource(URL input,
			IBeforeParsingCallback parsingCallback) throws Exception {
		return XWTLoaderManager.getActive().loadAsResource(null, input,
				parsingCallback);
	}

	/**
	 * Load the content from IUIResource.
	 * 
	 * @param input
	 * @return
	 * @throws Exception
	 */
	static public IUIResource loadAsResource(URL input) throws Exception {
		return XWTLoaderManager.getActive().loadAsResource(null, input);
	}

	/**
	 * Load the file content under a UI Object with a DataContext. All widget
	 * will be created. This method returns the root element. The DataContext
	 * will be associated to the root element.
	 */
	static public Object load(Object parent, IUIResource resource,
			Object dataContext) throws Exception {
		return XWTLoaderManager.getActive().load(parent, resource, dataContext);
	}

	static public Object load(Object parent, IUIResource resource,
			Map<String, Object> options) throws Exception {
		return XWTLoaderManager.getActive().load(parent, resource, options);
	}

	/**
	 * Open and show the file content in a new Shell.
	 */
	static public void open(final URL url) throws Exception {
		XWT.checkInitialization();
		XWTLoaderManager.getActive().open(url);
	}

	/**
	 * Open and show the file content in a new Shell.
	 */
	static public void open(final Class<?> type) throws Exception {
		XWT.checkInitialization();
		XWTLoaderManager.getActive().open(type);
	}

	/**
	 * Open and show the file content in a new Shell.
	 */
	static public void open(final IUIResource resource) throws Exception {
		XWT.checkInitialization();
		XWTLoaderManager.getActive().open(resource);
	}

	/**
	 * load the content from a stream with a style, a DataContext and a
	 * ResourceDictionary. The root elements will be hold by UI Object parent
	 */
	static public Object load(Object parent, InputStream stream, URL file,
			Object dataContext) throws Exception {
		return XWTLoaderManager.getActive().load(parent, stream, file,
				dataContext);
	}

	/**
	 * load the file content. The corresponding UI element is not yet created
	 */
	static public void open(URL url, Object dataContext) throws Exception {
		XWT.checkInitialization();
		XWTLoaderManager.getActive().open(url, dataContext);
	}

	/**
	 * load the content from IUIResource. The corresponding UI element is not
	 * yet created
	 */
	static public void open(IUIResource resource, Object dataContext)
			throws Exception {
		XWT.checkInitialization();
		XWTLoaderManager.getActive().open(resource, dataContext);
	}

	/**
	 * load the file content. The corresponding UI element is not yet created
	 */
	static public void open(Class<?> type, Object dataContext) throws Exception {
		open(type.getResource(type.getSimpleName()
				+ IConstants.XWT_EXTENSION_SUFFIX), dataContext);
	}

	/**
	 * load the file content. The corresponding UI element is not yet created
	 */
	static public void open(URL url, Map<String, Object> options)
			throws Exception {
		XWT.checkInitialization();
		XWTLoaderManager.getActive().open(url, options);
	}

	/**
	 * load the content from IUIResource. The corresponding UI element is not
	 * yet created
	 */
	static public void open(IUIResource resource, Map<String, Object> options)
			throws Exception {
		XWT.checkInitialization();
		XWTLoaderManager.getActive().open(resource, options);
	}

	static public Object convertFrom(Class<?> targetType, String string) {
		return XWTLoaderManager.getActive().convertFrom(targetType, string);
	}

	static public Object loadWithOptions(URL url, Map<String, Object> options)
			throws Exception {
		return XWTLoaderManager.getActive().loadWithOptions(url, options);
	}

	static public Object loadWithOptions(IUIResource resource,
			Map<String, Object> options) throws Exception {
		return XWTLoaderManager.getActive().loadWithOptions(resource, options);
	}

	/**
	 * 
	 * @param stream
	 * @param url
	 * @param options
	 * @return
	 * @throws Exception
	 */
	static public Object load(InputStream stream, URL url) throws Exception {
		XWT.checkInitialization();
		return loadWithOptions(stream, url, Collections.EMPTY_MAP);
	}

	/**
	 * 
	 * @param stream
	 * @param url
	 * @param options
	 * @return
	 * @throws Exception
	 */
	static public Object loadWithOptions(InputStream stream, URL url,
			Map<String, Object> options) throws Exception {
		XWT.checkInitialization();
		return XWTLoaderManager.getActive().loadWithOptions(stream, url,
				options);
	}

	/**
	 * Metaclass services to return all registered Metaclasses.
	 * 
	 * @param stream
	 * @param url
	 * @param loadData
	 * @return
	 * @throws Exception
	 */
	static public IMetaclass[] getAllMetaclasses() {
		return XWTLoaderManager.getActive().getAllMetaclasses();
	}

	/**
	 * Get the corresponding Metaclass
	 * 
	 * @param tagName
	 * @param ns
	 *            The namespace
	 * @return
	 */
	static public IMetaclass getMetaclass(String tagName, String ns) {
		return XWTLoaderManager.getActive().getMetaclass(tagName, ns);
	}

	/**
	 * Register a Data converter
	 * 
	 * @param converter
	 * @param type
	 */
	public static void registerEventGroup(Class<?> type, IEventGroup eventGroup) {
		XWTLoaderManager.getActive().registerEventGroup(type, eventGroup);
	}

	/**
	 * Register a Data converter
	 * 
	 * @param converter
	 * @param type
	 */
	public static void registerConvertor(IConverter converter) {
		XWTLoaderManager.getActive().registerConvertor(converter);
	}

	/**
	 * Register a command to a name
	 * 
	 * @param name
	 * @param command
	 */
	public static void registerCommand(String name, ICommand command) {
		XWTLoaderManager.getActive().registerCommand(name, command);
	}

	/**
	 * Add a default style
	 * 
	 * @param style
	 * @return
	 */
	public static void addDefaultStyle(IStyle style) {
		XWTLoaderManager.getActive().addDefaultStyle(style);
	}

	public static void addDataProviderFactory(String name,
			IDataProviderFactory dataProviderFactory) {
		XWTLoaderManager.getActive().addDataProviderFactory(name,
				dataProviderFactory);
	}

	public static void removeDataProviderFactory(String name) {
		XWTLoaderManager.getActive().removeDataProviderFactory(name);
	}

	public static void removeDataProviderFactory(
			IDataProviderFactory dataProviderFactory) {
		XWTLoaderManager.getActive().removeDataProviderFactory(
				dataProviderFactory);
	}

	public static Collection<IDataProviderFactory> getDataProviderFactories() {
		return XWTLoaderManager.getActive().getDataProviderFactories();
	}

	/**
	 * Register UI type
	 * 
	 * @param javaclass
	 */
	static public IMetaclass registerMetaclass(Class<?> type) {
		return XWTLoaderManager.getActive().registerMetaclass(type);
	}

	/**
	 * Register UI type
	 * 
	 * @param javaclass
	 */
	static public void registerMetaclass(IMetaclass type) {
		XWTLoaderManager.getActive().registerMetaclass(type);
	}

	/**
	 * Get the dynamic property value
	 * 
	 * @param javaclass
	 */
	static public Object getPropertyValue(Object uiElement, IProperty property) {
		return XWTLoaderManager.getActive().getPropertyValue(uiElement,
				property);
	}

	/**
	 * Get the dynamic property value
	 * 
	 * @param javaclass
	 */
	static public Object getPropertyValue(Object uiElement, String propertyName) {
		IMetaclass metaclass = XWT.getMetaclass(uiElement);
		IProperty property = metaclass.findProperty(propertyName);
		if (property == null) {
			return null;
		}
		return XWTLoaderManager.getActive().getPropertyValue(uiElement,
				property);
	}

	/**
	 * Set the dynamic property value
	 * 
	 * @param javaclass
	 */
	static public void setPropertyValue(Object uiElement, IProperty property,
			Object value) {
		XWTLoaderManager.getActive().setPropertyValue(uiElement, property,
				value);
	}

	/**
	 * Set the dynamic property value
	 * 
	 * @param javaclass
	 */
	static public void setPropertyValue(Object uiElement, String propertyName,
			Object value) {
		IMetaclass metaclass = XWT.getMetaclass(uiElement);
		IProperty property = metaclass.findProperty(propertyName);
		if (property == null) {
			throw new XWTException("Property " + propertyName + " not found.");
		}
		XWTLoaderManager.getActive().setPropertyValue(uiElement, property,
				value);
	}

	/**
	 * Remove the dynamic property value
	 * 
	 * @param javaclass
	 */
	static public void removePropertyValue(Object uiElement, IProperty property) {
		XWTLoaderManager.getActive().removePropertyValue(uiElement, property);
	}

	/**
	 * Remove the dynamic property value
	 * 
	 * @param javaclass
	 */
	static public boolean hasPropertyValue(Object uiElement, IProperty property) {
		return XWTLoaderManager.getActive().hasPropertyValue(uiElement,
				property);
	}

	/**
	 * Find a Data converter
	 * 
	 * @param converter
	 * @param type
	 */
	static public IConverter findConvertor(Class<?> source, Class<?> target) {
		return XWTLoaderManager.getActive().findConvertor(source, target);
	}

	/**
	 * Switch current loading context
	 * 
	 */
	public static void setLoadingContext(ILoadingContext loadingContext) {
		XWTLoaderManager.getActive().setLoadingContext(loadingContext);
	}

	/**
	 * Return current loading context
	 * 
	 * @return ILoadingContext
	 */
	public static ILoadingContext getLoadingContext() {
		return XWTLoaderManager.getActive().getLoadingContext();
	}

	/**
	 * Add a tracking option
	 * 
	 * @param tracking
	 */
	static public void addTracking(Tracking tracking) {
		XWTLoaderManager.getActive().addTracking(tracking);
	}

	/**
	 * Test if the tracking on argument is enabled.
	 * 
	 * @param tracking
	 * @return
	 */
	static public boolean isTracking(Tracking tracking) {
		return XWTLoaderManager.getActive().isTracking(tracking);
	}

	/**
	 * Get all tracking options
	 * 
	 * @return
	 */
	static public Set<Tracking> getTrackings() {
		return XWTLoaderManager.getActive().getTrackings();
	}

	/**
	 * Set up the default ICLRFactory
	 * 
	 * @param factory
	 */
	static public void setCLRFactory(ICLRFactory factory) {
		XWTLoaderManager.getActive().setCLRFactory(factory);
	}

	static public boolean checkInitialization() {
		if (isAllInitializersInitialized()) {
			return false;
		}
		return checkInitialization(-1);
	}

	static public boolean checkInitialization(long timeoutMillis) {
		long started = System.currentTimeMillis();
		while (true) {
			if (timeoutMillis != -1
					&& System.currentTimeMillis() - started > timeoutMillis) {
				return false;
			}

			if (isAllInitializersInitialized()) {
				return false;
			}

			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				return false;
			}
		}
	}

	private static boolean isAllInitializersInitialized() {
		synchronized (initializers) {
			for (IXWTInitializer initializer : initializers) {
				if (!initializer.isInitialized()) {
					return false;
				}
			}
		}
		return true;
	}

	/**
	 * The default CLRFactory.
	 * 
	 * @return
	 */
	static public ICLRFactory getCLRFactory() {
		return XWTLoaderManager.getActive().getCLRFactory();
	}

	/**
	 * Find a command by name
	 * 
	 * @param name
	 * @return
	 */
	static public ICommand getCommand(String name) {
		return XWTLoaderManager.getActive().getCommand(name);
	}

	public static IDataProvider findDataProvider(Object dataContext) {
		return XWTLoaderManager.getActive().findDataProvider(dataContext);
	}

	static public Realm getRealm() {
		return XWTLoaderManager.getActive().getRealm();
	}

	static public boolean isXWTNamespace(String namespace) {
		return IConstants.XWT_X_NAMESPACE.equals(namespace)
				|| IConstants.XWT_NAMESPACE.equals(namespace)
				|| namespace.startsWith(IConstants.XAML_CLR_NAMESPACE_PROTO);
	}

	/**
	 * Check if the value of a property is to resolve.
	 * 
	 * @param type
	 *            type of property
	 * @return
	 */
	public static boolean isFileResolveType(Class<?> type) {
		return XWTLoaderManager.getActive().isFileResolveType(type);
	}

	/**
	 * Register the value of a property is to resolve.
	 * 
	 * @param type
	 *            type of property
	 * @return
	 */
	public static void registerFileResolveType(Class<?> type) {
		XWTLoaderManager.getActive().registerFileResolveType(type);
	}

	/**
	 * Register the value of a property is to resolve.
	 * 
	 * @param type
	 *            type of property
	 * @return
	 */
	public static void unregisterFileResolveType(Class<?> type) {
		XWTLoaderManager.getActive().unregisterFileResolveType(type);
	}

	static class DisplayThread extends Thread implements Listener {
		protected long startTime = -1;
		protected boolean toStop = false;
		protected Runnable runnable;

		public DisplayThread(Runnable runnable) {
			this.runnable = runnable;
		}

		public void handleEvent(Event event) {
		}
	}

	/**
	 * Run in UI context.
	 * 
	 * @param runnable
	 */
	public static void runOnUIThread(final Runnable runnable) {
		String platform = SWT.getPlatform();
		if (platform.startsWith("win") || platform.endsWith("cocoa") || platform.startsWith("rap")) {
			XWTLoaderManager.getDefault();
			runnable.run();
		} else if (platform.endsWith("gtk")) {
			synchronized (displayLock) {
				if (displayThread == null || !displayThread.isAlive()) {
					try {
						Field field = Display.class.getDeclaredField("Default");
						if (field != null) {
							field.setAccessible(true);
							Display defaultDisplay = (Display) field.get(null);
							if (defaultDisplay != null) {
								displayThread = defaultDisplay.getThread();
							}
						}
					} catch (Exception e) {
					}
				}

				if (displayThread == null || !displayThread.isAlive()) {
					displayThread = new Thread() {
						private long startTime = -1;
						private Display display;
						private boolean toStop = false;
						private boolean ignoreNotification = false;
						protected Runnable runnable = new Runnable() {
							public void run() {
								if (ignoreNotification) {
									startTime = -1;
									return;
								}
								if (startTime == -1) {
									startTime = System.currentTimeMillis();
								} else {
									if ((System.currentTimeMillis() - startTime) > 10000
											&& display.getActiveShell() == null
											&& display.getShells().length == 0) {
										toStop = true;
										display.wake();
									} else {
										startTime = System.currentTimeMillis();
									}
								}
							}
						};

						@Override
						public void run() {
							// Set default XWT ICLRFactory
							XWTLoaderManager.getDefault();
							display = Display.getDefault();
							runnable.run();
							while (true) {
								if (!display.readAndDispatch()) {
									display.timerExec(10000, runnable);
									display.sleep();
									ignoreNotification = true;
								}
								if (toStop) {
									break;
								}
								startTime = -1;
							}
						}
					};
					displayThread.start();
				} else {
					XWTLoaderManager.getDefault();
					XWT.checkInitialization();
					Display display = Display.findDisplay(displayThread);
					if (display != null) {
						display.syncExec(runnable);
					}
				}
			}
		} else {
			throw new UnsupportedOperationException();
		}
	}

	public static void addInitializer(IXWTInitializer initializer) {
		synchronized (initializers) {
			if (!XWTLoaderManager.isStarted()) {
				initializers.add(initializer);
			}
		}
	}

	static List<IXWTInitializer> getInitializers() {
		return initializers;
	}

	public static Object findParent(Object element, Class<?> type) {
		Widget widget = UserData.getWidget(element);
		if (widget == null) {
			return null;
		}
		return UserData.findParent(widget, type);
	}

	static void runInitializers(IXWTLoader loader) {
		synchronized (initializers) {
			for (IXWTInitializer initializer : XWT.getInitializers()) {
				initializer.initialize(loader);
			}
		}
	}
}