Attachment #39265 for bug #127025

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




		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.viewers.AsynchronousViewer#clearChildren(org.eclipse.swt.widgets.Widget)
	 */
	protected void clearChildren(Widget item) {
		if (item instanceof Table) {
			fTable.clearAll();
		}	
			widget.setData(node.getElement());
			internalRefresh(node);
		}
	}
	
	
}




                                    return false;
                                }
                            }
                            if (widget instanceof TreeItem && !widget.isDisposed()) {
                                TreeItem treeItem = (TreeItem) widget;
                                if (treeItem.getExpanded()) {
                                    return path.getSegmentCount() == treePath.getSegmentCount();

        return paths;
    }
    
    /**
     * Container status of a node changed
     * 
     * @param node
     */
    protected void nodeContainerChanged(ModelNode node) {
		Widget widget = findItem(node);
		if (widget != null && !widget.isDisposed()) {
			boolean expanded = true;
			if (node.isContainer() && getItemCount(widget) == 0) {
				setItemCount(widget, 1);
			}
			if (widget instanceof TreeItem) {
				expanded = ((TreeItem) widget).getExpanded();
			}
			if (expanded) {
				updateChildren(node);
			}
		}
		attemptPendingUpdates();
	}
    
    protected int getItemCount(Widget widget) {
    	if (widget instanceof TreeItem) {
			return ((TreeItem) widget).getItemCount();

    		fTree.clearAll(true);
    	}
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.debug.internal.ui.viewers.AsynchronousViewer#clearChildren(org.eclipse.swt.widgets.Widget)
     */
    protected void clearChildren(Widget widget) {
    	if (widget instanceof TreeItem && !widget.isDisposed()) {
			TreeItem item = (TreeItem) widget;
			item.clearAll(true);
		} else {
			fTree.clearAll(true);
		}
    }

    /*
     * (non-Javadoc)

		return new AsynchronousTreeModel(this);
	}
    

    /* (non-Javadoc)
     * @see org.eclipse.debug.internal.ui.viewers.AsynchronousModelViewer#nodeChanged(org.eclipse.debug.internal.ui.viewers.ModelNode)
     */
    public void nodeChanged(ModelNode node) {
		Widget widget = findItem(node);
		if (widget != null && !widget.isDisposed()) {
			if (widget instanceof TreeItem) {
				clear(widget);
				return;
			}
			widget.setData(node.getElement());
			mapElement(node, widget);
			internalRefresh(node);
			attemptPendingUpdates();
		}
	}
    
    /**
	 * Attempt pending udpates. Subclasses may override but should call super.
	 */

			}
		}
	}
	
	/**
	 * Notification the container status of a node has changed/been computed.
	 * 
	 * @param node
	 */
	protected void nodeContainerChanged(ModelNode node) {
		Widget widget = findItem(node);
		if (widget != null && !widget.isDisposed()) {
			if (node.isContainer()) {
				if (widget instanceof TreeItem) {
					if (((TreeItem)widget).getExpanded()) {
						updateChildren(node);
					}
				} else {
					updateChildren(node);
				}
				attemptPendingUpdates();
			}
		}			
	}

}




