Attachment #113163 for bug #248174

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 248174
Collapse All | Expand All




import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
import org.eclipse.core.databinding.property.PropertyObservables;
import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.databinding.viewers.ViewerProperties;
import org.eclipse.jface.databinding.viewers.ViewersObservables;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.TableViewer;


	public void testConstructor_IllegalArgumentException() {
		try {
			ViewersObservables.observeInput(null);
			fail("Expected IllegalArgumentException for null argument");
		} catch (IllegalArgumentException expected) {
		}
	}

	public void testSetInputOnViewer_FiresNoChangeEvents() {
		IObservableValue observable = ViewersObservables.observeInput(viewer);
		ValueChangeEventTracker listener = ValueChangeEventTracker
				.observe(observable);

		assertNull(viewer.getInput());
		assertEquals(0, listener.count);

	}

	public void testGetSetValue_FiresChangeEvents() {
		IObservableValue observable = ViewersObservables.observeInput(viewer);
				.getDefault(), viewer);
		ValueChangeEventTracker listener = new ValueChangeEventTracker();
		observable.addValueChangeListener(listener);


	}

	public void testGetValueType_AlwaysNull() throws Exception {
		IObservableValue observable = ViewersObservables.observeInput(viewer);
				.getDefault(), viewer);
		assertEquals(null, observable.getValueType());
	}

	public void testDispose() throws Exception {
		IObservableValue observable = ViewersObservables.observeInput(viewer);
				.getDefault(), viewer);
		observable.dispose();
		assertNull(observable.getRealm());
		try {

	}

	public static Test suite() {
		TestSuite suite = new TestSuite(ViewerInputObservableValueTest.class
				.getName());
		suite.addTestSuite(ViewerInputObservableValueTest.class);
		suite.addTest(MutableObservableValueContractTest.suite(new Delegate()));
		return suite;

		}

		public IObservableValue createObservableValue(Realm realm) {
			return PropertyObservables.observeValue(realm, viewer,
					ViewerProperties.input());
		}

		public void change(IObservable observable) {
			IObservableValue value = (IObservableValue) observable;
			value.setValue(createValue(value));
		}






import junit.framework.TestCase;

import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.databinding.viewers.ViewersObservables;
import org.eclipse.jface.internal.databinding.viewers.SelectionProviderSingleSelectionObservableValue;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**


	/*
	 * (non-Javadoc)
	 * 
	 * @see junit.framework.TestCase#setUp()
	 */
	protected void setUp() throws Exception {


	/*
	 * (non-Javadoc)
	 * 
	 * @see junit.framework.TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {


	public void testConstructorIllegalArgumentException() {
		try {
			ViewersObservables.observeSingleSelection(null);
					.getRealm(Display.getDefault()), null);
			fail();
		} catch (IllegalArgumentException e) {
		}

	 * </ul>
	 */
	public void testGetSetValue() {
		IObservableValue observable = ViewersObservables
				.observeSingleSelection(selectionProvider);
				selectionProvider);
		ValueChangeEventTracker listener = new ValueChangeEventTracker();
		observable.addValueChangeListener(listener);
		assertNull(observable.getValue());

	}

	public void testDispose() throws Exception {
		IObservableValue observable = ViewersObservables
				.observeSingleSelection(selectionProvider);
				selectionProvider);
		ValueChangeEventTracker listener = new ValueChangeEventTracker();
		observable.addValueChangeListener(listener);






import junit.framework.TestCase;

import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
import org.eclipse.jface.databinding.viewers.ViewersObservables;
import org.eclipse.jface.internal.databinding.viewers.SelectionProviderMultipleSelectionObservableList;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**


	private TableViewer viewer;

	private static String[] model = new String[] { "element0", "element1", "element2", "element3" };

	protected void setUp() throws Exception {
		Shell shell = new Shell();


	public void testConstructorIllegalArgumentException() {
		try {
			ViewersObservables.observeMultiSelection(null);
					.getRealm(Display.getDefault()), null, Object.class);
			fail();
		} catch (IllegalArgumentException e) {
		}

	 * </ul>
	 */
	public void testAddRemove() {
		IObservableList observable = ViewersObservables
				.observeMultiSelection(selectionProvider);
				selectionProvider, Object.class);
		ListChangeEventTracker listener = new ListChangeEventTracker();
		observable.addListChangeListener(listener);
		assertEquals(0, observable.size());

		selectionProvider.setSelection(new StructuredSelection(model[0]));
		assertEquals(1, listener.count);
		assertEquals(1, listener.event.diff.getDifferences().length);
		assertDiffEntry(listener.event.diff.getDifferences()[0], 0, model[0],
				true);
		assertEquals(observable, listener.event.getObservableList());
		assertEquals(1, observable.size());
		assertEquals(model[0], observable.get(0));

		selectionProvider.setSelection(new StructuredSelection(model[1]));
		assertEquals(2, listener.count);
		assertEquals(2, listener.event.diff.getDifferences().length);
		assertDiffEntry(listener.event.diff.getDifferences()[0], 0, model[1],
				true);
		assertDiffEntry(listener.event.diff.getDifferences()[1], 1, model[0],
				false);
		assertEquals(observable, listener.event.getObservableList());
		assertEquals(1, observable.size());
		assertEquals(model[1], observable.get(0));

		selectionProvider.setSelection(new StructuredSelection(new Object[] {
				model[2], model[3] }));
		assertEquals(3, listener.count);
		assertEquals(3, listener.event.diff.getDifferences().length);
		assertDiffEntry(listener.event.diff.getDifferences()[0], 0, model[2],
				true);
		assertDiffEntry(listener.event.diff.getDifferences()[1], 1, model[3],
				true);
		assertDiffEntry(listener.event.diff.getDifferences()[2], 2, model[1],
				false);
		assertEquals(observable, listener.event.getObservableList());
		assertEquals(2, observable.size());
		assertEquals(model[2], observable.get(0));
		assertEquals(model[3], observable.get(1));

		selectionProvider.setSelection(StructuredSelection.EMPTY);
		assertEquals(4, listener.count);
		assertEquals(2, listener.event.diff.getDifferences().length);
		assertDiffEntry(listener.event.diff.getDifferences()[0], 1, model[3],
				false);
		assertDiffEntry(listener.event.diff.getDifferences()[1], 0, model[2],
				false);
		assertEquals(observable, listener.event.getObservableList());
		assertEquals(0, observable.size());

		observable.add(model[1]);
		assertEquals(5, listener.count);
		assertEquals(1, listener.event.diff.getDifferences().length);
		assertDiffEntry(listener.event.diff.getDifferences()[0], 0, model[1],
				true);
		assertEquals(observable, listener.event.getObservableList());
		assertEquals(1, ((IStructuredSelection) viewer.getSelection()).size());

		observable.add(0, model[2]);
		assertEquals(6, listener.count);
		assertEquals(1, listener.event.diff.getDifferences().length);
		// This is a bit surprising (we added at index 0 but the event says
		// index 1).
		// It is to the fact that the observable list tracks the underlying
		// selection
		// provider's notion of which element is at which index.
		assertDiffEntry(listener.event.diff.getDifferences()[0], 0, model[2],
				true);
		assertEquals(observable, listener.event.getObservableList());
		assertEquals(2, ((IStructuredSelection) viewer.getSelection()).size());

		observable.clear();
		assertEquals(7, listener.count);
		assertEquals(2, listener.event.diff.getDifferences().length);
		assertDiffEntry(listener.event.diff.getDifferences()[0], 0, model[1],
				false);
		assertDiffEntry(listener.event.diff.getDifferences()[1], 0, model[2],
				false);
		assertEquals(observable, listener.event.getObservableList());
		assertEquals(0, ((IStructuredSelection) viewer.getSelection()).size());
	}

	/**
	 * @param diffEntry





package org.eclipse.jface.tests.databinding.viewers;

import org.eclipse.core.databinding.observable.IDecoratingObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.databinding.viewers.IViewerObservableValue;
import org.eclipse.jface.databinding.viewers.ViewersObservables;
import org.eclipse.jface.internal.databinding.viewers.ViewerInputProperty;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;

	}

	public void testObserveInput_InstanceOfViewerInputObservableValue() {
		IViewerObservableValue observable = (IViewerObservableValue) ViewersObservables
				.observeInput(viewer);
		assertTrue(observable.getViewer() == viewer);
		IPropertyObservable propertyObservable = (IPropertyObservable) ((IDecoratingObservable) observable)
				.getDecorated();
		assertTrue(propertyObservable.getProperty() instanceof ViewerInputProperty);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 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 206839)
 *******************************************************************************/

package org.eclipse.jface.internal.databinding.viewers;

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.jface.util.Util;
import org.eclipse.jface.viewers.Viewer;

/**
 * Observes the input of a <code>Viewer</code>.
 * <p>
 * This observer is blind to changes in the viewer's input unless its
 * {@link #setValue(Object)} method is called directly.
 * 
 * @since 1.2
 */
public class ViewerInputObservableValue extends AbstractObservableValue {

  private final Viewer viewer;

  /**
   * Constructs a new instance associated with the provided <code>viewer</code>.
   * 
   * @param realm
   * @param viewer
   */
  public ViewerInputObservableValue( Realm realm, Viewer viewer ) {
    super( realm );
    if ( viewer == null ) {
      throw new IllegalArgumentException( "The 'viewer' parameter is null." ); //$NON-NLS-1$
    }

    this.viewer = viewer;
  }

  /**
   * Sets the input to the provided <code>value</code>. Value change events are
   * fired after input is set in the viewer.
   * 
   * @param value object to set as input
   */
  protected void doSetValue( final Object value ) {
    Object oldValue = doGetValue();
    viewer.setInput( value );
    if ( !Util.equals( oldValue, value ) ) {
      fireValueChange( Diffs.createValueDiff( oldValue, value ) );
    }
  }

  /**
   * Retrieves the current input.
   * 
   * @return the current input
   */
  protected Object doGetValue() {
    return viewer.getInput();
  }

  public Object getValueType() {
    return null;
  }
}




/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 *     Brad Reynolds - bug 137877
 *     Brad Reynolds - bug 164653
 *     Brad Reynolds - bug 147515
 *     Ashley Cambrell - bug 198906
 *******************************************************************************/

package org.eclipse.jface.internal.databinding.viewers;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.jface.databinding.viewers.IViewerObservableValue;
import org.eclipse.jface.viewers.Viewer;

/**
 * Observes single selection of a <code>Viewer</code>.
 * 
 * @since 1.2
 */
public class ViewerSingleSelectionObservableValue extends
		SelectionProviderSingleSelectionObservableValue implements
		IViewerObservableValue {

	private Viewer viewer;

	/**
	 * @param realm
	 * @param viewer
	 */
	public ViewerSingleSelectionObservableValue(Realm realm, Viewer viewer) {
		super(realm, viewer);
		this.viewer = viewer;
	}

	public Viewer getViewer() {
		return viewer;
	}
}




/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 *     Brad Reynolds - bug 137877
 *     Brad Reynolds - bug 164653
 *     Brad Reynolds - bug 147515
 *     Ashley Cambrell - bug 198906
 *******************************************************************************/

package org.eclipse.jface.internal.databinding.viewers;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.jface.databinding.viewers.IViewerObservableList;
import org.eclipse.jface.viewers.Viewer;

/**
 * Observes single selection of a <code>Viewer</code>.
 * 
 * @since 1.2
 */
