taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/TaxonNameEditor.java

   1 /**
   2 * Copyright (C) 2007 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
  10 package eu.etaxonomy.taxeditor.editor.name;
  11
  12 import java.util.ArrayList;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Set;
  16
  17 import org.eclipse.core.commands.operations.IUndoContext;
  18 import org.eclipse.core.runtime.IAdaptable;
  19 import org.eclipse.core.runtime.IProgressMonitor;
  20 import org.eclipse.core.runtime.OperationCanceledException;
  21 import org.eclipse.jface.action.MenuManager;
  22 import org.eclipse.jface.dialogs.MessageDialog;
  23 import org.eclipse.jface.viewers.ISelection;
  24 import org.eclipse.jface.viewers.ISelectionProvider;
  25 import org.eclipse.jface.viewers.StructuredSelection;
  26 import org.eclipse.swt.dnd.DND;
  27 import org.eclipse.swt.dnd.DropTarget;
  28 import org.eclipse.swt.dnd.Transfer;
  29 import org.eclipse.swt.widgets.Composite;
  30 import org.eclipse.swt.widgets.Menu;
  31 import org.eclipse.ui.IEditorInput;
  32 import org.eclipse.ui.IEditorSite;
  33 import org.eclipse.ui.ISelectionListener;
  34 import org.eclipse.ui.ISelectionService;
  35 import org.eclipse.ui.IWorkbenchPart;
  36 import org.eclipse.ui.IWorkbenchPartReference;
  37 import org.eclipse.ui.PartInitException;
  38 import org.eclipse.ui.forms.ManagedForm;
  39 import org.eclipse.ui.forms.widgets.FormToolkit;
  40 import org.eclipse.ui.forms.widgets.ScrolledForm;
  41 import org.eclipse.ui.forms.widgets.TableWrapLayout;
  42 import org.eclipse.ui.part.EditorPart;
  43
  44 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  45 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  46 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  47 import eu.etaxonomy.cdm.model.common.CdmBase;
  48 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
  49 import eu.etaxonomy.cdm.model.taxon.Taxon;
  50 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  51 import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
  52 import eu.etaxonomy.taxeditor.editor.CdmDataTransfer;
  53 import eu.etaxonomy.taxeditor.editor.EditorUtil;
  54 import eu.etaxonomy.taxeditor.editor.IDropTargetable;
  55 import eu.etaxonomy.taxeditor.editor.IMultiPageTaxonEditorPage;
  56 import eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor;
  57 import eu.etaxonomy.taxeditor.editor.SimpleSelectionProvider;
  58 import eu.etaxonomy.taxeditor.editor.TaxonEditorInput;
  59 import eu.etaxonomy.taxeditor.editor.name.container.AbstractGroup;
  60 import eu.etaxonomy.taxeditor.editor.name.container.AbstractGroupedContainer;
  61 import eu.etaxonomy.taxeditor.editor.name.container.AcceptedGroup;
  62 import eu.etaxonomy.taxeditor.editor.name.container.AcceptedNameContainer;
  63 import eu.etaxonomy.taxeditor.editor.name.container.ConceptGroup;
  64 import eu.etaxonomy.taxeditor.editor.name.container.ContainerFactory;
  65 import eu.etaxonomy.taxeditor.editor.name.container.HomotypicalSynonymGroup;
  66 import eu.etaxonomy.taxeditor.editor.name.container.MisappliedGroup;
  67 import eu.etaxonomy.taxeditor.editor.name.dnd.NameEditorDropTargetListener;
  68 import eu.etaxonomy.taxeditor.model.IPartChangeListener;
  69 import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;
  70 import eu.etaxonomy.taxeditor.model.TaxeditorPartService;
  71 import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
  72 import eu.etaxonomy.taxeditor.preference.Resources;
  73
  74 /**
  75  * <p>TaxonNameEditor class.</p>
  76  *
  77  * @author p.ciardelli
  78  * @author n.hoffmann
  79  * @created 15.05.2008
  80  * @version 1.0
  81  */
  82 public class TaxonNameEditor extends EditorPart implements IMultiPageTaxonEditorPage, IAdaptable, IConversationEnabled, IPostOperationEnabled, IPartContentHasDetails, IPartChangeListener
  83                 , ISelectionListener, IDropTargetable {
  84
  85         /** Constant <code>ID="eu.etaxonomy.taxeditor.taxonNameEditor"</code> */
  86         public static final String ID = "eu.etaxonomy.taxeditor.taxonNameEditor";
  87
  88         private Taxon taxon;
  89
  90         private ManagedForm managedForm;
  91         private ScrolledForm scrolledForm;
  92         private Composite parent;
  93         private ISelectionProvider provider;
  94
  95         private MultiPageTaxonEditor editor;
  96
  97         private TaxonBase selection;
  98
  99         private ConversationHolder conversation;
 100
 101         private MenuManager menuManager;
 102
 103         private Menu menu;
 104
 105         private MisappliedGroup misappliedGroup;
 106
 107         private ConceptGroup conceptGroup;
 108
 109         private List<HomotypicalSynonymGroup> heterotypicSynonymGroups = new ArrayList<HomotypicalSynonymGroup>();
 110
 111         private DropTarget target;
 112
 113         private ISelectionService selectionService;
 114
 115         private AcceptedGroup acceptedGroup;
 116
 117         private TaxonBase objectAffectedByLastOperation;
 118
 119         /**
 120          * <p>Constructor for TaxonNameEditor.</p>
 121          *
 122          * @param editor a {@link eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor} object.
 123          */
 124         public TaxonNameEditor(MultiPageTaxonEditor editor){
 125                 this.editor = editor;
 126                 conversation = editor.getConversationHolder();
 127         }
 128
 129
 130
 131         /**
 132          * <p>getUndoContext</p>
 133          *
 134          * @return a {@link org.eclipse.core.commands.operations.IUndoContext} object.
 135          */
 136         public IUndoContext getUndoContext() {
 137                 return editor.getUndoContext();
 138         }
 139
 140         /* (non-Javadoc)
 141          * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)
 142          */
 143         /** {@inheritDoc} */
 144         public void createPartControl(Composite composite) {
 145                 selectionService = getSite().getWorkbenchWindow().getSelectionService();
 146                 selectionService.addSelectionListener(this);
 147
 148                 createManagedForm(composite);
 149
 150                 TaxeditorPartService.getInstance().addListener(TaxeditorPartService.PART_ACTIVATED, this);
 151         }
 152
 153         /**
 154          * <p>createManagedForm</p>
 155          *
 156          * @param composite a {@link org.eclipse.swt.widgets.Composite} object.
 157          */
 158         protected void createManagedForm(Composite composite) {
 159
 160                 managedForm = new ManagedForm(composite) {
 161
 162                         public void dirtyStateChanged() {
 163                                 firePropertyChange(PROP_DIRTY);
 164                         }
 165                         public boolean setInput(Object input) {
 166                                 if (input instanceof AbstractGroupedContainer) {
 167                                         selection = ((AbstractGroupedContainer) input).getData();
 168                                         provider.setSelection(new StructuredSelection(selection));
 169                                 }
 170                                 return super.setInput(input);
 171                         }
 172                 };
 173
 174
 175                 scrolledForm = managedForm.getForm();
 176                 parent = scrolledForm.getBody();
 177
 178                 // register the context menu
 179                 menuManager = new MenuManager();
 180                 ISelectionProvider selectionProvider = getSite().getSelectionProvider();
 181                 getSite().registerContextMenu(TaxonNameEditor.ID, menuManager, selectionProvider);
 182
 183                 parent.setData(taxon);
 184
 185                 TableWrapLayout layout = new TableWrapLayout();
 186                 layout.leftMargin = 0;
 187                 layout.rightMargin = 0;
 188                 layout.topMargin = 0;
 189                 layout.bottomMargin = 0;
 190
 191                 layout.verticalSpacing = 0;
 192                 layout.horizontalSpacing = 0;
 193
 194                 parent.setLayout(layout);
 195                 parent.setBackground(EditorUtil.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));
 196
 197                 createOrUpdateNameComposites();
 198
 199                 createDragSupport();
 200
 201                 setFocus();
 202         }
 203
 204         /**
 205          * <p>createNameComposites</p>
 206          */
 207         public void createOrUpdateNameComposites(){
 208
 209                 ContainerFactory.createOrUpdateAcceptedTaxonsHomotypicGroup(this);
 210                 ContainerFactory.createOrUpdateHeterotypicSynonymyGroups(this);
 211                 ContainerFactory.createOrUpdateMisapplicationsGroup(this);
 212                 ContainerFactory.createOrUpdateConceptGroup(this);
 213
 214                 // Redraw composite
 215                 managedForm.reflow(true);
 216         }
 217
 218
 219
 220
 221         /**
 222          * <p>Getter for the field <code>taxon</code>.</p>
 223          *
 224          * @return a {@link eu.etaxonomy.cdm.model.taxon.Taxon} object.
 225          */
 226         public Taxon getTaxon() {
 227                 return (Taxon) HibernateProxyHelper.deproxy(taxon);
 228         }
 229
 230         /**
 231          * <p>setDirty</p>
 232          */
 233         public void setDirty() {
 234                 managedForm.dirtyStateChanged();
 235         }
 236
 237
 238         /*
 239          * (non-Javadoc)
 240          * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 241          */
 242         /** {@inheritDoc} */
 243         @Override
 244         public void setFocus(){
 245                 if(getSelectedContainer() == null){
 246                         throw new IllegalStateException("There should always be a selected object.");
 247                 }
 248                 getSelectedContainer().setSelected();
 249         }
 250
 251         /** {@inheritDoc} */
 252         public void setInput(IEditorInput input){
 253                 this.setInputWithNotify(input);
 254         }
 255
 256         /*
 257          * (non-Javadoc)
 258          * @see eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder()
 259          */
 260         /**
 261          * <p>getConversationHolder</p>
 262          *
 263          * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.
 264          */
 265         public ConversationHolder getConversationHolder(){
 266                 return conversation;
 267         }
 268
 269         /*
 270          * (non-Javadoc)
 271          * @see eu.etaxonomy.cdm.persistence.hibernate.ICdmPostCrudObserver#update(eu.etaxonomy.cdm.persistence.hibernate.CdmCrudEvent)
 272          */
 273         /** {@inheritDoc} */
 274         public void update(CdmDataChangeMap events) {
 275                 //redraw();
 276         }
 277
 278         /**
 279          * Redraws this editor
 280          * return true on success
 281          *
 282          * @return a boolean.
 283          */
 284         public boolean redraw(){
 285                 return redraw(true);
 286         }
 287
 288         /**
 289          * {@inheritDoc}
 290          *
 291          * Redraws the editor controls
 292          */
 293         public boolean redraw(boolean focus) {
 294
 295                 createOrUpdateNameComposites();
 296
 297                 if(focus){
 298                         setFocus();
 299                 }
 300
 301                 return true;
 302         }
 303
 304
 305         /**
 306          * <p>getMultiPageTaxonEditor</p>
 307          *
 308          * @return a {@link eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor} object.
 309          */
 310         public MultiPageTaxonEditor getMultiPageTaxonEditor() {
 311                 return editor;
 312         }
 313
 314
 315         /*
 316          * (non-Javadoc)
 317          * @see eu.etaxonomy.taxeditor.store.operations.IPostOperationEnabled#postOperation()
 318          */
 319         /** {@inheritDoc} */
 320         public boolean postOperation(CdmBase objectAffectedByOperation) {
 321
 322                 editor.changed(objectAffectedByOperation);
 323
 324                 redraw(false);
 325
 326                 if(objectAffectedByOperation instanceof TaxonBase){
 327                         objectAffectedByLastOperation = (TaxonBase) objectAffectedByOperation;
 328                 }
 329
 330                 return true;
 331         }
 332
 333         /**
 334          * <p>Getter for the field <code>managedForm</code>.</p>
 335          *
 336          * @return the managedForm
 337          */
 338         public ManagedForm getManagedForm() {
 339                 return managedForm;
 340         }
 341
 342         /**
 343          * <p>getControl</p>
 344          *
 345          * @return a {@link org.eclipse.swt.widgets.Composite} object.
 346          */
 347         public Composite getControl() {
 348                 return this.getManagedForm().getForm().getBody();
 349         }
 350
 351
 352         /**
 353          * <p>Getter for the field <code>menu</code>.</p>
 354          *
 355          * @return the menu
 356          */
 357         public Menu getMenu() {
 358                 if(menu == null || menu.isDisposed()){
 359                         // Creating the menu because it was either not initialised or disposed while refreshing the editor
 360                         menu = menuManager.createContextMenu(parent);
 361                 }
 362                 return menu;
 363         }
 364
 365         /**
 366          * <p>checkForEmptyNames</p>
 367          *
 368          * @return true if there are empty names
 369          */
 370         public boolean checkForEmptyNames() {
 371                 for(AbstractGroupedContainer container : getGroupedContainers()){
 372                         if(container.getName() == null || container.getName().getTitleCache().equals("")){
 373                                 MessageDialog.openWarning(EditorUtil.getShell(), "No Name Specified", "An attempt was made to save a taxon or synonym with " +
 374                                 "an empty name. Operation was cancelled.");
 375                                 return true;
 376                         }
 377                 }
 378                 return false;
 379         }
 380
 381         /** {@inheritDoc} */
 382         @Override
 383         public void doSave(IProgressMonitor monitor) {
 384
 385                 monitor.beginTask("Saving names", getGroupedContainers().size());
 386
 387         try {
 388                         // check for empty names
 389                         for(AbstractGroupedContainer container : getGroupedContainers()){
 390
 391                                 monitor.subTask("Saving composite: " + container.getTaxonBase().getTitleCache());
 392                                 container.persistName();
 393
 394                                 // In case the progress monitor was canceled throw an exception.
 395                                 if (monitor.isCanceled()) {
 396                         throw new OperationCanceledException();
 397                     }
 398
 399                                 // Otherwise declare this step as done.
 400                                 monitor.worked(1);
 401                         }
 402         }
 403         finally {
 404
 405                 // Stop the progress monitor.
 406                 monitor.done();
 407         }
 408
 409         }
 410
 411         /** {@inheritDoc} */
 412         @Override
 413         public void doSaveAs() {}
 414
 415         /** {@inheritDoc} */
 416         @Override
 417         public void init(IEditorSite site, IEditorInput input)
 418                         throws PartInitException {
 419
 420                 if (!(input instanceof IEditorInput))
 421                         throw new PartInitException(
 422                                 "Invalid Input: Must be IEditorInput");
 423
 424                 if (input.getAdapter(Taxon.class) != null) {
 425                         taxon = (Taxon) input.getAdapter(Taxon.class);
 426                 } else {
 427                         throw new PartInitException(
 428                                 "Invalid Input: Taxon cannot be null");
 429                 }
 430
 431                 setSite(site);
 432                 setInput(input);
 433
 434                 provider = new SimpleSelectionProvider();
 435                 getSite().setSelectionProvider(provider);
 436         }
 437
 438         /**
 439          *
 440          */
 441         private void createDragSupport() {
 442                 // Listen for names being dragged outside of existing homotypic groups -
 443                 //  user wants to create a new group
 444                 Transfer[] types = new Transfer[] {CdmDataTransfer.getInstance()};
 445                 int operations = DND.DROP_MOVE;
 446                 if(target == null){
 447                         target = new DropTarget(parent, operations);
 448                         target.setTransfer(types);
 449                         target.addDropListener(new NameEditorDropTargetListener(this));
 450                 }
 451         }
 452
 453         /**
 454          * <p>Getter for the field <code>acceptedNameContainer</code>.</p>
 455          *
 456          * @return a {@link eu.etaxonomy.taxeditor.editor.name.container.AcceptedNameContainer} object.
 457          */
 458         public AcceptedNameContainer getAcceptedNameContainer() {
 459                 return getAcceptedGroup().getAcceptedNameContainer();
 460         }
 461
 462         /**
 463          * <p>getSynonymGroup</p>
 464          *
 465          * @param homotypicalGroup a {@link eu.etaxonomy.cdm.model.name.HomotypicalGroup} object.
 466          * @return a {@link eu.etaxonomy.taxeditor.editor.name.container.HomotypicalSynonymGroup} object.
 467          */
 468         public HomotypicalSynonymGroup getHomotypicalGroupContainer(HomotypicalGroup homotypicalGroup) {
 469                 for(HomotypicalSynonymGroup group : getHeterotypicSynonymGroups()){
 470                         if(group.getGroup().equals(homotypicalGroup)){
 471                                 return group;
 472                         }
 473                 }
 474
 475                 return null;
 476         }
 477
 478         /**
 479          * <p>Getter for the field <code>conceptGroup</code>.</p>
 480          *
 481          * @return a {@link eu.etaxonomy.taxeditor.editor.name.container.ConceptGroup} object.
 482          */
 483         public ConceptGroup getConceptGroup() {
 484                 return conceptGroup;
 485         }
 486
 487         /**
 488          * <p>getDirtyNames</p>
 489          *
 490          * @return a Set containing all composites that have been edited
 491          */
 492         public Set<AbstractGroupedContainer> getDirtyNames(){
 493                 Set<AbstractGroupedContainer> dirtyNames = new HashSet<AbstractGroupedContainer>();
 494
 495                 for(AbstractGroupedContainer composite : getGroupedContainers()){
 496                         if(composite.isDirty()){
 497                                 dirtyNames.add(composite);
 498                         }
 499                 }
 500
 501                 return dirtyNames;
 502         }
 503
 504         /**
 505          * <p>getGroupedContainers</p>
 506          *
 507          * @return a {@link java.util.List} object.
 508          */
 509         public List<AbstractGroupedContainer> getGroupedContainers(){
 510                 List<AbstractGroupedContainer> groupedComposites = new ArrayList<AbstractGroupedContainer>();
 511
 512                 for(AbstractGroup group : getAllGroups()){
 513                         groupedComposites.addAll(group.getGroupedContainers());
 514                 }
 515
 516                 return groupedComposites;
 517         }
 518
 519         /**
 520          * <p>getAllGroups</p>
 521          *
 522          * @return a {@link java.util.List} object.
 523          */
 524         public List<AbstractGroup> getAllGroups(){
 525                 List<AbstractGroup> allGroups = new ArrayList<AbstractGroup>();
 526
 527                 allGroups.add(getAcceptedGroup());
 528
 529                 allGroups.addAll(getHeterotypicSynonymGroups());
 530
 531                 if(misappliedGroup != null){
 532                         allGroups.add(misappliedGroup);
 533                 }
 534
 535                 if(conceptGroup != null){
 536                         allGroups.add(conceptGroup);
 537                 }
 538
 539                 return allGroups;
 540         }
 541
 542         /* (non-Javadoc)
 543          * @see org.eclipse.ui.part.EditorPart#isDirty()
 544          */
 545         /** {@inheritDoc} */
 546         @Override
 547         public boolean isDirty() {
 548                 return editor.isDirty();
 549         }
 550
 551         /* (non-Javadoc)
 552          * @see org.eclipse.ui.part.WorkbenchPart#dispose()
 553          */
 554         /** {@inheritDoc} */
 555         @Override
 556         public void dispose() {
 557                 super.dispose();
 558         }
 559
 560         /* (non-Javadoc)
 561          * @see org.eclipse.ui.part.EditorPart#isSaveAsAllowed()
 562          */
 563         /** {@inheritDoc} */
 564         @Override
 565         public boolean isSaveAsAllowed() {
 566                 return false;
 567         }
 568
 569         /*
 570          * (non-Javadoc)
 571          * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
 572          */
 573         /** {@inheritDoc} */
 574         public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 575
 576         }
 577
 578         /**
 579          * <p>getNameEditor</p>
 580          *
 581          * @return a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
 582          */
 583         public TaxonNameEditor getEditor() {
 584                 return this;
 585         }
 586
 587         /**
 588          * <p>Getter for the field <code>selectedObject</code>.</p>
 589          *
 590          * @return a {@link eu.etaxonomy.taxeditor.editor.name.container.AbstractGroupedContainer} object.
 591          */
 592         public AbstractGroupedContainer getSelectedContainer(){
 593
 594                 TaxonBase selectedTaxonBase = null;
 595
 596                 TaxonEditorInput input = (TaxonEditorInput) editor.getEditorInput();
 597                 if(input.getInitiallySelectedTaxonBase() != null){
 598                         selectedTaxonBase = input.getInitiallySelectedTaxonBase();
 599                 }else{
 600                         if(selection != null){
 601                                 selectedTaxonBase = selection;
 602                         }
 603                 }
 604
 605                 return (selectedTaxonBase != null) ? getContainer(selectedTaxonBase) : getAcceptedNameContainer();
 606         }
 607
 608         /**
 609          * <p>dragEntered</p>
 610          */
 611         public void dragEntered() {
 612                 // TODO change this
 613                 getControl().setBackground(EditorUtil.getColor(Resources.COLOR_DRAG_ENTER));
 614         }
 615
 616         /**
 617          * <p>dragLeft</p>
 618          */
 619         public void dragLeft() {
 620                 getControl().setBackground(EditorUtil.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));
 621         }
 622
 623         /**
 624          * <p>Setter for the field <code>conceptGroup</code>.</p>
 625          *
 626          * @param conceptGroup a {@link eu.etaxonomy.taxeditor.editor.name.container.ConceptGroup} object.
 627          */
 628         public void setConceptGroup(ConceptGroup conceptGroup) {
 629                 this.conceptGroup = conceptGroup;
 630         }
 631
 632         /**
 633          * <p>setMisapplicationsGroup</p>
 634          *
 635          * @param misappliedGroup a {@link eu.etaxonomy.taxeditor.editor.name.container.MisappliedGroup} object.
 636          */
 637         public void setMisapplicationsGroup(MisappliedGroup misappliedGroup) {
 638                 this.misappliedGroup = misappliedGroup;
 639         }
 640
 641         /*
 642          * (non-Javadoc)
 643          * @see eu.etaxonomy.taxeditor.editor.IMultiPageTaxonEditorPage#isRedrawing()
 644          */
 645         /**
 646          * <p>isRedrawing</p>
 647          *
 648          * @return a boolean.
 649          */
 650         public boolean isRedrawing() {
 651                 return false;
 652         }
 653
 654         /**
 655          * <p>getToolkit</p>
 656          *
 657          * @return a {@link org.eclipse.ui.forms.widgets.FormToolkit} object.
 658          */
 659         public FormToolkit getToolkit() {
 660                 return managedForm.getToolkit();
 661         }
 662
 663         /**
 664          * <p>getHeterotypicSynonymGroups</p>
 665          *
 666          * @return a {@link java.util.List} object.
 667          */
 668         public List<HomotypicalSynonymGroup> getHeterotypicSynonymGroups(){
 669                 return heterotypicSynonymGroups;
 670         }
 671
 672
 673         /**
 674          * <p>addHeterotypicSynonymGroup</p>
 675          *
 676          * @param group a {@link eu.etaxonomy.taxeditor.editor.name.container.HomotypicalSynonymGroup} object.
 677          */
 678         public void addHeterotypicSynonymGroup(HomotypicalSynonymGroup group) {
 679                 heterotypicSynonymGroups.add(group);
 680         }
 681
 682         /**
 683          * <p>getHomotypicSynonymGroup</p>
 684          *
 685          * @return a {@link eu.etaxonomy.taxeditor.editor.name.container.HomotypicalSynonymGroup} object.
 686          */
 687         public AcceptedGroup getAcceptedGroup() {
 688                 return acceptedGroup;
 689         }
 690
 691
 692
 693         /**
 694          *
 695          * @param acceptedGroup
 696          */
 697         public void setAcceptedGroup(
 698                         AcceptedGroup acceptedGroup) {
 699                 this.acceptedGroup = acceptedGroup;
 700         }
 701
 702         /**
 703          * <p>Getter for the field <code>misappliedGroup</code>.</p>
 704          *
 705          * @return a {@link eu.etaxonomy.taxeditor.editor.name.container.MisappliedGroup} object.
 706          */
 707         public MisappliedGroup getMisappliedGroup() {
 708                 return misappliedGroup;
 709         }
 710
 711         // TODO not very useful at the moment
 712         /**
 713          * <p>isActive</p>
 714          *
 715          * @return a boolean.
 716          */
 717         public boolean isActive(){
 718                 IWorkbenchPart activePart = EditorUtil.getActivePart();
 719                 return editor.equals(activePart);
 720         }
 721
 722         /**
 723          * <p>onComplete</p>
 724          *
 725          * @return a boolean.
 726          */
 727         public boolean onComplete() {
 728                 getContainer(objectAffectedByLastOperation).setSelected();
 729                 return true;
 730         }
 731
 732
 733
 734         /** {@inheritDoc} */
 735         public void partChanged(Integer eventType, IWorkbenchPartReference partRef) {
 736                 if(! partRef.getPart(false).equals(editor)){
 737 //                      getSelectedObject().colorSelected(AbstractGroupedContainer.SELECTED_NO_FOCUS);
 738                 }
 739         }
 740
 741
 742
 743         /**
 744          * @param retainedGroup
 745          */
 746         public void removeGroup(AbstractGroup group) {
 747                 if(group != null){
 748                         group.dispose();
 749                         getHeterotypicSynonymGroups().remove(group);
 750                 }
 751         }
 752
 753
 754
 755         /**
 756          * @param element
 757          * @return
 758          */
 759         public AbstractGroupedContainer getContainer(TaxonBase taxonBase) {
 760                 List<AbstractGroupedContainer> groupedContainers = getGroupedContainers();
 761                 for(AbstractGroupedContainer container : groupedContainers){
 762                         if(container.getData().equals(taxonBase) && container.getNameViewer().getTextWidget() != null){
 763                                 return container;
 764                         }
 765                 }
 766                 return getAcceptedNameContainer();
 767         }
 768 }