Attachment 62828 Details for Bug 180799 – The snippet proposed

The snippet proposed

SnippetDirty.java (text/plain), 9.90 KB, created by Nicolas Jouanin

on 2007-04-03 16:37:38 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Nicolas Jouanin

Created: 2007-04-03 16:37:38 EDT

Size: 9.90 KB

patch

obsolete

>import java.beans.PropertyChangeListener;
>import java.beans.PropertyChangeSupport;
>import java.util.Iterator;
>import java.util.LinkedList;
>import java.util.List;
>
>import org.eclipse.core.databinding.Binding;
>import org.eclipse.core.databinding.DataBindingContext;
>import org.eclipse.core.databinding.beans.BeansObservables;
>import org.eclipse.core.databinding.observable.ChangeEvent;
>import org.eclipse.core.databinding.observable.IChangeListener;
>import org.eclipse.core.databinding.observable.Realm;
>import org.eclipse.core.databinding.observable.list.IListChangeListener;
>import org.eclipse.core.databinding.observable.list.ListChangeEvent;
>import org.eclipse.core.databinding.observable.list.ListDiff;
>import org.eclipse.core.databinding.observable.list.ListDiffEntry;
>import org.eclipse.core.databinding.observable.list.WritableList;
>import org.eclipse.core.databinding.observable.map.IObservableMap;
>import org.eclipse.core.databinding.observable.value.WritableValue;
>import org.eclipse.jface.databinding.swt.SWTObservables;
>import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
>import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider;
>import org.eclipse.jface.viewers.IStructuredSelection;
>import org.eclipse.jface.viewers.TableViewer;
>import org.eclipse.swt.SWT;
>import org.eclipse.swt.events.SelectionAdapter;
>import org.eclipse.swt.events.SelectionEvent;
>import org.eclipse.swt.layout.GridData;
>import org.eclipse.swt.layout.GridLayout;
>import org.eclipse.swt.widgets.Button;
>import org.eclipse.swt.widgets.Display;
>import org.eclipse.swt.widgets.Label;
>import org.eclipse.swt.widgets.Shell;
>import org.eclipse.swt.widgets.Table;
>import org.eclipse.swt.widgets.Text;
>
>
>public class SnippetDirty {
>	public static void main(String[] args) {
>		ViewModel viewModel = new ViewModel();
>		Shell shell = new View(viewModel).createShell();
>
>		// The SWT event loop
>		Display display = Display.getCurrent();
>		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);
>		}
>	}
>	static String someOtherProperty = new String();  
>
>	// 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"));
>			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 getPeople() {
>			return people;
>		}
>	}
>
>	// The GUI view
>	//implements IChangeListener , to listener to model changes
>	static class View 
>		implements IChangeListener {
>		private ViewModel viewModel;
>		private Table committers;
>		private Button delButton;
>		private Text somePropertyText;
>		private Text msgText;
>		private int nb = 0;
>
>		//Binding list change listener
>		//Watch for binding list changes and register or remove IChangeListeners
>		private IListChangeListener bindingsListener = new IListChangeListener() {
>			public void handleListChange(ListChangeEvent event) {
>				ListDiff diff = event.diff;
>				ListDiffEntry[] differences = diff.getDifferences();
>				for (int i = 0; i < differences.length; i++) {
>					ListDiffEntry listDiffEntry = differences[i];
>					Binding binding = (Binding) listDiffEntry.getElement();
>					if (listDiffEntry.isAddition()) {
>						binding.getTarget().addChangeListener(View.this);
>					} else {
>						binding.getTarget().removeChangeListener(View.this);
>					}
>				}
>			}
>		};		
>
>		public View(ViewModel viewModel) {
>			this.viewModel = viewModel;
>		}
>
>		public Shell createShell() {
>			// Build a UI
>			Display display = Display.getDefault();
>			Shell shell = new Shell(display);
>			GridLayout layout = new GridLayout();
>			layout.numColumns = 1;
>			shell.setLayout(layout);
>			committers = new Table(shell, SWT.BORDER | SWT.FULL_SELECTION);
>			committers.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 2));
>			committers.setLinesVisible(true);
>		
>			delButton = new Button(shell, SWT.NONE);
>			delButton.setText("Remove person");
>			
>			Label lab = new Label(shell,SWT.NONE);
>			lab.setText("Some other model property:");
>			lab.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));
>			
>			somePropertyText = new Text(shell, SWT.NONE);
>			somePropertyText.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));
>			
>			Label lab2 = new Label(shell,SWT.NONE);
>			lab2.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));
>
>			msgText = new Text(shell, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI);
>			msgText.setEnabled(false);
>			msgText.setEditable(false);
>			GridData data = new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1);
>			data.heightHint = 50;
>			msgText.setLayoutData(data);
>
>			// 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.
>			Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
>				public void run() {
>					DataBindingContext bindingContext = new DataBindingContext();
>					bindGUI(bindingContext);
>				}
>			});
>
>			// Open and return the Shell
>			shell.pack();
>			shell.open();
>			return shell;
>		}
>
>		protected void bindGUI(DataBindingContext bindingContext) {
>			final TableViewer peopleViewer = new TableViewer(committers);
>
>			//Table binding
>			final WritableList observablePeople = new WritableList(viewModel.getPeople(), Person.class); 
>			final WritableList targetPeople = new WritableList(); 
>			
>			//Bind target list with model list
>			//targetPeople is set as the viewer input.
>			//Any change made by the user to the targetPeople will be automatically made by binding to 
>			//observablePeople.
>			bindingContext.bindList(targetPeople, observablePeople, null, null);
>
>			//Table viewer providers stuffs
>			ObservableListContentProvider peopleViewerContentProvider = 
>				new ObservableListContentProvider();
>			peopleViewer.setContentProvider(peopleViewerContentProvider);
>			
>			IObservableMap[] attributeMaps = BeansObservables.observeMaps(
>					peopleViewerContentProvider.getKnownElements(), Person.class,
>					new String[] { "name" });
>			peopleViewer.setLabelProvider(new ObservableMapLabelProvider(attributeMaps));
>			//Set target list as input
>			peopleViewer.setInput(targetPeople);
>
>			//remove people button pressed listener
>			delButton.addSelectionListener(new SelectionAdapter() {
>				@Override
>				public void widgetSelected(SelectionEvent e) {
>					IStructuredSelection selection = (IStructuredSelection)peopleViewer.getSelection();
>					if(!selection.isEmpty()) {
>						for(Object selectionItem : selection.toArray()) {
>							if(selectionItem instanceof Person) {
>								//Remove selected item from target list
>								//Note that dirty state should be set here
>								//Because of registered IChangeListener, this is done automatically
>								targetPeople.remove(selectionItem);
>							}
>						}
>					}
>				}			
>			});
>
>			//some other property binding
>			bindingContext.bindValue(
>					SWTObservables.observeText(somePropertyText, SWT.Modify), 
>					new WritableValue(someOtherProperty, null),
>					null,
>					null);
>			
>			//Listen to target changes to report dirty state
>			//Binding list is iterated and each binding is added this class a change listener
>			//handleChange will be called when any binded object changes
>			bindingContext.getBindings().addListChangeListener(bindingsListener);
>			for (Iterator it = bindingContext.getBindings().iterator(); it.hasNext();) {
>				Binding binding = (Binding) it.next();
>				binding.getTarget().addChangeListener(this);
>			}
>		}
>
>		public void handleChange(ChangeEvent event) {
>			// report dirty
>			//setDirty(true);
>			//firePropertyChange(PROP!DIRTY);
>			msgText.append("[" + nb ++ + "] dirty state fired !! \n");
>			
>		}
>		
>		//Dispose method sample
>//		public void dispose()
>//		{
>//			for (Iterator it = bindingContext.getBindings().iterator(); it.hasNext();) {
>//				Binding binding = (Binding) it.next();
>//				binding.getTarget().removeChangeListener(this);
>//			}
>//			bindingContext.getBindings().removeListChangeListener(bindingsListener);
>//			super.dispose();
>//		}
>	}
>
>
>}

Actions: View

Attachments on bug 180799: 62828