Attachment #39227 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);
			int itemCount = fTree.getItemCount();
			for (int i = 0; i < itemCount; i++) {
				fTree.clear(i, true);
			}
			System.out.println("stop");
		}
    }

    /*
     * (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();
			}
		}			
	}

}





	protected static final String OLD_LABEL = "old_label"; //$NON-NLS-1$
	protected static final String OLD_IMAGE = "old_image"; //$NON-NLS-1$

    /**
     * Map of parent nodes for which children were needed to "set data"
     * in the virtual widget. A parent is added to this map when we try go
     * get children but they aren't there yet. The children are retrieved
     * asynchronously, and later put back into the widgetry.
     * The value is an array of ints of the indicies of the children that 
     * were requested. 
     */	
	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 (index == -1) {
			return;
		}
       
		ModelNode[] nodes = getModel().getNodes(parentItem.getData());
		if (nodes != null) {

		        		        internalRefresh(child);
		        		    }
		        		});
		        	}
		        		addPendingChildIndex(node, index);
		            }
		        	return;
				}
			}
        }
    }
	
	protected abstract void restoreLabels(Item item);

	/**




        final AsynchronousTreeViewer viewer = getTreeViewer();
        preservingSelection(new Runnable() {
			public void run() {
		        viewer.nodeChildrenChanged(parentNode);
				viewer.nodeChildrenChanged(parentNode);
			}
		});
    }

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

			}
		}
//    	 update tree outside lock
    	preservingSelection(new Runnable() {
			public void run() {
				getViewer().nodeChildrenChanged(node);
		    	getTreeViewer().nodeContainerChanged(node);
			}
		});
    	
            }
        } else if (!containsChildren && prevChildren != null) {            
            for (int i = 0; i < prevChildren.length; i++) {
                ModelNode child = prevChildren[i];
                viewer.nodeDisposed(child);
            }            
            viewer.nodeChildrenChanged(node);
        }
    }    
}




        
        ModelNode[] prevKids = null;
        ModelNode[] newChildren = null;
        ModelNode[] unmap = null; 
        
        synchronized (this) {
        	if (isDisposed()) {

    			}
            	parentNode.setChildren(newChildren);
            } else {
            	newChildren = new ModelNode[children.length];
            	unmap = new ModelNode[prevKids.length];
            	for (int i = 0; i < prevKids.length; i++) {
					unmap[i] = prevKids[i];	
				}
            	for (int i = 0; i < children.length; i++) {
					Object child = children[i];
					boolean found = false;
					for (int j = 0; j < prevKids.length; j++) {
						ModelNode prevKid = prevKids[j];
						if (prevKid != null && child.equals(prevKid.getElement())) {
							newChildren[i] = prevKid;
							prevKids[j] = null;
							found = true;
							break;
						}
					}
					if (!found) {
						newChildren[i] = new ModelNode(parentNode, child);
						mapElement(child, newChildren[i]);
					}
				}
            	for (int i = 0; i < prevKids.length; i++) {
            		ModelNode kid = prevKids[i];
            		if (kid != null) {
            			kid.dispose();
            			unmapNode(kid);
            		}
            	}
    	        parentNode.setChildren(newChildren);
                }
            }        	
        }
        
        //update viewer outside the lock
    	final ModelNode[] finalUnmap = unmap; 
        preservingSelection(new Runnable() {
            public void run() {
            	if (finalUnmap != null) {
	            	for (int i = 0; i < finalUnmap.length; i++) {
						viewer.unmapNode(finalUnmap[i]);
					}
	                        viewer.nodeDisposed(kid);
	                    } else {
	                        viewer.nodeChanged(kid);
	                    }
	                }
            	}
            	viewer.nodeChildrenChanged(parentNode);
            }
        });        	        


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 473-489 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/AsynchronousTableViewer.java (-11 / +7 lines)
473	}	473	}
474	}	474	}
475		475
476	public void nodeChanged(ModelNode node) {	476	/* (non-Javadoc)
477	Widget widget = findItem(node);	477	* @see org.eclipse.debug.internal.ui.viewers.AsynchronousViewer#clearChildren(org.eclipse.swt.widgets.Widget)
478	if (widget != null && !widget.isDisposed()) {	478	*/
479	if (widget instanceof TableItem) {	479	protected void clearChildren(Widget item) {
480	clear(widget);	480	if (item instanceof Table) {
481	return;	481	fTable.clearAll();
482	}	482	}
483	widget.setData(node.getElement());
484	internalRefresh(node);
485	}
486	}	483	}
487		484
488
489	}	485	}

