Attachment #58157 for bug #172646

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




				return new StructuredSelection(element);
			}

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

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

				tableEditor.minimumWidth = layoutData.minimumWidth;
			}

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

		};
	}
	

	protected void doClear(int index) {
		table.clear(index);
	}
	

	protected ViewerCell getFocusCell() {
		//TODO Focus tracking has to be implemented in M6
		return null;
	}
}




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

		};
	}


	protected int doGetColumnCount() {
		return tree.getColumnCount();
	}
	
	protected ViewerCell getFocusCell() {
		//TODO Focus tracking has to be implemented in M6
		return null;
	}
}

Lines 2950-2953 Link Here

(-)src/org/eclipse/jface/viewers/AbstractTreeViewer.java (+7 lines)
2950	return false;	2950	return false;
2951	return ((TreePath) elementOrTreePath).getSegmentCount() == 0;	2951	return ((TreePath) elementOrTreePath).getSegmentCount() == 0;
2952	}	2952	}
		2953
		2954	// --------------------------------------------------
		2955	// These methods should be overwritten by subclasses and are only here to provide backwards compatility
		2956
		2957	protected ViewerCell getFocusCell() {
		2958	return null;
		2959	}
2953	}	2960	}

Lines 13-18 Link Here

(-)src/org/eclipse/jface/viewers/EditingSupport.java (-2 / +12 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	if( l.size() > 1 \|\| ! l.contains(cell2edit.getElement()) ) {
		179	viewer.setSelection(new StructuredSelection(cell2edit.getElement()));
		180	}
		181
		182	EditorActivationEvent acEvent = new EditorActivationEvent(cell2edit,event);
		183	viewer.fireEditorActivationEvent(acEvent);
		184	viewer.getControl().setRedraw(true);
175	}	185	}
176	}	186	}
177		187

Lines 14-20 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewer.java (-3 / +114 lines)
14		14
15	package org.eclipse.jface.viewers;	15	package org.eclipse.jface.viewers;
16		16
		17
		18	import java.util.List;
		19
17	import org.eclipse.core.runtime.Assert;	20	import org.eclipse.core.runtime.Assert;
		21	import org.eclipse.swt.events.KeyEvent;
		22	import org.eclipse.swt.events.KeyListener;
18	import org.eclipse.swt.events.MouseAdapter;	23	import org.eclipse.swt.events.MouseAdapter;
19	import org.eclipse.swt.events.MouseEvent;	24	import org.eclipse.swt.events.MouseEvent;
20	import org.eclipse.swt.graphics.Point;	25	import org.eclipse.swt.graphics.Point;
Lines 50-55 Link Here
50		55
51	private int tabEditingStyle = EditingSupport.TABING_NONE;	56	private int tabEditingStyle = EditingSupport.TABING_NONE;
52		57
		58	private KeyListener keyboardActivationListener;
		59
53	/**	60	/**
54	* Create a new instance of the receiver.	61	* Create a new instance of the receiver.
55	*/	62	*/
Lines 76-82 Link Here
76	if (viewerEditor != null) {	83	if (viewerEditor != null) {
77	control.addMouseListener(new MouseAdapter() {	84	control.addMouseListener(new MouseAdapter() {
78	public void mouseDown(MouseEvent e) {	85	public void mouseDown(MouseEvent e) {
79	viewerEditor.handleMouseDown(e);	86	handleMouseDown(e);
80	}	87	}
81	});	88	});
82	}	89	}
Lines 371-380 Link Here
371	*/	378	*/
372	public void editElement(Object element, int column) {	379	public void editElement(Object element, int column) {
373	if (viewerEditor != null) {	380	if (viewerEditor != null) {
374	viewerEditor.editElement(element, column);	381	Widget item = findItem(element);
		382	if( item != null ) {
		383	ViewerRow row = getViewerRowFromItem(item);
		384	if( row != null ) {
		385	ViewerCell cell = row.getCell(column);
		386	if( cell != null ) {
		387	getControl().setRedraw(false);
		388
		389	List l = getSelectionFromWidget();
		390
		391	if( l.size() > 1 \|\| ! l.contains(cell.getElement()) ) {
		392	setSelection(new StructuredSelection(cell.getElement()));
		393	}
		394
		395	fireEditorActivationEvent(new EditorActivationEvent(cell));
		396	getControl().setRedraw(true);
		397	}
		398	}
		399	}
375	}	400	}
376	}	401	}
377		402
		403	/**
		404	* Invoking this method fires an editor activation event which tries to enable the editor
		405	* but before this event is passed to {@link EditorActivationStrategy} to see
		406	* if this event should really trigger editor activation
		407	* @param event the activation event
		408	*/
		409	protected void fireEditorActivationEvent(EditorActivationEvent event) {
		410	viewerEditor.handleEditorActivationEvent(event);
		411	}
		412
378	/**	413	/**
379	* Return the CellEditors for the receiver, or <code>null</code> if no	414	* Return the CellEditors for the receiver, or <code>null</code> if no
380	* cell editors are set.	415	* cell editors are set.
Lines 546-551 Link Here
546	}	581	}
547		582
548	/**	583	/**
		584	* To fully control the strategy used to control on which cell-selection
		585	* events the editor has to be activated you can pass your customized
		586	* strategy using this method.
		587	*
		588	* @param editorActivationStrategy
		589	* the strategy used to activate an editor
		590	*/
		591	public void setEditorActivationStrategy(
		592	EditorActivationStrategy editorActivationStrategy) {
		593	if( viewerEditor != null ) {
		594	viewerEditor.setEditorActivationStrategy(editorActivationStrategy);
		595	} else {
		596	throw new IllegalStateException("This feature is not supported by the widget"); //$NON-NLS-1$
		597	}
		598	}
		599
		600	/**
		601	* Enable activation of cell editors by keyboard
		602	* @param enable <code>true</code> to enable
		603	*/
		604	public void setEnableEditorActivationWithKeyboard(boolean enable) {
		605	if( enable ) {
		606	if( keyboardActivationListener == null ) {
		607	keyboardActivationListener = new KeyListener() {
		608
		609	public void keyPressed(KeyEvent e) {
		610	ViewerCell cell = getFocusCell();
		611
		612	if( cell != null ) {
		613	fireEditorActivationEvent(new EditorActivationEvent(cell,e));
		614	}
		615	}
		616
		617	public void keyReleased(KeyEvent e) {
		618
		619	}
		620
		621	};
		622	getControl().addKeyListener(keyboardActivationListener);
		623	}
		624	} else {
		625	if( keyboardActivationListener != null ) {
		626	getControl().removeKeyListener(keyboardActivationListener);
		627	keyboardActivationListener = null;
		628	}
		629	}
		630	}
		631
		632	/**
		633	* @param listener
		634	*/
		635	public void addEditorActivationListner(AbstractViewerEditorActivationListener listener) {
		636	this.viewerEditor.addEditorActivationListener(listener);
		637	}
		638
		639	/**
		640	* @param listener
		641	*/
		642	public void removeEditorActivationListener(AbstractViewerEditorActivationListener listener) {
		643	this.viewerEditor.removeEditorActivationListener(listener);
		644	}
		645
		646	private void handleMouseDown(MouseEvent e) {
		647	ViewerCell cell = getCell(new Point(e.x,e.y));
648
649	if( cell != null ) {
650	fireEditorActivationEvent(new EditorActivationEvent(cell,e));
651	}
652	}
653
654	/**
655	* @return the cell currently focused or <code>null</code>
656	*/
657	protected abstract ViewerCell getFocusCell();
658
659	/**
549	* Returns the number of columns contained in the receiver. If no columns	660	* Returns the number of columns contained in the receiver. If no columns
550	* were created by the programmer, this value is zero, despite the fact that	661	* were created by the programmer, this value is zero, despite the fact that
551	* visually, one column of items may be visible. This occurs when the	662	* visually, one column of items may be visible. This occurs when the




import org.eclipse.swt.widgets.Control;

/**
 * Abstract base class for cell editors. Implements property change listener
 * handling, and SWT window management.
 * <p>
 * Subclasses implement particular kinds of cell editors. This package contains
 * various specialized cell editors:
 * <ul>
 * <li><code>TextCellEditor</code> - for simple text strings</li>
 * <li><code>ColorCellEditor</code> - for colors</li>
 * <li><code>ComboBoxCellEditor</code> - value selected from drop-down combo
 * box</li>
 * <li><code>CheckboxCellEditor</code> - boolean valued checkbox</li>
 * <li><code>DialogCellEditor</code> - value from arbitrary dialog</li>
 * </ul>
 * </p>
 */
