Attachment #65145 for bug #154571

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

Lines 17-23 Link Here

(-)src/org/eclipse/jface/viewers/TableViewer.java (-2 / +5 lines)
17		17
18	import org.eclipse.core.runtime.Assert;	18	import org.eclipse.core.runtime.Assert;
19	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.graphics.Image;
21	import org.eclipse.swt.graphics.Point;	20	import org.eclipse.swt.graphics.Point;
22	import org.eclipse.swt.widgets.Composite;	21	import org.eclipse.swt.widgets.Composite;
23	import org.eclipse.swt.widgets.Control;	22	import org.eclipse.swt.widgets.Control;
Lines 232-239 Link Here
232	int columnCount = Math.max(1, table.getColumnCount());	231	int columnCount = Math.max(1, table.getColumnCount());
233	for (int i = 0; i < columnCount; i++) {	232	for (int i = 0; i < columnCount; i++) {
234	tableItem.setText(i, ""); //$NON-NLS-1$	233	tableItem.setText(i, ""); //$NON-NLS-1$
		234	if (tableItem.getImage(i) != null) {
		235	tableItem.setImage(i, null);
		236	}
235	}	237	}
236	tableItem.setImage(new Image[columnCount]);// Clear all images
237	}	238	}
238		239
239	protected void doRemove(int start, int end) {	240	protected void doRemove(int start, int end) {
Lines 311-316 Link Here
311	*/	312	*/
312	public void refresh(final Object element, final boolean updateLabels,	313	public void refresh(final Object element, final boolean updateLabels,
313	boolean reveal) {	314	boolean reveal) {
		315	if (isBusy())
		316	return;
314	preservingSelection(new Runnable() {	317	preservingSelection(new Runnable() {
315	public void run() {	318	public void run() {
316	internalRefresh(element, updateLabels);	319	internalRefresh(element, updateLabels);




	public void add(Object parentElementOrTreePath, Object[] childElements) {
		Assert.isNotNull(parentElementOrTreePath);
		assertElementsNotNull(childElements);
		if (isBusy())
			return;
		Widget[] widgets = internalFindItems(parentElementOrTreePath);
		// If parent hasn't been realized yet, just ignore the add.
		if (widgets.length == 0) {

			int index;
			if (comparator == null) {
				if (itemExists(items, element)) {
					internalRefresh(element);
					newItem = false;
				}
				index = -1;

						// any)
						if (items[lastInsertion].getData().equals(element)) {
							// refresh the element in case it has new children
							internalRefresh(element);
							newItem = false;
						}
						lastInsertion++;// We had an insertion so increment

	 *            the widget
	 */
	protected void createChildren(final Widget widget) {
		boolean oldBusy = busy;
		busy = true;
		try {
			final Item[] tis = getChildren(widget);
			if (tis != null && tis.length > 0) {
				Object data = tis[0].getData();
				if (data != null) {
					return; // children already there!
				}
			}
	
			BusyIndicator.showWhile(widget.getDisplay(), new Runnable() {
				public void run() {
					// fix for PR 1FW89L7:
					// don't complain and remove all "dummies" ...
					if (tis != null) {
						for (int i = 0; i < tis.length; i++) {
							if (tis[i].getData() != null) {
								disassociate(tis[i]);
								Assert.isTrue(tis[i].getData() == null,
										"Second or later child is non -null");//$NON-NLS-1$
	
							}
							tis[i].dispose();
						}
						tis[i].dispose();
					}
					Object d = widget.getData();
					if (d != null) {
						Object parentElement = d;
						Object[] children;
						if (isTreePathContentProvider() && widget instanceof Item) {
							TreePath path = getTreePathFromItem((Item) widget);
							children = getSortedChildren(path);
						} else {
							children = getSortedChildren(parentElement);
						}
						for (int i = 0; i < children.length; i++) {
							createTreeItem(widget, children[i], -1);
						}
					}
				}
	
			});
		} finally {
			busy = oldBusy;
		}
	}

	/**

	
	/* (non-Javadoc) Method declared on StructuredViewer. */
	protected void doUpdateItem(Widget widget, Object element, boolean fullMap) {
		boolean oldBusy = busy;
		busy = true;
		try {
			if (widget instanceof Item) {
				Item item = (Item) widget;
				
				// ensure that back pointer is correct
				if (fullMap) {
					associate(element, item);
				} else {
					Object data = item.getData();
					if (data != null) {
						unmapElement(data, item);
					}
					item.setData(element);
					mapElement(element, item);
				}
				
				// update icon and label
				SafeRunnable.run(new UpdateItemSafeRunnable(item, element));
			}
		} finally {
			busy = oldBusy;
			SafeRunnable.run(new UpdateItemSafeRunnable(item, element));
		}
	}


	 *            levels of the tree
	 */
	public void expandToLevel(Object elementOrTreePath, int level) {
		if (isBusy())
			return;
		Widget w = internalExpand(elementOrTreePath, true);
		if (w != null) {
			internalExpandToLevel(w, level);


	/* (non-Javadoc) Method declared on StructuredViewer. */
	protected Object[] getRawChildren(Object parentElementOrTreePath) {
		boolean oldBusy = busy;
		busy = true;
		try {
			Object parent;
			TreePath path;
			if (parentElementOrTreePath instanceof TreePath) {
				path = (TreePath) parentElementOrTreePath;
				parent = path.getLastSegment();
			} else {
				parent = parentElementOrTreePath;
				path = null;
			}
			if (parent != null) {
				if (equals(parent, getRoot())) {
					return super.getRawChildren(parent);
				}
				IContentProvider cp = getContentProvider();
				if (cp instanceof ITreePathContentProvider) {
					ITreePathContentProvider tpcp = (ITreePathContentProvider) cp;
					if (w instanceof Item) {
						Item item = (Item) w;
						path = getTreePathFromItem(item);
					}
					if (path == null) {
						// A path was not provided so try and find one
						Widget w = findItem(parent);
						if (w instanceof Item) {
							Item item = (Item) w;
							path = getTreePathFromItem(item);
						}
						if (path == null) {
							path = new TreePath(new Object[] { parent });
						}
					}
					Object[] result = tpcp.getChildren(path);
					if (result != null) {
						return result;
					}
				} else if (cp instanceof ITreeContentProvider) {
					ITreeContentProvider tcp = (ITreeContentProvider) cp;
					Object[] result = tcp.getChildren(parent);
					if (result != null) {
						return result;
					}
				}
				Object[] result = tpcp.getChildren(path);
				if (result != null) {
					return result;
				}
			} else if (cp instanceof ITreeContentProvider) {
				ITreeContentProvider tcp = (ITreeContentProvider) cp;
				Object[] result = tcp.getChildren(parent);
				if (result != null) {
					return result;
				}
			}
			return new Object[0];
		} finally {
			busy = oldBusy;
		}
		return new Object[0];
	}

	/**

		if (elementsOrTreePaths.length == 0) {
			return;
		}
		if (isBusy())
			return;
		preservingSelection(new Runnable() {
			public void run() {
				internalRemove(elementsOrTreePaths);

		if (elements.length == 0) {
			return;
		}
		if (isBusy())
			return;
		preservingSelection(new Runnable() {
			public void run() {
				internalRemove(parent, elements);

	 */
	public void setExpandedElements(Object[] elements) {
		assertElementsNotNull(elements);
		if (isBusy()) {
			return;
		}
		CustomHashtable expandedElements = newHashtable(elements.length * 2 + 1);
		for (int i = 0; i < elements.length; ++i) {
			Object element = elements[i];

	 */
	public void setExpandedTreePaths(TreePath[] treePaths) {
		assertElementsNotNull(treePaths);
		if (isBusy())
			return;
		final IElementComparer comparer = getComparer();
		IElementComparer treePathComparer = new IElementComparer() {


	 */
	public void setExpandedState(Object elementOrTreePath, boolean expanded) {
		Assert.isNotNull(elementOrTreePath);
		if (isBusy())
			return;
		Widget item = internalExpand(elementOrTreePath, false);
		if (item instanceof Item) {
			if (expanded) {

			int position) {
		Assert.isNotNull(parentElementOrTreePath);
		Assert.isNotNull(element);
		if (isBusy())
			return;
		if (getComparator() != null || hasFilters()) {
			add(parentElementOrTreePath, new Object[] { element });
			return;

Lines 393-398 Link Here

(-)src/org/eclipse/jface/viewers/TreeViewer.java (-50 / +82 lines)
393	* @since 3.2	393	* @since 3.2
394	*/	394	*/
395	public void setChildCount(final Object elementOrTreePath, final int count) {	395	public void setChildCount(final Object elementOrTreePath, final int count) {
		396	if (isBusy())
		397	return;
396	preservingSelection(new Runnable() {	398	preservingSelection(new Runnable() {
397	public void run() {	399	public void run() {
398	if (internalIsInputOrEmptyPath(elementOrTreePath)) {	400	if (internalIsInputOrEmptyPath(elementOrTreePath)) {
Lines 434-439 Link Here
434	*/	436	*/
435	public void replace(final Object parentElementOrTreePath, final int index,	437	public void replace(final Object parentElementOrTreePath, final int index,
436	final Object element) {	438	final Object element) {
		439	if (isBusy())
		440	return;
437	preservingSelection(new Runnable() {	441	preservingSelection(new Runnable() {
438	public void run() {	442	public void run() {
439	Widget[] itemsToDisassociate;	443	Widget[] itemsToDisassociate;
Lines 508-526 Link Here
508	}	512	}
509		513
510	protected Object getParentElement(Object element) {	514	protected Object getParentElement(Object element) {
511	if (contentProviderIsLazy && !contentProviderIsTreeBased && !(element instanceof TreePath)) {	515	boolean oldBusy = busy;
512	ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();	516	busy = true;
513	return lazyTreeContentProvider.getParent(element);	517	try {
514	}	518	if (contentProviderIsLazy && !contentProviderIsTreeBased && !(element instanceof TreePath)) {
515	if (contentProviderIsLazy && contentProviderIsTreeBased && !(element instanceof TreePath)) {	519	ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();
516	ILazyTreePathContentProvider lazyTreePathContentProvider = (ILazyTreePathContentProvider) getContentProvider();	520	return lazyTreeContentProvider.getParent(element);
517	TreePath[] parents = lazyTreePathContentProvider	521	}
518	.getParents(element);	522	if (contentProviderIsLazy && contentProviderIsTreeBased && !(element instanceof TreePath)) {
519	if (parents != null && parents.length > 0) {	523	ILazyTreePathContentProvider lazyTreePathContentProvider = (ILazyTreePathContentProvider) getContentProvider();
520	return parents[0];	524	TreePath[] parents = lazyTreePathContentProvider
521	}	525	.getParents(element);
		526	if (parents != null && parents.length > 0) {
		527	return parents[0];
		528	}
		529	}
		530	return super.getParentElement(element);
		531	} finally {
		532	busy = oldBusy;
522	}	533	}
523	return super.getParentElement(element);
524	}	534	}
525		535
526	protected void createChildren(Widget widget) {	536	protected void createChildren(Widget widget) {
Lines 770-775 Link Here
770	* @since 3.3	780	* @since 3.3
771	*/	781	*/
772	public void remove(final Object parentOrTreePath, final int index) {	782	public void remove(final Object parentOrTreePath, final int index) {
		783	if (isBusy())
		784	return;
773	final List oldSelection = new LinkedList(Arrays	785	final List oldSelection = new LinkedList(Arrays
774	.asList(((TreeSelection) getSelection()).getPaths()));	786	.asList(((TreeSelection) getSelection()).getPaths()));
775	preservingSelection(new Runnable() {	787	preservingSelection(new Runnable() {
Lines 864-869 Link Here
864	* @since 3.3	876	* @since 3.3
865	*/	877	*/
866	public void setHasChildren(final Object elementOrTreePath, final boolean hasChildren) {	878	public void setHasChildren(final Object elementOrTreePath, final boolean hasChildren) {
		879	if (isBusy())
		880	return;
867	preservingSelection(new Runnable() {	881	preservingSelection(new Runnable() {
868	public void run() {	882	public void run() {
869	if (internalIsInputOrEmptyPath(elementOrTreePath)) {	883	if (internalIsInputOrEmptyPath(elementOrTreePath)) {
Lines 903-929 Link Here
903	* @param index	917	* @param index
904	*/	918	*/
905	private void virtualLazyUpdateWidget(Widget widget, int index) {	919	private void virtualLazyUpdateWidget(Widget widget, int index) {
906	if (contentProviderIsTreeBased) {	920	boolean oldBusy = busy;
907	TreePath treePath;	921	busy = false;
908	if (widget instanceof Item) {	922	try {
909	if (widget.getData() == null) {	923	if (contentProviderIsTreeBased) {
910	// we need to materialize the parent first	924	TreePath treePath;
911	// see bug 167668	925	if (widget instanceof Item) {
912	// however, that would be too risky	926	if (widget.getData() == null) {
913	// see bug 182782 and bug 182598	927	// we need to materialize the parent first
914	// so we just ignore this call altogether	928	// see bug 167668
915	// and don't do this: virtualMaterializeItem((TreeItem) widget);	929	// however, that would be too risky
916	return;	930	// see bug 182782 and bug 182598
		931	// so we just ignore this call altogether
		932	// and don't do this: virtualMaterializeItem((TreeItem) widget);
		933	return;
		934	}
		935	treePath = getTreePathFromItem((Item) widget);
		936	} else {
		937	treePath = TreePath.EMPTY;
917	}	938	}
918	treePath = getTreePathFromItem((Item) widget);	939	((ILazyTreePathContentProvider) getContentProvider())
		940	.updateElement(treePath, index);
919	} else {	941	} else {
920	treePath = TreePath.EMPTY;	942	((ILazyTreeContentProvider) getContentProvider()).updateElement(
		943	widget.getData(), index);
921	}	944	}
922	((ILazyTreePathContentProvider) getContentProvider())	945	} finally {
923	.updateElement(treePath, index);	946	busy = oldBusy;
924	} else {
925	((ILazyTreeContentProvider) getContentProvider()).updateElement(
926	widget.getData(), index);
927	}	947	}
928	}	948	}
929		949
Lines 933-949 Link Here
933	* @param currentChildCount	953	* @param currentChildCount
934	*/	954	*/
935	private void virtualLazyUpdateChildCount(Widget widget, int currentChildCount) {	955	private void virtualLazyUpdateChildCount(Widget widget, int currentChildCount) {
936	if (contentProviderIsTreeBased) {	956	boolean oldBusy = busy;
937	TreePath treePath;	957	busy = false;
938	if (widget instanceof Item) {	958	try {
939	treePath = getTreePathFromItem((Item) widget);	959	if (contentProviderIsTreeBased) {
		960	TreePath treePath;
		961	if (widget instanceof Item) {
		962	treePath = getTreePathFromItem((Item) widget);
		963	} else {
		964	treePath = TreePath.EMPTY;
		965	}
		966	((ILazyTreePathContentProvider) getContentProvider())
		967	.updateChildCount(treePath, currentChildCount);
940	} else {	968	} else {
941	treePath = TreePath.EMPTY;	969	((ILazyTreeContentProvider) getContentProvider()).updateChildCount(widget.getData(), currentChildCount);
942	}	970	}
943	((ILazyTreePathContentProvider) getContentProvider())	971	} finally {
944	.updateChildCount(treePath, currentChildCount);	972	busy = oldBusy;
945	} else {
946	((ILazyTreeContentProvider) getContentProvider()).updateChildCount(widget.getData(), currentChildCount);
947	}	973	}
948	}	974	}
949		975
Lines 953-971 Link Here
953	* @param currentChildCount	979	* @param currentChildCount
954	*/	980	*/
955	private void virtualLazyUpdateHasChildren(Item item, int currentChildCount) {	981	private void virtualLazyUpdateHasChildren(Item item, int currentChildCount) {
956	if (contentProviderIsTreeBased) {	982	boolean oldBusy = busy;
957	TreePath treePath;	983	busy = false;
958	treePath = getTreePathFromItem(item);	984	try {
959	if (currentChildCount == 0) {	985	if (contentProviderIsTreeBased) {
960	// item is not expanded (but may have a plus currently)	986	TreePath treePath;
961	((ILazyTreePathContentProvider) getContentProvider())	987	treePath = getTreePathFromItem(item);
962	.updateHasChildren(treePath);	988	if (currentChildCount == 0) {
		989	// item is not expanded (but may have a plus currently)
		990	((ILazyTreePathContentProvider) getContentProvider())
		991	.updateHasChildren(treePath);
		992	} else {
		993	((ILazyTreePathContentProvider) getContentProvider())
		994	.updateChildCount(treePath, currentChildCount);
		995	}
963	} else {	996	} else {
964	((ILazyTreePathContentProvider) getContentProvider())	997	((ILazyTreeContentProvider) getContentProvider()).updateChildCount(item.getData(), currentChildCount);
965	.updateChildCount(treePath, currentChildCount);
966	}	998	}
967	} else {	999	} finally {
968	((ILazyTreeContentProvider) getContentProvider()).updateChildCount(item.getData(), currentChildCount);	1000	busy = oldBusy;
969	}	1001	}
970	}	1002	}
971		1003

Lines 240-247 Link Here

(-)src/org/eclipse/jface/viewers/AbstractTableViewer.java (-38 / +62 lines)
240	*/	240	*/
241	public void add(Object[] elements) {	241	public void add(Object[] elements) {
242	assertElementsNotNull(elements);	242	assertElementsNotNull(elements);
		243	if (isBusy())
		244	return;
243	Object[] filtered = filter(elements);	245	Object[] filtered = filter(elements);
244		246
245	for (int i = 0; i < filtered.length; i++) {	247	for (int i = 0; i < filtered.length; i++) {
246	Object element = filtered[i];	248	Object element = filtered[i];
247	int index = indexForElement(element);	249	int index = indexForElement(element);
Lines 338-379 Link Here
338	* java.lang.Object, boolean)	340	* java.lang.Object, boolean)
339	*/	341	*/
340	protected void doUpdateItem(Widget widget, Object element, boolean fullMap) {	342	protected void doUpdateItem(Widget widget, Object element, boolean fullMap) {
341	if (widget instanceof Item) {	343	boolean oldBusy = busy;
342	final Item item = (Item) widget;	344	busy = true;
343		345	try {
344	// remember element we are showing	346	if (widget instanceof Item) {
345	if (fullMap) {	347	final Item item = (Item) widget;
346	associate(element, item);	348
347	} else {	349	// remember element we are showing
348	Object data = item.getData();	350	if (fullMap) {
349	if (data != null) {	351	associate(element, item);
350	unmapElement(data, item);	352	} else {
		353	Object data = item.getData();
		354	if (data != null) {
		355	unmapElement(data, item);
		356	}
		357	item.setData(element);
		358	mapElement(element, item);
351	}	359	}
352	item.setData(element);	360
353	mapElement(element, item);	361	int columnCount = doGetColumnCount();
354	}	362	if (columnCount == 0)
355		363	columnCount = 1;// If there are no columns do the first one
356	int columnCount = doGetColumnCount();	364
357	if (columnCount == 0)	365	ViewerRow viewerRowFromItem = getViewerRowFromItem(item);
358	columnCount = 1;// If there are no columns do the first one	366	// Also enter loop if no columns added. See 1G9WWGZ: JFUIF:WINNT -
359		367	// TableViewer with 0 columns does not work
360	ViewerRow viewerRowFromItem = getViewerRowFromItem(item);	368	for (int column = 0; column < columnCount \|\| column == 0; column++) {
361	// Also enter loop if no columns added. See 1G9WWGZ: JFUIF:WINNT -	369	ViewerColumn columnViewer = getViewerColumn(column);
362	// TableViewer with 0 columns does not work	370	columnViewer.refresh(updateCell(viewerRowFromItem,
363	for (int column = 0; column < columnCount \|\| column == 0; column++) {	371	column, element));
364	ViewerColumn columnViewer = getViewerColumn(column);	372
365	columnViewer.refresh(updateCell(viewerRowFromItem,	373	// As it is possible for user code to run the event
366	column, element));	374	// loop check here.
367		375	if (item.isDisposed()) {
368	// As it is possible for user code to run the event	376	unmapElement(element, item);
369	// loop check here.	377	return;
370	if (item.isDisposed()) {	378	}
371	unmapElement(element, item);	379
372	return;
373	}	380	}
374		381
375	}	382	}
376		383	} finally {
		384	busy = oldBusy;
377	}	385	}
378	}	386	}
379		387
Lines 545-552 Link Here
545	protected void inputChanged(Object input, Object oldInput) {	553	protected void inputChanged(Object input, Object oldInput) {
546	getControl().setRedraw(false);	554	getControl().setRedraw(false);
547	try {	555	try {
548	// refresh() attempts to preserve selection, which we want here	556	preservingSelection(new Runnable() {
549	refresh();	557	public void run() {
		558	internalRefresh(getRoot());
		559	}
		560	});
550	} finally {	561	} finally {
551	getControl().setRedraw(true);	562	getControl().setRedraw(true);
552	}	563	}
Lines 577-583 Link Here
577	if (position == -1) {	588	if (position == -1) {
578	position = doGetItemCount();	589	position = doGetItemCount();
579	}	590	}
580		591	if (isBusy())
		592	return;
581	createItem(element, position);	593	createItem(element, position);
582	}	594	}
583		595
Lines 722-728 Link Here
722	Object input = getInput();	734	Object input = getInput();
723	for (int i = 0; i < elements.length; ++i) {	735	for (int i = 0; i < elements.length; ++i) {
724	if (equals(elements[i], input)) {	736	if (equals(elements[i], input)) {
725	setInput(null);	737	boolean oldBusy = busy;
		738	busy = false;
		739	try {
		740	setInput(null);
		741	} finally {
		742	busy = oldBusy;
		743	}
726	return;	744	return;
727	}	745	}
728	}	746	}
Lines 772-777 Link Here
772	*/	790	*/
773	public void remove(final Object[] elements) {	791	public void remove(final Object[] elements) {
774	assertElementsNotNull(elements);	792	assertElementsNotNull(elements);
		793	if (isBusy())
		794	return;
775	if (elements.length == 0) {	795	if (elements.length == 0) {
776	return;	796	return;
777	}	797	}
Lines 965-970 Link Here
965	* @since 3.1	985	* @since 3.1
966	*/	986	*/
967	public void setItemCount(int count) {	987	public void setItemCount(int count) {
		988	if (isBusy())
		989	return;
968	int oldCount = doGetItemCount();	990	int oldCount = doGetItemCount();
969	if (count < oldCount) {	991	if (count < oldCount) {
970	// need to disassociate elements that are being disposed	992	// need to disassociate elements that are being disposed
Lines 995-1000 Link Here
995	* @since 3.1	1017	* @since 3.1
996	*/	1018	*/
997	public void replace(Object element, int index) {	1019	public void replace(Object element, int index) {
		1020	if (isBusy())
		1021	return;
998	Item item = doGetItem(index);	1022	Item item = doGetItem(index);
999	refreshItem(item, element);	1023	refreshItem(item, element);
1000	}	1024	}

Lines 16-21 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewer.java (+45 lines)
16		16
17		17
18	import org.eclipse.core.runtime.Assert;	18	import org.eclipse.core.runtime.Assert;
		19	import org.eclipse.core.runtime.IStatus;
		20	import org.eclipse.core.runtime.Status;
		21	import org.eclipse.jface.util.Policy;
19	import org.eclipse.swt.events.MouseAdapter;	22	import org.eclipse.swt.events.MouseAdapter;
20	import org.eclipse.swt.events.MouseEvent;	23	import org.eclipse.swt.events.MouseEvent;
21	import org.eclipse.swt.graphics.Point;	24	import org.eclipse.swt.graphics.Point;
Lines 48-53 Link Here
48	private ViewerCell cell = new ViewerCell(null, 0, null);	51	private ViewerCell cell = new ViewerCell(null, 0, null);
49		52
50	private ColumnViewerEditor viewerEditor;	53	private ColumnViewerEditor viewerEditor;
		54
		55	/* package */ boolean busy;
51		56
52	/**	57	/**
53	* Create a new instance of the receiver.	58	* Create a new instance of the receiver.
Lines 56-61 Link Here
56		61
57	}	62	}
58		63
		64	/* package */ boolean isBusy() {
		65	if (busy) {
		66	Policy.getLog().log(
		67	new Status(
		68	IStatus.WARNING,
		69	Policy.JFACE,
		70	"Ignoring reentrant call while viewer is busy", new RuntimeException())); //$NON-NLS-1$
		71	return true;
		72	}
		73	return false;
		74	}
		75
59	protected void hookControl(Control control) {	76	protected void hookControl(Control control) {
60	super.hookControl(control);	77	super.hookControl(control);
61	viewerEditor = createViewerEditor();	78	viewerEditor = createViewerEditor();
Lines 457-462 Link Here
457	}	474	}
458	return false;	475	return false;
459	}	476	}
		477
		478	public void refresh(Object element) {
		479	if (isBusy())
		480	return;
		481	super.refresh(element);
		482	}
		483
		484	public void refresh(Object element, boolean updateLabels) {
		485	if (isBusy())
		486	return;
		487	super.refresh(element, updateLabels);
		488	}
		489
		490	public void update(Object element, String[] properties) {
		491	if (isBusy())
		492	return;
		493	super.update(element, properties);
		494	}
460		495
461	/**	496	/**
462	* Sets the cell editors of this column viewer. If editing is not supported	497	* Sets the cell editors of this column viewer. If editing is not supported
Lines 590-593 Link Here
590	public ColumnViewerEditor getColumnViewerEditor() {	625	public ColumnViewerEditor getColumnViewerEditor() {
591	return viewerEditor;	626	return viewerEditor;
592	}	627	}
		628
		629	protected Object[] getRawChildren(Object parent) {
		630	boolean oldBusy = busy;
		631	busy = true;
		632	try {
		633	return super.getRawChildren(parent);
		634	} finally {
		635	busy = oldBusy;
		636	}
		637	}
593	}	638	}

Lines 1976-1982 Link Here

(-)src/org/eclipse/jface/viewers/StructuredViewer.java (-1 / +5 lines)
1976	}	1976	}
1977	}	1977	}
1978	if (needsRefilter) {	1978	if (needsRefilter) {
1979	refresh();	1979	preservingSelection(new Runnable() {
		1980	public void run() {
		1981	internalRefresh(getRoot());
		1982	}
		1983	});
1980	return;	1984	return;
1981	}	1985	}
1982		1986

Return to bug 154571

Lines 127-133 Link Here

(-)src/org/eclipse/jface/viewers/AbstractTreeViewer.java (-89 / +122 lines)
127	public void add(Object parentElementOrTreePath, Object[] childElements) {	127	public void add(Object parentElementOrTreePath, Object[] childElements) {
128	Assert.isNotNull(parentElementOrTreePath);	128	Assert.isNotNull(parentElementOrTreePath);
129	assertElementsNotNull(childElements);	129	assertElementsNotNull(childElements);
130		130	if (isBusy())
		131	return;
131	Widget[] widgets = internalFindItems(parentElementOrTreePath);	132	Widget[] widgets = internalFindItems(parentElementOrTreePath);
132	// If parent hasn't been realized yet, just ignore the add.	133	// If parent hasn't been realized yet, just ignore the add.
133	if (widgets.length == 0) {	134	if (widgets.length == 0) {
Lines 334-340 Link Here
334	int index;	335	int index;
335	if (comparator == null) {	336	if (comparator == null) {
336	if (itemExists(items, element)) {	337	if (itemExists(items, element)) {
337	refresh(element);	338	internalRefresh(element);
338	newItem = false;	339	newItem = false;
339	}	340	}
340	index = -1;	341	index = -1;
Lines 355-361 Link Here
355	// any)	356	// any)
356	if (items[lastInsertion].getData().equals(element)) {	357	if (items[lastInsertion].getData().equals(element)) {
357	// refresh the element in case it has new children	358	// refresh the element in case it has new children
358	refresh(element);	359	internalRefresh(element);
359	newItem = false;	360	newItem = false;
360	}	361	}
361	lastInsertion++;// We had an insertion so increment	362	lastInsertion++;// We had an insertion so increment
Lines 740-785 Link Here
740	* the widget	741	* the widget
741	*/	742	*/
742	protected void createChildren(final Widget widget) {	743	protected void createChildren(final Widget widget) {
743	final Item[] tis = getChildren(widget);	744	boolean oldBusy = busy;
744	if (tis != null && tis.length > 0) {	745	busy = true;
745	Object data = tis[0].getData();	746	try {
746	if (data != null) {	747	final Item[] tis = getChildren(widget);
747	return; // children already there!	748	if (tis != null && tis.length > 0) {
		749	Object data = tis[0].getData();
		750	if (data != null) {
		751	return; // children already there!
		752	}
748	}	753	}
749	}	754
750		755	BusyIndicator.showWhile(widget.getDisplay(), new Runnable() {
751	BusyIndicator.showWhile(widget.getDisplay(), new Runnable() {	756	public void run() {
752	public void run() {	757	// fix for PR 1FW89L7:
753	// fix for PR 1FW89L7:	758	// don't complain and remove all "dummies" ...
754	// don't complain and remove all "dummies" ...	759	if (tis != null) {
755	if (tis != null) {	760	for (int i = 0; i < tis.length; i++) {
756	for (int i = 0; i < tis.length; i++) {	761	if (tis[i].getData() != null) {
757	if (tis[i].getData() != null) {	762	disassociate(tis[i]);
758	disassociate(tis[i]);	763	Assert.isTrue(tis[i].getData() == null,
759	Assert.isTrue(tis[i].getData() == null,	764	"Second or later child is non -null");//$NON-NLS-1$
760	"Second or later child is non -null");//$NON-NLS-1$	765
761		766	}
		767	tis[i].dispose();
762	}	768	}
763	tis[i].dispose();
764	}	769	}
765	}	770	Object d = widget.getData();
766	Object d = widget.getData();	771	if (d != null) {
767	if (d != null) {	772	Object parentElement = d;
768	Object parentElement = d;	773	Object[] children;
769	Object[] children;	774	if (isTreePathContentProvider() && widget instanceof Item) {
770	if (isTreePathContentProvider() && widget instanceof Item) {	775	TreePath path = getTreePathFromItem((Item) widget);
771	TreePath path = getTreePathFromItem((Item) widget);	776	children = getSortedChildren(path);
772	children = getSortedChildren(path);	777	} else {
773	} else {	778	children = getSortedChildren(parentElement);
774	children = getSortedChildren(parentElement);	779	}
775	}	780	for (int i = 0; i < children.length; i++) {
776	for (int i = 0; i < children.length; i++) {	781	createTreeItem(widget, children[i], -1);
777	createTreeItem(widget, children[i], -1);	782	}
778	}	783	}
779	}	784	}
780	}	785
781		786	});
782	});	787	} finally {
		788	busy = oldBusy;
		789	}
783	}	790	}
784		791
785	/**	792	/**
Lines 944-966 Link Here
944		951
945	/* (non-Javadoc) Method declared on StructuredViewer. */	952	/* (non-Javadoc) Method declared on StructuredViewer. */
946	protected void doUpdateItem(Widget widget, Object element, boolean fullMap) {	953	protected void doUpdateItem(Widget widget, Object element, boolean fullMap) {
947	if (widget instanceof Item) {	954	boolean oldBusy = busy;
948	Item item = (Item) widget;	955	busy = true;
949		956	try {
950	// ensure that back pointer is correct	957	if (widget instanceof Item) {
951	if (fullMap) {	958	Item item = (Item) widget;
952	associate(element, item);	959
953	} else {	960	// ensure that back pointer is correct
954	Object data = item.getData();	961	if (fullMap) {
955	if (data != null) {	962	associate(element, item);
956	unmapElement(data, item);	963	} else {
		964	Object data = item.getData();
		965	if (data != null) {
		966	unmapElement(data, item);
		967	}
		968	item.setData(element);
		969	mapElement(element, item);
957	}	970	}
958	item.setData(element);	971
959	mapElement(element, item);	972	// update icon and label
		973	SafeRunnable.run(new UpdateItemSafeRunnable(item, element));
960	}	974	}
961		975	} finally {
962	// update icon and label	976	busy = oldBusy;
963	SafeRunnable.run(new UpdateItemSafeRunnable(item, element));
964	}	977	}
965	}	978	}
966		979
Lines 995-1000 Link Here
995	* levels of the tree	1008	* levels of the tree
996	*/	1009	*/
997	public void expandToLevel(Object elementOrTreePath, int level) {	1010	public void expandToLevel(Object elementOrTreePath, int level) {
		1011	if (isBusy())
		1012	return;
998	Widget w = internalExpand(elementOrTreePath, true);	1013	Widget w = internalExpand(elementOrTreePath, true);
999	if (w != null) {	1014	if (w != null) {
1000	internalExpandToLevel(w, level);	1015	internalExpandToLevel(w, level);
Lines 1248-1293 Link Here
1248		1263
1249	/* (non-Javadoc) Method declared on StructuredViewer. */	1264	/* (non-Javadoc) Method declared on StructuredViewer. */
1250	protected Object[] getRawChildren(Object parentElementOrTreePath) {	1265	protected Object[] getRawChildren(Object parentElementOrTreePath) {
1251	Object parent;	1266	boolean oldBusy = busy;
1252	TreePath path;	1267	busy = true;
1253	if (parentElementOrTreePath instanceof TreePath) {	1268	try {
1254	path = (TreePath) parentElementOrTreePath;	1269	Object parent;
1255	parent = path.getLastSegment();	1270	TreePath path;
1256	} else {	1271	if (parentElementOrTreePath instanceof TreePath) {
1257	parent = parentElementOrTreePath;	1272	path = (TreePath) parentElementOrTreePath;
1258	path = null;	1273	parent = path.getLastSegment();
1259	}	1274	} else {
1260	if (parent != null) {	1275	parent = parentElementOrTreePath;
1261	if (equals(parent, getRoot())) {	1276	path = null;
1262	return super.getRawChildren(parent);	1277	}
1263	}	1278	if (parent != null) {
1264	IContentProvider cp = getContentProvider();	1279	if (equals(parent, getRoot())) {
1265	if (cp instanceof ITreePathContentProvider) {	1280	return super.getRawChildren(parent);
1266	ITreePathContentProvider tpcp = (ITreePathContentProvider) cp;	1281	}
1267	if (path == null) {	1282	IContentProvider cp = getContentProvider();
1268	// A path was not provided so try and find one	1283	if (cp instanceof ITreePathContentProvider) {
1269	Widget w = findItem(parent);	1284	ITreePathContentProvider tpcp = (ITreePathContentProvider) cp;
1270	if (w instanceof Item) {
1271	Item item = (Item) w;
1272	path = getTreePathFromItem(item);
1273	}
1274	if (path == null) {	1285	if (path == null) {
1275	path = new TreePath(new Object[] { parent });	1286	// A path was not provided so try and find one
		1287	Widget w = findItem(parent);
		1288	if (w instanceof Item) {
		1289	Item item = (Item) w;
		1290	path = getTreePathFromItem(item);
		1291	}
		1292	if (path == null) {
		1293	path = new TreePath(new Object[] { parent });
		1294	}
		1295	}
		1296	Object[] result = tpcp.getChildren(path);
		1297	if (result != null) {
		1298	return result;
		1299	}
		1300	} else if (cp instanceof ITreeContentProvider) {
		1301	ITreeContentProvider tcp = (ITreeContentProvider) cp;
		1302	Object[] result = tcp.getChildren(parent);
		1303	if (result != null) {
		1304	return result;
1276	}	1305	}
1277	}
1278	Object[] result = tpcp.getChildren(path);
1279	if (result != null) {
1280	return result;
1281	}
1282	} else if (cp instanceof ITreeContentProvider) {
1283	ITreeContentProvider tcp = (ITreeContentProvider) cp;
1284	Object[] result = tcp.getChildren(parent);
1285	if (result != null) {
1286	return result;
1287	}	1306	}
1288	}	1307	}
		1308	return new Object[0];
		1309	} finally {
		1310	busy = oldBusy;
1289	}	1311	}
1290	return new Object[0];
1291	}	1312	}
1292		1313
1293	/**	1314	/**
Lines 2045-2050 Link Here
2045	if (elementsOrTreePaths.length == 0) {	2066	if (elementsOrTreePaths.length == 0) {
2046	return;	2067	return;
2047	}	2068	}
		2069	if (isBusy())
		2070	return;
2048	preservingSelection(new Runnable() {	2071	preservingSelection(new Runnable() {
2049	public void run() {	2072	public void run() {
2050	internalRemove(elementsOrTreePaths);	2073	internalRemove(elementsOrTreePaths);
Lines 2075-2080 Link Here
2075	if (elements.length == 0) {	2098	if (elements.length == 0) {
2076	return;	2099	return;
2077	}	2100	}
		2101	if (isBusy())
		2102	return;
2078	preservingSelection(new Runnable() {	2103	preservingSelection(new Runnable() {
2079	public void run() {	2104	public void run() {
2080	internalRemove(parent, elements);	2105	internalRemove(parent, elements);
Lines 2227-2232 Link Here
2227	*/	2252	*/
2228	public void setExpandedElements(Object[] elements) {	2253	public void setExpandedElements(Object[] elements) {
2229	assertElementsNotNull(elements);	2254	assertElementsNotNull(elements);
		2255	if (isBusy()) {
		2256	return;
		2257	}
2230	CustomHashtable expandedElements = newHashtable(elements.length * 2 + 1);	2258	CustomHashtable expandedElements = newHashtable(elements.length * 2 + 1);
2231	for (int i = 0; i < elements.length; ++i) {	2259	for (int i = 0; i < elements.length; ++i) {
2232	Object element = elements[i];	2260	Object element = elements[i];
Lines 2261-2266 Link Here
2261	*/	2289	*/
2262	public void setExpandedTreePaths(TreePath[] treePaths) {	2290	public void setExpandedTreePaths(TreePath[] treePaths) {
2263	assertElementsNotNull(treePaths);	2291	assertElementsNotNull(treePaths);
		2292	if (isBusy())
		2293	return;
2264	final IElementComparer comparer = getComparer();	2294	final IElementComparer comparer = getComparer();
2265	IElementComparer treePathComparer = new IElementComparer() {	2295	IElementComparer treePathComparer = new IElementComparer() {
2266		2296
Lines 2303-2308 Link Here
2303	*/	2333	*/
2304	public void setExpandedState(Object elementOrTreePath, boolean expanded) {	2334	public void setExpandedState(Object elementOrTreePath, boolean expanded) {
2305	Assert.isNotNull(elementOrTreePath);	2335	Assert.isNotNull(elementOrTreePath);
		2336	if (isBusy())
		2337	return;
2306	Widget item = internalExpand(elementOrTreePath, false);	2338	Widget item = internalExpand(elementOrTreePath, false);
2307	if (item instanceof Item) {	2339	if (item instanceof Item) {
2308	if (expanded) {	2340	if (expanded) {
Lines 2787-2793 Link Here
2787	int position) {	2819	int position) {
2788	Assert.isNotNull(parentElementOrTreePath);	2820	Assert.isNotNull(parentElementOrTreePath);
2789	Assert.isNotNull(element);	2821	Assert.isNotNull(element);
2790		2822	if (isBusy())
		2823	return;
2791	if (getComparator() != null \|\| hasFilters()) {	2824	if (getComparator() != null \|\| hasFilters()) {
2792	add(parentElementOrTreePath, new Object[] { element });	2825	add(parentElementOrTreePath, new Object[] { element });
2793	return;	2826	return;