import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.viewers.provisional.IAsynchronousRequestMonitor;
import org.eclipse.debug.internal.ui.viewers.provisional.IModelChangedListener;
import org.eclipse.debug.internal.ui.viewers.provisional.IModelProxy;


	protected static final String OLD_LABEL = "old_label"; //$NON-NLS-1$
	protected static final String OLD_IMAGE = "old_image"; //$NON-NLS-1$
	
	   // debug flags
	public static boolean DEBUG_VIEWER = false;
	
	static {
		DEBUG_VIEWER = DebugUIPlugin.DEBUG && "true".equals( //$NON-NLS-1$
		 Platform.getDebugOption("org.eclipse.debug.ui/debug/viewers/viewer")); //$NON-NLS-1$
	}    	
     */	
	private Map fParentsPendingChildren = new HashMap();
	
	/**
	 * Creates a new viewer 

	 * @see org.eclipse.jface.viewers.Viewer#inputChanged(java.lang.Object, java.lang.Object)
	 */
	protected synchronized void inputChanged(Object input, Object oldInput) {
		fParentsPendingChildren.clear();
		if (fUpdatePolicy == null) {
			fUpdatePolicy = createUpdatePolicy();
            fUpdatePolicy.init(this);

	protected AsynchronousModel getModel() {
		return fModel;
	}	
    
    /**
     * A node has been disposed from the model.
     * 
     * @param node
     */
    protected void nodeDisposed(ModelNode node) {
    	Widget widget = findItem(node);
    	if (widget != null) {
    		unmapNode(node);
    		widget.dispose();
		}
	}
    
	/**
	 * Unmaps the node from its widget and all of its children nodes from
	 * their widgets.
	 * 
	 * @param node
	 */
	protected void unmapNode(ModelNode node) {
		unmapElement(node);
		ModelNode[] childrenNodes = node.getChildrenNodes();
		if (childrenNodes != null) {
			for (int i = 0; i < childrenNodes.length; i++) {
				unmapNode(childrenNodes[i]);
			}
		}
	}    

	/**
	 * A node in the model has been updated

	protected void nodeChanged(ModelNode node) {
		Widget widget = findItem(node);
		if (widget != null) {
			clear(widget);
			attemptPendingUpdates();
		}
	}


	}

	/**
	 * Clears the given widget
	 * retrieved yet when the tree got the call to "set data".
	 * 
	 * @param item
	 * @param children
	 */
	protected void nodeChildrenSet(ModelNode parent, ModelNode[] children) {
		int[] indicies = removePendingChildren(parent);
		Widget widget = findItem(parent);
		if (widget != null && !widget.isDisposed()) {
			if (indicies != null) {
				for (int i = 0; i < indicies.length; i++) {
					int index = indicies[i];
					Widget item = getChildWidget(widget, index);
					if (item != null) {
						if (index < children.length) {
							ModelNode childNode = children[index];
							mapElement(childNode, item);
							item.setData(childNode.getElement());
							internalRefresh(childNode);
						}
					}
				}
				setItemCount(widget, children.length);
			} else {
				setItemCount(widget, children.length);
			}
		}
		attemptPendingUpdates();
	}

    protected abstract void clear(Widget item);
    
    /**
     * Clears the children of the widget.
     * 
     * @param item
     */
    protected abstract void clearChildren(Widget item);

	/**
	 * Returns the child widet at the given index for the given parent or

    protected void attemptPendingUpdates() {
    	attemptSelection(false);
    }
	
	/**
	 * Notification a node's children have changed.
	 * Updates the child count for the parent's widget
	 * and clears children to be updated.
	 * 
	 * @param parentNode
	 */
	protected void nodeChildrenChanged(ModelNode parentNode) {
		Widget widget = findItem(parentNode);
		if (widget != null && !widget.isDisposed()) {
			int childCount = parentNode.getChildCount();
			setItemCount(widget, childCount);
			clearChildren(widget);
			attemptPendingUpdates();
		}		
	}
	
	/**
	 * Unmaps the node from its widget and all of its children nodes from
	 * their widgets.
	 * 
	 * @param node
	 */
	protected void unmapNode(ModelNode node) {
		unmapElement(node);
		ModelNode[] childrenNodes = node.getChildrenNodes();
		if (childrenNodes != null) {
			for (int i = 0; i < childrenNodes.length; i++) {
				unmapNode(childrenNodes[i]);
			Widget widget = findItem(parentNode);
			if (widget != null && !widget.isDisposed()) {
				int childCount = parentNode.getChildCount();
				setItemCount(widget, childCount);
				attemptPendingUpdates();
			}
		}
	}

    	return findItem((Object)node);
    }

    /**
     * Note that the child at the specified index was requested by a widget
     * when revealed but that the data was not in the model yet. When the data
     * becomes available, map it to its widget.
     * 
     * @param parent
     * @param index
     */
	protected synchronized void addPendingChildIndex(ModelNode parent, int index) {
	    int[] indicies = (int[]) fParentsPendingChildren.get(parent);
	    if (indicies == null) {
	        indicies = new int[]{index};
	    } else {
	        int[] next = new int[indicies.length + 1];
	        System.arraycopy(indicies, 0, next, 0, indicies.length);
	        next[indicies.length] = index;
	        indicies = next;
	    }
	    fParentsPendingChildren.put(parent, indicies);    	
	}
	
	/**
	 * Removes and returns and children indicies that were pending for the given
	 * parent node. May return <code>null</code>.
	 * 
	 * @param parent
	 * @return indicies of children that data were requested for or <code>null</code>
	 */
	protected int[] removePendingChildren(ModelNode parent) {
		return (int[]) fParentsPendingChildren.remove(parent);
	}

	/*
	 * (non-Javadoc)
	 * 


		Widget parentItem = getParentWidget(event.item);
		int index = event.index;
		if (DEBUG_VIEWER) {
			DebugUIPlugin.debug("SET DATA [" + index + "]: " + parentItem);  //$NON-NLS-1$//$NON-NLS-2$
		}
		if (index == -1) {
			return;
		}
       
		ModelNode[] nodes = getModel().getNodes(parentItem.getData());
		if (nodes != null) {

		        		final ModelNode child = childrenNodes[index];
		        		mapElement(child, event.item);
		        		event.item.setData(child.getElement());
		        		clearChildren(event.item);
		        		if (DEBUG_VIEWER) {
		        			DebugUIPlugin.debug("\tPARENT: " + node); //$NON-NLS-1$
		        			DebugUIPlugin.debug("\tMAPPED: " + child); //$NON-NLS-1$
		        			Widget[] widgets = findItems(child);
		        			if (widgets.length != 1) {
		        				DebugUIPlugin.debug("\t\t*** NODE MAPPED > 1 ITEM ***"); //$NON-NLS-1$
		        				for (int j = 0; j < widgets.length; j++) {
									DebugUIPlugin.debug("\t\t\t" + widgets[j]); //$NON-NLS-1$
								}
		        			}
		        		}
		        		preservingSelection(new Runnable() {
		        		    public void run() {
		        		        internalRefresh(child);
		        		    }
		        		});
		        	}
		        		addPendingChildIndex(node, index);
		            }
		        	return;
				} else {
					if (DEBUG_VIEWER) {
						Widget[] widgets = findItems(node);
						DebugUIPlugin.debug("\tITEM NOT FOUND: " + node); //$NON-NLS-1$
						DebugUIPlugin.debug("\tITEMS WERE: "); //$NON-NLS-1$
						for (int j = 0; j < widgets.length; j++) {
							DebugUIPlugin.debug("\t\t" + widgets[j]); //$NON-NLS-1$
						}
					}
				}
			}
        } else {
        	if (DEBUG_VIEWER) {
        		DebugUIPlugin.debug("\tNOT FOUND IN MODEL: " + parentItem.getData()); //$NON-NLS-1$
        	}
        }
    }
	
	protected abstract void restoreLabels(Item item);

	/**




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

import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.viewers.provisional.IAsynchronousContentAdapter;
import org.eclipse.debug.internal.ui.viewers.provisional.IContainerRequestMonitor;
import org.eclipse.jface.viewers.TreePath;

 * @since 3.2
 */
public class AsynchronousTreeModel extends AsynchronousModel {
	
	/**
	 * Constructs a new empty tree model
	 * 

	 */
	public AsynchronousTreeModel(AsynchronousViewer viewer) {
		super(viewer);
		
	}
	
	/**

        if (parentNode == null) {
            return;
        }
        int index = -1;
        synchronized (this) {
        	index = parentNode.getChildIndex(node);
            parentNode.removeChild(node);
            unmapNode(node);
            node.dispose();
            if (DEBUG_MODEL) {
            	DebugUIPlugin.debug("REMOVE: " + node);   //$NON-NLS-1$
            	DebugUIPlugin.debug(toString());
            }
        }
        final int unmapFrom = index;
        final AsynchronousTreeViewer viewer = getTreeViewer();
        preservingSelection(new Runnable() {
			public void run() {
				// unmap the removed node and all children that were shifted
				viewer.unmapNode(node);
				if (unmapFrom > -1) {
					ModelNode[] childrenNodes = parentNode.getChildrenNodes();
					for (int i = unmapFrom; i < childrenNodes.length; i++) {
						viewer.unmapNode(childrenNodes[i]);
					}
				}
		        viewer.nodeChildrenChanged(parentNode);
			}
		});
    }

            ModelNode node = new ModelNode(parent, element);
            parent.addChild(node);
            mapElement(element, node);
            if (DEBUG_MODEL) {
            	DebugUIPlugin.debug("ADD: (parent) " + parent + " (child) " + element);   //$NON-NLS-1$//$NON-NLS-2$
            	DebugUIPlugin.debug(toString());
            }
        }
        //TODO sort???
        // notify the viewer to update

     * @param node
     * @param containsChildren
     */
     void setIsContainer(final ModelNode node, boolean containsChildren) {
    	ModelNode[] prevChildren = null;
    	boolean prevContains = false;
    	synchronized (this) {
    		prevContains = node.isContainer();
			prevChildren = node.getChildrenNodes();
			node.setIsContainer(containsChildren);
			if (!containsChildren && prevChildren != null) {

                }
                node.setChildren(null);
			}
			if (DEBUG_MODEL) {
				DebugUIPlugin.debug("SET CONTAINER: " + node); //$NON-NLS-1$
				DebugUIPlugin.debug(toString());
			}
		}
//    	 update tree outside lock
    	preservingSelection(new Runnable() {
			public void run() {
		    	getTreeViewer().nodeContainerChanged(node);
		    	getViewer().nodeChildrenChanged(node);
			}
		});
    	
            }
        } else if (!containsChildren && prevChildren != null) {            
            for (int i = 0; i < prevChildren.length; i++) {
                ModelNode child = prevChildren[i];
                viewer.nodeDisposed(child);
            }            
            viewer.nodeChildrenChanged(node);
        }
    }    
}