public class ViewerMultipleSelectionObservableList extends
		SelectionProviderMultipleSelectionObservableList implements
		IViewerObservableList {

	private Viewer viewer;

	/**
	 * @param realm
	 * @param viewer
	 * @param elementType
	 */
	public ViewerMultipleSelectionObservableList(Realm realm, Viewer viewer,
			Object elementType) {
		super(realm, viewer, elementType);
		this.viewer = viewer;
	}

	public Viewer getViewer() {
		return viewer;
	}
}




/*******************************************************************************
 * 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 (bug 124684)
 ******************************************************************************/

package org.eclipse.jface.internal.databinding.viewers;

import java.util.Arrays;
import java.util.Set;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.jface.databinding.viewers.IViewerObservableSet;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;

/**
 * An observable set that tracks the checked elements in a CheckboxTableViewer
 * or CheckboxTreeViewer
 * 
 * @since 1.2
 */
public class CheckboxViewerCheckedElementsObservableSet extends
		CheckableCheckedElementsObservableSet implements IViewerObservableSet {
	private StructuredViewer viewer;

	/**
	 * Constructs a new instance on the given realm and checkable.
	 * 
	 * @param realm
	 *            the observable's realm
	 * @param viewer
	 *            the CheckboxTableViewer viewer to track.
	 * @param elementType
	 *            type of elements in the set
	 */
	public CheckboxViewerCheckedElementsObservableSet(Realm realm,
			CheckboxTableViewer viewer, Object elementType) {
		super(realm, viewer, elementType, createElementSet(viewer));
		this.viewer = viewer;
	}

	/**
	 * Constructs a new instance on the given realm and checkable.
	 * 
	 * @param realm
	 *            the observable's realm
	 * @param viewer
	 *            the CheckboxTreeViewer viewer to track.
	 * @param elementType
	 *            type of elements in the set
	 */
	public CheckboxViewerCheckedElementsObservableSet(Realm realm,
			CheckboxTreeViewer viewer, Object elementType) {
		super(realm, viewer, elementType, createElementSet(viewer));
		this.viewer = viewer;
	}

	Set createDiffSet() {
		return ViewerElementSet.withComparer(viewer.getComparer());
	}

	private static Set createElementSet(CheckboxTableViewer viewer) {
		Set set = ViewerElementSet.withComparer(viewer.getComparer());
		set.addAll(Arrays.asList(viewer.getCheckedElements()));
		return set;
	}

	private static Set createElementSet(CheckboxTreeViewer viewer) {
		Set set = ViewerElementSet.withComparer(viewer.getComparer());
		set.addAll(Arrays.asList(viewer.getCheckedElements()));
		return set;
	}

	public Viewer getViewer() {
		return viewer;
	}

	public synchronized void dispose() {
		viewer = null;
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 *     Brad Reynolds - bug 137877
 *     Brad Reynolds - bug 164653
 *     Brad Reynolds - bug 147515
 *     Ashley Cambrell - bug 198906
 *******************************************************************************/

package org.eclipse.jface.internal.databinding.viewers;

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.jface.util.Util;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;

/**
 * Observes single selection of an <code>ISelectionProvider</code>.
 *
 * @since 1.1
 */
public class SelectionProviderSingleSelectionObservableValue extends
		AbstractObservableValue {

	private final ISelectionProvider selectionProvider;

	private boolean updating = false;

	private Object currentSelection;

	private ISelectionChangedListener selectionChangedListener;

	/**
	 * Constructs a new instance associated with the provided
	 * <code>selectionProvider</code>. In order to initialize itself properly
	 * the constructor invokes {@link #doGetValue()}. This could be dangerous
	 * for subclasses, see {@link #doGetValue()} for an explanation.
	 *
	 * @param realm
	 *
	 * @param selectionProvider
	 * @see #doGetValue()
	 */
	public SelectionProviderSingleSelectionObservableValue(Realm realm,
			ISelectionProvider selectionProvider) {
		super(realm);
		if (selectionProvider == null) {
			throw new IllegalArgumentException(
					"The 'selectionProvider' parameter is null."); //$NON-NLS-1$
		}

		this.selectionProvider = selectionProvider;
		this.currentSelection = doGetValue();

		selectionChangedListener = new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				if (!updating) {
					Object oldSelection = currentSelection;
					currentSelection = doGetValue();
					fireValueChange(Diffs.createValueDiff(oldSelection,
							currentSelection));
				}
			}
		};
		selectionProvider.addSelectionChangedListener(selectionChangedListener);
	}

	/**
	 * Sets the selection to the provided <code>value</code>. Value change
	 * events are fired after selection is set in the selection provider.
	 *
	 * @param value
	 *            object to set as selected, <code>null</code> if wanting to
	 *            remove selection
	 */
	public void doSetValue(final Object value) {
		try {
			updating = true;

			Object oldSelection = currentSelection;
			selectionProvider
					.setSelection(value == null ? StructuredSelection.EMPTY
							: new StructuredSelection(value));
			currentSelection = doGetValue();
			if (!Util.equals(oldSelection, currentSelection)) {
				fireValueChange(Diffs.createValueDiff(oldSelection,
						currentSelection));
			}
		} finally {
			updating = false;
		}
	}

	/**
	 * Retrieves the current selection.
	 * <p>
	 * If a subclass overrides this method it must not depend upon the subclass
	 * to have been fully initialized before this method is invoked.
	 * <code>doGetValue()</code> is invoked by the
	 * {@link #SelectionProviderSingleSelectionObservableValue(Realm, ISelectionProvider) constructor}
	 * which means the subclass's constructor will not have fully executed
	 * before this method is invoked.
	 * </p>
	 *
	 * @return selection will be an instance of
	 *         <code>IStructuredSelection</code> if a selection exists,
	 *         <code>null</code> if no selection
	 * @see #SelectionProviderSingleSelectionObservableValue(Realm,
	 *      ISelectionProvider)
	 */
	protected Object doGetValue() {
		ISelection selection = selectionProvider.getSelection();
		if (selection instanceof IStructuredSelection) {
			IStructuredSelection sel = (IStructuredSelection) selection;
			return sel.getFirstElement();
		}

		return null;
	}

	public Object getValueType() {
		return null;
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.core.databinding.observable.value.AbstractObservableValue#dispose()
	 */
	public synchronized void dispose() {
		selectionProvider
				.removeSelectionChangedListener(selectionChangedListener);
		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 (bug 124684)
 ******************************************************************************/

package org.eclipse.jface.internal.databinding.viewers;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.set.AbstractObservableSet;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ICheckable;

/**
 * 
 * @since 1.2
 */
public class CheckableCheckedElementsObservableSet extends
		AbstractObservableSet {
	private ICheckable checkable;
	private Set wrappedSet;
	private Object elementType;
	private ICheckStateListener listener;

	/**
	 * Constructs a new instance on the given realm and checkable.
	 * 
	 * @param realm
	 *            the observable's realm
	 * @param checkable
	 *            the ICheckable to track
	 * @param elementType
	 *            type of elements in the set
	 */
	public CheckableCheckedElementsObservableSet(Realm realm,
			ICheckable checkable, Object elementType) {
		this(realm, checkable, elementType, new HashSet());
	}

	/**
	 * Constructs a new instance of the given realm, and checkable,
	 * 
	 * @param realm
	 *            the observable's realm
	 * @param checkable
	 *            the ICheckable to track
	 * @param elementType
	 *            type of elements in the set
	 * @param wrappedSet
	 *            the set being wrapped
	 */
	public CheckableCheckedElementsObservableSet(Realm realm,
			ICheckable checkable, Object elementType, final Set wrappedSet) {
		super(realm);
		Assert.isNotNull(checkable, "Checkable cannot be null"); //$NON-NLS-1$
		Assert.isNotNull(wrappedSet, "Wrapped set cannot be null"); //$NON-NLS-1$
		this.checkable = checkable;
		this.wrappedSet = wrappedSet;
		this.elementType = elementType;

		listener = new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				Object element = event.getElement();
				if (event.getChecked()) {
					if (wrappedSet.add(element))
						fireSetChange(Diffs.createSetDiff(Collections
								.singleton(element), Collections.EMPTY_SET));
				} else {
					if (wrappedSet.remove(element))
						fireSetChange(Diffs.createSetDiff(
								Collections.EMPTY_SET, Collections
										.singleton(element)));
				}
			}
		};
		checkable.addCheckStateListener(listener);
	}

	protected Set getWrappedSet() {
		return wrappedSet;
	}

	Set createDiffSet() {
		return new HashSet();
	}

	public Object getElementType() {
		return elementType;
	}

	public boolean add(Object o) {
		getterCalled();
		boolean added = wrappedSet.add(o);
		if (added) {
			checkable.setChecked(o, true);
			fireSetChange(Diffs.createSetDiff(Collections.singleton(o),
					Collections.EMPTY_SET));
		}
		return added;
	}

	public boolean remove(Object o) {
		getterCalled();
		boolean removed = wrappedSet.remove(o);
		if (removed) {
			checkable.setChecked(o, false);
			fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
					Collections.singleton(o)));
		}
		return removed;
	}

	public boolean addAll(Collection c) {
		getterCalled();
		Set additions = createDiffSet();
		for (Iterator iterator = c.iterator(); iterator.hasNext();) {
			Object element = iterator.next();
			if (wrappedSet.add(element)) {
				checkable.setChecked(element, true);
				additions.add(element);
			}
		}
		boolean changed = !additions.isEmpty();
		if (changed)
			fireSetChange(Diffs.createSetDiff(additions, Collections.EMPTY_SET));
		return changed;
	}

	public boolean removeAll(Collection c) {
		getterCalled();
		Set removals = createDiffSet();
		for (Iterator iterator = c.iterator(); iterator.hasNext();) {
			Object element = iterator.next();
			if (wrappedSet.remove(element)) {
				checkable.setChecked(element, false);
				removals.add(element);
			}
		}
		boolean changed = !removals.isEmpty();
		if (changed)
			fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removals));
		return changed;
	}

	public boolean retainAll(Collection c) {
		getterCalled();

		// To ensure that elements are compared correctly, e.g. ViewerElementSet
		Set toRetain = createDiffSet();
		toRetain.addAll(c);

		Set removals = createDiffSet();
		for (Iterator iterator = wrappedSet.iterator(); iterator.hasNext();) {
			Object element = iterator.next();
			if (!toRetain.contains(element)) {
				iterator.remove();
				checkable.setChecked(element, false);
				removals.add(element);
			}
		}
		boolean changed = !removals.isEmpty();
		if (changed)
			fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removals));
		return changed;
	}

	public void clear() {
		removeAll(wrappedSet);
	}

	public Iterator iterator() {
		getterCalled();
		final Iterator wrappedIterator = wrappedSet.iterator();
		return new Iterator() {
			private Object last = null;

			public boolean hasNext() {
				getterCalled();
				return wrappedIterator.hasNext();
			}

			public Object next() {
				getterCalled();
				return last = wrappedIterator.next();
			}

			public void remove() {
				getterCalled();
				wrappedIterator.remove();
				checkable.setChecked(last, false);
				fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
						Collections.singleton(last)));
			}
		};
	}

	public synchronized void dispose() {
		if (checkable != null) {
			checkable.removeCheckStateListener(listener);
			checkable = null;
			listener = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2005, 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 (bug 239302)
 *******************************************************************************/

package org.eclipse.jface.internal.databinding.viewers;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.set.ObservableSet;
import org.eclipse.jface.databinding.viewers.IViewerObservableSet;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;

/**
 * An observable set that tracks the filters of the given viewer. Note that this
 * set will not track changes that are made using direct API on StructuredViewer
 * (by calling
 * {@link StructuredViewer#addFilter(org.eclipse.jface.viewers.ViewerFilter)
 * addFilter()},
 * {@link StructuredViewer#removeFilter(org.eclipse.jface.viewers.ViewerFilter)
 * removeFilter()}, or
 * {@link StructuredViewer#setFilters(org.eclipse.jface.viewers.ViewerFilter[])
 * setFilters()}) -- it is assumed that filters are only changed through the
 * set.
 * 
 * @since 1.2
 */
public class ViewerFiltersObservableSet extends ObservableSet implements
		IViewerObservableSet {

	private StructuredViewer viewer;

	/**
	 * @param realm
	 * @param viewer
	 */
	public ViewerFiltersObservableSet(Realm realm, StructuredViewer viewer) {
		super(realm, new HashSet(Arrays.asList(viewer.getFilters())),
				ViewerFilter.class);
		this.viewer = viewer;
	}

	public Viewer getViewer() {
		return viewer;
	}

	private void replaceFilters() {
		viewer.getControl().setRedraw(false);
		try {
			viewer.setFilters((ViewerFilter[]) wrappedSet
					.toArray(new ViewerFilter[wrappedSet.size()]));
		} finally {
			viewer.getControl().setRedraw(true);
		}
	}

	private void addFilter(ViewerFilter filter) {
		viewer.getControl().setRedraw(false);
		try {
			viewer.addFilter(filter);
		} finally {
			viewer.getControl().setRedraw(true);
		}
	}

	private void removeFilter(ViewerFilter filter) {
		viewer.getControl().setRedraw(false);
		try {
			viewer.removeFilter(filter);
		} finally {
			viewer.getControl().setRedraw(true);
		}
	}

	public boolean add(Object element) {
		checkRealm();
		boolean added = wrappedSet.add(element);
		if (added) {
			addFilter((ViewerFilter) element);
			fireSetChange(Diffs.createSetDiff(Collections.singleton(element),
					Collections.EMPTY_SET));
		}
		return added;
	}

	public boolean addAll(Collection c) {
		getterCalled();
		Set additions = new HashSet();
		Iterator it = c.iterator();
		while (it.hasNext()) {
			Object element = it.next();
			if (wrappedSet.add(element)) {
				additions.add(element);
			}
		}
		if (additions.size() > 0) {
			replaceFilters();
			fireSetChange(Diffs.createSetDiff(additions, Collections.EMPTY_SET));
			return true;
		}
		return false;
	}

	public void clear() {
		getterCalled();
		Set removes = new HashSet(wrappedSet);
		wrappedSet.clear();
		replaceFilters();
		fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
	}

	public boolean remove(Object o) {
		getterCalled();
		boolean removed = wrappedSet.remove(o);
		if (removed) {
			removeFilter((ViewerFilter) o);
			fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
					Collections.singleton(o)));
		}
		return removed;
	}

	public boolean removeAll(Collection c) {
		getterCalled();
		Set removes = new HashSet();
		Iterator it = c.iterator();
		while (it.hasNext()) {
			Object element = it.next();
			if (wrappedSet.remove(element)) {
				removes.add(element);
			}
		}
		if (removes.size() > 0) {
			replaceFilters();
			fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
			return true;
		}
		return false;
	}

	public boolean retainAll(Collection c) {
		getterCalled();
		Set removes = new HashSet();
		Iterator it = wrappedSet.iterator();
		while (it.hasNext()) {
			Object element = it.next();
			if (!c.contains(element)) {
				it.remove();
				removes.add(element);
			}
		}
		if (removes.size() > 0) {
			replaceFilters();
			fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
			return true;
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Peter Centgraf 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:
 *     Peter Centgraf - initial API and implementation, bug 124683
 *     Boris Bokowski, IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jface.internal.databinding.viewers;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.WritableList;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;

/**
 * Observes multiple-selection of an {@link ISelectionProvider}.
 * 
 * @since 1.2
 */
public class SelectionProviderMultipleSelectionObservableList extends
		WritableList {

	protected ISelectionProvider selectionProvider;
	protected boolean handlingSelection;
	protected boolean updating;
	protected SelectionListener selectionListener = new SelectionListener();

	class SelectionListener implements ISelectionChangedListener {
		public void selectionChanged(SelectionChangedEvent event) {
			if (updating) {
				return;
			}
			handlingSelection = true;
			try {
				updateWrappedList(new ArrayList(getSelectionList(event.getSelection())));
			} finally {
				handlingSelection = false;
			}
		}
	}

	/**
	 * Create a new observable list based on the current selection of the given
	 * selection provider. Assumes that the selection provider provides
	 * structured selections.
	 * 
	 * @param realm
	 * @param selectionProvider
	 * @param elementType
	 */
	public SelectionProviderMultipleSelectionObservableList(Realm realm,
			ISelectionProvider selectionProvider, Object elementType) {
		super(realm, new ArrayList(getSelectionList(selectionProvider)), elementType);
		this.selectionProvider = selectionProvider;
		selectionProvider.addSelectionChangedListener(selectionListener);
	}

	protected void fireListChange(ListDiff diff) {
		if (handlingSelection) {
			super.fireListChange(diff);
		} else {
			// this is a bit of a hack - we are changing the diff to match the order
			// of elements returned by the selection provider after we've set the
			// selection.
			updating = true;
			try {
				List oldList = getSelectionList(selectionProvider);
				selectionProvider
						.setSelection(new StructuredSelection(wrappedList));
				wrappedList = new ArrayList(getSelectionList(selectionProvider));
				super.fireListChange(Diffs.computeListDiff(oldList, wrappedList));
			} finally {
				updating = false;
			}
		}
	}

	protected static List getSelectionList(ISelectionProvider selectionProvider) {
		if (selectionProvider == null) {
			throw new IllegalArgumentException();
		}
		return getSelectionList(selectionProvider.getSelection());
	}

	protected static List getSelectionList(ISelection sel) {
		if (sel instanceof IStructuredSelection) {
			return ((IStructuredSelection) sel).toList();
		}
		return Collections.EMPTY_LIST;
	}

	public synchronized void dispose() {
		selectionProvider.removeSelectionChangedListener(selectionListener);
		selectionProvider = null;
		super.dispose();
	}
}





package org.eclipse.jface.databinding.viewers;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.IListProperty;
import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.PropertyObservables;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.internal.databinding.viewers.ViewerObservableListDecorator;
import org.eclipse.jface.internal.databinding.viewers.ViewerObservableSetDecorator;
import org.eclipse.jface.internal.databinding.viewers.ViewerObservableValueDecorator;
import org.eclipse.jface.internal.databinding.viewers.SelectionProviderSingleSelectionObservableValue;
import org.eclipse.jface.internal.databinding.viewers.ViewerFiltersObservableSet;
import org.eclipse.jface.internal.databinding.viewers.ViewerInputObservableValue;
import org.eclipse.jface.internal.databinding.viewers.ViewerMultipleSelectionObservableList;
import org.eclipse.jface.internal.databinding.viewers.ViewerSingleSelectionObservableValue;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckable;

 * @since 1.1
 */
public class ViewersObservables {
	private static Realm getDefaultRealm() {
		return SWTObservables.getRealm(Display.getDefault());
	}

	private static Realm getRealm(Viewer viewer) {
		return SWTObservables.getRealm(viewer.getControl().getDisplay());
	}

	private static void checkNull(Object obj) {
		if (obj == null)
			throw new IllegalArgumentException();
	}

	private static IObservableValue observeProperty(Object source,
			IValueProperty property) {
		checkNull(source);
		if (source instanceof Viewer) {
			return observeViewerProperty((Viewer) source, property);
		}
		return PropertyObservables.observeValue(getDefaultRealm(), source,
				property);
	}

	private static IViewerObservableValue observeViewerProperty(Viewer viewer,
			IValueProperty property) {
		checkNull(viewer);
		return new ViewerObservableValueDecorator(PropertyObservables
				.observeValue(getRealm(viewer), viewer, property), viewer);
	}

	private static IObservableSet observeProperty(Object source,
			ISetProperty property) {
		checkNull(source);
		if (source instanceof Viewer) {
			return observeViewerProperty((Viewer) source, property);
		}
		return PropertyObservables.observeSet(getDefaultRealm(), source,
				property);
	}

	private static IViewerObservableSet observeViewerProperty(Viewer viewer,
			ISetProperty property) {
		checkNull(viewer);
		return new ViewerObservableSetDecorator(PropertyObservables.observeSet(
				getRealm(viewer), viewer, property), viewer);
	}

	private static IObservableList observeProperty(Object source,
			IListProperty property) {
		checkNull(source);
		if (source instanceof Viewer) {
			return observeViewerProperty((Viewer) source, property);
		}
		Realm realm = getDefaultRealm();
		return PropertyObservables.observeList(realm, source, property);
	}

	private static IViewerObservableList observeViewerProperty(Viewer viewer,
			IListProperty property) {
		checkNull(viewer);
		Realm realm = getRealm(viewer);
		return new ViewerObservableListDecorator(PropertyObservables
				.observeList(realm, viewer, property), viewer);
	}

	/**
	 * Returns an observable value that tracks the current selection of the

	 */
	public static IObservableValue observeSingleSelection(
			ISelectionProvider selectionProvider) {
		return observeProperty(selectionProvider, SelectionProviderProperties
				.singleSelection());
		}
		return new SelectionProviderSingleSelectionObservableValue(
				SWTObservables.getRealm(Display.getDefault()),
				selectionProvider);
	}

	/**

	 */
	public static IObservableList observeMultiSelection(
			ISelectionProvider selectionProvider) {
		return observeProperty(selectionProvider, SelectionProviderProperties
				.multipleSelection());
		}
		return new SelectionProviderMultipleSelectionObservableList(
				SWTObservables.getRealm(Display.getDefault()),
				selectionProvider, Object.class);
	}

	/**

	 * @since 1.2
	 */
	public static IViewerObservableValue observeSingleSelection(Viewer viewer) {
		return observeViewerProperty(viewer, SelectionProviderProperties
				.singleSelection());
				viewer);
	}
	
	/**

	 * 
	 * @since 1.2
	 */
	public static IViewerObservableList observeMultiSelection(Viewer viewer) {
		return observeViewerProperty(viewer, SelectionProviderProperties
				.multipleSelection());
				SWTObservables.getRealm(Display.getDefault()),
				viewer, Object.class);
	}
	
	/**

	 * @since 1.2
	 */
	public static IObservableValue observeInput(Viewer viewer) {
		return observeViewerProperty(viewer, ViewerProperties.input());
				.getControl().getDisplay()), viewer);
	}

	/**

			return observeCheckedElements((CheckboxTreeViewer) checkable,
					elementType);
		}
		return observeProperty(checkable, CheckableProperties
				.checkedElements(elementType));
	}

	/**

	 */
	public static IViewerObservableSet observeCheckedElements(
			CheckboxTableViewer viewer, Object elementType) {
		return observeViewerProperty(viewer, CheckboxTableViewerProperties
				.checkedElements(elementType));
				elementType);
	}

	/**

	 */
	public static IViewerObservableSet observeCheckedElements(
			CheckboxTreeViewer viewer, Object elementType) {
		return observeViewerProperty(viewer, CheckboxTreeViewerProperties
				.checkedElements(elementType));
				elementType);
	}

	/**

	 * @since 1.3
	 */
	public static IViewerObservableSet observeFilters(StructuredViewer viewer) {
		return observeViewerProperty(viewer, StructuredViewerProperties
				.filters());
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.BasicListProperty;
import org.eclipse.jface.util.Util;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;

/**
 * @since 3.3
 * 
 */
public class SelectionProviderMultipleSelectionProperty extends BasicListProperty
		implements ISelectionChangedListener {
	private Map sourceToList = new HashMap();

	protected void addListenerTo(Object source) {
		((ISelectionProvider) source).addSelectionChangedListener(this);
		sourceToList.put(source, getList(source));
	}

	protected void removeListenerFrom(Object source) {
		((ISelectionProvider) source).removeSelectionChangedListener(this);
		sourceToList.remove(source);
	}

	public void selectionChanged(SelectionChangedEvent event) {
		Object source = event.getSelectionProvider();
		if (!isUpdating(source)) {
			List oldList = (List) sourceToList.get(source);
			List newList = getList(source);
			sourceToList.put(source, newList);
			if (!Util.equals(oldList, newList)) {
				fireListChange(source, Diffs.computeListDiff(oldList, newList));
			}
		}
	}

	public List getList(Object source) {
		ISelection selection = ((ISelectionProvider) source).getSelection();
		if (selection instanceof IStructuredSelection) {
			return ((IStructuredSelection) selection).toList();
		}
		return Collections.EMPTY_LIST;
	}

	protected void doSetList(Object source, List list) {
		((ISelectionProvider) source)
				.setSelection(new StructuredSelection(list));
		sourceToList.put(source, list);
	}

	public Object getElementType() {
		return Object.class;
	}
}




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

package org.eclipse.jface.databinding.viewers;

import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.jface.internal.databinding.viewers.StructuredViewerFiltersProperty;

/**
 * A factory for creating properties of JFace StructuredViewers
 * 
 * @since 1.3
 */
public class StructuredViewerProperties {
	/**
	 * Returns a value property for the input of a JFace StructuredViewer.
	 * 
	 * @return a value property for the input of a JFace StructuredViewer.
	 */
	public static ISetProperty filters() {
		return new StructuredViewerFiltersProperty();
	}
}




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

package org.eclipse.jface.databinding.viewers;

import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.jface.internal.databinding.viewers.CheckboxTableViewerCheckedElementsProperty;

/**
 * A factory for creating properties of JFace CheckboxTableViewer
 * 
 * @since 1.3
 */
public class CheckboxTableViewerProperties {
	/**
	 * Returns a set property for the checked elements of a JFace
	 * CheckboxTableViewer.
	 * 
	 * @param elementType
	 *            the element type of the returned property
	 * 
	 * @return a set property for the checked elements of a JFace
	 *         CheckboxTableViewer.
	 */
	public static ISetProperty checkedElements(Object elementType) {
		return new CheckboxTableViewerCheckedElementsProperty(elementType);
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import org.eclipse.core.databinding.observable.set.DecoratingObservableSet;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.jface.databinding.viewers.IViewerObservableSet;
import org.eclipse.jface.viewers.Viewer;

/**
 * @since 3.3
 * 
 */
public class ViewerObservableSetDecorator extends DecoratingObservableSet
		implements IViewerObservableSet {
	private final Viewer viewer;

	/**
	 * @param decorated
	 * @param viewer
	 */
	public ViewerObservableSetDecorator(IObservableSet decorated, Viewer viewer) {
		super(decorated, true);
		this.viewer = viewer;
	}

	public Viewer getViewer() {
		return viewer;
	}

}




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

package org.eclipse.jface.databinding.viewers;

import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.jface.internal.databinding.viewers.CheckableCheckedElementsProperty;

/**
 * A factory for creating properties of JFace ICheckables
 * 
 * @since 1.3
 */
public class CheckableProperties {
	/**
	 * Returns a set property for the checked elements of a JFace ICheckable.
	 * 
	 * @param elementType
	 *            the element type of the returned property
	 * 
	 * @return a set property for the checked elements of a JFace ICheckable.
	 */
	public static ISetProperty checkedElements(Object elementType) {
		return new CheckableCheckedElementsProperty(elementType);
	}
}




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

package org.eclipse.jface.databinding.viewers;

import org.eclipse.core.databinding.property.IListProperty;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.jface.internal.databinding.viewers.SelectionProviderMultipleSelectionProperty;
import org.eclipse.jface.internal.databinding.viewers.SelectionProviderSingleSelectionProperty;

/**
 * A factory for creating properties of JFace ISelectionProviders
 * 
 * @since 1.3
 */
public class SelectionProviderProperties {
	/**
	 * Returns a value property for the single selection of a JFace
	 * ISelectionProvider.
	 * 
	 * @return a value property for the single selection of a JFace
	 *         ISelectionProvider.
	 */
	public static IValueProperty singleSelection() {
		return new SelectionProviderSingleSelectionProperty();
	}

	/**
	 * Returns a list property for the multiple selection of a JFace
	 * ISelectionProvider.
	 * 
	 * @return a list property for the multiple selection of a JFace
	 *         ISelectionProvider.
	 */
	public static IListProperty multipleSelection() {
		return new SelectionProviderMultipleSelectionProperty();
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.SetProperty;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ICheckable;

/**
 * @since 3.3
 * 
 */
public class CheckableCheckedElementsProperty extends SetProperty implements
		ICheckStateListener {
	private Object elementType;

	private Map sourceToSet = new HashMap();

	/**
	 * @param elementType
	 */
	public CheckableCheckedElementsProperty(Object elementType) {
		this.elementType = elementType;

	}

	protected void addListenerTo(Object source) {
		((ICheckable) source).addCheckStateListener(this);
		sourceToSet.put(source, getSet(source));
	}

	protected void removeListenerFrom(Object source) {
		((ICheckable) source).removeCheckStateListener(this);
		sourceToSet.remove(source);
	}

	public void checkStateChanged(CheckStateChangedEvent event) {
		// ICheckable is documented to not fire events when setChecked() is
		// called, so no need to check whether the element is being updated.

		Object source = event.getCheckable();
		Set set = (Set) sourceToSet.get(source);

		Object element = event.getElement();
		if (event.getChecked()) {
			if (set.add(element)) {
				fireSetChange(source, Diffs.createSetDiff(Collections
						.singleton(element), Collections.EMPTY_SET));
			}
		} else {
			if (set.remove(element)) {
				fireSetChange(source, Diffs.createSetDiff(
						Collections.EMPTY_SET, Collections.singleton(element)));
			}
		}
	}

	public Object getElementType() {
		return elementType;
	}

	public final Set getSet(Object source) {
		ICheckable checkable = (ICheckable) source;

		Set set = doGetSet(checkable);
		if (set == null) {
			set = (Set) sourceToSet.get(source);
		}
		if (set == null) {
			set = createElementSet(checkable);
		}
		sourceToSet.put(source, set);

		return set;
	}

	protected Set doGetSet(ICheckable checkable) {
		return null;
	}

	protected Set createElementSet(ICheckable checkable) {
		return new HashSet();
	}

	public boolean add(Object source, Object o) {
		ICheckable checkable = (ICheckable) source;
		Set set = getSet(source);

		boolean added = set.add(source);
		if (added) {
			checkable.setChecked(o, true);
			if (hasListeners(source)) {
				fireSetChange(source, Diffs.createSetDiff(Collections
						.singleton(o), Collections.EMPTY_SET));
			}
		}
		return added;
	}

	public boolean addAll(Object source, Collection c) {
		ICheckable checkable = (ICheckable) source;
		Set set = getSet(source);
		Set additions = createElementSet(checkable);

		for (Iterator it = c.iterator(); it.hasNext();) {
			Object element = it.next();
			if (set.add(element)) {
				checkable.setChecked(element, true);
				additions.add(element);
			}
		}

		boolean changed = !additions.isEmpty();
		if (changed && hasListeners(source))
			fireSetChange(source, Diffs.createSetDiff(additions,
					Collections.EMPTY_SET));

		return changed;
	}

	public void clear(Object source) {
		if (isEmpty(source))
			return;

		ICheckable checkable = (ICheckable) source;
		Set set = getSet(source);

		for (Iterator it = set.iterator(); it.hasNext();) {
			checkable.setChecked(it.next(), false);
		}

		sourceToSet.put(source, createElementSet(checkable));

		if (hasListeners(source)) {
			fireSetChange(source, Diffs.createSetDiff(Collections.EMPTY_SET,
					set));
		}
	}

	public boolean remove(Object source, Object o) {
		ICheckable checkable = (ICheckable) source;
		Set set = getSet(source);

		boolean removed = set.remove(o);
		if (removed) {
			checkable.setChecked(o, false);
			if (hasListeners(source)) {
				fireSetChange(source, Diffs.createSetDiff(
						Collections.EMPTY_SET, Collections.singleton(o)));
			}
		}
		return removed;
	}

	public boolean removeAll(Object source, Collection c) {
		ICheckable checkable = (ICheckable) source;
		Set set = getSet(source);
		Set removals = createElementSet(checkable);

		for (Iterator it = set.iterator(); it.hasNext();) {
			Object element = it.next();
			if (c.contains(element)) {
				it.remove();
				checkable.setChecked(element, false);
				removals.add(element);
			}
		}

		boolean changed = !removals.isEmpty();
		if (changed && hasListeners(source))
			fireSetChange(source, Diffs.createSetDiff(Collections.EMPTY_SET,
					removals));

		return changed;
	}

	public boolean retainAll(Object source, Collection c) {
		ICheckable checkable = (ICheckable) source;
		Set set = getSet(source);
		Set removals = createElementSet(checkable);

		for (Iterator it = set.iterator(); it.hasNext();) {
			Object element = it.next();
			if (!c.contains(element)) {
				it.remove();
				checkable.setChecked(element, false);
				removals.add(element);
			}
		}

		boolean changed = !removals.isEmpty();
		if (changed && hasListeners(source))
			fireSetChange(source, Diffs.createSetDiff(Collections.EMPTY_SET,
					removals));

		return changed;
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import java.util.Arrays;
import java.util.Set;

import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckable;

/**
 * @since 3.3
 * 
 */
public class CheckboxTableViewerCheckedElementsProperty extends
		CheckableCheckedElementsProperty {
	/**
	 * @param elementType
	 */
	public CheckboxTableViewerCheckedElementsProperty(Object elementType) {
		super(elementType);
	}

	protected Set createElementSet(ICheckable checkable) {
		return ViewerElementSet.withComparer(((CheckboxTableViewer) checkable)
				.getComparer());
	}

	protected Set doGetSet(ICheckable checkable) {
		CheckboxTableViewer viewer = (CheckboxTableViewer) checkable;
		Set set = createElementSet(viewer);
		set.addAll(Arrays.asList(viewer.getCheckedElements()));
		return set;
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import org.eclipse.core.databinding.observable.list.DecoratingObservableList;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.jface.databinding.viewers.IViewerObservableList;
import org.eclipse.jface.viewers.Viewer;

/**
 * @since 3.3
 * 
 */
public class ViewerObservableListDecorator extends DecoratingObservableList
		implements IViewerObservableList {
	private final Viewer viewer;

	/**
	 * @param decorated
	 * @param viewer
	 */
	public ViewerObservableListDecorator(IObservableList decorated,
			Viewer viewer) {
		super(decorated, true);
		this.viewer = viewer;
	}

	public Viewer getViewer() {
		return viewer;
	}

}




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

package org.eclipse.jface.databinding.viewers;

import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.jface.internal.databinding.viewers.ViewerInputProperty;

/**
 * A factory for creating properties of JFace Viewers
 * 
 * @since 1.3
 */
public class ViewerProperties {
	/**
	 * Returns a value property for the input of a JFace Viewer.
	 * 
	 * @return a value property for the input of a JFace Viewer.
	 */
	public static IValueProperty input() {
		return new ViewerInputProperty();
	}
}




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

package org.eclipse.jface.databinding.viewers;

import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.jface.internal.databinding.viewers.CheckboxTreeViewerCheckedElementsProperty;

/**
 * A factory for creating properties of JFace CheckboxTreeViewer
 * 
 * @since 1.3
 */
public class CheckboxTreeViewerProperties {
	/**
	 * Returns a set property for the checked elements of a JFace
	 * CheckboxTreeViewer.
	 * 
	 * @param elementType
	 *            the element type of the returned property
	 * 
	 * @return a set property for the checked elements of a JFace
	 *         CheckboxTreeViewer.
	 */
	public static ISetProperty checkedElements(Object elementType) {
		return new CheckboxTreeViewerCheckedElementsProperty(elementType);
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import org.eclipse.core.databinding.property.BasicValueProperty;
import org.eclipse.jface.viewers.Viewer;

/**
 * @since 3.3
 * 
 */
public class ViewerInputProperty extends BasicValueProperty {
	protected void addListenerTo(Object source) {
		// no listener API
	}

	protected void removeListenerFrom(Object source) {
		// no listener API
	}

	public Object getValueType() {
		return null;
	}

	public Object getValue(Object source) {
		return ((Viewer) source).getInput();
	}

	protected void doSetValue(Object source, Object value) {
		((Viewer) source).setInput(value);
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.BasicValueProperty;
import org.eclipse.jface.util.Util;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;

/**
 * @since 3.3
 * 
 */
public class SelectionProviderSingleSelectionProperty extends
		BasicValueProperty implements ISelectionChangedListener {
	private Map sourceToValue = new HashMap();

	protected void addListenerTo(Object source) {
		((ISelectionProvider) source).addSelectionChangedListener(this);
		sourceToValue.put(source, getValue(source));
	}

	protected void removeListenerFrom(Object source) {
		((ISelectionProvider) source).removeSelectionChangedListener(this);
		sourceToValue.remove(source);
	}

	public void selectionChanged(SelectionChangedEvent event) {
		Object source = event.getSelectionProvider();
		if (!isUpdating(source)) {
			Object oldValue = sourceToValue.get(source);
			Object newValue = getValue(source);
			sourceToValue.put(source, newValue);
			if (!Util.equals(oldValue, newValue)) {
				fireValueChange(source, Diffs.createValueDiff(oldValue,
						newValue));
			}
		}
		
	}

	public Object getValueType() {
		return null;
	}

	public Object getValue(Object source) {
		ISelection selection = ((ISelectionProvider) source).getSelection();
		if (selection instanceof IStructuredSelection) {
			return ((IStructuredSelection) selection).getFirstElement();
		}
		return null;
	}

	protected void doSetValue(Object source, Object value) {
		((ISelectionProvider) source)
				.setSelection(value == null ? StructuredSelection.EMPTY
						: new StructuredSelection(value));
		sourceToValue.put(source, value);
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import java.util.Arrays;
import java.util.Set;

import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckable;

/**
 * @since 3.3
 * 
 */
public class CheckboxTreeViewerCheckedElementsProperty extends
		CheckableCheckedElementsProperty {
	/**
	 * @param elementType
	 */
	public CheckboxTreeViewerCheckedElementsProperty(Object elementType) {
		super(elementType);
	}

	protected Set createElementSet(ICheckable checkable) {
		return ViewerElementSet.withComparer(((CheckboxTreeViewer) checkable)
				.getComparer());
	}

	protected Set doGetSet(ICheckable checkable) {
		CheckboxTreeViewer viewer = (CheckboxTreeViewer) checkable;
		Set set = createElementSet(viewer);
		set.addAll(Arrays.asList(viewer.getCheckedElements()));
		return set;
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.BasicSetProperty;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.ViewerFilter;

/**
 * @since 3.3
 * 
 */
public class StructuredViewerFiltersProperty extends BasicSetProperty {
	protected void addListenerTo(Object source) {
		// no listener API
	}

	protected void removeListenerFrom(Object source) {
		// no listener API
	}

	public Object getElementType() {
		return ViewerFilter.class;
	}

	public Set getSet(Object source) {
		return new HashSet(Arrays.asList(((StructuredViewer) source)
				.getFilters()));
	}

	protected void doSetSet(Object source, Set set) {
		StructuredViewer viewer = (StructuredViewer) source;
		viewer.getControl().setRedraw(false);
		try {
			viewer.setFilters((ViewerFilter[]) set.toArray(new ViewerFilter[set
					.size()]));
		} finally {
			viewer.getControl().setRedraw(true);
		}
	}

	public boolean add(Object source, Object o) {
		StructuredViewer viewer = (StructuredViewer) source;
		ViewerFilter filter = (ViewerFilter) o;

		Set filters = getSet(source);
		boolean added = filters.add(o);
		if (added) {
			viewer.addFilter(filter);
			if (hasListeners(source)) {
				fireSetChange(source, Diffs.createSetDiff(Collections
						.singleton(filter), Collections.EMPTY_SET));
			}
		}
		return added;
	}

	public boolean remove(Object source, Object o) {
		StructuredViewer viewer = (StructuredViewer) source;
		ViewerFilter filter = (ViewerFilter) o;

		Set filters = getSet(source);
		boolean removed = filters.remove(o);
		if (removed) {
			viewer.removeFilter(filter);
			if (hasListeners(source)) {
				fireSetChange(source, Diffs.createSetDiff(
						Collections.EMPTY_SET, Collections.singleton(filter)));
			}
		}
		return removed;
	}
}




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

package org.eclipse.jface.internal.databinding.viewers;

import org.eclipse.core.databinding.observable.value.DecoratingObservableValue;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.databinding.viewers.IViewerObservableValue;
import org.eclipse.jface.viewers.Viewer;

/**
 * @since 3.3
 * 
 */
public class ViewerObservableValueDecorator extends DecoratingObservableValue
		implements IViewerObservableValue {
	private final Viewer viewer;

	/**
	 * @param decorated
	 * @param viewer
	 */
	public ViewerObservableValueDecorator(IObservableValue decorated,
			Viewer viewer) {
		super(decorated, true);
		this.viewer = viewer;
	}

	public Viewer getViewer() {
		return viewer;
	}
}

Return to bug 248174

Lines 18-27 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/viewers/ViewerInputObservableValueTest.java (-14 / +15 lines)
18	import org.eclipse.core.databinding.observable.Realm;	18	import org.eclipse.core.databinding.observable.Realm;
19	import org.eclipse.core.databinding.observable.value.IObservableValue;	19	import org.eclipse.core.databinding.observable.value.IObservableValue;
20	import org.eclipse.core.databinding.observable.value.ValueChangeEvent;	20	import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
		21	import org.eclipse.core.databinding.property.PropertyObservables;
21	import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
22	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;	23	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
23	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;	24	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
24	import org.eclipse.jface.internal.databinding.viewers.ViewerInputObservableValue;	25	import org.eclipse.jface.databinding.viewers.ViewerProperties;
		26	import org.eclipse.jface.databinding.viewers.ViewersObservables;
25	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	27	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
26	import org.eclipse.jface.viewers.IStructuredContentProvider;	28	import org.eclipse.jface.viewers.IStructuredContentProvider;
27	import org.eclipse.jface.viewers.TableViewer;	29	import org.eclipse.jface.viewers.TableViewer;
Lines 55-70 Link Here
55		57
56	public void testConstructor_IllegalArgumentException() {	58	public void testConstructor_IllegalArgumentException() {
57	try {	59	try {
58	new ViewerInputObservableValue(Realm.getDefault(), null);	60	ViewersObservables.observeInput(null);
59	fail("Expected IllegalArgumentException for null argument");	61	fail("Expected IllegalArgumentException for null argument");
60	} catch (IllegalArgumentException expected) {	62	} catch (IllegalArgumentException expected) {
61	}	63	}
62	}	64	}
63		65
64	public void testSetInputOnViewer_FiresNoChangeEvents() {	66	public void testSetInputOnViewer_FiresNoChangeEvents() {
65	IObservableValue observable = new ViewerInputObservableValue(Realm	67	IObservableValue observable = ViewersObservables.observeInput(viewer);
66	.getDefault(), viewer);	68	ValueChangeEventTracker listener = ValueChangeEventTracker
67	ValueChangeEventTracker listener = ValueChangeEventTracker.observe(observable);	69	.observe(observable);
68		70
69	assertNull(viewer.getInput());	71	assertNull(viewer.getInput());
70	assertEquals(0, listener.count);	72	assertEquals(0, listener.count);
Lines 81-88 Link Here
81	}	83	}
82		84
83	public void testGetSetValue_FiresChangeEvents() {	85	public void testGetSetValue_FiresChangeEvents() {
84	IObservableValue observable = new ViewerInputObservableValue(Realm	86	IObservableValue observable = ViewersObservables.observeInput(viewer);
85	.getDefault(), viewer);
86	ValueChangeEventTracker listener = new ValueChangeEventTracker();	87	ValueChangeEventTracker listener = new ValueChangeEventTracker();
87	observable.addValueChangeListener(listener);	88	observable.addValueChangeListener(listener);
88		89
Lines 103-116 Link Here
103	}	104	}
104		105
105	public void testGetValueType_AlwaysNull() throws Exception {	106	public void testGetValueType_AlwaysNull() throws Exception {
106	IObservableValue observable = new ViewerInputObservableValue(Realm	107	IObservableValue observable = ViewersObservables.observeInput(viewer);
107	.getDefault(), viewer);
108	assertEquals(null, observable.getValueType());	108	assertEquals(null, observable.getValueType());
109	}	109	}
110		110
111	public void testDispose() throws Exception {	111	public void testDispose() throws Exception {
112	IObservableValue observable = new ViewerInputObservableValue(Realm	112	IObservableValue observable = ViewersObservables.observeInput(viewer);
113	.getDefault(), viewer);
114	observable.dispose();	113	observable.dispose();
115	assertNull(observable.getRealm());	114	assertNull(observable.getRealm());
116	try {	115	try {
Lines 141-147 Link Here
141	}	140	}
142		141
143	public static Test suite() {	142	public static Test suite() {
144	TestSuite suite = new TestSuite(ViewerInputObservableValueTest.class.getName());	143	TestSuite suite = new TestSuite(ViewerInputObservableValueTest.class
		144	.getName());
145	suite.addTestSuite(ViewerInputObservableValueTest.class);	145	suite.addTestSuite(ViewerInputObservableValueTest.class);
146	suite.addTest(MutableObservableValueContractTest.suite(new Delegate()));	146	suite.addTest(MutableObservableValueContractTest.suite(new Delegate()));
147	return suite;	147	return suite;
Lines 165-175 Link Here
165	}	165	}
166		166
167	public IObservableValue createObservableValue(Realm realm) {	167	public IObservableValue createObservableValue(Realm realm) {
168	return new ViewerInputObservableValue(realm, viewer);	168	return PropertyObservables.observeValue(realm, viewer,
		169	ViewerProperties.input());
169	}	170	}
170		171
171	public void change(IObservable observable) {	172	public void change(IObservable observable) {
172	IObservableValue value = (IObservableValue)observable;	173	IObservableValue value = (IObservableValue) observable;
173	value.setValue(createValue(value));	174	value.setValue(createValue(value));
174	}	175	}
175		176

Lines 14-29 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/viewers/SelectionProviderSingleSelectionObservableValueTest.java (-13 / +9 lines)
14		14
15	import junit.framework.TestCase;	15	import junit.framework.TestCase;
16		16
		17	import org.eclipse.core.databinding.observable.value.IObservableValue;
17	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;	18	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
18	import org.eclipse.jface.databinding.swt.SWTObservables;	19	import org.eclipse.jface.databinding.viewers.ViewersObservables;
19	import org.eclipse.jface.internal.databinding.viewers.SelectionProviderSingleSelectionObservableValue;
20	import org.eclipse.jface.viewers.ISelectionProvider;	20	import org.eclipse.jface.viewers.ISelectionProvider;
21	import org.eclipse.jface.viewers.IStructuredContentProvider;	21	import org.eclipse.jface.viewers.IStructuredContentProvider;
22	import org.eclipse.jface.viewers.StructuredSelection;	22	import org.eclipse.jface.viewers.StructuredSelection;
23	import org.eclipse.jface.viewers.TableViewer;	23	import org.eclipse.jface.viewers.TableViewer;
24	import org.eclipse.jface.viewers.Viewer;	24	import org.eclipse.jface.viewers.Viewer;
25	import org.eclipse.swt.SWT;	25	import org.eclipse.swt.SWT;
26	import org.eclipse.swt.widgets.Display;
27	import org.eclipse.swt.widgets.Shell;	26	import org.eclipse.swt.widgets.Shell;
28		27
29	/**	28	/**
Lines 41-47 Link Here
41		40
42	/*	41	/*
43	* (non-Javadoc)	42	* (non-Javadoc)
44	*	43	*
45	* @see junit.framework.TestCase#setUp()	44	* @see junit.framework.TestCase#setUp()
46	*/	45	*/
47	protected void setUp() throws Exception {	46	protected void setUp() throws Exception {
Lines 54-60 Link Here
54		53
55	/*	54	/*
56	* (non-Javadoc)	55	* (non-Javadoc)
57	*	56	*
58	* @see junit.framework.TestCase#tearDown()	57	* @see junit.framework.TestCase#tearDown()
59	*/	58	*/
60	protected void tearDown() throws Exception {	59	protected void tearDown() throws Exception {
Lines 65-72 Link Here
65		64
66	public void testConstructorIllegalArgumentException() {	65	public void testConstructorIllegalArgumentException() {
67	try {	66	try {
68	new SelectionProviderSingleSelectionObservableValue(SWTObservables	67	ViewersObservables.observeSingleSelection(null);
69	.getRealm(Display.getDefault()), null);
70	fail();	68	fail();
71	} catch (IllegalArgumentException e) {	69	} catch (IllegalArgumentException e) {
72	}	70	}
Lines 80-88 Link Here
80	* </ul>	78	* </ul>
81	*/	79	*/
82	public void testGetSetValue() {	80	public void testGetSetValue() {
83	SelectionProviderSingleSelectionObservableValue observable = new SelectionProviderSingleSelectionObservableValue(	81	IObservableValue observable = ViewersObservables
84	SWTObservables.getRealm(Display.getDefault()),	82	.observeSingleSelection(selectionProvider);
85	selectionProvider);
86	ValueChangeEventTracker listener = new ValueChangeEventTracker();	83	ValueChangeEventTracker listener = new ValueChangeEventTracker();
87	observable.addValueChangeListener(listener);	84	observable.addValueChangeListener(listener);
88	assertNull(observable.getValue());	85	assertNull(observable.getValue());
Lines 110-118 Link Here
110	}	107	}
111		108
112	public void testDispose() throws Exception {	109	public void testDispose() throws Exception {
113	SelectionProviderSingleSelectionObservableValue observable = new SelectionProviderSingleSelectionObservableValue(	110	IObservableValue observable = ViewersObservables
114	SWTObservables.getRealm(Display.getDefault()),	111	.observeSingleSelection(selectionProvider);
115	selectionProvider);
116	ValueChangeEventTracker listener = new ValueChangeEventTracker();	112	ValueChangeEventTracker listener = new ValueChangeEventTracker();
117	observable.addValueChangeListener(listener);	113	observable.addValueChangeListener(listener);
118		114

Lines 11-21 Link Here

(-)src/org/eclipse/jface/tests/databinding/viewers/ViewersObservablesTest.java (-4 / +10 lines)
11		11
12	package org.eclipse.jface.tests.databinding.viewers;	12	package org.eclipse.jface.tests.databinding.viewers;
13		13
		14	import org.eclipse.core.databinding.observable.IDecoratingObservable;
14	import org.eclipse.core.databinding.observable.Realm;	15	import org.eclipse.core.databinding.observable.Realm;
15	import org.eclipse.core.databinding.observable.value.IObservableValue;	16	import org.eclipse.core.databinding.property.IPropertyObservable;
16	import org.eclipse.jface.databinding.swt.SWTObservables;	17	import org.eclipse.jface.databinding.swt.SWTObservables;
		18	import org.eclipse.jface.databinding.viewers.IViewerObservableValue;
17	import org.eclipse.jface.databinding.viewers.ViewersObservables;	19	import org.eclipse.jface.databinding.viewers.ViewersObservables;
18	import org.eclipse.jface.internal.databinding.viewers.ViewerInputObservableValue;	20	import org.eclipse.jface.internal.databinding.viewers.ViewerInputProperty;
19	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	21	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
20	import org.eclipse.jface.viewers.TableViewer;	22	import org.eclipse.jface.viewers.TableViewer;
21	import org.eclipse.swt.SWT;	23	import org.eclipse.swt.SWT;
Lines 48-54 Link Here
48	}	50	}
49		51
50	public void testObserveInput_InstanceOfViewerInputObservableValue() {	52	public void testObserveInput_InstanceOfViewerInputObservableValue() {
51	IObservableValue observable = ViewersObservables.observeInput(viewer);	53	IViewerObservableValue observable = (IViewerObservableValue) ViewersObservables
52	assertTrue(observable instanceof ViewerInputObservableValue);	54	.observeInput(viewer);
		55	assertTrue(observable.getViewer() == viewer);
		56	IPropertyObservable propertyObservable = (IPropertyObservable) ((IDecoratingObservable) observable)
		57	.getDecorated();
		58	assertTrue(propertyObservable.getProperty() instanceof ViewerInputProperty);
53	}	59	}
54	}	60	}

Removed Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/ViewerInputObservableValue.java (-73 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 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 (bug 206839)
10	*******************************************************************************/
11
12	package org.eclipse.jface.internal.databinding.viewers;
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.jface.util.Util;
18	import org.eclipse.jface.viewers.Viewer;
19
20	/**
21	* Observes the input of a <code>Viewer</code>.
22	* <p>
23	* This observer is blind to changes in the viewer's input unless its
24	* {@link #setValue(Object)} method is called directly.
25	*
26	* @since 1.2
27	*/
28	public class ViewerInputObservableValue extends AbstractObservableValue {
29
30	private final Viewer viewer;
31
32	/**
33	* Constructs a new instance associated with the provided <code>viewer</code>.
34	*
35	* @param realm
36	* @param viewer
37	*/
38	public ViewerInputObservableValue( Realm realm, Viewer viewer ) {
39	super( realm );
40	if ( viewer == null ) {
41	throw new IllegalArgumentException( "The 'viewer' parameter is null." ); //$NON-NLS-1$
42	}
43
44	this.viewer = viewer;
45	}
46
47	/**
48	* Sets the input to the provided <code>value</code>. Value change events are
49	* fired after input is set in the viewer.
50	*
51	* @param value object to set as input
52	*/
53	protected void doSetValue( final Object value ) {
54	Object oldValue = doGetValue();
55	viewer.setInput( value );
56	if ( !Util.equals( oldValue, value ) ) {
57	fireValueChange( Diffs.createValueDiff( oldValue, value ) );
58	}
59	}
60
61	/**
62	* Retrieves the current input.
63	*
64	* @return the current input
65	*/
66	protected Object doGetValue() {
67	return viewer.getInput();
68	}
69
70	public Object getValueType() {
71	return null;
72	}
73	}

Removed Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/ViewerSingleSelectionObservableValue.java (-45 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 2008 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	* Brad Reynolds - bug 137877
11	* Brad Reynolds - bug 164653
12	* Brad Reynolds - bug 147515
13	* Ashley Cambrell - bug 198906
14	*******************************************************************************/
15
16	package org.eclipse.jface.internal.databinding.viewers;
17
18	import org.eclipse.core.databinding.observable.Realm;
19	import org.eclipse.jface.databinding.viewers.IViewerObservableValue;
20	import org.eclipse.jface.viewers.Viewer;
21
22	/**
23	* Observes single selection of a <code>Viewer</code>.
24	*
25	* @since 1.2
26	*/
27	public class ViewerSingleSelectionObservableValue extends
28	SelectionProviderSingleSelectionObservableValue implements
29	IViewerObservableValue {
30
31	private Viewer viewer;
32
33	/**
34	* @param realm
35	* @param viewer
36	*/
37	public ViewerSingleSelectionObservableValue(Realm realm, Viewer viewer) {
38	super(realm, viewer);
39	this.viewer = viewer;
40	}
41
42	public Viewer getViewer() {
43	return viewer;
44	}
45	}

Removed Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/CheckboxViewerCheckedElementsObservableSet.java (-90 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 (bug 124684)
10	******************************************************************************/
11
12	package org.eclipse.jface.internal.databinding.viewers;
13
14	import java.util.Arrays;
15	import java.util.Set;
16
17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.jface.databinding.viewers.IViewerObservableSet;
19	import org.eclipse.jface.viewers.CheckboxTableViewer;
20	import org.eclipse.jface.viewers.CheckboxTreeViewer;
21	import org.eclipse.jface.viewers.StructuredViewer;
22	import org.eclipse.jface.viewers.Viewer;
23
24	/**
25	* An observable set that tracks the checked elements in a CheckboxTableViewer
26	* or CheckboxTreeViewer
27	*
28	* @since 1.2
29	*/
30	public class CheckboxViewerCheckedElementsObservableSet extends
31	CheckableCheckedElementsObservableSet implements IViewerObservableSet {
32	private StructuredViewer viewer;
33
34	/**
35	* Constructs a new instance on the given realm and checkable.
36	*
37	* @param realm
38	* the observable's realm
39	* @param viewer
40	* the CheckboxTableViewer viewer to track.
41	* @param elementType
42	* type of elements in the set
43	*/
44	public CheckboxViewerCheckedElementsObservableSet(Realm realm,
45	CheckboxTableViewer viewer, Object elementType) {
46	super(realm, viewer, elementType, createElementSet(viewer));
47	this.viewer = viewer;
48	}
49
50	/**
51	* Constructs a new instance on the given realm and checkable.
52	*
53	* @param realm
54	* the observable's realm
55	* @param viewer
56	* the CheckboxTreeViewer viewer to track.
57	* @param elementType
58	* type of elements in the set
59	*/
60	public CheckboxViewerCheckedElementsObservableSet(Realm realm,
61	CheckboxTreeViewer viewer, Object elementType) {
62	super(realm, viewer, elementType, createElementSet(viewer));
63	this.viewer = viewer;
64	}
65
66	Set createDiffSet() {
67	return ViewerElementSet.withComparer(viewer.getComparer());
68	}
69
70	private static Set createElementSet(CheckboxTableViewer viewer) {
71	Set set = ViewerElementSet.withComparer(viewer.getComparer());
72	set.addAll(Arrays.asList(viewer.getCheckedElements()));
73	return set;
74	}
75
76	private static Set createElementSet(CheckboxTreeViewer viewer) {
77	Set set = ViewerElementSet.withComparer(viewer.getComparer());
78	set.addAll(Arrays.asList(viewer.getCheckedElements()));
79	return set;
80	}
81
82	public Viewer getViewer() {
83	return viewer;
84	}
85
86	public synchronized void dispose() {
87	viewer = null;
88	super.dispose();
89	}
90	}

Removed Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/ViewerFiltersObservableSet.java (-174 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 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 (bug 239302)
10	*******************************************************************************/
11
12	package org.eclipse.jface.internal.databinding.viewers;
13
14	import java.util.Arrays;
15	import java.util.Collection;
16	import java.util.Collections;
17	import java.util.HashSet;
18	import java.util.Iterator;
19	import java.util.Set;
20
21	import org.eclipse.core.databinding.observable.Diffs;
22	import org.eclipse.core.databinding.observable.Realm;
23	import org.eclipse.core.databinding.observable.set.ObservableSet;
24	import org.eclipse.jface.databinding.viewers.IViewerObservableSet;
25	import org.eclipse.jface.viewers.StructuredViewer;
26	import org.eclipse.jface.viewers.Viewer;
27	import org.eclipse.jface.viewers.ViewerFilter;
28
29	/**
30	* An observable set that tracks the filters of the given viewer. Note that this
31	* set will not track changes that are made using direct API on StructuredViewer
32	* (by calling
33	* {@link StructuredViewer#addFilter(org.eclipse.jface.viewers.ViewerFilter)
34	* addFilter()},
35	* {@link StructuredViewer#removeFilter(org.eclipse.jface.viewers.ViewerFilter)
36	* removeFilter()}, or
37	* {@link StructuredViewer#setFilters(org.eclipse.jface.viewers.ViewerFilter[])
38	* setFilters()}) -- it is assumed that filters are only changed through the
39	* set.
40	*
41	* @since 1.2
42	*/
43	public class ViewerFiltersObservableSet extends ObservableSet implements
44	IViewerObservableSet {
45
46	private StructuredViewer viewer;
47
48	/**
49	* @param realm
50	* @param viewer
51	*/
52	public ViewerFiltersObservableSet(Realm realm, StructuredViewer viewer) {
53	super(realm, new HashSet(Arrays.asList(viewer.getFilters())),
54	ViewerFilter.class);
55	this.viewer = viewer;
56	}
57
58	public Viewer getViewer() {
59	return viewer;
60	}
61
62	private void replaceFilters() {
63	viewer.getControl().setRedraw(false);
64	try {
65	viewer.setFilters((ViewerFilter[]) wrappedSet
66	.toArray(new ViewerFilter[wrappedSet.size()]));
67	} finally {
68	viewer.getControl().setRedraw(true);
69	}
70	}
71
72	private void addFilter(ViewerFilter filter) {
73	viewer.getControl().setRedraw(false);
74	try {
75	viewer.addFilter(filter);
76	} finally {
77	viewer.getControl().setRedraw(true);
78	}
79	}
80
81	private void removeFilter(ViewerFilter filter) {
82	viewer.getControl().setRedraw(false);
83	try {
84	viewer.removeFilter(filter);
85	} finally {
86	viewer.getControl().setRedraw(true);
87	}
88	}
89
90	public boolean add(Object element) {
91	checkRealm();
92	boolean added = wrappedSet.add(element);
93	if (added) {
94	addFilter((ViewerFilter) element);
95	fireSetChange(Diffs.createSetDiff(Collections.singleton(element),
96	Collections.EMPTY_SET));
97	}
98	return added;
99	}
100
101	public boolean addAll(Collection c) {
102	getterCalled();
103	Set additions = new HashSet();
104	Iterator it = c.iterator();
105	while (it.hasNext()) {
106	Object element = it.next();
107	if (wrappedSet.add(element)) {
108	additions.add(element);
109	}
110	}
111	if (additions.size() > 0) {
112	replaceFilters();
113	fireSetChange(Diffs.createSetDiff(additions, Collections.EMPTY_SET));
114	return true;
115	}
116	return false;
117	}
118
119	public void clear() {
120	getterCalled();
121	Set removes = new HashSet(wrappedSet);
122	wrappedSet.clear();
123	replaceFilters();
124	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
125	}
126
127	public boolean remove(Object o) {
128	getterCalled();
129	boolean removed = wrappedSet.remove(o);
130	if (removed) {
131	removeFilter((ViewerFilter) o);
132	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
133	Collections.singleton(o)));
134	}
135	return removed;
136	}
137
138	public boolean removeAll(Collection c) {
139	getterCalled();
140	Set removes = new HashSet();
141	Iterator it = c.iterator();
142	while (it.hasNext()) {
143	Object element = it.next();
144	if (wrappedSet.remove(element)) {
145	removes.add(element);
146	}
147	}
148	if (removes.size() > 0) {
149	replaceFilters();
150	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
151	return true;
152	}
153	return false;
154	}
155
156	public boolean retainAll(Collection c) {
157	getterCalled();
158	Set removes = new HashSet();
159	Iterator it = wrappedSet.iterator();
160	while (it.hasNext()) {
161	Object element = it.next();
162	if (!c.contains(element)) {
163	it.remove();
164	removes.add(element);
165	}
166	}
167	if (removes.size() > 0) {
168	replaceFilters();
169	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
170	return true;
171	}
172	return false;
173	}
174	}

Removed Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/SelectionProviderMultipleSelectionObservableList.java (-111 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Peter Centgraf 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	* Peter Centgraf - initial API and implementation, bug 124683
10	* Boris Bokowski, IBM Corporation - initial API and implementation
11	*******************************************************************************/
12	package org.eclipse.jface.internal.databinding.viewers;
13
14	import java.util.ArrayList;
15	import java.util.Collections;
16	import java.util.List;
17
18	import org.eclipse.core.databinding.observable.Diffs;
19	import org.eclipse.core.databinding.observable.Realm;
20	import org.eclipse.core.databinding.observable.list.ListDiff;
21	import org.eclipse.core.databinding.observable.list.WritableList;
22	import org.eclipse.jface.viewers.ISelection;
23	import org.eclipse.jface.viewers.ISelectionChangedListener;
24	import org.eclipse.jface.viewers.ISelectionProvider;
25	import org.eclipse.jface.viewers.IStructuredSelection;
26	import org.eclipse.jface.viewers.SelectionChangedEvent;
27	import org.eclipse.jface.viewers.StructuredSelection;
28
29	/**
30	* Observes multiple-selection of an {@link ISelectionProvider}.
31	*
32	* @since 1.2
33	*/
34	public class SelectionProviderMultipleSelectionObservableList extends
35	WritableList {
36
37	protected ISelectionProvider selectionProvider;
38	protected boolean handlingSelection;
39	protected boolean updating;
40	protected SelectionListener selectionListener = new SelectionListener();
41
42	class SelectionListener implements ISelectionChangedListener {
43	public void selectionChanged(SelectionChangedEvent event) {
44	if (updating) {
45	return;
46	}
47	handlingSelection = true;
48	try {
49	updateWrappedList(new ArrayList(getSelectionList(event.getSelection())));
50	} finally {
51	handlingSelection = false;
52	}
53	}
54	}
55
56	/**
57	* Create a new observable list based on the current selection of the given
58	* selection provider. Assumes that the selection provider provides
59	* structured selections.
60	*
61	* @param realm
62	* @param selectionProvider
63	* @param elementType
64	*/
65	public SelectionProviderMultipleSelectionObservableList(Realm realm,
66	ISelectionProvider selectionProvider, Object elementType) {
67	super(realm, new ArrayList(getSelectionList(selectionProvider)), elementType);
68	this.selectionProvider = selectionProvider;
69	selectionProvider.addSelectionChangedListener(selectionListener);
70	}
71
72	protected void fireListChange(ListDiff diff) {
73	if (handlingSelection) {
74	super.fireListChange(diff);
75	} else {
76	// this is a bit of a hack - we are changing the diff to match the order
77	// of elements returned by the selection provider after we've set the
78	// selection.
79	updating = true;
80	try {
81	List oldList = getSelectionList(selectionProvider);
82	selectionProvider
83	.setSelection(new StructuredSelection(wrappedList));
84	wrappedList = new ArrayList(getSelectionList(selectionProvider));
85	super.fireListChange(Diffs.computeListDiff(oldList, wrappedList));
86	} finally {
87	updating = false;
88	}
89	}
90	}
91
92	protected static List getSelectionList(ISelectionProvider selectionProvider) {
93	if (selectionProvider == null) {
94	throw new IllegalArgumentException();
95	}
96	return getSelectionList(selectionProvider.getSelection());
97	}
98
99	protected static List getSelectionList(ISelection sel) {
100	if (sel instanceof IStructuredSelection) {
101	return ((IStructuredSelection) sel).toList();
102	}
103	return Collections.EMPTY_LIST;
104	}
105
106	public synchronized void dispose() {
107	selectionProvider.removeSelectionChangedListener(selectionListener);
108	selectionProvider = null;
109	super.dispose();
110	}
111	}

Lines 12-29 Link Here

(-)src/org/eclipse/jface/databinding/viewers/ViewersObservables.java (-40 / +90 lines)
12		12
13	package org.eclipse.jface.databinding.viewers;	13	package org.eclipse.jface.databinding.viewers;
14		14
		15	import org.eclipse.core.databinding.observable.Realm;
15	import org.eclipse.core.databinding.observable.list.IObservableList;	16	import org.eclipse.core.databinding.observable.list.IObservableList;
16	import org.eclipse.core.databinding.observable.set.IObservableSet;	17	import org.eclipse.core.databinding.observable.set.IObservableSet;
17	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
		19	import org.eclipse.core.databinding.property.IListProperty;
		20	import org.eclipse.core.databinding.property.ISetProperty;
		21	import org.eclipse.core.databinding.property.IValueProperty;
		22	import org.eclipse.core.databinding.property.PropertyObservables;
18	import org.eclipse.jface.databinding.swt.SWTObservables;	23	import org.eclipse.jface.databinding.swt.SWTObservables;
19	import org.eclipse.jface.internal.databinding.viewers.CheckableCheckedElementsObservableSet;	24	import org.eclipse.jface.internal.databinding.viewers.ViewerObservableListDecorator;
20	import org.eclipse.jface.internal.databinding.viewers.CheckboxViewerCheckedElementsObservableSet;	25	import org.eclipse.jface.internal.databinding.viewers.ViewerObservableSetDecorator;
21	import org.eclipse.jface.internal.databinding.viewers.SelectionProviderMultipleSelectionObservableList;	26	import org.eclipse.jface.internal.databinding.viewers.ViewerObservableValueDecorator;
22	import org.eclipse.jface.internal.databinding.viewers.SelectionProviderSingleSelectionObservableValue;
23	import org.eclipse.jface.internal.databinding.viewers.ViewerFiltersObservableSet;
24	import org.eclipse.jface.internal.databinding.viewers.ViewerInputObservableValue;
25	import org.eclipse.jface.internal.databinding.viewers.ViewerMultipleSelectionObservableList;
26	import org.eclipse.jface.internal.databinding.viewers.ViewerSingleSelectionObservableValue;
27	import org.eclipse.jface.viewers.CheckboxTableViewer;	27	import org.eclipse.jface.viewers.CheckboxTableViewer;
28	import org.eclipse.jface.viewers.CheckboxTreeViewer;	28	import org.eclipse.jface.viewers.CheckboxTreeViewer;
29	import org.eclipse.jface.viewers.ICheckable;	29	import org.eclipse.jface.viewers.ICheckable;
Lines 39-44 Link Here
39	* @since 1.1	39	* @since 1.1
40	*/	40	*/
41	public class ViewersObservables {	41	public class ViewersObservables {
		42	private static Realm getDefaultRealm() {
		43	return SWTObservables.getRealm(Display.getDefault());
		44	}
		45
		46	private static Realm getRealm(Viewer viewer) {
		47	return SWTObservables.getRealm(viewer.getControl().getDisplay());
		48	}
		49
		50	private static void checkNull(Object obj) {
		51	if (obj == null)
		52	throw new IllegalArgumentException();
		53	}
		54
		55	private static IObservableValue observeProperty(Object source,
		56	IValueProperty property) {
		57	checkNull(source);
		58	if (source instanceof Viewer) {
		59	return observeViewerProperty((Viewer) source, property);
		60	}
		61	return PropertyObservables.observeValue(getDefaultRealm(), source,
		62	property);
		63	}
		64
		65	private static IViewerObservableValue observeViewerProperty(Viewer viewer,
		66	IValueProperty property) {
		67	checkNull(viewer);
		68	return new ViewerObservableValueDecorator(PropertyObservables
		69	.observeValue(getRealm(viewer), viewer, property), viewer);
		70	}
		71
		72	private static IObservableSet observeProperty(Object source,
		73	ISetProperty property) {
		74	checkNull(source);
		75	if (source instanceof Viewer) {
		76	return observeViewerProperty((Viewer) source, property);
		77	}
		78	return PropertyObservables.observeSet(getDefaultRealm(), source,
		79	property);
		80	}
		81
		82	private static IViewerObservableSet observeViewerProperty(Viewer viewer,
		83	ISetProperty property) {
		84	checkNull(viewer);
		85	return new ViewerObservableSetDecorator(PropertyObservables.observeSet(
		86	getRealm(viewer), viewer, property), viewer);
		87	}
		88
		89	private static IObservableList observeProperty(Object source,
		90	IListProperty property) {
		91	checkNull(source);
		92	if (source instanceof Viewer) {
		93	return observeViewerProperty((Viewer) source, property);
		94	}
		95	Realm realm = getDefaultRealm();
		96	return PropertyObservables.observeList(realm, source, property);
		97	}
		98
		99	private static IViewerObservableList observeViewerProperty(Viewer viewer,
		100	IListProperty property) {
		101	checkNull(viewer);
		102	Realm realm = getRealm(viewer);
		103	return new ViewerObservableListDecorator(PropertyObservables
		104	.observeList(realm, viewer, property), viewer);
		105	}
42		106
43	/**	107	/**
44	* Returns an observable value that tracks the current selection of the	108	* Returns an observable value that tracks the current selection of the
Lines 53-64 Link Here
53	*/	117	*/
54	public static IObservableValue observeSingleSelection(	118	public static IObservableValue observeSingleSelection(
55	ISelectionProvider selectionProvider) {	119	ISelectionProvider selectionProvider) {
56	if (selectionProvider instanceof Viewer) {	120	return observeProperty(selectionProvider, SelectionProviderProperties
57	return observeSingleSelection((Viewer) selectionProvider);	121	.singleSelection());
58	}
59	return new SelectionProviderSingleSelectionObservableValue(
60	SWTObservables.getRealm(Display.getDefault()),
61	selectionProvider);
62	}	122	}
63		123
64	/**	124	/**
Lines 82-93 Link Here
82	*/	142	*/
83	public static IObservableList observeMultiSelection(	143	public static IObservableList observeMultiSelection(
84	ISelectionProvider selectionProvider) {	144	ISelectionProvider selectionProvider) {
85	if (selectionProvider instanceof Viewer) {	145	return observeProperty(selectionProvider, SelectionProviderProperties
86	return observeMultiSelection((Viewer) selectionProvider);	146	.multipleSelection());
87	}
88	return new SelectionProviderMultipleSelectionObservableList(
89	SWTObservables.getRealm(Display.getDefault()),
90	selectionProvider, Object.class);
91	}	147	}
92		148
93	/**	149	/**
Lines 104-112 Link Here
104	* @since 1.2	160	* @since 1.2
105	*/	161	*/
106	public static IViewerObservableValue observeSingleSelection(Viewer viewer) {	162	public static IViewerObservableValue observeSingleSelection(Viewer viewer) {
107	return new ViewerSingleSelectionObservableValue(	163	return observeViewerProperty(viewer, SelectionProviderProperties
108	SWTObservables.getRealm(Display.getDefault()),	164	.singleSelection());
109	viewer);
110	}	165	}
111		166
112	/**	167	/**
Lines 128-138 Link Here
128	*	183	*
129	* @since 1.2	184	* @since 1.2
130	*/	185	*/
131	public static IViewerObservableList observeMultiSelection(	186	public static IViewerObservableList observeMultiSelection(Viewer viewer) {
132	Viewer viewer) {	187	return observeViewerProperty(viewer, SelectionProviderProperties
133	return new ViewerMultipleSelectionObservableList(	188	.multipleSelection());
134	SWTObservables.getRealm(Display.getDefault()),
135	viewer, Object.class);
136	}	189	}
137		190
138	/**	191	/**
Lines 147-154 Link Here
147	* @since 1.2	200	* @since 1.2
148	*/	201	*/
149	public static IObservableValue observeInput(Viewer viewer) {	202	public static IObservableValue observeInput(Viewer viewer) {
150	return new ViewerInputObservableValue(SWTObservables.getRealm(viewer	203	return observeViewerProperty(viewer, ViewerProperties.input());
151	.getControl().getDisplay()), viewer);
152	}	204	}
153		205
154	/**	206	/**
Lines 173-180 Link Here
173	return observeCheckedElements((CheckboxTreeViewer) checkable,	225	return observeCheckedElements((CheckboxTreeViewer) checkable,
174	elementType);	226	elementType);
175	}	227	}
176	return new CheckableCheckedElementsObservableSet(SWTObservables	228	return observeProperty(checkable, CheckableProperties
177	.getRealm(Display.getDefault()), checkable, elementType);	229	.checkedElements(elementType));
178	}	230	}
179		231
180	/**	232	/**
Lines 192-200 Link Here
192	*/	244	*/
193	public static IViewerObservableSet observeCheckedElements(	245	public static IViewerObservableSet observeCheckedElements(
194	CheckboxTableViewer viewer, Object elementType) {	246	CheckboxTableViewer viewer, Object elementType) {
195	return new CheckboxViewerCheckedElementsObservableSet(SWTObservables	247	return observeViewerProperty(viewer, CheckboxTableViewerProperties
196	.getRealm(viewer.getControl().getDisplay()), viewer,	248	.checkedElements(elementType));
197	elementType);
198	}	249	}
199		250
200	/**	251	/**
Lines 212-220 Link Here
212	*/	263	*/
213	public static IViewerObservableSet observeCheckedElements(	264	public static IViewerObservableSet observeCheckedElements(
214	CheckboxTreeViewer viewer, Object elementType) {	265	CheckboxTreeViewer viewer, Object elementType) {
215	return new CheckboxViewerCheckedElementsObservableSet(SWTObservables	266	return observeViewerProperty(viewer, CheckboxTreeViewerProperties
216	.getRealm(viewer.getControl().getDisplay()), viewer,	267	.checkedElements(elementType));
217	elementType);
218	}	268	}
219		269
220	/**	270	/**
Lines 235-241 Link Here
235	* @since 1.3	285	* @since 1.3
236	*/	286	*/
237	public static IViewerObservableSet observeFilters(StructuredViewer viewer) {	287	public static IViewerObservableSet observeFilters(StructuredViewer viewer) {
238	return new ViewerFiltersObservableSet(SWTObservables.getRealm(viewer	288	return observeViewerProperty(viewer, StructuredViewerProperties
239	.getControl().getDisplay()), viewer);	289	.filters());
240	}	290	}
241	}	291	}

Added Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/SelectionProviderMultipleSelectionProperty.java (+76 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.internal.databinding.viewers;
13
14	import java.util.Collections;
15	import java.util.HashMap;
16	import java.util.List;
17	import java.util.Map;
18
19	import org.eclipse.core.databinding.observable.Diffs;
20	import org.eclipse.core.databinding.property.BasicListProperty;
21	import org.eclipse.jface.util.Util;
22	import org.eclipse.jface.viewers.ISelection;
23	import org.eclipse.jface.viewers.ISelectionChangedListener;
24	import org.eclipse.jface.viewers.ISelectionProvider;
25	import org.eclipse.jface.viewers.IStructuredSelection;
26	import org.eclipse.jface.viewers.SelectionChangedEvent;
27	import org.eclipse.jface.viewers.StructuredSelection;
28
29	/**
30	* @since 3.3
31	*
32	*/
33	public class SelectionProviderMultipleSelectionProperty extends BasicListProperty
34	implements ISelectionChangedListener {
35	private Map sourceToList = new HashMap();
36
37	protected void addListenerTo(Object source) {
38	((ISelectionProvider) source).addSelectionChangedListener(this);
39	sourceToList.put(source, getList(source));
40	}
41
42	protected void removeListenerFrom(Object source) {
43	((ISelectionProvider) source).removeSelectionChangedListener(this);
44	sourceToList.remove(source);
45	}
46
47	public void selectionChanged(SelectionChangedEvent event) {
48	Object source = event.getSelectionProvider();
49	if (!isUpdating(source)) {
50	List oldList = (List) sourceToList.get(source);
51	List newList = getList(source);
52	sourceToList.put(source, newList);
53	if (!Util.equals(oldList, newList)) {
54	fireListChange(source, Diffs.computeListDiff(oldList, newList));
55	}
56	}
57	}
58
59	public List getList(Object source) {
60	ISelection selection = ((ISelectionProvider) source).getSelection();
61	if (selection instanceof IStructuredSelection) {
62	return ((IStructuredSelection) selection).toList();
63	}
64	return Collections.EMPTY_LIST;
65	}
66
67	protected void doSetList(Object source, List list) {
68	((ISelectionProvider) source)
69	.setSelection(new StructuredSelection(list));
70	sourceToList.put(source, list);
71	}
72
73	public Object getElementType() {
74	return Object.class;
75	}
76	}