Attachment #59808 for bug #172646

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

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.CellEditorActivationEvent;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITableColorProvider;
import org.eclipse.jface.viewers.ITableFontProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.nebula.nebface.viewers.GridViewerEditorActivationSupport;
import org.eclipse.swt.nebula.nebface.viewers.GridViewer;
import org.eclipse.swt.nebula.widgets.grid.GridColumn;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**
 * Example usage of none mandatory interfaces of ITableFontProvider and
 * ITableColorProvider
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * 
 */
public class GridViewerSnippet1 {

	private class MyContentProvider implements IStructuredContentProvider {

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
		 */
		public Object[] getElements(Object inputElement) {
			return (MyModel[]) inputElement;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
		 */
		public void dispose() {

		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
		 *      java.lang.Object, java.lang.Object)
		 */
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

		}

	}

	public static boolean flag = true;
	
	public class MyModel {
		public int counter;

		public MyModel(int counter) {
			this.counter = counter;
		}

		public String toString() {
			return "Item " + this.counter;
		}
	}

	public class MyLabelProvider extends LabelProvider implements
			ITableLabelProvider, ITableFontProvider, ITableColorProvider {
		FontRegistry registry = new FontRegistry();

		public Image getColumnImage(Object element, int columnIndex) {
			return null;
		}

		public String getColumnText(Object element, int columnIndex) {
			return "Column " + columnIndex + " => " + element.toString();
		}

		public Font getFont(Object element, int columnIndex) {
			if (((MyModel) element).counter % 2 == 0) {
				return registry.getBold(Display.getCurrent().getSystemFont()
						.getFontData()[0].getName());
			}
			return null;
		}

		public Color getBackground(Object element, int columnIndex) {
			if (((MyModel) element).counter % 2 == 0) {
				return Display.getCurrent().getSystemColor(SWT.COLOR_RED);
			}
			return null;
		}

		public Color getForeground(Object element, int columnIndex) {
			if (((MyModel) element).counter % 2 == 1) {
				return Display.getCurrent().getSystemColor(SWT.COLOR_RED);
			}
			return null;
		}

	}

	public GridViewerSnippet1(Shell shell) {
		final GridViewer v = new GridViewer(shell, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
		v.setLabelProvider(new MyLabelProvider());
		v.setContentProvider(new MyContentProvider());
		v.getGrid().setCellSelectionEnabled(true);
				
		v.setCellEditors(new CellEditor[] { new TextCellEditor(v.getGrid()), new TextCellEditor(v.getGrid()) });
		v.setCellModifier(new ICellModifier() {

			public boolean canModify(Object element, String property) {
				return true;
			}

			public Object getValue(Object element, String property) {
				return "Column " + property + " => " + element.toString();
			}

			public void modify(Object element, String property, Object value) {
				
			}
			
		});
		
		v.setColumnProperties(new String[] {"1","2"});
		
		GridViewerEditorActivationSupport support = new GridViewerEditorActivationSupport(v) {
			protected boolean isEditorActivationEvent(
					CellEditorActivationEvent event) {
				return event.eventType == CellEditorActivationEvent.TRAVERSAL || event.eventType == CellEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || ( event.eventType == CellEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR ) || event.eventType == CellEditorActivationEvent.PROGRAMATIC;
			}
		};
		support.setEnableEditorActivationWithKeyboard(true);
		
		v.setEditorActivationSupport(support);
		v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL|EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR|EditingSupport.TABBING_VERTICAL);
		
		GridColumn column = new GridColumn(v.getGrid(), SWT.NONE);
		column.setWidth(200);
		column.setText("Column 1");

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

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

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

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

		return elements;
	}

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

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

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

		display.dispose();

	}

}




				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-21 Link Here

