Attachment #47453 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.HashSet;
import java.util.List;

import org.eclipse.jface.internal.viewers.RowPart;
import org.eclipse.jface.util.Assert;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

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;


/**
 * A concrete viewer based on a SWT <code>Table</code> control.
 * <p>

 * @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(createNewRowPart(null, SWT.NONE, index).getItem(), 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( getRowPartFromItem(item),column);
				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);
				}

			}

		}
	}

	protected Widget getColumnViewerOwner(int columnIndex) {
		if( columnIndex < 0 || columnIndex > getTable().getColumnCount() ) {
			return null;
		}
		
		if (getTable().getColumnCount() == 0)// Hang it off the table if it
			return getTable();
		
		
		return getTable().getColumn(columnIndex);
	}
	
	/**
	 * 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.

	}

	/*
	 * (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);
	}
	
	protected RowPart getRowPartFromItem(Widget item) {
		RowPart part = (RowPart)item.getData(RowPart.ROWPART_KEY);
		
		if( part == null ) {
			part = new TableRowPart(((TableItem)item));
			part.associate();
		}
		
		return part;
	}
		
	protected RowPart createNewRowPart(RowPart parent, int style, int rowIndex) {
		TableItem item;
		
		if( rowIndex >= 0 ) {
			item = new TableItem(table,SWT.NONE,rowIndex);
		} else {
			item = new TableItem(table,SWT.NONE);
		}
		
		return getRowPartFromItem(item);
	}
	
	public Item getItem(int x, int y) {
		return table.getItem(new Point(x,y));
	}
	
	protected ColumnViewerPart createColumnViewer(Widget columnOwner, ViewerLabelProvider labelProvider) {
		if( columnOwner instanceof TableColumn ) {
			return new TableColumnViewerPart((TableColumn)columnOwner,labelProvider);
		}
		
		return super.createColumnViewer(columnOwner, labelProvider);
	}
}





import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.internal.viewers.RowPart;
import org.eclipse.jface.util.Assert;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TreeEditor;

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(getRowPartFromItem(treeItem),column);
		
		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);
							}
						}

						// As it is possible for user code to run the event
						// loop check here.
						if (treeItem.isDisposed()) {
							unmapElement(element, treeItem);
							return;
						}

	}
						image = updateLabel.getImage();
					}
				} else {
					text = tprov.getColumnText(element, column);
					image = tprov.getColumnImage(element, column);
				}

	protected Widget getColumnViewerOwner(int columnIndex) {
		if( columnIndex < 0 || columnIndex > getTree().getColumnCount() ) {
			return null;
				}
				treeItem.setText(column, text);
				if (treeItem.getImage(column) != image) {
					treeItem.setImage(column, image);
				}
			}
			getColorAndFontCollector().applyFontsAndColors(treeItem);
		}
		
		if (getTree().getColumnCount() == 0)// Hang it off the table if it
			return getTree();
		
		return getTree().getColumn(columnIndex);
	}

	/**
	 * 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 Item newItem(Widget parent, int flags, int ix) {
		TreeItem item;
		
		if (parent instanceof TreeItem) {
			item = (TreeItem)createNewRowPart(getRowPartFromItem(parent),flags, ix).getItem();
			} else {
				item = new TreeItem((Tree) parent, flags, ix);
			}
		} else {
			item = (TreeItem)createNewRowPart(null,flags, ix).getItem();
				item = new TreeItem((TreeItem) parent, flags);
			} else {
				item = new TreeItem((Tree) parent, flags);
			}
		}
		
		return item;
	}


	 */
	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++) {
					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);
						}
					}
				}
			});
		}
	}
	
	protected RowPart getRowPartFromItem(Widget item) {
		RowPart part = (RowPart)item.getData(RowPart.ROWPART_KEY);
		
		if( part == null ) {
			part = new TreeRowPart(((TreeItem)item));
			part.associate();
		}
		
		return part;
	}
		
	protected RowPart createNewRowPart(RowPart parent, int style, int rowIndex) {
		if( parent == null ) {
			if( rowIndex >= 0 ) {
				return getRowPartFromItem(new TreeItem(tree,style,rowIndex));
			}
			return getRowPartFromItem(new TreeItem(tree,style));
		}
		
		if( rowIndex >= 0 ) {
			return getRowPartFromItem(new TreeItem((TreeItem)parent.getItem(),SWT.NONE,rowIndex));
		}
		
		return getRowPartFromItem(new TreeItem((TreeItem)parent.getItem(),SWT.NONE));
	}
	
	protected ColumnViewerPart createColumnViewer(Widget columnOwner, ViewerLabelProvider labelProvider) {
		if( columnOwner instanceof TreeColumn ) {
			return new TreeColumnViewerPart((TreeColumn)columnOwner,labelProvider);
		}
		
		return super.createColumnViewer(columnOwner, labelProvider);
	}
}




import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Tree;

/**
 * Internal tree viewer implementation.

    }

    private void activateCellEditor() {
    	ColumnViewerPart part = (ColumnViewerPart)((Tree)viewer.getControl()).getColumn(columnNumber).getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
    	Object element = treeItem.getData();
    	
    	if( part != null && part.getEditingSupport() != null && part.getEditingSupport().canEdit(element) ) {
    		cellEditor = part.getEditingSupport().getCellEditor(element);
    		cellEditor.addListener(cellEditorListener);
            Object value = part.getEditingSupport().getValue(element);
            cellEditor.setValue(value);
            // Tricky flow of control here:
            // activate() can trigger callback to cellEditorListener which will clear cellEditor
            // so must get control first, but must still call activate() even if there is no control.
            final Control control = cellEditor.getControl();
            cellEditor.activate();
            if (control == null) {
				return;
			}
            setLayoutData(cellEditor.getLayoutData());
            setEditor(control, treeItem, columnNumber);
            cellEditor.setFocus();
            if (focusListener == null) {
                focusListener = new FocusAdapter() {
                    public void focusLost(FocusEvent e) {
                        applyEditorValue();
                            public void focusLost(FocusEvent e) {
                                applyEditorValue();
                            }
                        };
                    }
                };
                    mouseListener = new MouseAdapter() {
                        public void mouseDown(MouseEvent e) {
                            // time wrap?	
                            // check for expiration of doubleClickTime
                            if (e.time <= doubleClickExpirationTime) {
                                control.removeMouseListener(mouseListener);
                                cancelEditing();
                                handleDoubleClickEvent();
                            } else if (mouseListener != null) {
                                control.removeMouseListener(mouseListener);
                            }
                        }
                    };
                    control.addMouseListener(mouseListener);
                }
            }
            control.addFocusListener(focusListener);
            mouseListener = new MouseAdapter() {
                public void mouseDown(MouseEvent e) {
                    // time wrap?	
                    // check for expiration of doubleClickTime
                    if (e.time <= doubleClickExpirationTime) {
                        control.removeMouseListener(mouseListener);
                        cancelEditing();
                        handleDoubleClickEvent();
                    } else if (mouseListener != null) {
                        control.removeMouseListener(mouseListener);
                    }
                }
            };
            control.addMouseListener(mouseListener);
    	}
    }

    /**

     * by delegating to the cell modifier.
     */
    private void saveEditorValue(CellEditor cellEditor, Item treeItem) {
    	ColumnViewerPart part = (ColumnViewerPart)treeItem.getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
    	
    	if( part != null && part.getEditingSupport() != null ) {
        	part.getEditingSupport().setValue(treeItem.getData(), cellEditor.getValue());
				property = columnProperties[columnNumber];
			}
            cellModifier.modify(treeItem, property, cellEditor.getValue());
        }
    }





 * The decorator decorates the label text, image, font and colors provided by 
 * the nested label provider.
 */
public class DecoratingLabelProvider extends TreeColumnViewerLabelProvider  {
        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);




import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Table;

/**
 * Internal table viewer implementation.

    }

    private void activateCellEditor() {
    	ColumnViewerPart part = (ColumnViewerPart)((Table)viewer.getControl()).getColumn(columnNumber).getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
    	Object element = tableItem.getData();
    	
    	if( part != null && part.getEditingSupport() != null && part.getEditingSupport().canEdit(element) ) {
    		cellEditor = part.getEditingSupport().getCellEditor(element);
    		cellEditor.addListener(cellEditorListener);
            Object value = part.getEditingSupport().getValue(element);
            cellEditor.setValue(value);
            // Tricky flow of control here:
            // activate() can trigger callback to cellEditorListener which will clear cellEditor
            // so must get control first, but must still call activate() even if there is no control.
            final Control control = cellEditor.getControl();
            cellEditor.activate();
            if (control == null) {
				return;
			}
            setLayoutData(cellEditor.getLayoutData());
            setEditor(control, tableItem, columnNumber);
            cellEditor.setFocus();
            if (focusListener == null) {
                focusListener = new FocusAdapter() {
                    public void focusLost(FocusEvent e) {
                        applyEditorValue();
                            public void focusLost(FocusEvent e) {
                                applyEditorValue();
                            }
                        };
                    }
                };
                    mouseListener = new MouseAdapter() {
                        public void mouseDown(MouseEvent e) {
                            // time wrap?	
                            // check for expiration of doubleClickTime
                            if (e.time <= doubleClickExpirationTime) {
                                control.removeMouseListener(mouseListener);
                                cancelEditing();
                                handleDoubleClickEvent();
                            } else if (mouseListener != null) {
                                control.removeMouseListener(mouseListener);
                            }
                        }
                    };
                    control.addMouseListener(mouseListener);
                }
            }
            control.addFocusListener(focusListener);
            mouseListener = new MouseAdapter() {
                public void mouseDown(MouseEvent e) {
                    // time wrap?	
                    // check for expiration of doubleClickTime
                    if (e.time <= doubleClickExpirationTime) {
                        control.removeMouseListener(mouseListener);
                        cancelEditing();
                        handleDoubleClickEvent();
                    } else if (mouseListener != null) {
                        control.removeMouseListener(mouseListener);
                    }
                }
            };
            control.addMouseListener(mouseListener);
    	}    	
    }

    /**


    abstract Rectangle getBounds(Item item, int columnNumber);

/**
     * Return the array of CellEditors used in the viewer
     * @return the cell editors
     */


    abstract int getColumnCount();

	/**
     * Return the properties for the column
     * @return the array of column properties
     */
    public Object[] getColumnProperties() {
        return columnProperties;
    }
    
    abstract Item[] getSelection();

    /**

     * by delegating to the cell modifier.
     */
    private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
    	ColumnViewerPart part = (ColumnViewerPart)tableItem.getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
    	
        if( part != null && part.getEditingSupport() != null ) {
        	part.getEditingSupport().setValue(tableItem.getData(), cellEditor.getValue());
        }        
            if (columnProperties != null
                    && columnNumber < columnProperties.length) {
				property = columnProperties[columnNumber];
			}
            cellModifier.modify(tableItem, property, cellEditor.getValue());
        }
    }

    /**

    public void setColumnProperties(String[] columnProperties) {
        this.columnProperties = columnProperties;
    }
    
    abstract void setEditor(Control w, Item item, int fColumnNumber);

    abstract void setLayoutData(CellEditor.LayoutData layoutData);

Lines 13-18 Link Here

(-)src/org/eclipse/jface/viewers/ViewerLabel.java (+93 lines)
13	import org.eclipse.swt.graphics.Color;	13	import org.eclipse.swt.graphics.Color;
14	import org.eclipse.swt.graphics.Font;	14	import org.eclipse.swt.graphics.Font;
15	import org.eclipse.swt.graphics.Image;	15	import org.eclipse.swt.graphics.Image;
		16	import org.eclipse.swt.graphics.Point;
16		17
17	/**	18	/**
18	* The ViewerLabel is the class that is passed to a viewer to handle updates of	19	* The ViewerLabel is the class that is passed to a viewer to handle updates of
Lines 43-48 Link Here
43	private Image startImage;	44	private Image startImage;
44		45
45	private boolean hasPendingDecorations;	46	private boolean hasPendingDecorations;
		47
		48	private String tooltipText;
		49
		50	private Color tooltipForegroundColor;
		51
		52	private Color tooltipBackgroundColor;
		53
		54	private Point tooltipShift;
46		55
47	/**	56	/**
48	* Create a new instance of the receiver with the supplied	57	* Create a new instance of the receiver with the supplied
Lines 241-244 Link Here
241	/* public */ boolean hasPendingDecorations() {	250	/* public */ boolean hasPendingDecorations() {
242	return hasPendingDecorations;	251	return hasPendingDecorations;
243	}	252	}
		253
		254	/**
		255	* @return Returns the tooltipText.
		256	*/
		257	public String getTooltipText() {
		258	return tooltipText;
		259	}
		260
		261	/**
		262	* @param tooltipText The tooltipText to set.
		263	*/
		264	public void setTooltipText(String tooltipText) {
		265	this.tooltipText = tooltipText;
		266	}
		267
		268	/**
		269	* @return Return whether or not the tooltip text has been set.
		270	*/
		271	public boolean hasNewTooltipText() {
		272	return this.tooltipText != null;
		273	}
		274
		275	/**
		276	* @return Returns the tooltipBackgroundColor.
		277	*/
		278	public Color getTooltipBackgroundColor() {
		279	return tooltipBackgroundColor;
		280	}
		281
		282	/**
		283	* @param tooltipBackgroundColor The tooltipBackgroundColor to set.
		284	*/
		285	public void setTooltipBackgroundColor(Color tooltipBackgroundColor) {
		286	this.tooltipBackgroundColor = tooltipBackgroundColor;
		287	}
		288
		289	/**
		290	* @return Return whether or not the tooltip background color has been set.
		291	*/
		292	public boolean hasNewTooltipBackgroundColor() {
		293	return tooltipBackgroundColor != null;
		294	}
		295
		296	/**
		297	* @return Returns the tooltipForegroundColor.
		298	*/
		299	public Color getTooltipForegroundColor() {
		300	return tooltipForegroundColor;
		301	}
		302
		303	/**
		304	* @param tooltipForegroundColor The tooltipForegroundColor to set.
		305	*/
		306	public void setTooltipForegroundColor(Color tooltipForegroundColor) {
		307	this.tooltipForegroundColor = tooltipForegroundColor;
		308	}
		309
		310	/**
		311	* @return Return whether or not the tooltip foreground color has been set.
		312	*/
		313	public boolean hasNewTooltipForegroundColor() {
		314	return tooltipForegroundColor != null;
		315	}
		316
