eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/ui/mvc/combo/EnumTermComboController.java

   1 /**
   2  * Copyright (C) 2014 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 package eu.etaxonomy.taxeditor.ui.mvc.combo;
  10
  11 import java.util.ArrayList;
  12 import java.util.Arrays;
  13 import java.util.Collection;
  14 import java.util.LinkedHashMap;
  15 import java.util.List;
  16 import java.util.Map.Entry;
  17
  18 import org.eclipse.swt.events.SelectionEvent;
  19 import org.eclipse.swt.events.SelectionListener;
  20 import org.eclipse.swt.graphics.Color;
  21 import org.eclipse.swt.widgets.Combo;
  22 import org.eclipse.swt.widgets.Composite;
  23
  24 import eu.etaxonomy.cdm.model.term.IEnumTerm;
  25 import eu.etaxonomy.cdm.model.reference.OriginalSourceType;
  26 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  27 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
  28 import eu.etaxonomy.cdm.model.reference.ReferenceType;
  29 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  30 import eu.etaxonomy.taxeditor.preference.Resources;
  31 import eu.etaxonomy.taxeditor.store.StoreUtil;
  32 import eu.etaxonomy.taxeditor.ui.element.AbstractCdmFormElement;
  33 import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
  34 import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
  35 import eu.etaxonomy.taxeditor.ui.element.IEnableableFormElement;
  36 import eu.etaxonomy.taxeditor.ui.element.ISelectable;
  37 import eu.etaxonomy.taxeditor.ui.mvc.interfaces.CdmCompositeController;
  38
  39 /**
  40  * @author pplitzner
  41  * @date 29.01.2014
  42  *
  43  */
  44 public class EnumTermComboController<T extends IEnumTerm<T>> extends AbstractCdmFormElement implements SelectionListener,
  45 IEnableableFormElement, ISelectable, CdmCompositeController {
  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                 Collection<NomenclaturalCode> result = Arrays.asList(NomenclaturalCode.values());
  58                 result.remove(NomenclaturalCode.ICVCN);
  59                 return  result;
  60             }
  61
  62             @Override
  63             public Class<NomenclaturalCode> getClazz() {
  64                 return NomenclaturalCode.class;
  65             }
  66
  67         },
  68         new CdmEnumDataHolder<ReferenceType>(){
  69
  70             @Override
  71             public String getName() {
  72                 return "Reference Type";
  73             }
  74
  75             @Override
  76             public Collection<ReferenceType> getElements() {
  77                 return Arrays.asList(ReferenceType.values());
  78             }
  79
  80             @Override
  81             public Class<ReferenceType> getClazz() {
  82                 return ReferenceType.class;
  83             }
  84
  85         },
  86         new CdmEnumDataHolder<SpecimenOrObservationType>(){
  87
  88             @Override
  89             public String getName() {
  90                 return "Specimen / Observation Type";
  91             }
  92
  93             @Override
  94             public Collection<SpecimenOrObservationType> getElements() {
  95                 return Arrays.asList(SpecimenOrObservationType.values());
  96             }
  97
  98             @Override
  99             public Class<SpecimenOrObservationType> getClazz() {
 100                 return SpecimenOrObservationType.class;
 101             }
 102
 103         },
 104         new CdmEnumDataHolder<OriginalSourceType>(){
 105
 106             @Override
 107             public String getName() {
 108                 return "Original Source Type";
 109             }
 110
 111             @Override
 112             public Collection<OriginalSourceType> getElements() {
 113                 return Arrays.asList(OriginalSourceType.values());
 114             }
 115
 116             @Override
 117             public Class<OriginalSourceType> getClazz() {
 118                 return OriginalSourceType.class;
 119             }
 120
 121         }
 122
 123     };
 124
 125     private static final int DEFAULT_VISIBLE_ITEMS = 10;
 126
 127     protected T selection;
 128
 129     protected List<T> elementTypeList = new ArrayList<T>();
 130
 131     protected Combo combo;
 132
 133     private final Class<T> enumType;
 134
 135     /**
 136      * <p>
 137      * Constructor for AbstractEnumComboElement.
 138      * </p>
 139      *
 140      * @param formFactory
 141      *            a {@link eu.etaxonomy.taxeditor.ui.element.CdmFormFactory}
 142      *            object.
 143      * @param parentElement
 144      *            a {@link eu.etaxonomy.taxeditor.ui.element.ICdmFormElement}
 145      *            object.
 146      * @param labelString
 147      *            a {@link java.lang.String} object.
 148      * @param <T>
 149      *            a T object.
 150      */
 151     public EnumTermComboController(Combo combo, CdmFormFactory formFactory,
 152             ICdmFormElement parentElement, Class<T> enumType, int style) {
 153         super(formFactory, (Composite)null);
 154         this.enumType = enumType;
 155         // create combo
 156         this.combo = combo;
 157         addControl(combo);
 158         setVisibleItemCount(DEFAULT_VISIBLE_ITEMS);
 159
 160         populateTypes();
 161
 162         combo.addSelectionListener(this);
 163
 164     }
 165
 166     private String getDefaultLabelString() {
 167         if(enumType.equals(ReferenceType.class)){
 168             return "Reference Type";
 169         } else if (enumType.equals(NomenclaturalCode.class)){
 170             return "Nomenclatural Code";
 171         } else if(enumType.equals(OriginalSourceType.class)) {
 172             return "Orig. Source Type";
 173         } else if(enumType.equals(SpecimenOrObservationType.class)) {
 174             return "Spec./Obs. Type";
 175         }
 176         return "No Label";
 177     }
 178
 179     /**
 180      * <p>
 181      * populateTypes
 182      * </p>
 183      */
 184     private void populateTypes(){
 185         Collection<T> elementsForClass = getElementsForClass(enumType);
 186         // special hierarchical order for specimens
 187         if(enumType.equals(SpecimenOrObservationType.class)){
 188             LinkedHashMap<T, String> orderedTerms = AbstractUtility.orderTerms(elementsForClass);
 189             for(Entry<T, String> keyLabelPair : orderedTerms.entrySet()){
 190                 elementTypeList.add(keyLabelPair.getKey());
 191                 combo.add(keyLabelPair.getValue());
 192             }
 193         }
 194         // default order
 195         else{
 196             for(T enumElement : getElementsForClass(enumType)){
 197                 elementTypeList.add(enumElement);
 198                 combo.add(((Enum) enumElement).name());
 199             }
 200         }
 201     }
 202
 203     /**
 204      * <p>
 205      * Setter for the field <code>selection</code>.
 206      * </p>
 207      *
 208      * @param selection
 209      *            the selection to set
 210      */
 211     public void setSelection(T selection) {
 212         this.selection = selection;
 213         combo.select(elementTypeList.indexOf(selection));
 214     }
 215
 216     /**
 217      * <p>
 218      * addSelectionListener
 219      * </p>
 220      *
 221      * @param listener
 222      *            a {@link org.eclipse.swt.events.SelectionListener} object.
 223      */
 224     public void addSelectionListener(SelectionListener listener) {
 225         combo.addSelectionListener(listener);
 226     }
 227
 228     /**
 229      * <p>
 230      * removeSelectionListener
 231      * </p>
 232      *
 233      * @param listener
 234      *            a {@link org.eclipse.swt.events.SelectionListener} object.
 235      */
 236     public void removeSelectionListener(SelectionListener listener) {
 237         combo.removeSelectionListener(listener);
 238     }
 239
 240     /** {@inheritDoc} */
 241     @Override
 242     public void setSelected(boolean selected) {
 243         setBackground(selected ? SELECTED : getPersistentBackground());
 244     }
 245
 246     /**
 247      * <p>
 248      * Getter for the field <code>selection</code>.
 249      * </p>
 250      *
 251      * @return the selection
 252      */
 253     public T getSelection() {
 254         return selection;
 255     }
 256
 257     /** {@inheritDoc} */
 258     @Override
 259     public void setEnabled(boolean enabled) {
 260         combo.setEnabled(enabled);
 261     }
 262
 263     /* (non-Javadoc)
 264      * @see eu.etaxonomy.taxeditor.ui.element.IEnableableFormElement#isEnabled()
 265      */
 266     @Override
 267     public boolean isEnabled() {
 268         return combo.isEnabled();
 269     }
 270
 271     /*
 272      * (non-Javadoc)
 273      *
 274      * @see
 275      * org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt
 276      * .events.SelectionEvent)
 277      */
 278     /** {@inheritDoc} */
 279     @Override
 280     public void widgetSelected(SelectionEvent e) {
 281         selection = elementTypeList.get(combo.getSelectionIndex());
 282     }
 283
 284     /** {@inheritDoc} */
 285     @Override
 286     public void setIrrelevant(boolean irrelevant) {
 287         String colorId = irrelevant ? Resources.COLOR_COMPOSITE_IRRELEVANT
 288                 : Resources.COLOR_COMPOSITE_BACKGROUND;
 289
 290         Color color = StoreUtil.getColor(colorId);
 291         combo.setBackground(color);
 292     }
 293
 294     /** {@inheritDoc} */
 295     @Override
 296     public void setBackground(Color color) {
 297 //        label.setBackground(color);
 298     }
 299
 300     /** {@inheritDoc} */
 301     @Override
 302     public void widgetDefaultSelected(SelectionEvent e) {
 303     }
 304
 305     public void setVisibleItemCount(int visibleItems){
 306         combo.setVisibleItemCount(visibleItems);
 307     }
 308
 309     private Collection<T> getElementsForClass(Class<T> clazz){
 310         CdmEnumDataHolder<T> dataHolder = getCdmEnumDataHolderForClass(clazz);
 311         if (dataHolder != null) {
 312             return dataHolder.getElements();
 313         }
 314         return null;
 315     }
 316
 317     private CdmEnumDataHolder<T> getCdmEnumDataHolderForClass(Class<T> clazz){
 318         for (CdmEnumDataHolder dataHolder : cdmEnumDataHolders) {
 319             if (dataHolder.getClazz().equals(clazz)){
 320                 return dataHolder;
 321             }
 322         }
 323         return null;
 324     }
 325
 326     private interface CdmEnumDataHolder<T> {
 327         Class<T> getClazz();
 328         String getName();
 329         Collection<T> getElements();
 330     }
 331 }