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