/*******************************************************************************

 * Copyright (c) 2009 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 (bug 175735)

 ******************************************************************************/

package org.eclipse.jface.examples.databinding.snippets;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.Collection;

import java.util.Iterator;

import org.eclipse.core.databinding.DataBindingContext;

import org.eclipse.core.databinding.beans.BeanProperties;

import org.eclipse.core.databinding.observable.Realm;

import org.eclipse.core.databinding.observable.list.IObservableList;

import org.eclipse.core.databinding.observable.list.WritableList;

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

import org.eclipse.core.databinding.property.Properties;

import org.eclipse.jface.databinding.swt.SWTObservables;

import org.eclipse.jface.databinding.swt.WidgetProperties;

import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;

import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider;

import org.eclipse.jface.databinding.viewers.ViewerProperties;

import org.eclipse.jface.util.Util;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.Text;

/**

 * @since 3.2

 * 

 */

public class Snippet028DuplexingObservableValue {

	protected Shell shell;

	private TableViewer viewer;

	private Table table;

	private Text releaseDate;

	private Text title;

	private Text director;

	private Text writer;

	/**

	 * Launch the application

	 * 

	 * @param args

	 */

	public static void main(String[] args) {

		try {

			Snippet028DuplexingObservableValue window = new Snippet028DuplexingObservableValue();

			window.open();

		} catch (Exception e) {

			e.printStackTrace();

		}

	}

	/**

	 * Open the window

	 */