317	/**
318	* @return Returns the tooltipShift.
319	*/
320	public Point getTooltipShift() {
321	return tooltipShift;
322	}
323
324	/**
325	* @param tooltipShift The tooltipShift to set.
326	*/
327	public void setTooltipShift(Point tooltipShift) {
328	this.tooltipShift = tooltipShift;
329	}
330
331	/**
332	* @return Return whether or not the tooltip shift has been set.
333	*/
334	public boolean hasTooltipShift() {
335	return this.tooltipShift != null;
336	}
244	}	337	}

Lines 16-21 Link Here

(-)src/org/eclipse/jface/viewers/StructuredViewer.java (+114 lines)
16	import java.util.List;	16	import java.util.List;
17		17
18	import org.eclipse.core.runtime.ListenerList;	18	import org.eclipse.core.runtime.ListenerList;
		19	import org.eclipse.jface.internal.viewers.RowPart;
19	import org.eclipse.jface.util.Assert;	20	import org.eclipse.jface.util.Assert;
20	import org.eclipse.jface.util.IOpenEventListener;	21	import org.eclipse.jface.util.IOpenEventListener;
21	import org.eclipse.jface.util.OpenStrategy;	22	import org.eclipse.jface.util.OpenStrategy;
Lines 31-36 Link Here
31	import org.eclipse.swt.events.SelectionListener;	32	import org.eclipse.swt.events.SelectionListener;
32	import org.eclipse.swt.graphics.Color;	33	import org.eclipse.swt.graphics.Color;
33	import org.eclipse.swt.graphics.Font;	34	import org.eclipse.swt.graphics.Font;
		35	import org.eclipse.swt.graphics.Point;
34	import org.eclipse.swt.widgets.Control;	36	import org.eclipse.swt.widgets.Control;
35	import org.eclipse.swt.widgets.Item;	37	import org.eclipse.swt.widgets.Item;
36	import org.eclipse.swt.widgets.TableItem;	38	import org.eclipse.swt.widgets.TableItem;
Lines 131-136 Link Here
131	*/	133	*/
132	private static Widget[] NO_WIDGETS = new Widget[0];	134	private static Widget[] NO_WIDGETS = new Widget[0];
133		135
		136	private TooltipSupport tooltipSupport;
		137
134	/**	138	/**
135	* The ColorAndFontCollector is a helper class for viewers	139	* The ColorAndFontCollector is a helper class for viewers
136	* that have color and font support ad optionally decorators.	140	* that have color and font support ad optionally decorators.
Lines 472-477 Link Here
472	*/	476	*/
473	protected StructuredViewer() {	477	protected StructuredViewer() {
474	// do nothing	478	// do nothing
		479	tooltipSupport = new TooltipSupport(this);
475	}	480	}
476		481
477	/**	482	/**
Lines 2112-2115 Link Here
2112	return colorAndFontCollector;	2117	return colorAndFontCollector;
2113	}	2118	}
2114		2119
		2120	/**
		2121	* Get the cell at this point.
		2122	* <p><i>Subclasses should overwrite this method and provide a meaningful implementation</i></p>
		2123	* @param point the point in the viewer where you need to corresponding cell from
		2124	* @param onlyInSelection search only in selection
		2125	* @return the cell or if no cell is found at this point
		2126	*/
		2127	Cell getCell(Point point) {
		2128	RowPart row = getRowPart(point);
		2129	if( row != null ) {
		2130	return row.getCell(point);
		2131	}
		2132
		2133	return null;
		2134	}
		2135
		2136	protected RowPart getRowPart(Point point) {
		2137	Item item = getItem(point.x, point.y);
		2138
		2139	if( item != null ) {
		2140	return getRowPartFromItem(item);
		2141	}
		2142
		2143	return null;
		2144	}
		2145
		2146	protected RowPart getRowPartFromItem(Widget item) {
		2147	return (RowPart)item.getData(RowPart.ROWPART_KEY);
		2148	}
		2149
		2150	protected RowPart createNewRowPart(RowPart parent, int style, int rowIndex) {
		2151	return null;
		2152	}
		2153
		2154	protected Widget getColumnViewerOwner(int columnIndex) {
		2155	return null;
		2156	}
		2157
		2158	public ICellModifier getCellModifier() {
		2159	return null;
		2160	}
		2161
		2162	public CellEditor[] getCellEditors() {
		2163	return null;
		2164	}
		2165
		2166	public Object[] getColumnProperties() {
		2167	return null;
		2168	}
		2169
		2170	/**
		2171	* Return the TableColumnViewer at columnIndex
		2172	*
		2173	* @param columnIndex
		2174	* @return TableColumnViewer
		2175	*/
		2176	public ColumnViewerPart getColumnViewer(final int columnIndex) {
		2177
		2178	ColumnViewerPart viewer;
		2179	Widget columnOwner = getColumnViewerOwner(columnIndex);
		2180
		2181	if( columnOwner == null ) {
		2182	return null;
		2183	}
2184
2185	viewer = (ColumnViewerPart)columnOwner.getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
2186
2187	if (viewer == null) {
2188	createColumnViewer(columnOwner, ViewerLabelProvider.createViewerLabelProvider(getLabelProvider()));
2189	if( getCellModifier() != null ) {
2190	viewer.setEditingSupport(new IEditingSupport() {
2191
2192	public boolean canEdit(Object element) {
2193	return getCellModifier().canModify(element, (String)getColumnProperties()[columnIndex]);
2194	}
2195
2196	public CellEditor getCellEditor(Object element) {
2197	return getCellEditors()[columnIndex];
2198	}
2199
2200	public Object getValue(Object element) {
2201	return getCellModifier().getValue(element, (String)getColumnProperties()[columnIndex]);
2202	}
2203
2204	public void setValue(Object element, Object value) {
2205	getCellModifier().modify( findItem(element), (String)getColumnProperties()[columnIndex], value);
2206	}
2207	});
2208	}
2209	}
2210
2211	// Reset the colum-index because maybe it changed from the last time
2212	viewer.getLabelProvider().setColumnIndex(columnIndex);
2213
2214	return viewer;
2215	}
2216
2217	protected ColumnViewerPart createColumnViewer(Widget columnOwner, ViewerLabelProvider labelProvider) {
2218	return new ColumnViewerPart(columnOwner,
2219	ViewerLabelProvider.createViewerLabelProvider(getLabelProvider()));
2220	}
2221
2222	public void activateCustomTooltips() {
2223	tooltipSupport.activate();
2224	}
2225
2226	public void deactivateCustomTooltips() {
2227	tooltipSupport.deactivate();
2228	}
2115	}	2229	}

Lines 20-25 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
20	org.eclipse.jface.fieldassist.images,	20	org.eclipse.jface.fieldassist.images,
21	org.eclipse.jface.images,	21	org.eclipse.jface.images,
22	org.eclipse.jface.internal.provisional.action;x-friends:="org.eclipse.ui.workbench",	22	org.eclipse.jface.internal.provisional.action;x-friends:="org.eclipse.ui.workbench",
		23	org.eclipse.jface.internal.viewers;x-internal:=true,
23	org.eclipse.jface.layout,	24	org.eclipse.jface.layout,
24	org.eclipse.jface.menus,	25	org.eclipse.jface.menus,
25	org.eclipse.jface.operation,	26	org.eclipse.jface.operation,




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

/**
 * @since 3.2
 * 
 */
public interface IEditingSupport {
	/**
	 * The editor to be shown
	 * 
	 * @param element
	 *            the model element
	 * @return the CellEditor
	 */
	public CellEditor getCellEditor(Object element);

	/**
	 * Is the cell editable
	 * 
	 * @param element
	 *            the model element
	 * @return true if editable
	 */
	public boolean canEdit(Object element);

	/**
	 * Get the value to set to the editor
	 * 
	 * @param element
	 *            the model element
	 * @return the value shown
	 */
	public Object getValue(Object element);

	/**
	 * Restore the value from the CellEditor
	 * 
	 * @param element
	 *            the model element
	 * @param value
	 *            the new value
	 */
	public void setValue(Object element, Object value);
}