Lines 17-22 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/AsynchronousModel.java (-44 / +95 lines)
17	import java.util.Map;	17	import java.util.Map;
18		18
19	import org.eclipse.core.runtime.IAdaptable;	19	import org.eclipse.core.runtime.IAdaptable;
		20	import org.eclipse.core.runtime.Platform;
		21	import org.eclipse.debug.internal.ui.DebugUIPlugin;
20	import org.eclipse.debug.internal.ui.elements.adapters.AsynchronousDebugLabelAdapter;	22	import org.eclipse.debug.internal.ui.elements.adapters.AsynchronousDebugLabelAdapter;
21	import org.eclipse.debug.internal.ui.viewers.provisional.IAsynchronousContentAdapter;	23	import org.eclipse.debug.internal.ui.viewers.provisional.IAsynchronousContentAdapter;
22	import org.eclipse.debug.internal.ui.viewers.provisional.IAsynchronousLabelAdapter;	24	import org.eclipse.debug.internal.ui.viewers.provisional.IAsynchronousLabelAdapter;
Lines 41-46 Link Here
41	private Map fModelProxies = new HashMap(); // map of installed model proxies, by element	43	private Map fModelProxies = new HashMap(); // map of installed model proxies, by element
42	private AsynchronousViewer fViewer; // viewer this model works for	44	private AsynchronousViewer fViewer; // viewer this model works for
43	private boolean fDisposed = false; // whether disposed	45	private boolean fDisposed = false; // whether disposed
		46
		47	// debug flags
		48	public static boolean DEBUG_MODEL = false;
		49
		50	static {
		51	DEBUG_MODEL = DebugUIPlugin.DEBUG && "true".equals( //$NON-NLS-1$
		52	Platform.getDebugOption("org.eclipse.debug.ui/debug/viewers/model")); //$NON-NLS-1$
		53	}
