Attachment #59931 for bug #172646

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




/*******************************************************************************
 * 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.CellNavigationStrategy;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ColumnViewerEditor;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.TreeViewerFocusCellManager;
import org.eclipse.jface.viewers.TreeViewerEditor;
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);

		 
		TreeViewerFocusCellManager focusCellManager = new TreeViewerFocusCellManager(v,new FocusCellOwnerDrawHighlighter(v));
		ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(v) {
			protected boolean isEditorActivationEvent(
					ColumnViewerEditorActivationEvent event) {
				return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL
						|| event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION
						|| (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR)
						|| event.eventType == ColumnViewerEditorActivationEvent.PROGRAMATIC;
			}
		};
		
		TreeViewerEditor treeViewerEditor = new TreeViewerEditor (v, focusCellManager, actSupport, ColumnViewerEditor.TABBING_HORIZONTAL
				| ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
				| ColumnViewerEditor.TABBING_VERTICAL | ColumnViewerEditor.KEYBOARD_ACTIVATION);
		v.setColumnViewerEditor(treeViewerEditor);
		
		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);
			}
		});

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

}






import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.viewers.CellEditor.LayoutData;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;

	private Table table;

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

	/**
	 * Creates a table viewer on a newly-created table control under the given
	 * parent. The table control is created using the SWT style bits
	 * <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>BORDER</code>. The

	 */
	public TableViewer(Table table) {
		this.table = table;
		tableEditor = new TableEditor(table);
		hookControl(table);
	}


	}
	
	protected ColumnViewerEditor createViewerEditor() {
		return new TableViewerEditor(this,new ColumnViewerEditorActivationStrategy(this),ColumnViewerEditor.DEFAULT);

			protected StructuredSelection createSelection(Object element) {
				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);
			}

			protected void setLayoutData(LayoutData layoutData) {
				tableEditor.grabHorizontal = layoutData.grabHorizontal;
				tableEditor.horizontalAlignment = layoutData.horizontalAlignment;
				tableEditor.minimumWidth = layoutData.minimumWidth;
			}

			protected void showSelection() {
				table.showSelection();
			}

		};
	}
	
	/**




import java.util.List;

import org.eclipse.jface.util.Policy;
import org.eclipse.jface.viewers.CellEditor.LayoutData;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TreeEditor;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.TreeEvent;

	private Tree tree;

	/**
	 * This viewer's tree editor.
	 */
	private TreeEditor treeEditor;

	/**
	 * Flag for whether the tree has been disposed of.
	 */
	private boolean treeIsDisposed = false;

		super();
		this.tree = tree;
		hookControl(tree);
		treeEditor = new TreeEditor(tree);
	}

	/*

	}

	protected ColumnViewerEditor createViewerEditor() {
		return new TreeViewerEditor(this,null,new ColumnViewerEditorActivationStrategy(this),ColumnViewerEditor.DEFAULT);

			protected StructuredSelection createSelection(Object element) {
				if (element instanceof TreePath) {
					return new TreeSelection((TreePath) element, getComparer());
				}

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

			protected void setLayoutData(LayoutData layoutData) {
				treeEditor.grabHorizontal = layoutData.grabHorizontal;
				treeEditor.horizontalAlignment = layoutData.horizontalAlignment;
				treeEditor.minimumWidth = layoutData.minimumWidth;
			}

			protected void showSelection() {
				getTree().showSelection();
			}

		};
	}

	/*




package org.eclipse.jface.viewers;

import org.eclipse.core.runtime.Assert;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.TraverseEvent;

/**
 * EditingSupport is the abstract superclass of the support for cell editing.

 * 
 */
public abstract class EditingSupport {
	/**
	 * Tabing from cell to cell is turned off
	 */
	public static final int TABBING_NONE = 1;

	/**
	 * Should if the end of the row is reach started from the start/end of the
	 * row below/above
	 */
	public static final int TABBING_MOVE_TO_ROW_NEIGHBOR = 1 << 1;

	/**
	 * Should if the end of the row is reach started from the beginning in the
	 * same row
	 */
	public static final int TABBING_CYCLE_IN_ROW = 1 << 2;

	/**
	 * Support tabing to Cell above/below the current cell
	 */
	public static final int TABBING_VERTICAL = 1 << 3;

	/**
	 * Should tabing from column to column with in one row be supported
	 */
	public static final int TABBING_HORIZONTAL = 1 << 4;

	private ColumnViewer viewer;


	 *            a new viewer
	 */
	public EditingSupport(ColumnViewer viewer) {
		Assert.isNotNull(viewer, "Viewer is not allowed to be null"); //$NON-NLS-1$
		this.viewer = viewer;
	}


	/**
	 * Restore the value from the CellEditor
	 * 
	 * <p>
	 * <b>Subclasses should overwrite!</b>
	 * </p>
	 * 
	 * @param element
	 *            the model element

	protected abstract void setValue(Object element, Object value);

	/**
	 * @return the viewer this editing support works for
	 */
	protected boolean isTabingSupported() {
		return (TABBING_NONE & getTabingStyle()) != TABBING_NONE;
	}

	/**
	 * @return the bit mask representing the tabing style
	 */
	public ColumnViewer getViewer() {
		return viewer;
	}

	/**
	 * @param cellEditor
	 *            the cell editor
	 * @param value
	 *            the value to set the editor to
	 * <li>{@link #TABBING_MOVE_TO_ROW_NEIGHBOR}</li>
	 * <li>{@link #TABBING_CYCLE_IN_ROW}</li>
	 * <li>{@link #TABBING_VERTICAL}</li>
	 * <li>{@link #TABBING_HORIZONTAL}</li>
	 * </ul>
	 * 
	 * <p>
	 * Subclasses may overwrite to implement their custom logic to edit the next
	 * cell
	 * </p>
	 * 
	 * @param columnIndex
	 *            the index of the current column
	 * @param row
	 *            the current row
	 * @param event
	 *            the travers event
	 */
	protected void setCellEditorValue(CellEditor cellEditor, Object value) {
		cellEditor.setValue(value);
		
		ViewerCell cell2edit = null;

		if (event.detail == SWT.TRAVERSE_TAB_PREVIOUS) {
			event.doit = false;

			if ((event.stateMask & SWT.CTRL) == SWT.CTRL
					&& (getTabingStyle() & TABBING_VERTICAL) == TABBING_VERTICAL) {
				cell2edit = searchCellAboveBelow(row, viewer, columnIndex, true);
			} else if ((getTabingStyle() & TABBING_HORIZONTAL) == TABBING_HORIZONTAL) {
				cell2edit = searchPreviousCell(row, viewer, columnIndex,
						columnIndex);
			}
		} else if (event.detail == SWT.TRAVERSE_TAB_NEXT) {
			event.doit = false;

			if ((event.stateMask & SWT.CTRL) == SWT.CTRL
					&& (getTabingStyle() & TABBING_VERTICAL) == TABBING_VERTICAL) {
				cell2edit = searchCellAboveBelow(row, viewer, columnIndex,
						false);
			} else if ((getTabingStyle() & TABBING_HORIZONTAL) == TABBING_HORIZONTAL) {
				cell2edit = searchNextCell(row, viewer, columnIndex,
						columnIndex);
			}
		}

		if (cell2edit != null) {
			viewer.editElement(cell2edit.getElement(), cell2edit
					.getColumnIndex());
		}
	}

	private ViewerCell searchCellAboveBelow(ViewerRow row, ColumnViewer viewer,
			int columnIndex, boolean above) {
		ViewerCell rv = null;

		ViewerRow newRow = null;

		if (above) {
			newRow = row.getNeighbor(ViewerRow.ABOVE, false);
		} else {
			newRow = row.getNeighbor(ViewerRow.BELOW,false);
		}

		if (newRow != null) {
			ViewerColumn column = viewer.getViewerColumn(columnIndex);
			if (column != null
					&& column.getEditingSupport().canEdit(
							newRow.getItem().getData())) {
				rv = newRow.getCell(columnIndex);
			} else {
				rv = searchCellAboveBelow(newRow, viewer, columnIndex, above);
			}
		}

		return rv;
	}

	private ViewerCell searchPreviousCell(ViewerRow row, ColumnViewer viewer,
			int columnIndex, int startIndex) {
		ViewerCell rv = null;

		if (columnIndex - 1 >= 0) {
			ViewerColumn column = viewer.getViewerColumn(columnIndex - 1);
			if (column != null
					&& column.getEditingSupport().canEdit(
							row.getItem().getData())) {
				rv = row.getCell(columnIndex - 1);
			} else {
				rv = searchPreviousCell(row, viewer, columnIndex - 1,
						startIndex);
			}
		} else {
			if ((getTabingStyle() & TABBING_CYCLE_IN_ROW) == TABBING_CYCLE_IN_ROW) {
				// Check that we don't get into endless loop
				if (columnIndex - 1 != startIndex) {
					// Don't subtract -1 from getColumnCount() we need to
					// start in the virtual column
					// next to it
					rv = searchPreviousCell(row, viewer, row.getColumnCount(),
							startIndex);
				}
			} else if ((getTabingStyle() & TABBING_MOVE_TO_ROW_NEIGHBOR) == TABBING_MOVE_TO_ROW_NEIGHBOR) {
				ViewerRow rowAbove = row.getNeighbor(ViewerRow.ABOVE,false);
				if (rowAbove != null) {
					rv = searchPreviousCell(rowAbove, viewer, rowAbove
							.getColumnCount(), startIndex);
				}
			}
		}

		return rv;
	}

	private ViewerCell searchNextCell(ViewerRow row, ColumnViewer viewer,
			int columnIndex, int startIndex) {
		ViewerCell rv = null;

		if (columnIndex + 1 < row.getColumnCount()) {
			ViewerColumn column = viewer.getViewerColumn(columnIndex + 1);
			if (column != null
					&& column.getEditingSupport().canEdit(
							row.getItem().getData())) {
				rv = row.getCell(columnIndex + 1);
			} else {
				rv = searchNextCell(row, viewer, columnIndex + 1, startIndex);
			}
		} else {
			if ((getTabingStyle() & TABBING_CYCLE_IN_ROW) == TABBING_CYCLE_IN_ROW) {
				// Check that we don't get into endless loop
				if (columnIndex + 1 != startIndex) {
					// Start from -1 from the virtual column before the
					// first one
					rv = searchNextCell(row, viewer, -1, startIndex);
				}
			} else if ((getTabingStyle() & TABBING_MOVE_TO_ROW_NEIGHBOR) == TABBING_MOVE_TO_ROW_NEIGHBOR) {
				ViewerRow rowBelow = row.getNeighbor(ViewerRow.BELOW,false);
				if (rowBelow != null) {
					rv = searchNextCell(rowBelow, viewer, -1, startIndex);
				}
			}
		}

		return rv;
	}
	
	/**
	 * @param cellEditor
	 *            the cell-editor
	 * @return the value retrieved from cell-editor
	 */
	protected Object getCellEditorValue(CellEditor cellEditor) {
		return cellEditor.getValue();
	}
}

Lines 14-19 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewer.java (-75 / +137 lines)
14		14
15	package org.eclipse.jface.viewers;	15	package org.eclipse.jface.viewers;
16		16
		17	import java.util.List;
		18
17	import org.eclipse.core.runtime.Assert;	19	import org.eclipse.core.runtime.Assert;
18	import org.eclipse.swt.events.MouseAdapter;	20	import org.eclipse.swt.events.MouseAdapter;
19	import org.eclipse.swt.events.MouseEvent;	21	import org.eclipse.swt.events.MouseEvent;
Lines 38-43 Link Here
38	*	40	*
39	*/	41	*/
40	public abstract class ColumnViewer extends StructuredViewer {	42	public abstract class ColumnViewer extends StructuredViewer {
		43	private CellEditor[] cellEditors;
		44
		45	private ICellModifier cellModifier;
		46
		47	private String[] columnProperties;
41		48
42	private ToolTipSupport tooltipSupport;	49	private ToolTipSupport tooltipSupport;
43		50
Lines 48-64 Link Here
48		55
49	private ColumnViewerEditor viewerEditor;	56	private ColumnViewerEditor viewerEditor;
50		57
51	private int tabEditingStyle = EditingSupport.TABBING_NONE;
52
53	/**	58	/**
54	* Create a new instance of the receiver.	59	* Create a new instance of the receiver.
55	*/	60	*/
56	public ColumnViewer() {	61	public ColumnViewer() {
57	viewerEditor = createViewerEditor();	62
58	}	63	}
59		64
60	protected void hookControl(Control control) {	65	protected void hookControl(Control control) {
61	super.hookControl(control);	66	super.hookControl(control);
		67	viewerEditor = createViewerEditor();
62	hookEditingSupport(control);	68	hookEditingSupport(control);
63	}	69	}
64		70
Lines 76-91 Link Here
76	if (viewerEditor != null) {	82	if (viewerEditor != null) {
77	control.addMouseListener(new MouseAdapter() {	83	control.addMouseListener(new MouseAdapter() {
78	public void mouseDown(MouseEvent e) {	84	public void mouseDown(MouseEvent e) {
79	viewerEditor.handleMouseDown(e);	85	handleMouseDown(e);
80	}	86	}
81	});	87	});
82	}	88	}
83	}	89	}
84		90
85	/**	91	/**
86	* Creates the viewer editor used for editing cell contents. To be implemented by subclasses.	92	* Creates the viewer editor used for editing cell contents. To be
		93	* implemented by subclasses.
87	*	94	*
88	* @return the editor, or <code>null</code> if this viewer does not support editing cell contents.	95	* @return the editor, or <code>null</code> if this viewer does not
		96	* support editing cell contents.
89	*/	97	*/
90	protected abstract ColumnViewerEditor createViewerEditor();	98	protected abstract ColumnViewerEditor createViewerEditor();
91		99
Lines 95-101 Link Here
95	*	103	*
96	* @param point	104	* @param point
97	* the widget-relative coordinates	105	* the widget-relative coordinates
98	* @return the cell or <code>null</code> if no cell is found at the given point	106	* @return the cell or <code>null</code> if no cell is found at the given
		107	* point