public abstract class CellEditor {

	/**
	 * List of cell editor listeners (element type:
	 * <code>ICellEditorListener</code>).
	 */
	private ListenerList listeners = new ListenerList();

	/**
	 * List of cell editor property change listeners (element type:
	 * <code>IPropertyChangeListener</code>).
	 */
	private ListenerList propertyChangeListeners = new ListenerList();

	/**
	 * Indicates whether this cell editor's current value is valid.
	 */
	private boolean valid = false;

	/**
	 * Optional cell editor validator; <code>null</code> if none.
	 */
	private ICellEditorValidator validator = null;

	/**
	 * The error message string to display for invalid values; <code>null</code>
	 * if none (that is, the value is valid).
	 */
	private String errorMessage = null;

	/**
	 * Indicates whether this cell editor has been changed recently.
	 */
	private boolean dirty = false;

	/**
	 * This cell editor's control, or <code>null</code> if not created yet.
	 */
	private Control control = null;

	/**
	 * Default cell editor style
	 */
	private static final int defaultStyle = SWT.NONE;

	/**
	 * This cell editor's style
	 */
	private int style = defaultStyle;

	/**
	 * Struct-like layout data for cell editors, with reasonable defaults for
	 * all fields.
	 */
	public static class LayoutData {
		/**
		 * Horizontal alignment; <code>SWT.LEFT</code> by default.
		 */
		public int horizontalAlignment = SWT.LEFT;

		/**
		 * Indicates control grabs additional space; <code>true</code> by
		 * default.
		 */
		public boolean grabHorizontal = true;

		/**
		 * Minimum width in pixels; <code>50</code> pixels by default.
		 */
		public int minimumWidth = 50;
	}

	/**
	 * Property name for the copy action
	 */
	public static final String COPY = "copy"; //$NON-NLS-1$

	/**
	 * Property name for the cut action
	 */
	public static final String CUT = "cut"; //$NON-NLS-1$

	/**
	 * Property name for the delete action
	 */
	public static final String DELETE = "delete"; //$NON-NLS-1$

	/**
	 * Property name for the find action
	 */
	public static final String FIND = "find"; //$NON-NLS-1$

	/**
	 * Property name for the paste action
	 */
	public static final String PASTE = "paste"; //$NON-NLS-1$

	/**
	 * Property name for the redo action
	 */
	public static final String REDO = "redo"; //$NON-NLS-1$

	/**
	 * Property name for the select all action
	 */
	public static final String SELECT_ALL = "selectall"; //$NON-NLS-1$

	/**
	 * Property name for the undo action
	 */
	public static final String UNDO = "undo"; //$NON-NLS-1$

	/**
	 * Creates a new cell editor with no control The cell editor has no cell
	 * validator.
	 * 
	 * @since 2.1
	 */
	protected CellEditor() {
	}

	/**
	 * Creates a new cell editor under the given parent control. The cell editor
	 * has no cell validator.
	 * 
	 * @param parent
	 *            the parent control
	 */
	protected CellEditor(Composite parent) {
		this(parent, defaultStyle);
	}

	/**
	 * Creates a new cell editor under the given parent control. The cell editor
	 * has no cell validator.
	 * 
	 * @param parent
	 *            the parent control
	 * @param style
	 *            the style bits
	 * @since 2.1
	 */
	protected CellEditor(Composite parent, int style) {
		this.style = style;
		create(parent);
	}

	/**
	 * Activates this cell editor.
	 * <p>
	 * The default implementation of this framework method does nothing.
	 * Subclasses may reimplement.
	 * </p>
	 */
	public void activate() {
	}

	/**
	 * Activate the editor but also inform the editor which event triggered its activation.
	 * <b>The default implementation simply calls {@link #activate()}</b>
	 * 
	 * @param activationEvent the editor activation event
	 */
	public void activate(EditorActivationEvent activationEvent) {
		activate();
	}

	/**
	 * Adds a listener to this cell editor. Has no effect if an identical
	 * listener is already registered.
	 * 
	 * @param listener
	 *            a cell editor listener
	 */
	public void addListener(ICellEditorListener listener) {
		listeners.add(listener);
	}

	/**
	 * Adds a property change listener to this cell editor. Has no effect if an
	 * identical property change listener is already registered.
	 * 
	 * @param listener
	 *            a property change listener
	 */
	public void addPropertyChangeListener(IPropertyChangeListener listener) {
		propertyChangeListeners.add(listener);
	}

	/**
	 * Creates the control for this cell editor under the given parent control.
	 * <p>
	 * This framework method must be implemented by concrete subclasses.
	 * </p>
	 * 
	 * @param parent
	 *            the parent control
	 * @return the new control, or <code>null</code> if this cell editor has
	 *         no control
	 */
	protected abstract Control createControl(Composite parent);

