Attachment #107002 for bug #222991





package org.eclipse.jface.databinding.viewers;

import java.util.Set;

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

import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.internal.databinding.viewers.ObservableCollectionContentProvider;
import org.eclipse.jface.internal.databinding.viewers.ViewerElementSet;
import org.eclipse.jface.viewers.AbstractListViewer;
import org.eclipse.jface.viewers.AbstractTableViewer;
import org.eclipse.jface.viewers.IStructuredContentProvider;

			((IObservableList) collection).removeListChangeListener(this);
		}

		public void handleListChange(final ListChangeEvent event) {
			if (isViewerDisposed())
				return;
			final Set removals = ViewerElementSet.withComparer(comparer);

			event.diff.accept(new ListDiffVisitor() {
				public void handleAdd(int index, Object element) {
					knownElements.add(element);
					viewerUpdater.insert(element, index);
					realizedElements.add(element);
				}

				public void handleRemove(int index, Object element) {
					boolean removingLast = removingLast(element);
					if (removingLast)
						realizedElements.remove(element);

					viewerUpdater.remove(element, index);

					if (removingLast)
						knownElements.remove(element);
				}

				private boolean removingLast(Object element) {
					return !event.getObservableList().contains(element);
				}

				public void handleReplace(int index, Object oldElement,
						Object newElement) {
					knownElements.add(newElement);
					boolean removingLast = removingLast(oldElement);
					if (removingLast)
						realizedElements.remove(oldElement);

					viewerUpdater.replace(oldElement, newElement, index);

					if (removingLast)
						knownElements.remove(oldElement);
					realizedElements.add(newElement);
				}

				public void handleMove(int oldIndex, int newIndex,

					viewerUpdater.move(element, oldIndex, newIndex);
				}
			});

			// For each removed element, do not remove from known elements if
			// the element is still present elsewhere in the list.
			removals.removeAll(event.getObservableList());
			knownElements.removeAll(removals);
		}
	}


	public IObservableSet getKnownElements() {
		return impl.getKnownElements();
	}

	/**
	 * 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() {
		return impl.getRealizedElements();
	}
}




				return;

			Set removals = event.diff.getRemovals();
			realizedElements.removeAll(removals);
			viewerUpdater.remove(removals.toArray());
			knownElements.removeAll(removals);

			Set additions = event.diff.getAdditions();
			knownElements.addAll(additions);
			viewerUpdater.add(additions.toArray());
			realizedElements.addAll(additions);
		}
	}


	public IObservableSet getKnownElements() {
		return impl.getKnownElements();
	}

	/**
	 * 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() {
		return impl.getRealizedElements();
	}
}

Lines 59-79 Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/ObservableCollectionContentProvider.java (-4 / +45 lines)
59	*/	59	*/
60	protected IObservableSet knownElements;	60	protected IObservableSet knownElements;
61		61
		62	/**
		63	* Observable set of known elements which have been realized in the viewer.
		64	* Subclasses must add new elements to this set <b>after</b> adding them to
		65	* the viewer, and must remove old elements from this set <b>before</b>
		66	* removing them from the viewer.
		67	*/
		68	protected IObservableSet realizedElements;
		69
62	private IObservableSet unmodifiableKnownElements;	70	private IObservableSet unmodifiableKnownElements;
		71	private IObservableSet unmodifiableRealizedElements;
63	private IObservableCollection observableCollection;	72	private IObservableCollection observableCollection;
64		73
		74	private Display display;
		75
