Attachment #58764 for bug #172646

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




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

package org.eclipse.jface.snippets.viewers;

import java.util.ArrayList;

import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationSupport;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.EditorActivationEvent;
import org.eclipse.jface.viewers.FocusCellMarkerDelegateOwnerDraw;
import org.eclipse.jface.viewers.ICellModifier;
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.graphics.Color;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.TreeItem;

/**
 * A simple TreeViewer to demonstrate usage
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * 
 */
public class Snippet026TreeViewerTabEditing {
	private class MyContentProvider implements ITreeContentProvider {

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

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

		}

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

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
		 */
		public Object getParent(Object element) {
			if (element == null) {
				return null;
			}

			return ((MyModel) element).parent;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
		 */
		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;
		}
	}

	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 FocusCellMarkerDelegateOwnerDraw(v));
		ColumnViewerEditorActivationSupport actSupport = new ColumnViewerEditorActivationSupport(v, cellSupport) {

			protected boolean isEditorActivationEvent(
					EditorActivationEvent event) {
				return event.eventType == EditorActivationEvent.TRAVERSAL || event.eventType == EditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || ( event.eventType == EditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR ) || event.eventType == EditorActivationEvent.PROGRAMATIC;
			}
			
		};
		actSupport.setEnableEditorActivationWithKeyboard(true);
		
		v.setEditorActivationSupport(actSupport);
		
		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();
			}
			
			public Color getSelectedCellBackgroundColor() {
				return shell.getDisplay().getSystemColor(SWT.COLOR_DARK_GREEN);
			}
		});
		
		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();
			}

			public Color getSelectedCellBackgroundColor() {
				return shell.getDisplay().getSystemColor(SWT.COLOR_DARK_GREEN);
			}

			
		});

		v.setContentProvider(new MyContentProvider());
		v.setCellModifier(new ICellModifier() {

			/* (non-Javadoc)
			 * @see org.eclipse.jface.viewers.ICellModifier#canModify(java.lang.Object, java.lang.String)
			 */
			public boolean canModify(Object element, String property) {
				return true;
			}

			/* (non-Javadoc)
			 * @see org.eclipse.jface.viewers.ICellModifier#getValue(java.lang.Object, java.lang.String)
			 */
			public Object getValue(Object element, String property) {
				return ((MyModel)element).counter + "";
			}

			/* (non-Javadoc)
			 * @see org.eclipse.jface.viewers.ICellModifier#modify(java.lang.Object, java.lang.String, java.lang.Object)
			 */
			public void modify(Object element, String property, Object value) {
				TreeItem item = (TreeItem)element;
				((MyModel)item.getData()).counter = Integer.parseInt(value.toString());
				v.update(item.getData(), null);
			}
			
		});
		
		v.setColumnProperties(new String[] { "column1", "column2" });
		v.setCellEditors(new CellEditor[] { new TextCellEditor(v.getTree()), new TextCellEditor(v.getTree()) });
		v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL|EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR|EditingSupport.TABBING_VERTICAL);
		
		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();
	}
}




				return new StructuredSelection(element);
			}

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

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

				tableEditor.minimumWidth = layoutData.minimumWidth;
			}

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

		};
	}
	




				return new StructuredSelection(element);
			}

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

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

				treeEditor.minimumWidth = layoutData.minimumWidth;
			}

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

		};
	}


Lines 13-18 Link Here

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





package org.eclipse.jface.viewers;

import java.util.List;

