/*******************************************************************************
* 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.papyrus.xwt;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.conversion.NumberToStringConverter;
import org.eclipse.core.databinding.conversion.StringToNumberConverter;
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.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.databinding.viewers.ObservableSetContentProvider;
import org.eclipse.papyrus.xwt.animation.Drawing;
import org.eclipse.papyrus.xwt.callback.IBeforeParsingCallback;
import org.eclipse.papyrus.xwt.collection.CollectionViewSource;
import org.eclipse.papyrus.xwt.converters.BindingToObject;
import org.eclipse.papyrus.xwt.converters.CollectionToBoolean;
import org.eclipse.papyrus.xwt.converters.CollectionToInteger;
import org.eclipse.papyrus.xwt.converters.DateToString;
import org.eclipse.papyrus.xwt.converters.EnumToString;
import org.eclipse.papyrus.xwt.converters.IStatusToBoolean;
import org.eclipse.papyrus.xwt.converters.IStatusToString;
import org.eclipse.papyrus.xwt.converters.ListToIObservableCollection;
import org.eclipse.papyrus.xwt.converters.ListToSet;
import org.eclipse.papyrus.xwt.converters.ObjectToBoolean;
import org.eclipse.papyrus.xwt.converters.ObjectToISelection;
import org.eclipse.papyrus.xwt.converters.ObjectToString;
import org.eclipse.papyrus.xwt.converters.SelectionToBoolean;
import org.eclipse.papyrus.xwt.converters.SetToIObservableCollection;
import org.eclipse.papyrus.xwt.converters.StringToBoolean;
import org.eclipse.papyrus.xwt.converters.StringToColor;
import org.eclipse.papyrus.xwt.converters.StringToDoubleArray;
import org.eclipse.papyrus.xwt.converters.StringToFont;
import org.eclipse.papyrus.xwt.converters.StringToFormAttachment;
import org.eclipse.papyrus.xwt.converters.StringToIValidationRule;
import org.eclipse.papyrus.xwt.converters.StringToIValueConverter;
import org.eclipse.papyrus.xwt.converters.StringToImage;
import org.eclipse.papyrus.xwt.converters.StringToIntArray;
import org.eclipse.papyrus.xwt.converters.StringToInteger;
import org.eclipse.papyrus.xwt.converters.StringToPoint;
import org.eclipse.papyrus.xwt.converters.StringToRectangle;
import org.eclipse.papyrus.xwt.converters.StringToType;
import org.eclipse.papyrus.xwt.converters.StringToURL;
import org.eclipse.papyrus.xwt.core.Condition;
import org.eclipse.papyrus.xwt.core.DataTrigger;
import org.eclipse.papyrus.xwt.core.EventTrigger;
import org.eclipse.papyrus.xwt.core.IBinding;
import org.eclipse.papyrus.xwt.core.IUserDataConstants;
import org.eclipse.papyrus.xwt.core.MultiDataTrigger;
import org.eclipse.papyrus.xwt.core.MultiTrigger;
import org.eclipse.papyrus.xwt.core.RadioEventGroup;
import org.eclipse.papyrus.xwt.core.Setter;
import org.eclipse.papyrus.xwt.core.Style;
import org.eclipse.papyrus.xwt.core.Trigger;
import org.eclipse.papyrus.xwt.core.TriggerBase;
import org.eclipse.papyrus.xwt.databinding.BindingContext;
import org.eclipse.papyrus.xwt.databinding.IBindingContext;
import org.eclipse.papyrus.xwt.dataproviders.ObjectDataProvider;
import org.eclipse.papyrus.xwt.input.ICommand;
import org.eclipse.papyrus.xwt.internal.core.BindingExpressionPath;
import org.eclipse.papyrus.xwt.internal.core.Core;
import org.eclipse.papyrus.xwt.internal.core.MetaclassManager;
import org.eclipse.papyrus.xwt.internal.core.MultiBinding;
import org.eclipse.papyrus.xwt.internal.core.ScopeKeeper;
import org.eclipse.papyrus.xwt.internal.core.ScopeManager;
import org.eclipse.papyrus.xwt.internal.core.UIResource;
import org.eclipse.papyrus.xwt.internal.core.UpdateSourceTrigger;
import org.eclipse.papyrus.xwt.internal.utils.ObjectUtil;
import org.eclipse.papyrus.xwt.internal.utils.UserData;
import org.eclipse.papyrus.xwt.javabean.ResourceLoaderFactory;
import org.eclipse.papyrus.xwt.javabean.ValueConvertorRegister;
import org.eclipse.papyrus.xwt.javabean.metadata.BindingMetaclass;
import org.eclipse.papyrus.xwt.javabean.metadata.ComboBoxCellEditorMetaclass;
import org.eclipse.papyrus.xwt.javabean.metadata.ExpandItemHeightAction;
import org.eclipse.papyrus.xwt.javabean.metadata.TableEditorMetaclass;
import org.eclipse.papyrus.xwt.javabean.metadata.TableViewerColumnMetaClass;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.AbstractProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.ColumnViewerColumnsProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.DataProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.DynamicBeanProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.DynamicProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.InputBeanProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.MultiSelectionBeanProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.PropertiesConstants;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.SingleSelectionBeanProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.StyleProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TableColumnEditorProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TableEditorDynamicProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TableItemEditorProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TableItemProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TableViewerColumnDynamicProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TableViewerColumnImageProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TableViewerColumnTextProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TableViewerColumnWidthProperty;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.TriggersProperty;
import org.eclipse.papyrus.xwt.jface.ComboBoxCellEditor;
import org.eclipse.papyrus.xwt.jface.DefaultCellModifier;
import org.eclipse.papyrus.xwt.jface.JFaceInitializer;
import org.eclipse.papyrus.xwt.jface.JFacesHelper;
import org.eclipse.papyrus.xwt.jface.ObservableTreeContentProvider;
import org.eclipse.papyrus.xwt.jface.ViewerFilter;
import org.eclipse.papyrus.xwt.metadata.DefaultLoadingType;
import org.eclipse.papyrus.xwt.metadata.DelegateProperty;
import org.eclipse.papyrus.xwt.metadata.ILoadingType;
import org.eclipse.papyrus.xwt.metadata.IMetaclass;
import org.eclipse.papyrus.xwt.metadata.IProperty;
import org.eclipse.papyrus.xwt.metadata.IValueLoading;
import org.eclipse.papyrus.xwt.utils.ResourceManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ControlEditor;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.ExpandItem;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.IME;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.List;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.TreeItem;
/**
* Default XWT loader
*
* @author yyang (yves.yang@soyatec.com) jliu (jin.liu@soyatec.com)
*/
public class XWTLoader implements IXWTLoader {
// Declarations
private Stack<Core> cores;
public Realm realm;
public XWTLoader() {
initialize();
}
public Object createUIProfile() {
Core core = new Core(new ResourceLoaderFactory(), this);
cores.push(core);
return core;
}
public boolean applyProfile(Object profile) {
if(profile instanceof Core) {
if(cores.peek() == profile) {
return false;
}
cores.push((Core)profile);
return true;
}
throw new XWTException("Wrong UI Profile.");
}
public Object restoreProfile() {
if(cores.size() > 1) {
return cores.pop();
}
throw new XWTException("No user-defined UI Profile.");
}
public Realm getRealm() {
if(realm != null) {
return realm;
}
Display display = Display.getCurrent();
if(display == null) {
display = Display.getDefault();
}
return SWTObservables.getRealm(display);
}
protected Core getCurrentCore() {
return cores.peek();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getLogger()
*/
public ILogger getLogger() {
return getCurrentCore().getLogger();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#setLogger(org.eclipse.papyrus.xwt.ILogger)
*/
public void setLogger(ILogger log) {
getCurrentCore().setLogger(log);
}
/**
* Get the dynamic property value
*
* @param javaclass
*/
public Object getPropertyValue(Object uiElement, IProperty property) {
return UserData.getLocalData(uiElement, property);
}
/**
* Set the dynamic property value
*
* @param javaclass
*/
public void setPropertyValue(Object uiElement, IProperty property, Object value) {
UserData.setLocalData(uiElement, property, value);
}
/**
* Remove the dynamic property value
*
* @param javaclass
*/
public void removePropertyValue(Object uiElement, IProperty property) {
UserData.removeLocalData(uiElement, property);
}
/**
* Remove the dynamic property value
*
* @param javaclass
*/
public boolean hasPropertyValue(Object uiElement, IProperty property) {
return UserData.hasLocalData(uiElement, property);
}
/**
* 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 <code>true</code> the listener is added, <code>false</code> if
* the listener already exists
*/
public boolean addObservableChangeListener(Object control, IChangeListener listener) {
ScopeKeeper scope = UserData.findScopeKeeper(control);
if(scope != null) {
return scope.addChangeListener(listener);
}
return false;
}
/**
* Undo the registration of the Observable IChangeListener for a given UI
* element.
*
* @param context
* @param listener
*/
public void removeObservableChangeListener(Object control, IChangeListener listener) {
ScopeKeeper scope = UserData.findScopeKeeper(control);
if(scope != null) {
scope.removeChangeListener(listener);
}
}
/**
*
* @param nsmapace
* @return
*/
public IObservable observe(Object control, Object data, String fullPath, UpdateSourceTrigger updateSourceTrigger) {
return ScopeManager.observe(control, data, new BindingExpressionPath(fullPath), updateSourceTrigger);
}
/**
*
* @param nsmapace
* @return
*/
public IObservableFactory observableFactory(Object control, String fullPath, UpdateSourceTrigger updateSourceTrigger) {
return ScopeManager.observableFactory(control, new BindingExpressionPath(fullPath), updateSourceTrigger);
}
/**
*
* @param nsmapace
* @return
*/
public IObservableList findObservableList(Object context, Object data, String fullPath) {
return ScopeManager.findObservableList(context, null, data, fullPath);
}
/**
*
* @param nsmapace
* @return
*/
public IObservableSet findObservableSet(Object context, Object data, String fullPath) {
return ScopeManager.findObservableSet(context, null, data, fullPath);
}
/**
*
* @param nsmapace
* @return
*/
public IObservableValue observableValue(Object control, Object data, String fullPath, UpdateSourceTrigger updateSourceTrigger) {
return ScopeManager.observableValue(control, data, fullPath, updateSourceTrigger);
}
/**
*
* @param nsmapace
* @return
*/
public IObservableValue findObservableValue(Object context, Object data, String fullPath) {
return ScopeManager.findObservableValue(context, null, data, fullPath);
}
/**
*
*/
public Object findResource(Object object, String key) {
return UserData.findResource(object, key);
}
public Map<String, Object> getResources(Object object) {
return UserData.getLocalResources(object);
}
/**
*
* @param nsmapace
* @param handler
*/
public void registerNamespaceHandler(String nsmapace, INamespaceHandler handler) {
getCurrentCore().registerNamespaceHandler(nsmapace, handler);
}
/**
*
* @param nsmapace
*/
public void unregisterNamespaceHandler(String nsmapace) {
getCurrentCore().unregisterNamespaceHandler(nsmapace);
}
/**
*
* @param nsmapace
* @return
*/
public INamespaceHandler getNamespaceHandler(String nsmapace) {
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
INamespaceHandler handler = core.getNamespaceHandler(nsmapace);
if(handler != null) {
return handler;
}
}
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getNamespace(java.lang.Class)
*/
public String getNamespace(Class<?> javaclass) {
if(getMetaclass(javaclass) != null) {
return IConstants.XWT_NAMESPACE;
}
Package javaPackage = javaclass.getPackage();
if(javaPackage == null) {
return IConstants.XAML_CLR_NAMESPACE_PROTO;
}
return IConstants.XAML_CLR_NAMESPACE_PROTO + javaclass.getPackage().getName();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getElementName(java.lang.Object)
*/
public String getElementName(Object object) {
return UserData.getElementName(object);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#findElementByName(org.eclipse.swt.widgets
* .Widget, java.lang.String)
*/
public Object findElementByName(Object context, String name) {
return UserData.findElementByName(context, name);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#getDataBindingContext(java.lang.Object,
* java.lang.String)
*/
public IBindingContext getBindingContext(Object element) {
IBindingContext dataBindingContext = UserData.getBindingContext(element);
if(dataBindingContext == null) {
dataBindingContext = UserData.createBindingContext(element);
}
return dataBindingContext;
}
public ICLRFactory getCLRFactory() {
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
ICLRFactory factory = core.getCLRFactory();
if(factory != null) {
return factory;
}
}
return null;
}
public void setCLRFactory(ICLRFactory clrFactory) {
cores.peek().setCLRFactory(clrFactory);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#getDataContext(org.eclipse.swt.widgets.
* Widget)
*/
public Object getDataContext(Object element) {
return UserData.getDataContext(element);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#getDataContext(org.eclipse.swt.widgets.
* Widget)
*/
public TriggerBase[] getTriggers(Object element) {
return UserData.getTriggers(element);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#setDataBindingContext(java.lang.Object,
* java.lang.Object)
*/
public void setDataBindingContext(Object widget, Object dataBindingContext) {
UserData.setBindingContext(widget, dataBindingContext);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#setDataContext(org.eclipse.swt.widgets.
* Widget, java.lang.Object)
*/
public void setDataContext(Object widget, Object dataContext) {
UserData.setDataContext(widget, dataContext);
}
/**
* Get the Triggers of given element
*
* @param context
* @return
*/
public void setTriggers(Object element, TriggerBase[] triggers) {
UserData.setTriggers(element, triggers);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#findCompositeParent(org.eclipse.swt.widgets
* .Widget)
*/
public Composite findCompositeParent(Object context) {
return UserData.findCompositeParent(context);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getMetaclass(java.lang.Object)
*/
public IMetaclass getMetaclass(Object object) {
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
IMetaclass metaclass = core.findMetaclass(object);
if(metaclass != null) {
return metaclass;
}
}
Class<?> javaClass = null;
if(object instanceof Class<?>) {
javaClass = (Class<?>)object;
} else {
javaClass = object.getClass();
}
Class<?> superclass = javaClass.getSuperclass();
IMetaclass superMetaclass = null;
if(superclass != null) {
superMetaclass = getMetaclass(superclass);
}
return getCurrentCore().registerMetaclass(javaClass, IConstants.XWT_NAMESPACE, superMetaclass);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#load(java.net.URL)
*/
public Object load(URL file) throws Exception {
return loadWithOptions(file, Collections.<String, Object> emptyMap());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#load(java.net.URL, java.lang.Object)
*/
public Object load(URL file, Object dataContext) throws Exception {
return load(null, file, dataContext);
}
public Object load(IUIResource resource, Object dataContext) throws Exception {
return load(null, resource, dataContext);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#load(org.eclipse.swt.widgets.Composite,
* java.net.URL)
*/
public Object load(Object parent, URL file) throws Exception {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(CONTAINER_PROPERTY, parent);
return loadWithOptions(file, options);
}
public Object load(Object parent, IUIResource resource) throws Exception {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(CONTAINER_PROPERTY, parent);
return loadWithOptions(resource, options);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#load(org.eclipse.swt.widgets.Composite,
* java.net.URL, java.lang.Object)
*/
public Object load(Object parent, URL file, Object dataContext) throws Exception {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(CONTAINER_PROPERTY, parent);
options.put(DATACONTEXT_PROPERTY, dataContext);
return loadWithOptions(file, options);
}
public Object load(Object parent, IUIResource resource, Object dataContext) throws Exception {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(CONTAINER_PROPERTY, parent);
options.put(DATACONTEXT_PROPERTY, dataContext);
return loadWithOptions(resource, options);
}
public Object load(Object parent, IUIResource resource, Map<String, Object> options) throws Exception {
if(options.isEmpty()) {
options = new HashMap<String, Object>();
}
options.put(CONTAINER_PROPERTY, parent);
return loadWithOptions(resource, options);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#load(org.eclipse.swt.widgets.Composite,
* java.lang.Class, java.lang.Object)
*/
public Object load(Object parent, Class<?> viewType, Object dataContext) throws Exception {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(CONTAINER_PROPERTY, parent);
options.put(DATACONTEXT_PROPERTY, dataContext);
return loadWithOptions(viewType, options);
}
protected Map<String, Object> prepareOptions(Map<String, Object> options, URL url) {
Boolean disabledStyle = (Boolean)options.get(DISABLE_STYLES_PROPERTY);
if(!Boolean.TRUE.equals(disabledStyle)) {
Collection<IStyle> defaultStyles = getDefaultStyles();
Object styles = options.get(DEFAULT_STYLES_PROPERTY);
if(styles != null) {
if(styles instanceof IStyle) {
defaultStyles.add((IStyle)styles);
} else if(styles instanceof Collection) {
for(Object element : (Collection<?>)styles) {
if(element instanceof IStyle) {
defaultStyles.add((IStyle)element);
} else {
throw new XWTException("IStyle is expected in [styles] parameters.");
}
}
} else if(styles instanceof Object[]) {
for(Object element : (Object[])styles) {
if(element instanceof IStyle) {
defaultStyles.add((IStyle)element);
} else {
throw new XWTException("IStyle is expected in [styles] parameters.");
}
}
}
options.remove(DEFAULT_STYLES_PROPERTY);
}
if(!defaultStyles.isEmpty()) {
ResourceDictionary dictionary = (ResourceDictionary)options.get(RESOURCE_DICTIONARY_PROPERTY);
if(dictionary == null) {
dictionary = new ResourceDictionary();
if(options == Collections.EMPTY_MAP) {
options = new HashMap<String, Object>();
}
options.put(RESOURCE_DICTIONARY_PROPERTY, dictionary);
}
dictionary.put(Core.DEFAULT_STYLES_KEY, defaultStyles);
}
}
// Register URL property
if(options == Collections.EMPTY_MAP) {
options = new HashMap<String, Object>();
}
options.put(URL_PROPERTY, url);
return options;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#loadWithOptions(java.lang.Class,
* java.util.Map)
*/
public Object loadWithOptions(Class<?> viewType, Map<String, Object> options) throws Exception {
ILoadingContext context = getLoadingContext();
try {
setLoadingContext(new DefaultLoadingContext(viewType.getClassLoader()));
options = prepareOptions(options, null);
return loadWithOptions(viewType.getResource(viewType.getSimpleName() + ".xwt"), options);
} finally {
setLoadingContext(context);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#open(java.lang.Class)
*/
public void open(Class<?> type) throws Exception {
open(type.getResource(type.getSimpleName() + IConstants.XWT_EXTENSION_SUFFIX), Collections.emptyMap());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#open(java.net.URL)
*/
public void open(URL url) throws Exception {
open(url, Collections.emptyMap());
}
public void open(IUIResource resource) throws Exception {
open(resource, Collections.emptyMap());
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#load(org.eclipse.swt.widgets.Composite,
* java.io.InputStream, java.net.URL, java.lang.Object)
*/
public Object load(Object parent, InputStream stream, URL file, Object dataContext) throws Exception {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(CONTAINER_PROPERTY, parent);
options.put(DATACONTEXT_PROPERTY, dataContext);
return loadWithOptions(stream, file, options);
}
public IUIResource loadAsResource(InputStream stream, URL input) throws Exception {
return loadAsResource(stream, input, null);
}
public IUIResource loadAsResource(InputStream stream, URL input, IBeforeParsingCallback parsingCallback) throws Exception {
return getCurrentCore().loadAsResource(stream, input, parsingCallback);
}
public IUIResource loadAsResource(URL input) throws Exception {
return loadAsResource(null, input, null);
}
public IUIResource loadAsResource(URL input, IBeforeParsingCallback parsingCallback) throws Exception {
return loadAsResource(null, input, parsingCallback);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#open(java.net.URL, java.lang.Object)
*/
public void open(URL url, Object dataContext) throws Exception {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(DATACONTEXT_PROPERTY, dataContext);
open(url, options);
}
public void open(IUIResource resource, Object dataContext) throws Exception {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(DATACONTEXT_PROPERTY, dataContext);
open(resource, options);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#open(java.lang.Class,
* java.lang.Object)
*/
public void open(Class<?> type, Object dataContext) throws Exception {
open(type.getResource(type.getSimpleName() + IConstants.XWT_EXTENSION_SUFFIX), dataContext);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#open(java.net.URL, java.util.Map)
*/
public void open(final URL url, final Map<String, Object> options) throws Exception {
if(SWT.getPlatform().startsWith("win")) {
if(Display.getCurrent() == null) {
new Display();
}
Realm.runWithDefault(getRealm(), new Runnable() {
public void run() {
try {
if(url == null) {
throw new XWTException("UI Resource is not found.");
}
Object element = loadWithOptions(url, options);
Shell shell = XWT.findShell(element);
if(shell == null) {
throw new XWTException("Root element must be a control.");
}
shell.addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
Shell[] shells = Display.getCurrent().getShells();
if(shells.length == 0) {
ResourceManager.resources.dispose();
}
}
});
shell.open();
while(!shell.isDisposed()) {
if(!shell.getDisplay().readAndDispatch()) {
shell.getDisplay().sleep();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
return;
}
Display defaultDisplay = Display.getDefault();
if(Thread.currentThread() == defaultDisplay.getThread()) {
Realm.runWithDefault(getRealm(), new Runnable() {
public void run() {
try {
if(url == null) {
throw new XWTException("UI Resource is not found.");
}
Object element = loadWithOptions(url, options);
Shell shell = XWT.findShell(element);
shell.open();
long startTime = -1;
while(true) {
if(!Display.getDefault().readAndDispatch()) {
Display.getDefault().sleep();
}
Shell[] shells = Display.getDefault().getShells();
if(shells.length == 0) {
if(startTime == -1) {
startTime = System.currentTimeMillis();
} else if((System.currentTimeMillis() - startTime) > 1000) {
break;
}
} else {
startTime = -1;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
} else {
defaultDisplay.asyncExec(new Runnable() {
public void run() {
Realm.runWithDefault(getRealm(), new Runnable() {
public void run() {
try {
if(url == null) {
throw new XWTException("UI Resource is not found.");
}
Object element = loadWithOptions(url, options);
Shell shell = XWT.findShell(element);
if(shell == null) {
throw new XWTException("Root element must be a control.");
}
shell.open();
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
});
}
}
public void open(final IUIResource resource, final Map<String, Object> options) throws Exception {
if(SWT.getPlatform().startsWith("win")) {
if(Display.getCurrent() == null) {
new Display();
}
Realm.runWithDefault(getRealm(), new Runnable() {
public void run() {
try {
Object element = loadWithOptions(resource, options);
Shell shell = XWT.findShell(element);
if(shell == null) {
throw new XWTException("Root element must be a control.");
}
shell.addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
Shell[] shells = Display.getCurrent().getShells();
if(shells.length == 0) {
ResourceManager.resources.dispose();
}
}
});
shell.open();
while(!shell.isDisposed()) {
if(!shell.getDisplay().readAndDispatch()) {
shell.getDisplay().sleep();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
return;
}
Display defaultDisplay = Display.getDefault();
if(Thread.currentThread() == defaultDisplay.getThread()) {
Realm.runWithDefault(getRealm(), new Runnable() {
public void run() {
try {
Object element = loadWithOptions(resource, options);
Shell shell = XWT.findShell(element);
if(shell == null) {
throw new XWTException("Root element must be a control.");
}
shell.open();
long startTime = -1;
while(true) {
if(!Display.getDefault().readAndDispatch()) {
Display.getDefault().sleep();
}
Shell[] shells = Display.getDefault().getShells();
if(shells.length == 0) {
if(startTime == -1) {
startTime = System.currentTimeMillis();
} else if((System.currentTimeMillis() - startTime) > 1000) {
break;
}
} else {
startTime = -1;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
} else {
defaultDisplay.asyncExec(new Runnable() {
public void run() {
Realm.runWithDefault(getRealm(), new Runnable() {
public void run() {
try {
Object element = loadWithOptions(resource, options);
Shell shell = XWT.findShell(element);
if(shell == null) {
throw new XWTException("Root element must be a control.");
}
shell.open();
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
});
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#convertFrom(org.eclipse.papyrus.xwt.metadata
* .IMetaclass, java.lang.String)
*/
public Object convertFrom(IMetaclass type, String string) {
Class<?> targetType = type.getType();
return convertFrom(targetType, string);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#convertFrom(java.lang.Class,
* java.lang.String)
*/
public Object convertFrom(Class<?> targetType, String string) {
if(targetType == String.class) {
return string;
}
IConverter converter = findConvertor(String.class, targetType);
if(converter != null) {
return converter.convert(string);
}
if(targetType == Object.class) {
return string;
}
throw new XWTException("Converter is missing of type: " + targetType.getName() + " from String");
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#loadWithOptions(java.net.URL,
* java.util.Map)
*/
public Object loadWithOptions(URL url, Map<String, Object> options) throws Exception {
if(url == null) {
throw new XWTException("UI Resource is not found.");
}
Composite object = (Composite)options.get(CONTAINER_PROPERTY);
ILoadingContext loadingContext = (object != null ? getLoadingContext(object) : getLoadingContext());
options = prepareOptions(options, url);
Object visualObject = getCurrentCore().load(loadingContext, url, options);
return visualObject;
}
public Object loadWithOptions(IUIResource resource, Map<String, Object> options) throws Exception {
UIResource uiResource = (UIResource)resource;
Object object = options.get(CONTAINER_PROPERTY);
ILoadingContext loadingContext = (object != null ? getLoadingContext(object) : getLoadingContext());
options = prepareOptions(options, uiResource.getURL());
Object visualObject = getCurrentCore().load(loadingContext, resource, options);
return visualObject;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#load(java.io.InputStream,
* java.net.URL)
*/
public Object load(InputStream stream, URL url) throws Exception {
return loadWithOptions(stream, url, Collections.<String, Object> emptyMap());
}
public Object load(IUIResource resource) throws Exception {
return loadWithOptions(resource, Collections.<String, Object> emptyMap());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#loadWithOptions(java.io.InputStream,
* java.net.URL, java.util.Map)
*/
public Object loadWithOptions(InputStream stream, URL base, Map<String, Object> options) throws Exception {
Composite object = (Composite)options.get(CONTAINER_PROPERTY);
ILoadingContext loadingContext = (object != null ? getLoadingContext(object) : getLoadingContext());
options = prepareOptions(options, base);
Control visualObject = getCurrentCore().load(loadingContext, stream, base, options);
return visualObject;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getAllMetaclasses()
*/
public IMetaclass[] getAllMetaclasses() {
Collection<IMetaclass> collector = new ArrayList<IMetaclass>();
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
Collection<IMetaclass> metaclasses = core.getAllMetaclasses(IConstants.XWT_NAMESPACE);
collector.addAll(metaclasses);
}
return collector.toArray(new IMetaclass[collector.size()]);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getMetaclass(java.lang.String,
* java.lang.String)
*/
public IMetaclass getMetaclass(String tagName, String ns) {
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
IMetaclass metaclass = core.getMetaclass(getLoadingContext(), tagName, ns);
if(metaclass != null) {
return metaclass;
}
}
throw new XWTException("Type " + tagName + " is not found.");
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#registerMetaclass(java.lang.Class)
*/
public IMetaclass registerMetaclass(Class<?> type) {
return getCurrentCore().registerMetaclass(type, IConstants.XWT_NAMESPACE);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#registerMetaclass(java.lang.Class)
*/
public void registerMetaclass(IMetaclass type) {
getCurrentCore().registerMetaclass(type, IConstants.XWT_NAMESPACE);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#registerMetaclassFactory(org.eclipse.e4
* .xwt.IMetaclassFactory)
*/
public void registerMetaclassFactory(IMetaclassFactory metaclassFactory) {
getCurrentCore().registerMetaclassFactory(metaclassFactory);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#findConvertor(java.lang.Class,
* java.lang.Class)
*/
public IConverter findConvertor(Class<?> source, Class<?> target) {
source = ObjectUtil.normalizedType(source);
target = ObjectUtil.normalizedType(target);
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
IConverter converter = core.findConvertor(source, target);
if(converter != null) {
return converter;
}
}
return null;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#registerConvertor(org.eclipse.core.databinding
* .conversion.IConverter)
*/
public void registerConvertor(IConverter converter) {
getCurrentCore().registerConvertor(converter);
}
protected void registerConvertor(Class<?> converter, String methodName) {
getCurrentCore().registerConvertor(converter, methodName);
}
protected void registerConvertor(Class<?> converterType, String methodName, boolean value) {
getCurrentCore().registerConvertor(converterType, methodName, value);
}
protected void registerConvertor(ValueConvertorRegister convertorRegister, Class<?> source, Class<?> target, Class<?> converterType, String methodName, boolean value) {
getCurrentCore().registerConvertor(convertorRegister, source, target, converterType, methodName, value);
}
protected IConverter loadConvertor(Class<?> converter, String methodName, boolean value) {
return getCurrentCore().loadConvertor(converter, methodName, value);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#addTracking(org.eclipse.papyrus.xwt.Tracking)
*/
public void addTracking(Tracking tracking) {
getCurrentCore().addTracking(tracking);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#isTracking(org.eclipse.papyrus.xwt.Tracking)
*/
public boolean isTracking(Tracking tracking) {
return getCurrentCore().isTracking(tracking);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getTrackings()
*/
public Set<Tracking> getTrackings() {
return getCurrentCore().getTrackings();
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#removeTracking(org.eclipse.papyrus.xwt.Tracking)
*/
public void removeTracking(Tracking tracking) {
getCurrentCore().removeTracking(tracking);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#registerCommand(java.lang.String,
* org.eclipse.papyrus.xwt.input.ICommand)
*/
public void registerCommand(String name, ICommand command) {
getCurrentCore().registerCommand(name, command);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getCommand(java.lang.String)
*/
public ICommand getCommand(String name) {
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
ICommand command = core.getCommand(name);
if(command != null) {
return command;
}
}
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getCommands()
*/
public Map<String, ICommand> getCommands() {
HashMap<String, ICommand> collector = new HashMap<String, ICommand>();
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
Map<String, ICommand> map = core.getCommands();
if(map != null) {
collector.putAll(map);
}
}
return collector;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#unregisterCommand(java.lang.String)
*/
public void unregisterCommand(String name) {
getCurrentCore().unregisterCommand(name);
}
/**
* Register a command to a name
*
* @param name
* @param command
*/
public void registerEventGroup(Class<?> type, IEventGroup eventGroup) {
IMetaclass metaclass = getMetaclass(type);
metaclass.addEventGroup(eventGroup);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#addDefaultStyle(org.eclipse.papyrus.xwt.IStyle)
*/
public void addDefaultStyle(IStyle style) {
getCurrentCore().addDefaultStyle(style);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#removeDefaultStyle(org.eclipse.papyrus.xwt.IStyle
* )
*/
public void removeDefaultStyle(IStyle style) {
getCurrentCore().removeDefaultStyle(style);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getDefaultStyles()
*/
public Collection<IStyle> getDefaultStyles() {
return getCurrentCore().getDefaultStyles();
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#addDataProviderFactory(org.eclipse.papyrus.xwt
* .IDataProviderFactory)
*/
public void addDataProviderFactory(String name, IDataProviderFactory dataProviderFactory) {
getCurrentCore().addDataProviderFactory(name, dataProviderFactory);
registerMetaclass(dataProviderFactory.getType());
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#removeDataProviderFactory(org.eclipse.e4
* .xwt.IDataProviderFactory)
*/
public void removeDataProviderFactory(String name) {
getCurrentCore().removeDataProviderFactory(name);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#removeDataProviderFactory(org.eclipse.e4
* .xwt.IDataProviderFactory)
*/
public void removeDataProviderFactory(IDataProviderFactory dataProviderFactory) {
getCurrentCore().removeDataProviderFactory(dataProviderFactory);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getDataProviderFactories()
*/
public Collection<IDataProviderFactory> getDataProviderFactories() {
ArrayList<IDataProviderFactory> collector = new ArrayList<IDataProviderFactory>();
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
Collection<IDataProviderFactory> factories = core.getDataProviderFactories();
if(factories != null) {
collector.addAll(factories);
}
}
return collector;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#findDataProvider(java.lang.Object)
*/
public IDataProvider findDataProvider(Object dataContext) {
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
IDataProvider provider = core.findDataProvider(dataContext);
if(provider != null) {
return provider;
}
}
return null;
}
private synchronized void initialize() {
cores = new Stack<Core>();
Core core = new Core(new ResourceLoaderFactory(), this);
cores.push(core);
core.registerService(ValueConvertorRegister.class, new ValueConvertorRegister());
core.registerMetaclassManager(IConstants.XWT_NAMESPACE, new MetaclassManager(null, null, this));
core.registerMetaclass(new BindingMetaclass(this), IConstants.XWT_NAMESPACE);
core.registerMetaclass(new BindingMetaclass(MultiBinding.class, this), IConstants.XWT_NAMESPACE);
core.registerMetaclass(new TableEditorMetaclass(core.getMetaclass(ControlEditor.class, IConstants.XWT_NAMESPACE), this), IConstants.XWT_NAMESPACE);
registerConvertor(ObjectToString.FROM_OBJECT);
registerConvertor(DateToString.instance);
registerConvertor(EnumToString.instance);
registerConvertor(StringToInteger.instance);
// It is not supported by eclipse 3.4.1
registerConvertor(StringToNumberConverter.class, "toBigDecimal");
registerConvertor(StringToNumberConverter.class, "toByte", false);
registerConvertor(StringToNumberConverter.toLong(false));
// It is not supported by eclipse 3.4.1
registerConvertor(StringToNumberConverter.class, "toShort", false);
registerConvertor(StringToNumberConverter.toFloat(false));
registerConvertor(StringToNumberConverter.toDouble(false));
registerConvertor(NumberToStringConverter.fromInteger(false));
// It is not supported by eclipse 3.4.1
registerConvertor(NumberToStringConverter.class, "fromBigDecimal");
registerConvertor(NumberToStringConverter.class, "fromByte", false);
registerConvertor(NumberToStringConverter.fromLong(false));
// It is not supported by eclipse 3.4.1
registerConvertor(NumberToStringConverter.class, "fromShort", false);
registerConvertor(NumberToStringConverter.fromFloat(false));
registerConvertor(NumberToStringConverter.fromDouble(false));
registerConvertor(StringToBoolean.instance);
registerConvertor(ObjectToBoolean.instance);
registerConvertor(SelectionToBoolean.instance);
registerConvertor(CollectionToBoolean.instance);
registerConvertor(CollectionToInteger.instance);
registerConvertor(StringToIntArray.instance);
registerConvertor(StringToDoubleArray.instance);
registerConvertor(BindingToObject.instance);
registerConvertor(StringToColor.instance);
registerConvertor(StringToFont.instance);
registerConvertor(StringToImage.instance);
registerConvertor(StringToPoint.instance);
registerConvertor(StringToRectangle.instance);
registerConvertor(StringToURL.instance);
registerConvertor(StringToType.instance);
registerConvertor(StringToFormAttachment.instance);
registerConvertor(StringToIValidationRule.instance);
registerConvertor(StringToIValueConverter.instance);
registerConvertor(ListToIObservableCollection.instance);
registerConvertor(SetToIObservableCollection.instance);
registerConvertor(ObjectToISelection.instance);
registerConvertor(ListToSet.instance);
// registerConvertor(StringToKeyTime.instance);
// registerConvertor(StringToKeySpline.instance);
registerConvertor(IStatusToString.instance);
registerConvertor(IStatusToBoolean.instance);
ValueConvertorRegister convertorRegister = (ValueConvertorRegister)core.getService(ValueConvertorRegister.class);
convertorRegister.register(String.class, float.class, StringToNumberConverter.toFloat(true));
convertorRegister.register(String.class, int.class, StringToInteger.instance);
// It is not supported by eclipse 3.4.1
// convertorRegister.register(String.class, short.class,
// StringToNumberConverter.toShort(true));
registerConvertor(convertorRegister, String.class, short.class, StringToNumberConverter.class, "toShort", true);
convertorRegister.register(String.class, long.class, StringToNumberConverter.toLong(true));
// It is not supported by eclipse 3.4.1
// convertorRegister.register(String.class, byte.class,
// StringToNumberConverter.toByte(true));
registerConvertor(convertorRegister, String.class, byte.class, StringToNumberConverter.class, "toByte", true);
convertorRegister.register(String.class, boolean.class, StringToBoolean.instance);
convertorRegister.register(String.class, double.class, StringToNumberConverter.toDouble(true));
convertorRegister.register(float.class, String.class, NumberToStringConverter.fromFloat(true));
convertorRegister.register(int.class, String.class, NumberToStringConverter.fromInteger(true));
// It is not supported by eclipse 3.4.1
// convertorRegister.register(short.class, String.class,
// NumberToStringConverter.fromShort(true));
registerConvertor(convertorRegister, short.class, String.class, NumberToStringConverter.class, "fromShort", true);
convertorRegister.register(long.class, String.class, NumberToStringConverter.fromLong(true));
// It is not supported by eclipse 3.4.1
// convertorRegister.register(byte.class, String.class,
// NumberToStringConverter.fromByte(true));
registerConvertor(convertorRegister, byte.class, String.class, NumberToStringConverter.class, "fromByte", true);
convertorRegister.register(double.class, String.class, NumberToStringConverter.fromDouble(true));
Class<?> type = org.eclipse.swt.widgets.Widget.class;
IMetaclass metaclass = registerMetaclass(type);
IProperty drawingProperty = new AbstractProperty(IUserDataConstants.XWT_DRAWING_KEY, Drawing.class) {
public void setValue(Object target, Object value) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchFieldException {
if(!ObjectUtil.isAssignableFrom(IBinding.class, getType())) {
if(value != null) {
value = ObjectUtil.resolveValue(value, getType(), value);
}
}
}
public Object getValue(Object target) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchFieldException {
return null;
}
};
metaclass.addProperty(drawingProperty);
IProperty dataContextProperty = new DataProperty(IConstants.XAML_DATA_CONTEXT, IUserDataConstants.XWT_DATACONTEXT_KEY);
metaclass.addProperty(dataContextProperty);
ILoadingType loadingType = new DefaultLoadingType(IValueLoading.PostChildren, new IProperty[]{ dataContextProperty });
metaclass.addProperty(new DataProperty(IConstants.XAML_BINDING_CONTEXT, IUserDataConstants.XWT_BINDING_CONTEXT_KEY));
metaclass.addProperty(new TriggersProperty(loadingType));
metaclass.addProperty(new StyleProperty());
registerEventGroup(type, new RadioEventGroup(IEventConstants.KEY_GROUP));
registerEventGroup(type, new RadioEventGroup(IEventConstants.MOUSE_GROUP));
registerEventGroup(type, new RadioEventGroup(IEventConstants.MOUSE_MOVING_GROUP));
registerEventGroup(type, new RadioEventGroup(IEventConstants.FOCUS_GROUP));
registerEventGroup(type, new RadioEventGroup(IEventConstants.EXPAND_GROUP));
registerEventGroup(type, new RadioEventGroup(IEventConstants.WINDOW_GROUP));
registerEventGroup(type, new RadioEventGroup(IEventConstants.ACTIVATION_GROUP));
registerEventGroup(type, new RadioEventGroup(IEventConstants.HARD_KEY));
type = org.eclipse.swt.browser.Browser.class;
IMetaclass browserMetaclass = registerMetaclass(type);
browserMetaclass.addProperty(new DynamicProperty(type, String.class, PropertiesConstants.PROPERTY_URL, loadingType));
browserMetaclass.addProperty(new DynamicProperty(type, String.class, PropertiesConstants.PROPERTY_TEXT, loadingType));
IMetaclass buttonMetaclass = registerMetaclass(Button.class);
buttonMetaclass.addProperty(new DataProperty(IConstants.XAML_COMMAND, IUserDataConstants.XWT_COMMAND_KEY, ICommand.class));
registerMetaclass(org.eclipse.swt.widgets.Canvas.class);
registerMetaclass(org.eclipse.swt.widgets.Caret.class);
metaclass = registerMetaclass(org.eclipse.swt.widgets.Combo.class);
if(metaclass != null) {
IProperty property = metaclass.findProperty("text");
IProperty inputProperty = new DelegateProperty(property, loadingType);
metaclass.addProperty(inputProperty);
}
registerMetaclass(org.eclipse.swt.widgets.Composite.class);
registerMetaclass(org.eclipse.swt.widgets.CoolBar.class);
registerMetaclass(org.eclipse.swt.widgets.CoolItem.class);
registerMetaclass(org.eclipse.swt.widgets.DateTime.class);
registerMetaclass(org.eclipse.swt.widgets.Decorations.class);
registerMetaclass(org.eclipse.swt.widgets.ExpandBar.class);
IMetaclass expandItemMetaclass = registerMetaclass(ExpandItem.class);
expandItemMetaclass.findProperty("control").addSetPostAction(new ExpandItemHeightAction());
registerMetaclass(Group.class);
registerMetaclass(IME.class);
registerMetaclass(Label.class);
registerMetaclass(Link.class);
registerMetaclass(Listener.class);
registerMetaclass(List.class);
registerMetaclass(Menu.class);
IMetaclass menuItemMetaclass = registerMetaclass(MenuItem.class);
menuItemMetaclass.addProperty(new DataProperty(IConstants.XAML_COMMAND, IUserDataConstants.XWT_COMMAND_KEY, ICommand.class));
registerMetaclass(org.eclipse.swt.widgets.MessageBox.class);
registerMetaclass(org.eclipse.swt.widgets.ProgressBar.class);
registerMetaclass(org.eclipse.swt.widgets.Sash.class);
registerMetaclass(org.eclipse.swt.widgets.Scale.class);
registerMetaclass(org.eclipse.swt.widgets.ScrollBar.class);
registerMetaclass(org.eclipse.swt.widgets.Shell.class);
registerMetaclass(org.eclipse.swt.widgets.Slider.class);
registerMetaclass(org.eclipse.swt.widgets.Spinner.class);
registerMetaclass(org.eclipse.swt.widgets.TabFolder.class);
registerMetaclass(org.eclipse.swt.widgets.TabItem.class);
registerMetaclass(org.eclipse.swt.widgets.Table.class);
type = org.eclipse.swt.widgets.TableItem.class;
metaclass = registerMetaclass(type);
metaclass.addProperty(new TableItemProperty());
metaclass.addProperty(new TableItemEditorProperty());
metaclass.addProperty(new DynamicBeanProperty(TableItem.class, String[].class, PropertiesConstants.PROPERTY_TEXTS, PropertiesConstants.PROPERTY_TEXT));
registerMetaclass(TableItemProperty.Cell.class);
registerMetaclass(ControlEditor.class);
registerMetaclass(TableEditor.class);
IMetaclass TableEditorMetaclass = core.getMetaclass(TableEditor.class, IConstants.XWT_NAMESPACE);
TableEditorMetaclass.addProperty(new TableEditorDynamicProperty(loadingType));
type = org.eclipse.swt.widgets.TableColumn.class;
metaclass = registerMetaclass(type);
metaclass.addProperty(new TableColumnEditorProperty());
registerMetaclass(org.eclipse.swt.widgets.Text.class);
registerMetaclass(org.eclipse.swt.widgets.ToolBar.class);
registerMetaclass(org.eclipse.swt.widgets.ToolItem.class);
registerMetaclass(org.eclipse.swt.widgets.ToolTip.class);
registerMetaclass(org.eclipse.swt.widgets.Tracker.class);
registerMetaclass(org.eclipse.swt.widgets.Tray.class);
registerMetaclass(org.eclipse.swt.widgets.Tree.class);
registerMetaclass(org.eclipse.swt.widgets.TreeColumn.class);
type = org.eclipse.swt.widgets.TreeItem.class;
registerMetaclass(type);
metaclass = registerMetaclass(type);
metaclass.addProperty(new DynamicBeanProperty(TreeItem.class, String[].class, PropertiesConstants.PROPERTY_TEXTS, PropertiesConstants.PROPERTY_TEXT));
if(metaclass != null) {
IProperty property = metaclass.findProperty("expanded");
IProperty expandedProperty = new DelegateProperty(property, loadingType);
metaclass.addProperty(expandedProperty);
}
// registerMetaclass(org.eclipse.swt.layout.FillData.class);
registerMetaclass(org.eclipse.swt.layout.FillLayout.class);
registerMetaclass(org.eclipse.swt.layout.FormAttachment.class);
registerMetaclass(org.eclipse.swt.layout.FormData.class);
registerMetaclass(org.eclipse.swt.layout.FormLayout.class);
registerMetaclass(org.eclipse.swt.layout.GridData.class);
registerMetaclass(org.eclipse.swt.layout.GridLayout.class);
registerMetaclass(org.eclipse.swt.layout.RowData.class);
registerMetaclass(org.eclipse.swt.layout.RowLayout.class);
registerMetaclass(org.eclipse.swt.custom.StackLayout.class);
registerMetaclass(org.eclipse.swt.custom.CLabel.class);
metaclass = registerMetaclass(org.eclipse.swt.custom.CCombo.class);
if(metaclass != null) {
IProperty property = metaclass.findProperty("text");
IProperty inputProperty = new DelegateProperty(property, loadingType);
metaclass.addProperty(inputProperty);
}
registerMetaclass(org.eclipse.swt.custom.CTabFolder.class);
registerMetaclass(org.eclipse.swt.custom.CTabItem.class);
metaclass = registerMetaclass(org.eclipse.swt.custom.SashForm.class);
if(metaclass != null) {
IProperty property = metaclass.findProperty("weights");
IProperty inputProperty = new DelegateProperty(property, loadingType);
metaclass.addProperty(inputProperty);
}
registerMetaclass(org.eclipse.swt.custom.StyledText.class);
registerMetaclass(org.eclipse.swt.custom.ScrolledComposite.class);
registerMetaclass(org.eclipse.swt.custom.TableTree.class);
registerMetaclass(org.eclipse.swt.custom.ViewForm.class);
registerMetaclass(org.eclipse.swt.custom.CBanner.class);
registerMetaclass(org.eclipse.swt.custom.TableCursor.class);
type = org.eclipse.jface.viewers.Viewer.class;
metaclass = core.getMetaclass(type, IConstants.XWT_NAMESPACE);
if(metaclass != null) {
IProperty property = metaclass.findProperty("Input");
IProperty inputProperty = new InputBeanProperty(property, loadingType);
metaclass.addProperty(inputProperty);
metaclass.addProperty(new DataProperty(IConstants.XAML_DATA_CONTEXT, IUserDataConstants.XWT_DATACONTEXT_KEY));
metaclass.removeProperty("selection");
metaclass.addProperty(new DataProperty(PropertiesConstants.PROPERTY_BINDING_PATH, IUserDataConstants.XWT_PROPERTY_DATA_KEY, String.class));
metaclass.addProperty(new DataProperty(PropertiesConstants.PROPERTY_ITEM_TEXT, IUserDataConstants.XWT_PROPERTY_ITEM_TEXT_KEY, IBinding.class));
metaclass.addProperty(new DataProperty(PropertiesConstants.PROPERTY_ITEM_IMAGE, IUserDataConstants.XWT_PROPERTY_ITEM_IMAGE_KEY, IBinding.class));
ILoadingType inputLoadingType = new DefaultLoadingType(IValueLoading.PostChildren, new IProperty[]{ inputProperty });
metaclass.addProperty(new SingleSelectionBeanProperty(PropertiesConstants.PROPERTY_SINGLE_SELECTION, inputLoadingType));
metaclass.addProperty(new MultiSelectionBeanProperty(PropertiesConstants.PROPERTY_MULTI_SELECTION, inputLoadingType));
}
type = org.eclipse.jface.viewers.AbstractListViewer.class;
metaclass = core.getMetaclass(type, IConstants.XWT_NAMESPACE);
if(metaclass != null) {
metaclass.addInitializer(new JFaceInitializer());
}
type = org.eclipse.jface.viewers.ColumnViewer.class;
metaclass = core.getMetaclass(type, IConstants.XWT_NAMESPACE);
if(metaclass != null) {
metaclass.addProperty(new DynamicBeanProperty(type, String[].class, PropertiesConstants.PROPERTY_COLUMN_PROPERTIES));
metaclass.addProperty(new ColumnViewerColumnsProperty());
metaclass.addInitializer(new JFaceInitializer());
}
for(Class<?> cls : JFacesHelper.getSupportedElements()) {
registerMetaclass(cls);
}
type = org.eclipse.jface.viewers.TableViewer.class;
metaclass = core.getMetaclass(type, IConstants.XWT_NAMESPACE);
IProperty property = metaclass.findProperty("table");
if(property instanceof AbstractProperty) {
AbstractProperty abstractProperty = (AbstractProperty)property;
abstractProperty.setValueAsParent(true);
}
core.registerMetaclass(new ComboBoxCellEditorMetaclass(core.getMetaclass(ComboBoxCellEditor.class.getSuperclass(), IConstants.XWT_NAMESPACE), this), IConstants.XWT_NAMESPACE);
type = org.eclipse.jface.viewers.TableViewerColumn.class;
core.registerMetaclass(new TableViewerColumnMetaClass(core.getMetaclass(type.getSuperclass(), IConstants.XWT_NAMESPACE), this), IConstants.XWT_NAMESPACE);
metaclass = core.getMetaclass(type, IConstants.XWT_NAMESPACE);
//
// PROPERTY_DATA_KEY
//
metaclass.addProperty(new TableViewerColumnWidthProperty());
metaclass.addProperty(new TableViewerColumnTextProperty());
metaclass.addProperty(new TableViewerColumnImageProperty());
metaclass.addProperty(new TableViewerColumnDynamicProperty(PropertiesConstants.PROPERTY_BINDING_PATH, IUserDataConstants.XWT_PROPERTY_DATA_KEY, String.class));
metaclass.addProperty(new TableViewerColumnDynamicProperty(PropertiesConstants.PROPERTY_ITEM_TEXT, IUserDataConstants.XWT_PROPERTY_ITEM_TEXT_KEY, IBinding.class));
metaclass.addProperty(new TableViewerColumnDynamicProperty(PropertiesConstants.PROPERTY_ITEM_IMAGE, IUserDataConstants.XWT_PROPERTY_ITEM_IMAGE_KEY, IBinding.class));
registerMetaclass(DefaultCellModifier.class);
registerMetaclass(ViewerFilter.class);
// DataBinding stuff
registerMetaclass(BindingContext.class);
registerMetaclass(ObjectDataProvider.class);
registerMetaclass(Style.class);
registerMetaclass(Setter.class);
registerMetaclass(Trigger.class);
registerMetaclass(MultiTrigger.class);
registerMetaclass(EventTrigger.class);
registerMetaclass(DataTrigger.class);
registerMetaclass(MultiDataTrigger.class);
registerMetaclass(Condition.class);
// registerConvertor(StringToDuration.instance);
// registerConvertor(StringToTimeSpan.instance);
// registerConvertor(StringToRepeatBehavior.instance);
registerMetaclass(CollectionViewSource.class);
registerMetaclass(ObservableListContentProvider.class);
registerMetaclass(ObservableSetContentProvider.class);
registerMetaclass(ObservableTreeContentProvider.class);
registerFileResolveType(Image.class);
registerFileResolveType(URL.class);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#findLoadingContext(java.lang.Object)
*/
public ILoadingContext findLoadingContext(Object container) {
for(int i = cores.size() - 1; i >= 0; i--) {
Core core = cores.get(i);
ILoadingContext context = core.findLoadingContext(container);
if(context != null) {
return context;
}
}
return null;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.papyrus.xwt.IXWTLoader#getLoadingContext(org.eclipse.swt.widgets
* .Composite)
*/
public ILoadingContext getLoadingContext(Object object) {
return findLoadingContext(object);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.xwt.IXWTLoader#getLoadingContext()
*/
public ILoadingContext getLoadingContext() {
return getCurrentCore().getLoadingContext();
}
/*
* (non-Javadoc)
*
* @seeorg.eclipse.e4.xwt.IXWTLoader#setLoadingContext(org.eclipse.papyrus.xwt.
* ILoadingContext)
*/
public void setLoadingContext(ILoadingContext loadingContext) {
getCurrentCore().setLoadingContext(loadingContext);
}
/**
* Check if the value of a property is to resolve.
*
* @param type
* type of property
* @return
*/
public boolean isFileResolveType(Class<?> type) {
return getCurrentCore().isFileResolveType(type);
}
/**
* Register the value of a property is to resolve.
*
* @param type
* type of property
* @return
*/
public void registerFileResolveType(Class<?> type) {
getCurrentCore().registerFileResolveType(type);
}
/**
* Register the value of a property is to resolve.
*
* @param type
* type of property
* @return
*/
public void unregisterFileResolveType(Class<?> type) {
getCurrentCore().unregisterFileResolveType(type);
}
}