Attachment #126516 for bug #262266

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

Lines 11-17 Link Here

(-)ui/org/eclipse/debug/internal/ui/views/memory/MemoryViewTreeViewer.java (-2 / +2 lines)
11		11
12	package org.eclipse.debug.internal.ui.views.memory;	12	package org.eclipse.debug.internal.ui.views.memory;
13		13
14	import org.eclipse.debug.internal.ui.viewers.model.TreeModelContentProvider;	14	import org.eclipse.debug.internal.ui.viewers.model.ITreeModelContentProvider;
15	import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;	15	import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;
16	import org.eclipse.debug.internal.ui.viewers.model.provisional.TreeModelViewer;	16	import org.eclipse.debug.internal.ui.viewers.model.provisional.TreeModelViewer;
17	import org.eclipse.swt.widgets.Composite;	17	import org.eclipse.swt.widgets.Composite;
Lines 40-46 Link Here
40	* (non-Javadoc)	40	* (non-Javadoc)
41	* @see org.eclipse.debug.internal.ui.viewers.model.InternalTreeModelViewer#createContentProvider()	41	* @see org.eclipse.debug.internal.ui.viewers.model.InternalTreeModelViewer#createContentProvider()
42	*/	42	*/
43	protected TreeModelContentProvider createContentProvider() {	43	protected ITreeModelContentProvider createContentProvider() {
44	return new MemoryViewTreeModelContentProvider();	44	return new MemoryViewTreeModelContentProvider();
45	}	45	}
46		46

Lines 285-290 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/provisional/ModelDelta.java (+3 lines)
285	if ((flags & IModelDelta.REVEAL) > 0) {	285	if ((flags & IModelDelta.REVEAL) > 0) {
286	buf.append("REVEAL \| "); //$NON-NLS-1$	286	buf.append("REVEAL \| "); //$NON-NLS-1$
287	}	287	}
		288	if ((flags & IModelDelta.FORCE) > 0) {
		289	buf.append("FORCE \| "); //$NON-NLS-1$
		290	}
288		291
289	}	292	}
290	buf.append('\n');	293	buf.append('\n');