import org.eclipse.core.runtime.Assert;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;

		if (viewerEditor != null) {
			control.addMouseListener(new MouseAdapter() {
				public void mouseDown(MouseEvent e) {
					handleMouseDown(e);
				}
			});
		}
	}

	/**
	 * Creates the viewer editor used for editing cell contents. To be
	 * implemented by subclasses.
	 * 
	 * @return the editor, or <code>null</code> if this viewer does not
	 *         support editing cell contents.
	 */
	protected abstract ColumnViewerEditor createViewerEditor();


	 * 
	 * @param point
	 *            the widget-relative coordinates
	 * @return the cell or <code>null</code> if no cell is found at the given
	 *         point
	 */
	ViewerCell getCell(Point point) {
		ViewerRow row = getViewerRow(point);

	/**
	 * Returns the viewer row associated with the given row widget.
	 * 
	 * @param item
	 *            the row widget
	 * @return ViewerRow the associated viewer row
	 */
	protected ViewerRow getViewerRowFromItem(Widget item) {

	/**
	 * Returns the column widget at the given column index.
	 * 
	 * @param columnIndex
	 *            the column index
	 * @return Widget the column widget
	 */
	protected abstract Widget getColumnViewerOwner(int columnIndex);

	 * @return the viewer column at the given index, or <code>null</code> if
	 *         there is none for the given index
	 */
	/* package */ViewerColumn getViewerColumn(final int columnIndex) {

		ViewerColumn viewer;
		Widget columnOwner = getColumnViewerOwner(columnIndex);

	}

	/**
	 * Sets up editing support for the given column based on the "old" cell
	 * editor API.
	 * 
	 * @param columnIndex
	 * @param viewer

	}

	/**
	 * Creates a generic viewer column for the given column widget, based on the
	 * given label provider.
	 * 
	 * @param columnOwner
	 *            the column widget
	 * @param labelProvider
	 *            the label provider to use for the column
	 * @return ViewerColumn the viewer column
	 */
	private ViewerColumn createViewerColumn(Widget columnOwner,
			CellLabelProvider labelProvider) {
		ViewerColumn column = new ViewerColumn(this, columnOwner) {
		};
		column.setLabelProvider(labelProvider, false);
		return column;
	}

	 * @param column
	 * @return ViewerCell
	 */
	/* package */ViewerCell updateCell(ViewerRow rowItem, int column) {
		cell.update(rowItem, column);
		return cell;
	}

	/**
	 * Returns the {@link Item} at the given widget-relative coordinates, or
	 * <code>null</code> if there is no item at the given coordinates.
	 * 
	 * @param point
	 *            the widget-relative coordinates
	 * @return the {@link Item} at the coordinates or <code>null</code> if
	 *         there is no item at the given coordinates
	 */
	protected abstract Item getItemAt(Point point);



	/**
	 * Cancels a currently active cell editor if one is active. All changes
	 * already done in the cell editor are lost.
	 * 
	 * @since 3.1 (in subclasses, added in 3.3 to abstract class)
	 */

	 */
	public void editElement(Object element, int column) {
		if (viewerEditor != null) {
			Widget item = findItem(element);
			if (item != null) {
				ViewerRow row = getViewerRowFromItem(item);
				if (row != null) {
					ViewerCell cell = row.getCell(column);
					if (cell != null) {
						getControl().setRedraw(false);

						List l = getSelectionFromWidget();

						if (l.size() > 1 || !l.contains(cell.getElement())) {
							setSelection(new StructuredSelection(cell
									.getElement()));
						}

						triggerEditorActivationEvent(new EditorActivationEvent(
								cell));
						getControl().setRedraw(true);
					}
				}
			}
		}
	}

	/**
	 * Return the CellEditors for the receiver, or <code>null</code> if no
	 * cell editors are set.
	 * <p>
	 * Since 3.3, an alternative API is available, see
	 * {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
	 * flexible way of editing values in a column viewer.
	 * </p>
	 * 
	 * @return CellEditor[]


	/**
	 * Returns the cell modifier of this viewer, or <code>null</code> if none
	 * has been set.
	 * 
	 * <p>
	 * Since 3.3, an alternative API is available, see
	 * {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
	 * flexible way of editing values in a column viewer.
	 * </p>
	 * 
	 * @return the cell modifier, or <code>null</code>

	 * 
	 * <p>
	 * Since 3.3, an alternative API is available, see
	 * {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
	 * flexible way of editing values in a column viewer.
	 * </p>
	 * 
	 * @return the list of column properties

	 * 
	 * <p>
	 * Since 3.3, an alternative API is available, see
	 * {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
	 * flexible way of editing values in a column viewer.
	 * </p>
	 * 
	 * @return <code>true</code> if there is an active cell editor, and

	 * 
	 * <p>
	 * Since 3.3, an alternative API is available, see
	 * {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
	 * flexible way of editing values in a column viewer.
	 * </p>
	 * 
	 * @param editors

	}

	/**
	 * Sets the cell modifier for this column viewer. This method does nothing
	 * if editing is not supported by this viewer.
	 * 
	 * <p>
	 * Since 3.3, an alternative API is available, see
	 * {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
	 * flexible way of editing values in a column viewer.
	 * </p>
	 * 
	 * @param modifier

	 * 
	 * <p>
	 * Since 3.3, an alternative API is available, see
	 * {@link ViewerColumn#setEditingSupport(EditingSupport)} for a more
	 * flexible way of editing values in a column viewer.
	 * </p>
	 * 
	 * @param columnProperties

			viewerEditor.setColumnProperties(columnProperties);
		}
	}

	/**
	 * The tab-editing style used if the default implementation is used
	 * 

	int getTabEditingStyle() {
		return this.tabEditingStyle;
	}

	/**
	 * Returns the number of columns contained in the receiver. If no columns
	 * were created by the programmer, this value is zero, despite the fact that

		}
		return null;
	}

	private void handleMouseDown(MouseEvent e) {
		ViewerCell cell = getCell(new Point(e.x, e.y));

		if (cell != null) {
			triggerEditorActivationEvent(new EditorActivationEvent(cell, e));
		}
	}

	/**
	 * Invoking this method fires an editor activation event which tries to
	 * enable the editor but before this event is passed to
	 * {@link ColumnViewerEditorActivationSupport} to see if this event should
	 * really trigger editor activation
	 * 
	 * @param event
	 *            the activation event
	 */
	protected void triggerEditorActivationEvent(EditorActivationEvent event) {
		viewerEditor.handleEditorActivationEvent(event);
	}

	/**
	 * To fully control the strategy used to control on which cell-selection
	 * events the editor has to be activated you can pass your customized
	 * strategy using this method.
	 * 
	 * @param editorActivationStrategy
	 *            the strategy used to activate an editor
	 */
	public void setEditorActivationSupport(
			ColumnViewerEditorActivationSupport editorActivationStrategy) {
		if (viewerEditor != null) {
			viewerEditor.setEditorActivationStrategy(editorActivationStrategy);
		} else {
			throw new IllegalStateException(
					"This feature is not supported by the widget"); //$NON-NLS-1$
		}
	}
}

Lines 853-856 Link Here

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

Lines 14-19 Link Here

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




/*******************************************************************************
 * Copyright (c) 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 FocusCellMarkerDelegateOwnerDraw extends FocusCellMarkerDelegate {
	
	/**
	 * @param viewer the viewer
	 */
	public FocusCellMarkerDelegateOwnerDraw(ColumnViewer viewer) {
		super(viewer);
		hookListener(viewer);
	}
	
	private void markFocusedCell(Event event,
			ViewerCell cell) {
		Color background = getSelectedCellBackgroundColor(cell);
		Color foreground = getSelectedCellForegroundColor(cell);

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

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

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

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

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

	private void hookListener(final ColumnViewer viewer) {
		System.err.println("HOOKING LISTENER"); //$NON-NLS-1$
		
		Listener listener = new Listener() {

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

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

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




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

/**
 * 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 FocusCellMarkerDelegate {
	private CellSupport cellSupport;
	
	private ColumnViewer viewer;

	/**
	 * @param viewer
	 */
	public FocusCellMarkerDelegate(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) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.viewers;

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

/**
 * This class is responsible to determin if a cell selection event is triggers
 * an editor activation
 * 
 * @since 3.3
 */
public class ColumnViewerEditorActivationSupport {
	private ColumnViewer viewer;
	
	private KeyListener keyboardActivationListener;
	
	private CellSupport cellSupport;
	
	/**
	 * @param viewer the viewer the editor support is attached to
	 * @param cellSupport the cell support or <code>null</code> if there's none
	 */
	public ColumnViewerEditorActivationSupport(ColumnViewer viewer, CellSupport cellSupport) {
		this.viewer = viewer;
		this.cellSupport = cellSupport;
	}
	
	/**
	 * @return the cell holding the current focus
	 */
	protected ViewerCell getFocusCell() {
		if( cellSupport != null ) {
			return cellSupport.getFocusCell();
		}
		
		return null;
	}
	
	/**
	 * @param event
	 * @return bla bl
	 */
	protected boolean isEditorActivationEvent(EditorActivationEvent event) {
		return event.eventType == EditorActivationEvent.TRAVERSAL || event.eventType == EditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || event.eventType == EditorActivationEvent.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.triggerEditorActivationEvent(new EditorActivationEvent(cell,e));
						}
					}

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




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

package org.eclipse.jface.viewers;

import java.util.EventObject;

/**
 * @since 3.3
 * 
 */
public class CellFocusChangedEvent 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 CellFocusChangedEvent(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 java.util.EventObject;

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

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

	/**
	 * Cancle the event
	 */
	public boolean cancle = false;
	
	/**
	 * @param source
	 */
	public EditorDeactivationEvent(Object source) {
		super(source);
	}

}




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

package org.eclipse.jface.viewers;

import 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 CellNavigationDelegate TABLE_NAVIGATE = new CellNavigationDelegate();

	private static final CellNavigationDelegate TREE_NAVIGATE = new CellNavigationDelegate() {
		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 CellNavigationDelegate navigationDelegate;
	
	/**
	 * @param viewer
	 * @param focusDrawingDelegate
	 */
	public SWTCellSupport(TableViewer viewer,
			FocusCellMarkerDelegate focusDrawingDelegate) {
		this(viewer, focusDrawingDelegate, TABLE_NAVIGATE);
	}

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

	private SWTCellSupport(ColumnViewer viewer,
			FocusCellMarkerDelegate focusDrawingDelegate,
			CellNavigationDelegate navigationDelegate) {
		super(viewer);
		if (viewer != focusDrawingDelegate.getViewer()) {
			throw new IllegalArgumentException(
					"The FocusCellMarkerDelegate 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( fireCellFocusEvent(new CellFocusChangedEvent(getViewer(), cell,
					getFocusCell()))) {
				getViewer().getControl().redraw();
			}
		}
	}

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

		if (navigationDelegate.isCollapseEvent(getViewer(), focusCell, event)) {
			navigationDelegate.collapse(getViewer(), focusCell, event);
		} else if (navigationDelegate.isExpandEvent(getViewer(), focusCell,
				event)) {
			System.err.println("EXPAND!!!"); //$NON-NLS-1$
			navigationDelegate.expand(getViewer(), focusCell, event);
		} else if (navigationDelegate.isNavigationEvent(getViewer(), event)) {
			tmp = navigationDelegate.findSelectedCell(getViewer(), focusCell,event);

			System.err.println("NEW CELL:" + tmp); //$NON-NLS-1$
			
			
			if (tmp != null) {
				if( fireCellFocusEvent(new CellFocusChangedEvent(getViewer(),tmp,focusCell)) ) {
					System.err.println("CHANGED!"); //$NON-NLS-1$
					getViewer().getControl().redraw();
				}
			}
		}

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

	private void handleSelection(Event event) {
		ViewerCell focusCell = getFocusCell();
		if( focusCell != null && focusCell.getItem() != event.item && event.item != null ) {
			ViewerRow row = getViewer().getViewerRowFromItem(event.item);
			Assert.isNotNull(row,"Internal Structure invalid. Row item has no row ViewerRow assigned"); //$NON-NLS-1$
			if( fireCellFocusEvent(new CellFocusChangedEvent(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 java.util.EventObject;

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

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

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

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

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

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

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

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

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

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

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

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

	/**
	 * The statemask
	 */
	public int stateMask;

	/**
	 * Cancle the event (=> editor is not activated)
	 */
	public boolean cancle = false;
	
	/**
	 * This constructor can be used when no event exists. The type set is
	 * {@link #PROGRAMATIC}
	 * 
	 * @param cell
	 *            the cell
	 */
	public EditorActivationEvent(ViewerCell cell) {
		super(cell);
		eventType = PROGRAMATIC;
	}

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

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

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

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

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




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

package org.eclipse.jface.viewers;

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

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

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

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




/*******************************************************************************
 * 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 CellFocusChangedListener {
	/**
	 * @param event
	 *            the event informing about the selection of a cell
	 */
	public abstract void cellSelected(CellFocusChangedEvent 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 cellFocusListener;

	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 addCellSelectionListener(CellFocusChangedListener listener) {
		cellFocusListener.add(listener);
	}

	/**
	 * @param listener
	 *            the listener to be removed
	 */
	public void removeCellSelectionListener(CellFocusChangedListener listener) {
		cellFocusListener.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 fireCellFocusEvent(CellFocusChangedEvent event) {
		if (event.focusCell.equals(event.focusLostCell)) {
			return false;
		}

		this.focusCell = event.focusCell;

		if( cellFocusListener == null ) {
			cellFocusListener = new ListenerList();
		}
		
		Object[] ls = cellFocusListener.getListeners();

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

Lines 5-10 Link Here

(-)META-INF/MANIFEST.MF (-3 / +3 lines)
5	Bundle-Version: 1.0.0	5	Bundle-Version: 1.0.0
6	Bundle-Localization: plugin	6	Bundle-Localization: plugin
7	Require-Bundle: org.eclipse.swt,	7	Require-Bundle: org.eclipse.swt,
8	org.eclipse.swt.nebula	8	org.eclipse.swt.nebula,
9	Export-Package: org.eclipse.swt.nebula.snippets.ctree,	9	org.eclipse.swt.nebula.nebface
10	org.eclipse.swt.nebula.snippets.grid	10	Export-Package: org.eclipse.swt.nebula.snippets.grid




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

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

import org.eclipse.jface.resource.FontRegistry;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.EditorActivationEvent;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITableColorProvider;
import org.eclipse.jface.viewers.ITableFontProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.nebula.nebface.viewers.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(
					EditorActivationEvent event) {
				return event.eventType == EditorActivationEvent.TRAVERSAL || event.eventType == EditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION || ( event.eventType == EditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR ) || event.eventType == EditorActivationEvent.PROGRAMATIC;
			}
		};
		support.setEnableEditorActivationWithKeyboard(true);
		
		v.setEditorActivationSupport(support);
		v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL|EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR|EditingSupport.TABBING_VERTICAL);
		
		GridColumn column = new GridColumn(v.getGrid(), SWT.NONE);
		column.setWidth(200);
		column.setText("Column 1");

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

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

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

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

		return elements;
	}

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

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

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

		display.dispose();

	}

}

Lines 4-10 Link Here

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

Lines 1-29 Link Here

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




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

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

import org.eclipse.jface.viewers.AbstractTableViewer;
import org.eclipse.jface.viewers.ColumnViewerEditor;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.ViewerCell;
import org.eclipse.jface.viewers.ViewerRow;
import org.eclipse.jface.viewers.CellEditor.LayoutData;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.nebula.widgets.grid.Grid;
import org.eclipse.swt.nebula.widgets.grid.GridEditor;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Widget;

/**
 * A concrete viewer based on an Grid control.
 * <p>
 * This class is not intended to be subclassed outside the viewer framework. It
 * is designed to be instantiated with a pre-existing Grid control and
 * configured with a domain-specific content provider, label provider, element
 * filter (optional), and element sorter (optional).
 * <p>
 * Content providers for grid viewers must not implement the
 * {@code ITreeContentProvider} interface.
 * <p>
 * 
 * @author rmcamara@us.ibm.com
 * @since
 * @3.3
 */
public class GridViewer extends AbstractTableViewer
{
    /** This viewer's grid control. */
    private Grid grid;
    
    /** Editor support for tables. */
    private GridEditor gridEditor;

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

    /**
     * Creates a grid viewer on a newly-created grid control under the given
     * parent. The grid control is created using the given SWT style bits. The
     * viewer has no input, no content provider, a default label provider, no
     * sorter, and no filters.
     * 
     * @param parent the parent control
     * @param style the SWT style bits used to create the grid.
     */
    public GridViewer(Composite parent, int style)
    {
        this(new Grid(parent, style));
    }

    /**
     * Creates a grid viewer on the given grid control. The viewer has no
     * input, no content provider, a default label provider, no sorter, and no
     * filters.
     * 
     * @param grid the grid control
     */
    public GridViewer(Grid grid)
    {
        this.grid = grid;
        gridEditor = new GridEditor(grid);
        hookControl(grid);
    }
    
    /**
     * Returns the underlying Grid Control. 
     * 
     * @return grid control.
     */
    public Grid getGrid()
    {
        return grid;
    }
		} else {
			item = new GridItem(grid, style);
		}

		return getViewerRowFromItem(item);
	}

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

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

        return getViewerRowFromItem(item);
    }

    /** {@inheritDoc} */
    protected ColumnViewerEditor createViewerEditor() 
    {
        return new ColumnViewerEditor(this) 
        {
            protected StructuredSelection createSelection(Object element) 
            {
                return new StructuredSelection(element);
            }

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

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

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

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

        };
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /** {@inheritDoc} */
    protected void doRemoveAll()
    {
        grid.removeAll();
    }

    /** {@inheritDoc} */
    protected void doSetSelection(Item[] items)
    {
        GridItem[] items2 = new GridItem[items.length];
        for (int i = 0; i < items.length; i++)
        {
            items2[i] = (GridItem) items[i];
        }
        grid.setSelection(items2);
    }

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

    /** {@inheritDoc} */
    protected void doShowItem(Item item)
    {
        grid.showItem((GridItem)item);
    }
			System.arraycopy(items, 0, tmp, 0, items.length);
			grid.setSelection(tmp);
		}

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

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

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

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

        return part;
    }
	}

    
    
    protected void doResetItem(Item item) {
		GridItem gridItem = (GridItem) item;
		int columnCount = Math.max(1, grid.getColumnCount());
		for (int i = 0; i < columnCount; i++) {
			gridItem.setText(i, ""); //$NON-NLS-1$
			gridItem.setImage(null);
		}
	}

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

		return null;
	}
}




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

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