44		54
45	/**	55	/**
46	* List of requests currently being performed.	56	* List of requests currently being performed.
Lines 59-65 Link Here
59	*/	69	*/
60	public AsynchronousModel(AsynchronousViewer viewer) {	70	public AsynchronousModel(AsynchronousViewer viewer) {
61	fViewer = viewer;	71	fViewer = viewer;
62		72	if (DEBUG_MODEL) {
		73	StringBuffer buffer = new StringBuffer();
		74	buffer.append("MODEL CREATED for: "); //$NON-NLS-1$
		75	buffer.append(fViewer);
		76	buffer.append(" ("); //$NON-NLS-1$
		77	buffer.append(this);
		78	buffer.append(")"); //$NON-NLS-1$
		79	DebugUIPlugin.debug(buffer.toString());
		80	}
63	}	81	}
64		82
65	/**	83	/**
Lines 83-88 Link Here
83	* Disposes this model	101	* Disposes this model
84	*/	102	*/
85	public synchronized void dispose() {	103	public synchronized void dispose() {
		104	if (DEBUG_MODEL) {
		105	StringBuffer buffer = new StringBuffer();
		106	buffer.append("MODEL DISPOSED for: "); //$NON-NLS-1$
		107	buffer.append(fViewer);
		108	buffer.append(" ("); //$NON-NLS-1$
		109	buffer.append(this);
		110	buffer.append(")"); //$NON-NLS-1$
		111	DebugUIPlugin.debug(buffer.toString());
		112	}
86	fDisposed = true;	113	fDisposed = true;
87	cancelPendingUpdates();	114	cancelPendingUpdates();
88	disposeAllModelProxies();	115	disposeAllModelProxies();
Lines 475-480 Link Here
475		502
476	ModelNode[] prevKids = null;	503	ModelNode[] prevKids = null;
477	ModelNode[] newChildren = null;	504	ModelNode[] newChildren = null;
		505	ModelNode[] unmap = null;
478		506
479	synchronized (this) {	507	synchronized (this) {
480	if (isDisposed()) {	508	if (isDisposed()) {
Lines 490-546 Link Here
490	}	518	}
491	parentNode.setChildren(newChildren);	519	parentNode.setChildren(newChildren);
492	} else {	520	} else {
493	for (int i = 0; i < prevKids.length; i++) {	521	newChildren = new ModelNode[children.length];
494	ModelNode kid = prevKids[i];	522	unmap = new ModelNode[prevKids.length];
495	if (i >= children.length) {	523	for (int i = 0; i < prevKids.length; i++) {
496	kid.dispose();	524	unmap[i] = prevKids[i];
497	unmapNode(kid);	525	}
498	} else {	526	for (int i = 0; i < children.length; i++) {
499	ModelNode prevNode = prevKids[i];	527	Object child = children[i];
500	Object nextChild = children[i];	528	boolean found = false;
501	if (!prevNode.getElement().equals(nextChild)) {	529	for (int j = 0; j < prevKids.length; j++) {
502	unmapNode(prevNode);	530	ModelNode prevKid = prevKids[j];
503	}	531	if (prevKid != null && child.equals(prevKid.getElement())) {
504	mapElement(nextChild, prevNode);	532	newChildren[i] = prevKid;
505	}	533	prevKids[j] = null;
506	}	534	found = true;
507	// create new children	535	break;
508	if (children.length > prevKids.length) {	536	}
509	newChildren = new ModelNode[children.length];	537	}
510	System.arraycopy(prevKids, 0, newChildren, 0, prevKids.length);	538	if (!found) {
511	for (int i = prevKids.length; i < children.length; i ++) {	539	newChildren[i] = new ModelNode(parentNode, child);
512	Object child = children[i];	540	mapElement(child, newChildren[i]);
513	ModelNode childNode = new ModelNode(parentNode, child);	541	}
514	mapElement(child, childNode);	542	}
515	newChildren[i] = childNode;	543	for (int i = 0; i < prevKids.length; i++) {
516	}	544	ModelNode kid = prevKids[i];
517	parentNode.setChildren(newChildren);	545	if (kid != null) {
518	}	546	kid.dispose();
519	if (children.length < prevKids.length) {	547	unmapNode(kid);
520	newChildren = new ModelNode[children.length];	548	}
521	System.arraycopy(prevKids, 0, newChildren, 0, children.length);	549	}
522	parentNode.setChildren(newChildren);	550	parentNode.setChildren(newChildren);
523	}	551	}
524	}	552	if (DEBUG_MODEL) {
		553	DebugUIPlugin.debug("CHILDREN CHANGED: " + parentNode); //$NON-NLS-1$
		554	DebugUIPlugin.debug(toString());
		555	}
525	}	556	}
526		557
527	//update viewer outside the lock	558	//update viewer outside the lock
528	final ModelNode[] finalPrevKids = prevKids;	559	final ModelNode[] finalUnmap = unmap;
529	preservingSelection(new Runnable() {	560	preservingSelection(new Runnable() {
530	public void run() {	561	public void run() {
531	if (finalPrevKids != null) {	562	if (finalUnmap != null) {
532	for (int i = 0; i < finalPrevKids.length; i++) {	563	for (int i = 0; i < finalUnmap.length; i++) {
533	ModelNode kid = finalPrevKids[i];	564	viewer.unmapNode(finalUnmap[i]);
534	if (i >= children.length) {	565	}
535	viewer.nodeDisposed(kid);
536	} else {
537	viewer.nodeChanged(kid);
538	}
539	}
540	}	566	}
541	viewer.nodeChildrenChanged(parentNode);	567	viewer.nodeChildrenChanged(parentNode);
542	}	568	}
543	});	569	});
544		570
545	}	571	}
		572
		573	public String toString() {
		574	StringBuffer buf = new StringBuffer();
		575	if (fRoot != null) {
		576	buf.append("ROOT: "); //$NON-NLS-1$
		577	append(buf, fRoot, 0);
		578	} else {
		579	buf.append("ROOT: null"); //$NON-NLS-1$
		580	}
		581	return buf.toString();
		582	}
		583
		584	private void append(StringBuffer buf, ModelNode node, int level) {
		585	for (int i = 0; i < level; i++) {
		586	buf.append('\t');
		587	}
		588	buf.append(node);
		589	buf.append('\n');
		590	ModelNode[] childrenNodes = node.getChildrenNodes();
		591	if (childrenNodes != null) {
		592	for (int i = 0; i < childrenNodes.length; i++) {
		593	append(buf, childrenNodes[i], level + 1);
		594	}
		595	}
		596	}