import org.eclipse.debug.internal.ui.viewers.model.provisional.PresentationContext;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.IBasicPropertyConstants;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.ILazyTreePathContentProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.TreePath;

							update = null;
						}
					} else {
						int modelIndex = ((ITreeModelContentProvider)getContentProvider()).viewToModelIndex(parentPath, i);
						if (update == null) {
							update = new VirtualChildrenUpdate(parentPath, this, model);
						} else if ((modelIndex - prevModelIndex) > 1) {

			if (fLabel == null) {
				return fItem.getImage();
			} else {
				return ((ITreeModelLabelProvider)getLabelProvider()).getImage(fLabel.fImage);
			}
		}


					int start = update.getOffset();
					int end = start + update.getLength();
					for (int i = start; i < end; i++) {
						int viewIndex = ((ITreeModelContentProvider)getContentProvider()).modelToViewIndex(parent, i);
						VirtualElement proxy = children[viewIndex];
						if (proxy.fFiltered) {
							fMonitor.worked(1); // don't need the label, this one is already done

		 * @see org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenUpdate#setChild(java.lang.Object, int)
		 */
		public void setChild(Object child, int offset) {
			int viewIndex = ((ITreeModelContentProvider)getContentProvider()).modelToViewIndex(getElementPath(), offset);
			VirtualElement virtualChild = getVirtualElement().fChildren[viewIndex];
			virtualChild.setElement(child);
			ITreeModelContentProvider provider = (ITreeModelContentProvider) getContentProvider();
			virtualChild.fFiltered = provider.shouldFilter(getElementPath(), child);
			if (!virtualChild.fFiltered) {
				virtualChild.retrieveChildren(getElementPath().createChildPath(child), fModel);

		setLabelProvider(createLabelProvider());
		
		if ((style & SWT.POP_UP) != 0) {
		    ((ITreeModelContentProvider)getContentProvider()).setSuppressModelControlDeltas(true);
		}
	}
	
	/**
	 * @return content provider for this tree viewer
	 */
	protected ITreeModelContentProvider createContentProvider()
	{
		return new TreeModelContentProvider();
	}

	/**
	 * @return label provider for this tree viewer
	 */
	protected ITreeModelLabelProvider createLabelProvider()
	{
		return new TreeModelLabelProvider(this);
	}

	protected void unmapElement(Object element, Widget widget) {
		if (fNotifyUnmap) {
			// TODO: should we update the filter with the "new non-identical element"?
		    ((ITreeModelContentProvider) getContentProvider()).unmapPath((TreePath) widget.getData(TREE_PATH_KEY));
			if (provider instanceof ModelContentProvider) {
				((ModelContentProvider) provider).unmapPath((TreePath) widget.getData(TREE_PATH_KEY));
			}
		}
		super.unmapElement(element, widget);
	}

				column.setWidth(1);
				ImageDescriptor image = presentation.getImageDescriptor(id);
				if (image != null) {
					column.setImage(((ITreeModelLabelProvider)getLabelProvider()).getImage(image));
				}
				column.setData(id);
			}

	 * @param listener listener
	 */
	public void addViewerUpdateListener(IViewerUpdateListener listener) {
		((ITreeModelContentProvider)getContentProvider()).addViewerUpdateListener(listener);
	}
	
	/**

	 * @param listener listener
	 */
	public void removeViewerUpdateListener(IViewerUpdateListener listener) {
	    ITreeModelContentProvider cp = (ITreeModelContentProvider)getContentProvider();
		if (cp !=  null) {
			cp.removeViewerUpdateListener(listener);
		}

	 * @param listener model delta listener
	 */
	public void addModelChangedListener(IModelChangedListener listener) {
		((ITreeModelContentProvider)getContentProvider()).addModelChangedListener(listener); 
	}
	
	/**

	 * @param listener model delta listener
	 */
	public void removeModelChangedListener(IModelChangedListener listener) {
	    ITreeModelContentProvider cp = (ITreeModelContentProvider)getContentProvider();
		if (cp !=  null) {
			cp.removeModelChangedListener(listener);
		}

			return;
		}
		
		if ( !((ITreeModelLabelProvider)getLabelProvider()).update(getTreePathFromItem(item)) ) {
            if (element instanceof String) {
                item.setData(PREV_LABEL_KEY, new String[] { (String)element } );
            }		    

	}
		
	public void addLabelUpdateListener(ILabelUpdateListener listener) {
	    ((ITreeModelLabelProvider)getLabelProvider()).addLabelUpdateListener(listener);
        if (labelProvider instanceof TreeModelLabelProvider) {
            ((TreeModelLabelProvider)labelProvider).addLabelUpdateListener(listener);
        }
	}
	
	public void removeLabelUpdateListener(ILabelUpdateListener listener) {
	    if (!getControl().isDisposed()) {
	        ((ITreeModelLabelProvider)getLabelProvider()).removeLabelUpdateListener(listener);
	        if (labelProvider instanceof TreeModelLabelProvider) {
	            ((TreeModelLabelProvider)labelProvider).removeLabelUpdateListener(listener);
	        }
	    }
	}
	

            } else {
                Image[] images = new Image[imageDescriptors.length];
                for (int i = 0; i < imageDescriptors.length; i++) {
                    images[i] = ((ITreeModelLabelProvider)getLabelProvider()).getImage(imageDescriptors[i]);
                }
                if (columnIds == null) {
                    item.setImage(images[0]);

            } else {
                Color[] foregrounds = new Color[_foregrounds.length];
                for (int i = 0; i< foregrounds.length; i++) {
                    foregrounds[i] = ((ITreeModelLabelProvider)getLabelProvider()).getColor(_foregrounds[i]);
                }
                if (columnIds == null) {
                    item.setForeground(0,foregrounds[0]);

            } else {
                Color[] backgrounds = new Color[_backgrounds.length];
                for (int i = 0; i< backgrounds.length; i++) {
                    backgrounds[i] = ((ITreeModelLabelProvider)getLabelProvider()).getColor(_backgrounds[i]);
                }
                if (columnIds == null) {
                    item.setBackground(0,backgrounds[0]);

            } else {
                Font[] fonts = new Font[fontDatas.length];
                for (int i = 0; i < fontDatas.length; i++) {
                    fonts[i] = ((ITreeModelLabelProvider)getLabelProvider()).getFont(fontDatas[i]);
                }
                if (columnIds == null) {
                    item.setFont(0,fonts[0]);

        TreeItem[] items = null;
        Widget w = internalGetWidgetToSelect(path);
        if (w instanceof Tree) {
            delta.setChildCount(
                ((ITreeModelContentProvider)getContentProvider()).viewToModelCount(path, tree.getItemCount()));
            delta.setFlags(delta.getFlags() | IModelDelta.EXPAND);
            items = tree.getItems(); 
        } else if (w instanceof TreeItem) {
            TreeItem item = (TreeItem)w;
            delta.setChildCount(
                ((ITreeModelContentProvider)getContentProvider()).viewToModelCount(path, item.getItemCount()));
            if (item.getExpanded()) {
                delta.setFlags(delta.getFlags() | IModelDelta.EXPAND);
            }

                if (selected) {
                    flags = flags | IModelDelta.SELECT;
                }
                int modelIndex = ((ITreeModelContentProvider)getContentProvider()).viewToModelIndex(parentPath, index);
                TreePath elementPath = parentPath.createChildPath(element);
                int numChildren = ((ITreeModelContentProvider)getContentProvider()).
                    viewToModelCount(elementPath, item.getItemCount());
                ModelDelta childDelta = delta.addNode(element, modelIndex, flags, numChildren);
                if (expanded) {
                    TreeItem[] items = item.getItems();

    }
    
    public void updateViewer(IModelDelta delta) {
        ((ITreeModelContentProvider)getContentProvider()).updateModel(delta);
    }
}




        fLabelProvider = new TreeModelLabelProvider(this);
        
        if ((style & SWT.POP_UP) != 0) {
            ((ITreeModelContentProvider)getContentProvider()).setSuppressModelControlDeltas(true);
        }
    }


        return -1;
    }

    private ITreeModelLabelProvider getLabelProvider() {
        return fLabelProvider;
    }

    private ITreeModelContentProvider getContentProvider() {
        return fContentProvider;
    }


    }
    
    public void removeViewerUpdateListener(IViewerUpdateListener listener) {
        ITreeModelContentProvider cp = getContentProvider();
        if (cp !=  null) {
            cp.removeViewerUpdateListener(listener);
        }

    }
    
    public void removeModelChangedListener(IModelChangedListener listener) {
        ITreeModelContentProvider cp = getContentProvider();
        if (cp !=  null) {
            cp.removeModelChangedListener(listener);
        }




/**
 * @since 3.3
 */
public class TreeModelLabelProvider extends ColumnLabelProvider implements ITreeModelLabelProvider {
	
	private ITreeModelLabelProviderTarget fViewer;
	private List fComplete;

	 * @param descriptor image descriptor or <code>null</code>
	 * @return image or <code>null</code>
	 */
	public Image getImage(ImageDescriptor descriptor) {
		if (descriptor == null) {
			return null;
		}

	 * @param fontData font data or <code>null</code>
	 * @return font font or <code>null</code>
	 */
	public Font getFont(FontData fontData) {
		if (fontData == null) {
			return null;
		}

	 * @param rgb RGB or <code>null</code>
	 * @return color or <code>null</code>
	 */
	public Color getColor(RGB rgb) {
		if (rgb == null) {
			return null;
		}

		}
    }
    
	public void addLabelUpdateListener(ILabelUpdateListener listener) {
		fLabelListeners.add(listener);
	}
	
	public void removeLabelUpdateListener(ILabelUpdateListener listener) {
		fLabelListeners.remove(listener);
	}
	

Lines 17-23 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/TreeModelContentProvider.java (-2 / +1 lines)
17	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDeltaVisitor;	17	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDeltaVisitor;
18	import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;	18	import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;
19	import org.eclipse.debug.internal.ui.viewers.model.provisional.ModelDelta;	19	import org.eclipse.debug.internal.ui.viewers.model.provisional.ModelDelta;
20	import org.eclipse.jface.viewers.ILazyTreePathContentProvider;
21	import org.eclipse.jface.viewers.TreePath;	20	import org.eclipse.jface.viewers.TreePath;
22	import org.eclipse.jface.viewers.TreeSelection;	21	import org.eclipse.jface.viewers.TreeSelection;
23		22
Lines 26-32 Link Here
26	*	25	*
27	* @since 3.3	26	* @since 3.3
28	*/	27	*/
29	public class TreeModelContentProvider extends ModelContentProvider implements ILazyTreePathContentProvider {	28	public class TreeModelContentProvider extends ModelContentProvider implements ITreeModelContentProvider {
30		29
31	/**	30	/**
32	* Re-filters any filtered children of the given parent element.	31	* Re-filters any filtered children of the given parent element.

Lines 18-25 Link Here

(-)ui/org/eclipse/debug/internal/ui/views/launch/LaunchViewBreadcrumb.java (-12 / +46 lines)
18	import org.eclipse.debug.internal.ui.viewers.breadcrumb.IBreadcrumbDropDownSite;	18	import org.eclipse.debug.internal.ui.viewers.breadcrumb.IBreadcrumbDropDownSite;
19	import org.eclipse.debug.internal.ui.viewers.breadcrumb.TreeViewerDropDown;	19	import org.eclipse.debug.internal.ui.viewers.breadcrumb.TreeViewerDropDown;
20	import org.eclipse.debug.internal.ui.viewers.model.ILabelUpdateListener;	20	import org.eclipse.debug.internal.ui.viewers.model.ILabelUpdateListener;
		21	import org.eclipse.debug.internal.ui.viewers.model.SubTreeModelViewer;
		22	import org.eclipse.debug.internal.ui.viewers.model.TreeModelContentProvider;
21	import org.eclipse.debug.internal.ui.viewers.model.provisional.ILabelUpdate;	23	import org.eclipse.debug.internal.ui.viewers.model.provisional.ILabelUpdate;
22	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta;	24	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta;
		25	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDeltaVisitor;
23	import org.eclipse.debug.internal.ui.viewers.model.provisional.ModelDelta;	26	import org.eclipse.debug.internal.ui.viewers.model.provisional.ModelDelta;
24	import org.eclipse.debug.internal.ui.viewers.model.provisional.TreeModelViewer;	27	import org.eclipse.debug.internal.ui.viewers.model.provisional.TreeModelViewer;
25	import org.eclipse.debug.ui.contexts.AbstractDebugContextProvider;	28	import org.eclipse.debug.ui.contexts.AbstractDebugContextProvider;
Lines 38-44 Link Here
38	import org.eclipse.jface.viewers.SelectionChangedEvent;	41	import org.eclipse.jface.viewers.SelectionChangedEvent;
39	import org.eclipse.jface.viewers.StructuredSelection;	42	import org.eclipse.jface.viewers.StructuredSelection;
40	import org.eclipse.jface.viewers.TreePath;	43	import org.eclipse.jface.viewers.TreePath;
41	import org.eclipse.jface.viewers.TreeSelection;
42	import org.eclipse.jface.viewers.TreeViewer;	44	import org.eclipse.jface.viewers.TreeViewer;
43	import org.eclipse.jface.viewers.Viewer;	45	import org.eclipse.jface.viewers.Viewer;
44	import org.eclipse.jface.viewers.ViewerFilter;	46	import org.eclipse.jface.viewers.ViewerFilter;
Lines 353-367 Link Here
353		355
354	TreeViewerDropDown dropDownTreeViewer = new TreeViewerDropDown() {	356	TreeViewerDropDown dropDownTreeViewer = new TreeViewerDropDown() {
355		357
356	TreeModelViewer fDropDownViewer;	358	SubTreeModelViewer fDropDownViewer;
357		359
358	protected TreeViewer createTreeViewer(Composite composite, int style, TreePath path) {	360	protected TreeViewer createTreeViewer(Composite composite, int style, final TreePath path) {
359	fDropDownViewer = new TreeModelViewer(	361	fDropDownViewer = new SubTreeModelViewer(
360	composite, SWT.SINGLE \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.VIRTUAL \| SWT.POP_UP,	362	composite, SWT.SINGLE \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.VIRTUAL \| SWT.POP_UP,
361	fTreeViewer.getPresentationContext());	363	fTreeViewer.getPresentationContext());
362		364
363	Object launchViewInput = fTreeViewer.getInput();	365	Object launchViewInput = fTreeViewer.getInput();
364	fDropDownViewer.setInput(launchViewInput);	366	fDropDownViewer.setInput(launchViewInput, path.getParentPath());
365		367
366	ViewerFilter[] filters = fTreeViewer.getFilters();	368	ViewerFilter[] filters = fTreeViewer.getFilters();
367	fDropDownViewer.setFilters(filters);	369	fDropDownViewer.setFilters(filters);
Lines 370-379 Link Here
370	fTreeViewer.saveElementState(TreePath.EMPTY, delta);	372	fTreeViewer.saveElementState(TreePath.EMPTY, delta);
371	fDropDownViewer.updateViewer(delta);	373	fDropDownViewer.updateViewer(delta);
372		374
373	if (path.getSegmentCount() != 0) {
374	fDropDownViewer.setSelection(new TreeSelection(path), true, true);
375	}
376
377	fDropDownViewer.addLabelUpdateListener(new ILabelUpdateListener() {	375	fDropDownViewer.addLabelUpdateListener(new ILabelUpdateListener() {
378	public void labelUpdateComplete(ILabelUpdate update) {}	376	public void labelUpdateComplete(ILabelUpdate update) {}
379	public void labelUpdatesBegin() {}	377	public void labelUpdatesBegin() {}
Lines 393-403 Link Here
393	}	391	}
394		392
395	protected void openElement(ISelection selection) {	393	protected void openElement(ISelection selection) {
		394	if (fTreeViewer.getControl().isDisposed()) {
		395	return;
		396	}
		397
396	if (selection != null && (selection instanceof ITreeSelection) && !selection.isEmpty()) {	398	if (selection != null && (selection instanceof ITreeSelection) && !selection.isEmpty()) {
397	ModelDelta delta = new ModelDelta(fDropDownViewer.getInput(), IModelDelta.NO_CHANGE);	399	// Create the path to the root element of the drop-down viewer. Need to calcualte
		400	// indexes and counts for the delta in order for the selection from the drop-down
		401	// viewer to work properly.
		402	TreeModelContentProvider contentProvider = (TreeModelContentProvider)fTreeViewer.getContentProvider();
		403	TreePath path = TreePath.EMPTY;
		404	int count = fTreeViewer.getChildCount(path);
		405	count = contentProvider.viewToModelCount(path, count);
		406	ModelDelta rootDelta =
		407	new ModelDelta(fTreeViewer.getInput(), -1, IModelDelta.NO_CHANGE, count);
		408	TreePath rootPath = fDropDownViewer.getRootPath();
		409	ModelDelta delta = rootDelta;
		410	for (int i = 0; i < rootPath.getSegmentCount(); i++) {
		411	Object element = rootPath.getSegment(i);
		412	int index = fTreeViewer.findElementIndex(path, element);
		413	index = contentProvider.viewToModelIndex(path, index);
		414	path = path.createChildPath(element);
		415	count = fTreeViewer.getChildCount(path);
		416	count = contentProvider.viewToModelCount(path, count);
		417	delta = delta.addNode(rootPath.getSegment(i), index, IModelDelta.NO_CHANGE, count);
		418	}
		419
		420	// Create the delta and save the drop-down viewer's state to it.
398	fDropDownViewer.saveElementState(TreePath.EMPTY, delta);	421	fDropDownViewer.saveElementState(TreePath.EMPTY, delta);
399	fTreeViewer.updateViewer(delta);	422
400	fTreeViewer.setSelection(selection, true, true);	423	// Add the IModelDelta.FORCE flag to override the current selection in view.
		424	rootDelta.accept(new IModelDeltaVisitor(){
		425	public boolean visit(IModelDelta paramDelta, int depth) {
		426	if ((paramDelta.getFlags() & IModelDelta.SELECT) != 0) {
		427	((ModelDelta)paramDelta).setFlags(paramDelta.getFlags() \| IModelDelta.FORCE);
		428	}
		429	return true;
		430	}
		431	});
		432
		433	// Save the state of the drop-down into the tree viewer.
		434	fTreeViewer.updateViewer(rootDelta);
401	fViewer.setSelection(StructuredSelection.EMPTY);	435	fViewer.setSelection(StructuredSelection.EMPTY);
402	site.close();	436	site.close();
403	}	437	}




/*******************************************************************************
 * Copyright (c) 2009 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.viewers.model;

import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelChangedListener;
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.IViewerUpdateListener;
import org.eclipse.debug.internal.ui.viewers.model.provisional.ModelDelta;
import org.eclipse.debug.internal.ui.viewers.model.provisional.TreeModelViewer;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.viewers.ViewerLabel;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;

/**
 * Specialized tree viewer which displays only sub-tree of a full model. 
 * 
 * @since 3.5
 */
public class SubTreeModelViewer extends TreeModelViewer {

    /**
     * The tree path in the model to the root element of this viewer.
     */
    private TreePath fRootPath = TreePath.EMPTY;

    /**
     * Viewer delegate that content and label providers refer to for viewer data.
     */
    private DelegatingTreeModelViewer fDelegatingViewer;
    
    /**
     * Returns the root element's model tree path. 
     */
    public TreePath getRootPath() {
        return fRootPath;
    }

    public SubTreeModelViewer(Composite parent, int style, IPresentationContext context) {
        super(parent, style, context);
    }

    /**
     * Sets the viewer's input and root element's path
     * 
     * @param input New viewer input.
     * @param rootPath New root element path.
     */
    public void setInput(Object input, TreePath rootPath) {
        fRootPath = rootPath;
        super.setInput(input);
    }
    
    /**
     * A proxy for the sub tree viewer which is given to the content and 
     * label providers.  It translates the sub-tree paths in the viewer to the 
     * full model paths that the providers expect.
     */
    public class DelegatingTreeModelViewer extends Viewer 
        implements ITreeModelLabelProviderTarget, ITreeModelContentProviderTarget 
    {
        public void reveal(TreePath path, int index) {
            if (path.startsWith(fRootPath, null)) {
                SubTreeModelViewer.this.reveal(createSubPath(path), index);
            }
        }
        
        public void replace(Object parentOrTreePath, int index, Object element) {
            if (parentOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)parentOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    SubTreeModelViewer.this.replace(createSubPath(path), index, element);
                }
            } else {
                SubTreeModelViewer.this.replace(parentOrTreePath, index, element);
            }
        }
        
        public void setChildCount(Object elementOrTreePath, int count) {
            if (elementOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)elementOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    SubTreeModelViewer.this.setChildCount(createSubPath(path), count);
                }
            } else {
                SubTreeModelViewer.this.setChildCount(elementOrTreePath, count);
            }
        }
        
        public void setHasChildren(Object elementOrTreePath, boolean hasChildren) {
            if (elementOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)elementOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    SubTreeModelViewer.this.setHasChildren(createSubPath(path), hasChildren);
                }
            } else {
                SubTreeModelViewer.this.setHasChildren(elementOrTreePath, hasChildren);
            }
        }

        public void autoExpand(TreePath elementPath) {
            // not supported
        }

        public void setExpandedState(Object elementOrTreePath, boolean expanded) {
            if (elementOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)elementOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    SubTreeModelViewer.this.setExpandedState(createSubPath(path), expanded);
                }
            } else {
                SubTreeModelViewer.this.setExpandedState(elementOrTreePath, expanded);
            }
        }
        
        public void expandToLevel(Object elementOrTreePath, int level) {
            if (elementOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)elementOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    SubTreeModelViewer.this.expandToLevel(createSubPath(path), level);
                }
            } else {
                SubTreeModelViewer.this.expandToLevel(elementOrTreePath, level);
            }
        }

        public void remove(Object elementOrTreePath) {
            if (elementOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)elementOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    SubTreeModelViewer.this.remove(createSubPath(path));
                }
            } else {
                SubTreeModelViewer.this.remove(elementOrTreePath);
            }
        }

        public void remove(Object parentOrTreePath, final int index) {
            if (parentOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)parentOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    SubTreeModelViewer.this.remove(createSubPath(path), index);
                }
            } else {
                SubTreeModelViewer.this.remove(parentOrTreePath, index);
            }
        }

        public void insert(Object parentOrTreePath, Object element, int position) {
            if (parentOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)parentOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    SubTreeModelViewer.this.insert(createSubPath(path), element, position);
                }
            } else {
                SubTreeModelViewer.this.insert(parentOrTreePath, element, position);
            }
        }

        public boolean getExpandedState(Object elementOrTreePath) {
            if (elementOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)elementOrTreePath;
                if (path.startsWith(fRootPath, null)) {
                    return SubTreeModelViewer.this.getExpandedState(createSubPath(path));
                }
            } else {
                return SubTreeModelViewer.this.getExpandedState(elementOrTreePath);
            }
            return false;
        }
        
        public int getChildCount(TreePath path) {
            if (path.startsWith(fRootPath, null)) {
                return SubTreeModelViewer.this.getChildCount(createSubPath(path));
            }        
            return -1;
        }

        public Object getChildElement(TreePath path, int index) {
            if (path.startsWith(fRootPath, null)) {
                return SubTreeModelViewer.this.getChildElement(createSubPath(path), index);
            }        
            return null;
        }
        
        public TreePath getTopElementPath() {
            return createFullPath(SubTreeModelViewer.this.getTopElementPath());
        }
        
        public int findElementIndex(TreePath parentPath, Object element) {
            if (parentPath.startsWith(fRootPath, null)) {
                return SubTreeModelViewer.this.findElementIndex(createSubPath(parentPath), element);
            }        
            return -1;
        }
        
        public void setElementData(TreePath path, int numColumns, String[] labels, ImageDescriptor[] images, FontData[] fontDatas, RGB[] foregrounds, RGB[] backgrounds) {
            if (path.startsWith(fRootPath, null)) {
                SubTreeModelViewer.this.setElementData(createSubPath(path), numColumns, labels, images, fontDatas, foregrounds, backgrounds);
            }        
        }

        public Control getControl() {
            return SubTreeModelViewer.this.getControl();
        }

        public Object getInput() {
            return SubTreeModelViewer.this.getInput();
        }

        public ISelection getSelection() {
            return SubTreeModelViewer.this.getSelection();
        }

        public void refresh() {
            SubTreeModelViewer.this.refresh();
        }

        public void setInput(Object input) {
            SubTreeModelViewer.this.setInput(input);
        }

        public void setSelection(ISelection selection, boolean reveal) {
            SubTreeModelViewer.this.setSelection(selection, reveal);
        }

        public String[] getVisibleColumns() {
             return SubTreeModelViewer.this.getVisibleColumns();
        }

        public void addLabelUpdateListener(ILabelUpdateListener listener) {
            SubTreeModelViewer.this.addLabelUpdateListener(listener);
        }

        public void addModelChangedListener(IModelChangedListener listener) {
            SubTreeModelViewer.this.addModelChangedListener(listener);
        }

        public void addViewerUpdateListener(IViewerUpdateListener listener) {
            SubTreeModelViewer.this.addViewerUpdateListener(listener);
        }

        public int getAutoExpandLevel() {
            return SubTreeModelViewer.this.getAutoExpandLevel();
        }

        public Display getDisplay() {
            return SubTreeModelViewer.this.getDisplay();
        }

        public ViewerLabel getElementLabel(TreePath path, String columnId) {
            return SubTreeModelViewer.this.getElementLabel(path, columnId);
        }

        public IPresentationContext getPresentationContext() {
            return SubTreeModelViewer.this.getPresentationContext();
        }

        public void removeLabelUpdateListener(ILabelUpdateListener listener) {
            SubTreeModelViewer.this.removeLabelUpdateListener(listener);
        }

        public void removeModelChangedListener(IModelChangedListener listener) {
            SubTreeModelViewer.this.removeModelChangedListener(listener);
        }

        public void removeViewerUpdateListener(IViewerUpdateListener listener) {
            SubTreeModelViewer.this.removeViewerUpdateListener(listener);
        }

        public void saveElementState(TreePath path, ModelDelta delta) {
            SubTreeModelViewer.this.saveElementState(path, delta);
        }

        public void setAutoExpandLevel(int level) {
            SubTreeModelViewer.this.setAutoExpandLevel(level);
        }

        public void setSelection(ISelection selection, boolean reveal, boolean force) {
            SubTreeModelViewer.this.setSelection(selection, reveal, force);
        }

        public void updateViewer(IModelDelta delta) {
            SubTreeModelViewer.this.updateViewer(delta);
        }

        public ViewerFilter[] getFilters() {
            return SubTreeModelViewer.this.getFilters();
        }

        public boolean overrideSelection(ISelection current, ISelection candidate) {
            return SubTreeModelViewer.this.overrideSelection(current, candidate);
        }

        public void refresh(Object element) {
            SubTreeModelViewer.this.refresh(element);
        }

        public void update(Object element) {
            SubTreeModelViewer.this.update(element);
        }
    }

    
    /**
     * Delegating content provider.  It translates all the calls to the 
     * underlying content provider to use full model tree paths.
     */
    private class SubTreeModelContentProvider implements ITreeModelContentProvider {
        
        private TreeModelContentProvider fBaseProvider;
        
        public SubTreeModelContentProvider() {
            fBaseProvider = new TreeModelContentProvider();
        }
        
        public void updateHasChildren(TreePath path) {
            fBaseProvider.updateHasChildren(createFullPath(path));
        }
        
        public void updateChildCount(TreePath path, int currentChildCount) {
            fBaseProvider.updateChildCount(createFullPath(path), currentChildCount);
        }

        public void updateElement(TreePath parentPath, int viewIndex) {
            fBaseProvider.updateElement(createFullPath(parentPath), viewIndex);
        }
        
        public int viewToModelCount(TreePath parentPath, int count) {
            return fBaseProvider.viewToModelCount(createFullPath(parentPath), count);
        }
        
        public int viewToModelIndex(TreePath parentPath, int index) {
            return fBaseProvider.viewToModelIndex(createFullPath(parentPath), index);
        }

        public void addModelChangedListener(IModelChangedListener listener) {
            fBaseProvider.addModelChangedListener(listener);
        }

        public void addViewerUpdateListener(IViewerUpdateListener listener) {
            fBaseProvider.addViewerUpdateListener(listener);
        }

        public boolean isSuppressModelControlDeltas() {
            return fBaseProvider.isSuppressModelControlDeltas();
        }

        public int modelToViewChildCount(TreePath parentPath, int count) {
            return fBaseProvider.modelToViewChildCount(createFullPath(parentPath), count);
        }

        public int modelToViewIndex(TreePath parentPath, int index) {
            return fBaseProvider.modelToViewIndex(createFullPath(parentPath), index);
        }

        public void removeModelChangedListener(IModelChangedListener listener) {
            fBaseProvider.removeModelChangedListener(listener);
        }

        public void removeViewerUpdateListener(IViewerUpdateListener listener) {
            fBaseProvider.removeViewerUpdateListener(listener);
        }

        public void setSuppressModelControlDeltas(boolean suppress) {
            fBaseProvider.setSuppressModelControlDeltas(suppress);
        }

        public boolean shouldFilter(Object parentElementOrTreePath, Object element) {
            if (parentElementOrTreePath instanceof TreePath) {
                TreePath path = (TreePath)parentElementOrTreePath;
                return fBaseProvider.shouldFilter(createFullPath(path), element);
            } else {
                return fBaseProvider.shouldFilter(parentElementOrTreePath, element);
            }
            
        }

        public void unmapPath(TreePath path) {
            fBaseProvider.unmapPath(createFullPath(path));
        }

        public void updateModel(IModelDelta delta) {
            fBaseProvider.updateModel(delta);
        }

        public TreePath[] getParents(Object element) {
            // Not used
            return null;
        }

        public void dispose() {
            fBaseProvider.dispose();
        }

        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            fBaseProvider.inputChanged(fDelegatingViewer, oldInput, newInput);
        }
    }

    /**
     * Delegating label provider.  It translates all the calls to the 
     * underlying label provider to use full model tree paths.
     */
    private class SubTreeModelLabelProvider extends ColumnLabelProvider
        implements ITreeModelLabelProvider 
    {

        private TreeModelLabelProvider fBaseProvider;
        
        public SubTreeModelLabelProvider(ITreeModelLabelProviderTarget viewer) {
            fBaseProvider = new TreeModelLabelProvider(viewer);
        }
        
        public boolean update(TreePath elementPath) {
            return fBaseProvider.update( createFullPath(elementPath) );
        }

        public void addLabelUpdateListener(ILabelUpdateListener listener) {
            fBaseProvider.addLabelUpdateListener(listener);
        }

        public Color getColor(RGB rgb) {
            return fBaseProvider.getColor(rgb);
        }

        public Font getFont(FontData fontData) {
            return fBaseProvider.getFont(fontData);
        }

        public Image getImage(ImageDescriptor descriptor) {
            return fBaseProvider.getImage(descriptor);
        }

        public void removeLabelUpdateListener(ILabelUpdateListener listener) {
            fBaseProvider.removeLabelUpdateListener(listener);
        }

        public void addListener(ILabelProviderListener listener) {
            fBaseProvider.addListener(listener);
        }

        public void dispose() {
            fBaseProvider.dispose();
            super.dispose();
        }

        public boolean isLabelProperty(Object element, String property) {
            return fBaseProvider.isLabelProperty(element, property);
        }

        public void removeListener(ILabelProviderListener listener) {
            fBaseProvider.removeListener(listener);
        }
    }
        
    private TreePath createFullPath(TreePath subPath) {
        Object[] segments = new Object[fRootPath.getSegmentCount() + subPath.getSegmentCount()];
        for (int i = 0; i < fRootPath.getSegmentCount(); i++) {
            segments[i] = fRootPath.getSegment(i);
        }
        for (int i = 0; i < subPath.getSegmentCount(); i++) {
            segments[i + fRootPath.getSegmentCount()] = subPath.getSegment(i);
        }
        return new TreePath(segments);
    }
    
    private TreePath createSubPath(TreePath fullPath) {
        if (fullPath.getSegmentCount() <= fRootPath.getSegmentCount()) {
            return TreePath.EMPTY;
        }
        Object[] segments = new Object[fullPath.getSegmentCount() - fRootPath.getSegmentCount()];
        for (int i = 0; i < segments.length; i++) {
            segments[i] = fullPath.getSegment(i + fRootPath.getSegmentCount());
        }
        return new TreePath(segments);
    }
    
    private DelegatingTreeModelViewer getDelegatingViewer() {
    	if (fDelegatingViewer == null) {
    		fDelegatingViewer = new DelegatingTreeModelViewer();
    	}
    	return fDelegatingViewer;
    }
    
    protected ITreeModelContentProvider createContentProvider() {
        return new SubTreeModelContentProvider();
    }
    
    protected ITreeModelLabelProvider createLabelProvider() {
        return new SubTreeModelLabelProvider(getDelegatingViewer());
    }
    

}




/*******************************************************************************
 * Copyright (c) 2009 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.viewers.model;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.RGB;

/**
 * {@link TreeModelViewer} label provider interface.  In addition to 
 * implementing this interface, the label provider for the TreeModelViewer
 * must also extend CellLabelProvider.    
 * 
 * @since 3.5
 */
public interface ITreeModelLabelProvider extends IBaseLabelProvider {

    public boolean update(TreePath elementPath);
    
    /**
     * Registers the specified listener for view label update notifications.
     */
    public void addLabelUpdateListener(ILabelUpdateListener listener);
    
    /**
     * Removes the specified listener from view label update notifications.
     */
    public void removeLabelUpdateListener(ILabelUpdateListener listener);

    /**
     * Returns an image for the given image descriptor or <code>null</code>. Adds the image
     * to a cache of images if it does not already exist.
     * 
     * @param descriptor image descriptor or <code>null</code>
     * @return image or <code>null</code>
     */
    public Image getImage(ImageDescriptor descriptor);
    
    /**
     * Returns a font for the given font data or <code>null</code>. Adds the font to the font 
     * cache if not yet created.
     * 
     * @param fontData font data or <code>null</code>
     * @return font font or <code>null</code>
     */
    public Font getFont(FontData fontData);

    /**
     * Returns a color for the given RGB or <code>null</code>. Adds the color to the color 
     * cache if not yet created.
     * 
     * @param rgb RGB or <code>null</code>
     * @return color or <code>null</code>
     */
    public Color getColor(RGB rgb);
}