import org.eclipse.jface.viewers.ViewerRow;

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

/**
 * GridViewerRow is the concrete implementation of the part that represents items in a
 * Grid.
 *
 * @author rmcamara@us.ibm.com
 * @since 3.3
 */
public class GridViewerRow extends ViewerRow
{
    private GridItem item;

    /**
     * Create a new instance of the receiver.
     * 
     * @param item GridItem source.
     */
    public GridViewerRow(Item item)
    {
        super(item);
        this.item = (GridItem)item;
    }

    /** {@inheritDoc} */
    public Rectangle getBounds(int columnIndex)
    {
        return item.getBounds(columnIndex);
    }

    /** {@inheritDoc} */
    public Rectangle getBounds()
    {
        // TODO This is not correct. Update once item returns the correct information.
        return item.getBounds(0);
    }

    /** {@inheritDoc} */
    public Item getItem()
    {
        return item;
    }

    /** {@inheritDoc} */
    public int getColumnCount()
    {
        return item.getParent().getColumnCount();
    }

    /** {@inheritDoc} */
    public Color getBackground(int columnIndex)
    {
        return item.getBackground(columnIndex);
    }

    /** {@inheritDoc} */
    public Font getFont(int columnIndex)
    {
        return item.getFont(columnIndex);
    }

