Attachment #47722 for bug #149193

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




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

package org.eclipse.jface.viewers;

import org.eclipse.swt.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 #doFindItem(Object)
 * @see #internalRefresh(Object, boolean)
 */
public class TableViewer extends ColumnViewer {

	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;

	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
	 * <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>BORDER</code>. The

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

			}

		}
	}

	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getColumnViewerOwner(int)
	 */
	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.
	 * 

		tableViewerImpl.editElement(element, column);
	}


	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getCellEditors()
	 * @return the list of cell editors
	 */
	public CellEditor[] getCellEditors() {
		return tableViewerImpl.getCellEditors();
	}

	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getCellModifier()
	 * @return the cell modifier
	 */
	public ICellModifier getCellModifier() {
		return tableViewerImpl.getCellModifier();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getColumnProperties()
	 * correspond with the columns of the table control. They are used to
	 * identify the column in a cell modifier.
	 * 
	 * @return the list of column properties
	 */
	public Object[] getColumnProperties() {
		return tableViewerImpl.getColumnProperties();
	}

	/*
	 * (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);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.StructuredViewer#getRowPartFromItem(org.eclipse.swt.widgets.Widget)
	 */
	protected RowPart getRowPartFromItem(Widget item) {
		RowPart part = (RowPart)item.getData(RowPart.ROWPART_KEY);
		
		if( part == null ) {
			part = new TableRowPart(((TableItem)item));
		}
		
		return part;
	}
		
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.StructuredViewer#createNewRowPart(org.eclipse.jface.internal.viewers.RowPart, int, int)
	 */
	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);
	}
	
	/**
	 * Returns the item at the given display-relative coordinates, or
	 * <code>null</code> if there is no item at that location.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * </p>
	 * 
	 * @param x
	 *            horizontal coordinate
	 * @param y
	 *            vertical coordinate
	 * @return the item, or <code>null</code> if there is no item at the given
	 *         coordinates
	 */
	protected Item getItem(int x, int y) {
		return table.getItem(new Point(x,y));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.StructuredViewer#createColumnViewer(org.eclipse.swt.widgets.Widget, org.eclipse.jface.viewers.ViewerLabelProvider)
	 */
	protected ColumnViewerPart createColumnViewer(Widget columnOwner, ViewerLabelProvider labelProvider) {
		if( columnOwner instanceof TableColumn ) {
			return new TableColumnViewerPart((TableColumn)columnOwner,labelProvider);
		}
		
		return super.createColumnViewer(columnOwner, labelProvider);
	}
	
	
}





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

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getColumnViewerOwner(int)
	 */
	protected Widget getColumnViewerOwner(int columnIndex) {
		if( columnIndex < 0 || columnIndex > getTree().getColumnCount() ) {
			return null;
					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;

		treeViewerImpl.editElement(element, column);
	}


	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getCellEditors()
	 * @return the list of cell editors
	 * @since 3.1
	 */
	public CellEditor[] getCellEditors() {
		return treeViewerImpl.getCellEditors();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getCellModifier()
	 * 
	 * @return the cell modifier
	 * @since 3.1
	 */
	public ICellModifier getCellModifier() {
		return treeViewerImpl.getCellModifier();

		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getColumnProperties()
	 * correspond with the columns of the tree control. They are used to
	 * identify the column in a cell modifier.
	 * 
	 * @return the list of column properties
	 * @since 3.1
	 */
	public Object[] getColumnProperties() {
		return treeViewerImpl.getColumnProperties();

		return ((TreeItem) item).getExpanded();
	}

	/**
	 * Returns the item at the given display-relative coordinates, or
	 * <code>null</code> if there is no item at that location.
	 * <p>
	 * The default implementation of this method returns <code>null</code>.
	 * </p>
	 * 
	 * @param x
	 *            horizontal coordinate
	 * @param y
	 *            vertical coordinate
	 * @return the item, or <code>null</code> if there is no item at the given
	 *         coordinates
	 */
	protected Item getItem(int x, int y) {
		return getTree().getItem(getTree().toControl(new Point(x, y)));

	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);
						}
					}
				}
			});
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ColumnViewer#getRowPartFromItem(org.eclipse.swt.widgets.Widget)
	 */
	protected RowPart getRowPartFromItem(Widget item) {
		RowPart part = (RowPart)item.getData(RowPart.ROWPART_KEY);
		
		if( part == null ) {
			part = new TreeRowPart(((TreeItem)item));
		}
		
		return part;
	}
		
	/**
	 * Create a new RowPart at rowIndex
	 * @param parent
	 * @param style
	 * @param rowIndex
	 * @return RowPart
	 */
	private 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);
	}
}

Lines 54-60 Link Here

(-)src/org/eclipse/jface/viewers/AbstractTreeViewer.java (-1 / +1 lines)
54	* @see TreeViewer	54	* @see TreeViewer
55	* @see TableTreeViewer	55	* @see TableTreeViewer
56	*/	56	*/
57	public abstract class AbstractTreeViewer extends StructuredViewer {	57	public abstract class AbstractTreeViewer extends ColumnViewer {
58		58
59	/**	59	/**
60	* Constant indicating that all levels of the tree should be expanded or	60	* Constant indicating that all levels of the tree should be expanded or





    private int doubleClickExpirationTime;

    private ColumnViewer viewer;

    TreeEditorImpl(ColumnViewer viewer) {
        this.viewer = viewer;
        initCellEditorListener();
    }

    }

    private void activateCellEditor() {
    	ColumnViewerPart part = viewer.getColumnViewer(columnNumber);
    	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) {
        super(provider);
        Assert.isNotNull(provider);
        this.provider = 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);





    private int doubleClickExpirationTime;

    private ColumnViewer viewer;

    TableEditorImpl(ColumnViewer viewer) {
        this.viewer = viewer;
        initCellEditorListener();
    }

     * 
     * @return the viewer
     */
    public ColumnViewer getViewer() {
        return viewer;
    }

    private void activateCellEditor() {
    	ColumnViewerPart part = viewer.getColumnViewer(columnNumber);
    	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 519-522 Link Here

(-)src/org/eclipse/jface/viewers/TableTreeViewer.java (+7 lines)
519	protected void showItem(Item item) {	519	protected void showItem(Item item) {
520	getTableTree().showItem((TableTreeItem) item);	520	getTableTree().showItem((TableTreeItem) item);
521	}	521	}
		522
		523	/* (non-Javadoc)
		524	* @see org.eclipse.jface.viewers.ColumnViewer#getColumnViewerOwner(int)
		525	*/
		526	protected Widget getColumnViewerOwner(int columnIndex) {
		527	return null;
		528	}
522	}	529	}

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	}




