import org.eclipse.jface.viewers.CheckboxCellEditor;

import org.eclipse.jface.viewers.TextCellEditor;

	public void testGetObservableForTextCellEditor() throws Exception {

		TextCellEditor editor = new TextCellEditor(shell);

		IObservable observable = factory.createObservable(editor);

		assertNotNull(observable);

	}

	public void testThrowsIAEIfTextCellEditorControlIsNotCreated() throws Exception {

		TextCellEditor editor = new TextCellEditor();

		try {

			factory.createObservable(editor);

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}

	}

	public void testGetObservableForCheckboxCellEditor() throws Exception {

		CheckboxCellEditor editor = new CheckboxCellEditor();

		IObservable observable = factory.createObservable(editor);

		assertNotNull(observable);

	}

 *     Brad Reynolds - bug 144260

import org.eclipse.jface.tests.internal.databinding.provisional.viewers.BooleanCellEditorObservableValueTest;

import org.eclipse.jface.tests.internal.databinding.provisional.viewers.TableViewerBindingFactoryTest;

import org.eclipse.jface.tests.internal.databinding.provisional.viewers.TableViewerEditorManagerTest;

		addTestSuite(BooleanCellEditorObservableValueTest.class);

		addTestSuite(TableViewerBindingFactoryTest.class);

		addTestSuite(TableViewerEditorManagerTest.class);

/*******************************************************************************

 * Copyright (c) 2006 Brad Reynolds 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:

 *     Brad Reynolds - initial API and implementation

 ******************************************************************************/

package org.eclipse.jface.tests.internal.databinding.provisional.viewers;

import junit.framework.TestCase;

import org.eclipse.jface.examples.databinding.model.Adventure;

import org.eclipse.jface.examples.databinding.model.Catalog;

import org.eclipse.jface.examples.databinding.model.Category;

import org.eclipse.jface.examples.databinding.model.Lodging;

import org.eclipse.jface.examples.databinding.model.SampleData;

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.viewers.TableViewerEditorManager;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.CheckboxCellEditor;

import org.eclipse.jface.viewers.ICellModifier;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TextCellEditor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.RowLayout;

import org.eclipse.swt.widgets.Shell;

/**

 * @since 3.2

 */

public class TableViewerEditorManagerTest extends TestCase {

	private Shell shell;

	private TableViewer viewer;

	private DataBindingContext context;

	private TableModelDescription description;

	private TableViewerEditorManager manager;

	private Catalog model;

