| /******************************************************************************* | |
| * 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.InvocationTargetException; | |
| import java.net.URL; | |
| import java.util.ArrayList; | |
| import java.util.Collection; | |
| import java.util.Collections; | |
| import java.util.Date; | |
| 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.jface.internal.databinding.swt.DateTimeSelectionProperty; | |
| 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; | |
| import org.eclipse.xwt.animation.BackEase; | |
| import org.eclipse.xwt.animation.BeginStoryboard; | |
| import org.eclipse.xwt.animation.BounceEase; | |
| import org.eclipse.xwt.animation.CircleEase; | |
| import org.eclipse.xwt.animation.ColorAnimation; | |
| import org.eclipse.xwt.animation.CubicEase; | |
| import org.eclipse.xwt.animation.DoubleAnimation; | |
| import org.eclipse.xwt.animation.Drawing; | |
| import org.eclipse.xwt.animation.ElasticEase; | |
| import org.eclipse.xwt.animation.ExponentialEase; | |
| import org.eclipse.xwt.animation.FloatAnimation; | |
| import org.eclipse.xwt.animation.IntAnimation; | |
| import org.eclipse.xwt.animation.PauseStoryboard; | |
| import org.eclipse.xwt.animation.PointAnimation; | |
| import org.eclipse.xwt.animation.PowerEase; | |
| import org.eclipse.xwt.animation.QuadraticEase; | |
| import org.eclipse.xwt.animation.QuarticEase; | |
| import org.eclipse.xwt.animation.QuinticEase; | |
| import org.eclipse.xwt.animation.RectangleAnimation; | |
| import org.eclipse.xwt.animation.ResumeStoryboard; | |
| import org.eclipse.xwt.animation.SineEase; | |
| import org.eclipse.xwt.animation.SizeAnimation; | |
| import org.eclipse.xwt.animation.StopStoryboard; | |
| import org.eclipse.xwt.animation.Storyboard; | |
| import org.eclipse.xwt.callback.IBeforeParsingCallback; | |
| import org.eclipse.xwt.collection.CollectionViewSource; | |
| import org.eclipse.xwt.converters.BindingToObject; | |
| import org.eclipse.xwt.converters.CollectionToBoolean; | |
| import org.eclipse.xwt.converters.CollectionToInteger; | |
| import org.eclipse.xwt.converters.DateToString; | |
| import org.eclipse.xwt.converters.EnumToString; | |
| import org.eclipse.xwt.converters.IStatusToBoolean; | |
| import org.eclipse.xwt.converters.IStatusToString; | |
| import org.eclipse.xwt.converters.ListToIObservableCollection; | |
| import org.eclipse.xwt.converters.ListToSet; | |
| import org.eclipse.xwt.converters.ObjectToBoolean; | |
| import org.eclipse.xwt.converters.ObjectToISelection; | |
| import org.eclipse.xwt.converters.ObjectToString; | |
| import org.eclipse.xwt.converters.SelectionToBoolean; | |
| import org.eclipse.xwt.converters.SetToIObservableCollection; | |
| import org.eclipse.xwt.converters.StringToBoolean; | |
| import org.eclipse.xwt.converters.StringToChar; | |
| import org.eclipse.xwt.converters.StringToColor; | |
| import org.eclipse.xwt.converters.StringToDoubleArray; | |
| import org.eclipse.xwt.converters.StringToDuration; | |
| import org.eclipse.xwt.converters.StringToFont; | |
| import org.eclipse.xwt.converters.StringToFormAttachment; | |
| import org.eclipse.xwt.converters.StringToIValidationRule; | |
| import org.eclipse.xwt.converters.StringToIValueConverter; | |
| import org.eclipse.xwt.converters.StringToImage; | |
| import org.eclipse.xwt.converters.StringToIntArray; | |
| import org.eclipse.xwt.converters.StringToInteger; | |
| import org.eclipse.xwt.converters.StringToKeySpline; | |
| import org.eclipse.xwt.converters.StringToKeyTime; | |
| import org.eclipse.xwt.converters.StringToPoint; | |
| import org.eclipse.xwt.converters.StringToRectangle; | |
| import org.eclipse.xwt.converters.StringToRepeatBehavior; | |
| import org.eclipse.xwt.converters.StringToTimeSpan; | |
| import org.eclipse.xwt.converters.StringToType; | |
| import org.eclipse.xwt.converters.StringToURL; | |
| import org.eclipse.xwt.core.Condition; | |
| import org.eclipse.xwt.core.DataTrigger; | |
| import org.eclipse.xwt.core.EventTrigger; | |
| import org.eclipse.xwt.core.IBinding; | |
| import org.eclipse.xwt.core.IUserDataConstants; | |
| import org.eclipse.xwt.core.MultiDataTrigger; | |
| import org.eclipse.xwt.core.MultiTrigger; | |
| import org.eclipse.xwt.core.RadioEventGroup; | |
| import org.eclipse.xwt.core.Setter; | |
| import org.eclipse.xwt.core.Style; | |
| import org.eclipse.xwt.core.Trigger; | |
| import org.eclipse.xwt.core.TriggerBase; | |
| import org.eclipse.xwt.core.ValidationStatus; | |
| import org.eclipse.xwt.databinding.BindingContext; | |
| import org.eclipse.xwt.databinding.IBindingContext; | |
| import org.eclipse.xwt.dataproviders.ObjectDataProvider; | |
| import org.eclipse.xwt.input.ICommand; | |
| import org.eclipse.xwt.internal.core.BindingExpressionPath; | |
| import org.eclipse.xwt.internal.core.Core; | |
| import org.eclipse.xwt.internal.core.MetaclassManager; | |
| import org.eclipse.xwt.internal.core.MultiBinding; | |
| import org.eclipse.xwt.internal.core.ScopeKeeper; | |
| import org.eclipse.xwt.internal.core.ScopeManager; | |
| import org.eclipse.xwt.internal.core.UIResource; | |
| import org.eclipse.xwt.internal.core.UpdateSourceTrigger; | |
| import org.eclipse.xwt.internal.utils.ObjectUtil; | |
| import org.eclipse.xwt.internal.utils.UserData; | |
| import org.eclipse.xwt.javabean.ResourceLoaderFactory; | |
| import org.eclipse.xwt.javabean.ValueConvertorRegister; | |
| import org.eclipse.xwt.javabean.metadata.BindingMetaclass; | |
| import org.eclipse.xwt.javabean.metadata.ComboBoxCellEditorMetaclass; | |
| import org.eclipse.xwt.javabean.metadata.ExpandItemHeightAction; | |
| import org.eclipse.xwt.javabean.metadata.TableEditorMetaclass; | |
| import org.eclipse.xwt.javabean.metadata.TableViewerColumnMetaClass; | |
| import org.eclipse.xwt.javabean.metadata.properties.AbstractProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.ColumnViewerColumnsProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.DataProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.DynamicBeanProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.DynamicProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.InputBeanProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.MultiSelectionBeanProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.PropertiesConstants; | |
| import org.eclipse.xwt.javabean.metadata.properties.SingleSelectionBeanProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.StyleProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TableColumnEditorProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TableEditorDynamicProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TableItemEditorProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TableItemProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TableViewerColumnDynamicProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TableViewerColumnImageProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TableViewerColumnTextProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TableViewerColumnWidthProperty; | |
| import org.eclipse.xwt.javabean.metadata.properties.TriggersProperty; | |
| import org.eclipse.xwt.jface.ComboBoxCellEditor; | |
| import org.eclipse.xwt.jface.DefaultCellModifier; | |
| import org.eclipse.xwt.jface.JFaceInitializer; | |
| import org.eclipse.xwt.jface.JFacesHelper; | |
| import org.eclipse.xwt.jface.ObservableTreeContentProvider; | |
| import org.eclipse.xwt.jface.ViewerFilter; | |
| import org.eclipse.xwt.metadata.DefaultLoadingType; | |
| import org.eclipse.xwt.metadata.DelegateProperty; | |
| import org.eclipse.xwt.metadata.ILoadingType; | |
| import org.eclipse.xwt.metadata.IMetaclass; | |
| import org.eclipse.xwt.metadata.IProperty; | |
| import org.eclipse.xwt.metadata.IValueLoading; | |
| import org.eclipse.xwt.utils.ResourceManager; | |
| /** | |
| * 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.xwt.IXWTLoader#getLogger() | |
| */ | |
| public ILogger getLogger() { | |
| return getCurrentCore().getLogger(); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#setLogger(org.eclipse.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.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.xwt.IXWTLoader#getElementName(java.lang.Object) | |
| */ | |
| public String getElementName(Object object) { | |
| return UserData.getElementName(object); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.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.xwt.IXWTLoader#getDataContext(org.eclipse.swt.widgets. | |
| * Widget) | |
| */ | |
| public Object getDataContext(Object element) { | |
| return UserData.getDataContext(element); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#getDataContext(org.eclipse.swt.widgets. | |
| * Widget) | |
| */ | |
| public TriggerBase[] getTriggers(Object element) { | |
| return UserData.getTriggers(element); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.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.xwt.IXWTLoader#findCompositeParent(org.eclipse.swt.widgets | |
| * .Widget) | |
| */ | |
| public Composite findCompositeParent(Object context) { | |
| return UserData.findCompositeParent(context); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.xwt.IXWTLoader#load(java.net.URL) | |
| */ | |
| public Object load(URL file) throws Exception { | |
| return loadWithOptions(file, Collections.EMPTY_MAP); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.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.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.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 (IStyle style : (Collection<IStyle>) styles) { | |
| defaultStyles.add(style); | |
| } | |
| } 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] paramters."); | |
| } | |
| } | |
| } | |
| 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.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.xwt.IXWTLoader#open(java.lang.Class) | |
| */ | |
| public void open(Class<?> type) throws Exception { | |
| open(type.getResource(type.getSimpleName() | |
| + IConstants.XWT_EXTENSION_SUFFIX), Collections.EMPTY_MAP); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#open(java.net.URL) | |
| */ | |
| public void open(URL url) throws Exception { | |
| open(url, Collections.EMPTY_MAP); | |
| } | |
| public void open(IUIResource resource) throws Exception { | |
| open(resource, Collections.EMPTY_MAP); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.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.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.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.xwt.IXWTLoader#convertFrom(org.eclipse.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.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.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.xwt.IXWTLoader#load(java.io.InputStream, java.net.URL) | |
| */ | |
| public Object load(InputStream stream, URL url) throws Exception { | |
| return loadWithOptions(stream, url, Collections.EMPTY_MAP); | |
| } | |
| public Object load(IUIResource resource) throws Exception { | |
| return loadWithOptions(resource, Collections.EMPTY_MAP); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.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.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.xwt.IXWTLoader#registerMetaclass(java.lang.Class) | |
| */ | |
| public IMetaclass registerMetaclass(Class<?> type) { | |
| return getCurrentCore().registerMetaclass(type, | |
| IConstants.XWT_NAMESPACE); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#registerMetaclass(java.lang.Class) | |
| */ | |
| public void registerMetaclass(IMetaclass type) { | |
| getCurrentCore().registerMetaclass(type, IConstants.XWT_NAMESPACE); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#registerMetaclassFactory(org.eclipse.e4 | |
| * .xwt.IMetaclassFactory) | |
| */ | |
| public void registerMetaclassFactory(IMetaclassFactory metaclassFactory) { | |
| getCurrentCore().registerMetaclassFactory(metaclassFactory); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.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.xwt.IXWTLoader#addTracking(org.eclipse.xwt.Tracking) | |
| */ | |
| public void addTracking(Tracking tracking) { | |
| getCurrentCore().addTracking(tracking); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#isTracking(org.eclipse.xwt.Tracking) | |
| */ | |
| public boolean isTracking(Tracking tracking) { | |
| return getCurrentCore().isTracking(tracking); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#getTrackings() | |
| */ | |
| public Set<Tracking> getTrackings() { | |
| return getCurrentCore().getTrackings(); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#removeTracking(org.eclipse.xwt.Tracking) | |
| */ | |
| public void removeTracking(Tracking tracking) { | |
| getCurrentCore().removeTracking(tracking); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#registerCommand(java.lang.String, | |
| * org.eclipse.xwt.input.ICommand) | |
| */ | |
| public void registerCommand(String name, ICommand command) { | |
| getCurrentCore().registerCommand(name, command); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.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.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.xwt.IXWTLoader#addDefaultStyle(org.eclipse.xwt.IStyle) | |
| */ | |
| public void addDefaultStyle(IStyle style) { | |
| getCurrentCore().addDefaultStyle(style); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#removeDefaultStyle(org.eclipse.xwt.IStyle | |
| * ) | |
| */ | |
| public void removeDefaultStyle(IStyle style) { | |
| getCurrentCore().removeDefaultStyle(style); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#getDefaultStyles() | |
| */ | |
| public Collection<IStyle> getDefaultStyles() { | |
| return getCurrentCore().getDefaultStyles(); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#addDataProviderFactory(org.eclipse.xwt | |
| * .IDataProviderFactory) | |
| */ | |
| public void addDataProviderFactory(String name, | |
| IDataProviderFactory dataProviderFactory) { | |
| getCurrentCore().addDataProviderFactory(name, dataProviderFactory); | |
| registerMetaclass(dataProviderFactory.getType()); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#removeDataProviderFactory(org.eclipse.e4 | |
| * .xwt.IDataProviderFactory) | |
| */ | |
| public void removeDataProviderFactory(String name) { | |
| getCurrentCore().removeDataProviderFactory(name); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#removeDataProviderFactory(org.eclipse.e4 | |
| * .xwt.IDataProviderFactory) | |
| */ | |
| public void removeDataProviderFactory( | |
| IDataProviderFactory dataProviderFactory) { | |
| getCurrentCore().removeDataProviderFactory(dataProviderFactory); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.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.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); | |
| registerConvertor(StringToChar.instance); | |
| // It is not supported by eclipse 3.4.1 | |
| registerConvertor(StringToNumberConverter.class, "toBigDecimal"); | |
| registerConvertor(StringToNumberConverter.class, "toBigInteger"); | |
| 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, "fromBigInteger"); | |
| 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 = (IMetaclass) 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 = (IMetaclass) 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 = (IMetaclass) 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); | |
| IMetaclass dateTimeMetaclass = registerMetaclass(org.eclipse.swt.widgets.DateTime.class); | |
| dateTimeMetaclass.addProperty(new DataProperty("selection", "selection", Date.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 = (IMetaclass) 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 = (IMetaclass) 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 = (IMetaclass) 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 = (IMetaclass) 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.ViewForm.class); | |
| registerMetaclass(org.eclipse.swt.custom.CBanner.class); | |
| registerMetaclass(org.eclipse.swt.custom.TableCursor.class); | |
| type = org.eclipse.jface.viewers.Viewer.class; | |
| metaclass = (IMetaclass) 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 = (IMetaclass) core.getMetaclass(type, | |
| IConstants.XWT_NAMESPACE); | |
| if (metaclass != null) { | |
| metaclass.addInitializer(new JFaceInitializer()); | |
| } | |
| type = org.eclipse.jface.viewers.ColumnViewer.class; | |
| metaclass = (IMetaclass) 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 = (IMetaclass) 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 = (IMetaclass) 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); | |
| registerMetaclass(ValidationStatus.class); | |
| // Animation | |
| registerMetaclass(Storyboard.class); | |
| registerMetaclass(BeginStoryboard.class); | |
| registerMetaclass(StopStoryboard.class); | |
| registerMetaclass(PauseStoryboard.class); | |
| registerMetaclass(ResumeStoryboard.class); | |
| registerMetaclass(IntAnimation.class); | |
| registerMetaclass(FloatAnimation.class); | |
| registerMetaclass(DoubleAnimation.class); | |
| registerMetaclass(ColorAnimation.class); | |
| registerMetaclass(PointAnimation.class); | |
| registerMetaclass(RectangleAnimation.class); | |
| registerMetaclass(SizeAnimation.class); | |
| try { | |
| Class.forName("org.pushingpixels.trident.Timeline"); | |
| registerMetaclass(BackEase.class); | |
| registerMetaclass(BounceEase.class); | |
| registerMetaclass(CircleEase.class); | |
| registerMetaclass(CubicEase.class); | |
| registerMetaclass(ElasticEase.class); | |
| registerMetaclass(ExponentialEase.class); | |
| registerMetaclass(PowerEase.class); | |
| registerMetaclass(QuadraticEase.class); | |
| registerMetaclass(QuarticEase.class); | |
| registerMetaclass(QuinticEase.class); | |
| registerMetaclass(SineEase.class); | |
| } catch (ClassNotFoundException e) { | |
| } | |
| 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.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.xwt.IXWTLoader#getLoadingContext(org.eclipse.swt.widgets | |
| * .Composite) | |
| */ | |
| public ILoadingContext getLoadingContext(Object object) { | |
| return findLoadingContext(object); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.xwt.IXWTLoader#getLoadingContext() | |
| */ | |
| public ILoadingContext getLoadingContext() { | |
| return getCurrentCore().getLoadingContext(); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @seeorg.eclipse.xwt.IXWTLoader#setLoadingContext(org.eclipse.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); | |
| } | |
| } |