	/**
	 * Creates the control for this cell editor under the given parent control.
	 * 
	 * @param parent
	 *            the parent control
	 * @since 2.1
	 */
	public void create(Composite parent) {
		Assert.isTrue(control == null);
		control = createControl(parent);
		// See 1GD5CA6: ITPUI:ALL - TaskView.setSelection does not work
		// Control is created with getVisible()==true by default.
		// This causes composite.setFocus() to work incorrectly.
		// The cell editor's control grabs focus instead, even if it is not
		// active.
		// Make the control invisible here by default.
		deactivate();
	}

	/**
	 * Hides this cell editor's control. Does nothing if this cell editor is not
	 * visible.
	 */
	public void deactivate() {
		if (control != null && !control.isDisposed()) {
			control.setVisible(false);
		}
	}

	/**
	 * Disposes of this cell editor and frees any associated SWT resources.
	 */
	public void dispose() {
		if (control != null && !control.isDisposed()) {
			control.dispose();
		}
		control = null;
	}

	/**
	 * Returns this cell editor's value.
	 * <p>
	 * This framework method must be implemented by concrete subclasses.
	 * </p>
	 * 
	 * @return the value of this cell editor
	 * @see #getValue
	 */
	protected abstract Object doGetValue();

	/**
	 * Sets the focus to the cell editor's control.
	 * <p>
	 * This framework method must be implemented by concrete subclasses.
	 * </p>
	 * 
	 * @see #setFocus
	 */
	protected abstract void doSetFocus();

	/**
	 * Sets this cell editor's value.
	 * <p>
	 * This framework method must be implemented by concrete subclasses.
	 * </p>
	 * 
	 * @param value
	 *            the value of this cell editor
	 * @see #setValue
	 */
	protected abstract void doSetValue(Object value);

	/**
	 * Notifies all registered cell editor listeners of an apply event. Only
	 * listeners registered at the time this method is called are notified.
	 * 
	 * @see ICellEditorListener#applyEditorValue
	 */
	protected void fireApplyEditorValue() {
		Object[] array = listeners.getListeners();
		for (int i = 0; i < array.length; i++) {
			final ICellEditorListener l = (ICellEditorListener) array[i];
			SafeRunnable.run(new SafeRunnable() {
				public void run() {
					l.applyEditorValue();
				}
			});
		}
	}

	/**
	 * Notifies all registered cell editor listeners that editing has been
	 * canceled.
	 * 
	 * @see ICellEditorListener#cancelEditor
	 */
	protected void fireCancelEditor() {
		Object[] array = listeners.getListeners();
		for (int i = 0; i < array.length; i++) {
			final ICellEditorListener l = (ICellEditorListener) array[i];
			SafeRunnable.run(new SafeRunnable() {
				public void run() {
					l.cancelEditor();
				}
			});
		}
	}

	/**
	 * Notifies all registered cell editor listeners of a value change.
	 * 
	 * @param oldValidState
	 *            the valid state before the end user changed the value
	 * @param newValidState
	 *            the current valid state
	 * @see ICellEditorListener#editorValueChanged
	 */
	protected void fireEditorValueChanged(final boolean oldValidState,
			final boolean newValidState) {
		Object[] array = listeners.getListeners();
		for (int i = 0; i < array.length; i++) {
			final ICellEditorListener l = (ICellEditorListener) array[i];
			SafeRunnable.run(new SafeRunnable() {
				public void run() {
					l.editorValueChanged(oldValidState, newValidState);
				}
			});
		}
	}

	/**
	 * Notifies all registered property listeners of an enablement change.
	 * 
	 * @param actionId
	 *            the id indicating what action's enablement has changed.
	 */
	protected void fireEnablementChanged(final String actionId) {
		Object[] array = propertyChangeListeners.getListeners();
		for (int i = 0; i < array.length; i++) {
			final IPropertyChangeListener l = (IPropertyChangeListener) array[i];
			SafeRunnable.run(new SafeRunnable() {
				public void run() {
					l.propertyChange(new PropertyChangeEvent(this, actionId,
							null, null));
				}
			});
		}
	}

	/**
	 * Sets the style bits for this cell editor.
	 * 
	 * @param style
	 *            the SWT style bits for this cell editor
	 * @since 2.1
	 */
	public void setStyle(int style) {
		this.style = style;
	}

	/**
	 * Returns the style bits for this cell editor.
	 * 
	 * @return the style for this cell editor
	 * @since 2.1
	 */
	public int getStyle() {
		return style;
	}

	/**
	 * Returns the control used to implement this cell editor.
	 * 
	 * @return the control, or <code>null</code> if this cell editor has no
	 *         control
	 */
	public Control getControl() {
		return control;
	}

	/**
	 * Returns the current error message for this cell editor.
	 * 
	 * @return the error message if the cell editor is in an invalid state, and
	 *         <code>null</code> if the cell editor is valid
	 */
	public String getErrorMessage() {
		return errorMessage;
	}

	/**
	 * Returns a layout data object for this cell editor. This is called each
	 * time the cell editor is activated and controls the layout of the SWT
	 * table editor.
	 * <p>
	 * The default implementation of this method sets the minimum width to the
	 * control's preferred width. Subclasses may extend or reimplement.
	 * </p>
	 * 
	 * @return the layout data object
	 */
	public LayoutData getLayoutData() {
		LayoutData result = new LayoutData();
		Control control = getControl();
		if (control != null) {
			result.minimumWidth = control.computeSize(SWT.DEFAULT, SWT.DEFAULT,
					true).x;
		}
		return result;
	}

	/**
	 * Returns the input validator for this cell editor.
	 * 
	 * @return the input validator, or <code>null</code> if none
	 */
	public ICellEditorValidator getValidator() {
		return validator;
	}

	/**
	 * Returns this cell editor's value provided that it has a valid one.
	 * 
	 * @return the value of this cell editor, or <code>null</code> if the cell
	 *         editor does not contain a valid value
	 */
	public final Object getValue() {
		if (!valid) {
			return null;
		}

		return doGetValue();
	}

	/**
	 * Returns whether this cell editor is activated.
	 * 
	 * @return <code>true</code> if this cell editor's control is currently
	 *         activated, and <code>false</code> if not activated
	 */
	public boolean isActivated() {
		// Use the state of the visible style bit (getVisible()) rather than the
		// window's actual visibility (isVisible()) to get correct handling when
		// an ancestor control goes invisible, see bug 85331.
		return control != null && control.getVisible();
	}

	/**
	 * Returns <code>true</code> if this cell editor is able to perform the
	 * copy action.
	 * <p>
	 * This default implementation always returns <code>false</code>.
	 * </p>
	 * <p>
	 * Subclasses may override
	 * </p>
	 * 
	 * @return <code>true</code> if copy is possible, <code>false</code>
	 *         otherwise
	 */
	public boolean isCopyEnabled() {
		return false;
	}

