eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/ui/combo/EnumComboElement.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.ui.combo;
  11
  12 import java.util.ArrayList;
  13 import java.util.Arrays;
  14 import java.util.Collection;
  15 import java.util.Collections;
  16 import java.util.Comparator;
  17 import java.util.LinkedHashMap;
  18 import java.util.List;
  19 import java.util.Map.Entry;
  20
  21 import org.eclipse.swt.events.SelectionEvent;
  22
  23 import eu.etaxonomy.cdm.model.common.IEnumTerm;
  24 import eu.etaxonomy.cdm.model.common.OriginalSourceType;
  25 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  26 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
  27 import eu.etaxonomy.cdm.model.reference.ReferenceType;
  28 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  29 import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
  30 import eu.etaxonomy.taxeditor.ui.element.CdmPropertyChangeEvent;
  31 import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
  32
  33 /**
  34  * @author n.hoffmann
  35  * @created Mar 16, 2010
  36  * @version 1.0
  37  */
  38 public class EnumComboElement<T extends IEnumTerm<T>> extends
  39                 AbstractComboElement<T>  {
  40
  41         //TODO RL
  42         public void setVisible(boolean b){
  43                 combo.setVisible(b);
  44         }
  45
  46
  47         private static CdmEnumDataHolder[] cdmEnumDataHolders = {
  48                 new CdmEnumDataHolder<NomenclaturalCode>(){
  49
  50                         @Override
  51                         public String getName() {
  52                                 return "Nomenclatural Code";
  53                         }
  54
  55                         @Override
  56                         public Collection<NomenclaturalCode> getElements() {
  57                                 return  Arrays.asList(NomenclaturalCode.values());
  58                         }
  59
  60                         @Override
  61                         public Class<NomenclaturalCode> getClazz() {
  62                                 return NomenclaturalCode.class;
  63                         }
  64
  65                 },
  66                 new CdmEnumDataHolder<ReferenceType>(){
  67
  68                         @Override
  69                         public String getName() {
  70                                 return "Reference Type";
  71                         }
  72
  73                         @Override
  74                         public Collection<ReferenceType> getElements() {
  75                                 return Arrays.asList(ReferenceType.values());
  76                         }
  77
  78                         @Override
  79                         public Class<ReferenceType> getClazz() {
  80                                 return ReferenceType.class;
  81                         }
  82
  83                 },
  84                 new CdmEnumDataHolder<SpecimenOrObservationType>(){
  85
  86                         @Override
  87                         public String getName() {
  88                                 return "Specimen / Observation Type";
  89                         }
  90
  91                         @Override
  92                         public Collection<SpecimenOrObservationType> getElements() {
  93                                 return Arrays.asList(SpecimenOrObservationType.values());
  94                         }
  95
  96                         @Override
  97                         public Class<SpecimenOrObservationType> getClazz() {
  98                                 return SpecimenOrObservationType.class;
  99                         }
 100
 101                 },
 102                 new CdmEnumDataHolder<OriginalSourceType>(){
 103
 104                         @Override
 105                         public String getName() {
 106                                 return "Original Source Type";
 107                         }
 108
 109                         @Override
 110                         public Collection<OriginalSourceType> getElements() {
 111                                 return Arrays.asList(OriginalSourceType.values());
 112                         }
 113
 114                         @Override
 115                         public Class<OriginalSourceType> getClazz() {
 116                                 return OriginalSourceType.class;
 117                         }
 118
 119                 }
 120
 121         };
 122
 123         protected List<T> elementTypeList = new ArrayList<T>();
 124
 125         private final Class<T> enumType;
 126
 127         public EnumComboElement(CdmFormFactory formFactory,
 128                         ICdmFormElement parentElement, Class<T> enumType, Comparator<T> comparator, int style) {
 129                 super(formFactory, parentElement);
 130                 this.enumType = enumType;
 131                 label.setText(getDefaultLabelString());
 132
 133                 populateTypes(comparator);
 134
 135                 combo.addSelectionListener(this);
 136         }
 137
 138
 139
 140         private String getDefaultLabelString() {
 141                 if(enumType.equals(ReferenceType.class)){
 142                         return "Reference Type";
 143                 } else if (enumType.equals(NomenclaturalCode.class)){
 144                         return "Nomenclatural Code";
 145                 } else if(enumType.equals(OriginalSourceType.class)) {
 146                         return "Orig. Source Type";
 147                 } else if(enumType.equals(SpecimenOrObservationType.class)) {
 148                         return "Spec./Obs. Type";
 149                 }
 150                 return "No Label";
 151         }
 152
 153     private void populateTypes(Comparator<T> comparator){
 154         List<T> elementsForClass = new ArrayList<T>(getElementsForClass(enumType));
 155         if(comparator!=null){
 156             Collections.sort(elementsForClass, comparator);
 157         }
 158         // special hierarchical order for specimens
 159         if(enumType.equals(SpecimenOrObservationType.class)){
 160             LinkedHashMap<T, String> orderedTerms = AbstractUtility.orderTerms(elementsForClass);
 161             for(Entry<T, String> keyLabelPair : orderedTerms.entrySet()){
 162                 elementTypeList.add(keyLabelPair.getKey());
 163                 combo.add(keyLabelPair.getValue());
 164             }
 165         }
 166         // default order
 167         else{
 168             for(T enumElement : elementsForClass){
 169                 elementTypeList.add(enumElement);
 170                 combo.add(((Enum) enumElement).name());
 171             }
 172         }
 173         }
 174
 175         @Override
 176     public void setSelection(T selection) {
 177                 this.selection = selection;
 178                 combo.select(elementTypeList.indexOf(selection));
 179         }
 180         /** {@inheritDoc} */
 181         @Override
 182     public void widgetSelected(SelectionEvent e) {
 183                 selection = elementTypeList.get(combo.getSelectionIndex());
 184                 firePropertyChangeEvent(new CdmPropertyChangeEvent(this, e));
 185         }
 186
 187         private Collection<T> getElementsForClass(Class<T> clazz){
 188                 CdmEnumDataHolder<T> dataHolder = getCdmEnumDataHolderForClass(clazz);
 189                 if (dataHolder != null) {
 190                         return dataHolder.getElements();
 191                 }
 192                 return null;
 193         }
 194
 195         private CdmEnumDataHolder<T> getCdmEnumDataHolderForClass(Class<T> clazz){
 196                 for (CdmEnumDataHolder dataHolder : cdmEnumDataHolders) {
 197                         if (dataHolder.getClazz().equals(clazz)){
 198                                 return dataHolder;
 199                         }
 200                 }
 201                 return null;
 202         }
 203
 204         private interface CdmEnumDataHolder<T> {
 205                 Class<T> getClazz();
 206                 String getName();
 207                 Collection<T> getElements();
 208         }
 209 }