eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/ui/section/userecords/UseRecordDetailElement.java

   1 /**
   2 * Copyright (C) 2011 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.section.userecords;
  10
  11 import java.util.ArrayList;
  12 import java.util.Iterator;
  13 import java.util.List;
  14 import java.util.ListIterator;
  15 import java.util.Map;
  16 import java.util.Set;
  17
  18 import org.apache.logging.log4j.LogManager;
  19 import org.apache.logging.log4j.Logger;
  20 import org.eclipse.swt.events.SelectionEvent;
  21 import org.eclipse.swt.events.SelectionListener;
  22
  23 import eu.etaxonomy.cdm.model.common.Language;
  24 import eu.etaxonomy.cdm.model.common.LanguageString;
  25 import eu.etaxonomy.cdm.model.common.Marker;
  26 import eu.etaxonomy.cdm.model.description.CategoricalData;
  27 import eu.etaxonomy.cdm.model.description.State;
  28 import eu.etaxonomy.cdm.model.description.StateData;
  29 import eu.etaxonomy.cdm.model.term.DefinedTerm;
  30 import eu.etaxonomy.cdm.model.term.TermType;
  31 import eu.etaxonomy.taxeditor.store.CdmStore;
  32 import eu.etaxonomy.taxeditor.store.TermStore;
  33 import eu.etaxonomy.taxeditor.store.UsageTermCollection;
  34 import eu.etaxonomy.taxeditor.ui.combo.term.TermComboElement;
  35 import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
  36 import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
  37 import eu.etaxonomy.taxeditor.ui.section.AbstractCdmDetailElement;
  38
  39 /**
  40  * The context manager mediates context start/stop and workbench shutdowns to all registered listeners.
  41  *
  42  * @author a.theys
  43  * @created mar 13, 2012
  44  */
  45 public class UseRecordDetailElement extends
  46                 AbstractCdmDetailElement<CategoricalData> implements SelectionListener {
  47
  48         @SuppressWarnings("unused")
  49         private static final Logger logger = LogManager.getLogger();
  50
  51         private TermComboElement<State> combo_UseCategory;
  52         private TermComboElement<State> combo_UseSubCategory;
  53         private TermComboElement<DefinedTerm> combo_PlantPart;
  54         private TermComboElement<DefinedTerm> combo_Country;
  55         private TermComboElement<DefinedTerm> combo_HumanGroup;
  56         private TermComboElement<DefinedTerm> combo_EthnicGroup;
  57
  58         public UseRecordDetailElement(CdmFormFactory formFactory,
  59                         ICdmFormElement formElement) {
  60                 super(formFactory, formElement);
  61         }
  62
  63         @Override
  64         protected void createControls(ICdmFormElement formElement,
  65                         CategoricalData entity, int style) {
  66
  67                 combo_UseCategory = formFactory.createDefinedTermComboElement(TermType.State, this, UsageTermCollection.useCategoryVocabularyLabel, null, style);
  68                 combo_UseCategory.addSelectionListener(this);
  69                 combo_UseSubCategory = formFactory.createDefinedTermComboElement(TermType.State, this, UsageTermCollection.useSubCategoryVocabularyLabel, null, style);
  70                 combo_PlantPart = formFactory.createDefinedTermComboElement(TermType.Modifier, this, UsageTermCollection.plantPartLabel, null, style);
  71                 combo_HumanGroup = formFactory.createDefinedTermComboElement(TermType.Modifier, this, UsageTermCollection.humanGroupLabel, null, style);
  72                 combo_HumanGroup.addSelectionListener(this);
  73                 combo_EthnicGroup = formFactory.createDefinedTermComboElement(TermType.Modifier, this, UsageTermCollection.ethnicGroupLabel, null, style);
  74                 combo_Country   = formFactory.createDefinedTermComboElement(TermType.Modifier, this, UsageTermCollection.countryLabel, null, style);
  75
  76
  77                 List<State> termsUseCategory = setUseCategoryComboTerms(TermStore.getTerms(State.class, null, false));
  78                 combo_UseCategory.setTerms(termsUseCategory);
  79                 combo_UseCategory.setSelection(stateSelection(UsageTermCollection.useCategoryVocabularyLabel));
  80
  81                 List<State> termsSubCategory = setUseCategoryComboTerms(TermStore.getTerms(State.class, null, false), combo_UseCategory.getSelection());
  82
  83                 if (termsSubCategory != null) {
  84                         combo_UseSubCategory.setTerms(termsSubCategory);
  85                         combo_UseSubCategory.setSelection(stateSelection(UsageTermCollection.useSubCategoryVocabularyLabel));
  86                         combo_UseSubCategory.setEnabled(true);
  87                 }
  88                 else {
  89                         combo_UseSubCategory.setEnabled(false);
  90                 }
  91
  92                 List<DefinedTerm> plantPartsToAdd = setModifierComboTerms(TermStore.getTerms(DefinedTerm.class, null, false), UsageTermCollection.plantPartLabel);
  93                 combo_PlantPart.setTerms(plantPartsToAdd);
  94                 combo_PlantPart.setSelection(modifierSelection(UsageTermCollection.plantPartLabel));
  95
  96                 List<DefinedTerm> countriesToAdd = setModifierComboTerms(TermStore.getTerms(DefinedTerm.class, null, false), UsageTermCollection.countryLabel);
  97                 combo_Country.setTerms(countriesToAdd);
  98                 combo_Country.setSelection(modifierSelection(UsageTermCollection.countryLabel));
  99
 100                 List<DefinedTerm> humanGroupToAdd = setModifierComboTerms(TermStore.getTerms(DefinedTerm.class, null, false), UsageTermCollection.humanGroupLabel);
 101                 combo_HumanGroup.setTerms(humanGroupToAdd);
 102                 combo_HumanGroup.setSelection(modifierSelection(UsageTermCollection.humanGroupLabel));
 103
 104                 List<DefinedTerm> ethnicGroupToAdd = setEthnicGroupComboTerms(TermStore.getTerms(DefinedTerm.class, null, false), combo_HumanGroup.getSelection());
 105                 if (ethnicGroupToAdd != null) {
 106                         combo_EthnicGroup.setTerms(ethnicGroupToAdd);
 107                         combo_EthnicGroup.setSelection(modifierSelection(UsageTermCollection.ethnicGroupLabel));
 108                         combo_EthnicGroup.setEnabled(true);
 109                 } else {
 110                         combo_EthnicGroup.setEnabled(false);
 111                 }
 112         }
 113
 114         /**
 115          * Returns the select modifier
 116          */
 117         private DefinedTerm modifierSelection(String comboCategory) {
 118                 if(!getEntity().getModifiers().isEmpty()) {
 119                         for (DefinedTerm modifier : getEntity().getModifiers()) {
 120                                 if(GetVocabularyType(modifier, comboCategory)) {
 121                                         return modifier;
 122                                 }
 123                         }
 124                 } else {
 125                         return null;
 126                 }
 127                 return null;
 128         }
 129
 130         /**
 131          * Returns the selected state
 132          */
 133         private State stateSelection(String comboCategory) {
 134                 if (!getEntity().getStateData().isEmpty()) {
 135                         for (StateData statedata : getEntity().getStateData()) {
 136                                 if (statedata.getModifyingText().get(CdmStore.getDefaultLanguage()) != null) {
 137                                         String testString = statedata.getModifyingText().get(CdmStore.getDefaultLanguage()).getText();
 138                                         if(testString.equals(comboCategory)) {
 139                                                 if(statedata.getState() !=null) {
 140                                                         return statedata.getState();
 141                                                 }
 142                                         }
 143                                 }
 144                         }
 145                 }
 146                 else {
 147                         return null;
 148                 }
 149                 return null;
 150         }
 151
 152         /**
 153          * This function sets the combo terms (Besides EthnicGroup
 154          */
 155         private List<DefinedTerm> setModifierComboTerms(List<DefinedTerm> listOfTerms, String modType) {
 156                 List<DefinedTerm> termsToAdd = new ArrayList<DefinedTerm>();
 157                 for (DefinedTerm term : listOfTerms) {
 158
 159                         if ((term.getPartOf() != null) && (term.getPartOf().getTitleCache().equals(modType))) {
 160                                 termsToAdd.add(term);
 161                         }
 162                         else if ((term.getVocabulary() != null) && (term.getPartOf() == null) && (term.getVocabulary().getTitleCache().equals(modType))) {
 163                                 termsToAdd.add(term);
 164                         }
 165                 }
 166
 167                 return termsToAdd;
 168         }
 169
 170         /**
 171          * This function sets the Use Category combo term
 172          */
 173         private List<State> setUseCategoryComboTerms(List<State> listOfTerms) {
 174         List<State> termsToAdd = new ArrayList<>();
 175                 for (State term : listOfTerms) {
 176                     if ((term.getPartOf() != null) && (term.getPartOf().getUuid().equals( UsageTermCollection.uuidUseCategoryVocabulary))) {
 177                                 termsToAdd.add(term);
 178                         }
 179                         else if ((term.getVocabulary() !=null) && (term.getPartOf() == null) && (term.getVocabulary().getUuid().equals(UsageTermCollection.uuidUseCategoryVocabulary))) {
 180                                 termsToAdd.add(term);
 181                         }
 182                 }
 183                 return termsToAdd;
 184         }
 185
 186         /**
 187          * This function sets the Use SubCategory combo term
 188          */
 189         private List<State> setUseCategoryComboTerms(List<State> listOfTerms,
 190                         State selectedUseCategory) {
 191
 192                 List<State> termsToAdd = new ArrayList<>();
 193                 if (combo_UseCategory.getSelection() != null) {
 194
 195                         for (State term : listOfTerms) {
 196                                 if ((term.getPartOf() != null) && (term.getPartOf().getTitleCache().equals(selectedUseCategory.getTitleCache()))) {
 197                                         termsToAdd.add(term);
 198                                 }
 199                                 else if ((term.getVocabulary() !=null) && (term.getVocabulary().getTitleCache().equals(selectedUseCategory.getTitleCache()))) {
 200                                         termsToAdd.add(term);
 201                                 }
 202
 203                         }
 204                 }
 205                 else if (!getEntity().getStateData().isEmpty()) {
 206                         for (StateData stateData : getEntity().getStateData()) {
 207                                 if (stateData.getModifyingText().get(CdmStore.getDefaultLanguage()) != null) {
 208                                         if ((stateData.getState() != null) && (stateData.getModifyingText().get(CdmStore.getDefaultLanguage()).getText() == UsageTermCollection.useCategoryVocabularyLabel)) {
 209                                                 for (State term : listOfTerms) {
 210                                                         if ((term.getPartOf() != null) && (term.getPartOf().getTitleCache().equals(stateData.getState().getTitleCache()))) {
 211                                                                 termsToAdd.add(term);
 212                                                         } else if ((term.getVocabulary() != null) && (term.getVocabulary().getTitleCache().equals(stateData.getState().getTitleCache()))) {
 213                                                                 termsToAdd.add(term);
 214                                                         }
 215                                                 }
 216
 217                                         }
 218                                 }
 219                         }
 220                 }
 221                 else {
 222                         return null;
 223                 }
 224
 225                 return termsToAdd;
 226         }
 227
 228
 229         /**
 230          * This function sets the EthnicGroup combo term
 231          */
 232         private List<DefinedTerm> setEthnicGroupComboTerms(List<DefinedTerm> listOfTerms,
 233                         DefinedTerm selectedHumangroup) {
 234                 List<DefinedTerm> termsToAdd = new ArrayList<DefinedTerm>();
 235                 if (combo_HumanGroup.getSelection() != null) {
 236                         for (DefinedTerm term : listOfTerms) {
 237
 238                                 if ((term.getPartOf() != null) && (term.getPartOf().getTitleCache().equals(selectedHumangroup.getTitleCache()))) {
 239                                         termsToAdd.add(term);
 240                                 }
 241                                 else if ((term.getVocabulary() != null) && (term.getVocabulary().getTitleCache().equals(selectedHumangroup.getTitleCache()))) {
 242                                         termsToAdd.add(term);
 243                                 }
 244                         }
 245                 }
 246                 else if (!getEntity().getModifiers().isEmpty()) {
 247                         for (DefinedTerm modifier : getEntity().getModifiers()) {
 248                                 if (modifier.getMarkers() != null) {
 249                                         for (Marker marker : modifier.getMarkers()) {
 250                                                 if(marker.getMarkerType().getTitleCache().equals(UsageTermCollection.humanGroupLabel)) {
 251                                                         for (DefinedTerm term : listOfTerms) {
 252                                                                 if ((term.getPartOf() != null) && (term.getPartOf().getTitleCache().equals(modifier.getTitleCache()))) {
 253                                                                         termsToAdd.add(modifier);
 254                                                                 } else if ((term.getVocabulary() != null) && (term.getVocabulary().getTitleCache().equals(modifier.getTitleCache()))) {
 255                                                                         termsToAdd.add(modifier);
 256                                                                 }
 257                                                         }
 258
 259                                                 }
 260                                         }
 261                                 }
 262                         }
 263                 } else {
 264                         return null;
 265                 }
 266
 267                 return termsToAdd;
 268         }
 269
 270         @Override
 271         public void handleEvent(Object eventSource) {
 272                 if (eventSource == combo_UseCategory) {
 273                         if (combo_UseCategory.getSelection() != null) {
 274                                 boolean isChanged = false;
 275                                 boolean isUseCategoryChanged = false;
 276                                 if (!getEntity().getStateData().isEmpty()) {
 277                                         for (StateData useCategoryStateDataCheck : getEntity().getStateData()) {
 278                                                 Map<Language, LanguageString> modText = useCategoryStateDataCheck.getModifyingText();
 279                                                 if(modText.get(CdmStore.getDefaultLanguage()) != null && modText.get(CdmStore.getDefaultLanguage()).getText().equals(UsageTermCollection.useCategoryVocabularyLabel)) {
 280                                                         if(!useCategoryStateDataCheck.getState().getTitleCache().equals(combo_UseCategory.getSelection().getTitleCache())) {
 281                                                                 isUseCategoryChanged = true;
 282                                                         }
 283
 284                                                 }
 285                                         }
 286                                         ListIterator<StateData> itrExistingStates = getEntity().getStateData().listIterator();
 287                                         while(itrExistingStates.hasNext()) {
 288                                                 StateData existingStateData = itrExistingStates.next();
 289                                                 Map<Language, LanguageString> modifyingText = existingStateData
 290                                                                 .getModifyingText();
 291                                                 if (modifyingText.get(CdmStore.getDefaultLanguage()) != null) {
 292                                                         if (modifyingText.get(CdmStore.getDefaultLanguage()).getText().equals(UsageTermCollection.useCategoryVocabularyLabel)) {
 293                                                                 isChanged = true;
 294                                                                 if(!existingStateData.getState().getTitleCache().equals(combo_UseCategory.getSelection().getTitleCache())) {
 295                                                                         itrExistingStates.remove();
 296                                                                         StateData stateData = StateData.NewInstance(combo_UseCategory.getSelection());
 297                                                                         stateData.setState(combo_UseCategory.getSelection());
 298                                                                         stateData.putModifyingText(CdmStore.getDefaultLanguage(),UsageTermCollection.useCategoryVocabularyLabel);
 299                                                                         itrExistingStates.add(stateData);
 300
 301                                                                 }
 302                                                         } else if (modifyingText.get(CdmStore.getDefaultLanguage()).getText().equals(UsageTermCollection.useSubCategoryVocabularyLabel) && isUseCategoryChanged == true) {
 303                                                                 itrExistingStates.remove();
 304                                                         }
 305                                                 }
 306                                         }
 307                                 }
 308
 309                                 if (isChanged == false) {
 310                                         StateData stateData = StateData
 311                                                         .NewInstance(combo_UseCategory.getSelection());
 312                                         stateData.setState(combo_UseCategory.getSelection());
 313                                         stateData.putModifyingText(CdmStore.getDefaultLanguage(), UsageTermCollection.useCategoryVocabularyLabel);
 314                                         getEntity().addStateData(stateData);
 315                                 }
 316
 317                                 combo_UseSubCategory.setEnabled(true);
 318                         }
 319                         else {
 320                                 if (!getEntity().getStateData().isEmpty()) {
 321                                         Iterator<StateData> itr = getEntity().getStateData().iterator();
 322                                         while(itr.hasNext()) {
 323                                                 itr.next();
 324                                                 itr.remove();
 325                                         }
 326                                         List<State> termsSubCategory = new ArrayList<>();
 327                                         State emptyState = State.NewInstance();
 328                                         termsSubCategory.add(emptyState);
 329                                         combo_UseSubCategory.setTerms(termsSubCategory);
 330                                         combo_UseSubCategory.setEnabled(false);
 331                                 }
 332                         }
 333                 }
 334
 335                 if (eventSource == combo_UseSubCategory) {
 336                         if (combo_UseSubCategory.getSelection() != null) {
 337                                 boolean isChanged = false;
 338                                 if (!getEntity().getStateData().isEmpty()) {
 339                                         ListIterator<StateData> itrExistingStates = getEntity().getStateData().listIterator();
 340                                         while(itrExistingStates.hasNext()) {
 341                                                 StateData existingStateData = itrExistingStates.next();
 342                                                 Map<Language, LanguageString> modifyingText = existingStateData
 343                                                                 .getModifyingText();
 344                                                 if (modifyingText.get(CdmStore.getDefaultLanguage()) != null) {
 345                                                         if (modifyingText.get(CdmStore.getDefaultLanguage()).getText().equals(UsageTermCollection.useSubCategoryVocabularyLabel)) {
 346                                                                 isChanged = true;
 347                                                                 if(!existingStateData.getState().getTitleCache().equals(combo_UseSubCategory.getSelection().getTitleCache())) {
 348                                                                         itrExistingStates.remove();
 349                                                                         StateData stateData = StateData.NewInstance(combo_UseSubCategory.getSelection());
 350                                                                         stateData.setState(combo_UseSubCategory.getSelection());
 351                                                                         stateData.putModifyingText(CdmStore.getDefaultLanguage(),UsageTermCollection.useSubCategoryVocabularyLabel);
 352                                                                         itrExistingStates.add(stateData);
 353                                                                 }
 354                                                         }
 355                                                 }
 356                                         }
 357                                 }
 358
 359                                 if (isChanged == false){
 360                                         StateData stateData = StateData
 361                                                         .NewInstance(combo_UseSubCategory.getSelection());
 362                                         stateData.setState(combo_UseSubCategory.getSelection());
 363                                         stateData.putModifyingText(CdmStore.getDefaultLanguage(), UsageTermCollection.useSubCategoryVocabularyLabel);
 364                                         getEntity().addStateData(stateData);
 365                                 }
 366                         } else {
 367                                 if (!getEntity().getStateData().isEmpty()) {
 368                                         Iterator<StateData> itrStateData = getEntity().getStateData().iterator();
 369                                         while(itrStateData.hasNext()) {
 370                                                 StateData existingStateData = itrStateData.next();
 371                                                 Map<Language, LanguageString> modifyingText = existingStateData
 372                                                                 .getModifyingText();
 373
 374                                                 if (modifyingText.get(CdmStore.getDefaultLanguage()) != null) {
 375                                                         if (modifyingText.get(CdmStore.getDefaultLanguage()).getText() == UsageTermCollection.useSubCategoryVocabularyLabel) {
 376                                                                 itrStateData.remove();
 377                                                         }
 378                                                 }
 379                                         }
 380                                 }
 381                         }
 382                 }
 383                 if (eventSource == combo_PlantPart) {
 384                         if (combo_PlantPart.getSelection() != null) {
 385                                 Iterator<DefinedTerm> itrExistingModifiers = getEntity().getModifiers().iterator();
 386                                 while (itrExistingModifiers.hasNext()) {
 387                                         DefinedTerm modifier = itrExistingModifiers.next();
 388                                         if(GetVocabularyType(modifier, UsageTermCollection.plantPartLabel)) {
 389                                                 itrExistingModifiers.remove();
 390                                         }
 391                                 }
 392                                 DefinedTerm plantPart = combo_PlantPart.getSelection();
 393                                 getEntity().addModifier(plantPart);
 394                         } else {
 395                                 Set<DefinedTerm> modifiers = getEntity().getModifiers();
 396                                 if(!modifiers.isEmpty()) {
 397                                         Iterator<DefinedTerm> itr = modifiers.iterator();
 398                                         while (itr.hasNext()) {
 399                                                 DefinedTerm currentMod = itr.next();
 400                                                 if(GetVocabularyType(currentMod, UsageTermCollection.plantPartLabel)) {
 401                                                         itr.remove();
 402                                                 }
 403                                         }
 404                                 }
 405                         }
 406                 }
 407                 if (eventSource == combo_Country) {
 408                         if (combo_Country.getSelection() != null) {
 409                                 Iterator<DefinedTerm> itrExistingModifiers = getEntity().getModifiers().iterator();
 410                                 while (itrExistingModifiers.hasNext()) {
 411                                         DefinedTerm modifier = itrExistingModifiers.next();
 412                                         if(GetVocabularyType(modifier, UsageTermCollection.countryLabel)) {
 413                                                 itrExistingModifiers.remove();
 414                                         }
 415                                 }
 416                                 DefinedTerm country = combo_Country.getSelection();
 417                                 getEntity().addModifier(country);
 418                         } else {
 419                                 Set<DefinedTerm> modifiers = getEntity().getModifiers();
 420                                 if(!modifiers.isEmpty()) {
 421                                         Iterator<DefinedTerm> itr = modifiers.iterator();
 422                                         while (itr.hasNext()) {
 423                                                 DefinedTerm currentMod = itr.next();
 424                                                 if(GetVocabularyType(currentMod, UsageTermCollection.countryLabel)) {
 425                                                         itr.remove();
 426                                                 }
 427                                         }
 428                                 }
 429                         }
 430                 }
 431                 if (eventSource == combo_HumanGroup) {
 432                         if (combo_HumanGroup.getSelection() != null) {
 433                                 boolean isHumanGroupChanged = true;
 434                                 for (DefinedTerm modToCheck: getEntity().getModifiers()) {
 435                                         if(modToCheck.equals(combo_HumanGroup.getSelection()) && (GetVocabularyType(modToCheck, UsageTermCollection.humanGroupLabel))) {
 436                                                 isHumanGroupChanged = false;
 437                                         }
 438                                 }
 439                                 Iterator<DefinedTerm> itrExistingModifiers = getEntity().getModifiers().iterator();
 440                                 while (itrExistingModifiers.hasNext()) {
 441                                         DefinedTerm modifier = itrExistingModifiers.next();
 442                                         if((GetVocabularyType(modifier, UsageTermCollection.humanGroupLabel) || GetVocabularyType(modifier, UsageTermCollection.ethnicGroupLabel)) && isHumanGroupChanged) {
 443                                                 itrExistingModifiers.remove();
 444                                         }
 445                                 }
 446                                 if(isHumanGroupChanged){
 447                                         DefinedTerm humanGroup = combo_HumanGroup.getSelection();
 448                                         getEntity().addModifier(humanGroup);
 449                                 }
 450                                 combo_EthnicGroup.setEnabled(true);
 451                         } else {
 452                                 Set<DefinedTerm> modifiers = getEntity().getModifiers();
 453                                 if(!modifiers.isEmpty()) {
 454                                         Iterator<DefinedTerm> itr = modifiers.iterator();
 455                                         while (itr.hasNext()) {
 456                                                 DefinedTerm currentMod = itr.next();
 457                                                 if(GetVocabularyType(currentMod, UsageTermCollection.humanGroupLabel) || GetVocabularyType(currentMod, UsageTermCollection.ethnicGroupLabel)) {
 458                                                         itr.remove();
 459                                                 }
 460                                         }
 461                                 }
 462                                 List<DefinedTerm> emptyListToResetComboBox = new ArrayList<DefinedTerm>();
 463
 464 //                              DefinedTerm emptyMod = DefinedTerm.NewInstance();
 465                                 DefinedTerm emptyMod = null;
 466
 467                                 emptyListToResetComboBox.add(emptyMod);
 468                                 combo_EthnicGroup.setTerms(emptyListToResetComboBox);
 469                                 combo_EthnicGroup.setEnabled(false);
 470                         }
 471                 }
 472                 if (eventSource == combo_EthnicGroup) {
 473                         if (combo_EthnicGroup.getSelection() != null) {
 474                                 Iterator<DefinedTerm> itrExistingModifiers = getEntity().getModifiers().iterator();
 475                                         while (itrExistingModifiers.hasNext()) {
 476                                                 DefinedTerm modifier = itrExistingModifiers.next();
 477                                                 if(GetVocabularyType(modifier, combo_HumanGroup.getSelection().getTitleCache())) {
 478                                                         itrExistingModifiers.remove();
 479                                                 }
 480                                         }
 481                                         DefinedTerm ethnicGroup = combo_EthnicGroup.getSelection();
 482                                         getEntity().addModifier(ethnicGroup);
 483                         } else {
 484                                 Set<DefinedTerm> modifiers = getEntity().getModifiers();
 485                                 if(!modifiers.isEmpty()) {
 486
 487                                         Iterator<DefinedTerm> itr = modifiers.iterator();
 488                                         while (itr.hasNext()) {
 489                                                 DefinedTerm currentMod = itr.next();
 490                                                 if(GetVocabularyType(currentMod, UsageTermCollection.ethnicGroupLabel)) {
 491                                                         itr.remove();
 492                                                 }
 493                                         }
 494                                 }
 495                         }
 496                 }
 497         }
 498
 499         /**
 500          * This function Checks the vocabulary type
 501          */
 502         private boolean GetVocabularyType(DefinedTerm term, String vocabularyExpected) {
 503                 if ((term.getPartOf() != null)  && (term.getPartOf().getTitleCache().equals(vocabularyExpected))) {
 504                         return true;
 505                 }
 506                 else if ((term.getVocabulary() != null) && (term.getPartOf()==null) && (term.getVocabulary().getTitleCache().equals(vocabularyExpected))) {
 507                         return true;
 508                 }
 509                 else if ((vocabularyExpected.equals(UsageTermCollection.ethnicGroupLabel))  && ((term.getPartOf() != null))) {
 510                         return true;
 511                 }
 512         return false;
 513         }
 514
 515         @Override
 516         public void setEntity(CategoricalData entity) {
 517                 super.setEntity(entity);
 518         }
 519
 520         @Override
 521         public void widgetSelected(SelectionEvent e) {
 522                 Object eventSource = e.getSource();
 523                 for (Object object: combo_UseCategory.getControls()) {
 524                         if (object == eventSource) {
 525                                 State selectedUseCategory = combo_UseCategory.getSelection();
 526                                 if (selectedUseCategory != null) {
 527                                         combo_UseSubCategory.setTerms(setUseCategoryComboTerms(TermStore.getTerms(State.class, null, false),selectedUseCategory));
 528
 529                                         if (!getEntity().getStateData().isEmpty()) {
 530                                                 Iterator<StateData> itrExistingState = getEntity().getStateData().iterator();
 531                                                 while(itrExistingState.hasNext()) {
 532                                                         StateData existingStateData = itrExistingState.next();
 533                                                         Map<Language, LanguageString> modifyingText = existingStateData.getModifyingText();
 534                                                         if (modifyingText.get(CdmStore.getDefaultLanguage()) != null) {
 535                                                                 if (modifyingText.get(CdmStore.getDefaultLanguage())
 536                                                                                 .getText().equals(UsageTermCollection.useSubCategoryVocabularyLabel)) {
 537                                                                         combo_UseSubCategory.setSelection(stateSelection(UsageTermCollection.useSubCategoryVocabularyLabel));
 538                                                                 }
 539                                                         }
 540                                                 }
 541                                         }
 542                                 }
 543                         }
 544                 }
 545                 for (Object object: combo_HumanGroup.getControls()) {
 546                         if (object == eventSource) {
 547                                 DefinedTerm selectedHumanGroup = combo_HumanGroup.getSelection();
 548                                 if (selectedHumanGroup != null) {
 549                                         combo_EthnicGroup.setTerms(setEthnicGroupComboTerms(TermStore.getTerms(DefinedTerm.class, null, false), selectedHumanGroup));
 550                                         if (!getEntity().getModifiers().isEmpty()) {
 551                                                 Iterator<DefinedTerm> iterModifiers = getEntity().getModifiers().iterator();
 552                                                 while (iterModifiers.hasNext()) {
 553                                                         DefinedTerm existingModifier = iterModifiers.next();
 554                                                         if(GetVocabularyType(existingModifier, UsageTermCollection.ethnicGroupLabel)) {
 555                                                                 combo_EthnicGroup.setSelection(modifierSelection(UsageTermCollection.ethnicGroupLabel));
 556                                                         }
 557                                                 }
 558                                         }
 559
 560                                 }
 561                         }
 562                 }
 563         }
 564
 565         @Override
 566         public void widgetDefaultSelected(SelectionEvent e) {
 567                 // TODO Auto-generated method stub
 568         }
 569 }