	/**
	 * Returns whether the given value is valid for this cell editor. This cell
	 * editor's validator (if any) makes the actual determination.
	 * 
	 * @param value
	 *            the value to check for
	 * 
	 * @return <code>true</code> if the value is valid, and <code>false</code>
	 *         if invalid
	 */
	protected boolean isCorrect(Object value) {
		errorMessage = null;
		if (validator == null) {
			return true;
		}

		errorMessage = validator.isValid(value);
		return (errorMessage == null || errorMessage.equals(""));//$NON-NLS-1$
	}

	/**
	 * Returns <code>true</code> if this cell editor is able to perform the
	 * cut action.
	 * <p>
	 * This default implementation always returns <code>false</code>.
	 * </p>
	 * <p>
	 * Subclasses may override
	 * </p>
	 * 
	 * @return <code>true</code> if cut is possible, <code>false</code>
	 *         otherwise
	 */
	public boolean isCutEnabled() {
		return false;
	}

	/**
	 * Returns <code>true</code> if this cell editor is able to perform the
	 * delete action.
	 * <p>
	 * This default implementation always returns <code>false</code>.
	 * </p>
	 * <p>
	 * Subclasses may override
	 * </p>
	 * 
	 * @return <code>true</code> if delete is possible, <code>false</code>
	 *         otherwise
	 */
	public boolean isDeleteEnabled() {
		return false;
	}

	/**
	 * Returns whether the value of this cell editor has changed since the last
	 * call to <code>setValue</code>.
	 * 
	 * @return <code>true</code> if the value has changed, and
	 *         <code>false</code> if unchanged
	 */
	public boolean isDirty() {
		return dirty;
	}

	/**
	 * Marks this cell editor as dirty.
	 * 
	 * @since 2.1
	 */
	protected void markDirty() {
		dirty = true;
	}

	/**
	 * Returns <code>true</code> if this cell editor is able to perform the
	 * find action.
	 * <p>
	 * This default implementation always returns <code>false</code>.
	 * </p>
	 * <p>
	 * Subclasses may override
	 * </p>
	 * 
	 * @return <code>true</code> if find is possible, <code>false</code>
	 *         otherwise
	 */
	public boolean isFindEnabled() {
		return false;
	}

	/**
	 * Returns <code>true</code> if this cell editor is able to perform the
	 * paste action.
	 * <p>
	 * This default implementation always returns <code>false</code>.
	 * </p>
	 * <p>
	 * Subclasses may override
	 * </p>
	 * 
	 * @return <code>true</code> if paste is possible, <code>false</code>
	 *         otherwise
	 */
	public boolean isPasteEnabled() {
		return false;
	}

	/**
	 * Returns <code>true</code> if this cell editor is able to perform the
	 * redo action.
	 * <p>
	 * This default implementation always returns <code>false</code>.
	 * </p>
	 * <p>
	 * Subclasses may override
	 * </p>
	 * 
	 * @return <code>true</code> if redo is possible, <code>false</code>
	 *         otherwise
	 */
	public boolean isRedoEnabled() {
		return false;
	}

	/**
	 * Returns <code>true</code> if this cell editor is able to perform the
	 * select all action.
	 * <p>
	 * This default implementation always returns <code>false</code>.
	 * </p>
	 * <p>
	 * Subclasses may override
	 * </p>
	 * 
	 * @return <code>true</code> if select all is possible, <code>false</code>
	 *         otherwise
	 */
	public boolean isSelectAllEnabled() {
		return false;
	}

	/**
	 * Returns <code>true</code> if this cell editor is able to perform the
	 * undo action.
	 * <p>
	 * This default implementation always returns <code>false</code>.
	 * </p>
	 * <p>
	 * Subclasses may override
	 * </p>
	 * 
	 * @return <code>true</code> if undo is possible, <code>false</code>
	 *         otherwise
	 */
	public boolean isUndoEnabled() {
		return false;
	}

	/**
	 * Returns whether this cell editor has a valid value. The default value is
	 * false.
	 * 
	 * @return <code>true</code> if the value is valid, and <code>false</code>
	 *         if invalid
	 * 
	 * @see #setValueValid(boolean)
	 */
	public boolean isValueValid() {
		return valid;
	}

	/**
	 * Processes a key release event that occurred in this cell editor.
	 * <p>
	 * The default implementation of this framework method cancels editing when
	 * the ESC key is pressed. When the RETURN key is pressed the current value
	 * is applied and the cell editor deactivates. Subclasses should call this
	 * method at appropriate times. Subclasses may also extend or reimplement.
	 * </p>
	 * 
	 * @param keyEvent
	 *            the key event
	 */
	protected void keyReleaseOccured(KeyEvent keyEvent) {
		if (keyEvent.character == '\u001b') { // Escape character
			fireCancelEditor();
		} else if (keyEvent.character == '\r') { // Return key
			fireApplyEditorValue();
			deactivate();
		}
	}

	/**
	 * Processes a focus lost event that occurred in this cell editor.
	 * <p>
	 * The default implementation of this framework method applies the current
	 * value and deactivates the cell editor. Subclasses should call this method
	 * at appropriate times. Subclasses may also extend or reimplement.
	 * </p>
	 */
	protected void focusLost() {
		if (isActivated()) {
			fireApplyEditorValue();
			deactivate();
		}
	}

	/**
	 * Performs the copy action. This default implementation does nothing.
	 * <p>
	 * Subclasses may override
	 * </p>
	 */
	public void performCopy() {
	}

	/**
	 * Performs the cut action. This default implementation does nothing.
	 * <p>
	 * Subclasses may override
	 * </p>
	 */
	public void performCut() {
	}

	/**
	 * Performs the delete action. This default implementation does nothing.
	 * <p>
	 * Subclasses may override
	 * </p>
	 */
	public void performDelete() {
	}

	/**
	 * Performs the find action. This default implementation does nothing.
	 * <p>
	 * Subclasses may override
	 * </p>
	 */
	public void performFind() {
	}

	/**
	 * Performs the paste action. This default implementation does nothing.
	 * <p>
	 * Subclasses may override
	 * </p>
	 */
	public void performPaste() {
	}

	/**
	 * Performs the redo action. This default implementation does nothing.
	 * <p>
	 * Subclasses may override
	 * </p>
	 */
	public void performRedo() {
	}

	/**
	 * Performs the select all action. This default implementation does nothing.
	 * <p>
	 * Subclasses may override
	 * </p>
	 */
	public void performSelectAll() {
	}

	/**
	 * Performs the undo action. This default implementation does nothing.
	 * <p>
	 * Subclasses may override
	 * </p>
	 */
	public void performUndo() {
	}