    /** {@inheritDoc} */
    public Color getForeground(int columnIndex)
    {
        return item.getForeground(columnIndex);
    }

    /** {@inheritDoc} */
    public Image getImage(int columnIndex)
    {
        return item.getImage(columnIndex);
    }

    /** {@inheritDoc} */
    public String getText(int columnIndex)
    {
        return item.getText(columnIndex);
    }

    /** {@inheritDoc} */
    public void setBackground(int columnIndex, Color color)
    {
        item.setBackground(columnIndex, color);
    }

    /** {@inheritDoc} */
    public void setFont(int columnIndex, Font font)
    {
        item.setFont(columnIndex, font);
    }

    /** {@inheritDoc} */
    public void setForeground(int columnIndex, Color color)
    {
        item.setForeground(columnIndex, color);
    }

    /** {@inheritDoc} */
    public void setImage(int columnIndex, Image image)
    {
        item.setImage(columnIndex, image);
    }

    /** {@inheritDoc} */
    public void setText(int columnIndex, String text)
    {
        item.setText(columnIndex, text == null ? "" : text); //$NON-NLS-1$
    }

    /** {@inheritDoc} */
    public Control getControl()
    {
        return item.getParent();
    }

    public ViewerRow getNeighbor(int direction, boolean sameLevel) {
		if( direction == ViewerRow.ABOVE ) {
			return getRowAbove();
		} else if( direction == ViewerRow.BELOW ) {
			return getRowBelow();
		} else {
			throw new IllegalArgumentException("Illegal value of direction argument."); //$NON-NLS-1$
				item.setImage(i, null);
			}
		}
	}

	
	private ViewerRow getRowAbove() {
		int index = item.getParent().indexOf(item) - 1;
		
		if( index >= 0 ) {
			return (ViewerRow)item.getParent().getItem(index).getData(ViewerRow.ROWPART_KEY); 
		}
		
		return null;
		return item.getBounds(0); // TODO IS THIS CORRECT
	}

	public int getColumnCount() {
		return item.getParent().getColumnCount();
	}

	public Font getFont(int columnIndex) {
		return item.getFont(columnIndex);
	}

	public Color getForeground(int columnIndex) {
		return item.getForeground(columnIndex);
	}

	public Image getImage(int columnIndex) {
		return item.getImage(columnIndex);
	}

	public Item getItem() {
		return item;
	}

	public String getText(int columnIndex) {
		return item.getText(columnIndex);
	}

	public void setBackground(int columnIndex, Color color) {
		item.setBackground(columnIndex, color);
	}

	public void setFont(int columnIndex, Font font) {
		item.setFont(columnIndex, font);
	}

	public void setForeground(int columnIndex, Color color) {
		item.setForeground(columnIndex, color);
	}

	public void setImage(int columnIndex, Image image) {
		item.setImage(columnIndex, image);
	}

	public void setText(int columnIndex, String text) {
		item.setText(columnIndex, text);
	}

	private ViewerRow getRowBelow() {
		int index = item.getParent().indexOf(item) + 1;
		
		if( index < item.getParent().getItemCount() ) {
			GridItem tmp = item.getParent().getItem(index);
			//TODO NULL can happen in case of VIRTUAL => How do we deal with that
			if( tmp != null ) {
				return (ViewerRow)tmp.getData(ViewerRow.ROWPART_KEY);
			}
		}
		
		return null;
	}
}




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

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

