eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/model/TaxonomicTreeContentProvider.java

   1 /**
   2  * Copyright (C) 2007 EDIT
   3  * European Distributed Institute of Taxonomy
   4  * http://www.e-taxonomy.eu
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version 1.1
   7  * See LICENSE.TXT at the top of this package for the full license terms.
   8  */
   9
  10 package eu.etaxonomy.taxeditor.model;
  11
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.List;
  15 import java.util.Set;
  16
  17 import org.apache.log4j.Logger;
  18 import org.eclipse.core.databinding.observable.set.IObservableSet;
  19 import org.eclipse.core.databinding.observable.set.ISetChangeListener;
  20 import org.eclipse.core.databinding.observable.set.SetChangeEvent;
  21 import org.eclipse.jface.viewers.ITreeContentProvider;
  22 import org.eclipse.jface.viewers.TreeViewer;
  23 import org.eclipse.jface.viewers.Viewer;
  24
  25 import eu.etaxonomy.cdm.model.taxon.Taxon;
  26 import eu.etaxonomy.taxeditor.TaxEditorPlugin;
  27
  28 /**
  29  * An implementation of ITreeContentProvider which adds taxa displayed in the tree
  30  *  to the Editor session on an as-loaded basis. Listens for any changes to the
  31  *  set of session taxa, updates the TreeViewer accordingly.
  32  * <p>
  33  * Could be re-written to implement ILazyTreeContentProvider at some point in the future.
  34  *  NO: sorting not possible with lazy tree.
  35  *
  36  * @author p.ciardelli
  37  * @created 28.05.2008
  38  * @version 1.0
  39  */
  40 public class TaxonomicTreeContentProvider implements ITreeContentProvider {
  41         private static final Logger logger = Logger
  42                         .getLogger(TaxonomicTreeContentProvider.class);
  43
  44         TreeViewer viewer;
  45
  46         /* (non-Javadoc)
  47          * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
  48          */
  49         @Override
  50         public Object[] getChildren(Object parentElement) {
  51                 if (!(parentElement instanceof Taxon)) {
  52                         logger.error("Method getChildren() expects a parentElement of type Taxon");
  53                         return new Object[0];
  54                 }
  55
  56                 Taxon parentTaxon = (Taxon) parentElement;
  57
  58                 // If this does not return null, the taxon's children have already
  59                 //      been requested during this session
  60                 Set<Taxon> childTaxa = TaxEditorPlugin.getDefault()
  61                                 .getSessionTaxonomicChildren(parentTaxon);
  62                 if (childTaxa == null) {
  63
  64                         removeSessionTaxaListener();
  65
  66                         // Request this taxon's children for the first time
  67                         //      during this session
  68                         childTaxa = parentTaxon.getTaxonomicChildren();
  69                         TaxEditorPlugin.getDefault().addSessionTaxa(childTaxa);
  70
  71                         addSessionTaxaListener();
  72                 }
  73
  74                 logger.warn("returning " + childTaxa.toString());
  75                 return childTaxa.toArray();
  76         }
  77
  78         @Override
  79         public Object getParent(Object element) {
  80                 if (!(element instanceof Taxon)) {
  81                         return null;
  82                 }
  83                 return ((Taxon) element).getTaxonomicParent();
  84         }
  85
  86         @Override
  87         public boolean hasChildren(Object element) {
  88                 if (!(element instanceof Taxon)) {
  89                         return false;
  90                 }
  91                 return ((Taxon) element).hasTaxonomicChildren();
  92         }
  93
  94         @Override
  95         public Object[] getElements(Object inputElement) {
  96 //              logger.warn("Get elements for " + inputElement.toString() + " with class " + inputElement.getClass());
  97 //              List elements = new ArrayList();
  98 //              if (inputElement instanceof Collection) {
  99 //                      logger.warn("instanceof collection");
 100 ////                    elements.addAll((Collection) inputElement);
 101 //                      for (Object parentElement : (Collection) inputElement) {
 102 //                              if (parentElement instanceof Taxon) {
 103 //                                      for (Object childElement : getChildren(parentElement)) {
 104 //                                              elements.add(childElement);
 105 //                                      }
 106 //                              }
 107 //                      }
 108 //              }
 109 ////            return TaxEditorPlugin.getDefault().getSessionRootTaxa().toArray();
 110 ////            return getChildren(inputElement);
 111 //              logger.warn("elements have " + elements.size());
 112 //              return elements.toArray();
 113                 return null;
 114         }
 115
 116         @Override
 117         public void dispose() {
 118                 removeSessionTaxaListener();
 119         }
 120
 121         @Override
 122         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 123                 if (!(viewer instanceof TreeViewer)) {
 124                         throw new IllegalArgumentException(
 125                                         "This content provider only works with viewer of type TreeViewer"); //$NON-NLS-1$
 126                 }
 127                 this.viewer = (TreeViewer) viewer;
 128
 129                 if (newInput != null && !(newInput instanceof Collection)) {
 130                         throw new IllegalArgumentException(
 131                                         "This content provider only works with input of type Collection<Taxon>"); //$NON-NLS-1$
 132                 }
 133
 134                 try {
 135                         Collection<Taxon> input = (Collection<Taxon>) newInput;
 136                         setInput(input);
 137                 } catch (ClassCastException e) {
 138                         throw new IllegalArgumentException(
 139                                 "This content provider only works with input of type Collection<Taxon>"); //$NON-NLS-1$
 140                 }
 141         }
 142
 143         private void setInput(Collection<Taxon> input) {
 144
 145                 removeSessionTaxaListener();
 146
 147                 if (input != null) {
 148                         TaxEditorPlugin.getDefault().addSessionTaxa(input);
 149                 }
 150
 151                 addSessionTaxaListener();
 152         }
 153
 154         private IObservableSet getObservableSessionTaxonSet() {
 155                 return TaxEditorPlugin.getDefault().getObservableSessionTaxa();
 156         }
 157
 158         private void addSessionTaxaListener() {
 159                 getObservableSessionTaxonSet().addSetChangeListener(listener);
 160         }
 161
 162         private void removeSessionTaxaListener() {
 163                 getObservableSessionTaxonSet().removeSetChangeListener(listener);
 164         }
 165
 166         private ISetChangeListener listener = new ISetChangeListener() {
 167                 @Override
 168                 public void handleSetChange(SetChangeEvent event) {
 169                         if (viewer.getControl().isDisposed()) {
 170                                 return;
 171                         }
 172                         for (Object addition : event.diff.getAdditions()) {
 173                                 if (addition instanceof Taxon) {
 174                                         Taxon taxon = (Taxon) addition;
 175                                         Taxon parentTaxon = taxon.getTaxonomicParent();
 176                                         if (parentTaxon == null) {
 177
 178                                                 // If a new root item has been added,
 179                                                 //  set it as the viewer's input
 180                                                 List<Taxon> newInput = new ArrayList<Taxon>();
 181                                                 newInput.add(taxon);
 182                                                 viewer.setInput(newInput);
 183 //                                              viewer.setInput(TaxEditorPlugin.getDefault().getSessionRootTaxa());
 184                                         } else {
 185                                                 viewer.add(parentTaxon, taxon);
 186                                         }
 187                                 }
 188                         }
 189                         for (Object removal : event.diff.getRemovals()) {
 190                                 if (removal instanceof Taxon) {
 191                                         Taxon taxon = (Taxon) removal;
 192                                         viewer.remove(taxon);
 193                                 }
 194                         }
 195 //                      viewer.getControl().setRedraw(true);
 196                         viewer.refresh();
 197                 }
 198         };
 199 }