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.common.IEnumTerm;
  25 import eu.etaxonomy.cdm.model.common.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                 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     private static final int DEFAULT_VISIBLE_ITEMS = 10;
 124
 125     protected T selection;
 126
 127     protected List<T> elementTypeList = new ArrayList<T>();
 128
 129     protected Combo combo;
 130
 131     private final Class<T> enumType;
 132
 133     /**
 134      * <p>
 135      * Constructor for AbstractEnumComboElement.
 136      * </p>
 137      *
 138      * @param formFactory
 139      *            a {@link eu.etaxonomy.taxeditor.ui.element.CdmFormFactory}
 140      *            object.
 141      * @param parentElement
 142      *            a {@link eu.etaxonomy.taxeditor.ui.element.ICdmFormElement}
 143      *            object.
 144      * @param labelString
 145      *            a {@link java.lang.String} object.
 146      * @param <T>
 147      *            a T object.
 148      */
 149     public EnumTermComboController(Combo combo, CdmFormFactory formFactory,
 150             ICdmFormElement parentElement, Class<T> enumType, int style) {
 151         super(formFactory, (Composite)null);
 152         this.enumType = enumType;
 153         // create combo
 154         this.combo = combo;
 155         addControl(combo);
 156         setVisibleItemCount(DEFAULT_VISIBLE_ITEMS);
 157
 158         populateTypes();
 159
 160         combo.addSelectionListener(this);
 161
 162     }
 163
 164     private String getDefaultLabelString() {
 165         if(enumType.equals(ReferenceType.class)){
 166             return "Reference Type";
 167         } else if (enumType.equals(NomenclaturalCode.class)){
 168             return "Nomenclatural Code";
 169         } else if(enumType.equals(OriginalSourceType.class)) {
 170             return "Orig. Source Type";
 171         } else if(enumType.equals(SpecimenOrObservationType.class)) {
 172             return "Spec./Obs. Type";
 173         }
 174         return "No Label";
 175     }
 176
 177     /**
 178      * <p>
 179      * populateTypes
 180      * </p>
 181      */
 182     private void populateTypes(){
 183         Collection<T> elementsForClass = getElementsForClass(enumType);
 184         // special hierarchical order for specimens
 185         if(enumType.equals(SpecimenOrObservationType.class)){
 186             LinkedHashMap<T, String> orderedTerms = AbstractUtility.orderTerms(elementsForClass);
 187             for(Entry<T, String> keyLabelPair : orderedTerms.entrySet()){
 188                 elementTypeList.add(keyLabelPair.getKey());
 189                 combo.add(keyLabelPair.getValue());
 190             }
 191         }
 192         // default order
 193         else{
 194             for(T enumElement : getElementsForClass(enumType)){
 195                 elementTypeList.add(enumElement);
 196                 combo.add(((Enum) enumElement).name());
 197             }
 198         }
 199     }
 200
 201     /**
 202      * <p>
 203      * Setter for the field <code>selection</code>.
 204      * </p>
 205      *
 206      * @param selection
 207      *            the selection to set
 208      */
 209     public void setSelection(T selection) {
 210         this.selection = selection;
 211         combo.select(elementTypeList.indexOf(selection));
 212     }
 213
 214     /**
 215      * <p>
 216      * addSelectionListener
 217      * </p>
 218      *
 219      * @param listener
 220      *            a {@link org.eclipse.swt.events.SelectionListener} object.
 221      */
 222     public void addSelectionListener(SelectionListener listener) {
 223         combo.addSelectionListener(listener);
 224     }
 225
 226     /**
 227      * <p>
 228      * removeSelectionListener
 229      * </p>
 230      *
 231      * @param listener
 232      *            a {@link org.eclipse.swt.events.SelectionListener} object.
 233      */
 234     public void removeSelectionListener(SelectionListener listener) {
 235         combo.removeSelectionListener(listener);
 236     }
 237
 238     /** {@inheritDoc} */
 239     @Override
 240     public void setSelected(boolean selected) {
 241         setBackground(selected ? SELECTED : getPersistentBackground());
 242     }
 243
 244     /**
 245      * <p>
 246      * Getter for the field <code>selection</code>.
 247      * </p>
 248      *
 249      * @return the selection
 250      */
 251     public T getSelection() {
 252         return selection;
 253     }
 254
 255     /** {@inheritDoc} */
 256     @Override
 257     public void setEnabled(boolean enabled) {
 258         combo.setEnabled(enabled);
 259     }
 260
 261     /* (non-Javadoc)
 262      * @see eu.etaxonomy.taxeditor.ui.element.IEnableableFormElement#isEnabled()
 263      */
 264     @Override
 265     public boolean isEnabled() {
 266         return combo.isEnabled();
 267     }
 268
 269     /*
 270      * (non-Javadoc)
 271      *
 272      * @see
 273      * org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt
 274      * .events.SelectionEvent)
 275      */
 276     /** {@inheritDoc} */
 277     @Override
 278     public void widgetSelected(SelectionEvent e) {
 279         selection = elementTypeList.get(combo.getSelectionIndex());
 280     }
 281
 282     /** {@inheritDoc} */
 283     @Override
 284     public void setIrrelevant(boolean irrelevant) {
 285         String colorId = irrelevant ? Resources.COLOR_COMPOSITE_IRRELEVANT
 286                 : Resources.COLOR_COMPOSITE_BACKGROUND;
 287
 288         Color color = StoreUtil.getColor(colorId);
 289         combo.setBackground(color);
 290     }
 291
 292     /** {@inheritDoc} */
 293     @Override
 294     public void setBackground(Color color) {
 295 //        label.setBackground(color);
 296     }
 297
 298     /** {@inheritDoc} */
 299     @Override
 300     public void widgetDefaultSelected(SelectionEvent e) {
 301     }
 302
 303     public void setVisibleItemCount(int visibleItems){
 304         combo.setVisibleItemCount(visibleItems);
 305     }
 306
 307     private Collection<T> getElementsForClass(Class<T> clazz){
 308         CdmEnumDataHolder<T> dataHolder = getCdmEnumDataHolderForClass(clazz);
 309         if (dataHolder != null) {
 310             return dataHolder.getElements();
 311         }
 312         return null;
 313     }
 314
 315     private CdmEnumDataHolder<T> getCdmEnumDataHolderForClass(Class<T> clazz){
 316         for (CdmEnumDataHolder dataHolder : cdmEnumDataHolders) {
 317             if (dataHolder.getClazz().equals(clazz)){
 318                 return dataHolder;
 319             }
 320         }
 321         return null;
 322     }
 323
 324     private interface CdmEnumDataHolder<T> {
 325         Class<T> getClazz();
 326         String getName();
 327         Collection<T> getElements();
 328     }
 329 }