99	*/	108	*/
100	ViewerCell getCell(Point point) {	109	ViewerCell getCell(Point point) {
101	ViewerRow row = getViewerRow(point);	110	ViewerRow row = getViewerRow(point);
Lines 127-133 Link Here
127	/**	136	/**
128	* Returns the viewer row associated with the given row widget.	137	* Returns the viewer row associated with the given row widget.
129	*	138	*
130	* @param item the row widget	139	* @param item
		140	* the row widget
131	* @return ViewerRow the associated viewer row	141	* @return ViewerRow the associated viewer row
132	*/	142	*/
133	protected ViewerRow getViewerRowFromItem(Widget item) {	143	protected ViewerRow getViewerRowFromItem(Widget item) {
Lines 137-143 Link Here
137	/**	147	/**
138	* Returns the column widget at the given column index.	148	* Returns the column widget at the given column index.
139	*	149	*
140	* @param columnIndex the column index	150	* @param columnIndex
		151	* the column index
141	* @return Widget the column widget	152	* @return Widget the column widget
142	*/	153	*/
143	protected abstract Widget getColumnViewerOwner(int columnIndex);	154	protected abstract Widget getColumnViewerOwner(int columnIndex);
Lines 150-156 Link Here
150	* @return the viewer column at the given index, or <code>null</code> if	161	* @return the viewer column at the given index, or <code>null</code> if
151	* there is none for the given index	162	* there is none for the given index
152	*/	163	*/
153	/* package */ ViewerColumn getViewerColumn(final int columnIndex) {	164	/* package */ViewerColumn getViewerColumn(final int columnIndex) {
154		165
155	ViewerColumn viewer;	166	ViewerColumn viewer;
156	Widget columnOwner = getColumnViewerOwner(columnIndex);	167	Widget columnOwner = getColumnViewerOwner(columnIndex);
Lines 176-182 Link Here
176	}	187	}
177		188
178	/**	189	/**
179	* Sets up editing support for the given column based on the "old" cell editor API.	190	* Sets up editing support for the given column based on the "old" cell
		191	* editor API.
180	*	192	*
181	* @param columnIndex	193	* @param columnIndex
182	* @param viewer	194	* @param viewer
Lines 229-243 Link Here
229	}	241	}
230		242
231	/**	243	/**
232	* Creates a generic viewer column for the given column widget, based on the given label provider.	244	* Creates a generic viewer column for the given column widget, based on the
		245	* given label provider.
233	*	246	*
234	* @param columnOwner the column widget	247	* @param columnOwner
235	* @param labelProvider the label provider to use for the column	248	* the column widget
		249	* @param labelProvider
		250	* the label provider to use for the column
236	* @return ViewerColumn the viewer column	251	* @return ViewerColumn the viewer column
237	*/	252	*/
238	private ViewerColumn createViewerColumn(Widget columnOwner,	253	private ViewerColumn createViewerColumn(Widget columnOwner,
239	CellLabelProvider labelProvider) {	254	CellLabelProvider labelProvider) {
240	ViewerColumn column = new ViewerColumn(this,columnOwner) {};	255	ViewerColumn column = new ViewerColumn(this, columnOwner) {
		256	};
241	column.setLabelProvider(labelProvider, false);	257	column.setLabelProvider(labelProvider, false);
242	return column;	258	return column;
243	}	259	}
Lines 269-287 Link Here
269	* @param column	285	* @param column
270	* @return ViewerCell	286	* @return ViewerCell
271	*/	287	*/
272	/* package */ ViewerCell updateCell(ViewerRow rowItem, int column) {	288	/* package */ViewerCell updateCell(ViewerRow rowItem, int column) {
273	cell.update(rowItem, column);	289	cell.update(rowItem, column);
274	return cell;	290	return cell;
275	}	291	}
276		292
277	/**	293	/**
278	* Returns the {@link Item} at the given widget-relative coordinates, or	294	* Returns the {@link Item} at the given widget-relative coordinates, or
279	* <code>null</code> if there is no item at the given coordinates.	295	* <code>null</code> if there is no item at the given coordinates.
280	*	296	*
281	* @param point	297	* @param point
282	* the widget-relative coordinates	298	* the widget-relative coordinates
283	* @return the {@link Item} at the coordinates or <code>null</code> if there	299	* @return the {@link Item} at the coordinates or <code>null</code> if
284	* is no item at the given coordinates	300	* there is no item at the given coordinates
285	*/	301	*/
286	protected abstract Item getItemAt(Point point);	302	protected abstract Item getItemAt(Point point);
287		303
Lines 339-345 Link Here
339		355
340	/**	356	/**
341	* Cancels a currently active cell editor if one is active. All changes	357	* Cancels a currently active cell editor if one is active. All changes
342	* already done in the cell editor are lost.	358	* already done in the cell editor are lost.
343	*	359	*
344	* @since 3.1 (in subclasses, added in 3.3 to abstract class)	360	* @since 3.1 (in subclasses, added in 3.3 to abstract class)
345	*/	361	*/
Lines 371-387 Link Here
371	*/	387	*/
372	public void editElement(Object element, int column) {	388	public void editElement(Object element, int column) {
373	if (viewerEditor != null) {	389	if (viewerEditor != null) {
374	viewerEditor.editElement(element, column);	390	Widget item = findItem(element);
		391	if (item != null) {
		392	ViewerRow row = getViewerRowFromItem(item);
		393	if (row != null) {
		394	ViewerCell cell = row.getCell(column);
		395	if (cell != null) {
		396	getControl().setRedraw(false);
		397
		398	List l = getSelectionFromWidget();
		399
		400	if (l.size() > 1 \|\| !l.contains(cell.getElement())) {
		401	setSelection(new StructuredSelection(cell
		402	.getElement()));
		403	}
		404
		405	triggerEditorActivationEvent(new ColumnViewerEditorActivationEvent(
		406	cell));
		407	getControl().setRedraw(true);
		408	}
		409	}
		410	}
375	}	411	}
376	}	412	}
377		413
378	/**	414	/**
379	* Return the CellEditors for the receiver, or <code>null</code> if no	415	* Return the CellEditors for the receiver, or <code>null</code> if no
380	* cell editors are set.	416	* cell editors are set.
381	* <p>	417	* <p>
382	* Since 3.3, an alternative API is available, see	418	* Since 3.3, an alternative API is available, see
383	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	419	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
384	* way of editing values in a column viewer.	420	* flexible way of editing values in a column viewer.
385	* </p>	421	* </p>
386	*	422	*
387	* @return CellEditor[]	423	* @return CellEditor[]
Lines 390-409 Link Here
390	* @see EditingSupport	426	* @see EditingSupport
391	*/	427	*/
392	public CellEditor[] getCellEditors() {	428	public CellEditor[] getCellEditors() {
393	if (viewerEditor != null) {	429	return cellEditors;
394	return viewerEditor.getCellEditors();
395	}
396	return null;
397	}	430	}
398		431
399	/**	432	/**
400	* Returns the cell modifier of this viewer, or <code>null</code> if none	433	* Returns the cell modifier of this viewer, or <code>null</code> if none
401	* has been set.	434	* has been set.
402	*	435	*
403	* <p>	436	* <p>
404	* Since 3.3, an alternative API is available, see	437	* Since 3.3, an alternative API is available, see
405	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	438	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
406	* way of editing values in a column viewer.	439	* flexible way of editing values in a column viewer.
407	* </p>	440	* </p>
408	*	441	*
409	* @return the cell modifier, or <code>null</code>	442	* @return the cell modifier, or <code>null</code>
Lines 412-421 Link Here
412	* @see EditingSupport	445	* @see EditingSupport
413	*/	446	*/
414	public ICellModifier getCellModifier() {	447	public ICellModifier getCellModifier() {
415	if (viewerEditor != null) {	448	return cellModifier;
416	return viewerEditor.getCellModifier();
417	}
418	return null;
419	}	449	}
420		450
421	/**	451	/**
Lines 425-432 Link Here
425	*	455	*
426	* <p>	456	* <p>
427	* Since 3.3, an alternative API is available, see	457	* Since 3.3, an alternative API is available, see
428	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	458	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
429	* way of editing values in a column viewer.	459	* flexible way of editing values in a column viewer.
430	* </p>	460	* </p>
431	*	461	*
432	* @return the list of column properties	462	* @return the list of column properties
Lines 435-444 Link Here
435	* @see EditingSupport	465	* @see EditingSupport
436	*/	466	*/
437	public Object[] getColumnProperties() {	467	public Object[] getColumnProperties() {
438	if (viewerEditor != null) {	468	return columnProperties;
439	return viewerEditor.getColumnProperties();
440	}
441	return null;
442	}	469	}
443		470
444	/**	471	/**
Lines 446-453 Link Here
446	*	473	*
447	* <p>	474	* <p>
448	* Since 3.3, an alternative API is available, see	475	* Since 3.3, an alternative API is available, see
449	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	476	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
450	* way of editing values in a column viewer.	477	* flexible way of editing values in a column viewer.
451	* </p>	478	* </p>
452	*	479	*
453	* @return <code>true</code> if there is an active cell editor, and	480	* @return <code>true</code> if there is an active cell editor, and
Lines 469-476 Link Here
469	*	496	*
470	* <p>	497	* <p>
471	* Since 3.3, an alternative API is available, see	498	* Since 3.3, an alternative API is available, see
472	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	499	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
473	* way of editing values in a column viewer.	500	* flexible way of editing values in a column viewer.
474	* </p>	501	* </p>
475	*	502	*
476	* @param editors	503	* @param editors
Lines 480-498 Link Here
480	* @see EditingSupport	507	* @see EditingSupport
481	*/	508	*/
482	public void setCellEditors(CellEditor[] editors) {	509	public void setCellEditors(CellEditor[] editors) {
483	if (viewerEditor != null) {	510	this.cellEditors = editors;
484	viewerEditor.setCellEditors(editors);
485	}
486	}	511	}
487		512
488	/**	513	/**
489	* Sets the cell modifier for this column viewer. This method does nothing if editing	514	* Sets the cell modifier for this column viewer. This method does nothing
490	* is not supported by this viewer.	515	* if editing is not supported by this viewer.
491	*	516	*
492	* <p>	517	* <p>
493	* Since 3.3, an alternative API is available, see	518	* Since 3.3, an alternative API is available, see
494	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	519	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
495	* way of editing values in a column viewer.	520	* flexible way of editing values in a column viewer.
496	* </p>	521	* </p>
497	*	522	*
498	* @param modifier	523	* @param modifier
Lines 502-510 Link Here
502	* @see EditingSupport	527	* @see EditingSupport
503	*/	528	*/
504	public void setCellModifier(ICellModifier modifier) {	529	public void setCellModifier(ICellModifier modifier) {
505	if (viewerEditor != null) {	530	this.cellModifier = modifier;
506	viewerEditor.setCellModifier(modifier);
507	}
508	}	531	}
509		532
510	/**	533	/**
Lines 515-522 Link Here
515	*	538	*
516	* <p>	539	* <p>
517	* Since 3.3, an alternative API is available, see	540	* Since 3.3, an alternative API is available, see
518	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	541	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
519	* way of editing values in a column viewer.	542	* flexible way of editing values in a column viewer.
520	* </p>	543	* </p>
521	*	544	*
522	* @param columnProperties	545	* @param columnProperties
Lines 526-550 Link Here
526	* @see EditingSupport	549	* @see EditingSupport
527	*/	550	*/
528	public void setColumnProperties(String[] columnProperties) {	551	public void setColumnProperties(String[] columnProperties) {
529	if (viewerEditor != null) {	552	this.columnProperties = columnProperties;
530	viewerEditor.setColumnProperties(columnProperties);
531	}
532	}
533
534	/**
535	* The tab-editing style used if the default implementation is used
536	*
537	* @param tabEditingStyle
538	* bit mask for the tab editing style
539	*/
540	public void setTabEditingStyle(int tabEditingStyle) {
541	this.tabEditingStyle = tabEditingStyle;
542	}	553	}
543		554
544	int getTabEditingStyle() {
545	return this.tabEditingStyle;
546	}
547
548	/**	555	/**
549	* Returns the number of columns contained in the receiver. If no columns	556	* Returns the number of columns contained in the receiver. If no columns
550	* were created by the programmer, this value is zero, despite the fact that	557	* were created by the programmer, this value is zero, despite the fact that
Lines 576-579 Link Here
576	}	583	}
577	return null;	584	return null;
578	}	585	}
579	}	586
		587	private void handleMouseDown(MouseEvent e) {
		588	ViewerCell cell = getCell(new Point(e.x, e.y));
		589
		590	if (cell != null) {
		591	triggerEditorActivationEvent(new ColumnViewerEditorActivationEvent(cell, e));
		592	}
		593	}
		594
		595	/**
		596	* Invoking this method fires an editor activation event which tries to
		597	* enable the editor but before this event is passed to
		598	* {@link ColumnViewerEditorActivationStrategy} to see if this event should really
		599	* trigger editor activation
		600	*
		601	* @param event
		602	* the activation event
		603	*/
		604	protected void triggerEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
		605	viewerEditor.handleEditorActivationEvent(event);
		606	}
		607
		608	/**
		609	* To fully control the strategy used to control on which cell-selection
		610	* events the editor has to be activated you can pass your customized
		611	* strategy using this method.
		612	*
		613	* @param editorActivationStrategy
		614	* the strategy used to activate an editor
		615	*/
		616	public void setEditorActivationSupport(
		617	ColumnViewerEditorActivationStrategy editorActivationStrategy) {
		618	if (viewerEditor != null) {
		619	viewerEditor.setEditorActivationStrategy(editorActivationStrategy);
		620	} else {
		621	throw new IllegalStateException(
		622	"This feature is not supported by the widget"); //$NON-NLS-1$
		623	}
		624	}
		625
		626	/**
		627	* @param columnViewerEditor
		628	* the new column viewer editor
		629	*/
		630	public void setColumnViewerEditor(ColumnViewerEditor columnViewerEditor) {
		631	Assert.isNotNull(viewerEditor);
		632	this.viewerEditor = columnViewerEditor;
		633	}
		634
		635	/**
		636	* @return the currently attached viewer editor
		637	*/
		638	public ColumnViewerEditor getColumnViewerEditor() {
		639	return viewerEditor;
		640	}
		641	}

Lines 853-856 Link Here

(-)src/org/eclipse/jface/viewers/CellEditor.java (+10 lines)
853	dirty = true;	853	dirty = true;
854	fireEditorValueChanged(oldValidState, newValidState);	854	fireEditorValueChanged(oldValidState, newValidState);
855	}	855	}
		856
		857	/**
		858	* Activate the editor but also inform the editor which event triggered its activation.
		859	* <b>The default implementation simply calls {@link #activate()}</b>
		860	*
		861	* @param activationEvent the editor activation event
		862	*/
		863	public void activate(ColumnViewerEditorActivationEvent activationEvent) {
		864	activate();
		865	}
856	}	866	}

Lines 14-19 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerEditor.java (-162 / +326 lines)
14		14
15	package org.eclipse.jface.viewers;	15	package org.eclipse.jface.viewers;
16		16
		17	import java.util.List;
		18
		19	import org.eclipse.core.runtime.ListenerList;
		20	import org.eclipse.swt.SWT;