	public void open() {

		final Display display = Display.getDefault();

		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {

			public void run() {

				createContents();

				shell.open();

				shell.layout();

				while (!shell.isDisposed()) {

					if (!display.readAndDispatch())

						display.sleep();

				}

			}

		});

	}

	protected void createContents() {

		shell = new Shell();

		shell.setSize(509, 375);

		shell.setText("Snippet028DuplexingObservableValue.java");

		final GridLayout gridLayout = new GridLayout();

		gridLayout.makeColumnsEqualWidth = true;

		gridLayout.numColumns = 4;

		shell.setLayout(gridLayout);

		viewer = new TableViewer(shell, SWT.FULL_SELECTION | SWT.MULTI

				| SWT.BORDER);

		table = viewer.getTable();

		table.setLinesVisible(true);

		table.setHeaderVisible(true);

		table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 4, 1));

		final TableColumn newColumnTableColumn_1 = new TableColumn(table,

				SWT.NONE);

		newColumnTableColumn_1.setWidth(120);

		newColumnTableColumn_1.setText("Movie");

		final TableColumn newColumnTableColumn = new TableColumn(table,

				SWT.NONE);

		newColumnTableColumn.setWidth(120);

		newColumnTableColumn.setText("Release Date");

		final TableColumn newColumnTableColumn_2 = new TableColumn(table,

				SWT.NONE);

		newColumnTableColumn_2.setWidth(120);

		newColumnTableColumn_2.setText("Director");

		final TableColumn newColumnTableColumn_3 = new TableColumn(table,

				SWT.NONE);

		newColumnTableColumn_3.setWidth(120);

		newColumnTableColumn_3.setText("Writer");

		final Label movieLabel = new Label(shell, SWT.NONE);

		movieLabel.setText("Movie");

		final Label directorLabel = new Label(shell, SWT.NONE);

		directorLabel.setLayoutData(new GridData());

		directorLabel.setText("Release Date");

		final Label producerLabel = new Label(shell, SWT.NONE);

		producerLabel.setText("Director");

		final Label scoreLabel = new Label(shell, SWT.NONE);

		scoreLabel.setText("Writer");

		title = new Text(shell, SWT.BORDER);

		final GridData gd_title = new GridData(SWT.FILL, SWT.CENTER, true,

				false);

		title.setLayoutData(gd_title);

		releaseDate = new Text(shell, SWT.BORDER);

		final GridData gd_releaseDate = new GridData(SWT.FILL, SWT.CENTER,

				true, false);

		releaseDate.setLayoutData(gd_releaseDate);

		director = new Text(shell, SWT.BORDER);

		final GridData gd_director = new GridData(SWT.FILL, SWT.CENTER, true,

				false);

		director.setLayoutData(gd_director);

		writer = new Text(shell, SWT.BORDER);

		final GridData gd_writer = new GridData(SWT.FILL, SWT.CENTER, true,

				false);

		writer.setLayoutData(gd_writer);

		bindUI();

	}

	// Minimal JavaBeans support

	public static abstract class AbstractModelObject {

		private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(

				this);

		public void addPropertyChangeListener(PropertyChangeListener listener) {

			propertyChangeSupport.addPropertyChangeListener(listener);

		}

		public void addPropertyChangeListener(String propertyName,

				PropertyChangeListener listener) {

			propertyChangeSupport.addPropertyChangeListener(propertyName,

					listener);

		}

		public void removePropertyChangeListener(PropertyChangeListener listener) {

			propertyChangeSupport.removePropertyChangeListener(listener);

		}

		public void removePropertyChangeListener(String propertyName,

				PropertyChangeListener listener) {

			propertyChangeSupport.removePropertyChangeListener(propertyName,

					listener);

		}

		protected void firePropertyChange(String propertyName, Object oldValue,

				Object newValue) {

			propertyChangeSupport.firePropertyChange(propertyName, oldValue,

					newValue);

		}

	}

	public static class MovieInfo extends AbstractModelObject {

		private String title;

		private String releaseDate;

		private String director;

		private String writer;

		public MovieInfo(String title, String releaseDate, String director,

				String writer) {

			this.title = title;

			this.releaseDate = releaseDate;

			this.director = director;

			this.writer = writer;

		}

		public String getTitle() {

			return title;

		}

		public void setTitle(String title) {

			firePropertyChange("title", this.title, this.title = title);

		}

		public String getReleaseDate() {

			return releaseDate;

		}

		public void setReleaseDate(String releaseDate) {

			firePropertyChange("releaseDate", this.releaseDate,

					this.releaseDate = releaseDate);

		}

		public String getDirector() {

			return director;

		}

		public void setDirector(String director) {

			firePropertyChange("director", this.director,

					this.director = director);

		}

		public String getWriter() {

			return writer;

		}

		public void setWriter(String writer) {

			firePropertyChange("writer", this.writer, this.writer = writer);

		}

	}

	private void bindUI() {

		IObservableList movies = new WritableList();

		movies.add(new MovieInfo("Cloverfield", "January 18, 2008",

				"Matt Reeves", "Drew Goddard"));

		movies.add(new MovieInfo("Iron Man", "May 2, 2008", "Jon Favreau",

				"Mark Fergus"));

		movies.add(new MovieInfo(

				"Indiana Jones and the Kingdom of the Crystal Skull",

				"May 22, 2008", "Steven Spielberg", "Drunken Lemurs"));

		movies.add(new MovieInfo("Get Smart", "June 20, 2008", "Peter Segal",

				"Tom J. Astle"));

		movies.add(new MovieInfo("Wanted", "June 27, 2008",

				"Timur Bekmambetov", "Michael Brandt"));

		movies.add(new MovieInfo("Wall-E", "June 27, 2008", "Andrew Stanton",

				"Andrew Stanton"));

		movies.add(new MovieInfo("The Dark Knight", "July 18, 2008",

				"Christopher Nolan", "David S. Goyer"));

		movies.add(new MovieInfo("007: Quantum of Solace", "October 31, 2008",

				"Marc Forster", "Robert Wade"));

		movies.add(new MovieInfo("Valkyrie", "December 25, 2008",

				"Bryan Singer", "Christopher McQuarrie"));

		ObservableListContentProvider cp = new ObservableListContentProvider();

		viewer.setContentProvider(cp);

		viewer.setLabelProvider(new ObservableMapLabelProvider(Properties

				.observeEach(cp.getKnownElements(), BeanProperties

						.values(new String[] { "title", "releaseDate",

								"director", "writer" }))));

		viewer.setInput(movies);

		DataBindingContext dbc = new DataBindingContext();

		IObservableList selections = ViewerProperties.multipleSelection()

				.observe(viewer);

		dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(title),

				new StringDuplexingObservableValue(BeanProperties

						.value("title").observeDetail(selections)));

		dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(releaseDate),

				new StringDuplexingObservableValue(BeanProperties.value(

						"releaseDate").observeDetail(selections)));

		dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(director),

				new StringDuplexingObservableValue(BeanProperties.value(

						"director").observeDetail(selections)));

		dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(writer),

				new StringDuplexingObservableValue(BeanProperties.value(

						"writer").observeDetail(selections)));

	}

	private static class StringDuplexingObservableValue extends

			DuplexingObservableValue {

		public StringDuplexingObservableValue(IObservableList target) {

			super(target);

		}

		protected Object coalesceElements(Collection elements) {

			Iterator it = elements.iterator();

			if (!it.hasNext())

				return "";

			Object first = it.next();

			while (it.hasNext()) {

				if (!Util.equals(first, it.next()))

					return "<Multiple values>";

			}

			return first;

		}

	}

}

import org.eclipse.core.tests.databinding.observable.value.DuplexingObservableValueTest;

		addTestSuite(DuplexingObservableValueTest.class);

/*******************************************************************************

 * Copyright (c) 2009 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 (bug 173735)

 *******************************************************************************/

package org.eclipse.core.tests.databinding.observable.value;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import org.eclipse.core.databinding.observable.list.IObservableList;

import org.eclipse.core.databinding.observable.list.WritableList;

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

import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;

import org.eclipse.jface.util.Util;

/**

 * @since 1.0

 * 

 */

public class DuplexingObservableValueTest extends AbstractDefaultRealmTestCase {

	private IObservableList list;

	private DuplexingObservableValue observable;

	protected void setUp() throws Exception {

		super.setUp();

		list = new WritableList(new ArrayList(), String.class);

	}

	public void testValueType_InheritFromTargetList() throws Exception {

		observable = new DuplexingObservableValue(list) {

			protected Object coalesceElements(Collection elements) {

				return null;

			}

		};

		assertEquals(

				"value type should be the element type of the target list",

				String.class, observable.getValueType());

	}

	public void testValueType_ProvidedInConstructor() throws Exception {

		observable = new DuplexingObservableValue(list, Object.class) {

			protected Object coalesceElements(Collection elements) {

				return null;

			}

		};

		assertEquals("value type should be the type passed to constructor",

				Object.class, observable.getValueType());

	}

	public void test_getValue() throws Exception {

		observable = new DuplexingObservableValue(list) {

			protected Object coalesceElements(Collection elements) {

				Iterator it = elements.iterator();

				if (!it.hasNext())

					return null;

				Object first = it.next();

				while (it.hasNext()) {

					Object next = it.next();

					if (!Util.equals(first, next))

						return "<Multiple Values>";

				}

				return first;

			}

		};

		assertNull(observable.getValue());

		list.add("42");

		assertEquals("Value should be \"42\"", "42", observable.getValue());

		list.add("42");

		assertEquals("Value should be \"42\"", "42", observable.getValue());

		list.add("watermelon");

		assertEquals("<Multiple Values>", observable.getValue());

		list.remove(2);

		assertEquals("Value should be \"42\"", "42", observable.getValue());

		list.clear();

		assertNull(observable.getValue());

	}

}

/*******************************************************************************

 * Copyright (c) 2009 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 (bug 175735)

 ******************************************************************************/

package org.eclipse.core.databinding.observable.value;

import java.util.Collection;

import org.eclipse.core.databinding.observable.ChangeEvent;

import org.eclipse.core.databinding.observable.IChangeListener;

import org.eclipse.core.databinding.observable.IStaleListener;

import org.eclipse.core.databinding.observable.StaleEvent;

import org.eclipse.core.databinding.observable.list.IObservableList;

/**

 * @since 1.2

 */

public abstract class DuplexingObservableValue extends AbstractObservableValue {

