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