	/**
	 * Removes the given listener from this cell editor. Has no affect if an
	 * identical listener is not registered.
	 * 
	 * @param listener
	 *            a cell editor listener
	 */
	public void removeListener(ICellEditorListener listener) {
		listeners.remove(listener);
	}

	/**
	 * Removes the given property change listener from this cell editor. Has no
	 * affect if an identical property change listener is not registered.
	 * 
	 * @param listener
	 *            a property change listener
	 */
	public void removePropertyChangeListener(IPropertyChangeListener listener) {
		propertyChangeListeners.remove(listener);
	}

	/**
	 * Sets or clears the current error message for this cell editor.
	 * <p>
	 * No formatting is done here, the message to be set is expected to be fully
	 * formatted before being passed in.
	 * </p>
	 * 
	 * @param message
	 *            the error message, or <code>null</code> to clear
	 */
	protected void setErrorMessage(String message) {
		errorMessage = message;
	}

	/**
	 * Sets the focus to the cell editor's control.
	 */
	public void setFocus() {
		doSetFocus();
	}

	/**
	 * Sets the input validator for this cell editor.
	 * 
	 * @param validator
	 *            the input validator, or <code>null</code> if none
	 */
	public void setValidator(ICellEditorValidator validator) {
		this.validator = validator;
	}

	/**
	 * Sets this cell editor's value.
	 * 
	 * @param value
	 *            the value of this cell editor
	 */
	public final void setValue(Object value) {
		valid = isCorrect(value);
		dirty = false;
		doSetValue(value);
	}

	/**
	 * Sets the valid state of this cell editor. The default value is false.
	 * Subclasses should call this method on construction.
	 * 
	 * @param valid
	 *            <code>true</code> if the current valie is valid, and
	 *            <code>false</code> if invalid
	 * 
	 * @see #isValueValid
	 */
	protected void setValueValid(boolean valid) {
		this.valid = valid;
	}

	/**
	 * The value has changed. Updates the valid state flag, marks this cell
	 * editor as dirty, and notifies all registered cell editor listeners of a
	 * value change.
	 * 
	 * @param oldValidState
	 *            the valid state before the end user changed the value
	 * @param newValidState
	 *            the current valid state
	 * @see ICellEditorListener#editorValueChanged
	 */
	protected void valueChanged(boolean oldValidState, boolean newValidState) {
		valid = newValidState;
		dirty = true;
		fireEditorValueChanged(oldValidState, newValidState);
	}
    }
}

Lines 14-19 Link Here

