Created
February 10, 2012 06:18
-
-
Save nikolaykasyanov/1787145 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/******************************************************************************* | |
* Copyright (c) 2006, 2009 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 | |
* Matthew Hall - bugs 260329, 260337 | |
******************************************************************************/ | |
package test; | |
import java.beans.PropertyChangeListener; | |
import java.beans.PropertyChangeSupport; | |
import java.util.LinkedList; | |
import java.util.List; | |
import org.eclipse.core.databinding.DataBindingContext; | |
import org.eclipse.core.databinding.beans.BeansObservables; | |
import org.eclipse.core.databinding.observable.Realm; | |
import org.eclipse.core.databinding.observable.list.WritableList; | |
import org.eclipse.core.databinding.observable.map.IObservableMap; | |
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.ObservableMapCellLabelProvider; | |
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.ColumnViewer; | |
import org.eclipse.jface.viewers.ILabelProviderListener; | |
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.Viewer; | |
import org.eclipse.jface.viewers.ViewerCell; | |
import org.eclipse.jface.viewers.ViewerComparator; | |
import org.eclipse.swt.SWT; | |
import org.eclipse.swt.events.SelectionAdapter; | |
import org.eclipse.swt.events.SelectionEvent; | |
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 TableWithDatabinding { | |
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"; | |
public Person(String name) { | |
this.name = name; | |
} | |
public String getName() { | |
return name; | |
} | |
public void setName(String name) { | |
String oldValue = this.name; | |
this.name = name; | |
firePropertyChange("name", oldValue, name); | |
} | |
} | |
// 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<Person> people = new LinkedList<Person>(); | |
{ | |
people.add(new Person("Steve Northover")); | |
people.add(new Person("Grant Gayed")); | |
people.add(new Person("Veronika Irvine")); | |
people.add(new Person("Mike Wilson")); | |
people.add(new Person("Christophe Cornu")); | |
people.add(new Person("Lynne Kues")); | |
people.add(new Person("Silenio Quarti")); | |
} | |
public List<Person> getPeople() { | |
return people; | |
} | |
} | |
/** | |
* Editing support that uses JFace Data Binding to control the editing | |
* lifecycle. The standard EditingSupport get/setValue(...) lifecycle is not | |
* used. | |
* | |
* @since 3.3 | |
*/ | |
private static class InlineEditingSupport extends | |
ObservableValueEditingSupport { | |
private CellEditor cellEditor; | |
/** | |
* @param viewer | |
* @param dbc | |
*/ | |
public InlineEditingSupport(ColumnViewer viewer, DataBindingContext dbc) { | |
super(viewer, dbc); | |
cellEditor = new TextCellEditor((Composite) viewer.getControl()); | |
} | |
protected CellEditor getCellEditor(Object element) { | |
return cellEditor; | |
} | |
protected IObservableValue doCreateCellEditorObservable( | |
CellEditor cellEditor) { | |
return SWTObservables.observeText(cellEditor.getControl(), | |
SWT.Modify); | |
} | |
protected IObservableValue doCreateElementObservable(Object element, | |
ViewerCell cell) { | |
return BeansObservables.observeValue(element, "name"); | |
} | |
} | |
public static class TableSorter extends ViewerComparator { | |
private int direction = 1; | |
@Override | |
public int compare(Viewer viewer, Object e1, Object e2) { | |
Person p1 = (Person) e1; | |
Person p2 = (Person) e2; | |
return direction * getComparator().compare(p1.name, p2.name); | |
} | |
@Override | |
public boolean isSorterProperty(Object element, String property) { | |
return true; | |
} | |
public void invertDirection() { | |
direction = direction == 1 ? -1 : 1; | |
} | |
public int getDirection() { | |
return direction; | |
} | |
} | |
// 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 | SWT.VIRTUAL); | |
committers.setLinesVisible(true); | |
committers.setHeaderVisible(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(200, 300); | |
shell.open(); | |
return shell; | |
} | |
protected void bindGUI(DataBindingContext bindingContext) { | |
// Since we're using a JFace Viewer, we do first wrap our Table... | |
final TableViewer peopleViewer = new TableViewer(committers); | |
TableViewerColumn column = new TableViewerColumn(peopleViewer, | |
SWT.NONE); | |
column.setEditingSupport(new InlineEditingSupport(peopleViewer, | |
bindingContext)); | |
column.getColumn().setWidth(190); | |
committers.setSortColumn(column.getColumn()); | |
committers.setSortDirection(SWT.UP); | |
final TableSorter ts = new TableSorter(); | |
column.getColumn().addSelectionListener(new SelectionAdapter() { | |
@Override | |
public void widgetSelected(SelectionEvent e) { | |
ts.invertDirection(); | |
committers.setSortDirection(ts.getDirection() == 1 ? SWT.UP : SWT.DOWN); | |
peopleViewer.refresh(); | |
} | |
}); | |
peopleViewer.setComparator(ts); | |
ObservableListContentProvider cp = new ObservableListContentProvider(); | |
IObservableMap nameMap = BeansObservables.observeMap(cp.getKnownElements(), "name"); | |
ObservableMapCellLabelProvider lp = new ObservableMapCellLabelProvider(nameMap); | |
lp.addListener(new ILabelProviderListener() { | |
@Override | |
public void labelProviderChanged(LabelProviderChangedEvent event) { | |
peopleViewer.update(event.getElements(), new String[] {"name"}); | |
//peopleViewer.refresh(); | |
} | |
}); | |
column.setLabelProvider(lp); | |
peopleViewer.setContentProvider(cp); | |
peopleViewer.setInput(new WritableList(viewModel | |
.getPeople(), Person.class)); | |
// Bind viewer to model | |
// ViewerSupport.bind(peopleViewer, new WritableList(viewModel | |
// .getPeople(), Person.class), BeanProperties.value( | |
// Person.class, "name")); | |
// bind selectedCommitter label to the name of the current selection | |
IObservableValue selection = ViewersObservables | |
.observeSingleSelection(peopleViewer); | |
bindingContext.bindValue(SWTObservables | |
.observeText(selectedCommitter), BeansObservables | |
.observeDetailValue(selection, "name", String.class)); | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment