Attachment #42561 for bug #142655

Lines 16-26 Link Here

(-)src/org/eclipse/jface/viewers/TableViewer.java (-6 / +124 lines)
16	import java.util.List;	16	import java.util.List;
17		17
18	import org.eclipse.jface.util.Assert;	18	import org.eclipse.jface.util.Assert;
		19	import org.eclipse.jface.viewers.editing.ITabulatorTraversingSupport;
		20	import org.eclipse.jface.viewers.editing.AbstractEditableTableColumn;
		21	import org.eclipse.jface.viewers.editing.TabulatorTraversingDelegate;
		22	import org.eclipse.jface.viewers.editing.TabulatorTraversingSupportWrapper;
19	import org.eclipse.swt.SWT;	23	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.custom.TableEditor;	24	import org.eclipse.swt.custom.TableEditor;
21	import org.eclipse.swt.events.MouseAdapter;	25	import org.eclipse.swt.events.MouseAdapter;
22	import org.eclipse.swt.events.MouseEvent;	26	import org.eclipse.swt.events.MouseEvent;
		27	import org.eclipse.swt.events.TraverseEvent;
		28	import org.eclipse.swt.events.TraverseListener;
23	import org.eclipse.swt.graphics.Image;	29	import org.eclipse.swt.graphics.Image;
		30	import org.eclipse.swt.graphics.Point;
24	import org.eclipse.swt.graphics.Rectangle;	31	import org.eclipse.swt.graphics.Rectangle;
25	import org.eclipse.swt.widgets.Composite;	32	import org.eclipse.swt.widgets.Composite;
26	import org.eclipse.swt.widgets.Control;	33	import org.eclipse.swt.widgets.Control;
Lines 63-70 Link Here
63	* @see #doFindItem(Object)	70	* @see #doFindItem(Object)
64	* @see #internalRefresh(Object, boolean)	71	* @see #internalRefresh(Object, boolean)
65	*/	72	*/
66	public class TableViewer extends StructuredViewer {	73	public class TableViewer extends StructuredViewer implements ITabulatorTraversingSupport {
67		74
68	private class VirtualManager{	75	private class VirtualManager{
69		76
70	/**	77	/**
Lines 255-260 Link Here
255	*/	262	*/
256	private TableColorAndFontNoOp tableColorAndFont = new TableColorAndFontNoOp();	263	private TableColorAndFontNoOp tableColorAndFont = new TableColorAndFontNoOp();
257		264
		265	private boolean tabediting = false;
		266
		267	private TabeditingListener tabeditingListener = new TabeditingListener();
		268
		269	private TabulatorTraversingDelegate tabeditingDelgate = new TabulatorTraversingDelegate();
		270
		271	private TooltipSupport tooltipSupport;
		272
258	/**	273	/**
259	* Creates a table viewer on a newly-created table control under the given	274	* Creates a table viewer on a newly-created table control under the given
260	* parent. The table control is created using the SWT style bits	275	* parent. The table control is created using the SWT style bits
Lines 297-309 Link Here
297	hookControl(table);	312	hookControl(table);
298	tableEditor = new TableEditor(table);	313	tableEditor = new TableEditor(table);
299	initTableViewerImpl();	314	initTableViewerImpl();
		315	initTooltip();
300	initializeVirtualManager(table.getStyle());	316	initializeVirtualManager(table.getStyle());
301	}	317	}
302		318
		319	private void initTooltip() {
		320	tooltipSupport = new TooltipSupport(this,
		321	new TooltipSupportDataProvider() {
		322
		323	public TooltipData getData(Event event) {
		324	TooltipData data = new TooltipData();
		325
		326	TableItem item = getTable().getItem(
		327	new Point(event.x, event.y));
		328
		329	if (item != null) {
		330	data.modelObject = item.getData();
		331	int columnIndex = -1;
		332	Rectangle bounds = null;
		333	for (int i = 0; i < getTable().getColumnCount(); i++) {
		334	bounds = item.getBounds(i);
		335
		336	if (bounds.contains(event.x, event.y)) {
		337	columnIndex = i;
		338	break;
		339	}
		340	}
		341
		342	if (columnIndex >= 0) {
		343	data.bounds = bounds;
		344	data.columnIndex = columnIndex;
		345	}
		346	}
		347
		348	return data;
		349	}
		350
		351	});
		352	}
		353
		354
303	/**	355	/**
304	* Initialize the virtual manager to manage the virtual state	356	* Initialize the virtual manager to manage the virtual state if the table
305	* if the table is VIRTUAL. If not use the default no-op	357	* is VIRTUAL. If not use the default no-op version.
306	* version.	358	*
307	* @param style	359	* @param style
308	*/	360	*/
309	private void initializeVirtualManager(int style) {	361	private void initializeVirtualManager(int style) {
Lines 518-523 Link Here
518	* Returns the cell editors of this table viewer.	570	* Returns the cell editors of this table viewer.
519	*	571	*
520	* @return the list of cell editors	572	* @return the list of cell editors
		573	* @deprecated please use the new interface {@link AbstractEditableTableColumn}
521	*/	574	*/
522	public CellEditor[] getCellEditors() {	575	public CellEditor[] getCellEditors() {
523	return tableViewerImpl.getCellEditors();	576	return tableViewerImpl.getCellEditors();
Lines 527-532 Link Here
527	* Returns the cell modifier of this table viewer.	580	* Returns the cell modifier of this table viewer.
528	*	581	*
529	* @return the cell modifier	582	* @return the cell modifier
		583	* @deprecated please use the new interface {@link AbstractEditableTableColumn}
530	*/	584	*/
531	public ICellModifier getCellModifier() {	585	public ICellModifier getCellModifier() {
532	return tableViewerImpl.getCellModifier();	586	return tableViewerImpl.getCellModifier();
Lines 538-543 Link Here
538	* identify the column in a cell modifier.	592	* identify the column in a cell modifier.
539	*	593	*
540	* @return the list of column properties	594	* @return the list of column properties
		595	* @deprecated please use the new interface {@link AbstractEditableTableColumn}
541	*/	596	*/
542	public Object[] getColumnProperties() {	597	public Object[] getColumnProperties() {
543	return tableViewerImpl.getColumnProperties();	598	return tableViewerImpl.getColumnProperties();
Lines 753-758 Link Here
753	.getSelection()));	808	.getSelection()));
754	fireOpen(new OpenEvent(viewer, viewer.getSelection()));	809	fireOpen(new OpenEvent(viewer, viewer.getSelection()));
755	}	810	}
		811
		812	TraverseListener getTabeditingListener() {
		813	return tabeditingListener;
		814	}
756	};	815	};
757	}	816	}
758		817
Lines 1034-1039 Link Here
1034	*	1093	*
1035	* @param editors	1094	* @param editors
1036	* the list of cell editors	1095	* the list of cell editors
		1096	* @deprecated please use the new interface {@link AbstractEditableTableColumn}
1037	*/	1097	*/
1038	public void setCellEditors(CellEditor[] editors) {	1098	public void setCellEditors(CellEditor[] editors) {
1039	tableViewerImpl.setCellEditors(editors);	1099	tableViewerImpl.setCellEditors(editors);
Lines 1044-1049 Link Here
1044	*	1104	*
1045	* @param modifier	1105	* @param modifier
1046	* the cell modifier	1106	* the cell modifier
		1107	* @deprecated please use the new interface {@link AbstractEditableTableColumn}
1047	*/	1108	*/
1048	public void setCellModifier(ICellModifier modifier) {	1109	public void setCellModifier(ICellModifier modifier) {
1049	tableViewerImpl.setCellModifier(modifier);	1110	tableViewerImpl.setCellModifier(modifier);
Lines 1056-1061 Link Here
1056	*	1117	*
1057	* @param columnProperties	1118	* @param columnProperties
1058	* the list of column properties	1119	* the list of column properties
		1120	* @deprecated please use the new interface {@link AbstractEditableTableColumn}
1059	*/	1121	*/
1060	public void setColumnProperties(String[] columnProperties) {	1122	public void setColumnProperties(String[] columnProperties) {
1061	tableViewerImpl.setColumnProperties(columnProperties);	1123	tableViewerImpl.setColumnProperties(columnProperties);
Lines 1079-1085 Link Here
1079	} else {	1141	} else {
1080	tableColorAndFont = new TableColorAndFontNoOp();	1142	tableColorAndFont = new TableColorAndFontNoOp();
1081	}	1143	}
1082		1144
		1145	tooltipSupport.configureSupport(labelProvider);
1083	}	1146	}
1084		1147
1085	/**	1148	/**
Lines 1278-1284 Link Here
1278	provider instanceof ILazyContentProvider);	1341	provider instanceof ILazyContentProvider);
1279	}	1342	}
1280		1343
		1344	/**
		1345	* @param tabediting The tabediting to set.
		1346	*/
		1347	public void setTabulatorTraversalEnabled(boolean tabediting) {
		1348	this.tabediting = tabediting;
		1349	}
		1350
		1351	public boolean isTabulatorTraversalEnabled() {
		1352	return tabediting;
		1353	}
1281		1354
		1355	protected class TabeditingListener implements TraverseListener {
		1356	private TabulatorTraversingSupportWrapper wrapper = new TabulatorTraversingSupportWrapper() {
		1357
		1358	public void setSelectedRow(int index) {
		1359	TableViewer.this.table.setSelection(index);
		1360	}
		1361
		1362	public int getColumnCount() {
		1363	return TableViewer.this.table.getColumnCount();
		1364	}
		1365
		1366	public int getCurrentColumnIndex() {
		1367	return TableViewer.this.tableEditor.getColumn();
		1368	}
		1369
		1370	public int getCurrentRowIndex() {
		1371	return TableViewer.this.table.getSelectionIndex();
		1372	}
		1373
		1374	public int getRowCount() {
		1375	return TableViewer.this.table.getItemCount();
		1376	}
		1377
		1378	};
		1379
		1380	public void keyTraversed(TraverseEvent e) {
		1381	if( TableViewer.this.tabeditingDelgate != null ) {
		1382	TableViewer.this.tabeditingDelgate.focusNewEditor(e, TableViewer.this, wrapper);
		1383	}
		1384	}
		1385	}
		1386
		1387	/* (non-Javadoc)
		1388	* @see org.eclipse.jface.viewers.editing.ITabEditingSupport#getTabeditingDelgate()
		1389	*/
		1390	public TabulatorTraversingDelegate getTabeditingDelgate() {
		1391	return this.tabeditingDelgate;
		1392	}
		1393
		1394	/* (non-Javadoc)
		1395	* @see org.eclipse.jface.viewers.editing.ITabEditingSupport#setTabeditingDelgate(org.eclipse.jface.viewers.editing.TabEditingDelegate)
		1396	*/
		1397	public void setTabeditingDelegate(TabulatorTraversingDelegate tabeditingDelgate) {
		1398	this.tabeditingDelgate = tabeditingDelgate;
		1399	}
1282		1400
1283	}	1401	}
1284		1402

Lines 15-26 Link Here

(-)src/org/eclipse/jface/viewers/TreeViewer.java (-2 / +127 lines)
15	import java.util.List;	15	import java.util.List;
16		16
17	import org.eclipse.jface.util.Assert;	17	import org.eclipse.jface.util.Assert;
		18	import org.eclipse.jface.viewers.editing.ITabulatorTraversingSupport;
		19	import org.eclipse.jface.viewers.editing.TabulatorTraversingDelegate;
		20	import org.eclipse.jface.viewers.editing.TabulatorTraversingSupportWrapper;
		21	import org.eclipse.jface.viewers.editing.AbstractEditableTreeColumn;
18	import org.eclipse.swt.SWT;	22	import org.eclipse.swt.SWT;
19	import org.eclipse.swt.custom.TreeEditor;	23	import org.eclipse.swt.custom.TreeEditor;
20	import org.eclipse.swt.events.DisposeEvent;	24	import org.eclipse.swt.events.DisposeEvent;
21	import org.eclipse.swt.events.DisposeListener;	25	import org.eclipse.swt.events.DisposeListener;
22	import org.eclipse.swt.events.MouseAdapter;	26	import org.eclipse.swt.events.MouseAdapter;
23	import org.eclipse.swt.events.MouseEvent;	27	import org.eclipse.swt.events.MouseEvent;
		28	import org.eclipse.swt.events.TraverseEvent;
		29	import org.eclipse.swt.events.TraverseListener;
24	import org.eclipse.swt.events.TreeListener;	30	import org.eclipse.swt.events.TreeListener;
25	import org.eclipse.swt.graphics.Image;	31	import org.eclipse.swt.graphics.Image;
26	import org.eclipse.swt.graphics.Point;	32	import org.eclipse.swt.graphics.Point;
Lines 47-54 Link Here
47	* <code>ITreeContentProvider</code> interface.	53	* <code>ITreeContentProvider</code> interface.
48	* </p>	54	* </p>
49	*/	55	*/
50	public class TreeViewer extends AbstractTreeViewer {	56	public class TreeViewer extends AbstractTreeViewer implements ITabulatorTraversingSupport {
51		57
52	/**	58	/**
53	* TreeColorAndFontCollector is an helper class for color and font support	59	* TreeColorAndFontCollector is an helper class for color and font support
54	* for trees that support the ITableFontProvider and the	60	* for trees that support the ITableFontProvider and the
Lines 137-142 Link Here
137	*/	143	*/
138	private boolean treeIsDisposed = false;	144	private boolean treeIsDisposed = false;
139		145
		146	private boolean tabediting = false;
		147
		148	private TabeditingListener tabeditingListener = new TabeditingListener();
		149
		150	private TabulatorTraversingDelegate tabeditingDelgate = new TabulatorTraversingDelegate();
		151
		152	private TooltipSupport tooltipSupport;
		153
140	/**	154	/**
141	* Creates a tree viewer on a newly-created tree control under the given	155	* Creates a tree viewer on a newly-created tree control under the given
142	* parent. The tree control is created using the SWT style bits	156	* parent. The tree control is created using the SWT style bits
Lines 179-186 Link Here
179	hookControl(tree);	193	hookControl(tree);
180	treeEditor = new TreeEditor(tree);	194	treeEditor = new TreeEditor(tree);
181	initTreeViewerImpl();	195	initTreeViewerImpl();
		196	initTooltip();
182	}	197	}
183		198
		199	private void initTooltip() {
		200	tooltipSupport = new TooltipSupport(this,
		201	new TooltipSupportDataProvider() {
		202
		203	public TooltipData getData(Event event) {
		204	TooltipData data = new TooltipData();
		205
		206	TreeItem item = getTree().getItem(
		207	new Point(event.x, event.y));
		208
		209	if (item != null) {
		210	data.modelObject = item.getData();
		211	int columnIndex = -1;
		212	Rectangle bounds = null;
		213	for (int i = 0; i < getTree().getColumnCount(); i++) {
		214	bounds = item.getBounds(i);
		215
		216	if (bounds.contains(event.x, event.y)) {
		217	columnIndex = i;
		218	break;
		219	}
		220	}
		221
		222	if (columnIndex >= 0) {
		223	data.bounds = bounds;
		224	data.columnIndex = columnIndex;
		225	}
		226	}
		227
		228	return data;
		229	}
		230
		231	});
		232	}
		233
184	/*	234	/*
185	* (non-Javadoc) Method declared in AbstractTreeViewer.	235	* (non-Javadoc) Method declared in AbstractTreeViewer.
186	*/	236	*/
Lines 357-362 Link Here
357	*	407	*
358	* @return the list of cell editors	408	* @return the list of cell editors
359	* @since 3.1	409	* @since 3.1
		410	* @deprecated please use the new interface {@link AbstractEditableTreeColumn}
360	*/	411	*/
361	public CellEditor[] getCellEditors() {	412	public CellEditor[] getCellEditors() {
362	return treeViewerImpl.getCellEditors();	413	return treeViewerImpl.getCellEditors();
Lines 367-372 Link Here
367	*	418	*
368	* @return the cell modifier	419	* @return the cell modifier
369	* @since 3.1	420	* @since 3.1
		421	* @deprecated please use the new interface {@link AbstractEditableTreeColumn}
370	*/	422	*/
371	public ICellModifier getCellModifier() {	423	public ICellModifier getCellModifier() {
372	return treeViewerImpl.getCellModifier();	424	return treeViewerImpl.getCellModifier();
Lines 392-397 Link Here
392	*	444	*
393	* @return the list of column properties	445	* @return the list of column properties
394	* @since 3.1	446	* @since 3.1
		447	* @deprecated please use the new interface {@link AbstractEditableTreeColumn}
395	*/	448	*/
396	public Object[] getColumnProperties() {	449	public Object[] getColumnProperties() {
397	return treeViewerImpl.getColumnProperties();	450	return treeViewerImpl.getColumnProperties();
Lines 558-563 Link Here
558	.getSelection()));	611	.getSelection()));
559	fireOpen(new OpenEvent(viewer, viewer.getSelection()));	612	fireOpen(new OpenEvent(viewer, viewer.getSelection()));
560	}	613	}
		614
		615	TraverseListener getTabeditingListener() {
		616	return tabeditingListener;
		617	}
561	};	618	};
562	}	619	}
563		620
Lines 606-611 Link Here
606	* @param editors	663	* @param editors
607	* the list of cell editors	664	* the list of cell editors
608	* @since 3.1	665	* @since 3.1
		666	* @deprecated please use the new interface {@link AbstractEditableTreeColumn}