	private IObservableList target;

	private final Object valueType;

	private boolean dirty = true;

	private boolean updating = false;

	private Object cachedValue = null; // applicable only while hasListener()

	private PrivateInterface privateInterface;

	/**

	 * @param target

	 */

	public DuplexingObservableValue(IObservableList target) {

		this(target, target.getElementType());

	}

	/**

	 * @param target

	 * @param valueType

	 */

	public DuplexingObservableValue(IObservableList target, Object valueType) {

		super(target.getRealm());

		this.target = target;

		this.valueType = valueType;

	}

	private class PrivateInterface implements IChangeListener, IStaleListener {

		public void handleChange(ChangeEvent event) {

			if (!updating)

				makeDirty();

		}

		public void handleStale(StaleEvent staleEvent) {

			if (!dirty) {

				fireStale();

			}

		}

	}

	protected void firstListenerAdded() {

		if (privateInterface == null)

			privateInterface = new PrivateInterface();

		target.addChangeListener(privateInterface);

		target.addStaleListener(privateInterface);

	}

	protected void lastListenerRemoved() {

		target.removeChangeListener(privateInterface);

		target.removeStaleListener(privateInterface);

	}

	protected final void makeDirty() {

		if (hasListeners() && !dirty) {

			dirty = true;

			// copy the old value

			final Object oldValue = cachedValue;

			// Fire the "dirty" event. This implementation recomputes the new

			// value lazily.

			fireValueChange(new ValueDiff() {

				public Object getOldValue() {

					return oldValue;

				}

				public Object getNewValue() {

					return getValue();

				}

			});

		}

	}

	public boolean isStale() {

		getValue();

		return target.isStale();

	}

	protected Object doGetValue() {

		if (!hasListeners())

			return coalesceElements(target);

		if (dirty) {

			cachedValue = coalesceElements(target);

			dirty = false;

			if (target.isStale())

				fireStale();

		}

		return cachedValue;

	}

	protected abstract Object coalesceElements(Collection elements);

	protected void doSetValue(Object value) {

		final Object oldValue = cachedValue;

		boolean wasUpdating = updating;

		try {

			updating = true;

			for (int i = 0; i < target.size(); i++)

				target.set(i, value);

		} finally {

			updating = wasUpdating;

		}

		// Fire the "dirty" event. This implementation recomputes the new

		// value lazily.

		if (hasListeners()) {

			fireValueChange(new ValueDiff() {

				public Object getOldValue() {

					return oldValue;

				}

				public Object getNewValue() {

					return getValue();

				}

			});

		}

	}

	public Object getValueType() {

		return valueType;

	}

	public synchronized void addChangeListener(IChangeListener listener) {

		super.addChangeListener(listener);

		// If somebody is listening, we need to make sure we attach our own

		// listeners

		computeValueForListeners();

	}

	public synchronized void addValueChangeListener(

			IValueChangeListener listener) {

		super.addValueChangeListener(listener);

		// If somebody is listening, we need to make sure we attach our own

		// listeners

		computeValueForListeners();

	}

	/**

	 * Some clients just add a listener and expect to get notified even if they

	 * never called getValue(), so we have to call getValue() ourselves here to

	 * be sure. Need to be careful about realms though, this method can be

	 * called outside of our realm. See also bug 198211. If a client calls this

	 * outside of our realm, they may receive change notifications before the

	 * runnable below has been executed. It is their job to figure out what to

	 * do with those notifications.

	 */

	private void computeValueForListeners() {

		getRealm().exec(new Runnable() {

			public void run() {

				// We are not currently listening.

				if (hasListeners()) {

					// But someone is listening for changes. Call getValue()

					// to make sure we start listening to the observables we

					// depend on.

					getValue();

				}

			}

		});

	}

	public synchronized void dispose() {

		if (privateInterface != null && target != null) {

			target.removeChangeListener(privateInterface);

			target.removeStaleListener(privateInterface);

		}

		target = null;

		privateInterface = null;

		super.dispose();

	}

}