65	/**	76	/**
66	* Constructs an ObservableCollectionContentProvider	77	* Constructs an ObservableCollectionContentProvider
67	*/	78	*/
68	protected ObservableCollectionContentProvider() {	79	protected ObservableCollectionContentProvider() {
69	final Realm realm = SWTObservables.getRealm(Display.getDefault());	80	display = Display.getDefault();
		81	final Realm realm = SWTObservables.getRealm(display);
70	viewerObservable = new WritableValue(realm);	82	viewerObservable = new WritableValue(realm);
71	viewerUpdater = null;	83	viewerUpdater = null;
72		84
73	// Known elements is a detail set of viewerObservable, so that when we	85	// Known elements is a detail set of viewerObservable, so that when we
74	// get the viewer instance we can swap in a set that uses its	86	// get the viewer instance we can swap in a set that uses its
75	// IElementComparer, if any.	87	// IElementComparer, if any.
76	IObservableFactory knownElementsFactory = new IObservableFactory() {	88	IObservableFactory elementSetFactory = new IObservableFactory() {
77	public IObservable createObservable(Object target) {	89	public IObservable createObservable(Object target) {
78	IElementComparer comparer = null;	90	IElementComparer comparer = null;
79	if (target instanceof StructuredViewer)	91	if (target instanceof StructuredViewer)
Lines 83-98 Link Here
83	}	95	}
84	};	96	};
85	knownElements = MasterDetailObservables.detailSet(viewerObservable,	97	knownElements = MasterDetailObservables.detailSet(viewerObservable,
86	knownElementsFactory, null);	98	elementSetFactory, null);
87	unmodifiableKnownElements = Observables	99	unmodifiableKnownElements = Observables
88	.unmodifiableObservableSet(knownElements);	100	.unmodifiableObservableSet(knownElements);
89		101
		102	realizedElements = MasterDetailObservables.detailSet(viewerObservable,
		103	elementSetFactory, null);
		104	unmodifiableRealizedElements = Observables
		105	.unmodifiableObservableSet(realizedElements);
		106
90	observableCollection = null;	107	observableCollection = null;
91	}	108	}
92		109
93	public Object[] getElements(Object inputElement) {	110	public Object[] getElements(Object inputElement) {
94	if (observableCollection == null)	111	if (observableCollection == null)
95	return new Object[0];	112	return new Object[0];
		113
		114	if (!realizedElements.equals(knownElements)) {
		115	display.asyncExec(new Runnable() {
		116	public void run() {
		117	realizedElements.addAll(knownElements);
		118	}
		119	});
		120	}
		121
96	return observableCollection.toArray();	122	return observableCollection.toArray();
97	}	123	}
98		124
Lines 108-113 Link Here
108	viewerUpdater = null;	134	viewerUpdater = null;
109	knownElements = null;	135	knownElements = null;
110	unmodifiableKnownElements = null;	136	unmodifiableKnownElements = null;
		137	realizedElements = null;
		138	unmodifiableRealizedElements = null;
		139	display = null;