(-)src/org/eclipse/jface/viewers/AbstractViewerEditor.java (-114 / +105 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 static EditorActivationStrategy defaultStrategy = new EditorActivationStrategy() {
		69	protected boolean isEditorActivationEvent(EditorActivationEvent event) {
		70	return event.eventType == EditorActivationEvent.MOUSE_CLICK_SELECTION
		71	\|\| event.eventType == EditorActivationEvent.PROGRAMATIC
		72	\|\| event.eventType == EditorActivationEvent.TRAVERSAL;
		73	}
		74	};
		75
		76	private EditorActivationStrategy editorActivationStrategy = defaultStrategy;
		77
65	/**	78	/**
66	* Create a new editor implementation for the viewer	79	* Create a new editor implementation for the viewer
67	*	80	*
Lines 92-104 Link Here
92		105
93	void activateCellEditor() {	106	void activateCellEditor() {
94		107
95	ViewerColumn part = viewer.getViewerColumn(columnNumber);	108	ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
96	Object element = item.getData();	109	Object element = cell.getElement();
97		110
98	if (part != null && part.getEditingSupport() != null	111	if (part != null && part.getEditingSupport() != null
99	&& part.getEditingSupport().canEdit(element)) {	112	&& part.getEditingSupport().canEdit(element)) {
100	cellEditor = part.getEditingSupport().getCellEditor(element);	113	cellEditor = part.getEditingSupport().getCellEditor(element);
101	if (cellEditor != null) {	114	if (cellEditor != null) {
		115	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		116	Object[] ls = editorActivationListener.getListeners();
		117	for( int i = 0; i < ls.length; i++ ) {
		118	((AbstractViewerEditorActivationListener)ls[i]).beforeEditorActivated(activationEvent);
		119	}
		120	}
		121
102	cellEditor.addListener(cellEditorListener);	122	cellEditor.addListener(cellEditorListener);
103	Object value = part.getEditingSupport().getValue(element);	123	Object value = part.getEditingSupport().getValue(element);
104	cellEditor.setValue(value);	124	cellEditor.setValue(value);
Lines 108-119 Link Here
108	// so must get control first, but must still call activate()	128	// so must get control first, but must still call activate()
109	// even if there is no control.	129	// even if there is no control.
110	final Control control = cellEditor.getControl();	130	final Control control = cellEditor.getControl();
111	cellEditor.activate();	131	cellEditor.activate(activationEvent);
112	if (control == null) {	132	if (control == null) {
113	return;	133	return;
114	}	134	}
115	setLayoutData(cellEditor.getLayoutData());	135	setLayoutData(cellEditor.getLayoutData());
116	setEditor(control, item, columnNumber);	136	setEditor(control, cell.getItem(), cell.getColumnIndex());
117	cellEditor.setFocus();	137	cellEditor.setFocus();
118	if (focusListener == null) {	138	if (focusListener == null) {
119	focusListener = new FocusAdapter() {	139	focusListener = new FocusAdapter() {
Lines 128-134 Link Here
128	public void mouseDown(MouseEvent e) {	148	public void mouseDown(MouseEvent e) {
129	// time wrap?	149	// time wrap?
130	// check for expiration of doubleClickTime	150	// check for expiration of doubleClickTime
131	if (e.time <= doubleClickExpirationTime) {	151	if (e.time <= activationTime) {
132	control.removeMouseListener(mouseListener);	152	control.removeMouseListener(mouseListener);
133	cancelEditing();	153	cancelEditing();
134	handleDoubleClickEvent();	154	handleDoubleClickEvent();
Lines 143-195 Link Here
143	tabeditingListener = new TraverseListener() {	163	tabeditingListener = new TraverseListener() {
144		164
145	public void keyTraversed(TraverseEvent e) {	165	public void keyTraversed(TraverseEvent e) {
146	ViewerColumn col = viewer.getViewerColumn(columnNumber);	166	ViewerColumn col = viewer.getViewerColumn(cell.getColumnIndex());
147	if ( col != null && col.getEditingSupport().isTabingSupported() ) {	167	if ( col != null && col.getEditingSupport().isTabingSupported() ) {
148	col.getEditingSupport().processTraversEvent(	168	col.getEditingSupport().processTraversEvent(
149	columnNumber,	169	cell.getColumnIndex(),
150	viewer.getViewerRowFromItem(item), e);	170	viewer.getViewerRowFromItem(cell.getItem()), e);
151	}	171	}
152	}	172	}
153	};	173	};
154	}	174	}
155		175
156	control.addTraverseListener(tabeditingListener);	176	control.addTraverseListener(tabeditingListener);
157		177
158	}	178	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
159	}	179	Object[] ls = editorActivationListener.getListeners();
160	}	180	for( int i = 0; i < ls.length; i++ ) {
161		181	((AbstractViewerEditorActivationListener)ls[i]).afterEditorActivated(activationEvent);
162	/**	182	}
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	}	183	}
185	}	184	}
186	if (columnToEdit == -1) {
187	return;
188	}
189	}	185	}
190
191	columnNumber = columnToEdit;
192	activateCellEditor();
193	}	186	}
194		187
195	/**	188	/**
Lines 203-210 Link Here
203	// in case save results in applyEditorValue being re-entered	196	// in case save results in applyEditorValue being re-entered
204	// see 1GAHI8Z: ITPUI:ALL - How to code event notification when	197	// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
205	// using cell editor ?	198	// using cell editor ?
		199
		200	EditorDeactivationEvent tmp = new EditorDeactivationEvent(cell);
		201	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		202	Object[] ls = editorActivationListener.getListeners();
		203	for( int i = 0; i < ls.length; i++ ) {
		204	((AbstractViewerEditorActivationListener)ls[i]).beforeEditorDeactivated(tmp);
		205	}
		206	}
		207
206	this.cellEditor = null;	208	this.cellEditor = null;
207	Item t = this.item;	209	this.activationEvent = null;
		210	Item t = this.cell.getItem();
208	// don't null out table item -- same item is still selected	211	// don't null out table item -- same item is still selected
209	if (t != null && !t.isDisposed()) {	212	if (t != null && !t.isDisposed()) {
210	saveEditorValue(c, t);	213	saveEditorValue(c, t);
Lines 227-232 Link Here
227	}	230	}
228	}	231	}
229	c.deactivate();	232	c.deactivate();
		233
		234	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		235	Object[] ls = editorActivationListener.getListeners();
		236	for( int i = 0; i < ls.length; i++ ) {
		237	((AbstractViewerEditorActivationListener)ls[i]).afterEditorDeactivated(tmp);
		238	}
		239	}
230	}	240	}
231	}	241	}
232		242
Lines 235-240 Link Here
235	*/	245	*/
236	void cancelEditing() {	246	void cancelEditing() {
237	if (cellEditor != null) {	247	if (cellEditor != null) {
		248	EditorDeactivationEvent tmp = new EditorDeactivationEvent(cell);
		249	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		250	Object[] ls = editorActivationListener.getListeners();
		251	for( int i = 0; i < ls.length; i++ ) {
		252	((AbstractViewerEditorActivationListener)ls[i]).beforeEditorDeactivated(tmp);
		253	}
		254	}
		255
238	setEditor(null, null, 0);	256	setEditor(null, null, 0);
239	cellEditor.removeListener(cellEditorListener);	257	cellEditor.removeListener(cellEditorListener);
240		258
Lines 256-325 Link Here
256		274
257	CellEditor oldEditor = cellEditor;	275	CellEditor oldEditor = cellEditor;
258	cellEditor = null;	276	cellEditor = null;
		277	activationEvent=null;
259	oldEditor.deactivate();	278	oldEditor.deactivate();
		279
		280	if( editorActivationListener != null && ! editorActivationListener.isEmpty() ) {
		281	Object[] ls = editorActivationListener.getListeners();
		282	for( int i = 0; i < ls.length; i++ ) {
		283	((AbstractViewerEditorActivationListener)ls[i]).afterEditorDeactivated(tmp);
		284	}
		285	}
260	}	286	}
261	}	287	}
262		288
263	/**	289	/**
264	* Enable the editor by mouse down	290	* Enable the editor by mouse down
265	*	291	*
266	* @param event	292	* @param event
267	*/	293	*/
268	void handleMouseDown(MouseEvent event) {	294	void handleEditorActivationEvent(EditorActivationEvent event) {
269	if (event.button != 1) {	295	if( editorActivationStrategy.isEditorActivationEvent(event) ) {
270	return;	296	if (cellEditor != null) {
271	}	297	applyEditorValue();
272		298	}
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		299
306	setSelection(createSelection(element), true);	300	this.cell = (ViewerCell)event.getSource();
307	Item[] selection = getSelection();	301	activationEvent = event;
308	if (selection.length != 1) {	302	activationTime = event.time + Display.getCurrent().getDoubleClickTime();
309	return;	303
		304	activateCellEditor();
310	}	305	}
311
312	item = selection[0];
313
314	// Make sure selection is visible
315	showSelection();
316	columnNumber = column;
317	activateCellEditor();
318
319	}	306	}
320		307
321	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {	308	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
322	ViewerColumn part = viewer.getViewerColumn(columnNumber);	309	ViewerColumn part = viewer.getViewerColumn(cell.getColumnIndex());
323		310
324	if (part != null && part.getEditingSupport() != null) {	311	if (part != null && part.getEditingSupport() != null) {
325	part.getEditingSupport().setValue(tableItem.getData(),	312	part.getEditingSupport().setValue(tableItem.getData(),
Lines 391-406 Link Here
391	return cellEditors;	378	return cellEditors;
392	}	379	}
393		380
394	void setSelection(StructuredSelection selection, boolean b) {
395	viewer.setSelection(selection, b);
396	}
397
398	void handleDoubleClickEvent() {	381	void handleDoubleClickEvent() {
399	viewer.fireDoubleClick(new DoubleClickEvent(viewer, viewer	382	viewer.fireDoubleClick(new DoubleClickEvent(viewer, viewer
400	.getSelection()));	383	.getSelection()));
401	viewer.fireOpen(new OpenEvent(viewer, viewer.getSelection()));	384	viewer.fireOpen(new OpenEvent(viewer, viewer.getSelection()));
402	}	385	}
403		386
		387	void addEditorActivationListener(AbstractViewerEditorActivationListener listener) {
		388	if( editorActivationListener == null ) {
		389	editorActivationListener = new ListenerList();
		390	}
		391	editorActivationListener.add(listener);
		392	}
		393
		394	void removeEditorActivationListener(AbstractViewerEditorActivationListener listener) {
		395	if( editorActivationListener != null ) {
		396	editorActivationListener.remove(listener);
		397	}
		398	}
		399
		400	void setEditorActivationStrategy(
		401	EditorActivationStrategy editorActivationStrategy) {
		402	this.editorActivationStrategy = editorActivationStrategy;
		403	}
		404
404	/**	405	/**
405	* Create a selection for this model element	406	* Create a selection for this model element
406	*	407	*
Lines 429-442 Link Here
429	* the layout data used when editor is displayed	430	* the layout data used when editor is displayed
430	*/	431	*/
431	protected abstract void setLayoutData(CellEditor.LayoutData layoutData);	432	protected abstract void setLayoutData(CellEditor.LayoutData layoutData);
432
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	}	433	}




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

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;

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

}




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