546	}	597	}




        fIsContainer = container;
    }
    
    public String toString() {
    	StringBuffer buf = new StringBuffer();
    	if (isDisposed()) {
    		buf.append("[DISPOSED] "); //$NON-NLS-1$
    	}
    	if (isContainer()) {
    		buf.append("[+] "); //$NON-NLS-1$
    	}
    	buf.append(getElement());
    	return buf.toString();
    }
    
}

Lines 151-163 Link Here

(-)ui/org/eclipse/debug/internal/ui/DebugUIPlugin.java (-30 / +10 lines)
151	public static String ATTR_LAUNCHING_CONFIG_HANDLE= getUniqueIdentifier() + "launching_config_handle"; //$NON-NLS-1$	151	public static String ATTR_LAUNCHING_CONFIG_HANDLE= getUniqueIdentifier() + "launching_config_handle"; //$NON-NLS-1$
152		152
153	/**	153	/**
154	* Flag indicating whether the debug UI is in trace
155	* mode. When in trace mode, extra debug information
156	* is produced.
157	*/
158	private boolean fTrace = false;
159
160	/**
161	* Singleton console document manager	154	* Singleton console document manager
162	*/	155	*/
163	private ProcessConsoleManager fProcessConsoleManager = null;	156	private ProcessConsoleManager fProcessConsoleManager = null;
Lines 190-195 Link Here
190	*/	183	*/
191	private ServiceTracker fServiceTracker;	184	private ServiceTracker fServiceTracker;
192	private PackageAdmin fPackageAdminService;	185	private PackageAdmin fPackageAdminService;
		186
		187	public static boolean DEBUG = false;