/*******************************************************************************
 * 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.internal.viewers.RowPart;
import org.eclipse.jface.util.Policy;
import org.eclipse.swt.widgets.Widget;

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

	private ViewerLabelProvider labelProvider;

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

	private IEditingSupport editingSupport;

	/**
	 * Create a new instance of the receiver at columnIndex.
	 * 
	 * @param columnOwner
	 * @param provider
	 */
	public ColumnViewerPart(Widget columnOwner, ViewerLabelProvider provider) {
		labelProvider = provider;
		columnOwner.setData(ColumnViewerPart.COLUMN_VIEWER_KEY, this);
	}

	/**
	 * Return the label provider for the receiver.
	 * 
	 * @return ViewerLabelProvider
	 */
	public ViewerLabelProvider getLabelProvider() {
		return labelProvider;
	}

	/**
	 * @param labelProvider
	 *            the new label-provider
	 */
	public void setLabelProvider(ViewerLabelProvider labelProvider) {
		this.labelProvider = labelProvider;
	}

	/**
	 * @return Returns the editingSupport.
	 */
	public IEditingSupport getEditingSupport() {
		return editingSupport;
	}

	/**
	 * @param editingSupport
	 *            The editingSupport to set.
	 */
	public void setEditingSupport(IEditingSupport editingSupport) {
		this.editingSupport = editingSupport;
	}

	/**
	 * Refresh the row for the given columnIndex
	 * 
	 * @param row
	 * @param element
	 * @param columnIndex
	 */
	public void refresh(RowPart row, int columnIndex) {
		ViewerLabel label = new ViewerLabel(row.getText(columnIndex), row
				.getImage(columnIndex));
		getLabelProvider().updateLabel(label, row.getElement(), columnIndex);

		row.setBackground(columnIndex, label.getBackground());
		row.setForeground(columnIndex, label.getForeground());
		row.setFont(columnIndex, label.getFont());

		if (label.hasNewText())
			row.setText(columnIndex, label.getText());

		if (label.hasNewImage())
			row.setImage(columnIndex, label.getImage());
	}

	/**
	 * Refresh the TreeItem for element.
	 * 
	 * @param item
	 * @param element
	 * @param columnIndex
	 */
/*	public void refresh(TreeItem item, Object element, int columnIndex) {

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

		// We can not make a null check because then we could not
		// set the items back to default state
		item.setBackground(columnIndex, label.getBackground());
		item.setForeground(columnIndex, label.getForeground());
		item.setFont(columnIndex, label.getFont());

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

		if (label.hasNewImage())
			item.setImage(columnIndex, label.getImage());
	}
*/
	/**
	 * Refresh the TableItem for element.
	 * 
	 * @param item
	 * @param element
	 * @param columnIndex
	 */
/*	public void refresh(TableItem item, Object element, int columnIndex) {

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

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

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

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

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

		if (label.hasNewImage())
			item.setImage(columnIndex, 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;


/**
 * TreeViewerLabelProvider is the ViewerLabelProvider that handles
 * TreePaths.
 * @since 3.2
 *
 */
public class TreeColumnViewerLabelProvider 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;
	}

}




/*******************************************************************************
 * 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;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Widget;

/**
 * @since 3.2
 *
 */
public class TableRowPart extends DefaultRowPartImpl {
	private TableItem item;
	
	public TableRowPart(TableItem item) {
		this.item = item;
	}
	
	public Rectangle getBounds(int columnIndex) {
		return item.getBounds(columnIndex);
	}

	public Rectangle getBounds() {
		return item.getBounds();
	}

	public Widget getItem() {
		return item;
	}

	public int getColumnCount() {
		return item.getParent().getColumnCount();
	}

	public Color getBackground(int columnIndex) {
		return item.getBackground(columnIndex);
	}

	public Font getFont(int columnIndex) {
		return item.getFont(columnIndex);
	}

	public Color getForeground(int columnIndex) {
		return item.getForeground(columnIndex);
	}

	public Image getImage(int columnIndex) {
		return item.getImage(columnIndex);
	}

	public String getText(int columnIndex) {
		return item.getText(columnIndex);
	}

	public void setBackground(int columnIndex, Color color) {
		item.setBackground(columnIndex, color);
	}

	public void setFont(int columnIndex, Font font) {
		item.setFont(columnIndex, font);
	}

	public void setForeground(int columnIndex, Color color) {
		item.setForeground(columnIndex, color);
	}

	public void setImage(int columnIndex, Image image) {
		item.setImage(columnIndex,image);
	}

	public void setText(int columnIndex, String text) {
		item.setText(columnIndex, text);
	}

}




/*******************************************************************************
 * Copyright (c) 2006 BestSolution Systemhaus GmbH
 * 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:
 *     Tom Schind - tom.schindl@bestsolution.at
 *******************************************************************************/
package org.eclipse.jface.viewers;

import org.eclipse.swt.graphics.Image;

/**
 * 
 * @since 3.3
 * 
 */
public interface ITableTooltipLabelProvider {
	/**
	 * Returns the tooltip text for the given element and column index, or
	 * <code>null</code> if a custom tooltip should not be displayed.
	 * 
	 * @param element
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column index used
	 * @return the text to be displayed in the tooltip, or <code>null</code>
	 *         if a custom tooltip should not be displayed
	 */
	public String getTooltipText(Object element, int columnIndex);

	/**
	 * The image displayed in the tooltip
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column index used
	 * @return the image displayed if null no image is displayed
	 */
	public Image getTooltipImage(Object object, int 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;

import org.eclipse.jface.internal.viewers.ITooltipAddonsProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;

/**
 * @since 3.2
 * 
 */
public class ViewerLabelProvider extends LabelProvider implements
		ILabelProvider, IColorProvider, IFontProvider, ITooltipLabelProvider,
		ITooltipColorProvider, ITooltipFontProvider, ITooltipAddonsProvider {

	private static ILabelProvider defaultLabelProvider = new LabelProvider() {

	};

	private ILabelProvider labelProvider = defaultLabelProvider;

	private IColorProvider colorProvider;

	private IFontProvider fontProvider;

	private ITooltipLabelProvider tooltipLabelProvider;

	private ITooltipColorProvider tooltipColorProvider;

	private ITooltipFontProvider tooltipFontProvider;

	private ITooltipAddonsProvider tooltipAddonsProvider;
	
	private int columnIndex;

	/**
	 * 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(
			IBaseLabelProvider labelProvider) {

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

	}

	private 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));
		}
	}

	/**
	 * Updates the label for the given element and the given index
	 * 
	 * @param label
	 *            the label to update
	 * @param element
	 *            the element
	 * @param columnIndex
	 *            the column index
	 */
	public void updateLabel(ViewerLabel label, Object element, int columnIndex) {
		setColumnIndex(columnIndex);
		updateLabel(label, element);
	}

	/**
	 * @param columnIndex the column-index
	 */
	public void setColumnIndex(int columnIndex) {
		this.columnIndex = columnIndex;
	}
	
	/**
	 * @return Returns the column index
	 */
	public int getColumnIndex() {
		return columnIndex;
	}
	
	/**
	 * 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 tooltip provider
	 * 
	 * @param tooltipProvider
	 */
	public void setTooltipLabelProvider(ITooltipLabelProvider tooltipProvider) {
		this.tooltipLabelProvider = tooltipProvider;
	}

	/**
	 * Set the tooltip color provider
	 * 
	 * @param tooltipColorProvider
	 *            ITooltipColorProvider to set
	 */
	public void setTooltipColorProvider(
			ITooltipColorProvider tooltipColorProvider) {
		this.tooltipColorProvider = tooltipColorProvider;
	}

	/**
	 * Set tooltip font provider
	 * 
	 * @param tooltipFontProvider
	 *            ITooltipFontProvider to set
	 */
	public void setTooltipFontProvider(ITooltipFontProvider tooltipFontProvider) {
		this.tooltipFontProvider = tooltipFontProvider;
	}

	/**
	 * Set the tooltip addons provider
	 * 
	 * @param tooltipAddonsProvider
	 *            ITooltipAddonsProvider to set
	 */
	public void setTooltipAddonsProvider(
			ITooltipAddonsProvider tooltipAddonsProvider) {
		this.tooltipAddonsProvider = tooltipAddonsProvider;
	}

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

		if (provider instanceof ITooltipLabelProvider)
			tooltipLabelProvider = (ITooltipLabelProvider) provider;

		if (provider instanceof ITooltipColorProvider)
			tooltipColorProvider = (ITooltipColorProvider) provider;

		if (provider instanceof ITooltipFontProvider)
			tooltipFontProvider = (ITooltipFontProvider) provider;

		if (provider instanceof ITooltipAddonsProvider)
			tooltipAddonsProvider = (ITooltipAddonsProvider) provider;
	}

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

		return fontProvider.getFont(element);

	}

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

		return colorProvider.getBackground(element);
	}

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

		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;
	}

	/**
	 * @return Returns the tooltipColorProvider
	 */
	public ITooltipColorProvider getTooltipColorProvider() {
		return tooltipColorProvider;
	}
	
	/**
	 * @return Returns the tooltipAddonsProvider.
	 */
	public ITooltipAddonsProvider getTooltipAddonsProvider() {
		return tooltipAddonsProvider;
	}

	/**
	 * @return Returns the tooltipFontProvider.
	 */
	public ITooltipFontProvider getTooltipFontProvider() {
		return tooltipFontProvider;
	}

	/**
	 * @return Returns the tooltipLabelProvider.
	 */
	public ITooltipLabelProvider getTooltipLabelProvider() {
		return tooltipLabelProvider;
	}

	public Image getTooltipImage(Object object) {
		if (tooltipLabelProvider == null) {
			return null;
		}

		return tooltipLabelProvider.getTooltipImage(object);
	}

	public String getTooltipText(Object element) {
		if (tooltipLabelProvider == null) {
			return null;
		}

		return tooltipLabelProvider.getTooltipText(element);
	}

	public Color getTooltipBackgroundColor(Object object) {
		if (tooltipColorProvider == null) {
			return null;
		}

		return tooltipColorProvider.getTooltipBackgroundColor(object);
	}

	public Color getTooltipForegroundColor(Object object) {
		if (tooltipColorProvider == null) {
			return null;
		}

		return tooltipColorProvider.getTooltipForegroundColor(object);
	}

	public Font getTooltipFont(Object object) {
		if (tooltipFontProvider == null) {
			return null;
		}

		return tooltipFontProvider.getTooltipFont(object);
	}

	public int getTooltipDisplayDelayTime(Object object) {
		if (tooltipAddonsProvider == null) {
			return 0;
		}

		return tooltipAddonsProvider.getTooltipDisplayDelayTime(object);
	}

	public Point getTooltipShift(Object object) {
		if (tooltipAddonsProvider == null) {
			return null;
		}
		return tooltipAddonsProvider.getTooltipShift(object);
	}

	public int getTooltipTimeDisplayed(Object object) {
		if (tooltipAddonsProvider == null) {
			return 0;
		}
		return tooltipAddonsProvider.getTooltipTimeDisplayed(object);
	}

	public boolean useNativeTooltip(Object object) {
		if (tooltipAddonsProvider == null) {
			return false;
		}
		return tooltipAddonsProvider.useNativeTooltip(object);
	}

	public int getTooltipImageStyle(Object object) {
		if (tooltipAddonsProvider == null) {
			return SWT.SHADOW_NONE;
		}
		return tooltipAddonsProvider.getTooltipImageStyle(object);
	}
}




/*******************************************************************************
 * 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) {
		super(labelProvider);

		if (labelProvider instanceof ITableLabelProvider)
			setLabelProvider(labelProviderFor((ITableLabelProvider) labelProvider));

		if (labelProvider instanceof ITableColorProvider)
			setColorProvider(colorProviderFor((ITableColorProvider) labelProvider));

		if (labelProvider instanceof ITableFontProvider)
			setFontProvider(fontProviderFor((ITableFontProvider) labelProvider));

		if (labelProvider instanceof ITableTooltipLabelProvider)
			setTooltipLabelProvider(tooltipLabelFor((ITableTooltipLabelProvider) labelProvider));
		
		if(labelProvider instanceof ITableTooltipColorProvider)
			setTooltipColorProvider(tooltipColorFor((ITableTooltipColorProvider)labelProvider));
		
		if(labelProvider instanceof ITableTooltipFontProvider)
			setTooltipFontProvider(tooltipFontFor((ITableTooltipFontProvider)labelProvider));
	}

	private ITooltipFontProvider tooltipFontFor(final ITableTooltipFontProvider provider) {
		return new ITooltipFontProvider() {

			public Font getTooltipFont(Object object) {
				return provider.getTooltipFont(object, getColumnIndex());
			}
		};
	}
	
	private ITooltipColorProvider tooltipColorFor(final ITableTooltipColorProvider provider) {
		return new ITooltipColorProvider() {

			public Color getTooltipBackgroundColor(Object object) {
				return provider.getTooltipBackgroundColor(object, getColumnIndex());
			}

			public Color getTooltipForegroundColor(Object object) {
				return provider.getTooltipForegroundColor(object, getColumnIndex());
			}
		};
	}
	
	private ITooltipLabelProvider tooltipLabelFor(
			final ITableTooltipLabelProvider provider) {
		return new ITooltipLabelProvider() {

			public Image getTooltipImage(Object object) {
				return provider.getTooltipImage(object, getColumnIndex());
			}

			public String getTooltipText(Object element) {
				return provider.getTooltipText(element, getColumnIndex());
			}

		};
	}

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

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

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
			 */
			public Image getImage(Object element) {
				return provider.getColumnImage(element, getColumnIndex());
			}
		};
	}

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

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

}