Lines 442-448 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/AsynchronousTreeViewer.java (-41 / +40 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	int itemCount = fTree.getItemCount();
		862	for (int i = 0; i < itemCount; i++) {
		863	fTree.clear(i, true);
		864	}
		865	System.out.println("stop");
		866	}
		867	}
873		868
874	/*	869	/*
875	* (non-Javadoc)	870	* (non-Javadoc)
Lines 1169-1192 Link Here
1169	return new AsynchronousTreeModel(this);	1164	return new AsynchronousTreeModel(this);
1170	}	1165	}
1171		1166
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	/**	1167	/**
1191	* Attempt pending udpates. Subclasses may override but should call super.	1168	* Attempt pending udpates. Subclasses may override but should call super.
1192	*/	1169	*/
Lines 1563-1566 Link Here
1563	}	1540	}
1564	}	1541	}
1565	}	1542	}
		1543
		1544	/**
		1545	* Notification the container status of a node has changed/been computed.
		1546	*
		1547	* @param node
		1548	*/
		1549	protected void nodeContainerChanged(ModelNode node) {
		1550	Widget widget = findItem(node);
		1551	if (widget != null && !widget.isDisposed()) {
		1552	if (node.isContainer()) {
		1553	if (widget instanceof TreeItem) {
		1554	if (((TreeItem)widget).getExpanded()) {
		1555	updateChildren(node);
		1556	}
		1557	} else {
		1558	updateChildren(node);
		1559	}
		1560	attemptPendingUpdates();
		1561	}
		1562	}
		1563	}
		1564
1566	}	1565	}

Lines 138-145 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/AsynchronousTreeModel.java (-18 / +9 lines)
138	final AsynchronousTreeViewer viewer = getTreeViewer();	138	final AsynchronousTreeViewer viewer = getTreeViewer();
139	preservingSelection(new Runnable() {	139	preservingSelection(new Runnable() {
140	public void run() {	140	public void run() {
141	viewer.nodeDisposed(node);	141	viewer.nodeChildrenChanged(parentNode);
142	viewer.nodeChildrenChanged(parentNode);
143	}	142	}
144	});	143	});
145	}	144	}
Lines 240-246 Link Here
240	* @param node	239	* @param node
241	* @param containsChildren	240	* @param containsChildren
242	*/	241	*/
243	void setIsContainer(ModelNode node, boolean containsChildren) {	242	void setIsContainer(final ModelNode node, boolean containsChildren) {
244	ModelNode[] prevChildren = null;	243	ModelNode[] prevChildren = null;
245	synchronized (this) {	244	synchronized (this) {
246	prevChildren = node.getChildrenNodes();	245	prevChildren = node.getChildrenNodes();
Lines 255-274 Link Here
255	}	254	}
256	}	255	}
257	// update tree outside lock	256	// update tree outside lock
258	AsynchronousTreeViewer viewer = getTreeViewer();	257	preservingSelection(new Runnable() {
259	if (containsChildren) {	258	public void run() {
260	if (prevChildren == null) {	259	getViewer().nodeChildrenChanged(node);
261	viewer.nodeChildrenChanged(node);	260	getTreeViewer().nodeContainerChanged(node);
262	viewer.nodeContainerChanged(node);	261	}
263	} else {	262	});
264	viewer.nodeContainerChanged(node);	263
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	}	264	}
274	}	265	}

Lines 475-480 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/AsynchronousModel.java (-42 / +37 lines)
475		475
476	ModelNode[] prevKids = null;	476	ModelNode[] prevKids = null;
477	ModelNode[] newChildren = null;	477	ModelNode[] newChildren = null;
		478	ModelNode[] unmap = null;