111	}	140	}
112		141
113	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {	142	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
Lines 203-206 Link Here
203	public IObservableSet getKnownElements() {	232	public IObservableSet getKnownElements() {
204	return unmodifiableKnownElements;	233	return unmodifiableKnownElements;
205	}	234	}
206	}	235
		236	/**
		237	* Returns the set of known elements which have been realized in the viewer.
		238	* Clients may track this set in order to perform custom actions on elements
		239	* while they are known to be present in the viewer.
		240	*
		241	* @return the set of known elements which have been realized in the viewer.
		242	* @since 1.3
		243	*/
		244	public IObservableSet getRealizedElements() {
		245	return unmodifiableRealizedElements;
		246	}
		247	}




				model1.getValue(), map.get(model1));
	}

	public void testGetValue_KeyOutOfDomain() {
		Bean model3 = new Bean("3");
		assertFalse(map.containsKey(model3));
		assertFalse(model3.getValue().equals(map.get(model3)));
	}

	public void testSetValueNotifications() throws Exception {
		String oldValue = model1.getValue();
		String newValue = model1.getValue() + model1.getValue();

		assertTrue(listener.diff.getRemovedKeys().contains(model1));
		assertEquals(1, map.size());
	}

	public void testGetObserved() throws Exception {
		assertEquals(set, map.getObserved());
	}

	public void testGetPropertyDescriptor() throws Exception {
		assertEquals(propertyDescriptor, map.getPropertyDescriptor());
	}

	public void testConstructor_SkipRegisterListeners() throws Exception {
		Realm realm = new CurrentRealm(true);
		WritableSet set = new WritableSet(realm);
		Bean bean = new Bean();
		set.add(bean);

		JavaBeanObservableMap observable = new JavaBeanObservableMap(set,
				new PropertyDescriptor("value", Bean.class), false);
		ChangeEventTracker.observe(observable);

		assertFalse(bean.hasListeners("value"));
	}

	public void testConstructor_RegistersListeners() throws Exception {
		Realm realm = new CurrentRealm(true);
		WritableSet set = new WritableSet(realm);
		Bean bean = new Bean();
		set.add(bean);

		JavaBeanObservableMap observable = new JavaBeanObservableMap(set,
				new PropertyDescriptor("value", Bean.class));
		ChangeEventTracker.observe(observable);

		assertTrue(bean.hasListeners("value"));

	}

	public static Test suite() {
		TestSuite suite = new TestSuite(JavaBeanObservableMapTest.class
				.getName());
		suite.addTestSuite(JavaBeanObservableMapTest.class);
		return suite;
	}




		IBeanObservable {

	private PropertyDescriptor propertyDescriptor;

	private PropertyChangeListener elementListener = new PropertyChangeListener() {
		public void propertyChange(final java.beans.PropertyChangeEvent event) {
			if (!updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						fireMapChange(Diffs.createMapDiffSingleChange(event
								.getSource(), event.getOldValue(), event
								.getNewValue()));
					}
				});

	}

	protected Object doGet(Object key) {
		if (!containsKey(key)) {
			return null;
		}
		try {

		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getObserved()
	 */
	public Object getObserved() {
		return keySet();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.core.databinding.beans.IBeanObservable#getPropertyDescriptor
	 * ()
	 */
	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;

Lines 224-231 Link Here

(-)src/org/eclipse/jface/examples/databinding/snippets/Snippet013TableViewerEditing.java (-1 / +4 lines)
224	peopleViewer.setContentProvider(peopleViewerContentProvider);	224	peopleViewer.setContentProvider(peopleViewerContentProvider);
225		225
226	// And a standard label provider that maps columns	226	// And a standard label provider that maps columns
		227	// IObservableMap[] attributeMaps = BeansObservables.observeMaps(
		228	// peopleViewerContentProvider.getKnownElements(),
		229	// Person.class, new String[] { "name" });
227	IObservableMap[] attributeMaps = BeansObservables.observeMaps(	230	IObservableMap[] attributeMaps = BeansObservables.observeMaps(
228	peopleViewerContentProvider.getKnownElements(),	231	peopleViewerContentProvider.getRealizedElements(),
229	Person.class, new String[] { "name" });	232	Person.class, new String[] { "name" });
230	peopleViewer.setLabelProvider(new ObservableMapLabelProvider(	233	peopleViewer.setLabelProvider(new ObservableMapLabelProvider(
231	attributeMaps));	234	attributeMaps));

Return to bug 222991

Lines 13-20 Link Here

(-)src/org/eclipse/jface/databinding/viewers/ObservableListContentProvider.java (-13 / +33 lines)
13		13
14	package org.eclipse.jface.databinding.viewers;	14	package org.eclipse.jface.databinding.viewers;
15		15
16	import java.util.Set;
17
18	import org.eclipse.core.databinding.observable.IObservableCollection;	16	import org.eclipse.core.databinding.observable.IObservableCollection;
19	import org.eclipse.core.databinding.observable.list.IListChangeListener;	17	import org.eclipse.core.databinding.observable.list.IListChangeListener;
20	import org.eclipse.core.databinding.observable.list.IObservableList;	18	import org.eclipse.core.databinding.observable.list.IObservableList;
Lines 23-29 Link Here
23	import org.eclipse.core.databinding.observable.set.IObservableSet;	21	import org.eclipse.core.databinding.observable.set.IObservableSet;
24	import org.eclipse.core.runtime.Assert;	22	import org.eclipse.core.runtime.Assert;
25	import org.eclipse.jface.internal.databinding.viewers.ObservableCollectionContentProvider;	23	import org.eclipse.jface.internal.databinding.viewers.ObservableCollectionContentProvider;
26	import org.eclipse.jface.internal.databinding.viewers.ViewerElementSet;
27	import org.eclipse.jface.viewers.AbstractListViewer;	24	import org.eclipse.jface.viewers.AbstractListViewer;
28	import org.eclipse.jface.viewers.AbstractTableViewer;	25	import org.eclipse.jface.viewers.AbstractTableViewer;
29	import org.eclipse.jface.viewers.IStructuredContentProvider;	26	import org.eclipse.jface.viewers.IStructuredContentProvider;
Lines 63-89 Link Here
63	((IObservableList) collection).removeListChangeListener(this);	60	((IObservableList) collection).removeListChangeListener(this);
64	}	61	}
65		62
66	public void handleListChange(ListChangeEvent event) {	63	public void handleListChange(final ListChangeEvent event) {
67	if (isViewerDisposed())	64	if (isViewerDisposed())
68	return;	65	return;
69	final Set removals = ViewerElementSet.withComparer(comparer);
70
71	event.diff.accept(new ListDiffVisitor() {	66	event.diff.accept(new ListDiffVisitor() {
72	public void handleAdd(int index, Object element) {	67	public void handleAdd(int index, Object element) {
73	knownElements.add(element);	68	knownElements.add(element);
74	viewerUpdater.insert(element, index);	69	viewerUpdater.insert(element, index);
		70	realizedElements.add(element);
75	}	71	}
76		72
77	public void handleRemove(int index, Object element) {	73	public void handleRemove(int index, Object element) {
		74	boolean removingLast = removingLast(element);
		75	if (removingLast)
		76	realizedElements.remove(element);
		77
78	viewerUpdater.remove(element, index);	78	viewerUpdater.remove(element, index);
79	removals.add(element);	79
		80	if (removingLast)
		81	knownElements.remove(element);
		82	}
		83
		84	private boolean removingLast(Object element) {
		85	return !event.getObservableList().contains(element);
80	}	86	}
81		87
82	public void handleReplace(int index, Object oldElement,	88	public void handleReplace(int index, Object oldElement,
83	Object newElement) {	89	Object newElement) {
84	knownElements.add(newElement);	90	knownElements.add(newElement);
		91	boolean removingLast = removingLast(oldElement);
		92	if (removingLast)
		93	realizedElements.remove(oldElement);
		94
85	viewerUpdater.replace(oldElement, newElement, index);	95	viewerUpdater.replace(oldElement, newElement, index);
86	removals.add(oldElement);	96
		97	if (removingLast)
		98	knownElements.remove(oldElement);
		99	realizedElements.add(newElement);
87	}	100	}
88		101
89	public void handleMove(int oldIndex, int newIndex,	102	public void handleMove(int oldIndex, int newIndex,
Lines 91-101 Link Here
91	viewerUpdater.move(element, oldIndex, newIndex);	104	viewerUpdater.move(element, oldIndex, newIndex);
92	}	105	}
93	});	106	});
94
95	// For each removed element, do not remove from known elements if
96	// the element is still present elsewhere in the list.
97	removals.removeAll(event.getObservableList());
98	knownElements.removeAll(removals);
99	}	107	}
100	}	108	}
101		109
Lines 130-133 Link Here
130	public IObservableSet getKnownElements() {	138	public IObservableSet getKnownElements() {
131	return impl.getKnownElements();	139	return impl.getKnownElements();
132	}	140	}
		141
		142	/**
		143	* Returns the set of known elements which have been realized in the viewer.
		144	* Clients may track this set in order to perform custom actions on elements
		145	* while they are known to be present in the viewer.
		146	*
		147	* @return the set of known elements which have been realized in the viewer.
		148	* @since 1.3
		149	*/
		150	public IObservableSet getRealizedElements() {
		151	return impl.getRealizedElements();
		152	}