17	import org.eclipse.swt.events.FocusAdapter;	21	import org.eclipse.swt.events.FocusAdapter;
18	import org.eclipse.swt.events.FocusEvent;	22	import org.eclipse.swt.events.FocusEvent;
19	import org.eclipse.swt.events.FocusListener;	23	import org.eclipse.swt.events.FocusListener;
Lines 22-28 Link Here
22	import org.eclipse.swt.events.MouseListener;	26	import org.eclipse.swt.events.MouseListener;
23	import org.eclipse.swt.events.TraverseEvent;	27	import org.eclipse.swt.events.TraverseEvent;
24	import org.eclipse.swt.events.TraverseListener;	28	import org.eclipse.swt.events.TraverseListener;
25	import org.eclipse.swt.graphics.Rectangle;
26	import org.eclipse.swt.widgets.Control;	29	import org.eclipse.swt.widgets.Control;
27	import org.eclipse.swt.widgets.Display;	30	import org.eclipse.swt.widgets.Display;
28	import org.eclipse.swt.widgets.Item;	31	import org.eclipse.swt.widgets.Item;
Lines 40-75 Link Here
40	public abstract class ColumnViewerEditor {	43	public abstract class ColumnViewerEditor {
41	private CellEditor cellEditor;	44	private CellEditor cellEditor;
42		45
43	private CellEditor[] cellEditors;	46	private ICellEditorListener cellEditorListener;
44		47
45	private ICellModifier cellModifier;	48	private FocusListener focusListener;
46		49
47	private String[] columnProperties;	50	private MouseListener mouseListener;
48		51
49	private int columnNumber;	52	private ColumnViewer viewer;
50		53
51	private ICellEditorListener cellEditorListener;	54	private TraverseListener tabeditingListener;
52		55
53	private FocusListener focusListener;	56	private int activationTime;
54		57
55	private MouseListener mouseListener;	58	private ViewerCell cell;
56		59
57	private int doubleClickExpirationTime;	60	private ColumnViewerEditorActivationEvent activationEvent;
58		61
59	private ColumnViewer viewer;	62	private ListenerList editorActivationListener;
60		63
61	private Item item;	64	private ColumnViewerEditorActivationStrategy editorActivationStrategy;
62		65
63	private TraverseListener tabeditingListener;	66	/**
		67	* Tabing from cell to cell is turned off
		68	*/
		69	public static final int DEFAULT = 1;
		70
		71	/**
		72	* Should if the end of the row is reach started from the start/end of the
		73	* row below/above
		74	*/
		75	public static final int TABBING_MOVE_TO_ROW_NEIGHBOR = 1 << 1;
		76
		77	/**
		78	* Should if the end of the row is reach started from the beginning in the
		79	* same row
		80	*/
		81	public static final int TABBING_CYCLE_IN_ROW = 1 << 2;
		82
		83	/**
		84	* Support tabing to Cell above/below the current cell
		85	*/
		86	public static final int TABBING_VERTICAL = 1 << 3;
		87
		88	/**
		89	* Should tabing from column to column with in one row be supported
		90	*/
		91	public static final int TABBING_HORIZONTAL = 1 << 4;
64		92
65	/**	93	/**
66	* Create a new editor implementation for the viewer
67	*	94	*
		95	*/
		96	public static final int KEYBOARD_ACTIVATION = 1 << 5;
		97
		98	private int feature;
		99
		100	/**
68	* @param viewer	101	* @param viewer
69	* the column viewer	102	* @param editorActivationStrategy
		103	* @param feature
70	*/	104	*/
71	public ColumnViewerEditor(ColumnViewer viewer) {	105	protected ColumnViewerEditor(ColumnViewer viewer,
		106	ColumnViewerEditorActivationStrategy editorActivationStrategy, int feature) {
72	this.viewer = viewer;	107	this.viewer = viewer;
		108	this.editorActivationStrategy = editorActivationStrategy;
		109	if( (feature & KEYBOARD_ACTIVATION) == KEYBOARD_ACTIVATION ) {
		110	this.editorActivationStrategy.setEnableEditorActivationWithKeyboard(true);
		111	}
		112	this.feature = feature;
73	initCellEditorListener();	113	initCellEditorListener();
74	}	114	}
75		115
Lines 92-119 Link Here
92		132
93	void activateCellEditor() {	133	void activateCellEditor() {
94		134
95	ViewerColumn part = viewer.getViewerColumn(columnNumber);	135	ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
96	Object element = item.getData();	136	Object element = cell.getElement();
97		137
98	if (part != null && part.getEditingSupport() != null	138	if (part != null && part.getEditingSupport() != null
99	&& part.getEditingSupport().canEdit(element)) {	139	&& part.getEditingSupport().canEdit(element)) {
		140
100	cellEditor = part.getEditingSupport().getCellEditor(element);	141	cellEditor = part.getEditingSupport().getCellEditor(element);
101	if (cellEditor != null) {	142	if (cellEditor != null) {
		143	if (editorActivationListener != null
		144	&& !editorActivationListener.isEmpty()) {
		145	Object[] ls = editorActivationListener.getListeners();
		146	for (int i = 0; i < ls.length; i++) {
		147
		148	if (activationEvent.cancle) {
		149	return;
		150	}
		151
		152	((ColumnViewerEditorActivationListener) ls[i])
		153	.beforeEditorActivated(activationEvent);
		154	}
		155	}
		156
102	cellEditor.addListener(cellEditorListener);	157	cellEditor.addListener(cellEditorListener);
103	Object value = part.getEditingSupport().getValue(element);	158	Object value = part.getEditingSupport().getValue(element);
104	cellEditor.setValue(value);	159	part.getEditingSupport().setCellEditorValue(cellEditor, value);
		160
105	// Tricky flow of control here:	161	// Tricky flow of control here:
106	// activate() can trigger callback to cellEditorListener which	162	// activate() can trigger callback to cellEditorListener which
107	// will clear cellEditor	163	// will clear cellEditor
108	// so must get control first, but must still call activate()	164	// so must get control first, but must still call activate()
109	// even if there is no control.	165	// even if there is no control.
110	final Control control = cellEditor.getControl();	166	final Control control = cellEditor.getControl();
111	cellEditor.activate();	167	cellEditor.activate(activationEvent);
112	if (control == null) {	168	if (control == null) {
113	return;	169	return;
114	}	170	}
115	setLayoutData(cellEditor.getLayoutData());	171	setLayoutData(cellEditor.getLayoutData());
116	setEditor(control, item, columnNumber);	172	setEditor(control, cell.getItem(), cell.getColumnIndex());
117	cellEditor.setFocus();	173	cellEditor.setFocus();
118	if (focusListener == null) {	174	if (focusListener == null) {
119	focusListener = new FocusAdapter() {	175	focusListener = new FocusAdapter() {
Lines 128-134 Link Here
128	public void mouseDown(MouseEvent e) {	184	public void mouseDown(MouseEvent e) {
129	// time wrap?	185	// time wrap?
130	// check for expiration of doubleClickTime	186	// check for expiration of doubleClickTime
131	if (e.time <= doubleClickExpirationTime) {	187	if (e.time <= activationTime) {
132	control.removeMouseListener(mouseListener);	188	control.removeMouseListener(mouseListener);
133	cancelEditing();	189	cancelEditing();
134	handleDoubleClickEvent();	190	handleDoubleClickEvent();
Lines 139-195 Link Here
139	};	195	};
140	control.addMouseListener(mouseListener);	196	control.addMouseListener(mouseListener);
141		197
142	if( tabeditingListener == null ) {	198	if (tabeditingListener == null) {
143	tabeditingListener = new TraverseListener() {	199	tabeditingListener = new TraverseListener() {
144		200
145	public void keyTraversed(TraverseEvent e) {	201	public void keyTraversed(TraverseEvent e) {
146	ViewerColumn col = viewer.getViewerColumn(columnNumber);	202	if ((feature & DEFAULT) != DEFAULT) {
147	if ( col != null && col.getEditingSupport().isTabingSupported() ) {	203	processTraversEvent(cell.getColumnIndex(),
148	col.getEditingSupport().processTraversEvent(	204	viewer.getViewerRowFromItem(cell
149	columnNumber,	205	.getItem()), e);
150	viewer.getViewerRowFromItem(item), e);
151	}	206	}
152	}	207	}
153	};	208	};
154	}	209	}
155
156	control.addTraverseListener(tabeditingListener);
157		210
158	}	211	control.addTraverseListener(tabeditingListener);
159	}
160	}
161		212
162	/**	213	if (editorActivationListener != null
163	* Activate a cell editor for the given mouse position.	214	&& !editorActivationListener.isEmpty()) {
164	*/	215	Object[] ls = editorActivationListener.getListeners();
165	private void activateCellEditor(MouseEvent event) {	216	for (int i = 0; i < ls.length; i++) {
166	if (item == null \|\| item.isDisposed()) {	217	((ColumnViewerEditorActivationListener) ls[i])
167	// item no longer exists	218	.afterEditorActivated(activationEvent);
168	return;	219	}
169	}
170	int columnToEdit;
171	ViewerRow row = viewer.getViewerRowFromItem(item);
172	int columns = row.getColumnCount();
173	if (columns == 0) {
174	// If no TableColumn, Table acts as if it has a single column
175	// which takes the whole width.
176	columnToEdit = 0;
177	} else {
178	columnToEdit = -1;
179	for (int i = 0; i < columns; i++) {
180	Rectangle bounds = row.getBounds(i);
181	if (bounds.contains(event.x, event.y)) {
182	columnToEdit = i;
183	break;
184	}	220	}
185	}	221	}
186	if (columnToEdit == -1) {
187	return;
188	}
189	}	222	}
190
191	columnNumber = columnToEdit;
192	activateCellEditor();
193	}	223	}
194		224
195	/**	225	/**
Lines 203-210 Link Here
203	// in case save results in applyEditorValue being re-entered	233	// in case save results in applyEditorValue being re-entered
204	// see 1GAHI8Z: ITPUI:ALL - How to code event notification when	234	// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
205	// using cell editor ?	235	// using cell editor ?
		236	ColumnViewerEditorDeactivationEvent tmp = new ColumnViewerEditorDeactivationEvent(cell);
		237	if (editorActivationListener != null
		238	&& !editorActivationListener.isEmpty()) {
		239	Object[] ls = editorActivationListener.getListeners();
		240	for (int i = 0; i < ls.length; i++) {
		241
		242	((ColumnViewerEditorActivationListener) ls[i])
		243	.beforeEditorDeactivated(tmp);
		244	}
		245	}
		246
206	this.cellEditor = null;	247	this.cellEditor = null;
207	Item t = this.item;	248	this.activationEvent = null;
		249	Item t = this.cell.getItem();
208	// don't null out table item -- same item is still selected	250	// don't null out table item -- same item is still selected
209	if (t != null && !t.isDisposed()) {	251	if (t != null && !t.isDisposed()) {
210	saveEditorValue(c, t);	252	saveEditorValue(c, t);
Lines 227-232 Link Here
227	}	269	}
228	}	270	}
229	c.deactivate();	271	c.deactivate();
		272
		273	if (editorActivationListener != null
		274	&& !editorActivationListener.isEmpty()) {
		275	Object[] ls = editorActivationListener.getListeners();
		276	for (int i = 0; i < ls.length; i++) {
		277	((ColumnViewerEditorActivationListener) ls[i])
		278	.afterEditorDeactivated(tmp);
		279	}
		280	}
230	}	281	}
231	}	282	}
232		283
Lines 235-240 Link Here
235	*/	286	*/
236	void cancelEditing() {	287	void cancelEditing() {
237	if (cellEditor != null) {	288	if (cellEditor != null) {
		289	ColumnViewerEditorDeactivationEvent tmp = new ColumnViewerEditorDeactivationEvent(cell);
		290	if (editorActivationListener != null
		291	&& !editorActivationListener.isEmpty()) {
		292	Object[] ls = editorActivationListener.getListeners();
		293	for (int i = 0; i < ls.length; i++) {
		294
		295	((ColumnViewerEditorActivationListener) ls[i])
		296	.beforeEditorDeactivated(tmp);
		297	}
		298	}
		299
238	setEditor(null, null, 0);	300	setEditor(null, null, 0);
239	cellEditor.removeListener(cellEditorListener);	301	cellEditor.removeListener(cellEditorListener);
240		302
Lines 256-262 Link Here
256		318
257	CellEditor oldEditor = cellEditor;	319	CellEditor oldEditor = cellEditor;
258	cellEditor = null;	320	cellEditor = null;
		321	activationEvent = null;
259	oldEditor.deactivate();	322	oldEditor.deactivate();
		323
		324	if (editorActivationListener != null
		325	&& !editorActivationListener.isEmpty()) {
		326	Object[] ls = editorActivationListener.getListeners();
		327	for (int i = 0; i < ls.length; i++) {
		328	((ColumnViewerEditorActivationListener) ls[i])
		329	.afterEditorDeactivated(tmp);
		330	}
		331	}
260	}	332	}
261	}	333	}
262		334
Lines 265-329 Link Here
265	*	337	*
266	* @param event	338	* @param event
267	*/	339	*/
268	void handleMouseDown(MouseEvent event) {	340	void handleEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
269	if (event.button != 1) {	341	if (editorActivationStrategy.isEditorActivationEvent(event)) {
270	return;	342	if (cellEditor != null) {
271	}	343	applyEditorValue();
272		344	}
273	if (cellEditor != null) {
274	applyEditorValue();
275	}
276
277	// activate the cell editor immediately. If a second mouseDown
278	// is received prior to the expiration of the doubleClick time then
279	// the cell editor will be deactivated and a doubleClick event will
280	// be processed.
281	//
282	doubleClickExpirationTime = event.time
283	+ Display.getCurrent().getDoubleClickTime();
284
285	Item[] items = getSelection();
286	// Do not edit if more than one row is selected.
287	if (items.length != 1) {
288	item = null;
289	return;
290	}
291	item = items[0];
292	activateCellEditor(event);
293	}
294		345
295	/**	346	this.cell = (ViewerCell) event.getSource();
296	* Start editing the given element.	347	activationEvent = event;
297	*	348	activationTime = event.time
298	* @param element	349	+ Display.getCurrent().getDoubleClickTime();
299	* @param column
300	*/
301	void editElement(Object element, int column) {
302	if (cellEditor != null) {
303	applyEditorValue();
304	}
305		350
306	setSelection(createSelection(element), true);	351	activateCellEditor();
307	Item[] selection = getSelection();
308	if (selection.length != 1) {
309	return;
310	}	352	}
311
312	item = selection[0];
313
314	// Make sure selection is visible
315	showSelection();
316	columnNumber = column;
317	activateCellEditor();
318
319	}	353	}
320		354
321	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {	355	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
322	ViewerColumn part = viewer.getViewerColumn(columnNumber);	356	ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
323		357
324	if (part != null && part.getEditingSupport() != null) {	358	if (part != null && part.getEditingSupport() != null) {
325	part.getEditingSupport().setValue(tableItem.getData(),	359	Object value = part.getEditingSupport().getCellEditorValue(cellEditor);
326	cellEditor.getValue());	360	part.getEditingSupport().setValue(tableItem.getData(),value);
327	}	361	}
328	}	362	}
329		363
Lines 337-404 Link Here
337	return cellEditor != null;	371	return cellEditor != null;
338	}	372	}
339		373
340	/**	374	void handleDoubleClickEvent() {
341	* Set the cell editors	375	viewer.fireDoubleClick(new DoubleClickEvent(viewer, viewer
342	*	376	.getSelection()));
343	* @param editors	377	viewer.fireOpen(new OpenEvent(viewer, viewer.getSelection()));
344	*/
345	void setCellEditors(CellEditor[] editors) {
346	this.cellEditors = editors;
347	}	378	}
348		379
349	/**	380	void addEditorActivationListener(
350	* Set the cell modifier	381	ColumnViewerEditorActivationListener listener) {
351	*	382	if (editorActivationListener == null) {
352	* @param modifier	383	editorActivationListener = new ListenerList();
353	*/	384	}
354	void setCellModifier(ICellModifier modifier) {	385	editorActivationListener.add(listener);
355	this.cellModifier = modifier;
356	}	386	}
357		387
358	/**	388	void removeEditorActivationListener(
359	* Set the column properties	389	ColumnViewerEditorActivationListener listener) {
360	*	390	if (editorActivationListener != null) {
361	* @param columnProperties	391	editorActivationListener.remove(listener);
362	*/	392	}
363	void setColumnProperties(String[] columnProperties) {
364	this.columnProperties = columnProperties;
365	}	393	}
366		394
367	/**	395	void setEditorActivationStrategy(
368	* Return the properties for the column	396	ColumnViewerEditorActivationStrategy editorActivationStrategy) {
369	*	397	this.editorActivationStrategy = editorActivationStrategy;
370	* @return the array of column properties
371	*/
372	Object[] getColumnProperties() {
373	return columnProperties;
374	}	398	}
375		399
376	/**	400	/**
377	* Get the cell modifier	401	* Process the travers event and opens the next available editor depending
		402	* of the implemented strategy. The default implementation uses the style
		403	* constants
		404	* <ul>
		405	* <li>{@link ColumnViewerEditor#TABBING_MOVE_TO_ROW_NEIGHBOR}</li>
		406	* <li>{@link ColumnViewerEditor#TABBING_CYCLE_IN_ROW}</li>
		407	* <li>{@link ColumnViewerEditor#TABBING_VERTICAL}</li>
		408	* <li>{@link ColumnViewerEditor#TABBING_HORIZONTAL}</li>
		409	* </ul>
		410	*
		411	* <p>
		412	* Subclasses may overwrite to implement their custom logic to edit the next
		413	* cell
		414	* </p>
378	*	415	*
379	* @return the cell modifier	416	* @param columnIndex
		417	* the index of the current column
		418	* @param row
		419	* the current row
		420	* @param event
		421	* the travers event
380	*/	422	*/
381	ICellModifier getCellModifier() {	423	protected void processTraversEvent(int columnIndex, ViewerRow row,
382	return cellModifier;	424	TraverseEvent event) {
		425
		426	ViewerCell cell2edit = null;
		427
		428	if (event.detail == SWT.TRAVERSE_TAB_PREVIOUS) {
		429	event.doit = false;
		430
		431	if ((event.stateMask & SWT.CTRL) == SWT.CTRL
		432	&& (feature & TABBING_VERTICAL) == TABBING_VERTICAL) {
		433	cell2edit = searchCellAboveBelow(row, viewer, columnIndex, true);
		434	} else if ((feature & TABBING_HORIZONTAL) == TABBING_HORIZONTAL) {
		435	cell2edit = searchPreviousCell(row, viewer, columnIndex,
		436	columnIndex);
		437	}
		438	} else if (event.detail == SWT.TRAVERSE_TAB_NEXT) {
		439	event.doit = false;
		440
		441	if ((event.stateMask & SWT.CTRL) == SWT.CTRL
		442	&& (feature & TABBING_VERTICAL) == TABBING_VERTICAL) {
		443	cell2edit = searchCellAboveBelow(row, viewer, columnIndex,
		444	false);
		445	} else if ((feature & TABBING_HORIZONTAL) == TABBING_HORIZONTAL) {
		446	cell2edit = searchNextCell(row, viewer, columnIndex,
		447	columnIndex);
		448	}
		449	}
		450
		451	if (cell2edit != null) {
		452	List l = viewer.getSelectionFromWidget();
		453
		454	viewer.getControl().setRedraw(false);
		455
		456	// TODO Is this correct in terms of other controls e.g. grid
		457	if (!l.contains(cell2edit.getElement())) {
		458	viewer.setSelection(new StructuredSelection(cell2edit
		459	.getElement()));
		460	}
		461
		462	ColumnViewerEditorActivationEvent acEvent = new ColumnViewerEditorActivationEvent(
		463	cell2edit, event);
		464	viewer.triggerEditorActivationEvent(acEvent);
		465	viewer.getControl().setRedraw(true);
		466	}
383	}	467	}
384		468
385	/**	469	private ViewerCell searchCellAboveBelow(ViewerRow row, ColumnViewer viewer,
386	* Return the array of CellEditors used in the viewer	470	int columnIndex, boolean above) {
387	*	471	ViewerCell rv = null;
388	* @return the cell editors	472
389	*/	473	ViewerRow newRow = null;
390	CellEditor[] getCellEditors() {	474
391	return cellEditors;	475	if (above) {
		476	newRow = row.getNeighbor(ViewerRow.ABOVE, false);
		477	} else {
		478	newRow = row.getNeighbor(ViewerRow.BELOW, false);
		479	}
		480
		481	if (newRow != null) {
		482	ViewerColumn column = viewer.getViewerColumn(columnIndex);
		483	if (column != null && column.getEditingSupport() != null
		484	&& column.getEditingSupport().canEdit(
		485	newRow.getItem().getData())) {
		486	rv = newRow.getCell(columnIndex);
		487	} else {
		488	rv = searchCellAboveBelow(newRow, viewer, columnIndex, above);
		489	}
		490	}
		491
		492	return rv;
392	}	493	}
393		494
394	void setSelection(StructuredSelection selection, boolean b) {	495	private ViewerCell searchPreviousCell(ViewerRow row, ColumnViewer viewer,
395	viewer.setSelection(selection, b);	496	int columnIndex, int startIndex) {
		497	ViewerCell rv = null;
		498
		499	if (columnIndex - 1 >= 0) {
		500	ViewerColumn column = viewer.getViewerColumn(columnIndex - 1);
		501	if (column != null && column.getEditingSupport() != null
		502	&& column.getEditingSupport().canEdit(
		503	row.getItem().getData())) {
		504	rv = row.getCell(columnIndex - 1);
		505	} else {
		506	rv = searchPreviousCell(row, viewer, columnIndex - 1,
		507	startIndex);
		508	}
		509	} else {
		510	if ((feature & TABBING_CYCLE_IN_ROW) == TABBING_CYCLE_IN_ROW) {
		511	// Check that we don't get into endless loop
		512	if (columnIndex - 1 != startIndex) {
		513	// Don't subtract -1 from getColumnCount() we need to
		514	// start in the virtual column
		515	// next to it
		516	rv = searchPreviousCell(row, viewer, row.getColumnCount(),
		517	startIndex);
		518	}
		519	} else if ((feature & TABBING_MOVE_TO_ROW_NEIGHBOR) == TABBING_MOVE_TO_ROW_NEIGHBOR) {
		520	ViewerRow rowAbove = row.getNeighbor(ViewerRow.ABOVE, false);
		521	if (rowAbove != null) {
		522	rv = searchPreviousCell(rowAbove, viewer, rowAbove
		523	.getColumnCount(), startIndex);
		524	}
		525	}
		526	}
		527
		528	return rv;
396	}	529	}
397		530
398	void handleDoubleClickEvent() {	531	private ViewerCell searchNextCell(ViewerRow row, ColumnViewer viewer,
399	viewer.fireDoubleClick(new DoubleClickEvent(viewer, viewer	532	int columnIndex, int startIndex) {
400	.getSelection()));	533	ViewerCell rv = null;
401	viewer.fireOpen(new OpenEvent(viewer, viewer.getSelection()));	534
		535	if (columnIndex + 1 < row.getColumnCount()) {
		536	ViewerColumn column = viewer.getViewerColumn(columnIndex + 1);
		537	if (column != null && column.getEditingSupport() != null
		538	&& column.getEditingSupport().canEdit(
		539	row.getItem().getData())) {
		540	rv = row.getCell(columnIndex + 1);
		541	} else {
		542	rv = searchNextCell(row, viewer, columnIndex + 1, startIndex);
		543	}
		544	} else {
		545	if ((feature & TABBING_CYCLE_IN_ROW) == TABBING_CYCLE_IN_ROW) {
		546	// Check that we don't get into endless loop
		547	if (columnIndex + 1 != startIndex) {
		548	// Start from -1 from the virtual column before the
		549	// first one
		550	rv = searchNextCell(row, viewer, -1, startIndex);
		551	}
		552	} else if ((feature & TABBING_MOVE_TO_ROW_NEIGHBOR) == TABBING_MOVE_TO_ROW_NEIGHBOR) {
		553	ViewerRow rowBelow = row.getNeighbor(ViewerRow.BELOW, false);
		554	if (rowBelow != null) {
		555	rv = searchNextCell(rowBelow, viewer, -1, startIndex);
		556	}
		557	}
		558	}
		559
		560	return rv;
402	}	561	}
403		562
404	/**	563	/**
Lines 431-442 Link Here
431	protected abstract void setLayoutData(CellEditor.LayoutData layoutData);	590	protected abstract void setLayoutData(CellEditor.LayoutData layoutData);
432		591
433	/**	592	/**
434	* Show up the current selection (scroll the selection into view)	593	* @return the cell currently holding the focus
		594	*
435	*/	595	*/
436	protected abstract void showSelection();	596	public ViewerCell getFocusCell() {
		597	return null;
		598	}
