Attachment #55449 for bug #167325

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

Lines 17-22 Link Here

(-)Eclipse JFace Snippets/org/eclipse/jface/snippets/viewers/Snippet010OwnerDraw.java (-25 / +24 lines)
17	import org.eclipse.jface.viewers.StructuredSelection;	17	import org.eclipse.jface.viewers.StructuredSelection;
18	import org.eclipse.jface.viewers.TableLayout;	18	import org.eclipse.jface.viewers.TableLayout;
19	import org.eclipse.jface.viewers.TableViewer;	19	import org.eclipse.jface.viewers.TableViewer;
		20	import org.eclipse.jface.viewers.TableViewerColumn;
20	import org.eclipse.swt.SWT;	21	import org.eclipse.swt.SWT;
21	import org.eclipse.swt.graphics.Color;	22	import org.eclipse.swt.graphics.Color;
22	import org.eclipse.swt.graphics.Rectangle;	23	import org.eclipse.swt.graphics.Rectangle;
Lines 28-34 Link Here
28	import org.eclipse.swt.widgets.Display;	29	import org.eclipse.swt.widgets.Display;
29	import org.eclipse.swt.widgets.Event;	30	import org.eclipse.swt.widgets.Event;
30	import org.eclipse.swt.widgets.Shell;	31	import org.eclipse.swt.widgets.Shell;
31	import org.eclipse.swt.widgets.TableColumn;
32		32
33	public class Snippet010OwnerDraw {	33	public class Snippet010OwnerDraw {
34		34
Lines 350-357 Link Here
350		350
351	});	351	});
352	createColumns();	352	createColumns();
		353
		354	OwnerDrawLabelProvider.setUpOwnerDraw(viewer);
		355	viewer.setInput(this);
		356	GridData data = new GridData(GridData.GRAB_HORIZONTAL
		357	\| GridData.GRAB_VERTICAL \| GridData.FILL_BOTH);
