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