609	*/	667	*/
610	public void setCellEditors(CellEditor[] editors) {	668	public void setCellEditors(CellEditor[] editors) {
611	treeViewerImpl.setCellEditors(editors);	669	treeViewerImpl.setCellEditors(editors);
Lines 617-625 Link Here
617	* @param modifier	675	* @param modifier
618	* the cell modifier	676	* the cell modifier
619	* @since 3.1	677	* @since 3.1
		678	* @deprecated please use the new interface {@link AbstractEditableTreeColumn}
620	*/	679	*/
621	public void setCellModifier(ICellModifier modifier) {	680	public void setCellModifier(ICellModifier modifier) {
622	treeViewerImpl.setCellModifier(modifier);	681	treeViewerImpl.setCellModifier(modifier);
		682
623	}	683	}
624		684
625	/**	685	/**
Lines 630-635 Link Here
630	* @param columnProperties	690	* @param columnProperties
631	* the list of column properties	691	* the list of column properties
632	* @since 3.1	692	* @since 3.1
		693	* @deprecated please use the new interface {@link AbstractEditableTreeColumn}
633	*/	694	*/
634	public void setColumnProperties(String[] columnProperties) {	695	public void setColumnProperties(String[] columnProperties) {
635	treeViewerImpl.setColumnProperties(columnProperties);	696	treeViewerImpl.setColumnProperties(columnProperties);
Lines 656-661 Link Here
656	\|\| labelProvider instanceof ILabelProvider);	717	\|\| labelProvider instanceof ILabelProvider);
657	super.setLabelProvider(labelProvider);	718	super.setLabelProvider(labelProvider);
658	treeColorAndFont = new TreeColorAndFontCollector(labelProvider);	719	treeColorAndFont = new TreeColorAndFontCollector(labelProvider);
		720	tooltipSupport.configureSupport(labelProvider);
659	}	721	}
660		722
661	/*	723	/*
Lines 985-988 Link Here
985	}});	1047	}});
986	}	1048	}
987	}	1049	}
		1050
		1051	/**
		1052	* @param tabediting The tabediting to set.
		1053	*/
		1054	public void setTabulatorTraversalEnabled(boolean tabediting) {
		1055	this.tabediting = tabediting;
		1056	}
		1057
		1058	/* (non-Javadoc)
		1059	* @see org.eclipse.jface.viewers.editing.ITabEditingSupport#isTabediting()
		1060	*/
		1061	public boolean isTabulatorTraversalEnabled() {
		1062	return this.tabediting;
		1063	}
		1064
		1065	/* (non-Javadoc)
		1066	* @see org.eclipse.jface.viewers.editing.ITabEditingSupport#getTabeditingDelgate()
		1067	*/
		1068	public TabulatorTraversingDelegate getTabeditingDelgate() {
		1069	return tabeditingDelgate;
		1070	}
		1071
		1072	/* (non-Javadoc)
		1073	* @see org.eclipse.jface.viewers.editing.ITabEditingSupport#setTabeditingDelgate(org.eclipse.jface.viewers.editing.TabEditingDelegate)
		1074	*/
		1075	public void setTabeditingDelegate(TabulatorTraversingDelegate tabeditingDelgate) {
		1076	this.tabeditingDelgate = tabeditingDelgate;
		1077	}
		1078
		1079	protected class TabeditingListener implements TraverseListener {
		1080	private TabulatorTraversingSupportWrapper wrapper = new TabulatorTraversingSupportWrapper() {
		1081
		1082	public void setSelectedRow(int index) {
		1083	TreeItem item = TreeViewer.this.tree.getItem(index);
		1084	TreeViewer.this.tree.setSelection(item);
		1085	}
		1086
		1087	public int getColumnCount() {
		1088	return TreeViewer.this.tree.getColumnCount();
		1089	}
		1090
		1091	public int getCurrentColumnIndex() {
		1092	return TreeViewer.this.treeEditor.getColumn();
		1093	}
		1094
		1095	public int getCurrentRowIndex() {
		1096	// FIXME TABING FROM ROW TO ROW
		1097	return 0;
		1098	}
		1099
		1100	public int getRowCount() {
		1101	// FIXME TABING FROM ROW TO ROW
		1102	return 0;
		1103	}
		1104
		1105	};
		1106
		1107	public void keyTraversed(TraverseEvent e) {
		1108	if( TreeViewer.this.tabeditingDelgate != null ) {
		1109	TreeViewer.this.tabeditingDelgate.focusNewEditor(e, TreeViewer.this, wrapper);
		1110	}
		1111	}
		1112	}
