Attachment 59015 Details for Bug 172646 – next iteration...

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

[patch] next iteration...

patch-172646.txt (text/plain), 108.45 KB, created by Boris Bokowski

on 2007-02-14 16:53:42 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Boris Bokowski

Created: 2007-02-14 16:53:42 EST

Size: 108.45 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.swt.nebula.snippets
>Index: META-INF/MANIFEST.MF
>===================================================================
>RCS file: /cvsroot/technology/org.eclipse.swt.nebula/org.eclipse.swt.nebula.snippets/META-INF/MANIFEST.MF,v
>retrieving revision 1.3
>diff -u -r1.3 MANIFEST.MF
>--- META-INF/MANIFEST.MF	12 Jan 2007 03:47:52 -0000	1.3
>+++ META-INF/MANIFEST.MF	14 Feb 2007 21:41:45 -0000
>@@ -5,6 +5,6 @@
> Bundle-Version: 1.0.0
> Bundle-Localization: plugin
> Require-Bundle: org.eclipse.swt,
>- org.eclipse.swt.nebula
>-Export-Package: org.eclipse.swt.nebula.snippets.ctree,
>- org.eclipse.swt.nebula.snippets.grid
>+ org.eclipse.swt.nebula,
>+ org.eclipse.swt.nebula.nebface
>+Export-Package: org.eclipse.swt.nebula.snippets.grid
>Index: src/org/eclipse/swt/nebface/snippets/viewers/GridViewerSnippet1.java
>===================================================================
>RCS file: src/org/eclipse/swt/nebface/snippets/viewers/GridViewerSnippet1.java
>diff -N src/org/eclipse/swt/nebface/snippets/viewers/GridViewerSnippet1.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/swt/nebface/snippets/viewers/GridViewerSnippet1.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,208 @@
>+/*******************************************************************************
>+ * Copyright (c) 2006 Tom Schindl 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:
>+ * Tom Schindl - initial API and implementation
>+ *******************************************************************************/
>+
>+package org.eclipse.swt.nebface.snippets.viewers;
>+
>+import org.eclipse.jface.resource.FontRegistry;
>+import org.eclipse.jface.viewers.CellEditor;
>+import org.eclipse.jface.viewers.EditingSupport;
>+import org.eclipse.jface.viewers.CellEditorActivationEvent;
>+import org.eclipse.jface.viewers.ICellModifier;
>+import org.eclipse.jface.viewers.IStructuredContentProvider;
>+import org.eclipse.jface.viewers.ITableColorProvider;
>+import org.eclipse.jface.viewers.ITableFontProvider;
>+import org.eclipse.jface.viewers.ITableLabelProvider;
>+import org.eclipse.jface.viewers.LabelProvider;
>+import org.eclipse.jface.viewers.TextCellEditor;
>+import org.eclipse.jface.viewers.Viewer;
>+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.layout.FillLayout;
>+import org.eclipse.swt.nebula.nebface.viewers.GridViewerEditorActivationSupport;
>+import org.eclipse.swt.nebula.nebface.viewers.GridViewer;
>+import org.eclipse.swt.nebula.widgets.grid.GridColumn;
>+import org.eclipse.swt.widgets.Display;
>+import org.eclipse.swt.widgets.Shell;
>+
>+/**
>+ * Example usage of none mandatory interfaces of ITableFontProvider and
>+ * ITableColorProvider
>+ * 
>+ * @author Tom Schindl <tom.schindl@bestsolution.at>
>+ * 
>+ */
>+public class GridViewerSnippet1 {
>+
>+	private class MyContentProvider implements IStructuredContentProvider {
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
>+		 */
>+		public Object[] getElements(Object inputElement) {
>+			return (MyModel[]) inputElement;
>+		}
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
>+		 */
>+		public void dispose() {
>+
>+		}
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
>+		 * java.lang.Object, java.lang.Object)
>+		 */
>+		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
>+
>+		}
>+
>+	}
>+
>+	public static boolean flag = true;
>+	
>+	public class MyModel {
>+		public int counter;
>+
>+		public MyModel(int counter) {
>+			this.counter = counter;
>+		}
>+
>+		public String toString() {
>+			return "Item " + this.counter;
>+		}
>+	}
>+
>+	public class MyLabelProvider extends LabelProvider implements
>+			ITableLabelProvider, ITableFontProvider, ITableColorProvider {
>+		FontRegistry registry = new FontRegistry();
>+
>+		public Image getColumnImage(Object element, int columnIndex) {
>+			return null;
>+		}
>+
>+		public String getColumnText(Object element, int columnIndex) {
>+			return "Column " + columnIndex + " => " + element.toString();
>+		}
>+
>+		public Font getFont(Object element, int columnIndex) {
>+			if (((MyModel) element).counter % 2 == 0) {
>+				return registry.getBold(Display.getCurrent().getSystemFont()
>+						.getFontData()[0].getName());
>+			}
>+			return null;
>+		}
>+
>+		public Color getBackground(Object element, int columnIndex) {
>+			if (((MyModel) element).counter % 2 == 0) {
>+				return Display.getCurrent().getSystemColor(SWT.COLOR_RED);
>+			}
>+			return null;
>+		}
>+
>+		public Color getForeground(Object element, int columnIndex) {
>+			if (((MyModel) element).counter % 2 == 1) {
>+				return Display.getCurrent().getSystemColor(SWT.COLOR_RED);
>+			}
>+			return null;
>+		}
>+
>+	}
>+
>+	public GridViewerSnippet1(Shell shell) {
>+		final GridViewer v = new GridViewer(shell, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
>+		v.setLabelProvider(new MyLabelProvider());
>+		v.setContentProvider(new MyContentProvider());
>+		v.getGrid().setCellSelectionEnabled(true);
>+				
>+		v.setCellEditors(new CellEditor[] { new TextCellEditor(v.getGrid()), new TextCellEditor(v.getGrid()) });
>+		v.setCellModifier(new ICellModifier() {
>+
>+			public boolean canModify(Object element, String property) {
>+				return true;
>+			}
>+
>+			public Object getValue(Object element, String property) {
>+				return "Column " + property + " => " + element.toString();
>+			}
>+
>+			public void modify(Object element, String property, Object value) {
>+				
>+			}
>+			
>+		});
>+		
>+		v.setColumnProperties(new String[] {"1","2"});
>+		
>+		GridViewerEditorActivationSupport support = new GridViewerEditorActivationSupport(v) {
>+			protected boolean isEditorActivationEvent(
>+					CellEditorActivationEvent event) {
>+				return event.eventType == CellEditorActivationEvent.TRAVERSAL || event.eventType == CellEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || ( event.eventType == CellEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR ) || event.eventType == CellEditorActivationEvent.PROGRAMATIC;
>+			}
>+		};
>+		support.setEnableEditorActivationWithKeyboard(true);
>+		
>+		v.setEditorActivationSupport(support);
>+		v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL|EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR|EditingSupport.TABBING_VERTICAL);
>+		
>+		GridColumn column = new GridColumn(v.getGrid(), SWT.NONE);
>+		column.setWidth(200);
>+		column.setText("Column 1");
>+
>+		column = new GridColumn(v.getGrid(), SWT.NONE);
>+		column.setWidth(200);
>+		column.setText("Column 2");
>+
>+		MyModel[] model = createModel();
>+		v.setInput(model);
>+		v.getGrid().setLinesVisible(true);
>+		v.getGrid().setHeaderVisible(true);
>+	}
>+
>+	private MyModel[] createModel() {
>+		MyModel[] elements = new MyModel[10];
>+
>+		for (int i = 0; i < 10; i++) {
>+			elements[i] = new MyModel(i);
>+		}
>+
>+		return elements;
>+	}
>+
>+	/**
>+	 * @param args
>+	 */
>+	public static void main(String[] args) {
>+		Display display = new Display();
>+
>+		Shell shell = new Shell(display);
>+		shell.setLayout(new FillLayout());
>+		new GridViewerSnippet1(shell);
>+		shell.open();
>+
>+		while (!shell.isDisposed()) {
>+			if (!display.readAndDispatch())
>+				display.sleep();
>+		}
>+
>+		display.dispose();
>+
>+	}
>+
>+}
>#P org.eclipse.jface
>Index: src/org/eclipse/jface/viewers/EditingSupport.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/EditingSupport.java,v
>retrieving revision 1.6
>diff -u -r1.6 EditingSupport.java
>--- src/org/eclipse/jface/viewers/EditingSupport.java	4 Feb 2007 22:00:23 -0000	1.6
>+++ src/org/eclipse/jface/viewers/EditingSupport.java	14 Feb 2007 21:41:46 -0000
>@@ -13,6 +13,8 @@
> 
> package org.eclipse.jface.viewers;
> 
>+import java.util.List;
>+
> import org.eclipse.core.runtime.Assert;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.events.TraverseEvent;
>@@ -170,8 +172,18 @@
> 		}
> 
> 		if (cell2edit != null) {
>-			viewer.editElement(cell2edit.getElement(), cell2edit
>-					.getColumnIndex());
>+			List l = viewer.getSelectionFromWidget();
>+						
>+			viewer.getControl().setRedraw(false);
>+			
>+			//TODO Is this correct in terms of other controls e.g. grid
>+			if( ! l.contains(cell2edit.getElement()) ) {
>+				viewer.setSelection(new StructuredSelection(cell2edit.getElement()));
>+			}
>+						
>+			CellEditorActivationEvent acEvent = new CellEditorActivationEvent(cell2edit,event);
>+			viewer.triggerCellEditorActivation(acEvent);
>+			viewer.getControl().setRedraw(true);
> 		}
> 	}
> 
>@@ -208,6 +220,7 @@
> 		if (columnIndex - 1 >= 0) {
> 			ViewerColumn column = viewer.getViewerColumn(columnIndex - 1);
> 			if (column != null
>+					&& column.getEditingSupport() != null
> 					&& column.getEditingSupport().canEdit(
> 							row.getItem().getData())) {
> 				rv = row.getCell(columnIndex - 1);
>@@ -244,6 +257,7 @@
> 		if (columnIndex + 1 < row.getColumnCount()) {
> 			ViewerColumn column = viewer.getViewerColumn(columnIndex + 1);
> 			if (column != null
>+					&& column.getEditingSupport() != null
> 					&& column.getEditingSupport().canEdit(
> 							row.getItem().getData())) {
> 				rv = row.getCell(columnIndex + 1);
>Index: src/org/eclipse/jface/viewers/CellEditor.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/CellEditor.java,v
>retrieving revision 1.25
>diff -u -r1.25 CellEditor.java
>--- src/org/eclipse/jface/viewers/CellEditor.java	10 Nov 2006 17:42:08 -0000	1.25
>+++ src/org/eclipse/jface/viewers/CellEditor.java	14 Feb 2007 21:41:46 -0000
>@@ -853,4 +853,14 @@
> dirty = true;
> fireEditorValueChanged(oldValidState, newValidState);
> }
>+ 
>+ /**
>+ * Activate the editor but also inform the editor which event triggered its activation.
>+ * The default implementation simply calls {@link #activate()}
>+ * 
>+ * @param activationEvent the editor activation event
>+ */
>+ public void activate(CellEditorActivationEvent activationEvent) {
>+ 	activate();
>+ }
> }
>Index: src/org/eclipse/jface/viewers/ColumnViewerEditor.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/ColumnViewerEditor.java,v
>retrieving revision 1.1
>diff -u -r1.1 ColumnViewerEditor.java
>--- src/org/eclipse/jface/viewers/ColumnViewerEditor.java	5 Feb 2007 02:49:28 -0000	1.1
>+++ src/org/eclipse/jface/viewers/ColumnViewerEditor.java	14 Feb 2007 21:41:46 -0000
>@@ -14,6 +14,8 @@
> 
> package org.eclipse.jface.viewers;
> 
>+
>+import org.eclipse.core.runtime.ListenerList;
> import org.eclipse.swt.events.FocusAdapter;
> import org.eclipse.swt.events.FocusEvent;
> import org.eclipse.swt.events.FocusListener;
>@@ -22,7 +24,6 @@
> import org.eclipse.swt.events.MouseListener;
> import org.eclipse.swt.events.TraverseEvent;
> import org.eclipse.swt.events.TraverseListener;
>-import org.eclipse.swt.graphics.Rectangle;
> import org.eclipse.swt.widgets.Control;
> import org.eclipse.swt.widgets.Display;
> import org.eclipse.swt.widgets.Item;
>@@ -46,22 +47,26 @@
> 
> 	private String[] columnProperties;
> 
>-	private int columnNumber;
>-
> 	private ICellEditorListener cellEditorListener;
> 
> 	private FocusListener focusListener;
> 
> 	private MouseListener mouseListener;
> 
>-	private int doubleClickExpirationTime;
>-
> 	private ColumnViewer viewer;
> 
>-	private Item item;
>-
> 	private TraverseListener tabeditingListener;
> 
>+	private int activationTime;
>+		
>+	private ViewerCell cell;
>+	
>+	private CellEditorActivationEvent activationEvent;
>+	
>+	private ListenerList editorActivationListener;
>+	
>+	private ColumnViewerEditorActivationSupport editorActivationStrategy;
>+
> 	/**
> 	 * Create a new editor implementation for the viewer
> 	 * 
>@@ -70,6 +75,19 @@
> 	 */
> 	public ColumnViewerEditor(ColumnViewer viewer) {
> 		this.viewer = viewer;
>+		editorActivationStrategy = new ColumnViewerEditorActivationSupport(viewer,null) {
>+			protected boolean isEditorActivationEvent(CellEditorActivationEvent event) {
>+				return event.eventType == CellEditorActivationEvent.MOUSE_CLICK_SELECTION
>+					|| event.eventType == CellEditorActivationEvent.PROGRAMATIC
>+					|| event.eventType == CellEditorActivationEvent.TRAVERSAL;
>+				}
>+
>+			protected ViewerCell getFocusCell() {
>+				return null;
>+			}
>+			
>+		};
>+		
> 		initCellEditorListener();
> 	}
> 
>@@ -92,13 +110,25 @@
> 
> 	void activateCellEditor() {
> 
>-		ViewerColumn part = viewer.getViewerColumn(columnNumber);
>-		Object element = item.getData();
>+		ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
>+		Object element = cell.getElement();
> 
> 		if (part != null && part.getEditingSupport() != null
> 				&& part.getEditingSupport().canEdit(element)) {
> 			cellEditor = part.getEditingSupport().getCellEditor(element);
> 			if (cellEditor != null) {
>+				if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
>+					Object[] ls = editorActivationListener.getListeners();
>+					for( int i = 0; i < ls.length; i++ ) {
>+						
>+						if( activationEvent.cancle ) {
>+							return;
>+						}
>+						
>+						((CellEditorActivationListener)ls[i]).beforeEditorActivated(activationEvent);
>+					}
>+				}
>+				
> 				cellEditor.addListener(cellEditorListener);
> 				Object value = part.getEditingSupport().getValue(element);
> 				cellEditor.setValue(value);
>@@ -108,12 +138,12 @@
> 				// so must get control first, but must still call activate()
> 				// even if there is no control.
> 				final Control control = cellEditor.getControl();
>-				cellEditor.activate();
>+				cellEditor.activate(activationEvent);
> 				if (control == null) {
> 					return;
> 				}
> 				setLayoutData(cellEditor.getLayoutData());
>-				setEditor(control, item, columnNumber);
>+				setEditor(control, cell.getItem(), cell.getColumnIndex());
> 				cellEditor.setFocus();
> 				if (focusListener == null) {
> 					focusListener = new FocusAdapter() {
>@@ -128,7 +158,7 @@
> 					public void mouseDown(MouseEvent e) {
> 						// time wrap?
> 						// check for expiration of doubleClickTime
>-						if (e.time <= doubleClickExpirationTime) {
>+						if (e.time <= activationTime) {
> 							control.removeMouseListener(mouseListener);
> 							cancelEditing();
> 							handleDoubleClickEvent();
>@@ -143,53 +173,26 @@
> 					tabeditingListener = new TraverseListener() {
> 
> 						public void keyTraversed(TraverseEvent e) {
>-							ViewerColumn col = viewer.getViewerColumn(columnNumber);
>+							ViewerColumn col = viewer.getViewerColumn(cell.getColumnIndex());
> 							if ( col != null && col.getEditingSupport().isTabingSupported() ) {
> 								col.getEditingSupport().processTraversEvent(
>-										columnNumber,
>-										viewer.getViewerRowFromItem(item), e);
>+										cell.getColumnIndex(),
>+										viewer.getViewerRowFromItem(cell.getItem()), e);
> 							}
> 						}
> 					};
> 				}
> 				
> 				control.addTraverseListener(tabeditingListener);
>-
>-			}
>-		}
>-	}
>-
>-	/**
>-	 * Activate a cell editor for the given mouse position.
>-	 */
>-	private void activateCellEditor(MouseEvent event) {
>-		if (item == null || item.isDisposed()) {
>-			// item no longer exists
>-			return;
>-		}
>-		int columnToEdit;
>-		ViewerRow row = viewer.getViewerRowFromItem(item);
>-		int columns = row.getColumnCount();
>-		if (columns == 0) {
>-			// If no TableColumn, Table acts as if it has a single column
>-			// which takes the whole width.
>-			columnToEdit = 0;
>-		} else {
>-			columnToEdit = -1;
>-			for (int i = 0; i < columns; i++) {
>-				Rectangle bounds = row.getBounds(i);
>-				if (bounds.contains(event.x, event.y)) {
>-					columnToEdit = i;
>-					break;
>+				
>+				if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
>+					Object[] ls = editorActivationListener.getListeners();
>+					for( int i = 0; i < ls.length; i++ ) {
>+						((CellEditorActivationListener)ls[i]).afterEditorActivated(activationEvent);
>+					}
> 				}
> 			}
>-			if (columnToEdit == -1) {
>-				return;
>-			}
> 		}
>-
>-		columnNumber = columnToEdit;
>-		activateCellEditor();
> 	}
> 
> 	/**
>@@ -203,8 +206,22 @@
> 			// in case save results in applyEditorValue being re-entered
> 			// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
> 			// using cell editor ?
>+			CellEditorDeactivationEvent tmp = new CellEditorDeactivationEvent(cell);
>+			if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
>+				Object[] ls = editorActivationListener.getListeners();
>+				for( int i = 0; i < ls.length; i++ ) {
>+					
>+					if( tmp.cancle ) {
>+						return;
>+					}
>+					
>+					((CellEditorActivationListener)ls[i]).beforeEditorDeactivated(tmp);
>+				}
>+			}
>+			
> 			this.cellEditor = null;
>-			Item t = this.item;
>+			this.activationEvent = null;
>+			Item t = this.cell.getItem();
> 			// don't null out table item -- same item is still selected
> 			if (t != null && !t.isDisposed()) {
> 				saveEditorValue(c, t);
>@@ -227,6 +244,13 @@
> 				}
> 			}
> 			c.deactivate();
>+			
>+			if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
>+				Object[] ls = editorActivationListener.getListeners();
>+				for( int i = 0; i < ls.length; i++ ) {
>+					((CellEditorActivationListener)ls[i]).afterEditorDeactivated(tmp);
>+				}
>+			}
> 		}
> 	}
> 
>@@ -235,6 +259,18 @@
> 	 */
> 	void cancelEditing() {
> 		if (cellEditor != null) {
>+			CellEditorDeactivationEvent tmp = new CellEditorDeactivationEvent(cell);
>+			if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
>+				Object[] ls = editorActivationListener.getListeners();
>+				for( int i = 0; i < ls.length; i++ ) {
>+					if( tmp.cancle ) {
>+						return;
>+					}
>+					
>+					((CellEditorActivationListener)ls[i]).beforeEditorDeactivated(tmp);
>+				}
>+			}
>+
> 			setEditor(null, null, 0);
> 			cellEditor.removeListener(cellEditorListener);
> 
>@@ -256,70 +292,39 @@
> 
> 			CellEditor oldEditor = cellEditor;
> 			cellEditor = null;
>+			activationEvent=null;
> 			oldEditor.deactivate();
>+			
>+			if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
>+				Object[] ls = editorActivationListener.getListeners();
>+				for( int i = 0; i < ls.length; i++ ) {
>+					((CellEditorActivationListener)ls[i]).afterEditorDeactivated(tmp);
>+				}
>+			}
> 		}
> 	}
>-
>+	
> 	/**
> 	 * Enable the editor by mouse down
> 	 * 
> 	 * @param event
> 	 */
>-	void handleMouseDown(MouseEvent event) {
>-		if (event.button != 1) {
>-			return;
>-		}
>-
>-		if (cellEditor != null) {
>-			applyEditorValue();
>-		}
>-
>-		// activate the cell editor immediately. If a second mouseDown
>-		// is received prior to the expiration of the doubleClick time then
>-		// the cell editor will be deactivated and a doubleClick event will
>-		// be processed.
>-		//
>-		doubleClickExpirationTime = event.time
>-				+ Display.getCurrent().getDoubleClickTime();
>-
>-		Item[] items = getSelection();
>-		// Do not edit if more than one row is selected.
>-		if (items.length != 1) {
>-			item = null;
>-			return;
>-		}
>-		item = items[0];
>-		activateCellEditor(event);
>-	}
>-
>-	/**
>-	 * Start editing the given element.
>-	 * 
>-	 * @param element
>-	 * @param column
>-	 */
>-	void editElement(Object element, int column) {
>-		if (cellEditor != null) {
>-			applyEditorValue();
>-		}
>+	void triggerCellEditorActivation(CellEditorActivationEvent event) {
>+		if( editorActivationStrategy.isEditorActivationEvent(event) ) {
>+			if (cellEditor != null) {
>+				applyEditorValue();
>+			}
> 
>-		setSelection(createSelection(element), true);
>-		Item[] selection = getSelection();
>-		if (selection.length != 1) {
>-			return;
>+			this.cell = (ViewerCell)event.getSource();			
>+			activationEvent = event;
>+			activationTime = event.time + Display.getCurrent().getDoubleClickTime();
>+			
>+			activateCellEditor();
> 		}
>-
>-		item = selection[0];
>-
>-		// Make sure selection is visible
>-		showSelection();
>-		columnNumber = column;
>-		activateCellEditor();
>-
> 	}
> 
> 	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
>-		ViewerColumn part = viewer.getViewerColumn(columnNumber);
>+		ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
> 
> 		if (part != null && part.getEditingSupport() != null) {
> 			part.getEditingSupport().setValue(tableItem.getData(),
>@@ -391,16 +396,30 @@
> 		return cellEditors;
> 	}
> 
>-	void setSelection(StructuredSelection selection, boolean b) {
>-		viewer.setSelection(selection, b);
>-	}
>-
> 	void handleDoubleClickEvent() {
> 		viewer.fireDoubleClick(new DoubleClickEvent(viewer, viewer
> 				.getSelection()));
> 		viewer.fireOpen(new OpenEvent(viewer, viewer.getSelection()));
> 	}
> 
>+	void addEditorActivationListener(CellEditorActivationListener listener) {
>+		if( editorActivationListener == null ) {
>+			editorActivationListener = new ListenerList();
>+		}
>+		editorActivationListener.add(listener);
>+	}
>+	
>+	void removeEditorActivationListener(CellEditorActivationListener listener) {
>+		if( editorActivationListener != null ) {
>+			editorActivationListener.remove(listener);
>+		}
>+	}
>+	
>+	void setEditorActivationStrategy(
>+			ColumnViewerEditorActivationSupport editorActivationStrategy) {
>+		this.editorActivationStrategy = editorActivationStrategy;
>+	}
>+	
> 	/**
> 	 * Create a selection for this model element
> 	 * 
>@@ -429,14 +448,4 @@
> 	 * the layout data used when editor is displayed
> 	 */
> 	protected abstract void setLayoutData(CellEditor.LayoutData layoutData);
>-
>-	/**
>-	 * Show up the current selection (scroll the selection into view)
>-	 */
>-	protected abstract void showSelection();
>-
>-	/**
>-	 * @return the current selection
>-	 */
>-	protected abstract Item[] getSelection();
>-}
>+}
>\ No newline at end of file
>Index: src/org/eclipse/jface/viewers/ColumnViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/ColumnViewer.java,v
>retrieving revision 1.24
>diff -u -r1.24 ColumnViewer.java
>--- src/org/eclipse/jface/viewers/ColumnViewer.java	5 Feb 2007 04:55:37 -0000	1.24
>+++ src/org/eclipse/jface/viewers/ColumnViewer.java	14 Feb 2007 21:41:46 -0000
>@@ -14,6 +14,8 @@
> 
> package org.eclipse.jface.viewers;
> 
>+import java.util.List;
>+
> import org.eclipse.core.runtime.Assert;
> import org.eclipse.swt.events.MouseAdapter;
> import org.eclipse.swt.events.MouseEvent;
>@@ -76,7 +78,7 @@
> 		if (viewerEditor != null) {
> 			control.addMouseListener(new MouseAdapter() {
> 				public void mouseDown(MouseEvent e) {
>-					viewerEditor.handleMouseDown(e);
>+					handleMouseDown(e);
> 				}
> 			});
> 		}
>@@ -371,7 +373,27 @@
> 	 */
> 	public void editElement(Object element, int column) {
> 		if (viewerEditor != null) {
>-			viewerEditor.editElement(element, column);
>+			Widget item = findItem(element);
>+			if (item != null) {
>+				ViewerRow row = getViewerRowFromItem(item);
>+				if (row != null) {
>+					ViewerCell cell = row.getCell(column);
>+					if (cell != null) {
>+						getControl().setRedraw(false);
>+
>+						List l = getSelectionFromWidget();
>+
>+						if (l.size() > 1 || !l.contains(cell.getElement())) {
>+							setSelection(new StructuredSelection(cell
>+									.getElement()));
>+						}
>+
>+						triggerCellEditorActivation(new CellEditorActivationEvent(
>+								cell));
>+						getControl().setRedraw(true);
>+					}
>+				}
>+			}
> 		}
> 	}
> 
>@@ -576,4 +598,43 @@
> 		}
> 		return null;
> 	}
>+
>+	private void handleMouseDown(MouseEvent e) {
>+		ViewerCell cell = getCell(new Point(e.x, e.y));
>+
>+		if (cell != null) {
>+			triggerCellEditorActivation(new CellEditorActivationEvent(cell, e));
>+		}
>+	}
>+
>+	/**
>+	 * Invoking this method fires an editor activation event which tries to
>+	 * enable the editor but before this event is passed to
>+	 * {@link ColumnViewerEditorActivationSupport} to see if this event should
>+	 * really trigger editor activation
>+	 * 
>+	 * @param event
>+	 * the activation event
>+	 */
>+	protected void triggerCellEditorActivation(CellEditorActivationEvent event) {
>+		viewerEditor.triggerCellEditorActivation(event);
>+	}
>+
>+	/**
>+	 * To fully control the strategy used to control on which cell-selection
>+	 * events the editor has to be activated you can pass your customized
>+	 * strategy using this method.
>+	 * 
>+	 * @param editorActivationStrategy
>+	 * the strategy used to activate an editor
>+	 */
>+	public void setEditorActivationSupport(
>+			ColumnViewerEditorActivationSupport editorActivationStrategy) {
>+		if (viewerEditor != null) {
>+			viewerEditor.setEditorActivationStrategy(editorActivationStrategy);
>+		} else {
>+			throw new IllegalStateException(
>+					"This feature is not supported by the widget"); //$NON-NLS-1$
>+		}
>+	}
> }
>Index: src/org/eclipse/jface/viewers/TableViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/TableViewer.java,v
>retrieving revision 1.75
>diff -u -r1.75 TableViewer.java
>--- src/org/eclipse/jface/viewers/TableViewer.java	5 Feb 2007 02:49:28 -0000	1.75
>+++ src/org/eclipse/jface/viewers/TableViewer.java	14 Feb 2007 21:41:46 -0000
>@@ -134,10 +134,6 @@
> 				return new StructuredSelection(element);
> 			}
> 
>-			protected Item[] getSelection() {
>-				return table.getSelection();
>-			}
>-
> 			protected void setEditor(Control w, Item item, int fColumnNumber) {
> 				tableEditor.setEditor(w, (TableItem) item, fColumnNumber);
> 			}
>@@ -148,10 +144,6 @@
> 				tableEditor.minimumWidth = layoutData.minimumWidth;
> 			}
> 
>-			protected void showSelection() {
>-				table.showSelection();
>-			}
>-
> 		};
> 	}
> 	
>Index: src/org/eclipse/jface/viewers/TreeViewer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/TreeViewer.java,v
>retrieving revision 1.77
>diff -u -r1.77 TreeViewer.java
>--- src/org/eclipse/jface/viewers/TreeViewer.java	5 Feb 2007 02:49:28 -0000	1.77
>+++ src/org/eclipse/jface/viewers/TreeViewer.java	14 Feb 2007 21:41:46 -0000
>@@ -284,10 +284,6 @@
> 				return new StructuredSelection(element);
> 			}
> 
>-			protected Item[] getSelection() {
>-				return tree.getSelection();
>-			}
>-
> 			protected void setEditor(Control w, Item item, int fColumnNumber) {
> 				treeEditor.setEditor(w, (TreeItem) item, fColumnNumber);
> 			}
>@@ -298,10 +294,6 @@
> 				treeEditor.minimumWidth = layoutData.minimumWidth;
> 			}
> 
>-			protected void showSelection() {
>-				getTree().showSelection();
>-			}
>-
> 		};
> 	}
> 
>Index: src/org/eclipse/jface/viewers/CellSupport.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/CellSupport.java
>diff -N src/org/eclipse/jface/viewers/CellSupport.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/CellSupport.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,91 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 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.core.runtime.ListenerList;
>+
>+/**
>+ * @since 3.3
>+ * 
>+ */
>+public abstract class CellSupport {
>+	private ListenerList focusCellChangedListeners = new ListenerList();
>+
>+	private ViewerCell focusCell;
>+
>+	private ColumnViewer viewer;
>+
>+	/**
>+	 * @param viewer
>+	 * the viewer who requests cell support
>+	 */
>+	public CellSupport(ColumnViewer viewer) {
>+		this.viewer = viewer;
>+		hookListener(viewer);
>+	}
>+
>+	/**
>+	 * @param viewer
>+	 * hook listeners into the viewer
>+	 */
>+	protected abstract void hookListener(ColumnViewer viewer);
>+
>+	/**
>+	 * @return the viewer
>+	 */
>+	protected ColumnViewer getViewer() {
>+		return viewer;
>+	}
>+
>+	/**
>+	 * @param listener
>+	 * the listener to be added
>+	 */
>+	public void addFocusCellChangedListener(FocusCellChangeListener listener) {
>+		focusCellChangedListeners.add(listener);
>+	}
>+
>+	/**
>+	 * @param listener
>+	 * the listener to be removed
>+	 */
>+	public void removeFocusCellChangedListener(FocusCellChangeListener listener) {
>+		focusCellChangedListeners.remove(listener);
>+	}
>+
>+	/**
>+	 * @return the cell who holds the keyboard focus
>+	 */
>+	public ViewerCell getFocusCell() {
>+		return focusCell;
>+	}
>+
>+	/**
>+	 * @param event
>+	 * inform listeners about the selection
>+	 * @return has this really been an change event
>+	 */
>+	protected boolean fireFocusCellChanged(FocusCellChangeEvent event) {
>+		if (event.focusCell.equals(event.focusLostCell)) {
>+			return false;
>+		}
>+
>+		this.focusCell = event.focusCell;
>+
>+		Object[] ls = focusCellChangedListeners.getListeners();
>+
>+		for (int i = 0; i < ls.length; i++) {
>+			((FocusCellChangeListener) ls[i]).handleFocusCellChange(event);
>+		}
>+		return true;
>+	}
>+}
>Index: src/org/eclipse/jface/viewers/FocusCellChangeListener.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/FocusCellChangeListener.java
>diff -N src/org/eclipse/jface/viewers/FocusCellChangeListener.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/FocusCellChangeListener.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,24 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ * IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.jface.viewers;
>+
>+/**
>+ * @since 3.3
>+ * 
>+ */
>+public abstract class FocusCellChangeListener {
>+	/**
>+	 * @param event
>+	 * the event informing about the selection of a cell
>+	 */
>+	public abstract void handleFocusCellChange(FocusCellChangeEvent event);
>+}
>Index: src/org/eclipse/jface/viewers/FocusCellHighlighter.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/FocusCellHighlighter.java
>diff -N src/org/eclipse/jface/viewers/FocusCellHighlighter.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/FocusCellHighlighter.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,53 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 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;
>+
>+/**
>+ * Implementors of this class are responsible to highlight the selected cell and
>+ * to remove the highlighting of cells who are not selected
>+ * 
>+ * @since 3.3
>+ * 
>+ */
>+public abstract class FocusCellHighlighter {
>+	private CellSupport cellSupport;
>+	
>+	private ColumnViewer viewer;
>+
>+	/**
>+	 * @param viewer
>+	 */
>+	public FocusCellHighlighter(ColumnViewer viewer) {
>+		this.viewer = viewer;
>+	}
>+	
>+	/**
>+	 * @param cellSupport associate the cell support with this class
>+	 */
>+	protected void setCellSupport(CellSupport cellSupport) {
>+		this.cellSupport = cellSupport;
>+	}
>+
>+	/**
>+	 * @return the viewer
>+	 */
>+	public ColumnViewer getViewer() {
>+		return viewer;
>+	}
>+	
>+	/**
>+	 * @return the cell currently holding the focus
>+	 */
>+	protected ViewerCell getFocusCell() {
>+		return cellSupport.getFocusCell();
>+	}
>+}
>Index: src/org/eclipse/jface/viewers/CellEditorActivationListener.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/CellEditorActivationListener.java
>diff -N src/org/eclipse/jface/viewers/CellEditorActivationListener.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/CellEditorActivationListener.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,52 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 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;
>+
>+/**
>+ * Parties interested in activation and deactivation of editors extend this
>+ * class and implement any or all of the methods
>+ * 
>+ * @since 3.3
>+ * 
>+ */
>+public abstract class CellEditorActivationListener {
>+	/**
>+	 * Called before an editor is activated
>+	 * 
>+	 * @param event
>+	 * the event
>+	 */
>+	public abstract void beforeEditorActivated(CellEditorActivationEvent event);
>+
>+	/**
>+	 * Called after an editor has been activated
>+	 * 
>+	 * @param event the event
>+	 */
>+	public abstract void afterEditorActivated(CellEditorActivationEvent event);
>+
>+	/**
>+	 * Called before an editor is deactivated
>+	 * 
>+	 * @param event
>+	 * the event
>+	 */
>+	public abstract void beforeEditorDeactivated(CellEditorDeactivationEvent event);
>+
>+	
>+	/**
>+	 * Called after an editor is deactivated
>+	 * 
>+	 * @param event the event
>+	 */
>+	public abstract void afterEditorDeactivated(CellEditorDeactivationEvent event);
>+}
>Index: src/org/eclipse/jface/viewers/CellNavigationStrategy.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/CellNavigationStrategy.java
>diff -N src/org/eclipse/jface/viewers/CellNavigationStrategy.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/CellNavigationStrategy.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,151 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ * IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.jface.viewers;
>+
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.widgets.Event;
>+
>+/**
>+ * @since 3.3
>+ * 
>+ */
>+public class CellNavigationStrategy {
>+	/**
>+	 * is the given event an event which moves the selection to another cell
>+	 * 
>+	 * @param viewer
>+	 * the viewer we are working for
>+	 * 
>+	 * @param event
>+	 * the key event
>+	 * @return <code>true</code> if a new cell is searched
>+	 */
>+	public boolean isNavigationEvent(ColumnViewer viewer, Event event) {
>+		switch (event.keyCode) {
>+		case SWT.ARROW_UP:
>+		case SWT.ARROW_DOWN:
>+		case SWT.ARROW_LEFT:
>+		case SWT.ARROW_RIGHT:
>+		case SWT.HOME:
>+		case SWT.PAGE_DOWN:
>+		case SWT.PAGE_UP:
>+		case SWT.END:
>+			return true;
>+		default:
>+			return false;
>+		}
>+	}
>+
>+	/**
>+	 * @param viewer
>+	 * the viewer we are working for
>+	 * @param cellToCollapse the cell to collapse
>+	 * @param event
>+	 * the key event
>+	 * @return <code>true</code> if this event triggers collapsing of a node
>+	 */
>+	public boolean isCollapseEvent(ColumnViewer viewer, ViewerCell cellToCollapse, Event event) {
>+		return false;
>+	}
>+
>+	/**
>+	 * @param viewer
>+	 * the viewer we are working for
>+	 * @param cellToExpand the cell to expand
>+	 * @param event
>+	 * the key event
>+	 * @return <code>true</code> if this event triggers expanding of a node
>+	 */
>+	public boolean isExpandEvent(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {
>+		return false;
>+	}
>+
>+	/**
>+	 * @param viewer
>+	 * the viewer working for
>+	 * @param cellToExpand
>+	 * the cell the user wants to expand
>+	 * @param event
>+	 * the event triggering the exansion
>+	 */
>+	public void expand(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {
>+
>+	}
>+
>+	/**
>+	 * @param viewer
>+	 * the viewer working for
>+	 * @param cellToCollapse
>+	 * the cell the user wants to collapse
>+	 * @param event
>+	 * the event triggering the exansion
>+	 */
>+	public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,
>+			Event event) {
>+
>+	}
>+
>+	/**
>+	 * @param viewer
>+	 * the viewer we are working for
>+	 * @param currentSelectedCell
>+	 * the cell currently selected
>+	 * @param event
>+	 * the key event
>+	 * @return the cell which is highlighted next or <code>null</code> if the
>+	 * default implementation is taken. E.g. it's fairly impossible to
>+	 * react on PAGE_DOWN requests
>+	 */
>+	public ViewerCell findSelectedCell(ColumnViewer viewer,
>+			ViewerCell currentSelectedCell, Event event) {
>+
>+		switch (event.keyCode) {
>+		case SWT.ARROW_UP:
>+			if (currentSelectedCell != null) {
>+				return currentSelectedCell.getNeighbor(ViewerCell.ABOVE, false);
>+			}
>+			break;
>+		case SWT.ARROW_DOWN:
>+			if (currentSelectedCell != null) {
>+				return currentSelectedCell.getNeighbor(ViewerCell.BELOW, false);
>+			}
>+			break;
>+		case SWT.ARROW_LEFT:
>+			if (currentSelectedCell != null) {
>+				return currentSelectedCell.getNeighbor(ViewerCell.LEFT, true);
>+			}
>+			break;
>+		case SWT.ARROW_RIGHT:
>+			if (currentSelectedCell != null) {
>+				return currentSelectedCell.getNeighbor(ViewerCell.RIGHT, true);
>+			}
>+			break;
>+		}
>+
>+		return null;
>+	}
>+
>+	/**
>+	 * This method is consulted to decide whether an event has to be cancled or
>+	 * not. By default events who collapse/expand tree-nodes are cancled
>+	 * 
>+	 * @param viewer
>+	 * the viewer working for
>+	 * @param event
>+	 * the event
>+	 * @return <code>true</code> if the event has to be cancled
>+	 */
>+	public boolean cancleEvent(ColumnViewer viewer, Event event) {
>+		return event.keyCode == SWT.ARROW_LEFT
>+				|| event.keyCode == SWT.ARROW_RIGHT;
>+	}
>+}
>Index: src/org/eclipse/jface/viewers/ColumnViewerEditorActivationSupport.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/ColumnViewerEditorActivationSupport.java
>diff -N src/org/eclipse/jface/viewers/ColumnViewerEditorActivationSupport.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/ColumnViewerEditorActivationSupport.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,96 @@
>+/*******************************************************************************
>+ * 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.events.KeyEvent;
>+import org.eclipse.swt.events.KeyListener;
>+
>+/**
>+ * This class is responsible to determin if a cell selection event is triggers
>+ * an editor activation
>+ * 
>+ * @since 3.3
>+ */
>+public class ColumnViewerEditorActivationSupport {
>+	private ColumnViewer viewer;
>+	
>+	private KeyListener keyboardActivationListener;
>+	
>+	private CellSupport cellSupport;
>+	
>+	/**
>+	 * @param viewer the viewer the editor support is attached to
>+	 * @param cellSupport the cell support or <code>null</code> if there's none
>+	 */
>+	public ColumnViewerEditorActivationSupport(ColumnViewer viewer, CellSupport cellSupport) {
>+		this.viewer = viewer;
>+		this.cellSupport = cellSupport;
>+	}
>+	
>+	/**
>+	 * @return the cell holding the current focus
>+	 */
>+	protected ViewerCell getFocusCell() {
>+		if( cellSupport != null ) {
>+			return cellSupport.getFocusCell();
>+		}
>+		
>+		return null;
>+	}
>+	
>+	/**
>+	 * @param event
>+	 * @return bla bl
>+	 */
>+	protected boolean isEditorActivationEvent(CellEditorActivationEvent event) {
>+		return event.eventType == CellEditorActivationEvent.TRAVERSAL || event.eventType == CellEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || event.eventType == CellEditorActivationEvent.PROGRAMATIC;
>+	}
>+	
>+	/**
>+	 * @return the viewer
>+	 */
>+	public ColumnViewer getViewer() {
>+		return viewer;
>+	}
>+	
>+	/**
>+	 * Enable activation of cell editors by keyboard
>+	 * @param enable <code>true</code> to enable
>+	 */
>+	public void setEnableEditorActivationWithKeyboard(boolean enable) {
>+		if( enable ) {
>+			if( keyboardActivationListener == null ) {
>+				keyboardActivationListener = new KeyListener() {
>+
>+					public void keyPressed(KeyEvent e) {
>+						ViewerCell cell = getFocusCell();
>+						
>+						if( cell != null ) {
>+							viewer.triggerCellEditorActivation(new CellEditorActivationEvent(cell,e));
>+						}
>+					}
>+
>+					public void keyReleased(KeyEvent e) {
>+						
>+					}
>+					
>+				};
>+				viewer.getControl().addKeyListener(keyboardActivationListener);
>+			}
>+		} else {
>+			if( keyboardActivationListener != null ) {
>+				viewer.getControl().removeKeyListener(keyboardActivationListener);
>+				keyboardActivationListener = null;
>+			}
>+		}
>+	}
>+}
>Index: src/org/eclipse/jface/viewers/CellEditorDeactivationEvent.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/CellEditorDeactivationEvent.java
>diff -N src/org/eclipse/jface/viewers/CellEditorDeactivationEvent.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/CellEditorDeactivationEvent.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,41 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ * IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.jface.viewers;
>+
>+import java.util.EventObject;
>+
>+/**
>+ * This event is fired when an editor deactivated
>+ * 
>+ * @since 3.3
>+ * 
>+ */
>+public class CellEditorDeactivationEvent extends EventObject {
>+
>+	/**
>+	 * 
>+	 */
>+	private static final long serialVersionUID = 1L;
>+
>+	/**
>+	 * Cancle the event
>+	 */
>+	public boolean cancle = false;
>+	
>+	/**
>+	 * @param source
>+	 */
>+	public CellEditorDeactivationEvent(Object source) {
>+		super(source);
>+	}
>+
>+}
>Index: src/org/eclipse/jface/viewers/FocusCellOwnerDrawHighlighter.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/FocusCellOwnerDrawHighlighter.java
>diff -N src/org/eclipse/jface/viewers/FocusCellOwnerDrawHighlighter.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/FocusCellOwnerDrawHighlighter.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,128 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 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.core.runtime.Assert;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.graphics.Color;
>+import org.eclipse.swt.graphics.GC;
>+import org.eclipse.swt.widgets.Event;
>+import org.eclipse.swt.widgets.Listener;
>+
>+/**
>+ * @since 3.3
>+ * 
>+ */
>+public class FocusCellOwnerDrawHighlighter extends FocusCellHighlighter {
>+	
>+	/**
>+	 * @param viewer the viewer
>+	 */
>+	public FocusCellOwnerDrawHighlighter(ColumnViewer viewer) {
>+		super(viewer);
>+		hookListener(viewer);
>+	}
>+	
>+	private void markFocusedCell(Event event,
>+			ViewerCell cell) {
>+		Color background = getSelectedCellBackgroundColor(cell);
>+		Color foreground = getSelectedCellForegroundColor(cell);
>+
>+		if (foreground != null || background != null) {
>+			GC gc = event.gc;
>+
>+			if (background == null) {
>+				background = cell.getItem().getDisplay().getSystemColor(
>+						SWT.COLOR_LIST_SELECTION);
>+			}
>+
>+			if (foreground == null) {
>+				foreground = cell.getItem().getDisplay().getSystemColor(
>+						SWT.COLOR_LIST_SELECTION_TEXT);
>+			}
>+
>+			gc.setBackground(background);
>+			gc.setForeground(foreground);
>+			gc.fillRectangle(event.getBounds());
>+			
>+			// This is a workaround for an SWT-Bug on WinXP bug 169517
>+			gc.drawText(" ", cell.getBounds().x, cell.getBounds().y, false); //$NON-NLS-1$
>+			event.detail &= ~SWT.SELECTED;
>+		}
>+	}
>+
>+	private void removeSelectionInformation(Event event,
>+			ViewerCell cell) {
>+		GC gc = event.gc;
>+		gc.setBackground(cell.getViewerRow().getBackground(
>+				cell.getColumnIndex()));
>+		gc.setForeground(cell.getViewerRow().getForeground(
>+				cell.getColumnIndex()));
>+		gc.fillRectangle(cell.getBounds());
>+		// This is a workaround for an SWT-Bug on WinXP bug 169517
>+		gc.drawText(" ", cell.getBounds().x, cell.getBounds().y, false); //$NON-NLS-1$
>+		event.detail &= ~SWT.SELECTED;
>+	}
>+
>+	private void hookListener(final ColumnViewer viewer) {
>+		System.err.println("HOOKING LISTENER"); //$NON-NLS-1$
>+		
>+		Listener listener = new Listener() {
>+
>+			public void handleEvent(Event event) {
>+				if((event.detail & SWT.SELECTED) > 0 ) {
>+					System.err.println("ERASE EVENT"); //$NON-NLS-1$
>+					ViewerCell focusCell = getFocusCell();
>+					ViewerRow row = viewer.getViewerRowFromItem(event.item);
>+					
>+					Assert.isNotNull(row, "Internal structure invalid. Item without associated row is not possible."); //$NON-NLS-1$
>+					
>+					ViewerCell cell = row.getCell(event.index);
>+					
>+//					if( focusCell != null ) {
>+//						System.err.println("FOCUS: " + focusCell.getColumnIndex() + " =>" + focusCell.getItem() ); //$NON-NLS-1$ //$NON-NLS-2$
>+//					}
>+//					
>+//					if( cell != null ) {
>+//						System.err.println("TO COLOR: " + cell.getColumnIndex() + " =>" + cell.getItem() ); //$NON-NLS-1$ //$NON-NLS-2$
>+//					}
>+					
>+					if (focusCell == null || ! cell.equals(focusCell)) {
>+						removeSelectionInformation(event, cell);
>+					} else {
>+						markFocusedCell(event,cell);
>+					}
>+				}
>+			}
>+			
>+		};
>+		viewer.getControl().addListener(SWT.EraseItem, listener);
>+	}
>+
>+	/**
>+	 * @param cell
>+	 * the cell which is colored
>+	 * @return the color
>+	 */
>+	protected Color getSelectedCellBackgroundColor(ViewerCell cell) {
>+		return null;
>+	}
>+
>+	/**
>+	 * @param cell
>+	 * the cell which is colored
>+	 * @return the color
>+	 */
>+	protected Color getSelectedCellForegroundColor(ViewerCell cell) {
>+		return null;
>+	}
>+}
>Index: src/org/eclipse/jface/viewers/SWTCellSupport.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/SWTCellSupport.java
>diff -N src/org/eclipse/jface/viewers/SWTCellSupport.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/SWTCellSupport.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,164 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 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.core.runtime.Assert;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.graphics.Point;
>+import org.eclipse.swt.widgets.Event;
>+import org.eclipse.swt.widgets.Listener;
>+import org.eclipse.swt.widgets.TreeItem;
>+
>+/**
>+ * @since 3.3
>+ * 
>+ */
>+public final class SWTCellSupport extends CellSupport {
>+	private static final CellNavigationStrategy TABLE_NAVIGATE = new CellNavigationStrategy();
>+
>+	private static final CellNavigationStrategy TREE_NAVIGATE = new CellNavigationStrategy() {
>+		public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,
>+				Event event) {
>+			if (cellToCollapse != null) {
>+				((TreeItem) cellToCollapse.getItem()).setExpanded(false);
>+			}
>+		}
>+
>+		public void expand(ColumnViewer viewer, ViewerCell cellToExpand,
>+				Event event) {
>+			if (cellToExpand != null) {
>+				TreeViewer v = (TreeViewer) viewer;
>+				v.setExpandedState(v
>+						.getTreePathFromItem(cellToExpand.getItem()), true);
>+			}
>+		}
>+
>+		public boolean isCollapseEvent(ColumnViewer viewer,
>+				ViewerCell cellToCollapse, Event event) {
>+			return cellToCollapse != null
>+					&& ((TreeItem) cellToCollapse.getItem()).getExpanded()
>+					&& cellToCollapse.getColumnIndex() == 0
>+					&& event.keyCode == SWT.ARROW_LEFT;
>+		}
>+
>+		public boolean isExpandEvent(ColumnViewer viewer,
>+				ViewerCell cellToExpand, Event event) {
>+			return cellToExpand != null
>+					&& ((TreeItem) cellToExpand.getItem()).getItemCount() > 0
>+					&& !((TreeItem) cellToExpand.getItem()).getExpanded()
>+					&& cellToExpand.getColumnIndex() == 0
>+					&& event.keyCode == SWT.ARROW_RIGHT;
>+		}
>+	};
>+
>+	private CellNavigationStrategy navigationDelegate;
>+	
>+	/**
>+	 * @param viewer
>+	 * @param focusDrawingDelegate
>+	 */
>+	public SWTCellSupport(TableViewer viewer,
>+			FocusCellHighlighter focusDrawingDelegate) {
>+		this(viewer, focusDrawingDelegate, TABLE_NAVIGATE);
>+	}
>+
>+	/**
>+	 * @param viewer
>+	 * @param focusDrawingDelegate
>+	 */
>+	public SWTCellSupport(TreeViewer viewer,
>+			FocusCellHighlighter focusDrawingDelegate) {
>+		this(viewer, focusDrawingDelegate, TREE_NAVIGATE);
>+	}
>+
>+	private SWTCellSupport(ColumnViewer viewer,
>+			FocusCellHighlighter focusDrawingDelegate,
>+			CellNavigationStrategy navigationDelegate) {
>+		super(viewer);
>+		if (viewer != focusDrawingDelegate.getViewer()) {
>+			throw new IllegalArgumentException(
>+					"The FocusCellHighlighter passed is not working for the same ColumnViewer than SWTCellSupport"); //$NON-NLS-1$
>+		}
>+
>+		this.navigationDelegate = navigationDelegate;
>+		focusDrawingDelegate.setCellSupport(this);
>+	}
>+
>+	private void handleMouseDown(Event event) {
>+		ViewerCell cell = getViewer().getCell(new Point(event.x, event.y));
>+		if (cell != null) {
>+			if( fireFocusCellChanged(new FocusCellChangeEvent(getViewer(), cell,
>+					getFocusCell()))) {
>+				getViewer().getControl().redraw();
>+			}
>+		}
>+	}
>+
>+	private void handleKeyDown(Event event) {
>+		ViewerCell focusCell = getFocusCell();
>+		ViewerCell tmp = null;
>+
>+		if (navigationDelegate.isCollapseEvent(getViewer(), focusCell, event)) {
>+			navigationDelegate.collapse(getViewer(), focusCell, event);
>+		} else if (navigationDelegate.isExpandEvent(getViewer(), focusCell,
>+				event)) {
>+			System.err.println("EXPAND!!!"); //$NON-NLS-1$
>+			navigationDelegate.expand(getViewer(), focusCell, event);
>+		} else if (navigationDelegate.isNavigationEvent(getViewer(), event)) {
>+			tmp = navigationDelegate.findSelectedCell(getViewer(), focusCell,event);
>+
>+			System.err.println("NEW CELL:" + tmp); //$NON-NLS-1$
>+			
>+			
>+			if (tmp != null) {
>+				if( fireFocusCellChanged(new FocusCellChangeEvent(getViewer(),tmp,focusCell)) ) {
>+					System.err.println("CHANGED!"); //$NON-NLS-1$
>+					getViewer().getControl().redraw();
>+				}
>+			}
>+		}
>+
>+		if (navigationDelegate.cancleEvent(getViewer(), event)) {
>+			event.doit = false;
>+		}
>+	}
>+
>+	private void handleSelection(Event event) {
>+		ViewerCell focusCell = getFocusCell();
>+		if( focusCell != null && focusCell.getItem() != event.item && event.item != null ) {
>+			ViewerRow row = getViewer().getViewerRowFromItem(event.item);
>+			Assert.isNotNull(row,"Internal Structure invalid. Row item has no row ViewerRow assigned"); //$NON-NLS-1$
>+			if( fireFocusCellChanged(new FocusCellChangeEvent(getViewer(),row.getCell(focusCell.getColumnIndex()),focusCell)) ) {
>+				getViewer().getControl().redraw();
>+			}
>+		}
>+	}
>+
>+	protected void hookListener(ColumnViewer viewer) {
>+		Listener listener = new Listener() {
>+
>+			public void handleEvent(Event event) {
>+				if (event.type == SWT.MouseDown) {
>+					handleMouseDown(event);
>+				} else if (event.type == SWT.KeyDown) {
>+					handleKeyDown(event);
>+				} else {
>+					handleSelection(event);
>+				}
>+			}
>+		};
>+
>+		viewer.getControl().addListener(SWT.MouseDown, listener);
>+		viewer.getControl().addListener(SWT.KeyDown, listener);
>+		viewer.getControl().addListener(SWT.Selection, listener);
>+	}
>+}
>Index: src/org/eclipse/jface/viewers/CellEditorActivationEvent.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/CellEditorActivationEvent.java
>diff -N src/org/eclipse/jface/viewers/CellEditorActivationEvent.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/CellEditorActivationEvent.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,164 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ * IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.jface.viewers;
>+
>+import java.util.EventObject;
>+
>+import org.eclipse.swt.events.KeyEvent;
>+import org.eclipse.swt.events.MouseEvent;
>+import org.eclipse.swt.events.TraverseEvent;
>+
>+/**
>+ * This event is passed on when a cell-editor is going to be activated
>+ * 
>+ * @since 3.3
>+ * 
>+ */
>+public class CellEditorActivationEvent extends EventObject {
>+	/**
>+	 * 
>+	 */
>+	private static final long serialVersionUID = 1L;
>+
>+	/**
>+	 * if a key is pressed on a selected cell
>+	 */
>+	public static final int KEY_PRESSED = 1;
>+
>+	/**
>+	 * if a cell is selected using a single click of the mouse
>+	 */
>+	public static final int MOUSE_CLICK_SELECTION = 2;
>+
>+	/**
>+	 * if a cell is selected using double clicking of the mouse
>+	 */
>+	public static final int MOUSE_DOUBLE_CLICK_SELECTION = 3;
>+
>+	/**
>+	 * if a cell is activated using code like e.g
>+	 * {@link ColumnViewer#editElement(Object, int)}
>+	 */
>+	public static final int PROGRAMATIC = 4;
>+
>+	/**
>+	 * is a cell is activated by traversing
>+	 */
>+	public static final int TRAVERSAL = 5;
>+
>+	/**
>+	 * the original event triggered
>+	 */
>+	public EventObject sourceEvent;
>+
>+	/**
>+	 * The time the event is triggered
>+	 */
>+	public int time;
>+
>+	/**
>+	 * The event type triggered:
>+	 * <ul>
>+	 * <li>{@link #KEY_PRESSED} if a key is pressed on a selected cell</li>
>+	 * <li>{@link #MOUSE_CLICK_SELECTION} if a cell is selected using a single
>+	 * click of the mouse</li>
>+	 * <li>{@link #MOUSE_DOUBLE_CLICK_SELECTION} if a cell is selected using
>+	 * double clicking of the mouse</li>
>+	 * </ul>
>+	 */
>+	public int eventType;
>+
>+	/**
>+	 * Only set for {@link #KEY_PRESSED}
>+	 */
>+	public int keyCode;
>+
>+	/**
>+	 * Only set for {@link #KEY_PRESSED}
>+	 */
>+	public char character;
>+
>+	/**
>+	 * The statemask
>+	 */
>+	public int stateMask;
>+
>+	/**
>+	 * Cancle the event (=> editor is not activated)
>+	 */
>+	public boolean cancle = false;
>+	
>+	/**
>+	 * This constructor can be used when no event exists. The type set is
>+	 * {@link #PROGRAMATIC}
>+	 * 
>+	 * @param cell
>+	 * the cell
>+	 */
>+	public CellEditorActivationEvent(ViewerCell cell) {
>+		super(cell);
>+		eventType = PROGRAMATIC;
>+	}
>+
>+	/**
>+	 * This constructor is used for all types of mouse events. Currently the
>+	 * type is can be {@link #MOUSE_CLICK_SELECTION} and
>+	 * {@link #MOUSE_DOUBLE_CLICK_SELECTION}
>+	 * 
>+	 * @param cell
>+	 * the cell source of the event
>+	 * @param event
>+	 * the event
>+	 */
>+	public CellEditorActivationEvent(ViewerCell cell, MouseEvent event) {
>+		super(cell);
>+
>+		if (event.count >= 2) {
>+			eventType = MOUSE_DOUBLE_CLICK_SELECTION;
>+		} else {
>+			eventType = MOUSE_CLICK_SELECTION;
>+		}
>+
>+		this.sourceEvent = event;
>+		this.time = event.time;
>+	}
>+
>+	/**
>+	 * @param cell
>+	 * the cell source of the event
>+	 * @param event
>+	 * the event
>+	 */
>+	public CellEditorActivationEvent(ViewerCell cell, KeyEvent event) {
>+		super(cell);
>+		this.eventType = KEY_PRESSED;
>+		this.sourceEvent = event;
>+		this.time = 0;
>+		this.keyCode = event.keyCode;
>+		this.character = event.character;
>+		this.stateMask = event.stateMask;
>+	}
>+
>+	/**
>+	 * This constructur is used to mark the activation triggered by a traversal
>+	 * 
>+	 * @param cell
>+	 * the cell source of the event
>+	 * @param event
>+	 * the event
>+	 */
>+	public CellEditorActivationEvent(ViewerCell cell, TraverseEvent event) {
>+		super(cell);
>+		this.eventType = TRAVERSAL;
>+		this.sourceEvent = event;
>+	}
>+}
>Index: src/org/eclipse/jface/viewers/FocusCellChangeEvent.java
>===================================================================
>RCS file: src/org/eclipse/jface/viewers/FocusCellChangeEvent.java
>diff -N src/org/eclipse/jface/viewers/FocusCellChangeEvent.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/viewers/FocusCellChangeEvent.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,51 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ * IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.jface.viewers;
>+
>+import java.util.EventObject;
>+
>+/**
>+ * @since 3.3
>+ * 
>+ */
>+public class FocusCellChangeEvent extends EventObject {
>+
>+	/**
>+	 * 
>+	 */
>+	private static final long serialVersionUID = 1L;
>+
>+	/**
>+	 * the cell who recevied the focus
>+	 */
>+	public ViewerCell focusCell;
>+	
>+	/**
>+	 * the cell who lost the focus
>+	 */
>+	public ViewerCell focusLostCell;
>+	
>+	/**
>+	 * @param viewer
>+	 * the viewer
>+	 * @param focusCell
>+	 * the cell who recevied the focus
>+	 * @param focusLostCell
>+	 * the cell who lost the focus
>+	 */
>+	public FocusCellChangeEvent(ColumnViewer viewer, ViewerCell focusCell,
>+			ViewerCell focusLostCell) {
>+		super(viewer);
>+		this.focusCell=focusCell;
>+		this.focusLostCell=focusLostCell;
>+	}
>+}
>#P org.eclipse.jface.snippets
>Index: Eclipse JFace Snippets/org/eclipse/jface/snippets/viewers/Snippet026TreeViewerTabEditing.java
>===================================================================
>RCS file: Eclipse JFace Snippets/org/eclipse/jface/snippets/viewers/Snippet026TreeViewerTabEditing.java
>diff -N Eclipse JFace Snippets/org/eclipse/jface/snippets/viewers/Snippet026TreeViewerTabEditing.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ Eclipse JFace Snippets/org/eclipse/jface/snippets/viewers/Snippet026TreeViewerTabEditing.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,203 @@
>+/*******************************************************************************
>+ * Copyright (c) 2006 Tom Schindl 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:
>+ * Tom Schindl - initial API and implementation
>+ *******************************************************************************/
>+
>+package org.eclipse.jface.snippets.viewers;
>+
>+import java.util.ArrayList;
>+
>+import org.eclipse.jface.viewers.CellEditor;
>+import org.eclipse.jface.viewers.CellEditorActivationEvent;
>+import org.eclipse.jface.viewers.ColumnLabelProvider;
>+import org.eclipse.jface.viewers.ColumnViewerEditorActivationSupport;
>+import org.eclipse.jface.viewers.EditingSupport;
>+import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;
>+import org.eclipse.jface.viewers.ITreeContentProvider;
>+import org.eclipse.jface.viewers.SWTCellSupport;
>+import org.eclipse.jface.viewers.TextCellEditor;
>+import org.eclipse.jface.viewers.TreeViewer;
>+import org.eclipse.jface.viewers.TreeViewerColumn;
>+import org.eclipse.jface.viewers.Viewer;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.layout.FillLayout;
>+import org.eclipse.swt.widgets.Display;
>+import org.eclipse.swt.widgets.Shell;
>+
>+/**
>+ * A simple TreeViewer to demonstrate usage
>+ * 
>+ * @author Tom Schindl <tom.schindl@bestsolution.at>
>+ * 
>+ */
>+public class Snippet026TreeViewerTabEditing {
>+	public Snippet026TreeViewerTabEditing(final Shell shell) {
>+		final TreeViewer v = new TreeViewer(shell, SWT.BORDER
>+				| SWT.FULL_SELECTION);
>+		v.getTree().setLinesVisible(true);
>+		v.getTree().setHeaderVisible(true);
>+
>+		SWTCellSupport cellSupport = new SWTCellSupport(v,
>+				new FocusCellOwnerDrawHighlighter(v));
>+		ColumnViewerEditorActivationSupport actSupport = new ColumnViewerEditorActivationSupport(
>+				v, cellSupport) {
>+
>+			protected boolean isEditorActivationEvent(
>+					CellEditorActivationEvent event) {
>+				return event.eventType == CellEditorActivationEvent.TRAVERSAL
>+						|| event.eventType == CellEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION
>+						|| (event.eventType == CellEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR)
>+						|| event.eventType == CellEditorActivationEvent.PROGRAMATIC;
>+			}
>+
>+		};
>+		actSupport.setEnableEditorActivationWithKeyboard(true);
>+
>+		v.setEditorActivationSupport(actSupport);
>+
>+		final TextCellEditor textCellEditor = new TextCellEditor(v.getTree());
>+
>+		TreeViewerColumn column = new TreeViewerColumn(v, SWT.NONE);
>+		column.getColumn().setWidth(200);
>+		column.getColumn().setText("Column 1");
>+		column.setLabelProvider(new ColumnLabelProvider() {
>+
>+			public String getText(Object element) {
>+				return "Column 1 => " + element.toString();
>+			}
>+
>+		});
>+		column.setEditingSupport(new EditingSupport(v) {
>+			protected boolean canEdit(Object element) {
>+				return true;
>+			}
>+
>+			protected CellEditor getCellEditor(Object element) {
>+				return textCellEditor;
>+			}
>+
>+			protected Object getValue(Object element) {
>+				return ((MyModel) element).counter + "";
>+			}
>+
>+			protected void setValue(Object element, Object value) {
>+				((MyModel) element).counter = Integer
>+						.parseInt(value.toString());
>+				v.update(element, null);
>+			}
>+		});
>+		v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL
>+				| EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR
>+				| EditingSupport.TABBING_VERTICAL);
>+
>+		column = new TreeViewerColumn(v, SWT.NONE);
>+		column.getColumn().setWidth(200);
>+		column.getColumn().setText("Column 2");
>+		column.setLabelProvider(new ColumnLabelProvider() {
>+
>+			public String getText(Object element) {
>+				return "Column 2 => " + element.toString();
>+			}
>+
>+		});
>+
>+		v.setContentProvider(new MyContentProvider());
>+
>+		v.setInput(createModel());
>+	}
>+
>+	private MyModel createModel() {
>+
>+		MyModel root = new MyModel(0, null);
>+		root.counter = 0;
>+
>+		MyModel tmp;
>+		MyModel subItem;
>+		for (int i = 1; i < 10; i++) {
>+			tmp = new MyModel(i, root);
>+			root.child.add(tmp);
>+			for (int j = 1; j < i; j++) {
>+				subItem = new MyModel(j, tmp);
>+				subItem.child.add(new MyModel(j * 100, subItem));
>+				tmp.child.add(subItem);
>+			}
>+		}
>+
>+		return root;
>+	}
>+
>+	public static void main(String[] args) {
>+		Display display = new Display();
>+		Shell shell = new Shell(display);
>+		shell.setLayout(new FillLayout());
>+		new Snippet026TreeViewerTabEditing(shell);
>+		shell.open();
>+
>+		while (!shell.isDisposed()) {
>+			if (!display.readAndDispatch())
>+				display.sleep();
>+		}
>+
>+		display.dispose();
>+	}
>+
>+	private class MyContentProvider implements ITreeContentProvider {
>+
>+		public Object[] getElements(Object inputElement) {
>+			return ((MyModel) inputElement).child.toArray();
>+		}
>+
>+		public void dispose() {
>+		}
>+
>+		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
>+		}
>+
>+		public Object[] getChildren(Object parentElement) {
>+			return getElements(parentElement);
>+		}
>+
>+		public Object getParent(Object element) {
>+			if (element == null) {
>+				return null;
>+			}
>+			return ((MyModel) element).parent;
>+		}
>+
>+		public boolean hasChildren(Object element) {
>+			return ((MyModel) element).child.size() > 0;
>+		}
>+
>+	}
>+
>+	public class MyModel {
>+		public MyModel parent;
>+
>+		public ArrayList child = new ArrayList();
>+
>+		public int counter;
>+
>+		public MyModel(int counter, MyModel parent) {
>+			this.parent = parent;
>+			this.counter = counter;
>+		}
>+
>+		public String toString() {
>+			String rv = "Item ";
>+			if (parent != null) {
>+				rv = parent.toString() + ".";
>+			}
>+
>+			rv += counter;
>+
>+			return rv;
>+		}
>+	}
>+
>+}
>#P org.eclipse.swt.nebula.nebface
>Index: src/org/eclipse/swt/nebula/nebface/viewers/CheckEditingSupport.java
>===================================================================
>RCS file: /cvsroot/technology/org.eclipse.swt.nebula/org.eclipse.swt.nebula.nebface/src/org/eclipse/swt/nebula/nebface/viewers/CheckEditingSupport.java,v
>retrieving revision 1.1
>diff -u -r1.1 CheckEditingSupport.java
>--- src/org/eclipse/swt/nebula/nebface/viewers/CheckEditingSupport.java	20 Dec 2006 15:00:38 -0000	1.1
>+++ src/org/eclipse/swt/nebula/nebface/viewers/CheckEditingSupport.java	14 Feb 2007 21:41:47 -0000
>@@ -1,29 +1,56 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 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:
>+ * chris.gross@us.ibm.com - initial API and implementation
>+ *******************************************************************************/ 
>+
> package org.eclipse.swt.nebula.nebface.viewers;
> 
> import org.eclipse.jface.viewers.CellEditor;
>+import org.eclipse.jface.viewers.ColumnViewer;
> import org.eclipse.jface.viewers.EditingSupport;
> 
>+/**
>+ * .
>+ *
>+ * @author chris.gross@us.ibm.com
>+ * @since 3.3
>+ */
> public abstract class CheckEditingSupport extends EditingSupport
> {
>+ /**
>+ * Checkbox editing support.
>+ * 
>+ * @param viewer column to add check box support for.
>+ */
>+ public CheckEditingSupport(ColumnViewer viewer)
>+ {
>+ super(viewer);
>+ }
> 
>+ /** {@inheritDoc} */
> protected boolean canEdit(Object element)
> {
>- // TODO Auto-generated method stub
> return false;
> }
> 
>+ /** {@inheritDoc} */
> protected CellEditor getCellEditor(Object element)
> {
>- // TODO Auto-generated method stub
> return null;
> }
> 
>+ /** {@inheritDoc} */
> protected Object getValue(Object element)
> {
>- // TODO Auto-generated method stub
> return null;
> }
> 
>- protected abstract void setValue(Object element, Object value);
>-
>+ /** {@inheritDoc} */
>+ public abstract void setValue(Object element, Object value);
> }
>Index: src/org/eclipse/swt/nebula/nebface/viewers/GridViewer.java
>===================================================================
>RCS file: /cvsroot/technology/org.eclipse.swt.nebula/org.eclipse.swt.nebula.nebface/src/org/eclipse/swt/nebula/nebface/viewers/GridViewer.java,v
>retrieving revision 1.1
>diff -u -r1.1 GridViewer.java
>--- src/org/eclipse/swt/nebula/nebface/viewers/GridViewer.java	20 Dec 2006 15:00:38 -0000	1.1
>+++ src/org/eclipse/swt/nebula/nebface/viewers/GridViewer.java	14 Feb 2007 21:41:47 -0000
>@@ -1,22 +1,24 @@
> /*******************************************************************************
>- * Copyright (c) 2006 Tom Schindl and others.
>+ * Copyright (c) 2007 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:
>- * Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
>- * IBM Corporation
>- *******************************************************************************/
>+ * rmcamara@us.ibm.com - initial API and implementation
>+ *******************************************************************************/ 
>+
> package org.eclipse.swt.nebula.nebface.viewers;
> 
>-import org.eclipse.jface.viewers.AbstractViewerEditor;
>-import org.eclipse.jface.viewers.BaseTableViewer;
>+import org.eclipse.jface.viewers.AbstractTableViewer;
>+import org.eclipse.jface.viewers.ColumnViewerEditor;
> import org.eclipse.jface.viewers.StructuredSelection;
>+import org.eclipse.jface.viewers.ViewerCell;
> import org.eclipse.jface.viewers.ViewerRow;
> import org.eclipse.jface.viewers.CellEditor.LayoutData;
> import org.eclipse.swt.SWT;
>+import org.eclipse.swt.graphics.Image;
> import org.eclipse.swt.graphics.Point;
> import org.eclipse.swt.nebula.widgets.grid.Grid;
> import org.eclipse.swt.nebula.widgets.grid.GridEditor;
>@@ -24,187 +26,294 @@
> import org.eclipse.swt.widgets.Composite;
> import org.eclipse.swt.widgets.Control;
> import org.eclipse.swt.widgets.Item;
>+import org.eclipse.swt.widgets.TableItem;
> import org.eclipse.swt.widgets.Widget;
> 
>-public class GridViewer extends BaseTableViewer {
>-	private static final int DEFAULT_STYLE = SWT.MULTI | SWT.H_SCROLL
>-			| SWT.V_SCROLL | SWT.BORDER;
>-
>-	private Grid grid;
>-
>-	private GridEditor gridEditor;
>-
>-	public GridViewer(Composite parent) {
>-		this(parent, DEFAULT_STYLE);
>-	}
>+/**
>+ * A concrete viewer based on an Grid control.
>+ * 
>+ * This class is not intended to be subclassed outside the viewer framework. It
>+ * is designed to be instantiated with a pre-existing Grid control and
>+ * configured with a domain-specific content provider, label provider, element
>+ * filter (optional), and element sorter (optional).
>+ * 
>+ * Content providers for grid viewers must not implement the
>+ * {@code ITreeContentProvider} interface.
>+ * 
>+ * 
>+ * @author rmcamara@us.ibm.com
>+ * @since
>+ * @3.3
>+ */
>+public class GridViewer extends AbstractTableViewer
>+{
>+ /** This viewer's grid control. */
>+ private Grid grid;
>+ 
>+ /** Editor support for tables. */
>+ private GridEditor gridEditor;
>+
>+ /**
>+ * Creates a grid viewer on a newly-created grid control under the given
>+ * parent. The grid control is created using the SWT style bits
>+ * <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>BORDER</code>. The
>+ * viewer has no input, no content provider, a default label provider, no
>+ * sorter, and no filters.
>+ * 
>+ * @param parent the parent control
>+ */
>+ public GridViewer(Composite parent)
>+ {
>+ this(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
>+ }
> 
>-	public GridViewer(Composite parent, int style) {
>-		this(new Grid(parent, style));
>-	}
>+ /**
>+ * Creates a grid viewer on a newly-created grid control under the given
>+ * parent. The grid control is created using the given SWT style bits. The
>+ * viewer has no input, no content provider, a default label provider, no
>+ * sorter, and no filters.
>+ * 
>+ * @param parent the parent control
>+ * @param style the SWT style bits used to create the grid.
>+ */
>+ public GridViewer(Composite parent, int style)
>+ {
>+ this(new Grid(parent, style));
>+ }
> 
>-	public GridViewer(Grid gridControl) {
>-		super();
>- grid = gridControl;
>-		gridEditor = new GridEditor(gridControl);
>+ /**
>+ * Creates a grid viewer on the given grid control. The viewer has no
>+ * input, no content provider, a default label provider, no sorter, and no
>+ * filters.
>+ * 
>+ * @param grid the grid control
>+ */
>+ public GridViewer(Grid grid)
>+ {
>+ this.grid = grid;
>+ gridEditor = new GridEditor(grid);
> hookControl(grid);
>-	}
>-
>-	public Grid getGrid() {
>-		return grid;
>-	}
>-
>-	protected ViewerRow createNewRowPart(int style, int rowIndex) {
>-		GridItem item;
>-
>-		if (rowIndex >= 0) {
>-			item = new GridItem(grid, style, rowIndex);
>-		} else {
>-			item = new GridItem(grid, style);
>-		}
>-
>-		return getViewerRowFromItem(item);
>-	}
>+ }
>+ 
>+ /**
>+ * Returns the underlying Grid Control. 
>+ * 
>+ * @return grid control.
>+ */
>+ public Grid getGrid()
>+ {
>+ return grid;
>+ }
> 
>- protected ViewerRow getViewerRowFromItem(Widget item) {
>- ViewerRow part = (ViewerRow) item.getData(ViewerRow.ROWPART_KEY);
>+ /** {@inheritDoc} */
>+ protected ViewerRow internalCreateNewRowPart(int style, int rowIndex)
>+ {
>+ GridItem item;
> 
>- if (part == null) {
>- part = new GridViewerRow(((GridItem) item));
>+ if (rowIndex >= 0) 
>+ {
>+ item = new GridItem(grid, style, rowIndex);
>+ } 
>+ else 
>+ {
>+ item = new GridItem(grid, style);
> }
> 
>- return part;
>+ return getViewerRowFromItem(item);
> }
> 
>-	protected AbstractViewerEditor createViewerEditor() {
>- return new AbstractViewerEditor(this) {
>-
>- protected StructuredSelection createSelection(Object element) {
>+ /** {@inheritDoc} */
>+ protected ColumnViewerEditor createViewerEditor() 
>+ {
>+ return new ColumnViewerEditor(this) 
>+ {
>+ protected StructuredSelection createSelection(Object element) 
>+ {
> return new StructuredSelection(element);
> }
> 
>- protected Item[] getSelection() {
>- return getGrid().getSelection();
>- }
>-
>- protected void setEditor(Control w, Item item, int fColumnNumber) {
>+ protected void setEditor(Control w, Item item, int fColumnNumber) 
>+ {
> gridEditor.setEditor(w, (GridItem) item, fColumnNumber);
> }
> 
>- protected void setLayoutData(LayoutData layoutData) {
>+ protected void setLayoutData(LayoutData layoutData) 
>+ {
> gridEditor.grabHorizontal = layoutData.grabHorizontal;
> gridEditor.horizontalAlignment = layoutData.horizontalAlignment;
> gridEditor.minimumWidth = layoutData.minimumWidth;
> }
>-
>- protected void showSelection() {
>- getGrid().showSelection();
>- }
>-
> };
>-	}
>-
>-	protected void internalClear(int index) {
>-		// TODO NEEDS IMP
>-	}
>+ }
> 
>-	protected void internalClearAll() {
>-		// TODO NEEDS IMP
>-	}
>+ /** {@inheritDoc} */
>+ protected void doClear(int index)
>+ {
>+ // TODO Fix when grid supports virtual
>+ }
> 
>-	protected void internalDeselectAll() {
>-		grid.deselectAll();
>-	}
>+ /** {@inheritDoc} */
>+ protected void doClearAll()
>+ {
>+ //TODO Fix when grid supports virtual
>+ }
>+ 
>+ /** {@inheritDoc} */
>+ protected void doSetItemCount(int count)
>+ {
>+ //TODO Once grid supports virtual
>+ }
> 
>-	protected Widget internalGetColumn(int index) {
>-		return grid.getColumn(index);
>-	}
>+ /** {@inheritDoc} */
>+ protected void doDeselectAll()
>+ {
>+ grid.deselectAll();
>+ }
> 
>-	protected int internalGetColumnCount() {
>-		return grid.getColumnCount();
>-	}
>+ /** {@inheritDoc} */
>+ protected Widget doGetColumn(int index)
>+ {
>+ return grid.getColumn(index);
>+ }
> 
>-	protected Widget[] internalGetColumns() {
>-		return grid.getColumns();
>-	}
>+ /** {@inheritDoc} */
>+ protected int doGetColumnCount()
>+ {
>+ return grid.getColumnCount();
>+ }
> 
>-	protected Item internalGetItem(int index) {
>-		return grid.getItem(index);
>-	}
>+ /** {@inheritDoc} */
>+ protected Item doGetItem(int index)
>+ {
>+ return grid.getItem(index);
>+ }
> 
>-	protected Item internalGetItem(Point point) {
>-		return grid.getItem(point);
>-	}
>+ /** {@inheritDoc} */
>+ protected int doGetItemCount()
>+ {
>+ return grid.getItemCount();
>+ }
> 
>-	protected int internalGetItemCount() {
>-		return grid.getItemCount();
>-	}
>+ /** {@inheritDoc} */
>+ protected Item[] doGetItems()
>+ {
>+ return grid.getItems();
>+ }
> 
>-	protected Item[] internalGetItems() {
>-		return grid.getItems();
>-	}
>+ /** {@inheritDoc} */
>+ protected Item[] doGetSelection()
>+ {
>+ return grid.getSelection();
>+ }
> 
>-	protected Widget[] internalGetSelection() {
>-		return grid.getSelection();
>-	}
>+ /** {@inheritDoc} */
>+ protected int[] doGetSelectionIndices()
>+ {
>+ return grid.getSelectionIndices();
>+ }
> 
>-	protected int[] internalGetSelectionIndices() {
>-		return grid.getSelectionIndices();
>-	}
>+ /** {@inheritDoc} */
>+ protected int doIndexOf(Item item)
>+ {
>+ return grid.indexOf((GridItem) item);
>+ }
> 
>-	protected int internalIndexOf(Item item) {
>-		return grid.indexOf((GridItem) item);
>-	}
>+ /** {@inheritDoc} */
>+ protected void doRemove(int[] indices)
>+ {
>+ grid.remove(indices);
>+ }
> 
>-	protected void internalRemove(int start, int end) {
>-		grid.remove(start, end);
>-	}
>+ /** {@inheritDoc} */
>+ protected void doRemove(int start, int end)
>+ {
>+ grid.remove(start, end);
>+ }
> 
>-	protected void internalRemove(int[] indices) {
>-		grid.remove(indices);
>-	}
>+ /** {@inheritDoc} */
>+ protected void doRemoveAll()
>+ {
>+ grid.removeAll();
>+ }
> 
>-	protected void internalRemoveAll() {
>-		grid.removeAll();
>-	}
>+ /** {@inheritDoc} */
>+ protected void doSetSelection(Item[] items)
>+ {
>+ GridItem[] items2 = new GridItem[items.length];
>+ for (int i = 0; i < items.length; i++)
>+ {
>+ items2[i] = (GridItem) items[i];
>+ }
>+ grid.setSelection(items2);
>+ }
> 
>-	protected void internalSetItemCount(int count) {
>-		// TODO NEEDS IMP
>-	}
>+ /** {@inheritDoc} */
>+ protected void doSetSelection(int[] indices)
>+ {
>+ grid.setSelection(indices);
>+ }
> 
>-	protected void internalSetSelection(Item[] items) {
>-		if (items != null) {
>-			grid.setSelection(new GridItem[0]);
>-		} else {
>-			GridItem[] tmp = new GridItem[items.length];
>-			System.arraycopy(items, 0, tmp, 0, items.length);
>-			grid.setSelection(tmp);
>-		}
>+ /** {@inheritDoc} */
>+ protected void doShowItem(Item item)
>+ {
>+ grid.showItem((GridItem)item);
>+ }
> 
>-	}
>+ /** {@inheritDoc} */
>+ protected void doShowSelection()
>+ {
>+ grid.showSelection();
>+ }
> 
>-	protected void internalSetSelection(int[] indices) {
>-		grid.setSelection(indices);
>-	}
>+ /** {@inheritDoc} */
>+ protected Item getItemAt(Point point)
>+ {
>+ return grid.getItem(point);
>+ }
> 
>-	protected void internalShowItem(Item item) {
>-		grid.showItem((GridItem) item);
>-	}
>+ /** {@inheritDoc} */
>+ public Control getControl()
>+ {
>+ return grid;
>+ }
>+ 
>+ /** {@inheritDoc} */
>+ protected ViewerRow getViewerRowFromItem(Widget item) 
>+ {
>+ ViewerRow part = (ViewerRow) item.getData(ViewerRow.ROWPART_KEY);
> 
>-	protected void internalShowSelection() {
>-		grid.showSelection();
>-	}
>+ if (part == null) 
>+ {
>+ part = new GridViewerRow(((GridItem) item));
>+ }
> 
>-	protected void internalSetControl(Control table) {
>-		grid = (Grid) table;
>-	}
>+ return part;
>+ }
> 
>-	public Control getControl() {
>-		return grid;
>+ 
>+ 
>+ protected void doResetItem(Item item) {
>+		GridItem gridItem = (GridItem) item;
>+		int columnCount = Math.max(1, grid.getColumnCount());
>+		for (int i = 0; i < columnCount; i++) {
>+			gridItem.setText(i, ""); //$NON-NLS-1$
>+			gridItem.setImage(null);
>+		}
> 	}
> 
>- protected Item getItemAt(Point point)
>- {
>- return grid.getItem(point);
>- }
>+	ViewerCell getFocusCell() {
>+		if( getGrid().getCellSelectionEnabled() ) {
>+			Point p = getGrid().getFocusCell();
>+			
>+			if( p.x >= 0 && p.y >= 0 ) {
>+				GridItem item = getGrid().getItem(p.y);
>+				if( item != null ) {
>+					ViewerRow row = (ViewerRow) item.getData(ViewerRow.ROWPART_KEY);
>+					return row.getCell(p.x);
>+				}
>+			}
>+		}
> 
>+		return null;
>+	}
> }
>Index: src/org/eclipse/swt/nebula/nebface/viewers/GridViewerColumn.java
>===================================================================
>RCS file: /cvsroot/technology/org.eclipse.swt.nebula/org.eclipse.swt.nebula.nebface/src/org/eclipse/swt/nebula/nebface/viewers/GridViewerColumn.java,v
>retrieving revision 1.1
>diff -u -r1.1 GridViewerColumn.java
>--- src/org/eclipse/swt/nebula/nebface/viewers/GridViewerColumn.java	20 Dec 2006 15:00:38 -0000	1.1
>+++ src/org/eclipse/swt/nebula/nebface/viewers/GridViewerColumn.java	14 Feb 2007 21:41:47 -0000
>@@ -1,18 +1,17 @@
> /*******************************************************************************
>- * Copyright (c) 2006 IBM Corporation and others.
>+ * Copyright (c) 2007 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
>- ******************************************************************************/
>+ * rmcamara@us.ibm.com - initial API and implementation
>+ *******************************************************************************/ 
> 
> package org.eclipse.swt.nebula.nebface.viewers;
> 
> import org.eclipse.jface.viewers.EditingSupport;
>-import org.eclipse.jface.viewers.TableViewer;
> import org.eclipse.jface.viewers.ViewerColumn;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.nebula.widgets.grid.Grid;
>@@ -20,49 +19,54 @@
> import org.eclipse.swt.nebula.widgets.grid.GridItem;
> import org.eclipse.swt.widgets.Event;
> import org.eclipse.swt.widgets.Listener;
>-import org.eclipse.swt.widgets.Table;
>-import org.eclipse.swt.widgets.TableColumn;
> 
> /**
>- * This is the JFace' implementation of SWT's {@link TableColumn} like
>- * {@link TableViewer} is JFace' implementation of {@link Table}
>- * 
>+ * The concrete implementation of the ColumnViewer for the grid.
>+ *
>+ * @author rmcamara@us.ibm.com
> * @since 3.3
> */
>-public final class GridViewerColumn extends ViewerColumn {
>-
>+public final class GridViewerColumn extends ViewerColumn 
>+{
>+ /** The concrete grid column that is being represented by the {@code ViewerColumn}.*/
> private GridColumn column;
>+ 
>+ /** Editor support for handling check events. */
> private CheckEditingSupport checkEditingSupport;
>+ 
>+ /** The parent grid viewer. */
> private GridViewer viewer;
> 
> /**
>- * Create a new column in the {@link TableViewer}
>+ * Create a new column in the {@link GridViewer}
> * 
> * @param viewer
> * the viewer the column belongs to
> * @param style
> * the style used to create the column for style bits see
>- * {@link TableColumn}
>- * @see TableColumn#TableColumn(Table, int)
>+ * {@link GridColumn}
>+ * @see GridColumn#GridColumn(Grid, int)
> */
>- public GridViewerColumn(GridViewer viewer, int style) {
>+ public GridViewerColumn(GridViewer viewer, int style) 
>+ {
> this(viewer, style, -1);
> this.viewer = viewer;
> }
> 
> /**
>- * Create a new column in the {@link TableViewer}
>+ * Create a new column in the {@link GridViewer}
> * 
> * @param viewer
> * the viewer the column belongs to
> * @param style
> * the style used to create the column for style bits see
>- * {@link TableColumn}
>+ * {@link GridColumn}
> * @param index
> * the index of the newly created column
>- * @see TableColumn#TableColumn(Table, int, int)
>+ * @see GridColumn#GridColumn(Grid, int, int)
> */
>- public GridViewerColumn(GridViewer viewer, int style, int index) {
>+ public GridViewerColumn(GridViewer viewer, int style, int index) 
>+ {
> this(viewer, createColumn((Grid) viewer.getControl(), style, index));
> this.viewer = viewer;
> }
>@@ -74,27 +78,34 @@
> * @param column
> * the column the viewer is attached to
> */
>- public GridViewerColumn(GridViewer viewer, GridColumn column) {
>+ public GridViewerColumn(GridViewer viewer, GridColumn column) 
>+ {
> super(viewer, column);
> this.column = column;
> this.viewer = viewer;
> }
> 
>- private static GridColumn createColumn(Grid grid, int style, int index) {
>- if (index >= 0) {
>- return new GridColumn(grid, style, index);
>+ private static GridColumn createColumn(Grid table, int style, int index) 
>+ {
>+ if (index >= 0) 
>+ {
>+ return new GridColumn(table, style, index);
> }
> 
>- return new GridColumn(grid, style);
>+ return new GridColumn(table, style);
> }
> 
> /**
>- * @return the underlying SWT column
>+ * Returns the underlying column.
>+ * 
>+ * @return the underlying Nebula column
> */
>- public GridColumn getColumn() {
>+ public GridColumn getColumn() 
>+ {
> return column;
> }
> 
>+ /** {@inheritDoc} */
> public void setEditingSupport(EditingSupport editingSupport)
> {
> if (editingSupport instanceof CheckEditingSupport)
>@@ -123,4 +134,4 @@
> super.setEditingSupport(editingSupport);
> } 
> }
>-}
>+}
>\ No newline at end of file
>Index: src/org/eclipse/swt/nebula/nebface/viewers/GridViewerRow.java
>===================================================================
>RCS file: /cvsroot/technology/org.eclipse.swt.nebula/org.eclipse.swt.nebula.nebface/src/org/eclipse/swt/nebula/nebface/viewers/GridViewerRow.java,v
>retrieving revision 1.1
>diff -u -r1.1 GridViewerRow.java
>--- src/org/eclipse/swt/nebula/nebface/viewers/GridViewerRow.java	20 Dec 2006 15:00:38 -0000	1.1
>+++ src/org/eclipse/swt/nebula/nebface/viewers/GridViewerRow.java	14 Feb 2007 21:41:47 -0000
>@@ -1,14 +1,14 @@
> /*******************************************************************************
>- * Copyright (c) 2006 Tom Schindl and others.
>+ * Copyright (c) 2007 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:
>- * Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
>- * IBM Corporation
>- *******************************************************************************/
>+ * rmcamara@us.ibm.com - initial API and implementation
>+ *******************************************************************************/ 
>+
> package org.eclipse.swt.nebula.nebface.viewers;
> 
> import org.eclipse.jface.viewers.ViewerRow;
>@@ -20,82 +20,151 @@
> import org.eclipse.swt.widgets.Control;
> import org.eclipse.swt.widgets.Item;
> 
>-public class GridViewerRow extends ViewerRow {
>-	private GridItem item;
>-
>-	public GridViewerRow(GridItem item) {
>-		super(item);
>-		this.item = item;
>-	}
>-
>-	public void clear() {
>-		item.setText("");
>-		if (getColumnCount() == 0) {
>-			item.setImage(null);
>+/**
>+ * GridViewerRow is the concrete implementation of the part that represents items in a
>+ * Grid.
>+ *
>+ * @author rmcamara@us.ibm.com
>+ * @since 3.3
>+ */
>+public class GridViewerRow extends ViewerRow
>+{
>+ private GridItem item;
>+
>+ /**
>+ * Create a new instance of the receiver.
>+ * 
>+ * @param item GridItem source.
>+ */
>+ public GridViewerRow(Item item)
>+ {
>+ super(item);
>+ this.item = (GridItem)item;
>+ }
>+
>+ /** {@inheritDoc} */
>+ public Rectangle getBounds(int columnIndex)
>+ {
>+ return item.getBounds(columnIndex);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public Rectangle getBounds()
>+ {
>+ // TODO This is not correct. Update once item returns the correct information.
>+ return item.getBounds(0);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public Item getItem()
>+ {
>+ return item;
>+ }
>+
>+ /** {@inheritDoc} */
>+ public int getColumnCount()
>+ {
>+ return item.getParent().getColumnCount();
>+ }
>+
>+ /** {@inheritDoc} */
>+ public Color getBackground(int columnIndex)
>+ {
>+ return item.getBackground(columnIndex);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public Font getFont(int columnIndex)
>+ {
>+ return item.getFont(columnIndex);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public Color getForeground(int columnIndex)
>+ {
>+ return item.getForeground(columnIndex);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public Image getImage(int columnIndex)
>+ {
>+ return item.getImage(columnIndex);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public String getText(int columnIndex)
>+ {
>+ return item.getText(columnIndex);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public void setBackground(int columnIndex, Color color)
>+ {
>+ item.setBackground(columnIndex, color);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public void setFont(int columnIndex, Font font)
>+ {
>+ item.setFont(columnIndex, font);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public void setForeground(int columnIndex, Color color)
>+ {
>+ item.setForeground(columnIndex, color);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public void setImage(int columnIndex, Image image)
>+ {
>+ item.setImage(columnIndex, image);
>+ }
>+
>+ /** {@inheritDoc} */
>+ public void setText(int columnIndex, String text)
>+ {
>+ item.setText(columnIndex, text == null ? "" : text); //$NON-NLS-1$
>+ }
>+
>+ /** {@inheritDoc} */
>+ public Control getControl()
>+ {
>+ return item.getParent();
>+ }
>+
>+ public ViewerRow getNeighbor(int direction, boolean sameLevel) {
>+		if( direction == ViewerRow.ABOVE ) {
>+			return getRowAbove();
>+		} else if( direction == ViewerRow.BELOW ) {
>+			return getRowBelow();
> 		} else {
>-			for (int i = 0; i < getColumnCount(); i++) {
>-				item.setImage(i, null);
>-			}
>+			throw new IllegalArgumentException("Illegal value of direction argument."); //$NON-NLS-1$
> 		}
> 	}
> 
>-	public Color getBackground(int columnIndex) {
>-		return item.getBackground(columnIndex);
>-	}
>-
>-	public Rectangle getBounds(int columnIndex) {
>-		return item.getBounds(columnIndex);
>-	}
>-
>-	public Rectangle getBounds() {
>-		return item.getBounds(0); // TODO IS THIS CORRECT
>-	}
>-
>-	public int getColumnCount() {
>-		return item.getParent().getColumnCount();
>-	}
>-
>-	public Font getFont(int columnIndex) {
>-		return item.getFont(columnIndex);
>-	}
>-
>-	public Color getForeground(int columnIndex) {
>-		return item.getForeground(columnIndex);
>-	}
>-
>-	public Image getImage(int columnIndex) {
>-		return item.getImage(columnIndex);
>-	}
>-
>-	public Item getItem() {
>-		return item;
>-	}
>-
>-	public String getText(int columnIndex) {
>-		return item.getText(columnIndex);
>-	}
>-
>-	public void setBackground(int columnIndex, Color color) {
>-		item.setBackground(columnIndex, color);
>-	}
>-
>-	public void setFont(int columnIndex, Font font) {
>-		item.setFont(columnIndex, font);
>-	}
>-
>-	public void setForeground(int columnIndex, Color color) {
>-		item.setForeground(columnIndex, color);
>-	}
>-
>-	public void setImage(int columnIndex, Image image) {
>-		item.setImage(columnIndex, image);
>-	}
>-
>-	public void setText(int columnIndex, String text) {
>-		item.setText(columnIndex, text);
>+	
>+	private ViewerRow getRowAbove() {
>+		int index = item.getParent().indexOf(item) - 1;
>+		
>+		if( index >= 0 ) {
>+			return (ViewerRow)item.getParent().getItem(index).getData(ViewerRow.ROWPART_KEY); 
>+		}
>+		
>+		return null;
> 	}
> 
>-	public Control getControl() {
>-		return item.getParent();
>+	private ViewerRow getRowBelow() {
>+		int index = item.getParent().indexOf(item) + 1;
>+		
>+		if( index < item.getParent().getItemCount() ) {
>+			GridItem tmp = item.getParent().getItem(index);
>+			//TODO NULL can happen in case of VIRTUAL => How do we deal with that
>+			if( tmp != null ) {
>+				return (ViewerRow)tmp.getData(ViewerRow.ROWPART_KEY);
>+			}
>+		}
>+		
>+		return null;
> 	}
>-}
>+}
>\ No newline at end of file
>Index: META-INF/MANIFEST.MF
>===================================================================
>RCS file: /cvsroot/technology/org.eclipse.swt.nebula/org.eclipse.swt.nebula.nebface/META-INF/MANIFEST.MF,v
>retrieving revision 1.5
>diff -u -r1.5 MANIFEST.MF
>--- META-INF/MANIFEST.MF	12 Jan 2007 03:49:24 -0000	1.5
>+++ META-INF/MANIFEST.MF	14 Feb 2007 21:41:47 -0000
>@@ -4,7 +4,7 @@
> Bundle-SymbolicName: org.eclipse.swt.nebula.nebface
> Bundle-Version: 1.0.0
> Bundle-Localization: plugin
>-Require-Bundle: org.eclipse.jface,
>+Require-Bundle: org.eclipse.jface;visibility:=reexport,
> org.eclipse.swt.nebula;visibility:=reexport,
> org.eclipse.equinox.common;visibility:=reexport
> Bundle-RequiredExecutionEnvironment: J2SE-1.4
>Index: src/org/eclipse/swt/nebula/nebface/viewers/GridViewerEditorActivationSupport.java
>===================================================================
>RCS file: src/org/eclipse/swt/nebula/nebface/viewers/GridViewerEditorActivationSupport.java
>diff -N src/org/eclipse/swt/nebula/nebface/viewers/GridViewerEditorActivationSupport.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/swt/nebula/nebface/viewers/GridViewerEditorActivationSupport.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,14 @@
>+package org.eclipse.swt.nebula.nebface.viewers;
>+
>+import org.eclipse.jface.viewers.ColumnViewerEditorActivationSupport;
>+import org.eclipse.jface.viewers.ViewerCell;
>+
>+public class GridViewerEditorActivationSupport extends ColumnViewerEditorActivationSupport {
>+	public GridViewerEditorActivationSupport(GridViewer viewer) {
>+		super(viewer,null);
>+	}
>+	
>+	protected ViewerCell getFocusCell() {
>+		return ((GridViewer)getViewer()).getFocusCell();
>+	}
>+}
>Index: src/org/eclipse/swt/nebula/nebface/viewers/GridTreeViewer.java
>===================================================================
>RCS file: src/org/eclipse/swt/nebula/nebface/viewers/GridTreeViewer.java
>diff -N src/org/eclipse/swt/nebula/nebface/viewers/GridTreeViewer.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/swt/nebula/nebface/viewers/GridTreeViewer.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,392 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 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:
>+ * rmcamara@us.ibm.com - initial API and implementation
>+ *******************************************************************************/ 
>+
>+package org.eclipse.swt.nebula.nebface.viewers;
>+
>+import org.eclipse.jface.viewers.AbstractTreeViewer;
>+import org.eclipse.jface.viewers.ColumnViewerEditor;
>+import org.eclipse.jface.viewers.StructuredSelection;
>+import org.eclipse.jface.viewers.TreePath;
>+import org.eclipse.jface.viewers.TreeSelection;
>+import org.eclipse.jface.viewers.ViewerRow;
>+import org.eclipse.jface.viewers.CellEditor.LayoutData;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.events.TreeListener;
>+import org.eclipse.swt.graphics.Point;
>+import org.eclipse.swt.nebula.widgets.grid.Grid;
>+import org.eclipse.swt.nebula.widgets.grid.GridEditor;
>+import org.eclipse.swt.nebula.widgets.grid.GridItem;
>+import org.eclipse.swt.widgets.Composite;
>+import org.eclipse.swt.widgets.Control;
>+import org.eclipse.swt.widgets.Item;
>+import org.eclipse.swt.widgets.Widget;
>+
>+import java.util.List;
>+
>+
>+/**
>+ * A concrete viewer based on an {@link Grid} control. This viewer is meant
>+ * to provide grid like support for a grid.
>+ * 
>+ * This class is not intended to be subclassed outside the viewer framework. It
>+ * is designed to be instantiated with a pre-existing grid control and
>+ * configured with a domain-specific content provider, label provider, element
>+ * filter (optional), and element sorter (optional).
>+ * 
>+ * Content providers for grid viewers must implement the
>+ * {@code ITreeContentProvider} interface.
>+ * 
>+ * @author rmcamara@us.ibm.com
>+ * @since 3.3
>+ */
>+public class GridTreeViewer extends AbstractTreeViewer
>+{
>+ /** This viewer's grid control. */
>+ private Grid grid;
>+
>+ /** Table editor. */
>+ private GridEditor gridEditor;
>+
>+ /**
>+ * Creates a grid viewer on a newly-created grid control under the given
>+ * parent. The grid control is created using the SWT style bits
>+ * <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>BORDER</code>. The
>+ * viewer has no input, no content provider, a default label provider, no
>+ * sorter, and no filters.
>+ * 
>+ * @param parent the parent control.
>+ */
>+ public GridTreeViewer(Composite parent)
>+ {
>+ this(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
>+ }
>+
>+ /**
>+ * Creates a grid viewer on a newly-created grid control under the given
>+ * parent. The grid control is created using the given SWT style bits. The
>+ * viewer has no input, no content provider, a default label provider, no
>+ * sorter, and no filters.
>+ * 
>+ * @param parent the parent control.
>+ * @param style the SWT style bits used to create the grid.
>+ */
>+ public GridTreeViewer(Composite parent, int style)
>+ {
>+ this(new Grid(parent, style));
>+ }
>+
>+ /**
>+ * Creates a grid viewer on the given grid control. The viewer has no
>+ * input, no content provider, a default label provider, no sorter, and no
>+ * filters.
>+ * 
>+ * @param grid the grid control.
>+ */
>+ public GridTreeViewer(Grid table)
>+ {
>+ this.grid = table;
>+ gridEditor = new GridEditor(table);
>+ hookControl(table);
>+ }
>+
>+ /**
>+ * {@inheritDoc}
>+ */
>+ public Control getControl()
>+ {
>+ return grid;
>+ }
>+
>+ /**
>+ * Returns this grid viewer's grid control.
>+ * 
>+ * @return the grid control
>+ */
>+ public Grid getGrid()
>+ {
>+ return grid;
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void addTreeListener(Control c, TreeListener listener)
>+ {
>+ ((Grid)c).addTreeListener(listener);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Widget doGetColumn(int index)
>+ {
>+ return grid.getColumn(index);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected int doGetColumnCount()
>+ {
>+ return grid.getColumnCount();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item[] getChildren(Widget o)
>+ {
>+ if (o instanceof GridItem)
>+ {
>+ return ((GridItem)o).getItems();
>+ }
>+ if (o instanceof Grid)
>+ {
>+ List rootlist = ((Grid)o).getRootItems();
>+ GridItem[] roots = new GridItem[rootlist.size()];
>+ 
>+ for (int i = 0; i < roots.length; i++)
>+ {
>+ roots[i] = (GridItem) rootlist.get(i);
>+ }
>+ 
>+ return roots;
>+ }
>+ return null;
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected boolean getExpanded(Item item)
>+ {
>+ return ((GridItem)item).isExpanded();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item getItemAt(Point p)
>+ {
>+ return grid.getItem(p);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item[] getItems(Item item)
>+ {
>+ return ((GridItem)item).getItems();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item getParentItem(Item item)
>+ {
>+ return ((GridItem)item).getParentItem();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item[] getSelection(Control widget)
>+ {
>+ return ((Grid)widget).getSelection();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item doGetParentItem(Item item)
>+ {
>+ return ((GridItem)item).getParentItem();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected int doIndexOf(Item parentItem, Item item)
>+ {
>+ return ((GridItem)parentItem).indexOf((GridItem)item);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected int doIndexOf(Item item)
>+ {
>+ return grid.indexOf((GridItem)item);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected ColumnViewerEditor createViewerEditor()
>+ {
>+ return new ColumnViewerEditor(this)
>+ {
>+ protected StructuredSelection createSelection(Object element)
>+ {
>+ if (element instanceof TreePath)
>+ {
>+ return new TreeSelection((TreePath)element, getComparer());
>+ }
>+
>+ return new StructuredSelection(element);
>+ }
>+
>+ protected void setEditor(Control w, Item item, int fColumnNumber)
>+ {
>+ gridEditor.setEditor(w, (GridItem)item, fColumnNumber);
>+ }
>+
>+ protected void setLayoutData(LayoutData layoutData)
>+ {
>+ gridEditor.grabHorizontal = layoutData.grabHorizontal;
>+ gridEditor.horizontalAlignment = layoutData.horizontalAlignment;
>+ gridEditor.minimumWidth = layoutData.minimumWidth;
>+ }
>+ };
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void removeAll(Control widget)
>+ {
>+ ((Grid)widget).removeAll();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void doSetExpanded(Item item, boolean expanded)
>+ {
>+ ((GridItem)item).setExpanded(expanded);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void doSetSelection(List items)
>+ {
>+ GridItem[] newItems = new GridItem[items.size()];
>+ items.toArray(newItems);
>+ getGrid().setSelection(newItems);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void showItem(Item item)
>+ {
>+ getGrid().showItem((GridItem)item);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item getChild(Widget widget, int index)
>+ {
>+ if (widget instanceof GridItem)
>+ {
>+ return ((GridItem)widget).getItem(index);
>+ }
>+ if (widget instanceof Grid)
>+ {
>+ return (GridItem) ((Grid)widget).getRootItems().get(index);
>+ }
>+ return null;
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected int doGetItemCount()
>+ {
>+ return grid.getItemCount();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item doGetItem(int index)
>+ {
>+ return grid.getItem(index);
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected Item doGetItem(Item item, int index)
>+ {
>+ return ((GridItem)item).getItem(index);
>+ }
>+ 
>+ /** {@inheritDoc} */
>+ protected int doGetItemCount(Item item)
>+ {
>+ return ((GridItem)item).getItemCount();
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void doSetItemCount(int count)
>+ {
>+ // TODO Implement once grid supports virtual
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void doSetItemCount(Item item, int count)
>+ {
>+ // TODO Implement once grid supports virtual
>+ }
>+ 
>+ /** {@inheritDoc} */
>+ protected void doClear(Item item, boolean all)
>+ {
>+ // TODO Once grid implements virtual.
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void doClearAll(Item item, boolean all)
>+ {
>+ //TODO implement once grid supports virtual.
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected void doClearAll(boolean all)
>+ {
>+ //TODO implement once grid supports virtual.
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected ViewerRow getViewerRowFromItem(Widget item)
>+ {
>+ ViewerRow part = (ViewerRow)item.getData(ViewerRow.ROWPART_KEY);
>+
>+ if (part == null)
>+ {
>+ part = new GridViewerRow(((GridItem)item));
>+ }
>+
>+ return part;
>+ }
>+
>+ /** {@inheritDoc} */
>+ protected ViewerRow doCreateNewRowPart(ViewerRow parent, int style, int rowIndex)
>+ {
>+ if (parent == null)
>+ {
>+ if (rowIndex >= 0)
>+ {
>+ return getViewerRowFromItem(new GridItem(grid, style, rowIndex));
>+ }
>+ return getViewerRowFromItem(new GridItem(grid, style));
>+ }
>+
>+ if (rowIndex >= 0)
>+ {
>+ return getViewerRowFromItem(new GridItem((GridItem)parent.getItem(), 
>+ SWT.NONE, rowIndex));
>+ }
>+
>+ return getViewerRowFromItem(new GridItem((GridItem)parent.getItem(), SWT.NONE));
>+ }
>+
>+ protected int getItemCount(Control control)
>+ {
>+ // TODO Auto-generated method stub
>+ return 0;
>+ }
>+
>+ protected int getItemCount(Item item)
>+ {
>+ // TODO Auto-generated method stub
>+ return 0;
>+ }
>+
>+ protected Item newItem(Widget parent, int style, int index)
>+ {
>+ // TODO Auto-generated method stub
>+ return null;
>+ }
>+
>+ protected void setExpanded(Item item, boolean expand)
>+ {
>+ // TODO Auto-generated method stub
>+ 
>+ }
>+
>+ protected void setSelection(List items)
>+ {
>+ // TODO Auto-generated method stub
>+ 
>+ }
>+}

Actions: View | Diff

Attachments on bug 172646: 58144 | 58157 | 58201 | 58739 | 58764 | 59015 | 59270 | 59808 | 59921 | 59931 | 60115 | 60666 | 61074 | 61075