Attachment #46263 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 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;


	 * The color and font collector for the cells.
	 */
	private TableColorAndFontNoOp tableColorAndFont = new TableColorAndFontNoOp();
	
	/**
	 * 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();
			if(columnCount == 0)
				columnCount = 1;//If there are no columns do the first one 

			// 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++) {
				ColumnViewerPart 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 ColumnViewerPart getColumnViewer(int columnIndex) {

		Object viewer;
		Widget columnOwner;
		if (getTable().getColumnCount() == 0)// Hang it off the table if it
			// has no columns
			columnOwner = getTable();
		else
			columnOwner = getTable().getColumn(columnIndex);
		viewer = columnOwner.getData(ColumnViewerPart.COLUMN_VIEWER_KEY);

		if (viewer == null) {
			viewer = new ColumnViewerPart(
					ViewerLabelProvider.createViewerLabelProvider(columnIndex,getLabelProvider()), columnIndex);
			columnOwner.setData(ColumnViewerPart.COLUMN_VIEWER_KEY, viewer);
		}
		return (ColumnViewerPart) viewer;
	}

	/**
	 * Set the TableColumnViewerPart at columnIndex to be viewerPart.
	 * 
	 * @param viewerPart
	 * @param columnIndex
	 */
	public void setColumnPart(ColumnViewerPart viewerPart, int columnIndex) {
		TableColumn column = getTable().getColumn(columnIndex);
		column.setData(ColumnViewerPart.COLUMN_VIEWER_KEY, viewerPart);
	}


	/**
	 * 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);
		clearColumnParts();//Clear before refresh
		super.setLabelProvider(labelProvider);
		if(labelProvider instanceof ITableFontProvider || labelProvider instanceof ITableColorProvider) {
			tableColorAndFont = new TableColorAndFontCollector(labelProvider);
		} else {
			tableColorAndFont = new TableColorAndFontNoOp();
		}
				
	}
	
	/**
	 * Clear the viewer parts for the columns
	 */
	private void clearColumnParts() {
		TableColumn[] columns = getTable().getColumns();
		if(columns.length == 0)
			getTable().setData(ColumnViewerPart.COLUMN_VIEWER_KEY,null);
		else{
			for (int i = 0; i < columns.length; i++) {
				columns[i].setData(ColumnViewerPart.COLUMN_VIEWER_KEY,null);
				
			}
		}
		
	}

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

}




import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.TreeListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;

public class TreeViewer extends AbstractTreeViewer {

	/**
	 * TreeColorAndFontCollector is an helper class for color and font support
	 * for trees that support the ITableFontProvider and the
	 * ITableColorProvider.
	 * 
	 * @see ITableColorProvider
	 * @see ITableFontProvider
	 */

	private class TreeColorAndFontCollector {

		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 TreeColorAndFontCollector(IBaseLabelProvider provider) {
			if (provider instanceof ITableFontProvider) {
				fontProvider = (ITableFontProvider) provider;
			}
			if (provider instanceof ITableColorProvider) {
				colorProvider = (ITableColorProvider) provider;
			}
		}

		/**
		 * Create an instance of the receiver with no color and font providers.
		 */
		public TreeColorAndFontCollector() {
		}

		/**
		 * Set the fonts and colors for the treeItem if there is a color and
		 * font provider available.
		 * 
		 * @param treeItem
		 *            The item to update.
		 * @param element
		 *            The element being represented
		 * @param column
		 *            The column index
		 */
		public void setFontsAndColors(TreeItem treeItem, Object element,
				int column) {
			if (colorProvider != null) {
				treeItem.setBackground(column, colorProvider.getBackground(
						element, column));
				treeItem.setForeground(column, colorProvider.getForeground(
						element, column));
			}
			if (fontProvider != null) {
				treeItem.setFont(column, fontProvider.getFont(element, column));
			}
		}

	}

	/**
	 * Internal tree viewer implementation.
	 */
	private TreeEditorImpl treeViewerImpl;

	private TreeEditor treeEditor;

	/**
	 * The color and font collector for the cells.
	 */
	private TreeColorAndFontCollector treeColorAndFont = new TreeColorAndFontCollector();
	