package org.eclipse.jface.viewers;

import java.util.EventObject;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * This class is responsible to determin if a cell selection event is triggers
 * an editor activation
 * 
 * @since 3.3
 */
public abstract class EditorActivationStrategy {
	/**
	 * @param event
	 * @return bla bl
	 */
	protected abstract boolean isEditorActivationEvent(EditorActivationEvent event);
}

Lines 4-10 Link Here

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

Lines 1-29 Link Here

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




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

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

import org.eclipse.jface.viewers.AbstractTableViewer;
import org.eclipse.jface.viewers.AbstractViewerEditor;
import org.eclipse.jface.viewers.BaseTableViewer;
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 AbstractViewerEditor createViewerEditor() 
    {
        return new AbstractViewerEditor(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);
		}
	}

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




/*******************************************************************************
 * 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.AbstractViewerEditor;
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 AbstractViewerEditor createViewerEditor()
    {
        return new AbstractViewerEditor(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
        
    }
}

Lines 6675-6681 Link Here

(-)src/org/eclipse/swt/nebula/widgets/grid/Grid.java (-1 / +1 lines)
6675	/**	6675	/**
6676	* Returns the current cell in focus. If cell selection is disabled, this method returns null.	6676	* Returns the current cell in focus. If cell selection is disabled, this method returns null.
6677	*	6677	*
6678	* @return cell in focus or {@code null}.	6678	* @return cell in focus or {@code null}. x represents the column and y the row the cell is in
6679	* @throws org.eclipse.swt.SWTException	6679	* @throws org.eclipse.swt.SWTException
6680	* <ul>	6680	* <ul>
6681	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>	6681	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

Lines 1-3 Link Here

(-).settings/org.eclipse.jdt.ui.prefs (-1 / +1 lines)
1	#Thu Jun 01 15:04:52 EDT 2006	1	#Thu Feb 01 11:43:25 CET 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/*\r\n @return the ${bare_field_name}\r\n /</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/\r\n @param ${param} the ${bare_field_name} to set\r\n /</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/\r\n ${tags}\r\n /</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*****************************************************************************\r\n Copyright (c) ${year} ${todo}\r\n * All rights reserved. This program and the accompanying materials\r\n * are made available under the terms of the Eclipse Public License v1.0\r\n * which accompanies this distribution, and is available at\r\n * http\://www.eclipse.org/legal/epl-v10.html\r\n \r\n Contributors\:\r\n * ${user} - initial API and implementation\r\n *****************************************************************************/ \r\n</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/\r\n * \r\n \r\n @author ${user}\r\n /</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/\r\n \r\n /</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/\r\n ${tags}\r\n /</template><template autoinsert\="false" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/* \r\n * {@inheritDoc}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="classbody_context" deleted\="false" description\="Code in new class type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.classbody" name\="classbody">\r\n</template><template autoinsert\="true" context\="interfacebody_context" deleted\="false" description\="Code in new interface type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.interfacebody" name\="interfacebody">\r\n</template><template autoinsert\="true" context\="enumbody_context" deleted\="false" description\="Code in new enum type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.enumbody" name\="enumbody">\r\n</template><template autoinsert\="true" context\="annotationbody_context" deleted\="false" description\="Code in new annotation type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.annotationbody" name\="annotationbody">\r\n</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates>	3	org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/*\r\n @return the ${bare_field_name}\r\n /</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/\r\n @param ${param} the ${bare_field_name} to set\r\n /</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/\r\n ${tags}\r\n /</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*****************************************************************************\r\n Copyright (c) ${year} ${todo}\r\n * All rights reserved. This program and the accompanying materials\r\n * are made available under the terms of the Eclipse Public License v1.0\r\n * which accompanies this distribution, and is available at\r\n * http\://www.eclipse.org/legal/epl-v10.html\r\n \r\n Contributors\:\r\n * ${user} - initial API and implementation\r\n *****************************************************************************/ \r\n</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/\r\n * \r\n \r\n @author ${user}\r\n /</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/\r\n \r\n /</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/\r\n ${tags}\r\n /</template><template autoinsert\="false" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/* \r\n * {@inheritDoc}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="classbody_context" deleted\="false" description\="Code in new class type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.classbody" name\="classbody">\r\n</template><template autoinsert\="true" context\="interfacebody_context" deleted\="false" description\="Code in new interface type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.interfacebody" name\="interfacebody">\r\n</template><template autoinsert\="true" context\="enumbody_context" deleted\="false" description\="Code in new enum type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.enumbody" name\="enumbody">\r\n</template><template autoinsert\="true" context\="annotationbody_context" deleted\="false" description\="Code in new annotation type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.annotationbody" name\="annotationbody">\r\n</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates>




#Thu Feb 01 16:16:19 CET 2007
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.1

org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.doc.comment.support=enabled
org.eclipse.jdt.core.compiler.problem.assertIdentifier=ignore
org.eclipse.jdt.core.compiler.problem.enumIdentifier=ignore
org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
org.eclipse.jdt.core.compiler.source=1.3

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.EditorActivationStrategy;
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.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"});
		
		v.setEditorActivationStrategy(new EditorActivationStrategy() {
			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;
			}
		});
		v.setEnableEditorActivationWithKeyboard(true);
		v.setTabEditingStyle(EditingSupport.TABING_HORIZONTAL|EditingSupport.TABING_MOVE_TO_ROW_NEIGHBOR|EditingSupport.TABING_VERTICAL);
		
		GridColumn column = new GridColumn(v.getGrid(), SWT.NONE);
		column.setWidth(200);
		column.setText("Column 1");

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

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

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

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

		return elements;
	}

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

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

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

		display.dispose();

	}

}

Return to bug 172646

Lines 134-143 Link Here

(-)src/org/eclipse/jface/viewers/TableViewer.java (-9 / +7 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 303-306 Link Here
303	protected void doClear(int index) {	295	protected void doClear(int index) {
304	table.clear(index);	296	table.clear(index);
305	}	297	}
306	}	298
		299
		300	protected ViewerCell getFocusCell() {
		301	//TODO Focus tracking has to be implemented in M6
		302	return null;
		303	}
		304	}

Lines 284-293 Link Here

(-)src/org/eclipse/jface/viewers/TreeViewer.java (-8 / +5 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
Lines 913-916 Link Here
913	protected int doGetColumnCount() {	905	protected int doGetColumnCount() {
914	return tree.getColumnCount();	906	return tree.getColumnCount();
915	}	907	}
		908
		909	protected ViewerCell getFocusCell() {
		910	//TODO Focus tracking has to be implemented in M6
		911	return null;
		912	}
916	}	913	}

Added Link Here

(-)src/org/eclipse/jface/viewers/EditorDeactivationEvent.java (+36 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	* @param source
31	*/
32	public EditorDeactivationEvent(Object source) {
33	super(source);
34	}
35
36	}