(-)src/org/eclipse/jface/viewers/EditingSupport.java (-3 / +295 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;
		19	import org.eclipse.core.runtime.ListenerList;
17	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
		21	import org.eclipse.swt.events.FocusAdapter;
		22	import org.eclipse.swt.events.FocusEvent;
		23	import org.eclipse.swt.events.FocusListener;
		24	import org.eclipse.swt.events.MouseAdapter;
		25	import org.eclipse.swt.events.MouseEvent;
		26	import org.eclipse.swt.events.MouseListener;
18	import org.eclipse.swt.events.TraverseEvent;	27	import org.eclipse.swt.events.TraverseEvent;
		28	import org.eclipse.swt.events.TraverseListener;
		29	import org.eclipse.swt.widgets.Control;
		30	import org.eclipse.swt.widgets.Display;
		31	import org.eclipse.swt.widgets.Item;
19		32
20	/**	33	/**
21	* EditingSupport is the abstract superclass of the support for cell editing.	34	* EditingSupport is the abstract superclass of the support for cell editing.
Lines 56-61 Link Here
56		69
57	private ColumnViewer viewer;	70	private ColumnViewer viewer;
58		71
		72	private ICellEditorListener cellEditorListener;
		73
		74	private FocusListener focusListener;
		75
		76	private MouseListener mouseListener;
		77
		78	private TraverseListener tabeditingListener;
		79
		80	private ViewerCell cell;
		81
		82	private int activationTime;
		83
		84	private CellEditor cellEditor;
		85
		86	private ColumnViewerEditor editor;
		87
59	/**	88	/**
60	* @param viewer	89	* @param viewer
61	* a new viewer	90	* a new viewer
Lines 63-68 Link Here
63	public EditingSupport(ColumnViewer viewer) {	92	public EditingSupport(ColumnViewer viewer) {
64	Assert.isNotNull(viewer,"Viewer is not allowed to be null"); //$NON-NLS-1$	93	Assert.isNotNull(viewer,"Viewer is not allowed to be null"); //$NON-NLS-1$
65	this.viewer = viewer;	94	this.viewer = viewer;
		95	initCellEditorListener();
66	}	96	}
67		97
68	/**	98	/**
Lines 170-177 Link Here
170	}	200	}
171		201
172	if (cell2edit != null) {	202	if (cell2edit != null) {
173	viewer.editElement(cell2edit.getElement(), cell2edit	203	List l = viewer.getSelectionFromWidget();
174	.getColumnIndex());	204
		205	viewer.getControl().setRedraw(false);
		206
		207	//TODO Is this correct in terms of other controls e.g. grid
		208	if( ! l.contains(cell2edit.getElement()) ) {
		209	viewer.setSelection(new StructuredSelection(cell2edit.getElement()));
		210	}
		211
		212	CellEditorActivationEvent acEvent = new CellEditorActivationEvent(cell2edit,event);
		213	viewer.triggerCellEditorActivation(acEvent);
		214	viewer.getControl().setRedraw(true);
175	}	215	}
176	}	216	}
177		217
Lines 208-213 Link Here
208	if (columnIndex - 1 >= 0) {	248	if (columnIndex - 1 >= 0) {
209	ViewerColumn column = viewer.getViewerColumn(columnIndex - 1);	249	ViewerColumn column = viewer.getViewerColumn(columnIndex - 1);
210	if (column != null	250	if (column != null
		251	&& column.getEditingSupport() != null
211	&& column.getEditingSupport().canEdit(	252	&& column.getEditingSupport().canEdit(
212	row.getItem().getData())) {	253	row.getItem().getData())) {
213	rv = row.getCell(columnIndex - 1);	254	rv = row.getCell(columnIndex - 1);
Lines 244-249 Link Here
244	if (columnIndex + 1 < row.getColumnCount()) {	285	if (columnIndex + 1 < row.getColumnCount()) {
245	ViewerColumn column = viewer.getViewerColumn(columnIndex + 1);	286	ViewerColumn column = viewer.getViewerColumn(columnIndex + 1);
246	if (column != null	287	if (column != null
		288	&& column.getEditingSupport() != null
247	&& column.getEditingSupport().canEdit(	289	&& column.getEditingSupport().canEdit(
248	row.getItem().getData())) {	290	row.getItem().getData())) {
249	rv = row.getCell(columnIndex + 1);	291	rv = row.getCell(columnIndex + 1);
Lines 275-278 Link Here
275	public ColumnViewer getViewer() {	317	public ColumnViewer getViewer() {
276	return viewer;	318	return viewer;
277	}	319	}
278	}	320
		321	// API MOVED FROM ColumnViewerEditor!
		322
		323	void activateCellEditor(ColumnViewerEditor editor, CellEditorActivationEvent activationEvent) {
		324	this.editor = editor;
		325	activationTime = activationEvent.time + Display.getCurrent().getDoubleClickTime();
		326	this.cell = (ViewerCell) activationEvent.getSource();
		327
		328	ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
		329	Object element = cell.getElement();
		330
		331	if (part != null && part.getEditingSupport() != null
		332	&& part.getEditingSupport().canEdit(element)) {
		333	cellEditor = part.getEditingSupport().getCellEditor(element);
		334	if (cellEditor != null) {
		335
		336	ListenerList list = editor.getEditorActivationListeners();
		337
		338	if( list != null && ! list.isEmpty() ) {
		339	Object[] ls = list.getListeners();
		340	for( int i = 0; i < ls.length; i++ ) {
		341
		342	if( ! activationEvent.doIt ) {
		343	return;
		344	}
		345
		346	((CellEditorActivationListener)ls[i]).beforeEditorActivated(activationEvent);
		347	}
		348	}
		349
		350	cellEditor.addListener(cellEditorListener);
		351	Object value = part.getEditingSupport().getValue(element);
		352	cellEditor.setValue(value);
		353	// Tricky flow of control here:
		354	// activate() can trigger callback to cellEditorListener which
		355	// will clear cellEditor
		356	// so must get control first, but must still call activate()
		357	// even if there is no control.
		358	final Control control = cellEditor.getControl();
		359	cellEditor.activate(activationEvent);
		360	if (control == null) {
		361	return;
		362	}
		363	editor.setLayoutData(cellEditor.getLayoutData());
		364	editor.setEditor(control, cell.getItem(), cell.getColumnIndex());
		365	cellEditor.setFocus();
		366	if (focusListener == null) {
		367	focusListener = new FocusAdapter() {
		368	public void focusLost(FocusEvent e) {
		369	applyEditorValue();
		370	}
		371	};
		372	}
		373	control.addFocusListener(focusListener);
		374
		375	mouseListener = new MouseAdapter() {
		376	public void mouseDown(MouseEvent e) {
		377	// time wrap?
		378	// check for expiration of doubleClickTime
		379	if (e.time <= activationTime) {
		380	control.removeMouseListener(mouseListener);
		381	cancelEditing();
		382	EditingSupport.this.editor.handleDoubleClickEvent();
		383	} else if (mouseListener != null) {
		384	control.removeMouseListener(mouseListener);
385	}
386	}
387	};
388	control.addMouseListener(mouseListener);
389
390	if( tabeditingListener == null ) {
391	tabeditingListener = new TraverseListener() {
392
393	public void keyTraversed(TraverseEvent e) {
394	ViewerColumn col = viewer.getViewerColumn(cell.getColumnIndex());
395	if ( col != null && col.getEditingSupport().isTabingSupported() ) {
396	col.getEditingSupport().processTraversEvent(
397	cell.getColumnIndex(),
398	viewer.getViewerRowFromItem(cell.getItem()), e);
399	}
400	}
401	};
402	}
403
404	control.addTraverseListener(tabeditingListener);
405
406	if( list != null && ! list.isEmpty() ) {
407	Object[] ls = list.getListeners();
408	for( int i = 0; i < ls.length; i++ ) {
409	if( ! activationEvent.doIt ) {
410	return;
411	}
412	((CellEditorActivationListener)ls[i]).afterEditorActivated(activationEvent);
413	}
414	}
415	}
416	}
417	}
418
419	/**
420	* Applies the current value and deactivates the currently active cell
421	* editor.
422	*/
423	void applyEditorValue() {
424	CellEditor c = this.cellEditor;
425	if (c != null && editor != null) {
426	// null out cell editor before calling save
427	// in case save results in applyEditorValue being re-entered
428	// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
429	// using cell editor ?
430	CellEditorDeactivationEvent tmp = new CellEditorDeactivationEvent(cell);
431	ListenerList listeners = editor.getEditorActivationListeners();
432	if( listeners != null && ! editor.getEditorActivationListeners().isEmpty() ) {
433	Object[] ls = editor.getEditorActivationListeners().getListeners();
434	for( int i = 0; i < ls.length; i++ ) {
435
436	if( ! tmp.doIt ) {
437	return;
438	}
439
440	((CellEditorActivationListener)ls[i]).beforeEditorDeactivated(tmp);
441	}
442	}
443
444	this.cellEditor = null;
445
446	Item t = this.cell.getItem();
447	// don't null out table item -- same item is still selected
448	if (t != null && !t.isDisposed()) {
449	saveEditorValue(c, t);
450	}
451	editor.setEditor(null, null, 0);
452	this.editor = null;
453	c.removeListener(cellEditorListener);
454	Control control = c.getControl();
455	if (control != null) {
456	if (mouseListener != null) {
457	control.removeMouseListener(mouseListener);
458	// Clear the instance not needed any more
459	mouseListener = null;
460	}
461	if (focusListener != null) {
462	control.removeFocusListener(focusListener);
463	}
464
465	if (tabeditingListener != null) {
466	control.removeTraverseListener(tabeditingListener);
467	}
468	}
469
470	c.deactivate();
471
472	if( listeners != null && ! listeners.isEmpty() ) {
473	Object[] ls = listeners.getListeners();
474	for( int i = 0; i < ls.length; i++ ) {
475	if( ! tmp.doIt ) {
476	return;
477	}
478	((CellEditorActivationListener)ls[i]).afterEditorDeactivated(tmp);
479	}
480	}
481	}
482	}
483
484	/**
485	* Cancle editing
486	*/
487	void cancelEditing() {
488	if (cellEditor != null && editor != null) {
489	CellEditorDeactivationEvent tmp = new CellEditorDeactivationEvent(cell);
490	ListenerList listeners = editor.getEditorActivationListeners();
491
492	if( listeners != null && ! listeners.isEmpty() ) {
493	Object[] ls = listeners.getListeners();
494	for( int i = 0; i < ls.length; i++ ) {
495	if( ! tmp.doIt ) {
496	return;
497	}
498
499	((CellEditorActivationListener)ls[i]).beforeEditorDeactivated(tmp);
500	}
501	}
502
503	editor.setEditor(null, null, 0);
504	cellEditor.removeListener(cellEditorListener);
505
506	Control control = cellEditor.getControl();
507	if (control != null) {
508	if (mouseListener != null) {
509	control.removeMouseListener(mouseListener);
510	// Clear the instance not needed any more
511	mouseListener = null;
512	}
513	if (focusListener != null) {
514	control.removeFocusListener(focusListener);
515	}
516
517	if (tabeditingListener != null) {
518	control.removeTraverseListener(tabeditingListener);
519	}
520	}
521
522	CellEditor oldEditor = cellEditor;
523	cellEditor = null;
524	editor=null;
525	oldEditor.deactivate();
526
527	if( listeners != null && ! listeners.isEmpty() ) {
528	Object[] ls = listeners.getListeners();
529	for( int i = 0; i < ls.length; i++ ) {
530
531	if( ! tmp.doIt ) {
532	return;
533	}
534
535	((CellEditorActivationListener)ls[i]).afterEditorDeactivated(tmp);
536	}
537	}
538	}
539	}
540
541	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
542	ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
543
544	if (part != null && part.getEditingSupport() != null) {
545	part.getEditingSupport().setValue(tableItem.getData(),
546	cellEditor.getValue());
547	}
548	}
549
550	private void initCellEditorListener() {
551	cellEditorListener = new ICellEditorListener() {
552	public void editorValueChanged(boolean oldValidState,
553	boolean newValidState) {
554	// Ignore.
555	}
556
557	public void cancelEditor() {
558	EditingSupport.this.cancelEditing();
559	}
560
561	public void applyEditorValue() {
562	EditingSupport.this.applyEditorValue();
563	}
564	};
565	}
566
567	boolean isCellEditorActive() {
568	return cellEditor != null;
569	}
570	}

