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