Attachment #62724 for bug #173898

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

Lines 16-21 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/ViewerUpdateMonitor.java (-18 / +46 lines)
16	import org.eclipse.core.runtime.jobs.ISchedulingRule;	16	import org.eclipse.core.runtime.jobs.ISchedulingRule;
17	import org.eclipse.debug.internal.core.commands.Request;	17	import org.eclipse.debug.internal.core.commands.Request;
18	import org.eclipse.debug.internal.ui.viewers.AsynchronousSchedulingRuleFactory;	18	import org.eclipse.debug.internal.ui.viewers.AsynchronousSchedulingRuleFactory;
		19	import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider;
19	import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;	20	import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;
20	import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerUpdate;	21	import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerUpdate;
21	import org.eclipse.jface.viewers.TreePath;	22	import org.eclipse.jface.viewers.TreePath;
Lines 37-42 Link Here
37	* Element	38	* Element
38	*/	39	*/
39	private Object fElement;	40	private Object fElement;
		41
		42	/**
		43	* Element content provider
		44	*/
		45	private IElementContentProvider fElementContentProvider;
40		46
41	/**	47	/**
42	* Whether this request's 'done' method has been called.	48	* Whether this request's 'done' method has been called.
Lines 44-52 Link Here
44	private boolean fDone = false;	50	private boolean fDone = false;
45		51
46	/**	52	/**
47	* Associated batch operation, or <code>null</code>	53	* Whether this request has been started
48	*/	54	*/
49	private BatchUpdate fBatchUpdate = null;	55	private boolean fStarted = false;
50		56
51	protected WorkbenchJob fViewerUpdateJob = new WorkbenchJob("Asynchronous viewer update") { //$NON-NLS-1$	57	protected WorkbenchJob fViewerUpdateJob = new WorkbenchJob("Asynchronous viewer update") { //$NON-NLS-1$
52	public IStatus runInUIThread(IProgressMonitor monitor) {	58	public IStatus runInUIThread(IProgressMonitor monitor) {
Lines 72-85 Link Here
72	* @param elementPath path to associated model element - empty for root element	78	* @param elementPath path to associated model element - empty for root element
73	* @param element associated model element	79	* @param element associated model element
74	*/	80	*/
75	public ViewerUpdateMonitor(ModelContentProvider contentProvider, TreePath elementPath, Object element) {	81	public ViewerUpdateMonitor(ModelContentProvider contentProvider, TreePath elementPath, Object element, IElementContentProvider elementContentProvider) {
		82	fElementContentProvider = elementContentProvider;
76	fContentProvider = contentProvider;	83	fContentProvider = contentProvider;
77	fElement = element;	84	fElement = element;
78	fElementPath = elementPath;	85	fElementPath = elementPath;
79	// serialize updates per viewer	86	// serialize updates per viewer
80	fViewerUpdateJob.setRule(getUpdateSchedulingRule());	87	fViewerUpdateJob.setRule(getUpdateSchedulingRule());
81	fViewerUpdateJob.setSystem(true);	88	fViewerUpdateJob.setSystem(true);
82	contentProvider.updateStarted(this);
83	}	89	}
84		90
85	/**	91	/**
Lines 98-104 Link Here
98	*/	104	*/
99	protected ModelContentProvider getContentProvider() {	105	protected ModelContentProvider getContentProvider() {
100	return fContentProvider;	106	return fContentProvider;
101	}	107	}
		108
		109	/**
		110	* Returns the element content provider to use for this request
		111	*
		112	* @return element content provider
		113	*/
		114	protected IElementContentProvider getElementContentProvider() {
		115	return fElementContentProvider;
		116	}
102		117
103	/* (non-Javadoc)	118	/* (non-Javadoc)
104	* @see org.eclipse.core.runtime.IProgressMonitor#done()	119	* @see org.eclipse.core.runtime.IProgressMonitor#done()
Lines 110-120 Link Here
110	}	125	}
111	fDone = true;	126	fDone = true;
112	}	127	}
113	if (fBatchUpdate != null) {	128	scheduleViewerUpdate();
114	fBatchUpdate.done(this);
115	} else {
116	scheduleViewerUpdate();
117	}
118	}	129	}
119		130
120	/**	131	/**
Lines 162-177 Link Here
162	}	173	}
163		174
164	/**	175	/**
165	* Whether this update is rooted at or below the given path.	176	* Returns whether this request can coalesce the given request, and performs the
		177	* coalesce if it can.
166	*	178	*
167	* @param path	179	* @param update request to coalesce with this request
168	* @return whether this update is rooted at or below the given path	180	* @return whether it worked
169	*/	181	*/
170	abstract boolean isContained(TreePath path);	182	abstract boolean coalesce(ViewerUpdateMonitor update);
171		183
172	synchronized void setBatchUpdate(BatchUpdate batchUpdate) {	184	/**
173	fBatchUpdate = batchUpdate;	185	* Starts this request. Subclasses must override startRequest().
174	batchUpdate.batch(this);	186	*/
175	}	187	final void start() {
		188	synchronized (this) {
		189	if (fStarted) {
		190	return;
		191	}
		192	fStarted = true;
		193	}
		194	getContentProvider().updateStarted(this);
		195	if (!isCanceled()) {
		196	startRequest();
		197	} else {
		198	done();
		199	}
		200	}
		201
		202	abstract void startRequest();
176		203
		204	abstract int getPriority();
177	}	205	}




 *******************************************************************************/
package org.eclipse.debug.internal.ui.viewers.model;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenUpdate;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IHasChildrenUpdate;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;
import org.eclipse.debug.internal.ui.viewers.model.provisional.ModelDelta;

	protected static final String[] STATE_PROPERTIES = new String[]{IBasicPropertyConstants.P_TEXT, IBasicPropertyConstants.P_IMAGE};
	
	/**
	 * Map of parent paths to requests
	 */
	private Map fPendingChildRequests = new HashMap();
	
	/**
	 * Map of content adapters to requests
	 */
	private Map fPendingCountRequests = new HashMap();
	
	/**
	 * Map of content adapters to requests
	 */
	private Map fPendingHasChildrenRequests = new HashMap();	
	
	private Timer fTimer = new Timer();
	
	/**
	 * Re-filters any filtered children of the given parent element.
	 * 
	 * @param path parent element

		Object element = getElement(path);
		IElementContentProvider contentAdapter = getContentAdapter(element);
		if (contentAdapter != null) {
			ChildrenCountUpdate request = new ChildrenCountUpdate(this, path, element, contentAdapter);
			schedule(request);
			if (requests != null) {
				requests.add(request);
				return;
			}
			requests = new ArrayList();
			requests.add(request);
			fPendingCountRequests.put(contentAdapter, requests);
			final IElementContentProvider adapter = contentAdapter;
			fTimer.schedule(new TimerTask() {
				public void run() {
					List updates = null;
					synchronized (TreeModelContentProvider.this) {
						updates = (List) fPendingCountRequests.remove(adapter);
					}
					ChildrenCountUpdate[] array = (ChildrenCountUpdate[]) updates.toArray(new ChildrenCountUpdate[updates.size()]);
					batch(array);
					adapter.update(array);
				}
			}, 10L);
		}
	}	
	
	protected synchronized void doUpdateElement(TreePath parentPath, int modelIndex) {
		ChildrenUpdate request = (ChildrenUpdate) fPendingChildRequests.get(parentPath);
		if (request != null) {
			if (request.coalesce(modelIndex)) {
				return;
			} else {
				request.start();
			}
		} 
		Object parent = getElement(parentPath);
		IElementContentProvider contentAdapter = getContentAdapter(parent);
		if (contentAdapter != null) {
			ChildrenUpdate request = new ChildrenUpdate(this, parentPath, parent, modelIndex, contentAdapter);
			schedule(request);
			fTimer.schedule(new TimerTask() {
				public void run() {
					newRequest.start();
				}
			}, 10L);
		}			
	}	
	

		Object element = getElement(path);
		IElementContentProvider contentAdapter = getContentAdapter(element);
		if (contentAdapter != null) {
			HasChildrenUpdate request = new HasChildrenUpdate(this, path, element, contentAdapter);
			schedule(request);
			if (requests != null) {
				requests.add(request);
				return;
			}
			requests = new ArrayList();
			requests.add(request);
			fPendingHasChildrenRequests.put(contentAdapter, requests);
			final IElementContentProvider adapter = contentAdapter;
			fTimer.schedule(new TimerTask() {
				public void run() {
					List list = null;
					synchronized (TreeModelContentProvider.this) {
						list = (List) fPendingHasChildrenRequests.remove(adapter);
					}
					adapter.update((IHasChildrenUpdate[]) list.toArray(new IHasChildrenUpdate[list.size()]));
				}
			}, 10L);
		}
	}		
	
	/**
	 * Batches the given update requests into one UI job on completion
	 * 
	 * @param updates updates to batch
	 */
	protected void batch(ViewerUpdateMonitor[] updates) {
		BatchUpdate batch = new BatchUpdate();
		for (int i = 0; i < updates.length; i++) {
			updates[i].setBatchUpdate(batch);
		}
	}
	
	protected synchronized void childRequestStarted(IChildrenUpdate update) {
		fPendingChildRequests.remove(update.getElementPath());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.provisional.viewers.ModelContentProvider#getPresentationContext()
	 */

		getTreeViewer().update(delta.getElement(), STATE_PROPERTIES);
	}

	public synchronized void dispose() {
		fTimer.cancel();
		fPendingChildRequests.clear();
		fPendingCountRequests.clear();
		super.dispose();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.provisional.viewers.ModelContentProvider#buildViewerState(org.eclipse.debug.internal.ui.viewers.provisional.ModelDelta)
	 */

Lines 83-91 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/ModelContentProvider.java (-16 / +166 lines)
83	private ListenerList fUpdateListeners = new ListenerList();	83	private ListenerList fUpdateListeners = new ListenerList();
84		84
85	/**	85	/**
86	* List of updates in progress	86	* Map of updates in progress: element path -> list of requests
87	*/	87	*/
88	private List fUpdatesInProgress = new ArrayList();	88	private Map fRequestsInProgress = new HashMap();
		89
		90	/**
		91	* Map of dependent requests waiting for parent requests to complete:
		92	* element path -> list of requests
		93	*/
		94	private Map fWaitingRequests = new HashMap();
89		95
90	/**	96	/**
91	* Map of viewer states keyed by viewer input mementos	97	* Map of viewer states keyed by viewer input mementos
Lines 164-173 Link Here
164	*/	170	*/
165	public synchronized void dispose() {	171	public synchronized void dispose() {
166	// cancel pending updates	172	// cancel pending updates
167	synchronized (fUpdatesInProgress) {	173	synchronized (fRequestsInProgress) {
168	Iterator iterator = fUpdatesInProgress.iterator();	174	Iterator iterator = fRequestsInProgress.values().iterator();
169	while (iterator.hasNext()) {	175	while (iterator.hasNext()) {
170	((IRequest) iterator.next()).cancel();	176	List requests = (List) iterator.next();
		177	Iterator reqIter = requests.iterator();
		178	while (reqIter.hasNext()) {
		179	((IRequest) reqIter.next()).cancel();
		180	}
171	}	181	}
172	}	182	}
173	fModelListeners.clear();	183	fModelListeners.clear();
Lines 797-802 Link Here
797	protected void unmapPath(TreePath path) {	807	protected void unmapPath(TreePath path) {
798	//System.out.println("Unmap " + path.getLastSegment());	808	//System.out.println("Unmap " + path.getLastSegment());
799	fTransform.clear(path);	809	fTransform.clear(path);
		810	cancelSubtreeUpdates(path);
800	}	811	}
801		812
802	/**	813	/**
Lines 845-853 Link Here
845	*/	856	*/
846	void updateStarted(IViewerUpdate update) {	857	void updateStarted(IViewerUpdate update) {
847	boolean begin = false;	858	boolean begin = false;
848	synchronized (fUpdatesInProgress) {	859	synchronized (fRequestsInProgress) {
849	begin = fUpdatesInProgress.isEmpty();	860	begin = fRequestsInProgress.isEmpty();
850	fUpdatesInProgress.add(update);	861	List requests = (List) fRequestsInProgress.get(update.getElementPath());
		862	if (requests == null) {
		863	requests = new ArrayList();
		864	fRequestsInProgress.put(update.getElementPath(), requests);
		865	}
		866	requests.add(update);
851	}	867	}
852	if (begin) {	868	if (begin) {
853	if (DEBUG_UPDATE_SEQUENCE) {	869	if (DEBUG_UPDATE_SEQUENCE) {
Lines 868-876 Link Here
868	*/	884	*/
869	void updateComplete(IViewerUpdate update) {	885	void updateComplete(IViewerUpdate update) {
870	boolean end = false;	886	boolean end = false;
871	synchronized (fUpdatesInProgress) {	887	synchronized (fRequestsInProgress) {
872	fUpdatesInProgress.remove(update);	888	List requests = (List) fRequestsInProgress.get(update.getElementPath());
873	end = fUpdatesInProgress.isEmpty();	889	if (requests != null) {
		890	requests.remove(update);
		891	trigger(update);
		892	if (requests.isEmpty()) {
		893	fRequestsInProgress.remove(update.getElementPath());
		894	}
		895	}
		896	end = fRequestsInProgress.isEmpty();
874	}	897	}
875	notifyUpdate(UPDATE_COMPLETE, update);	898	notifyUpdate(UPDATE_COMPLETE, update);
876	if (DEBUG_UPDATE_SEQUENCE) {	899	if (DEBUG_UPDATE_SEQUENCE) {
Lines 915-928 Link Here
915	}	938	}
916		939
917	protected void cancelSubtreeUpdates(TreePath path) {	940	protected void cancelSubtreeUpdates(TreePath path) {
918	synchronized (fUpdatesInProgress) {	941	synchronized (fRequestsInProgress) {
919	for (int i = 0; i < fUpdatesInProgress.size(); i++) {	942	Iterator iterator = fRequestsInProgress.entrySet().iterator();
920	ViewerUpdateMonitor update = (ViewerUpdateMonitor) fUpdatesInProgress.get(i);	943	while (iterator.hasNext()) {
921	if (update.isContained(path)) {	944	Entry entry = (Entry) iterator.next();
922	update.cancel();	945	TreePath entryPath = (TreePath) entry.getKey();
		946	if (entryPath.startsWith(path, null)) {
		947	List requests = (List) entry.getValue();
		948	Iterator reqIter = requests.iterator();
		949	while (reqIter.hasNext()) {
		950	((IRequest)reqIter.next()).cancel();
		951	}
		952	}
		953	}
		954	List purge = new ArrayList();
		955	iterator = fWaitingRequests.keySet().iterator();
		956	while (iterator.hasNext()) {
		957	TreePath entryPath = (TreePath) iterator.next();
		958	if (entryPath.startsWith(path, null)) {
		959	purge.add(entryPath);
923	}	960	}
924	}	961	}
		962	iterator = purge.iterator();
		963	while (iterator.hasNext()) {
		964	fWaitingRequests.remove(iterator.next());
		965	}
		966	}
		967	}
		968
		969	/**
		970	* Returns whether this given request should be run, or should wait for parent
		971	* update to complete.
		972	*
		973	* @param update
		974	* @return whether to start the given request
		975	*/
		976	void schedule(ViewerUpdateMonitor update) {
		977	synchronized (fRequestsInProgress) {
		978	List requests = (List) fWaitingRequests.get(update.getElementPath());
		979	if (requests == null) {
		980	// no waiting requests
		981	TreePath parentPath = update.getElementPath();
		982	while (fRequestsInProgress.get(parentPath) == null) {
		983	parentPath = parentPath.getParentPath();
		984	if (parentPath == null) {
		985	// no running requests: start request
		986	update.start();
		987	return;
		988	}
		989	}
		990	// request running on parent, add to waiting list
		991	requests = new ArrayList();
		992	fWaitingRequests.put(update.getElementPath(), requests);
		993	requests.add(update);
		994	} else {
		995	// there are waiting requests: coalesce with existing request?
		996	Iterator reqIter = requests.iterator();
		997	while (reqIter.hasNext()) {
		998	ViewerUpdateMonitor waiting = (ViewerUpdateMonitor) reqIter.next();
		999	if (waiting.coalesce(update)) {
		1000	// coalesced with existing request, done
		1001	return;
		1002	}
		1003	}
		1004	// add to list of waiting requests
		1005	requests.add(update);
		1006	return;
		1007	}
		1008	}
		1009	}
		1010
		1011	/**
		1012	* Triggers waiting requests based on the given request that just completed.
		1013	*
		1014	* TODO: do we cancel updates if the request has been canceled?
		1015	*
		1016	* @param request
		1017	*/
		1018	void trigger(IViewerUpdate request) {
		1019	if (fWaitingRequests.isEmpty()) {
		1020	return;
		1021	}
		1022	TreePath completedPath = request.getElementPath();
		1023	List waiting = (List) fWaitingRequests.get(completedPath);
		1024	if (waiting != null && waiting.isEmpty()) {
		1025	// TODO: why does this happen
1026	fWaitingRequests.remove(completedPath);
1027	waiting = null;
1028	}
1029	if (waiting == null) {
1030	// no waiting, update the entry with the shortest path
1031	int length = Integer.MAX_VALUE;
1032	Iterator entries = fWaitingRequests.entrySet().iterator();
1033	Entry candidate = null;
1034	while (entries.hasNext()) {
1035	Entry entry = (Entry) entries.next();
1036	TreePath key = (TreePath) entry.getKey();
1037	if (key.getSegmentCount() < length) {
1038	candidate = entry;
1039	length = key.getSegmentCount();
1040	}
1041	}
1042	if (candidate != null) {
1043	startHighestPriorityRequest(completedPath, (List) candidate.getValue());
1044	}
1045	} else {
1046	// start the highest priority request
1047	startHighestPriorityRequest(completedPath, waiting);
1048	}
1049	}
1050
1051	/**
1052	* @param completedPath
1053	* @param waiting
1054	*/
1055	private void startHighestPriorityRequest(TreePath completedPath, List waiting) {
1056	if (waiting.isEmpty()) {
1057	// TODO: this should not happen?
1058	fWaitingRequests.remove(completedPath);
1059	return;
1060	}
1061	int priority = 4;
1062	ViewerUpdateMonitor next = null;
1063	Iterator requests = waiting.iterator();
1064	while (requests.hasNext()) {
1065	ViewerUpdateMonitor vu = (ViewerUpdateMonitor) requests.next();
1066	if (vu.getPriority() < priority) {
1067	next = vu;
1068	priority = next.getPriority();
1069	}
1070	}
1071	waiting.remove(next);
1072	if (waiting.isEmpty()) {
1073	fWaitingRequests.remove(completedPath);
925	}	1074	}
		1075	next.start();
926	}	1076	}
927		1077
928	/**	1078	/**




package org.eclipse.debug.internal.ui.viewers.model;

import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenCountUpdate;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.TreeViewer;


	/**
	 * @param contentProvider
	 */
	public ChildrenCountUpdate(ModelContentProvider contentProvider, TreePath elementPath, Object element, IElementContentProvider elementContentProvider) {
		super(contentProvider, elementPath, element, elementContentProvider);
	}

	/* (non-Javadoc)

	public void setChildCount(int numChildren) {
		fCount = numChildren;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#isContained(org.eclipse.jface.viewers.TreePath)
	 */
	boolean isContained(TreePath path) {
		return getElementPath().startsWith(path, null);
	}
	
	public String toString() {
		StringBuffer buf = new StringBuffer();

		return buf.toString();
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#coalesce(org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor)
	 */
	boolean coalesce(ViewerUpdateMonitor request) {
		if (request instanceof ChildrenCountUpdate) {
			return getElementPath().equals(request.getElementPath());
		}
		return false;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#startRequest()
	 */
	void startRequest() {
		getElementContentProvider().update(new IChildrenCountUpdate[]{this});
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#getPriority()
	 */
	int getPriority() {
		return 2;
	}		
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 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.debug.internal.ui.viewers.model;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.ui.progress.WorkbenchJob;

/**
 * A group of viewer updates to batch together into one UI update job.
 * 
 * @since 3.3
 */
class BatchUpdate {
	
	/**
	 * Pending batched updates
	 */
	private Set fPending = new HashSet();
	
	/**
	 * List of updates needing to run a UI job
	 */
	private List fComplete = null;
	
    protected WorkbenchJob fViewerUpdateJob = new WorkbenchJob("Asynchronous viewer update") { //$NON-NLS-1$
        public IStatus runInUIThread(IProgressMonitor monitor) {
            // necessary to check if viewer is disposed
        	Iterator updates = fComplete.iterator();
    		while (updates.hasNext()) {
    			ViewerUpdateMonitor update = (ViewerUpdateMonitor) updates.next();
		    	try {
		            if (!update.isCanceled() && !update.getContentProvider().isDisposed()) {
		            	IStatus status = update.getStatus();
		                if (status == null || status.isOK()) {
		                	update.performUpdate();
		                }
		            }
		    	} finally {
		    		update.getContentProvider().updateComplete(update);
		    	}
    		}
            return Status.OK_STATUS;
        }
    };	
    
    /**
	 * Creates a new batch update.
	 */
	BatchUpdate() {
		fViewerUpdateJob.setSystem(true);
	}
	
	/**
	 * Batch the given update with this group.
	 * 
	 * @param update update to batch
	 */
	public synchronized void batch(ViewerUpdateMonitor update) {
		fPending.add(update);
	}
	
	/**
	 * Notification the given update is done.
	 * 
	 * @param update update completed
	 */
	public void done(ViewerUpdateMonitor update) {
		boolean allDone = false;
		synchronized (this) {
			fPending.remove(update);
			allDone = fPending.isEmpty();
			if (!update.isCanceled()) {
				if (fComplete == null) {
					fComplete = new ArrayList(fPending.size() + 1);
				}
				fComplete.add(update);
			}
		}
		if (update.isCanceled()) {
			update.getContentProvider().updateComplete(update);
		}
		synchronized (this) {
			if (allDone && fComplete != null) {
				fViewerUpdateJob.schedule();
			}
		}
	}

}




		((TreeModelLabelProvider)getLabelProvider()).removeLabelUpdateListener(listener);
	}

	public void replace(final Object parentElementOrTreePath, final int index,
			final Object element) {
		preservingSelection(new Runnable() {
			public void run() {
				if (internalIsInputOrEmptyPath(parentElementOrTreePath)) {
					if (index < getTree().getItemCount()) {
						updateItem(getTree().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()) {
							TreeItem item = parentItem.getItem(index);
							boolean clear = false;
							if (item.getData() != null) {
								if (!item.getData().equals(element)) {
									clear = true;
								}
							}
							updateItem(item, element);
							if (clear) {
								System.out.println("CLEAR ALL: " + element);
								item.clearAll(true);
							}
						}
					}
				}
			}

		});
	}
}

Lines 10-15 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/HasChildrenUpdate.java (-9 / +48 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.debug.internal.ui.viewers.model;	11	package org.eclipse.debug.internal.ui.viewers.model;
12		12
		13	import java.util.ArrayList;
		14	import java.util.List;
		15
		16	import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementContentProvider;
13	import org.eclipse.debug.internal.ui.viewers.model.provisional.IHasChildrenUpdate;	17	import org.eclipse.debug.internal.ui.viewers.model.provisional.IHasChildrenUpdate;
14	import org.eclipse.jface.viewers.TreePath;	18	import org.eclipse.jface.viewers.TreePath;
15	import org.eclipse.jface.viewers.TreeViewer;	19	import org.eclipse.jface.viewers.TreeViewer;
Lines 21-31 Link Here
21		25
22	private boolean fHasChildren = false;	26	private boolean fHasChildren = false;
23		27
		28	private List fBatchedRequests = null;
		29
24	/**	30	/**
25	* @param contentProvider	31	* @param contentProvider
26	*/	32	*/
27	public HasChildrenUpdate(ModelContentProvider contentProvider, TreePath elementPath, Object element) {	33	public HasChildrenUpdate(ModelContentProvider contentProvider, TreePath elementPath, Object element, IElementContentProvider elementContentProvider) {
28	super(contentProvider, elementPath, element);	34	super(contentProvider, elementPath, element, elementContentProvider);
29	}	35	}
30		36
31	/* (non-Javadoc)	37	/* (non-Javadoc)
Lines 50-66 Link Here
50	fHasChildren = hasChildren;	56	fHasChildren = hasChildren;
51	}	57	}
52		58
53	/* (non-Javadoc)
54	* @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#isContained(org.eclipse.jface.viewers.TreePath)
55	*/
56	boolean isContained(TreePath path) {
57	return getElementPath().startsWith(path, null);
58	}
59
60	public String toString() {	59	public String toString() {
61	StringBuffer buf = new StringBuffer();	60	StringBuffer buf = new StringBuffer();
62	buf.append("IHasChildrenUpdate: "); //$NON-NLS-1$	61	buf.append("IHasChildrenUpdate: "); //$NON-NLS-1$
63	buf.append(getElement());	62	buf.append(getElement());
64	return buf.toString();	63	return buf.toString();
		64	}
		65
		66	/* (non-Javadoc)
		67	* @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#coalesce(org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor)
		68	*/
		69	boolean coalesce(ViewerUpdateMonitor request) {
		70	if (request instanceof HasChildrenUpdate) {
		71	if (getElementPath().equals(request.getElementPath())) {
		72	// duplicate request
		73	return true;
		74	} else if (getElementContentProvider().equals(request.getElementContentProvider())) {
		75	if (fBatchedRequests == null) {
		76	fBatchedRequests = new ArrayList();
		77	fBatchedRequests.add(this);
		78	}
		79	fBatchedRequests.add(request);
		80	return true;
		81	}
		82	}
		83	return false;
		84	}
		85
		86	/* (non-Javadoc)
		87	* @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#startRequest()
		88	*/
		89	void startRequest() {
		90	if (fBatchedRequests == null) {
		91	getElementContentProvider().update(new IHasChildrenUpdate[]{this});
		92	} else {
		93	// TODO: batching does not seem to work
		94	//System.out.println("batched: " + fBatchedRequests.size());
		95	getElementContentProvider().update((IHasChildrenUpdate[]) fBatchedRequests.toArray(new IHasChildrenUpdate[fBatchedRequests.size()]));
		96	}
		97	}
		98
		99	/* (non-Javadoc)
		100	* @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#getPriority()
		101	*/
		102	int getPriority() {
		103	return 1;
65	}	104	}
66	}	105	}




				return childIndex;
			}
			int offset = 0;
			System.out.print("filtered: ");
			for (int i = 0; i < filteredChildren.length; i++) {
				if (childIndex == filteredChildren[i] ) {
					System.out.println("none");
					return -1;
				} else if (childIndex > filteredChildren[i]) {
					System.out.print(filteredChildren[i]);
					offset++;
				} else {
					break;
				}
			}
			System.out.println();
			return childIndex - offset;
		}	
		

	 * @param path element path
	 */
	public synchronized void clear(TreePath path) {
		if (path.getSegmentCount() > 0) {
			System.out.println("clear: " + path.getLastSegment().toString());
		}
		root.clear(path, 0);
	}
	

	 * @param index index to clear
	 */
	public synchronized void clear(TreePath parentPath, int index) {
		if (parentPath.getSegmentCount() > 0) {
			System.out.println("clear index: " + parentPath.getLastSegment().toString() + " " + index);
		}
		root.clear(parentPath, index, 0);
	}	
	




	private Object[] fElements;
	private int fIndex;
	private int fLength;
	private IElementContentProvider fContentProvider;
	private boolean fStarted = false;

	/**
	 * Constructs a request to update an element

	 * @param node node to update
	 * @param model model containing the node
	 */
	public ChildrenUpdate(ModelContentProvider provider, TreePath elementPath, Object element, int index, IElementContentProvider elementContentProvider) {
		super(provider, elementPath, element, elementContentProvider);
		fIndex = index;
		fLength = 1;
		fContentProvider = presentation;
	}

	/*

							}
							viewer.insert(elementPath, element, insertIndex);
						} else {
							if (viewIndex == 2 && modelIndex == 2) {
								System.out.println("stop");
							}
							if (ModelContentProvider.DEBUG_CONTENT_PROVIDER) {
								System.out.println("replace(" + getElement() + ", modelIndex: " + modelIndex + " viewIndex: " + viewIndex + ", " + element + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
							}

		}
		fElements[index - fIndex] = child;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#coalesce(org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor)
	 * coalesced.
	 * 
	 * @param index
	 * @return whether it worked
	 */
	boolean coalesce(ViewerUpdateMonitor request) {
		if (request instanceof ChildrenUpdate) {
			ChildrenUpdate cu = (ChildrenUpdate) request;
			int end = fIndex + fLength;
			int otherStart = cu.getOffset();
			if (otherStart == end) {
				fLength = fLength + cu.getLength();
				return true;
			} else if (otherStart == fIndex) {
				if (cu.getLength() > getLength()) {
					fLength = cu.getLength();
				}
				return true;
			} else if ((otherStart > fIndex) && (otherStart < end)) {
				int otherEnd = otherStart + cu.getLength();
				fLength = otherEnd - fIndex;
				return true;
			}
			fStarted = true;
		}
		//System.out.println("\tRequest (" + fParent + "): " + fIndex + " length: " + fLength);
		TreeModelContentProvider contentProvider = (TreeModelContentProvider)getContentProvider();
		contentProvider.childRequestStarted(this);
		if (!isCanceled()) {
			fContentProvider.update(new IChildrenUpdate[]{this});
		} else {
			done();
		}
		return false;
	}

	/* (non-Javadoc)

	public int getOffset() {
		return fIndex;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#startRequest()
	 */
	void startRequest() {
		System.out.println("Children Batched: " + fLength);
		getElementContentProvider().update(new IChildrenUpdate[]{this});
	}

	public String toString() {
		StringBuffer buf = new StringBuffer();
		buf.append("IChildrenUpdate: "); //$NON-NLS-1$

		buf.append(getLength());
		buf.append("}"); //$NON-NLS-1$
		return buf.toString();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#getPriority()
	 */
	int getPriority() {
		return 3;
	}	
}


Return to bug 173898

Lines 203-217 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/FilterTransform.java (+10 lines)
203	return childIndex;	203	return childIndex;
204	}	204	}
205	int offset = 0;	205	int offset = 0;
		206	System.out.print("filtered: ");
206	for (int i = 0; i < filteredChildren.length; i++) {	207	for (int i = 0; i < filteredChildren.length; i++) {
207	if (childIndex == filteredChildren[i] ) {	208	if (childIndex == filteredChildren[i] ) {
		209	System.out.println("none");
208	return -1;	210	return -1;
209	} else if (childIndex > filteredChildren[i]) {	211	} else if (childIndex > filteredChildren[i]) {
		212	System.out.print(filteredChildren[i]);
210	offset++;	213	offset++;
211	} else {	214	} else {
212	break;	215	break;
213	}	216	}
214	}	217	}
		218	System.out.println();
215	return childIndex - offset;	219	return childIndex - offset;
216	}	220	}
217		221
Lines 280-285 Link Here
280	* @param path element path	284	* @param path element path
281	*/	285	*/
282	public synchronized void clear(TreePath path) {	286	public synchronized void clear(TreePath path) {
		287	if (path.getSegmentCount() > 0) {
		288	System.out.println("clear: " + path.getLastSegment().toString());
		289	}
283	root.clear(path, 0);	290	root.clear(path, 0);
284	}	291	}
285		292
Lines 290-295 Link Here
290	* @param index index to clear	297	* @param index index to clear
291	*/	298	*/
292	public synchronized void clear(TreePath parentPath, int index) {	299	public synchronized void clear(TreePath parentPath, int index) {
		300	if (parentPath.getSegmentCount() > 0) {
		301	System.out.println("clear index: " + parentPath.getLastSegment().toString() + " " + index);
		302	}
293	root.clear(parentPath, index, 0);	303	root.clear(parentPath, index, 0);
294	}	304	}
295		305

Removed Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/BatchUpdate.java (-105 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.internal.ui.viewers.model;
12
13	import java.util.ArrayList;
14	import java.util.HashSet;
15	import java.util.Iterator;
16	import java.util.List;
17	import java.util.Set;
18
19	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.core.runtime.IStatus;
21	import org.eclipse.core.runtime.Status;
22	import org.eclipse.ui.progress.WorkbenchJob;
23
24	/**
25	* A group of viewer updates to batch together into one UI update job.
26	*
27	* @since 3.3
28	*/
29	class BatchUpdate {
30
31	/**
32	* Pending batched updates
33	*/
34	private Set fPending = new HashSet();
35
36	/**
37	* List of updates needing to run a UI job
38	*/
39	private List fComplete = null;
40
41	protected WorkbenchJob fViewerUpdateJob = new WorkbenchJob("Asynchronous viewer update") { //$NON-NLS-1$
42	public IStatus runInUIThread(IProgressMonitor monitor) {
43	// necessary to check if viewer is disposed
44	Iterator updates = fComplete.iterator();
45	while (updates.hasNext()) {
46	ViewerUpdateMonitor update = (ViewerUpdateMonitor) updates.next();
47	try {
48	if (!update.isCanceled() && !update.getContentProvider().isDisposed()) {
49	IStatus status = update.getStatus();
50	if (status == null \|\| status.isOK()) {
51	update.performUpdate();
52	}
53	}
54	} finally {
55	update.getContentProvider().updateComplete(update);
56	}
57	}
58	return Status.OK_STATUS;
59	}
60	};
61
62	/**
63	* Creates a new batch update.
64	*/
65	BatchUpdate() {
66	fViewerUpdateJob.setSystem(true);
67	}
68
69	/**
70	* Batch the given update with this group.
71	*
72	* @param update update to batch
73	*/
74	public synchronized void batch(ViewerUpdateMonitor update) {
75	fPending.add(update);
76	}
77
78	/**
79	* Notification the given update is done.
80	*
81	* @param update update completed
82	*/
83	public void done(ViewerUpdateMonitor update) {
84	boolean allDone = false;
85	synchronized (this) {
86	fPending.remove(update);
87	allDone = fPending.isEmpty();
88	if (!update.isCanceled()) {
89	if (fComplete == null) {
90	fComplete = new ArrayList(fPending.size() + 1);
91	}
92	fComplete.add(update);
93	}
94	}
95	if (update.isCanceled()) {
96	update.getContentProvider().updateComplete(update);
97	}
98	synchronized (this) {
99	if (allDone && fComplete != null) {
100	fViewerUpdateJob.schedule();
101	}
102	}
103	}
104
105	}

Lines 1042-1045 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/InternalTreeModelViewer.java (+32 lines)
1042	((TreeModelLabelProvider)getLabelProvider()).removeLabelUpdateListener(listener);	1042	((TreeModelLabelProvider)getLabelProvider()).removeLabelUpdateListener(listener);
1043	}	1043	}
1044		1044
		1045	public void replace(final Object parentElementOrTreePath, final int index,
		1046	final Object element) {
		1047	preservingSelection(new Runnable() {
		1048	public void run() {
		1049	if (internalIsInputOrEmptyPath(parentElementOrTreePath)) {
		1050	if (index < getTree().getItemCount()) {
		1051	updateItem(getTree().getItem(index), element);
		1052	}
		1053	} else {
		1054	Widget[] parentItems = internalFindItems(parentElementOrTreePath);
		1055	for (int i = 0; i < parentItems.length; i++) {
		1056	TreeItem parentItem = (TreeItem) parentItems[i];
		1057	if (index < parentItem.getItemCount()) {
		1058	TreeItem item = parentItem.getItem(index);
		1059	boolean clear = false;
		1060	if (item.getData() != null) {
		1061	if (!item.getData().equals(element)) {
		1062	clear = true;
		1063	}
		1064	}
		1065	updateItem(item, element);
		1066	if (clear) {
		1067	System.out.println("CLEAR ALL: " + element);
		1068	item.clearAll(true);
		1069	}
		1070	}
		1071	}
		1072	}
		1073	}
		1074
		1075	});
		1076	}
1045	}	1077	}

Lines 22-29 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/ChildrenUpdate.java (-38 / +39 lines)
22	private Object[] fElements;	22	private Object[] fElements;
23	private int fIndex;	23	private int fIndex;
24	private int fLength;	24	private int fLength;
25	private IElementContentProvider fContentProvider;
26	private boolean fStarted = false;
27		25
28	/**	26	/**
29	* Constructs a request to update an element	27	* Constructs a request to update an element
Lines 31-41 Link Here
31	* @param node node to update	29	* @param node node to update
32	* @param model model containing the node	30	* @param model model containing the node
33	*/	31	*/
34	public ChildrenUpdate(ModelContentProvider provider, TreePath elementPath, Object element, int index, IElementContentProvider presentation) {	32	public ChildrenUpdate(ModelContentProvider provider, TreePath elementPath, Object element, int index, IElementContentProvider elementContentProvider) {
35	super(provider, elementPath, element);	33	super(provider, elementPath, element, elementContentProvider);
36	fIndex = index;	34	fIndex = index;
37	fLength = 1;	35	fLength = 1;
38	fContentProvider = presentation;
39	}	36	}
40		37
41	/*	38	/*
Lines 69-74 Link Here
69	}	66	}
70	viewer.insert(elementPath, element, insertIndex);	67	viewer.insert(elementPath, element, insertIndex);
71	} else {	68	} else {
		69	if (viewIndex == 2 && modelIndex == 2) {
		70	System.out.println("stop");
		71	}
72	if (ModelContentProvider.DEBUG_CONTENT_PROVIDER) {	72	if (ModelContentProvider.DEBUG_CONTENT_PROVIDER) {
73	System.out.println("replace(" + getElement() + ", modelIndex: " + modelIndex + " viewIndex: " + viewIndex + ", " + element + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$	73	System.out.println("replace(" + getElement() + ", modelIndex: " + modelIndex + " viewIndex: " + viewIndex + ", " + element + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
74	}	74	}
Lines 93-129 Link Here
93	}	93	}
94	fElements[index - fIndex] = child;	94	fElements[index - fIndex] = child;
95	}	95	}
96		96
97	/**	97	/* (non-Javadoc)
98	* Coalesce the request with the given index. Return whether the requests can be	98	* @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#coalesce(org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor)
99	* coalesced.
100	*
101	* @param index
102	* @return whether it worked
103	*/	99	*/
104	public boolean coalesce(int index) {	100	boolean coalesce(ViewerUpdateMonitor request) {
105	if (index == fIndex + fLength) {	101	if (request instanceof ChildrenUpdate) {
106	fLength++;	102	ChildrenUpdate cu = (ChildrenUpdate) request;
107	return true;	103	int end = fIndex + fLength;
108	}	104	int otherStart = cu.getOffset();
109	return false;	105	if (otherStart == end) {
110	}	106	fLength = fLength + cu.getLength();
111		107	return true;
112	public void start() {	108	} else if (otherStart == fIndex) {
113	synchronized (this) {	109	if (cu.getLength() > getLength()) {
114	if (fStarted) {	110	fLength = cu.getLength();
115	return;	111	}
		112	return true;
		113	} else if ((otherStart > fIndex) && (otherStart < end)) {
		114	int otherEnd = otherStart + cu.getLength();
		115	fLength = otherEnd - fIndex;
		116	return true;
116	}	117	}
117	fStarted = true;
118	}
119	//System.out.println("\tRequest (" + fParent + "): " + fIndex + " length: " + fLength);
120	TreeModelContentProvider contentProvider = (TreeModelContentProvider)getContentProvider();
121	contentProvider.childRequestStarted(this);
122	if (!isCanceled()) {
123	fContentProvider.update(new IChildrenUpdate[]{this});
124	} else {
125	done();
126	}	118	}
		119	return false;
127	}	120	}
128		121
129	/* (non-Javadoc)	122	/* (non-Javadoc)
Lines 139-152 Link Here
139	public int getOffset() {	132	public int getOffset() {
140	return fIndex;	133	return fIndex;
141	}	134	}
142		135
143	/* (non-Javadoc)	136	/* (non-Javadoc)
144	* @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#isContained(org.eclipse.jface.viewers.TreePath)	137	* @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#startRequest()
145	*/	138	*/
146	boolean isContained(TreePath path) {	139	void startRequest() {
147	return getElementPath().startsWith(path, null);	140	System.out.println("Children Batched: " + fLength);
		141	getElementContentProvider().update(new IChildrenUpdate[]{this});
148	}	142	}
149		143
150	public String toString() {	144	public String toString() {
151	StringBuffer buf = new StringBuffer();	145	StringBuffer buf = new StringBuffer();
152	buf.append("IChildrenUpdate: "); //$NON-NLS-1$	146	buf.append("IChildrenUpdate: "); //$NON-NLS-1$
Lines 157-162 Link Here
157	buf.append(getLength());	151	buf.append(getLength());
158	buf.append("}"); //$NON-NLS-1$	152	buf.append("}"); //$NON-NLS-1$
159	return buf.toString();	153	return buf.toString();
		154	}
		155
		156	/* (non-Javadoc)
		157	* @see org.eclipse.debug.internal.ui.viewers.model.ViewerUpdateMonitor#getPriority()
		158	*/
		159	int getPriority() {
		160	return 3;
160	}	161	}
161	}	162	}
162		163