eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/ui/combo/EnumComboElement.java

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