193		188
194	/**	189	/**
195	* Dummy launch node representing a launch that is waiting	190	* Dummy launch node representing a launch that is waiting
Lines 216-232 Link Here
216	}	211	}
217		212
218	/**	213	/**
219	* Returns whether the debug UI plug-in is in trace
220	* mode.
221	*
222	* @return whether the debug UI plug-in is in trace
223	* mode
224	*/
225	public boolean isTraceMode() {
226	return fTrace;
227	}
228
229	/**
230	* Returns the bundle the given class originated from.	214	* Returns the bundle the given class originated from.
231	*	215	*
232	* @param clazz a class	216	* @param clazz a class
Lines 242-265 Link Here
242	}	226	}
243		227
244	/**	228	/**
245	* Logs the given message if in trace mode.
246	*
247	* @param String message to log
248	*/
249	public static void logTraceMessage(String message) {
250	if (getDefault().isTraceMode()) {
251	IStatus s = new Status(IStatus.WARNING, IDebugUIConstants.PLUGIN_ID, IDebugUIConstants.INTERNAL_ERROR, message, null);
252	getDefault().getLog().log(s);
253	}
254	}
255
256	/**
257	* Constructs the debug UI plugin	229	* Constructs the debug UI plugin
258	*/	230	*/
259	public DebugUIPlugin() {	231	public DebugUIPlugin() {
260	super();	232	super();
261	fgDebugUIPlugin= this;	233	fgDebugUIPlugin= this;
262	}	234	}
		235
		236	public static void debug(String message) {
		237	if (DEBUG) {
		238	System.out.println(message);
		239	}
		240	}
263		241
264	/**	242	/**
265	* Returns the singleton instance of the debug plugin.	243	* Returns the singleton instance of the debug plugin.
Lines 409-414 Link Here
409	public void start(BundleContext context) throws Exception {	387	public void start(BundleContext context) throws Exception {
410	super.start(context);	388	super.start(context);
411		389
		390	DEBUG = "true".equals(Platform.getDebugOption("org.eclipse.debug.ui/debug")); //$NON-NLS-1$//$NON-NLS-2$
		391
412	// make sure the perspective manager is created	392	// make sure the perspective manager is created
413	// and be the first debug event listener	393	// and be the first debug event listener
414	fPerspectiveManager = new PerspectiveManager();	394	fPerspectiveManager = new PerspectiveManager();

Lines 1-2 Link Here

(-).options (-1 / +2 lines)
1	org.eclipse.debug.ui/debug = false	1	org.eclipse.debug.ui/debug = false
2	org.eclipse.debug.ui/debug/viewer_cache_debug = false	2	org.eclipse.debug.ui/debug/viewers/model = false
		3	org.eclipse.debug.ui/debug/viewers/viewer = false

Lines 488-498 Link Here

(-)ui/org/eclipse/debug/internal/ui/views/memory/renderings/AsyncVirtualContentTableViewer.java (-5 / +2 lines)
488	// is causing the table viewer to not scroll or move cursor properly.	488	// is causing the table viewer to not scroll or move cursor properly.
489	// #interalRefresh on a child will never cause a structural	489	// #interalRefresh on a child will never cause a structural
490	// change in a table viewer. As a result, there is no need to preserve selection	490	// change in a table viewer. As a result, there is no need to preserve selection
491	internalRefresh(child);	491	internalRefresh(child);
492		492	}
493	} else {
494	addPendingChildIndex(node, index);
495	}
496	return;	493	return;
497	}	494	}
498	}	495	}

Return to bug 127025

Lines 442-448 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/AsynchronousTreeViewer.java (-41 / +35 lines)
442	return false;	442	return false;
443	}	443	}
444	}	444	}
445	if (widget instanceof TreeItem) {	445	if (widget instanceof TreeItem && !widget.isDisposed()) {
446	TreeItem treeItem = (TreeItem) widget;	446	TreeItem treeItem = (TreeItem) widget;
447	if (treeItem.getExpanded()) {	447	if (treeItem.getExpanded()) {
448	return path.getSegmentCount() == treePath.getSegmentCount();	448	return path.getSegmentCount() == treePath.getSegmentCount();
Lines 747-774 Link Here
747	return paths;	747	return paths;
748	}	748	}
749		749
750	/**
751	* Container status of a node changed
752	*
753	* @param node
754	*/
755	protected void nodeContainerChanged(ModelNode node) {
756	Widget widget = findItem(node);
757	if (widget != null && !widget.isDisposed()) {
758	boolean expanded = true;
759	if (node.isContainer() && getItemCount(widget) == 0) {
760	setItemCount(widget, 1);
761	}
762	if (widget instanceof TreeItem) {
763	expanded = ((TreeItem) widget).getExpanded();
764	}
765	if (expanded) {
766	updateChildren(node);
767	}
768	}
769	attemptPendingUpdates();
770	}
771
772	protected int getItemCount(Widget widget) {	750	protected int getItemCount(Widget widget) {
773	if (widget instanceof TreeItem) {	751	if (widget instanceof TreeItem) {
774	return ((TreeItem) widget).getItemCount();	752	return ((TreeItem) widget).getItemCount();
Lines 870-875 Link Here
870	fTree.clearAll(true);	848	fTree.clearAll(true);
871	}	849	}
872	}	850	}
		851
		852	/* (non-Javadoc)
		853	* @see org.eclipse.debug.internal.ui.viewers.AsynchronousViewer#clearChildren(org.eclipse.swt.widgets.Widget)
		854	*/
		855	protected void clearChildren(Widget widget) {
		856	if (widget instanceof TreeItem && !widget.isDisposed()) {
		857	TreeItem item = (TreeItem) widget;
		858	item.clearAll(true);
		859	} else {
		860	fTree.clearAll(true);
		861	}
		862	}