Lines 14-19 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewer.java (-2 / +63 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 76-82 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	}
Lines 371-377 Link Here
371	*/	373	*/
372	public void editElement(Object element, int column) {	374	public void editElement(Object element, int column) {
373	if (viewerEditor != null) {	375	if (viewerEditor != null) {
374	viewerEditor.editElement(element, column);	376	Widget item = findItem(element);
		377	if (item != null) {
		378	ViewerRow row = getViewerRowFromItem(item);
		379	if (row != null) {
		380	ViewerCell cell = row.getCell(column);
		381	if (cell != null) {
		382	getControl().setRedraw(false);
		383
		384	List l = getSelectionFromWidget();
		385
		386	if (l.size() > 1 \|\| !l.contains(cell.getElement())) {
		387	setSelection(new StructuredSelection(cell
		388	.getElement()));
		389	}
		390
		391	triggerCellEditorActivation(new CellEditorActivationEvent(
		392	cell));
		393	getControl().setRedraw(true);
		394	}
		395	}
		396	}
375	}	397	}
376	}	398	}
377		399
Lines 576-579 Link Here
576	}	598	}
577	return null;	599	return null;
578	}	600	}
		601
		602	private void handleMouseDown(MouseEvent e) {
		603	ViewerCell cell = getCell(new Point(e.x, e.y));
		604
		605	if (cell != null) {
		606	triggerCellEditorActivation(new CellEditorActivationEvent(cell, e));
		607	}
		608	}
		609
		610	/**
		611	* Invoking this method fires an editor activation event which tries to
		612	* enable the editor but before this event is passed to
		613	* {@link ColumnViewerEditorActivationSupport} to see if this event should
		614	* really trigger editor activation
		615	*
		616	* @param event
		617	* the activation event
		618	*/
		619	protected void triggerCellEditorActivation(CellEditorActivationEvent event) {
		620	viewerEditor.triggerCellEditorActivation(event);
		621	}
		622
		623	/**
		624	* To fully control the strategy used to control on which cell-selection
		625	* events the editor has to be activated you can pass your customized
		626	* strategy using this method.
		627	*
		628	* @param editorActivationStrategy
		629	* the strategy used to activate an editor
		630	*/
		631	public void setEditorActivationSupport(
		632	ColumnViewerEditorActivationSupport editorActivationStrategy) {
		633	if (viewerEditor != null) {
		634	viewerEditor.setEditorActivationStrategy(editorActivationStrategy);
		635	} else {
		636	throw new IllegalStateException(
		637	"This feature is not supported by the widget"); //$NON-NLS-1$
		638	}
		639	}
579	}	640	}

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





package org.eclipse.jface.viewers;


import org.eclipse.core.runtime.ListenerList;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Item;

/**

 * 
 */
public abstract class ColumnViewerEditor {
	private CellEditor cellEditor;

	private CellEditor[] cellEditors;

	private ICellModifier cellModifier;

	private String[] columnProperties;

	private int columnNumber;

	private ICellEditorListener cellEditorListener;

	private FocusListener focusListener;

	private MouseListener mouseListener;

	private int doubleClickExpirationTime;

	private ColumnViewer viewer;
	
	private ListenerList editorActivationListener;
	
	private ColumnViewerEditorActivationSupport editorActivationStrategy;
	
	private ViewerColumn activePart;

	/**
	 * Create a new editor implementation for the viewer

	 */
	public ColumnViewerEditor(ColumnViewer viewer) {
		this.viewer = viewer;
		editorActivationStrategy = new ColumnViewerEditorActivationSupport(viewer,null) {
			protected boolean isEditorActivationEvent(CellEditorActivationEvent event) {
				return event.eventType == CellEditorActivationEvent.MOUSE_CLICK_SELECTION
					|| event.eventType == CellEditorActivationEvent.PROGRAMATIC
					|| event.eventType == CellEditorActivationEvent.TRAVERSAL;
			public void editorValueChanged(boolean oldValidState,
					boolean newValidState) {
				// Ignore.
			}

			public void cancelEditor() {
				ColumnViewerEditor.this.cancelEditing();
			}

			public void applyEditorValue() {
				ColumnViewerEditor.this.applyEditorValue();
			}
		};
	}

	void activateCellEditor() {

		ViewerColumn part = viewer.getViewerColumn(columnNumber);
		Object element = item.getData();

		if (part != null && part.getEditingSupport() != null
				&& part.getEditingSupport().canEdit(element)) {
			cellEditor = part.getEditingSupport().getCellEditor(element);
			if (cellEditor != null) {
				cellEditor.addListener(cellEditorListener);
				Object value = part.getEditingSupport().getValue(element);
				cellEditor.setValue(value);
				// Tricky flow of control here:
				// activate() can trigger callback to cellEditorListener which
				// will clear cellEditor
				// so must get control first, but must still call activate()
				// even if there is no control.
				final Control control = cellEditor.getControl();
				cellEditor.activate();
				if (control == null) {
					return;
				}
				setLayoutData(cellEditor.getLayoutData());
				setEditor(control, item, columnNumber);
				cellEditor.setFocus();
				if (focusListener == null) {
					focusListener = new FocusAdapter() {
						public void focusLost(FocusEvent e) {
							applyEditorValue();
						}
					};
				}
				control.addFocusListener(focusListener);

				mouseListener = new MouseAdapter() {
					public void mouseDown(MouseEvent e) {
						// time wrap?
						// check for expiration of doubleClickTime
						if (e.time <= doubleClickExpirationTime) {
							control.removeMouseListener(mouseListener);
							cancelEditing();
							handleDoubleClickEvent();
						} else if (mouseListener != null) {
							control.removeMouseListener(mouseListener);
						}
					}
				};
				control.addMouseListener(mouseListener);

				if( tabeditingListener == null ) {
					tabeditingListener = new TraverseListener() {

						public void keyTraversed(TraverseEvent e) {
							ViewerColumn col = viewer.getViewerColumn(columnNumber);
							if ( col != null && col.getEditingSupport().isTabingSupported() ) {
								col.getEditingSupport().processTraversEvent(
										columnNumber,
										viewer.getViewerRowFromItem(item), e);
							}
						}
					};
				}
				
				control.addTraverseListener(tabeditingListener);

			protected ViewerCell getFocusCell() {
				return null;
			}
			
		};
		
	}
	
	void cancelEditing() {
		if( activePart != null && activePart.getEditingSupport().isCellEditorActive() ) {
			activePart.getEditingSupport().cancelEditing();
	private void activateCellEditor(MouseEvent event) {
		if (item == null || item.isDisposed()) {
			// item no longer exists
			return;
		}
		int columnToEdit;
		ViewerRow row = viewer.getViewerRowFromItem(item);
		int columns = row.getColumnCount();
		if (columns == 0) {
			// If no TableColumn, Table acts as if it has a single column
			// which takes the whole width.
			columnToEdit = 0;
		} else {
			columnToEdit = -1;
			for (int i = 0; i < columns; i++) {
				Rectangle bounds = row.getBounds(i);
				if (bounds.contains(event.x, event.y)) {
					columnToEdit = i;
					break;
				}
			}
			if (columnToEdit == -1) {
				return;
			}
		}

		columnNumber = columnToEdit;
		activateCellEditor();
	}
	
	/**
	 * Applies the current value and deactivates the currently active cell
	 * editor.
	 */
	void applyEditorValue() {
		if( activePart != null && activePart.getEditingSupport().isCellEditorActive() ) {
			activePart.getEditingSupport().applyEditorValue();
			// null out cell editor before calling save
			// in case save results in applyEditorValue being re-entered
			// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
			// using cell editor ?
			this.cellEditor = null;
			Item t = this.item;
			// don't null out table item -- same item is still selected
			if (t != null && !t.isDisposed()) {
				saveEditorValue(c, t);
			}
			setEditor(null, null, 0);
			c.removeListener(cellEditorListener);
			Control control = c.getControl();
			if (control != null) {
				if (mouseListener != null) {
					control.removeMouseListener(mouseListener);
					// Clear the instance not needed any more
					mouseListener = null;
				}
				if (focusListener != null) {
					control.removeFocusListener(focusListener);
				}

				if (tabeditingListener != null) {
					control.removeTraverseListener(tabeditingListener);
				}
			}
			c.deactivate();
		}
	}
	
	/**
	 * Cancle editing
	 */
	void cancelEditing() {
		if (cellEditor != null) {
			setEditor(null, null, 0);
			cellEditor.removeListener(cellEditorListener);

			Control control = cellEditor.getControl();
			if (control != null) {
				if (mouseListener != null) {
					control.removeMouseListener(mouseListener);
					// Clear the instance not needed any more
					mouseListener = null;
				}
				if (focusListener != null) {
					control.removeFocusListener(focusListener);
				}

				if (tabeditingListener != null) {
					control.removeTraverseListener(tabeditingListener);
				}
			}

			CellEditor oldEditor = cellEditor;
			cellEditor = null;
			oldEditor.deactivate();
		}
	}

	/**
	 * Enable the editor by mouse down
	 * 
	 * @param event
	 */
	void triggerCellEditorActivation(CellEditorActivationEvent event) {
		if( editorActivationStrategy.isEditorActivationEvent(event) ) {
			
			if (activePart != null && activePart.getEditingSupport() != null ) {
				activePart.getEditingSupport().applyEditorValue();
			}
			applyEditorValue();
		}

		// activate the cell editor immediately. If a second mouseDown
		// is received prior to the expiration of the doubleClick time then
		// the cell editor will be deactivated and a doubleClick event will
		// be processed.
		//
		doubleClickExpirationTime = event.time
				+ Display.getCurrent().getDoubleClickTime();

		Item[] items = getSelection();
		// Do not edit if more than one row is selected.
		if (items.length != 1) {
			item = null;
			return;
		}
		item = items[0];
		activateCellEditor(event);
	}

	/**
	 * Start editing the given element.
	 * 
	 * @param element
	 * @param column
	 */
	void editElement(Object element, int column) {
		if (cellEditor != null) {
			applyEditorValue();
		}

		setSelection(createSelection(element), true);
		Item[] selection = getSelection();
		if (selection.length != 1) {
			return;
		}

		item = selection[0];

		// Make sure selection is visible
		showSelection();
		columnNumber = column;
		activateCellEditor();

	}

			ViewerCell cell = (ViewerCell)event.getSource();			
			ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());

			if (part != null && part.getEditingSupport() != null ) {
				part.getEditingSupport().activateCellEditor(this,event);
			}
		}
	}


	 *         <code>false</code> is returned.
	 */
	boolean isCellEditorActive() {
		return activePart != null && activePart.getEditingSupport() != null && activePart.getEditingSupport().isCellEditorActive();
	}

	/**

		return cellEditors;
	}

	void setSelection(StructuredSelection selection, boolean b) {
		viewer.setSelection(selection, b);
	}

	void handleDoubleClickEvent() {
		viewer.fireDoubleClick(new DoubleClickEvent(viewer, viewer
				.getSelection()));
		viewer.fireOpen(new OpenEvent(viewer, viewer.getSelection()));
	}

	void addEditorActivationListener(CellEditorActivationListener listener) {
		if( editorActivationListener == null ) {
			editorActivationListener = new ListenerList();
		}
		editorActivationListener.add(listener);
	}
	
	void removeEditorActivationListener(CellEditorActivationListener listener) {
		if( editorActivationListener != null ) {
			editorActivationListener.remove(listener);
		}
	}
	
	ListenerList getEditorActivationListeners() {
		return editorActivationListener;
	}
	
	void setEditorActivationStrategy(
			ColumnViewerEditorActivationSupport editorActivationStrategy) {
		this.editorActivationStrategy = editorActivationStrategy;
	}
	
	/**
	 * Create a selection for this model element
	 * 

	 *            the layout data used when editor is displayed
	 */
	protected abstract void setLayoutData(CellEditor.LayoutData layoutData);
}
	/**
	 * Show up the current selection (scroll the selection into view)
	 */
	protected abstract void showSelection();

