Attachment 43411 Details for Bug 144260 – CellEditor support

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

[patch] CellEditor support

patch.txt (text/plain), 43.13 KB, created by Brad Reynolds

on 2006-06-03 01:16:38 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Brad Reynolds

Created: 2006-06-03 01:16:38 EDT

Size: 43.13 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jface.tests.databinding
>Index: src/org/eclipse/jface/tests/databinding/scenarios/TableScenarios.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/databinding/scenarios/TableScenarios.java,v
>retrieving revision 1.29
>diff -u -r1.29 TableScenarios.java
>--- src/org/eclipse/jface/tests/databinding/scenarios/TableScenarios.java	23 Mar 2006 17:09:06 -0000	1.29
>+++ src/org/eclipse/jface/tests/databinding/scenarios/TableScenarios.java	3 Jun 2006 05:12:03 -0000
>@@ -16,12 +16,17 @@
> import org.eclipse.jface.examples.databinding.model.SampleData;
> import org.eclipse.jface.internal.databinding.provisional.description.Property;
> import org.eclipse.jface.internal.databinding.provisional.description.TableModelDescription;
>+import org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerEditorManager;
> import org.eclipse.jface.viewers.ITableLabelProvider;
>+import org.eclipse.jface.viewers.StructuredSelection;
> import org.eclipse.jface.viewers.TableViewer;
>+import org.eclipse.jface.viewers.TextCellEditor;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.graphics.Image;
> import org.eclipse.swt.layout.FillLayout;
>+import org.eclipse.swt.widgets.Event;
> import org.eclipse.swt.widgets.TableColumn;
>+import org.eclipse.swt.widgets.Text;
> 
> /**
>  * To run the tests in this class, right-click and select "Run As JUnit Plug-in
>@@ -112,6 +117,78 @@
> 		}
> 	}
> 
>+	public void testEditColumnWithTextCellEditor() throws Exception {
>+		TableModelDescription description = new TableModelDescription(
>+				new Property(catalog, "accounts", Account.class, Boolean.TRUE),
>+				new String[] { "firstName", "lastName" });
>+
>+		getDbc().bind(tableViewer, description, null);
>+
>+		TableViewerEditorManager manager = new TableViewerEditorManager(
>+				tableViewer, description, getDbc());
>+		TextCellEditor editor = new TextCellEditor();
>+		manager.bind(editor, "firstName", String.class, null);
>+
>+		Account account = catalog.getAccounts()[0];
>+		String originalValue = account.getFirstName();
>+
>+		tableViewer.editElement(account, 0);
>+		assertEquals(account,
>+				((StructuredSelection) tableViewer.getSelection())
>+						.getFirstElement());
>+
>+		String newValue = editor.getValue().toString() + ","
>+				+ editor.getValue().toString();
>+		editor.setValue(newValue);
>+
>+		// Value shouldn't yet change
>+		assertEquals(originalValue, account.getFirstName());
>+
>+		getShell().open();
>+
>+		// Apply value
>+		Text text = (Text) editor.getControl();
>+		Event event = new Event();
>+		event.detail = SWT.TRAVERSE_RETURN;
>+		text.notifyListeners(SWT.Traverse, event);
>+		tableViewer.getTable().setFocus();
>+
>+		assertEquals(newValue, account.getFirstName());
>+	}
>+
>+	public void testCancelEditOfTextCellEditor() throws Exception {
>+		TableModelDescription description = new TableModelDescription(
>+				new Property(catalog, "accounts", Account.class, Boolean.TRUE),
>+				new String[] { "firstName", "lastName" });
>+
>+		getDbc().bind(tableViewer, description, null);
>+
>+		TableViewerEditorManager manager = new TableViewerEditorManager(
>+				tableViewer, description, getDbc());
>+		TextCellEditor editor = new TextCellEditor();
>+		manager.bind(editor, "firstName", String.class, null);
>+
>+		Account account = catalog.getAccounts()[0];
>+		String originalValue = account.getFirstName();
>+
>+		tableViewer.editElement(account, 0);
>+		assertEquals(account,
>+				((StructuredSelection) tableViewer.getSelection())
>+						.getFirstElement());
>+
>+		String newValue = editor.getValue().toString() + ","
>+				+ editor.getValue().toString();
>+		editor.setValue(newValue);
>+
>+		// Value shouldn't yet change
>+		assertEquals(originalValue, account.getFirstName());
>+
>+		// Aborts the edit
>+		tableViewer.getTable().setFocus();
>+
>+		assertEquals(originalValue, account.getFirstName());
>+	}
>+
> 	public void testScenario02() throws SecurityException, IllegalArgumentException {
> 		// Show that a TableViewer with three columns can be used to update
> 		// columns
>@@ -135,7 +212,7 @@
> //		// Check whether the model has changed
> //		assertEquals("Bill",account.getFirstName());
> 	}
>-	
>+
> 	public void testScenario04() {
> //		// Show that when an item is added to a collection the table gets an extra item
> //		Account[] accounts = catalog.getAccounts();	
>@@ -212,7 +289,7 @@
> //		assertEquals(tableViewer.getTable().getItemCount(),numberOfAccounts);
> //		
> 	}
>-		
>+
> 	public void testScenario03() {
> //		// Show that converters work for table columns
> //		Account[] accounts = catalog.getAccounts();
>@@ -247,7 +324,7 @@
> //					.convertModelToTarget(account.getState())), col_state);
> //		}
> 	}
>-	
>+
> 	public void testScenario05() {
> //		// Show that when the model changes then the UI refreshes to reflect this
> //
>@@ -281,7 +358,7 @@
> //		assertEquals(lastName,account.getLastName());
> //		
> 	}
>-	
>+
> 	public void testScenario06(){
> //		// Check that explicit type means that defaulting of converters works
> //		TableViewerDescription tableViewerDescription = new TableViewerDescription(
>@@ -301,7 +378,7 @@
> //		assertEquals(transporation.getPrice(),123.45,0);
> 		
> 	}
>-	
>+
> 	public void testScenario07(){
> //		// Verify that even when a column's property type is not set, that it is worked out lazily from the target type 
> //		TableViewerDescription tableViewerDescription = new TableViewerDescription(
>@@ -322,7 +399,7 @@
> //		assertEquals(transporation.getPrice(),123.45,0);
> //		
> 	}
>-	
>+
> 	public void testScenario08_00(){
> //		// Verify that binding to a Collection property (rather than an array) works when specifying data type
> //		TableViewerDescription tableViewerDescription = new TableViewerDescription(
>@@ -347,7 +424,7 @@
> //		assertEquals("Cricket11Players",firstSignon.getPassword());
> //		
> 	}
>-	
>+
> 	public void testScenario08_01(){
> //		// Verify that binding to a Collection property (rather than an array) works without specifying data type
> //		TableViewerDescription tableViewerDescription = new TableViewerDescription(
>@@ -372,7 +449,7 @@
> //		assertEquals("Cricket11Players",firstSignon.getPassword());
> //		
> 	}
>-	
>+
> 	public void testScenario09(){
> //		// Verify that nested properties work.  Catalog has adventures.  Adventure has defaultLodging.  Loding has name.
> //		TableViewerDescription tableViewerDescription = new TableViewerDescription(tableViewer);
>@@ -381,32 +458,29 @@
> //		getDbc().bind(tableViewerDescription,new Property(category, "adventures"),null);
> //		
> 	}
>-/**	
>-	public void testScenario10(){
>-		// Verify that for TIME_EARLY updating occurs on a per key basic for a TextCellEditor
>-		// Show that converters work for table columns
>-		Account[] accounts = catalog.getAccounts();
>-		Account firstAccount = accounts[0];
>-		SampleData.getSWTObservableFactory().setUpdateTime(DataBindingContext.TIME_EARLY);
>-		TableViewerDescription tableViewerDescription = new TableViewerDescription(tableViewer);
>-		tableViewerDescription.addEditableColumn("lastName");
>-		tableViewerDescription.addColumn("lastName");
>-		getDbc().bind(tableViewerDescription,new Property(catalog, "accounts"), null);
>-		
>-		// Verify that the first account is shown in the first row with the last name correctly
>-		assertEquals(tableViewer.getTable().getItem(0).getData(),firstAccount);
>-		assertEquals(tableViewer.getTable().getItem(0).getText(0),firstAccount.getLastName());
>-		assertEquals(tableViewer.getTable().getItem(0).getText(1),firstAccount.getLastName());
>-		// Create a cell editor over the first column
>-		tableViewer.editElement(firstAccount, 0);
>-		// Set the text property of the cell editor which is now active over the "firstName" column
>-		CellEditor[] cellEditors = tableViewer.getCellEditors();
>-		TextCellEditor lastNameCellEditor = (TextCellEditor) cellEditors[0];
>-		((Text)lastNameCellEditor.getControl()).setText("E");
>-		// Verify that the key press goes to the model
>-		assertEquals(firstAccount.getLastName(),"E");
>-		
>-	}
>- **/	
>-}
> 
>+	/**
>+	 * public void testScenario10(){ // Verify that for TIME_EARLY updating
>+	 * occurs on a per key basic for a TextCellEditor // Show that converters
>+	 * work for table columns Account[] accounts = catalog.getAccounts();
>+	 * Account firstAccount = accounts[0];
>+	 * SampleData.getSWTObservableFactory().setUpdateTime(DataBindingContext.TIME_EARLY);
>+	 * TableViewerDescription tableViewerDescription = new
>+	 * TableViewerDescription(tableViewer);
>+	 * tableViewerDescription.addEditableColumn("lastName");
>+	 * tableViewerDescription.addColumn("lastName");
>+	 * getDbc().bind(tableViewerDescription,new Property(catalog, "accounts"),
>+	 * null); // Verify that the first account is shown in the first row with
>+	 * the last name correctly
>+	 * assertEquals(tableViewer.getTable().getItem(0).getData(),firstAccount);
>+	 * assertEquals(tableViewer.getTable().getItem(0).getText(0),firstAccount.getLastName());
>+	 * assertEquals(tableViewer.getTable().getItem(0).getText(1),firstAccount.getLastName()); //
>+	 * Create a cell editor over the first column
>+	 * tableViewer.editElement(firstAccount, 0); // Set the text property of the
>+	 * cell editor which is now active over the "firstName" column CellEditor[]
>+	 * cellEditors = tableViewer.getCellEditors(); TextCellEditor
>+	 * lastNameCellEditor = (TextCellEditor) cellEditors[0];
>+	 * ((Text)lastNameCellEditor.getControl()).setText("E"); // Verify that the
>+	 * key press goes to the model assertEquals(firstAccount.getLastName(),"E"); }
>+	 */
>+}
>Index: src/org/eclipse/jface/tests/internal/databinding/viewers/ViewersObservableFactoryTests.java
>===================================================================
>RCS file: src/org/eclipse/jface/tests/internal/databinding/viewers/ViewersObservableFactoryTests.java
>diff -N src/org/eclipse/jface/tests/internal/databinding/viewers/ViewersObservableFactoryTests.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/tests/internal/databinding/viewers/ViewersObservableFactoryTests.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,54 @@
>+package org.eclipse.jface.tests.internal.databinding.viewers;
>+
>+import junit.framework.TestCase;
>+
>+import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;
>+import org.eclipse.jface.internal.databinding.provisional.observable.IObservable;
>+import org.eclipse.jface.internal.databinding.provisional.viewers.ViewersObservableFactory;
>+import org.eclipse.jface.viewers.TableViewer;
>+import org.eclipse.jface.viewers.TextCellEditor;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.widgets.Shell;
>+
>+/**
>+ * @since 3.2
>+ *
>+ */
>+public class ViewersObservableFactoryTests extends TestCase {
>+	private ViewersObservableFactory factory;
>+	private TableViewer viewer;
>+	
>+	/* (non-Javadoc)
>+	 * @see junit.framework.TestCase#setUp()
>+	 */
>+	protected void setUp() throws Exception {
>+		super.setUp();
>+		
>+		factory = new ViewersObservableFactory();
>+		
>+		Shell shell = new Shell();
>+		viewer = new TableViewer(shell, SWT.NONE);
>+	}
>+	
>+	public void testCreateTextCellEditorObservable() throws Exception {
>+		TextCellEditor editor = new TextCellEditor(viewer.getTable());
>+		IObservable observable = factory.createObservable(editor);
>+		assertNotNull(observable);
>+		assertTrue(observable instanceof TextObservableValue);
>+	}
>+	
>+	/**
>+	 * TextCellEditor must have been constructed with a parent.
>+	 * 
>+	 * @throws Exception
>+	 */
>+	public void testCreateTextCellEditorObservableWithoutViewerException() throws Exception {
>+		try {
>+			TextCellEditor editor = new TextCellEditor();
>+			factory.createObservable(editor);
>+			fail("Exception should have been thrown.");
>+		} catch (IllegalArgumentException e) {
>+			assertTrue(true);
>+		}
>+	}
>+}
>Index: src/org/eclipse/jface/tests/internal/databinding/viewers/TableViewerEditorManagerTests.java
>===================================================================
>RCS file: src/org/eclipse/jface/tests/internal/databinding/viewers/TableViewerEditorManagerTests.java
>diff -N src/org/eclipse/jface/tests/internal/databinding/viewers/TableViewerEditorManagerTests.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/tests/internal/databinding/viewers/TableViewerEditorManagerTests.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,152 @@
>+package org.eclipse.jface.tests.internal.databinding.viewers;
>+
>+import junit.framework.TestCase;
>+
>+import org.eclipse.jface.examples.databinding.model.SampleData;
>+import org.eclipse.jface.internal.databinding.internal.ValueBinding;
>+import org.eclipse.jface.internal.databinding.provisional.Binding;
>+import org.eclipse.jface.internal.databinding.provisional.DataBindingContext;
>+import org.eclipse.jface.internal.databinding.provisional.description.Property;
>+import org.eclipse.jface.internal.databinding.provisional.description.TableModelDescription;
>+import org.eclipse.jface.internal.databinding.provisional.observable.IObservable;
>+import org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerEditorManager;
>+import org.eclipse.jface.viewers.CellEditor;
>+import org.eclipse.jface.viewers.TableViewer;
>+import org.eclipse.jface.viewers.TextCellEditor;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.widgets.Shell;
>+
>+/**
>+ * @since 3.2
>+ */
>+public class TableViewerEditorManagerTests extends TestCase {
>+	private TableViewer viewer;
>+
>+	private DataBindingContext context;
>+
>+	private TableModelDescription description;
>+	private TableViewerEditorManager manager;
>+
>+	protected void setUp() throws Exception {
>+		Shell shell = new Shell();
>+
>+		viewer = new TableViewer(shell, SWT.NONE);
>+		context = SampleData.getDatabindingContext(shell);
>+		description = new TableModelDescription(new Property(null, null),
>+				new String[] { "firstName", "middleName", "lastName" });
>+		manager = new TableViewerEditorManager(viewer, description, context);
>+	}
>+
>+	public void testConstruction() throws Exception {
>+		assertEquals(viewer, manager.getTableViewer());
>+		assertEquals(description, manager.getTableModelDescription());
>+		assertEquals(context, manager.getDataBindingContext());
>+	}
>+
>+	public void testConstructionExceptions() throws Exception {
>+		try {
>+			manager = new TableViewerEditorManager(null, description, context);
>+			fail("Exception should have been thrown.");
>+		} catch (NullPointerException e) {
>+			assertTrue(true);
>+		}
>+
>+		try {
>+			manager = new TableViewerEditorManager(viewer, null, context);
>+			fail("Exception should have been thrown.");
>+		} catch (NullPointerException e) {
>+			assertTrue(true);
>+		}
>+
>+		try {
>+			manager = new TableViewerEditorManager(viewer, description, null);
>+			fail("Exception should have been thrown.");
>+		} catch (NullPointerException e) {
>+			assertTrue(true);
>+		}
>+	}
>+
>+	public void testCellModifierCreation() throws Exception {
>+		assertNotNull(viewer.getCellModifier());
>+	}
>+
>+	public void testCellEditorArrayCreation() throws Exception {
>+		CellEditor[] editors = viewer.getCellEditors();
>+		assertNotNull(editors);
>+		assertEquals(description.getColumnIDs().length, editors.length);
>+	}
>+
>+	public void testSetColumnProperties() throws Exception {
>+		Object[] properties = viewer.getColumnProperties();
>+		Object[] columnIDs = description.getColumnIDs();
>+		assertNotNull(properties);
>+		assertEquals(columnIDs.length, properties.length);
>+
>+		for (int i = 0; i < properties.length; i++) {
>+			assertEquals(columnIDs[i], properties[i]);
>+		}
>+	}
>+
>+	public void testBindEditor() throws Exception {
>+		Binding binding = manager.bind(new TextCellEditor(), "firstName", String.class,
>+				null);
>+		assertNotNull(binding);
>+		assertTrue(binding instanceof ValueBinding);
>+	}
>+	
>+	public void testSetEditorOnViewer() throws Exception {
>+		CellEditor editor = new TextCellEditor();
>+		manager.bind(editor, "firstName", String.class, null);
>+		assertEquals(editor, viewer.getCellEditors()[0]);
>+	}
>+
>+	public void testBindEditorNullPointerExceptions() throws Exception {
>+		try {
>+			manager.bind(null, "firstName", String.class, null);
>+			fail("Exception should have been thrown.");
>+		} catch (NullPointerException e) {
>+			assertTrue(true);
>+		}
>+		
>+		try {
>+			manager.bind(new TextCellEditor(viewer.getTable()), null, String.class, null);
>+			fail("Exception should have been thrown.");
>+		} catch (NullPointerException e) {
>+			assertTrue(true);
>+		}
>+		
>+		try {
>+			manager.bind(new TextCellEditor(viewer.getTable()), "firstName", null, null);
>+			fail("Exception should have been thrown.");
>+		} catch (NullPointerException e) {
>+			assertTrue(true);
>+		}
>+	}
>+	
>+	public void testCreateControlIfNullWhenBound() throws Exception {
>+		TextCellEditor editor = new TextCellEditor();
>+		assertNull(editor.getControl());
>+		manager.bind(editor, "firstName", String.class, null);
>+		assertNotNull(editor.getControl());
>+	}
>+	
>+	public void testIAEIfColumnIDNotFound() throws Exception {
>+		try {
>+			manager.bind(new TextCellEditor(viewer.getTable()), "invalid column ID", String.class, null);
>+			fail("Exception should have been thrown.");
>+		} catch (IllegalArgumentException e) {
>+			assertTrue(true);
>+		}
>+	}
>+	
>+	public void testReuseSelectionAcrossBindings() throws Exception {
>+		manager.bind(new TextCellEditor(),	"firstName", String.class, null);
>+		IObservable selection1 = manager.getSelectionObservable();
>+		assertNotNull(selection1);
>+		
>+		manager.bind(new TextCellEditor(), "lastName", String.class, null);
>+		IObservable selection2 = manager.getSelectionObservable();
>+		assertNotNull(selection2);
>+		assertSame(selection1, selection2);
>+	}
>+}
>Index: src/org/eclipse/jface/tests/databinding/swt/TextObservableValueTests.java
>===================================================================
>RCS file: src/org/eclipse/jface/tests/databinding/swt/TextObservableValueTests.java
>diff -N src/org/eclipse/jface/tests/databinding/swt/TextObservableValueTests.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/tests/databinding/swt/TextObservableValueTests.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,132 @@
>+package org.eclipse.jface.tests.databinding.swt;
>+
>+import junit.framework.TestCase;
>+
>+import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;
>+import org.eclipse.jface.internal.databinding.provisional.observable.value.IObservableValue;
>+import org.eclipse.jface.internal.databinding.provisional.observable.value.IValueChangeListener;
>+import org.eclipse.jface.internal.databinding.provisional.observable.value.ValueDiff;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.widgets.Event;
>+import org.eclipse.swt.widgets.Shell;
>+import org.eclipse.swt.widgets.Text;
>+
>+/**
>+ * Tests for TextObservableValue.
>+ * 
>+ * @since 3.2
>+ */
>+public class TextObservableValueTests extends TestCase {
>+	private Shell shell;
>+
>+	private Text text;
>+
>+	protected void setUp() throws Exception {
>+		super.setUp();
>+
>+		shell = new Shell();
>+		text = new Text(shell, SWT.NONE);
>+	}
>+
>+	/**
>+	 * Asserts that if the a <code>null</code> Text is passed TextObservableValue throws a NPE.
>+	 */
>+	public void testConstructor() {
>+		try {
>+			new TextObservableValue(null, SWT.NONE);
>+			fail();
>+		} catch (NullPointerException e) {
>+			assertTrue(true);
>+		}
>+	}
>+	
>+	/**
>+	 * Asserts that only valid SWT event types are accepted on construction of TextObservableValue.
>+	 */
>+	public void testConstructorUpdateEventTypes() {
>+		try {
>+			new TextObservableValue(text, SWT.NONE);
>+			new TextObservableValue(text, SWT.FocusOut);
>+			new TextObservableValue(text, SWT.Modify);
>+			assertTrue(true);
>+		} catch (IllegalArgumentException e) {
>+			fail();
>+		}
>+		
>+		try {
>+			new TextObservableValue(text, SWT.Verify);
>+			fail();
>+		} catch (IllegalArgumentException e) {
>+			assertTrue(true);
>+		}
>+	}
>+	
>+	public void testFireValueChangeEventsOnFocusOut() {
>+		TextObservableValue observable = new TextObservableValue(text,
>+				SWT.FocusOut);
>+		ValueChangeCounter counter = new ValueChangeCounter();
>+		observable.addValueChangeListener(counter);
>+
>+		text.setText("value");
>+		assertEquals(0, counter.count);
>+		text.notifyListeners(SWT.FocusOut, null);
>+		assertEquals(1, counter.count);
>+	}
>+
>+	public void testFireValueChangeEventsOnModify() {
>+		TextObservableValue observable = new TextObservableValue(text,
>+				SWT.Modify);
>+		ValueChangeCounter counter = new ValueChangeCounter();
>+		observable.addValueChangeListener(counter);
>+
>+		text.setText("value");
>+		assertEquals(1, counter.count);
>+	}
>+
>+	public void testSuppressFireValueChangeEvents() {
>+		TextObservableValue observable = new TextObservableValue(text, SWT.NONE);
>+		ValueChangeCounter counter = new ValueChangeCounter();
>+		observable.addValueChangeListener(counter);
>+
>+		text.setText("value");
>+		assertEquals(0, counter.count);
>+		text.notifyListeners(SWT.Modify, null);
>+		assertEquals(0, counter.count);
>+		text.notifyListeners(SWT.FocusOut, null);
>+		assertEquals(0, counter.count);
>+	}
>+
>+	public void testFireChangeEventsOnTraversal() {
>+		TextObservableValue observable = TextObservableValue.asTraversalObservable(text, SWT.TRAVERSE_RETURN | SWT.TRAVERSE_TAB_NEXT);
>+		
>+		ValueChangeCounter counter = new ValueChangeCounter();
>+		observable.addValueChangeListener(counter);
>+		
>+		text.setText("value");
>+		assertEquals(0, counter.count);
>+		text.notifyListeners(SWT.Modify, null);
>+		assertEquals(0, counter.count);
>+		text.notifyListeners(SWT.FocusOut, null);
>+		assertEquals(0, counter.count);
>+		
>+		Event event = new Event();
>+		event.detail = SWT.TRAVERSE_RETURN;
>+		
>+		text.notifyListeners(SWT.Traverse, event);
>+		assertEquals(1, counter.count);
>+		
>+		event = new Event();
>+		event.detail = SWT.TRAVERSE_TAB_NEXT;
>+		
>+		text.notifyListeners(SWT.Traverse, event);
>+		assertEquals(2, counter.count);
>+	}
>+
>+	private class ValueChangeCounter implements IValueChangeListener {
>+		private int count;
>+
>+		public void handleValueChange(IObservableValue source, ValueDiff diff) {
>+			count++;
>+		}
>+	}
>+}
>#P org.eclipse.jface.databinding
>Index: src/org/eclipse/jface/internal/databinding/internal/swt/TextObservableValue.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/internal/swt/TextObservableValue.java,v
>retrieving revision 1.2.4.4
>diff -u -r1.2.4.4 TextObservableValue.java
>--- src/org/eclipse/jface/internal/databinding/internal/swt/TextObservableValue.java	14 May 2006 19:10:40 -0000	1.2.4.4
>+++ src/org/eclipse/jface/internal/databinding/internal/swt/TextObservableValue.java	3 Jun 2006 05:12:05 -0000
>@@ -11,10 +11,13 @@
> package org.eclipse.jface.internal.databinding.internal.swt;
> 
> import org.eclipse.jface.internal.databinding.provisional.observable.Diffs;
>+import org.eclipse.jface.internal.databinding.provisional.observable.IObservable;
> import org.eclipse.jface.internal.databinding.provisional.observable.value.AbstractVetoableValue;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.events.KeyEvent;
> import org.eclipse.swt.events.KeyListener;
>+import org.eclipse.swt.events.TraverseEvent;
>+import org.eclipse.swt.events.TraverseListener;
> import org.eclipse.swt.events.VerifyEvent;
> import org.eclipse.swt.events.VerifyListener;
> import org.eclipse.swt.widgets.Event;
>@@ -22,62 +25,191 @@
> import org.eclipse.swt.widgets.Text;
> 
> /**
>- * @since 1.0
>+ * {@link IObservable} implementation that manages the binding of a model
>+ * property to a {@link Text} widget. The time at which communication of the
>+ * value change event is specified by the consumer on construction.
>+ * 
>+ * <dl>
>+ * <dt>Events:</dt>
>+ * <dd> If the update event type (specified on construction) is
>+ * <code>SWT.Modify</code> a value change event will be fired on every key
>+ * stroke. If the update event type is <code>SWT.FocusOut</code> a value
>+ * change event will be fired on focus out. When in either mode if the user is
>+ * entering text and presses [Escape] the value will be reverted back to the
>+ * previous, unedited, model value. Regardless of the update event type a value
>+ * changing event will fire on verify.</dd>
>+ * </dl>
>+ * 
>+ * <p>
>+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
>+ * part of a work in progress. There is no guarantee that this API will remain
>+ * unchanged during the 3.2 release cycle. Please do not use this API without
>+ * consulting with the Platform/UI team.
>+ * </p>
>  * 
>+ * @since 1.0
>  */
> public class TextObservableValue extends AbstractVetoableValue {
>-
>+	/**
>+	 * {@link Text} widget that this is being observed.
>+	 */
> 	private final Text text;
> 
>+	/**
>+	 * Flag to track when the model is updating the widget. When
>+	 * <code>true</code> the handlers for the SWT events should not process
>+	 * the event as this would cause an infinite loop.
>+	 */
> 	private boolean updating = false;
> 
>-	private int updatePolicy;
>+	/**
>+	 * SWT event that on firing this observable will fire change events in an
>+	 * attempt to update the model.
>+	 */
>+	private final int updateEventType;
>+
>+	/**
>+	 * Valid types for the {@link #updateEventType}.
>+	 */
>+	private static final int[] validUpdateEventTypes = new int[] { SWT.Modify,
>+			SWT.FocusOut, SWT.NONE };
> 
>+	/**
>+	 * Previous value from the model. It is maintained so that when entering
>+	 * text if the consumer were to press [Escape] the value can be reverted
>+	 * back to the last known model value.
>+	 */
> 	private String bufferedValue;
> 
>-	private Listener updateListener = new Listener() {
>-		public void handleEvent(Event event) {
>-			if (!updating) {
>-				String oldValue = bufferedValue;
>-				String newValue = text.getText();
>-
>-				// If we are updating on focus lost then when we fire the change
>-				// event change the buffered value
>-				if (updatePolicy == SWT.FocusOut) {
>-					bufferedValue = text.getText();
>+	private Listener updateListener;
>+
>+	private VerifyListener verifyListener;
>+
>+	private KeyListener keyListener;
>+
>+	private TraverseListener traverseListener;
>+
>+	/**
>+	 * Private constructor for constructing a new instance.
>+	 * 
>+	 * @param text
>+	 * @param updateEventType
>+	 *            -1 if not specified
>+	 * @param traversalDetail
>+	 *            -1 if not specified
>+	 * @throws IllegalArgumentException if both <code>updateEventType</code> and <code>traverseEventType</code> == -1.
>+	 * @throws IllegalArgumentException if <code>updateEventType</code> is unsupported
>+	 */
>+	private TextObservableValue(final Text text, final int updateEventType,
>+			final int traversalDetail) {
>+		if (text == null) {
>+			throw new NullPointerException("Parameter " + text + " was null."); //$NON-NLS-1$ //$NON-NLS-2$
>+		}
>+
>+		if (updateEventType == -1 && traversalDetail == -1) {
>+			throw new IllegalArgumentException(
>+					"Update event type or traversal event must be set."); //$NON-NLS-1$
>+		}
>+		
>+		if (updateEventType > -1) {
>+			boolean eventValid = false;
>+			for (int i = 0; !eventValid && i < validUpdateEventTypes.length; i++) {
>+				eventValid = (updateEventType == validUpdateEventTypes[i]);
>+			}
>+			if (!eventValid) {
>+				throw new IllegalArgumentException(
>+						"UpdateEventType [" + updateEventType + "] is unsupported."); //$NON-NLS-1$//$NON-NLS-2$
>+			}
>+			
>+			setupLifecycleHandling(text, updateEventType);
>+		}
>+
>+		if (traversalDetail > -1) {
>+			setupTraverseHandling(text, traversalDetail);
>+		}
>+
>+		this.text = text;
>+		this.updateEventType = updateEventType;
>+
>+		keyListener = new KeyListener() {
>+			public void keyPressed(KeyEvent e) {
>+				if (e.character == SWT.ESC && bufferedValue != null) {
>+					// Revert the value in the text field to the model value
>+					text.setText(bufferedValue);
>+				}
>+			}
>+
>+			public void keyReleased(KeyEvent e) {
>+			}
>+		};
>+		text.addKeyListener(keyListener);
>+	}
>+
>+	/**
>+	 * Performs setup for firing value change events on traversal.
>+	 * 
>+	 * @param text
>+	 * @param traverseEventTypes
>+	 */
>+	private void setupTraverseHandling(final Text text,
>+			final int traverseEventTypes) {
>+		traverseListener = new TraverseListener() {
>+			public void keyTraversed(TraverseEvent e) {
>+				if ((e.detail & traverseEventTypes) != 0) {
>+					String oldValue = bufferedValue;
>+					String newValue = text.getText();
>+
> 					if (!newValue.equals(oldValue)) {
> 						fireValueChange(Diffs.createValueDiff(oldValue,
> 								newValue));
> 					}
>-				} else {
>-					fireValueChange(Diffs.createValueDiff(oldValue, text
>-							.getText()));
> 				}
> 			}
>-		}
>-	};
>-
>-	private VerifyListener verifyListener;
>-
>-	private KeyListener keyListener;
>+		};
>+		text.addTraverseListener(traverseListener);
>+	}
> 
> 	/**
>+	 * Performs validation and setup for listeners of lifecycle events like
>+	 * modify and focus out.
>+	 * 
> 	 * @param text
>-	 * @param updatePolicy
>+	 * @param event
>+	 * @param updateListener
> 	 */
>-	public TextObservableValue(final Text text, int updatePolicy) {
>-		this.text = text;
>-		this.updatePolicy = updatePolicy;
>-		if (updatePolicy != SWT.None) {
>-			text.addListener(updatePolicy, updateListener);
>+	private void setupLifecycleHandling(final Text text, int event) {
>+		if (event != SWT.None) {
>+			updateListener = new Listener() {
>+				public void handleEvent(Event event) {
>+					if (!updating) {
>+						String oldValue = bufferedValue;
>+						String newValue = text.getText();
>+
>+						// If we are updating on focus lost then when we fire
>+						// the change
>+						// event change the buffered value
>+						if (updateEventType == SWT.FocusOut) {
>+							bufferedValue = text.getText();
>+							if (!newValue.equals(oldValue)) {
>+								fireValueChange(Diffs.createValueDiff(oldValue,
>+										newValue));
>+							}
>+						} else {
>+							fireValueChange(Diffs.createValueDiff(oldValue,
>+									text.getText()));
>+						}
>+					}
>+				}
>+			};
>+			text.addListener(event, updateListener);
> 		}
>-		// If the update policy is TIME_EARLY then the model is notified of
>+		// If the update policy is SWT.Modify then the model is notified of
> 		// changed on key stroke by key stroke
> 		// When escape is pressed we need to rollback to the previous value
> 		// which is done with a key listener, however
> 		// the bufferedValue (the last remembered change value) must be changed
> 		// on focus lost
>-		if (updatePolicy == SWT.Modify) {
>+		if (event == SWT.Modify) {
> 			text.addListener(SWT.FocusOut, new Listener() {
> 				public void handleEvent(Event event) {
> 					if (!updating) {
>@@ -101,20 +233,33 @@
> 			}
> 		};
> 		text.addVerifyListener(verifyListener);
>-		keyListener = new KeyListener() {
>-			public void keyPressed(KeyEvent e) {
>-				if (e.character == SWT.ESC && bufferedValue != null) {
>-					// Revert the value in the text field to the model value
>-					text.setText(bufferedValue);
>-				}
>-			}
>+	}
> 
>-			public void keyReleased(KeyEvent e) {
>-			}
>-		};
>-		text.addKeyListener(keyListener);
>+	/**
>+	 * Constructs a new instance bound to <code>text</code> and configured to
>+	 * fire change events at the time of the <code>updateEventType</code>.
>+	 * 
>+	 * @param text
>+	 * @param updateEventType
>+	 *            SWT event constant as to what SWT event to update the model in
>+	 *            response to. Appropriate values are: <code>SWT.Modify</code>,
>+	 *            <code>SWT.FocusOut</code>, <code>SWT.NONE</code>.
>+	 * @throws IllegalArgumentException
>+	 *             if <code>updateEventType</code> is an incorrect type.
>+	 */
>+	public TextObservableValue(final Text text, final int updateEventType) {
>+		this(text, updateEventType, -1);
> 	}
> 
>+	/**
>+	 * Sets the bound {@link Text Text's} text to the passed <code>value</code>.
>+	 * 
>+	 * @param value
>+	 *            new value, String expected
>+	 * @see org.eclipse.jface.internal.databinding.provisional.observable.value.AbstractVetoableValue#doSetValue(java.lang.Object)
>+	 * @throws ClassCastException
>+	 *             if the value is anything other than a String
>+	 */
> 	public void doSetValue(final Object value) {
> 		try {
> 			updating = true;
>@@ -135,12 +280,35 @@
> 
> 	public void dispose() {
> 		if (!text.isDisposed()) {
>-			text.removeKeyListener(keyListener);
>-			if (updatePolicy != SWT.None) {
>-				text.removeListener(updatePolicy, updateListener);
>+			if (keyListener != null) {
>+				text.removeKeyListener(keyListener);
>+			}
>+			if (updateListener != null) {
>+				text.removeListener(updateEventType, updateListener);
>+			}
>+
>+			if (verifyListener != null) {
>+				text.removeVerifyListener(verifyListener);
>+			}
>+
>+			if (traverseListener != null) {
>+				text.removeTraverseListener(traverseListener);
> 			}
>-			text.removeVerifyListener(verifyListener);
> 		}
> 		super.dispose();
> 	}
>+
>+	/**
>+	 * Constructs a TextObservableValue whose update policy is defined for
>+	 * traversal events rather than lifecycle events like Modify and FocusOut.
>+	 * 
>+	 * @param text
>+	 * @param details
>+	 *            traversal detail values or'd "|" together
>+	 * @return TextObservableValue
>+	 */
>+	public static TextObservableValue asTraversalObservable(Text text,
>+			int details) {
>+		return new TextObservableValue(text, -1, details);
>+	}
> }
>Index: src/org/eclipse/jface/internal/databinding/provisional/viewers/ViewersObservableFactory.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/provisional/viewers/ViewersObservableFactory.java,v
>retrieving revision 1.4
>diff -u -r1.4 ViewersObservableFactory.java
>--- src/org/eclipse/jface/internal/databinding/provisional/viewers/ViewersObservableFactory.java	17 Mar 2006 07:30:01 -0000	1.4
>+++ src/org/eclipse/jface/internal/databinding/provisional/viewers/ViewersObservableFactory.java	3 Jun 2006 05:12:05 -0000
>@@ -10,6 +10,7 @@
>  *******************************************************************************/
> package org.eclipse.jface.internal.databinding.provisional.viewers;
> 
>+import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;
> import org.eclipse.jface.internal.databinding.internal.viewers.AbstractListViewerObservableCollectionWithLabels;
> import org.eclipse.jface.internal.databinding.internal.viewers.StructuredViewerObservableValue;
> import org.eclipse.jface.internal.databinding.internal.viewers.TableViewerObservableCollectionWithLabels;
>@@ -17,8 +18,12 @@
> import org.eclipse.jface.internal.databinding.provisional.factories.IObservableFactory;
> import org.eclipse.jface.internal.databinding.provisional.observable.IObservable;
> import org.eclipse.jface.viewers.AbstractListViewer;
>+import org.eclipse.jface.viewers.CellEditor;
> import org.eclipse.jface.viewers.StructuredViewer;
> import org.eclipse.jface.viewers.TableViewer;
>+import org.eclipse.jface.viewers.TextCellEditor;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.widgets.Text;
> 
> /**
>  * A factory that supports binding to JFace viewers. This factory supports the
>@@ -36,6 +41,7 @@
>  * ViewersProperties.CONTENT</li>
>  * </ul>
>  * </li>
>+ * <li>TextCellEditor</li>
>  * </ul>
>  * TODO complete the list
>  * 
>@@ -85,7 +91,22 @@
> 		} else if (description instanceof TableViewer) {
> 			return new TableViewerObservableCollectionWithLabels(
> 					(TableViewer) description);
>+
>+		} else if (description instanceof CellEditor) {
>+			CellEditor editor = (CellEditor) description;
>+
>+			if (editor.getControl() == null) {
>+				throw new IllegalArgumentException(
>+						"The CellEditor's control has not been constructed. The editor must have a control to bind.  Use the editor contructor that accepts a parent."); //$NON-NLS-1$
>+			}
>+
>+			if (description instanceof TextCellEditor) {
>+				return TextObservableValue.asTraversalObservable(
>+						(Text) editor.getControl(), SWT.TRAVERSE_RETURN
>+								| SWT.TRAVERSE_TAB_NEXT);
>+			}
> 		}
>+
> 		return null;
> 	}
> }
>Index: src/org/eclipse/jface/internal/databinding/provisional/viewers/TableViewerEditorManager.java
>===================================================================
>RCS file: src/org/eclipse/jface/internal/databinding/provisional/viewers/TableViewerEditorManager.java
>diff -N src/org/eclipse/jface/internal/databinding/provisional/viewers/TableViewerEditorManager.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/internal/databinding/provisional/viewers/TableViewerEditorManager.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,254 @@
>+package org.eclipse.jface.internal.databinding.provisional.viewers;
>+
>+import org.eclipse.jface.internal.databinding.provisional.BindSpec;
>+import org.eclipse.jface.internal.databinding.provisional.Binding;
>+import org.eclipse.jface.internal.databinding.provisional.DataBindingContext;
>+import org.eclipse.jface.internal.databinding.provisional.description.Property;
>+import org.eclipse.jface.internal.databinding.provisional.description.TableModelDescription;
>+import org.eclipse.jface.internal.databinding.provisional.observable.IObservable;
>+import org.eclipse.jface.util.Assert;
>+import org.eclipse.jface.viewers.CellEditor;
>+import org.eclipse.jface.viewers.ICellModifier;
>+import org.eclipse.jface.viewers.TableViewer;
>+
>+/**
>+ * Manages the process of binding editors to a <code>TableViewer</code>. When
>+ * using the manager manipulation of the cell modifier, column properties, or
>+ * editors on the viewer is forbidden.
>+ * 
>+ * @since 3.3
>+ */
>+public class TableViewerEditorManager {
>+	/**
>+	 * TableViewer whose editors are being managed.
>+	 */
>+	private final TableViewer tableViewer;
>+
>+	/**
>+	 * Describes the model of the viewer, used to determine columns to edit.
>+	 */
>+	private final TableModelDescription tableModelDescription;
>+
>+	/**
>+	 * Used to create observables for cell editors and to bind editors to the
>+	 * model.
>+	 */
>+	private final DataBindingContext dataBindingContext;
>+
>+	/**
>+	 * IObservable that provides the ability to observe selection of the
>+	 * TableViewer. All editors observe the same instance.
>+	 */
>+	private IObservable selectionObservable;
>+
>+	/**
>+	 * Constructs a new instance.
>+	 * 
>+	 * @param tableViewer
>+	 *            viewer to associate editors with
>+	 * @param tableModelDescription
>+	 *            description of the model to apply to editing
>+	 * @param dataBindingContext
>+	 *            context to use when binding
>+	 */
>+	public TableViewerEditorManager(TableViewer tableViewer,
>+			TableModelDescription tableModelDescription,
>+			DataBindingContext dataBindingContext) {
>+		if (tableViewer == null) {
>+			throw new NullPointerException(
>+					"Parameter " + tableViewer + " was null."); //$NON-NLS-1$ //$NON-NLS-2$
>+		}
>+		if (tableModelDescription == null) {
>+			throw new NullPointerException(
>+					"Parameter " + tableModelDescription + " was null."); //$NON-NLS-1$ //$NON-NLS-2$
>+		}
>+		if (dataBindingContext == null) {
>+			throw new NullPointerException(
>+					"Parameter " + dataBindingContext + " was null."); //$NON-NLS-1$ //$NON-NLS-2$
>+		}
>+
>+		this.tableViewer = tableViewer;
>+		this.tableModelDescription = tableModelDescription;
>+		this.dataBindingContext = dataBindingContext;
>+
>+		tableViewer.setCellModifier(new CellModifier(tableViewer));
>+
>+		Object[] columnIDs = tableModelDescription.getColumnIDs();
>+		int columnCount = (columnIDs != null) ? columnIDs.length : 0;
>+
>+		tableViewer.setCellEditors(new CellEditor[columnCount]);
>+
>+		String[] properties = new String[columnCount];
>+		tableViewer.setColumnProperties(properties);
>+
>+		for (int i = 0; i < columnCount; i++) {
>+			properties[i] = columnIDs[i].toString();
>+		}
>+	}
>+
>+	/**
>+	 * @return Returns the dataBindingContext.
>+	 */
>+	public DataBindingContext getDataBindingContext() {
>+		return dataBindingContext;
>+	}
>+
>+	/**
>+	 * @return Returns the tableModelDescription.
>+	 */
>+	public TableModelDescription getTableModelDescription() {
>+		return tableModelDescription;
>+	}
>+
>+	/**
>+	 * @return Returns the tableViewer.
>+	 */
>+	public TableViewer getTableViewer() {
>+		return tableViewer;
>+	}
>+
>+	/**
>+	 * ICellModifier implementation that mostly ignores it's duty of being the
>+	 * translator between an editor on the value being edited. The binding
>+	 * framework takes place of the ICellModifier but editing can't occur in
>+	 * viewers without an ICellModifier.
>+	 * 
>+	 * @since 3.3
>+	 */
>+	private static class CellModifier implements ICellModifier {
>+		private final TableViewer viewer;
>+
>+		private CellModifier(TableViewer viewer) {
>+			this.viewer = viewer;
>+		}
>+
>+		/**
>+		 * Returns the editor for the property.
>+		 * 
>+		 * @param property
>+		 * @return editor, <code>null</code> if not found
>+		 */
>+		private CellEditor getEditor(String property) {
>+			Assert.isNotNull(property);
>+
>+			CellEditor editor = null;
>+			Object[] properties = viewer.getColumnProperties();
>+			for (int i = 0; i < properties.length; i++) {
>+				if (property.equals(properties[i])) {
>+					editor = viewer.getCellEditors()[i];
>+					break;
>+				}
>+			}
>+			return editor;
>+		}
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.jface.viewers.ICellModifier#canModify(java.lang.Object,
>+		 *      java.lang.String)
>+		 */
>+		public boolean canModify(Object element, String property) {
>+			return getEditor(property) != null;
>+		}
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.jface.viewers.ICellModifier#getValue(java.lang.Object,
>+		 *      java.lang.String)
>+		 */
>+		public Object getValue(Object element, String property) {
>+			/*
>+			 * this is a workaround. if we return null the CellEditor will throw
>+			 * an exception. the binding framework will set the appropriate
>+			 * value after this method is invoked.
>+			 */
>+			CellEditor editor = getEditor(property);
>+
>+			Assert.isTrue(editor != null);
>+
>+			return editor.getValue();
>+		}
>+
>+		/*
>+		 * (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) {
>+			// modifies are handled by the binding framework
>+		}
>+	}
>+
>+	/**
>+	 * Assigns an editor to the viewer.
>+	 * 
>+	 * @param cellEditor
>+	 * @param columnID
>+	 *            value that corresponds to the column specified in the
>+	 *            TableModelDescription
>+	 * @param columnIDType
>+	 *            type of the attribute to bind the editor to
>+	 * @param bindSpec
>+	 *            spec that contains validators, converters, etc. to employ when
>+	 *            updating the observables, can be <code>null</code>.
>+	 * @return binding
>+	 * @throws IllegalArgumentException
>+	 *             if the columnID is not found in the TableModelDescription's
>+	 *             columnIDs.
>+	 */
>+	public Binding bind(CellEditor cellEditor, Object columnID,
>+			Class columnIDType, BindSpec bindSpec) {
>+		if (cellEditor == null) {
>+			throw new NullPointerException(
>+					"Parameter " + cellEditor + " was null."); //$NON-NLS-1$ //$NON-NLS-2$
>+		}
>+		if (columnID == null) {
>+			throw new NullPointerException(
>+					"Parameter " + columnID + " was null."); //$NON-NLS-1$ //$NON-NLS-2$
>+		}
>+		if (columnIDType == null) {
>+			throw new NullPointerException(
>+					"Parameter " + columnIDType + " was null."); //$NON-NLS-1$ //$NON-NLS-2$
>+		}
>+
>+		int columnIndex = -1;
>+		Object[] columnIDs = tableModelDescription.getColumnIDs();
>+		for (int i = 0; columnIndex == -1 && i < columnIDs.length; i++) {
>+			if (columnID.equals(columnIDs[i])) {
>+				columnIndex = i;
>+			}
>+		}
>+
>+		if (columnIndex == -1) {
>+			throw new IllegalArgumentException(
>+					"Column with ID [" + columnID + "] not found in TableModelDescription."); //$NON-NLS-1$//$NON-NLS-2$
>+		}
>+
>+		tableViewer.getCellEditors()[columnIndex] = cellEditor;
>+
>+		if (selectionObservable == null) {
>+			selectionObservable = dataBindingContext
>+					.createObservable(new Property(tableViewer,
>+							ViewersProperties.SINGLE_SELECTION));
>+			Assert.isNotNull(selectionObservable);
>+		}
>+
>+		if (cellEditor.getControl() == null) {
>+			cellEditor.create(tableViewer.getTable());
>+		}
>+
>+		return dataBindingContext.bind(cellEditor, new Property(
>+				selectionObservable, columnID, columnIDType, Boolean.FALSE),
>+				bindSpec);
>+	}
>+
>+	/**
>+	 * @return Returns the viewerSelectionObservable.
>+	 */
>+	public IObservable getSelectionObservable() {
>+		return selectionObservable;
>+	}
>+}

Actions: View | Diff

Attachments on bug 144260: 42873 | 43411 | 45272 | 45438 | 82061 | 82072