Attachment #46241 for bug #149193

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




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Tom Schindl <tom.schindl@bestsolution.at> (bug 83200)
 *******************************************************************************/

package org.eclipse.jface.viewers;

import java.util.List;

import org.eclipse.jface.util.Assert;
import org.eclipse.jface.util.Policy;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Widget;


 * @see #internalRefresh(Object, boolean)
 */
public class TableViewer extends StructuredViewer {

	private class VirtualManager {

		/**
		 * The currently invisible elements as provided by the content provider
		 * or by addition. This will not be populated by an
		 * ILazyStructuredContentProvider as an ILazyStructuredContentProvider
		 * is only queried on the virtual callback.
		 * on the virtual callback.
		 */
		private Object[] cachedElements = new Object[0];

		/**
		 * Create a new instance of the receiver.
		 * 
		 */
		public VirtualManager() {
			addTableListener();
		}

		
		/**
		 * Add the listener for SetData on the table
		 */
		private void addTableListener() {
			table.addListener(SWT.SetData, new Listener() {
				/*
				 * (non-Javadoc)
				 * 
				 * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
				 */
				public void handleEvent(Event event) {
					TableItem item = (TableItem) event.item;
					final int index = table.indexOf(item);
					Object element = resolveElement(index);
					if (element == null) {
						// Didn't find it so make a request
						// Keep looking if it is not in the cache.
						IContentProvider contentProvider = getContentProvider();
						// If we are building lazily then request lookup now
						if (contentProvider instanceof ILazyContentProvider) {
							((ILazyContentProvider) contentProvider)
									.updateElement(index);
							return;
						}
					}

					associate(element, item);
					updateItem(item, element);
					updateItem(item,element);
				}

			});
		}

		/**
		 * Get the element at index.Resolve it lazily if this is available.
		 * 
		 * @param index
		 * @return Object or <code>null</code> if it could not be found
		 * not be found
		 */
		protected Object resolveElement(int index) {

			Object element = null;
			if (index < cachedElements.length) {
				element = cachedElements[index];
			}

			return element;
		}

		/**
		 * A non visible item has been added.
		 * 
		 * @param element
		 * @param index
		 */
		public void notVisibleAdded(Object element, int index) {

			int requiredCount = index + 1;

			if (requiredCount > getTable().getItemCount()) {
				getTable().setItemCount(requiredCount);
				Object[] newCache = new Object[requiredCount];
				System.arraycopy(cachedElements, 0, newCache, 0,
						cachedElements.length);
				cachedElements = newCache;
			}

			
			cachedElements[index] = element;

		}

	}

	private VirtualManager virtualManager;
	
	/**
	 * TableColorAndFontNoOp is an optimization for tables without
	 * color and font support.
	 * @see ITableColorProvider
	 * @see ITableFontProvider
	 */
	private class TableColorAndFontNoOp{
		
		/**
		 * Create a new instance of the receiver.
		 *
		 */
		TableColorAndFontNoOp(){
			
		}
		
		/**
		 * Set the fonts and colors for the tableItem if there is a color
		 * and font provider available.
		 * @param tableItem The item to update.
		 * @param element The element being represented
		 * @param column The column index
		 */
		public void setFontsAndColors(TableItem tableItem, Object element, int column){
		}	
		
	}

	/**
	 * TableColorAndFontCollector is an helper class for color and font
	 * support for tables that support the ITableFontProvider and
	 * the ITableColorProvider.
	 * @see ITableColorProvider
	 * @see ITableFontProvider
	 */
	
	private class TableColorAndFontCollector extends TableColorAndFontNoOp{
		
		ITableFontProvider fontProvider = null;
		ITableColorProvider colorProvider = null;
		
		/**
		 * Create an instance of the receiver. Set the color and font
		 * providers if provider can be cast to the correct type.
		 * @param provider IBaseLabelProvider
		 */
		public TableColorAndFontCollector(IBaseLabelProvider provider){
			if(provider instanceof ITableFontProvider) {
				fontProvider = (ITableFontProvider) provider;
			}
			if(provider instanceof ITableColorProvider) {
				colorProvider = (ITableColorProvider) provider;
			}
		}
	
		
		/**
		 * Set the fonts and colors for the tableItem if there is a color
		 * and font provider available.
		 * @param tableItem The item to update.
		 * @param element The element being represented
		 * @param column The column index
		 */
		public void setFontsAndColors(TableItem tableItem, Object element, int column){
			if (colorProvider != null) {
				tableItem.setBackground(column, colorProvider.getBackground(element,
						column));
				tableItem.setForeground(column, colorProvider.getForeground(element,
						column));
			}
			if(fontProvider != null) {
				tableItem.setFont(column,fontProvider.getFont(element,column));
			}
		}	
		
	}
	
	/**
	 * Internal table viewer implementation.
	 */
	private TableEditorImpl tableViewerImpl;

	 * This viewer's table editor.
	 */
	private TableEditor tableEditor;

	

	private ViewerLabelProvider viewerLabelProvider;

	private static String TABLE_VIEWER_KEY = Policy.JFACE + ".columnViewer";//$NON-NLS-1$

	/**
	 * Creates a table viewer on a newly-created table control under the given
	 * parent. The table control is created using the SWT style bits

	 *            SWT style bits
	 */
	public TableViewer(Composite parent, int style) {
		this(new Table(parent, style));
	}

	/**

		initTableViewerImpl();
		initializeVirtualManager(table.getStyle());
	}

	/**
	 * Initialize the virtual manager to manage the virtual state if the table
	 * is VIRTUAL. If not use the default no-op version.
	 * 
	 * @param style
	 */
	private void initializeVirtualManager(int style) {
		if ((style & SWT.VIRTUAL) == 0) {
			return;
		}

		virtualManager = new VirtualManager();
	}

