eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/featuretree/TermTreeContentProvider.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.featuretree;
  11
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.UUID;
  16
  17 import org.eclipse.jface.viewers.ITreeContentProvider;
  18 import org.eclipse.jface.viewers.Viewer;
  19
  20 import eu.etaxonomy.cdm.model.term.DefinedTermBase;
  21 import eu.etaxonomy.cdm.model.term.TermNode;
  22 import eu.etaxonomy.cdm.model.term.TermTree;
  23 import eu.etaxonomy.cdm.persistence.dto.TermNodeDto;
  24 import eu.etaxonomy.cdm.persistence.dto.TermTreeDto;
  25
  26 /**
  27  * <p>TermTreeContentProvider class.</p>
  28  *
  29  * @author n.hoffmann
  30  * @created Aug 5, 2010
  31  * @version 1.0
  32  */
  33 public class TermTreeContentProvider<T extends DefinedTermBase> implements ITreeContentProvider {
  34
  35     Viewer viewer;
  36     TermNodeDto oldInput;
  37     TermNodeDto newInput;
  38     Map<UUID, TermNodeDto> uuidTermMap = new HashMap<>();
  39
  40         /* (non-Javadoc)
  41          * @see org.eclipse.jface.viewers.IContentProvider#dispose()
  42          */
  43         /** {@inheritDoc} */
  44         @Override
  45         public void dispose() {
  46
  47         }
  48
  49         /* (non-Javadoc)
  50          * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
  51          */
  52         /** {@inheritDoc} */
  53         @Override
  54         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  55             this.viewer = viewer;
  56             if (oldInput instanceof TermNodeDto){
  57                 this.oldInput = (TermNodeDto)oldInput;
  58             }
  59             if (newInput instanceof TermNodeDto){
  60                 this.newInput = (TermNodeDto)newInput;
  61             }
  62             if (oldInput instanceof TermTreeDto){
  63                 this.oldInput = ((TermTreeDto)oldInput).getRoot();
  64             }
  65             if (newInput instanceof TermTreeDto){
  66             this.newInput = ((TermTreeDto)newInput).getRoot();
  67         }
  68
  69         }
  70
  71         /** {@inheritDoc} */
  72         @Override
  73         public Object[] getElements(Object inputElement) {
  74                 return this.getChildren(inputElement);
  75         }
  76
  77         /** {@inheritDoc} */
  78         @Override
  79         public Object[] getChildren(Object parentElement) {
  80             if(parentElement instanceof TermTree){
  81             List<TermNode> children = ((TermTree) parentElement).getRootChildren();
  82             return children.toArray();
  83         }else if(parentElement instanceof TermNode){
  84             List<TermNode> children = ((TermNode) parentElement).getChildNodes();
  85             return children.toArray();
  86         }
  87                 if(parentElement instanceof TermTreeDto){
  88                     if (((TermTreeDto) parentElement).getRoot() != null){
  89                         List<TermNodeDto> children = ((TermTreeDto) parentElement).getRoot().getChildren();
  90                         return children.toArray();
  91                     }
  92                         return new Object[]{};
  93                 }else if(parentElement instanceof TermNodeDto){
  94                         List<TermNodeDto> children = ((TermNodeDto) parentElement).getChildren();
  95                         return children.toArray();
  96                 }else if(parentElement instanceof List){
  97                         return ((List<TermNodeDto>) parentElement).toArray();
  98                 }else{
  99                         return new Object[]{};
 100                 }
 101         }
 102
 103         /** {@inheritDoc} */
 104         @Override
 105         public Object getParent(Object element) {
 106             if(element instanceof TermNode){
 107             return ((TermNode) element).getParent();
 108         }
 109             if(element instanceof TermNodeDto){
 110                 TermNodeDto parent = uuidTermMap.get(((TermNodeDto) element).getParentUuid());
 111                 return parent;
 112             }
 113                 return null;
 114         }
 115
 116         public Map<UUID, TermNodeDto> getUuidTermMap() {
 117         return uuidTermMap;
 118     }
 119
 120         public void setUuidTermMap(Map<UUID, TermNodeDto> uuidTermMap) {
 121         this.uuidTermMap = uuidTermMap;
 122     }
 123
 124
 125     /** {@inheritDoc} */
 126         @Override
 127         public boolean hasChildren(Object element) {
 128                 return getChildren(element).length != 0;
 129         }
 130
 131
 132 }