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