public void createPartControl(Composite parent) {
		Composite container = new Composite(parent, SWT.NONE);
		container.setLayout(new GridLayout(1, false));

		Composite treeComposite = new Composite(container, SWT.NONE);
		treeComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
		treeComposite.setLayout(new FillLayout());

		createInitialModel();

		treeViewer = new TreeViewer(treeComposite);

		ObservableListTreeContentProvider cp = new ObservableListTreeContentProvider(
				new DataModelTreeFactory(), null);

		treeViewer.setContentProvider(cp);

		IObservableSet knownElementSet = cp.getKnownElements();
		IObservableMap[] map = new IObservableMap[3];

		map[0] = EMFProperties.value(
				ModelPackage.Literals.BRANCH__NAME
				).observeDetail(knownElementSet);

		map[1] = EMFProperties.value(
				ModelPackage.Literals.LEAF__NAME
				).observeDetail(knownElementSet);

		map[2] = EMFProperties.value(
				ModelPackage.Literals.SINGLE_ITEM__NAME
				).observeDetail(knownElementSet);


		treeViewer.setLabelProvider(new TestModelLabelProvider(treeViewer, map));

		treeViewer.addDoubleClickListener(new IDoubleClickListener() {
			public void doubleClick(DoubleClickEvent event) {
				Object selection = ((IStructuredSelection) treeViewer
						.getSelection()).getFirstElement();
				treeViewer.setExpandedState(selection,
						!treeViewer.getExpandedState(selection));
			}
		});


		treeViewer.setInput(root);
	}

	private void createInitialModel(){
		root = ModelFactory.eINSTANCE.createRoot();
		root.setName("root");
		Branch branch1 = ModelFactory.eINSTANCE.createBranch();
		branch1.setName("branch1");
		root.getBranches().add(branch1);
		Leaf leaf1 = ModelFactory.eINSTANCE.createLeaf();
		leaf1.setName("Leaf1");
		branch1.getLeaves().add(leaf1);
		SingleItem singleItem = ModelFactory.eINSTANCE.createSingleItem();
		singleItem.setName("item1");
		leaf1.setSingleItem(singleItem);

	}

public class DataModelTreeFactory implements IObservableFactory {

	private IEMFListProperty rootNodes = EMFProperties.list(
			   ModelPackage.Literals.ROOT__BRANCHES);

	private IEMFListProperty branchNodes = EMFProperties.list(
			   ModelPackage.Literals.BRANCH__LEAVES);

	private IEMFListProperty leafNodes = EMFProperties.list(
			   ModelPackage.Literals.LEAF__SINGLE_ITEM);
	