/*******************************************************************************
 * 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.internal.viewers;

import org.eclipse.jface.util.Policy;
import org.eclipse.jface.viewers.Cell;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Widget;

/**
 * @since 3.2
 * 
 */
public abstract class RowPart {
	public static final String ROWPART_KEY = Policy.JFACE + ".ROWPART"; //$NON-NLS-1$
	
	public abstract Rectangle getBounds(int columnIndex);

	public abstract Rectangle getBounds();

	public abstract Widget getItem();

	public abstract int getColumnCount();
	
	public abstract Image getImage(int columnIndex);
	
	public abstract void setImage(int columnIndex,Image image);
	
	public abstract String getText(int columnIndex);
	
	public abstract void setText(int columnIndex,String text);
	
	public abstract Color getBackground(int columnIndex);
	
	public abstract void setBackground(int columnIndex, Color color);
	
	public abstract Color getForeground(int columnIndex);
	
	public abstract void setForeground(int columnIndex, Color color);
	
	public abstract Font getFont(int columnIndex);
	
	public abstract void setFont(int columnIndex,Font font);
	
	public Cell getCell(Point point) {
		int index = getColumIndex(point);
		
		if( index >= 0 ) {
			return new Cell(this,index);
		}

		return null;
	}
	
	public int getColumIndex(Point point) {
		int count = getColumnCount();
		
		for(int i = 0; i < count; i++ ) {
			if( getBounds(i).contains(point) ) {
				return i;
			}
		}
		
		return -1;
	}
	
	public Object getElement() {
		return getItem().getData();
	}
	
	public void associate() {
		getItem().setData(RowPart.ROWPART_KEY, this);
	}
}




/*******************************************************************************
 * 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.internal.viewers.RowPart;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Widget;

/**
 * @since 3.2
 *
 */
public class DefaultRowPartImpl extends RowPart {

	public Color getBackground(int columnIndex) {
		return null;
	}

	public Rectangle getBounds(int columnIndex) {
		return null;
	}

	public Rectangle getBounds() {
		return null;
	}

	public int getColumnCount() {
		return 0;
	}

	public Font getFont(int columnIndex) {
		return null;
	}

	public Color getForeground(int columnIndex) {
		return null;
	}

	public Image getImage(int columnIndex) {
		return null;
	}

	public Widget getItem() {
		return null;
	}

	public String getText(int columnIndex) {
		return null;
	}


	public void setBackground(int columnIndex, Color color) {
		
	}


	public void setFont(int columnIndex, Font font) {
		
	}

	public void setForeground(int columnIndex, Color color) {
		
	}

	public void setImage(int columnIndex, Image image) {
		
	}

	public void setText(int columnIndex, String text) {
		
	}
	
}




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

/**
 * @since 3.3
 * 
 */
public interface ITableTooltipColorProvider {
	/**
	 * The foreground color used to display the the text in the tooltip
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column index used
	 * @return the color used or <code>null</code> if you want to use the
	 *         default color {@link SWT#COLOR_INFO_FOREGROUND}
	 */
	public Color getTooltipForegroundColor(Object object, int columnIndex);

	/**
	 * The background color used for the tooltip
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column index used
	 * @return the color used or <code>null</code> if you want to use the
	 */
	public Color getTooltipBackgroundColor(Object object, int 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;

import java.util.Timer;

import org.eclipse.jface.internal.viewers.RowPart;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;

/**
 * @since 3.2
 *
 */
public class TooltipSupport {
	private StructuredViewer viewer;
	private Listener listener = new MouseListener();
	private static final int DEFAULT_SHIFT_X = 10;
	private static final int DEFAULT_SHIFT_Y = 0;
	
	TooltipSupport(StructuredViewer viewer) {
		this.viewer = viewer;
	}
	
	/**
	 * activate tooltip support for this viewer
	 */
	public void activate() {
		deactivate();
		viewer.getControl().addListener(SWT.Dispose, listener);
		viewer.getControl().addListener(SWT.MouseHover, listener);
		viewer.getControl().addListener(SWT.MouseMove, listener);
		viewer.getControl().addListener(SWT.MouseExit, listener);
		viewer.getControl().addListener(SWT.MouseDown, listener);
	}
	
	/**
	 * deactivate tooltip support for this viewer
	 */
	public void deactivate() {
		viewer.getControl().removeListener(SWT.Dispose, listener);
		viewer.getControl().removeListener(SWT.MouseHover, listener);
		viewer.getControl().removeListener(SWT.MouseMove, listener);
		viewer.getControl().removeListener(SWT.MouseExit, listener);
		viewer.getControl().removeListener(SWT.MouseDown, listener);
	}
	
	private class MouseListener implements Listener {
		private Shell tip;
		private TooltipHideListener hideListener = new TooltipHideListener();
		private Timer timer = new Timer();
		
		public void handleEvent(Event event) {
			switch (event.type) {
			case SWT.Dispose:
				if( timer != null ) {
					timer.cancel();
				}
			case SWT.KeyDown:
			case SWT.MouseMove:
			case SWT.MouseDown:
				disposeTooltip(tip);
				break;
			case SWT.MouseHover:
				Point p = new Point(event.x, event.y);
				RowPart row = viewer.getRowPart(p);
				viewer.getControl().setToolTipText(""); //$NON-NLS-1$

				if (row != null) {
					popupTooltip(row, p);
				}

				break;
			}
		}
		
		private void popupTooltip(RowPart row, Point p) {
			Object element = row.getElement();
			disposeTooltip(tip);

			ColumnViewerPart viewPart = viewer.getColumnViewer(row.getColumIndex(p));
			
			if( viewPart == null ) {
				return;
			}
			
			ViewerLabelProvider labelProvider = viewPart.getLabelProvider();
			
			String text = labelProvider.getTooltipText(element);
			
			if( text != null ) {
				
				if( labelProvider.useNativeTooltip(element) ) {
					viewer.getControl().setToolTipText(text);
					return;
				}
				
				tip = new Shell(viewer.getControl().getShell(), SWT.ON_TOP | SWT.TOOL);
				tip.setLayout(new FillLayout());
				CLabel label = new CLabel(tip, labelProvider.getTooltipImageStyle(element));
				label.setText(text);
				label.addListener(SWT.MouseExit, hideListener);
				label.addListener(SWT.MouseDown, hideListener);
				
				Image img =  labelProvider.getTooltipImage(element);
				
				if( img != null) {
					label.setImage(img);
				}
				
				Color color = labelProvider.getTooltipForegroundColor(element);
				if( color == null ) {
					color = viewer.getControl().getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND);
				}
				label.setForeground(color);
				
				color = labelProvider.getTooltipBackgroundColor(element);
				if( color == null ) {
					color = viewer.getControl().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND);
				}
				label.setBackground(color);
				
				Font font = labelProvider.getTooltipFont(element);
				
				if( font != null ) {
					label.setFont(font);
				}
				
				Point pt = viewer.getControl().toDisplay(p);
				Point shift = labelProvider.getTooltipShift(element);
				
				if( shift == null ) {
					pt.x += DEFAULT_SHIFT_X;
					pt.y += DEFAULT_SHIFT_Y;
				} else {
					pt.x += shift.x;
					pt.y += shift.y;
				}
				
				tip.pack();
				tip.setLocation(pt);
				tip.setVisible(true);
			}
		}
		
		private void disposeTooltip(Shell tip) {
			if (tip != null && !tip.isDisposed()) {
				tip.dispose();
			}

			tip = null;
		}
	}
	
	private class TooltipHideListener implements Listener {
		public void handleEvent(Event event) {
			CLabel label = (CLabel) event.widget;
			Shell shell = label.getShell();
			switch (event.type) {
			case SWT.MouseDown:
				viewer.setSelection(new StructuredSelection());
				// fall through
			case SWT.MouseExit:
				viewer.getControl().setFocus();
				shell.dispose();
				break;
			}
		}
	}
}




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

/**
 * @since 3.3
 *
 */
public interface ITooltipFontProvider {
	/**
	 * The font used to display the tooltip
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @return the font if null default font is used
	 */
	public Font getTooltipFont(Object object);
}




/*******************************************************************************
 * 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.internal.viewers;

import org.eclipse.swt.graphics.Point;

/**
 * @since 3.2
 * 
 */
public interface ITableTooltipAddonsProvider {
	/**
	 * This is the amount the used to control how much the tooltip is shifted
	 * from the current mouse position
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column-index
	 * @return shift of the tooltip
	 */
	public Point getTooltipShift(Object object, int columnIndex);

	/**
	 * If you want your tooltip to be using the native Tooltip you can force
	 * this by returning true from this method. If native tooltips are used only
	 * the text-value is used all other feature are of custom tooltips are not
	 * supported.
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column-index
	 * @return true if native tooltips should be used
	 */
	public boolean useNativeTooltip(Object object, int columnIndex);

	/**
	 * The time in milliseconds after the tooltip is hidden
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column-index
	 * @return milliseconds
	 */
	public int getTooltipTimeDisplayed(Object object, int columnIndex);

	/**
	 * The time in milliseconds until the tooltip pops up
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column-index
	 * @return milliseconds
	 */
	public int getTooltipDisplayDelayTime(Object object, int columnIndex);