437		599
438	/**	600	/**
439	* @return the current selection	601	* @return the viewer working for
440	*/	602	*/
441	protected abstract Item[] getSelection();	603	protected ColumnViewer getViewer() {
442	}	604	return viewer;
		605	}
		606	}




/*******************************************************************************
 * 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.jface.viewers.CellEditor.LayoutData;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.TableItem;

/**
 * @since 3.3
 *
 */
public class TableViewerEditor extends ColumnViewerEditor {
	/**
	 * This viewer's table editor.
	 */
	private TableEditor tableEditor;
	
	/**
	 * @param viewer
	 * @param editorActivationStrategy
	 * @param feature
	 */
	public TableViewerEditor(TableViewer viewer, ColumnViewerEditorActivationStrategy editorActivationStrategy, int feature) {
		super(viewer,editorActivationStrategy,feature);
		tableEditor = new TableEditor(viewer.getTable());
	}
	
	protected StructuredSelection createSelection(Object element) {
		return new StructuredSelection(element);
	}

	protected void setEditor(Control w, Item item, int columnNumber) {
		tableEditor.setEditor(w, (TableItem) item, columnNumber);
	}

	protected void setLayoutData(LayoutData layoutData) {
		tableEditor.grabHorizontal = layoutData.grabHorizontal;
		tableEditor.horizontalAlignment = layoutData.horizontalAlignment;
		tableEditor.minimumWidth = layoutData.minimumWidth;
	}
}




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

	/**
	 * <b>Only set for {@link #KEY_PRESSED}</b>
	 */
	public int keyCode;

	/**
	 * <b>Only set for {@link #KEY_PRESSED}</b>
	 */
	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 ColumnViewerEditorActivationEvent(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 ColumnViewerEditorActivationEvent(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 ColumnViewerEditorActivationEvent(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 ColumnViewerEditorActivationEvent(ViewerCell cell, TraverseEvent event) {
		super(cell);
		this.eventType = TRAVERSAL;
		this.sourceEvent = event;
	}
}




/*******************************************************************************
 * 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 ColumnViewerEditorDeactivationEvent extends EventObject {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	/**
	 * @param source
	 */
	public ColumnViewerEditorDeactivationEvent(Object source) {
		super(source);
	}

}




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

/**
 * @since 3.3
 * 
 */
class SWTFocusCellManager {
	
	private CellNavigationStrategy navigationDelegate;

	private ColumnViewer viewer;

	private ViewerCell focusCell;

	/**
	 * @param viewer
	 * @param focusDrawingDelegate
	 * @param navigationDelegate
	 */
	public SWTFocusCellManager(ColumnViewer viewer,
			FocusCellHighlighter focusDrawingDelegate,
			CellNavigationStrategy navigationDelegate) {
		this.viewer = viewer;
		this.navigationDelegate = navigationDelegate;
		hookListener(viewer);
	}

	private void handleMouseDown(Event event) {
		ViewerCell cell = viewer.getCell(new Point(event.x, event.y));
		if (cell != null) {

			if (!cell.equals(focusCell)) {
				this.focusCell = cell;
				viewer.getControl().redraw();
			}
		}
	}

	private void handleKeyDown(Event event) {
		ViewerCell tmp = null;

		if (navigationDelegate.isCollapseEvent(viewer, focusCell, event)) {
			navigationDelegate.collapse(viewer, focusCell, event);
		} else if (navigationDelegate.isExpandEvent(viewer, focusCell, event)) {
			navigationDelegate.expand(viewer, focusCell, event);
		} else if (navigationDelegate.isNavigationEvent(viewer, event)) {
			tmp = navigationDelegate.findSelectedCell(viewer, focusCell, event);

			if (tmp != null) {
				if (!tmp.equals(focusCell)) {
					this.focusCell = tmp;
					viewer.getControl().redraw();
				}
			}
		}

		if (navigationDelegate.cancleEvent(viewer, event)) {
			event.doit = false;
		}
	}

	private void handleSelection(Event event) {
		if (focusCell != null && focusCell.getItem() != event.item
				&& event.item != null) {
			ViewerRow row = viewer.getViewerRowFromItem(event.item);
			Assert
					.isNotNull(row,
							"Internal Structure invalid. Row item has no row ViewerRow assigned"); //$NON-NLS-1$
			ViewerCell tmp = row.getCell(focusCell.getColumnIndex());
			if (!focusCell.equals(tmp)) {
				this.focusCell = tmp;
				viewer.getControl().redraw();
			}
		}
	}

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

	/**
	 * @return the cell with the focus
	 * 
	 */
	public ViewerCell getFocusCell() {
		return focusCell;
	}
}




/*******************************************************************************
 * 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.jface.viewers.CellEditor.LayoutData;
import org.eclipse.swt.custom.TreeEditor;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.TreeItem;

/**
 * @since 3.3
 *
 */
public class TreeViewerEditor extends ColumnViewerEditor {
	/**
	 * This viewer's tree editor.
	 */
	private TreeEditor treeEditor;
	
	private SWTFocusCellManager focusCellManager;
	
	/**
	 * @param viewer
	 * @param focusCellManager 
	 * @param editorActivationStrategy
	 * @param feature
	 */
	public TreeViewerEditor(TreeViewer viewer, SWTFocusCellManager focusCellManager, ColumnViewerEditorActivationStrategy editorActivationStrategy, int feature) {
		super(viewer,editorActivationStrategy,feature);
		treeEditor = new TreeEditor(viewer.getTree());
		this.focusCellManager = focusCellManager; 
	}
	
	protected StructuredSelection createSelection(Object element) {
		if (element instanceof TreePath) {
			return new TreeSelection((TreePath) element, getViewer().getComparer());
		}

		return new StructuredSelection(element);
	}

	protected void setEditor(Control w, Item item, int fColumnNumber) {
		treeEditor.setEditor(w, (TreeItem) item, fColumnNumber);
	}

	protected void setLayoutData(LayoutData layoutData) {
		treeEditor.grabHorizontal = layoutData.grabHorizontal;
		treeEditor.horizontalAlignment = layoutData.horizontalAlignment;
		treeEditor.minimumWidth = layoutData.minimumWidth;
	}

	public ViewerCell getFocusCell() {
		if( focusCellManager != null ) {
			return focusCellManager.getFocusCell();
		}
		
		return super.getFocusCell();
	}
}




/*******************************************************************************
 * 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 class TableViewerFocusCellManager extends SWTFocusCellManager {
	private static final CellNavigationStrategy TABLE_NAVIGATE = new CellNavigationStrategy();
	
	/**
	 * @param viewer
	 * @param focusDrawingDelegate
	 */
	public TableViewerFocusCellManager(TableViewer viewer,
			FocusCellHighlighter focusDrawingDelegate) {
		super(viewer, focusDrawingDelegate, TABLE_NAVIGATE);
	}

}