import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.ViewerColumn;
import org.eclipse.swt.SWT;
import org.eclipse.swt.nebula.widgets.grid.Grid;

import org.eclipse.swt.nebula.widgets.grid.GridItem;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;

/**
 * The concrete implementation of the ColumnViewer for the grid.
 *
 * @author rmcamara@us.ibm.com
 * @since 3.3
 */
public final class GridViewerColumn extends ViewerColumn 
{
    /** The concrete grid column that is being represented by the {@code ViewerColumn}.*/
    private GridColumn column;
    
    /** Editor support for handling check events. */
    private CheckEditingSupport checkEditingSupport;
    
    /** The parent grid viewer. */
    private GridViewer viewer;

    /**
     * Create a new column in the {@link GridViewer}
     * 
     * @param viewer
     *            the viewer the column belongs to
     * @param style
     *            the style used to create the column for style bits see
     *            {@link GridColumn}
     * @see GridColumn#GridColumn(Grid, int)
     */
    public GridViewerColumn(GridViewer viewer, int style) 
    {
        this(viewer, style, -1);
        this.viewer = viewer;
    }

    /**
     * Create a new column in the {@link GridViewer}
     * 
     * @param viewer
     *            the viewer the column belongs to
     * @param style
     *            the style used to create the column for style bits see
     *            {@link GridColumn}
     * @param index
     *            the index of the newly created column
     * @see GridColumn#GridColumn(Grid, int, int)
     */
    public GridViewerColumn(GridViewer viewer, int style, int index) 
    {
        this(viewer, createColumn((Grid) viewer.getControl(), style, index));
        this.viewer = viewer;
    }

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

        return new GridColumn(table, style);
    }

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

            super.setEditingSupport(editingSupport);
        }        
    }
}




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

import org.eclipse.jface.viewers.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
        
    }
}

Return to bug 172646

Added Link Here