	/**
	 * The style used to create the label
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column-index
	 * @return style mask
	 */
	public int getTooltipImageStyle(Object object, int 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.internal.viewers;

import org.eclipse.swt.graphics.Point;

/**
 * @since 3.2
 * 
 */
public interface ITooltipAddonsProvider {
	/**
	 * This is the amount the used to control how much the tooltip is shifted
	 * from the current mouse position
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @return shift of the tooltip
	 */
	public Point getTooltipShift(Object object);

	/**
	 * If you want your tooltip to be using the native Tooltip you can force
	 * this by returning true from this method. If native tooltips are used only
	 * the text-value is used all other feature are of custom tooltips are not
	 * supported.
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @return true if native tooltips should be used
	 */
	public boolean useNativeTooltip(Object object);

	/**
	 * The time in milliseconds after the tooltip is hidden
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @return milliseconds
	 */
	public int getTooltipTimeDisplayed(Object object);

	/**
	 * The time in milliseconds until the tooltip pops up
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @return milliseconds
	 */
	public int getTooltipDisplayDelayTime(Object object);

	/**
	 * The style used to create the label
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @return style mask
	 */
	public int getTooltipImageStyle(Object object);
}




/*******************************************************************************
 * 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;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Widget;

/**
 * @since 3.2
 *
 */
public class TreeRowPart extends DefaultRowPartImpl {
	private TreeItem item;
	
	public TreeRowPart(TreeItem item) {
		this.item = item;
	}
	
	public Rectangle getBounds(int columnIndex) {
		return item.getBounds(columnIndex);
	}

	public Rectangle getBounds() {
		return item.getBounds();
	}

	public int getColumnCount() {
		return item.getParent().getItemCount();
	}

	public Widget getItem() {
		return item;
	}

	public Color getBackground(int columnIndex) {
		return item.getBackground(columnIndex);
	}

	public Font getFont(int columnIndex) {
		return item.getFont(columnIndex);
	}

	public Color getForeground(int columnIndex) {
		return item.getForeground(columnIndex);
	}

	public Image getImage(int columnIndex) {
		return item.getImage(columnIndex);
	}

	public String getText(int columnIndex) {
		return item.getText(columnIndex);
	}

	public void setBackground(int columnIndex, Color color) {
		item.setBackground(columnIndex, color);
	}

	public void setFont(int columnIndex, Font font) {
		item.setFont(columnIndex, font);
	}

	public void setForeground(int columnIndex, Color color) {
		item.setForeground(columnIndex, color);
	}

	public void setImage(int columnIndex, Image image) {
		item.setImage(columnIndex,image);
	}

	public void setText(int columnIndex, String text) {
		item.setText(columnIndex, text);
	}
}




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

/**
 * Wrapper class for {@link TreeColumn}
 * @since 3.3
 * 
 */
public class TreeColumnViewerPart extends ColumnViewerPart {
	private TreeColumn column;

	/**
	 * Create new TableColumnViewerPart. This simply wrapps up a new
	 * {@link TreeColumn#TableColumn(org.eclipse.swt.widgets.Table, int)}.
	 * Before calling {@link TreeViewer#setInput(Object)}} you need to set the
	 * label-provider using
	 * {@link ColumnViewerPart#setLabelProvider(ViewerLabelProvider)}
	 * 
	 * @param parent
	 *            the table-viewer
	 * @param style
	 *            style bits used to create TableColumn {@link TreeColumn}
	 */
	public TreeColumnViewerPart(TreeViewer parent, int style) {
		this(new TreeColumn(parent.getTree(), style),null);
	}

	/**
	 * Create new TableColumnViewerPart. This simply wrapps up a new
	 * {@link TableColumn#TableColumn(org.eclipse.swt.widgets.Table, int, int)}
	 * 
	 * @param parent
	 *            the table-viewer
	 * @param style
	 *            style style bits used to create TableColumn
	 *            {@link TableColumn}
	 * @param index
	 *            the index of the column
	 */
	public TreeColumnViewerPart(TreeViewer parent, int style, int index) {
		this(new TreeColumn(parent.getTree(), style, index),null);
	}

	/**
	 * Wrap an existing TableColumn
	 * 
	 * @param column
	 *            the existing table-column
	 * @param labelProvider
	 *            the label provider
	 */
	public TreeColumnViewerPart(TreeColumn column,
			ViewerLabelProvider labelProvider) {
		super(column,labelProvider);
		this.column = column;
	}

	/**
	 * @return access the underlying tree-column
	 */
	public TreeColumn getColumn() {
		return column;
	}
}




/*******************************************************************************
 * 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.internal.viewers.ITooltipAddonsProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;

/**
 * @since 3.2
 * 
 */
public abstract class AbstractTooltipProvider implements ITooltipLabelProvider,
		ITooltipFontProvider, ITooltipColorProvider, ITooltipAddonsProvider {

	public Image getTooltipImage(Object object) {
		return null;
	}

	public Font getTooltipFont(Object object) {
		return null;
	}

	public Color getTooltipBackgroundColor(Object object) {
		return null;
	}

	public Color getTooltipForegroundColor(Object object) {
		return null;
	}

	public int getTooltipDisplayDelayTime(Object object) {
		return 0;
	}

	public Point getTooltipShift(Object object) {
		return null;
	}

	public int getTooltipTimeDisplayed(Object object) {
		return 0;
	}

	public boolean useNativeTooltip(Object object) {
		return false;
	}
	
	public int getTooltipImageStyle(Object object) {
		return SWT.SHADOW_NONE;
	}
}




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

/**
 * @since 3.3
 * 
 */
public interface ITableTooltipFontProvider {
	/**
	 * The font used to display the tooltip
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @param columnIndex
	 *            the column index used
	 * @return the font if null default font is used
	 */
	public Font getTooltipFont(Object object, int 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;

import org.eclipse.jface.internal.viewers.ITableTooltipAddonsProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;

/**
 * @since 3.2
 * 
 */
public abstract class AbstractTableTooltipProvider implements
		ITableTooltipLabelProvider, ITableTooltipColorProvider,
		ITableTooltipFontProvider, ITableTooltipAddonsProvider {

	public Image getTooltipImage(Object object, int columnIndex) {
		return null;
	}

	public Color getTooltipBackgroundColor(Object object, int columnIndex) {
		return null;
	}

	public Color getTooltipForegroundColor(Object object, int columnIndex) {
		return null;
	}

	public Font getTooltipFont(Object object, int columnIndex) {
		return null;
	}

	public int getTooltipDisplayDelayTime(Object object, int columnIndex) {
		return 0;
	}

	public Point getTooltipShift(Object object, int columnIndex) {
		return null;
	}

	public int getTooltipTimeDisplayed(Object object, int columnIndex) {
		return 0;
	}

	public boolean useNativeTooltip(Object object, int columnIndex) {
		return false;
	}

	public int getTooltipImageStyle(Object object, int columnIndex) {
		return SWT.SHADOW_NONE;
	}	
}




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

/**
 * Wrapper class for {@link TableColumn}
 * @since 3.3
 * 
 */
public class TableColumnViewerPart extends ColumnViewerPart {
	private TableColumn column;

	/**
	 * Create new TableColumnViewerPart. This simply wrapps up a new
	 * {@link TableColumn#TableColumn(org.eclipse.swt.widgets.Table, int)}.
	 * Before calling {@link TableViewer#setInput(Object)}} you need to set the
	 * label-provider using
	 * {@link ColumnViewerPart#setLabelProvider(ViewerLabelProvider)}
	 * 
	 * @param parent
	 *            the table-viewer
	 * @param style
	 *            style bits used to create TableColumn {@link TableColumn}
	 */
	public TableColumnViewerPart(TableViewer parent, int style) {
		this(new TableColumn(parent.getTable(), style),null);
	}

	/**
	 * Create new TableColumnViewerPart. This simply wrapps up a new
	 * {@link TableColumn#TableColumn(org.eclipse.swt.widgets.Table, int, int)}
	 * 
	 * @param parent
	 *            the table-viewer
	 * @param style
	 *            style style bits used to create TableColumn
	 *            {@link TableColumn}
	 * @param index
	 *            the index of the column
	 */
	public TableColumnViewerPart(TableViewer parent, int style, int index) {
		this(new TableColumn(parent.getTable(), style, index),null);
	}

	/**
	 * Wrap an existing TableColumn
	 * 
	 * @param column
	 *            the existing table-column
	 * @param labelProvider
	 *            the label provider
	 */
	public TableColumnViewerPart(TableColumn column,
			ViewerLabelProvider labelProvider) {
		super(column,labelProvider);
		this.column = column;
	}

	/**
	 * @return access the underlying table-column
	 */
	public TableColumn getColumn() {
		return column;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 BestSolution Systemhaus GmbH
 * 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:
 *     Tom Schind - tom.schindl@bestsolution.at
 *******************************************************************************/
package org.eclipse.jface.viewers;

import org.eclipse.swt.graphics.Image;

/**
 * 
 * @since 3.3
 *
 */
public interface ITooltipLabelProvider {
	/**
	 * Returns the tooltip text for the given element and column index, or
	 * <code>null</code> if a custom tooltip should not be displayed.
	 * 
	 * @param element
	 *            the element for which the tooltip is shown
	 * @return the text to be displayed in the tooltip, or <code>null</code>
	 *         if a custom tooltip should not be displayed
	 */
	public String getTooltipText(Object element);

	/**
	 * The image displayed in the tooltip
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @return the image displayed if null no image is displayed
	 */
	public Image getTooltipImage(Object object);
}




/*******************************************************************************
 * 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.internal.viewers.RowPart;
import org.eclipse.swt.graphics.Rectangle;

/**
 * @since 3.2
 *
 */
public class Cell {
	private int columnIndex;
	private RowPart row;
	
	public Cell(RowPart row, int columnIndex) {
		this.row = row;
		this.columnIndex = columnIndex;
	}
	
	public int getColumnIndex() {
		return columnIndex;
	}
	
	public Rectangle getBounds() {
		return row.getBounds(columnIndex);
	}
	
	public Object getElement() {
		return row.getElement();
	}
}




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

/**
 * @since 3.2
 *
 */
public interface ITooltipColorProvider {
	/**
	 * The foreground color used to display the the text in the tooltip
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * @return the color used or <code>null</code> if you want to use the
	 *         default color {@link SWT#COLOR_INFO_FOREGROUND}
	 */
	public Color getTooltipForegroundColor(Object object);

	/**
	 * The background color used for the tooltip
	 * 
	 * @param object
	 *            the element for which the tooltip is shown
	 * 
	 * @return the color used or <code>null</code> if you want to use the
	 */
	public Color getTooltipBackgroundColor(Object object);

}

Return to bug 149193

Lines 21-26 Link Here

(-)src/org/eclipse/jface/viewers/TreeEditorImpl.java (-51 / +45 lines)
21	import org.eclipse.swt.widgets.Control;	21	import org.eclipse.swt.widgets.Control;
22	import org.eclipse.swt.widgets.Display;	22	import org.eclipse.swt.widgets.Display;
23	import org.eclipse.swt.widgets.Item;	23	import org.eclipse.swt.widgets.Item;
		24	import org.eclipse.swt.widgets.Tree;
24		25
25	/**	26	/**
26	* Internal tree viewer implementation.	27	* Internal tree viewer implementation.
Lines 66-117 Link Here
66	}	67	}
67		68
68	private void activateCellEditor() {	69	private void activateCellEditor() {
69	if (cellEditors != null) {	70	ColumnViewerPart part = (ColumnViewerPart)((Tree)viewer.getControl()).getColumn(columnNumber).getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
70	if (cellEditors[columnNumber] != null && cellModifier != null) {	71	Object element = treeItem.getData();
71	Object element = treeItem.getData();	72
72	String property = columnProperties[columnNumber];	73	if( part != null && part.getEditingSupport() != null && part.getEditingSupport().canEdit(element) ) {
73	if (cellModifier.canModify(element, property)) {	74	cellEditor = part.getEditingSupport().getCellEditor(element);
74	cellEditor = cellEditors[columnNumber];	75	cellEditor.addListener(cellEditorListener);
75	//tree.showSelection();	76	Object value = part.getEditingSupport().getValue(element);
76	cellEditor.addListener(cellEditorListener);	77	cellEditor.setValue(value);
77	Object value = cellModifier.getValue(element, property);	78	// Tricky flow of control here:
78	cellEditor.setValue(value);	79	// activate() can trigger callback to cellEditorListener which will clear cellEditor
79	// Tricky flow of control here:	80	// so must get control first, but must still call activate() even if there is no control.
80	// activate() can trigger callback to cellEditorListener which will clear cellEditor	81	final Control control = cellEditor.getControl();
81	// so must get control first, but must still call activate() even if there is no control.	82	cellEditor.activate();
82	final Control control = cellEditor.getControl();	83	if (control == null) {
83	cellEditor.activate();	84	return;
84	if (control == null) {	85	}
85	return;	86	setLayoutData(cellEditor.getLayoutData());
86	}	87	setEditor(control, treeItem, columnNumber);
87	setLayoutData(cellEditor.getLayoutData());	88	cellEditor.setFocus();
88	setEditor(control, treeItem, columnNumber);	89	if (focusListener == null) {
89	cellEditor.setFocus();	90	focusListener = new FocusAdapter() {
90	if (focusListener == null) {	91	public void focusLost(FocusEvent e) {
91	focusListener = new FocusAdapter() {	92	applyEditorValue();
92	public void focusLost(FocusEvent e) {
93	applyEditorValue();
94	}
95	};
96	}	93	}
97	control.addFocusListener(focusListener);	94	};
98	mouseListener = new MouseAdapter() {
99	public void mouseDown(MouseEvent e) {
100	// time wrap?
101	// check for expiration of doubleClickTime
102	if (e.time <= doubleClickExpirationTime) {
103	control.removeMouseListener(mouseListener);
104	cancelEditing();
105	handleDoubleClickEvent();
106	} else if (mouseListener != null) {
107	control.removeMouseListener(mouseListener);
108	}
109	}
110	};
111	control.addMouseListener(mouseListener);
112	}
113	}	95	}
114	}	96	control.addFocusListener(focusListener);
		97	mouseListener = new MouseAdapter() {
		98	public void mouseDown(MouseEvent e) {
		99	// time wrap?
		100	// check for expiration of doubleClickTime
		101	if (e.time <= doubleClickExpirationTime) {
		102	control.removeMouseListener(mouseListener);
		103	cancelEditing();
		104	handleDoubleClickEvent();
		105	} else if (mouseListener != null) {
		106	control.removeMouseListener(mouseListener);
		107	}
		108	}
		109	};
		110	control.addMouseListener(mouseListener);
		111	}
115	}	112	}
116		113
117	/**	114	/**
Lines 313-325 Link Here
313	* by delegating to the cell modifier.	310	* by delegating to the cell modifier.
314	*/	311	*/
315	private void saveEditorValue(CellEditor cellEditor, Item treeItem) {	312	private void saveEditorValue(CellEditor cellEditor, Item treeItem) {
316	if (cellModifier != null) {	313	ColumnViewerPart part = (ColumnViewerPart)treeItem.getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
317	String property = null;	314
318	if (columnProperties != null	315	if( part != null && part.getEditingSupport() != null ) {
319	&& columnNumber < columnProperties.length) {	316	part.getEditingSupport().setValue(treeItem.getData(), cellEditor.getValue());
320	property = columnProperties[columnNumber];
321	}
322	cellModifier.modify(treeItem, property, cellEditor.getValue());
323	}	317	}
324	}	318	}
325		319

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 TreeColumnViewerLabelProvider {
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);

Lines 21-26 Link Here

(-)src/org/eclipse/jface/viewers/TableEditorImpl.java (-59 / +50 lines)
21	import org.eclipse.swt.widgets.Control;	21	import org.eclipse.swt.widgets.Control;
22	import org.eclipse.swt.widgets.Display;	22	import org.eclipse.swt.widgets.Display;
23	import org.eclipse.swt.widgets.Item;	23	import org.eclipse.swt.widgets.Item;
		24	import org.eclipse.swt.widgets.Table;
24		25
25	/**	26	/**
26	* Internal table viewer implementation.	27	* Internal table viewer implementation.
Lines 66-117 Link Here
66	}	67	}
67		68
68	private void activateCellEditor() {	69	private void activateCellEditor() {
69	if (cellEditors != null) {	70	ColumnViewerPart part = (ColumnViewerPart)((Table)viewer.getControl()).getColumn(columnNumber).getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
70	if (cellEditors[columnNumber] != null && cellModifier != null) {	71	Object element = tableItem.getData();
71	Object element = tableItem.getData();	72
72	String property = columnProperties[columnNumber];	73	if( part != null && part.getEditingSupport() != null && part.getEditingSupport().canEdit(element) ) {
73	if (cellModifier.canModify(element, property)) {	74	cellEditor = part.getEditingSupport().getCellEditor(element);
74	cellEditor = cellEditors[columnNumber];	75	cellEditor.addListener(cellEditorListener);
75	//table.showSelection();	76	Object value = part.getEditingSupport().getValue(element);
76	cellEditor.addListener(cellEditorListener);	77	cellEditor.setValue(value);
77	Object value = cellModifier.getValue(element, property);	78	// Tricky flow of control here:
78	cellEditor.setValue(value);	79	// activate() can trigger callback to cellEditorListener which will clear cellEditor
79	// Tricky flow of control here:	80	// so must get control first, but must still call activate() even if there is no control.
80	// activate() can trigger callback to cellEditorListener which will clear cellEditor	81	final Control control = cellEditor.getControl();
81	// so must get control first, but must still call activate() even if there is no control.	82	cellEditor.activate();
82	final Control control = cellEditor.getControl();	83	if (control == null) {
83	cellEditor.activate();	84	return;
84	if (control == null) {	85	}
85	return;	86	setLayoutData(cellEditor.getLayoutData());
86	}	87	setEditor(control, tableItem, columnNumber);
87	setLayoutData(cellEditor.getLayoutData());	88	cellEditor.setFocus();
88	setEditor(control, tableItem, columnNumber);	89	if (focusListener == null) {
89	cellEditor.setFocus();	90	focusListener = new FocusAdapter() {
90	if (focusListener == null) {	91	public void focusLost(FocusEvent e) {
91	focusListener = new FocusAdapter() {	92	applyEditorValue();
92	public void focusLost(FocusEvent e) {
93	applyEditorValue();
94	}
95	};
96	}	93	}
97	control.addFocusListener(focusListener);	94	};
98	mouseListener = new MouseAdapter() {
99	public void mouseDown(MouseEvent e) {
100	// time wrap?
101	// check for expiration of doubleClickTime
102	if (e.time <= doubleClickExpirationTime) {
103	control.removeMouseListener(mouseListener);
104	cancelEditing();
105	handleDoubleClickEvent();
106	} else if (mouseListener != null) {
107	control.removeMouseListener(mouseListener);
108	}
109	}
110	};
111	control.addMouseListener(mouseListener);
112	}
113	}	95	}
114	}	96	control.addFocusListener(focusListener);
		97	mouseListener = new MouseAdapter() {
		98	public void mouseDown(MouseEvent e) {
		99	// time wrap?
		100	// check for expiration of doubleClickTime
		101	if (e.time <= doubleClickExpirationTime) {
		102	control.removeMouseListener(mouseListener);
		103	cancelEditing();
		104	handleDoubleClickEvent();
		105	} else if (mouseListener != null) {
		106	control.removeMouseListener(mouseListener);
		107	}
		108	}
		109	};
		110	control.addMouseListener(mouseListener);
		111	}
115	}	112	}
116		113
117	/**	114	/**
Lines 217-223 Link Here
217		214
218	abstract Rectangle getBounds(Item item, int columnNumber);	215	abstract Rectangle getBounds(Item item, int columnNumber);
219		216
220	/**	217	/**
221	* Return the array of CellEditors used in the viewer	218	* Return the array of CellEditors used in the viewer
222	* @return the cell editors	219	* @return the cell editors
223	*/	220	*/
Lines 235-248 Link Here
235		232
236	abstract int getColumnCount();	233	abstract int getColumnCount();
237		234
238	/**	235	/**
239	* Return the properties for the column	236	* Return the properties for the column
240	* @return the array of column properties	237	* @return the array of column properties
241	*/	238	*/
242	public Object[] getColumnProperties() {	239	public Object[] getColumnProperties() {
243	return columnProperties;	240	return columnProperties;
244	}	241	}
245		242
246	abstract Item[] getSelection();	243	abstract Item[] getSelection();
247		244
248	/**	245	/**
Lines 308-324 Link Here
308	* by delegating to the cell modifier.	305	* by delegating to the cell modifier.
309	*/	306	*/
310	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {	307	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
311	if (cellModifier != null) {	308	ColumnViewerPart part = (ColumnViewerPart)tableItem.getData(ColumnViewerPart.COLUMN_VIEWER_KEY);
312	if (!cellEditor.isValueValid()) {	309
313	///Do what ???	310	if( part != null && part.getEditingSupport() != null ) {
314	}	311	part.getEditingSupport().setValue(tableItem.getData(), cellEditor.getValue());
315	String property = null;	312	}
316	if (columnProperties != null
317	&& columnNumber < columnProperties.length) {
318	property = columnProperties[columnNumber];
319	}
320	cellModifier.modify(tableItem, property, cellEditor.getValue());
321	}
322	}	313	}
323		314
324	/**	315	/**
Lines 344-350 Link Here
344	public void setColumnProperties(String[] columnProperties) {	335	public void setColumnProperties(String[] columnProperties) {
345	this.columnProperties = columnProperties;	336	this.columnProperties = columnProperties;
346	}	337	}
347		338
348	abstract void setEditor(Control w, Item item, int fColumnNumber);	339	abstract void setEditor(Control w, Item item, int fColumnNumber);
349		340
350	abstract void setLayoutData(CellEditor.LayoutData layoutData);	341	abstract void setLayoutData(CellEditor.LayoutData layoutData);

Added Link Here

(-)src/org/eclipse/jface/viewers/IEditingSupport.java (+55 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	* @since 3.2
16	*
17	*/
18	public interface IEditingSupport {
19	/**
20	* The editor to be shown
21	*
22	* @param element
23	* the model element
24	* @return the CellEditor
25	*/
26	public CellEditor getCellEditor(Object element);
27
28	/**
29	* Is the cell editable
30	*
31	* @param element
32	* the model element
33	* @return true if editable
34	*/
35	public boolean canEdit(Object element);
36
37	/**
38	* Get the value to set to the editor
39	*
40	* @param element
41	* the model element
42	* @return the value shown
43	*/
44	public Object getValue(Object element);
45
46	/**
47	* Restore the value from the CellEditor
48	*
49	* @param element
50	* the model element
51	* @param value
52	* the new value
53	*/
54	public void setValue(Object element, Object value);
55	}

Added Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerPart.java (+152 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.internal.viewers.RowPart;
15	import org.eclipse.jface.util.Policy;
16	import org.eclipse.swt.widgets.Widget;
17
18	/**
19	* The ColumnViewerPart is abstract implementation of the column parts.
20	*
21	* @since 3.3
22	*
23	*/
24	public class ColumnViewerPart {
25
26	private ViewerLabelProvider labelProvider;
27
28	static String COLUMN_VIEWER_KEY = Policy.JFACE + ".columnViewer";//$NON-NLS-1$
29
30	private IEditingSupport editingSupport;
31
32	/**
33	* Create a new instance of the receiver at columnIndex.
34	*
35	* @param columnOwner
36	* @param provider
37	*/
38	public ColumnViewerPart(Widget columnOwner, ViewerLabelProvider provider) {
39	labelProvider = provider;
40	columnOwner.setData(ColumnViewerPart.COLUMN_VIEWER_KEY, this);
41	}
42
43	/**
44	* Return the label provider for the receiver.
45	*
46	* @return ViewerLabelProvider
47	*/
48	public ViewerLabelProvider getLabelProvider() {
49	return labelProvider;
50	}
51
52	/**
53	* @param labelProvider
54	* the new label-provider
55	*/
56	public void setLabelProvider(ViewerLabelProvider labelProvider) {
57	this.labelProvider = labelProvider;
58	}
59
60	/**
61	* @return Returns the editingSupport.
62	*/
63	public IEditingSupport getEditingSupport() {
64	return editingSupport;
65	}
66
67	/**
68	* @param editingSupport
69	* The editingSupport to set.
70	*/
71	public void setEditingSupport(IEditingSupport editingSupport) {
72	this.editingSupport = editingSupport;
73	}
74
75	/**
76	* Refresh the row for the given columnIndex
77	*
78	* @param row
79	* @param element
80	* @param columnIndex
81	*/
82	public void refresh(RowPart row, int columnIndex) {
83	ViewerLabel label = new ViewerLabel(row.getText(columnIndex), row
84	.getImage(columnIndex));
85	getLabelProvider().updateLabel(label, row.getElement(), columnIndex);
86
87	row.setBackground(columnIndex, label.getBackground());
88	row.setForeground(columnIndex, label.getForeground());
89	row.setFont(columnIndex, label.getFont());
90
91	if (label.hasNewText())
92	row.setText(columnIndex, label.getText());
93
94	if (label.hasNewImage())
95	row.setImage(columnIndex, label.getImage());
96	}
97
98	/**
99	* Refresh the TreeItem for element.
100	*
101	* @param item
102	* @param element
103	* @param columnIndex
104	*/
105	/* public void refresh(TreeItem item, Object element, int columnIndex) {
106
107	ViewerLabel label = new ViewerLabel(item.getText(columnIndex), item
108	.getImage(columnIndex));
109	getLabelProvider().updateLabel(label, element, columnIndex);
110
111	// We can not make a null check because then we could not
112	// set the items back to default state
113	item.setBackground(columnIndex, label.getBackground());
114	item.setForeground(columnIndex, label.getForeground());
115	item.setFont(columnIndex, label.getFont());
116
117	if (label.hasNewText())
118	item.setText(columnIndex, label.getText());
119
120	if (label.hasNewImage())
121	item.setImage(columnIndex, label.getImage());
122	}
123	*/
124	/**
125	* Refresh the TableItem for element.
126	*
127	* @param item
128	* @param element
129	* @param columnIndex
130	*/
131	/* public void refresh(TableItem item, Object element, int columnIndex) {
132
133	ViewerLabel label = new ViewerLabel(item.getText(columnIndex), item
134	.getImage(columnIndex));
135	getLabelProvider().updateLabel(label, element, columnIndex);
136
137	if (label.hasNewBackground())
138	item.setBackground(columnIndex, label.getBackground());
139
140	if (label.hasNewForeground())
141	item.setForeground(columnIndex, label.getForeground());
142
143	if (label.hasNewFont())
144	item.setFont(columnIndex, label.getFont());
145
146	if (label.hasNewText())
147	item.setText(columnIndex, label.getText());
148
149	if (label.hasNewImage())
150	item.setImage(columnIndex, label.getImage());
151	}*/
152	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TreeColumnViewerLabelProvider.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 TreeColumnViewerLabelProvider 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	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TableRowPart.java (+88 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	import org.eclipse.swt.graphics.Rectangle;
18	import org.eclipse.swt.widgets.TableItem;
19	import org.eclipse.swt.widgets.Widget;
20
21	/**
22	* @since 3.2
23	*
24	*/
25	public class TableRowPart extends DefaultRowPartImpl {
26	private TableItem item;
27
28	public TableRowPart(TableItem item) {
29	this.item = item;
30	}
31
32	public Rectangle getBounds(int columnIndex) {
33	return item.getBounds(columnIndex);
34	}
35
36	public Rectangle getBounds() {
37	return item.getBounds();
38	}
39
40	public Widget getItem() {
41	return item;
42	}
43
44	public int getColumnCount() {
45	return item.getParent().getColumnCount();
46	}
47
48	public Color getBackground(int columnIndex) {
49	return item.getBackground(columnIndex);
50	}
51
52	public Font getFont(int columnIndex) {
53	return item.getFont(columnIndex);
54	}
55
56	public Color getForeground(int columnIndex) {
57	return item.getForeground(columnIndex);
58	}
59
60	public Image getImage(int columnIndex) {
61	return item.getImage(columnIndex);
62	}
63
64	public String getText(int columnIndex) {
65	return item.getText(columnIndex);
66	}
67
68	public void setBackground(int columnIndex, Color color) {
69	item.setBackground(columnIndex, color);
70	}
71
72	public void setFont(int columnIndex, Font font) {
73	item.setFont(columnIndex, font);
74	}
75
76	public void setForeground(int columnIndex, Color color) {
77	item.setForeground(columnIndex, color);
78	}
79
80	public void setImage(int columnIndex, Image image) {
81	item.setImage(columnIndex,image);
82	}
83
84	public void setText(int columnIndex, String text) {
85	item.setText(columnIndex, text);
86	}
87
88	}

Added Link Here

(-)src/org/eclipse/jface/viewers/ITableTooltipLabelProvider.java (+44 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 BestSolution Systemhaus GmbH
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	* Tom Schind - tom.schindl@bestsolution.at
10	*******************************************************************************/
11	package org.eclipse.jface.viewers;
12
13	import org.eclipse.swt.graphics.Image;
14
15	/**
16	*
17	* @since 3.3
18	*
19	*/
20	public interface ITableTooltipLabelProvider {
21	/**
22	* Returns the tooltip text for the given element and column index, or
23	* <code>null</code> if a custom tooltip should not be displayed.
24	*
25	* @param element
26	* the element for which the tooltip is shown
27	* @param columnIndex
28	* the column index used
29	* @return the text to be displayed in the tooltip, or <code>null</code>
30	* if a custom tooltip should not be displayed
31	*/
32	public String getTooltipText(Object element, int columnIndex);
33
34	/**
35	* The image displayed in the tooltip
36	*
37	* @param object
38	* the element for which the tooltip is shown
39	* @param columnIndex
40	* the column index used
41	* @return the image displayed if null no image is displayed
42	*/
43	public Image getTooltipImage(Object object, int columnIndex);
44	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TableColumnViewerLabelProvider.java (+178 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
36	* the index into the table for this column
37	* @see ITableLabelProvider
38	* @see ITableColorProvider
39	* @see ITableFontProvider
40	*/
41	public TableColumnViewerLabelProvider(IBaseLabelProvider labelProvider) {
42	super(labelProvider);
43
44	if (labelProvider instanceof ITableLabelProvider)
45	setLabelProvider(labelProviderFor((ITableLabelProvider) labelProvider));
46
47	if (labelProvider instanceof ITableColorProvider)
48	setColorProvider(colorProviderFor((ITableColorProvider) labelProvider));
49
50	if (labelProvider instanceof ITableFontProvider)
51	setFontProvider(fontProviderFor((ITableFontProvider) labelProvider));
52
53	if (labelProvider instanceof ITableTooltipLabelProvider)
54	setTooltipLabelProvider(tooltipLabelFor((ITableTooltipLabelProvider) labelProvider));
55
56	if(labelProvider instanceof ITableTooltipColorProvider)
57	setTooltipColorProvider(tooltipColorFor((ITableTooltipColorProvider)labelProvider));
58
59	if(labelProvider instanceof ITableTooltipFontProvider)
60	setTooltipFontProvider(tooltipFontFor((ITableTooltipFontProvider)labelProvider));
61	}
62
63	private ITooltipFontProvider tooltipFontFor(final ITableTooltipFontProvider provider) {
64	return new ITooltipFontProvider() {
65
66	public Font getTooltipFont(Object object) {
67	return provider.getTooltipFont(object, getColumnIndex());
68	}
69	};
70	}
71
72	private ITooltipColorProvider tooltipColorFor(final ITableTooltipColorProvider provider) {
73	return new ITooltipColorProvider() {
74
75	public Color getTooltipBackgroundColor(Object object) {
76	return provider.getTooltipBackgroundColor(object, getColumnIndex());
77	}
78
79	public Color getTooltipForegroundColor(Object object) {
80	return provider.getTooltipForegroundColor(object, getColumnIndex());
81	}
82	};
83	}
84
85	private ITooltipLabelProvider tooltipLabelFor(
86	final ITableTooltipLabelProvider provider) {
87	return new ITooltipLabelProvider() {
88
89	public Image getTooltipImage(Object object) {
90	return provider.getTooltipImage(object, getColumnIndex());
91	}
92
93	public String getTooltipText(Object element) {
94	return provider.getTooltipText(element, getColumnIndex());
95	}
96
97	};
98	}
99
100	/**
101	* Return the IFontProvider based on provider at columnIndex.
102	*
103	* @param provider
104	* @param columnIndex
105	* @return IFontProvider
106	*/
107	private IFontProvider fontProviderFor(final ITableFontProvider provider) {
108	return new IFontProvider() {
109	/*
110	* (non-Javadoc)
111	*
112	* @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
113	*/
114	public Font getFont(Object element) {
115	return provider.getFont(element, getColumnIndex());
116	}
117	};
118	}
119
120	/**
121	* Return the ILabelProvider based on provider at columnIndex.
122	*
123	* @param provider
124	* @param columnIndex
125	* @return ILabelProvider
126	*/
127	private ILabelProvider labelProviderFor(final ITableLabelProvider provider) {
128	return new LabelProvider() {
129	/*
130	* (non-Javadoc)
131	*
132	* @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
133	*/
134	public String getText(Object element) {
135	return provider.getColumnText(element, getColumnIndex());
136	}
137
138	/*
139	* (non-Javadoc)
140	*
141	* @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
142	*/
143	public Image getImage(Object element) {
144	return provider.getColumnImage(element, getColumnIndex());
145	}
146	};
147	}
148
149	/**
150	* Create an IColorProvider from the ITableColorProvider at columnIndex.
151	*
152	* @param provider
153	* @param columnIndex
154	* @return IColorProvider
155	*/
156	private IColorProvider colorProviderFor(final ITableColorProvider provider) {
157	return new IColorProvider() {
158	/*
159	* (non-Javadoc)
160	*
161	* @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
162	*/
163	public Color getBackground(Object element) {
164	return provider.getBackground(element, getColumnIndex());
165	}
166
167	/*
168	* (non-Javadoc)
169	*
170	* @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
171	*/
172	public Color getForeground(Object element) {
173	return provider.getForeground(element, getColumnIndex());
174	}
175	};
176	}
177
178	}

Added Link Here

(-)src/org/eclipse/jface/internal/viewers/RowPart.java (+87 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.internal.viewers;
13
14	import org.eclipse.jface.util.Policy;
15	import org.eclipse.jface.viewers.Cell;
16	import org.eclipse.swt.graphics.Color;
17	import org.eclipse.swt.graphics.Font;
18	import org.eclipse.swt.graphics.Image;
19	import org.eclipse.swt.graphics.Point;
20	import org.eclipse.swt.graphics.Rectangle;
21	import org.eclipse.swt.widgets.Widget;
22
23	/**
24	* @since 3.2
25	*
26	*/
27	public abstract class RowPart {
28	public static final String ROWPART_KEY = Policy.JFACE + ".ROWPART"; //$NON-NLS-1$
29
30	public abstract Rectangle getBounds(int columnIndex);
31
32	public abstract Rectangle getBounds();
33
34	public abstract Widget getItem();
35
36	public abstract int getColumnCount();
37
38	public abstract Image getImage(int columnIndex);
39
40	public abstract void setImage(int columnIndex,Image image);
41
42	public abstract String getText(int columnIndex);
43
44	public abstract void setText(int columnIndex,String text);
45
46	public abstract Color getBackground(int columnIndex);
47
48	public abstract void setBackground(int columnIndex, Color color);
49
50	public abstract Color getForeground(int columnIndex);
51
52	public abstract void setForeground(int columnIndex, Color color);
53
54	public abstract Font getFont(int columnIndex);
55
56	public abstract void setFont(int columnIndex,Font font);
57
58	public Cell getCell(Point point) {
59	int index = getColumIndex(point);
60
61	if( index >= 0 ) {
62	return new Cell(this,index);
63	}
64
65	return null;
66	}
67
68	public int getColumIndex(Point point) {
69	int count = getColumnCount();
70
71	for(int i = 0; i < count; i++ ) {
72	if( getBounds(i).contains(point) ) {
73	return i;
74	}
75	}
76
77	return -1;
78	}
79
80	public Object getElement() {
81	return getItem().getData();
82	}
83
84	public void associate() {
85	getItem().setData(RowPart.ROWPART_KEY, this);
86	}
87	}

Added Link Here

(-)src/org/eclipse/jface/viewers/DefaultRowPartImpl.java (+85 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.internal.viewers.RowPart;
15	import org.eclipse.swt.graphics.Color;
16	import org.eclipse.swt.graphics.Font;
17	import org.eclipse.swt.graphics.Image;
18	import org.eclipse.swt.graphics.Rectangle;
19	import org.eclipse.swt.widgets.Widget;
20
21	/**
22	* @since 3.2
23	*
24	*/
25	public class DefaultRowPartImpl extends RowPart {
26
27	public Color getBackground(int columnIndex) {
28	return null;
29	}
30
31	public Rectangle getBounds(int columnIndex) {
32	return null;
33	}
34
35	public Rectangle getBounds() {
36	return null;
37	}
38
39	public int getColumnCount() {
40	return 0;
41	}
42
43	public Font getFont(int columnIndex) {
44	return null;
45	}
46
47	public Color getForeground(int columnIndex) {
48	return null;
49	}
50
51	public Image getImage(int columnIndex) {
52	return null;
53	}
54
55	public Widget getItem() {
56	return null;
57	}
58
59	public String getText(int columnIndex) {
60	return null;
61	}
62
63
64	public void setBackground(int columnIndex, Color color) {
65
66	}
67
68
69	public void setFont(int columnIndex, Font font) {
70
71	}
72
73	public void setForeground(int columnIndex, Color color) {
74
75	}
76
77	public void setImage(int columnIndex, Image image) {
78
79	}
80
81	public void setText(int columnIndex, String text) {
82
83	}
84
85	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TooltipSupport.java (+187 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 java.util.Timer;
15
16	import org.eclipse.jface.internal.viewers.RowPart;
17	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.custom.CLabel;
19	import org.eclipse.swt.graphics.Color;
20	import org.eclipse.swt.graphics.Font;
21	import org.eclipse.swt.graphics.Image;
22	import org.eclipse.swt.graphics.Point;
23	import org.eclipse.swt.layout.FillLayout;
24	import org.eclipse.swt.widgets.Event;
25	import org.eclipse.swt.widgets.Listener;
26	import org.eclipse.swt.widgets.Shell;
27
28	/**
29	* @since 3.2
30	*
31	*/
32	public class TooltipSupport {
33	private StructuredViewer viewer;
34	private Listener listener = new MouseListener();
35	private static final int DEFAULT_SHIFT_X = 10;
36	private static final int DEFAULT_SHIFT_Y = 0;
37
38	TooltipSupport(StructuredViewer viewer) {
39	this.viewer = viewer;
40	}
41
42	/**
43	* activate tooltip support for this viewer
44	*/
45	public void activate() {
46	deactivate();
47	viewer.getControl().addListener(SWT.Dispose, listener);
48	viewer.getControl().addListener(SWT.MouseHover, listener);
49	viewer.getControl().addListener(SWT.MouseMove, listener);
50	viewer.getControl().addListener(SWT.MouseExit, listener);
51	viewer.getControl().addListener(SWT.MouseDown, listener);
52	}
53
54	/**
55	* deactivate tooltip support for this viewer
56	*/
57	public void deactivate() {
58	viewer.getControl().removeListener(SWT.Dispose, listener);
59	viewer.getControl().removeListener(SWT.MouseHover, listener);
60	viewer.getControl().removeListener(SWT.MouseMove, listener);
61	viewer.getControl().removeListener(SWT.MouseExit, listener);
62	viewer.getControl().removeListener(SWT.MouseDown, listener);
63	}
64
65	private class MouseListener implements Listener {
66	private Shell tip;
67	private TooltipHideListener hideListener = new TooltipHideListener();
68	private Timer timer = new Timer();
69
70	public void handleEvent(Event event) {
71	switch (event.type) {
72	case SWT.Dispose:
73	if( timer != null ) {
74	timer.cancel();
75	}
76	case SWT.KeyDown:
77	case SWT.MouseMove:
78	case SWT.MouseDown:
79	disposeTooltip(tip);
80	break;
81	case SWT.MouseHover:
82	Point p = new Point(event.x, event.y);
83	RowPart row = viewer.getRowPart(p);
84	viewer.getControl().setToolTipText(""); //$NON-NLS-1$
85
86	if (row != null) {
87	popupTooltip(row, p);
88	}
89
90	break;
91	}
92	}
93
94	private void popupTooltip(RowPart row, Point p) {
95	Object element = row.getElement();
96	disposeTooltip(tip);
97
98	ColumnViewerPart viewPart = viewer.getColumnViewer(row.getColumIndex(p));
99
100	if( viewPart == null ) {
101	return;
102	}
103
104	ViewerLabelProvider labelProvider = viewPart.getLabelProvider();
105
106	String text = labelProvider.getTooltipText(element);
107
108	if( text != null ) {
109
110	if( labelProvider.useNativeTooltip(element) ) {
111	viewer.getControl().setToolTipText(text);
112	return;
113	}
114
115	tip = new Shell(viewer.getControl().getShell(), SWT.ON_TOP \| SWT.TOOL);
116	tip.setLayout(new FillLayout());
117	CLabel label = new CLabel(tip, labelProvider.getTooltipImageStyle(element));
118	label.setText(text);
119	label.addListener(SWT.MouseExit, hideListener);
120	label.addListener(SWT.MouseDown, hideListener);
121
122	Image img = labelProvider.getTooltipImage(element);
123
124	if( img != null) {
125	label.setImage(img);
126	}
127
128	Color color = labelProvider.getTooltipForegroundColor(element);
129	if( color == null ) {
130	color = viewer.getControl().getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND);
131	}
132	label.setForeground(color);
133
134	color = labelProvider.getTooltipBackgroundColor(element);
135	if( color == null ) {
136	color = viewer.getControl().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND);
137	}
138	label.setBackground(color);
139
140	Font font = labelProvider.getTooltipFont(element);
141
142	if( font != null ) {
143	label.setFont(font);
144	}
145
146	Point pt = viewer.getControl().toDisplay(p);
147	Point shift = labelProvider.getTooltipShift(element);
148
149	if( shift == null ) {
150	pt.x += DEFAULT_SHIFT_X;
151	pt.y += DEFAULT_SHIFT_Y;
152	} else {
153	pt.x += shift.x;
154	pt.y += shift.y;
155	}
156
157	tip.pack();
158	tip.setLocation(pt);
159	tip.setVisible(true);
160	}
161	}
162
163	private void disposeTooltip(Shell tip) {
164	if (tip != null && !tip.isDisposed()) {
165	tip.dispose();
166	}
167
168	tip = null;
169	}
170	}
171
172	private class TooltipHideListener implements Listener {
173	public void handleEvent(Event event) {
174	CLabel label = (CLabel) event.widget;
175	Shell shell = label.getShell();
176	switch (event.type) {
177	case SWT.MouseDown:
178	viewer.setSelection(new StructuredSelection());
179	// fall through
180	case SWT.MouseExit:
181	viewer.getControl().setFocus();
182	shell.dispose();
183	break;
184	}
185	}
186	}
187	}

Added Link Here

(-)src/org/eclipse/jface/viewers/ITooltipFontProvider.java (+29 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.Font;
15
16	/**
17	* @since 3.3
18	*
19	*/
20	public interface ITooltipFontProvider {
21	/**
22	* The font used to display the tooltip
23	*
24	* @param object
25	* the element for which the tooltip is shown
26	* @return the font if null default font is used
27	*/
28	public Font getTooltipFont(Object object);
29	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TreeRowPart.java (+87 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	import org.eclipse.swt.graphics.Rectangle;
18	import org.eclipse.swt.widgets.TreeItem;
19	import org.eclipse.swt.widgets.Widget;
20
21	/**
22	* @since 3.2
23	*
24	*/
25	public class TreeRowPart extends DefaultRowPartImpl {
26	private TreeItem item;
27
28	public TreeRowPart(TreeItem item) {
29	this.item = item;
30	}
31
32	public Rectangle getBounds(int columnIndex) {
33	return item.getBounds(columnIndex);
34	}
35
36	public Rectangle getBounds() {
37	return item.getBounds();
38	}
39
40	public int getColumnCount() {
41	return item.getParent().getItemCount();
42	}
43
44	public Widget getItem() {
45	return item;
46	}
47
48	public Color getBackground(int columnIndex) {
49	return item.getBackground(columnIndex);
50	}
51
52	public Font getFont(int columnIndex) {
53	return item.getFont(columnIndex);
54	}
55
56	public Color getForeground(int columnIndex) {
57	return item.getForeground(columnIndex);
58	}
59
60	public Image getImage(int columnIndex) {
61	return item.getImage(columnIndex);
62	}
63
64	public String getText(int columnIndex) {
65	return item.getText(columnIndex);
66	}
67
68	public void setBackground(int columnIndex, Color color) {
69	item.setBackground(columnIndex, color);
70	}
71
72	public void setFont(int columnIndex, Font font) {
73	item.setFont(columnIndex, font);
74	}
75
76	public void setForeground(int columnIndex, Color color) {
77	item.setForeground(columnIndex, color);
78	}
79
80	public void setImage(int columnIndex, Image image) {
81	item.setImage(columnIndex,image);
82	}
83
84	public void setText(int columnIndex, String text) {
85	item.setText(columnIndex, text);
86	}
87	}

Added Link Here

(-)src/org/eclipse/jface/viewers/AbstractTooltipProvider.java (+63 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.internal.viewers.ITooltipAddonsProvider;
15	import org.eclipse.swt.SWT;
16	import org.eclipse.swt.graphics.Color;
17	import org.eclipse.swt.graphics.Font;
18	import org.eclipse.swt.graphics.Image;
19	import org.eclipse.swt.graphics.Point;
20
21	/**
22	* @since 3.2
23	*
24	*/
25	public abstract class AbstractTooltipProvider implements ITooltipLabelProvider,
26	ITooltipFontProvider, ITooltipColorProvider, ITooltipAddonsProvider {
27
28	public Image getTooltipImage(Object object) {
29	return null;
30	}
31
32	public Font getTooltipFont(Object object) {
33	return null;
34	}
35
36	public Color getTooltipBackgroundColor(Object object) {
37	return null;
38	}
39
40	public Color getTooltipForegroundColor(Object object) {
41	return null;
42	}
43
44	public int getTooltipDisplayDelayTime(Object object) {
45	return 0;
46	}
47
48	public Point getTooltipShift(Object object) {
49	return null;
50	}
51
52	public int getTooltipTimeDisplayed(Object object) {
53	return 0;
54	}
55
56	public boolean useNativeTooltip(Object object) {
57	return false;
58	}
59
60	public int getTooltipImageStyle(Object object) {
61	return SWT.SHADOW_NONE;
62	}
63	}

Added Link Here

(-)src/org/eclipse/jface/viewers/Cell.java (+41 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.internal.viewers.RowPart;
15	import org.eclipse.swt.graphics.Rectangle;
16
17	/**
18	* @since 3.2
19	*
20	*/
21	public class Cell {
22	private int columnIndex;
23	private RowPart row;
24
25	public Cell(RowPart row, int columnIndex) {
26	this.row = row;
27	this.columnIndex = columnIndex;
28	}
29
30	public int getColumnIndex() {
31	return columnIndex;
32	}
33
34	public Rectangle getBounds() {
35	return row.getBounds(columnIndex);
36	}
37
38	public Object getElement() {
39	return row.getElement();
40	}
41	}