988	}	1113	}





package org.eclipse.jface.viewers;

import org.eclipse.jface.viewers.editing.AbstractEditableTreeColumn;
import org.eclipse.jface.viewers.editing.IEditableColumn;
import org.eclipse.jface.viewers.editing.IEditableMultiColumn;
import org.eclipse.jface.viewers.editing.ITabulatorTraversingSupport;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.TreeColumn;

/**
 * Internal tree viewer implementation.

 */
/* package */abstract class TreeEditorImpl {

	private CellEditor cellEditor;

	/**
	 * @deprecated
	 */
	private CellEditor[] cellEditors;

	/**
	 * @deprecated
	 */
	private ICellModifier cellModifier;

	/**
	 * @deprecated
	 */
	private String[] columnProperties;

	private Item treeItem;

	private int columnNumber;

	private ICellEditorListener cellEditorListener;

	private FocusListener focusListener;

	private MouseListener mouseListener;

	private int doubleClickExpirationTime;

	private StructuredViewer viewer;

	TreeEditorImpl(StructuredViewer viewer) {
		this.viewer = viewer;
		initCellEditorListener();
	}

	/**
	 * Returns this <code>TreeViewerImpl</code> viewer
	 * 
	 * @return the viewer
	 */
	public StructuredViewer getViewer() {
		return viewer;
	}

	private void activateCellEditor() {
		CellEditor editor = getEditor(columnNumber);

		if (editor != null) {
			Object element = treeItem.getData();

			cellEditor = editor;

			if(viewer instanceof ITabulatorTraversingSupport && ((ITabulatorTraversingSupport) viewer).isTabulatorTraversalEnabled()) {
				cellEditor.getControl().addTraverseListener(getTabeditingListener());
			}

			// tree.showSelection();
			cellEditor.addListener(cellEditorListener);
			Object value = getModelValue(element, columnNumber);
			cellEditor.setValue(value);
			// Tricky flow of control here:
			// activate() can trigger callback to cellEditorListener which will
			// clear cellEditor
			// so must get control first, but must still call activate() even if
			// there is no control.
			final Control control = cellEditor.getControl();
			cellEditor.activate();
			if (control == null) {
				return;
			}
			setLayoutData(cellEditor.getLayoutData());
			setEditor(control, treeItem, columnNumber);
			cellEditor.setFocus();
			if (focusListener == null) {
				focusListener = new FocusAdapter() {
					public void focusLost(FocusEvent e) {
						applyEditorValue();
					}
				};
			}
			control.addFocusListener(focusListener);
			mouseListener = new MouseAdapter() {
				public void mouseDown(MouseEvent e) {
					// time wrap?
					// check for expiration of doubleClickTime
					if (e.time <= doubleClickExpirationTime) {
						control.removeMouseListener(mouseListener);
						cancelEditing();
						handleDoubleClickEvent();
					} else if (mouseListener != null) {
						control.removeMouseListener(mouseListener);
					}
				}
			};
			control.addMouseListener(mouseListener);
		}
	}
                            } else if (mouseListener != null) {
                                control.removeMouseListener(mouseListener);
                            }
                        }
                    };
                    control.addMouseListener(mouseListener);
                }
            }
        }
    }

	private CellEditor getEditor(int columnNumber) {
		CellEditor editor = null;
     */
    private void activateCellEditor(MouseEvent event) {
        if (treeItem == null || treeItem.isDisposed()) {
            //item no longer exists
            return;
        }
        int columnToEdit;
        int columns = getColumnCount();
        if (columns == 0) {
            // If no TreeColumn, Tree acts as if it has a single column
            // which takes the whole width.
            columnToEdit = 0;
        } else {
            columnToEdit = -1;
            for (int i = 0; i < columns; i++) {
                Rectangle bounds = getBounds(treeItem, i);
                if (bounds.contains(event.x, event.y)) {
                    columnToEdit = i;
                    break;
                }
            }
            if (columnToEdit == -1) {
                return;
            }
        }

		// Ensure compatility with old interface
		if (cellEditors != null) {
			if (cellEditors[columnNumber] != null && cellModifier != null) {
				Object element = treeItem.getData();
				String property = columnProperties[columnNumber];

				if (cellModifier.canModify(element, property)) {
					editor = cellEditors[columnNumber];
				}
			}
		} else {
			if (viewer instanceof TreeViewer) {
				TreeColumn column = ((TreeViewer)viewer).getTree().getColumn(columnNumber);
				if( column.getData(IEditableColumn.EDITING_SUPPORT_KEY) != null ) {
					IEditableColumn eColumn = (IEditableColumn)column.getData(IEditableColumn.EDITING_SUPPORT_KEY);
					
					Object element = treeItem.getData();
					
					if( column instanceof IEditableMultiColumn  ) {
						IEditableMultiColumn t = (IEditableMultiColumn)eColumn;
						
						if( t.canEdit(element, columnNumber) ) {
							editor = t.getCellEditor(element, columnNumber);
						}
					} else {
						if( eColumn.canEdit(element)) {
							editor = eColumn.getCellEditor(element);
						}
					}
		    	}
			}
		}

		return editor;
	}

	private Object getModelValue(Object element, int columnNumber) {
		Object value = null;
		if (cellEditors != null ) {
			if( cellModifier != null ) {
				String property = columnProperties[columnNumber];
				value = cellModifier.getValue(element, property);
			}
		} else {
			IEditableColumn column = (IEditableColumn)((TableViewer)viewer).getTable().getColumn(columnNumber).getData(IEditableColumn.EDITING_SUPPORT_KEY);
			
			if( column instanceof IEditableMultiColumn ) {
            	value = ((IEditableMultiColumn)column).getValue(element,columnNumber);
            } else {
            	value = column.getValue(element);
            }
		}

		return value;
	}

	/**
	 * Activate a cell editor for the given mouse position.
	 */
	private void activateCellEditor(MouseEvent event) {
		if (treeItem == null || treeItem.isDisposed()) {
			// item no longer exists
			return;
		}
		int columnToEdit;
		int columns = getColumnCount();
		if (columns == 0) {
			// If no TreeColumn, Tree acts as if it has a single column
			// which takes the whole width.
			columnToEdit = 0;
		} else {
			columnToEdit = -1;
			for (int i = 0; i < columns; i++) {
				Rectangle bounds = getBounds(treeItem, i);
				if (bounds.contains(event.x, event.y)) {
					columnToEdit = i;
					break;
				}
			}
			if (columnToEdit == -1) {
				return;
			}
		}

		columnNumber = columnToEdit;
		activateCellEditor();
	}

	/**
	 * Deactivates the currently active cell editor.
	 */
	public void applyEditorValue() {
		CellEditor c = this.cellEditor;
		if (c != null) {
			if( viewer instanceof ITabulatorTraversingSupport ) {
        		c.getControl().removeTraverseListener(getTabeditingListener());
        	}
			
			// null out cell editor before calling save
			// in case save results in applyEditorValue being re-entered
			// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
			// using cell editor ?
			this.cellEditor = null;
			Item t = this.treeItem;
			// don't null out tree item -- same item is still selected
			if (t != null && !t.isDisposed()) {
				saveEditorValue(c, t);
			}
			setEditor(null, null, 0);
			c.removeListener(cellEditorListener);
			Control control = c.getControl();
			if (control != null) {
				if (mouseListener != null) {
					control.removeMouseListener(mouseListener);
				}
				if (focusListener != null) {
					control.removeFocusListener(focusListener);
				}
			}
			c.deactivate();
		}
	}

	/**
	 * Cancels the active cell editor, without saving the value back to the
	 * domain model.
	 */
	public void cancelEditing() {
		if (cellEditor != null) {
			
			if( viewer instanceof ITabulatorTraversingSupport ) {
        		cellEditor.getControl().removeTraverseListener(getTabeditingListener());
        	}
			
			setEditor(null, null, 0);
			cellEditor.removeListener(cellEditorListener);
			CellEditor oldEditor = cellEditor;
			cellEditor = null;
			oldEditor.deactivate();
		}
	}

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

		IStructuredSelection structuredSelection;
		if (element instanceof TreePath) {
			structuredSelection = new TreeSelection((TreePath) element, viewer
					.getComparer());
		} else {
			structuredSelection = new StructuredSelection(element);
		}
		setSelection(structuredSelection, true);
		Item[] selection = getSelection();
		if (selection.length != 1) {
			return;
		}

		treeItem = selection[0];

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

	}

	abstract Rectangle getBounds(Item item, int columnNumber);

	/**
	 * Get the Cell Editors for the receiver.
	 * 
	 * @return CellEditor[]
	 * @deprecated please use the new interface {@link AbstractEditableTreeColumn}
	 */
	public CellEditor[] getCellEditors() {
		return cellEditors;
	}

	/**
	 * Get the cell modifier for the receiver.
	 * 
	 * @return ICellModifier
	 * @deprecated please use the new interface {@link AbstractEditableTreeColumn}
	 */
	public ICellModifier getCellModifier() {
		return cellModifier;
	}

	abstract int getColumnCount();

	/**
	 * Get the column properties for the receiver.
	 * 
	 * @return Object[]
	 * @deprecated please use the new interface {@link AbstractEditableTreeColumn}
	 */
	public Object[] getColumnProperties() {
		return columnProperties;
	}

	abstract Item[] getSelection();

	/**
	 * Handles the mouse down event; activates the cell editor.
	 * 
	 * @param event
	 *            the mouse event that should be handled
	 */
	public void handleMouseDown(MouseEvent event) {
		if (event.button != 1) {
			return;
		}

		if (cellEditor != null) {
			applyEditorValue();
		}

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

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

	private void initCellEditorListener() {
		cellEditorListener = new ICellEditorListener() {
			public void editorValueChanged(boolean oldValidState,
					boolean newValidState) {
				// Ignore.
			}

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

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

	/**
	 * Return whether or not there is an active cell editor.
	 * 
	 * @return boolean <code>true</code> if there is an active cell editor;
	 *         otherwise <code>false</code> is returned.
	 */
	public boolean isCellEditorActive() {
		return cellEditor != null;
	}

	/**
	 * Saves the value of the currently active cell editor, by delegating to the
	 * cell modifier.
	 */
	private void saveEditorValue(CellEditor cellEditor, Item treeItem) {
		if( cellEditors != null ) {
			if (cellModifier != null) {
				String property = null;
				if (columnProperties != null
						&& columnNumber < columnProperties.length) {
					property = columnProperties[columnNumber];
				}
				cellModifier.modify(treeItem, property, cellEditor.getValue());
			}
		} else {
			IEditableColumn column = (IEditableColumn)((TreeViewer)viewer).getTree().getColumn(columnNumber).getData(IEditableColumn.EDITING_SUPPORT_KEY);
            if( column instanceof IEditableMultiColumn ) {
            	((IEditableMultiColumn)column).setValue(treeItem.getData(),cellEditor.getValue(),columnNumber);
            } else {
            	column.setValue(treeItem.getData(),cellEditor.getValue());
            }
		}
	}

	/**
	 * Set the cell editors for the receiver.
	 * 
	 * @param editors
	 * @deprecated please use the new interface {@link AbstractEditableTreeColumn}
	 */
	public void setCellEditors(CellEditor[] editors) {
		this.cellEditors = editors;
	}

	/**
	 * Set the cell modifier for the receiver.
	 * 
	 * @param modifier
	 * @deprecated please use the new interface {@link AbstractEditableTreeColumn}
	 */
	public void setCellModifier(ICellModifier modifier) {
		this.cellModifier = modifier;
	}

	/**
	 * Set the column properties for the receiver.
	 * 
	 * @param columnProperties
	 * @deprecated please use the new interface {@link AbstractEditableTreeColumn}
	 */
	public void setColumnProperties(String[] columnProperties) {
		this.columnProperties = columnProperties;
	}

	abstract void setEditor(Control w, Item item, int fColumnNumber);

	abstract void setLayoutData(CellEditor.LayoutData layoutData);
     * Set the cell modifier for the receiver.
     * @param modifier
     */
    public void setCellModifier(ICellModifier modifier) {
        this.cellModifier = modifier;
    }

    /**
     * Set the column properties for the receiver.
     * @param columnProperties
     */
    public void setColumnProperties(String[] columnProperties) {
        this.columnProperties = columnProperties;
    }

    abstract void setEditor(Control w, Item item, int fColumnNumber);

	abstract void setSelection(IStructuredSelection selection, boolean b);

	abstract void showSelection();

	abstract void handleDoubleClickEvent();

	abstract TraverseListener getTabeditingListener();
}





package org.eclipse.jface.viewers;

import org.eclipse.jface.viewers.editing.AbstractEditableTableColumn;
import org.eclipse.jface.viewers.editing.IEditableColumn;
import org.eclipse.jface.viewers.editing.IEditableMultiColumn;
import org.eclipse.jface.viewers.editing.ITabulatorTraversingSupport;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.TableColumn;

/**
 * Internal table viewer implementation.

 */
/* package */abstract class TableEditorImpl {

	private CellEditor cellEditor;

	/**
	 * @deprecated
	 */
	private CellEditor[] cellEditors;

	/**
	 * @deprecated
	 */
	private ICellModifier cellModifier;

	/**
	 * @deprecated
	 */
	private String[] columnProperties;

	private Item tableItem;

	private int columnNumber;

	private ICellEditorListener cellEditorListener;

	private FocusListener focusListener;

	private MouseListener mouseListener;

	private int doubleClickExpirationTime;

	private StructuredViewer viewer;

	TableEditorImpl(StructuredViewer viewer) {
		this.viewer = viewer;
		initCellEditorListener();
	}

	/**
	 * Returns this <code>TableViewerImpl</code> viewer
	 * 
	 * @return the viewer
	 */
	public StructuredViewer getViewer() {
		return viewer;
	}

	private void activateCellEditor() {
		CellEditor editor = getEditor(columnNumber);

		if (editor != null) {
			Object element = tableItem.getData();

			cellEditor = editor;

			if(viewer instanceof ITabulatorTraversingSupport && ((ITabulatorTraversingSupport) viewer).isTabulatorTraversalEnabled()) {
				cellEditor.getControl().addTraverseListener(getTabeditingListener());
			}

			// table.showSelection();
			cellEditor.addListener(cellEditorListener);
			Object value = getModelValue(element, columnNumber);
			cellEditor.setValue(value);
			// Tricky flow of control here:
			// activate() can trigger callback to cellEditorListener which will
			// clear cellEditor
			// so must get control first, but must still call activate() even if
			// there is no control.
			final Control control = cellEditor.getControl();
			cellEditor.activate();
			if (control == null) {
				return;
			}
			setLayoutData(cellEditor.getLayoutData());
			setEditor(control, tableItem, columnNumber);
			cellEditor.setFocus();
			if (focusListener == null) {
				focusListener = new FocusAdapter() {
					public void focusLost(FocusEvent e) {
						applyEditorValue();
					}
				};
			}
			control.addFocusListener(focusListener);
			mouseListener = new MouseAdapter() {
				public void mouseDown(MouseEvent e) {
					// time wrap?
					// check for expiration of doubleClickTime
					if (e.time <= doubleClickExpirationTime) {
						control.removeMouseListener(mouseListener);
						cancelEditing();
						handleDoubleClickEvent();
					} else if (mouseListener != null) {
						control.removeMouseListener(mouseListener);
					}
				}
			};
			control.addMouseListener(mouseListener);
		}
	}
                            } else if (mouseListener != null) {
                                control.removeMouseListener(mouseListener);
                            }
                        }
                    };
                    control.addMouseListener(mouseListener);
                }
            }
        }
    }

	private CellEditor getEditor(int columnNumber) {
		CellEditor editor = null;
     */
    private void activateCellEditor(MouseEvent event) {
        if (tableItem == null || tableItem.isDisposed()) {
            //item no longer exists
            return;
        }
        int columnToEdit;
        int columns = getColumnCount();
        if (columns == 0) {
            // If no TableColumn, Table acts as if it has a single column
            // which takes the whole width.
            columnToEdit = 0;
        } else {
            columnToEdit = -1;
            for (int i = 0; i < columns; i++) {
                Rectangle bounds = getBounds(tableItem, i);
                if (bounds.contains(event.x, event.y)) {
                    columnToEdit = i;
                    break;
                }
            }
            if (columnToEdit == -1) {
                return;
            }
        }

		// Ensure compatility with old interface
		if (cellEditors != null) {
			if (cellEditors[columnNumber] != null && cellModifier != null) {
				Object element = tableItem.getData();
				String property = columnProperties[columnNumber];

				if (cellModifier.canModify(element, property)) {
					editor = cellEditors[columnNumber];
				}
			}
		} else {
			if( viewer instanceof TableViewer ) {
				TableColumn column = ((TableViewer)viewer).getTable().getColumn(columnNumber);
				if( column.getData(IEditableColumn.EDITING_SUPPORT_KEY) != null ) {
					IEditableColumn eColumn = (IEditableColumn)column.getData(IEditableColumn.EDITING_SUPPORT_KEY);
					
					Object element = tableItem.getData();
					
					if( column instanceof IEditableMultiColumn  ) {
						IEditableMultiColumn t = (IEditableMultiColumn)eColumn;
						
						if( t.canEdit(element, columnNumber) ) {
							editor = t.getCellEditor(element, columnNumber);
						}
					} else {
						if( eColumn.canEdit(element)) {
							editor = eColumn.getCellEditor(element);
						}
					}
		    	}
			}
		}

		return editor;
	}

	private Object getModelValue(Object element, int columnNumber) {
		Object value = null;
		if (cellEditors != null ) {
			if( cellModifier != null ) {
				String property = columnProperties[columnNumber];
				value = cellModifier.getValue(element, property);
			}
		} else {
			IEditableColumn column = (IEditableColumn)((TableViewer)viewer).getTable().getColumn(columnNumber).getData(IEditableColumn.EDITING_SUPPORT_KEY);
			
			if( column instanceof IEditableMultiColumn ) {
            	value = ((IEditableMultiColumn)column).getValue(element,columnNumber);
            } else {
            	value = column.getValue(element);
            }
		}

		return value;
	}

	/**
	 * Activate a cell editor for the given mouse position.
	 */
	private void activateCellEditor(MouseEvent event) {
		if (tableItem == null || tableItem.isDisposed()) {
			// item no longer exists
			return;
		}
		int columnToEdit;
		int columns = getColumnCount();
		if (columns == 0) {
			// If no TableColumn, Table acts as if it has a single column
			// which takes the whole width.
			columnToEdit = 0;
		} else {
			columnToEdit = -1;
			for (int i = 0; i < columns; i++) {
				Rectangle bounds = getBounds(tableItem, i);
				if (bounds.contains(event.x, event.y)) {
					columnToEdit = i;
					break;
				}
			}
			if (columnToEdit == -1) {
				return;
			}
		}

		columnNumber = columnToEdit;
		activateCellEditor();
	}

	/**
	 * Deactivates the currently active cell editor.
	 */
	public void applyEditorValue() {
		CellEditor c = this.cellEditor;
		if (c != null) {
			if( viewer instanceof ITabulatorTraversingSupport ) {
        		c.getControl().removeTraverseListener(getTabeditingListener());
        	}
			
			// null out cell editor before calling save
			// in case save results in applyEditorValue being re-entered
			// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
			// using cell editor ?
			this.cellEditor = null;
			Item t = this.tableItem;
			// don't null out table item -- same item is still selected
			if (t != null && !t.isDisposed()) {
				saveEditorValue(c, t);
			}
			setEditor(null, null, 0);
			c.removeListener(cellEditorListener);
			Control control = c.getControl();
			if (control != null) {
				if (mouseListener != null) {
					control.removeMouseListener(mouseListener);
				}
				if (focusListener != null) {
					control.removeFocusListener(focusListener);
				}
			}
			c.deactivate();
		}
	}

	/**
	 * Cancels the active cell editor, without saving the value back to the
	 * domain model.
	 */
	public void cancelEditing() {
		if (cellEditor != null) {
			
			if( viewer instanceof ITabulatorTraversingSupport ) {
        		cellEditor.getControl().removeTraverseListener(getTabeditingListener());
        	}
			
			setEditor(null, null, 0);
			cellEditor.removeListener(cellEditorListener);
			CellEditor oldEditor = cellEditor;
			cellEditor = null;
			oldEditor.deactivate();
		}
	}

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

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

		tableItem = selection[0];

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

	}

	abstract Rectangle getBounds(Item item, int columnNumber);

	/**
	 * Return the array of CellEditors used in the viewer
	 * 
	 * @return the cell editors
	 * @deprecated please use the new interface {@link AbstractEditableTableColumn}
	 */
	public CellEditor[] getCellEditors() {
		return cellEditors;
	}

	/**
	 * Get the cell modifier
	 * 
	 * @return the cell modifier
	 * @deprecated please use the new interface {@link AbstractEditableTableColumn}
	 */
	public ICellModifier getCellModifier() {
		return cellModifier;
	}

	abstract int getColumnCount();

	/**
	 * Return the properties for the column
	 * 
	 * @return the array of column properties
	 * @deprecated please use the new interface {@link AbstractEditableTableColumn}
	 */
	public Object[] getColumnProperties() {
		return columnProperties;
	}

	abstract Item[] getSelection();

	/**
	 * Handles the mouse down event; activates the cell editor.
	 * 
	 * @param event
	 *            the mouse event that should be handled
	 */
	public void handleMouseDown(MouseEvent event) {
		if (event.button != 1) {
			return;
		}

		if (cellEditor != null) {
			applyEditorValue();
		}

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

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

	private void initCellEditorListener() {
		cellEditorListener = new ICellEditorListener() {
			public void editorValueChanged(boolean oldValidState,
					boolean newValidState) {
				// Ignore.
			}

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

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

	/**
	 * Return whether there is an active cell editor.
	 * 
	 * @return <code>true</code> if there is an active cell editor; otherwise
	 *         <code>false</code> is returned.
	 */
	public boolean isCellEditorActive() {
		return cellEditor != null;
	}

	/**
	 * Saves the value of the currently active cell editor, by delegating to the
	 * cell modifier.
	 */
	private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
		if( cellEditors != null ) {
			if (cellModifier != null) {
				if (!cellEditor.isValueValid()) {
					// /Do what ???
				}
				String property = null;
				if (columnProperties != null
						&& columnNumber < columnProperties.length) {
					property = columnProperties[columnNumber];
				}
				cellModifier.modify(tableItem, property, cellEditor.getValue());
			}
		} else {
			IEditableColumn column = (IEditableColumn)((TableViewer)viewer).getTable().getColumn(columnNumber).getData(IEditableColumn.EDITING_SUPPORT_KEY);
            if( column instanceof IEditableMultiColumn ) {
            	((IEditableMultiColumn)column).setValue(tableItem.getData(),cellEditor.getValue(),columnNumber);
            } else {
            	column.setValue(tableItem.getData(),cellEditor.getValue());
            }
		}
	}

	/**
	 * Set the cell editors
	 * 
	 * @param editors
	 * @deprecated please use the new interface {@link AbstractEditableTableColumn}
	 */
	public void setCellEditors(CellEditor[] editors) {
		this.cellEditors = editors;
	}

	/**
	 * Set the cell modifier
	 * 
	 * @param modifier
	 * @deprecated please use the new interface {@link AbstractEditableTableColumn}
	 */
	public void setCellModifier(ICellModifier modifier) {
		this.cellModifier = modifier;
	}

	/**
	 * Set the column properties
	 * 
	 * @param columnProperties
	 * @deprecated please use the new interface {@link AbstractEditableTableColumn}
	 */
	public void setColumnProperties(String[] columnProperties) {
		this.columnProperties = columnProperties;
	}

	abstract void setEditor(Control w, Item item, int fColumnNumber);

	abstract void setLayoutData(CellEditor.LayoutData layoutData);

	abstract void setSelection(StructuredSelection selection, boolean b);

	abstract void showSelection();

	abstract void handleDoubleClickEvent();

	abstract TraverseListener getTabeditingListener();
}

Lines 20-25 Link Here

(-)src/org/eclipse/jface/viewers/TableTreeViewer.java (+9 lines)
20	import org.eclipse.swt.custom.TableTreeItem;	20	import org.eclipse.swt.custom.TableTreeItem;
21	import org.eclipse.swt.events.MouseAdapter;	21	import org.eclipse.swt.events.MouseAdapter;
22	import org.eclipse.swt.events.MouseEvent;	22	import org.eclipse.swt.events.MouseEvent;
		23	import org.eclipse.swt.events.TraverseListener;
23	import org.eclipse.swt.events.TreeListener;	24	import org.eclipse.swt.events.TreeListener;
24	import org.eclipse.swt.graphics.Image;	25	import org.eclipse.swt.graphics.Image;
25	import org.eclipse.swt.graphics.Point;	26	import org.eclipse.swt.graphics.Point;
Lines 107-112 Link Here
107	fireDoubleClick(new DoubleClickEvent(viewer, viewer.getSelection()));	108	fireDoubleClick(new DoubleClickEvent(viewer, viewer.getSelection()));
108	fireOpen(new OpenEvent(viewer, viewer.getSelection()));	109	fireOpen(new OpenEvent(viewer, viewer.getSelection()));
109	}	110	}
		111
		112	/* (non-Javadoc)
		113	* @see org.eclipse.jface.viewers.TableEditorImpl#getTabeditingListener()
		114	*/
		115	TraverseListener getTabeditingListener() {
		116	// TODO Auto-generated method stub
		117	return null;
		118	}