/*******************************************************************************
 * 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 FocusCellHighlighter {
	private ColumnViewer viewer;

	/**
	 * @param viewer
	 */
	public FocusCellHighlighter(ColumnViewer viewer) {
		this.viewer = viewer;
	}

	/**
	 * @return the focus cell
	 */
	public ViewerCell getFocusCell() {
		return viewer.getColumnViewerEditor().getFocusCell();
	}
}




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

		Listener listener = new Listener() {

			public void handleEvent(Event event) {
				if ((event.detail & SWT.SELECTED) > 0) {
					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 || !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;
	}
}




/*******************************************************************************
 * 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 ColumnViewerEditorActivationListener {
	/**
	 * Called before an editor is activated
	 * 
	 * @param event
	 *            the event
	 */
	public abstract void beforeEditorActivated(ColumnViewerEditorActivationEvent event);

	/**
	 * Called after an editor has been activated
	 * 
	 * @param event the event
	 */
	public abstract void afterEditorActivated(ColumnViewerEditorActivationEvent event);

	/**
	 * Called before an editor is deactivated
	 * 
	 * @param event
	 *            the event
	 */
	public abstract void beforeEditorDeactivated(ColumnViewerEditorDeactivationEvent event);

	
	/**
	 * Called after an editor is deactivated
	 * 
	 * @param event the event
	 */
	public abstract void afterEditorDeactivated(ColumnViewerEditorDeactivationEvent event);
}




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

/**
 * @since 3.3
 *
 */
public class TreeViewerFocusCellManager extends SWTFocusCellManager {
	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;
		}
	};
	
	/**
	 * @param viewer
	 * @param focusDrawingDelegate
	 */
	public TreeViewerFocusCellManager(TreeViewer viewer,
			FocusCellHighlighter focusDrawingDelegate) {
		super(viewer, focusDrawingDelegate,TREE_NAVIGATE);
	}

}




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




/*******************************************************************************
 * 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 ColumnViewerEditorActivationStrategy {
	private ColumnViewer viewer;
	
	private KeyListener keyboardActivationListener;
	
	/**
	 * @param viewer the viewer the editor support is attached to
	 */
	public ColumnViewerEditorActivationStrategy(ColumnViewer viewer) {
		this.viewer = viewer;
	}
	
	/**
	 * @param event
	 * @return bla bl
	 */
	protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
		return event.eventType == ColumnViewerEditorActivationEvent.MOUSE_CLICK_SELECTION
			|| event.eventType == ColumnViewerEditorActivationEvent.PROGRAMATIC
			|| event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL;
		}

	/**
	 * @return the cell holding the current focus
	 */
	private ViewerCell getFocusCell() {
		return viewer.getColumnViewerEditor().getFocusCell();
	}
	
	/**
	 * @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.triggerEditorActivationEvent(new ColumnViewerEditorActivationEvent(cell,e));
						}
					}

					public void keyReleased(KeyEvent e) {
						
					}
					
				};
				viewer.getControl().addKeyListener(keyboardActivationListener);
			}
		} else {
			if( keyboardActivationListener != null ) {
				viewer.getControl().removeKeyListener(keyboardActivationListener);
				keyboardActivationListener = null;
			}
		}
	}

}

Lines 6-11 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
6	Bundle-Localization: plugin	6	Bundle-Localization: plugin
7	Require-Bundle: org.eclipse.swt,	7	Require-Bundle: org.eclipse.swt,
8	org.eclipse.swt.nebula,	8	org.eclipse.swt.nebula,
9	org.eclipse.nebula.widgets.gallery	9	org.eclipse.nebula.widgets.gallery,
		10	org.eclipse.swt.nebula.nebface
10	Export-Package: org.eclipse.swt.nebula.snippets.ctree,	11	Export-Package: org.eclipse.swt.nebula.snippets.ctree,
11	org.eclipse.swt.nebula.snippets.grid	12	org.eclipse.swt.nebula.snippets.grid




/*******************************************************************************
 * 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.ColumnViewerEditor;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
import org.eclipse.jface.viewers.EditingSupport;
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.TreeViewerEditor;
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.GridViewerEditor;
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"});
		
		ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(v) {
			protected boolean isEditorActivationEvent(
					ColumnViewerEditorActivationEvent event) {
				return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL
						|| event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION
						|| (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR)
						|| event.eventType == ColumnViewerEditorActivationEvent.PROGRAMATIC;
			}
		};
		
		GridViewerEditor gridViewerEditor = new GridViewerEditor(v, actSupport, ColumnViewerEditor.TABBING_HORIZONTAL
				| ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
				| ColumnViewerEditor.TABBING_VERTICAL | ColumnViewerEditor.KEYBOARD_ACTIVATION);
		
		v.setColumnViewerEditor(gridViewerEditor);
		
		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();

	}

}

Lines 4-10 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
4	Bundle-SymbolicName: org.eclipse.swt.nebula.nebface	4	Bundle-SymbolicName: org.eclipse.swt.nebula.nebface
5	Bundle-Version: 1.0.0	5	Bundle-Version: 1.0.0
6	Bundle-Localization: plugin	6	Bundle-Localization: plugin
7	Require-Bundle: org.eclipse.jface,	7	Require-Bundle: org.eclipse.jface;visibility:=reexport,
8	org.eclipse.swt.nebula;visibility:=reexport,	8	org.eclipse.swt.nebula;visibility:=reexport,
9	org.eclipse.equinox.common;visibility:=reexport	9	org.eclipse.equinox.common;visibility:=reexport
10	Bundle-RequiredExecutionEnvironment: J2SE-1.4	10	Bundle-RequiredExecutionEnvironment: J2SE-1.4

Lines 1-29 Link Here

(-)src/org/eclipse/swt/nebula/nebface/viewers/CheckEditingSupport.java (-5 / +32 lines)
		1	/*******************************************************************************
		2	* Copyright (c) 2007 IBM Corporation and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* chris.gross@us.ibm.com - initial API and implementation
		10	*******************************************************************************/
		11
1	package org.eclipse.swt.nebula.nebface.viewers;	12	package org.eclipse.swt.nebula.nebface.viewers;
2		13
3	import org.eclipse.jface.viewers.CellEditor;	14	import org.eclipse.jface.viewers.CellEditor;
		15	import org.eclipse.jface.viewers.ColumnViewer;
4	import org.eclipse.jface.viewers.EditingSupport;	16	import org.eclipse.jface.viewers.EditingSupport;
5		17
		18	/**
		19	* .
		20	*
		21	* @author chris.gross@us.ibm.com
		22	* @since 3.3
		23	*/
6	public abstract class CheckEditingSupport extends EditingSupport	24	public abstract class CheckEditingSupport extends EditingSupport
7	{	25	{
		26	/**
		27	* Checkbox editing support.
		28	*
		29	* @param viewer column to add check box support for.
		30	*/
		31	public CheckEditingSupport(ColumnViewer viewer)
		32	{
		33	super(viewer);
		34	}
8		35
		36	/** {@inheritDoc} */
9	protected boolean canEdit(Object element)	37	protected boolean canEdit(Object element)
10	{	38	{
11	// TODO Auto-generated method stub
12	return false;	39	return false;
13	}	40	}
14		41
		42	/** {@inheritDoc} */
15	protected CellEditor getCellEditor(Object element)	43	protected CellEditor getCellEditor(Object element)
16	{	44	{
17	// TODO Auto-generated method stub
18	return null;	45	return null;
19	}	46	}
20		47
		48	/** {@inheritDoc} */
21	protected Object getValue(Object element)	49	protected Object getValue(Object element)
22	{	50	{
23	// TODO Auto-generated method stub
24	return null;	51	return null;
25	}	52	}
26		53
27	protected abstract void setValue(Object element, Object value);	54	/** {@inheritDoc} */
28		55	public abstract void setValue(Object element, Object value);
29	}	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:
 *    rmcamara@us.ibm.com - initial API and implementation
 *******************************************************************************/ 

package org.eclipse.swt.nebula.nebface.viewers;

import org.eclipse.jface.viewers.AbstractTableViewer;
import org.eclipse.jface.viewers.ColumnViewerEditor;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
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;

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;

/**
 * A concrete viewer based on an Grid control.
 * <p>
 * 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).
 * <p>
 * Content providers for grid viewers must not implement the
 * {@code ITreeContentProvider} interface.
 * <p>
 * 
 * @author rmcamara@us.ibm.com
 * @since
 * @3.3
 */
public class GridViewer extends AbstractTableViewer
{
    /** This viewer's grid control. */
    private Grid grid;

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

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

    /**
     * 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;
        hookControl(grid);
    }
    
    /**
     * Returns the underlying Grid Control. 
     * 
     * @return grid control.
     */
    public Grid getGrid()
    {
        return grid;
    }
		} else {
			item = new GridItem(grid, style);
		}

		return getViewerRowFromItem(item);
	}

    /** {@inheritDoc} */
    protected ViewerRow internalCreateNewRowPart(int style, int rowIndex)
    {
        GridItem item;

        if (rowIndex >= 0) 
        {
            item = new GridItem(grid, style, rowIndex);
        } 
        else 
        {
            item = new GridItem(grid, style);
        }

        return getViewerRowFromItem(item);
    }

    /** {@inheritDoc} */
    protected ColumnViewerEditor createViewerEditor() 
    {
        return new GridViewerEditor(this,new ColumnViewerEditorActivationStrategy(this),ColumnViewerEditor.DEFAULT);
    }
            }

            protected Item[] getSelection() {
                return getGrid().getSelection();
            }

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

            protected void showSelection() {
                getGrid().showSelection();
            }

        };
	}

	protected void internalClear(int index) {
		// TODO NEEDS IMP
	}

	protected void internalClearAll() {
		// TODO NEEDS IMP
	}

	protected void internalDeselectAll() {
		grid.deselectAll();
	}

	protected Widget internalGetColumn(int index) {
		return grid.getColumn(index);
	}

	protected int internalGetColumnCount() {
		return grid.getColumnCount();
	}

	protected Widget[] internalGetColumns() {
		return grid.getColumns();
	}

    /** {@inheritDoc} */
    protected void doClear(int index)
    {
        // TODO Fix when grid supports virtual
    }

    /** {@inheritDoc} */
    protected void doClearAll()
    {
        //TODO Fix when grid supports virtual
    }
    
    /** {@inheritDoc} */
    protected void doSetItemCount(int count)
    {
        //TODO Once grid supports virtual
    }

    /** {@inheritDoc} */
    protected void doDeselectAll()
    {
        grid.deselectAll();
    }

    /** {@inheritDoc} */
    protected Widget doGetColumn(int index)
    {
        return grid.getColumn(index);
    }

    /** {@inheritDoc} */
    protected int doGetColumnCount()
    {
        return grid.getColumnCount();
    }

    /** {@inheritDoc} */
    protected Item doGetItem(int index)
    {
        return grid.getItem(index);
    }

    /** {@inheritDoc} */
    protected int doGetItemCount()
    {
        return grid.getItemCount();
    }

    /** {@inheritDoc} */
    protected Item[] doGetItems()
    {
        return grid.getItems();
    }

    /** {@inheritDoc} */
    protected Item[] doGetSelection()
    {
        return grid.getSelection();
    }

    /** {@inheritDoc} */
    protected int[] doGetSelectionIndices()
    {
        return grid.getSelectionIndices();
    }

    /** {@inheritDoc} */
    protected int doIndexOf(Item item)
    {
        return grid.indexOf((GridItem) item);
    }

    /** {@inheritDoc} */
    protected void doRemove(int[] indices)
    {
        grid.remove(indices);
    }
			System.arraycopy(items, 0, tmp, 0, items.length);
			grid.setSelection(tmp);
		}

    /** {@inheritDoc} */
    protected void doRemove(int start, int end)
    {
        grid.remove(start, end);
    }

    /** {@inheritDoc} */
    protected void doRemoveAll()
    {
        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);
    }

    /** {@inheritDoc} */
    protected void doSetSelection(int[] indices)
    {
        grid.setSelection(indices);
    }

    /** {@inheritDoc} */
    protected void doShowItem(Item item)
    {
        grid.showItem((GridItem)item);
    }

    /** {@inheritDoc} */
    protected void doShowSelection()
    {
        grid.showSelection();
    }

    /** {@inheritDoc} */
    protected Item getItemAt(Point point)
    {
        return grid.getItem(point);
    }

    /** {@inheritDoc} */
    public Control getControl()
    {
        return grid;
    }
    
    /** {@inheritDoc} */
    protected ViewerRow getViewerRowFromItem(Widget item) 
    {
        ViewerRow part = (ViewerRow) item.getData(ViewerRow.ROWPART_KEY);

        if (part == null) 
        {
            part = new GridViewerRow(((GridItem) item));
        }

        return part;
    }

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




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

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