/*******************************************************************************
 * Copyright (c) 2009 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.viewers.model;

import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelChangedListener;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerUpdateListener;
import org.eclipse.jface.viewers.ILazyTreePathContentProvider;
import org.eclipse.jface.viewers.TreePath;

/** 
 * {@link TreeModelViewer} content provider interface.
 *  
 * @since 3.5
 */
public interface ITreeModelContentProvider extends ILazyTreePathContentProvider {

    /**
     * Translates and returns the given child index from the viewer coordinate
     * space to the model coordinate space.
     *  
     * @param parentPath path to parent element
     * @param index index of child element in viewer (filtered) space
     * @return index of child element in model (raw) space
     */
    public int viewToModelIndex(TreePath parentPath, int index);
    
    /**
     * Translates and returns the given child count from the viewer coordinate
     * space to the model coordinate space.
     *  
     * @param parentPath path to parent element
     * @param count number of child elements in viewer (filtered) space
     * @return number of child elements in model (raw) space
     */
    public int viewToModelCount(TreePath parentPath, int count);
    
    /**
     * Translates and returns the given child index from the model coordinate
     * space to the viewer coordinate space.
     *  
     * @param parentPath path to parent element
     * @param index index of child element in model (raw) space
     * @return index of child element in viewer (filtered) space or -1 if filtered
     */
    public int modelToViewIndex(TreePath parentPath, int index);