110	}	119	}
111		120
112	/**	121	/**

Lines 29-34 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
29	org.eclipse.jface.util,	29	org.eclipse.jface.util,
30	org.eclipse.jface.viewers,	30	org.eclipse.jface.viewers,
31	org.eclipse.jface.viewers.deferred,	31	org.eclipse.jface.viewers.deferred,
		32	org.eclipse.jface.viewers.editing,
32	org.eclipse.jface.window,	33	org.eclipse.jface.window,
33	org.eclipse.jface.wizard,	34	org.eclipse.jface.wizard,
34	org.eclipse.jface.wizard.images	35	org.eclipse.jface.wizard.images




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

package org.eclipse.jface.viewers;

import org.eclipse.jface.viewers.TooltipSupportDataProvider.TooltipData;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.ToolTip;

/**
 * This class adds tooltip support to viewers whose LabelProvider implement the
 * none manadory interface {@link ITooltipProvider}. This class is not
 * dependent on any Viewer but uses TooltipSupportDataProvider to fetch all data
 * important to display the Tooltip
 * 
 * @since 3.3
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 */
class TooltipSupport {
	private TooltipSupportDataProvider dataProvider;

	private ITooltipProvider tooltipPv;

	private Viewer viewer;

	private ToolTip tip;

	private TooltipListener tooltipListener;