/**
 * 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 {
			throw new IllegalArgumentException("Illegal value of direction argument."); //$NON-NLS-1$
				item.setImage(i, null);
			}
		}
	}

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




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

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;

/**
 * The concrete implementation of the ColumnViewer for the grid.
 *
 * @author rmcamara@us.ibm.com
 * @since 3.3
 */
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 GridViewer}
     * 
     * @param viewer
     *            the viewer the column belongs to
     * @param style
     *            the style used to create the column for style bits see
     *            {@link GridColumn}
     * @see GridColumn#GridColumn(Grid, int)
     */
    public GridViewerColumn(GridViewer viewer, int style) 
    {
        this(viewer, style, -1);
        this.viewer = viewer;
    }

    /**
     * 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 GridColumn}
     * @param index
     *            the index of the newly created column
     * @see GridColumn#GridColumn(Grid, int, int)
     */
    public GridViewerColumn(GridViewer viewer, int style, int index) 
    {
        this(viewer, createColumn((Grid) viewer.getControl(), style, index));
        this.viewer = viewer;
    }

     * @param column
     *            the column the viewer is attached to
     */
    public GridViewerColumn(GridViewer viewer, GridColumn column) 
    {
        super(viewer, column);
        this.column = column;
        this.viewer = viewer;
    }
    
    private static GridColumn createColumn(Grid table, int style, int index) 
    {
        if (index >= 0) 
        {
            return new GridColumn(table, style, index);
        }

        return new GridColumn(table, style);
    }

    /**
     * Returns the underlying column.
     * 
     * @return the underlying Nebula column
     */
    public GridColumn getColumn() 
    {
        return column;
    }
    
    /** {@inheritDoc} */
    public void setEditingSupport(EditingSupport editingSupport)
    {
        if (editingSupport instanceof CheckEditingSupport)

            super.setEditingSupport(editingSupport);
        }        
    }
}




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




package org.eclipse.swt.nebula.nebface.viewers;

import org.eclipse.jface.viewers.ColumnViewerEditor;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
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.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.Control;
import org.eclipse.swt.widgets.Item;

public class GridViewerEditor extends ColumnViewerEditor {
	/** Editor support for tables. */
    private GridEditor gridEditor;
    
	public GridViewerEditor(GridViewer viewer,
			ColumnViewerEditorActivationStrategy editorActivationStrategy,
			int feature) {
		super(viewer, editorActivationStrategy, feature);
		this.gridEditor = new GridEditor(viewer.getGrid());
	}

	protected StructuredSelection createSelection(Object element) 
    {
        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;
    }

	public ViewerCell getFocusCell() {
		Grid grid = ((GridViewer)getViewer()).getGrid();
		
		if( grid.getCellSelectionEnabled() ) {
			Point p = grid.getFocusCell();
			
			if( p.x >= 0 && p.y >= 0 ) {
				GridItem item = grid.getItem(p.y);
				if( item != null ) {
					ViewerRow row = (ViewerRow) item.getData(ViewerRow.ROWPART_KEY);
					return row.getCell(p.x);
				}
			}
		}
		
		return null;
	}
}

Return to bug 172646

Lines 12-21 Link Here

(-)Eclipse JFace Snippets/org/eclipse/jface/snippets/viewers/Snippet025TabEditing.java (-1 / +4 lines)
12	package org.eclipse.jface.snippets.viewers;	12	package org.eclipse.jface.snippets.viewers;
13		13
14	import org.eclipse.jface.viewers.CellEditor;	14	import org.eclipse.jface.viewers.CellEditor;
		15	import org.eclipse.jface.viewers.ColumnViewerEditor;
		16	import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
15	import org.eclipse.jface.viewers.EditingSupport;	17	import org.eclipse.jface.viewers.EditingSupport;
16	import org.eclipse.jface.viewers.ICellModifier;	18	import org.eclipse.jface.viewers.ICellModifier;
17	import org.eclipse.jface.viewers.IStructuredContentProvider;	19	import org.eclipse.jface.viewers.IStructuredContentProvider;
18	import org.eclipse.jface.viewers.LabelProvider;	20	import org.eclipse.jface.viewers.LabelProvider;
		21	import org.eclipse.jface.viewers.TableViewerEditor;
19	import org.eclipse.jface.viewers.TableViewer;	22	import org.eclipse.jface.viewers.TableViewer;
20	import org.eclipse.jface.viewers.TextCellEditor;	23	import org.eclipse.jface.viewers.TextCellEditor;
21	import org.eclipse.jface.viewers.Viewer;	24	import org.eclipse.jface.viewers.Viewer;
Lines 111-117 Link Here
111		114
112	v.setColumnProperties(new String[] { "column1", "column2" });	115	v.setColumnProperties(new String[] { "column1", "column2" });
113	v.setCellEditors(new CellEditor[] { new TextCellEditor(v.getTable()), new TextCellEditor(v.getTable()) });	116	v.setCellEditors(new CellEditor[] { new TextCellEditor(v.getTable()), new TextCellEditor(v.getTable()) });
114	v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL\|EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR\|EditingSupport.TABBING_VERTICAL);	117	v.setColumnViewerEditor(new TableViewerEditor(v,new ColumnViewerEditorActivationStrategy(v),ColumnViewerEditor.TABBING_HORIZONTAL\|ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR\|ColumnViewerEditor.TABBING_VERTICAL));
115		118
116		119
117	MyModel[] model = createModel();	120	MyModel[] model = createModel();

Added Link Here

(-)Eclipse (+202 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 Tom Schindl and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Tom Schindl - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.jface.snippets.viewers;
13
14	import java.util.ArrayList;
15
16	import org.eclipse.jface.viewers.CellEditor;
17	import org.eclipse.jface.viewers.CellNavigationStrategy;
18	import org.eclipse.jface.viewers.ColumnLabelProvider;
19	import org.eclipse.jface.viewers.ColumnViewerEditor;
20	import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
21	import org.eclipse.jface.viewers.EditingSupport;
22	import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
23	import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;
24	import org.eclipse.jface.viewers.ITreeContentProvider;
25	import org.eclipse.jface.viewers.TextCellEditor;
26	import org.eclipse.jface.viewers.TreeViewerFocusCellManager;
27	import org.eclipse.jface.viewers.TreeViewerEditor;
28	import org.eclipse.jface.viewers.TreeViewer;
29	import org.eclipse.jface.viewers.TreeViewerColumn;
30	import org.eclipse.jface.viewers.Viewer;
31	import org.eclipse.swt.SWT;
32	import org.eclipse.swt.layout.FillLayout;
33	import org.eclipse.swt.widgets.Display;
34	import org.eclipse.swt.widgets.Shell;
35
36	/**
37	* A simple TreeViewer to demonstrate usage
38	*
39	* @author Tom Schindl <tom.schindl@bestsolution.at>
40	*
41	*/
42	public class Snippet026TreeViewerTabEditing {
43	public Snippet026TreeViewerTabEditing(final Shell shell) {
44	final TreeViewer v = new TreeViewer(shell, SWT.BORDER
45	\| SWT.FULL_SELECTION);
46	v.getTree().setLinesVisible(true);
47	v.getTree().setHeaderVisible(true);
48
49
50	TreeViewerFocusCellManager focusCellManager = new TreeViewerFocusCellManager(v,new FocusCellOwnerDrawHighlighter(v));
51	ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(v) {
52	protected boolean isEditorActivationEvent(
53	ColumnViewerEditorActivationEvent event) {
54	return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL
55	\|\| event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION
56	\|\| (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR)
57	\|\| event.eventType == ColumnViewerEditorActivationEvent.PROGRAMATIC;
58	}
59	};
60
61	TreeViewerEditor treeViewerEditor = new TreeViewerEditor (v, focusCellManager, actSupport, ColumnViewerEditor.TABBING_HORIZONTAL
62	\| ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
63	\| ColumnViewerEditor.TABBING_VERTICAL \| ColumnViewerEditor.KEYBOARD_ACTIVATION);
64	v.setColumnViewerEditor(treeViewerEditor);
65
66	final TextCellEditor textCellEditor = new TextCellEditor(v.getTree());
67
68	TreeViewerColumn column = new TreeViewerColumn(v, SWT.NONE);
69	column.getColumn().setWidth(200);
70	column.getColumn().setText("Column 1");
71	column.setLabelProvider(new ColumnLabelProvider() {
72
73	public String getText(Object element) {
74	return "Column 1 => " + element.toString();
75	}
76
77	});
78	column.setEditingSupport(new EditingSupport(v) {
79	protected boolean canEdit(Object element) {
80	return true;
81	}
82
83	protected CellEditor getCellEditor(Object element) {
84	return textCellEditor;
85	}
86
87	protected Object getValue(Object element) {
88	return ((MyModel) element).counter + "";
89	}
90
91	protected void setValue(Object element, Object value) {
92	((MyModel) element).counter = Integer
93	.parseInt(value.toString());
94	v.update(element, null);
95	}
96	});
97
98	column = new TreeViewerColumn(v, SWT.NONE);
99	column.getColumn().setWidth(200);
100	column.getColumn().setText("Column 2");
101	column.setLabelProvider(new ColumnLabelProvider() {
102
103	public String getText(Object element) {
104	return "Column 2 => " + element.toString();
105	}
106
107	});
108
109	v.setContentProvider(new MyContentProvider());
110
111	v.setInput(createModel());
112	}
113
114	private MyModel createModel() {
115
116	MyModel root = new MyModel(0, null);
117	root.counter = 0;
118
119	MyModel tmp;
120	MyModel subItem;
121	for (int i = 1; i < 10; i++) {
122	tmp = new MyModel(i, root);
123	root.child.add(tmp);
124	for (int j = 1; j < i; j++) {
125	subItem = new MyModel(j, tmp);
126	subItem.child.add(new MyModel(j * 100, subItem));
127	tmp.child.add(subItem);
128	}
129	}
130
131	return root;
132	}
133
134	public static void main(String[] args) {
135	Display display = new Display();
136	Shell shell = new Shell(display);
137	shell.setLayout(new FillLayout());
138	new Snippet026TreeViewerTabEditing(shell);
139	shell.open();
140
141	while (!shell.isDisposed()) {
142	if (!display.readAndDispatch())
143	display.sleep();
144	}
145
146	display.dispose();
147	}
148
149	private class MyContentProvider implements ITreeContentProvider {
150
151	public Object[] getElements(Object inputElement) {
152	return ((MyModel) inputElement).child.toArray();
153	}
154
155	public void dispose() {
156	}
157
158	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
159	}
160
161	public Object[] getChildren(Object parentElement) {
162	return getElements(parentElement);
163	}
164
165	public Object getParent(Object element) {
166	if (element == null) {
167	return null;
168	}
169	return ((MyModel) element).parent;
170	}
171
172	public boolean hasChildren(Object element) {
173	return ((MyModel) element).child.size() > 0;
174	}
175
176	}
177
178	public class MyModel {
179	public MyModel parent;
180
181	public ArrayList child = new ArrayList();
182
183	public int counter;
184
185	public MyModel(int counter, MyModel parent) {
186	this.parent = parent;
187	this.counter = counter;
188	}
189
190	public String toString() {
191	String rv = "Item ";
192	if (parent != null) {
193	rv = parent.toString() + ".";
194	}
195
196	rv += counter;
197
198	return rv;
199	}
200	}
201
202	}

Lines 16-24 Link Here

