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