	/**
	 * Create a new tooltip supported who displays tooltips when the mouse
	 * hovers an item in the viewer
	 * 
	 * @param viewer
	 *            the viewer
	 * @param dataProvider
	 *            class who provides information used to create the tooltip
	 */
	TooltipSupport(Viewer viewer, TooltipSupportDataProvider dataProvider) {
		this.viewer = viewer;
		this.dataProvider = dataProvider;
		this.tooltipListener = new TooltipListener();
	}

	/**
	 * Show up the tooltip to the user if possible
	 * 
	 * @param event
	 *            the mouse event occurred when the hovering the item
	 */
	private void showTooltip(Event event) {
		switch (event.type) {
		case SWT.MouseHover:
			TooltipData data = dataProvider.getData(event);

			if (data.columnIndex >= 0) {
				String content = tooltipPv.getTooltipText(data.modelObject,
						data.columnIndex);

				if (tip == null) {
					tip = new ToolTip(viewer.getControl().getShell(), SWT.NONE);
				} else {
					tip.setVisible(false);
				}

				if (content != null) {
					tip.setMessage(content);
					tip.setLocation(viewer.getControl().toDisplay(
							data.bounds.x, data.bounds.y));
					tip.setVisible(true);
				}
			}
			break;
		}
	}

	/**
	 * Configure the support for tooltips. If the label-provider passed is an
	 * instance of ITooltipProvider custom tooltips are turned for the
	 * underlying SWT-Widget if a normal LabelProvider is passed the
	 * TooltipSupport is turned off
	 * 
	 * @param labelProvider
	 *            the label provider
	 */
	void configureSupport(IBaseLabelProvider labelProvider) {
		if (labelProvider instanceof ITooltipProvider) {
			if (tooltipPv == null) {
				viewer.getControl().addListener(SWT.Dispose, tooltipListener);
				viewer.getControl().addListener(SWT.KeyDown, tooltipListener);
				viewer.getControl().addListener(SWT.MouseMove, tooltipListener);
				viewer.getControl()
						.addListener(SWT.MouseHover, tooltipListener);
			}
			tooltipPv = (ITooltipProvider) labelProvider;
		} else {
			if (tooltipPv != null) {
				viewer.getControl()
						.removeListener(SWT.Dispose, tooltipListener);
				viewer.getControl()
						.removeListener(SWT.KeyDown, tooltipListener);
				viewer.getControl().removeListener(SWT.MouseMove,
						tooltipListener);
				viewer.getControl().removeListener(SWT.MouseHover,
						tooltipListener);
				tooltipListener = null;
			}
			tooltipPv = null;
		}
	}