	/**
	 * Flag for whether the tree has been disposed of.
	 */
	private boolean treeIsDisposed = false;

	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void doUpdateItem(final Item item, Object element) {
 		if (!(item instanceof TreeItem)) {
			return;
		}
		TreeItem treeItem = (TreeItem) item;

			return;
		}

		int columnCount = getTree().getColumnCount();
		if(columnCount == 0)//If no columns are created then fake one
			columnCount = 1;

		for (int column = 0; column < columnCount; column++) {
			ColumnViewerPart columnViewer = getColumnViewer(column);
			columnViewer.refresh(treeItem, element);
		
		if(prov instanceof ILabelProvider) {
			lprov = (ILabelProvider) prov;
		}
		
		if (prov instanceof IViewerLabelProvider) {
			vprov = (IViewerLabelProvider) prov;
		} 
		
		if (prov instanceof ITableLabelProvider) {
			tprov = (ITableLabelProvider) prov;
		}
		
		if (prov instanceof ITreePathLabelProvider) {
			pprov = (ITreePathLabelProvider) prov;
		}
		
		
		int columnCount = tree.getColumnCount();
		if (columnCount == 0) {// If no columns were created use the label
								// provider

			ViewerLabel updateLabel = new ViewerLabel(treeItem.getText(),
					treeItem.getImage());
			if (pprov != null) {
				TreePath path = getTreePathFromItem(item);
				buildLabel(updateLabel,path,pprov);
			} else 
				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;
			}

		}
				treeItem.setText(updateLabel.getText());
			}
			if (updateLabel.hasNewImage()) {
				treeItem.setImage(updateLabel.getImage());
			}
			
			if (!updateLabel.hasPendingDecorations())
				getColorAndFontCollector().applyFontsAndColors(treeItem);

		} else {// Use the table based support
			for (int column = 0; column < columnCount; column++) {
				// Similar code in TableViewer.doUpdateItem()
				String text = "";//$NON-NLS-1$
				Image image = null;
				treeColorAndFont.setFontsAndColors(treeItem, element, column);

				if (tprov == null) {
					if (column == 0) {
						ViewerLabel updateLabel = new ViewerLabel(treeItem
								.getText(), treeItem.getImage());
						if(vprov != null) {
							buildLabel(updateLabel,element,vprov);
						} else{
							if(lprov != null) {
								buildLabel(updateLabel,element,lprov);
							}
						}

	}
						// loop check here.
						if (treeItem.isDisposed()) {
							unmapElement(element, treeItem);
							return;
						}

	/**
	 * Get the TreeColumnViewerPart at the columnIndex.
	 * 
	 * @param columnIndex
	 * @return ColumnViewerPart
	 */
	private ColumnViewerPart getColumnViewer(int columnIndex) {

		Object viewer;
		Widget columnOwner;
		if (getTree().getColumnCount() == 0)// Hang it off the table if it
			// has no columns
			columnOwner = getTree();
		else
			columnOwner = getTree().getColumn(columnIndex);
		viewer = columnOwner.getData(ColumnViewerPart.COLUMN_VIEWER_KEY);

		if (viewer == null) {
			viewer = new ColumnViewerPart(
					ViewerLabelProvider.createViewerLabelProvider(columnIndex,
							getLabelProvider()), columnIndex);
			columnOwner.setData(ColumnViewerPart.COLUMN_VIEWER_KEY, viewer);
		}
		return (ColumnViewerPart) viewer;
	}

	/**
	 * Override to handle tree paths.
	 * 
	 * @see org.eclipse.jface.viewers.StructuredViewer#buildLabel(org.eclipse.jface.viewers.ViewerLabel,
	 *      java.lang.Object)
	 */
	protected void buildLabel(ViewerLabel updateLabel, Object elementOrPath) {
		Object element;

	protected Item getParentItem(Item item) {
		return ((TreeItem) item).getParentItem();
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */

			}
		});
		if ((treeControl.getStyle() & SWT.VIRTUAL) != 0) {
			treeControl.addDisposeListener(new DisposeListener() {
				public void widgetDisposed(DisposeEvent e) {
					treeIsDisposed = true;
					unmapAllElements();
				}
			});
			treeControl.addListener(SWT.SetData, new Listener() {

				public void handleEvent(Event event) {
					if (getContentProvider() instanceof ILazyTreeContentProvider) {

	 */
	protected void setExpanded(Item node, boolean expand) {
		((TreeItem) node).setExpanded(expand);
		if (getContentProvider() instanceof ILazyTreeContentProvider) {
			// force repaints to happen
			getControl().update();
		}

	 * <code>ITableLabelProvider</code> may also implement
	 * {@link ITableColorProvider} and/or {@link ITableFontProvider} to provide
	 * colors and/or fonts. Note that the underlying {@link Tree} must be
	 * configured with {@link TreeColumn} objects in this case.
	 * </p>
	 * <p>
	 * If the label provider is an <code>ILabelProvider</code>, then it

	public void setLabelProvider(IBaseLabelProvider labelProvider) {
		Assert.isTrue(labelProvider instanceof ITableLabelProvider
				|| labelProvider instanceof ILabelProvider);
		clearColumnParts();//Clear before refresh
		super.setLabelProvider(labelProvider);
		
	}

	/**
	 * Clear the viewer parts for the columns
	 */
	private void clearColumnParts() {
		TreeColumn[] columns = getTree().getColumns();
		if(columns.length == 0)
			getTree().setData(ColumnViewerPart.COLUMN_VIEWER_KEY,null);
		else{
			for (int i = 0; i < columns.length; i++) {
				columns[i].setData(ColumnViewerPart.COLUMN_VIEWER_KEY,null);
				
			}
		}
		
	}

	/*

	 *            the array of items
	 * @return <code>true</code> if the refer to the same elements,
	 *         <code>false</code> otherwise
	 * 
	 * @since 3.1
	 */
	protected boolean isSameSelection(List items, Item[] current) {

		// Go through the items of the current collection
		// If there is a mismatch return false
		for (int i = 0; i < current.length; i++) {
			if (current[i].getData() == null
					|| !itemSet.containsKey(current[i].getData())) {
				return false;
			}
		}

		getTree().showItem((TreeItem) item);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.AbstractTreeViewer#getChild(org.eclipse.swt.widgets.Widget,
	 *      int)
	 */
	protected Item getChild(Widget widget, int index) {
		if (widget instanceof TreeItem) {

		}
		return null;
	}

	protected void assertContentProviderType(IContentProvider provider) {
		if (provider instanceof ILazyTreeContentProvider) {
			return;
		}
		super.assertContentProviderType(provider);
	}

	protected Object[] getRawChildren(Object parent) {
		if (getContentProvider() instanceof ILazyTreeContentProvider) {
			return new Object[0];
		}
		return super.getRawChildren(parent);
	}

	/**
	 * For a TreeViewer with a tree with the VIRTUAL style bit set, set the
	 * number of children of the given element. To set the number of children of
	 * the invisible root of the tree, the input object is passed as the
	 * element.
	 * 
	 * @param element
	 * @param count
	 * 
	 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.2 release cycle. Please do not use this API
	 * without consulting with the Platform/UI team.
	 * </p>
	 * 
	 * @since 3.2
	 */
	public void setChildCount(Object element, int count) {
		Tree tree = (Tree) doFindInputItem(element);
		if (tree != null) {

		}
		Widget[] items = findItems(element);
		for (int i = 0; i < items.length; i++) {
			TreeItem treeItem = (TreeItem) items[i];
			treeItem.setItemCount(count);
		}
	}

	/**

	 * This method should be called by implementers of ILazyTreeContentProvider
	 * to populate this viewer.
	 * </p>
	 * 
	 * @param parent
	 *            the parent of the element that should be updated
	 * @param index
	 *            the index in the parent's children
	 * @param element
	 *            the new element
	 * 
	 * @see #setChildCount(Object, int)
	 * @see ILazyTreeContentProvider
	 * 
	 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.2 release cycle. Please do not use this API
	 * without consulting with the Platform/UI team.
	 * </p>
	 * 
	 * @since 3.2
	 */
	public void replace(Object parent, int index, Object element) {
		if (parent.equals(getInput())) {
			if (index < tree.getItemCount()) {
				updateItem(tree.getItem(index), element);
			}

				if (index < parentItem.getItemCount()) {
					updateItem(parentItem.getItem(index), element);
				}
			}
		}
	}

	public boolean isExpandable(Object element) {
		if (getContentProvider() instanceof ILazyTreeContentProvider) {
			TreeItem treeItem = (TreeItem) internalExpand(element, false);
			if (treeItem == null) {
				return false;
			}
			virtualMaterializeItem(treeItem);
			return treeItem.getItemCount() > 0;
		}
		return super.isExpandable(element);
	}

	protected Object getParentElement(Object element) {
		if (!(element instanceof TreePath)
				&& (getContentProvider() instanceof ILazyTreeContentProvider)) {
			ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();
			return lazyTreeContentProvider.getParent(element);
		}
		return super.getParentElement(element);
	}

	protected void createChildren(Widget widget) {
		if (getContentProvider() instanceof ILazyTreeContentProvider) {
			final Item[] tis = getChildren(widget);
			if (tis != null && tis.length > 0) {
				// children already there, touch them
				for (int i = 0; i < tis.length; i++) {
    		return lazyTreeContentProvider.getParent(element);
    	}
        return super.getParentElement(element);
	}
    
    protected void createChildren(Widget widget) {
    	if (getContentProvider() instanceof ILazyTreeContentProvider) {
    		final Item[] tis = getChildren(widget);
    		if (tis != null && tis.length > 0) {
    			// children already there, touch them
    			for (int i = 0; i < tis.length; i++) {
					tis[i].getText();
				}
				return;
			}
			ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();
			Object element = widget.getData();
			if (element == null && widget instanceof TreeItem) {
				// parent has not been materialized
				virtualMaterializeItem((TreeItem) widget);
				// try getting the element now that updateElement was called
				element = widget.getData();
			}
			TreeItem[] children;
			if (widget instanceof Tree) {
				children = ((Tree) widget).getItems();
			} else {
				children = ((TreeItem) widget).getItems();
			}
			if (element != null && children.length > 0) {
				for (int i = 0; i < children.length; i++) {
					lazyTreeContentProvider.updateElement(element, i);
				}
			}
			return;
		}
		super.createChildren(widget);
	}

	protected void internalAdd(Widget widget, Object parentElement,
			Object[] childElements) {
		if (getContentProvider() instanceof ILazyTreeContentProvider) {
			if (widget instanceof TreeItem) {
				TreeItem ti = (TreeItem) widget;
				int count = ti.getItemCount() + childElements.length;
				ti.setItemCount(count);
				ti.clearAll(false);
			} else {
				Tree t = (Tree) widget;
				t.setItemCount(t.getItemCount() + childElements.length);
				t.clearAll(false);
			}
			return;
		}
		super.internalAdd(widget, parentElement, childElements);
	}

	private void virtualMaterializeItem(TreeItem treeItem) {
		if (treeItem.getData() != null) {

			lazyTreeContentProvider.updateElement(parentElement, index);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.AbstractTreeViewer#internalRefreshStruct(org.eclipse.swt.widgets.Widget,
	 *      java.lang.Object, boolean)
	 */
	protected void internalRefreshStruct(Widget widget, Object element,
			boolean updateLabels) {
		if (getContentProvider() instanceof ILazyTreeContentProvider) {
			// first phase: update child counts
			virtualRefreshChildCounts(widget, element);
			// second phase: update labels
			if (updateLabels) {
				if (widget instanceof Tree) {
					((Tree) widget).clearAll(true);
				} else if (widget instanceof TreeItem) {
					((TreeItem) widget).clearAll(true);
				}
			}
			return;
		}
		super.internalRefreshStruct(widget, element, updateLabels);
	}

	/**
	 * Traverses the visible (expanded) part of the tree and updates child
	 * counts.
	 * 
	 * @param widget
	 * @param element
	 * @param updateLabels
	 */
	private void virtualRefreshChildCounts(Widget widget, Object element) {
		ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();
		if (widget instanceof Tree || ((TreeItem) widget).getExpanded()) {
			// widget shows children - it is safe to call getChildren
			if (element != null) {
				lazyTreeContentProvider.updateChildCount(element,
						getChildren(widget).length);
			} else {
				if (widget instanceof Tree) {
					((Tree) widget).setItemCount(0);
				} else {
					((TreeItem) widget).setItemCount(0);
				}
			}
			// need to get children again because they might have been updated
			// through a callback to setChildCount.
			Item[] items = getChildren(widget);
			for (int i = 0; i < items.length; i++) {
				Item item = items[i];

			}
		}
	}

	/*
	 * To unmap elements correctly, we need to register a dispose listener with
	 * the item if the tree is virtual.

		super.mapElement(element, item);
		// make sure to unmap elements if the tree is virtual
		if ((getTree().getStyle() & SWT.VIRTUAL) != 0) {
			item.addDisposeListener(new DisposeListener() {
				public void widgetDisposed(DisposeEvent e) {
					if (!treeIsDisposed) {
						Object data = item.getData();

							unmapElement(data, item);
						}
					}
				}
			});
		}
	}
}




 * 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.jface.util.Policy;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.TreeItem;

/**
 * The ColumnViewerPart is abstract implementation of the 
 * column parts.
 * @since 3.3
 *
 */
public class ColumnViewerPart {

	private int index;
	private ViewerLabelProvider labelProvider;
	static String COLUMN_VIEWER_KEY = Policy.JFACE + ".columnViewer";//$NON-NLS-1$
	
	/**
	 * Create a new instance of the receiver at columnIndex.
	 * @param provider
	 * @param columnIndex
	 */
	public ColumnViewerPart(ViewerLabelProvider provider, int columnIndex) {
		index = columnIndex;
		labelProvider = provider;
	}
	
	/**
	 * Return the column index for the receiver
	 * @return int
	 */
	public int getIndex() {
		return index;
	}
	/**
	 * Return the label provider for the receiver.
	 * @return ViewerLabelProvider
	 */
	public ViewerLabelProvider getLabelProvider() {
		return labelProvider;
	}
	
	/**
	 * Refresh the TreeItem for element.
	 * @param item
	 * @param element
	 */
	public void refresh(TreeItem item, Object element) {

		ViewerLabel label = new ViewerLabel(item.getText(getIndex()), item
				.getImage(getIndex()));
		getLabelProvider().updateLabel(label, element);

		if (label.hasNewBackground())
			item.setBackground(getIndex(), label.getBackground());

		if (label.hasNewForeground())
			item.setForeground(getIndex(), label.getForeground());

		if (label.hasNewFont())
			item.setFont(getIndex(), label.getFont());

		if (label.hasNewText())
			item.setText(getIndex(), label.getText());

		if (label.hasNewImage())
			item.setImage(getIndex(), label.getImage());

	}
	
	/**
	 * Refresh the TableItem for element.
	 * @param item
	 * @param element
	 */
	public void refresh(TableItem item, Object element) {

		ViewerLabel label = new ViewerLabel(item.getText(getIndex()), item
				.getImage(getIndex()));
		getLabelProvider().updateLabel(label, element);

		if (label.hasNewBackground())
			item.setBackground(getIndex(), label.getBackground());

		if (label.hasNewForeground())
			item.setForeground(getIndex(), label.getForeground());

		if (label.hasNewFont())
			item.setFont(getIndex(), label.getFont());

		if (label.hasNewText())
			item.setText(getIndex(), label.getText());

		if (label.hasNewImage())
			item.setImage(getIndex(), label.getImage());

	}
}




/*******************************************************************************
 * 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;

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

	/**
	 * Create a new instance of the receiver based on labelProvider.
	 * 
	 * @param labelProvider
	 */
	public ViewerLabelProvider(IBaseLabelProvider labelProvider) {
		super();
		setProviders(labelProvider);
	}

	/**
	 * Create a ViewerLabelProvider for the column at index
	 * 
	 * @param columnIndex
	 * @param labelProvider The labelProvider to convert
	 * @return ViewerLabelProvider
	 */
	static ViewerLabelProvider createViewerLabelProvider(int columnIndex,
			IBaseLabelProvider labelProvider) {

		if (labelProvider instanceof ITableLabelProvider
				|| labelProvider instanceof ITableColorProvider
				|| labelProvider instanceof ITableFontProvider)
			return new TableColumnViewerLabelProvider(labelProvider,
					columnIndex);
		return new ViewerLabelProvider(labelProvider);

	}

	/*
	 * (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.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;

/**
 * TableColumnViewerLabelProvider is the mapping from the table based providers
 * to the ViewerLabelProvider.
 * 
 * @since 3.3
 * @see ITableLabelProvider
 * @see ITableColorProvider
 * @see ITableFontProvider
 * 
 */
class TableColumnViewerLabelProvider extends ViewerLabelProvider {

	/**
	 * Create a new instance of the receiver.
	 * 
	 * @param labelProvider
	 *            instance of a table based label provider
	 * @param columnIndex the index into the table for this column 
	 * @see ITableLabelProvider
	 * @see ITableColorProvider
	 * @see ITableFontProvider
	 */
	public TableColumnViewerLabelProvider(IBaseLabelProvider labelProvider,
			int columnIndex) {
		super(labelProvider);
		
		if (labelProvider instanceof ITableLabelProvider)
			setLabelProvider(labelProviderFor(
					(ITableLabelProvider) labelProvider, columnIndex));

		if (labelProvider instanceof ITableColorProvider)
			setColorProvider(colorProviderFor(
					(ITableColorProvider) labelProvider, columnIndex));
		
		if (labelProvider instanceof ITableFontProvider)
			setFontProvider(fontProviderFor(
					(ITableFontProvider) labelProvider, columnIndex));
	}

	/**
	 * Return the IFontProvider based on provider at columnIndex.
	 * @param provider
	 * @param columnIndex
	 * @return IFontProvider
	 */
	private IFontProvider fontProviderFor(final ITableFontProvider provider,final int columnIndex) {
		return new IFontProvider(){
			/* (non-Javadoc)
			 * @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
			 */
			public Font getFont(Object element) {
				return provider.getFont(element, columnIndex);
			}
		};
	}

	/**
	 * Return the ILabelProvider based on provider at columnIndex.
	 * @param provider
	 * @param columnIndex
	 * @return ILabelProvider
	 */
	private ILabelProvider labelProviderFor(final ITableLabelProvider provider, final int columnIndex) {
		return new LabelProvider(){
			/* (non-Javadoc)
			 * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
			 */
			public String getText(Object element) {
				return provider.getColumnText(element,columnIndex);
			}
			
			/* (non-Javadoc)
			 * @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
			 */
			public Image getImage(Object element) {
				return provider.getColumnImage(element,columnIndex);
			}
		};
	}

	/**
	 * Create an IColorProvider from the ITableColorProvider at columnIndex.
	 * 
	 * @param provider
	 * @param columnIndex
	 * @return IColorProvider
	 */
	private IColorProvider colorProviderFor(final ITableColorProvider provider,
			final int columnIndex) {
		return new IColorProvider() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
			 */
			public Color getBackground(Object element) {
				return provider.getBackground(element, columnIndex);
			}

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

}




/*******************************************************************************
 * 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/ColumnViewerPart.java (+110 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.jface.util.Policy;
15	import org.eclipse.swt.widgets.TableItem;
16	import org.eclipse.swt.widgets.TreeItem;
17
18	/**
19	* The ColumnViewerPart is abstract implementation of the
20	* column parts.
21	* @since 3.3
22	*
23	*/
24	public class ColumnViewerPart {
25
26	private int index;
27	private ViewerLabelProvider labelProvider;
28	static String COLUMN_VIEWER_KEY = Policy.JFACE + ".columnViewer";//$NON-NLS-1$
29
30	/**
31	* Create a new instance of the receiver at columnIndex.
32	* @param provider
33	* @param columnIndex
34	*/
35	public ColumnViewerPart(ViewerLabelProvider provider, int columnIndex) {
36	index = columnIndex;
37	labelProvider = provider;
38	}
39
40	/**
41	* Return the column index for the receiver
42	* @return int
43	*/
44	public int getIndex() {
45	return index;
46	}
47	/**
48	* Return the label provider for the receiver.
49	* @return ViewerLabelProvider
50	*/
51	public ViewerLabelProvider getLabelProvider() {
52	return labelProvider;
53	}
54
55	/**
56	* Refresh the TreeItem for element.
57	* @param item
58	* @param element
59	*/
60	public void refresh(TreeItem item, Object element) {
61
62	ViewerLabel label = new ViewerLabel(item.getText(getIndex()), item
63	.getImage(getIndex()));
64	getLabelProvider().updateLabel(label, element);
65
66	if (label.hasNewBackground())
67	item.setBackground(getIndex(), label.getBackground());
68
69	if (label.hasNewForeground())
70	item.setForeground(getIndex(), label.getForeground());
71
72	if (label.hasNewFont())
73	item.setFont(getIndex(), label.getFont());
74
75	if (label.hasNewText())
76	item.setText(getIndex(), label.getText());
77
78	if (label.hasNewImage())
79	item.setImage(getIndex(), label.getImage());
80
81	}
82
83	/**
84	* Refresh the TableItem for element.
85	* @param item
86	* @param element
87	*/
88	public void refresh(TableItem item, Object element) {
89
90	ViewerLabel label = new ViewerLabel(item.getText(getIndex()), item
91	.getImage(getIndex()));
92	getLabelProvider().updateLabel(label, element);
93
94	if (label.hasNewBackground())
95	item.setBackground(getIndex(), label.getBackground());
96
97	if (label.hasNewForeground())
98	item.setForeground(getIndex(), label.getForeground());
99
100	if (label.hasNewFont())
101	item.setFont(getIndex(), label.getFont());
102
103	if (label.hasNewText())
104	item.setText(getIndex(), label.getText());
105
106	if (label.hasNewImage())
107	item.setImage(getIndex(), label.getImage());
108
109	}
110	}

Added Link Here

(-)src/org/eclipse/jface/viewers/ViewerLabelProvider.java (+220 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	* Create a new instance of the receiver.
67	*/
68	public ViewerLabelProvider() {
69	super();
70	}
71
72	/**
73	* Create a new instance of the receiver based on labelProvider.
74	*
75	* @param labelProvider
76	*/
77	public ViewerLabelProvider(IBaseLabelProvider labelProvider) {
78	super();
79	setProviders(labelProvider);
80	}
81
82	/**
83	* Create a ViewerLabelProvider for the column at index
84	*
85	* @param columnIndex
86	* @param labelProvider The labelProvider to convert
87	* @return ViewerLabelProvider
88	*/
89	static ViewerLabelProvider createViewerLabelProvider(int columnIndex,
90	IBaseLabelProvider labelProvider) {
91
92	if (labelProvider instanceof ITableLabelProvider
93	\|\| labelProvider instanceof ITableColorProvider
94	\|\| labelProvider instanceof ITableFontProvider)
95	return new TableColumnViewerLabelProvider(labelProvider,
96	columnIndex);
97	return new ViewerLabelProvider(labelProvider);
98
99	}
100
101	/*
102	* (non-Javadoc)
103	*
104	* @see org.eclipse.jface.viewers.IViewerLabelProvider#updateLabel(org.eclipse.jface.viewers.ViewerLabel,
105	* java.lang.Object)
106	*/
107	public void updateLabel(ViewerLabel label, Object element) {
108	label.setText(labelProvider.getText(element));
109	label.setImage(labelProvider.getImage(element));
110
111	if (colorProvider != null) {
112	label.setBackground(colorProvider.getBackground(element));
113	label.setForeground(colorProvider.getForeground(element));
114	}
115
116	if (fontProvider != null) {
117	label.setFont(fontProvider.getFont(element));
118	}
119
120	}
121
122	/**
123	* Set the colorProvider to use for the receiver.
124	*
125	* @param colorProvider
126	* The colorProvider to set.
127	*/
128	public void setColorProvider(IColorProvider colorProvider) {
129	this.colorProvider = colorProvider;
130	}
131
132	/**
133	* Set the fontProvider to fontProvider.
134	*
135	* @param fontProvider
136	* The fontProvider to set.
137	*/
138	public void setFontProvider(IFontProvider fontProvider) {
139	this.fontProvider = fontProvider;
140	}
141
142	/**
143	* Set the labelProvider to be provider.
144	*
145	* @param provider
146	* ILabelProvider provider to set.
147	*/
148	public void setLabelProvider(ILabelProvider provider) {
149	this.labelProvider = provider;
150	}
151
152	/**
153	* Set the any providers for the receiver that can be adapted from provider.
154	*
155	* @param provider
156	*/
157	public void setProviders(Object provider) {
158	if (provider instanceof ILabelProvider)
159	labelProvider = (ILabelProvider) provider;
160	if (provider instanceof IColorProvider)
161	colorProvider = (IColorProvider) provider;
162	if (provider instanceof IFontProvider)
163	fontProvider = (IFontProvider) provider;
164
165	}
166
167	/*
168	* (non-Javadoc)
169	*
170	* @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
171	*/
172	public Font getFont(Object element) {
173	return fontProvider.getFont(element);
174
175	}
176
177	/*
178	* (non-Javadoc)
179	*
180	* @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
181	*/
182	public Color getBackground(Object element) {
183	return colorProvider.getBackground(element);
184	}
185
186	/*
187	* (non-Javadoc)
188	*
189	* @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
190	*/
191	public Color getForeground(Object element) {
192	return colorProvider.getForeground(element);
193	}
194
195	/**
196	* Get the IColorProvider for the receiver.
197	*
198	* @return IColorProvider
199	*/
200	public IColorProvider getColorProvider() {
201	return colorProvider;
202	}
203
204	/**
205	* Get the IFontProvider for the receiver.
206	*
207	* @return IFontProvider
208	*/
209	public IFontProvider getFontProvider() {
210	return fontProvider;
211	}
212
213	/**
214	* @return Returns the labelProvider.
215	*/
216	public ILabelProvider getLabelProvider() {
217	return labelProvider;
218	}
219
220	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TableColumnViewerLabelProvider.java (+128 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	import org.eclipse.swt.graphics.Image;
17
18	/**
19	* TableColumnViewerLabelProvider is the mapping from the table based providers
20	* to the ViewerLabelProvider.
21	*
22	* @since 3.3
23	* @see ITableLabelProvider
24	* @see ITableColorProvider
25	* @see ITableFontProvider
26	*
27	*/
28	class TableColumnViewerLabelProvider extends ViewerLabelProvider {
29
30	/**
31	* Create a new instance of the receiver.
32	*
33	* @param labelProvider
34	* instance of a table based label provider
35	* @param columnIndex the index into the table for this column
36	* @see ITableLabelProvider
37	* @see ITableColorProvider
38	* @see ITableFontProvider
39	*/
40	public TableColumnViewerLabelProvider(IBaseLabelProvider labelProvider,
41	int columnIndex) {
42	super(labelProvider);
43
44	if (labelProvider instanceof ITableLabelProvider)
45	setLabelProvider(labelProviderFor(
46	(ITableLabelProvider) labelProvider, columnIndex));
47
48	if (labelProvider instanceof ITableColorProvider)
49	setColorProvider(colorProviderFor(
50	(ITableColorProvider) labelProvider, columnIndex));
51
52	if (labelProvider instanceof ITableFontProvider)
53	setFontProvider(fontProviderFor(
54	(ITableFontProvider) labelProvider, columnIndex));
55	}
56
57	/**
58	* Return the IFontProvider based on provider at columnIndex.
59	* @param provider
60	* @param columnIndex
61	* @return IFontProvider
62	*/
63	private IFontProvider fontProviderFor(final ITableFontProvider provider,final int columnIndex) {
64	return new IFontProvider(){
65	/* (non-Javadoc)
66	* @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
67	*/
68	public Font getFont(Object element) {
69	return provider.getFont(element, columnIndex);
70	}
71	};
72	}
73
74	/**
75	* Return the ILabelProvider based on provider at columnIndex.
76	* @param provider
77	* @param columnIndex
78	* @return ILabelProvider
79	*/
80	private ILabelProvider labelProviderFor(final ITableLabelProvider provider, final int columnIndex) {
81	return new LabelProvider(){
82	/* (non-Javadoc)
83	* @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
84	*/
85	public String getText(Object element) {
86	return provider.getColumnText(element,columnIndex);
87	}
88
89	/* (non-Javadoc)
90	* @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
91	*/
92	public Image getImage(Object element) {
93	return provider.getColumnImage(element,columnIndex);
94	}
95	};
96	}
97
98	/**
99	* Create an IColorProvider from the ITableColorProvider at columnIndex.
100	*
101	* @param provider
102	* @param columnIndex
103	* @return IColorProvider
104	*/
105	private IColorProvider colorProviderFor(final ITableColorProvider provider,
106	final int columnIndex) {
107	return new IColorProvider() {
108	/*
109	* (non-Javadoc)
110	*
111	* @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
112	*/
113	public Color getBackground(Object element) {
114	return provider.getBackground(element, columnIndex);
115	}
116
117	/*
118	* (non-Javadoc)
119	*
120	* @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
121	*/
122	public Color getForeground(Object element) {
123	return provider.getForeground(element, columnIndex);
124	}
125	};
126	}
127
128	}

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	}