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