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

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