873		863
874	/*	864	/*
875	* (non-Javadoc)	865	* (non-Javadoc)
Lines 1169-1192 Link Here
1169	return new AsynchronousTreeModel(this);	1159	return new AsynchronousTreeModel(this);
1170	}	1160	}
1171		1161
1172
1173	/* (non-Javadoc)
1174	* @see org.eclipse.debug.internal.ui.viewers.AsynchronousModelViewer#nodeChanged(org.eclipse.debug.internal.ui.viewers.ModelNode)
1175	*/
1176	public void nodeChanged(ModelNode node) {
1177	Widget widget = findItem(node);
1178	if (widget != null && !widget.isDisposed()) {
1179	if (widget instanceof TreeItem) {
1180	clear(widget);
1181	return;
1182	}
1183	widget.setData(node.getElement());
1184	mapElement(node, widget);
1185	internalRefresh(node);
1186	attemptPendingUpdates();
1187	}
1188	}
1189
1190	/**	1162	/**
1191	* Attempt pending udpates. Subclasses may override but should call super.	1163	* Attempt pending udpates. Subclasses may override but should call super.
1192	*/	1164	*/
Lines 1563-1566 Link Here
1563	}	1535	}
1564	}	1536	}
1565	}	1537	}
		1538
		1539	/**
		1540	* Notification the container status of a node has changed/been computed.
		1541	*
		1542	* @param node
		1543	*/
		1544	protected void nodeContainerChanged(ModelNode node) {
		1545	Widget widget = findItem(node);
		1546	if (widget != null && !widget.isDisposed()) {
		1547	if (node.isContainer()) {
		1548	if (widget instanceof TreeItem) {
		1549	if (((TreeItem)widget).getExpanded()) {
		1550	updateChildren(node);
		1551	}
		1552	} else {
		1553	updateChildren(node);
		1554	}
		1555	attemptPendingUpdates();
		1556	}
		1557	}
		1558	}
		1559
1566	}	1560	}

Lines 194-197 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/ModelNode.java (+12 lines)
194	fIsContainer = container;	194	fIsContainer = container;
195	}	195	}
196		196
		197	public String toString() {
		198	StringBuffer buf = new StringBuffer();
		199	if (isDisposed()) {
		200	buf.append("[DISPOSED] "); //$NON-NLS-1$
		201	}
		202	if (isContainer()) {
		203	buf.append("[+] "); //$NON-NLS-1$
		204	}
		205	buf.append(getElement());
		206	return buf.toString();
		207	}
		208
197	}	209	}