133	}	153	}

Lines 64-69 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/beans/JavaBeanObservableMapTest.java (-9 / +18 lines)
64	model1.getValue(), map.get(model1));	64	model1.getValue(), map.get(model1));
65	}	65	}
66		66
		67	public void testGetValue_KeyOutOfDomain() {
		68	Bean model3 = new Bean("3");
		69	assertFalse(map.containsKey(model3));
		70	assertFalse(model3.getValue().equals(map.get(model3)));
		71	}
		72
67	public void testSetValueNotifications() throws Exception {	73	public void testSetValueNotifications() throws Exception {
68	String oldValue = model1.getValue();	74	String oldValue = model1.getValue();
69	String newValue = model1.getValue() + model1.getValue();	75	String newValue = model1.getValue() + model1.getValue();
Lines 127-160 Link Here
127	assertTrue(listener.diff.getRemovedKeys().contains(model1));	133	assertTrue(listener.diff.getRemovedKeys().contains(model1));
128	assertEquals(1, map.size());	134	assertEquals(1, map.size());
129	}	135	}
130		136
131	public void testGetObserved() throws Exception {	137	public void testGetObserved() throws Exception {
132	assertEquals(set, map.getObserved());	138	assertEquals(set, map.getObserved());
133	}	139	}
134		140
135	public void testGetPropertyDescriptor() throws Exception {	141	public void testGetPropertyDescriptor() throws Exception {
136	assertEquals(propertyDescriptor, map.getPropertyDescriptor());	142	assertEquals(propertyDescriptor, map.getPropertyDescriptor());
137	}	143	}
138		144
139	public void testConstructor_SkipRegisterListeners() throws Exception {	145	public void testConstructor_SkipRegisterListeners() throws Exception {
140	Realm realm = new CurrentRealm(true);	146	Realm realm = new CurrentRealm(true);
141	WritableSet set = new WritableSet(realm);	147	WritableSet set = new WritableSet(realm);
142	Bean bean = new Bean();	148	Bean bean = new Bean();
143	set.add(bean);	149	set.add(bean);
144		150
145	JavaBeanObservableMap observable = new JavaBeanObservableMap(set, new PropertyDescriptor("value", Bean.class), false);	151	JavaBeanObservableMap observable = new JavaBeanObservableMap(set,
		152	new PropertyDescriptor("value", Bean.class), false);
146	ChangeEventTracker.observe(observable);	153	ChangeEventTracker.observe(observable);
147		154
148	assertFalse(bean.hasListeners("value"));	155	assertFalse(bean.hasListeners("value"));
149	}	156	}
150		157
151	public void testConstructor_RegistersListeners() throws Exception {	158	public void testConstructor_RegistersListeners() throws Exception {
152	Realm realm = new CurrentRealm(true);	159	Realm realm = new CurrentRealm(true);
153	WritableSet set = new WritableSet(realm);	160	WritableSet set = new WritableSet(realm);
154	Bean bean = new Bean();	161	Bean bean = new Bean();
155	set.add(bean);	162	set.add(bean);
156		163
157	JavaBeanObservableMap observable = new JavaBeanObservableMap(set, new PropertyDescriptor("value", Bean.class));	164	JavaBeanObservableMap observable = new JavaBeanObservableMap(set,
		165	new PropertyDescriptor("value", Bean.class));
158	ChangeEventTracker.observe(observable);	166	ChangeEventTracker.observe(observable);
159		167
160	assertTrue(bean.hasListeners("value"));	168	assertTrue(bean.hasListeners("value"));
Lines 172-178 Link Here
172	}	180	}
173		181
174	public static Test suite() {	182	public static Test suite() {
175	TestSuite suite = new TestSuite(JavaBeanObservableMapTest.class.getName());	183	TestSuite suite = new TestSuite(JavaBeanObservableMapTest.class
		184	.getName());
176	suite.addTestSuite(JavaBeanObservableMapTest.class);	185	suite.addTestSuite(JavaBeanObservableMapTest.class);
177	return suite;	186	return suite;
178	}	187	}