/*******************************************************************************
 * 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
 *     Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.jface.util.Policy;
import org.eclipse.swt.widgets.Widget;

/**
 * The ColumnViewerPart is abstract implementation of the column parts.
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public class ColumnViewerPart {

	private ViewerLabelProvider labelProvider;

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

	private EditingSupport 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.
	 */
	EditingSupport getEditingSupport() {
		return editingSupport;
	}

	/**
	 * @param editingSupport
	 *            The editingSupport to set.
	 */
	void setEditingSupport(EditingSupport 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.getItem().getData(), 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
 *     Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Widget;

/**
 * The ColumnViewer is the abstract superclass of viewers that jave columns
 * (TreeViewer and TableViewer).
 * 
 * @since 3.3 <strong>EXPERIMENTAL</strong> This class or interface has been
 *        added as part of a work in progress. This API may change at any given
 *        time. Please do not use this API without consulting with the
 *        Platform/UI team.
 * 
 */
abstract class ColumnViewer extends StructuredViewer {

	private TooltipSupport tooltipSupport;

	/**
	 * Create a new instance of the receiver.
	 */
	public ColumnViewer() {
		super();
		tooltipSupport = new TooltipSupport(this);
	}

	/**
	 * Get the cell at this point.
	 * <p>
	 * <i>Subclasses should overwrite this method and provide a meaningful
	 * implementation</i>
	 * </p>
	 * 
	 * @param point
	 *            the point in the viewer where you need to corresponding cell
	 *            from
	 * @param onlyInSelection
	 *            search only in selection
	 * @return the cell or if no cell is found at this point
	 */
	Cell getCell(Point point) {
		RowPart row = getRowPart(point);
		if (row != null) {
			return row.getCell(point);
		}

		return null;
	}

	/**
	 * Get the RowPart at point.
	 * 
	 * @param point
	 * @return RowPart
	 */
	protected RowPart getRowPart(Point point) {
		Item item = getItem(point.x, point.y);

		if (item != null) {
			return getRowPartFromItem(item);
		}

		return null;
	}

	protected RowPart getRowPartFromItem(Widget item) {
		return (RowPart) item.getData(RowPart.ROWPART_KEY);
	}

	/**
	 * Get the widget for the column at columnIndex.
	 * 
	 * @param columnIndex
	 * @return Widget
	 */
	protected abstract Widget getColumnViewerOwner(int columnIndex);

	/**
	 * Returns the cell modifier of this viewer.
	 * 
	 * @return the cell modifier
	 * @since 3.1 (in subclasses, added in 3.3 to abstract class)
	 */
	public abstract ICellModifier getCellModifier();

	/**
	 * Return the CellEditors for the receiver.
	 * 
	 * @return CellEditor[]
	 * @since 3.1 (in subclasses, added in 3.3 to abstract class)
	 */
	public abstract CellEditor[] getCellEditors();

	/**
	 * Returns the column properties of this table viewer. The properties must
	 * correspond with the columns of the table control. They are used to
	 * identify the column in a cell modifier.
	 * 
	 * @return the list of column properties
	 * @since 3.1 (in subclasses, added in 3.3 to abstract class)
	 */
	public abstract Object[] getColumnProperties();

	/**
	 * Return the TableColumnViewer at columnIndex
	 * 
	 * @param columnIndex
	 * @return TableColumnViewer
	 */
	public ColumnViewerPart getColumnViewer(final int columnIndex) {

		ColumnViewerPart viewer;
		Widget columnOwner = getColumnViewerOwner(columnIndex);

		if (columnOwner == null) {
			return null;
		}

		viewer = (ColumnViewerPart) columnOwner
				.getData(ColumnViewerPart.COLUMN_VIEWER_KEY);

		if (viewer == null) {
			viewer = createColumnViewer(columnOwner, ViewerLabelProvider
					.createViewerLabelProvider(getLabelProvider()));
			if (getCellModifier() != null) {
				viewer.setEditingSupport(new EditingSupport() {

					/*
					 * (non-Javadoc)
					 * 
					 * @see org.eclipse.jface.viewers.EditingSupport#canEdit(java.lang.Object)
					 */
					public boolean canEdit(Object element) {
						return getCellModifier().canModify(element,
								(String) getColumnProperties()[columnIndex]);
					}

					/*
					 * (non-Javadoc)
					 * 
					 * @see org.eclipse.jface.viewers.EditingSupport#getCellEditor(java.lang.Object)
					 */
					public CellEditor getCellEditor(Object element) {
						return getCellEditors()[columnIndex];
					}

					/*
					 * (non-Javadoc)
					 * 
					 * @see org.eclipse.jface.viewers.EditingSupport#getValue(java.lang.Object)
					 */
					public Object getValue(Object element) {
						return getCellModifier().getValue(element,
								(String) getColumnProperties()[columnIndex]);
					}

					/*
					 * (non-Javadoc)
					 * 
					 * @see org.eclipse.jface.viewers.EditingSupport#setValue(java.lang.Object,
					 *      java.lang.Object)
					 */
					public void setValue(Object element, Object value) {
						getCellModifier().modify(findItem(element),
								(String) getColumnProperties()[columnIndex],
								value);
					}
				});
			}
		}

		// Reset the colum-index because maybe it changed from the last time
		viewer.getLabelProvider().setColumnIndex(columnIndex);

		return viewer;
	}

	/**
	 * Create a ColumnViewerPart for the columnOwner.
	 * 
	 * @param columnOwner
	 * @param labelProvider
	 * @return ColumnViewerPart
	 */
	protected ColumnViewerPart createColumnViewer(Widget columnOwner,
			ViewerLabelProvider labelProvider) {
		return new ColumnViewerPart(columnOwner, labelProvider);
	}

	/**
	 * Activate the tooltip support.
	 */
	public void activateCustomTooltips() {
		tooltipSupport.activate();
	}

	/**
	 * Deactivate the tooltip support.
	 */
	public void deactivateCustomTooltips() {
		tooltipSupport.deactivate();
	}

}




/*******************************************************************************
 * 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
 *     Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;


/**
 * TreeViewerLabelProvider is the ViewerLabelProvider that handles
 * TreePaths.
 * @since 3.3
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 *
 */
public class TreeColumnViewerLabelProvider extends TableColumnViewerLabelProvider {
	 private ITreePathLabelProvider treePathProvider;	
	
	
	/**
	 * Create a new instance of the receiver with the supplied labelProvider.
	 * @param labelProvider
	 */
	public TreeColumnViewerLabelProvider(IBaseLabelProvider labelProvider) {
		super(labelProvider);
	}

	/**
	 * 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
 *
 * @since 3.3
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Tom Shindl <tom.schindl@bestsolution.at> - 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.Item;
import org.eclipse.swt.widgets.TableItem;

/**
 * TableRowPart is the Table specific implementation of RowPart
 * @since 3.3
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 *
 */
public class TableRowPart extends RowPart {
	private TableItem item;
	
	/**
	 * Create a new instance of the receiver from item.
	 * @param item
	 */
	TableRowPart(TableItem item) {
		super(item);
		this.item = item;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getBounds(int)
	 */
	public Rectangle getBounds(int columnIndex) {
		return item.getBounds(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getBounds()
	 */
	public Rectangle getBounds() {
		return item.getBounds();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getItem()
	 */
	public Item getItem() {
		return item;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getColumnCount()
	 */
	public int getColumnCount() {
		return item.getParent().getColumnCount();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getBackground(int)
	 */
	public Color getBackground(int columnIndex) {
		return item.getBackground(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getFont(int)
	 */
	public Font getFont(int columnIndex) {
		return item.getFont(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getForeground(int)
	 */
	public Color getForeground(int columnIndex) {
		return item.getForeground(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getImage(int)
	 */
	public Image getImage(int columnIndex) {
		return item.getImage(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getText(int)
	 */
	public String getText(int columnIndex) {
		return item.getText(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setBackground(int, org.eclipse.swt.graphics.Color)
	 */
	public void setBackground(int columnIndex, Color color) {
		item.setBackground(columnIndex, color);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setFont(int, org.eclipse.swt.graphics.Font)
	 */
	public void setFont(int columnIndex, Font font) {
		item.setFont(columnIndex, font);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setForeground(int, org.eclipse.swt.graphics.Color)
	 */
	public void setForeground(int columnIndex, Color color) {
		item.setForeground(columnIndex, color);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setImage(int, org.eclipse.swt.graphics.Image)
	 */
	public void setImage(int columnIndex, Image image) {
		item.setImage(columnIndex,image);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setText(int, java.lang.String)
	 */
	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.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.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 * @since 3.3
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
 * @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));
	}


	/**
	 * 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
 *     Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

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;

/**
 * The ViewerLabelProvider is an abstract implementation of a 
 * label provider for structured viewers.
 * @since 3.3
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 */
public class ViewerLabelProvider extends LabelProvider implements
		ILabelProvider, IColorProvider, IFontProvider {

	private static ILabelProvider defaultLabelProvider = new LabelProvider() {

	};

	private ILabelProvider labelProvider = defaultLabelProvider;

	private IColorProvider colorProvider;

	private IFontProvider fontProvider;

	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 any providers for the receiver that can be adapted from provider.
	 * 
	 * @param provider
	 */
	public void setProviders(Object provider) {
		if (provider instanceof ILabelProvider)
			setLabelProvider((ILabelProvider) provider);

		if (provider instanceof IColorProvider)
			colorProvider = (IColorProvider) provider;

		if (provider instanceof IFontProvider)
			fontProvider = (IFontProvider) provider;

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
	 */
	public Font getFont(Object element) {
		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;
	}

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

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

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

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

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

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

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

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

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

	/**
	 * 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) {
		return SWT.SHADOW_NONE;
	}

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

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

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

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

	/**
	 * 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) {
		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
 *     Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import java.util.Timer;

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;

/**
 * The TooltipSupport is the class that provides tooltips for
 * ColumnViewers.
 * @since 3.3
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 *
 */
class TooltipSupport {
	private ColumnViewer viewer;
	private Listener listener = new MouseListener();
	private static final int DEFAULT_SHIFT_X = 10;
	private static final int DEFAULT_SHIFT_Y = 0;
	
	TooltipSupport(ColumnViewer 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();
		
		/* (non-Javadoc)
		 * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
		 */
		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;
			}
		}
		
		/**
		 * Popup a tooltip for the row at Point p.
		 * @param row
		 * @param p
		 */
		private void popupTooltip(RowPart row, Point p) {
			Object element = row.getItem().getData();
			disposeTooltip(tip);

			ColumnViewerPart viewPart = viewer.getColumnViewer(row.getColumnIndex(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);
			}
		}
		
		/**
		 * Dispose the tooltip.
		 * @param tip
		 */
		private void disposeTooltip(Shell tip) {
			if (tip != null && !tip.isDisposed()) {
				tip.dispose();
			}

			tip = null;
		}
	}
	
	/**
	 * TooltipHideListener is a listener for tooltip removal.
	 * @since 3.3
	 *
	 */
	private class TooltipHideListener implements Listener {
		/* (non-Javadoc)
		 * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
		 */
		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;

/**
 * EditingSupport is the abstract superclass of the support for cell editing.
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 * @since 3.3
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
 * 
 */
abstract class EditingSupport {
	/**
	 * The editor to be shown
	 * 
	 * @param element
	 *            the model element
	 * @return the CellEditor
	 */
	abstract CellEditor getCellEditor(Object element);

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

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

	/**
	 * Restore the value from the CellEditor
	 * 
	 * @param element
	 *            the model element
	 * @param value
	 *            the new value
	 */
	abstract 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.swt.widgets.TreeColumn;

/**
 * Wrapper class for {@link TreeColumn}
 * @since 3.3
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.

 * 
 */
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
 *     Tom Schindl <tom.schindl@bestsolution.at> - 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.Item;
import org.eclipse.swt.widgets.TreeItem;

/**
 * TreeRowPart is the Tree implementation of RowPart.
 * @since 3.3
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 *
 */
public class TreeRowPart extends RowPart {
	private TreeItem item;
	
	/**
	 * Create a new instance of the receiver.
	 * @param item
	 */
	TreeRowPart(TreeItem item) {
		super(item);
		this.item = item;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getBounds(int)
	 */
	public Rectangle getBounds(int columnIndex) {
		return item.getBounds(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getBounds()
	 */
	public Rectangle getBounds() {
		return item.getBounds();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getColumnCount()
	 */
	public int getColumnCount() {
		return item.getParent().getItemCount();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getItem()
	 */
	public Item getItem() {
		return item;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getBackground(int)
	 */
	public Color getBackground(int columnIndex) {
		return item.getBackground(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getFont(int)
	 */
	public Font getFont(int columnIndex) {
		return item.getFont(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getForeground(int)
	 */
	public Color getForeground(int columnIndex) {
		return item.getForeground(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getImage(int)
	 */
	public Image getImage(int columnIndex) {
		return item.getImage(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#getText(int)
	 */
	public String getText(int columnIndex) {
		return item.getText(columnIndex);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setBackground(int, org.eclipse.swt.graphics.Color)
	 */
	public void setBackground(int columnIndex, Color color) {
		item.setBackground(columnIndex, color);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setFont(int, org.eclipse.swt.graphics.Font)
	 */
	public void setFont(int columnIndex, Font font) {
		item.setFont(columnIndex, font);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setForeground(int, org.eclipse.swt.graphics.Color)
	 */
	public void setForeground(int columnIndex, Color color) {
		item.setForeground(columnIndex, color);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setImage(int, org.eclipse.swt.graphics.Image)
	 */
	public void setImage(int columnIndex, Image image) {
		item.setImage(columnIndex,image);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.RowPart#setText(int, java.lang.String)
	 */
	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
 *     Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.jface.util.Policy;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
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.Item;

/**
 * RowPart is the abstract superclass of the part that represents items in a 
 * Table or Tree.
 * @since 3.3
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 * 
 */
public abstract class RowPart {
	/**
	 * Key used to reference RowPart in the widgets data-map
	 */
	public static final String ROWPART_KEY = Policy.JFACE + ".ROWPART"; //$NON-NLS-1$
		
	/**
	 * Create a new instance of the receiver.
	 * @param item
	 */
	RowPart(final Item item) {
		item.setData(RowPart.ROWPART_KEY, this);
		item.addDisposeListener(new DisposeListener() {

			/* (non-Javadoc)
			 * @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
			 */
			public void widgetDisposed(DisposeEvent e) {
				item.setData(ROWPART_KEY, null);
			}
			
		});
	}
	
	/**
	 * Get the bounds of the entry at the columnIndex,
	 * @param columnIndex
	 * @return Rectangle
	 */
	public abstract Rectangle getBounds(int columnIndex);

	/**
	 * Return the bounds for the whole item.
	 * @return Rectangle
	 */
	public abstract Rectangle getBounds();

	/**
	 * Return the item for the receiver.
	 * @return Item
	 */
	public abstract Item getItem();

	/**
	 * Return the number of columns for the receiver.
	 * @return int
	 */
	public abstract int getColumnCount();
	
	/**
	 * Return the image at the columnIndex.
	 * @param columnIndex
	 * @return Image
	 */
	public abstract Image getImage(int columnIndex);
	
	/**
	 * Set the image at the columnIndex
	 * @param columnIndex
	 * @param image
	 */
	public abstract void setImage(int columnIndex,Image image);
	
	/**
	 * Get the text at the columnIndex.
	 * @param columnIndex
	 * @return String
	 */
	public abstract String getText(int columnIndex);
	
	/**
	 * Set the text at the columnIndex
	 * @param columnIndex
	 * @param text
	 */
	public abstract void setText(int columnIndex,String text);
	
	/**
	 * Get the background at the columnIndex,
	 * @param columnIndex
	 * @return Color
	 */
	public abstract Color getBackground(int columnIndex);
	
	/**
	 * Set the background at the columnIndex.
	 * @param columnIndex
	 * @param color
	 */
	public abstract void setBackground(int columnIndex, Color color);
	
	/**
	 * Get the foreground at the columnIndex.
	 * @param columnIndex
	 * @return Color
	 */
	public abstract Color getForeground(int columnIndex);
	
	/**
	 * Set the foreground at the columnIndex.
	 * @param columnIndex
	 * @param color
	 */
	public abstract void setForeground(int columnIndex, Color color);
	
	/**
	 * Get the font at the columnIndex.
	 * @param columnIndex
	 * @return Font
	 */
	public abstract Font getFont(int columnIndex);
	
	/**
	 * Set the font at the columnIndex.
	 * @param columnIndex
	 * @param font
	 */
	public abstract void setFont(int columnIndex,Font font);
	
	
	/**
	 * Get the Cell at point.
	 * @param point
	 * @return Cell
	 */
	public Cell getCell(Point point) {
		int index = getColumnIndex(point);
		
		if( index >= 0 ) {
			return new Cell(this,index);
		}

		return null;
	}
	
	/**
	 * Get the columnIndex of the point.
	 * @param point
	 * @return the column index or -1 if it cannot be found.
	 */
	public int getColumnIndex(Point point) {
		int count = getColumnCount();
		
		for(int i = 0; i < count; i++ ) {
			if( getBounds(i).contains(point) ) {
				return i;
			}
		}
		
		return -1;
	}
	
}




/*******************************************************************************
 * 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
 *     Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.swt.graphics.Rectangle;

/**
 * The Cell is the JFace representation of a cell entry in a RowPart.
 * @since 3.3
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 *
 */
public class Cell {
	private int columnIndex;
	private RowPart row;
	
	/**
	 * Create a new instance of the receiver on the row.
	 * @param row
	 * @param columnIndex
	 */
	public Cell(RowPart row, int columnIndex) {
		this.row = row;
		this.columnIndex = columnIndex;
	}
	
	/**
	 * Get the index of the cell.
	 * @return int
	 */
	public int getColumnIndex() {
		return columnIndex;
	}
	
	/**
	 * Get the bounds of the cell.
	 * @return Rectangle
	 */
	public Rectangle getBounds() {
		return row.getBounds(columnIndex);
	}
	
	/**
	 * Get the element this row represents.
	 * @return Object
	 */
	public Object getElement() {
		return row.getItem().getData();
	}
}




/*******************************************************************************
 * 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}
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as
 * part of a work in progress. This API may change at any given time. Please 
 * do not use this API without consulting with the Platform/UI team.
 * @since 3.3
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
 * 
 */
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;
	}
}

Return to bug 149193

Lines 49-57 Link Here

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

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 43-50 Link Here
43	*/	41	*/
44	public DecoratingLabelProvider(ILabelProvider provider,	42	public DecoratingLabelProvider(ILabelProvider provider,
45	ILabelDecorator decorator) {	43	ILabelDecorator decorator) {
		44	super(provider);
46	Assert.isNotNull(provider);	45	Assert.isNotNull(provider);
47	this.provider = 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 49-57 Link Here

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

Added Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerPart.java (+158 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	* Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
11	******************************************************************************/
12
13	package org.eclipse.jface.viewers;
14
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	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
21	* part of a work in progress. This API may change at any given time. Please
22	* do not use this API without consulting with the Platform/UI team.
23	*
24	* @since 3.3
25	*
26	*/
27	public class ColumnViewerPart {
28
29	private ViewerLabelProvider labelProvider;
30
31	static String COLUMN_VIEWER_KEY = Policy.JFACE + ".columnViewer";//$NON-NLS-1$
32
33	private EditingSupport editingSupport;
34
35
36
37
38	/**
39	* Create a new instance of the receiver at columnIndex.
40	*
41	* @param columnOwner
42	* @param provider
43	*/
44	public ColumnViewerPart(Widget columnOwner, ViewerLabelProvider provider) {
45	labelProvider = provider;
46	columnOwner.setData(ColumnViewerPart.COLUMN_VIEWER_KEY, this);
47	}
48
49	/**
50	* Return the label provider for the receiver.
51	*
52	* @return ViewerLabelProvider
53	*/
54	public ViewerLabelProvider getLabelProvider() {
55	return labelProvider;
56	}
57
58	/**
59	* @param labelProvider
60	* the new label-provider
61	*/
62	public void setLabelProvider(ViewerLabelProvider labelProvider) {
63	this.labelProvider = labelProvider;
64	}
65
66	/**
67	* @return Returns the editingSupport.
68	*/
69	EditingSupport getEditingSupport() {
70	return editingSupport;
71	}
72
73	/**
74	* @param editingSupport
75	* The editingSupport to set.
76	*/
77	void setEditingSupport(EditingSupport editingSupport) {
78	this.editingSupport = editingSupport;
79	}
80
81	/**
82	* Refresh the row for the given columnIndex
83	*
84	* @param row
85	* @param element
86	* @param columnIndex
87	*/
88	public void refresh(RowPart row, int columnIndex) {
89	ViewerLabel label = new ViewerLabel(row.getText(columnIndex), row
90	.getImage(columnIndex));
91	getLabelProvider().updateLabel(label, row.getItem().getData(), columnIndex);
92
93	row.setBackground(columnIndex, label.getBackground());
94	row.setForeground(columnIndex, label.getForeground());
95	row.setFont(columnIndex, label.getFont());
96
97	if (label.hasNewText())
98	row.setText(columnIndex, label.getText());
99
100	if (label.hasNewImage())
101	row.setImage(columnIndex, label.getImage());
102	}
103
104	/**
105	* Refresh the TreeItem for element.
106	*
107	* @param item
108	* @param element
109	* @param columnIndex
110	*/
111	/* public void refresh(TreeItem item, Object element, int columnIndex) {
112
113	ViewerLabel label = new ViewerLabel(item.getText(columnIndex), item
114	.getImage(columnIndex));
115	getLabelProvider().updateLabel(label, element, columnIndex);
116
117	// We can not make a null check because then we could not
118	// set the items back to default state
119	item.setBackground(columnIndex, label.getBackground());
120	item.setForeground(columnIndex, label.getForeground());
121	item.setFont(columnIndex, label.getFont());
122
123	if (label.hasNewText())
124	item.setText(columnIndex, label.getText());
125
126	if (label.hasNewImage())
127	item.setImage(columnIndex, label.getImage());
128	}
129	*/
130	/**
131	* Refresh the TableItem for element.
132	*
133	* @param item
134	* @param element
135	* @param columnIndex
136	*/
137	/* public void refresh(TableItem item, Object element, int columnIndex) {
138
139	ViewerLabel label = new ViewerLabel(item.getText(columnIndex), item
140	.getImage(columnIndex));
141	getLabelProvider().updateLabel(label, element, columnIndex);
142
143	if (label.hasNewBackground())
144	item.setBackground(columnIndex, label.getBackground());
145
146	if (label.hasNewForeground())
147	item.setForeground(columnIndex, label.getForeground());
148
149	if (label.hasNewFont())
150	item.setFont(columnIndex, label.getFont());
151
152	if (label.hasNewText())
153	item.setText(columnIndex, label.getText());
154
155	if (label.hasNewImage())
156	item.setImage(columnIndex, label.getImage());
157	}*/
158	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TreeColumnViewerLabelProvider.java (+64 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	* Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
11	******************************************************************************/
12
13	package org.eclipse.jface.viewers;
14
15
16	/**
17	* TreeViewerLabelProvider is the ViewerLabelProvider that handles
18	* TreePaths.
19	* @since 3.3
20	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
21	* part of a work in progress. This API may change at any given time. Please
22	* do not use this API without consulting with the Platform/UI team.
23	*
24	*/
25	public class TreeColumnViewerLabelProvider extends TableColumnViewerLabelProvider {
26	private ITreePathLabelProvider treePathProvider;
27
28
29	/**
30	* Create a new instance of the receiver with the supplied labelProvider.
31	* @param labelProvider
32	*/
33	public TreeColumnViewerLabelProvider(IBaseLabelProvider labelProvider) {
34	super(labelProvider);
35	}
36
37	/**
38	* Update the label for the element with TreePath.
39	* @param label
40	* @param elementPath
41	*/
42	public void updateLabel(ViewerLabel label, TreePath elementPath) {
43	treePathProvider.updateLabel(label, elementPath);
44
45	}
46
47	/* (non-Javadoc)
48	* @see org.eclipse.jface.viewers.ViewerLabelProvider#setProviders(java.lang.Object)
49	*/
50	public void setProviders(Object provider) {
51	super.setProviders(provider);
52	if(provider instanceof ITreePathLabelProvider)
53	treePathProvider = (ITreePathLabelProvider) provider;
54	}
55
56	/**
57	* Return the ITreePathLabelProvider for the receiver.
58	* @return Returns the treePathProvider.
59	*/
60	public ITreePathLabelProvider getTreePathProvider() {
61	return treePathProvider;
62	}
63
64	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TableRowPart.java (+141 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	* @since 3.3
9	* Contributors:
10	* IBM Corporation - initial API and implementation
11	* Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
12	******************************************************************************/
13
14	package org.eclipse.jface.viewers;
15
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.Rectangle;
20	import org.eclipse.swt.widgets.Item;
21	import org.eclipse.swt.widgets.TableItem;
22
23	/**
24	* TableRowPart is the Table specific implementation of RowPart
25	* @since 3.3
26	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
27	* part of a work in progress. This API may change at any given time. Please
28	* do not use this API without consulting with the Platform/UI team.
29	*
30	*/
31	public class TableRowPart extends RowPart {
32	private TableItem item;
33
34	/**
35	* Create a new instance of the receiver from item.
36	* @param item
37	*/
38	TableRowPart(TableItem item) {
39	super(item);
40	this.item = item;
41	}
42
43	/* (non-Javadoc)
44	* @see org.eclipse.jface.viewers.RowPart#getBounds(int)
45	*/
46	public Rectangle getBounds(int columnIndex) {
47	return item.getBounds(columnIndex);
48	}
49
50	/* (non-Javadoc)
51	* @see org.eclipse.jface.viewers.RowPart#getBounds()
52	*/
53	public Rectangle getBounds() {
54	return item.getBounds();
55	}
56
57	/* (non-Javadoc)
58	* @see org.eclipse.jface.viewers.RowPart#getItem()
59	*/
60	public Item getItem() {
61	return item;
62	}
63
64	/* (non-Javadoc)
65	* @see org.eclipse.jface.viewers.RowPart#getColumnCount()
66	*/
67	public int getColumnCount() {
68	return item.getParent().getColumnCount();
69	}
70
71	/* (non-Javadoc)
72	* @see org.eclipse.jface.viewers.RowPart#getBackground(int)
73	*/
74	public Color getBackground(int columnIndex) {
75	return item.getBackground(columnIndex);
76	}
77
78	/* (non-Javadoc)
79	* @see org.eclipse.jface.viewers.RowPart#getFont(int)
80	*/
81	public Font getFont(int columnIndex) {
82	return item.getFont(columnIndex);
83	}
84
85	/* (non-Javadoc)
86	* @see org.eclipse.jface.viewers.RowPart#getForeground(int)
87	*/
88	public Color getForeground(int columnIndex) {
89	return item.getForeground(columnIndex);
90	}
91
92	/* (non-Javadoc)
93	* @see org.eclipse.jface.viewers.RowPart#getImage(int)
94	*/
95	public Image getImage(int columnIndex) {
96	return item.getImage(columnIndex);
97	}
98
99	/* (non-Javadoc)
100	* @see org.eclipse.jface.viewers.RowPart#getText(int)
101	*/
102	public String getText(int columnIndex) {
103	return item.getText(columnIndex);
104	}
105
106	/* (non-Javadoc)
107	* @see org.eclipse.jface.viewers.RowPart#setBackground(int, org.eclipse.swt.graphics.Color)
108	*/
109	public void setBackground(int columnIndex, Color color) {
110	item.setBackground(columnIndex, color);
111	}
112
113	/* (non-Javadoc)
114	* @see org.eclipse.jface.viewers.RowPart#setFont(int, org.eclipse.swt.graphics.Font)
115	*/
116	public void setFont(int columnIndex, Font font) {
117	item.setFont(columnIndex, font);
118	}
119
120	/* (non-Javadoc)
121	* @see org.eclipse.jface.viewers.RowPart#setForeground(int, org.eclipse.swt.graphics.Color)
122	*/
123	public void setForeground(int columnIndex, Color color) {
124	item.setForeground(columnIndex, color);
125	}
126
127	/* (non-Javadoc)
128	* @see org.eclipse.jface.viewers.RowPart#setImage(int, org.eclipse.swt.graphics.Image)
129	*/
130	public void setImage(int columnIndex, Image image) {
131	item.setImage(columnIndex,image);
132	}
133
134	/* (non-Javadoc)
135	* @see org.eclipse.jface.viewers.RowPart#setText(int, java.lang.String)
136	*/
137	public void setText(int columnIndex, String text) {
138	item.setText(columnIndex, text);
139	}
140
141	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TableColumnViewerLabelProvider.java (+139 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	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
23	* part of a work in progress. This API may change at any given time. Please
24	* do not use this API without consulting with the Platform/UI team.
25	* @since 3.3
26	* Contributors:
27	* IBM Corporation - initial API and implementation
28	* Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
29	* @see ITableLabelProvider
30	* @see ITableColorProvider
31	* @see ITableFontProvider
32	*
33	*/
34	class TableColumnViewerLabelProvider extends ViewerLabelProvider {
35
36	/**
37	* Create a new instance of the receiver.
38	*
39	* @param labelProvider
40	* instance of a table based label provider
41	* @param columnIndex
42	* the index into the table for this column
43	* @see ITableLabelProvider
44	* @see ITableColorProvider
45	* @see ITableFontProvider
46	*/
47	public TableColumnViewerLabelProvider(IBaseLabelProvider labelProvider) {
48	super(labelProvider);
49
50	if (labelProvider instanceof ITableLabelProvider)
51	setLabelProvider(labelProviderFor((ITableLabelProvider) labelProvider));
52
53	if (labelProvider instanceof ITableColorProvider)
54	setColorProvider(colorProviderFor((ITableColorProvider) labelProvider));
55
56	if (labelProvider instanceof ITableFontProvider)
57	setFontProvider(fontProviderFor((ITableFontProvider) labelProvider));
58	}
59
60
61	/**
62	* Return the IFontProvider based on provider at columnIndex.
63	*
64	* @param provider
65	* @param columnIndex
66	* @return IFontProvider
67	*/
68	private IFontProvider fontProviderFor(final ITableFontProvider provider) {
69	return new IFontProvider() {
70	/*
71	* (non-Javadoc)
72	*
73	* @see org.eclipse.jface.viewers.IFontProvider#getFont(java.lang.Object)
74	*/
75	public Font getFont(Object element) {
76	return provider.getFont(element, getColumnIndex());
77	}
78	};
79	}
80
81	/**
82	* Return the ILabelProvider based on provider at columnIndex.
83	*
84	* @param provider
85	* @param columnIndex
86	* @return ILabelProvider
87	*/
88	private ILabelProvider labelProviderFor(final ITableLabelProvider provider) {
89	return new LabelProvider() {
90	/*
91	* (non-Javadoc)
92	*
93	* @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
94	*/
95	public String getText(Object element) {
96	return provider.getColumnText(element, getColumnIndex());
97	}
98
99	/*
100	* (non-Javadoc)
101	*
102	* @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
103	*/
104	public Image getImage(Object element) {
105	return provider.getColumnImage(element, getColumnIndex());
106	}
107	};
108	}
109
110	/**
111	* Create an IColorProvider from the ITableColorProvider at columnIndex.
112	*
113	* @param provider
114	* @param columnIndex
115	* @return IColorProvider
116	*/
117	private IColorProvider colorProviderFor(final ITableColorProvider provider) {
118	return new IColorProvider() {
119	/*
120	* (non-Javadoc)
121	*
122	* @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
123	*/
124	public Color getBackground(Object element) {
125	return provider.getBackground(element, getColumnIndex());
126	}
127
128	/*
129	* (non-Javadoc)
130	*
131	* @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
132	*/
133	public Color getForeground(Object element) {
134	return provider.getForeground(element, getColumnIndex());
135	}
136	};
137	}
138
139	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TooltipSupport.java (+212 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	* Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
11	******************************************************************************/
12
13	package org.eclipse.jface.viewers;
14
15	import java.util.Timer;
16
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	* The TooltipSupport is the class that provides tooltips for
30	* ColumnViewers.
31	* @since 3.3
32	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
33	* part of a work in progress. This API may change at any given time. Please
34	* do not use this API without consulting with the Platform/UI team.
35	*
36	*/
37	class TooltipSupport {
38	private ColumnViewer viewer;
39	private Listener listener = new MouseListener();
40	private static final int DEFAULT_SHIFT_X = 10;
41	private static final int DEFAULT_SHIFT_Y = 0;
42
43	TooltipSupport(ColumnViewer viewer) {
44	this.viewer = viewer;
45	}
46
47	/**
48	* activate tooltip support for this viewer
49	*/
50	public void activate() {
51	deactivate();
52	viewer.getControl().addListener(SWT.Dispose, listener);
53	viewer.getControl().addListener(SWT.MouseHover, listener);
54	viewer.getControl().addListener(SWT.MouseMove, listener);
55	viewer.getControl().addListener(SWT.MouseExit, listener);
56	viewer.getControl().addListener(SWT.MouseDown, listener);
57	}
58
59	/**
60	* deactivate tooltip support for this viewer
61	*/
62	public void deactivate() {
63	viewer.getControl().removeListener(SWT.Dispose, listener);
64	viewer.getControl().removeListener(SWT.MouseHover, listener);
65	viewer.getControl().removeListener(SWT.MouseMove, listener);
66	viewer.getControl().removeListener(SWT.MouseExit, listener);
67	viewer.getControl().removeListener(SWT.MouseDown, listener);
68	}
69
70	private class MouseListener implements Listener {
71	private Shell tip;
72	private TooltipHideListener hideListener = new TooltipHideListener();
73	private Timer timer = new Timer();
74
75	/* (non-Javadoc)
76	* @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
77	*/
78	public void handleEvent(Event event) {
79	switch (event.type) {
80	case SWT.Dispose:
81	if( timer != null ) {
82	timer.cancel();
83	}
84	case SWT.KeyDown:
85	case SWT.MouseMove:
86	case SWT.MouseDown:
87	disposeTooltip(tip);
88	break;
89	case SWT.MouseHover:
90	Point p = new Point(event.x, event.y);
91	RowPart row = viewer.getRowPart(p);
92	viewer.getControl().setToolTipText(""); //$NON-NLS-1$
93
94	if (row != null) {
95	popupTooltip(row, p);
96	}
97
98	break;
99	}
100	}
101
102	/**
103	* Popup a tooltip for the row at Point p.
104	* @param row
105	* @param p
106	*/
107	private void popupTooltip(RowPart row, Point p) {
108	Object element = row.getItem().getData();
109	disposeTooltip(tip);
110
111	ColumnViewerPart viewPart = viewer.getColumnViewer(row.getColumnIndex(p));
112
113	if( viewPart == null ) {
114	return;
115	}
116
117	ViewerLabelProvider labelProvider = viewPart.getLabelProvider();
118
119	String text = labelProvider.getTooltipText(element);
120
121	if( text != null ) {
122
123	if( labelProvider.useNativeTooltip(element) ) {
124	viewer.getControl().setToolTipText(text);
125	return;
126	}
127
128	tip = new Shell(viewer.getControl().getShell(), SWT.ON_TOP \| SWT.TOOL);
129	tip.setLayout(new FillLayout());
130	CLabel label = new CLabel(tip, labelProvider.getTooltipImageStyle(element));
131	label.setText(text);
132	label.addListener(SWT.MouseExit, hideListener);
133	label.addListener(SWT.MouseDown, hideListener);
134
135	Image img = labelProvider.getTooltipImage(element);
136
137	if( img != null) {
138	label.setImage(img);
139	}
140
141	Color color = labelProvider.getTooltipForegroundColor(element);
142	if( color == null ) {
143	color = viewer.getControl().getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND);
144	}
145	label.setForeground(color);
146
147	color = labelProvider.getTooltipBackgroundColor(element);
148	if( color == null ) {
149	color = viewer.getControl().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND);
150	}
151	label.setBackground(color);
152
153	Font font = labelProvider.getTooltipFont(element);
154
155	if( font != null ) {
156	label.setFont(font);
157	}
158
159	Point pt = viewer.getControl().toDisplay(p);
160	Point shift = labelProvider.getTooltipShift(element);
161
162	if( shift == null ) {
163	pt.x += DEFAULT_SHIFT_X;
164	pt.y += DEFAULT_SHIFT_Y;
165	} else {
166	pt.x += shift.x;
167	pt.y += shift.y;
168	}
169
170	tip.pack();
171	tip.setLocation(pt);
172	tip.setVisible(true);
173	}
174	}
175
176	/**
177	* Dispose the tooltip.
178	* @param tip
179	*/
180	private void disposeTooltip(Shell tip) {
181	if (tip != null && !tip.isDisposed()) {
182	tip.dispose();
183	}
184
185	tip = null;
186	}
187	}
188
189	/**
190	* TooltipHideListener is a listener for tooltip removal.
191	* @since 3.3
192	*
193	*/
194	private class TooltipHideListener implements Listener {
195	/* (non-Javadoc)
196	* @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
197	*/
198	public void handleEvent(Event event) {
199	CLabel label = (CLabel) event.widget;
200	Shell shell = label.getShell();
201	switch (event.type) {
202	case SWT.MouseDown:
203	viewer.setSelection(new StructuredSelection());
204	// fall through
205	case SWT.MouseExit:
206	viewer.getControl().setFocus();
207	shell.dispose();
208	break;
209	}
210	}
211	}
212	}

Added Link Here

(-)src/org/eclipse/jface/viewers/EditingSupport.java (+62 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	* EditingSupport is the abstract superclass of the support for cell editing.
16	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
17	* part of a work in progress. This API may change at any given time. Please
18	* do not use this API without consulting with the Platform/UI team.
19	* @since 3.3
20	* Contributors:
21	* IBM Corporation - initial API and implementation
22	* Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
23	*
24	*/
25	abstract class EditingSupport {
26	/**
27	* The editor to be shown
28	*
29	* @param element
30	* the model element
31	* @return the CellEditor
32	*/
33	abstract CellEditor getCellEditor(Object element);
34
35	/**
36	* Is the cell editable
37	*
38	* @param element
39	* the model element
40	* @return true if editable
41	*/
42	abstract boolean canEdit(Object element);
43
44	/**
45	* Get the value to set to the editor
46	*
47	* @param element
48	* the model element
49	* @return the value shown
50	*/
51	abstract Object getValue(Object element);
52
53	/**
54	* Restore the value from the CellEditor
55	*
56	* @param element
57	* the model element
58	* @param value
59	* the new value
60	*/
61	abstract void setValue(Object element, Object value);
62	}

Added Link Here

(-)src/org/eclipse/jface/viewers/TreeRowPart.java (+139 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	* Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
11	******************************************************************************/
12
13	package org.eclipse.jface.viewers;
14
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.Item;
20	import org.eclipse.swt.widgets.TreeItem;
21
22	/**
23	* TreeRowPart is the Tree implementation of RowPart.
24	* @since 3.3
25	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
26	* part of a work in progress. This API may change at any given time. Please
27	* do not use this API without consulting with the Platform/UI team.
28	*
29	*/
30	public class TreeRowPart extends RowPart {
31	private TreeItem item;
32
33	/**
34	* Create a new instance of the receiver.
35	* @param item
36	*/
37	TreeRowPart(TreeItem item) {
38	super(item);
39	this.item = item;
40	}
41
42	/* (non-Javadoc)
43	* @see org.eclipse.jface.viewers.RowPart#getBounds(int)
44	*/
45	public Rectangle getBounds(int columnIndex) {
46	return item.getBounds(columnIndex);
47	}
48
49	/* (non-Javadoc)
50	* @see org.eclipse.jface.viewers.RowPart#getBounds()
51	*/
52	public Rectangle getBounds() {
53	return item.getBounds();
54	}
55
56	/* (non-Javadoc)
57	* @see org.eclipse.jface.viewers.RowPart#getColumnCount()
58	*/
59	public int getColumnCount() {
60	return item.getParent().getItemCount();
61	}
62
63	/* (non-Javadoc)
64	* @see org.eclipse.jface.viewers.RowPart#getItem()
65	*/
66	public Item getItem() {
67	return item;
68	}
69
70	/* (non-Javadoc)
71	* @see org.eclipse.jface.viewers.RowPart#getBackground(int)
72	*/
73	public Color getBackground(int columnIndex) {
74	return item.getBackground(columnIndex);
75	}
76
77	/* (non-Javadoc)
78	* @see org.eclipse.jface.viewers.RowPart#getFont(int)
79	*/
80	public Font getFont(int columnIndex) {
81	return item.getFont(columnIndex);
82	}
83
84	/* (non-Javadoc)
85	* @see org.eclipse.jface.viewers.RowPart#getForeground(int)
86	*/
87	public Color getForeground(int columnIndex) {
88	return item.getForeground(columnIndex);
89	}
90
91	/* (non-Javadoc)
92	* @see org.eclipse.jface.viewers.RowPart#getImage(int)
93	*/
94	public Image getImage(int columnIndex) {
95	return item.getImage(columnIndex);
96	}
97
98	/* (non-Javadoc)
99	* @see org.eclipse.jface.viewers.RowPart#getText(int)
100	*/
101	public String getText(int columnIndex) {
102	return item.getText(columnIndex);
103	}
104
105	/* (non-Javadoc)
106	* @see org.eclipse.jface.viewers.RowPart#setBackground(int, org.eclipse.swt.graphics.Color)
107	*/
108	public void setBackground(int columnIndex, Color color) {
109	item.setBackground(columnIndex, color);
110	}
111
112	/* (non-Javadoc)
113	* @see org.eclipse.jface.viewers.RowPart#setFont(int, org.eclipse.swt.graphics.Font)
114	*/
115	public void setFont(int columnIndex, Font font) {
116	item.setFont(columnIndex, font);
117	}
118
119	/* (non-Javadoc)
120	* @see org.eclipse.jface.viewers.RowPart#setForeground(int, org.eclipse.swt.graphics.Color)
121	*/
122	public void setForeground(int columnIndex, Color color) {
123	item.setForeground(columnIndex, color);
124	}
125
126	/* (non-Javadoc)
127	* @see org.eclipse.jface.viewers.RowPart#setImage(int, org.eclipse.swt.graphics.Image)
128	*/
129	public void setImage(int columnIndex, Image image) {
130	item.setImage(columnIndex,image);
131	}
132
133	/* (non-Javadoc)
134	* @see org.eclipse.jface.viewers.RowPart#setText(int, java.lang.String)
135	*/
136	public void setText(int columnIndex, String text) {
137	item.setText(columnIndex, text);
138	}
139	}

Added Link Here

(-)src/org/eclipse/jface/viewers/RowPart.java (+186 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	* Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
11	******************************************************************************/
12
13	package org.eclipse.jface.viewers;
14
15	import org.eclipse.jface.util.Policy;
16	import org.eclipse.swt.events.DisposeEvent;
17	import org.eclipse.swt.events.DisposeListener;
18	import org.eclipse.swt.graphics.Color;
19	import org.eclipse.swt.graphics.Font;
20	import org.eclipse.swt.graphics.Image;
21	import org.eclipse.swt.graphics.Point;
22	import org.eclipse.swt.graphics.Rectangle;
23	import org.eclipse.swt.widgets.Item;
24
25	/**
26	* RowPart is the abstract superclass of the part that represents items in a
27	* Table or Tree.
28	* @since 3.3
29	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
30	* part of a work in progress. This API may change at any given time. Please
31	* do not use this API without consulting with the Platform/UI team.
32	*
33	*/
34	public abstract class RowPart {
35	/**
36	* Key used to reference RowPart in the widgets data-map
37	*/
38	public static final String ROWPART_KEY = Policy.JFACE + ".ROWPART"; //$NON-NLS-1$
39
40	/**
41	* Create a new instance of the receiver.
42	* @param item
43	*/
44	RowPart(final Item item) {
45	item.setData(RowPart.ROWPART_KEY, this);
46	item.addDisposeListener(new DisposeListener() {
47
48	/* (non-Javadoc)
49	* @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
50	*/
51	public void widgetDisposed(DisposeEvent e) {
52	item.setData(ROWPART_KEY, null);
53	}
54
55	});
56	}
57
58	/**
59	* Get the bounds of the entry at the columnIndex,
60	* @param columnIndex
61	* @return Rectangle
62	*/
63	public abstract Rectangle getBounds(int columnIndex);
64
65	/**
66	* Return the bounds for the whole item.
67	* @return Rectangle
68	*/
69	public abstract Rectangle getBounds();
70
71	/**
72	* Return the item for the receiver.
73	* @return Item
74	*/
75	public abstract Item getItem();
76
77	/**
78	* Return the number of columns for the receiver.
79	* @return int
80	*/
81	public abstract int getColumnCount();
82
83	/**
84	* Return the image at the columnIndex.
85	* @param columnIndex
86	* @return Image
87	*/
88	public abstract Image getImage(int columnIndex);
89
90	/**
91	* Set the image at the columnIndex
92	* @param columnIndex
93	* @param image
94	*/
95	public abstract void setImage(int columnIndex,Image image);
96
97	/**
98	* Get the text at the columnIndex.
99	* @param columnIndex
100	* @return String
101	*/
102	public abstract String getText(int columnIndex);
103
104	/**
105	* Set the text at the columnIndex
106	* @param columnIndex
107	* @param text
108	*/
109	public abstract void setText(int columnIndex,String text);
110
111	/**
112	* Get the background at the columnIndex,
113	* @param columnIndex
114	* @return Color
115	*/
116	public abstract Color getBackground(int columnIndex);
117
118	/**
119	* Set the background at the columnIndex.
120	* @param columnIndex
121	* @param color
122	*/
123	public abstract void setBackground(int columnIndex, Color color);
124
125	/**
126	* Get the foreground at the columnIndex.
127	* @param columnIndex
128	* @return Color
129	*/
130	public abstract Color getForeground(int columnIndex);
131
132	/**
133	* Set the foreground at the columnIndex.
134	* @param columnIndex
135	* @param color
136	*/
137	public abstract void setForeground(int columnIndex, Color color);
138
139	/**
140	* Get the font at the columnIndex.
141	* @param columnIndex
142	* @return Font
143	*/
144	public abstract Font getFont(int columnIndex);
145
146	/**
147	* Set the font at the columnIndex.
148	* @param columnIndex
149	* @param font
150	*/
151	public abstract void setFont(int columnIndex,Font font);
152
153
154	/**
155	* Get the Cell at point.
156	* @param point
157	* @return Cell
158	*/
159	public Cell getCell(Point point) {
160	int index = getColumnIndex(point);
161
162	if( index >= 0 ) {
163	return new Cell(this,index);
164	}
165
166	return null;
167	}
168
169	/**
170	* Get the columnIndex of the point.
171	* @param point
172	* @return the column index or -1 if it cannot be found.
173	*/
174	public int getColumnIndex(Point point) {
175	int count = getColumnCount();
176
177	for(int i = 0; i < count; i++ ) {
178	if( getBounds(i).contains(point) ) {
179	return i;
180	}
181	}
182
183	return -1;
184	}
185
186	}

Added Link Here

(-)src/org/eclipse/jface/viewers/Cell.java (+62 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	* Tom Shindl <tom.schindl@bestsolution.at> - initial API and implementation
11	******************************************************************************/
12
13	package org.eclipse.jface.viewers;
14
15	import org.eclipse.swt.graphics.Rectangle;
16
17	/**
18	* The Cell is the JFace representation of a cell entry in a RowPart.
19	* @since 3.3
20	* <strong>EXPERIMENTAL</strong> This class or interface has been added as
21	* part of a work in progress. This API may change at any given time. Please
22	* do not use this API without consulting with the Platform/UI team.
23	*
24	*/
25	public class Cell {
26	private int columnIndex;
27	private RowPart row;
28
29	/**
30	* Create a new instance of the receiver on the row.
31	* @param row
32	* @param columnIndex
33	*/
34	public Cell(RowPart row, int columnIndex) {
35	this.row = row;
36	this.columnIndex = columnIndex;
37	}
38
39	/**
40	* Get the index of the cell.
41	* @return int
42	*/
43	public int getColumnIndex() {
44	return columnIndex;
45	}
46
47	/**
48	* Get the bounds of the cell.
49	* @return Rectangle
50	*/
51	public Rectangle getBounds() {
52	return row.getBounds(columnIndex);
53	}
54
55	/**
56	* Get the element this row represents.
57	* @return Object
58	*/
59	public Object getElement() {
60	return row.getItem().getData();
61	}
62	}