	@Override
	public IObservable createObservable(Object target) {
		System.out.println("target instanceof " + target.getClass());		
		if (target instanceof IObservableList){
	      return (IObservable)target;
	    } else if (target instanceof Root) {
	    	return rootNodes.observe(target);
	    } else if (target instanceof Branch) {
	    	return branchNodes.observe(target);
	    } else if (target instanceof Leaf) {
	    	return leafNodes.observe(target);
	    } 
		return null;
	}
}

				SingleItem item = modelFactory.createSingleItem();
				item.setName("Item");
				leaf.setSingleItem(item);

  public abstract static class EMFValuePropertyListener extends EMFPropertyListener
  {
    @Override
    public void notifyChanged(Notification msg)
    {
      if (getFeature() == msg.getFeature() && !msg.isTouch())
      {
        getListener().handleEvent(

package emftest.app;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.WritableList;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
import org.eclipse.emf.databinding.EMFProperties;
import org.eclipse.emf.databinding.IEMFListProperty;
import org.eclipse.emf.databinding.IEMFValueProperty;

import EMFTest.model.Branch;
import EMFTest.model.Leaf;
import EMFTest.model.ModelPackage;
import EMFTest.model.Root;

public class DataModelTreeFactory implements IObservableFactory {

	private IEMFListProperty rootNodes = EMFProperties.list(
			   ModelPackage.Literals.ROOT__BRANCHES);

	private IEMFListProperty branchNodes = EMFProperties.list(
			   ModelPackage.Literals.BRANCH__LEAVES);

	private IEMFValueProperty LEAF__SINGLE_ITEM = EMFProperties.value(
			   ModelPackage.Literals.LEAF__SINGLE_ITEM);

	private IEMFValueProperty LEAF__SINGLE_ITEM2 = EMFProperties.value(
			   ModelPackage.Literals.LEAF__SINGLE_ITEM2);

	
	@Override
	public IObservable createObservable(Object target) {
		System.out.println("target instanceof " + target.getClass());		
		if (target instanceof IObservableList){
	      return (IObservable)target;
	    } else if (target instanceof Root) {
	    	return rootNodes.observe(target);
	    } else if (target instanceof Branch) {
	    	return branchNodes.observe(target);
	    } else if (target instanceof Leaf) {
	    	final WritableList singleItemWritableList = new WritableList();
	    	
			if (((Leaf) target).getSingleItem() != null) {
				singleItemWritableList.add(0, ((Leaf) target).getSingleItem());
			}
			if (((Leaf) target).getSingleItem2() != null) {
				singleItemWritableList.add(0, ((Leaf) target).getSingleItem2());
			}

	    	LEAF__SINGLE_ITEM.observe(
	    			target).addValueChangeListener(new IValueChangeListener() {
	    				public void handleValueChange(ValueChangeEvent event) {
	    					if (event.diff.getOldValue() != null) {
	    						singleItemWritableList.remove(event.diff.getOldValue());
	    					}
	    					if (event.diff.getNewValue() != null) {
	    						singleItemWritableList.add(0, event.diff.getNewValue());
	    					}
	    				}
	    			});
	    	LEAF__SINGLE_ITEM2.observe(
	    			target).addValueChangeListener(new IValueChangeListener() {
	    				public void handleValueChange(ValueChangeEvent event) {
	    					if (event.diff.getOldValue() != null) {
	    						singleItemWritableList.remove(event.diff.getOldValue());
	    					}
	    					if (event.diff.getNewValue() != null) {
	    						singleItemWritableList.add(0, event.diff.getNewValue());
	    					}
	    				}
	    			});

	    	return singleItemWritableList;

	    } 
		return null;
	}
}

public class ValuePropertyList extends WritableList {
	ArrayList<IObservableValue> observableValues = new ArrayList<IObservableValue>();
	IEMFValueProperty [] valueProperties;
	
	public ValuePropertyList(EStructuralFeature... features) {
		valueProperties = new IEMFValueProperty [features.length];
		int i = 0;
		for (EStructuralFeature feature : features) {
			valueProperties[i++] = EMFProperties.value(feature);
		}
	}

	public WritableList observe(Object target){
		for (IEMFValueProperty valueProperty : valueProperties) {
			observeProperty(target,valueProperty);
		}
		return this;
	}
	
	private void observeProperty(Object target,IEMFValueProperty valueProperty){
		Object singleValue = ((EObject)target).eGet(
				(EStructuralFeature)valueProperty.getValueType());
		if (singleValue != null) {
			add(0, singleValue);
		}
		IObservableValue observableValue = valueProperty.observe(target);
		observableValue.addValueChangeListener(new IValueChangeListener() {
			public void handleValueChange(ValueChangeEvent event) {
				if (event.diff.getOldValue() != null) {
					remove(event.diff.getOldValue());
				}
				if (event.diff.getNewValue() != null) {
					add(0, event.diff.getNewValue());
				}
			}
		});
	   observableValues.add(observableValue);
	}

	@Override
	public synchronized void dispose() {
    	   for (IObservableValue observableValue : observableValues) {
    		System.out.println("disposing " + observableValue.toString() );
    		observableValue.dispose();
    	   }		
	   super.dispose();
	}
}

public class DataModelTreeFactory implements IObservableFactory {

	private IEMFListProperty rootNodes = EMFProperties.list(
			   ModelPackage.Literals.ROOT__BRANCHES);

	private IEMFListProperty branchNodes = EMFProperties.list(
			   ModelPackage.Literals.BRANCH__LEAVES);
	
	@Override
	public IObservable createObservable(Object target) {
		if (target instanceof IObservableList){
	      return (IObservable)target;
	    } else if (target instanceof Root) {
	    	return rootNodes.observe(target);
	    } else if (target instanceof Branch) {
	    	return branchNodes.observe(target);
	    } else if (target instanceof Leaf) {
	    	return new ValuePropertyList(
	    			ModelPackage.Literals.LEAF__SINGLE_ITEM,
	    			ModelPackage.Literals.LEAF__SINGLE_ITEM2).
	    			observe(target);
	    } 
		return null;
	}
}