bundles/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/viewers/ObservableCollectionContentProvider.java - e4/org.eclipse.e4.databinding - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008, 2009 Matthew Hall and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     Matthew Hall - initial API and implementation (bug 215531)
  *     Matthew Hall - bugs 226765, 222991, 238296, 263956, 226292, 265051,
  *                    266038
  ******************************************************************************/

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

 import org.eclipse.core.databinding.observable.IObservable;
 import org.eclipse.core.databinding.observable.IObservableCollection;
 import org.eclipse.core.databinding.observable.Observables;
 import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
 import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
 import org.eclipse.core.databinding.observable.set.IObservableSet;
 import org.eclipse.core.databinding.observable.value.IObservableValue;
 import org.eclipse.core.databinding.observable.value.WritableValue;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.jface.databinding.swt.SWTObservables;
 import org.eclipse.jface.databinding.viewers.IViewerUpdater;
 import org.eclipse.jface.viewers.AbstractListViewer;
 import org.eclipse.jface.viewers.AbstractTableViewer;
 import org.eclipse.jface.viewers.CheckboxTableViewer;
 import org.eclipse.jface.viewers.IElementComparer;
 import org.eclipse.jface.viewers.IStructuredContentProvider;
 import org.eclipse.jface.viewers.StructuredViewer;
 import org.eclipse.jface.viewers.Viewer;
 import org.eclipse.swt.widgets.Display;

 /**
  * NON-API - Abstract base class for content providers where the viewer input is
  * expected to be an {@link IObservableCollection}.
  *
  * @since 1.2
  */
 public abstract class ObservableCollectionContentProvider implements
 		IStructuredContentProvider {
 	private Display display;

 	private IObservableValue viewerObservable;

 	/**
 	 * Element comparer used by the viewer (may be null).
 	 */
 	protected IElementComparer comparer;

 	private IObservableFactory elementSetFactory;

 	private final IViewerUpdater explicitViewerUpdater;

 	/**
 	 * Interface for sending updates to the viewer.
 	 */
 	protected IViewerUpdater viewerUpdater;

 	/**
 	 * Observable set of all elements known to the content provider. Subclasses
 	 * must add new elements to this set <b>before</b> adding them to the
 	 * viewer, and must remove old elements from this set <b>after</b> removing
 	 * them from the viewer.
 	 */
 	protected IObservableSet knownElements;
 	private IObservableSet unmodifiableKnownElements;

 	/**
 	 * Observable set of known elements which have been realized in the viewer.
 	 * Subclasses must add new elements to this set <b>after</b> adding them to
 	 * the viewer, and must remove old elements from this set <b>before</b>
 	 * removing them from the viewer.
 	 */
 	protected IObservableSet realizedElements;
 	private IObservableSet unmodifiableRealizedElements;

 	private IObservableCollection observableCollection;

 	/**
 	 * Constructs an ObservableCollectionContentProvider
 	 *
 	 * @param explicitViewerUpdater
 	 */
 	protected ObservableCollectionContentProvider(
 			IViewerUpdater explicitViewerUpdater) {
 		this.explicitViewerUpdater = explicitViewerUpdater;

 		display = Display.getDefault();
 		viewerObservable = new WritableValue(SWTObservables.getRealm(display));
 		viewerUpdater = null;

 		elementSetFactory = new IObservableFactory() {
 			public IObservable createObservable(Object target) {
 				IElementComparer comparer = null;
 				if (target instanceof StructuredViewer)
 					comparer = ((StructuredViewer) target).getComparer();
 				return ObservableViewerElementSet.withComparer(SWTObservables
 						.getRealm(display), null, comparer);
 			}
 		};
 		knownElements = MasterDetailObservables.detailSet(viewerObservable,
 				elementSetFactory, null);
 		unmodifiableKnownElements = Observables
 				.unmodifiableObservableSet(knownElements);

 		observableCollection = null;
 	}

 	public Object[] getElements(Object inputElement) {
 		if (observableCollection == null)
 			return new Object[0];

 		knownElements.addAll(observableCollection);
 		if (realizedElements != null) {
 			if (!realizedElements.equals(knownElements)) {
 				asyncUpdateRealizedElements();
 			}
 		}

 		return observableCollection.toArray();
 	}

 	private void asyncUpdateRealizedElements() {
 		if (realizedElements == null)
 			return;
 		display.asyncExec(new Runnable() {
 			public void run() {
 				if (realizedElements != null) {
 					realizedElements.addAll(knownElements);
 				}
 			}
 		});
 	}

 	public void dispose() {
 		if (observableCollection != null)
 			removeCollectionChangeListener(observableCollection);

 		if (viewerObservable != null) {
 			viewerObservable.dispose();
 			viewerObservable = null;
 		}
 		viewerUpdater = null;
 		knownElements = null;
 		unmodifiableKnownElements = null;
 		realizedElements = null;
 		unmodifiableRealizedElements = null;
 		display = null;
 	}

 	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 		setViewer(viewer);
 		setInput(newInput);
 	}

 	private void setViewer(Viewer viewer) {
 		viewerUpdater = createViewerUpdater(viewer);
 		comparer = getElementComparer(viewer);
 		viewerObservable.setValue(viewer); // (clears knownElements)
 	}

 	private static IElementComparer getElementComparer(Viewer viewer) {
 		if (viewer instanceof StructuredViewer)
 			return ((StructuredViewer) viewer).getComparer();
 		return null;
 	}

 	IViewerUpdater createViewerUpdater(Viewer viewer) {
 		if (explicitViewerUpdater != null)
 			return explicitViewerUpdater;
 		if (viewer instanceof AbstractListViewer)
 			return new ListViewerUpdater((AbstractListViewer) viewer);
 		if (viewer instanceof CheckboxTableViewer)
 			return new CheckboxTableViewerUpdater((CheckboxTableViewer) viewer);
 		if (viewer instanceof AbstractTableViewer)
 			return new TableViewerUpdater((AbstractTableViewer) viewer);
 		throw new IllegalArgumentException(
 				"This content provider only works with AbstractTableViewer or AbstractListViewer"); //$NON-NLS-1$
 	}

 	void setInput(Object input) {
 		if (observableCollection != null) {
 			removeCollectionChangeListener(observableCollection);
 			observableCollection = null;
 		}

 		knownElements.clear();
 		if (realizedElements != null)
 			realizedElements.clear();

 		if (input != null) {
 			checkInput(input);
 			Assert.isTrue(input instanceof IObservableCollection,
 					"Input must be an IObservableCollection"); //$NON-NLS-1$
 			observableCollection = (IObservableCollection) input;
 			addCollectionChangeListener(observableCollection);
 		}
 	}

 	/**
 	 * Throws an exception if the input is not the correct type.
 	 *
 	 * @param input
 	 *            the input to check
 	 */
 	protected abstract void checkInput(Object input);

 	/**
 	 * Register for change event notification from the given collection.
 	 *
 	 * @param collection
 	 *            observable collection to listen to
 	 */
 	protected abstract void addCollectionChangeListener(
 			IObservableCollection collection);

 	/**
 	 * Deregisters from change events notification on the given collection.
 	 *
 	 * @param collection
 	 *            observable collection to stop listening to
 	 */
 	protected abstract void removeCollectionChangeListener(
 			IObservableCollection collection);

 	/**
 	 * Returns whether the viewer is disposed. Collection change listeners in
 	 * subclasses should verify that the viewer is not disposed before sending
 	 * any updates to the {@link ViewerUpdater viewer updater}.
 	 *
 	 * @return whether the viewer is disposed.
 	 */
 	protected final boolean isViewerDisposed() {
 		Viewer viewer = (Viewer) viewerObservable.getValue();
 		return viewer == null || viewer.getControl() == null
 				|| viewer.getControl().isDisposed();
 	}

 	/**
 	 * Returns the set of elements known to this content provider. Label
 	 * providers may track this set if they need to be notified about additions
 	 * before the viewer sees the added element, and notified about removals
 	 * after the element was removed from the viewer. This is intended for use
 	 * by label providers, as it will always return the items that need labels.
 	 *
 	 * @return unmodifiable observable set of items that will need labels
 	 */
 	public IObservableSet getKnownElements() {
 		return unmodifiableKnownElements;
 	}

 	/**
 	 * Returns the set of known elements which have been realized in the viewer.
 	 * Clients may track this set in order to perform custom actions on elements
 	 * while they are known to be present in the viewer.
 	 *
 	 * @return the set of known elements which have been realized in the viewer.
 	 * @since 1.3
 	 */
 	public IObservableSet getRealizedElements() {
 		if (realizedElements == null) {
 			realizedElements = MasterDetailObservables.detailSet(
 					viewerObservable, elementSetFactory, null);
 			unmodifiableRealizedElements = Observables
 					.unmodifiableObservableSet(realizedElements);
 			asyncUpdateRealizedElements();
 		}
 		return unmodifiableRealizedElements;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2008, 2009 Matthew Hall and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Matthew Hall - initial API and implementation (bug 215531)
	* Matthew Hall - bugs 226765, 222991, 238296, 263956, 226292, 265051,
	* 266038
	******************************************************************************/

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

	import org.eclipse.core.databinding.observable.IObservable;
	import org.eclipse.core.databinding.observable.IObservableCollection;
	import org.eclipse.core.databinding.observable.Observables;
	import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
	import org.eclipse.core.databinding.observable.set.IObservableSet;
	import org.eclipse.core.databinding.observable.value.IObservableValue;
	import org.eclipse.core.databinding.observable.value.WritableValue;
	import org.eclipse.core.runtime.Assert;
	import org.eclipse.jface.databinding.swt.SWTObservables;
	import org.eclipse.jface.databinding.viewers.IViewerUpdater;
	import org.eclipse.jface.viewers.AbstractListViewer;
	import org.eclipse.jface.viewers.AbstractTableViewer;
	import org.eclipse.jface.viewers.CheckboxTableViewer;
	import org.eclipse.jface.viewers.IElementComparer;
	import org.eclipse.jface.viewers.IStructuredContentProvider;
	import org.eclipse.jface.viewers.StructuredViewer;
	import org.eclipse.jface.viewers.Viewer;
	import org.eclipse.swt.widgets.Display;

	/**
	* NON-API - Abstract base class for content providers where the viewer input is
	* expected to be an {@link IObservableCollection}.
	*
	* @since 1.2
	*/
	public abstract class ObservableCollectionContentProvider implements
	IStructuredContentProvider {
	private Display display;

	private IObservableValue viewerObservable;

	/**
	* Element comparer used by the viewer (may be null).
	*/
	protected IElementComparer comparer;

	private IObservableFactory elementSetFactory;

	private final IViewerUpdater explicitViewerUpdater;

	/**
	* Interface for sending updates to the viewer.
	*/
	protected IViewerUpdater viewerUpdater;

	/**
	* Observable set of all elements known to the content provider. Subclasses
	* must add new elements to this set <b>before</b> adding them to the
	* viewer, and must remove old elements from this set <b>after</b> removing
	* them from the viewer.
	*/
	protected IObservableSet knownElements;
	private IObservableSet unmodifiableKnownElements;

	/**
	* Observable set of known elements which have been realized in the viewer.
	* Subclasses must add new elements to this set <b>after</b> adding them to
	* the viewer, and must remove old elements from this set <b>before</b>
	* removing them from the viewer.
	*/
	protected IObservableSet realizedElements;
	private IObservableSet unmodifiableRealizedElements;

	private IObservableCollection observableCollection;

	/**
	* Constructs an ObservableCollectionContentProvider
	*
	* @param explicitViewerUpdater
	*/
	protected ObservableCollectionContentProvider(
	IViewerUpdater explicitViewerUpdater) {
	this.explicitViewerUpdater = explicitViewerUpdater;

	display = Display.getDefault();
	viewerObservable = new WritableValue(SWTObservables.getRealm(display));
	viewerUpdater = null;

	elementSetFactory = new IObservableFactory() {
	public IObservable createObservable(Object target) {
	IElementComparer comparer = null;
	if (target instanceof StructuredViewer)
	comparer = ((StructuredViewer) target).getComparer();
	return ObservableViewerElementSet.withComparer(SWTObservables
	.getRealm(display), null, comparer);
	}
	};
	knownElements = MasterDetailObservables.detailSet(viewerObservable,
	elementSetFactory, null);
	unmodifiableKnownElements = Observables
	.unmodifiableObservableSet(knownElements);

	observableCollection = null;
	}

	public Object[] getElements(Object inputElement) {
	if (observableCollection == null)
	return new Object[0];

	knownElements.addAll(observableCollection);
	if (realizedElements != null) {
	if (!realizedElements.equals(knownElements)) {
	asyncUpdateRealizedElements();
	}
	}

	return observableCollection.toArray();
	}

	private void asyncUpdateRealizedElements() {
	if (realizedElements == null)
	return;
	display.asyncExec(new Runnable() {
	public void run() {
	if (realizedElements != null) {
	realizedElements.addAll(knownElements);
	}
	}
	});
	}

	public void dispose() {
	if (observableCollection != null)
	removeCollectionChangeListener(observableCollection);

	if (viewerObservable != null) {
	viewerObservable.dispose();
	viewerObservable = null;
	}
	viewerUpdater = null;
	knownElements = null;
	unmodifiableKnownElements = null;
	realizedElements = null;
	unmodifiableRealizedElements = null;
	display = null;
	}

	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
	setViewer(viewer);
	setInput(newInput);
	}

	private void setViewer(Viewer viewer) {
	viewerUpdater = createViewerUpdater(viewer);
	comparer = getElementComparer(viewer);
	viewerObservable.setValue(viewer); // (clears knownElements)
	}

	private static IElementComparer getElementComparer(Viewer viewer) {
	if (viewer instanceof StructuredViewer)
	return ((StructuredViewer) viewer).getComparer();
	return null;
	}

	IViewerUpdater createViewerUpdater(Viewer viewer) {
	if (explicitViewerUpdater != null)
	return explicitViewerUpdater;
	if (viewer instanceof AbstractListViewer)
	return new ListViewerUpdater((AbstractListViewer) viewer);
	if (viewer instanceof CheckboxTableViewer)
	return new CheckboxTableViewerUpdater((CheckboxTableViewer) viewer);
	if (viewer instanceof AbstractTableViewer)
	return new TableViewerUpdater((AbstractTableViewer) viewer);
	throw new IllegalArgumentException(
	"This content provider only works with AbstractTableViewer or AbstractListViewer"); //$NON-NLS-1$
	}

	void setInput(Object input) {
	if (observableCollection != null) {
	removeCollectionChangeListener(observableCollection);
	observableCollection = null;
	}

	knownElements.clear();
	if (realizedElements != null)
	realizedElements.clear();

	if (input != null) {
	checkInput(input);
	Assert.isTrue(input instanceof IObservableCollection,
	"Input must be an IObservableCollection"); //$NON-NLS-1$
	observableCollection = (IObservableCollection) input;
	addCollectionChangeListener(observableCollection);
	}
	}

	/**
	* Throws an exception if the input is not the correct type.
	*
	* @param input
	* the input to check
	*/
	protected abstract void checkInput(Object input);

	/**
	* Register for change event notification from the given collection.
	*
	* @param collection
	* observable collection to listen to
	*/
	protected abstract void addCollectionChangeListener(
	IObservableCollection collection);

	/**
	* Deregisters from change events notification on the given collection.
	*
	* @param collection
	* observable collection to stop listening to
	*/
	protected abstract void removeCollectionChangeListener(
	IObservableCollection collection);

	/**
	* Returns whether the viewer is disposed. Collection change listeners in
	* subclasses should verify that the viewer is not disposed before sending
	* any updates to the {@link ViewerUpdater viewer updater}.
	*
	* @return whether the viewer is disposed.
	*/
	protected final boolean isViewerDisposed() {
	Viewer viewer = (Viewer) viewerObservable.getValue();
	return viewer == null \|\| viewer.getControl() == null
	\|\| viewer.getControl().isDisposed();
	}

	/**
	* Returns the set of elements known to this content provider. Label
	* providers may track this set if they need to be notified about additions
	* before the viewer sees the added element, and notified about removals
	* after the element was removed from the viewer. This is intended for use
	* by label providers, as it will always return the items that need labels.
	*
	* @return unmodifiable observable set of items that will need labels
	*/
	public IObservableSet getKnownElements() {
	return unmodifiableKnownElements;
	}

	/**
	* Returns the set of known elements which have been realized in the viewer.
	* Clients may track this set in order to perform custom actions on elements
	* while they are known to be present in the viewer.
	*
	* @return the set of known elements which have been realized in the viewer.
	* @since 1.3
	*/
	public IObservableSet getRealizedElements() {
	if (realizedElements == null) {
	realizedElements = MasterDetailObservables.detailSet(
	viewerObservable, elementSetFactory, null);
	unmodifiableRealizedElements = Observables
	.unmodifiableObservableSet(realizedElements);
	asyncUpdateRealizedElements();
	}
	return unmodifiableRealizedElements;
	}
	}