Added Link Here

(-)src/org/eclipse/jface/viewers/EditorActivationEvent.java (+159 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import 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	* This constructor can be used when no event exists. The type set is
97	* {@link #PROGRAMATIC}
98	*
99	* @param cell
100	* the cell
101	*/
102	public EditorActivationEvent(ViewerCell cell) {
103	super(cell);
104	eventType = PROGRAMATIC;
105	}
106
107	/**
108	* This constructor is used for all types of mouse events. Currently the
109	* type is can be {@link #MOUSE_CLICK_SELECTION} and
110	* {@link #MOUSE_DOUBLE_CLICK_SELECTION}
111	*
112	* @param cell
113	* the cell source of the event
114	* @param event
115	* the event
116	*/
117	public EditorActivationEvent(ViewerCell cell, MouseEvent event) {
118	super(cell);
119
120	if (event.count >= 2) {
121	eventType = MOUSE_DOUBLE_CLICK_SELECTION;
122	} else {
123	eventType = MOUSE_CLICK_SELECTION;
124	}
125
126	this.sourceEvent = event;
127	this.time = event.time;
128	}
129
130	/**
131	* @param cell
132	* the cell source of the event
133	* @param event
134	* the event
135	*/
136	public EditorActivationEvent(ViewerCell cell, KeyEvent event) {
137	super(cell);
138	this.eventType = KEY_PRESSED;
139	this.sourceEvent = event;
140	this.time = 0;
141	this.keyCode = event.keyCode;
142	this.character = event.character;
143	this.stateMask = event.stateMask;
144	}
145
146	/**
147	* This constructur is used to mark the activation triggered by a traversal
148	*
149	* @param cell
150	* the cell source of the event
151	* @param event
152	* the event
153	*/
154	public EditorActivationEvent(ViewerCell cell, TraverseEvent event) {
155	super(cell);
156	this.eventType = TRAVERSAL;
157	this.sourceEvent = event;
158	}
159	}

Added Link Here

(-)src/org/eclipse/jface/viewers/EditorActivationStrategy.java (+26 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	/**
15	* This class is responsible to determin if a cell selection event is triggers
16	* an editor activation
17	*
18	* @since 3.3
19	*/
20	public abstract class EditorActivationStrategy {
21	/**
22	* @param event
23	* @return bla bl
24	*/
25	protected abstract boolean isEditorActivationEvent(EditorActivationEvent event);
26	}

Lines 1-4 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-1 / +13 lines)
1	#Thu Jun 01 12:46:14 EDT 2006	1	#Thu Feb 01 16:16:19 CET 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.1	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.1
Lines 7-12 Link Here
7	org.eclipse.jdt.core.compiler.debug.lineNumber=generate	7	org.eclipse.jdt.core.compiler.debug.lineNumber=generate
8	org.eclipse.jdt.core.compiler.debug.localVariable=generate	8	org.eclipse.jdt.core.compiler.debug.localVariable=generate
9	org.eclipse.jdt.core.compiler.debug.sourceFile=generate	9	org.eclipse.jdt.core.compiler.debug.sourceFile=generate
		10	org.eclipse.jdt.core.compiler.doc.comment.support=enabled
10	org.eclipse.jdt.core.compiler.problem.assertIdentifier=ignore	11	org.eclipse.jdt.core.compiler.problem.assertIdentifier=ignore
11	org.eclipse.jdt.core.compiler.problem.enumIdentifier=ignore	12	org.eclipse.jdt.core.compiler.problem.enumIdentifier=ignore
		13	org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
		14	org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
		15	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
		16	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=enabled
		17	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
		18	org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
		19	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
		20	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
		21	org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
		22	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
		23	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
12	org.eclipse.jdt.core.compiler.source=1.3	24	org.eclipse.jdt.core.compiler.source=1.3

Added Link Here

(-)src/org/eclipse/swt/nebface/snippets/viewers/GridViewerSnippet1.java (+206 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.EditorActivationStrategy;
19	import org.eclipse.jface.viewers.ICellModifier;
20	import org.eclipse.jface.viewers.IStructuredContentProvider;
21	import org.eclipse.jface.viewers.ITableColorProvider;
22	import org.eclipse.jface.viewers.ITableFontProvider;
23	import org.eclipse.jface.viewers.ITableLabelProvider;
24	import org.eclipse.jface.viewers.LabelProvider;
25	import org.eclipse.jface.viewers.TextCellEditor;
26	import org.eclipse.jface.viewers.Viewer;
27	import org.eclipse.swt.SWT;
28	import org.eclipse.swt.graphics.Color;
29	import org.eclipse.swt.graphics.Font;
30	import org.eclipse.swt.graphics.Image;
31	import org.eclipse.swt.layout.FillLayout;
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	v.setEditorActivationStrategy(new EditorActivationStrategy() {
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	v.setEnableEditorActivationWithKeyboard(true);
160	v.setTabEditingStyle(EditingSupport.TABING_HORIZONTAL\|EditingSupport.TABING_MOVE_TO_ROW_NEIGHBOR\|EditingSupport.TABING_VERTICAL);
161
162	GridColumn column = new GridColumn(v.getGrid(), SWT.NONE);
163	column.setWidth(200);
164	column.setText("Column 1");
165
166	column = new GridColumn(v.getGrid(), SWT.NONE);
167	column.setWidth(200);
168	column.setText("Column 2");
169
170	MyModel[] model = createModel();
171	v.setInput(model);
172	v.getGrid().setLinesVisible(true);
173	v.getGrid().setHeaderVisible(true);
174	}
175
176	private MyModel[] createModel() {
177	MyModel[] elements = new MyModel[10];
178
179	for (int i = 0; i < 10; i++) {
180	elements[i] = new MyModel(i);
181	}
182
183	return elements;
184	}
185
186	/**
187	* @param args
188	*/
189	public static void main(String[] args) {
190	Display display = new Display();
191
192	Shell shell = new Shell(display);
193	shell.setLayout(new FillLayout());
194	new GridViewerSnippet1(shell);
195	shell.open();
196
197	while (!shell.isDisposed()) {
198	if (!display.readAndDispatch())
199	display.sleep();
200	}
201
202	display.dispose();
203
204	}
205
206	}