Attachment #58739 for bug #172646

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




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

				tableEditor.minimumWidth = layoutData.minimumWidth;
			}

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

		};
	}
	




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

				treeEditor.minimumWidth = layoutData.minimumWidth;
			}

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

		};
	}


Lines 13-18 Link Here

(-)src/org/eclipse/jface/viewers/EditingSupport.java (-2 / +14 lines)
13		13
14	package org.eclipse.jface.viewers;	14	package org.eclipse.jface.viewers;
15		15
		16	import java.util.List;
		17
16	import org.eclipse.core.runtime.Assert;	18	import org.eclipse.core.runtime.Assert;
17	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.events.TraverseEvent;	20	import org.eclipse.swt.events.TraverseEvent;
Lines 170-177 Link Here
170	}	172	}
171		173
172	if (cell2edit != null) {	174	if (cell2edit != null) {
173	viewer.editElement(cell2edit.getElement(), cell2edit	175	List l = viewer.getSelectionFromWidget();
174	.getColumnIndex());	176
		177	viewer.getControl().setRedraw(false);
		178
		179	//TODO Is this correct in terms of other controls e.g. grid
		180	if( ! l.contains(cell2edit.getElement()) ) {
		181	viewer.setSelection(new StructuredSelection(cell2edit.getElement()));
		182	}
		183
		184	EditorActivationEvent acEvent = new EditorActivationEvent(cell2edit,event);
		185	viewer.triggerEditorActivationEvent(acEvent);
		186	viewer.getControl().setRedraw(true);
175	}	187	}
176	}	188	}
177		189

Lines 14-19 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewer.java (-40 / +111 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 49-55 Link Here
49	private ColumnViewerEditor viewerEditor;	51	private ColumnViewerEditor viewerEditor;
50		52
51	private int tabEditingStyle = EditingSupport.TABBING_NONE;	53	private int tabEditingStyle = EditingSupport.TABBING_NONE;
52		54
53	/**	55	/**
54	* Create a new instance of the receiver.	56	* Create a new instance of the receiver.
55	*/	57	*/
Lines 76-91 Link Here
76	if (viewerEditor != null) {	78	if (viewerEditor != null) {
77	control.addMouseListener(new MouseAdapter() {	79	control.addMouseListener(new MouseAdapter() {
78	public void mouseDown(MouseEvent e) {	80	public void mouseDown(MouseEvent e) {
79	viewerEditor.handleMouseDown(e);	81	handleMouseDown(e);
80	}	82	}
81	});	83	});
82	}	84	}
83	}	85	}
84		86
85	/**	87	/**
86	* Creates the viewer editor used for editing cell contents. To be implemented by subclasses.	88	* Creates the viewer editor used for editing cell contents. To be
		89	* implemented by subclasses.
87	*	90	*
88	* @return the editor, or <code>null</code> if this viewer does not support editing cell contents.	91	* @return the editor, or <code>null</code> if this viewer does not
		92	* support editing cell contents.
89	*/	93	*/
90	protected abstract ColumnViewerEditor createViewerEditor();	94	protected abstract ColumnViewerEditor createViewerEditor();
91		95
Lines 95-101 Link Here
95	*	99	*
96	* @param point	100	* @param point
97	* the widget-relative coordinates	101	* the widget-relative coordinates
98	* @return the cell or <code>null</code> if no cell is found at the given point	102	* @return the cell or <code>null</code> if no cell is found at the given
		103	* point