    /**
     * Returns whether the given element is filtered.
     * 
     * @param parentElementOrTreePath
     *            the parent element or path
     * @param element
     *            the child element
     * @return whether to filter the element
     */
    public boolean shouldFilter(Object parentElementOrTreePath, Object element);   

    /**
     * Notification the given element is being unmapped.
     * 
     * @param path
     */
    public void unmapPath(TreePath path);

    /**
     * Turns on the mode which causes the model viewer to ignore SELECT, 
     * EXPAND, and COLLAPSE flags of {@link IModelDelta}.
     *  
     * @param suppress If <code>true</code> it turns on the suppress mode.
     */
    public void setSuppressModelControlDeltas(boolean suppress);
    
    /**
     * Returns true if the viewer is currently in the mode to ignore SELECT, 
     * REVEAL, EXPAND, and COLLAPSE flags of {@link IModelDelta}.
     *  
     * @return Returns <code>true</code> if in suppress mode.
     */
    public boolean isSuppressModelControlDeltas();
    
    /**
     * Translates and returns the given child count from the model coordinate
     * space to the viewer coordinate space.
     *  
     * @param parentPath path to parent element
     * @param count child count element in model (raw) space
     * @return child count in viewer (filtered) space
     */
    public int modelToViewChildCount(TreePath parentPath, int count);

    /**
     * Registers the specified listener for view update notifications.
     */
    public void addViewerUpdateListener(IViewerUpdateListener listener);
    
    /**
     * Removes the specified listener from update notifications.
     */
    public void removeViewerUpdateListener(IViewerUpdateListener listener);
    
    /**
     * Registers the given listener for model delta notification.
     * This listener is called immediately after the viewer processes
     * the delta.  
     */
    public void addModelChangedListener(IModelChangedListener listener);
    
    /**
     * Removes the given listener from model delta notification.
     */
    public void removeModelChangedListener(IModelChangedListener listener);
    
    /**
     * Instructs the content provider to process the given model delta.  This
     * mechanism can be used to control the view's layout (expanding, selecting
     * , etc.) 
     * 
     * @param delta The model delta to process.
     */
    public void updateModel(IModelDelta delta);
}

Return to bug 262266