Lines 33-46 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/JavaBeanObservableMap.java (-7 / +13 lines)
33	IBeanObservable {	33	IBeanObservable {
34		34
35	private PropertyDescriptor propertyDescriptor;	35	private PropertyDescriptor propertyDescriptor;
36		36
37	private PropertyChangeListener elementListener = new PropertyChangeListener() {	37	private PropertyChangeListener elementListener = new PropertyChangeListener() {
38	public void propertyChange(final java.beans.PropertyChangeEvent event) {	38	public void propertyChange(final java.beans.PropertyChangeEvent event) {
39	if (!updating) {	39	if (!updating) {
40	getRealm().exec(new Runnable() {	40	getRealm().exec(new Runnable() {
41	public void run() {	41	public void run() {
42	fireMapChange(Diffs.createMapDiffSingleChange(	42	fireMapChange(Diffs.createMapDiffSingleChange(event
43	event.getSource(), event.getOldValue(), event	43	.getSource(), event.getOldValue(), event
44	.getNewValue()));	44	.getNewValue()));
45	}	45	}
46	});	46	});
Lines 94-100 Link Here
94	}	94	}
95		95
96	protected Object doGet(Object key) {	96	protected Object doGet(Object key) {
97	if (key == null) {	97	if (!containsKey(key)) {
98	return null;	98	return null;
99	}	99	}
100	try {	100	try {
Lines 126-140 Link Here
126	}	126	}
127	}	127	}
128		128
129	/* (non-Javadoc)	129	/*
		130	* (non-Javadoc)
		131	*
130	* @see org.eclipse.core.databinding.beans.IBeanObservable#getObserved()	132	* @see org.eclipse.core.databinding.beans.IBeanObservable#getObserved()
131	*/	133	*/
132	public Object getObserved() {	134	public Object getObserved() {
133	return keySet();	135	return keySet();
134	}	136	}
135		137
136	/* (non-Javadoc)	138	/*
137	* @see org.eclipse.core.databinding.beans.IBeanObservable#getPropertyDescriptor()	139	* (non-Javadoc)
		140	*
		141	* @see
		142	* org.eclipse.core.databinding.beans.IBeanObservable#getPropertyDescriptor
		143	* ()
138	*/	144	*/
139	public PropertyDescriptor getPropertyDescriptor() {	145	public PropertyDescriptor getPropertyDescriptor() {
140	return propertyDescriptor;	146	return propertyDescriptor;