(-)Eclipse (+247 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.ColumnLabelProvider;
18	import org.eclipse.jface.viewers.ColumnViewerEditorActivationSupport;
19	import org.eclipse.jface.viewers.EditingSupport;
20	import org.eclipse.jface.viewers.EditorActivationEvent;
21	import org.eclipse.jface.viewers.FocusCellMarkerDelegateOwnerDraw;
22	import org.eclipse.jface.viewers.ICellModifier;
23	import org.eclipse.jface.viewers.ITreeContentProvider;
24	import org.eclipse.jface.viewers.SWTCellSupport;
25	import org.eclipse.jface.viewers.TextCellEditor;
26	import org.eclipse.jface.viewers.TreeViewer;
27	import org.eclipse.jface.viewers.TreeViewerColumn;
28	import org.eclipse.jface.viewers.Viewer;
29	import org.eclipse.swt.SWT;
30	import org.eclipse.swt.graphics.Color;
31	import org.eclipse.swt.layout.FillLayout;
32	import org.eclipse.swt.widgets.Display;
33	import org.eclipse.swt.widgets.Shell;
34	import org.eclipse.swt.widgets.TreeItem;
35
36	/**
37	* A simple TreeViewer to demonstrate usage
38	*
39	* @author Tom Schindl <tom.schindl@bestsolution.at>
40	*
41	*/
42	public class Snippet026TreeViewerTabEditing {
43	private class MyContentProvider implements ITreeContentProvider {
44
45	/*
46	* (non-Javadoc)
47	*
48	* @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
49	*/
50	public Object[] getElements(Object inputElement) {
51	return ((MyModel) inputElement).child.toArray();
52	}
53
54	/*
55	* (non-Javadoc)
56	*
57	* @see org.eclipse.jface.viewers.IContentProvider#dispose()
58	*/
59	public void dispose() {
60
61	}
62
63	/*
64	* (non-Javadoc)
65	*
66	* @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
67	* java.lang.Object, java.lang.Object)
68	*/
69	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
70
71	}
72
73	/*
74	* (non-Javadoc)
75	*
76	* @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
77	*/
78	public Object[] getChildren(Object parentElement) {
79	return getElements(parentElement);
80	}
81
82	/*
83	* (non-Javadoc)
84	*
85	* @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
86	*/
87	public Object getParent(Object element) {
88	if (element == null) {
89	return null;
90	}
91
92	return ((MyModel) element).parent;
93	}
94
95	/*
96	* (non-Javadoc)
97	*
98	* @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
99	*/
100	public boolean hasChildren(Object element) {
101	return ((MyModel) element).child.size() > 0;
102	}
103
104	}
105
106	public class MyModel {
107	public MyModel parent;
108
109	public ArrayList child = new ArrayList();
110
111	public int counter;
112
113	public MyModel(int counter, MyModel parent) {
114	this.parent = parent;
115	this.counter = counter;
116	}
117
118	public String toString() {
119	String rv = "Item ";
120	if (parent != null) {
121	rv = parent.toString() + ".";
122	}
123
124	rv += counter;
125
126	return rv;
127	}
128	}
129
130	public Snippet026TreeViewerTabEditing(final Shell shell) {
131	final TreeViewer v = new TreeViewer(shell,SWT.BORDER\|SWT.FULL_SELECTION);
132	v.getTree().setLinesVisible(true);
133	v.getTree().setHeaderVisible(true);
134
135	SWTCellSupport cellSupport = new SWTCellSupport(v,new FocusCellMarkerDelegateOwnerDraw(v));
136	ColumnViewerEditorActivationSupport actSupport = new ColumnViewerEditorActivationSupport(v, cellSupport) {
137
138	protected boolean isEditorActivationEvent(
139	EditorActivationEvent event) {
140	return event.eventType == EditorActivationEvent.TRAVERSAL \|\| event.eventType == EditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION \|\| ( event.eventType == EditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR ) \|\| event.eventType == EditorActivationEvent.PROGRAMATIC;
141	}
142
143	};
144	actSupport.setEnableEditorActivationWithKeyboard(true);
145
146	v.setEditorActivationSupport(actSupport);
147
148	TreeViewerColumn column = new TreeViewerColumn(v,SWT.NONE);
149	column.getColumn().setWidth(200);
150	column.getColumn().setText("Column 1");
151	column.setLabelProvider(new ColumnLabelProvider() {
152
153	public String getText(Object element) {
154	return "Column 1 => " + element.toString();
155	}
156
157	public Color getSelectedCellBackgroundColor() {
158	return shell.getDisplay().getSystemColor(SWT.COLOR_DARK_GREEN);
159	}
160	});
161
162	column = new TreeViewerColumn(v,SWT.NONE);
163	column.getColumn().setWidth(200);
164	column.getColumn().setText("Column 2");
165	column.setLabelProvider(new ColumnLabelProvider() {
166
167	public String getText(Object element) {
168	return "Column 2 => " + element.toString();
169	}
170
171	public Color getSelectedCellBackgroundColor() {
172	return shell.getDisplay().getSystemColor(SWT.COLOR_DARK_GREEN);
173	}
174
175
176	});
177
178	v.setContentProvider(new MyContentProvider());
179	v.setCellModifier(new ICellModifier() {
180
181	/* (non-Javadoc)
182	* @see org.eclipse.jface.viewers.ICellModifier#canModify(java.lang.Object, java.lang.String)
183	*/
184	public boolean canModify(Object element, String property) {
185	return true;
186	}
187
188	/* (non-Javadoc)
189	* @see org.eclipse.jface.viewers.ICellModifier#getValue(java.lang.Object, java.lang.String)
190	*/
191	public Object getValue(Object element, String property) {
192	return ((MyModel)element).counter + "";
193	}
194
195	/* (non-Javadoc)
196	* @see org.eclipse.jface.viewers.ICellModifier#modify(java.lang.Object, java.lang.String, java.lang.Object)
197	*/
198	public void modify(Object element, String property, Object value) {
199	TreeItem item = (TreeItem)element;
200	((MyModel)item.getData()).counter = Integer.parseInt(value.toString());
201	v.update(item.getData(), null);
202	}
203
204	});
205
206	v.setColumnProperties(new String[] { "column1", "column2" });
207	v.setCellEditors(new CellEditor[] { new TextCellEditor(v.getTree()), new TextCellEditor(v.getTree()) });
208	v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL\|EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR\|EditingSupport.TABBING_VERTICAL);
209
210	v.setInput(createModel());
211	}
212
213	private MyModel createModel() {
214
215	MyModel root = new MyModel(0, null);
216	root.counter = 0;
217
218	MyModel tmp;
219	MyModel subItem;
220	for (int i = 1; i < 10; i++) {
221	tmp = new MyModel(i, root);
222	root.child.add(tmp);
223	for (int j = 1; j < i; j++) {
224	subItem = new MyModel(j, tmp);
225	subItem.child.add(new MyModel(j*100,subItem));
226	tmp.child.add(subItem);
227	}
228	}
229
230	return root;
231	}
232
233	public static void main(String[] args) {
234	Display display = new Display();
235	Shell shell = new Shell(display);
236	shell.setLayout(new FillLayout());
237	new Snippet026TreeViewerTabEditing(shell);
238	shell.open();
239
240	while (!shell.isDisposed()) {
241	if (!display.readAndDispatch())
242	display.sleep();
243	}
244
245	display.dispose();
246	}
247	}

Lines 134-143 Link Here

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

Lines 284-293 Link Here

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

Added Link Here