Lines 180-186 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/InternalVirtualTreeModelViewer.java (-5 / +5 lines)
180	fLabelProvider = new TreeModelLabelProvider(this);	180	fLabelProvider = new TreeModelLabelProvider(this);
181		181
182	if ((style & SWT.POP_UP) != 0) {	182	if ((style & SWT.POP_UP) != 0) {
183	((ModelContentProvider)getContentProvider()).setSuppressModelControlDeltas(true);	183	((ITreeModelContentProvider)getContentProvider()).setSuppressModelControlDeltas(true);
184	}	184	}
185	}	185	}
186		186
Lines 368-378 Link Here
368	return -1;	368	return -1;
369	}	369	}
370		370
371	private TreeModelLabelProvider getLabelProvider() {	371	private ITreeModelLabelProvider getLabelProvider() {
372	return fLabelProvider;	372	return fLabelProvider;
373	}	373	}
374		374
375	private TreeModelContentProvider getContentProvider() {	375	private ITreeModelContentProvider getContentProvider() {
376	return fContentProvider;	376	return fContentProvider;
377	}	377	}
378		378
Lines 1176-1182 Link Here
1176	}	1176	}
1177		1177
1178	public void removeViewerUpdateListener(IViewerUpdateListener listener) {	1178	public void removeViewerUpdateListener(IViewerUpdateListener listener) {
1179	ModelContentProvider cp = getContentProvider();	1179	ITreeModelContentProvider cp = getContentProvider();
1180	if (cp != null) {	1180	if (cp != null) {
1181	cp.removeViewerUpdateListener(listener);	1181	cp.removeViewerUpdateListener(listener);
1182	}	1182	}
Lines 1187-1193 Link Here
1187	}	1187	}
1188		1188
1189	public void removeModelChangedListener(IModelChangedListener listener) {	1189	public void removeModelChangedListener(IModelChangedListener listener) {
1190	ModelContentProvider cp = getContentProvider();	1190	ITreeModelContentProvider cp = getContentProvider();
1191	if (cp != null) {	1191	if (cp != null) {
1192	cp.removeModelChangedListener(listener);	1192	cp.removeModelChangedListener(listener);
1193	}	1193	}

Lines 881-887 Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/ModelContentProvider.java (-11 / +15 lines)
881	*	881	*
882	* @param suppress If <code>true</code> it turns on the suppress mode.	882	* @param suppress If <code>true</code> it turns on the suppress mode.
883	*/	883	*/
884	protected void setSuppressModelControlDeltas(boolean suppress) {	884	public void setSuppressModelControlDeltas(boolean suppress) {
885	fSuppressModelControlRequests = suppress;	885	fSuppressModelControlRequests = suppress;
886	}	886	}
887		887
Lines 891-900 Link Here
891	*	891	*
892	* @return Returns <code>true</code> if in suppress mode.	892	* @return Returns <code>true</code> if in suppress mode.
893	*/	893	*/
894	protected boolean isSuppressModelControlDeltas() {	894	public boolean isSuppressModelControlDeltas() {
895	return fSuppressModelControlRequests;	895	return fSuppressModelControlRequests;
896	}	896	}
897		897
		898	public void updateModel(IModelDelta delta) {
		899	updateNodes(new IModelDelta[] { delta }, true);
		900	}
		901
898	/**	902	/**
899	* Updates the viewer with the following deltas.	903	* Updates the viewer with the following deltas.
900	*	904	*
Lines 1037-1043 Link Here
1037	* @param index index of child element in model (raw) space	1041	* @param index index of child element in model (raw) space
1038	* @return index of child element in viewer (filtered) space or -1 if filtered	1042	* @return index of child element in viewer (filtered) space or -1 if filtered
1039	*/	1043	*/
1040	protected int modelToViewIndex(TreePath parentPath, int index) {	1044	public int modelToViewIndex(TreePath parentPath, int index) {
1041	return fTransform.modelToViewIndex(parentPath, index);	1045	return fTransform.modelToViewIndex(parentPath, index);
1042	}	1046	}
1043		1047
Lines 1049-1055 Link Here
1049	* @param count child count element in model (raw) space	1053	* @param count child count element in model (raw) space
1050	* @return child count in viewer (filtered) space	1054	* @return child count in viewer (filtered) space
1051	*/	1055	*/
1052	protected int modelToViewChildCount(TreePath parentPath, int count) {	1056	public int modelToViewChildCount(TreePath parentPath, int count) {
1053	return fTransform.modelToViewCount(parentPath, count);	1057	return fTransform.modelToViewCount(parentPath, count);
1054	}	1058	}
1055		1059
Lines 1102-1108 Link Here
1102	}	1106	}
1103		1107
1104	/**	1108	/**
1105	* Returns whether the given element is filtered.	1109	* Returns whether the given element is filtered.
1106	*	1110	*
1107	* @param parentElementOrTreePath	1111	* @param parentElementOrTreePath
1108	* the parent element or path	1112	* the parent element or path
Lines 1110-1116 Link Here
1110	* the child element	1114	* the child element
1111	* @return whether to filter the element	1115	* @return whether to filter the element
1112	*/	1116	*/
1113	protected boolean shouldFilter(Object parentElementOrTreePath, Object element) {	1117	public boolean shouldFilter(Object parentElementOrTreePath, Object element) {
1114	ViewerFilter[] filters = fViewer.getFilters();	1118	ViewerFilter[] filters = fViewer.getFilters();
1115	if (filters.length > 0) {	1119	if (filters.length > 0) {
1116	for (int j = 0; j < filters.length; j++) {	1120	for (int j = 0; j < filters.length; j++) {
Lines 1138-1144 Link Here
1138	*	1142	*
1139	* @param path	1143	* @param path
1140	*/	1144	*/
1141	protected void unmapPath(TreePath path) {	1145	public void unmapPath(TreePath path) {
1142	//System.out.println("Unmap " + path.getLastSegment());	1146	//System.out.println("Unmap " + path.getLastSegment());
1143	fTransform.clear(path);	1147	fTransform.clear(path);
1144	cancelSubtreeUpdates(path);	1148	cancelSubtreeUpdates(path);
Lines 1175-1185 Link Here
1175	}	1179	}
1176	}	1180	}
1177		1181
1178	void addViewerUpdateListener(IViewerUpdateListener listener) {	1182	public void addViewerUpdateListener(IViewerUpdateListener listener) {
1179	fUpdateListeners.add(listener);	1183	fUpdateListeners.add(listener);
1180	}	1184	}
1181		1185
1182	void removeViewerUpdateListener(IViewerUpdateListener listener) {	1186	public void removeViewerUpdateListener(IViewerUpdateListener listener) {
1183	fUpdateListeners.remove(listener);	1187	fUpdateListeners.remove(listener);
1184	}	1188	}
1185		1189
Lines 1413-1419 Link Here
1413	*	1417	*
1414	* @param listener model delta listener	1418	* @param listener model delta listener
1415	*/	1419	*/
1416	void addModelChangedListener(IModelChangedListener listener) {	1420	public void addModelChangedListener(IModelChangedListener listener) {
1417	fModelListeners.add(listener);	1421	fModelListeners.add(listener);
1418	}	1422	}
1419		1423
Lines 1422-1428 Link Here
1422	*	1426	*
1423	* @param listener model delta listener	1427	* @param listener model delta listener
1424	*/	1428	*/
1425	void removeModelChangedListener(IModelChangedListener listener) {	1429	public void removeModelChangedListener(IModelChangedListener listener) {
1426	fModelListeners.remove(listener);	1430	fModelListeners.remove(listener);
1427	}	1431	}
1428		1432

Added Link Here

(-)ui/org/eclipse/debug/internal/ui/viewers/model/SubTreeModelViewer.java (+516 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Wind River Systems 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	* Wind River Systems - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.internal.ui.viewers.model;
12
13	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelChangedListener;
14	import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta;
15	import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;
16	import org.eclipse.debug.internal.ui.viewers.model.provisional.IViewerUpdateListener;
17	import org.eclipse.debug.internal.ui.viewers.model.provisional.ModelDelta;
18	import org.eclipse.debug.internal.ui.viewers.model.provisional.TreeModelViewer;
19	import org.eclipse.jface.resource.ImageDescriptor;
20	import org.eclipse.jface.viewers.ColumnLabelProvider;
21	import org.eclipse.jface.viewers.ILabelProviderListener;
22	import org.eclipse.jface.viewers.ISelection;
23	import org.eclipse.jface.viewers.TreePath;
24	import org.eclipse.jface.viewers.Viewer;
25	import org.eclipse.jface.viewers.ViewerFilter;
26	import org.eclipse.jface.viewers.ViewerLabel;
27	import org.eclipse.swt.graphics.Color;
28	import org.eclipse.swt.graphics.Font;
29	import org.eclipse.swt.graphics.FontData;
30	import org.eclipse.swt.graphics.Image;
31	import org.eclipse.swt.graphics.RGB;
32	import org.eclipse.swt.widgets.Composite;
33	import org.eclipse.swt.widgets.Control;
34	import org.eclipse.swt.widgets.Display;
35
36	/**
37	* Specialized tree viewer which displays only sub-tree of a full model.
38	*
39	* @since 3.5
40	*/
41	public class SubTreeModelViewer extends TreeModelViewer {
42
43	/**
44	* The tree path in the model to the root element of this viewer.
45	*/
46	private TreePath fRootPath = TreePath.EMPTY;
47
48	/**
49	* Viewer delegate that content and label providers refer to for viewer data.
50	*/
51	private DelegatingTreeModelViewer fDelegatingViewer;
52
53	/**
54	* Returns the root element's model tree path.
55	*/
56	public TreePath getRootPath() {
57	return fRootPath;
58	}
59
60	public SubTreeModelViewer(Composite parent, int style, IPresentationContext context) {
61	super(parent, style, context);
62	}
63
64	/**
65	* Sets the viewer's input and root element's path
66	*
67	* @param input New viewer input.
68	* @param rootPath New root element path.
69	*/
70	public void setInput(Object input, TreePath rootPath) {
71	fRootPath = rootPath;
72	super.setInput(input);
73	}
74
75	/**
76	* A proxy for the sub tree viewer which is given to the content and
77	* label providers. It translates the sub-tree paths in the viewer to the
78	* full model paths that the providers expect.
79	*/
80	public class DelegatingTreeModelViewer extends Viewer
81	implements ITreeModelLabelProviderTarget, ITreeModelContentProviderTarget
82	{
83	public void reveal(TreePath path, int index) {
84	if (path.startsWith(fRootPath, null)) {
85	SubTreeModelViewer.this.reveal(createSubPath(path), index);
86	}
87	}
88
89	public void replace(Object parentOrTreePath, int index, Object element) {
90	if (parentOrTreePath instanceof TreePath) {
91	TreePath path = (TreePath)parentOrTreePath;
92	if (path.startsWith(fRootPath, null)) {
93	SubTreeModelViewer.this.replace(createSubPath(path), index, element);
94	}
95	} else {
96	SubTreeModelViewer.this.replace(parentOrTreePath, index, element);
97	}
98	}
99
100	public void setChildCount(Object elementOrTreePath, int count) {
101	if (elementOrTreePath instanceof TreePath) {
102	TreePath path = (TreePath)elementOrTreePath;
103	if (path.startsWith(fRootPath, null)) {
104	SubTreeModelViewer.this.setChildCount(createSubPath(path), count);
105	}
106	} else {
107	SubTreeModelViewer.this.setChildCount(elementOrTreePath, count);
108	}
109	}
110
111	public void setHasChildren(Object elementOrTreePath, boolean hasChildren) {
112	if (elementOrTreePath instanceof TreePath) {
113	TreePath path = (TreePath)elementOrTreePath;
114	if (path.startsWith(fRootPath, null)) {
115	SubTreeModelViewer.this.setHasChildren(createSubPath(path), hasChildren);
116	}
117	} else {
118	SubTreeModelViewer.this.setHasChildren(elementOrTreePath, hasChildren);
119	}
120	}
121
122	public void autoExpand(TreePath elementPath) {
123	// not supported
124	}
125
126	public void setExpandedState(Object elementOrTreePath, boolean expanded) {
127	if (elementOrTreePath instanceof TreePath) {
128	TreePath path = (TreePath)elementOrTreePath;
129	if (path.startsWith(fRootPath, null)) {
130	SubTreeModelViewer.this.setExpandedState(createSubPath(path), expanded);
131	}
132	} else {
133	SubTreeModelViewer.this.setExpandedState(elementOrTreePath, expanded);
134	}
135	}
136
137	public void expandToLevel(Object elementOrTreePath, int level) {
138	if (elementOrTreePath instanceof TreePath) {
139	TreePath path = (TreePath)elementOrTreePath;
140	if (path.startsWith(fRootPath, null)) {
141	SubTreeModelViewer.this.expandToLevel(createSubPath(path), level);
142	}
143	} else {
144	SubTreeModelViewer.this.expandToLevel(elementOrTreePath, level);
145	}
146	}
147
148	public void remove(Object elementOrTreePath) {
149	if (elementOrTreePath instanceof TreePath) {
150	TreePath path = (TreePath)elementOrTreePath;
151	if (path.startsWith(fRootPath, null)) {
152	SubTreeModelViewer.this.remove(createSubPath(path));
153	}
154	} else {
155	SubTreeModelViewer.this.remove(elementOrTreePath);
156	}
157	}
158
159	public void remove(Object parentOrTreePath, final int index) {
160	if (parentOrTreePath instanceof TreePath) {
161	TreePath path = (TreePath)parentOrTreePath;
162	if (path.startsWith(fRootPath, null)) {
163	SubTreeModelViewer.this.remove(createSubPath(path), index);
164	}
165	} else {
166	SubTreeModelViewer.this.remove(parentOrTreePath, index);
167	}
168	}
169
170	public void insert(Object parentOrTreePath, Object element, int position) {
171	if (parentOrTreePath instanceof TreePath) {
172	TreePath path = (TreePath)parentOrTreePath;
173	if (path.startsWith(fRootPath, null)) {
174	SubTreeModelViewer.this.insert(createSubPath(path), element, position);
175	}
176	} else {
177	SubTreeModelViewer.this.insert(parentOrTreePath, element, position);
178	}
179	}
180
181	public boolean getExpandedState(Object elementOrTreePath) {
182	if (elementOrTreePath instanceof TreePath) {
183	TreePath path = (TreePath)elementOrTreePath;
184	if (path.startsWith(fRootPath, null)) {
185	return SubTreeModelViewer.this.getExpandedState(createSubPath(path));
186	}
187	} else {
188	return SubTreeModelViewer.this.getExpandedState(elementOrTreePath);
189	}
190	return false;
191	}
192
193	public int getChildCount(TreePath path) {
194	if (path.startsWith(fRootPath, null)) {
195	return SubTreeModelViewer.this.getChildCount(createSubPath(path));
196	}
197	return -1;
198	}
199
200	public Object getChildElement(TreePath path, int index) {
201	if (path.startsWith(fRootPath, null)) {
202	return SubTreeModelViewer.this.getChildElement(createSubPath(path), index);
203	}
204	return null;
205	}
206
207	public TreePath getTopElementPath() {
208	return createFullPath(SubTreeModelViewer.this.getTopElementPath());
209	}
210
211	public int findElementIndex(TreePath parentPath, Object element) {
212	if (parentPath.startsWith(fRootPath, null)) {
213	return SubTreeModelViewer.this.findElementIndex(createSubPath(parentPath), element);
214	}
215	return -1;
216	}
217
218	public void setElementData(TreePath path, int numColumns, String[] labels, ImageDescriptor[] images, FontData[] fontDatas, RGB[] foregrounds, RGB[] backgrounds) {
219	if (path.startsWith(fRootPath, null)) {
220	SubTreeModelViewer.this.setElementData(createSubPath(path), numColumns, labels, images, fontDatas, foregrounds, backgrounds);
221	}
222	}
223
224	public Control getControl() {
225	return SubTreeModelViewer.this.getControl();
226	}
227
228	public Object getInput() {
229	return SubTreeModelViewer.this.getInput();
230	}
231
232	public ISelection getSelection() {
233	return SubTreeModelViewer.this.getSelection();
234	}
235
236	public void refresh() {
237	SubTreeModelViewer.this.refresh();
238	}
239
240	public void setInput(Object input) {
241	SubTreeModelViewer.this.setInput(input);
242	}
243
244	public void setSelection(ISelection selection, boolean reveal) {
245	SubTreeModelViewer.this.setSelection(selection, reveal);
246	}
247
248	public String[] getVisibleColumns() {
249	return SubTreeModelViewer.this.getVisibleColumns();
250	}
251
252	public void addLabelUpdateListener(ILabelUpdateListener listener) {
253	SubTreeModelViewer.this.addLabelUpdateListener(listener);
254	}
255
256	public void addModelChangedListener(IModelChangedListener listener) {
257	SubTreeModelViewer.this.addModelChangedListener(listener);
258	}
259
260	public void addViewerUpdateListener(IViewerUpdateListener listener) {
261	SubTreeModelViewer.this.addViewerUpdateListener(listener);
262	}
263
264	public int getAutoExpandLevel() {
265	return SubTreeModelViewer.this.getAutoExpandLevel();
266	}
267
268	public Display getDisplay() {
269	return SubTreeModelViewer.this.getDisplay();
270	}
271
272	public ViewerLabel getElementLabel(TreePath path, String columnId) {
273	return SubTreeModelViewer.this.getElementLabel(path, columnId);
274	}
275
276	public IPresentationContext getPresentationContext() {
277	return SubTreeModelViewer.this.getPresentationContext();
278	}
279
280	public void removeLabelUpdateListener(ILabelUpdateListener listener) {
281	SubTreeModelViewer.this.removeLabelUpdateListener(listener);
282	}
283
284	public void removeModelChangedListener(IModelChangedListener listener) {
285	SubTreeModelViewer.this.removeModelChangedListener(listener);
286	}
287
288	public void removeViewerUpdateListener(IViewerUpdateListener listener) {
289	SubTreeModelViewer.this.removeViewerUpdateListener(listener);
290	}
291
292	public void saveElementState(TreePath path, ModelDelta delta) {
293	SubTreeModelViewer.this.saveElementState(path, delta);
294	}
295
296	public void setAutoExpandLevel(int level) {
297	SubTreeModelViewer.this.setAutoExpandLevel(level);
298	}
299
300	public void setSelection(ISelection selection, boolean reveal, boolean force) {
301	SubTreeModelViewer.this.setSelection(selection, reveal, force);
302	}
303
304	public void updateViewer(IModelDelta delta) {
305	SubTreeModelViewer.this.updateViewer(delta);
306	}
307
308	public ViewerFilter[] getFilters() {
309	return SubTreeModelViewer.this.getFilters();
310	}
311
312	public boolean overrideSelection(ISelection current, ISelection candidate) {
313	return SubTreeModelViewer.this.overrideSelection(current, candidate);
314	}
315
316	public void refresh(Object element) {
317	SubTreeModelViewer.this.refresh(element);
318	}
319
320	public void update(Object element) {
321	SubTreeModelViewer.this.update(element);
322	}
323	}
324
325
326	/**
327	* Delegating content provider. It translates all the calls to the
328	* underlying content provider to use full model tree paths.
329	*/
330	private class SubTreeModelContentProvider implements ITreeModelContentProvider {
331
332	private TreeModelContentProvider fBaseProvider;
333
334	public SubTreeModelContentProvider() {
335	fBaseProvider = new TreeModelContentProvider();
336	}
337
338	public void updateHasChildren(TreePath path) {
339	fBaseProvider.updateHasChildren(createFullPath(path));
340	}
341
342	public void updateChildCount(TreePath path, int currentChildCount) {
343	fBaseProvider.updateChildCount(createFullPath(path), currentChildCount);
344	}
345
346	public void updateElement(TreePath parentPath, int viewIndex) {
347	fBaseProvider.updateElement(createFullPath(parentPath), viewIndex);
348	}
349
350	public int viewToModelCount(TreePath parentPath, int count) {
351	return fBaseProvider.viewToModelCount(createFullPath(parentPath), count);
352	}
353
354	public int viewToModelIndex(TreePath parentPath, int index) {
355	return fBaseProvider.viewToModelIndex(createFullPath(parentPath), index);
356	}
357
358	public void addModelChangedListener(IModelChangedListener listener) {
359	fBaseProvider.addModelChangedListener(listener);
360	}
361
362	public void addViewerUpdateListener(IViewerUpdateListener listener) {
363	fBaseProvider.addViewerUpdateListener(listener);
364	}
365
366	public boolean isSuppressModelControlDeltas() {
367	return fBaseProvider.isSuppressModelControlDeltas();
368	}
369
370	public int modelToViewChildCount(TreePath parentPath, int count) {
371	return fBaseProvider.modelToViewChildCount(createFullPath(parentPath), count);
372	}
373
374	public int modelToViewIndex(TreePath parentPath, int index) {
375	return fBaseProvider.modelToViewIndex(createFullPath(parentPath), index);
376	}
377
378	public void removeModelChangedListener(IModelChangedListener listener) {
379	fBaseProvider.removeModelChangedListener(listener);
380	}
381
382	public void removeViewerUpdateListener(IViewerUpdateListener listener) {
383	fBaseProvider.removeViewerUpdateListener(listener);
384	}
385
386	public void setSuppressModelControlDeltas(boolean suppress) {
387	fBaseProvider.setSuppressModelControlDeltas(suppress);
388	}
389
390	public boolean shouldFilter(Object parentElementOrTreePath, Object element) {
391	if (parentElementOrTreePath instanceof TreePath) {
392	TreePath path = (TreePath)parentElementOrTreePath;
393	return fBaseProvider.shouldFilter(createFullPath(path), element);
394	} else {
395	return fBaseProvider.shouldFilter(parentElementOrTreePath, element);
396	}
397
398	}
399
400	public void unmapPath(TreePath path) {
401	fBaseProvider.unmapPath(createFullPath(path));
402	}
403
404	public void updateModel(IModelDelta delta) {
405	fBaseProvider.updateModel(delta);
406	}
407
408	public TreePath[] getParents(Object element) {
409	// Not used
410	return null;
411	}
412
413	public void dispose() {
414	fBaseProvider.dispose();
415	}
416
417	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
418	fBaseProvider.inputChanged(fDelegatingViewer, oldInput, newInput);
419	}
420	}
421
422	/**
423	* Delegating label provider. It translates all the calls to the
424	* underlying label provider to use full model tree paths.
425	*/
426	private class SubTreeModelLabelProvider extends ColumnLabelProvider
427	implements ITreeModelLabelProvider
428	{
429
430	private TreeModelLabelProvider fBaseProvider;
431
432	public SubTreeModelLabelProvider(ITreeModelLabelProviderTarget viewer) {
433	fBaseProvider = new TreeModelLabelProvider(viewer);
434	}
435
436	public boolean update(TreePath elementPath) {
437	return fBaseProvider.update( createFullPath(elementPath) );
438	}
439
440	public void addLabelUpdateListener(ILabelUpdateListener listener) {
441	fBaseProvider.addLabelUpdateListener(listener);
442	}
443
444	public Color getColor(RGB rgb) {
445	return fBaseProvider.getColor(rgb);
446	}
447
448	public Font getFont(FontData fontData) {
449	return fBaseProvider.getFont(fontData);
450	}
451
452	public Image getImage(ImageDescriptor descriptor) {
453	return fBaseProvider.getImage(descriptor);
454	}
455
456	public void removeLabelUpdateListener(ILabelUpdateListener listener) {
457	fBaseProvider.removeLabelUpdateListener(listener);
458	}
459
460	public void addListener(ILabelProviderListener listener) {
461	fBaseProvider.addListener(listener);
462	}
463
464	public void dispose() {
465	fBaseProvider.dispose();
466	super.dispose();
467	}
468
469	public boolean isLabelProperty(Object element, String property) {
470	return fBaseProvider.isLabelProperty(element, property);
471	}
472
473	public void removeListener(ILabelProviderListener listener) {
474	fBaseProvider.removeListener(listener);
475	}
476	}
477
478	private TreePath createFullPath(TreePath subPath) {
479	Object[] segments = new Object[fRootPath.getSegmentCount() + subPath.getSegmentCount()];
480	for (int i = 0; i < fRootPath.getSegmentCount(); i++) {
481	segments[i] = fRootPath.getSegment(i);
482	}
483	for (int i = 0; i < subPath.getSegmentCount(); i++) {
484	segments[i + fRootPath.getSegmentCount()] = subPath.getSegment(i);
485	}
486	return new TreePath(segments);
487	}
488
489	private TreePath createSubPath(TreePath fullPath) {
490	if (fullPath.getSegmentCount() <= fRootPath.getSegmentCount()) {
491	return TreePath.EMPTY;
492	}
493	Object[] segments = new Object[fullPath.getSegmentCount() - fRootPath.getSegmentCount()];
494	for (int i = 0; i < segments.length; i++) {
495	segments[i] = fullPath.getSegment(i + fRootPath.getSegmentCount());
496	}
497	return new TreePath(segments);
498	}
499
500	private DelegatingTreeModelViewer getDelegatingViewer() {
501	if (fDelegatingViewer == null) {
502	fDelegatingViewer = new DelegatingTreeModelViewer();
503	}
504	return fDelegatingViewer;
505	}
506
507	protected ITreeModelContentProvider createContentProvider() {
508	return new SubTreeModelContentProvider();
509	}
510
511	protected ITreeModelLabelProvider createLabelProvider() {
512	return new SubTreeModelLabelProvider(getDelegatingViewer());
513	}
514
515
516	}