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