Attachment 82072 Details for Bug 144260 – Column builder prototype (requires attachment 82061 patch)

[patch] Column builder prototype (requires attachment 82061 patch)

Snippet013TableViewerEditing.java (text/plain), 12.53 KB, created by Brad Reynolds

on 2007-11-05 01:10:09 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Brad Reynolds

Created: 2007-11-05 01:10:09 EST

Size: 12.53 KB

patch

obsolete

>/*******************************************************************************
> * Copyright (c) 2006 The Pampered Chef, Inc. 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:
> *     The Pampered Chef, Inc. - initial API and implementation
> *     Tom Schindl - cell editing
> ******************************************************************************/
>
>package org.eclipse.jface.examples.databinding.snippets;
>
>import java.beans.PropertyChangeListener;
>import java.beans.PropertyChangeSupport;
>import java.util.LinkedList;
>import java.util.List;
>import java.util.Set;
>
>import org.eclipse.core.databinding.DataBindingContext;
>import org.eclipse.core.databinding.beans.BeansObservables;
>import org.eclipse.core.databinding.observable.IObservable;
>import org.eclipse.core.databinding.observable.Realm;
>import org.eclipse.core.databinding.observable.list.WritableList;
>import org.eclipse.core.databinding.observable.map.IMapChangeListener;
>import org.eclipse.core.databinding.observable.map.IObservableMap;
>import org.eclipse.core.databinding.observable.map.MapChangeEvent;
>import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
>import org.eclipse.core.databinding.observable.set.IObservableSet;
>import org.eclipse.core.databinding.observable.value.IObservableValue;
>import org.eclipse.jface.databinding.swt.SWTObservables;
>import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
>import org.eclipse.jface.databinding.viewers.ObservableValueEditingSupport;
>import org.eclipse.jface.databinding.viewers.ViewersObservables;
>import org.eclipse.jface.viewers.CellEditor;
>import org.eclipse.jface.viewers.CellLabelProvider;
>import org.eclipse.jface.viewers.ColumnViewer;
>import org.eclipse.jface.viewers.LabelProviderChangedEvent;
>import org.eclipse.jface.viewers.TableViewer;
>import org.eclipse.jface.viewers.TableViewerColumn;
>import org.eclipse.jface.viewers.TextCellEditor;
>import org.eclipse.jface.viewers.ViewerCell;
>import org.eclipse.swt.SWT;
>import org.eclipse.swt.layout.FillLayout;
>import org.eclipse.swt.widgets.Composite;
>import org.eclipse.swt.widgets.Display;
>import org.eclipse.swt.widgets.Label;
>import org.eclipse.swt.widgets.Shell;
>import org.eclipse.swt.widgets.Table;
>
>/**
> * Demonstrates binding a TableViewer to a collection using the 3.3 Viewer APIs.
> */
>public class Snippet013TableViewerEditing {
>	public static void main(String[] args) {
>		final Display display = new Display();
>		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
>			public void run() {
>				ViewModel viewModel = new ViewModel();
>				Shell shell = new View(viewModel).createShell();
>
>				// The SWT event loop
>				while (!shell.isDisposed()) {
>					if (!display.readAndDispatch()) {
>						display.sleep();
>					}
>				}
>			}
>		});
>	}
>
>	// Minimal JavaBeans support
>	public static abstract class AbstractModelObject {
>		private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(
>				this);
>
>		public void addPropertyChangeListener(PropertyChangeListener listener) {
>			propertyChangeSupport.addPropertyChangeListener(listener);
>		}
>
>		public void addPropertyChangeListener(String propertyName,
>				PropertyChangeListener listener) {
>			propertyChangeSupport.addPropertyChangeListener(propertyName,
>					listener);
>		}
>
>		public void removePropertyChangeListener(PropertyChangeListener listener) {
>			propertyChangeSupport.removePropertyChangeListener(listener);
>		}
>
>		public void removePropertyChangeListener(String propertyName,
>				PropertyChangeListener listener) {
>			propertyChangeSupport.removePropertyChangeListener(propertyName,
>					listener);
>		}
>
>		protected void firePropertyChange(String propertyName, Object oldValue,
>				Object newValue) {
>			propertyChangeSupport.firePropertyChange(propertyName, oldValue,
>					newValue);
>		}
>	}
>
>	// The data model class. This is normally a persistent class of some sort.
>	static class Person extends AbstractModelObject {
>		// A property...
>		String name = "John Smith";
>		private String os;
>
>		public Person(String name, String os) {
>			this.name = name;
>			this.os = os;
>		}
>
>		public String getName() {
>			return name;
>		}
>
>		public void setName(String name) {
>			String oldValue = this.name;
>			this.name = name;
>			firePropertyChange("name", oldValue, name);
>		}
>		
>		public String getOS() {
>			return os;
>		}
>		
>		public void setOS(String os) {
>			this.os = os;
>		}
>	}
>
>	// The View's model--the root of our Model graph for this particular GUI.
>	//
>	// Typically each View class has a corresponding ViewModel class.
>	// The ViewModel is responsible for getting the objects to edit from the
>	// data access tier. Since this snippet doesn't have any persistent objects
>	// ro retrieve, this ViewModel just instantiates a model object to edit.
>	static class ViewModel {
>		// The model to bind
>		private List people = new LinkedList();
>		{
>			people.add(new Person("Steve Northover", "Windows"));
>			people.add(new Person("Grant Gayed", "Linux"));
>			people.add(new Person("Veronika Irvine", "OS X"));
>			people.add(new Person("Mike Wilson", "Linux"));
>			people.add(new Person("Christophe Cornu", "Windows"));
>			people.add(new Person("Lynne Kues", "Linux"));
>			people.add(new Person("Silenio Quarti", "OS X"));
>		}
>
>		public List getPeople() {
>			return people;
>		}
>	}
>
>	// The GUI view
>	static class View {
>		private ViewModel viewModel;
>
>		private Table committers;
>
>		private Label selectedCommitter;
>
>		public View(ViewModel viewModel) {
>			this.viewModel = viewModel;
>		}
>
>		public Shell createShell() {
>			// Build a UI
>			Display display = Display.getDefault();
>			Shell shell = new Shell(display);
>			shell.setLayout(new FillLayout(SWT.VERTICAL));
>			committers = new Table(shell, SWT.BORDER | SWT.FULL_SELECTION);
>			committers.setLinesVisible(true);
>
>			selectedCommitter = new Label(shell, SWT.NONE);
>			// Set up data binding. In an RCP application, the threading
>			// Realm
>			// will be set for you automatically by the Workbench. In an SWT
>			// application, you can do this once, wrpping your binding
>			// method call.
>			DataBindingContext bindingContext = new DataBindingContext();
>			bindGUI(bindingContext);
>
>			// Open and return the Shell
>			shell.setSize(100, 300);
>			shell.open();
>			return shell;
>		}
>
>		protected void bindGUI(DataBindingContext bindingContext) {
>			// Since we're using a JFace Viewer, we do first wrap our Table...
>			TableViewer peopleViewer = new TableViewer(committers);
>
>			// Create a standard content provider
>			ObservableListContentProvider peopleViewerContentProvider = new ObservableListContentProvider();
>			peopleViewer.setContentProvider(peopleViewerContentProvider);
>
>			BeanTableViewerBuilder builder = new BeanTableViewerBuilder(
>					peopleViewer,
>					peopleViewerContentProvider.getKnownElements(), Person.class);
>			
>			builder.column("name").withTextEditor(bindingContext).build(SWT.NONE);
>			builder.column("OS").build(SWT.NONE);
>
>			// Now set the Viewer's input
>			peopleViewer.setInput(new WritableList(viewModel.getPeople(),
>					Person.class));
>
>			for (int i = 0; i < peopleViewer.getTable().getColumnCount(); i++) {
>				peopleViewer.getTable().getColumn(i).setWidth(100);
>			}
>			
>			// bind selectedCommitter label to the name of the current selection
>			IObservableValue selection = ViewersObservables
>					.observeSingleSelection(peopleViewer);
>			bindingContext.bindValue(SWTObservables
>					.observeText(selectedCommitter), BeansObservables
>					.observeDetailValue(Realm.getDefault(), selection, "name",
>							String.class), null, null);
>		}
>	}
>
>	/**
>	 * Model technology agnostic builder for a TableViewerColumn.
>	 */
>	static class TableViewerColumnBuilder {
>		private TableViewer viewer;
>		private TextCellEditor editor;
>		private ObservableFactoryEditingSupport editingSupport;
>		private IObservableFactory modelFactory;
>		private CellLabelProvider labelProvider;
>
>		TableViewerColumnBuilder(TableViewer viewer, IObservableFactory modelFactory, CellLabelProvider labelProvider) {
>			this.viewer = viewer;
>			this.modelFactory = modelFactory;
>			this.labelProvider = labelProvider;
>		}
>		
>		/**
>		 * Creates a new TextCellEditor with the provided <code>dbc</code>.
>		 * 
>		 * @param dbc
>		 * @return builder
>		 */
>		public TableViewerColumnBuilder withTextEditor(DataBindingContext dbc) {
>			IObservableFactory factory = new IObservableFactory() {
>				public IObservable createObservable(Object target) {
>					CellEditor editor = (CellEditor) target;
>
>					return SWTObservables.observeText(editor.getControl(),
>							SWT.NONE);
>				}
>			};
>			
>			editor = new TextCellEditor((Composite) viewer.getControl());
>			return withCellEditor(dbc, editor, factory);
>		}
>		
>		/**
>		 * Employs the provided instances to edit the column.
>		 * 
>		 * @param dbc
>		 * @param editor
>		 * @param factory create IObservableValues for the editor
>		 * @return builder
>		 */
>		public TableViewerColumnBuilder withCellEditor(DataBindingContext dbc, CellEditor editor, IObservableFactory factory) {
>			editingSupport = new ObservableFactoryEditingSupport(viewer, dbc, factory, editor, modelFactory);
>			
>			return this;
>		}
>		
>		/**
>		 * Creates the column.
>		 * 
>		 * @param style column style
>		 * @return table viewer column
>		 */
>		public TableViewerColumn build(int style) {
>			TableViewerColumn column = new TableViewerColumn(viewer, style);
>			column.setLabelProvider(labelProvider);
>			
>			if (editor != null) {
>				column.setEditingSupport(editingSupport);
>			}
>
>			return column;
>		}
>	}
>	
>	/**
>	 * Builder for the creation of columns for bean attributes.
>	 */
>	public static class BeanTableViewerBuilder {
>		private IObservableSet elements;
>
>		private TableViewer viewer;
>		private Class bean;
>
>		public BeanTableViewerBuilder(TableViewer viewer, IObservableSet elements, Class bean) {
>			this.elements = elements;
>			this.viewer = viewer;
>			this.bean = bean;
>		}
>		
>		/**
>		 * Creates a new column builder for the provided <code>property</code>.
>		 * 
>		 * @param property
>		 * @return column builder
>		 */
>		public TableViewerColumnBuilder column(String property) {
>			IObservableFactory factory = BeansObservables.valueFactory(Realm.getDefault(), property);
>			
>			CellLabelProvider labelProvider = new PropertyCellLabelProvider(
>					BeansObservables.observeMap(elements, bean,
>							property));
>			TableViewerColumnBuilder builder = new TableViewerColumnBuilder(viewer, factory, labelProvider);
>			return builder;
>		}
>	}
>
>	/**
>	 * Editing support that uses JFace Data Binding to control the editing
>	 * lifecycle. The standard EditingSupport get/setValue(...) lifecycle is not
>	 * used.
>	 */
>	static class ObservableFactoryEditingSupport extends
>			ObservableValueEditingSupport {
>		private CellEditor cellEditor;
>
>		private IObservableFactory targetFactory;
>
>		private IObservableFactory modelFactory;
>
>		/**
>		 * @param viewer
>		 * @param dbc
>		 */
>		public ObservableFactoryEditingSupport(ColumnViewer viewer,
>				DataBindingContext dbc, IObservableFactory targetFactory,
>				CellEditor cellEditor, IObservableFactory modelFactory) {
>
>			super(viewer, dbc);
>			this.targetFactory = targetFactory;
>			this.cellEditor = cellEditor;
>			this.modelFactory = modelFactory;
>		}
>
>		protected CellEditor getCellEditor(Object element) {
>			return cellEditor;
>		}
>
>		protected IObservableValue doCreateCellEditorObservable(
>				CellEditor cellEditor) {
>
>			return (IObservableValue) targetFactory.createObservable(cellEditor);
>		}
>
>		protected IObservableValue doCreateElementObservable(Object element,
>				ViewerCell cell) {
>			
>			return (IObservableValue) modelFactory.createObservable(element);
>		}
>	}
>	
>	/**
>	 * Label provider for bean attributes.
>	 */
>	public static class PropertyCellLabelProvider extends CellLabelProvider {
>		private IObservableMap map;
>		
>		private IMapChangeListener mapChangeListener = new IMapChangeListener() {
>			public void handleMapChange(MapChangeEvent event) {
>				Set affectedElements = event.diff.getChangedKeys();
>				LabelProviderChangedEvent newEvent = new LabelProviderChangedEvent(
>						PropertyCellLabelProvider.this, affectedElements
>								.toArray());
>				fireLabelProviderChanged(newEvent);
>			}
>		};
>		
>		/**
>		 * @param map
>		 */
>		public PropertyCellLabelProvider(IObservableMap map) {
>			this.map = map;
>			map.addMapChangeListener(mapChangeListener);
>		}
>
>		/* (non-Javadoc)
>		 * @see org.eclipse.jface.viewers.CellLabelProvider#update(org.eclipse.jface.viewers.ViewerCell)
>		 */
>		public void update(ViewerCell cell) {
>			String text = (String) map.get(cell.getElement());
>			cell.setText(text != null ? text : ""); //$NON-NLS-1$
>		}
>	}
>}

Actions: View | Diff

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