353		358
354	viewer.setLabelProvider(new OwnerDrawLabelProvider() {	359	viewer.getControl().setLayoutData(data);
		360
		361	viewer.setSelection(new StructuredSelection(entries[1]));
		362	}
		363
		364	/**
		365	* Create the columns to be used in the tree.
		366	*/
		367	private void createColumns() {
		368	TableLayout layout = new TableLayout();
		369	viewer.getTable().setLayout(layout);
		370	viewer.getTable().setHeaderVisible(true);
		371	viewer.getTable().setLinesVisible(true);
		372
		373	for (int i = 0; i < COLUMN_COUNT; i++) {
		374	TableViewerColumn tc = new TableViewerColumn(viewer, SWT.NONE, i);
		375	tc.setLabelProvider(new OwnerDrawLabelProvider() {
355	/*	376	/*
356	* (non-Javadoc)	377	* (non-Javadoc)
357	*	378	*
Lines 399-428 Link Here
399		420
400	}	421	}
401	});	422	});
402
403	OwnerDrawLabelProvider.setUpOwnerDraw(viewer);
404	viewer.setInput(this);
405	GridData data = new GridData(GridData.GRAB_HORIZONTAL
406	\| GridData.GRAB_VERTICAL \| GridData.FILL_BOTH);
407
408	viewer.getControl().setLayoutData(data);
409
410	viewer.setSelection(new StructuredSelection(entries[1]));
411	}
412
413	/**
414	* Create the columns to be used in the tree.
415	*/
416	private void createColumns() {
417	TableLayout layout = new TableLayout();
418	viewer.getTable().setLayout(layout);
419	viewer.getTable().setHeaderVisible(true);
420	viewer.getTable().setLinesVisible(true);
421
422	for (int i = 0; i < COLUMN_COUNT; i++) {
423	TableColumn tc = new TableColumn(viewer.getTable(), SWT.NONE, i);
424	layout.addColumnData(new ColumnPixelData(100));	423	layout.addColumnData(new ColumnPixelData(100));
425	tc.setText(getTitleFor(i));	424	tc.getColumn().setText(getTitleFor(i));
426	}	425	}
427	;	426	;
428	}	427	}




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

package org.eclipse.jface.snippets.viewers;

import java.util.ArrayList;

import org.eclipse.jface.resource.FontRegistry;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;

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

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

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

		}

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

		}

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

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

			return ((MyModel) element).parent;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
		 */
		public boolean hasChildren(Object element) {
			return ((MyModel) element).child.size() > 0;
		}

	}

	public class MyModel {
		public MyModel parent;

		public ArrayList child = new ArrayList();

		public int counter;

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

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

			rv += counter;

			return rv;
		}
	}

	public class MyLabelProvider extends LabelProvider implements
			ITableLabelProvider {
		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 Snippet026TreeViewerTabEditing(Shell shell) {
		final TreeViewer v = new TreeViewer(shell,SWT.BORDER|SWT.FULL_SELECTION);
		
		TreeColumn column = new TreeColumn(v.getTree(),SWT.NONE);
		column.setWidth(200);
		column.setText("Column 1");
		
		column = new TreeColumn(v.getTree(),SWT.NONE);
		column.setWidth(200);
		column.setText("Column 2");
		
		v.setLabelProvider(new MyLabelProvider());
		v.setContentProvider(new MyContentProvider());
		v.setCellModifier(new ICellModifier() {

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

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

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

	private MyModel createModel() {

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

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

		return root;
	}

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

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

		display.dispose();
	}
}




		return item.getParent();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerRow#getRowAbove(boolean)
	 */
	public ViewerRow getRowAbove(boolean sameLevel) {
		int index = item.getParent().indexOf(item) - 1;
		
		if( index >= 0 ) {
			return (ViewerRow)item.getParent().getItem(index).getData(ViewerRow.ROWPART_KEY); 
		}
		
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerRow#getRowBelow(boolean)
	 */
	public ViewerRow getRowBelow(boolean sameLevel) {
		int index = item.getParent().indexOf(item) + 1;
		
		if( index < item.getParent().getItemCount() ) {
			TableItem 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;
	}

}




import org.eclipse.core.runtime.Assert;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;

/**
 * EditingSupport is the abstract superclass of the support for cell editing.

		ViewerRow newRow = null;

		if (above) {
			newRow = row.getRowAbove(false);
		} else {
			newRow = row.getRowBelow(false);
		}

		if (newRow != null) {

							startIndex);
				}
			} else if ((getTabingStyle() & TABING_MOVE_TO_ROW_NEIGHBOR) == TABING_MOVE_TO_ROW_NEIGHBOR) {
				ViewerRow rowAbove = row.getRowAbove(false);
				if (rowAbove != null) {
					rv = searchPreviousCell(rowAbove, viewer, rowAbove
							.getColumnCount(), startIndex);

					rv = searchNextCell(row, viewer, -1, startIndex);
				}
			} else if ((getTabingStyle() & TABING_MOVE_TO_ROW_NEIGHBOR) == TABING_MOVE_TO_ROW_NEIGHBOR) {
				ViewerRow rowBelow = row.getRowBelow(false);
				if (rowBelow != null) {
					rv = searchNextCell(rowBelow, viewer, -1, startIndex);
				}


		return rv;
	}

	private ViewerRow getRowAbove(ViewerRow row, ColumnViewer viewer) {
		// TODO maybe there's a better solution maybe we should provide an
		// API in ViewerColumn
		// to find row above/below itself?
		Rectangle r = row.getBounds();
		return viewer.getViewerRow(new Point(r.x, r.y - 2));
	}

	private ViewerRow getRowBelow(ViewerRow row, ColumnViewer viewer) {
		// TODO maybe there's a better solution maybe we should provide an
		// API in ViewerColumn
		// to find row above/below itself?
		Rectangle r = row.getBounds();
		return viewer.getViewerRow(new Point(r.x,
				r.y + r.height + 2));
	}
	
	/**
	 * @return the viewer this editing support works for




import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;

/**

	public Control getControl() {
		return item.getParent();
	}

	private TreeItem findLastVisibleItem(TreeItem parentItem) {
		TreeItem rv = parentItem;
		
		if( rv.getExpanded() && rv.getItemCount() > 0 ) {
			rv = findLastVisibleItem(rv.getItem(rv.getItemCount()-1));
		}
		
		return rv;
	}

	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerRow#getRowAbove(boolean)
	 */
	public ViewerRow getRowAbove(boolean sameLevel) {
		Tree tree = item.getParent();
		
		// This means we have top-level item
		if( item.getParentItem() == null ) {
			int index = tree.indexOf(item) - 1;
			TreeItem nextTopItem = null;
			
			if( index >= 0 ) {
				nextTopItem = tree.getItem(index);
			}
			
			if( nextTopItem != null ) {
				if( sameLevel ) {
					return (ViewerRow)nextTopItem.getData(ViewerRow.ROWPART_KEY);
				}
				
				return (ViewerRow) findLastVisibleItem(nextTopItem).getData(ViewerRow.ROWPART_KEY);
			}
		} else {
			TreeItem[] neighbours = item.getParentItem().getItems();
			TreeItem itemBefore = null;
			for( int i = 0; i < neighbours.length; i++ ) {
				if( neighbours[i] != item ) {
					itemBefore = neighbours[i];
				} else {
					break;
				}
			}
			
			// This means that this was the first child
			if( itemBefore == null ) {
				itemBefore = item.getParentItem();
			} else {
				itemBefore = findLowestLeave(itemBefore);
			}
			
			if( itemBefore != null ) {
				return (ViewerRow) itemBefore.getData(ViewerRow.ROWPART_KEY);
			}
		}
		
		return null;
	}

	private TreeItem findLowestLeave(TreeItem item) {
		TreeItem rv = item;
		
		if( rv.getExpanded() && rv.getItemCount() > 0 ) {
			rv = findLowestLeave(rv.getItem(rv.getItemCount()-1));
		}
		
		return rv;
	}
	
	private TreeItem findNextItem(TreeItem item) {
		TreeItem rv = null;
		TreeItem parent = item.getParentItem();
		TreeItem[] neighbours;
		
		if( parent == null ) {
			neighbours = item.getParent().getItems();
		} else {
			neighbours = parent.getItems();
		}
		
		int i = 0; 
		for( i = 0; i < neighbours.length; i++ ) {
			if( neighbours[i] == item ) {
				break;
			}
		}
				
		// This is once more the last item in the tree
		// Search on
		if( i == neighbours.length - 1 ) {
			if( item.getParentItem() != null ) {
				rv = findNextItem(item.getParentItem());
			}
		} else {
			rv = neighbours[i+1];
		}
		
		return rv;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerRow#getRowBelow(boolean)
	 */
	public ViewerRow getRowBelow(boolean sameLevel) {
		Tree tree = item.getParent();
		
		// This means we have top-level item
		if( item.getParentItem() == null ) {
			if( sameLevel || ! item.getExpanded() ) {
				int index = tree.indexOf(item) + 1;
				
				if( index < tree.getItemCount() ) {
					return (ViewerRow)tree.getItem(index).getData(ViewerRow.ROWPART_KEY);
				}
			} else if( item.getExpanded() && item.getItemCount() > 0 ) {
				return (ViewerRow)item.getItem(0).getData(ViewerRow.ROWPART_KEY);
			}
		} else {
			if( sameLevel || ! item.getExpanded() ) {
				TreeItem[] neighbours = item.getParentItem().getItems();
				TreeItem itemAfter = null;
				int i = 0;
				for( i = 0; i < neighbours.length; i++ ) {
					if( neighbours[i] == item ) {
						break;
					}
				}
				
				// This would mean that it was the last item
				if( i == neighbours.length - 1 ) {
					itemAfter = findNextItem( item.getParentItem() );
				} else {
					itemAfter = neighbours[i+1];
				}
				
				if( itemAfter != null ) {
					return (ViewerRow) itemAfter.getData(ViewerRow.ROWPART_KEY);
				}
				
			} else if( item.getExpanded() && item.getItemCount() > 0 ) {
				return (ViewerRow)item.getItem(0).getData(ViewerRow.ROWPART_KEY);
			}
		}

		return null;
	}
}




	 */
	public int getColumnIndex(Point point) {
		int count = getColumnCount();

		// If there are no columns the column-index is 0
		if (count == 0) {
			return 0;
		}

		for (int i = 0; i < count; i++) {
			if (getBounds(i).contains(point)) {
				return i;

	 */
	public abstract Control getControl();

	/**
	 * Find the row above this row
	 * 
	 * @param sameLevel
	 *            search at the samelevel
	 * @return the row above or <code>null</code>
	 */
	public abstract ViewerRow getRowAbove(boolean sameLevel);

	/**
	 * Find the row below this row
	 * 
	 * @param sameLevel
	 *            search at the samelevel
	 * @return the row below or <code>null</code>
	 */
	public abstract ViewerRow getRowBelow(boolean sameLevel);
}




	public Control getControl() {
		return row.getControl();
	}

	/**
	 * @param sameLevel
	 *            should the cell be at the same hirarchie level than this cell
	 * @return the {@link ViewerCell} or <code>null</code> if no cell above
	 *         can be found
	 */
	public ViewerCell getCellAbove(boolean sameLevel) {
		ViewerRow rowAbove = row.getRowAbove(sameLevel);

		if (rowAbove != null) {
			return rowAbove.getCell(getColumnIndex());
		}

		return null;
	}

	/**
	 * @param sameLevel
	 *            should the cell be at the same hirarchie level than this cell
	 * @return the {@link ViewerCell} or <code>null</code> if no cell below
	 *         can be found
	 */
	public ViewerCell getCellBelow(boolean sameLevel) {
		ViewerRow rowBelow = row.getRowBelow(sameLevel);
		if (rowBelow != null) {
			rowBelow.getCell(getColumnIndex());
		}
		return null;
	}

	/**
	 * @return the {@link ViewerCell} to the left of this cell or
	 *         <code>null</code> if no cell below can be found
	 */
	public ViewerCell getCellLeft() {
		int index = getColumnIndex() - 1;

		if (index >= 0) {
			return row.getCell(index);
		}

		return null;
	}

	/**
	 * @return the {@link ViewerCell} to the right of this cell or
	 *         <code>null</code> if no cell below can be found
	 */
	public ViewerCell getCellRight() {
		int index = getColumnIndex() + 1;

		if (index < row.getColumnCount()) {
			return row.getCell(index);
		}

		return null;
	}
}

Return to bug 167325

Lines 146-149 Link Here

(-)src/org/eclipse/jface/viewers/TableViewerRow.java (+30 lines)
146	return item.getParent();	146	return item.getParent();
147	}	147	}
148		148
		149	/* (non-Javadoc)
		150	* @see org.eclipse.jface.viewers.ViewerRow#getRowAbove(boolean)
		151	*/
		152	public ViewerRow getRowAbove(boolean sameLevel) {
		153	int index = item.getParent().indexOf(item) - 1;
		154
		155	if( index >= 0 ) {
		156	return (ViewerRow)item.getParent().getItem(index).getData(ViewerRow.ROWPART_KEY);
		157	}
		158
		159	return null;
		160	}
		161
		162	/* (non-Javadoc)
		163	* @see org.eclipse.jface.viewers.ViewerRow#getRowBelow(boolean)
		164	*/
		165	public ViewerRow getRowBelow(boolean sameLevel) {
		166	int index = item.getParent().indexOf(item) + 1;
		167
		168	if( index < item.getParent().getItemCount() ) {
		169	TableItem tmp = item.getParent().getItem(index);
		170	//TODO NULL can happen in case of VIRTUAL => How do we deal with that
		171	if( tmp != null ) {
		172	return (ViewerRow)tmp.getData(ViewerRow.ROWPART_KEY);
		173	}
		174	}
		175
		176	return null;
		177	}
		178
149	}	179	}

