path: root/plugins/xwt/org.eclipse.papyrus.xwt/src/org/eclipse/papyrus/xwt/databinding/JFaceXWTDataBinding.java

/*******************************************************************************
 * Copyright (c) 2006, 2010 Soyatec (http://www.soyatec.com) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Soyatec - initial API and implementation
 *******************************************************************************/
package org.eclipse.papyrus.xwt.databinding;

import java.beans.BeanInfo;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.value.SimpleValueProperty;
import org.eclipse.core.internal.databinding.property.value.SimplePropertyObservableValue;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.databinding.viewers.ViewerProperties;
import org.eclipse.jface.databinding.viewers.ViewersObservables;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.papyrus.xwt.XWT;
import org.eclipse.papyrus.xwt.XWTException;
import org.eclipse.papyrus.xwt.internal.core.ScopeManager;
import org.eclipse.papyrus.xwt.internal.core.UpdateSourceTrigger;
import org.eclipse.papyrus.xwt.internal.databinding.menuitem.MenuItemEnabledObservableValue;
import org.eclipse.papyrus.xwt.internal.databinding.menuitem.MenuItemSelectionObservableValue;
import org.eclipse.papyrus.xwt.internal.utils.LoggerManager;
import org.eclipse.papyrus.xwt.internal.utils.UserData;
import org.eclipse.papyrus.xwt.javabean.metadata.properties.EventProperty;
import org.eclipse.papyrus.xwt.metadata.IMetaclass;
import org.eclipse.papyrus.xwt.metadata.IProperty;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Text;

/**
 * 
 * @author yyang (yves.yang@soyatec.com)
 */
public class JFaceXWTDataBinding {

	static final String ENABLED = "enabled";

	static final String SELECTION = "selection";

	static final String TEXT = "text";

	public static final Class<?>[] CONTROL_ARGUMENT_TYPES = new Class[]{ Control.class };

	public static final Class<?>[] VIEWER_ARGUMENT_TYPES = new Class[]{ Viewer.class };

	static String[] VIEWERS_PROPERTIES = null;
	static {
		Method[] methods = ViewerProperties.class.getDeclaredMethods();
		VIEWERS_PROPERTIES = new String[methods.length];
		for(int i = 0; i < methods.length; i++) {
			VIEWERS_PROPERTIES[i] = methods[i].getName();
		}
	}

	public static boolean isViewerProperty(String propertyName) {
		for(String name : VIEWERS_PROPERTIES) {
			if(name.equals(propertyName)) {
				return true;
			}
		}
		return false;
	}

	public static Class<?> getValueType(Class<?> type, String propertyName) {
		if(type == null || propertyName == null || propertyName.indexOf(".") != -1) {
			return null;
		}
		try {
			IMetaclass metaclass = XWT.getMetaclass(type);
			IProperty property = metaclass.findProperty(propertyName);
			if(property != null) {
				return property.getType();
			}
		} catch (Exception e) {
			LoggerManager.log(e);
		}
		return null;
	}

	public static Object getValue(Object target, String propertyName) {
		if(target == null || propertyName == null || propertyName.indexOf(".") != -1) {
			return target;
		}
		Class<?> type = target.getClass();
		try {
			BeanInfo beanInfo = java.beans.Introspector.getBeanInfo(type);
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for(PropertyDescriptor pd : propertyDescriptors) {
				if(propertyName.equalsIgnoreCase(pd.getName())) {
					Method readMethod = pd.getReadMethod();
					if(readMethod != null) {
						return readMethod.invoke(target);
					}
				}
			}
			Field[] fields = type.getDeclaredFields();
			for(Field field : fields) {
				if(propertyName.equalsIgnoreCase(field.getName())) {
					Object object = field.get(target);
					return object;
				}
			}
			return UserData.getLocalData(target, propertyName);
		} catch (Exception e) {
			LoggerManager.log(e);
		}
		return null;
	}

