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