	/**
	 * @return the current selection
	 */
	protected abstract Item[] getSelection();
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import java.util.EventObject;

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

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

	/**
	 * Cancle the event
	 */
	public boolean doIt = true;
	
	/**
	 * @param source
	 */
	public CellEditorDeactivationEvent(Object source) {
		super(source);
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;

/**
 * This class is responsible to determin if a cell selection event is triggers
 * an editor activation
 * 
 * @since 3.3
 */
public class ColumnViewerEditorActivationSupport {
	/**
	 * Enable editor activation using the keyboard 
	 */
	public static final int WITH_KEYBOARD_ACTIVATION = 1;
	
	private ColumnViewer viewer;
	
	private KeyListener keyboardActivationListener;
	
	private CellSupport cellSupport;
	
	/**
	 * @param viewer the viewer the editor support is attached to
	 */
	public ColumnViewerEditorActivationSupport(ColumnViewer viewer) {
		this(viewer,null);
	}
	
	/**
	 * @param viewer the viewer the editor support is attached to
	 * @param cellSupport the cell support or <code>null</code> if there's none
	 */
	public ColumnViewerEditorActivationSupport(ColumnViewer viewer, CellSupport cellSupport) {
		this(viewer,cellSupport,SWT.NONE);
	}
	
	/**
	 * @param viewer the viewer the editor support is attached to
	 * @param cellSupport the cell support or <code>null</code> if there's none
	 * @param feature the feature bits used to turn on features easily ({@link #WITH_KEYBOARD_ACTIVATION})
	 */
	public ColumnViewerEditorActivationSupport(ColumnViewer viewer, CellSupport cellSupport, int feature) {
		this.viewer = viewer;
		this.cellSupport = cellSupport;
		if( (feature & WITH_KEYBOARD_ACTIVATION) == WITH_KEYBOARD_ACTIVATION ) {
			setEnableEditorActivationWithKeyboard(true);
		}
	}
	
	/**
	 * @return the cell holding the current focus
	 */
	protected ViewerCell getFocusCell() {
		if( cellSupport != null ) {
			return cellSupport.getFocusCell();
		}
		
		return null;
	}
	
	/**
	 * @param event
	 * @return <code>true</code> if the this event triggers editor activation
	 */
	protected boolean isEditorActivationEvent(CellEditorActivationEvent event) {
		return event.eventType == CellEditorActivationEvent.TRAVERSAL || event.eventType == CellEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || event.eventType == CellEditorActivationEvent.PROGRAMATIC;
	}
	
	/**
	 * @return the viewer
	 */
	public ColumnViewer getViewer() {
		return viewer;
	}
	
	/**
	 * Enable activation of cell editors by keyboard
	 * @param enable <code>true</code> to enable
	 */
	public void setEnableEditorActivationWithKeyboard(boolean enable) {
		if( enable ) {
			if( keyboardActivationListener == null ) {
				keyboardActivationListener = new KeyListener() {

					public void keyPressed(KeyEvent e) {
						ViewerCell cell = getFocusCell();
						
						if( cell != null ) {
							viewer.triggerCellEditorActivation(new CellEditorActivationEvent(cell,e));
						}
					}

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




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

/**
 * Implementors of this class are responsible to highlight the selected cell and
 * to remove the highlighting of cells who are not selected
 * 
 * @since 3.3
 * 
 */
public abstract class FocusCellHighlighter {
	private CellSupport cellSupport;
	
	private ColumnViewer viewer;

	/**
	 * @param viewer
	 */
	public FocusCellHighlighter(ColumnViewer viewer) {
		this.viewer = viewer;
	}
	
	/**
	 * @param cellSupport associate the cell support with this class
	 */
	protected void setCellSupport(CellSupport cellSupport) {
		this.cellSupport = cellSupport;
	}

	/**
	 * @return the viewer
	 */
	public ColumnViewer getViewer() {
		return viewer;
	}
	
	/**
	 * @return the cell currently holding the focus
	 */
	protected ViewerCell getFocusCell() {
		return cellSupport.getFocusCell();
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

/**
 * @since 3.3
 * 
 */
public abstract class FocusCellChangeListener {
	/**
	 * @param event
	 *            the event informing about the selection of a cell
	 */
	public abstract void handleFocusCellChange(FocusCellChangeEvent event);
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import java.util.EventObject;

/**
 * @since 3.3
 * 
 */
public class FocusCellChangeEvent extends EventObject {

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

	/**
	 * the cell who recevied the focus
	 */
	public ViewerCell focusCell;
	
	/**
	 * the cell who lost the focus
	 */
	public ViewerCell focusLostCell;
	
	/**
	 * @param viewer
	 *            the viewer
	 * @param focusCell
	 *            the cell who recevied the focus
	 * @param focusLostCell
	 *            the cell who lost the focus
	 */
	public FocusCellChangeEvent(ColumnViewer viewer, ViewerCell focusCell,
			ViewerCell focusLostCell) {
		super(viewer);
		this.focusCell=focusCell;
		this.focusLostCell=focusLostCell;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.core.runtime.Assert;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

/**
 * @since 3.3
 * 
 */
public class FocusCellOwnerDrawHighlighter extends FocusCellHighlighter {
	
	/**
	 * @param viewer the viewer
	 */
	public FocusCellOwnerDrawHighlighter(ColumnViewer viewer) {
		super(viewer);
		hookListener(viewer);
	}
	
	private void markFocusedCell(Event event,
			ViewerCell cell) {
		Color background = getSelectedCellBackgroundColor(cell);
		Color foreground = getSelectedCellForegroundColor(cell);

		if (foreground != null || background != null) {
			GC gc = event.gc;

			if (background == null) {
				background = cell.getItem().getDisplay().getSystemColor(
						SWT.COLOR_LIST_SELECTION);
			}

			if (foreground == null) {
				foreground = cell.getItem().getDisplay().getSystemColor(
						SWT.COLOR_LIST_SELECTION_TEXT);
			}

			gc.setBackground(background);
			gc.setForeground(foreground);
			gc.fillRectangle(event.getBounds());
			
			// This is a workaround for an SWT-Bug on WinXP bug 169517
			gc.drawText(" ", cell.getBounds().x, cell.getBounds().y, false); //$NON-NLS-1$
			event.detail &= ~SWT.SELECTED;
		}
	}

	private void removeSelectionInformation(Event event,
			ViewerCell cell) {
		GC gc = event.gc;
		gc.setBackground(cell.getViewerRow().getBackground(
				cell.getColumnIndex()));
		gc.setForeground(cell.getViewerRow().getForeground(
				cell.getColumnIndex()));
		gc.fillRectangle(cell.getBounds());
		// This is a workaround for an SWT-Bug on WinXP bug 169517
		gc.drawText(" ", cell.getBounds().x, cell.getBounds().y, false); //$NON-NLS-1$
		event.detail &= ~SWT.SELECTED;
	}

	private void hookListener(final ColumnViewer viewer) {
		
		Listener listener = new Listener() {

			public void handleEvent(Event event) {
				if((event.detail & SWT.SELECTED) > 0 ) {
					ViewerCell focusCell = getFocusCell();
					ViewerRow row = viewer.getViewerRowFromItem(event.item);
					
					Assert.isNotNull(row, "Internal structure invalid. Item without associated row is not possible."); //$NON-NLS-1$
					
					ViewerCell cell = row.getCell(event.index);
										
					if (focusCell == null || ! cell.equals(focusCell)) {
						removeSelectionInformation(event, cell);
					} else {
						markFocusedCell(event,cell);
					}
				}
			}
			
		};
		viewer.getControl().addListener(SWT.EraseItem, listener);
	}

	/**
	 * @param cell
	 *            the cell which is colored
	 * @return the color
	 */
	protected Color getSelectedCellBackgroundColor(ViewerCell cell) {
		return null;
	}

	/**
	 * @param cell
	 *            the cell which is colored
	 * @return the color
	 */
	protected Color getSelectedCellForegroundColor(ViewerCell cell) {
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.core.runtime.Assert;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.TreeItem;

/**
 * @since 3.3
 * 
 */
public final class SWTCellSupport extends CellSupport {
	private static final CellNavigationStrategy TABLE_NAVIGATE = new CellNavigationStrategy();

	private static final CellNavigationStrategy TREE_NAVIGATE = new CellNavigationStrategy() {
		public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,
				Event event) {
			if (cellToCollapse != null) {
				((TreeItem) cellToCollapse.getItem()).setExpanded(false);
			}
		}

		public void expand(ColumnViewer viewer, ViewerCell cellToExpand,
				Event event) {
			if (cellToExpand != null) {
				TreeViewer v = (TreeViewer) viewer;
				v.setExpandedState(v
						.getTreePathFromItem(cellToExpand.getItem()), true);
			}
		}

		public boolean isCollapseEvent(ColumnViewer viewer,
				ViewerCell cellToCollapse, Event event) {
			return cellToCollapse != null
					&& ((TreeItem) cellToCollapse.getItem()).getExpanded()
					&& cellToCollapse.getColumnIndex() == 0
					&& event.keyCode == SWT.ARROW_LEFT;
		}

		public boolean isExpandEvent(ColumnViewer viewer,
				ViewerCell cellToExpand, Event event) {
			return cellToExpand != null
					&& ((TreeItem) cellToExpand.getItem()).getItemCount() > 0
					&& !((TreeItem) cellToExpand.getItem()).getExpanded()
					&& cellToExpand.getColumnIndex() == 0
					&& event.keyCode == SWT.ARROW_RIGHT;
		}
	};

	private CellNavigationStrategy navigationDelegate;
	
	/**
	 * @param viewer
	 * @param focusDrawingDelegate
	 */
	public SWTCellSupport(TableViewer viewer,
			FocusCellHighlighter focusDrawingDelegate) {
		this(viewer, focusDrawingDelegate, TABLE_NAVIGATE);
	}

	/**
	 * @param viewer
	 * @param focusDrawingDelegate
	 */
	public SWTCellSupport(TreeViewer viewer,
			FocusCellHighlighter focusDrawingDelegate) {
		this(viewer, focusDrawingDelegate, TREE_NAVIGATE);
	}

	private SWTCellSupport(ColumnViewer viewer,
			FocusCellHighlighter focusDrawingDelegate,
			CellNavigationStrategy navigationDelegate) {
		super(viewer);
		if (viewer != focusDrawingDelegate.getViewer()) {
			throw new IllegalArgumentException(
					"The FocusCellHighlighter passed is not working for the same ColumnViewer than SWTCellSupport"); //$NON-NLS-1$
		}

		this.navigationDelegate = navigationDelegate;
		focusDrawingDelegate.setCellSupport(this);
	}

	private void handleMouseDown(Event event) {
		ViewerCell cell = getViewer().getCell(new Point(event.x, event.y));
		if (cell != null) {
			if( fireFocusCellChanged(new FocusCellChangeEvent(getViewer(), cell,
					getFocusCell()))) {
				getViewer().getControl().redraw();
			}
		}
	}

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

		if (navigationDelegate.isCollapseEvent(getViewer(), focusCell, event)) {
			navigationDelegate.collapse(getViewer(), focusCell, event);
		} else if (navigationDelegate.isExpandEvent(getViewer(), focusCell,
				event)) {
			navigationDelegate.expand(getViewer(), focusCell, event);
		} else if (navigationDelegate.isNavigationEvent(getViewer(), event)) {
			tmp = navigationDelegate.findSelectedCell(getViewer(), focusCell,event);
			
			if (tmp != null) {
				if( fireFocusCellChanged(new FocusCellChangeEvent(getViewer(),tmp,focusCell)) ) {
					getViewer().getControl().redraw();
				}
			}
		}

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

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

	protected void hookListener(ColumnViewer viewer) {
		Listener listener = new Listener() {

			public void handleEvent(Event event) {
				if (event.type == SWT.MouseDown) {
					handleMouseDown(event);
				} else if (event.type == SWT.KeyDown) {
					handleKeyDown(event);
				} else {
					handleSelection(event);
				}
			}
		};

		viewer.getControl().addListener(SWT.MouseDown, listener);
		viewer.getControl().addListener(SWT.KeyDown, listener);
		viewer.getControl().addListener(SWT.Selection, listener);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;

/**
 * @since 3.3
 * 
 */
public class CellNavigationStrategy {
	/**
	 * is the given event an event which moves the selection to another cell
	 * 
	 * @param viewer
	 *            the viewer we are working for
	 * 
	 * @param event
	 *            the key event
	 * @return <code>true</code> if a new cell is searched
	 */
	public boolean isNavigationEvent(ColumnViewer viewer, Event event) {
		switch (event.keyCode) {
		case SWT.ARROW_UP:
		case SWT.ARROW_DOWN:
		case SWT.ARROW_LEFT:
		case SWT.ARROW_RIGHT:
		case SWT.HOME:
		case SWT.PAGE_DOWN:
		case SWT.PAGE_UP:
		case SWT.END:
			return true;
		default:
			return false;
		}
	}

	/**
	 * @param viewer
	 *            the viewer we are working for
	 * @param cellToCollapse the cell to collapse
	 * @param event
	 *            the key event
	 * @return <code>true</code> if this event triggers collapsing of a node
	 */
	public boolean isCollapseEvent(ColumnViewer viewer, ViewerCell cellToCollapse, Event event) {
		return false;
	}

	/**
	 * @param viewer
	 *            the viewer we are working for
	 * @param cellToExpand the cell to expand
	 * @param event
	 *            the key event
	 * @return <code>true</code> if this event triggers expanding of a node
	 */
	public boolean isExpandEvent(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {
		return false;
	}

	/**
	 * @param viewer
	 *            the viewer working for
	 * @param cellToExpand
	 *            the cell the user wants to expand
	 * @param event
	 *            the event triggering the exansion
	 */
	public void expand(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {

	}

	/**
	 * @param viewer
	 *            the viewer working for
	 * @param cellToCollapse
	 *            the cell the user wants to collapse
	 * @param event
	 *            the event triggering the exansion
	 */
	public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,
			Event event) {

	}

	/**
	 * @param viewer
	 *            the viewer we are working for
	 * @param currentSelectedCell
	 *            the cell currently selected
	 * @param event
	 *            the key event
	 * @return the cell which is highlighted next or <code>null</code> if the
	 *         default implementation is taken. E.g. it's fairly impossible to
	 *         react on PAGE_DOWN requests
	 */
	public ViewerCell findSelectedCell(ColumnViewer viewer,
			ViewerCell currentSelectedCell, Event event) {

		switch (event.keyCode) {
		case SWT.ARROW_UP:
			if (currentSelectedCell != null) {
				return currentSelectedCell.getNeighbor(ViewerCell.ABOVE, false);
			}
			break;
		case SWT.ARROW_DOWN:
			if (currentSelectedCell != null) {
				return currentSelectedCell.getNeighbor(ViewerCell.BELOW, false);
			}
			break;
		case SWT.ARROW_LEFT:
			if (currentSelectedCell != null) {
				return currentSelectedCell.getNeighbor(ViewerCell.LEFT, true);
			}
			break;
		case SWT.ARROW_RIGHT:
			if (currentSelectedCell != null) {
				return currentSelectedCell.getNeighbor(ViewerCell.RIGHT, true);
			}
			break;
		}

		return null;
	}

	/**
	 * This method is consulted to decide whether an event has to be cancled or
	 * not. By default events who collapse/expand tree-nodes are cancled
	 * 
	 * @param viewer
	 *            the viewer working for
	 * @param event
	 *            the event
	 * @return <code>true</code> if the event has to be cancled
	 */
	public boolean cancleEvent(ColumnViewer viewer, Event event) {
		return event.keyCode == SWT.ARROW_LEFT
				|| event.keyCode == SWT.ARROW_RIGHT;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

/**
 * Parties interested in activation and deactivation of editors extend this
 * class and implement any or all of the methods
 * 
 * @since 3.3
 * 
 */
public abstract class CellEditorActivationListener {
	/**
	 * Called before an editor is activated
	 * 
	 * @param event
	 *            the event
	 */
	public abstract void beforeEditorActivated(CellEditorActivationEvent event);

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

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

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




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.core.runtime.ListenerList;

/**
 * @since 3.3
 * 
 */
public abstract class CellSupport {
	private ListenerList focusCellChangedListeners = new ListenerList();

	private ViewerCell focusCell;

	private ColumnViewer viewer;

	/**
	 * @param viewer
	 *            the viewer who requests cell support
	 */
	public CellSupport(ColumnViewer viewer) {
		this.viewer = viewer;
		hookListener(viewer);
	}

	/**
	 * @param viewer
	 *            hook listeners into the viewer
	 */
	protected abstract void hookListener(ColumnViewer viewer);

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

	/**
	 * @param listener
	 *            the listener to be added
	 */
	public void addFocusCellChangedListener(FocusCellChangeListener listener) {
		focusCellChangedListeners.add(listener);
	}

	/**
	 * @param listener
	 *            the listener to be removed
	 */
	public void removeFocusCellChangedListener(FocusCellChangeListener listener) {
		focusCellChangedListeners.remove(listener);
	}

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

	/**
	 * @param event
	 *            inform listeners about the selection
	 * @return has this really been an change event
	 */
	protected boolean fireFocusCellChanged(FocusCellChangeEvent event) {
		if (event.focusCell.equals(event.focusLostCell)) {
			return false;
		}

		this.focusCell = event.focusCell;

		Object[] ls = focusCellChangedListeners.getListeners();

		for (int i = 0; i < ls.length; i++) {
			((FocusCellChangeListener) ls[i]).handleFocusCellChange(event);
		}
		return true;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

import java.util.EventObject;

import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.TraverseEvent;

/**
 * This event is passed on when a cell-editor is going to be activated
 * 
 * @since 3.3
 * 
 */
public class CellEditorActivationEvent extends EventObject {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	/**
	 * if a key is pressed on a selected cell
	 */
	public static final int KEY_PRESSED = 1;

	/**
	 * if a cell is selected using a single click of the mouse
	 */
	public static final int MOUSE_CLICK_SELECTION = 2;

	/**
	 * if a cell is selected using double clicking of the mouse
	 */
	public static final int MOUSE_DOUBLE_CLICK_SELECTION = 3;

	/**
	 * if a cell is activated using code like e.g
	 * {@link ColumnViewer#editElement(Object, int)}
	 */
	public static final int PROGRAMATIC = 4;

	/**
	 * is a cell is activated by traversing
	 */
	public static final int TRAVERSAL = 5;

	/**
	 * the original event triggered
	 */
	public EventObject sourceEvent;

	/**
	 * The time the event is triggered
	 */
	public int time;

	/**
	 * The event type triggered:
	 * <ul>
	 * <li>{@link #KEY_PRESSED} if a key is pressed on a selected cell</li>
	 * <li>{@link #MOUSE_CLICK_SELECTION} if a cell is selected using a single
	 * click of the mouse</li>
	 * <li>{@link #MOUSE_DOUBLE_CLICK_SELECTION} if a cell is selected using
	 * double clicking of the mouse</li>
	 * </ul>
	 */
	public int eventType;

	/**
	 * <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 doIt = true;
	
	/**
	 * This constructor can be used when no event exists. The type set is
	 * {@link #PROGRAMATIC}
	 * 
	 * @param cell
	 *            the cell
	 */
	public CellEditorActivationEvent(ViewerCell cell) {
		super(cell);
		eventType = PROGRAMATIC;
	}

	/**
	 * This constructor is used for all types of mouse events. Currently the
	 * type is can be {@link #MOUSE_CLICK_SELECTION} and
	 * {@link #MOUSE_DOUBLE_CLICK_SELECTION}
	 * 
	 * @param cell
	 *            the cell source of the event
	 * @param event
	 *            the event
	 */
	public CellEditorActivationEvent(ViewerCell cell, MouseEvent event) {
		super(cell);

		if (event.count >= 2) {
			eventType = MOUSE_DOUBLE_CLICK_SELECTION;
		} else {
			eventType = MOUSE_CLICK_SELECTION;
		}

		this.sourceEvent = event;
		this.time = event.time;
	}

	/**
	 * @param cell
	 *            the cell source of the event
	 * @param event
	 *            the event
	 */
	public CellEditorActivationEvent(ViewerCell cell, KeyEvent event) {
		super(cell);
		this.eventType = KEY_PRESSED;
		this.sourceEvent = event;
		this.time = 0;
		this.keyCode = event.keyCode;
		this.character = event.character;
		this.stateMask = event.stateMask;
	}

	/**
	 * This constructur is used to mark the activation triggered by a traversal
	 * 
	 * @param cell
	 *            the cell source of the event
	 * @param event
	 *            the event
	 */
	public CellEditorActivationEvent(ViewerCell cell, TraverseEvent event) {
		super(cell);
		this.eventType = TRAVERSAL;
		this.sourceEvent = event;
	}
}

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.ColumnViewerEditorActivationSupport;
import org.eclipse.jface.viewers.ViewerCell;

public class GridViewerEditorActivationSupport extends ColumnViewerEditorActivationSupport {
	public GridViewerEditorActivationSupport(GridViewer viewer) {
		super(viewer,null);
	}
	
	protected ViewerCell getFocusCell() {
		return ((GridViewer)getViewer()).getFocusCell();
	}
}




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




/*******************************************************************************
 * Copyright (c) 2006 Tom Schindl and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Tom Schindl - initial API and implementation
 *******************************************************************************/

package org.eclipse.jface.snippets.viewers;

import java.util.ArrayList;

import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.CellEditorActivationEvent;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationSupport;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SWTCellSupport;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**
 * A simple TreeViewer to demonstrate usage
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * 
 */
public class Snippet026TreeViewerTabEditing {
	public Snippet026TreeViewerTabEditing(final Shell shell) {
		final TreeViewer v = new TreeViewer(shell, SWT.BORDER
				| SWT.FULL_SELECTION);
		v.getTree().setLinesVisible(true);
		v.getTree().setHeaderVisible(true);

		SWTCellSupport cellSupport = new SWTCellSupport(v,
				new FocusCellOwnerDrawHighlighter(v));
		ColumnViewerEditorActivationSupport actSupport = new ColumnViewerEditorActivationSupport(
				v, cellSupport) {

			protected boolean isEditorActivationEvent(
					CellEditorActivationEvent event) {
				return event.eventType == CellEditorActivationEvent.TRAVERSAL
						|| event.eventType == CellEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION
						|| (event.eventType == CellEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR)
						|| event.eventType == CellEditorActivationEvent.PROGRAMATIC;
			}

		};
		actSupport.setEnableEditorActivationWithKeyboard(true);

		v.setEditorActivationSupport(actSupport);

		final TextCellEditor textCellEditor = new TextCellEditor(v.getTree());

		TreeViewerColumn column = new TreeViewerColumn(v, SWT.NONE);
		column.getColumn().setWidth(200);
		column.getColumn().setText("Column 1");
		column.setLabelProvider(new ColumnLabelProvider() {

			public String getText(Object element) {
				return "Column 1 => " + element.toString();
			}

		});
		column.setEditingSupport(new EditingSupport(v) {
			protected boolean canEdit(Object element) {
				return true;
			}

			protected CellEditor getCellEditor(Object element) {
				return textCellEditor;
			}

			protected Object getValue(Object element) {
				return ((MyModel) element).counter + "";
			}

			protected void setValue(Object element, Object value) {
				((MyModel) element).counter = Integer
						.parseInt(value.toString());
				v.update(element, null);
			}
		});
		v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL
				| EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR
				| EditingSupport.TABBING_VERTICAL);

		column = new TreeViewerColumn(v, SWT.NONE);
		column.getColumn().setWidth(200);
		column.getColumn().setText("Column 2");
		column.setLabelProvider(new ColumnLabelProvider() {

			public String getText(Object element) {
				return "Column 2 => " + element.toString();
			}

		});
		
		v.setContentProvider(new MyContentProvider());

		v.setInput(createModel());
	}

	private MyModel createModel() {

		MyModel root = new MyModel(0, null);
		root.counter = 0;

		MyModel tmp;
		MyModel subItem;
		for (int i = 1; i < 10; i++) {
			tmp = new MyModel(i, root);
			root.child.add(tmp);
			for (int j = 1; j < i; j++) {
				subItem = new MyModel(j, tmp);
				subItem.child.add(new MyModel(j * 100, subItem));
				tmp.child.add(subItem);
			}
		}

		return root;
	}

	public static void main(String[] args) {
		Display display = new Display();
		Shell shell = new Shell(display);
		shell.setLayout(new FillLayout());
		new Snippet026TreeViewerTabEditing(shell);
		shell.open();

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

		display.dispose();
	}

	private class MyContentProvider implements ITreeContentProvider {

		public Object[] getElements(Object inputElement) {
			return ((MyModel) inputElement).child.toArray();
		}

		public void dispose() {
		}

		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		}

		public Object[] getChildren(Object parentElement) {
			return getElements(parentElement);
		}

		public Object getParent(Object element) {
			if (element == null) {
				return null;
			}
			return ((MyModel) element).parent;
		}

		public boolean hasChildren(Object element) {
			return ((MyModel) element).child.size() > 0;
		}

	}

	public class MyModel {
		public MyModel parent;

		public ArrayList child = new ArrayList();

		public int counter;

		public MyModel(int counter, MyModel parent) {
			this.parent = parent;
			this.counter = counter;
		}

		public String toString() {
			String rv = "Item ";
			if (parent != null) {
				rv = parent.toString() + ".";
			}

			rv += counter;

			return rv;
		}
	}

}

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

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.CellEditorActivationEvent;
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.GridViewerEditorActivationSupport;
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	GridViewerEditorActivationSupport support = new GridViewerEditorActivationSupport(v) {
154	protected boolean isEditorActivationEvent(
155	CellEditorActivationEvent event) {
156	return event.eventType == CellEditorActivationEvent.TRAVERSAL \|\| event.eventType == CellEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION \|\| ( event.eventType == CellEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR ) \|\| event.eventType == CellEditorActivationEvent.PROGRAMATIC;
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	}

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/ColumnViewerEditorActivationSupport.java (+121 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.SWT;
15	import org.eclipse.swt.events.KeyEvent;
16	import org.eclipse.swt.events.KeyListener;
17
18	/**
19	* This class is responsible to determin if a cell selection event is triggers
20	* an editor activation
21	*
22	* @since 3.3
23	*/
24	public class ColumnViewerEditorActivationSupport {
25	/**
26	* Enable editor activation using the keyboard
27	*/
28	public static final int WITH_KEYBOARD_ACTIVATION = 1;
29
30	private ColumnViewer viewer;
31
32	private KeyListener keyboardActivationListener;
33
34	private CellSupport cellSupport;
35
36	/**
37	* @param viewer the viewer the editor support is attached to
38	*/
39	public ColumnViewerEditorActivationSupport(ColumnViewer viewer) {
40	this(viewer,null);
41	}
42
43	/**
44	* @param viewer the viewer the editor support is attached to
45	* @param cellSupport the cell support or <code>null</code> if there's none
46	*/
47	public ColumnViewerEditorActivationSupport(ColumnViewer viewer, CellSupport cellSupport) {
48	this(viewer,cellSupport,SWT.NONE);
49	}
50
51	/**
52	* @param viewer the viewer the editor support is attached to
53	* @param cellSupport the cell support or <code>null</code> if there's none
54	* @param feature the feature bits used to turn on features easily ({@link #WITH_KEYBOARD_ACTIVATION})
55	*/
56	public ColumnViewerEditorActivationSupport(ColumnViewer viewer, CellSupport cellSupport, int feature) {
57	this.viewer = viewer;
58	this.cellSupport = cellSupport;
59	if( (feature & WITH_KEYBOARD_ACTIVATION) == WITH_KEYBOARD_ACTIVATION ) {
60	setEnableEditorActivationWithKeyboard(true);
61	}
62	}
63
64	/**
65	* @return the cell holding the current focus
66	*/
67	protected ViewerCell getFocusCell() {
68	if( cellSupport != null ) {
69	return cellSupport.getFocusCell();
70	}
71
72	return null;
73	}
74
75	/**
76	* @param event
77	* @return <code>true</code> if the this event triggers editor activation
78	*/
79	protected boolean isEditorActivationEvent(CellEditorActivationEvent event) {
80	return event.eventType == CellEditorActivationEvent.TRAVERSAL \|\| event.eventType == CellEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION \|\| event.eventType == CellEditorActivationEvent.PROGRAMATIC;
81	}
82
83	/**
84	* @return the viewer
85	*/
86	public ColumnViewer getViewer() {
87	return viewer;
88	}
89
90	/**
91	* Enable activation of cell editors by keyboard
92	* @param enable <code>true</code> to enable
93	*/
94	public void setEnableEditorActivationWithKeyboard(boolean enable) {
95	if( enable ) {
96	if( keyboardActivationListener == null ) {
97	keyboardActivationListener = new KeyListener() {
98
99	public void keyPressed(KeyEvent e) {
100	ViewerCell cell = getFocusCell();
101
102	if( cell != null ) {
103	viewer.triggerCellEditorActivation(new CellEditorActivationEvent(cell,e));
104	}
105	}
106
107	public void keyReleased(KeyEvent e) {
108
109	}
110
111	};
112	viewer.getControl().addKeyListener(keyboardActivationListener);
113	}
114	} else {
115	if( keyboardActivationListener != null ) {
116	viewer.getControl().removeKeyListener(keyboardActivationListener);
117	keyboardActivationListener = null;
118	}
119	}
120	}
121	}

Added Link Here

(-)src/org/eclipse/jface/viewers/FocusCellHighlighter.java (+53 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	/**
15	* Implementors of this class are responsible to highlight the selected cell and
16	* to remove the highlighting of cells who are not selected
17	*
18	* @since 3.3
19	*
20	*/
21	public abstract class FocusCellHighlighter {
22	private CellSupport cellSupport;
23
24	private ColumnViewer viewer;
25
26	/**
27	* @param viewer
28	*/
29	public FocusCellHighlighter(ColumnViewer viewer) {
30	this.viewer = viewer;
31	}
32
33	/**
34	* @param cellSupport associate the cell support with this class
35	*/
36	protected void setCellSupport(CellSupport cellSupport) {
37	this.cellSupport = cellSupport;
38	}
39
40	/**
41	* @return the viewer
42	*/
43	public ColumnViewer getViewer() {
44	return viewer;
45	}
46
47	/**
48	* @return the cell currently holding the focus
49	*/
50	protected ViewerCell getFocusCell() {
51	return cellSupport.getFocusCell();
52	}
53	}

Added Link Here

(-)src/org/eclipse/jface/viewers/SWTCellSupport.java (+159 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.core.runtime.Assert;
15	import org.eclipse.swt.SWT;
16	import org.eclipse.swt.graphics.Point;
17	import org.eclipse.swt.widgets.Event;
18	import org.eclipse.swt.widgets.Listener;
19	import org.eclipse.swt.widgets.TreeItem;
20
21	/**
22	* @since 3.3
23	*
24	*/
25	public final class SWTCellSupport extends CellSupport {
26	private static final CellNavigationStrategy TABLE_NAVIGATE = new CellNavigationStrategy();
27
28	private static final CellNavigationStrategy TREE_NAVIGATE = new CellNavigationStrategy() {
29	public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,
30	Event event) {
31	if (cellToCollapse != null) {
32	((TreeItem) cellToCollapse.getItem()).setExpanded(false);
33	}
34	}
35
36	public void expand(ColumnViewer viewer, ViewerCell cellToExpand,
37	Event event) {
38	if (cellToExpand != null) {
39	TreeViewer v = (TreeViewer) viewer;
40	v.setExpandedState(v
41	.getTreePathFromItem(cellToExpand.getItem()), true);
42	}
43	}
44
45	public boolean isCollapseEvent(ColumnViewer viewer,
46	ViewerCell cellToCollapse, Event event) {
47	return cellToCollapse != null
48	&& ((TreeItem) cellToCollapse.getItem()).getExpanded()
49	&& cellToCollapse.getColumnIndex() == 0
50	&& event.keyCode == SWT.ARROW_LEFT;
51	}
52
53	public boolean isExpandEvent(ColumnViewer viewer,
54	ViewerCell cellToExpand, Event event) {
55	return cellToExpand != null
56	&& ((TreeItem) cellToExpand.getItem()).getItemCount() > 0
57	&& !((TreeItem) cellToExpand.getItem()).getExpanded()
58	&& cellToExpand.getColumnIndex() == 0
59	&& event.keyCode == SWT.ARROW_RIGHT;
60	}
61	};
62
63	private CellNavigationStrategy navigationDelegate;
64
65	/**
66	* @param viewer
67	* @param focusDrawingDelegate
68	*/
69	public SWTCellSupport(TableViewer viewer,
70	FocusCellHighlighter focusDrawingDelegate) {
71	this(viewer, focusDrawingDelegate, TABLE_NAVIGATE);
72	}
73
74	/**
75	* @param viewer
76	* @param focusDrawingDelegate
77	*/
78	public SWTCellSupport(TreeViewer viewer,
79	FocusCellHighlighter focusDrawingDelegate) {
80	this(viewer, focusDrawingDelegate, TREE_NAVIGATE);
81	}
82
83	private SWTCellSupport(ColumnViewer viewer,
84	FocusCellHighlighter focusDrawingDelegate,
85	CellNavigationStrategy navigationDelegate) {
86	super(viewer);
87	if (viewer != focusDrawingDelegate.getViewer()) {
88	throw new IllegalArgumentException(
89	"The FocusCellHighlighter passed is not working for the same ColumnViewer than SWTCellSupport"); //$NON-NLS-1$
90	}
91
92	this.navigationDelegate = navigationDelegate;
93	focusDrawingDelegate.setCellSupport(this);
94	}
95
96	private void handleMouseDown(Event event) {
97	ViewerCell cell = getViewer().getCell(new Point(event.x, event.y));
98	if (cell != null) {
99	if( fireFocusCellChanged(new FocusCellChangeEvent(getViewer(), cell,
100	getFocusCell()))) {
101	getViewer().getControl().redraw();
102	}
103	}
104	}
105
106	private void handleKeyDown(Event event) {
107	ViewerCell focusCell = getFocusCell();
108	ViewerCell tmp = null;
109
110	if (navigationDelegate.isCollapseEvent(getViewer(), focusCell, event)) {
111	navigationDelegate.collapse(getViewer(), focusCell, event);
112	} else if (navigationDelegate.isExpandEvent(getViewer(), focusCell,
113	event)) {
114	navigationDelegate.expand(getViewer(), focusCell, event);
115	} else if (navigationDelegate.isNavigationEvent(getViewer(), event)) {
116	tmp = navigationDelegate.findSelectedCell(getViewer(), focusCell,event);
117
118	if (tmp != null) {
119	if( fireFocusCellChanged(new FocusCellChangeEvent(getViewer(),tmp,focusCell)) ) {
120	getViewer().getControl().redraw();
121	}
122	}
123	}
124
125	if (navigationDelegate.cancleEvent(getViewer(), event)) {
126	event.doit = false;
127	}
128	}
129
130	private void handleSelection(Event event) {
131	ViewerCell focusCell = getFocusCell();
132	if( focusCell != null && focusCell.getItem() != event.item && event.item != null ) {
133	ViewerRow row = getViewer().getViewerRowFromItem(event.item);
134	Assert.isNotNull(row,"Internal Structure invalid. Row item has no row ViewerRow assigned"); //$NON-NLS-1$
135	if( fireFocusCellChanged(new FocusCellChangeEvent(getViewer(),row.getCell(focusCell.getColumnIndex()),focusCell)) ) {
136	getViewer().getControl().redraw();
137	}
138	}
139	}
140
141	protected void hookListener(ColumnViewer viewer) {
142	Listener listener = new Listener() {
143
144	public void handleEvent(Event event) {
145	if (event.type == SWT.MouseDown) {
146	handleMouseDown(event);
147	} else if (event.type == SWT.KeyDown) {
148	handleKeyDown(event);
149	} else {
150	handleSelection(event);
151	}
152	}
153	};
154
155	viewer.getControl().addListener(SWT.MouseDown, listener);
156	viewer.getControl().addListener(SWT.KeyDown, listener);
157	viewer.getControl().addListener(SWT.Selection, listener);
158	}
159	}

Added Link Here

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

Added Link Here

(-)src/org/eclipse/jface/viewers/CellSupport.java (+91 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.core.runtime.ListenerList;
15
16	/**
17	* @since 3.3
18	*
19	*/
20	public abstract class CellSupport {
21	private ListenerList focusCellChangedListeners = new ListenerList();
22
23	private ViewerCell focusCell;
24
25	private ColumnViewer viewer;
26
27	/**
28	* @param viewer
29	* the viewer who requests cell support
30	*/
31	public CellSupport(ColumnViewer viewer) {
32	this.viewer = viewer;
33	hookListener(viewer);
34	}
35
36	/**
37	* @param viewer
38	* hook listeners into the viewer
39	*/
40	protected abstract void hookListener(ColumnViewer viewer);
41
42	/**
43	* @return the viewer
44	*/
45	protected ColumnViewer getViewer() {
46	return viewer;
47	}
48
49	/**
50	* @param listener
51	* the listener to be added
52	*/
53	public void addFocusCellChangedListener(FocusCellChangeListener listener) {
54	focusCellChangedListeners.add(listener);
55	}
56
57	/**
58	* @param listener
59	* the listener to be removed
60	*/
61	public void removeFocusCellChangedListener(FocusCellChangeListener listener) {
62	focusCellChangedListeners.remove(listener);
63	}
64
65	/**
66	* @return the cell who holds the keyboard focus
67	*/
68	public ViewerCell getFocusCell() {
69	return focusCell;
70	}
71
72	/**
73	* @param event
74	* inform listeners about the selection
75	* @return has this really been an change event
76	*/
77	protected boolean fireFocusCellChanged(FocusCellChangeEvent event) {
78	if (event.focusCell.equals(event.focusLostCell)) {
79	return false;
80	}
81
82	this.focusCell = event.focusCell;
83
84	Object[] ls = focusCellChangedListeners.getListeners();
85
86	for (int i = 0; i < ls.length; i++) {
87	((FocusCellChangeListener) ls[i]).handleFocusCellChange(event);
88	}
89	return true;
90	}
91	}

Added Link Here

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