Attachment 106468 Details for Bug 237359 – updated patch after merging conflicting changes

[patch] updated patch after merging conflicting changes

patch-237359.txt (text/plain), 31.97 KB, created by Boris Bokowski

on 2008-07-03 12:11:55 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Boris Bokowski

Created: 2008-07-03 12:11:55 EDT

Size: 31.97 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jface.examples.databinding
>Index: src/org/eclipse/jface/examples/databinding/snippets/Snippet024AsyncAndCheckAndFilter.java
>===================================================================
>RCS file: src/org/eclipse/jface/examples/databinding/snippets/Snippet024AsyncAndCheckAndFilter.java
>diff -N src/org/eclipse/jface/examples/databinding/snippets/Snippet024AsyncAndCheckAndFilter.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/examples/databinding/snippets/Snippet024AsyncAndCheckAndFilter.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,454 @@
>+/*******************************************************************************
>+ * 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.examples.databinding.snippets;
>+
>+import java.util.ArrayList;
>+import java.util.Collections;
>+import java.util.Iterator;
>+import java.util.List;
>+
>+import org.eclipse.core.databinding.observable.IObservable;
>+import org.eclipse.core.databinding.observable.Observables;
>+import org.eclipse.core.databinding.observable.Realm;
>+import org.eclipse.core.databinding.observable.list.ComputedList;
>+import org.eclipse.core.databinding.observable.list.IObservableList;
>+import org.eclipse.core.databinding.observable.list.WritableList;
>+import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
>+import org.eclipse.core.databinding.observable.set.IObservableSet;
>+import org.eclipse.core.databinding.observable.set.ISetChangeListener;
>+import org.eclipse.core.databinding.observable.set.SetChangeEvent;
>+import org.eclipse.core.databinding.observable.set.WritableSet;
>+import org.eclipse.core.databinding.observable.value.IObservableValue;
>+import org.eclipse.jface.databinding.swt.ISWTObservableValue;
>+import org.eclipse.jface.databinding.swt.SWTObservables;
>+import org.eclipse.jface.databinding.viewers.ObservableListTreeContentProvider;
>+import org.eclipse.jface.databinding.viewers.TreeStructureAdvisor;
>+import org.eclipse.jface.layout.GridDataFactory;
>+import org.eclipse.jface.viewers.CheckStateChangedEvent;
>+import org.eclipse.jface.viewers.CheckboxTreeViewer;
>+import org.eclipse.jface.viewers.DoubleClickEvent;
>+import org.eclipse.jface.viewers.ICheckStateListener;
>+import org.eclipse.jface.viewers.IDoubleClickListener;
>+import org.eclipse.jface.viewers.IStructuredSelection;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.events.DisposeEvent;
>+import org.eclipse.swt.events.DisposeListener;
>+import org.eclipse.swt.layout.GridLayout;
>+import org.eclipse.swt.widgets.Control;
>+import org.eclipse.swt.widgets.Display;
>+import org.eclipse.swt.widgets.Shell;
>+import org.eclipse.swt.widgets.Text;
>+
>+public class Snippet024AsyncAndCheckAndFilter {
>+
>+	public static void main(String[] args) {
>+		final Display display = new Display();
>+		final Shell shell = new Shell(display);
>+		shell.setLayout(new GridLayout(1, false));
>+
>+		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
>+			public void run() {
>+				new Snippet024AsyncAndCheckAndFilter().createControls(shell);
>+
>+				shell.pack();
>+				shell.open();
>+				while (!shell.isDisposed()) {
>+					if (!display.readAndDispatch())
>+						display.sleep();
>+				}
>+			}
>+		});
>+		display.dispose();
>+	}
>+
>+	static abstract class Node {
>+		private final String name;
>+		private final Node parent;
>+
>+		public Node getParent() {
>+			return parent;
>+		}
>+
>+		Node(Node parent, String name) {
>+			this.parent = parent;
>+			this.name = name;
>+		}
>+
>+		public String toString() {
>+			return name;
>+		}
>+
>+		public abstract IObservableList createChildren();
>+	}
>+
>+	static class Pending extends Node {
>+		Pending(Node parent) {
>+			super(parent, "Pending...");
>+		}
>+
>+		public IObservableList createChildren() {
>+			return null;
>+		}
>+	}
>+
>+	static class Root extends Node {
>+		private final IObservableSet checked;
>+		private final IObservableValue filter;
>+		private final ObservableListTreeContentProvider provider;
>+
>+		Root(IObservableSet checkedElements, IObservableValue filter, ObservableListTreeContentProvider contentProvider) {
>+			super(null, "root");
>+			checked = checkedElements;
>+			this.filter = filter;
>+			provider = contentProvider;
>+		}
>+
>+		public IObservableList createChildren() {
>+			final List repositories = new ArrayList();
>+			repositories.add(new Repository(this, "Eclipse SDK Update Site",
>+					checked, filter));
>+			repositories.add(new Repository(this, "EMF Update Site", checked,
>+					filter));
>+			repositories.add(new Repository(this, "Ganymede Update Site",
>+					checked, filter));
>+			repositories.add(new Repository(this, "Mylyn Update Site", checked,
>+					filter));
>+			return new ComputedList() {
>+				protected List calculate() {
>+					if (((String)filter.getValue()).length() == 0) {
>+						return Observables.staticObservableList(repositories);
>+					} else {
>+						List result = new ArrayList();
>+						for (Iterator it = repositories.iterator(); it
>+								.hasNext();) {
>+							Object object = it.next();
>+							if (!provider.getObservableChildren(object).isEmpty()) {
>+								result.add(object);
>+							}
>+						}
>+						return result;
>+					}
>+				}
>+			};
>+		}
>+	}
>+
>+	static class Repository extends Node {
>+		private WritableList iuList;
>+		protected Pending pendingNode;
>+		private final IObservableSet checked;
>+		private final IObservableValue filter;
>+
>+		Repository(Root root, String name, IObservableSet checkedElements,
>+				IObservableValue filter) {
>+			super(root, name);
>+			checked = checkedElements;
>+			this.filter = filter;
>+		}
>+
>+		public IObservableList getIUList() {
>+			return new ComputedList() {
>+				protected List calculate() {
>+					List result = new ArrayList();
>+					for (Iterator it = getUnfilteredIUList().iterator(); it
>+							.hasNext();) {
>+						Node nodeObject = (Node) it.next();
>+						String filterString = (String) filter.getValue();
>+						if (filterString.length() == 0
>+								|| nodeObject.name.toLowerCase().indexOf(
>+										filterString.toLowerCase()) != -1) {
>+							result.add(nodeObject);
>+						}
>+					}
>+					return result;
>+				}
>+			};
>+		}
>+
>+		private IObservableList getUnfilteredIUList() {
>+			if (iuList == null) {
>+				iuList = new WritableList();
>+				refreshIUList();
>+			}
>+			return iuList;
>+		}
>+
>+		public void refreshIUList() {
>+			if (iuList.isStale()) {
>+				// we are already refreshing
>+				return;
>+			}
>+			iuList.setStale(true);
>+			iuList.clear();
>+			Display.getDefault().timerExec(3000, new Runnable() {
>+				public void run() {
>+					List bulkAdd = new ArrayList();
>+					Category c1 = new Category(Repository.this,
>+							"Alpha Category");
>+					bulkAdd.add(new IU(c1, "Alpha Bar"));
>+					bulkAdd.add(new IU(c1, "Alpha Bas"));
>+					bulkAdd.add(new IU(c1, "Alpha Foo"));
>+					bulkAdd.add(new IU(c1, "Alpha Meh"));
>+					bulkAdd.add(new IU(c1, "Alpha Moo"));
>+					Category c2 = new Category(Repository.this,
>+							"Beta Category");
>+					bulkAdd.add(new IU(c2, "Beta Bar"));
>+					bulkAdd.add(new IU(c2, "Beta Bas"));
>+					bulkAdd.add(new IU(c2, "Beta Foo"));
>+					bulkAdd.add(new IU(c2, "Beta Meh"));
>+					bulkAdd.add(new IU(c2, "Beta Moo"));
>+					Category c3 = new Category(Repository.this,
>+							"Gamma Category");
>+					bulkAdd.add(new IU(c3, "Gamma Bar"));
>+					bulkAdd.add(new IU(c3, "Gamma Bas"));
>+					bulkAdd.add(new IU(c3, "Gamma Foo"));
>+					bulkAdd.add(new IU(c3, "Gamma Meh"));
>+					bulkAdd.add(new IU(c3, "Gamma Moo"));
>+					iuList.setStale(false);
>+					// System.out.println("finished retrieval, pendingNode="
>+					// + pendingNode);
>+					if (pendingNode != null) {
>+						if (checked.contains(pendingNode)) {
>+							// System.out
>+							// .println(
>+							// "pending node was checked, adding nodes to checked set:"
>+							// + bulkAdd.size());
>+							checked.remove(pendingNode);
>+							checked.add(c1);
>+							checked.add(c2);
>+							checked.add(c3);
>+							checked.addAll(bulkAdd);
>+						}
>+						pendingNode = null;
>+					}
>+					iuList.addAll(bulkAdd);
>+				}
>+			});
>+		}
>+
>+		public IObservableList createChildren() {
>+			return new ComputedList() {
>+				protected List calculate() {
>+					if (getIUList().isStale()) {
>+						if (pendingNode == null) {
>+							pendingNode = new Pending(Repository.this);
>+						}
>+						return Collections.singletonList(pendingNode);
>+					}
>+					List result = new ArrayList();
>+					for (Iterator it = getIUList().iterator(); it.hasNext();) {
>+						IU iu = (IU) it.next();
>+						if (!result.contains(iu.getParent())) {
>+							result.add(iu.getParent());
>+						}
>+					}
>+					return result;
>+				}
>+			};
>+		}
>+	}
>+
>+	static class Category extends Node {
>+		Category(Repository repo, String name) {
>+			super(repo, name);
>+		}
>+
>+		public IObservableList createChildren() {
>+			return new ComputedList() {
>+				protected List calculate() {
>+					List result = new ArrayList();
>+					for (Iterator it = ((Repository) getParent()).getIUList()
>+							.iterator(); it.hasNext();) {
>+						IU iu = (IU) it.next();
>+						if (iu.getParent() == Category.this) {
>+							result.add(iu);
>+						}
>+					}
>+					// System.out.println("returning children, " +
>+					// result.size());
>+					return result;
>+				}
>+			};
>+		}
>+	}
>+
>+	static class IU extends Node {
>+		IU(Category category, String name) {
>+			super(category, name);
>+		}
>+
>+		public IObservableList createChildren() {
>+			return null;
>+		}
>+	}
>+
>+	private CheckboxTreeViewer viewer;
>+	private IObservableSet knownElements;
>+	private IObservableSet checkedElements;
>+	private IObservableSet grayedElements;
>+	private ObservableListTreeContentProvider contentProvider;
>+	private TreeStructureAdvisor treeStructureAdvisor;
>+	private ISWTObservableValue delayedFilterValue;
>+
>+    boolean viewerIsDisposed;
>+
>+    protected void createControls(Shell shell) {
>+		Text filter = new Text(shell, SWT.BORDER | SWT.SEARCH);
>+		ISWTObservableValue filterValue = SWTObservables.observeText(filter,
>+				SWT.Modify);
>+		delayedFilterValue = SWTObservables.observeDelayedValue(200,
>+				filterValue);
>+		viewer = new CheckboxTreeViewer(shell){
>+		    protected void hookControl(Control control) {
>+		        control.addDisposeListener(new DisposeListener() {
>+		            public void widgetDisposed(DisposeEvent event) {
>+		                viewerIsDisposed = true;
>+		            }
>+		        });
>+		        super.hookControl(control);
>+		    }
>+		};
>+		GridDataFactory.defaultsFor(viewer.getControl()).hint(400, 600)
>+				.applyTo(viewer.getControl());
>+		treeStructureAdvisor = new TreeStructureAdvisor() {
>+			public Object getParent(Object element) {
>+				if (element instanceof Node) {
>+					return ((Node) element).getParent();
>+				}
>+				return null;
>+			}
>+
>+			public Boolean hasChildren(Object element) {
>+				return (element instanceof IU || element instanceof Pending) ? Boolean.FALSE
>+						: Boolean.TRUE;
>+			}
>+		};
>+		IObservableFactory listFactory = new IObservableFactory() {
>+			public IObservable createObservable(Object target) {
>+				return ((Node) target).createChildren();
>+			}
>+		};
>+		contentProvider = new ObservableListTreeContentProvider(listFactory,
>+				treeStructureAdvisor);
>+		viewer.setContentProvider(contentProvider);
>+		knownElements = contentProvider.getDeferredKnownElements();
>+		checkedElements = new WritableSet();
>+		grayedElements = new WritableSet();
>+		viewer.addCheckStateListener(new ICheckStateListener() {
>+			public void checkStateChanged(CheckStateChangedEvent event) {
>+				handleChecked(event.getElement(), event.getChecked());
>+			}
>+		});
>+		knownElements.addSetChangeListener(new ISetChangeListener() {
>+			public void handleSetChange(SetChangeEvent event) {
>+				if (viewerIsDisposed) {
>+					return;
>+				}
>+				for (Iterator it = event.diff.getRemovals().iterator(); it
>+						.hasNext();) {
>+					Object removed = it.next();
>+					if (removed instanceof IU) {
>+						Object parent = treeStructureAdvisor.getParent(removed);
>+						Object[] children = contentProvider.getChildren(parent);
>+						boolean atLeastOneChecked = false;
>+						boolean atLeastOneUnchecked = false;
>+						for (int i = 0; i < children.length; i++) {
>+							Object child = children[i];
>+							if (checkedElements.contains(child)) {
>+								atLeastOneChecked = true;
>+							} else {
>+								atLeastOneUnchecked = true;
>+							}
>+						}
>+						checkParentPath(parent, !atLeastOneUnchecked, atLeastOneChecked && atLeastOneUnchecked);
>+					}
>+				}
>+				for (Iterator it = event.diff.getAdditions().iterator(); it
>+						.hasNext();) {
>+					Object added = it.next();
>+					if (added instanceof IU) {
>+						boolean checked = checkedElements.contains(added);
>+						viewer.setChecked(added, checked);
>+						handleChecked(added, checked);
>+					}
>+				}
>+			}
>+		});
>+		viewer.addDoubleClickListener(new IDoubleClickListener(){
>+			public void doubleClick(DoubleClickEvent event) {
>+				IStructuredSelection selection = (IStructuredSelection) event.getSelection();
>+				if (selection.getFirstElement() instanceof Repository) {
>+					((Repository) selection.getFirstElement()).refreshIUList();
>+				}
>+			}
>+		});
>+		viewer.setInput(new Root(checkedElements, delayedFilterValue, 
>+				contentProvider));
>+	}
>+
>+	protected void handleChecked(Object element, boolean checked) {
>+		checkSubtree(element, checked);
>+		checkParentPath(element, checked, false);
>+	}
>+
>+	private void checkParentPath(Object element, boolean checked, boolean grayed) {
>+		if (element == null) {
>+			return;
>+		}
>+		if (grayed) {
>+			checked = true;
>+		} else {
>+			Object[] children = contentProvider.getChildren(element);
>+			for (int i = 0; i < children.length; i++) {
>+				Object child = children[i];
>+				if (grayedElements.contains(child)
>+						|| checked != checkedElements.contains(child)) {
>+					checked = grayed = true;
>+					break;
>+				}
>+			}
>+		}
>+		updateCheckedGrayed(element, checked, grayed);
>+		checkParentPath(treeStructureAdvisor.getParent(element), checked,
>+				grayed);
>+	}
>+
>+	private void checkSubtree(Object element, boolean checked) {
>+		updateCheckedGrayed(element, checked, false);
>+		if (!(element instanceof Pending)) {
>+			Object[] children = contentProvider.getChildren(element);
>+			for (int i = 0; i < children.length; i++) {
>+				Object child = children[i];
>+				checkSubtree(child, checked);
>+			}
>+		}
>+	}
>+
>+	private void updateCheckedGrayed(Object element, boolean checked,
>+			boolean grayed) {
>+		if (checked) {
>+			checkedElements.add(element);
>+		} else {
>+			checkedElements.remove(element);
>+		}
>+		if (grayed) {
>+			grayedElements.add(element);
>+		} else {
>+			grayedElements.remove(element);
>+		}
>+		if (knownElements.contains(element)) {
>+			viewer.setChecked(element, checked);
>+			viewer.setGrayed(element, grayed);
>+		}
>+	}
>+
>+}
>#P org.eclipse.core.databinding
>Index: src/org/eclipse/core/databinding/observable/list/AbstractObservableList.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.core.databinding/src/org/eclipse/core/databinding/observable/list/AbstractObservableList.java,v
>retrieving revision 1.11
>diff -u -r1.11 AbstractObservableList.java
>--- src/org/eclipse/core/databinding/observable/list/AbstractObservableList.java	7 Apr 2008 21:16:18 -0000	1.11
>+++ src/org/eclipse/core/databinding/observable/list/AbstractObservableList.java	3 Jul 2008 16:10:26 -0000
>@@ -76,33 +76,47 @@
> 	}
> 
> 	public synchronized void addListChangeListener(IListChangeListener listener) {
>-		changeSupport.addListener(ListChangeEvent.TYPE, listener);
>+		if (changeSupport != null) {
>+			changeSupport.addListener(ListChangeEvent.TYPE, listener);
>+		}
> 	}
> 
> 	public synchronized void removeListChangeListener(IListChangeListener listener) {
>-		changeSupport.removeListener(ListChangeEvent.TYPE, listener);
>+		if (changeSupport != null) {
>+			changeSupport.removeListener(ListChangeEvent.TYPE, listener);
>+		}
> 	}
> 
> 	protected void fireListChange(ListDiff diff) {
> 		// fire general change event first
> 		fireChange();
>-		changeSupport.fireEvent(new ListChangeEvent(this, diff));
>+		if (changeSupport != null) {
>+			changeSupport.fireEvent(new ListChangeEvent(this, diff));
>+		}
> 	}
> 
> 	public synchronized void addChangeListener(IChangeListener listener) {
>-		changeSupport.addChangeListener(listener);
>+		if (changeSupport != null) {
>+			changeSupport.addChangeListener(listener);
>+		}
> 	}
> 
> 	public synchronized void removeChangeListener(IChangeListener listener) {
>-		changeSupport.removeChangeListener(listener);
>+		if (changeSupport != null) {
>+			changeSupport.removeChangeListener(listener);
>+		}
> 	}
> 
> 	public synchronized void addStaleListener(IStaleListener listener) {
>-		changeSupport.addStaleListener(listener);
>+		if (changeSupport != null) {
>+			changeSupport.addStaleListener(listener);
>+		}
> 	}
> 
> 	public synchronized void removeStaleListener(IStaleListener listener) {
>-		changeSupport.removeStaleListener(listener);
>+		if (changeSupport != null) {
>+			changeSupport.removeStaleListener(listener);
>+		}
> 	}
> 
> 	/**
>Index: src/org/eclipse/core/databinding/observable/list/ComputedList.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.core.databinding/src/org/eclipse/core/databinding/observable/list/ComputedList.java,v
>retrieving revision 1.2
>diff -u -r1.2 ComputedList.java
>--- src/org/eclipse/core/databinding/observable/list/ComputedList.java	5 Dec 2007 04:05:15 -0000	1.2
>+++ src/org/eclipse/core/databinding/observable/list/ComputedList.java	3 Jul 2008 16:10:26 -0000
>@@ -121,12 +121,14 @@
> 		}
> 
> 		public void handleStale(StaleEvent event) {
>-			if (!dirty)
>+			if (!disposed && !dirty)
> 				makeStale();
> 		}
> 
> 		public void handleChange(ChangeEvent event) {
>-			makeDirty();
>+			if (!disposed) {
>+				makeDirty();
>+			}
> 		}
> 	}
> 
>@@ -134,6 +136,8 @@
> 
> 	private Object elementType;
> 
>+	private boolean disposed;
>+
> 	protected int doGetSize() {
> 		return doGetList().size();
> 	}
>@@ -154,19 +158,23 @@
> 			// - Run the calculate method
> 			// - While doing so, add any observable that is touched to the
> 			// dependencies list
>-			IObservable[] newDependencies = ObservableTracker.runAndMonitor(
>+			final IObservable[] newDependencies = ObservableTracker.runAndMonitor(
> 					privateInterface, privateInterface, null);
> 
>-			// If any dependencies are stale, a stale event will be fired here
>-			// even if we were already stale before recomputing. This is in case
>-			// clients assume that a list change is indicative of non-staleness.
>-			stale = false;
>-			for (int i = 0; i < newDependencies.length; i++) {
>-				if (newDependencies[i].isStale()) {
>-					makeStale();
>-					break;
>+			ObservableTracker.runAndIgnore(new Runnable() {
>+				public void run() {
>+					// If any dependencies are stale, a stale event will be fired here
>+					// even if we were already stale before recomputing. This is in case
>+					// clients assume that a list change is indicative of non-staleness.
>+					stale = false;
>+					for (int i = 0; i < newDependencies.length; i++) {
>+						if (newDependencies[i].isStale()) {
>+							makeStale();
>+							break;
>+						}
>+					}
> 				}
>-			}
>+			});
> 
> 			if (!stale) {
> 				for (int i = 0; i < newDependencies.length; i++) {
>@@ -231,13 +239,16 @@
> 	}
> 
> 	private void makeStale() {
>-		if (!stale) {
>+		if (!disposed && !stale) {
> 			stale = true;
> 			fireStale();
> 		}
> 	}
> 
> 	public boolean isStale() {
>+		if (disposed) {
>+			return false;
>+		}
> 		// recalculate list if dirty, to ensure staleness is correct.
> 		getList();
> 		return stale;
>@@ -284,6 +295,7 @@
> 	}
> 
> 	public synchronized void dispose() {
>+		disposed = true;
> 		stopListening();
> 		super.dispose();
> 	}
>Index: src/org/eclipse/core/databinding/observable/set/DeferredObservableSet.java
>===================================================================
>RCS file: src/org/eclipse/core/databinding/observable/set/DeferredObservableSet.java
>diff -N src/org/eclipse/core/databinding/observable/set/DeferredObservableSet.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/core/databinding/observable/set/DeferredObservableSet.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,98 @@
>+/*******************************************************************************
>+ * 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.core.databinding.observable.set;
>+
>+import java.util.HashSet;
>+import java.util.Iterator;
>+import java.util.Set;
>+
>+import org.eclipse.core.databinding.observable.Diffs;
>+import org.eclipse.core.runtime.Assert;
>+
>+/**
>+ * A read-only observable set that can defer changes to its underlying
>+ * observable set.
>+ * 
>+ * @since 1.1
>+ * 
>+ */
>+public class DeferredObservableSet extends ObservableSet {
>+	
>+	private IObservableSet target;
>+	private ISetChangeListener listener = new ISetChangeListener(){
>+		public void handleSetChange(SetChangeEvent event) {
>+			if (deferChanges == 0) {
>+				fireSetChange(Diffs.createSetDiff(event.diff.getAdditions(), event.diff.getRemovals()));
>+			} else {
>+				for (Iterator it = event.diff.getAdditions().iterator(); it
>+						.hasNext();) {
>+					Object added = it.next();
>+					if (!deferredRemovals.remove(added)) {
>+						deferredAdditions.add(added);
>+					}
>+				}
>+				for (Iterator it = event.diff.getRemovals().iterator(); it
>+				.hasNext();) {
>+					Object removed = it.next();
>+					if (!deferredAdditions.remove(removed)) {
>+						deferredRemovals.add(removed);
>+					}
>+				}
>+			}
>+		}
>+	};
>+	
>+	private int deferChanges;
>+	
>+	private Set deferredAdditions = new HashSet();
>+	private Set deferredRemovals = new HashSet();
>+
>+	/**
>+	 * @param target
>+	 * @param elementType 
>+	 */
>+	public DeferredObservableSet(IObservableSet target, Object elementType) {
>+		super(new HashSet(), elementType);
>+		this.target = target;
>+		target.addSetChangeListener(listener);
>+		wrappedSet.addAll(target);
>+	}
>+	
>+	/**
>+	 * @param defer
>+	 */
>+	public void deferChanges(boolean defer) {
>+		checkRealm();
>+		if (defer) {
>+			deferChanges++;
>+		} else {
>+			--deferChanges;
>+		}
>+		Assert.isTrue(deferChanges >= 0);
>+		if (deferChanges == 0 && (deferredRemovals.size() > 0 || deferredAdditions.size() > 0)) {
>+			wrappedSet.removeAll(deferredRemovals);
>+			wrappedSet.addAll(deferredAdditions);
>+			SetDiff diff = Diffs.createSetDiff(new HashSet(deferredAdditions), new HashSet(deferredRemovals));
>+			deferredAdditions.clear();
>+			deferredRemovals.clear();
>+			fireSetChange(diff);
>+		}
>+	}
>+	
>+	public synchronized void dispose() {
>+		target.removeSetChangeListener(listener);
>+		listener = null;
>+		target = null;
>+		super.dispose();
>+	}
>+
>+}
>#P org.eclipse.jface.databinding
>Index: src/org/eclipse/jface/databinding/viewers/ObservableSetTreeContentProvider.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.databinding/src/org/eclipse/jface/databinding/viewers/ObservableSetTreeContentProvider.java,v
>retrieving revision 1.3
>diff -u -r1.3 ObservableSetTreeContentProvider.java
>--- src/org/eclipse/jface/databinding/viewers/ObservableSetTreeContentProvider.java	29 Apr 2008 01:44:21 -0000	1.3
>+++ src/org/eclipse/jface/databinding/viewers/ObservableSetTreeContentProvider.java	3 Jul 2008 16:10:32 -0000
>@@ -159,4 +159,11 @@
> 	public IObservableSet getKnownElements() {
> 		return impl.getKnownElements();
> 	}
>+
>+	/**
>+	 * @return bla
>+	 */
>+	public IObservableSet getDeferredKnownElements() {
>+		return impl.getDeferredKnownElements();
>+	}
> }
>\ No newline at end of file
>Index: src/org/eclipse/jface/databinding/viewers/ObservableListTreeContentProvider.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.databinding/src/org/eclipse/jface/databinding/viewers/ObservableListTreeContentProvider.java,v
>retrieving revision 1.4
>diff -u -r1.4 ObservableListTreeContentProvider.java
>--- src/org/eclipse/jface/databinding/viewers/ObservableListTreeContentProvider.java	29 Apr 2008 01:44:21 -0000	1.4
>+++ src/org/eclipse/jface/databinding/viewers/ObservableListTreeContentProvider.java	3 Jul 2008 16:10:32 -0000
>@@ -64,10 +64,14 @@
> 				final Set removals = ViewerElementSet.withComparer(comparer);
> 				event.diff.accept(new ListDiffVisitor() {
> 					public void handleAdd(int index, Object child) {
>+
>+						deferredKnownElements.deferChanges(true);
> 						// adds to known elements if new element
> 						getOrCreateNode(child).addParent(parentElement);
> 
> 						viewerUpdater.insert(parentElement, child, index);
>+						
>+						deferredKnownElements.deferChanges(false);
> 					}
> 
> 					public void handleRemove(int index, Object child) {
>@@ -78,11 +82,13 @@
> 
> 					public void handleReplace(int index, Object oldChild,
> 							Object newChild) {
>+						deferredKnownElements.deferChanges(true);
> 						getOrCreateNode(newChild).addParent(parentElement);
> 
> 						viewerUpdater.replace(parentElement, oldChild,
> 								newChild, index);
> 
>+						deferredKnownElements.deferChanges(false);
> 						removals.add(oldChild);
> 					}
> 
>@@ -183,4 +189,19 @@
> 	public IObservableSet getKnownElements() {
> 		return impl.getKnownElements();
> 	}
>+
>+	/**
>+	 * @return bla
>+	 */
>+	public IObservableSet getDeferredKnownElements() {
>+		return impl.getDeferredKnownElements();
>+	}
>+
>+	/**
>+	 * @param element
>+	 * @return bla
>+	 */
>+	public IObservableList getObservableChildren(Object element) {
>+		return (IObservableList) impl.getObservableChildren(element);
>+	}
> }
>\ No newline at end of file
>Index: src/org/eclipse/jface/internal/databinding/viewers/ObservableCollectionTreeContentProvider.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/viewers/ObservableCollectionTreeContentProvider.java,v
>retrieving revision 1.6
>diff -u -r1.6 ObservableCollectionTreeContentProvider.java
>--- src/org/eclipse/jface/internal/databinding/viewers/ObservableCollectionTreeContentProvider.java	2 Jul 2008 18:00:42 -0000	1.6
>+++ src/org/eclipse/jface/internal/databinding/viewers/ObservableCollectionTreeContentProvider.java	3 Jul 2008 16:10:32 -0000
>@@ -23,6 +23,7 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
> import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
>+import org.eclipse.core.databinding.observable.set.DeferredObservableSet;
> import org.eclipse.core.databinding.observable.set.IObservableSet;
> import org.eclipse.core.databinding.observable.value.IObservableValue;
> import org.eclipse.core.databinding.observable.value.WritableValue;
>@@ -62,6 +63,7 @@
> 	protected IElementComparer comparer;
> 
> 	private IObservableSet knownElements;
>+	protected DeferredObservableSet deferredKnownElements;
> 	private IObservableSet unmodifiableKnownElements;
> 
> 	private IObservableFactory /* <IObservableCollection> */collectionFactory;
>@@ -70,6 +72,8 @@
> 
> 	private TreeStructureAdvisor structureAdvisor;
> 
>+	private IObservableSet unmodifiableDeferredKnownElements;
>+
> 	/**
> 	 * Constructs an ObservableCollectionTreeContentProvider using the given
> 	 * parent provider and collection factory.
>@@ -100,6 +104,9 @@
> 				knownElementsFactory, null);
> 		unmodifiableKnownElements = Observables
> 				.unmodifiableObservableSet(knownElements);
>+		deferredKnownElements = new DeferredObservableSet(knownElements, null);
>+		unmodifiableDeferredKnownElements = Observables
>+				.unmodifiableObservableSet(deferredKnownElements);
> 
> 		Assert
> 				.isNotNull(collectionFactory,
>@@ -158,12 +165,27 @@
> 		return getChildren(input, true);
> 	}
> 
>+	private boolean deferringKnownElements;
>+	
> 	public Object[] getChildren(Object element) {
> 		return getChildren(element, false);
> 	}
> 
> 	private Object[] getChildren(Object element, boolean input) {
>-		Object[] children = getOrCreateNode(element, input).getChildren();
>+		if (!deferringKnownElements) {
>+			deferringKnownElements = true;
>+			deferredKnownElements.deferChanges(true);
>+			realm.asyncExec(new Runnable(){
>+				public void run() {
>+					deferringKnownElements = false;
>+					if (deferredKnownElements != null) {
>+						deferredKnownElements.deferChanges(false);
>+					}
>+				}
>+			});
>+		}
>+		TreeNode node = getOrCreateNode(element, input);
>+		Object[] children = node.getChildren();
> 		for (int i = 0; i < children.length; i++)
> 			getOrCreateNode(children[i], false).addParent(element);
> 		return children;
>@@ -176,9 +198,19 @@
> 				return hasChildren.booleanValue();
> 			}
> 		}
>+		if (!deferringKnownElements) {
>+			deferringKnownElements = true;
>+			deferredKnownElements.deferChanges(true);
>+			realm.asyncExec(new Runnable(){
>+				public void run() {
>+					deferringKnownElements = false;
>+					deferredKnownElements.deferChanges(false);
>+				}
>+			});
>+		}
> 		return getOrCreateNode(element, false).hasChildren();
> 	}
>-
>+	
> 	protected TreeNode getOrCreateNode(Object element) {
> 		return getOrCreateNode(element, false);
> 	}
>@@ -226,6 +258,7 @@
> 		viewerUpdater = null;
> 		comparer = null;
> 		knownElements = null;
>+		deferredKnownElements = null;
> 		unmodifiableKnownElements = null;
> 		collectionFactory = null;
> 	}
>@@ -244,6 +277,13 @@
> 	}
> 
> 	/**
>+	 * @return bla
>+	 */
>+	public IObservableSet getDeferredKnownElements() {
>+		return unmodifiableDeferredKnownElements;
>+	}
>+	
>+	/**
> 	 * Returns a listener which, when a collection change event is received,
> 	 * updates the tree viewer through the {@link #viewerUpdater} field, and
> 	 * maintains the adds and removes parents from the appropriate tree nodes.
>@@ -369,6 +409,11 @@
> 			initChildren();
> 			return children.toArray();
> 		}
>+		
>+		IObservableCollection getChildrenObservable() {
>+			initChildren();
>+			return children;
>+		}
> 
> 		private void dispose() {
> 			if (element != null) {
>@@ -395,4 +440,12 @@
> 			}
> 		}
> 	}
>+
>+	/**
>+	 * @param element
>+	 * @return bla
>+	 */
>+	public IObservableCollection getObservableChildren(Object element) {
>+		return getOrCreateNode(element).getChildrenObservable();
>+	}
> }
>\ No newline at end of file
>Index: src/org/eclipse/jface/internal/databinding/swt/DelayedObservableValue.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/swt/DelayedObservableValue.java,v
>retrieving revision 1.1
>diff -u -r1.1 DelayedObservableValue.java
>--- src/org/eclipse/jface/internal/databinding/swt/DelayedObservableValue.java	19 Mar 2008 23:03:22 -0000	1.1
>+++ src/org/eclipse/jface/internal/databinding/swt/DelayedObservableValue.java	3 Jul 2008 16:10:32 -0000
>@@ -138,7 +138,11 @@
> 
> 	protected Object doGetValue() {
> 		if (dirty) {
>-			cachedValue = observable.getValue();
>+			ObservableTracker.runAndIgnore(new Runnable(){
>+				public void run() {
>+					cachedValue = observable.getValue();
>+				}
>+			});
> 			dirty = false;
> 
> 			if (updater != null && !updater.running) {

Actions: View | Diff

Attachments on bug 237359: 105085 | 105213 | 106468 | 111741 | 114127