Attachment 62175 Details for Bug 154571 – patch

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

[patch] patch

patch-154571.txt (text/plain), 28.86 KB, created by Boris Bokowski

on 2007-03-27 23:53:11 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Boris Bokowski

Created: 2007-03-27 23:53:11 EDT

Size: 28.86 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jface
>Index: src/org/eclipse/jface/viewers/TableViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/TableViewer.java,v
>retrieving revision 1.79
>diff -u -r1.79 TableViewer.java
>--- src/org/eclipse/jface/viewers/TableViewer.java	16 Mar 2007 18:01:01 -0000	1.79
>+++ src/org/eclipse/jface/viewers/TableViewer.java	28 Mar 2007 03:51:44 -0000
>@@ -311,11 +311,18 @@
> 	 */
> 	public void refresh(final Object element, final boolean updateLabels,
> 			boolean reveal) {
>-		preservingSelection(new Runnable() {
>-			public void run() {
>-				internalRefresh(element, updateLabels);
>-			}
>-		}, reveal);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					internalRefresh(element, updateLabels);
>+				}
>+			}, reveal);
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>Index: src/org/eclipse/jface/viewers/AbstractTreeViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/AbstractTreeViewer.java,v
>retrieving revision 1.114
>diff -u -r1.114 AbstractTreeViewer.java
>--- src/org/eclipse/jface/viewers/AbstractTreeViewer.java	16 Mar 2007 18:01:01 -0000	1.114
>+++ src/org/eclipse/jface/viewers/AbstractTreeViewer.java	28 Mar 2007 03:51:41 -0000
>@@ -127,15 +127,21 @@
> 	public void add(Object parentElementOrTreePath, Object[] childElements) {
> 		Assert.isNotNull(parentElementOrTreePath);
> 		assertElementsNotNull(childElements);
>-
>-		Widget[] widgets = internalFindItems(parentElementOrTreePath);
>-		// If parent hasn't been realized yet, just ignore the add.
>-		if (widgets.length == 0) {
>+		if (isBusy())
> 			return;
>-		}
>-
>-		for (int i = 0; i < widgets.length; i++) {
>-			internalAdd(widgets[i], parentElementOrTreePath, childElements);
>+		busy = true;
>+		try {
>+			Widget[] widgets = internalFindItems(parentElementOrTreePath);
>+			// If parent hasn't been realized yet, just ignore the add.
>+			if (widgets.length == 0) {
>+				return;
>+			}
>+	
>+			for (int i = 0; i < widgets.length; i++) {
>+				internalAdd(widgets[i], parentElementOrTreePath, childElements);
>+			}
>+		} finally {
>+			busy = false;
> 		}
> 	}
> 
>@@ -334,7 +340,7 @@
> 			int index;
> 			if (comparator == null) {
> 				if (itemExists(items, element)) {
>-					refresh(element);
>+					internalRefresh(element);
> 					newItem = false;
> 				}
> 				index = -1;
>@@ -355,7 +361,7 @@
> 						// any)
> 						if (items[lastInsertion].getData().equals(element)) {
> 							// refresh the element in case it has new children
>-							refresh(element);
>+							internalRefresh(element);
> 							newItem = false;
> 						}
> 						lastInsertion++;// We had an insertion so increment
>@@ -994,9 +1000,16 @@
> 	 *            levels of the tree
> 	 */
> 	public void expandToLevel(Object elementOrTreePath, int level) {
>-		Widget w = internalExpand(elementOrTreePath, true);
>-		if (w != null) {
>-			internalExpandToLevel(w, level);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			Widget w = internalExpand(elementOrTreePath, true);
>+			if (w != null) {
>+				internalExpandToLevel(w, level);
>+			}
>+		} finally {
>+			busy = false;
> 		}
> 	}
> 
>@@ -2047,11 +2060,18 @@
> 		if (elementsOrTreePaths.length == 0) {
> 			return;
> 		}
>-		preservingSelection(new Runnable() {
>-			public void run() {
>-				internalRemove(elementsOrTreePaths);
>-			}
>-		});
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					internalRemove(elementsOrTreePaths);
>+				}
>+			});
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>@@ -2077,11 +2097,18 @@
> 		if (elements.length == 0) {
> 			return;
> 		}
>-		preservingSelection(new Runnable() {
>-			public void run() {
>-				internalRemove(parent, elements);
>-			}
>-		});
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					internalRemove(parent, elements);
>+				}
>+			});
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>@@ -2229,21 +2256,29 @@
> 	 */
> 	public void setExpandedElements(Object[] elements) {
> 		assertElementsNotNull(elements);
>-		CustomHashtable expandedElements = newHashtable(elements.length * 2 + 1);
>-		for (int i = 0; i < elements.length; ++i) {
>-			Object element = elements[i];
>-			// Ensure item exists for element. This will materialize items for
>-			// each element and their parents, if possible. This is important
>-			// to support expanding of inner tree nodes without necessarily
>-			// expanding their parents.
>-			internalExpand(element, false);
>-			expandedElements.put(element, element);
>-		}
>-		// this will traverse all existing items, and create children for
>-		// elements that need to be expanded. If the tree contains multiple
>-		// equal elements, and those are in the set of elements to be expanded,
>-		// only the first item found for each element will be expanded.
>-		internalSetExpanded(expandedElements, getControl());
>+		if (isBusy()) {
>+			return;
>+		}
>+		busy = true;
>+		try {
>+			CustomHashtable expandedElements = newHashtable(elements.length * 2 + 1);
>+			for (int i = 0; i < elements.length; ++i) {
>+				Object element = elements[i];
>+				// Ensure item exists for element. This will materialize items for
>+				// each element and their parents, if possible. This is important
>+				// to support expanding of inner tree nodes without necessarily
>+				// expanding their parents.
>+				internalExpand(element, false);
>+				expandedElements.put(element, element);
>+			}
>+			// this will traverse all existing items, and create children for
>+			// elements that need to be expanded. If the tree contains multiple
>+			// equal elements, and those are in the set of elements to be expanded,
>+			// only the first item found for each element will be expanded.
>+			internalSetExpanded(expandedElements, getControl());
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>@@ -2263,34 +2298,41 @@
> 	 */
> 	public void setExpandedTreePaths(TreePath[] treePaths) {
> 		assertElementsNotNull(treePaths);
>-		final IElementComparer comparer = getComparer();
>-		IElementComparer treePathComparer = new IElementComparer() {
>-
>-			public boolean equals(Object a, Object b) {
>-				return ((TreePath) a).equals(((TreePath) b), comparer);
>-			}
>-
>-			public int hashCode(Object element) {
>-				return ((TreePath) element).hashCode(comparer);
>-			}
>-		};
>-		CustomHashtable expandedTreePaths = new CustomHashtable(
>-				treePaths.length * 2 + 1, treePathComparer);
>-		for (int i = 0; i < treePaths.length; ++i) {
>-			TreePath treePath = treePaths[i];
>-			// Ensure item exists for element. This will materialize items for
>-			// each element and their parents, if possible. This is important
>-			// to support expanding of inner tree nodes without necessarily
>-			// expanding their parents.
>-			internalExpand(treePath, false);
>-			expandedTreePaths.put(treePath, treePath);
>-		}
>-		// this will traverse all existing items, and create children for
>-		// elements that need to be expanded. If the tree contains multiple
>-		// equal elements, and those are in the set of elements to be expanded,
>-		// only the first item found for each element will be expanded.
>-		internalSetExpandedTreePaths(expandedTreePaths, getControl(),
>-				new TreePath(new Object[0]));
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			final IElementComparer comparer = getComparer();
>+			IElementComparer treePathComparer = new IElementComparer() {
>+	
>+				public boolean equals(Object a, Object b) {
>+					return ((TreePath) a).equals(((TreePath) b), comparer);
>+				}
>+	
>+				public int hashCode(Object element) {
>+					return ((TreePath) element).hashCode(comparer);
>+				}
>+			};
>+			CustomHashtable expandedTreePaths = new CustomHashtable(
>+					treePaths.length * 2 + 1, treePathComparer);
>+			for (int i = 0; i < treePaths.length; ++i) {
>+				TreePath treePath = treePaths[i];
>+				// Ensure item exists for element. This will materialize items for
>+				// each element and their parents, if possible. This is important
>+				// to support expanding of inner tree nodes without necessarily
>+				// expanding their parents.
>+				internalExpand(treePath, false);
>+				expandedTreePaths.put(treePath, treePath);
>+			}
>+			// this will traverse all existing items, and create children for
>+			// elements that need to be expanded. If the tree contains multiple
>+			// equal elements, and those are in the set of elements to be expanded,
>+			// only the first item found for each element will be expanded.
>+			internalSetExpandedTreePaths(expandedTreePaths, getControl(),
>+					new TreePath(new Object[0]));
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>@@ -2305,12 +2347,19 @@
> 	 */
> 	public void setExpandedState(Object elementOrTreePath, boolean expanded) {
> 		Assert.isNotNull(elementOrTreePath);
>-		Widget item = internalExpand(elementOrTreePath, false);
>-		if (item instanceof Item) {
>-			if (expanded) {
>-				createChildren(item);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			Widget item = internalExpand(elementOrTreePath, false);
>+			if (item instanceof Item) {
>+				if (expanded) {
>+					createChildren(item);
>+				}
>+				setExpanded((Item) item, expanded);
> 			}
>-			setExpanded((Item) item, expanded);
>+		} finally {
>+			busy = false;
> 		}
> 	}
> 
>@@ -2789,42 +2838,48 @@
> 			int position) {
> 		Assert.isNotNull(parentElementOrTreePath);
> 		Assert.isNotNull(element);
>-
>-		if (getComparator() != null || hasFilters()) {
>-			add(parentElementOrTreePath, new Object[] { element });
>+		if (isBusy())
> 			return;
>-		}
>-		Widget[] items;
>-		if (internalIsInputOrEmptyPath(parentElementOrTreePath)) {
>-			items = new Widget[] { getControl() };
>-		} else {
>-			items = internalFindItems(parentElementOrTreePath);
>-		}
>-
>-		for (int i = 0; i < items.length; i++) {
>-			Widget widget = items[i];
>-			if (widget instanceof Item) {
>-				Item item = (Item) widget;
>-
>-				Item[] childItems = getChildren(item);
>-				if (getExpanded(item)
>-						|| (childItems.length > 0 && childItems[0].getData() != null)) {
>-					// item has real children, go ahead and add
>+		busy = true;
>+		try {
>+			if (getComparator() != null || hasFilters()) {
>+				add(parentElementOrTreePath, new Object[] { element });
>+				return;
>+			}
>+			Widget[] items;
>+			if (internalIsInputOrEmptyPath(parentElementOrTreePath)) {
>+				items = new Widget[] { getControl() };
>+			} else {
>+				items = internalFindItems(parentElementOrTreePath);
>+			}
>+	
>+			for (int i = 0; i < items.length; i++) {
>+				Widget widget = items[i];
>+				if (widget instanceof Item) {
>+					Item item = (Item) widget;
>+	
>+					Item[] childItems = getChildren(item);
>+					if (getExpanded(item)
>+							|| (childItems.length > 0 && childItems[0].getData() != null)) {
>+						// item has real children, go ahead and add
>+						int insertionPosition = position;
>+						if (insertionPosition == -1) {
>+							insertionPosition = getItemCount(item);
>+						}
>+	
>+						createTreeItem(item, element, insertionPosition);
>+					}
>+				} else {
> 					int insertionPosition = position;
> 					if (insertionPosition == -1) {
>-						insertionPosition = getItemCount(item);
>+						insertionPosition = getItemCount((Control) widget);
> 					}
>-
>-					createTreeItem(item, element, insertionPosition);
>-				}
>-			} else {
>-				int insertionPosition = position;
>-				if (insertionPosition == -1) {
>-					insertionPosition = getItemCount((Control) widget);
>+	
>+					createTreeItem(widget, element, insertionPosition);
> 				}
>-
>-				createTreeItem(widget, element, insertionPosition);
> 			}
>+		} finally {
>+			busy = false;
> 		}
> 	}
> 
>Index: src/org/eclipse/jface/viewers/TreeViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/TreeViewer.java,v
>retrieving revision 1.82
>diff -u -r1.82 TreeViewer.java
>--- src/org/eclipse/jface/viewers/TreeViewer.java	16 Mar 2007 19:59:48 -0000	1.82
>+++ src/org/eclipse/jface/viewers/TreeViewer.java	28 Mar 2007 03:51:44 -0000
>@@ -376,19 +376,26 @@
> 	 * @since 3.2
> 	 */
> 	public void setChildCount(final Object elementOrTreePath, final int count) {
>-		preservingSelection(new Runnable() {
>-			public void run() {
>-				if (internalIsInputOrEmptyPath(elementOrTreePath)) {
>-					getTree().setItemCount(count);
>-					return;
>-				}
>-				Widget[] items = internalFindItems(elementOrTreePath);
>-				for (int i = 0; i < items.length; i++) {
>-					TreeItem treeItem = (TreeItem) items[i];
>-					treeItem.setItemCount(count);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					if (internalIsInputOrEmptyPath(elementOrTreePath)) {
>+						getTree().setItemCount(count);
>+						return;
>+					}
>+					Widget[] items = internalFindItems(elementOrTreePath);
>+					for (int i = 0; i < items.length; i++) {
>+						TreeItem treeItem = (TreeItem) items[i];
>+						treeItem.setItemCount(count);
>+					}
> 				}
>-			}
>-		});
>+			});
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>@@ -417,24 +424,31 @@
> 	 */
> 	public void replace(final Object parentElementOrTreePath, final int index,
> 			final Object element) {
>-		preservingSelection(new Runnable() {
>-			public void run() {
>-				if (internalIsInputOrEmptyPath(parentElementOrTreePath)) {
>-					if (index < tree.getItemCount()) {
>-						updateItem(tree.getItem(index), element);
>-					}
>-				} else {
>-					Widget[] parentItems = internalFindItems(parentElementOrTreePath);
>-					for (int i = 0; i < parentItems.length; i++) {
>-						TreeItem parentItem = (TreeItem) parentItems[i];
>-						if (index < parentItem.getItemCount()) {
>-							updateItem(parentItem.getItem(index), element);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					if (internalIsInputOrEmptyPath(parentElementOrTreePath)) {
>+						if (index < tree.getItemCount()) {
>+							updateItem(tree.getItem(index), element);
>+						}
>+					} else {
>+						Widget[] parentItems = internalFindItems(parentElementOrTreePath);
>+						for (int i = 0; i < parentItems.length; i++) {
>+							TreeItem parentItem = (TreeItem) parentItems[i];
>+							if (index < parentItem.getItemCount()) {
>+								updateItem(parentItem.getItem(index), element);
>+							}
> 						}
> 					}
> 				}
>-			}
>-
>-		});
>+				
>+			});
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	public boolean isExpandable(Object element) {
>@@ -702,32 +716,39 @@
> 	 * @since 3.3
> 	 */
> 	public void remove(final Object parentOrTreePath, final int index) {
>-		preservingSelection(new Runnable() {
>-			public void run() {
>-				if (internalIsInputOrEmptyPath(parentOrTreePath)) {
>-					Tree tree = (Tree) getControl();
>-					if (index < tree.getItemCount()) {
>-						TreeItem item = tree.getItem(index);
>-						if (item.getData() != null) {
>-							disassociate(item);
>-						}
>-						item.dispose();
>-					}
>-				} else {
>-					Widget[] parentItems = internalFindItems(parentOrTreePath);
>-					for (int i = 0; i < parentItems.length; i++) {
>-						TreeItem parentItem = (TreeItem) parentItems[i];
>-						if (index < parentItem.getItemCount()) {
>-							TreeItem item = parentItem.getItem(index);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					if (internalIsInputOrEmptyPath(parentOrTreePath)) {
>+						Tree tree = (Tree) getControl();
>+						if (index < tree.getItemCount()) {
>+							TreeItem item = tree.getItem(index);
> 							if (item.getData() != null) {
> 								disassociate(item);
> 							}
> 							item.dispose();
> 						}
>+					} else {
>+						Widget[] parentItems = internalFindItems(parentOrTreePath);
>+						for (int i = 0; i < parentItems.length; i++) {
>+							TreeItem parentItem = (TreeItem) parentItems[i];
>+							if (index < parentItem.getItemCount()) {
>+								TreeItem item = parentItem.getItem(index);
>+								if (item.getData() != null) {
>+									disassociate(item);
>+								}
>+								item.dispose();
>+							}
>+						}
> 					}
> 				}
>-			}
>-		});
>+			});
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 	
> 	/* (non-Javadoc)
>@@ -772,37 +793,44 @@
> 	 * @since 3.3
> 	 */
> 	public void setHasChildren(final Object elementOrTreePath, final boolean hasChildren) {
>-		preservingSelection(new Runnable() {
>-			public void run() {
>-				if (internalIsInputOrEmptyPath(elementOrTreePath)) {
>-					if (hasChildren) {
>-						virtualLazyUpdateChildCount(getTree(),
>-								getChildren(getTree()).length);
>-					} else {
>-						setChildCount(elementOrTreePath, 0);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					if (internalIsInputOrEmptyPath(elementOrTreePath)) {
>+						if (hasChildren) {
>+							virtualLazyUpdateChildCount(getTree(),
>+									getChildren(getTree()).length);
>+						} else {
>+							setChildCount(elementOrTreePath, 0);
>+						}
>+						return;
> 					}
>-					return;
>-				}
>-				Widget[] items = internalFindItems(elementOrTreePath);
>-				for (int i = 0; i < items.length; i++) {
>-					TreeItem item = (TreeItem) items[i];
>-					if (!hasChildren) {
>-						item.setItemCount(0);
>-					} else {
>-						if (!item.getExpanded()) {
>-							item.setItemCount(1);
>-							TreeItem child = item.getItem(0);
>-							if (child.getData() != null) {
>-								disassociate(child);
>-							}
>-							item.clear(0, true);
>+					Widget[] items = internalFindItems(elementOrTreePath);
>+					for (int i = 0; i < items.length; i++) {
>+						TreeItem item = (TreeItem) items[i];
>+						if (!hasChildren) {
>+							item.setItemCount(0);
> 						} else {
>-                            virtualLazyUpdateChildCount(item, item.getItemCount());
>-                        }                            
>+							if (!item.getExpanded()) {
>+								item.setItemCount(1);
>+								TreeItem child = item.getItem(0);
>+								if (child.getData() != null) {
>+									disassociate(child);
>+								}
>+								item.clear(0, true);
>+							} else {
>+								virtualLazyUpdateChildCount(item, item.getItemCount());
>+							}                            
>+						}
> 					}
> 				}
>-			}
>-		});
>+			});
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>@@ -811,23 +839,29 @@
> 	 * @param index
> 	 */
> 	private void virtualLazyUpdateWidget(Widget widget, int index) {
>-		if (contentProviderIsTreeBased) {
>-			TreePath treePath;
>-			if (widget instanceof Item) {
>-				if (widget.getData() == null) {
>-					// temporary fix to avoid a NPE (the tree will still be screwed up)
>-					// see bug 167668
>-					return;
>+		boolean oldBusy = busy;
>+		busy = false;
>+		try {
>+			if (contentProviderIsTreeBased) {
>+				TreePath treePath;
>+				if (widget instanceof Item) {
>+					if (widget.getData() == null) {
>+						// temporary fix to avoid a NPE (the tree will still be screwed up)
>+						// see bug 167668
>+						return;
>+					}
>+					treePath = getTreePathFromItem((Item) widget);
>+				} else {
>+					treePath = TreePath.EMPTY;
> 				}
>-				treePath = getTreePathFromItem((Item) widget);
>+				((ILazyTreePathContentProvider) getContentProvider())
>+				.updateElement(treePath, index);
> 			} else {
>-				treePath = TreePath.EMPTY;
>+				((ILazyTreeContentProvider) getContentProvider()).updateElement(
>+						widget.getData(), index);
> 			}
>-			((ILazyTreePathContentProvider) getContentProvider())
>-					.updateElement(treePath, index);
>-		} else {
>-			((ILazyTreeContentProvider) getContentProvider()).updateElement(
>-					widget.getData(), index);
>+		} finally {
>+			busy = oldBusy;
> 		}
> 	}
> 
>@@ -837,17 +871,23 @@
> 	 * @param currentChildCount
> 	 */
> 	private void virtualLazyUpdateChildCount(Widget widget, int currentChildCount) {
>-		if (contentProviderIsTreeBased) {
>-			TreePath treePath;
>-			if (widget instanceof Item) {
>-				treePath = getTreePathFromItem((Item) widget);
>+		boolean oldBusy = busy;
>+		busy = false;
>+		try {
>+			if (contentProviderIsTreeBased) {
>+				TreePath treePath;
>+				if (widget instanceof Item) {
>+					treePath = getTreePathFromItem((Item) widget);
>+				} else {
>+					treePath = TreePath.EMPTY;
>+				}
>+				((ILazyTreePathContentProvider) getContentProvider())
>+						.updateChildCount(treePath, currentChildCount);
> 			} else {
>-				treePath = TreePath.EMPTY;
>+				((ILazyTreeContentProvider) getContentProvider()).updateChildCount(widget.getData(), currentChildCount);
> 			}
>-			((ILazyTreePathContentProvider) getContentProvider())
>-					.updateChildCount(treePath, currentChildCount);
>-		} else {
>-			((ILazyTreeContentProvider) getContentProvider()).updateChildCount(widget.getData(), currentChildCount);
>+		} finally {
>+			busy = oldBusy;
> 		}
> 	}
> 	
>@@ -857,19 +897,25 @@
> 	 * @param currentChildCount
> 	 */
> 	private void virtualLazyUpdateHasChildren(Item item, int currentChildCount) {
>-		if (contentProviderIsTreeBased) {
>-			TreePath treePath;
>-			treePath = getTreePathFromItem(item);
>-			if (currentChildCount == 0) {
>-				// item is not expanded (but may have a plus currently)
>-				((ILazyTreePathContentProvider) getContentProvider())
>-						.updateHasChildren(treePath);
>+		boolean oldBusy = busy;
>+		busy = false;
>+		try {
>+			if (contentProviderIsTreeBased) {
>+				TreePath treePath;
>+				treePath = getTreePathFromItem(item);
>+				if (currentChildCount == 0) {
>+					// item is not expanded (but may have a plus currently)
>+					((ILazyTreePathContentProvider) getContentProvider())
>+					.updateHasChildren(treePath);
>+				} else {
>+					((ILazyTreePathContentProvider) getContentProvider())
>+					.updateChildCount(treePath, currentChildCount);
>+				}
> 			} else {
>-				((ILazyTreePathContentProvider) getContentProvider())
>-						.updateChildCount(treePath, currentChildCount);
>+				((ILazyTreeContentProvider) getContentProvider()).updateChildCount(item.getData(), currentChildCount);
> 			}
>-		} else {
>-			((ILazyTreeContentProvider) getContentProvider()).updateChildCount(item.getData(), currentChildCount);
>+		} finally {
>+			busy = oldBusy;
> 		}
> 	}
> 
>Index: src/org/eclipse/jface/viewers/AbstractTableViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/AbstractTableViewer.java,v
>retrieving revision 1.8
>diff -u -r1.8 AbstractTableViewer.java
>--- src/org/eclipse/jface/viewers/AbstractTableViewer.java	21 Mar 2007 15:46:16 -0000	1.8
>+++ src/org/eclipse/jface/viewers/AbstractTableViewer.java	28 Mar 2007 03:51:39 -0000
>@@ -239,12 +239,19 @@
> 	 */
> 	public void add(Object[] elements) {
> 		assertElementsNotNull(elements);
>-		Object[] filtered = filter(elements);
>-
>-		for (int i = 0; i < filtered.length; i++) {
>-			Object element = filtered[i];
>-			int index = indexForElement(element);
>-			createItem(element, index);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			Object[] filtered = filter(elements);
>+			
>+			for (int i = 0; i < filtered.length; i++) {
>+				Object element = filtered[i];
>+				int index = indexForElement(element);
>+				createItem(element, index);
>+			}
>+		} finally {
>+			busy = false;
> 		}
> 	}
> 
>@@ -541,8 +548,11 @@
> 	protected void inputChanged(Object input, Object oldInput) {
> 		getControl().setRedraw(false);
> 		try {
>-			// refresh() attempts to preserve selection, which we want here
>-			refresh();
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					internalRefresh(getRoot());
>+				}
>+			});
> 		} finally {
> 			getControl().setRedraw(true);
> 		}
>@@ -573,8 +583,14 @@
> 		if (position == -1) {
> 			position = doGetItemCount();
> 		}
>-
>-		createItem(element, position);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			createItem(element, position);
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/*
>@@ -719,6 +735,7 @@
> 		Object input = getInput();
> 		for (int i = 0; i < elements.length; ++i) {
> 			if (equals(elements[i], input)) {
>+				busy = false;
> 				setInput(null);
> 				return;
> 			}
>@@ -769,14 +786,21 @@
> 	 */
> 	public void remove(final Object[] elements) {
> 		assertElementsNotNull(elements);
>-		if (elements.length == 0) {
>+		if (isBusy())
> 			return;
>-		}
>-		preservingSelection(new Runnable() {
>-			public void run() {
>-				internalRemove(elements);
>+		busy = true;
>+		try {
>+			if (elements.length == 0) {
>+				return;
> 			}
>-		});
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					internalRemove(elements);
>+				}
>+			});
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>@@ -960,21 +984,28 @@
> 	 * @since 3.1
> 	 */
> 	public void setItemCount(int count) {
>-		int oldCount = doGetItemCount();
>-		if (count < oldCount) {
>-			// need to disassociate elements that are being disposed
>-			for (int i = count; i < oldCount; i++) {
>-				Item item = doGetItem(i);
>-				if (item.getData() != null) {
>-					disassociate(item);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			int oldCount = doGetItemCount();
>+			if (count < oldCount) {
>+				// need to disassociate elements that are being disposed
>+				for (int i = count; i < oldCount; i++) {
>+					Item item = doGetItem(i);
>+					if (item.getData() != null) {
>+						disassociate(item);
>+					}
> 				}
> 			}
>+			doSetItemCount(count);
>+			if (virtualManager != null) {
>+				virtualManager.adjustCacheSize(count);
>+			}
>+			getControl().redraw();
>+		} finally {
>+			busy = false;
> 		}
>-		doSetItemCount(count);
>-		if (virtualManager != null) {
>-			virtualManager.adjustCacheSize(count);
>-		}
>-		getControl().redraw();
> 	}
> 
> 	/**
>@@ -990,8 +1021,15 @@
> 	 * @since 3.1
> 	 */
> 	public void replace(Object element, int index) {
>-		Item item = doGetItem(index);
>-		refreshItem(item, element);
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			Item item = doGetItem(index);
>+			refreshItem(item, element);
>+		} finally {
>+			busy = false;
>+		}
> 	}
> 
> 	/**
>Index: src/org/eclipse/jface/viewers/ColumnViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/ColumnViewer.java,v
>retrieving revision 1.29
>diff -u -r1.29 ColumnViewer.java
>--- src/org/eclipse/jface/viewers/ColumnViewer.java	21 Mar 2007 15:46:16 -0000	1.29
>+++ src/org/eclipse/jface/viewers/ColumnViewer.java	28 Mar 2007 03:51:42 -0000
>@@ -16,6 +16,9 @@
> 
> 
> import org.eclipse.core.runtime.Assert;
>+import org.eclipse.core.runtime.IStatus;
>+import org.eclipse.core.runtime.Status;
>+import org.eclipse.jface.util.Policy;
> import org.eclipse.swt.events.MouseAdapter;
> import org.eclipse.swt.events.MouseEvent;
> import org.eclipse.swt.graphics.Point;
>@@ -48,6 +51,8 @@
> 	private ViewerCell cell = new ViewerCell(null, 0);
> 
> 	private ColumnViewerEditor viewerEditor;
>+	
>+	/* package */ boolean busy;
> 
> 	/**
> 	 * Create a new instance of the receiver.
>@@ -56,6 +61,18 @@
> 
> 	}
> 
>+	/* package */ boolean isBusy() {
>+		if (busy) {
>+			Policy.getLog().log(
>+				new Status(
>+					IStatus.WARNING,
>+					Policy.JFACE,
>+					"Ignoring reentrant call while viewer is busy", new RuntimeException())); //$NON-NLS-1$
>+			return true;
>+		}
>+		return false;
>+	}
>+
> 	protected void hookControl(Control control) {
> 		super.hookControl(control);
> 		viewerEditor = createViewerEditor();
>@@ -457,6 +474,39 @@
> 		}
> 		return false;
> 	}
>+	
>+	public void refresh(Object element) {
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			super.refresh(element);
>+		} finally {
>+			busy = false;
>+		}
>+	}
>+	
>+	public void refresh(Object element, boolean updateLabels) {
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			super.refresh(element, updateLabels);
>+		} finally {
>+			busy = false;
>+		}
>+	}
>+	
>+	public void update(Object element, String[] properties) {
>+		if (isBusy())
>+			return;
>+		busy = true;
>+		try {
>+			super.update(element, properties);
>+		} finally {
>+			busy = false;
>+		}
>+	}
> 
> 	/**
> 	 * Sets the cell editors of this column viewer. If editing is not supported
>Index: src/org/eclipse/jface/viewers/StructuredViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/StructuredViewer.java,v
>retrieving revision 1.60
>diff -u -r1.60 StructuredViewer.java
>--- src/org/eclipse/jface/viewers/StructuredViewer.java	19 Mar 2007 21:00:38 -0000	1.60
>+++ src/org/eclipse/jface/viewers/StructuredViewer.java	28 Mar 2007 03:51:44 -0000
>@@ -1999,7 +1999,11 @@
> 			}
> 		}
> 		if (needsRefilter) {
>-			refresh();
>+			preservingSelection(new Runnable() {
>+				public void run() {
>+					internalRefresh(getRoot());
>+				}
>+			});
> 			return;
> 		}
>

Actions: View | Diff

Attachments on bug 154571: 62175 | 62287 | 65145