(-)src/org/eclipse/jface/viewers/FocusCellMarkerDelegateOwnerDraw.java (+128 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.Color;
17	import org.eclipse.swt.graphics.GC;
18	import org.eclipse.swt.widgets.Event;
19	import org.eclipse.swt.widgets.Listener;
20
21	/**
22	* @since 3.3
23	*
24	*/
25	public class FocusCellMarkerDelegateOwnerDraw extends FocusCellMarkerDelegate {
26
27	/**
28	* @param viewer the viewer
29	*/
30	public FocusCellMarkerDelegateOwnerDraw(ColumnViewer viewer) {
31	super(viewer);
32	hookListener(viewer);
33	}
34
35	private void markFocusedCell(Event event,
36	ViewerCell cell) {
37	Color background = getSelectedCellBackgroundColor(cell);
38	Color foreground = getSelectedCellForegroundColor(cell);
39
40	if (foreground != null \|\| background != null) {
41	GC gc = event.gc;
42
43	if (background == null) {
44	background = cell.getItem().getDisplay().getSystemColor(
45	SWT.COLOR_LIST_SELECTION);
46	}
47
48	if (foreground == null) {
49	foreground = cell.getItem().getDisplay().getSystemColor(
50	SWT.COLOR_LIST_SELECTION_TEXT);
51	}
52
53	gc.setBackground(background);
54	gc.setForeground(foreground);
55	gc.fillRectangle(event.getBounds());
56
57	// This is a workaround for an SWT-Bug on WinXP bug 169517
58	gc.drawText(" ", cell.getBounds().x, cell.getBounds().y, false); //$NON-NLS-1$
59	event.detail &= ~SWT.SELECTED;
60	}
61	}
62
63	private void removeSelectionInformation(Event event,
64	ViewerCell cell) {
65	GC gc = event.gc;
66	gc.setBackground(cell.getViewerRow().getBackground(
67	cell.getColumnIndex()));
68	gc.setForeground(cell.getViewerRow().getForeground(
69	cell.getColumnIndex()));
70	gc.fillRectangle(cell.getBounds());
71	// This is a workaround for an SWT-Bug on WinXP bug 169517
72	gc.drawText(" ", cell.getBounds().x, cell.getBounds().y, false); //$NON-NLS-1$
73	event.detail &= ~SWT.SELECTED;
74	}
75
76	private void hookListener(final ColumnViewer viewer) {
77	System.err.println("HOOKING LISTENER"); //$NON-NLS-1$
78
79	Listener listener = new Listener() {
80
81	public void handleEvent(Event event) {
82	if((event.detail & SWT.SELECTED) > 0 ) {
83	System.err.println("ERASE EVENT"); //$NON-NLS-1$
84	ViewerCell focusCell = getFocusCell();
85	ViewerRow row = viewer.getViewerRowFromItem(event.item);
86
87	Assert.isNotNull(row, "Internal structure invalid. Item without associated row is not possible."); //$NON-NLS-1$
88
89	ViewerCell cell = row.getCell(event.index);
90
91	// if( focusCell != null ) {
92	// System.err.println("FOCUS: " + focusCell.getColumnIndex() + " =>" + focusCell.getItem() ); //$NON-NLS-1$ //$NON-NLS-2$
93	// }
94	//
95	// if( cell != null ) {
96	// System.err.println("TO COLOR: " + cell.getColumnIndex() + " =>" + cell.getItem() ); //$NON-NLS-1$ //$NON-NLS-2$
97	// }
98
99	if (focusCell == null \|\| ! cell.equals(focusCell)) {
100	removeSelectionInformation(event, cell);
101	} else {
102	markFocusedCell(event,cell);
103	}
104	}
105	}
106
107	};
108	viewer.getControl().addListener(SWT.EraseItem, listener);
109	}
110
111	/**
112	* @param cell
113	* the cell which is colored
114	* @return the color
115	*/
116	protected Color getSelectedCellBackgroundColor(ViewerCell cell) {
117	return null;
118	}
119
120	/**
121	* @param cell
122	* the cell which is colored
123	* @return the color
124	*/
125	protected Color getSelectedCellForegroundColor(ViewerCell cell) {
126	return null;
127	}
128	}

Added Link Here

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

Added Link Here

(-)src/org/eclipse/jface/viewers/CellFocusChangedEvent.java (+51 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import java.util.EventObject;
15
16	/**
17	* @since 3.3
18	*
19	*/
20	public class CellFocusChangedEvent extends EventObject {
21
22	/**
23	*
24	*/
25	private static final long serialVersionUID = 1L;
26
27	/**
28	* the cell who recevied the focus
29	*/
30	public ViewerCell focusCell;
31
32	/**
33	* the cell who lost the focus
34	*/
35	public ViewerCell focusLostCell;
36
37	/**
38	* @param viewer
39	* the viewer
40	* @param focusCell
41	* the cell who recevied the focus
42	* @param focusLostCell
43	* the cell who lost the focus
44	*/
45	public CellFocusChangedEvent(ColumnViewer viewer, ViewerCell focusCell,
46	ViewerCell focusLostCell) {
47	super(viewer);
48	this.focusCell=focusCell;
49	this.focusLostCell=focusLostCell;
50	}
51	}

Added Link Here

(-)src/org/eclipse/jface/viewers/EditorDeactivationEvent.java (+41 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import java.util.EventObject;
15
16	/**
17	* This event is fired when an editor deactivated
18	*
19	* @since 3.3
20	*
21	*/
22	public class EditorDeactivationEvent extends EventObject {
23
24	/**
25	*
26	*/
27	private static final long serialVersionUID = 1L;
28
29	/**
30	* Cancle the event
31	*/
32	public boolean cancle = false;
33
34	/**
35	* @param source
36	*/
37	public EditorDeactivationEvent(Object source) {
38	super(source);
39	}
40
41	}

Added Link Here

(-)src/org/eclipse/jface/viewers/SWTCellSupport.java (+164 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import 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 CellNavigationDelegate TABLE_NAVIGATE = new CellNavigationDelegate();
27
28	private static final CellNavigationDelegate TREE_NAVIGATE = new CellNavigationDelegate() {
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 CellNavigationDelegate navigationDelegate;
64
65	/**
66	* @param viewer
67	* @param focusDrawingDelegate
68	*/
69	public SWTCellSupport(TableViewer viewer,
70	FocusCellMarkerDelegate focusDrawingDelegate) {
71	this(viewer, focusDrawingDelegate, TABLE_NAVIGATE);
72	}
73
74	/**
75	* @param viewer
76	* @param focusDrawingDelegate
77	*/
78	public SWTCellSupport(TreeViewer viewer,
79	FocusCellMarkerDelegate focusDrawingDelegate) {
80	this(viewer, focusDrawingDelegate, TREE_NAVIGATE);
81	}
82
83	private SWTCellSupport(ColumnViewer viewer,
84	FocusCellMarkerDelegate focusDrawingDelegate,
85	CellNavigationDelegate navigationDelegate) {
86	super(viewer);
87	if (viewer != focusDrawingDelegate.getViewer()) {
88	throw new IllegalArgumentException(
89	"The FocusCellMarkerDelegate 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( fireCellFocusEvent(new CellFocusChangedEvent(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	System.err.println("EXPAND!!!"); //$NON-NLS-1$
115	navigationDelegate.expand(getViewer(), focusCell, event);
116	} else if (navigationDelegate.isNavigationEvent(getViewer(), event)) {
117	tmp = navigationDelegate.findSelectedCell(getViewer(), focusCell,event);
118
119	System.err.println("NEW CELL:" + tmp); //$NON-NLS-1$
120
121
122	if (tmp != null) {
123	if( fireCellFocusEvent(new CellFocusChangedEvent(getViewer(),tmp,focusCell)) ) {
124	System.err.println("CHANGED!"); //$NON-NLS-1$
125	getViewer().getControl().redraw();
126	}
127	}
128	}
129
130	if (navigationDelegate.cancleEvent(getViewer(), event)) {
131	event.doit = false;
132	}
133	}
134
135	private void handleSelection(Event event) {
136	ViewerCell focusCell = getFocusCell();
137	if( focusCell != null && focusCell.getItem() != event.item && event.item != null ) {
138	ViewerRow row = getViewer().getViewerRowFromItem(event.item);
139	Assert.isNotNull(row,"Internal Structure invalid. Row item has no row ViewerRow assigned"); //$NON-NLS-1$
140	if( fireCellFocusEvent(new CellFocusChangedEvent(getViewer(),row.getCell(focusCell.getColumnIndex()),focusCell)) ) {
141	getViewer().getControl().redraw();
142	}
143	}
144	}
145
146	protected void hookListener(ColumnViewer viewer) {
147	Listener listener = new Listener() {
148
149	public void handleEvent(Event event) {
150	if (event.type == SWT.MouseDown) {
151	handleMouseDown(event);
152	} else if (event.type == SWT.KeyDown) {
153	handleKeyDown(event);
154	} else {
155	handleSelection(event);
156	}
157	}
158	};
159
160	viewer.getControl().addListener(SWT.MouseDown, listener);
161	viewer.getControl().addListener(SWT.KeyDown, listener);
162	viewer.getControl().addListener(SWT.Selection, listener);
163	}
164	}

Added Link Here

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

Added Link Here

(-)src/org/eclipse/jface/viewers/CellSupport.java (+95 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 cellFocusListener;
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 addCellSelectionListener(CellFocusChangedListener listener) {
54	cellFocusListener.add(listener);
55	}
56
57	/**
58	* @param listener
59	* the listener to be removed
60	*/
61	public void removeCellSelectionListener(CellFocusChangedListener listener) {
62	cellFocusListener.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 fireCellFocusEvent(CellFocusChangedEvent event) {
78	if (event.focusCell.equals(event.focusLostCell)) {
79	return false;
80	}
81
82	this.focusCell = event.focusCell;
83
84	if( cellFocusListener == null ) {
85	cellFocusListener = new ListenerList();
86	}
87
88	Object[] ls = cellFocusListener.getListeners();
89
90	for (int i = 0; i < ls.length; i++) {
91	((CellFocusChangedListener) ls[i]).cellSelected(event);
92	}
93	return true;
94	}
95	}

Added Link Here

(-)src/org/eclipse/swt/nebface/snippets/viewers/GridViewerSnippet1.java (+208 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 Tom Schindl and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Tom Schindl - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.swt.nebface.snippets.viewers;
13
14	import org.eclipse.jface.resource.FontRegistry;
15	import org.eclipse.jface.viewers.CellEditor;
16	import org.eclipse.jface.viewers.EditingSupport;
17	import org.eclipse.jface.viewers.EditorActivationEvent;
18	import org.eclipse.jface.viewers.ICellModifier;
19	import org.eclipse.jface.viewers.IStructuredContentProvider;
20	import org.eclipse.jface.viewers.ITableColorProvider;
21	import org.eclipse.jface.viewers.ITableFontProvider;
22	import org.eclipse.jface.viewers.ITableLabelProvider;
23	import org.eclipse.jface.viewers.LabelProvider;
24	import org.eclipse.jface.viewers.TextCellEditor;
25	import org.eclipse.jface.viewers.Viewer;
26	import org.eclipse.swt.SWT;
27	import org.eclipse.swt.graphics.Color;
28	import org.eclipse.swt.graphics.Font;
29	import org.eclipse.swt.graphics.Image;
30	import org.eclipse.swt.layout.FillLayout;
31	import org.eclipse.swt.nebula.nebface.viewers.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	EditorActivationEvent event) {
156	return event.eventType == EditorActivationEvent.TRAVERSAL \|\| event.eventType == EditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION \|\| ( event.eventType == EditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR ) \|\| event.eventType == EditorActivationEvent.PROGRAMATIC;
157	}
158	};
159	support.setEnableEditorActivationWithKeyboard(true);
160
161	v.setEditorActivationSupport(support);
162	v.setTabEditingStyle(EditingSupport.TABBING_HORIZONTAL\|EditingSupport.TABBING_MOVE_TO_ROW_NEIGHBOR\|EditingSupport.TABBING_VERTICAL);
163
164	GridColumn column = new GridColumn(v.getGrid(), SWT.NONE);
165	column.setWidth(200);
166	column.setText("Column 1");
167
168	column = new GridColumn(v.getGrid(), SWT.NONE);
169	column.setWidth(200);
170	column.setText("Column 2");
171
172	MyModel[] model = createModel();
173	v.setInput(model);
174	v.getGrid().setLinesVisible(true);
175	v.getGrid().setHeaderVisible(true);
176	}
177
178	private MyModel[] createModel() {
179	MyModel[] elements = new MyModel[10];
180
181	for (int i = 0; i < 10; i++) {
182	elements[i] = new MyModel(i);
183	}
184
185	return elements;
186	}
187
188	/**
189	* @param args
190	*/
191	public static void main(String[] args) {
192	Display display = new Display();
193
194	Shell shell = new Shell(display);
195	shell.setLayout(new FillLayout());
196	new GridViewerSnippet1(shell);
197	shell.open();
198
199	while (!shell.isDisposed()) {
200	if (!display.readAndDispatch())
201	display.sleep();
202	}
203
204	display.dispose();
205
206	}
207
208	}