Attachment 105085 Details for Bug 237359 – work in progress

[patch] work in progress

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

on 2008-06-16 17:04:51 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Boris Bokowski

Created: 2008-06-16 17:04:51 EDT

Size: 21.45 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.core.databinding
>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	16 Jun 2008 21:03:50 -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	16 Jun 2008 21:03:50 -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,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/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.5
>diff -u -r1.5 ObservableCollectionTreeContentProvider.java
>--- src/org/eclipse/jface/internal/databinding/viewers/ObservableCollectionTreeContentProvider.java	29 Apr 2008 01:44:21 -0000	1.5
>+++ src/org/eclipse/jface/internal/databinding/viewers/ObservableCollectionTreeContentProvider.java	16 Jun 2008 21:03:50 -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,10 @@
> 
> 	private TreeStructureAdvisor structureAdvisor;
> 
>+	protected ObservableViewerElementSet internalCurrentKnownElements;
>+
>+	private IObservableSet unmodifiableDeferredKnownElements;
>+
> 	/**
> 	 * Constructs an ObservableCollectionTreeContentProvider using the given
> 	 * parent provider and collection factory.
>@@ -100,6 +106,9 @@
> 				knownElementsFactory, null);
> 		unmodifiableKnownElements = Observables
> 				.unmodifiableObservableSet(knownElements);
>+		deferredKnownElements = new DeferredObservableSet(knownElements, null);
>+		unmodifiableDeferredKnownElements = Observables
>+				.unmodifiableObservableSet(deferredKnownElements);
> 
> 		Assert
> 				.isNotNull(collectionFactory,
>@@ -158,8 +167,21 @@
> 		return getChildren(input);
> 	}
> 
>+	private boolean deferringKnownElements;
>+	
> 	public Object[] getChildren(Object element) {
>-		Object[] children = getOrCreateNode(element).getChildren();
>+		if (!deferringKnownElements) {
>+			deferringKnownElements = true;
>+			deferredKnownElements.deferChanges(true);
>+			realm.asyncExec(new Runnable(){
>+				public void run() {
>+					deferringKnownElements = false;
>+					deferredKnownElements.deferChanges(false);
>+				}
>+			});
>+		}
>+		TreeNode node = getOrCreateNode(element);
>+		Object[] children = node.getChildren();
> 		for (int i = 0; i < children.length; i++)
> 			getOrCreateNode(children[i]).addParent(element);
> 		return children;
>@@ -172,9 +194,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).hasChildren();
> 	}
>-
>+	
> 	protected TreeNode getOrCreateNode(Object element) {
> 		TreeNode node = getExistingNode(element);
> 		if (node == null) {
>@@ -214,6 +246,7 @@
> 		viewerUpdater = null;
> 		comparer = null;
> 		knownElements = null;
>+		deferredKnownElements = null;
> 		unmodifiableKnownElements = null;
> 		collectionFactory = null;
> 	}
>@@ -232,6 +265,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.
>#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,342 @@
>+/*******************************************************************************
>+ * 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.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.ICheckStateListener;
>+import org.eclipse.swt.layout.GridLayout;
>+import org.eclipse.swt.widgets.Display;
>+import org.eclipse.swt.widgets.Shell;
>+
>+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;
>+
>+		Root(IObservableSet checkedElements) {
>+			super(null, "root");
>+			checked = checkedElements;
>+		}
>+
>+		public IObservableList createChildren() {
>+			List repositories = new ArrayList();
>+			repositories.add(new Repository(this, "Eclipse SDK Update Site",
>+					checked));
>+			repositories.add(new Repository(this, "EMF Update Site", checked));
>+			repositories.add(new Repository(this, "Ganymede Update Site",
>+					checked));
>+			repositories
>+					.add(new Repository(this, "Mylyn Update Site", checked));
>+			return Observables.staticObservableList(repositories);
>+		}
>+	}
>+
>+	static class Repository extends Node {
>+		WritableList iuList;
>+		protected Pending pendingNode;
>+		private final IObservableSet checked;
>+
>+		Repository(Root root, String name, IObservableSet checkedElements) {
>+			super(root, name);
>+			checked = checkedElements;
>+		}
>+
>+		public IObservableList getIUList() {
>+			if (iuList == null) {
>+				iuList = new WritableList();
>+				iuList.setStale(true);
>+				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, "Bar"));
>+						bulkAdd.add(new IU(c1, "Bas"));
>+						bulkAdd.add(new IU(c1, "Foo"));
>+						bulkAdd.add(new IU(c1, "Meh"));
>+						bulkAdd.add(new IU(c1, "Moo"));
>+						Category c2 = new Category(Repository.this,
>+								"Beta Category");
>+						bulkAdd.add(new IU(c2, "Bar"));
>+						bulkAdd.add(new IU(c2, "Bas"));
>+						bulkAdd.add(new IU(c2, "Foo"));
>+						bulkAdd.add(new IU(c2, "Meh"));
>+						bulkAdd.add(new IU(c2, "Moo"));
>+						Category c3 = new Category(Repository.this,
>+								"Gamma Category");
>+						bulkAdd.add(new IU(c3, "Bar"));
>+						bulkAdd.add(new IU(c3, "Bas"));
>+						bulkAdd.add(new IU(c3, "Foo"));
>+						bulkAdd.add(new IU(c3, "Meh"));
>+						bulkAdd.add(new IU(c3, "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);
>+					}
>+				});
>+			}
>+			return iuList;
>+		}
>+
>+		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;
>+
>+	protected void createControls(Shell shell) {
>+		viewer = new CheckboxTreeViewer(shell);
>+		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) {
>+				for (Iterator it = event.diff.getAdditions().iterator(); it
>+						.hasNext();) {
>+					Object added = it.next();
>+					System.out.println("added element: " + added + ", checked="
>+							+ checkedElements.contains(added));
>+					if (checkedElements.contains(added)) {
>+						viewer.setChecked(added, true);
>+					}
>+				}
>+			}
>+		});
>+		viewer.setInput(new Root(checkedElements));
>+	}
>+
>+	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);
>+		}
>+	}
>+
>+}

Actions: View | Diff

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