478		479
479	synchronized (this) {	480	synchronized (this) {
480	if (isDisposed()) {	481	if (isDisposed()) {
Lines 490-544 Link Here
490	}	491	}
491	parentNode.setChildren(newChildren);	492	parentNode.setChildren(newChildren);
492	} else {	493	} else {
493	for (int i = 0; i < prevKids.length; i++) {	494	newChildren = new ModelNode[children.length];
494	ModelNode kid = prevKids[i];	495	unmap = new ModelNode[prevKids.length];
495	if (i >= children.length) {	496	for (int i = 0; i < prevKids.length; i++) {
496	kid.dispose();	497	unmap[i] = prevKids[i];
497	unmapNode(kid);	498	}
498	} else {	499	for (int i = 0; i < children.length; i++) {
499	ModelNode prevNode = prevKids[i];	500	Object child = children[i];
500	Object nextChild = children[i];	501	boolean found = false;
501	if (!prevNode.getElement().equals(nextChild)) {	502	for (int j = 0; j < prevKids.length; j++) {
502	unmapNode(prevNode);	503	ModelNode prevKid = prevKids[j];
503	}	504	if (prevKid != null && child.equals(prevKid.getElement())) {
504	mapElement(nextChild, prevNode);	505	newChildren[i] = prevKid;
505	}	506	prevKids[j] = null;
506	}	507	found = true;
507	// create new children	508	break;
508	if (children.length > prevKids.length) {	509	}
509	newChildren = new ModelNode[children.length];	510	}
510	System.arraycopy(prevKids, 0, newChildren, 0, prevKids.length);	511	if (!found) {
511	for (int i = prevKids.length; i < children.length; i ++) {	512	newChildren[i] = new ModelNode(parentNode, child);
512	Object child = children[i];	513	mapElement(child, newChildren[i]);
513	ModelNode childNode = new ModelNode(parentNode, child);	514	}
514	mapElement(child, childNode);	515	}
515	newChildren[i] = childNode;	516	for (int i = 0; i < prevKids.length; i++) {
516	}	517	ModelNode kid = prevKids[i];
517	parentNode.setChildren(newChildren);	518	if (kid != null) {
518	}	519	kid.dispose();
519	if (children.length < prevKids.length) {	520	unmapNode(kid);
520	newChildren = new ModelNode[children.length];	521	}
521	System.arraycopy(prevKids, 0, newChildren, 0, children.length);	522	}
522	parentNode.setChildren(newChildren);	523	parentNode.setChildren(newChildren);
523	}
524	}	524	}
525	}	525	}
526		526
527	//update viewer outside the lock	527	//update viewer outside the lock
528	final ModelNode[] finalPrevKids = prevKids;	528	final ModelNode[] finalUnmap = unmap;
529	preservingSelection(new Runnable() {	529	preservingSelection(new Runnable() {
530	public void run() {	530	public void run() {
531	if (finalPrevKids != null) {	531	if (finalUnmap != null) {
532	for (int i = 0; i < finalPrevKids.length; i++) {	532	for (int i = 0; i < finalUnmap.length; i++) {
533	ModelNode kid = finalPrevKids[i];	533	viewer.unmapNode(finalUnmap[i]);
534	if (i >= children.length) {	534	}
535	viewer.nodeDisposed(kid);
536	} else {
537	viewer.nodeChanged(kid);
538	}
539	}
540	}	535	}
541	viewer.nodeChildrenChanged(parentNode);	536	viewer.nodeChildrenChanged(parentNode);
542	}	537	}
543	});	538	});
544		539