(-)src/org/eclipse/jface/viewers/TableViewer.java (-33 / +1 lines)
16		16
17		17
18	import org.eclipse.core.runtime.Assert;	18	import org.eclipse.core.runtime.Assert;
19	import org.eclipse.jface.viewers.CellEditor.LayoutData;
20	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
21	import org.eclipse.swt.custom.TableEditor;
22	import org.eclipse.swt.graphics.Image;	20	import org.eclipse.swt.graphics.Image;
23	import org.eclipse.swt.graphics.Point;	21	import org.eclipse.swt.graphics.Point;
24	import org.eclipse.swt.widgets.Composite;	22	import org.eclipse.swt.widgets.Composite;
Lines 67-77 Link Here
67	private Table table;	65	private Table table;
68		66
69	/**	67	/**
70	* This viewer's table editor.
71	*/
72	private TableEditor tableEditor;
73
74	/**
75	* Creates a table viewer on a newly-created table control under the given	68	* Creates a table viewer on a newly-created table control under the given
76	* parent. The table control is created using the SWT style bits	69	* parent. The table control is created using the SWT style bits
77	* <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>BORDER</code>. The	70	* <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>BORDER</code>. The
Lines 110-116 Link Here
110	*/	103	*/
111	public TableViewer(Table table) {	104	public TableViewer(Table table) {
112	this.table = table;	105	this.table = table;
113	tableEditor = new TableEditor(table);
114	hookControl(table);	106	hookControl(table);
115	}	107	}
116		108
Lines 128-158 Link Here
128	}	120	}
129		121
130	protected ColumnViewerEditor createViewerEditor() {	122	protected ColumnViewerEditor createViewerEditor() {
131	return new ColumnViewerEditor(this) {	123	return new TableViewerEditor(this,new ColumnViewerEditorActivationStrategy(this),ColumnViewerEditor.DEFAULT);
132
133	protected StructuredSelection createSelection(Object element) {
134	return new StructuredSelection(element);
135	}
136
137	protected Item[] getSelection() {
138	return table.getSelection();
139	}
140
141	protected void setEditor(Control w, Item item, int fColumnNumber) {
142	tableEditor.setEditor(w, (TableItem) item, fColumnNumber);
143	}
144
145	protected void setLayoutData(LayoutData layoutData) {
146	tableEditor.grabHorizontal = layoutData.grabHorizontal;
147	tableEditor.horizontalAlignment = layoutData.horizontalAlignment;
148	tableEditor.minimumWidth = layoutData.minimumWidth;
149	}
150
151	protected void showSelection() {
152	table.showSelection();
153	}
154
155	};
156	}	124	}
157		125
158	/**	126	/**

Lines 16-24 Link Here

(-)src/org/eclipse/jface/viewers/TreeViewer.java (-37 / +1 lines)
16	import java.util.List;	16	import java.util.List;
17		17
18	import org.eclipse.jface.util.Policy;	18	import org.eclipse.jface.util.Policy;
19	import org.eclipse.jface.viewers.CellEditor.LayoutData;
20	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
21	import org.eclipse.swt.custom.TreeEditor;
22	import org.eclipse.swt.events.DisposeEvent;	20	import org.eclipse.swt.events.DisposeEvent;
23	import org.eclipse.swt.events.DisposeListener;	21	import org.eclipse.swt.events.DisposeListener;
24	import org.eclipse.swt.events.TreeEvent;	22	import org.eclipse.swt.events.TreeEvent;
Lines 63-73 Link Here
63	private Tree tree;	61	private Tree tree;
64		62
65	/**	63	/**
66	* This viewer's tree editor.
67	*/
68	private TreeEditor treeEditor;
69
70	/**
71	* Flag for whether the tree has been disposed of.	64	* Flag for whether the tree has been disposed of.
72	*/	65	*/
73	private boolean treeIsDisposed = false;	66	private boolean treeIsDisposed = false;
Lines 116-122 Link Here
116	super();	109	super();
117	this.tree = tree;	110	this.tree = tree;
118	hookControl(tree);	111	hookControl(tree);
119	treeEditor = new TreeEditor(tree);
120	}	112	}
121		113
122	/*	114	/*
Lines 274-308 Link Here
274	}	266	}
275		267
276	protected ColumnViewerEditor createViewerEditor() {	268	protected ColumnViewerEditor createViewerEditor() {
277	return new ColumnViewerEditor(this) {	269	return new TreeViewerEditor(this,null,new ColumnViewerEditorActivationStrategy(this),ColumnViewerEditor.DEFAULT);
278
279	protected StructuredSelection createSelection(Object element) {
280	if (element instanceof TreePath) {
281	return new TreeSelection((TreePath) element, getComparer());
282	}
283
284	return new StructuredSelection(element);
285	}
286
287	protected Item[] getSelection() {
288	return tree.getSelection();
289	}
290
291	protected void setEditor(Control w, Item item, int fColumnNumber) {
292	treeEditor.setEditor(w, (TreeItem) item, fColumnNumber);
293	}
294
295	protected void setLayoutData(LayoutData layoutData) {
296	treeEditor.grabHorizontal = layoutData.grabHorizontal;
297	treeEditor.horizontalAlignment = layoutData.horizontalAlignment;
298	treeEditor.minimumWidth = layoutData.minimumWidth;
299	}
300
301	protected void showSelection() {
302	getTree().showSelection();
303	}
304
305	};
306	}	270	}
307		271
308	/*	272	/*

Lines 14-21 Link Here

(-)src/org/eclipse/jface/viewers/EditingSupport.java (-190 / +18 lines)
14	package org.eclipse.jface.viewers;	14	package org.eclipse.jface.viewers;
15		15
16	import org.eclipse.core.runtime.Assert;	16	import org.eclipse.core.runtime.Assert;
17	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.events.TraverseEvent;
19		17
20	/**	18	/**
21	* EditingSupport is the abstract superclass of the support for cell editing.	19	* EditingSupport is the abstract superclass of the support for cell editing.
Lines 27-58 Link Here
27	*	25	*
28	*/	26	*/
29	public abstract class EditingSupport {	27	public abstract class EditingSupport {
30	/**
31	* Tabing from cell to cell is turned off
32	*/
33	public static final int TABBING_NONE = 1;
34
35	/**
36	* Should if the end of the row is reach started from the start/end of the
37	* row below/above
38	*/
39	public static final int TABBING_MOVE_TO_ROW_NEIGHBOR = 1 << 1;
40
41	/**
42	* Should if the end of the row is reach started from the beginning in the
43	* same row
44	*/
45	public static final int TABBING_CYCLE_IN_ROW = 1 << 2;
46
47	/**
48	* Support tabing to Cell above/below the current cell
49	*/
50	public static final int TABBING_VERTICAL = 1 << 3;
51
52	/**
53	* Should tabing from column to column with in one row be supported
54	*/
55	public static final int TABBING_HORIZONTAL = 1 << 4;
56		28
57	private ColumnViewer viewer;	29	private ColumnViewer viewer;
58		30
Lines 61-67 Link Here
61	* a new viewer	33	* a new viewer
62	*/	34	*/
63	public EditingSupport(ColumnViewer viewer) {	35	public EditingSupport(ColumnViewer viewer) {
64	Assert.isNotNull(viewer,"Viewer is not allowed to be null"); //$NON-NLS-1$	36	Assert.isNotNull(viewer, "Viewer is not allowed to be null"); //$NON-NLS-1$
65	this.viewer = viewer;	37	this.viewer = viewer;
66	}	38	}
67		39
Lines 95-101 Link Here
95	/**	67	/**
96	* Restore the value from the CellEditor	68	* Restore the value from the CellEditor
97	*	69	*
98	* <p><b>Subclasses should overwrite!</b></p>	70	* <p>
		71	* <b>Subclasses should overwrite!</b>
		72	* </p>
99	*	73	*
100	* @param element	74	* @param element
101	* the model element	75	* the model element
Lines 105-278 Link Here
105	protected abstract void setValue(Object element, Object value);	79	protected abstract void setValue(Object element, Object value);
106		80
107	/**	81	/**
108	* @return <code>true</code> if tabing supported	82	* @return the viewer this editing support works for
109	*/
110	protected boolean isTabingSupported() {
111	return (TABBING_NONE & getTabingStyle()) != TABBING_NONE;
112	}
113
114	/**
115	* @return the bit mask representing the tabing style
116	*/	83	*/
117	int getTabingStyle() {	84	public ColumnViewer getViewer() {
118	return viewer.getTabEditingStyle();	85	return viewer;
119	}	86	}
120		87
121	/**	88	/**
122	* Process the travers event and opens the next available editor depending	89	* @param cellEditor
123	* of the implemented strategy. The default implementation uses the style	90	* the cell editor
124	* constants	91	* @param value
125	* <ul>	92	* the value to set the editor to
126	* <li>{@link #TABBING_MOVE_TO_ROW_NEIGHBOR}</li>
127	* <li>{@link #TABBING_CYCLE_IN_ROW}</li>
128	* <li>{@link #TABBING_VERTICAL}</li>
129	* <li>{@link #TABBING_HORIZONTAL}</li>
130	* </ul>
131	*
132	* <p>
133	* Subclasses may overwrite to implement their custom logic to edit the next
134	* cell
135	* </p>
136	*
137	* @param columnIndex
138	* the index of the current column
139	* @param row
140	* the current row
141	* @param event
142	* the travers event
143	*/	93	*/
144	protected void processTraversEvent(int columnIndex,	94	protected void setCellEditorValue(CellEditor cellEditor, Object value) {
145	ViewerRow row, TraverseEvent event) {	95	cellEditor.setValue(value);
146
147	ViewerCell cell2edit = null;
148
149	if (event.detail == SWT.TRAVERSE_TAB_PREVIOUS) {
150	event.doit = false;
151
152	if ((event.stateMask & SWT.CTRL) == SWT.CTRL
153	&& (getTabingStyle() & TABBING_VERTICAL) == TABBING_VERTICAL) {
154	cell2edit = searchCellAboveBelow(row, viewer, columnIndex, true);
155	} else if ((getTabingStyle() & TABBING_HORIZONTAL) == TABBING_HORIZONTAL) {
156	cell2edit = searchPreviousCell(row, viewer, columnIndex,
157	columnIndex);
158	}
159	} else if (event.detail == SWT.TRAVERSE_TAB_NEXT) {
160	event.doit = false;
161
162	if ((event.stateMask & SWT.CTRL) == SWT.CTRL
163	&& (getTabingStyle() & TABBING_VERTICAL) == TABBING_VERTICAL) {
164	cell2edit = searchCellAboveBelow(row, viewer, columnIndex,
165	false);
166	} else if ((getTabingStyle() & TABBING_HORIZONTAL) == TABBING_HORIZONTAL) {
167	cell2edit = searchNextCell(row, viewer, columnIndex,
168	columnIndex);
169	}
170	}
171
172	if (cell2edit != null) {
173	viewer.editElement(cell2edit.getElement(), cell2edit
174	.getColumnIndex());
175	}
176	}
177
178	private ViewerCell searchCellAboveBelow(ViewerRow row, ColumnViewer viewer,
179	int columnIndex, boolean above) {
180	ViewerCell rv = null;
181
182	ViewerRow newRow = null;
183
184	if (above) {
185	newRow = row.getNeighbor(ViewerRow.ABOVE, false);
186	} else {
187	newRow = row.getNeighbor(ViewerRow.BELOW,false);
188	}
189
190	if (newRow != null) {
191	ViewerColumn column = viewer.getViewerColumn(columnIndex);
192	if (column != null
193	&& column.getEditingSupport().canEdit(
194	newRow.getItem().getData())) {
195	rv = newRow.getCell(columnIndex);
196	} else {
197	rv = searchCellAboveBelow(newRow, viewer, columnIndex, above);
198	}
199	}
200
201	return rv;
202	}
203
204	private ViewerCell searchPreviousCell(ViewerRow row, ColumnViewer viewer,
205	int columnIndex, int startIndex) {
206	ViewerCell rv = null;
207
208	if (columnIndex - 1 >= 0) {
209	ViewerColumn column = viewer.getViewerColumn(columnIndex - 1);
210	if (column != null
211	&& column.getEditingSupport().canEdit(
212	row.getItem().getData())) {
213	rv = row.getCell(columnIndex - 1);
214	} else {
215	rv = searchPreviousCell(row, viewer, columnIndex - 1,
216	startIndex);
217	}
218	} else {
219	if ((getTabingStyle() & TABBING_CYCLE_IN_ROW) == TABBING_CYCLE_IN_ROW) {
220	// Check that we don't get into endless loop
221	if (columnIndex - 1 != startIndex) {
222	// Don't subtract -1 from getColumnCount() we need to
223	// start in the virtual column
224	// next to it
225	rv = searchPreviousCell(row, viewer, row.getColumnCount(),
226	startIndex);
227	}
228	} else if ((getTabingStyle() & TABBING_MOVE_TO_ROW_NEIGHBOR) == TABBING_MOVE_TO_ROW_NEIGHBOR) {
229	ViewerRow rowAbove = row.getNeighbor(ViewerRow.ABOVE,false);
230	if (rowAbove != null) {
231	rv = searchPreviousCell(rowAbove, viewer, rowAbove
232	.getColumnCount(), startIndex);
233	}
234	}
235	}
236
237	return rv;
238	}	96	}
239		97
240	private ViewerCell searchNextCell(ViewerRow row, ColumnViewer viewer,
241	int columnIndex, int startIndex) {
242	ViewerCell rv = null;
243
244	if (columnIndex + 1 < row.getColumnCount()) {
245	ViewerColumn column = viewer.getViewerColumn(columnIndex + 1);
246	if (column != null
247	&& column.getEditingSupport().canEdit(
248	row.getItem().getData())) {
249	rv = row.getCell(columnIndex + 1);
250	} else {
251	rv = searchNextCell(row, viewer, columnIndex + 1, startIndex);
252	}
253	} else {
254	if ((getTabingStyle() & TABBING_CYCLE_IN_ROW) == TABBING_CYCLE_IN_ROW) {
255	// Check that we don't get into endless loop
256	if (columnIndex + 1 != startIndex) {
257	// Start from -1 from the virtual column before the
258	// first one
259	rv = searchNextCell(row, viewer, -1, startIndex);
260	}
261	} else if ((getTabingStyle() & TABBING_MOVE_TO_ROW_NEIGHBOR) == TABBING_MOVE_TO_ROW_NEIGHBOR) {
262	ViewerRow rowBelow = row.getNeighbor(ViewerRow.BELOW,false);
263	if (rowBelow != null) {
264	rv = searchNextCell(rowBelow, viewer, -1, startIndex);
265	}
266	}
267	}
268
269	return rv;
270	}
271
272	/**	98	/**
273	* @return the viewer this editing support works for	99	* @param cellEditor
		100	* the cell-editor
		101	* @return the value retrieved from cell-editor
274	*/	102	*/
275	public ColumnViewer getViewer() {	103	protected Object getCellEditorValue(CellEditor cellEditor) {
276	return viewer;	104	return cellEditor.getValue();
277	}	105	}
278	}	106	}

Added Link Here

