eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/dnd/NameEditorDropTargetListener.java

   1 /**
   2  *
   3  */
   4 package eu.etaxonomy.taxeditor.editor.name.dnd;
   5
   6 import org.eclipse.core.runtime.Assert;
   7 import org.eclipse.swt.dnd.DND;
   8 import org.eclipse.swt.dnd.DropTargetAdapter;
   9 import org.eclipse.swt.dnd.DropTargetEvent;
  10
  11 import eu.etaxonomy.cdm.model.common.ICdmBase;
  12 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
  13 import eu.etaxonomy.cdm.model.taxon.Synonym;
  14 import eu.etaxonomy.cdm.model.taxon.Taxon;
  15 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  16 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  17 import eu.etaxonomy.taxeditor.editor.EditorUtil;
  18 import eu.etaxonomy.taxeditor.editor.IDropTargetable;
  19 import eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor;
  20 import eu.etaxonomy.taxeditor.editor.name.container.AbstractHomotypicalGroupContainer;
  21 import eu.etaxonomy.taxeditor.editor.name.container.MisappliedGroup;
  22 import eu.etaxonomy.taxeditor.editor.name.operation.ChangeConceptRelationshipTypeOperation;
  23 import eu.etaxonomy.taxeditor.editor.name.operation.ChangeConceptToSynonymOperation;
  24 import eu.etaxonomy.taxeditor.editor.name.operation.ChangeHomotypicGroupOperation;
  25 import eu.etaxonomy.taxeditor.editor.name.operation.ChangeSynonymToMisapplicationOperation;
  26 import eu.etaxonomy.taxeditor.editor.name.operation.MoveSynonymToAnotherAcceptedTaxonOperation;
  27 import eu.etaxonomy.taxeditor.model.MessagingUtils;
  28 import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
  29
  30 /**
  31  * <p>NameEditorDropTargetListener class.</p>
  32  *
  33  * @author n.hoffmann
  34  * @version $Id: $
  35  */
  36 public class NameEditorDropTargetListener extends DropTargetAdapter {
  37
  38         private IDropTargetable target;
  39
  40
  41         /**
  42          * <p>Constructor for NameEditorDropTargetListener.</p>
  43          *
  44          * @param target a {@link eu.etaxonomy.taxeditor.editor.IDropTargetable} object.
  45          */
  46         public NameEditorDropTargetListener(IDropTargetable target){
  47                 this.target = target;
  48         }
  49
  50         /** {@inheritDoc} */
  51         public void dragEnter(DropTargetEvent dropTargetEvent) {
  52                 target.dragEntered();
  53
  54 //              if(! EditorUtil.getActiveMultiPageTaxonEditor().equals(editor.getMultiPageTaxonEditor())){
  55 //                      editor.getMultiPageTaxonEditor().setFocus();
  56 //              }
  57         }
  58
  59         /** {@inheritDoc} */
  60         public void dragLeave(DropTargetEvent dropTargetEvent) {
  61                 target.dragLeft();
  62         }
  63
  64         /** {@inheritDoc} */
  65         public void drop(DropTargetEvent dropTargetEvent) {
  66
  67                 TaxonBase taxonBase = getDroppedTaxonBase(dropTargetEvent);
  68
  69                 Assert.isNotNull(taxonBase);
  70
  71                 if(taxonBase.getHomotypicGroup().equals(getHomotypicalGroup())){
  72                         // do nothing when dragged to the same group
  73                         dropTargetEvent.detail = DND.DROP_NONE;
  74                         return;
  75                 }
  76
  77                 // Execute operations at end of drag event
  78                 AbstractPostOperation operation = createOperation(taxonBase);
  79
  80                 // Execute operation if it has been initiated
  81                 if (operation == null) {
  82                         MessagingUtils.warn(getClass(), "User unsuccessfully tried to drop: " + taxonBase.getClass() +
  83                                         ". Target: " + target);
  84                         dropTargetEvent.detail = DND.DROP_NONE;
  85                 } else {
  86                         EditorUtil.executeOperation(operation);
  87                 }
  88                 target.getEditor().getConversationHolder().commit();
  89                 if (!target.equals(EditorUtil.getActiveMultiPageTaxonEditor().getActiveEditor())){
  90                         ((TaxonNameEditor)EditorUtil.getActiveMultiPageTaxonEditor().getActiveEditor()).redraw();
  91                         ((TaxonNameEditor)EditorUtil.getActiveMultiPageTaxonEditor().getActiveEditor()).getConversationHolder().commit();
  92
  93                 }
  94                 target.getEditor().redraw();
  95
  96         }
  97
  98         private AbstractPostOperation createOperation(TaxonBase taxonBase) {
  99
 100                 if(taxonBase instanceof Synonym){
 101                         Synonym synonym = (Synonym) taxonBase;
 102
 103                         if(target instanceof AbstractHomotypicalGroupContainer){
 104                                 HomotypicalGroup homotypicalGroup = ((AbstractHomotypicalGroupContainer) target).getGroup();
 105
 106                                 return new ChangeHomotypicGroupOperation("Change Homotypical Group", getEditor().getUndoContext(),
 107                                                 getEditor().getTaxon(), synonym, homotypicalGroup, target);
 108                         }
 109                         else if(target instanceof MisappliedGroup){
 110                                 return new ChangeSynonymToMisapplicationOperation("Change Synonym to Misapplication", getEditor().getUndoContext(),
 111                                                 getEditor().getTaxon(), synonym, target);
 112                         }
 113                         else if(target instanceof TaxonNameEditor){
 114                                 if (target.equals(getEditor())){
 115                                         return new ChangeHomotypicGroupOperation("Change Homotypical Group", getEditor().getUndoContext(),
 116                                                 getEditor().getTaxon(), synonym, null, target);
 117                                 } else{
 118                                         getEditor().getConversationHolder().commit();
 119                                         ((TaxonNameEditor) target).getConversationHolder().commit();
 120
 121                                         return new MoveSynonymToAnotherAcceptedTaxonOperation("Change accepted Taxon", getEditor().getUndoContext(), getEditor().getTaxon().getUuid(), synonym.getUuid(), ((TaxonNameEditor) target).getTaxon(), null );
 122
 123                                 }
 124                         }
 125
 126                 }else if(taxonBase instanceof Taxon){
 127                         Taxon concept = (Taxon) taxonBase;
 128
 129                         if(target instanceof AbstractHomotypicalGroupContainer){
 130                                 HomotypicalGroup homotypicalGroup = ((AbstractHomotypicalGroupContainer) target).getGroup();
 131
 132                                 return new ChangeConceptToSynonymOperation("Change to Synonym", getEditor().getUndoContext(),
 133                                                 getEditor().getTaxon(), concept, homotypicalGroup, target);
 134                         }
 135                         else if(target instanceof MisappliedGroup ){
 136                                 return new ChangeConceptRelationshipTypeOperation("Change", getEditor().getUndoContext(),
 137                                                 getEditor().getTaxon(), concept, TaxonRelationshipType.MISAPPLIED_NAME_FOR(), target);
 138                         }
 139                 }
 140
 141
 142                 return null;
 143         }
 144
 145         /** {@inheritDoc} */
 146         @Override
 147         public void dropAccept(DropTargetEvent event) {
 148                 // pass
 149         }
 150
 151
 152         private HomotypicalGroup getHomotypicalGroup() {
 153                 if(target instanceof AbstractHomotypicalGroupContainer){
 154                         return ((AbstractHomotypicalGroupContainer) target).getGroup();
 155                 }
 156                 return null;
 157         }
 158
 159         private TaxonBase getDroppedTaxonBase(DropTargetEvent dropTargetEvent){
 160                 if(dropTargetEvent.data instanceof ICdmBase[]){
 161
 162                         ICdmBase[] cdmBaseObjects = (ICdmBase[]) dropTargetEvent.data;
 163
 164                         if(cdmBaseObjects[0] instanceof TaxonBase){
 165                                 return (TaxonBase) cdmBaseObjects[0];
 166                         }
 167                 }
 168                 return null;
 169         }
 170
 171         /**
 172          * @return
 173          *
 174          */
 175         private TaxonNameEditor getEditor() {
 176                 return (TaxonNameEditor) EditorUtil.getActiveMultiPageTaxonEditor().getActiveEditor();
 177         }
 178 }