	/**

	public void add(Object[] elements) {
		assertElementsNotNull(elements);
		Object[] filtered = filter(elements);

		for (int i = 0; i < filtered.length; i++) {
			Object element = filtered[i];
			int index = indexForElement(element);


	/**
	 * Create a new TableItem at index if required.
	 * 
	 * @param element
	 * @param index
	 * 
	 * @since 3.1
	 */
	private void createItem(Object element, int index) {
		if (virtualManager == null) {
			updateItem(new TableItem(getTable(), SWT.NONE, index), element);
		} else {
			virtualManager.notVisibleAdded(element, index);

		}
	}


	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#doFindInputItem(java.lang.Object)
	 */
	protected Widget doFindInputItem(Object element) {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#doFindItem(java.lang.Object)
	 */
	protected Widget doFindItem(Object element) {

		TableItem[] children = table.getItems();
		for (int i = 0; i < children.length; i++) {
			TableItem item = children[i];

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#doUpdateItem(org.eclipse.swt.widgets.Widget,
	 *      java.lang.Object, boolean)
	 */
	protected void doUpdateItem(Widget widget, Object element, boolean fullMap) {
		if (widget instanceof TableItem) {

			if (fullMap) {
				associate(element, item);
			} else {
				Object data = item.getData();
				if (data != null) {
					unmapElement(data, item);
				}
				item.setData(element);
				mapElement(element, item);
			}

			IBaseLabelProvider prov = getLabelProvider();
			ITableLabelProvider tprov = null;		
			ILabelProvider lprov = null;
			IViewerLabelProvider vprov = null;
			
			if(prov instanceof ILabelProvider) {
				lprov = (ILabelProvider) prov;
			}
			
			if (prov instanceof IViewerLabelProvider) {
				vprov = (IViewerLabelProvider) prov;
			} 

			if (prov instanceof ITableLabelProvider) {
				tprov = (ITableLabelProvider) prov;
			} 
			
			int columnCount = table.getColumnCount();

			getColorAndFontCollector().setFontsAndColors(element);
			
			// Also enter loop if no columns added. See 1G9WWGZ: JFUIF:WINNT -
			// TableViewer with 0 columns does not work
			for (int column = 0; column < columnCount || column == 0; column++) {
				TableColumnViewerPart columnViewer = getColumnViewer(column);
				columnViewer.refresh(item, element);
				Image image = null;
				tableColorAndFont.setFontsAndColors(ti,element,column);

				if (tprov == null) {
					if (column == 0) {
						ViewerLabel updateLabel = new ViewerLabel(item
								.getText(), item.getImage());
						
						if(vprov != null) {
							buildLabel(updateLabel,element,vprov);
						} else{
							if(lprov != null) {
								buildLabel(updateLabel,element,lprov);
							}
						}
						
//						As it is possible for user code to run the event 
			            //loop check here.
						if (item.isDisposed()) {
			                unmapElement(element, item);
			                return;
			            }   
						
						text = updateLabel.getText();
						image = updateLabel.getImage();
					}
				} else {
					text = tprov.getColumnText(element, column);
					image = tprov.getColumnImage(element, column);
				}

				// As it is possible for user code to run the event
				// loop check here.
				if (item.isDisposed()) {
					unmapElement(element, item);
					return;
				if (ti.getImage(column) != image) {
					ti.setImage(column, image);
				}

			}

			
			getColorAndFontCollector().applyFontsAndColors(ti);
		}
	}

	/**
	 * Return the TableColumnViewer at columnIndex
	 * 
	 * @param columnIndex
	 * @return TableColumnViewer
	 */
	public TableColumnViewerPart getColumnViewer(int columnIndex) {
		TableColumn column = getTable().getColumn(columnIndex);
		Object viewer = column.getData(TABLE_VIEWER_KEY);
		if (viewer == null){
			viewer = new TableColumnViewerPart(
					createViewerLabelProvider(columnIndex), columnIndex);
			column.setData(TABLE_VIEWER_KEY, viewer);
		}
		return (TableColumnViewerPart) viewer;
	}
	
	/**
	 * Set the TableColumnViewerPart at columnIndex to be 
	 * viewerPart.
	 * @param viewerPart
	 * @param columnIndex
	 */
	public void setTableColumnPart(TableColumnViewerPart viewerPart, int columnIndex){
		TableColumn column = getTable().getColumn(columnIndex);
		column.setData(TABLE_VIEWER_KEY, viewerPart);
	}

	/**
	 * Create a ViewerLabelProvider for the column at index
	 * 
	 * @param columnIndex
	 * @return ViewerLabelProvider
	 */
	private ViewerLabelProvider createViewerLabelProvider(int columnIndex) {
		return null;//We will create a mapping from the old
		//api here
	}

	/**
	 * Starts editing the given element.
	 * 
	 * @param element

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.Viewer#getControl()
	 */
	public Control getControl() {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#getSelectionFromWidget()
	 */
	protected List getSelectionFromWidget() {
		if (virtualManager != null) {
			return getVirtualSelection();
		}
		Widget[] items = table.getSelection();

		}
		return list;
	}

	/**
	 * Get the virtual selection. Avoid calling SWT whenever possible to prevent
	 * extra widget creation.
	 * 
	 * @return List of Object
	 */

	private List getVirtualSelection() {

		List result = new ArrayList();
		int[] selectionIndices = getTable().getSelectionIndices();
		if (getContentProvider() instanceof ILazyContentProvider) {
			ILazyContentProvider lazy = (ILazyContentProvider) getContentProvider();
			for (int i = 0; i < selectionIndices.length; i++) {
				int selectionIndex = selectionIndices[i];
				lazy.updateElement(selectionIndex);// Start the update
				Object element = getTable().getItem(selectionIndex).getData();
				// Only add the element if it got updated.
				// If this is done deferred the selection will
				// be incomplete until selection is finished.
				if (element != null) {
					result.add(element);
				}
			}
		} else {
		else{
			for (int i = 0; i < selectionIndices.length; i++) {
				Object element = null;
				// See if it is cached
				int selectionIndex = selectionIndices[i];
				if (selectionIndex < virtualManager.cachedElements.length) {
					element = virtualManager.cachedElements[selectionIndex];
				}
				if (element == null) {
					// Not cached so try the item's data
					TableItem item = getTable().getItem(selectionIndex);
					element = item.getData();
				}
				if (element != null) {
					result.add(element);
				}
			}

			
		}
		return result;
	}

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ContentViewer#hookControl(org.eclipse.swt.widgets.Control)
	 */
	protected void hookControl(Control control) {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.Viewer#inputChanged(java.lang.Object,
	 *      java.lang.Object)
	 */
	protected void inputChanged(Object input, Object oldInput) {
		getControl().setRedraw(false);

		if (position == -1) {
			position = table.getItemCount();
		}

		createItem(element, position);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#internalRefresh(java.lang.Object)
	 */
	protected void internalRefresh(Object element) {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#internalRefresh(java.lang.Object,
	 *      boolean)
	 */
	protected void internalRefresh(Object element, boolean updateLabels) {
		tableViewerImpl.applyEditorValue();
		if (element == null || equals(element, getRoot())) {
			if (virtualManager == null) {
				internalRefreshAll(updateLabels);
			} else {
				internalVirtualRefreshAll();
			}
		} else {

	 * @since 3.1
	 */
	private void internalVirtualRefreshAll() {

		Object root = getRoot();
		IContentProvider contentProvider = getContentProvider();

		// Invalidate for lazy
		if (!(contentProvider instanceof ILazyContentProvider)
				&& (contentProvider instanceof IStructuredContentProvider)) {
			// Don't cache if the root is null but cache if it is not lazy.
			if (root != null) {
				virtualManager.cachedElements = ((IStructuredContentProvider) getContentProvider())
						.getElements(root);
				getTable().setItemCount(virtualManager.cachedElements.length);
			}
		}

	}

	/**
	 * Refresh all of the elements of the table. update the labels if
	 * updatLabels is true;
	 * 
	 * @param updateLabels
	 * 
	 * @since 3.1

		TableItem[] items = getTable().getItems();
		int min = Math.min(children.length, items.length);
		for (int i = 0; i < min; ++i) {

			
			TableItem item = items[i];

			// if the element is unchanged, update its label if appropriate
			if (equals(children[i], item.getData())) {
				if (updateLabels) {

				// So, if the object associated with this item has changed,
				// just disassociate it for now, and update it below.
				item.setText(""); //$NON-NLS-1$
				item.setImage(new Image[Math.max(1, table.getColumnCount())]);// Clear
				// all
				// images
				disassociate(item);
			}
		}
		// dispose of all items beyond the end of the current elements
		if (min < items.length) {
			for (int i = items.length; --i >= min;) {

				disassociate(items[i]);
			}
			table.remove(min, items.length - 1);

		}
		// Update items which were removed above
		for (int i = 0; i < min; ++i) {

			TableItem item = items[i];
			if (item.getData() == null) {
				updateItem(item, children[i]);

		}
		// add any remaining elements
		for (int i = min; i < children.length; ++i) {
			createItem(children[i], i);
		}
	}


	/**
	 * Removes the given elements from this table viewer.
	 * 

	 */
	public void remove(final Object[] elements) {
		assertElementsNotNull(elements);
		if (elements.length == 0) {
			return;
		}
		preservingSelection(new Runnable() {
			public void run() {
				internalRemove(elements);

	 * the model. Note that there is another method for efficiently processing
	 * the simultaneous removal of multiple elements.
	 * </p>
	 * <strong>NOTE:</strong> removing an object from a virtual table will
	 * decrement the itemCount.
	 * 
	 * @param element
	 *            the element

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#reveal(java.lang.Object)
	 */
	public void reveal(Object element) {

	 * may also implement {@link IColorProvider} and/or {@link IFontProvider} to
	 * provide colors and/or fonts.
	 * </p>
	 * <p>
	 * If the label provider implements the mixin interface ITooltipProvider, it
	 * can provide custom tooltips.
	 * </p>
	 */
	public void setLabelProvider(IBaseLabelProvider labelProvider) {
		Assert.isTrue(labelProvider instanceof ITableLabelProvider
				|| labelProvider instanceof ILabelProvider);
		super.setLabelProvider(labelProvider);
		viewerLabelProvider = new ViewerLabelProvider();
		viewerLabelProvider.setProviders(labelProvider);
		} else {
			tableColorAndFont = new TableColorAndFontNoOp();
		}
				
	}

	/**
	 * <p>
	 * Sets a new selection for this viewer and optionally makes it visible. The
	 * TableViewer implmentation of this method is ineffecient for the
	 * ILazyContentProvider as lookup is done by indices rather than elements
	 * and may require population of the entire table in worse case.
	 * </p>
	 * <p>
	 * Use Table#setSelection(int[] indices) and Table#showSelection() if you
	 * wish to set selection more effeciently when using a ILazyContentProvider.
	 * </p>
	 * 
	 * @param selection
	 *            the new selection
	 * @param reveal
	 *            <code>true</code> if the selection is to be made visible,
	 *            and <code>false</code> otherwise
	 * @see Table#setSelection(int[])
	 * @see Table#showSelection()
	 */

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#setSelectionToWidget(java.util.List,
	 *      boolean)
	 */
	protected void setSelectionToWidget(List list, boolean reveal) {

		if (list == null) {
			table.deselectAll();
			return;
		}

		if (virtualManager != null) {
			virtualSetSelectionToWidget(list, reveal);
			return;
		}

		int size = list.size();
		TableItem[] items = new TableItem[size];
		int count = 0;

		if (reveal) {
			table.showSelection();
		}

	}

	
	/**
	 * Set the selection on a virtual table
	 * 
	 * @param list
	 *            The elements to set
	 * @param reveal
	 *            Whether or not reveal the first item.
	 */
	private void virtualSetSelectionToWidget(List list, boolean reveal) {
		int size = list.size();
		int[] indices = new int[list.size()];

		TableItem firstItem = null;
		int count = 0;
		HashSet virtualElements = new HashSet();
		for (int i = 0; i < size; ++i) {
			Object o = list.get(i);
			Widget w = findItem(o);

				virtualElements.add(o);
			}
		}

		if (getContentProvider() instanceof ILazyContentProvider) {
			ILazyContentProvider provider = (ILazyContentProvider) getContentProvider();

			// Now go through it again until all is done or we are no longer
			// virtual
			// This may create all items so it is not a good
			// idea in general.
			// Use #setSelection (int [] indices,boolean reveal) instead
			for (int i = 0; virtualElements.size() > 0
					&& i < getTable().getItemCount(); i++) {
				provider.updateElement(i);
				TableItem item = getTable().getItem(i);
				if (virtualElements.contains(item.getData())) {
					indices[count++] = i;
					virtualElements.remove(item.getData());
					if (firstItem == null) {
						firstItem = item;
					}
				}
			}
		} else {

			if (count != list.size()) {// As this is expensive skip it if all
				// have been found
				// If it is not lazy we can use the cache
				for (int i = 0; i < virtualManager.cachedElements.length; i++) {
					Object element = virtualManager.cachedElements[i];
					if (virtualElements.contains(element)) {
						TableItem item = getTable().getItem(i);
						item.getText();// Be sure to fire the update
						indices[count++] = i;
						virtualElements.remove(element);
						if (firstItem == null) {
							firstItem = item;

				}
			}
		}

		if (count < size) {
			System.arraycopy(indices, 0, indices = new int[count], 0, count);
		}


	/**
	 * Set the item count of the receiver.
	 * 
	 * @param count
	 *            the new table size.
	 * 
	 * @since 3.1
	 */
	public void setItemCount(int count) {
		getTable().setItemCount(count);
		getTable().redraw();
	}

	/**
	 * Replace the entries starting at index with elements. This method assumes
	 * all of these values are correct and will not call the content provider to
	 * verify. <strong>Note that this method will create a TableItem for all of
	 * the elements provided</strong>.
	 * 
	 * @param element
	 * @param index
	 * @see ILazyContentProvider
	 * 
	 * @since 3.1
	 */
	public void replace(Object element, int index) {
		TableItem item = getTable().getItem(index);
		refreshItem(item, element);
	}

	/**
	 * Clear the table item at the specified index
	 * 
	 * @param index
	 *            the index of the table item to be cleared
	 * 
	 * @since 3.1
	 */

		}
		table.clear(index);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#getRawChildren(java.lang.Object)
	 */
	protected Object[] getRawChildren(Object parent) {

		Assert.isTrue(!(getContentProvider() instanceof ILazyContentProvider),
				"Cannot get raw children with an ILazyContentProvider");//$NON-NLS-1$
		return super.getRawChildren(parent);

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#assertContentProviderType(org.eclipse.jface.viewers.IContentProvider)
	 */
	protected void assertContentProviderType(IContentProvider provider) {
		Assert.isTrue(provider instanceof IStructuredContentProvider
				|| provider instanceof ILazyContentProvider);
	}
	
	
	
}

}




 * The decorator decorates the label text, image, font and colors provided by 
 * the nested label provider.
 */
public class DecoratingLabelProvider extends TreeViewerLabelProvider  {
        ILabelProvider, IViewerLabelProvider, IColorProvider, IFontProvider, ITreePathLabelProvider {
		
    private ILabelProvider provider;

    private ILabelDecorator decorator;


    public DecoratingLabelProvider(ILabelProvider provider,
            ILabelDecorator decorator) {
        Assert.isNotNull(provider);
        setProviders(provider);
        this.decorator = decorator;
    }


     */
    public void addListener(ILabelProviderListener listener) {
        super.addListener(listener);
        getLabelProvider().addListener(listener);
        if (decorator != null) {
            decorator.addListener(listener);
        }

     * disposes both the nested label provider and the label decorator.
     */
    public void dispose() {
        getLabelProvider().dispose();
        if (decorator != null) {
            decorator.dispose();
        }

     * <code>decorateImage</code> method.
     */
    public Image getImage(Object element) {
        Image image = getLabelProvider().getImage(element);
        if (decorator != null) {
        	if (decorator instanceof LabelDecorator) {
				LabelDecorator ld2 = (LabelDecorator) decorator;

    }

    /**
     * Returns the nested label provider.
     *
     * @return the nested label provider
     */
    public ILabelProvider getLabelProvider() {
        return provider;
    }

    /**
     * The <code>DecoratingLabelProvider</code> implementation of this 
     * <code>ILabelProvider</code> method returns the text label provided
     * by the nested label provider's <code>getText</code> method, 

     * <code>decorateText</code> method.
     */
    public String getText(Object element) {
        String text = getLabelProvider().getText(element);
        if (decorator != null) {
        	if (decorator instanceof LabelDecorator) {
				LabelDecorator ld2 = (LabelDecorator) decorator;

     * decorator returns <code>true</code>.
     */
    public boolean isLabelProperty(Object element, String property) {
        if (getLabelProvider().isLabelProperty(element, property)) {
			return true;
		}
        if (decorator != null && decorator.isLabelProperty(element, property)) {

     */
    public void removeListener(ILabelProviderListener listener) {
        super.removeListener(listener);
        getLabelProvider().removeListener(listener);
        if (decorator != null) {
            decorator.removeListener(listener);
        }

		
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
	 */
	public Color getBackground(Object element) {
		if(provider instanceof IColorProvider) {
			return ((IColorProvider) provider).getBackground(element);
		}
		return null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
	 */
	public Font getFont(Object element) {
		if(provider instanceof IFontProvider) {
			return ((IFontProvider) provider).getFont(element);
		}
		return null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
	 */
	public Color getForeground(Object element) {
		if(provider instanceof IColorProvider) {
			return ((IColorProvider) provider).getForeground(element);
		}
		return null;
	}

    /**
     * Return the decoration context associated with this label provider.
     * It will be passed to the decorator if the decorator is an 

		this.decorationContext = decorationContext;
	}

	

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.TreeViewerLabelProvider#updateLabel(org.eclipse.jface.viewers.ViewerLabel, org.eclipse.jface.viewers.TreePath)
	 */
	public void updateLabel(ViewerLabel settings, TreePath elementPath) {
        ILabelDecorator currentDecorator = getLabelDecorator();

        settings.setHasPendingDecorations(!decorationReady);
        // update icon and label

        if (getTreePathProvider() == null) {
			ITreePathLabelProvider pprov = (ITreePathLabelProvider) getLabelProvider();
			if (decorationReady || oldText == null
	                || settings.getText().length() == 0) {
				pprov.updateLabel(settings, elementPath);




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;

/**
 * @since 3.2
 * 
 */
public class ViewerLabelProvider extends LabelProvider implements
		ILabelProvider, IViewerLabelProvider, IColorProvider, IFontProvider {

	private static IFontProvider defaultFontProvider = new IFontProvider() {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
		 */
		public Font getFont(Object element) {
			return null;
		}
	};

	private static IColorProvider defaultColorProvider = new IColorProvider() {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
		 */
		public Color getBackground(Object element) {
			return null;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
		 */
		public Color getForeground(Object element) {
			return null;
		}
	};
	
	private static ILabelProvider defaultLabelProvider = new LabelProvider(){
		
	};

	private ILabelProvider labelProvider = defaultLabelProvider;

	private IColorProvider colorProvider = defaultColorProvider;

	private IFontProvider fontProvider = defaultFontProvider;

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.IViewerLabelProvider#updateLabel(org.eclipse.jface.viewers.ViewerLabel,
	 *      java.lang.Object)
	 */
	public void updateLabel(ViewerLabel label, Object element) {
		label.setText(labelProvider.getText(element));
		label.setImage(labelProvider.getImage(element));

		if (colorProvider != null) {
			label.setBackground(colorProvider.getBackground(element));
			label.setForeground(colorProvider.getForeground(element));
		}

		if (fontProvider != null) {
			label.setFont(fontProvider.getFont(element));
		}

	}

	/**
	 * Set the colorProvider to use for the receiver.
	 * 
	 * @param colorProvider
	 *            The colorProvider to set.
	 */
	public void setColorProvider(IColorProvider colorProvider) {
		this.colorProvider = colorProvider;
	}

	/**
	 * Set the fontProvider to fontProvider.
	 * 
	 * @param fontProvider
	 *            The fontProvider to set.
	 */
	public void setFontProvider(IFontProvider fontProvider) {
		this.fontProvider = fontProvider;
	}

	/**
	 * Set the labelProvider to be provider.
	 * 
	 * @param provider
	 *            ILabelProvider provider to set.
	 */
	public void setLabelProvider(ILabelProvider provider) {
		this.labelProvider = provider;
	}

	/**
	 * Set the any providers for the receiver that can be adapted from provider.
	 * 
	 * @param provider
	 */
	public void setProviders(Object provider) {
		if (provider instanceof ILabelProvider)
			labelProvider = (ILabelProvider) provider;
		if (provider instanceof IColorProvider)
			colorProvider = (IColorProvider) provider;
		if (provider instanceof IFontProvider)
			fontProvider = (IFontProvider) provider;

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
	 */
	public Font getFont(Object element) {
		return fontProvider.getFont(element);

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
	 */
	public Color getBackground(Object element) {
		return colorProvider.getBackground(element);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
	 */
	public Color getForeground(Object element) {
		return colorProvider.getForeground(element);
	}

	/**
	 * Get the IColorProvider for the receiver.
	 * @return IColorProvider
	 */
	public IColorProvider getColorProvider() {
		return colorProvider;
	}

	/**
	 * Get the IFontProvider for the receiver.
	 * @return IFontProvider
	 */
	public IFontProvider getFontProvider() {
		return fontProvider;
	}

	/**
	 * @return Returns the labelProvider.
	 */
	public ILabelProvider getLabelProvider() {
		return labelProvider;
	}

	

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;

/**
 * The TableColumnViewer is the viewer for a TableColumn.
 * 
 * @since 3.3
 * 
 */
public class TableColumnViewerPart {

	private TableColumn tableColumn;
	private int index;
	private ViewerLabelProvider labelProvider;

	
	/**
	 * Create a new instance of the receiver at 
	 * @param provider
	 * @param columnIndex
	 */
	public TableColumnViewerPart(ViewerLabelProvider provider, int columnIndex) {
		index = columnIndex;
		labelProvider = provider;
	}


	/**
	 * @param item
	 * @param element
	 */
	public void refresh(TableItem item, Object element) {
		
		ViewerLabel label = new ViewerLabel(item.getText(index),item.getImage(index));
		labelProvider.updateLabel(label,element);
		
		if(label.hasNewBackground())
			item.setBackground(index, label.getBackground());
		
		if(label.hasNewForeground())
			item.setForeground(index, label.getForeground());
		
		if(label.hasNewFont())
			item.setFont(index, label.getFont());
		
		if(label.hasNewText())
			item.setText(index, label.getText());
		
		if(label.hasNewImage())
			item.setImage(index, label.getImage());
		
		
	}


	/**
	 * @return Returns the tableColumn.
	 */
	public TableColumn getTableColumn() {
		return tableColumn;
	}


}

	





/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;


/**
 * TreeViewerLabelProvider is the ViewerLabelProvider that handles
 * TreePaths.
 * @since 3.2
 *
 */
public class TreeViewerLabelProvider extends ViewerLabelProvider {
	 private ITreePathLabelProvider treePathProvider;
	
	
	
	/**
	 * Update the label for the element with TreePath.
	 * @param label
	 * @param elementPath
	 */
	public void updateLabel(ViewerLabel label, TreePath elementPath) {
		treePathProvider.updateLabel(label, elementPath);

	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerLabelProvider#setProviders(java.lang.Object)
	 */
	public void setProviders(Object provider) {
		super.setProviders(provider);
		if(provider instanceof ITreePathLabelProvider)
			treePathProvider = (ITreePathLabelProvider) provider;
	}

	/**
	 * Return the ITreePathLabelProvider for the receiver.
	 * @return Returns the treePathProvider.
	 */
	public ITreePathLabelProvider getTreePathProvider() {
		return treePathProvider;
	}

}

Return to bug 149193

Lines 22-31 Link Here

(-)src/org/eclipse/jface/viewers/DecoratingLabelProvider.java (-52 / +13 lines)
22	* The decorator decorates the label text, image, font and colors provided by	22	* The decorator decorates the label text, image, font and colors provided by
23	* the nested label provider.	23	* the nested label provider.
24	*/	24	*/
25	public class DecoratingLabelProvider extends LabelProvider implements	25	public class DecoratingLabelProvider extends TreeViewerLabelProvider {
26	ILabelProvider, IViewerLabelProvider, IColorProvider, IFontProvider, ITreePathLabelProvider {
27		26
28	private ILabelProvider provider;
29		27
30	private ILabelDecorator decorator;	28	private ILabelDecorator decorator;
31		29
Lines 44-50 Link Here
44	public DecoratingLabelProvider(ILabelProvider provider,	42	public DecoratingLabelProvider(ILabelProvider provider,
45	ILabelDecorator decorator) {	43	ILabelDecorator decorator) {
46	Assert.isNotNull(provider);	44	Assert.isNotNull(provider);
47	this.provider = provider;	45	setProviders(provider);
48	this.decorator = decorator;	46	this.decorator = decorator;
49	}	47	}
50		48
Lines 56-62 Link Here
56	*/	54	*/
57	public void addListener(ILabelProviderListener listener) {	55	public void addListener(ILabelProviderListener listener) {
58	super.addListener(listener);	56	super.addListener(listener);
59	provider.addListener(listener);	57	getLabelProvider().addListener(listener);
60	if (decorator != null) {	58	if (decorator != null) {
61	decorator.addListener(listener);	59	decorator.addListener(listener);
62	}	60	}
Lines 68-74 Link Here
68	* disposes both the nested label provider and the label decorator.	66	* disposes both the nested label provider and the label decorator.
69	*/	67	*/
70	public void dispose() {	68	public void dispose() {
71	provider.dispose();	69	getLabelProvider().dispose();
72	if (decorator != null) {	70	if (decorator != null) {
73	decorator.dispose();	71	decorator.dispose();
74	}	72	}
Lines 82-88 Link Here
82	* <code>decorateImage</code> method.	80	* <code>decorateImage</code> method.
83	*/	81	*/
84	public Image getImage(Object element) {	82	public Image getImage(Object element) {
85	Image image = provider.getImage(element);	83	Image image = getLabelProvider().getImage(element);
86	if (decorator != null) {	84	if (decorator != null) {
87	if (decorator instanceof LabelDecorator) {	85	if (decorator instanceof LabelDecorator) {
88	LabelDecorator ld2 = (LabelDecorator) decorator;	86	LabelDecorator ld2 = (LabelDecorator) decorator;
Lines 110-124 Link Here
110	}	108	}
111		109
112	/**	110	/**
113	* Returns the nested label provider.
114	*
115	* @return the nested label provider
116	*/
117	public ILabelProvider getLabelProvider() {
118	return provider;
119	}
120
121	/**
122	* The <code>DecoratingLabelProvider</code> implementation of this	111	* The <code>DecoratingLabelProvider</code> implementation of this
123	* <code>ILabelProvider</code> method returns the text label provided	112	* <code>ILabelProvider</code> method returns the text label provided
124	* by the nested label provider's <code>getText</code> method,	113	* by the nested label provider's <code>getText</code> method,
Lines 126-132 Link Here
126	* <code>decorateText</code> method.	115	* <code>decorateText</code> method.
127	*/	116	*/
128	public String getText(Object element) {	117	public String getText(Object element) {
129	String text = provider.getText(element);	118	String text = getLabelProvider().getText(element);
130	if (decorator != null) {	119	if (decorator != null) {
131	if (decorator instanceof LabelDecorator) {	120	if (decorator instanceof LabelDecorator) {
132	LabelDecorator ld2 = (LabelDecorator) decorator;	121	LabelDecorator ld2 = (LabelDecorator) decorator;
Lines 151-157 Link Here
151	* decorator returns <code>true</code>.	140	* decorator returns <code>true</code>.
152	*/	141	*/
153	public boolean isLabelProperty(Object element, String property) {	142	public boolean isLabelProperty(Object element, String property) {
154	if (provider.isLabelProperty(element, property)) {	143	if (getLabelProvider().isLabelProperty(element, property)) {
155	return true;	144	return true;
156	}	145	}
157	if (decorator != null && decorator.isLabelProperty(element, property)) {	146	if (decorator != null && decorator.isLabelProperty(element, property)) {
Lines 168-174 Link Here
168	*/	157	*/
169	public void removeListener(ILabelProviderListener listener) {	158	public void removeListener(ILabelProviderListener listener) {
170	super.removeListener(listener);	159	super.removeListener(listener);
171	provider.removeListener(listener);	160	getLabelProvider().removeListener(listener);
172	if (decorator != null) {	161	if (decorator != null) {
173	decorator.removeListener(listener);	162	decorator.removeListener(listener);
174	}	163	}
Lines 260-295 Link Here
260		249
261	}	250	}
262		251
263	/* (non-Javadoc)
264	* @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
265	*/
266	public Color getBackground(Object element) {
267	if(provider instanceof IColorProvider) {
268	return ((IColorProvider) provider).getBackground(element);
269	}
270	return null;
271	}
272
273	/* (non-Javadoc)
274	* @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
275	*/
276	public Font getFont(Object element) {
277	if(provider instanceof IFontProvider) {
278	return ((IFontProvider) provider).getFont(element);
279	}
280	return null;
281	}
282
283	/* (non-Javadoc)
284	* @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
285	*/
286	public Color getForeground(Object element) {
287	if(provider instanceof IColorProvider) {
288	return ((IColorProvider) provider).getForeground(element);
289	}
290	return null;
291	}
292
293	/**	252	/**
294	* Return the decoration context associated with this label provider.	253	* Return the decoration context associated with this label provider.
295	* It will be passed to the decorator if the decorator is an	254	* It will be passed to the decorator if the decorator is an
Lines 314-321 Link Here
314	this.decorationContext = decorationContext;	273	this.decorationContext = decorationContext;
315	}	274	}
316		275
		276
		277
317	/* (non-Javadoc)	278	/* (non-Javadoc)
318	* @see org.eclipse.jface.viewers.ITreePathLabelProvider#updateLabel(org.eclipse.jface.viewers.ViewerLabel, org.eclipse.jface.viewers.TreePath)	279	* @see org.eclipse.jface.viewers.TreeViewerLabelProvider#updateLabel(org.eclipse.jface.viewers.ViewerLabel, org.eclipse.jface.viewers.TreePath)
319	*/	280	*/
320	public void updateLabel(ViewerLabel settings, TreePath elementPath) {	281	public void updateLabel(ViewerLabel settings, TreePath elementPath) {
321	ILabelDecorator currentDecorator = getLabelDecorator();	282	ILabelDecorator currentDecorator = getLabelDecorator();
Lines 338-345 Link Here
338	settings.setHasPendingDecorations(!decorationReady);	299	settings.setHasPendingDecorations(!decorationReady);
339	// update icon and label	300	// update icon and label
340		301
341	if (provider instanceof ITreePathLabelProvider) {	302	if (getTreePathProvider() == null) {
342	ITreePathLabelProvider pprov = (ITreePathLabelProvider) provider;	303	ITreePathLabelProvider pprov = (ITreePathLabelProvider) getLabelProvider();
343	if (decorationReady \|\| oldText == null	304	if (decorationReady \|\| oldText == null
344	\|\| settings.getText().length() == 0) {	305	\|\| settings.getText().length() == 0) {
345	pprov.updateLabel(settings, elementPath);	306	pprov.updateLabel(settings, elementPath);

Added Link Here

(-)src/org/eclipse/jface/viewers/ViewerLabelProvider.java (+184 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.swt.graphics.Color;
15	import org.eclipse.swt.graphics.Font;
16
17	/**
18	* @since 3.2
19	*
20	*/
21	public class ViewerLabelProvider extends LabelProvider implements
22	ILabelProvider, IViewerLabelProvider, IColorProvider, IFontProvider {
23
24	private static IFontProvider defaultFontProvider = new IFontProvider() {
25	/*
26	* (non-Javadoc)
27	*
28	* @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
29	*/
30	public Font getFont(Object element) {
31	return null;
32	}
33	};
34
35	private static IColorProvider defaultColorProvider = new IColorProvider() {
36	/*
37	* (non-Javadoc)
38	*
39	* @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
40	*/
41	public Color getBackground(Object element) {
42	return null;
43	}
44
45	/*
46	* (non-Javadoc)
47	*
48	* @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
49	*/
50	public Color getForeground(Object element) {
51	return null;
52	}
53	};
54
55	private static ILabelProvider defaultLabelProvider = new LabelProvider(){
56
57	};
58
59	private ILabelProvider labelProvider = defaultLabelProvider;
60
61	private IColorProvider colorProvider = defaultColorProvider;
62
63	private IFontProvider fontProvider = defaultFontProvider;
64
65	/*
66	* (non-Javadoc)
67	*
68	* @see org.eclipse.jface.viewers.IViewerLabelProvider#updateLabel(org.eclipse.jface.viewers.ViewerLabel,
69	* java.lang.Object)
70	*/
71	public void updateLabel(ViewerLabel label, Object element) {
72	label.setText(labelProvider.getText(element));
73	label.setImage(labelProvider.getImage(element));
74
75	if (colorProvider != null) {
76	label.setBackground(colorProvider.getBackground(element));
77	label.setForeground(colorProvider.getForeground(element));
78	}
79
80	if (fontProvider != null) {
81	label.setFont(fontProvider.getFont(element));
82	}
83
84	}
85
86	/**
87	* Set the colorProvider to use for the receiver.
88	*
89	* @param colorProvider
90	* The colorProvider to set.
91	*/
92	public void setColorProvider(IColorProvider colorProvider) {
93	this.colorProvider = colorProvider;
94	}
95
96	/**
97	* Set the fontProvider to fontProvider.
98	*
99	* @param fontProvider
100	* The fontProvider to set.
101	*/
102	public void setFontProvider(IFontProvider fontProvider) {
103	this.fontProvider = fontProvider;
104	}
105
106	/**
107	* Set the labelProvider to be provider.
108	*
109	* @param provider
110	* ILabelProvider provider to set.
111	*/
112	public void setLabelProvider(ILabelProvider provider) {
113	this.labelProvider = provider;
114	}
115
116	/**
117	* Set the any providers for the receiver that can be adapted from provider.
118	*
119	* @param provider
120	*/
121	public void setProviders(Object provider) {
122	if (provider instanceof ILabelProvider)
123	labelProvider = (ILabelProvider) provider;
124	if (provider instanceof IColorProvider)
125	colorProvider = (IColorProvider) provider;
126	if (provider instanceof IFontProvider)
127	fontProvider = (IFontProvider) provider;
128
129	}
130
131	/*
132	* (non-Javadoc)
133	*
134	* @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
135	*/
136	public Font getFont(Object element) {
137	return fontProvider.getFont(element);
138
139	}
140
141	/*
142	* (non-Javadoc)
143	*
144	* @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
145	*/
146	public Color getBackground(Object element) {
147	return colorProvider.getBackground(element);
148	}
149
150	/*
151	* (non-Javadoc)
152	*
153	* @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
154	*/
155	public Color getForeground(Object element) {
156	return colorProvider.getForeground(element);
157	}
158
159	/**
160	* Get the IColorProvider for the receiver.
161	* @return IColorProvider
162	*/
163	public IColorProvider getColorProvider() {
164	return colorProvider;
165	}
166
167	/**
168	* Get the IFontProvider for the receiver.
169	* @return IFontProvider
170	*/
171	public IFontProvider getFontProvider() {
172	return fontProvider;
173	}
174
175	/**
176	* @return Returns the labelProvider.
177	*/
178	public ILabelProvider getLabelProvider() {
179	return labelProvider;
180	}
181
182
183
184	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TableColumnViewerPart.java (+80 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.swt.widgets.TableColumn;
15	import org.eclipse.swt.widgets.TableItem;
16
17	/**
18	* The TableColumnViewer is the viewer for a TableColumn.
19	*
20	* @since 3.3
21	*
22	*/
23	public class TableColumnViewerPart {
24
25	private TableColumn tableColumn;
26	private int index;
27	private ViewerLabelProvider labelProvider;
28
29
30	/**
31	* Create a new instance of the receiver at
32	* @param provider
33	* @param columnIndex
34	*/
35	public TableColumnViewerPart(ViewerLabelProvider provider, int columnIndex) {
36	index = columnIndex;
37	labelProvider = provider;
38	}
39
40
41	/**
42	* @param item
43	* @param element
44	*/
45	public void refresh(TableItem item, Object element) {
46
47	ViewerLabel label = new ViewerLabel(item.getText(index),item.getImage(index));
48	labelProvider.updateLabel(label,element);
49
50	if(label.hasNewBackground())
51	item.setBackground(index, label.getBackground());
52
53	if(label.hasNewForeground())
54	item.setForeground(index, label.getForeground());
55
56	if(label.hasNewFont())
57	item.setFont(index, label.getFont());
58
59	if(label.hasNewText())
60	item.setText(index, label.getText());
61
62	if(label.hasNewImage())
63	item.setImage(index, label.getImage());
64
65
66	}
67
68
69	/**
70	* @return Returns the tableColumn.
71	*/
72	public TableColumn getTableColumn() {
73	return tableColumn;
74	}
75
76
77	}
78
79
80

Added Link Here

(-)src/org/eclipse/jface/viewers/TreeViewerLabelProvider.java (+53 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14
15	/**
16	* TreeViewerLabelProvider is the ViewerLabelProvider that handles
17	* TreePaths.
18	* @since 3.2
19	*
20	*/
21	public class TreeViewerLabelProvider extends ViewerLabelProvider {
22	private ITreePathLabelProvider treePathProvider;
23
24
25
26	/**
27	* Update the label for the element with TreePath.
28	* @param label
29	* @param elementPath
30	*/
31	public void updateLabel(ViewerLabel label, TreePath elementPath) {
32	treePathProvider.updateLabel(label, elementPath);
33
34	}
35
36	/* (non-Javadoc)
37	* @see org.eclipse.jface.viewers.ViewerLabelProvider#setProviders(java.lang.Object)
38	*/
39	public void setProviders(Object provider) {
40	super.setProviders(provider);
41	if(provider instanceof ITreePathLabelProvider)
42	treePathProvider = (ITreePathLabelProvider) provider;
43	}
44
45	/**
46	* Return the ITreePathLabelProvider for the receiver.
47	* @return Returns the treePathProvider.
48	*/
49	public ITreePathLabelProvider getTreePathProvider() {
50	return treePathProvider;
51	}
52
53	}