Lines 16-23 Link Here

(-)src/org/eclipse/jface/viewers/EditingSupport.java (-23 / +4 lines)
16	import org.eclipse.core.runtime.Assert;	16	import org.eclipse.core.runtime.Assert;
17	import org.eclipse.swt.SWT;	17	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.events.TraverseEvent;	18	import org.eclipse.swt.events.TraverseEvent;
19	import org.eclipse.swt.graphics.Point;
20	import org.eclipse.swt.graphics.Rectangle;
21		19
22	/**	20	/**
23	* EditingSupport is the abstract superclass of the support for cell editing.	21	* EditingSupport is the abstract superclass of the support for cell editing.
Lines 184-192 Link Here
184	ViewerRow newRow = null;	182	ViewerRow newRow = null;
185		183
186	if (above) {	184	if (above) {
187	newRow = getRowAbove(row, viewer);	185	newRow = row.getRowAbove(false);
188	} else {	186	} else {
189	newRow = getRowBelow(row, viewer);	187	newRow = row.getRowBelow(false);
190	}	188	}
191		189
192	if (newRow != null) {	190	if (newRow != null) {
Lines 228-234 Link Here
228	startIndex);	226	startIndex);
229	}	227	}
230	} else if ((getTabingStyle() & TABING_MOVE_TO_ROW_NEIGHBOR) == TABING_MOVE_TO_ROW_NEIGHBOR) {	228	} else if ((getTabingStyle() & TABING_MOVE_TO_ROW_NEIGHBOR) == TABING_MOVE_TO_ROW_NEIGHBOR) {
231	ViewerRow rowAbove = getRowAbove(row, viewer);	229	ViewerRow rowAbove = row.getRowAbove(false);
232	if (rowAbove != null) {	230	if (rowAbove != null) {
233	rv = searchPreviousCell(rowAbove, viewer, rowAbove	231	rv = searchPreviousCell(rowAbove, viewer, rowAbove
234	.getColumnCount(), startIndex);	232	.getColumnCount(), startIndex);
Lines 261-267 Link Here
261	rv = searchNextCell(row, viewer, -1, startIndex);	259	rv = searchNextCell(row, viewer, -1, startIndex);
262	}	260	}
263	} else if ((getTabingStyle() & TABING_MOVE_TO_ROW_NEIGHBOR) == TABING_MOVE_TO_ROW_NEIGHBOR) {	261	} else if ((getTabingStyle() & TABING_MOVE_TO_ROW_NEIGHBOR) == TABING_MOVE_TO_ROW_NEIGHBOR) {
264	ViewerRow rowBelow = getRowBelow(row, viewer);	262	ViewerRow rowBelow = row.getRowBelow(false);
265	if (rowBelow != null) {	263	if (rowBelow != null) {
266	rv = searchNextCell(rowBelow, viewer, -1, startIndex);	264	rv = searchNextCell(rowBelow, viewer, -1, startIndex);
267	}	265	}
Lines 270-292 Link Here
270		268
271	return rv;	269	return rv;
272	}	270	}
273
274	private ViewerRow getRowAbove(ViewerRow row, ColumnViewer viewer) {
275	// TODO maybe there's a better solution maybe we should provide an
276	// API in ViewerColumn
277	// to find row above/below itself?
278	Rectangle r = row.getBounds();
279	return viewer.getViewerRow(new Point(r.x, r.y - 2));
280	}
281
282	private ViewerRow getRowBelow(ViewerRow row, ColumnViewer viewer) {
283	// TODO maybe there's a better solution maybe we should provide an
284	// API in ViewerColumn
285	// to find row above/below itself?
286	Rectangle r = row.getBounds();
287	return viewer.getViewerRow(new Point(r.x,
288	r.y + r.height + 2));
289	}
290		271
291	/**	272	/**
292	* @return the viewer this editing support works for	273	* @return the viewer this editing support works for

Lines 18-23 Link Here

(-)src/org/eclipse/jface/viewers/TreeViewerRow.java (+148 lines)
18	import org.eclipse.swt.graphics.Rectangle;	18	import org.eclipse.swt.graphics.Rectangle;
19	import org.eclipse.swt.widgets.Control;	19	import org.eclipse.swt.widgets.Control;
20	import org.eclipse.swt.widgets.Item;	20	import org.eclipse.swt.widgets.Item;
		21	import org.eclipse.swt.widgets.Tree;
21	import org.eclipse.swt.widgets.TreeItem;	22	import org.eclipse.swt.widgets.TreeItem;
22		23
23	/**	24	/**
Lines 144-147 Link Here
144	public Control getControl() {	145	public Control getControl() {
145	return item.getParent();	146	return item.getParent();
146	}	147	}
		148
		149	private TreeItem findLastVisibleItem(TreeItem parentItem) {
		150	TreeItem rv = parentItem;
		151
		152	if( rv.getExpanded() && rv.getItemCount() > 0 ) {
		153	rv = findLastVisibleItem(rv.getItem(rv.getItemCount()-1));
		154	}
		155
		156	return rv;
		157	}
		158
		159
		160	/* (non-Javadoc)
		161	* @see org.eclipse.jface.viewers.ViewerRow#getRowAbove(boolean)
		162	*/
		163	public ViewerRow getRowAbove(boolean sameLevel) {
		164	Tree tree = item.getParent();
		165
		166	// This means we have top-level item
		167	if( item.getParentItem() == null ) {
		168	int index = tree.indexOf(item) - 1;
		169	TreeItem nextTopItem = null;
		170
		171	if( index >= 0 ) {
		172	nextTopItem = tree.getItem(index);
		173	}
		174
		175	if( nextTopItem != null ) {
		176	if( sameLevel ) {
		177	return (ViewerRow)nextTopItem.getData(ViewerRow.ROWPART_KEY);
		178	}
		179
		180	return (ViewerRow) findLastVisibleItem(nextTopItem).getData(ViewerRow.ROWPART_KEY);
		181	}
		182	} else {
		183	TreeItem[] neighbours = item.getParentItem().getItems();
		184	TreeItem itemBefore = null;
		185	for( int i = 0; i < neighbours.length; i++ ) {
		186	if( neighbours[i] != item ) {
		187	itemBefore = neighbours[i];
		188	} else {
		189	break;
		190	}
		191	}
		192
		193	// This means that this was the first child
		194	if( itemBefore == null ) {
		195	itemBefore = item.getParentItem();
		196	} else {
		197	itemBefore = findLowestLeave(itemBefore);
		198	}
		199
		200	if( itemBefore != null ) {
		201	return (ViewerRow) itemBefore.getData(ViewerRow.ROWPART_KEY);
		202	}
		203	}
		204
		205	return null;
		206	}
		207
		208	private TreeItem findLowestLeave(TreeItem item) {
		209	TreeItem rv = item;
		210
		211	if( rv.getExpanded() && rv.getItemCount() > 0 ) {
212	rv = findLowestLeave(rv.getItem(rv.getItemCount()-1));
213	}
214
215	return rv;
216	}
217
218	private TreeItem findNextItem(TreeItem item) {
219	TreeItem rv = null;
220	TreeItem parent = item.getParentItem();
221	TreeItem[] neighbours;
222
223	if( parent == null ) {
224	neighbours = item.getParent().getItems();
225	} else {
226	neighbours = parent.getItems();
227	}
228
229	int i = 0;
230	for( i = 0; i < neighbours.length; i++ ) {
231	if( neighbours[i] == item ) {
232	break;
233	}
234	}
235
236	// This is once more the last item in the tree
237	// Search on
238	if( i == neighbours.length - 1 ) {
239	if( item.getParentItem() != null ) {
240	rv = findNextItem(item.getParentItem());
241	}
242	} else {
243	rv = neighbours[i+1];
244	}
245
246	return rv;
247	}
248
249	/* (non-Javadoc)
250	* @see org.eclipse.jface.viewers.ViewerRow#getRowBelow(boolean)
251	*/
252	public ViewerRow getRowBelow(boolean sameLevel) {
253	Tree tree = item.getParent();
254
255	// This means we have top-level item
256	if( item.getParentItem() == null ) {
257	if( sameLevel \|\| ! item.getExpanded() ) {
258	int index = tree.indexOf(item) + 1;
259
260	if( index < tree.getItemCount() ) {
261	return (ViewerRow)tree.getItem(index).getData(ViewerRow.ROWPART_KEY);
262	}
263	} else if( item.getExpanded() && item.getItemCount() > 0 ) {
264	return (ViewerRow)item.getItem(0).getData(ViewerRow.ROWPART_KEY);
265	}
266	} else {
267	if( sameLevel \|\| ! item.getExpanded() ) {
268	TreeItem[] neighbours = item.getParentItem().getItems();
269	TreeItem itemAfter = null;
270	int i = 0;
271	for( i = 0; i < neighbours.length; i++ ) {
272	if( neighbours[i] == item ) {
273	break;
274	}
275	}
276
277	// This would mean that it was the last item
278	if( i == neighbours.length - 1 ) {
279	itemAfter = findNextItem( item.getParentItem() );
280	} else {
281	itemAfter = neighbours[i+1];
282	}
283
284	if( itemAfter != null ) {
285	return (ViewerRow) itemAfter.getData(ViewerRow.ROWPART_KEY);
286	}
287
288	} else if( item.getExpanded() && item.getItemCount() > 0 ) {
289	return (ViewerRow)item.getItem(0).getData(ViewerRow.ROWPART_KEY);
290	}
291	}
292
293	return null;
294	}
147	}	295	}