Lines 10-15 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/AsynchronousTreeModel.java (-19 / +37 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.debug.internal.ui.viewers;	11	package org.eclipse.debug.internal.ui.viewers;
12		12
		13	import org.eclipse.debug.internal.ui.DebugUIPlugin;
13	import org.eclipse.debug.internal.ui.viewers.provisional.IAsynchronousContentAdapter;	14	import org.eclipse.debug.internal.ui.viewers.provisional.IAsynchronousContentAdapter;
14	import org.eclipse.debug.internal.ui.viewers.provisional.IContainerRequestMonitor;	15	import org.eclipse.debug.internal.ui.viewers.provisional.IContainerRequestMonitor;
15	import org.eclipse.jface.viewers.TreePath;	16	import org.eclipse.jface.viewers.TreePath;
Lines 21-27 Link Here
21	* @since 3.2	22	* @since 3.2
22	*/	23	*/
23	public class AsynchronousTreeModel extends AsynchronousModel {	24	public class AsynchronousTreeModel extends AsynchronousModel {
24		25
25	/**	26	/**
26	* Constructs a new empty tree model	27	* Constructs a new empty tree model
27	*	28	*
Lines 29-34 Link Here
29	*/	30	*/
30	public AsynchronousTreeModel(AsynchronousViewer viewer) {	31	public AsynchronousTreeModel(AsynchronousViewer viewer) {
31	super(viewer);	32	super(viewer);
		33
32	}	34	}
33		35
34	/**	36	/**
Lines 130-145 Link Here
130	if (parentNode == null) {	132	if (parentNode == null) {
131	return;	133	return;
132	}	134	}
		135	int index = -1;
133	synchronized (this) {	136	synchronized (this) {
		137	index = parentNode.getChildIndex(node);
134	parentNode.removeChild(node);	138	parentNode.removeChild(node);
135	unmapNode(node);	139	unmapNode(node);
136	node.dispose();	140	node.dispose();
		141	if (DEBUG_MODEL) {
		142	DebugUIPlugin.debug("REMOVE: " + node); //$NON-NLS-1$
		143	DebugUIPlugin.debug(toString());
		144	}
137	}	145	}
		146	final int unmapFrom = index;
138	final AsynchronousTreeViewer viewer = getTreeViewer();	147	final AsynchronousTreeViewer viewer = getTreeViewer();
139	preservingSelection(new Runnable() {	148	preservingSelection(new Runnable() {
140	public void run() {	149	public void run() {
141	viewer.nodeDisposed(node);	150	// unmap the removed node and all children that were shifted
142	viewer.nodeChildrenChanged(parentNode);	151	viewer.unmapNode(node);
		152	if (unmapFrom > -1) {
		153	ModelNode[] childrenNodes = parentNode.getChildrenNodes();
		154	for (int i = unmapFrom; i < childrenNodes.length; i++) {
		155	viewer.unmapNode(childrenNodes[i]);
		156	}
		157	}
		158	viewer.nodeChildrenChanged(parentNode);
143	}	159	}
144	});	160	});
145	}	161	}
Lines 166-171 Link Here
166	ModelNode node = new ModelNode(parent, element);	182	ModelNode node = new ModelNode(parent, element);
167	parent.addChild(node);	183	parent.addChild(node);
168	mapElement(element, node);	184	mapElement(element, node);
		185	if (DEBUG_MODEL) {
		186	DebugUIPlugin.debug("ADD: (parent) " + parent + " (child) " + element); //$NON-NLS-1$//$NON-NLS-2$
		187	DebugUIPlugin.debug(toString());
		188	}
169	}	189	}
170	//TODO sort???	190	//TODO sort???
171	// notify the viewer to update	191	// notify the viewer to update
Lines 240-248 Link Here
240	* @param node	260	* @param node
241	* @param containsChildren	261	* @param containsChildren
242	*/	262	*/
243	void setIsContainer(ModelNode node, boolean containsChildren) {	263	void setIsContainer(final ModelNode node, boolean containsChildren) {
244	ModelNode[] prevChildren = null;	264	ModelNode[] prevChildren = null;
		265	boolean prevContains = false;
245	synchronized (this) {	266	synchronized (this) {
		267	prevContains = node.isContainer();
246	prevChildren = node.getChildrenNodes();	268	prevChildren = node.getChildrenNodes();
247	node.setIsContainer(containsChildren);	269	node.setIsContainer(containsChildren);
248	if (!containsChildren && prevChildren != null) {	270	if (!containsChildren && prevChildren != null) {
Lines 253-274 Link Here
253	}	275	}
254	node.setChildren(null);	276	node.setChildren(null);
255	}	277	}
		278	if (DEBUG_MODEL) {
		279	DebugUIPlugin.debug("SET CONTAINER: " + node); //$NON-NLS-1$
		280	DebugUIPlugin.debug(toString());
		281	}
256	}	282	}
257	// update tree outside lock	283	// update tree outside lock
258	AsynchronousTreeViewer viewer = getTreeViewer();	284	preservingSelection(new Runnable() {
259	if (containsChildren) {	285	public void run() {
260	if (prevChildren == null) {	286	getTreeViewer().nodeContainerChanged(node);
261	viewer.nodeChildrenChanged(node);	287	getViewer().nodeChildrenChanged(node);
262	viewer.nodeContainerChanged(node);	288	}
263	} else {	289	});
264	viewer.nodeContainerChanged(node);	290
265	}
266	} else if (!containsChildren && prevChildren != null) {
267	for (int i = 0; i < prevChildren.length; i++) {
268	ModelNode child = prevChildren[i];
269	viewer.nodeDisposed(child);
270	}
271	viewer.nodeChildrenChanged(node);
272	}
273	}	291	}
274	}	292	}