99	*/	104	*/
100	ViewerCell getCell(Point point) {	105	ViewerCell getCell(Point point) {
101	ViewerRow row = getViewerRow(point);	106	ViewerRow row = getViewerRow(point);
Lines 127-133 Link Here
127	/**	132	/**
128	* Returns the viewer row associated with the given row widget.	133	* Returns the viewer row associated with the given row widget.
129	*	134	*
130	* @param item the row widget	135	* @param item
		136	* the row widget
131	* @return ViewerRow the associated viewer row	137	* @return ViewerRow the associated viewer row
132	*/	138	*/
133	protected ViewerRow getViewerRowFromItem(Widget item) {	139	protected ViewerRow getViewerRowFromItem(Widget item) {
Lines 137-143 Link Here
137	/**	143	/**
138	* Returns the column widget at the given column index.	144	* Returns the column widget at the given column index.
139	*	145	*
140	* @param columnIndex the column index	146	* @param columnIndex
		147	* the column index
141	* @return Widget the column widget	148	* @return Widget the column widget
142	*/	149	*/
143	protected abstract Widget getColumnViewerOwner(int columnIndex);	150	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	157	* @return the viewer column at the given index, or <code>null</code> if
151	* there is none for the given index	158	* there is none for the given index
152	*/	159	*/
153	/* package */ ViewerColumn getViewerColumn(final int columnIndex) {	160	/* package */ViewerColumn getViewerColumn(final int columnIndex) {
154		161
155	ViewerColumn viewer;	162	ViewerColumn viewer;
156	Widget columnOwner = getColumnViewerOwner(columnIndex);	163	Widget columnOwner = getColumnViewerOwner(columnIndex);
Lines 176-182 Link Here
176	}	183	}
177		184
178	/**	185	/**
179	* Sets up editing support for the given column based on the "old" cell editor API.	186	* Sets up editing support for the given column based on the "old" cell
		187	* editor API.
180	*	188	*
181	* @param columnIndex	189	* @param columnIndex
182	* @param viewer	190	* @param viewer
Lines 229-243 Link Here
229	}	237	}
230		238
231	/**	239	/**
232	* Creates a generic viewer column for the given column widget, based on the given label provider.	240	* Creates a generic viewer column for the given column widget, based on the
		241	* given label provider.
233	*	242	*
234	* @param columnOwner the column widget	243	* @param columnOwner
235	* @param labelProvider the label provider to use for the column	244	* the column widget
		245	* @param labelProvider
		246	* the label provider to use for the column
236	* @return ViewerColumn the viewer column	247	* @return ViewerColumn the viewer column
237	*/	248	*/
238	private ViewerColumn createViewerColumn(Widget columnOwner,	249	private ViewerColumn createViewerColumn(Widget columnOwner,
239	CellLabelProvider labelProvider) {	250	CellLabelProvider labelProvider) {
240	ViewerColumn column = new ViewerColumn(this,columnOwner) {};	251	ViewerColumn column = new ViewerColumn(this, columnOwner) {
		252	};
241	column.setLabelProvider(labelProvider, false);	253	column.setLabelProvider(labelProvider, false);
242	return column;	254	return column;
243	}	255	}
Lines 269-287 Link Here
269	* @param column	281	* @param column
270	* @return ViewerCell	282	* @return ViewerCell
271	*/	283	*/
272	/* package */ ViewerCell updateCell(ViewerRow rowItem, int column) {	284	/* package */ViewerCell updateCell(ViewerRow rowItem, int column) {
273	cell.update(rowItem, column);	285	cell.update(rowItem, column);
274	return cell;	286	return cell;
275	}	287	}
276		288
277	/**	289	/**
278	* Returns the {@link Item} at the given widget-relative coordinates, or	290	* Returns the {@link Item} at the given widget-relative coordinates, or
279	* <code>null</code> if there is no item at the given coordinates.	291	* <code>null</code> if there is no item at the given coordinates.
280	*	292	*
281	* @param point	293	* @param point
282	* the widget-relative coordinates	294	* the widget-relative coordinates
283	* @return the {@link Item} at the coordinates or <code>null</code> if there	295	* @return the {@link Item} at the coordinates or <code>null</code> if
284	* is no item at the given coordinates	296	* there is no item at the given coordinates
285	*/	297	*/
286	protected abstract Item getItemAt(Point point);	298	protected abstract Item getItemAt(Point point);
287		299
Lines 339-345 Link Here
339		351
340	/**	352	/**
341	* Cancels a currently active cell editor if one is active. All changes	353	* Cancels a currently active cell editor if one is active. All changes
342	* already done in the cell editor are lost.	354	* already done in the cell editor are lost.
343	*	355	*
344	* @since 3.1 (in subclasses, added in 3.3 to abstract class)	356	* @since 3.1 (in subclasses, added in 3.3 to abstract class)
345	*/	357	*/
Lines 371-387 Link Here
371	*/	383	*/
372	public void editElement(Object element, int column) {	384	public void editElement(Object element, int column) {
373	if (viewerEditor != null) {	385	if (viewerEditor != null) {
374	viewerEditor.editElement(element, column);	386	Widget item = findItem(element);
		387	if (item != null) {
		388	ViewerRow row = getViewerRowFromItem(item);
		389	if (row != null) {
		390	ViewerCell cell = row.getCell(column);
		391	if (cell != null) {
		392	getControl().setRedraw(false);
		393
		394	List l = getSelectionFromWidget();
		395
		396	if (l.size() > 1 \|\| !l.contains(cell.getElement())) {
		397	setSelection(new StructuredSelection(cell
		398	.getElement()));
		399	}
		400
		401	triggerEditorActivationEvent(new EditorActivationEvent(
		402	cell));
		403	getControl().setRedraw(true);
		404	}
		405	}
		406	}
375	}	407	}
376	}	408	}
377		409
378	/**	410	/**
379	* Return the CellEditors for the receiver, or <code>null</code> if no	411	* Return the CellEditors for the receiver, or <code>null</code> if no
380	* cell editors are set.	412	* cell editors are set.
381	* <p>	413	* <p>
382	* Since 3.3, an alternative API is available, see	414	* Since 3.3, an alternative API is available, see
383	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	415	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
384	* way of editing values in a column viewer.	416	* flexible way of editing values in a column viewer.
385	* </p>	417	* </p>
386	*	418	*
387	* @return CellEditor[]	419	* @return CellEditor[]
Lines 398-409 Link Here
398		430
399	/**	431	/**
400	* Returns the cell modifier of this viewer, or <code>null</code> if none	432	* Returns the cell modifier of this viewer, or <code>null</code> if none
401	* has been set.	433	* has been set.
402	*	434	*
403	* <p>	435	* <p>
404	* Since 3.3, an alternative API is available, see	436	* Since 3.3, an alternative API is available, see
405	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	437	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
406	* way of editing values in a column viewer.	438	* flexible way of editing values in a column viewer.
407	* </p>	439	* </p>
408	*	440	*
409	* @return the cell modifier, or <code>null</code>	441	* @return the cell modifier, or <code>null</code>
Lines 425-432 Link Here
425	*	457	*
426	* <p>	458	* <p>
427	* Since 3.3, an alternative API is available, see	459	* Since 3.3, an alternative API is available, see
428	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	460	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
429	* way of editing values in a column viewer.	461	* flexible way of editing values in a column viewer.
430	* </p>	462	* </p>
431	*	463	*
432	* @return the list of column properties	464	* @return the list of column properties
Lines 446-453 Link Here
446	*	478	*
447	* <p>	479	* <p>
448	* Since 3.3, an alternative API is available, see	480	* Since 3.3, an alternative API is available, see
449	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	481	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
450	* way of editing values in a column viewer.	482	* flexible way of editing values in a column viewer.
451	* </p>	483	* </p>
452	*	484	*
453	* @return <code>true</code> if there is an active cell editor, and	485	* @return <code>true</code> if there is an active cell editor, and
Lines 469-476 Link Here
469	*	501	*
470	* <p>	502	* <p>
471	* Since 3.3, an alternative API is available, see	503	* Since 3.3, an alternative API is available, see
472	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	504	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
473	* way of editing values in a column viewer.	505	* flexible way of editing values in a column viewer.
474	* </p>	506	* </p>
475	*	507	*
476	* @param editors	508	* @param editors
Lines 486-498 Link Here
486	}	518	}
487		519
488	/**	520	/**
489	* Sets the cell modifier for this column viewer. This method does nothing if editing	521	* Sets the cell modifier for this column viewer. This method does nothing
490	* is not supported by this viewer.	522	* if editing is not supported by this viewer.
491	*	523	*
492	* <p>	524	* <p>
493	* Since 3.3, an alternative API is available, see	525	* Since 3.3, an alternative API is available, see
494	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	526	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
495	* way of editing values in a column viewer.	527	* flexible way of editing values in a column viewer.
496	* </p>	528	* </p>
497	*	529	*
498	* @param modifier	530	* @param modifier
Lines 515-522 Link Here
515	*	547	*
516	* <p>	548	* <p>
517	* Since 3.3, an alternative API is available, see	549	* Since 3.3, an alternative API is available, see
518	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more flexible	550	* {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
519	* way of editing values in a column viewer.	551	* flexible way of editing values in a column viewer.
520	* </p>	552	* </p>
521	*	553	*
522	* @param columnProperties	554	* @param columnProperties
Lines 530-536 Link Here
530	viewerEditor.setColumnProperties(columnProperties);	562	viewerEditor.setColumnProperties(columnProperties);
531	}	563	}
532	}	564	}
533		565
534	/**	566	/**
535	* The tab-editing style used if the default implementation is used	567	* The tab-editing style used if the default implementation is used
536	*	568	*
Lines 544-550 Link Here
544	int getTabEditingStyle() {	576	int getTabEditingStyle() {
545	return this.tabEditingStyle;	577	return this.tabEditingStyle;
546	}	578	}
547		579
548	/**	580	/**
549	* Returns the number of columns contained in the receiver. If no columns	581	* 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	582	* were created by the programmer, this value is zero, despite the fact that
Lines 576-579 Link Here
576	}	608	}
577	return null;	609	return null;
578	}	610	}
579	}	611
		612	private void handleMouseDown(MouseEvent e) {
		613	ViewerCell cell = getCell(new Point(e.x, e.y));
		614
		615	if (cell != null) {
		616	triggerEditorActivationEvent(new EditorActivationEvent(cell, e));
		617	}
		618	}
		619
		620	/**
		621	* Invoking this method fires an editor activation event which tries to
		622	* enable the editor but before this event is passed to
		623	* {@link ColumnViewerKeyboardSupport} to see if this event should
		624	* really trigger editor activation
		625	*
		626	* @param event
		627	* the activation event
		628	*/
		629	protected void triggerEditorActivationEvent(EditorActivationEvent event) {
		630	viewerEditor.handleEditorActivationEvent(event);
		631	}
		632
		633	/**
		634	* To fully control the strategy used to control on which cell-selection
		635	* events the editor has to be activated you can pass your customized
		636	* strategy using this method.
		637	*
		638	* @param editorActivationStrategy
		639	* the strategy used to activate an editor
		640	*/
		641	public void setEditorActivationSupport(
		642	ColumnViewerKeyboardSupport editorActivationStrategy) {
		643	if (viewerEditor != null) {
		644	viewerEditor.setEditorActivationStrategy(editorActivationStrategy);
		645	} else {
		646	throw new IllegalStateException(
		647	"This feature is not supported by the widget"); //$NON-NLS-1$
		648	}
		649	}
		650	}

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(EditorActivationEvent activationEvent) {
		864	activate();
		865	}
856	}	866	}

Lines 14-19 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerEditor.java (-115 / +124 lines)
14		14
15	package org.eclipse.jface.viewers;	15	package org.eclipse.jface.viewers;
16		16
		17
		18	import org.eclipse.core.runtime.ListenerList;
17	import org.eclipse.swt.events.FocusAdapter;	19	import org.eclipse.swt.events.FocusAdapter;
18	import org.eclipse.swt.events.FocusEvent;	20	import org.eclipse.swt.events.FocusEvent;
19	import org.eclipse.swt.events.FocusListener;	21	import org.eclipse.swt.events.FocusListener;
Lines 22-28 Link Here
22	import org.eclipse.swt.events.MouseListener;	24	import org.eclipse.swt.events.MouseListener;
23	import org.eclipse.swt.events.TraverseEvent;	25	import org.eclipse.swt.events.TraverseEvent;
24	import org.eclipse.swt.events.TraverseListener;	26	import org.eclipse.swt.events.TraverseListener;
25	import org.eclipse.swt.graphics.Rectangle;
26	import org.eclipse.swt.widgets.Control;	27	import org.eclipse.swt.widgets.Control;
27	import org.eclipse.swt.widgets.Display;	28	import org.eclipse.swt.widgets.Display;
28	import org.eclipse.swt.widgets.Item;	29	import org.eclipse.swt.widgets.Item;
Lines 46-67 Link Here
46		47
47	private String[] columnProperties;	48	private String[] columnProperties;
48		49
49	private int columnNumber;
50
51	private ICellEditorListener cellEditorListener;	50	private ICellEditorListener cellEditorListener;
52		51
53	private FocusListener focusListener;	52	private FocusListener focusListener;
54		53
55	private MouseListener mouseListener;	54	private MouseListener mouseListener;
56		55
57	private int doubleClickExpirationTime;
58
59	private ColumnViewer viewer;	56	private ColumnViewer viewer;
60		57
61	private Item item;
62
63	private TraverseListener tabeditingListener;	58	private TraverseListener tabeditingListener;
64		59
		60	private int activationTime;
		61
		62	private ViewerCell cell;
		63
		64	private EditorActivationEvent activationEvent;
		65
		66	private ListenerList editorActivationListener;
		67
		68	private ColumnViewerKeyboardSupport editorActivationStrategy;
		69
65	/**	70	/**
66	* Create a new editor implementation for the viewer	71	* Create a new editor implementation for the viewer
67	*	72	*
Lines 70-75 Link Here
70	*/	75	*/
71	public ColumnViewerEditor(ColumnViewer viewer) {	76	public ColumnViewerEditor(ColumnViewer viewer) {
72	this.viewer = viewer;	77	this.viewer = viewer;
		78	editorActivationStrategy = new ColumnViewerKeyboardSupport(viewer) {
		79	protected boolean isEditorActivationEvent(EditorActivationEvent event) {
		80	return event.eventType == EditorActivationEvent.MOUSE_CLICK_SELECTION
		81	\|\| event.eventType == EditorActivationEvent.PROGRAMATIC
		82	\|\| event.eventType == EditorActivationEvent.TRAVERSAL;
		83	}
		84
		85	protected ViewerCell getFocusCell() {
		86	return null;
		87	}
		88
		89	};
		90
73	initCellEditorListener();	91	initCellEditorListener();
74	}	92	}
75		93
Lines 92-104 Link Here
92		110
93	void activateCellEditor() {	111	void activateCellEditor() {
94		112
95	ViewerColumn part = viewer.getViewerColumn(columnNumber);	113	ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
96	Object element = item.getData();	114	Object element = cell.getElement();
97		115
98	if (part != null && part.getEditingSupport() != null	116	if (part != null && part.getEditingSupport() != null
99	&& part.getEditingSupport().canEdit(element)) {	117	&& part.getEditingSupport().canEdit(element)) {
100	cellEditor = part.getEditingSupport().getCellEditor(element);	118	cellEditor = part.getEditingSupport().getCellEditor(element);
101	if (cellEditor != null) {	119	if (cellEditor != null) {
		120	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		121	Object[] ls = editorActivationListener.getListeners();
		122	for( int i = 0; i < ls.length; i++ ) {
		123
		124	if( activationEvent.cancle ) {
		125	return;
		126	}
		127
		128	((ColumnViewerEditorActivationListener)ls[i]).beforeEditorActivated(activationEvent);
		129	}
		130	}
		131
102	cellEditor.addListener(cellEditorListener);	132	cellEditor.addListener(cellEditorListener);
103	Object value = part.getEditingSupport().getValue(element);	133	Object value = part.getEditingSupport().getValue(element);
104	cellEditor.setValue(value);	134	cellEditor.setValue(value);
Lines 108-119 Link Here
108	// so must get control first, but must still call activate()	138	// so must get control first, but must still call activate()
109	// even if there is no control.	139	// even if there is no control.
110	final Control control = cellEditor.getControl();	140	final Control control = cellEditor.getControl();
111	cellEditor.activate();	141	cellEditor.activate(activationEvent);
112	if (control == null) {	142	if (control == null) {
113	return;	143	return;
114	}	144	}
115	setLayoutData(cellEditor.getLayoutData());	145	setLayoutData(cellEditor.getLayoutData());
116	setEditor(control, item, columnNumber);	146	setEditor(control, cell.getItem(), cell.getColumnIndex());
117	cellEditor.setFocus();	147	cellEditor.setFocus();
118	if (focusListener == null) {	148	if (focusListener == null) {
119	focusListener = new FocusAdapter() {	149	focusListener = new FocusAdapter() {
Lines 128-134 Link Here
128	public void mouseDown(MouseEvent e) {	158	public void mouseDown(MouseEvent e) {
129	// time wrap?	159	// time wrap?
130	// check for expiration of doubleClickTime	160	// check for expiration of doubleClickTime
131	if (e.time <= doubleClickExpirationTime) {	161	if (e.time <= activationTime) {
132	control.removeMouseListener(mouseListener);	162	control.removeMouseListener(mouseListener);
133	cancelEditing();	163	cancelEditing();
134	handleDoubleClickEvent();	164	handleDoubleClickEvent();
Lines 143-195 Link Here
143	tabeditingListener = new TraverseListener() {	173	tabeditingListener = new TraverseListener() {
144		174
145	public void keyTraversed(TraverseEvent e) {	175	public void keyTraversed(TraverseEvent e) {
146	ViewerColumn col = viewer.getViewerColumn(columnNumber);	176	ViewerColumn col = viewer.getViewerColumn(cell.getColumnIndex());
147	if ( col != null && col.getEditingSupport().isTabingSupported() ) {	177	if ( col != null && col.getEditingSupport().isTabingSupported() ) {
148	col.getEditingSupport().processTraversEvent(	178	col.getEditingSupport().processTraversEvent(
149	columnNumber,	179	cell.getColumnIndex(),
150	viewer.getViewerRowFromItem(item), e);	180	viewer.getViewerRowFromItem(cell.getItem()), e);
151	}	181	}
152	}	182	}
153	};	183	};
154	}	184	}
155		185
156	control.addTraverseListener(tabeditingListener);	186	control.addTraverseListener(tabeditingListener);
157		187
158	}	188	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
159	}	189	Object[] ls = editorActivationListener.getListeners();
160	}	190	for( int i = 0; i < ls.length; i++ ) {
161		191	((ColumnViewerEditorActivationListener)ls[i]).afterEditorActivated(activationEvent);
162	/**	192	}
163	* Activate a cell editor for the given mouse position.
164	*/
165	private void activateCellEditor(MouseEvent event) {
166	if (item == null \|\| item.isDisposed()) {
167	// item no longer exists
168	return;
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	}	193	}
185	}	194	}
186	if (columnToEdit == -1) {
187	return;
188	}
189	}	195	}
190
191	columnNumber = columnToEdit;
192	activateCellEditor();
193	}	196	}
194		197
195	/**	198	/**
Lines 203-210 Link Here
203	// in case save results in applyEditorValue being re-entered	206	// in case save results in applyEditorValue being re-entered
204	// see 1GAHI8Z: ITPUI:ALL - How to code event notification when	207	// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
205	// using cell editor ?	208	// using cell editor ?
		209	EditorDeactivationEvent tmp = new EditorDeactivationEvent(cell);
		210	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		211	Object[] ls = editorActivationListener.getListeners();
		212	for( int i = 0; i < ls.length; i++ ) {
		213
		214	if( tmp.cancle ) {
		215	return;
		216	}
		217
		218	((ColumnViewerEditorActivationListener)ls[i]).beforeEditorDeactivated(tmp);
		219	}
		220	}
		221
206	this.cellEditor = null;	222	this.cellEditor = null;
207	Item t = this.item;	223	this.activationEvent = null;
		224	Item t = this.cell.getItem();
208	// don't null out table item -- same item is still selected	225	// don't null out table item -- same item is still selected
209	if (t != null && !t.isDisposed()) {	226	if (t != null && !t.isDisposed()) {
210	saveEditorValue(c, t);	227	saveEditorValue(c, t);
Lines 227-232 Link Here
227	}	244	}
228	}	245	}
229	c.deactivate();	246	c.deactivate();
		247
		248	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		249	Object[] ls = editorActivationListener.getListeners();
		250	for( int i = 0; i < ls.length; i++ ) {
		251	((ColumnViewerEditorActivationListener)ls[i]).afterEditorDeactivated(tmp);
		252	}
		253	}
230	}	254	}
231	}	255	}
232		256
Lines 235-240 Link Here
235	*/	259	*/
236	void cancelEditing() {	260	void cancelEditing() {
237	if (cellEditor != null) {	261	if (cellEditor != null) {
		262	EditorDeactivationEvent tmp = new EditorDeactivationEvent(cell);
		263	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		264	Object[] ls = editorActivationListener.getListeners();
		265	for( int i = 0; i < ls.length; i++ ) {
		266	if( tmp.cancle ) {
		267	return;
		268	}
		269
		270	((ColumnViewerEditorActivationListener)ls[i]).beforeEditorDeactivated(tmp);
		271	}
		272	}
		273
238	setEditor(null, null, 0);	274	setEditor(null, null, 0);
239	cellEditor.removeListener(cellEditorListener);	275	cellEditor.removeListener(cellEditorListener);
240		276
Lines 256-325 Link Here
256		292
257	CellEditor oldEditor = cellEditor;	293	CellEditor oldEditor = cellEditor;
258	cellEditor = null;	294	cellEditor = null;
		295	activationEvent=null;
259	oldEditor.deactivate();	296	oldEditor.deactivate();
		297
		298	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		299	Object[] ls = editorActivationListener.getListeners();
		300	for( int i = 0; i < ls.length; i++ ) {
		301	((ColumnViewerEditorActivationListener)ls[i]).afterEditorDeactivated(tmp);
		302	}
		303	}
260	}	304	}
261	}	305	}
262		306
263	/**	307	/**
264	* Enable the editor by mouse down	308	* Enable the editor by mouse down
265	*	309	*
266	* @param event	310	* @param event
267	*/	311	*/
268	void handleMouseDown(MouseEvent event) {	312	void handleEditorActivationEvent(EditorActivationEvent event) {
269	if (event.button != 1) {	313	if( editorActivationStrategy.isEditorActivationEvent(event) ) {
270	return;	314	if (cellEditor != null) {
271	}	315	applyEditorValue();
272		316	}
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
295	/**
296	* Start editing the given element.
297	*
298	* @param element
299	* @param column
300	*/
301	void editElement(Object element, int column) {
302	if (cellEditor != null) {
303	applyEditorValue();
304	}
305		317
306	setSelection(createSelection(element), true);	318	this.cell = (ViewerCell)event.getSource();
307	Item[] selection = getSelection();	319	activationEvent = event;
308	if (selection.length != 1) {	320	activationTime = event.time + Display.getCurrent().getDoubleClickTime();
309	return;	321
		322	activateCellEditor();
310	}	323	}
311
312	item = selection[0];
313
314	// Make sure selection is visible
315	showSelection();
316	columnNumber = column;
317	activateCellEditor();
318
319	}	324	}
320		325
321	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {	326	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
322	ViewerColumn part = viewer.getViewerColumn(columnNumber);	327	ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
323		328
324	if (part != null && part.getEditingSupport() != null) {	329	if (part != null && part.getEditingSupport() != null) {
325	part.getEditingSupport().setValue(tableItem.getData(),	330	part.getEditingSupport().setValue(tableItem.getData(),
Lines 391-406 Link Here
391	return cellEditors;	396	return cellEditors;
392	}	397	}
393		398
394	void setSelection(StructuredSelection selection, boolean b) {
395	viewer.setSelection(selection, b);
396	}
397
398	void handleDoubleClickEvent() {	399	void handleDoubleClickEvent() {
399	viewer.fireDoubleClick(new DoubleClickEvent(viewer, viewer	400	viewer.fireDoubleClick(new DoubleClickEvent(viewer, viewer
400	.getSelection()));	401	.getSelection()));
401	viewer.fireOpen(new OpenEvent(viewer, viewer.getSelection()));	402	viewer.fireOpen(new OpenEvent(viewer, viewer.getSelection()));
402	}	403	}
403		404
		405	void addEditorActivationListener(ColumnViewerEditorActivationListener listener) {
		406	if( editorActivationListener == null ) {
		407	editorActivationListener = new ListenerList();
		408	}
		409	editorActivationListener.add(listener);
		410	}
		411
		412	void removeEditorActivationListener(ColumnViewerEditorActivationListener listener) {
		413	if( editorActivationListener != null ) {
		414	editorActivationListener.remove(listener);
		415	}
		416	}
		417
		418	void setEditorActivationStrategy(
		419	ColumnViewerKeyboardSupport editorActivationStrategy) {
		420	this.editorActivationStrategy = editorActivationStrategy;
		421	}
		422
404	/**	423	/**
405	* Create a selection for this model element	424	* Create a selection for this model element
406	*	425	*
Lines 429-442 Link Here
429	* the layout data used when editor is displayed	448	* the layout data used when editor is displayed
430	*/	449	*/
431	protected abstract void setLayoutData(CellEditor.LayoutData layoutData);	450	protected abstract void setLayoutData(CellEditor.LayoutData layoutData);
432		451	}
433	/**
434	* Show up the current selection (scroll the selection into view)
435	*/
436	protected abstract void showSelection();
437
438	/**
439	* @return the current selection
440	*/
441	protected abstract Item[] getSelection();
442	}




/*******************************************************************************
 * 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 abstract class ColumnViewerKeyboardSupport {
	private ColumnViewer viewer;
	
	private KeyListener keyboardActivationListener;
	
	/**
	 * @param viewer the viewer the editor support is attached to
	 */
	public ColumnViewerKeyboardSupport(ColumnViewer viewer) {
		this.viewer = viewer;
	}
	
	/**
	 * @return the cell holding the current focus
	 */
	protected abstract ViewerCell getFocusCell();
	
	/**
	 * @param event
	 * @return bla bl
	 */
	protected abstract boolean isEditorActivationEvent(EditorActivationEvent event);
	
	/**
	 * @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 EditorActivationEvent(cell,e));
						}
					}

					public void keyReleased(KeyEvent e) {
						
					}
					
				};
				viewer.getControl().addKeyListener(keyboardActivationListener);
			}
		} else {
			if( keyboardActivationListener != null ) {
				viewer.getControl().removeKeyListener(keyboardActivationListener);
				keyboardActivationListener = 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;

import java.util.EventObject;

/**
 * This event is fired when an editor deactivated
 * 
 * @since 3.3
 * 
 */
public class EditorDeactivationEvent extends EventObject {

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

	/**
	 * Cancle the event
	 */
	public boolean cancle = false;
	
	/**
	 * @param source
	 */
	public EditorDeactivationEvent(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 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 EditorActivationEvent 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 EditorActivationEvent(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 EditorActivationEvent(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 EditorActivationEvent(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 EditorActivationEvent(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;

/**
 * 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(EditorActivationEvent event);

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

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

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

Lines 5-10 Link Here

(-)META-INF/MANIFEST.MF (-3 / +3 lines)
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.swt,	7	Require-Bundle: org.eclipse.swt,
8	org.eclipse.swt.nebula	8	org.eclipse.swt.nebula,
9	Export-Package: org.eclipse.swt.nebula.snippets.ctree,	9	org.eclipse.swt.nebula.nebface
10	org.eclipse.swt.nebula.snippets.grid	10	Export-Package: 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.EditingSupport;
import org.eclipse.jface.viewers.EditorActivationEvent;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITableColorProvider;
import org.eclipse.jface.viewers.ITableFontProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.nebula.nebface.viewers.GridViewerKeyboardSupport;
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"});
		
		GridViewerKeyboardSupport support = new GridViewerKeyboardSupport(v) {
			protected boolean isEditorActivationEvent(
					EditorActivationEvent event) {
				return event.eventType == EditorActivationEvent.TRAVERSAL || event.eventType == EditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || ( event.eventType == EditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR ) || event.eventType == EditorActivationEvent.PROGRAMATIC;
			}
		};
		support.setEnableEditorActivationWithKeyboard(true);
		
		v.setEditorActivationSupport(support);
		v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL|EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR|EditingSupport.TABBING_VERTICAL);
		
		GridColumn column = new GridColumn(v.getGrid(), SWT.NONE);
		column.setWidth(200);
		column.setText("Column 1");

		column = new GridColumn(v.getGrid(), SWT.NONE);
		column.setWidth(200);
		column.setText("Column 2");

		MyModel[] model = createModel();
		v.setInput(model);
		v.getGrid().setLinesVisible(true);
		v.getGrid().setHeaderVisible(true);
	}

	private MyModel[] createModel() {
		MyModel[] elements = new MyModel[10];

		for (int i = 0; i < 10; i++) {
			elements[i] = new MyModel(i);
		}

		return elements;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Display display = new Display();

		Shell shell = new Shell(display);
		shell.setLayout(new FillLayout());
		new GridViewerSnippet1(shell);
		shell.open();

		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();
		}

		display.dispose();

	}

}

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.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;
    
    /** Editor support for tables. */
    private GridEditor gridEditor;

    /**
     * Creates a grid viewer on a newly-created grid control under the given
     * parent. The grid control is created using the SWT style bits
     * <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>BORDER</code>. The
     * viewer has no input, no content provider, a default label provider, no
     * sorter, and no filters.
     * 
     * @param parent the parent control
     */
    public GridViewer(Composite parent)
    {
        this(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
    }

    /**
     * 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;
        gridEditor = new GridEditor(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 ColumnViewerEditor(this) 
        {
            protected StructuredSelection createSelection(Object element) 
            {
                return new StructuredSelection(element);
            }

            protected void setEditor(Control w, Item item, int fColumnNumber) 
            {
            }

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

            protected void setLayoutData(LayoutData layoutData) 
            {
                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
	}

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

    /** {@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);
    }
			System.arraycopy(items, 0, tmp, 0, items.length);
			grid.setSelection(tmp);
		}

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

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

		return null;
	}
}




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




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

import org.eclipse.jface.viewers.ColumnViewerKeyboardSupport;
import org.eclipse.jface.viewers.EditorActivationEvent;
import org.eclipse.jface.viewers.ViewerCell;

public class GridViewerKeyboardSupport extends ColumnViewerKeyboardSupport {
	public GridViewerKeyboardSupport(GridViewer viewer) {
		super(viewer);
	}
	
	protected ViewerCell getFocusCell() {
		return ((GridViewer)getViewer()).getFocusCell();
	}

	protected boolean isEditorActivationEvent(EditorActivationEvent event) {
		return event.eventType == EditorActivationEvent.TRAVERSAL || event.eventType == EditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || event.eventType == EditorActivationEvent.PROGRAMATIC;
	}

}




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

Return to bug 172646

Lines 134-143 Link Here

(-)src/org/eclipse/jface/viewers/TableViewer.java (-8 lines)
134	return new StructuredSelection(element);	134	return new StructuredSelection(element);
135	}	135	}
136		136
137	protected Item[] getSelection() {
138	return table.getSelection();
139	}
140
141	protected void setEditor(Control w, Item item, int fColumnNumber) {	137	protected void setEditor(Control w, Item item, int fColumnNumber) {
142	tableEditor.setEditor(w, (TableItem) item, fColumnNumber);	138	tableEditor.setEditor(w, (TableItem) item, fColumnNumber);
143	}	139	}
Lines 148-157 Link Here
148	tableEditor.minimumWidth = layoutData.minimumWidth;	144	tableEditor.minimumWidth = layoutData.minimumWidth;
149	}	145	}
150		146
151	protected void showSelection() {
152	table.showSelection();
153	}
154
155	};	147	};
156	}	148	}
157		149

Lines 284-293 Link Here

(-)src/org/eclipse/jface/viewers/TreeViewer.java (-8 lines)
284	return new StructuredSelection(element);	284	return new StructuredSelection(element);
285	}	285	}
286		286
287	protected Item[] getSelection() {
288	return tree.getSelection();
289	}
290
291	protected void setEditor(Control w, Item item, int fColumnNumber) {	287	protected void setEditor(Control w, Item item, int fColumnNumber) {
292	treeEditor.setEditor(w, (TreeItem) item, fColumnNumber);	288	treeEditor.setEditor(w, (TreeItem) item, fColumnNumber);
293	}	289	}
Lines 298-307 Link Here
298	treeEditor.minimumWidth = layoutData.minimumWidth;	294	treeEditor.minimumWidth = layoutData.minimumWidth;
299	}	295	}
300		296
301	protected void showSelection() {
302	getTree().showSelection();
303	}
304
305	};	297	};
306	}	298	}
307		299

Added Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerKeyboardSupport.java (+85 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.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 abstract class ColumnViewerKeyboardSupport {
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 ColumnViewerKeyboardSupport(ColumnViewer viewer) {
32	this.viewer = viewer;
33	}
34
35	/**
36	* @return the cell holding the current focus
37	*/
38	protected abstract ViewerCell getFocusCell();
39
40	/**
41	* @param event
42	* @return bla bl
43	*/
44	protected abstract boolean isEditorActivationEvent(EditorActivationEvent event);
45
46	/**
47	* @return the viewer
48	*/
49	public ColumnViewer getViewer() {
50	return viewer;
51	}
52
53	/**
54	* Enable activation of cell editors by keyboard
55	* @param enable <code>true</code> to enable
56	*/
57	public void setEnableEditorActivationWithKeyboard(boolean enable) {
58	if( enable ) {
59	if( keyboardActivationListener == null ) {
60	keyboardActivationListener = new KeyListener() {
61
62	public void keyPressed(KeyEvent e) {
63	ViewerCell cell = getFocusCell();
64
65	if( cell != null ) {
66	viewer.triggerEditorActivationEvent(new EditorActivationEvent(cell,e));
67	}
68	}
69
70	public void keyReleased(KeyEvent e) {
71
72	}
73
74	};
75	viewer.getControl().addKeyListener(keyboardActivationListener);
76	}
77	} else {
78	if( keyboardActivationListener != null ) {
79	viewer.getControl().removeKeyListener(keyboardActivationListener);
80	keyboardActivationListener = null;
81	}
82	}
83	}
84
85	}

Added Link Here

(-)src/org/eclipse/jface/viewers/EditorDeactivationEvent.java (+41 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 java.util.EventObject;
15
16	/**
17	* This event is fired when an editor deactivated
18	*
19	* @since 3.3
20	*
21	*/
22	public class EditorDeactivationEvent extends EventObject {
23
24	/**
25	*
26	*/
27	private static final long serialVersionUID = 1L;
28
29	/**
30	* Cancle the event
31	*/
32	public boolean cancle = false;
33
34	/**
35	* @param source
36	*/
37	public EditorDeactivationEvent(Object source) {
38	super(source);
39	}
40
41	}

Added Link Here

(-)src/org/eclipse/jface/viewers/EditorActivationEvent.java (+164 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 java.util.EventObject;
15
16	import org.eclipse.swt.events.KeyEvent;
17	import org.eclipse.swt.events.MouseEvent;
18	import org.eclipse.swt.events.TraverseEvent;
19
20	/**
21	* This event is passed on when a cell-editor is going to be activated
22	*
23	* @since 3.3
24	*
25	*/
26	public class EditorActivationEvent extends EventObject {
27	/**
28	*
29	*/
30	private static final long serialVersionUID = 1L;
31
32	/**
33	* if a key is pressed on a selected cell
34	*/
35	public static final int KEY_PRESSED = 1;
36
37	/**
38	* if a cell is selected using a single click of the mouse
39	*/
40	public static final int MOUSE_CLICK_SELECTION = 2;
41
42	/**
43	* if a cell is selected using double clicking of the mouse
44	*/
45	public static final int MOUSE_DOUBLE_CLICK_SELECTION = 3;
46
47	/**
48	* if a cell is activated using code like e.g
49	* {@link ColumnViewer#editElement(Object, int)}
50	*/
51	public static final int PROGRAMATIC = 4;
52
53	/**
54	* is a cell is activated by traversing
55	*/
56	public static final int TRAVERSAL = 5;
57
58	/**
59	* the original event triggered
60	*/
61	public EventObject sourceEvent;
62
63	/**
64	* The time the event is triggered
65	*/
66	public int time;
67
68	/**
69	* The event type triggered:
70	* <ul>
71	* <li>{@link #KEY_PRESSED} if a key is pressed on a selected cell</li>
72	* <li>{@link #MOUSE_CLICK_SELECTION} if a cell is selected using a single
73	* click of the mouse</li>
74	* <li>{@link #MOUSE_DOUBLE_CLICK_SELECTION} if a cell is selected using
75	* double clicking of the mouse</li>
76	* </ul>
77	*/
78	public int eventType;
79
80	/**
81	* <b>Only set for {@link #KEY_PRESSED}</b>
82	*/
83	public int keyCode;
84
85	/**
86	* <b>Only set for {@link #KEY_PRESSED}</b>
87	*/
88	public char character;
89
90	/**
91	* The statemask
92	*/
93	public int stateMask;
94
95	/**
96	* Cancle the event (=> editor is not activated)
97	*/
98	public boolean cancle = false;
99
100	/**
101	* This constructor can be used when no event exists. The type set is
102	* {@link #PROGRAMATIC}
103	*
104	* @param cell
105	* the cell
106	*/
107	public EditorActivationEvent(ViewerCell cell) {
108	super(cell);
109	eventType = PROGRAMATIC;
110	}
111
112	/**
113	* This constructor is used for all types of mouse events. Currently the
114	* type is can be {@link #MOUSE_CLICK_SELECTION} and
115	* {@link #MOUSE_DOUBLE_CLICK_SELECTION}
116	*
117	* @param cell
118	* the cell source of the event
119	* @param event
120	* the event
121	*/
122	public EditorActivationEvent(ViewerCell cell, MouseEvent event) {
123	super(cell);
124
125	if (event.count >= 2) {
126	eventType = MOUSE_DOUBLE_CLICK_SELECTION;
127	} else {
128	eventType = MOUSE_CLICK_SELECTION;
129	}
130
131	this.sourceEvent = event;
132	this.time = event.time;
133	}
134
135	/**
136	* @param cell
137	* the cell source of the event
138	* @param event
139	* the event
140	*/
141	public EditorActivationEvent(ViewerCell cell, KeyEvent event) {
142	super(cell);
143	this.eventType = KEY_PRESSED;
144	this.sourceEvent = event;
145	this.time = 0;
146	this.keyCode = event.keyCode;
147	this.character = event.character;
148	this.stateMask = event.stateMask;
149	}
150
151	/**
152	* This constructur is used to mark the activation triggered by a traversal
153	*
154	* @param cell
155	* the cell source of the event
156	* @param event
157	* the event
158	*/
159	public EditorActivationEvent(ViewerCell cell, TraverseEvent event) {
160	super(cell);
161	this.eventType = TRAVERSAL;
162	this.sourceEvent = event;
163	}
164	}

Added Link Here

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