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

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