	public static void setValue(Object target, String propertyName, Object value) {
		Class<?> type = target.getClass();
		try {
			BeanInfo beanInfo = java.beans.Introspector.getBeanInfo(type);
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for(PropertyDescriptor pd : propertyDescriptors) {
				if(propertyName.equals(pd.getName())) {
					Method writeMethod = pd.getWriteMethod();
					if(writeMethod == null) {
						return;
					}
					if(!writeMethod.isAccessible()) {
						writeMethod.setAccessible(true);
					}
					Class<?>[] parameterTypes = writeMethod.getParameterTypes();
					Class targetType = parameterTypes[0];
					if(targetType != value.getClass()) {
						if(targetType.isEnum() && value instanceof String) {
							try {
								writeMethod.invoke(target, new Object[]{ Enum.valueOf(targetType, (String)value) });
								return;
							} catch (Exception e) {
							}
						}
						IConverter c = XWT.findConvertor(value.getClass(), targetType);
						if(c != null) {
							value = c.convert(value);
						}
					}
					writeMethod.invoke(target, new Object[]{ value });
					return;
				}
			}
			Field[] fields = type.getDeclaredFields();
			for(Field field : fields) {
				if(propertyName.equals(field.getName())) {
					if(!field.isAccessible()) {
						field.setAccessible(true);
					}
					Class fieldType = field.getType();
					if(fieldType.isEnum() && value instanceof String) {
						try {
							field.set(target, Enum.valueOf(fieldType, (String)value));
							return;
						} catch (Exception e) {
						}
					}
					IConverter c = XWT.findConvertor(value.getClass(), fieldType);
					if(c != null) {
						value = c.convert(value);
					}
					field.set(target, value);
					return;
				}
			}

			IMetaclass metaclass = XWT.getMetaclass(type);
			IProperty property = metaclass.findProperty(propertyName);
			if(property != null) {
				property.setValue(target, value);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static boolean isPropertyReadOnly(Class<?> type, String propertyName) {
		if(type == null || propertyName == null || propertyName.indexOf(".") != -1) {
			return true;
		}
		try {
			IMetaclass metaclass = XWT.getMetaclass(type);
			IProperty property = metaclass.findProperty(propertyName);
			if(property != null) {
				return property.isReadOnly();
			}
		} catch (Exception e) {
			LoggerManager.log(e);
		}
		return true;
	}


	public static boolean isBeanSupport(Object target) {
		Class<?> type = toType(target);
		Method method = null;
		try {
			try {
				method = type.getMethod("addPropertyChangeListener", new Class[]{ String.class, PropertyChangeListener.class });
			} catch (NoSuchMethodException e) {
				method = type.getMethod("addPropertyChangeListener", new Class[]{ PropertyChangeListener.class });
			}
		} catch (SecurityException e) {
		} catch (NoSuchMethodException e) {
		}
		return method != null;
	}

	public static Class<?> toType(Object target) {
		Class<?> type = null;
		if(target instanceof IObservableValue) {
			IObservableValue value = (IObservableValue)target;
			Object valueType = value.getValueType();
			if(valueType instanceof Class<?>) {
				type = (Class<?>)valueType;
			}
		} else if(target instanceof Class<?>) {
			type = (Class<?>)target;
		} else {
			type = target.getClass();
		}
		if(type == null) {
			return Object.class;
		}
		return type;
	}

	public static boolean isValueProperty(Class<?> object, String propertyName) {
		if(propertyName == null) {
			return false;
		}

		if(Viewer.class.isAssignableFrom(object)) {
			return isViewerValueProperty(object, propertyName);
		} else if(MenuItem.class.isAssignableFrom(object)) {
			//
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=280157
			// testcase:
			// org.eclipse.papyrus.xwt.tests.databinding.bindcontrol.BindMenuItem
			//
			if(ENABLED.equalsIgnoreCase(propertyName)) {
				return true;
			} else if(SELECTION.equalsIgnoreCase(propertyName)) {
				return true;
			}
		}
		boolean isProperty = isControlValueProperty(object, propertyName);
		if(isProperty) {
			return true;
		}
		return false;
	}

	public static IObservable observeWidget(Object object, String propertyName, UpdateSourceTrigger updateSourceTrigger, int observedKind) {
		if(propertyName == null) {
			return null;
		}
		try {
			switch(observedKind) {
			case ScopeManager.AUTO:
				return observePropertyValue(object, propertyName, updateSourceTrigger);
			case ScopeManager.COLLECTION:
			case ScopeManager.SET:
			case ScopeManager.LIST:
				break;
			case ScopeManager.VALUE:
				return observePropertyValue(object, propertyName, updateSourceTrigger);
			default:
				break;
			}
		} catch (XWTException e) {
		}
		return null;
	}

	protected static IObservable observePropertyValue(Object object, String propertyName, UpdateSourceTrigger updateSourceTrigger) {
		if(object instanceof Viewer) {
			if("input".equals(propertyName)) {
				Viewer viewer = (Viewer)object;
				SimpleValueProperty property = (SimpleValueProperty)ViewerProperties.input();
				IObservableValue observableValue = new SimplePropertyObservableValue(XWT.getRealm(), viewer, property);
				return new TypedViewerObservableValueDecorator(observableValue, viewer);
			} else if("singleSelection".equals(propertyName)) {
				Viewer viewer = (Viewer)object;
				SimpleValueProperty property = (SimpleValueProperty)ViewerProperties.singleSelection();
				IObservableValue observableValue = new SimplePropertyObservableValue(XWT.getRealm(), viewer, property);
				return new TypedViewerObservableValueDecorator(observableValue, viewer);
			}
			return observePropertyValue((Viewer)object, propertyName, updateSourceTrigger);
		} else if(object instanceof MenuItem) {
			//
			// TODO https://bugs.eclipse.org/bugs/show_bug.cgi?id=280157
			// testcase:
			// org.eclipse.papyrus.xwt.tests.databinding.bindcontrol.BindMenuItem
			//
			if(ENABLED.equalsIgnoreCase(propertyName)) {
				return new MenuItemEnabledObservableValue((MenuItem)object);
			} else if(SELECTION.equalsIgnoreCase(propertyName)) {
				return new MenuItemSelectionObservableValue((MenuItem)object);
			}
		} else if(object instanceof Control) {
			return observePropertyValue((Control)object, propertyName, updateSourceTrigger);
		}
		return null;
	}

	protected static boolean isControlValueProperty(Class<?> type, String propertyName) {
		if(TEXT.equalsIgnoreCase(propertyName)) {
			if(Text.class.isAssignableFrom(type)) {
				return true;
			}
			// widget button is not supported at 3.4 version.
			if(SWT.getVersion() == 3449 && Button.class.isAssignableFrom(type)) {
				return false;
			}
		}
		String getterName = "observe" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
		Method method;
		try {
			method = SWTObservables.class.getMethod(getterName, CONTROL_ARGUMENT_TYPES);
			if(method == null) {
				for(Method element : SWTObservables.class.getMethods()) {
					if(element.getParameterTypes().length != 0) {
						continue;
					}
					if(element.getName().equalsIgnoreCase(getterName)) {
						return true;
					}
				}
			}
		} catch (Exception e) {
			throw new XWTException(e);
		}
		IMetaclass mateclass = XWT.getMetaclass(type);
		IProperty property = mateclass.findProperty(propertyName);
		if(property instanceof EventProperty) {
			return true;
		}
		return false;
	}

	protected static IObservableValue observePropertyValue(Control control, String propertyName, UpdateSourceTrigger updateSourceTrigger) {
		if(TEXT.equalsIgnoreCase(propertyName)) {
			if(control instanceof Text || control instanceof StyledText) {
				int event = SWT.None;
				switch(updateSourceTrigger) {
				case Default:
					event = SWT.FocusOut;
					break;
				case LostFocus:
					event = SWT.FocusOut;
					break;
				case PropertyChanged:
					event = SWT.Modify;
					break;
				default:
					throw new IllegalStateException("UpdateSourceTrigger of value " + updateSourceTrigger.name());
				}
				IObservableValue observableValue = SWTObservables.observeText(control, event);
				if(observableValue != null) {
					return observableValue;
				}
			}
			// widget button is not supported at 3.4 version.
			if(SWT.getVersion() == 3449 && control instanceof Button) {
				return null;
			}
			try {
				IObservableValue observableValue = SWTObservables.observeText(control);
				if(observableValue != null) {
					return observableValue;
				}
			} catch (IllegalArgumentException e) {
				throw new XWTException(e);
			}
		} else {
			if(propertyName == null) {
				return null;
			}
			String getterName = "observe" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
			Method method;
			try {
				method = SWTObservables.class.getMethod(getterName, CONTROL_ARGUMENT_TYPES);
				if(method == null) {
					for(Method element : SWTObservables.class.getMethods()) {
						if(element.getParameterTypes().length != 0) {
							continue;
						}
						if(element.getName().equalsIgnoreCase(getterName)) {
							method = element;
							break;
						}
					}
				}
				if(method != null) {
					IObservableValue observableValue = (IObservableValue)method.invoke(null, control);
					if(observableValue != null) {
						return observableValue;
					}
				}
			} catch (Exception e) {
				throw new XWTException(e);
			}
		}
		IMetaclass mateclass = XWT.getMetaclass(control);
		IProperty property = mateclass.findProperty(propertyName);
		if(property instanceof EventProperty) {
			return new EventPropertyObservableValue(control, (EventProperty)property);
		}
		return null;
	}

	protected static boolean isViewerValueProperty(Class<?> viewerType, String property) {
		String getterName = "observe" + property.substring(0, 1).toUpperCase() + property.substring(1);
		try {
			Method method = ViewersObservables.class.getMethod(getterName, VIEWER_ARGUMENT_TYPES);
			if(method == null) {
				for(Method element : ViewersObservables.class.getMethods()) {
					if(element.getParameterTypes().length != 0) {
						continue;
					}
					if(element.getName().equalsIgnoreCase(getterName)) {
						return true;
					}
				}
			}
		} catch (Exception e) {
			throw new XWTException(e);
		}
		return false;
	}

	protected static IObservable observePropertyValue(Viewer viewer, String property, UpdateSourceTrigger updateSourceTrigger) {
		String getterName = "observe" + property.substring(0, 1).toUpperCase() + property.substring(1);
		Method method;
		try {
			method = ViewersObservables.class.getMethod(getterName, VIEWER_ARGUMENT_TYPES);
			if(method == null) {
				for(Method element : ViewersObservables.class.getMethods()) {
					if(element.getParameterTypes().length != 0) {
						continue;
					}
					if(element.getName().equalsIgnoreCase(getterName)) {
						method = element;
						break;
					}
				}
			}
			if(method != null) {
				IObservable observableValue = (IObservable)method.invoke(null, viewer);
				if(observableValue != null) {
					return observableValue;
				}
			}
		} catch (Exception e) {
			throw new XWTException(e);
		}
		return null;
	}
}