	/**
	 * Table Listener used to inform for widget events
	 * 
	 * @since 3.3
	 */
	private class TooltipListener implements Listener {

		public void handleEvent(Event event) {
			showTooltip(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;

import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Event;

/**
 * This class is responsible for providing the data used by the
 * {@link TooltipSupport}. This class gives TooltipSupport the possibility to
 * be completely independent from the viewer it is working for
 * 
 * @since 3.3
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 */
public abstract class TooltipSupportDataProvider {
	/**
	 * @param event
	 *            the event that occurred
	 * @return the data needed by TooltipSupport
	 */
	public abstract TooltipData getData(Event event);

	/**
	 * Wrapps up all data needed so they can be returned by one function call
	 * 
	 * @since 3.3
	 * @author Tom Schindl <tom.schindl@bestsolution.at>
	 */
	protected class TooltipData {
		/**
		 * 
		 */
		public int columnIndex = -1;

		/**
		 * 
		 */
		public Rectangle bounds = null;

		/**
		 * 
		 */
		public Object modelObject = null;
	}
}




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

/**
 * 
 * If you want to provide custom tooltips your LabelProvider should implement
 * this interface
 * 
 * @since 3.3
 * 
 */
public interface ITooltipProvider {
	/**
	 * Get the tooltip for the selected item
	 * 
	 * @param object
	 *            the model object
	 * @param columnIndex
	 *            the index of the column
	 * @return the tooltip displayed
	 */
	public String getTooltipText(Object object, int columnIndex);
}




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

import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.TraverseEvent;

/**
 * TableViewer delegates tabulator traversing to the class which implements how
 * elements are the next column in the table is selected. You may sub-class this
 * class and implement your own selection algorithm.
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * 
 * @since 3.3
 * @see TableViewer#setTabeditingDelegate(TabEditingDelegate)
 * @see TableViewer#setTabulatorTraversalEnabled(boolean)
 * 
 */
public class TabulatorTraversingDelegate {
	private boolean moveToRowNeighbor = false;

	private boolean cycleInRow = false;

	private boolean rowTabing = true;

	private boolean columnTabing = true;

	/**
	 * This method is called when in the actually active cell-editor a traversal
	 * event is kicked of by the user. Subclasses may override this method to
	 * implement their own selection mechanism.
	 * 
	 * @param e
	 *            the traversal event
	 * 
	 * @param activeColumn
	 *            the currently active column
	 * @param totalColumns
	 *            the totla number of columns
	 * @param activeRow
	 *            the active row
	 * @param totalRows
	 *            the total number of rows
	 * @param viewer
	 *            the viewer which support tabing
	 * @param widgetWrapper
	 *            the swt wigdet wrapped in a helper class
	 * @return true of a new column is activated
	 * @since 3.3
	 */
	public boolean focusNewEditor(TraverseEvent e, ITabulatorTraversingSupport viewer,
			TabulatorTraversingSupportWrapper widgetWrapper) {
		// FIXME WHAT TO DO WHEN THE NEXT COLUMN IS NOT EDITABLE/HAS NO FOCUS
		
		int activeColumn = widgetWrapper.getCurrentColumnIndex();
		int totalColumns = widgetWrapper.getColumnCount();
		int activeRow = widgetWrapper.getCurrentRowIndex(); 
		int totalRows = widgetWrapper.getRowCount();
		
		int editColumn = -1;

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

			if ((e.stateMask & SWT.CTRL) == SWT.CTRL && rowTabing) {
				if (activeRow > 0) {
					widgetWrapper.setSelectedRow(--activeRow);
					editColumn = activeColumn;
				}
			} else if (columnTabing) {
				if (activeColumn > 0) {
					editColumn = --activeColumn;
				} else if (cycleInRow) {
					editColumn = totalColumns - 1;
				} else if (moveToRowNeighbor) {
					if (activeRow > 0) {
						widgetWrapper.setSelectedRow(--activeRow);
						editColumn = totalColumns - 1;
					}
				}
			}
		} else if (e.detail == SWT.TRAVERSE_TAB_NEXT) {
			e.doit = false;

			if ((e.stateMask & SWT.CTRL) == SWT.CTRL && rowTabing) {
				if (activeRow < totalRows - 1) {
					widgetWrapper.setSelectedRow(++activeRow);
					editColumn = activeColumn;
				}
			} else if (columnTabing) {
				if (activeColumn < totalColumns - 1) {
					editColumn = ++activeColumn;
				} else if (cycleInRow) {
					editColumn = 0;
				} else if (moveToRowNeighbor) {
					if (activeRow < totalRows - 1) {
						widgetWrapper.setSelectedRow(++activeRow);
						editColumn = 0;
					}
				}
			}
		}

		if (editColumn >= 0) {
			viewer.editElement(((IStructuredSelection) viewer.getSelection())
					.getFirstElement(), editColumn);
			return true;
		}

		return false;
	}

	/**
	 * @return Returns the columnTabing.
	 * @since 3.3
	 */
	public boolean isColumnTabing() {
		return columnTabing;
	}

	/**
	 * Setting this to true the user can move from column to column pressing TAB
	 * and SHIFT+TAB. This is turned on by default.
	 * 
	 * @param columnTabing
	 *            The columnTabing to set.
	 * @since 3.3
	 */
	public void setColumnTabing(boolean columnTabing) {
		this.columnTabing = columnTabing;
	}

	/**
	 * @return Returns the cycleInRow.
	 * @since 3.3
	 */
	public boolean isCycleInRow() {
		return cycleInRow;
	}

	/**
	 * Setting this to true results in the fact that when the end of the row is
	 * reached the cursor is moved to the first column in the row. This is
	 * turned of by default.
	 * 
	 * @param cycleInRow
	 *            The cycleInRow to set.
	 * @since 3.3
	 */
	public void setCycleInRow(boolean cycleInRow) {
		this.cycleInRow = cycleInRow;
	}

	/**
	 * Setting this to true results in the fact that when the end of the current
	 * row is reached the cursor is moved to first/last column in the
	 * successor/predecessor. This is turned of by default.
	 * 
	 * @return Returns the moveToRowNeighbor.
	 * @since 3.3
	 */
	public boolean isMoveToRowNeighbor() {
		return moveToRowNeighbor;
	}

	/**
	 * @param moveToRowNeighbor
	 *            The moveToRowNeighbor to set.
	 * @since 3.3
	 */
	public void setMoveToRowNeighbor(boolean moveToRowNeighbor) {
		this.moveToRowNeighbor = moveToRowNeighbor;
	}

	/**
	 * @return Returns the rowTabing.
	 * @since 3.3
	 */
	public boolean isRowTabing() {
		return rowTabing;
	}

	/**
	 * Setting this to true results in the fact that you user can jump from row
	 * to row using CTRL+TAB/CTRL+SHIFT+TAB. This is turned on by default.
	 * 
	 * @param rowTabing
	 *            The rowTabing to set.
	 * @since 3.3
	 */
	public void setRowTabing(boolean rowTabing) {
		this.rowTabing = rowTabing;
	}
}




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

import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.widgets.TableColumn;

/**
 * This class represents an editable column in a table. It holds a Mapping
 * between Object types from your model and CellEditors used to edit the element
 * and is responsible for providing the cell-editor values to the editor and
 * restoring the values after editing has finished
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * @since 3.3
 */
public abstract class AbstractEditableTableColumn extends AbstractEditingColumn {

	private TableColumn tableColumn;

	/**
	 * Creates a new TableColumn which supports editing
	 * 
	 * @param viewer
	 *            the viewer the column is child of
	 * @param style
	 *            the style used for the column
	 * @since 3.3
	 */
	public AbstractEditableTableColumn(TableViewer viewer, int style) {
		this(new TableColumn(viewer.getTable(), style));
	}

	/**
	 * Add support for editing to the tablecolumn
	 * 
	 * @param tableColumn
	 *            column which should provide editing support
	 */
	public AbstractEditableTableColumn(TableColumn tableColumn) {
		super(tableColumn);
		this.tableColumn = tableColumn;
	}

	protected void doSetText(String text) {
		this.tableColumn.setText(text);
	}

	protected void doSetWidth(int width) {
		this.tableColumn.setWidth(width);
	}
}




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

/**
 * This class wraps calls to really objects because they are not accessible
 * through an interface because they are done on the concrete SWT-Classes e.g.
 * Tree/Table/...
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * @since 3.3
 */
public abstract class TabulatorTraversingSupportWrapper {
	/**
	 * Set the current selected row
	 * 
	 * @param index
	 *            the new row index
	 * @since 3.3
	 */
	public abstract void setSelectedRow(int index);

	/**
	 * @return the total number of columns
	 * @since 3.3
	 */
	public abstract int getColumnCount();

	/**
	 * @return the total number of rows
	 * @since 3.3
	 */
	public abstract int getRowCount();

	/**
	 * @return the current column index
	 * @since 3.3
	 */
	public abstract int getCurrentColumnIndex();

	/**
	 * @return the current row index
	 * @since 3.3
	 */
	public abstract int getCurrentRowIndex();
}




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

import java.util.HashMap;

import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.swt.widgets.Item;

/**
 * 
 * @since 3.3
 */
public abstract class AbstractEditingColumn implements IEditableColumn {

	/**
	 * The map between object types and cell-editors
	 */
	private HashMap cellEditors = new HashMap();

	protected AbstractEditingColumn(Item swtColumn) {
		swtColumn.setData(EDITING_SUPPORT_KEY, this);
	}

	public CellEditor getCellEditor(Object element) {
		return (CellEditor) this.cellEditors.get(element.getClass());
	}

	/**
	 * Add a mapping for the model element class type to your own type
	 * 
	 * @param elementType
	 *            the element type used
	 * @param cellEditor
	 *            the cell-editor used to edit this model element
	 * @since 3.3
	 */
	public void addCellEditorMapping(Class elementType, CellEditor cellEditor) {
		this.cellEditors.put(elementType, cellEditor);
	}

	/**
	 * Sets the column's text.
	 * 
	 * @param text
	 *            displayed in the column header
	 */
	public void setText(String text) {
		doSetText(text);
	}

	/**
	 * Set the column's width
	 * 
	 * @param width
	 *            the width of the column
	 */
	public void setWidth(int width) {
		doSetWidth(width);
	}

	protected abstract void doSetText(String text);

	protected abstract void doSetWidth(int width);
}




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

import org.eclipse.jface.viewers.ISelection;

/**
 * Viewers who want to provide tabulator traversal features have to implement
 * this interface.
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * @since 3.3
 */
public interface ITabulatorTraversingSupport {

	/**
	 * @param tabulatorTraversalEnabled
	 *            Turn on/off tab-editing support
	 * @since 3.3
	 */
	public void setTabulatorTraversalEnabled(boolean tabulatorTraversalEnabled);

	/**
	 * @return is tab-editing turned on
	 * @since 3.3
	 */
	public boolean isTabulatorTraversalEnabled();

	/**
	 * Set your own tab-editing delegate
	 * 
	 * @param tabeditingDelgate
	 *            the new delegate
	 * @since 3.3
	 */
	public void setTabeditingDelegate(
			TabulatorTraversingDelegate tabeditingDelgate);

	/**
	 * @return the tabediting delegate
	 * @since 3.3
	 */
	public TabulatorTraversingDelegate getTabeditingDelgate();

	/**
	 * Starts editing the given element.
	 * 
	 * @param element
	 *            the element
	 * @param column
	 *            the column number
	 * @see TableViewer#editElement(Object, int)
	 * @see AdvancedTreeViewer#editElement(Object, int)
	 */
	public void editElement(Object element, int column);

	/**
	 * The <code>StructuredViewer</code> implementation of this method returns
	 * the result as an <code>IStructuredSelection</code>.
	 * <p>
	 * Subclasses do not typically override this method, but implement
	 * <code>getSelectionFromWidget(List)</code> instead.
	 * <p>
	 * 
	 * @return ISelection
	 * @see ISelectionProvider#getSelection()
	 */
	public ISelection getSelection();
}




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

import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ICellModifier;

/**
 * This interface can be used if there are multiple columns using the same
 * editor. The resulting code is very similar to the one found in:
 * <ul>
 * <li>{@link ICellModifier#modify(Object, String, Object)}</li>
 * <li>{@link ICellModifier#getValue(Object, String)} </li>
 * </ul>
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * @since 3.3
 */
public interface IEditableMultiColumn extends IEditableColumn {

	/**
	 * Fetch the cell editor for this model element
	 * 
	 * @param element
	 *            the model element
	 * @param columnIndex
	 *            the current column index
	 * @return the celleditor or null if none is known for this object type
	 * @since 3.3
	 */
	public CellEditor getCellEditor(Object element, int columnIndex);
	
	/**
	 * enable/disable editing
	 * 
	 * @param element
	 *            the model element which should be edited
	 * @param columnIndex
	 *            the current column index
	 * @return true if a editor should be displayed
	 * @since 3.3
	 */
	public boolean canEdit(Object element, int columnIndex);

	/**
	 * fetch the value for the desired column index passed on to the CellEditor
	 * 
	 * @param element
	 *            the model element
	 * @param columnIndex
	 *            the column-index
	 * @return the value for editing
	 * @see AbstractEditableTableColumn#getValue(Object)
	 * @see AbstractEditableTreeColumn#getValue(Object)
	 * @since 3.3
	 */
	public abstract Object getValue(Object element, int columnIndex);

	/**
	 * restore the value from the editor in the model object
	 * 
	 * @param element
	 *            the model element
	 * @param value
	 *            the value entered into the cell-editor
	 * @param columnIndex
	 *            the current column index
	 * @since 3.3
	 */
	public abstract void setValue(Object element, Object value, int columnIndex);
}




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

import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.swt.widgets.Item;

/**
 * This interface has to be implemented by any editable Column which is added to
 * a TreeViewer or a TableViewer
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * @since 3.3
 */
public interface IEditableColumn {
	
	/**
	 * Key used to restore editing support into {@link Item#setData(String, Object)}
	 */
	public static final String EDITING_SUPPORT_KEY = "editingSupport"; //$NON-NLS-1$
	
	/**
	 * Fetch the cell editor for this model element
	 * 
	 * @param element
	 *            the model element
	 * @return the celleditor or null if none is known for this object type
	 * @since 3.3
	 */
	public CellEditor getCellEditor(Object element);

	/**
	 * enable/disable editing
	 * 
	 * @param element
	 *            the model element which should be edited
	 * @return true if a editor should be displayed
	 * @since 3.3
	 */
	public boolean canEdit(Object element);

	/**
	 * @param element
	 *            the model element
	 * @return the value which is put in the cell-editor when it pops up
	 * @since 3.3
	 */
	public Object getValue(Object element);

	/**
	 * Restore the value in the model element
	 * 
	 * @param element
	 *            the model element
	 * @param value
	 *            the new value from the cell-editor
	 * @since 3.3
	 */
	public void setValue(Object element, Object value);
}




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

import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.widgets.TreeColumn;

/**
 * This class represents an editable column in a tree. It holds a Mapping
 * between Object types from your model and CellEditors used to edit the element
 * and is responsible for providing the cell-editor values to the editor and
 * restoring the values after editing has finished
 * 
 * @author Tom Schindl <tom.schindl@bestsolution.at>
 * @since 3.3
 */
public abstract class AbstractEditableTreeColumn extends AbstractEditingColumn {
	private TreeColumn treeColumn;

	/**
	 * Creates a new TreeColumn which supports editing
	 * 
	 * @param parent
	 *            the viewer the column is child of
	 * @param style
	 *            the style used for the column
	 * @since 3.3
	 */
	public AbstractEditableTreeColumn(TreeViewer parent, int style) {
		this(new TreeColumn(parent.getTree(), style));
	}

	/**
	 * Add support for editing to the treecolumn
	 * 
	 * @param treeColumn
	 *            column which should provide editing support
	 */
	public AbstractEditableTreeColumn(TreeColumn treeColumn) {
		super(treeColumn);
		this.treeColumn = treeColumn;
	}

	protected void doSetText(String text) {
		this.treeColumn.setText(text);
	}

	protected void doSetWidth(int width) {
		this.treeColumn.setWidth(width);
	}
}

Return to bug 142655

Added Link Here

(-)src/org/eclipse/jface/viewers/TooltipSupport.java (+133 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.viewers;
13
14	import org.eclipse.jface.viewers.TooltipSupportDataProvider.TooltipData;
15	import org.eclipse.swt.SWT;
16	import org.eclipse.swt.widgets.Event;
17	import org.eclipse.swt.widgets.Listener;
18	import org.eclipse.swt.widgets.ToolTip;
19
20	/**
21	* This class adds tooltip support to viewers whose LabelProvider implement the
22	* none manadory interface {@link ITooltipProvider}. This class is not
23	* dependent on any Viewer but uses TooltipSupportDataProvider to fetch all data
24	* important to display the Tooltip
25	*
26	* @since 3.3
27	* @author Tom Schindl <tom.schindl@bestsolution.at>
28	*/
29	class TooltipSupport {
30	private TooltipSupportDataProvider dataProvider;
31
32	private ITooltipProvider tooltipPv;
33
34	private Viewer viewer;
35
36	private ToolTip tip;
37
38	private TooltipListener tooltipListener;
39
40	/**
41	* Create a new tooltip supported who displays tooltips when the mouse
42	* hovers an item in the viewer
43	*
44	* @param viewer
45	* the viewer
46	* @param dataProvider
47	* class who provides information used to create the tooltip
48	*/
49	TooltipSupport(Viewer viewer, TooltipSupportDataProvider dataProvider) {
50	this.viewer = viewer;
51	this.dataProvider = dataProvider;
52	this.tooltipListener = new TooltipListener();
53	}
54
55	/**
56	* Show up the tooltip to the user if possible
57	*
58	* @param event
59	* the mouse event occurred when the hovering the item
60	*/
61	private void showTooltip(Event event) {
62	switch (event.type) {
63	case SWT.MouseHover:
64	TooltipData data = dataProvider.getData(event);
65
66	if (data.columnIndex >= 0) {
67	String content = tooltipPv.getTooltipText(data.modelObject,
68	data.columnIndex);
69
70	if (tip == null) {
71	tip = new ToolTip(viewer.getControl().getShell(), SWT.NONE);
72	} else {
73	tip.setVisible(false);
74	}
75
76	if (content != null) {
77	tip.setMessage(content);
78	tip.setLocation(viewer.getControl().toDisplay(
79	data.bounds.x, data.bounds.y));
80	tip.setVisible(true);
81	}
82	}
83	break;
84	}
85	}
86
87	/**
88	* Configure the support for tooltips. If the label-provider passed is an
89	* instance of ITooltipProvider custom tooltips are turned for the
90	* underlying SWT-Widget if a normal LabelProvider is passed the
91	* TooltipSupport is turned off
92	*
93	* @param labelProvider
94	* the label provider
95	*/
96	void configureSupport(IBaseLabelProvider labelProvider) {
97	if (labelProvider instanceof ITooltipProvider) {
98	if (tooltipPv == null) {
99	viewer.getControl().addListener(SWT.Dispose, tooltipListener);
100	viewer.getControl().addListener(SWT.KeyDown, tooltipListener);
101	viewer.getControl().addListener(SWT.MouseMove, tooltipListener);
102	viewer.getControl()
103	.addListener(SWT.MouseHover, tooltipListener);
104	}
105	tooltipPv = (ITooltipProvider) labelProvider;
106	} else {
107	if (tooltipPv != null) {
108	viewer.getControl()
109	.removeListener(SWT.Dispose, tooltipListener);
110	viewer.getControl()
111	.removeListener(SWT.KeyDown, tooltipListener);
112	viewer.getControl().removeListener(SWT.MouseMove,
113	tooltipListener);
114	viewer.getControl().removeListener(SWT.MouseHover,
115	tooltipListener);
116	tooltipListener = null;
117	}
118	tooltipPv = null;
119	}
120	}
121
122	/**
123	* Table Listener used to inform for widget events
124	*
125	* @since 3.3
126	*/
127	private class TooltipListener implements Listener {
128
129	public void handleEvent(Event event) {
130	showTooltip(event);
131	}
132	}
133	}

Added Link Here

(-)src/org/eclipse/jface/viewers/ITooltipProvider.java (+33 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	*
16	* If you want to provide custom tooltips your LabelProvider should implement
17	* this interface
18	*
19	* @since 3.3
20	*
21	*/
22	public interface ITooltipProvider {
23	/**
24	* Get the tooltip for the selected item
25	*
26	* @param object
27	* the model object
28	* @param columnIndex
29	* the index of the column
30	* @return the tooltip displayed
31	*/
32	public String getTooltipText(Object object, int columnIndex);
33	}

Added Link Here

(-)src/org/eclipse/jface/viewers/editing/TabulatorTraversingDelegate.java (+205 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.editing;
13
14	import org.eclipse.jface.viewers.IStructuredSelection;
15	import org.eclipse.swt.SWT;
16	import org.eclipse.swt.events.TraverseEvent;
17
18	/**
19	* TableViewer delegates tabulator traversing to the class which implements how
20	* elements are the next column in the table is selected. You may sub-class this
21	* class and implement your own selection algorithm.
22	*
23	* @author Tom Schindl <tom.schindl@bestsolution.at>
24	*
25	* @since 3.3
26	* @see TableViewer#setTabeditingDelegate(TabEditingDelegate)
27	* @see TableViewer#setTabulatorTraversalEnabled(boolean)
28	*
29	*/
30	public class TabulatorTraversingDelegate {
31	private boolean moveToRowNeighbor = false;
32
33	private boolean cycleInRow = false;
34
35	private boolean rowTabing = true;
36
37	private boolean columnTabing = true;
38
39	/**
40	* This method is called when in the actually active cell-editor a traversal
41	* event is kicked of by the user. Subclasses may override this method to
42	* implement their own selection mechanism.
43	*
44	* @param e
45	* the traversal event
46	*
47	* @param activeColumn
48	* the currently active column
49	* @param totalColumns
50	* the totla number of columns
51	* @param activeRow
52	* the active row
53	* @param totalRows
54	* the total number of rows
55	* @param viewer
56	* the viewer which support tabing
57	* @param widgetWrapper
58	* the swt wigdet wrapped in a helper class
59	* @return true of a new column is activated
60	* @since 3.3
61	*/
62	public boolean focusNewEditor(TraverseEvent e, ITabulatorTraversingSupport viewer,
63	TabulatorTraversingSupportWrapper widgetWrapper) {
64	// FIXME WHAT TO DO WHEN THE NEXT COLUMN IS NOT EDITABLE/HAS NO FOCUS
65
66	int activeColumn = widgetWrapper.getCurrentColumnIndex();
67	int totalColumns = widgetWrapper.getColumnCount();
68	int activeRow = widgetWrapper.getCurrentRowIndex();
69	int totalRows = widgetWrapper.getRowCount();
70
71	int editColumn = -1;
72
73	if (e.detail == SWT.TRAVERSE_TAB_PREVIOUS) {
74	e.doit = false;
75
76	if ((e.stateMask & SWT.CTRL) == SWT.CTRL && rowTabing) {
77	if (activeRow > 0) {
78	widgetWrapper.setSelectedRow(--activeRow);
79	editColumn = activeColumn;
80	}
81	} else if (columnTabing) {
82	if (activeColumn > 0) {
83	editColumn = --activeColumn;
84	} else if (cycleInRow) {
85	editColumn = totalColumns - 1;
86	} else if (moveToRowNeighbor) {
87	if (activeRow > 0) {
88	widgetWrapper.setSelectedRow(--activeRow);
89	editColumn = totalColumns - 1;
90	}
91	}
92	}
93	} else if (e.detail == SWT.TRAVERSE_TAB_NEXT) {
94	e.doit = false;
95
96	if ((e.stateMask & SWT.CTRL) == SWT.CTRL && rowTabing) {
97	if (activeRow < totalRows - 1) {
98	widgetWrapper.setSelectedRow(++activeRow);
99	editColumn = activeColumn;
100	}
101	} else if (columnTabing) {
102	if (activeColumn < totalColumns - 1) {
103	editColumn = ++activeColumn;
104	} else if (cycleInRow) {
105	editColumn = 0;
106	} else if (moveToRowNeighbor) {
107	if (activeRow < totalRows - 1) {
108	widgetWrapper.setSelectedRow(++activeRow);
109	editColumn = 0;
110	}
111	}
112	}
113	}
114
115	if (editColumn >= 0) {
116	viewer.editElement(((IStructuredSelection) viewer.getSelection())
117	.getFirstElement(), editColumn);
118	return true;
119	}
120
121	return false;
122	}
123
124	/**
125	* @return Returns the columnTabing.
126	* @since 3.3
127	*/
128	public boolean isColumnTabing() {
129	return columnTabing;
130	}
131
132	/**
133	* Setting this to true the user can move from column to column pressing TAB
134	* and SHIFT+TAB. This is turned on by default.
135	*
136	* @param columnTabing
137	* The columnTabing to set.
138	* @since 3.3
139	*/
140	public void setColumnTabing(boolean columnTabing) {
141	this.columnTabing = columnTabing;
142	}
143
144	/**
145	* @return Returns the cycleInRow.
146	* @since 3.3
147	*/
148	public boolean isCycleInRow() {
149	return cycleInRow;
150	}
151
152	/**
153	* Setting this to true results in the fact that when the end of the row is
154	* reached the cursor is moved to the first column in the row. This is
155	* turned of by default.
156	*
157	* @param cycleInRow
158	* The cycleInRow to set.
159	* @since 3.3
160	*/
161	public void setCycleInRow(boolean cycleInRow) {
162	this.cycleInRow = cycleInRow;
163	}
164
165	/**
166	* Setting this to true results in the fact that when the end of the current
167	* row is reached the cursor is moved to first/last column in the
168	* successor/predecessor. This is turned of by default.
169	*
170	* @return Returns the moveToRowNeighbor.
171	* @since 3.3
172	*/
173	public boolean isMoveToRowNeighbor() {
174	return moveToRowNeighbor;
175	}
176
177	/**
178	* @param moveToRowNeighbor
179	* The moveToRowNeighbor to set.
180	* @since 3.3
181	*/
182	public void setMoveToRowNeighbor(boolean moveToRowNeighbor) {
183	this.moveToRowNeighbor = moveToRowNeighbor;
184	}
185
186	/**
187	* @return Returns the rowTabing.
188	* @since 3.3
189	*/
190	public boolean isRowTabing() {
191	return rowTabing;
192	}
193
194	/**
195	* Setting this to true results in the fact that you user can jump from row
196	* to row using CTRL+TAB/CTRL+SHIFT+TAB. This is turned on by default.
197	*
198	* @param rowTabing
199	* The rowTabing to set.
200	* @since 3.3
201	*/
202	public void setRowTabing(boolean rowTabing) {
203	this.rowTabing = rowTabing;
204	}
205	}