Attachment #106529 for bug #194734

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 194734 | Differences between

and this patch

Collapse All | Expand All




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.internal.databinding.beans;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.eclipse.core.databinding.BindingException;
import org.eclipse.core.databinding.beans.BeansObservables;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.ValueProperty;
import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.internal.databinding.Util;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

/**
 * @since 3.3
 * 
 */
public class BeanValueProperty extends ValueProperty {
	private PropertyDescriptor propertyDescriptor;
	private final boolean attachListener;

	private boolean updating;

	private ListenerSupport listenerSupport;

	/**
	 * @param propertyDescriptor
	 */
	public BeanValueProperty(PropertyDescriptor propertyDescriptor) {
		this(propertyDescriptor, true);
	}

	/**
	 * @param propertyDescriptor
	 * @param attachListener
	 */
	public BeanValueProperty(PropertyDescriptor propertyDescriptor,
			boolean attachListener) {
		this.propertyDescriptor = propertyDescriptor;
		this.attachListener = attachListener;

	}

	protected void addListenerTo(Object source) {
		if (attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
		}
	}

	private void initListenerSupport() {
		if (listenerSupport == null) {
			synchronized (this) {
				if (listenerSupport != null) {
					PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
						public void propertyChange(PropertyChangeEvent evt) {
							if (!updating) {
								fireValueChange(evt.getSource(), Diffs
										.createValueDiff(evt.getOldValue(), evt
												.getNewValue()));
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void removeListenerFrom(Object source) {
		if (attachListener && listenerSupport != null) {
			listenerSupport.unhookListener(source);
		}
	}

	public Object getValueType(Object source) {
		return propertyDescriptor.getPropertyType();
	}

	public Object getValue(Object source) {
		try {
			Method readMethod = propertyDescriptor.getReadMethod();
			if (readMethod == null) {
				throw new BindingException(propertyDescriptor.getName()
						+ " property does not have a read method."); //$NON-NLS-1$
			}
			if (!readMethod.isAccessible()) {
				readMethod.setAccessible(true);
			}
			return readMethod.invoke(source, null);
		} catch (InvocationTargetException e) {
			/*
			 * InvocationTargetException wraps any exception thrown by the
			 * invoked method.
			 */
			throw new RuntimeException(e.getCause());
		} catch (Exception e) {
			if (BeansObservables.DEBUG) {
				Policy
						.getLog()
						.log(
								new Status(
										IStatus.WARNING,
										Policy.JFACE_DATABINDING,
										IStatus.OK,
										"Could not read value of " + source + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
			}
			return null;
		}
	}

	public void setValue(Object source, Object value) {
		Object oldValue = getValue(source);

		if (Util.equals(oldValue, value)) {
			return;
		}

		updating = true;
		try {
			Method writeMethod = propertyDescriptor.getWriteMethod();
			if (!writeMethod.isAccessible()) {
				writeMethod.setAccessible(true);
			}
			writeMethod.invoke(source, new Object[] { value });
		} catch (InvocationTargetException e) {
			/*
			 * InvocationTargetException wraps any exception thrown by the
			 * invoked method.
			 */
			throw new RuntimeException(e.getCause());
		} catch (Exception e) {
			if (BeansObservables.DEBUG) {
				Policy
						.getLog()
						.log(
								new Status(
										IStatus.WARNING,
										Policy.JFACE_DATABINDING,
										IStatus.OK,
										"Could not change value of " + source + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
			}
		} finally {
			updating = false;
		}

		Object newValue = getValue(source);
		if (!Util.equals(oldValue, newValue)) {
			fireValueChange(source, Diffs.createValueDiff(oldValue, newValue));
		}
	}

	public synchronized void dispose() {
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		propertyDescriptor = null;
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.beans;

import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.internal.databinding.beans.BeanValueProperty;

/**
 * @since 1.2
 * 
 */
public class PojoProperties {
	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a bean value property for the given property name.
	 */
	public static IValueProperty valueProperty(Class beanClass,
			String propertyName) {
		return new BeanValueProperty(BeansObservables.getPropertyDescriptor(
				beanClass, propertyName), false);
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.beans;

import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.internal.databinding.beans.BeanValueProperty;

/**
 * @since 1.2
 * 
 */
public class BeanProperties {
	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a value property for the given property name of the given bean
	 *         class.
	 */
	public static IValueProperty valueProperty(Class beanClass,
			String propertyName) {
		return new BeanValueProperty(BeansObservables.getPropertyDescriptor(
				beanClass, propertyName));
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.runtime.ListenerList;

/**
 * @since 1.2
 */
public abstract class ValueProperty extends Property implements IValueProperty {
	private Map valueChangeListeners;

	public final void addValueChangeListener(Object source,
			IValuePropertyChangeListener listener) {
		boolean wasAlreadyListening = isListeningTo(source);

		if (valueChangeListeners == null) {
			synchronized (this) {
				if (valueChangeListeners == null) {
					valueChangeListeners = Collections
							.synchronizedMap(new IdentityHashMap());
				}
			}
		}

		synchronized (valueChangeListeners) {
			if (valueChangeListeners.containsKey(source)) {
				ListenerList listeners = (ListenerList) valueChangeListeners
						.get(source);
				listeners.add(listener);
			} else {
				ListenerList listeners = new ListenerList();
				listeners.add(listener);
				valueChangeListeners.put(source, listeners);
			}
		}

		if (!wasAlreadyListening)
			addListenerTo(source);
	}

	public final void removeValueChangeListener(Object source,
			IValuePropertyChangeListener listener) {
		if (valueChangeListeners != null) {
			ListenerList listeners = (ListenerList) valueChangeListeners
					.get(source);
			if (listeners != null) {
				listeners.remove(listener);
				if (listeners.isEmpty()) {
					valueChangeListeners.remove(source);
					if (!isListeningTo(source)) {
						removeListenerFrom(source);
					}
				}
			}
		}
	}

	protected boolean isListeningTo(Object source) {
		return super.isListeningTo(source)
				|| (valueChangeListeners != null && valueChangeListeners
						.containsKey(source));
	}

	protected void fireChange(Object source) {
		throw new IllegalStateException(
				"ValueProperty subclasses must call fireValueChange() instead of fireChange()"); //$NON-NLS-1$
	}

	protected void fireValueChange(Object source, ValueDiff diff) {
		super.fireChange(source);
		if (valueChangeListeners == null)
			return;
		ListenerList listenerList = (ListenerList) valueChangeListeners
				.get(source);
		if (listenerList != null) {
			ValuePropertyChangeEvent event = new ValuePropertyChangeEvent(
					source, this, diff);
			Object[] listeners = listenerList.getListeners();
			for (int i = 0; i < listeners.length; i++) {
				((IValuePropertyChangeListener) listeners[i])
						.handleValuePropertyChange(event);
			}
		}
	}

	public synchronized void dispose() {
		if (valueChangeListeners != null) {
			for (Iterator iterator = valueChangeListeners.keySet().iterator(); iterator
					.hasNext();) {
				Object source = iterator.next();
				iterator.remove();
				if (!isListeningTo(source))
					removeListenerFrom(source);
			}
			valueChangeListeners = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * @since 1.2
 * 
 */
public interface IValuePropertyChangeListener {
	/**
	 * @param event
	 */
	public void handleValuePropertyChange(ValuePropertyChangeEvent event);
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import org.eclipse.core.databinding.observable.value.ValueDiff;

/**
 * @since 1.2
 * 
 */
public class ValuePropertyChangeEvent {
	private final Object source;
	private final IValueProperty property;
	private final ValueDiff diff;

	/**
	 * @param source
	 * @param property
	 * @param diff
	 */
	public ValuePropertyChangeEvent(Object source, IValueProperty property,
			ValueDiff diff) {
		this.source = source;
		this.property = property;
		this.diff = diff;
	}

	/**
	 * @return Returns the source.
	 */
	public Object getSource() {
		return source;
	}

	/**
	 * @return Returns the property.
	 */
	public IValueProperty getProperty() {
		return property;
	}

	/**
	 * @return Returns the diff.
	 */
	public ValueDiff getDiff() {
		return diff;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * @since 1.2
 * 
 */
public interface IPropertyChangeListener {
	/**
	 * @param event
	 */
	public void handlePropertyChange(PropertyChangeEvent event);
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * @since 1.2
 * 
 */
public class PropertyChangeEvent {
	private final Object source;
	private final IProperty property;

	/**
	 * @param source
	 * @param property
	 */
	public PropertyChangeEvent(Object source, IProperty property) {
		this.source = source;
		this.property = property;

	}

	/**
	 * @return Returns the source.
	 */
	public Object getSource() {
		return source;
	}

	/**
	 * @return Returns the property.
	 */
	public IProperty getProperty() {
		return property;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.ValuePropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 * 
 */
public class PropertyObservableValue extends AbstractObservableValue {
	private Object source;
	private IValueProperty property;

	private volatile boolean updating = false;

	private boolean disposed = false;

	private IValuePropertyChangeListener listener = new IValuePropertyChangeListener() {
		public void handleValuePropertyChange(
				final ValuePropertyChangeEvent event) {
			if (!disposed && !updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						fireValueChange(event.getDiff());
					}
				});
			}
		}
	};

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public PropertyObservableValue(Realm realm, Object source,
			IValueProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

	protected void firstListenerAdded() {
		if (!disposed) {
			property.addValueChangeListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (!disposed) {
			property.removeValueChangeListener(source, listener);
		}
	}

	protected Object doGetValue() {
		return property.getValue(source);
	}

	protected void doSetValue(Object value) {
		Object oldValue = doGetValue();

		updating = true;
		try {
			property.setValue(source, value);
		} finally {
			updating = false;
		}

		Object newValue = doGetValue();
		if (!Util.equals(oldValue, newValue)) {
			fireValueChange(Diffs.createValueDiff(oldValue, newValue));
		}
	}

	public Object getValueType() {
		return property.getValueType(source);
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeValueChangeListener(source, listener);
			property = null;
			source = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * Interface for observing a property of a source object.
 * 
 * @since 1.2
 */
public interface IProperty {
	/**
	 * Adds the given change listener to the list of change listeners for the
	 * given source object. When this property changes on the source, change
	 * listeners are notified in a generic way, without specifying the change
	 * that happened. To get the changed state, a change listener needs to query
	 * for the current state of this property.
	 * 
	 * @param source
	 *            the object to listen to
	 * @param listener
	 *            the listener to receive change notifications
	 */
	public void addChangeListener(Object source,
			IPropertyChangeListener listener);

	/**
	 * Removes the given change listener from the list of change listeners for
	 * the given source object. Has no effect if the given listener is not
	 * registered as a change listener on the source object.
	 * 
	 * @param source
	 *            the object to stop listening to
	 * @param listener
	 *            the listener currently receiving change notifications
	 */
	public void removeChangeListener(Object source,
			IPropertyChangeListener listener);

	/**
	 * Disposes the property, removing all property listeners on source objects.
	 */
	public void dispose();
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.internal.databinding.property.PropertyObservableValue;

/**
 * @since 1.2
 * 
 */
public class PropertyObservables {
	/**
	 * @param source
	 * @param property
	 * @return an observable value that tracks the given property of the source
	 *         object.
	 * @since 1.2
	 */
	public static IObservableValue observeValue(Object source,
			IValueProperty property) {
		return observeValue(Realm.getDefault(), source, property);
	}

	/**
	 * @param realm
	 * @param source
	 * @param property
	 * @return an observable value that tracks the given property of the source
	 *         object
	 * @since 1.2
	 */
	public static IObservableValue observeValue(Realm realm, Object source,
			IValueProperty property) {
		return new PropertyObservableValue(realm, source, property);
	}

	/**
	 * Returns a factory for creating obervable values tracking the given
	 * property of a particular source object
	 * 
	 * @param property
	 *            the property to be observed
	 * @return an observable value factory on
	 */
	public static IObservableFactory valueFactory(IValueProperty property) {
		return valueFactory(Realm.getDefault(), property);
	}

	/**
	 * Returns a factory for creating obervable values tracking the given
	 * property of a particular source object
	 * 
	 * @param realm
	 *            the realm to use
	 * @param property
	 *            the property to be observed
	 * @return an observable value factory
	 */
	public static IObservableFactory valueFactory(final Realm realm,
			final IValueProperty property) {
		return new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return observeValue(realm, target, property);
			}
		};
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.ListenerList;

/**
 * @since 1.2
 * 
 */
public abstract class Property implements IProperty {
	private Map changeListeners;

	public final void addChangeListener(Object source,
			IPropertyChangeListener listener) {
		boolean wasAlreadyListening = isListeningTo(source);

		if (changeListeners == null) {
			synchronized (this) {
				if (changeListeners == null) {
					changeListeners = Collections
							.synchronizedMap(new IdentityHashMap());
				}
			}
		}

		synchronized (changeListeners) {
			if (changeListeners.containsKey(source)) {
				ListenerList listeners = (ListenerList) changeListeners
						.get(source);
				listeners.add(listener);
			} else {
				ListenerList listeners = new ListenerList();
				listeners.add(listener);
				changeListeners.put(source, listeners);
			}
		}

		if (!wasAlreadyListening)
			addListenerTo(source);
	}

	public final void removeChangeListener(Object source,
			IPropertyChangeListener listener) {
		if (changeListeners != null) {
			ListenerList listeners = (ListenerList) changeListeners.get(source);
			if (listeners != null) {
				listeners.remove(listener);
				if (listeners.isEmpty()) {
					changeListeners.remove(source);
					if (!isListeningTo(source)) {
						removeListenerFrom(source);
					}
				}
			}
		}
	}

	protected boolean isListeningTo(Object source) {
		return changeListeners != null && changeListeners.containsKey(source);
	}

	protected abstract void addListenerTo(Object source);

	protected abstract void removeListenerFrom(Object source);

	protected void fireChange(Object source) {
		if (changeListeners == null)
			return;
		ListenerList listenerList = (ListenerList) changeListeners.get(source);
		if (listenerList != null) {
			PropertyChangeEvent event = new PropertyChangeEvent(source, this);
			Object[] listeners = listenerList.getListeners();
			for (int i = 0; i < listeners.length; i++) {
				((IPropertyChangeListener) listeners[i])
						.handlePropertyChange(event);
			}
		}
	}

	public synchronized void dispose() {
		if (changeListeners != null) {
			for (Iterator iterator = changeListeners.keySet().iterator(); iterator.hasNext();) {
				Object source = iterator.next();
				iterator.remove();
				if (!isListeningTo(source))
					removeListenerFrom(source);
			}
			changeListeners = null;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * Interface for observing a value property of a source object.
 * 
 * @since 1.2
 */
public interface IValueProperty extends IProperty {
	/**
	 * @param source
	 * @return the value type
	 */
	public Object getValueType(Object source);

	/**
	 * @param source
	 * @return the property value
	 */
	public Object getValue(Object source);

	/**
	 * @param source
	 * @param value
	 */
	public void setValue(Object source, Object value);

	/**
	 * @param source
	 * @param listener
	 */
	public void addValueChangeListener(Object source,
			IValuePropertyChangeListener listener);

	/**
	 * @param source
	 * @param listener
	 */
	public void removeValueChangeListener(Object source,
			IValuePropertyChangeListener listener);
}

Return to bug 194734

Added Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanValueProperty.java (+178 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.core.internal.databinding.beans;
13
14	import java.beans.PropertyChangeEvent;
15	import java.beans.PropertyChangeListener;
16	import java.beans.PropertyDescriptor;
17	import java.lang.reflect.InvocationTargetException;
18	import java.lang.reflect.Method;
19
20	import org.eclipse.core.databinding.BindingException;
21	import org.eclipse.core.databinding.beans.BeansObservables;
22	import org.eclipse.core.databinding.observable.Diffs;
23	import org.eclipse.core.databinding.property.ValueProperty;
24	import org.eclipse.core.databinding.util.Policy;
25	import org.eclipse.core.internal.databinding.Util;
26	import org.eclipse.core.runtime.IStatus;
27	import org.eclipse.core.runtime.Status;
28
29	/**
30	* @since 3.3
31	*
32	*/
33	public class BeanValueProperty extends ValueProperty {
34	private PropertyDescriptor propertyDescriptor;
35	private final boolean attachListener;
36
37	private boolean updating;
38
39	private ListenerSupport listenerSupport;
40
41	/**
42	* @param propertyDescriptor
43	*/
44	public BeanValueProperty(PropertyDescriptor propertyDescriptor) {
45	this(propertyDescriptor, true);
46	}
47
48	/**
49	* @param propertyDescriptor
50	* @param attachListener
51	*/
52	public BeanValueProperty(PropertyDescriptor propertyDescriptor,
53	boolean attachListener) {
54	this.propertyDescriptor = propertyDescriptor;
55	this.attachListener = attachListener;
56
57	}
58
59	protected void addListenerTo(Object source) {
60	if (attachListener) {
61	initListenerSupport();
62	listenerSupport.hookListener(source);
63	}
64	}
65
66	private void initListenerSupport() {
67	if (listenerSupport == null) {
68	synchronized (this) {
69	if (listenerSupport != null) {
70	PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
71	public void propertyChange(PropertyChangeEvent evt) {
72	if (!updating) {
73	fireValueChange(evt.getSource(), Diffs
74	.createValueDiff(evt.getOldValue(), evt
75	.getNewValue()));
76	}
77	}
78	};
79	listenerSupport = new ListenerSupport(
80	propertyChangeListener, propertyDescriptor
81	.getName());
82	}
83	}
84	}
85	}
86
87	protected void removeListenerFrom(Object source) {
88	if (attachListener && listenerSupport != null) {
89	listenerSupport.unhookListener(source);
90	}
91	}
92
93	public Object getValueType(Object source) {
94	return propertyDescriptor.getPropertyType();
95	}
96
97	public Object getValue(Object source) {
98	try {
99	Method readMethod = propertyDescriptor.getReadMethod();
100	if (readMethod == null) {
101	throw new BindingException(propertyDescriptor.getName()
102	+ " property does not have a read method."); //$NON-NLS-1$
103	}
104	if (!readMethod.isAccessible()) {
105	readMethod.setAccessible(true);
106	}
107	return readMethod.invoke(source, null);
108	} catch (InvocationTargetException e) {
109	/*
110	* InvocationTargetException wraps any exception thrown by the
111	* invoked method.
112	*/
113	throw new RuntimeException(e.getCause());
114	} catch (Exception e) {
115	if (BeansObservables.DEBUG) {
116	Policy
117	.getLog()
118	.log(
119	new Status(
120	IStatus.WARNING,
121	Policy.JFACE_DATABINDING,
122	IStatus.OK,
123	"Could not read value of " + source + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
124	}
125	return null;
126	}
127	}
128
129	public void setValue(Object source, Object value) {
130	Object oldValue = getValue(source);
131
132	if (Util.equals(oldValue, value)) {
133	return;
134	}
135
136	updating = true;
137	try {
138	Method writeMethod = propertyDescriptor.getWriteMethod();
139	if (!writeMethod.isAccessible()) {
140	writeMethod.setAccessible(true);
141	}
142	writeMethod.invoke(source, new Object[] { value });
143	} catch (InvocationTargetException e) {
144	/*
145	* InvocationTargetException wraps any exception thrown by the
146	* invoked method.
147	*/
148	throw new RuntimeException(e.getCause());
149	} catch (Exception e) {
150	if (BeansObservables.DEBUG) {
151	Policy
152	.getLog()
153	.log(
154	new Status(
155	IStatus.WARNING,
156	Policy.JFACE_DATABINDING,
157	IStatus.OK,
158	"Could not change value of " + source + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
159	}
160	} finally {
161	updating = false;
162	}
163
164	Object newValue = getValue(source);
165	if (!Util.equals(oldValue, newValue)) {
166	fireValueChange(source, Diffs.createValueDiff(oldValue, newValue));
167	}
168	}
169
170	public synchronized void dispose() {
171	if (listenerSupport != null) {
172	listenerSupport.dispose();
173	listenerSupport = null;
174	}
175	propertyDescriptor = null;
176	super.dispose();
177	}
178	}

Added Link Here

(-)src/org/eclipse/core/databinding/property/ValueProperty.java (+115 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.core.databinding.property;
13
14	import java.util.Collections;
15	import java.util.IdentityHashMap;
16	import java.util.Iterator;
17	import java.util.Map;
18
19	import org.eclipse.core.databinding.observable.value.ValueDiff;
20	import org.eclipse.core.runtime.ListenerList;
21
22	/**
23	* @since 1.2
24	*/
25	public abstract class ValueProperty extends Property implements IValueProperty {
26	private Map valueChangeListeners;
27
28	public final void addValueChangeListener(Object source,
29	IValuePropertyChangeListener listener) {
30	boolean wasAlreadyListening = isListeningTo(source);
31
32	if (valueChangeListeners == null) {
33	synchronized (this) {
34	if (valueChangeListeners == null) {
35	valueChangeListeners = Collections
36	.synchronizedMap(new IdentityHashMap());
37	}
38	}
39	}
40
41	synchronized (valueChangeListeners) {
42	if (valueChangeListeners.containsKey(source)) {
43	ListenerList listeners = (ListenerList) valueChangeListeners
44	.get(source);
45	listeners.add(listener);
46	} else {
47	ListenerList listeners = new ListenerList();
48	listeners.add(listener);
49	valueChangeListeners.put(source, listeners);
50	}
51	}
52
53	if (!wasAlreadyListening)
54	addListenerTo(source);
55	}
56
57	public final void removeValueChangeListener(Object source,
58	IValuePropertyChangeListener listener) {
59	if (valueChangeListeners != null) {
60	ListenerList listeners = (ListenerList) valueChangeListeners
61	.get(source);
62	if (listeners != null) {
63	listeners.remove(listener);
64	if (listeners.isEmpty()) {
65	valueChangeListeners.remove(source);
66	if (!isListeningTo(source)) {
67	removeListenerFrom(source);
68	}
69	}
70	}
71	}
72	}
73
74	protected boolean isListeningTo(Object source) {
75	return super.isListeningTo(source)
76	\|\| (valueChangeListeners != null && valueChangeListeners
77	.containsKey(source));
78	}
79
80	protected void fireChange(Object source) {
81	throw new IllegalStateException(
82	"ValueProperty subclasses must call fireValueChange() instead of fireChange()"); //$NON-NLS-1$
83	}
84
85	protected void fireValueChange(Object source, ValueDiff diff) {
86	super.fireChange(source);
87	if (valueChangeListeners == null)
88	return;
89	ListenerList listenerList = (ListenerList) valueChangeListeners
90	.get(source);
91	if (listenerList != null) {
92	ValuePropertyChangeEvent event = new ValuePropertyChangeEvent(
93	source, this, diff);
94	Object[] listeners = listenerList.getListeners();
95	for (int i = 0; i < listeners.length; i++) {
96	((IValuePropertyChangeListener) listeners[i])
97	.handleValuePropertyChange(event);
98	}
99	}
100	}
101
102	public synchronized void dispose() {
103	if (valueChangeListeners != null) {
104	for (Iterator iterator = valueChangeListeners.keySet().iterator(); iterator
105	.hasNext();) {
106	Object source = iterator.next();
107	iterator.remove();
108	if (!isListeningTo(source))
109	removeListenerFrom(source);
110	}
111	valueChangeListeners = null;
112	}
113	super.dispose();
114	}
115	}

Added Link Here

(-)src/org/eclipse/core/internal/databinding/property/PropertyObservableValue.java (+104 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.core.internal.databinding.property;
13
14	import org.eclipse.core.databinding.observable.Diffs;
15	import org.eclipse.core.databinding.observable.Realm;
16	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
17	import org.eclipse.core.databinding.property.IValueProperty;
18	import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
19	import org.eclipse.core.databinding.property.ValuePropertyChangeEvent;
20	import org.eclipse.core.internal.databinding.Util;
21
22	/**
23	* @since 1.2
24	*
25	*/
26	public class PropertyObservableValue extends AbstractObservableValue {
27	private Object source;
28	private IValueProperty property;
29
30	private volatile boolean updating = false;
31
32	private boolean disposed = false;
33
34	private IValuePropertyChangeListener listener = new IValuePropertyChangeListener() {
35	public void handleValuePropertyChange(
36	final ValuePropertyChangeEvent event) {
37	if (!disposed && !updating) {
38	getRealm().exec(new Runnable() {
39	public void run() {
40	fireValueChange(event.getDiff());
41	}
42	});
43	}
44	}
45	};
46
47	/**
48	* @param realm
49	* @param source
50	* @param property
51	*/
52	public PropertyObservableValue(Realm realm, Object source,
53	IValueProperty property) {
54	super(realm);
55	this.source = source;
56	this.property = property;
57	}
58
59	protected void firstListenerAdded() {
60	if (!disposed) {
61	property.addValueChangeListener(source, listener);
62	}
63	}
64
65	protected void lastListenerRemoved() {
66	if (!disposed) {
67	property.removeValueChangeListener(source, listener);
68	}
69	}
70
71	protected Object doGetValue() {
72	return property.getValue(source);
73	}
74
75	protected void doSetValue(Object value) {
76	Object oldValue = doGetValue();
77
78	updating = true;
79	try {
80	property.setValue(source, value);
81	} finally {
82	updating = false;
83	}
84
85	Object newValue = doGetValue();
86	if (!Util.equals(oldValue, newValue)) {
87	fireValueChange(Diffs.createValueDiff(oldValue, newValue));
88	}
89	}
90
91	public Object getValueType() {
92	return property.getValueType(source);
93	}
94
95	public synchronized void dispose() {
96	if (!disposed) {
97	disposed = true;
98	property.removeValueChangeListener(source, listener);
99	property = null;
100	source = null;
101	}
102	super.dispose();
103	}
104	}

Added Link Here

(-)src/org/eclipse/core/databinding/property/Property.java (+106 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.core.databinding.property;
13
14	import java.util.Collections;
15	import java.util.IdentityHashMap;
16	import java.util.Iterator;
17	import java.util.Map;
18
19	import org.eclipse.core.runtime.ListenerList;
20
21	/**
22	* @since 1.2
23	*
24	*/
25	public abstract class Property implements IProperty {
26	private Map changeListeners;
27
28	public final void addChangeListener(Object source,
29	IPropertyChangeListener listener) {
30	boolean wasAlreadyListening = isListeningTo(source);
31
32	if (changeListeners == null) {
33	synchronized (this) {
34	if (changeListeners == null) {
35	changeListeners = Collections
36	.synchronizedMap(new IdentityHashMap());
37	}
38	}
39	}
40
41	synchronized (changeListeners) {
42	if (changeListeners.containsKey(source)) {
43	ListenerList listeners = (ListenerList) changeListeners
44	.get(source);
45	listeners.add(listener);
46	} else {
47	ListenerList listeners = new ListenerList();
48	listeners.add(listener);
49	changeListeners.put(source, listeners);
50	}
51	}
52
53	if (!wasAlreadyListening)
54	addListenerTo(source);
55	}
56
57	public final void removeChangeListener(Object source,
58	IPropertyChangeListener listener) {
59	if (changeListeners != null) {
60	ListenerList listeners = (ListenerList) changeListeners.get(source);
61	if (listeners != null) {
62	listeners.remove(listener);
63	if (listeners.isEmpty()) {
64	changeListeners.remove(source);
65	if (!isListeningTo(source)) {
66	removeListenerFrom(source);
67	}
68	}
69	}
70	}
71	}
72
73	protected boolean isListeningTo(Object source) {
74	return changeListeners != null && changeListeners.containsKey(source);
75	}
76
77	protected abstract void addListenerTo(Object source);
78
79	protected abstract void removeListenerFrom(Object source);
80
81	protected void fireChange(Object source) {
82	if (changeListeners == null)
83	return;
84	ListenerList listenerList = (ListenerList) changeListeners.get(source);
85	if (listenerList != null) {
86	PropertyChangeEvent event = new PropertyChangeEvent(source, this);
87	Object[] listeners = listenerList.getListeners();
88	for (int i = 0; i < listeners.length; i++) {
89	((IPropertyChangeListener) listeners[i])
90	.handlePropertyChange(event);
91	}
92	}
93	}
94
95	public synchronized void dispose() {
96	if (changeListeners != null) {
97	for (Iterator iterator = changeListeners.keySet().iterator(); iterator.hasNext();) {
98	Object source = iterator.next();
99	iterator.remove();
100	if (!isListeningTo(source))
101	removeListenerFrom(source);
102	}
103	changeListeners = null;
104	}
105	}
106	}

Added Link Here

(-)src/org/eclipse/core/databinding/beans/PojoProperties.java (+32 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.core.databinding.beans;
13
14	import org.eclipse.core.databinding.property.IValueProperty;
15	import org.eclipse.core.internal.databinding.beans.BeanValueProperty;
16
17	/**
18	* @since 1.2
19	*
20	*/
21	public class PojoProperties {
22	/**
23	* @param beanClass
24	* @param propertyName
25	* @return a bean value property for the given property name.
26	*/
27	public static IValueProperty valueProperty(Class beanClass,
28	String propertyName) {
29	return new BeanValueProperty(BeansObservables.getPropertyDescriptor(
30	beanClass, propertyName), false);
31	}
32	}