Lines 113-128 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/AsynchronousViewer.java (-119 / +42 lines)
113		113
114	protected static final String OLD_LABEL = "old_label"; //$NON-NLS-1$	114	protected static final String OLD_LABEL = "old_label"; //$NON-NLS-1$
115	protected static final String OLD_IMAGE = "old_image"; //$NON-NLS-1$	115	protected static final String OLD_IMAGE = "old_image"; //$NON-NLS-1$
116
117	/**
118	* Map of parent nodes for which children were needed to "set data"
119	* in the virtual widget. A parent is added to this map when we try go
120	* get children but they aren't there yet. The children are retrieved
121	* asynchronously, and later put back into the widgetry.
122	* The value is an array of ints of the indicies of the children that
123	* were requested.
124	*/
125	private Map fParentsPendingChildren = new HashMap();
126		116
127	/**	117	/**
128	* Creates a new viewer	118	* Creates a new viewer
Lines 238-244 Link Here
238	* @see org.eclipse.jface.viewers.Viewer#inputChanged(java.lang.Object, java.lang.Object)	228	* @see org.eclipse.jface.viewers.Viewer#inputChanged(java.lang.Object, java.lang.Object)
239	*/	229	*/
240	protected synchronized void inputChanged(Object input, Object oldInput) {	230	protected synchronized void inputChanged(Object input, Object oldInput) {
241	fParentsPendingChildren.clear();
242	if (fUpdatePolicy == null) {	231	if (fUpdatePolicy == null) {
243	fUpdatePolicy = createUpdatePolicy();	232	fUpdatePolicy = createUpdatePolicy();
244	fUpdatePolicy.init(this);	233	fUpdatePolicy.init(this);
Lines 832-866 Link Here
832	protected AsynchronousModel getModel() {	821	protected AsynchronousModel getModel() {
833	return fModel;	822	return fModel;
834	}	823	}
835
836	/**
837	* A node has been disposed from the model.
838	*
839	* @param node
840	*/
841	protected void nodeDisposed(ModelNode node) {
842	Widget widget = findItem(node);
843	if (widget != null) {
844	unmapNode(node);
845	widget.dispose();
846	}
847	}
848
849	/**
850	* Unmaps the node from its widget and all of its children nodes from
851	* their widgets.
852	*
853	* @param node
854	*/
855	protected void unmapNode(ModelNode node) {
856	unmapElement(node);
857	ModelNode[] childrenNodes = node.getChildrenNodes();
858	if (childrenNodes != null) {
859	for (int i = 0; i < childrenNodes.length; i++) {
860	unmapNode(childrenNodes[i]);
861	}
862	}
863	}
864		824
865	/**	825	/**
866	* A node in the model has been updated	826	* A node in the model has been updated
Lines 870-877 Link Here
870	protected void nodeChanged(ModelNode node) {	830	protected void nodeChanged(ModelNode node) {
871	Widget widget = findItem(node);	831	Widget widget = findItem(node);
872	if (widget != null) {	832	if (widget != null) {
873	widget.setData(node.getElement());	833	clear(widget);
874	internalRefresh(node);	834	attemptPendingUpdates();
875	}	835	}
876	}	836	}
877		837
Lines 892-929 Link Here
892	}	852	}
893		853
894	/**	854	/**
895	* Called when nodes are set in the model. The children may not have been	855	* Clears the given widget
896	* retrieved yet when the tree got the call to "set data".
897	*	856	*
898	* @param parent	857	* @param item
899	* @param children
900	*/	858	*/
901	protected void nodeChildrenSet(ModelNode parent, ModelNode[] children) {
902	int[] indicies = removePendingChildren(parent);
903	Widget widget = findItem(parent);
904	if (widget != null && !widget.isDisposed()) {
905	if (indicies != null) {
906	for (int i = 0; i < indicies.length; i++) {
907	int index = indicies[i];
908	Widget item = getChildWidget(widget, index);
909	if (item != null) {
910	if (index < children.length) {
911	ModelNode childNode = children[index];
912	mapElement(childNode, item);
913	item.setData(childNode.getElement());
914	internalRefresh(childNode);
915	}
916	}
917	}
918	setItemCount(widget, children.length);
919	} else {
920	setItemCount(widget, children.length);
921	}
922	}
923	attemptPendingUpdates();
924	}
925
926	protected abstract void clear(Widget item);	859	protected abstract void clear(Widget item);
		860
		861	/**
		862	* Clears the children of the widget.
		863	*
		864	* @param item
		865	*/
		866	protected abstract void clearChildren(Widget item);
927		867
928	/**	868	/**
929	* Returns the child widet at the given index for the given parent or	869	* Returns the child widet at the given index for the given parent or
Lines 949-970 Link Here
949	protected void attemptPendingUpdates() {	889	protected void attemptPendingUpdates() {
950	attemptSelection(false);	890	attemptSelection(false);
951	}	891	}
952		892
953	/**	893	/**
954	* The children of a node have changed.	894	* Notification a node's children have changed.
		895	* Updates the child count for the parent's widget
		896	* and clears children to be updated.
955	*	897	*
956	* @param parent	898	* @param parentNode
957	*/	899	*/
958	protected void nodeChildrenChanged(ModelNode parentNode) {	900	protected void nodeChildrenChanged(ModelNode parentNode) {
959	ModelNode[] childrenNodes = parentNode.getChildrenNodes();	901	Widget widget = findItem(parentNode);
		902	if (widget != null && !widget.isDisposed()) {
		903	int childCount = parentNode.getChildCount();
		904	setItemCount(widget, childCount);
		905	clearChildren(widget);
		906	attemptPendingUpdates();
		907	}
		908	}
		909
		910	/**
		911	* Unmaps the node from its widget and all of its children nodes from
		912	* their widgets.
		913	*
		914	* @param node
		915	*/
		916	protected void unmapNode(ModelNode node) {
		917	unmapElement(node);
		918	ModelNode[] childrenNodes = node.getChildrenNodes();
960	if (childrenNodes != null) {	919	if (childrenNodes != null) {
961	nodeChildrenSet(parentNode, childrenNodes);	920	for (int i = 0; i < childrenNodes.length; i++) {
962	} else {	921	unmapNode(childrenNodes[i]);
963	Widget widget = findItem(parentNode);
964	if (widget != null && !widget.isDisposed()) {
965	int childCount = parentNode.getChildCount();
966	setItemCount(widget, childCount);
967	attemptPendingUpdates();
968	}	922	}
969	}	923	}
970	}	924	}
Lines 997-1034 Link Here
997	return findItem((Object)node);	951	return findItem((Object)node);
998	}	952	}
999		953
1000	/**
1001	* Note that the child at the specified index was requested by a widget
1002	* when revealed but that the data was not in the model yet. When the data
1003	* becomes available, map it to its widget.
1004	*
1005	* @param parent
1006	* @param index
1007	*/
1008	protected synchronized void addPendingChildIndex(ModelNode parent, int index) {
1009	int[] indicies = (int[]) fParentsPendingChildren.get(parent);
1010	if (indicies == null) {
1011	indicies = new int[]{index};
1012	} else {
1013	int[] next = new int[indicies.length + 1];
1014	System.arraycopy(indicies, 0, next, 0, indicies.length);
1015	next[indicies.length] = index;
1016	indicies = next;
1017	}
1018	fParentsPendingChildren.put(parent, indicies);
1019	}
1020
1021	/**
1022	* Removes and returns and children indicies that were pending for the given
1023	* parent node. May return <code>null</code>.
1024	*
1025	* @param parent
1026	* @return indicies of children that data were requested for or <code>null</code>
1027	*/
1028	protected int[] removePendingChildren(ModelNode parent) {
1029	return (int[]) fParentsPendingChildren.remove(parent);
1030	}
1031
1032	/*	954	/*
1033	* (non-Javadoc)	955	* (non-Javadoc)
1034	*	956	*
Lines 1042-1047 Link Here
1042		964
1043	Widget parentItem = getParentWidget(event.item);	965	Widget parentItem = getParentWidget(event.item);
1044	int index = event.index;	966	int index = event.index;
		967	if (index == -1) {
		968	return;
		969	}
1045		970
1046	ModelNode[] nodes = getModel().getNodes(parentItem.getData());	971	ModelNode[] nodes = getModel().getNodes(parentItem.getData());
1047	if (nodes != null) {	972	if (nodes != null) {
Lines 1059-1073 Link Here
1059	internalRefresh(child);	984	internalRefresh(child);
1060	}	985	}
1061	});	986	});
1062	} else {	987	}
1063	addPendingChildIndex(node, index);
1064	}
1065	return;	988	return;
1066	}	989	}
1067	}	990	}
1068	}	991	}
1069	}	992	}
1070		993
1071	protected abstract void restoreLabels(Item item);	994	protected abstract void restoreLabels(Item item);
1072		995
1073	/**	996	/**