	protected void setUp() throws Exception {

		shell = new Shell();

		shell.setLayout(new RowLayout());

		viewer = new TableViewer(shell, SWT.NONE);

		context = SampleData.getDatabindingContext(shell);

		model = SampleData.CATALOG_2005;

		description = new TableModelDescription(new Property(model,

				"lodgings", Lodging.class, Boolean.TRUE),

				new String[] { "name", "description" });

		context.bind(viewer, description, null);

		manager = new TableViewerEditorManager(viewer, description.getColumnIDs(), context);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see junit.framework.TestCase#tearDown()

	 */

	protected void tearDown() throws Exception {

		if (shell != null && !shell.isDisposed()) {

			shell.dispose();

			shell = null;

		}

	}

	public void testCreateControlIfItDoesntExist() throws Exception {

		TextCellEditor editor = new TextCellEditor();

		manager.setEditor(editor, "name", String.class, null);

		assertNotNull(viewer.getCellEditors()[0]);

	}

	public void testSetupViewerForEditing() throws Exception {

		assertNotNull(viewer.getCellModifier());

		assertNotNull(viewer.getColumnProperties());

		assertEquals(2, viewer.getColumnProperties().length);

		assertNotNull(viewer.getColumnProperties()[0]);

		assertEquals("name", viewer.getColumnProperties()[0]);

		assertNotNull(viewer.getCellEditors());

		assertEquals(2, viewer.getCellEditors().length);

		assertNull(viewer.getCellEditors()[0]);

		TextCellEditor editor = new TextCellEditor();

		manager.setEditor(editor, "name", String.class, null);

		assertEquals(editor, viewer.getCellEditors()[0]);

	}

	public void testSetValueInTextCellEditorOnEdit() throws Exception {

		TextCellEditor editor = new TextCellEditor();

		manager.setEditor(editor, "name", String.class, null);

		viewer.editElement(model.getLodgings()[0], 0);

		Lodging lodging = model.getLodgings()[0];

		assertEquals(lodging.getName(), editor.getValue());

	}

	public void testUpdateModelFromTextCellEditorAfterEdit() throws Exception {

		TextCellEditor editor = new TextCellEditor();

		manager.setEditor(editor, "name", String.class, null);

		Lodging lodging = model.getLodgings()[0];

		viewer.editElement(lodging, 0);

		assertTrue(editor.isActivated());

		String newValue = lodging.getName() + " new";

		editor.setValue(newValue);

		editor.getControl().notifyListeners(SWT.FocusOut, null);

		assertFalse(editor.isActivated());

		assertEquals(newValue, lodging.getName());

	}

	public void testToggleCheckboxCellEditorValueOnEdit() throws Exception {

		Category model = SampleData.WINTER_CATEGORY;

		description = new TableModelDescription(new Property(model,

				"adventures", Adventure.class, Boolean.TRUE),

				new String[] { "petsAllowed" });

		context.bind(viewer, description, null);

		manager = new TableViewerEditorManager(viewer, description.getColumnIDs(), context);

		CheckboxCellEditor editor = new CheckboxCellEditor();

		manager.setEditor(editor, "petsAllowed", boolean.class, null);

		Adventure adventure = model.getAdventures()[0];

		boolean old = adventure.isPetsAllowed();

		viewer.editElement(adventure, 0);

		assertEquals(!old, adventure.isPetsAllowed());

	}

	public void testRemoveEditor() throws Exception {

		TextCellEditor editor = new TextCellEditor();

		Binding binding = manager.setEditor(editor, "name", String.class, null);

		assertNotNull(binding);

		assertFalse(binding.isDisposed());

		ICellModifier cellModifier = viewer.getCellModifier();

		Lodging lodging = model.getLodgings()[0];

		assertTrue(cellModifier.canModify(lodging, "name"));

		manager.setEditor(null, "name", String.class, null);

		assertTrue(binding.isDisposed());

		assertFalse(cellModifier.canModify(lodging, "name"));

	}

	public void testSetEditorForExistingEditableColumn() throws Exception {

		TextCellEditor firstEditor = new TextCellEditor();

		Binding firstBinding = manager.setEditor(firstEditor, "name", String.class, null);

		assertFalse(firstBinding.isDisposed());

		TextCellEditor secondEditor = new TextCellEditor();

		Binding secondBinding = manager.setEditor(secondEditor, "name", String.class, null);

		assertTrue(firstBinding.isDisposed());

		assertFalse(secondBinding.isDisposed());

		ICellModifier cellModifier = viewer.getCellModifier();

		Lodging lodging = model.getLodgings()[0];

		assertTrue(cellModifier.canModify(lodging, "name"));

	}

	public void testSetEditorForInvalidColumnID() throws Exception {

		try {

			TextCellEditor editor = new TextCellEditor();

			manager.setEditor(editor, "bogus ID", String.class, null);

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}

	}

	public void testSetNullColumnID() throws Exception {

		try {

			TextCellEditor editor = new TextCellEditor();

			manager.setEditor(editor, null, String.class, null);

		} catch (IllegalArgumentException e) {

		}

	}

	public void testSetNullPropertyType() throws Exception {

		try {

			TextCellEditor editor = new TextCellEditor();

			manager.setEditor(editor, "name", null, null);

		} catch (IllegalArgumentException e) {

		}

	}

	public void testCellModifierOnlyAllowsEditingForColumnsWithAnEditor() throws Exception {

		ICellModifier modifier = viewer.getCellModifier();

		Lodging lodging = model.getLodgings()[0];

		TextCellEditor editor = new TextCellEditor();

		manager.setEditor(editor, "name", String.class, null);

		assertTrue(modifier.canModify(lodging, "name"));

		assertFalse(modifier.canModify(lodging, "description"));

	}

	public void testConstructWithNullTableViewer() throws Exception {

		try {

			manager = new TableViewerEditorManager(null, description.getColumnIDs(), context);

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}

	}

	public void testConstructWithNullTableModelDescription() throws Exception {

		try {

			manager = new TableViewerEditorManager(viewer, null, context);

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}

	}

	public void testConstructWithNullDataBindingContext() throws Exception {

		try {

			manager = new TableViewerEditorManager(viewer, description.getColumnIDs(), null);

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}

	}

	public void testGetEditor() throws Exception {

		assertNull(manager.getEditor("name"));

		TextCellEditor editor = new TextCellEditor();

		manager.setEditor(editor, "name", String.class, null);

		CellEditor nameEditor = manager.getEditor("name");

		assertNotNull(nameEditor);

		assertEquals(editor, nameEditor);

	}

	public void testGetInvalidEditor() throws Exception {

		try {

			manager.getEditor("column ID that does not exist");

			fail("exception should have been thrown");			

		} catch (IllegalArgumentException e) {

		}

	}

	public void testGetBinding() throws Exception {

		assertNull(manager.getBinding("name"));

		TextCellEditor editor = new TextCellEditor();

		Binding binding = manager.setEditor(editor, "name", String.class, null);

		Binding nameBinding = manager.getBinding("name");

		assertNotNull(nameBinding);

		assertEquals(binding, nameBinding);

	}

	public void testGetInvalidBinding() throws Exception {

		try {

			manager.getBinding("column ID that does not exist");

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2006 Brad Reynolds 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:

 *     Brad Reynolds - initial API and implementation

 ******************************************************************************/

package org.eclipse.jface.tests.internal.databinding.provisional.viewers;

import junit.framework.TestCase;

import org.eclipse.jface.examples.databinding.model.Catalog;

import org.eclipse.jface.examples.databinding.model.Lodging;

import org.eclipse.jface.examples.databinding.model.SampleData;

import org.eclipse.jface.internal.databinding.provisional.Binding;

import org.eclipse.jface.internal.databinding.provisional.DataBindingContext;

import org.eclipse.jface.internal.databinding.provisional.observable.IObservable;

import org.eclipse.jface.internal.databinding.provisional.observable.list.WritableList;

import org.eclipse.jface.internal.databinding.provisional.observable.value.IObservableValue;

import org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerBindingFactory;

import org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerBindingRecord;

import org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerEditorManager;

import org.eclipse.jface.internal.databinding.provisional.viewers.ViewersProperties;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TextCellEditor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.RowLayout;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.TableItem;

/**

 * @since 3.2

 */

public class TableViewerBindingFactoryTest extends TestCase {

	private Shell shell;

	private TableViewer viewer;

	private DataBindingContext context;

	private Catalog model;

	private TableViewerBindingFactory factory;

	/* (non-Javadoc)

	 * @see junit.framework.TestCase#setUp()

	 */

	protected void setUp() throws Exception {

		shell = new Shell();

		shell.setLayout(new RowLayout());

		viewer = new TableViewer(shell, SWT.NONE);

		context = SampleData.getDatabindingContext(shell);

		model = SampleData.CATALOG_2005;

		factory = new TableViewerBindingFactory();

	}

	/* (non-Javadoc)

	 * @see junit.framework.TestCase#tearDown()

	 */

	protected void tearDown() throws Exception {

		if (shell != null && !shell.isDisposed()) {

			shell.dispose();

			shell = null;

		}

	}

	public void testAddAndGetFactoryColumnIDs() throws Exception {

		Object[] columnIDs = factory.getColumnIDs();

		assertNotNull(columnIDs);

		assertEquals(0, columnIDs.length);

		factory.addColumn("name");

		columnIDs = factory.getColumnIDs();

		assertNotNull(columnIDs);

		assertEquals(1, columnIDs.length);

		assertEquals("name", columnIDs[0]);

		factory.addColumn("description");

		columnIDs = factory.getColumnIDs();

		assertEquals(2, columnIDs.length);

		assertEquals("name", columnIDs[0]);

		assertEquals("description", columnIDs[1]);

		assertEquals("name", factory.getColumnID(0));

		assertEquals("description", factory.getColumnID(1));

	}

	public void testBindingRecordValues() throws Exception {

		factory.addColumn("name");

		factory.addColumn("description");

		TableViewerBindingRecord record = factory.bind(viewer, model, "lodgings", Lodging.class, context, null);

		Object[] columnIDs = record.getColumnIDs();

		assertNotNull(columnIDs);

		assertEquals(2, columnIDs.length);

		assertEquals("name", columnIDs[0]);

		assertEquals("description", columnIDs[1]);

		assertNotNull(record.getBinding());

	}

	public void testBindProperty() throws Exception {

		Table table = viewer.getTable();

		for (int i = 0; i < 2; i++) {

			new TableColumn(table, SWT.NONE);

		}

		factory.addColumn("name");

		factory.addColumn("description");

		TableViewerBindingRecord tvb = factory.bind(viewer, model, "lodgings", Lodging.class, context, null);

		Binding binding = tvb.getBinding();

		assertNotNull(binding);

		//Assert the binding worked

		TableItem item = table.getItem(0);

		Lodging lodging = model.getLodgings()[0];

		assertEquals(lodging, item.getData());

		assertEquals(lodging.getName(), item.getText(0));

		assertEquals(lodging.getDescription(), item.getText(1));		

	}

	public void testAddEditableColumn() throws Exception {

		TextCellEditor nameEditor = new TextCellEditor();

		factory.addEditableColumn("name", nameEditor, String.class, null);

		factory.addColumn("description");

		TableViewerBindingRecord tvb = factory.bind(viewer, model, "lodgings", Lodging.class, context, null);

		TableViewerEditorManager editorManager = tvb.getTableViewerEditorManager();

		assertNotNull(editorManager);

		assertEquals(nameEditor, editorManager.getEditor("name"));

		assertNull(editorManager.getEditor("description"));

	}

	public void testAddEditableColumnWithNullEditor() throws Exception {

		try {

			factory.addEditableColumn("name", null, String.class, null);

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}		

	}

	public void testAddEditableColumnWithNullPropertyType() throws Exception {

		try {

			factory.addEditableColumn("name", new TextCellEditor(), null, null);

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}

	}

	public void testBindObservableList() throws Exception {

		WritableList list = new WritableList(Lodging.class);

		Lodging lodging = new Lodging();

		lodging.setName("lodging name");

		list.add(lodging);

		factory.addColumn("name");

		TableViewerBindingRecord tvb = factory.bind(viewer, list, context, null);

		assertNotNull(tvb.getBinding());

		//Assert the binding worked

		Table table = viewer.getTable();

		TableItem item = table.getItem(0);

		assertEquals(lodging, item.getData());

		assertEquals(lodging.getName(), item.getText(0));

	}

	public void testAddNullColumnID() throws Exception {

		try {

			factory.addColumn(null);

			fail("exception should have been thrown");

		} catch (IllegalArgumentException e) {

		}

	}

	public void testGetContentObservable() throws Exception {

		Table table = viewer.getTable();

		for (int i = 0; i < 2; i++) {

			new TableColumn(table, SWT.NONE);

		}

		factory.addColumn("name");

		factory.addColumn("description");

		TableViewerBindingRecord tvb = factory.bind(viewer, model, "lodgings", Lodging.class, context, null);

		IObservable observable = tvb.getObservable(ViewersProperties.CONTENT);

		assertNotNull(observable);

	}

	public void testGetSelectionObservableValue() throws Exception {

		Table table = viewer.getTable();

		for (int i = 0; i < 2; i++) {

			new TableColumn(table, SWT.NONE);

		}

		factory.addColumn("name");

		factory.addColumn("description");

		TableViewerBindingRecord record = factory.bind(viewer, model, "lodgings", Lodging.class, context, null);

		IObservableValue selectionObservable = record.getSelection();

		assertNotNull(selectionObservable);

		//assert that only one selection observable is created

		assertSame(selectionObservable, record.getSelection());

		table.setSelection(0);

		assertEquals(model.getLodgings()[0], selectionObservable.getValue());

		table.setSelection(1);

		assertEquals(model.getLodgings()[1], selectionObservable.getValue());

	}

}

/*******************************************************************************

 * Copyright (c) 2006 Brad Reynolds 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:

 *     Brad Reynolds - initial API and implementation

 ******************************************************************************/

package org.eclipse.jface.tests.internal.databinding.provisional.viewers;

import junit.framework.TestCase;

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.jface.internal.databinding.provisional.viewers.BooleanCellEditorObservableValue;

import org.eclipse.jface.viewers.CheckboxCellEditor;

/**

 * @since 3.2

 */

public class BooleanCellEditorObservableValueTest extends TestCase {

	private BooleanCellEditorObservableValue observable;

	private MyCheckboxCellEditor cellEditor;

	protected void setUp() throws Exception {

		cellEditor = new MyCheckboxCellEditor();

		cellEditor.setValue(Boolean.FALSE);

		observable = new BooleanCellEditorObservableValue(cellEditor);

	}

	private class MyCheckboxCellEditor extends CheckboxCellEditor {

		protected void setValueValid(boolean valid) {

			// TODO Auto-generated method stub

			super.setValueValid(valid);

		}

	}

	public void testConstructionIllegalArgumentExceptions() throws Exception {

		try {

			new BooleanCellEditorObservableValue(null);

			fail("Exception should have been thrown.");

		} catch (IllegalArgumentException e) {

		}

	}

	public void testGetValueType() throws Exception {

		assertEquals(Boolean.class, observable.getValueType());

	}

	public void testGetValue() throws Exception {

		cellEditor.setValue(Boolean.TRUE);

		assertEquals(Boolean.TRUE, observable.getValue());

		cellEditor.setValue(Boolean.FALSE);

		assertEquals(Boolean.FALSE, observable.getValue());

	}

	public void testSetFalseWhenCellEditorValueIsNull() throws Exception {

		cellEditor.setValueValid(false);

		assertNull(cellEditor.getValue());

		observable.setValue(Boolean.FALSE);

		Boolean editorValue = (Boolean) cellEditor.getValue();

		assertNotNull(editorValue);

		assertEquals(Boolean.FALSE, editorValue);

	}

	public void testObservableSetValueSame() throws Exception {

		ValueChangeCounter listener = new ValueChangeCounter();

		observable.addValueChangeListener(listener);

		assertEquals(0, listener.count);

		assertEquals(Boolean.FALSE, observable.getValue());

		assertEquals(Boolean.FALSE, cellEditor.getValue());

		observable.setValue(Boolean.FALSE);

		assertEquals(0, listener.count);

		assertEquals(Boolean.FALSE, observable.getValue());

		assertEquals(Boolean.FALSE, cellEditor.getValue());

	}

	public void testObservableSetValueDifferent() throws Exception {

		ValueChangeCounter listener = new ValueChangeCounter();

		observable.addValueChangeListener(listener);

		assertEquals(0, listener.count);

		assertEquals(Boolean.FALSE, observable.getValue());

		assertEquals(Boolean.FALSE, cellEditor.getValue());

		observable.setValue(Boolean.TRUE);

		assertEquals(1, listener.count);

		assertEquals(Boolean.TRUE, observable.getValue());

		assertEquals(Boolean.TRUE, cellEditor.getValue());

		assertEquals(observable, listener.source);

		assertEquals(Boolean.FALSE, listener.diff.getOldValue());

		assertEquals(Boolean.TRUE, listener.diff.getNewValue());

	}

	public void testCellEditorChangeValue() throws Exception {

		ValueChangeCounter listener = new ValueChangeCounter();

		observable.addValueChangeListener(listener);

		assertEquals(0, listener.count);

		assertEquals(Boolean.FALSE, observable.getValue());

		assertEquals(Boolean.FALSE, cellEditor.getValue());

		cellEditor.activate();

		assertEquals(1, listener.count);

		assertEquals(Boolean.TRUE, observable.getValue());

		assertEquals(Boolean.TRUE, cellEditor.getValue());

		assertEquals(observable, listener.source);

		assertEquals(Boolean.FALSE, listener.diff.getOldValue());

		assertEquals(Boolean.TRUE, listener.diff.getNewValue());

	}

	public void testCellEditorSetValueDifferent() throws Exception {

		ValueChangeCounter listener = new ValueChangeCounter();

		observable.addValueChangeListener(listener);

		assertEquals(0, listener.count);

		assertEquals(Boolean.FALSE, observable.getValue());

		assertEquals(Boolean.FALSE, cellEditor.getValue());

		cellEditor.setValue(Boolean.TRUE);

		assertEquals(0, listener.count);

		assertEquals(Boolean.TRUE, observable.getValue());

		assertEquals(Boolean.TRUE, cellEditor.getValue());

	}

	public void testSetObservableNullValue() throws Exception {

		ValueChangeCounter listener = new ValueChangeCounter();

		observable.addValueChangeListener(listener);

		assertEquals(0, listener.count);

		assertEquals(Boolean.FALSE, observable.getValue());

		assertEquals(Boolean.FALSE, cellEditor.getValue());

		observable.setValue(null);

		assertEquals(0, listener.count);

		assertEquals(Boolean.FALSE, observable.getValue());

		assertEquals(Boolean.FALSE, cellEditor.getValue());

	}

	private class ValueChangeCounter implements IValueChangeListener {

		private int count;

		private IObservableValue source;

		private ValueDiff diff;

		public void handleValueChange(IObservableValue source, ValueDiff diff) {

			count++;

			this.source = source;

			this.diff = diff;

		}

	}

}

 *     Brad Reynolds - bug 144260

import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;

import org.eclipse.jface.internal.databinding.provisional.description.TableModelDescription;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.CheckboxCellEditor;

import org.eclipse.jface.viewers.TextCellEditor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Text;

 * <li>object instanceof <code>TextCellEditor</code></li>

 * <li>object instanceof <code>CheckboxCellEditor</code></li>

		} else if (description instanceof CellEditor) {

			if (description instanceof TextCellEditor) {

				TextCellEditor editor = (TextCellEditor) description;

				if (editor.getControl() == null) {

					throw new IllegalArgumentException(

							"The TextCellEditor control must be created before creating the observable."); //$NON-NLS-1$

				}

				//Updating of the model will need to be done manually, hence the SWT.NONE.

				return new TextObservableValue((Text) editor.getControl(),

						SWT.NONE);

			} else if (description instanceof CheckboxCellEditor) {

				return new BooleanCellEditorObservableValue(

						(CheckboxCellEditor) description);

			}

/*******************************************************************************

 * Copyright (c) 2006 Brad Reynolds 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:

 *     Brad Reynolds - initial API and implementation

 ******************************************************************************/

package org.eclipse.jface.internal.databinding.provisional.viewers;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

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.internal.databinding.provisional.observable.list.IObservableList;

import org.eclipse.jface.internal.databinding.provisional.observable.value.IObservableValue;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.swt.events.DisposeEvent;

import org.eclipse.swt.events.DisposeListener;

/**

 * Builds a binding for a <code>TableViewer</code>.

 * 

 * @since 3.2

 */

public class TableViewerBindingFactory {

	/**

	 * Empty array to represent no column IDs.

	 */

	private static final Object[] NO_COLUMN_IDS = new Object[0];

	/**

	 * Maintains the order of columns.

	 */

	private List columnIDs;

	/**

	 * Maintains columnData instances keyed by column ID.

	 */

	private Map columnDatas;

	/**

	 * Constructs a new instance.

	 */

	public TableViewerBindingFactory() {

	}

	/**

	 * Adds a column to the binding.

	 * 

	 * @param columnID

	 */

	public void addColumn(Object columnID) {

		addColumn(columnID, null, null, null);

	}

	/**

	 * Adds a column that is to be edited with the provided editor data.

	 * 

	 * @param columnID

	 * @param cellEditor

	 * @param propertyType

	 * @param bindSpec

	 */

	private void addColumn(Object columnID, CellEditor cellEditor,

			Class propertyType, BindSpec bindSpec) {

		if (columnID == null) {

			throw new IllegalArgumentException(

					"Parameter " + columnID + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		if (columnDatas == null) {

			columnIDs = new ArrayList();

			columnDatas = new HashMap();

		}

		columnIDs.add(columnID);

		columnDatas.put(columnID, new ColumnData(cellEditor, propertyType,

				bindSpec));

	}

	/**

	 * Adds a column that is to be edited using the editor data.

	 * 

	 * @param columnID

	 * @param cellEditor

	 * @param propertyType

	 * @param bindSpec

	 *            can be <code>null</code>

	 */

	public void addEditableColumn(Object columnID, CellEditor cellEditor,

			Class propertyType, BindSpec bindSpec) {

		if (columnID == null) {

			throw new IllegalArgumentException(

					"Parameter " + columnID + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		if (cellEditor == null) {

			throw new IllegalArgumentException(

					"Parameter " + cellEditor + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		if (propertyType == null) {

			throw new IllegalArgumentException(

					"Parameter " + propertyType + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		addColumn(columnID, cellEditor, propertyType, bindSpec);

	}

	/**

	 * Returns the columnID for the column index.

	 * 

	 * @param columnIndex

	 * @return column ID

	 */

	public Object getColumnID(int columnIndex) {

		if (columnIDs == null || columnIndex >= columnIDs.size()

				|| columnIndex < 0) {

			throw new IllegalArgumentException(

					"Parameter columnIndex [" + columnIndex + "] is out of bounds."); //$NON-NLS-1$//$NON-NLS-2$

		}

		return columnIDs.get(columnIndex);

	}

	/**

	 * @return Number of columns added to the factory.

	 */

	public int getColumnCount() {

		return (columnDatas != null) ? columnDatas.size() : 0;

	}

	/**

	 * Binds a viewer to the provided <code>propertyName</code> of the

	 * <code>model</code> which contains objects of the provided

	 * <code>propertyType</code>.

	 * 

	 * @param viewer

	 * @param model

	 * @param propertyName

	 * @param propertyType

	 * @param context

	 * @param bindSpec

	 * @return binding manager

	 */

	public TableViewerBindingRecord bind(TableViewer viewer, Object model,

			String propertyName, Class propertyType,

			DataBindingContext context, BindSpec bindSpec) {

		TableModelDescription description = new TableModelDescription(

				new Property(model, propertyName, propertyType, Boolean.TRUE),

				getColumnIDs());

		return bind(viewer, description, context, bindSpec);

	}

	/**

	 * Binds a viewer to the provided <code>observableList</code>.

	 * 

	 * @param viewer

	 * @param observableList

	 * @param context

	 * @param bindSpec

	 * 

	 * @return binding manager

	 */

	public TableViewerBindingRecord bind(TableViewer viewer,

			IObservableList observableList, DataBindingContext context,

			BindSpec bindSpec) {

		TableModelDescription description = new TableModelDescription(

				observableList, getColumnIDs());

		return bind(viewer, description, context, bindSpec);

	}

	private TableViewerBindingRecord bind(TableViewer viewer,

			TableModelDescription description, DataBindingContext context,

			BindSpec bindSpec) {

		// Perform the binding.

		Binding binding = context.bind(viewer, description, bindSpec);

		// Setup editing.

		TableViewerEditorManager editorManager = new TableViewerEditorManager(

				viewer, description.getColumnIDs(), context);

		if (columnDatas != null) {

			for (Iterator it = columnIDs.iterator(); it.hasNext();) {

				Object columnID = it.next();

				ColumnData data = (ColumnData) columnDatas.get(columnID);

				if (data.editor != null) {

					editorManager.setEditor(data.editor, columnID,

							data.propertyType, data.bindSpec);

				}

			}

		}

		return new TableViewerBindingRecordImpl(viewer, context, binding,

				editorManager, description.getColumnIDs());

	}

	/**

	 * @return columnIDs, empty array if none

	 */

	public Object[] getColumnIDs() {

		Object[] result = NO_COLUMN_IDS;

		if (columnIDs != null) {

			result = columnIDs.toArray();

		}

		return result;

	}

	/**

	 * Manages relationship between columnID and the editor data.

	 * 

	 * @since 3.2

	 */

	private static class ColumnData {

		private final CellEditor editor;

		private final Class propertyType;

		private final BindSpec bindSpec;

		/**

		 * Constructs a new instance.

		 * 

		 * @param editor

		 * @param propertyType

		 * @param bindSpec

		 */

		public ColumnData(CellEditor editor, Class propertyType,

				BindSpec bindSpec) {

			this.editor = editor;

			this.propertyType = propertyType;

			this.bindSpec = bindSpec;

		}

	}

	/**

	 * Implementation of TableViewerBindingRecord to use internally.

	 * 

	 * @since 3.2

	 */

	private static class TableViewerBindingRecordImpl extends

			TableViewerBindingRecord {

		private final TableViewer viewer;

		private final DataBindingContext context;

		private final Binding binding;

		private final TableViewerEditorManager manager;

		private final Object[] columnIDs;

		private IObservableValue selection;

		private LinkedList observables;

		TableViewerBindingRecordImpl(TableViewer viewer,

				DataBindingContext context, Binding binding,

				TableViewerEditorManager manager, Object[] columnIDs) {

			this.viewer = viewer;

			this.context = context;

			this.binding = binding;

			this.manager = manager;

			this.columnIDs = columnIDs;

			viewer.getTable().addDisposeListener(new DisposeListener() {

				public void widgetDisposed(DisposeEvent e) {

					if (observables != null) {

						for (Iterator it = observables.iterator(); it.hasNext();) {

							((IObservable) it.next()).dispose();

						}

						observables.clear();

					}

				}

			});

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerBindingRecord#getBinding()

		 */

		public Binding getBinding() {

			return binding;

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerBindingRecord#getColumnIDs()

		 */

		public Object[] getColumnIDs() {

			return columnIDs;

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerBindingRecord#getObservable(int)

		 */

		public IObservable getObservable(String viewersProperty) {

			IObservable observable = context.createObservable(new Property(

					viewer, viewersProperty));

			if (observables == null) {

				observables = new LinkedList();

			}

			observables.add(observable);

			return observable;

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerBindingRecord#getSelection()

		 */

		public IObservableValue getSelection() {

			IObservableValue result = this.selection;

			if (result == null) {

				this.selection = result = (IObservableValue) getObservable(ViewersProperties.SINGLE_SELECTION);

			}

			return result;

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.internal.databinding.provisional.viewers.TableViewerBindingRecord#getTableViewerEditorManager()

		 */

		public TableViewerEditorManager getTableViewerEditorManager() {

			return manager;

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2006 Brad Reynolds 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:

 *     Brad Reynolds - initial API and implementation

 ******************************************************************************/

package org.eclipse.jface.internal.databinding.provisional.viewers;

import org.eclipse.jface.internal.databinding.provisional.Binding;

import org.eclipse.jface.internal.databinding.provisional.observable.IObservable;

import org.eclipse.jface.internal.databinding.provisional.observable.value.IObservableValue;

/**

 * Maintains the artifacts of the binding of a TableViewer.

 * 

 * @since 3.2

 */

public abstract class TableViewerBindingRecord {

	/**

	 * @return column IDs provided when the viewer was bound

	 */

	public abstract Object[] getColumnIDs();

	/**

	 * @return binding for the viewer

	 */

	public abstract Binding getBinding();

	/**

	 * @return manager that provides access to the editing capabilities of the binding

	 */

	public abstract TableViewerEditorManager getTableViewerEditorManager();

	/**

	 * @param viewersProperty

	 * @return observable for the provided {@link ViewersProperties viewer property}

	 */

	public abstract IObservable getObservable(String viewersProperty);

	/**

	 * @return observable value for the selection of the table viewer

	 */

	public abstract IObservableValue getSelection();

}

/*******************************************************************************

 * Copyright (c) 2006 Brad Reynolds 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:

 *     Brad Reynolds - initial API and implementation

 ******************************************************************************/

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.observable.IObservable;

import org.eclipse.jface.internal.databinding.provisional.observable.value.AbstractObservableValue;

import org.eclipse.jface.internal.databinding.provisional.observable.value.ValueDiff;

import org.eclipse.jface.util.Assert;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ICellModifier;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.swt.widgets.Item;

/**

 * Manages the editing of a bound <code>TableViewer</code>.

 * <p>

 * The <code>CellEditor</code> must not propagate changes to the model on its

 * own. This is facilitated by this manager and if the editor was to propagate

 * changes on its own the behavior is undefined.

 * </p>

 * 

 * @since 3.2

 */

public class TableViewerEditorManager {

	private final Object[] columnIDs;

	/**

	 * Viewer to associate editors with.

	 */

	private final TableViewer viewer;

	/**

	 * Bindings that have been created for editors.

	 */

	private Binding[] bindings;

	/**

	 * DBC to use for creating editor bindings.

	 */

	private final DataBindingContext context;

	/**

	 * Observable that represents the element being edited. This is set in

	 * CellModifer getValue as this is the only place that we have access to

	 * this.

	 */

	private EditableElement editableElement;

	/**

	 * Constructs a new instance.

	 * 

	 * @param viewer

	 * @param columnIDs

	 * @param context

	 */

	public TableViewerEditorManager(TableViewer viewer, Object[] columnIDs,

			DataBindingContext context) {

		if (viewer == null) {

			throw new IllegalArgumentException(

					"Parameter " + viewer + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		if (columnIDs == null) {

			throw new IllegalArgumentException(

					"Parameter " + columnIDs + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		if (context == null) {

			throw new IllegalArgumentException(

					"Parameter " + context + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		this.viewer = viewer;

		this.context = context;

		this.columnIDs = columnIDs;

		int columnCount = (columnIDs != null) ? columnIDs.length : 0;

		viewer.setCellEditors(new CellEditor[columnCount]);

		String[] properties = new String[columnCount];

		viewer.setColumnProperties(properties);

		for (int i = 0; i < columnCount; i++) {

			properties[i] = columnIDs[i].toString();

		}

		editableElement = new EditableElement();

		bindings = new Binding[columnCount];

		viewer.setCellModifier(new CellModifier());

	}

	/**

	 * Returns the binding for the columnID.

	 * 

	 * @param columnID 

	 * @return binding, <code>null</code> if a binding doesn't exist because there is no editor.

	 */

	public Binding getBinding(Object columnID) {

		int columnIndex = getValidColumnIndex(columnID);

		return bindings[columnIndex];

	}

	/**

	 * Retuns the editor for the columnID.

	 * 

	 * @param columnID 

	 * @return editor, <code>null</code> if an editor was not set

	 */

	public CellEditor getEditor(Object columnID) {

		int columnIndex = getValidColumnIndex(columnID);

		return viewer.getCellEditors()[columnIndex];

	}

	/**

	 * Sets a <code>editor</code> as the editor for the provided

	 * <code>columnID</code>.

	 * 

	 * @param editor

	 *            if <code>null</code> removes the current editor

	 * @param columnID

	 * @param propertyType

	 *            type of the attribute to be edited

	 * @param bindSpec

	 *            can be <code>null</code>

	 * @return binding for the editor

	 */

	public Binding setEditor(CellEditor editor, Object columnID,

			Class propertyType, BindSpec bindSpec) {

		if (columnID == null) {

			throw new IllegalArgumentException(

					"Parameter " + columnID + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		if (propertyType == null) {

			throw new IllegalArgumentException(

					"Parameter " + propertyType + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		int columnIndex = getValidColumnIndex(columnID);

		viewer.getCellEditors()[columnIndex] = editor;

		Binding existingBinding = bindings[columnIndex];

		if (existingBinding != null) {

			// Remove the existing editor.

			existingBinding.dispose();

			bindings[columnIndex] = null;

		}

		Binding result = null;

		if (editor != null) {

			if (editor.getControl() == null) {

				editor.create(viewer.getTable());

			}

			IObservable observable = context.createObservable(new Property(

					editableElement, columnID, propertyType, Boolean.FALSE));

			result = context.bind(editor, observable, bindSpec);

			bindings[columnIndex] = result;

		}

		return result;

	}

	/**

	 * Returns the index for the column ID.

	 * 

	 * @param columnID

	 * @return column index, -1 if not found

	 */

	private int getColumnIndex(Object columnID) {

		int columnIndex = -1;

		for (int i = 0; columnIndex == -1 && i < columnIDs.length; i++) {

			if (columnID.equals(columnIDs[i])) {

				columnIndex = i;

			}

		}

		return columnIndex;

	}

	/**

	 * Returns the column index of the provided <code>columnID</code>.

	 * 

	 * @param columnID

	 * @return index

	 * @throws IllegalArgumentException

	 *             if columnID is invalid.

	 */

	private int getValidColumnIndex(Object columnID) {

		int index = getColumnIndex(columnID);

		if (index <= -1) {

			throw new IllegalArgumentException(

					"ColumnID [" + columnID + "] is an invalid columnID."); //$NON-NLS-1$//$NON-NLS-2$

		}

		return index;

	}

	/**

	 * Observable for the element being edited.

	 * 

	 * @since 3.2

	 */

	private static class EditableElement extends AbstractObservableValue {

		private Object element;

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.internal.databinding.provisional.observable.value.AbstractObservableValue#setValue(java.lang.Object)

		 */

		public void setValue(Object value) {

			final Object old = element;

			element = value;

			fireValueChange(new ValueDiff() {

				public Object getNewValue() {

					return element;

				}

				public Object getOldValue() {

					return old;

				}

			});

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.internal.databinding.provisional.observable.value.AbstractObservableValue#doGetValue()

		 */

		protected Object doGetValue() {

			return element;

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.internal.databinding.provisional.observable.value.IObservableValue#getValueType()

		 */

		public Object getValueType() {

			return Object.class;

		}

	}

	/**

	 * <code>ICellModifier</code> implementation to be used in data binding

	 * that when requested retrieves the values from the model and sets the

	 * value in the model. The observables should not automatically update the

	 * model, the cell modifier handles this.

	 * 

	 * @since 3.2

	 */

	private class CellModifier implements ICellModifier {

		public boolean canModify(Object element, String property) {

			int columnIndex = getColumnIndex(property);

			Assert.isTrue(columnIndex > -1);

			return bindings[columnIndex] != null;

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.viewers.ICellModifier#getValue(java.lang.Object,

		 *      java.lang.String)

		 */

		public Object getValue(Object element, String property) {

			if (editableElement.getValue() != element) {

				editableElement.setValue(element);

			}

			Binding binding = getBinding(property);

			Assert.isNotNull(binding);

			binding.updateTargetFromModel();

			/*

			 * Something has to be returned so just pass the value of the

			 * editor, it's the correct value at this point. This will end up

			 * setting the value twice but the observable shouldn't fire 2

			 * change events as the value didn't change on the second set.

			 */

			return getEditor(property).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) {

			element = ((Item) element).getData();

			Assert.isTrue(editableElement.getValue().equals(element));

			Binding binding = getBinding(property);

			Assert.isNotNull(binding);

			binding.updateModelFromTarget();

			editableElement.setValue(null);

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2006 Brad Reynolds 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:

 *     Brad Reynolds - initial API and implementation

 ******************************************************************************/

package org.eclipse.jface.internal.databinding.provisional.viewers;

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.AbstractObservableValue;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ICellEditorListener;

/**

 * {@link IObservable} implementation for a <code>CellEditor</code> that has

 * no control and its value is of type boolean.

 * 

 * @since 3.2

 */

public class BooleanCellEditorObservableValue extends AbstractObservableValue {

	private final CellEditor editor;

	private CellEditorListener listener;

	/**

	 * Constructs a new instance.

	 * 

	 * @param cellEditor

	 */

	public BooleanCellEditorObservableValue(final CellEditor cellEditor) {

		if (cellEditor == null) {

			throw new IllegalArgumentException(

					"Parameter " + cellEditor + " was null."); //$NON-NLS-1$ //$NON-NLS-2$

		}

		this.editor = cellEditor;

		listener = new CellEditorListener(this);

		editor.addListener(listener);

	}

	public void dispose() {

		super.dispose();

		if (listener != null) {

			editor.removeListener(listener);

			listener = null;

		}

	}

	/**

	 * @see org.eclipse.jface.internal.databinding.provisional.observable.value.AbstractObservableValue#doGetValue()

	 */

	protected Object doGetValue() {

		return editor.getValue();

	}

	/**

	 * @see org.eclipse.jface.internal.databinding.provisional.observable.value.IObservableValue#getValueType()

	 */

	public Object getValueType() {

		return Boolean.class;

	}

	/**

	 * @see org.eclipse.jface.internal.databinding.provisional.observable.value.AbstractObservableValue#setValue(java.lang.Object)

	 */

	public void setValue(Object value) {

		Boolean oldValue = (Boolean) editor.getValue();

		Boolean newValue = (value == null) ? Boolean.FALSE : (Boolean) value;

		if (!newValue.equals(oldValue)) {

			editor.setValue(newValue); // does not fire an event

			fireValueChange(Diffs.createValueDiff(oldValue, newValue));

		}

	}

	private static class CellEditorListener implements ICellEditorListener {

		private final BooleanCellEditorObservableValue observable;

		private CellEditorListener(BooleanCellEditorObservableValue observable) {

			this.observable = observable;

		}

		public void applyEditorValue() {

			/*

			 * When applyEditorValue() is invoked the value has changed. Because

			 * of the nature of a boolean we know the old is the opposite of the

			 * current value.

			 */

			boolean value = ((Boolean) observable.editor.getValue())

					.booleanValue();

			observable.fireValueChange(Diffs.createValueDiff(Boolean

					.valueOf(!value), Boolean.valueOf(value)));

		}

		public void cancelEditor() {

			// not needed

		}

		public void editorValueChanged(boolean oldValidState,

				boolean newValidState) {

			// not needed

		}

	}

}