Lines 190-201 Link Here

(-)src/org/eclipse/jface/viewers/ViewerRow.java (-3 / +20 lines)
190	*/	190	*/
191	public int getColumnIndex(Point point) {	191	public int getColumnIndex(Point point) {
192	int count = getColumnCount();	192	int count = getColumnCount();
193		193
194	// If there are no columns the column-index is 0	194	// If there are no columns the column-index is 0
195	if( count == 0 ) {	195	if (count == 0) {
196	return 0;	196	return 0;
197	}	197	}
198		198
199	for (int i = 0; i < count; i++) {	199	for (int i = 0; i < count; i++) {
200	if (getBounds(i).contains(point)) {	200	if (getBounds(i).contains(point)) {
201	return i;	201	return i;
Lines 226-229 Link Here
226	*/	226	*/
227	public abstract Control getControl();	227	public abstract Control getControl();
228		228
		229	/**
		230	* Find the row above this row
		231	*
		232	* @param sameLevel
		233	* search at the samelevel
		234	* @return the row above or <code>null</code>
		235	*/
		236	public abstract ViewerRow getRowAbove(boolean sameLevel);
		237
		238	/**
		239	* Find the row below this row
		240	*
		241	* @param sameLevel
		242	* search at the samelevel
		243	* @return the row below or <code>null</code>
		244	*/
		245	public abstract ViewerRow getRowBelow(boolean sameLevel);
229	}	246	}

Lines 177-180 Link Here

(-)src/org/eclipse/jface/viewers/ViewerCell.java (+58 lines)
177	public Control getControl() {	177	public Control getControl() {
178	return row.getControl();	178	return row.getControl();
179	}	179	}
		180
		181	/**
		182	* @param sameLevel
		183	* should the cell be at the same hirarchie level than this cell
		184	* @return the {@link ViewerCell} or <code>null</code> if no cell above
		185	* can be found
		186	*/
		187	public ViewerCell getCellAbove(boolean sameLevel) {
		188	ViewerRow rowAbove = row.getRowAbove(sameLevel);
		189
		190	if (rowAbove != null) {
		191	return rowAbove.getCell(getColumnIndex());
		192	}
		193
		194	return null;
		195	}
		196
		197	/**
		198	* @param sameLevel
		199	* should the cell be at the same hirarchie level than this cell
		200	* @return the {@link ViewerCell} or <code>null</code> if no cell below
		201	* can be found
		202	*/
		203	public ViewerCell getCellBelow(boolean sameLevel) {
		204	ViewerRow rowBelow = row.getRowBelow(sameLevel);
		205	if (rowBelow != null) {
		206	rowBelow.getCell(getColumnIndex());
		207	}
		208	return null;
		209	}
		210
		211	/**
		212	* @return the {@link ViewerCell} to the left of this cell or
		213	* <code>null</code> if no cell below can be found
		214	*/
		215	public ViewerCell getCellLeft() {
		216	int index = getColumnIndex() - 1;
		217
		218	if (index >= 0) {
		219	return row.getCell(index);
		220	}
		221
		222	return null;
		223	}
		224
		225	/**
		226	* @return the {@link ViewerCell} to the right of this cell or
		227	* <code>null</code> if no cell below can be found
		228	*/
		229	public ViewerCell getCellRight() {
		230	int index = getColumnIndex() + 1;
		231
		232	if (index < row.getColumnCount()) {
		233	return row.getCell(index);
		234	}
		235
		236	return null;
		237	}
180	}	238	}

Added Link Here

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