(-)src/org/eclipse/jface/viewers/SWTFocusCellManager.java (+120 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.core.runtime.Assert;
15	import org.eclipse.swt.SWT;
16	import org.eclipse.swt.graphics.Point;
17	import org.eclipse.swt.widgets.Event;
18	import org.eclipse.swt.widgets.Listener;
19
20	/**
21	* @since 3.3
22	*
23	*/
24	class SWTFocusCellManager {
25
26	private CellNavigationStrategy navigationDelegate;
27
28	private ColumnViewer viewer;
29
30	private ViewerCell focusCell;
31
32	/**
33	* @param viewer
34	* @param focusDrawingDelegate
35	* @param navigationDelegate
36	*/
37	public SWTFocusCellManager(ColumnViewer viewer,
38	FocusCellHighlighter focusDrawingDelegate,
39	CellNavigationStrategy navigationDelegate) {
40	this.viewer = viewer;
41	this.navigationDelegate = navigationDelegate;
42	hookListener(viewer);
43	}
44
45	private void handleMouseDown(Event event) {
46	ViewerCell cell = viewer.getCell(new Point(event.x, event.y));
47	if (cell != null) {
48
49	if (!cell.equals(focusCell)) {
50	this.focusCell = cell;
51	viewer.getControl().redraw();
52	}
53	}
54	}
55
56	private void handleKeyDown(Event event) {
57	ViewerCell tmp = null;
58
59	if (navigationDelegate.isCollapseEvent(viewer, focusCell, event)) {
60	navigationDelegate.collapse(viewer, focusCell, event);
61	} else if (navigationDelegate.isExpandEvent(viewer, focusCell, event)) {
62	navigationDelegate.expand(viewer, focusCell, event);
63	} else if (navigationDelegate.isNavigationEvent(viewer, event)) {
64	tmp = navigationDelegate.findSelectedCell(viewer, focusCell, event);
65
66	if (tmp != null) {
67	if (!tmp.equals(focusCell)) {
68	this.focusCell = tmp;
69	viewer.getControl().redraw();
70	}
71	}
72	}
73
74	if (navigationDelegate.cancleEvent(viewer, event)) {
75	event.doit = false;
76	}
77	}
78
79	private void handleSelection(Event event) {
80	if (focusCell != null && focusCell.getItem() != event.item
81	&& event.item != null) {
82	ViewerRow row = viewer.getViewerRowFromItem(event.item);
83	Assert
84	.isNotNull(row,
85	"Internal Structure invalid. Row item has no row ViewerRow assigned"); //$NON-NLS-1$
86	ViewerCell tmp = row.getCell(focusCell.getColumnIndex());
87	if (!focusCell.equals(tmp)) {
88	this.focusCell = tmp;
89	viewer.getControl().redraw();
90	}
91	}
92	}
93
94	private void hookListener(ColumnViewer viewer) {
95	Listener listener = new Listener() {
96
97	public void handleEvent(Event event) {
98	if (event.type == SWT.MouseDown) {
99	handleMouseDown(event);
100	} else if (event.type == SWT.KeyDown) {
101	handleKeyDown(event);
102	} else {
103	handleSelection(event);
104	}
105	}
106	};
107
108	viewer.getControl().addListener(SWT.MouseDown, listener);
109	viewer.getControl().addListener(SWT.KeyDown, listener);
110	viewer.getControl().addListener(SWT.Selection, listener);
111	}
112
113	/**
114	* @return the cell with the focus
115	*
116	*/
117	public ViewerCell getFocusCell() {
118	return focusCell;
119	}
120	}

Added Link Here

(-)src/org/eclipse/jface/viewers/FocusCellHighlighter.java (+34 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	/**
15	* @since 3.3
16	*
17	*/
18	public abstract class FocusCellHighlighter {
19	private ColumnViewer viewer;
20
21	/**
22	* @param viewer
23	*/
24	public FocusCellHighlighter(ColumnViewer viewer) {
25	this.viewer = viewer;
26	}
27
28	/**
29	* @return the focus cell
30	*/
31	public ViewerCell getFocusCell() {
32	return viewer.getColumnViewerEditor().getFocusCell();
33	}
34	}

Added Link Here

(-)src/org/eclipse/jface/viewers/CellNavigationStrategy.java (+151 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.swt.SWT;
15	import org.eclipse.swt.widgets.Event;
16
17	/**
18	* @since 3.3
19	*
20	*/
21	public class CellNavigationStrategy {
22	/**
23	* is the given event an event which moves the selection to another cell
24	*
25	* @param viewer
26	* the viewer we are working for
27	*
28	* @param event
29	* the key event
30	* @return <code>true</code> if a new cell is searched
31	*/
32	public boolean isNavigationEvent(ColumnViewer viewer, Event event) {
33	switch (event.keyCode) {
34	case SWT.ARROW_UP:
35	case SWT.ARROW_DOWN:
36	case SWT.ARROW_LEFT:
37	case SWT.ARROW_RIGHT:
38	case SWT.HOME:
39	case SWT.PAGE_DOWN:
40	case SWT.PAGE_UP:
41	case SWT.END:
42	return true;
43	default:
44	return false;
45	}
46	}
47
48	/**
49	* @param viewer
50	* the viewer we are working for
51	* @param cellToCollapse the cell to collapse
52	* @param event
53	* the key event
54	* @return <code>true</code> if this event triggers collapsing of a node
55	*/
56	public boolean isCollapseEvent(ColumnViewer viewer, ViewerCell cellToCollapse, Event event) {
57	return false;
58	}
59
60	/**
61	* @param viewer
62	* the viewer we are working for
63	* @param cellToExpand the cell to expand
64	* @param event
65	* the key event
66	* @return <code>true</code> if this event triggers expanding of a node
67	*/
68	public boolean isExpandEvent(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {
69	return false;
70	}
71
72	/**
73	* @param viewer
74	* the viewer working for
75	* @param cellToExpand
76	* the cell the user wants to expand
77	* @param event
78	* the event triggering the exansion
79	*/
80	public void expand(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {
81
82	}
83
84	/**
85	* @param viewer
86	* the viewer working for
87	* @param cellToCollapse
88	* the cell the user wants to collapse
89	* @param event
90	* the event triggering the exansion
91	*/
92	public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,
93	Event event) {
94
95	}
96
97	/**
98	* @param viewer
99	* the viewer we are working for
100	* @param currentSelectedCell
101	* the cell currently selected
102	* @param event
103	* the key event
104	* @return the cell which is highlighted next or <code>null</code> if the
105	* default implementation is taken. E.g. it's fairly impossible to
106	* react on PAGE_DOWN requests
107	*/
108	public ViewerCell findSelectedCell(ColumnViewer viewer,
109	ViewerCell currentSelectedCell, Event event) {
110
111	switch (event.keyCode) {
112	case SWT.ARROW_UP:
113	if (currentSelectedCell != null) {
114	return currentSelectedCell.getNeighbor(ViewerCell.ABOVE, false);
115	}
116	break;
117	case SWT.ARROW_DOWN:
118	if (currentSelectedCell != null) {
119	return currentSelectedCell.getNeighbor(ViewerCell.BELOW, false);
120	}
121	break;
122	case SWT.ARROW_LEFT:
123	if (currentSelectedCell != null) {
124	return currentSelectedCell.getNeighbor(ViewerCell.LEFT, true);
125	}
126	break;
127	case SWT.ARROW_RIGHT:
128	if (currentSelectedCell != null) {
129	return currentSelectedCell.getNeighbor(ViewerCell.RIGHT, true);
130	}
131	break;
132	}
133
134	return null;
135	}
136
137	/**
138	* This method is consulted to decide whether an event has to be cancled or
139	* not. By default events who collapse/expand tree-nodes are cancled
140	*
141	* @param viewer
142	* the viewer working for
143	* @param event
144	* the event
145	* @return <code>true</code> if the event has to be cancled
146	*/
147	public boolean cancleEvent(ColumnViewer viewer, Event event) {
148	return event.keyCode == SWT.ARROW_LEFT
149	\|\| event.keyCode == SWT.ARROW_RIGHT;
150	}
151	}

Added Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerEditorActivationStrategy.java (+91 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.swt.events.KeyEvent;
15	import org.eclipse.swt.events.KeyListener;
16
17	/**
18	* This class is responsible to determin if a cell selection event is triggers
19	* an editor activation
20	*
21	* @since 3.3
22	*/
23	public class ColumnViewerEditorActivationStrategy {
24	private ColumnViewer viewer;
25
26	private KeyListener keyboardActivationListener;
27
28	/**
29	* @param viewer the viewer the editor support is attached to
30	*/
31	public ColumnViewerEditorActivationStrategy(ColumnViewer viewer) {
32	this.viewer = viewer;
33	}
34
35	/**
36	* @param event
37	* @return bla bl
38	*/
39	protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
40	return event.eventType == ColumnViewerEditorActivationEvent.MOUSE_CLICK_SELECTION
41	\|\| event.eventType == ColumnViewerEditorActivationEvent.PROGRAMATIC
42	\|\| event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL;
43	}
44
45	/**
46	* @return the cell holding the current focus
47	*/
48	private ViewerCell getFocusCell() {
49	return viewer.getColumnViewerEditor().getFocusCell();
50	}
51
52	/**
53	* @return the viewer
54	*/
55	public ColumnViewer getViewer() {
56	return viewer;
57	}
58
59	/**
60	* Enable activation of cell editors by keyboard
61	* @param enable <code>true</code> to enable
62	*/
63	public void setEnableEditorActivationWithKeyboard(boolean enable) {
64	if( enable ) {
65	if( keyboardActivationListener == null ) {
66	keyboardActivationListener = new KeyListener() {
67
68	public void keyPressed(KeyEvent e) {
69	ViewerCell cell = getFocusCell();
70
71	if( cell != null ) {
72	viewer.triggerEditorActivationEvent(new ColumnViewerEditorActivationEvent(cell,e));
73	}
74	}
75
76	public void keyReleased(KeyEvent e) {
77
78	}
79
80	};
81	viewer.getControl().addKeyListener(keyboardActivationListener);
82	}
83	} else {
84	if( keyboardActivationListener != null ) {
85	viewer.getControl().removeKeyListener(keyboardActivationListener);
86	keyboardActivationListener = null;
87	}
88	}
89	}
90
91	}

Added Link Here

(-)src/org/eclipse/swt/nebface/snippets/viewers/GridViewerSnippet1.java (+216 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 Tom Schindl and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Tom Schindl - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.swt.nebface.snippets.viewers;
13
14	import org.eclipse.jface.resource.FontRegistry;
15	import org.eclipse.jface.viewers.CellEditor;
16	import org.eclipse.jface.viewers.ColumnViewerEditor;
17	import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
18	import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
19	import org.eclipse.jface.viewers.EditingSupport;
20	import org.eclipse.jface.viewers.ICellModifier;
21	import org.eclipse.jface.viewers.IStructuredContentProvider;
22	import org.eclipse.jface.viewers.ITableColorProvider;
23	import org.eclipse.jface.viewers.ITableFontProvider;
24	import org.eclipse.jface.viewers.ITableLabelProvider;
25	import org.eclipse.jface.viewers.LabelProvider;
26	import org.eclipse.jface.viewers.TextCellEditor;
27	import org.eclipse.jface.viewers.TreeViewerEditor;
28	import org.eclipse.jface.viewers.Viewer;
29	import org.eclipse.swt.SWT;
30	import org.eclipse.swt.graphics.Color;
31	import org.eclipse.swt.graphics.Font;
32	import org.eclipse.swt.graphics.Image;
33	import org.eclipse.swt.layout.FillLayout;
34	import org.eclipse.swt.nebula.nebface.viewers.GridViewerEditor;
35	import org.eclipse.swt.nebula.nebface.viewers.GridViewer;
36	import org.eclipse.swt.nebula.widgets.grid.GridColumn;
37	import org.eclipse.swt.widgets.Display;
38	import org.eclipse.swt.widgets.Shell;
39
40	/**
41	* Example usage of none mandatory interfaces of ITableFontProvider and
42	* ITableColorProvider
43	*
44	* @author Tom Schindl <tom.schindl@bestsolution.at>
45	*
46	*/
47	public class GridViewerSnippet1 {
48
49	private class MyContentProvider implements IStructuredContentProvider {
50
51	/*
52	* (non-Javadoc)
53	*
54	* @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
55	*/
56	public Object[] getElements(Object inputElement) {
57	return (MyModel[]) inputElement;
58	}
59
60	/*
61	* (non-Javadoc)
62	*
63	* @see org.eclipse.jface.viewers.IContentProvider#dispose()
64	*/
65	public void dispose() {
66
67	}
68
69	/*
70	* (non-Javadoc)
71	*
72	* @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
73	* java.lang.Object, java.lang.Object)
74	*/
75	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
76
77	}
78
79	}
80
81	public static boolean flag = true;
82
83	public class MyModel {
84	public int counter;
85
86	public MyModel(int counter) {
87	this.counter = counter;
88	}
89
90	public String toString() {
91	return "Item " + this.counter;
92	}
93	}
94
95	public class MyLabelProvider extends LabelProvider implements
96	ITableLabelProvider, ITableFontProvider, ITableColorProvider {
97	FontRegistry registry = new FontRegistry();
98
99	public Image getColumnImage(Object element, int columnIndex) {
100	return null;
101	}
102
103	public String getColumnText(Object element, int columnIndex) {
104	return "Column " + columnIndex + " => " + element.toString();
105	}
106
107	public Font getFont(Object element, int columnIndex) {
108	if (((MyModel) element).counter % 2 == 0) {
109	return registry.getBold(Display.getCurrent().getSystemFont()
110	.getFontData()[0].getName());
111	}
112	return null;
113	}
114
115	public Color getBackground(Object element, int columnIndex) {
116	if (((MyModel) element).counter % 2 == 0) {
117	return Display.getCurrent().getSystemColor(SWT.COLOR_RED);
118	}
119	return null;
120	}
121
122	public Color getForeground(Object element, int columnIndex) {
123	if (((MyModel) element).counter % 2 == 1) {
124	return Display.getCurrent().getSystemColor(SWT.COLOR_RED);
125	}
126	return null;
127	}
128
129	}
130
131	public GridViewerSnippet1(Shell shell) {
132	final GridViewer v = new GridViewer(shell, SWT.BORDER \| SWT.V_SCROLL \| SWT.H_SCROLL);
133	v.setLabelProvider(new MyLabelProvider());
134	v.setContentProvider(new MyContentProvider());
135	v.getGrid().setCellSelectionEnabled(true);
136
137	v.setCellEditors(new CellEditor[] { new TextCellEditor(v.getGrid()), new TextCellEditor(v.getGrid()) });
138	v.setCellModifier(new ICellModifier() {
139
140	public boolean canModify(Object element, String property) {
141	return true;
142	}
143
144	public Object getValue(Object element, String property) {
145	return "Column " + property + " => " + element.toString();
146	}
147
148	public void modify(Object element, String property, Object value) {
149
150	}
151
152	});
153
154	v.setColumnProperties(new String[] {"1","2"});
155
156	ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(v) {
157	protected boolean isEditorActivationEvent(
158	ColumnViewerEditorActivationEvent event) {
159	return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL
160	\|\| event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION
161	\|\| (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR)
162	\|\| event.eventType == ColumnViewerEditorActivationEvent.PROGRAMATIC;
163	}
164	};
165
166	GridViewerEditor gridViewerEditor = new GridViewerEditor(v, actSupport, ColumnViewerEditor.TABBING_HORIZONTAL
167	\| ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
168	\| ColumnViewerEditor.TABBING_VERTICAL \| ColumnViewerEditor.KEYBOARD_ACTIVATION);
169
170	v.setColumnViewerEditor(gridViewerEditor);
171
172	GridColumn column = new GridColumn(v.getGrid(), SWT.NONE);
173	column.setWidth(200);
174	column.setText("Column 1");
175
176	column = new GridColumn(v.getGrid(), SWT.NONE);
177	column.setWidth(200);
178	column.setText("Column 2");
179
180	MyModel[] model = createModel();
181	v.setInput(model);
182	v.getGrid().setLinesVisible(true);
183	v.getGrid().setHeaderVisible(true);
184	}
185
186	private MyModel[] createModel() {
187	MyModel[] elements = new MyModel[10];
188
189	for (int i = 0; i < 10; i++) {
190	elements[i] = new MyModel(i);
191	}
192
193	return elements;
194	}
195
196	/**
197	* @param args
198	*/
199	public static void main(String[] args) {
200	Display display = new Display();
201
202	Shell shell = new Shell(display);
203	shell.setLayout(new FillLayout());
204	new GridViewerSnippet1(shell);
205	shell.open();
206
207	while (!shell.isDisposed()) {
208	if (!display.readAndDispatch())
209	display.sleep();
210	}
211
212	display.dispose();
213
214	}
215
216	}