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