eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/prototype2/model/NameTreeContentProvider.java

   1 package eu.etaxonomy.taxeditor.prototype2.model;
   2
   3 import java.util.Set;
   4
   5 import org.eclipse.core.databinding.observable.Realm;
   6 import org.eclipse.core.databinding.observable.list.IListChangeListener;
   7 import org.eclipse.core.databinding.observable.list.IObservableList;
   8 import org.eclipse.core.databinding.observable.list.ListChangeEvent;
   9 import org.eclipse.core.databinding.observable.list.ListDiffEntry;
  10 import org.eclipse.core.databinding.observable.list.WritableList;
  11 import org.eclipse.core.databinding.observable.set.IObservableSet;
  12 import org.eclipse.core.databinding.observable.set.WritableSet;
  13 import org.eclipse.core.runtime.Assert;
  14 import org.eclipse.jface.databinding.swt.SWTObservables;
  15 import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
  16 import org.eclipse.jface.viewers.ITreeContentProvider;
  17 import org.eclipse.jface.viewers.Viewer;
  18 import org.eclipse.swt.widgets.Display;
  19
  20 import eu.etaxonomy.cdm.model.taxon.Taxon;
  21 import eu.etaxonomy.taxeditor.prototype2.view.TaxonomicTreeViewer;
  22
  23 /**
  24  * Adds tree functionality (get parent, get children) to ObservableListContentProvider;
  25  *  much code was copied almost in tact from parent class due to
  26  *  viewer type restrictions and private settings of variables and methods
  27  *
  28  * @author p.ciardelli
  29  *
  30  */
  31 public class NameTreeContentProvider extends ObservableListContentProvider
  32                 implements ITreeContentProvider {
  33
  34         public Object[] getChildren(Object parentElement) {
  35                 Set<Taxon> children = ((Taxon) parentElement).getTaxonomicChildren();
  36                 observableList.addAll(children);
  37                 return children == null ? new Object[0] : children.toArray();
  38         }
  39
  40         public Object getParent(Object element) {
  41                 return ((Taxon) element).getTaxonomicParent();
  42         }
  43
  44         public boolean hasChildren(Object element) {
  45                 return ((Taxon) element).hasTaxonomicChildren();
  46         }
  47
  48         private IObservableList observableList;
  49
  50         private Viewer viewer;
  51
  52         private IListChangeListener listener = new IListChangeListener() {
  53                 public void handleListChange(ListChangeEvent event) {
  54                         if (viewer.getControl().isDisposed()) {
  55                                 return;
  56                         }
  57                         ListDiffEntry[] differences = event.diff.getDifferences();
  58                         for (int i = 0; i < differences.length; i++) {
  59                                 ListDiffEntry entry = differences[i];
  60
  61                                 if (entry.isAddition()) {
  62
  63                                         knownElements.add(entry.getElement());
  64
  65                                         ((TaxonomicTreeViewer) viewer).add(
  66                                                         ((Taxon) entry.getElement()).getTaxonomicParent(),
  67                                                         entry.getElement());
  68                                 } else {
  69
  70                                         knownElements.remove(entry.getElement());
  71
  72                                         ((TaxonomicTreeViewer) viewer).remove(entry.getElement());
  73                                 }
  74                         }
  75                 }
  76         };
  77
  78         private IObservableSet knownElements;
  79
  80         /**
  81          *
  82          */
  83         public NameTreeContentProvider() {
  84
  85                 Assert.isNotNull(Realm.getDefault());
  86
  87                 observableList = new WritableList(SWTObservables.getRealm(Display.getDefault()));
  88                 knownElements = new WritableSet(SWTObservables.getRealm(Display.getDefault()));
  89         }
  90
  91         public Object[] getElements(Object inputElement) {
  92                 return observableList.toArray();
  93         }
  94
  95         public void dispose() {
  96                 observableList.removeListChangeListener(listener);
  97         }
  98
  99         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 100                 this.viewer = viewer;
 101
 102                 if (newInput != null && !(newInput instanceof IObservableList)) {
 103                         throw new IllegalArgumentException(
 104                                         "This content provider only works with input of type IObservableList"); //$NON-NLS-1$
 105                 }
 106
 107                 setInput((IObservableList) newInput);
 108         }
 109
 110         /**
 111          * @param list
 112          */
 113         private void setInput(IObservableList list) {
 114
 115                 if (list == null) {
 116                         list = new WritableList(SWTObservables.getRealm(Display.getDefault()));
 117                 }
 118
 119                 if (observableList != null) {
 120                         observableList.removeListChangeListener(listener);
 121                 }
 122
 123                 knownElements.clear();
 124
 125                 observableList = list;
 126
 127                 knownElements.addAll(list);
 128
 129
 130                 observableList.addListChangeListener(listener);
 131         }
 132
 133         /**
 134          * @return the set of elements known to this content provider. Label providers may track
 135          * this set if they need to be notified about additions before the viewer sees the added
 136          * element, and notified about removals after the element was removed from the viewer.
 137          */
 138         public IObservableSet getKnownElements() {
 139                 return knownElements;
 140         }
 141 }