eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/derivate/DerivateDropListener.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2014 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10 package eu.etaxonomy.taxeditor.editor.view.derivate;
  11
  12 import org.eclipse.jface.util.LocalSelectionTransfer;
  13 import org.eclipse.jface.viewers.IStructuredSelection;
  14 import org.eclipse.jface.viewers.TreeNode;
  15 import org.eclipse.jface.viewers.ViewerDropAdapter;
  16 import org.eclipse.swt.dnd.TransferData;
  17
  18 import eu.etaxonomy.cdm.model.molecular.Amplification;
  19 import eu.etaxonomy.cdm.model.molecular.DnaSample;
  20 import eu.etaxonomy.cdm.model.molecular.Sequence;
  21 import eu.etaxonomy.cdm.model.molecular.SingleRead;
  22 import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
  23 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  24 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  25 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
  26
  27 /**
  28  * @author pplitzner
  29  * @date 18.03.2014
  30  *
  31  */
  32 public class DerivateDropListener extends ViewerDropAdapter {
  33
  34     private final DerivateView derivateView;
  35
  36     /**
  37      * @param derivateView
  38      */
  39     protected DerivateDropListener(DerivateView derivateView) {
  40         super(derivateView.viewer);
  41         this.derivateView = derivateView;
  42     }
  43
  44     /* (non-Javadoc)
  45      * @see org.eclipse.jface.viewers.ViewerDropAdapter#performDrop(java.lang.Object)
  46      */
  47     @Override
  48     public boolean performDrop(Object data) {
  49         Object target = getCurrentTarget();
  50         if(target instanceof TreeNode && data instanceof IStructuredSelection && ((IStructuredSelection) data).size()==1 && ((IStructuredSelection) data).getFirstElement() instanceof TreeNode){
  51             TreeNode targetNode = (TreeNode) target;
  52             TreeNode draggednode = (TreeNode) ((IStructuredSelection) data).getFirstElement();
  53             if(moveDropTarget(draggednode, targetNode)){
  54                 derivateView.changed(null);
  55                 return true;
  56             }
  57         }
  58         return false;
  59     }
  60
  61     /* (non-Javadoc)
  62      * @see org.eclipse.jface.viewers.ViewerDropAdapter#validateDrop(java.lang.Object, int, org.eclipse.swt.dnd.TransferData)
  63      */
  64     @Override
  65     public boolean validateDrop(Object target, int operation, TransferData transferType) {
  66         return LocalSelectionTransfer.getTransfer().isSupportedType(transferType) && target instanceof TreeNode;
  67     }
  68
  69     /**
  70      * @param value
  71      * @return
  72      */
  73     private boolean moveDropTarget(TreeNode draggedObject, TreeNode target) {
  74         Object dragValue = draggedObject.getValue();
  75         Object targetValue = target.getValue();
  76         TreeNode dragParentNode = draggedObject.getParent();
  77         Object dragParentSpecimen = dragParentNode.getValue();
  78
  79         // drag'n'drop for SpecimenOrObservationBase
  80         if(dragValue instanceof DerivedUnit && targetValue instanceof SpecimenOrObservationBase<?>){
  81             DerivedUnit draggedSpecimen = (DerivedUnit) dragValue;
  82             SpecimenOrObservationBase<?> targetSpecimen = (SpecimenOrObservationBase<?>) targetValue;
  83             SpecimenOrObservationType dragType = draggedSpecimen.getRecordBasis();
  84             SpecimenOrObservationType targetType = targetSpecimen.getRecordBasis();
  85             //check if type is a sub derivate type
  86             if(!dragParentNode.equals(target) //don't drag on direct parent node
  87                     && (targetType==SpecimenOrObservationType.FieldUnit //dragging on FieldUnit always works (except when direct parent)
  88                     || (dragType.isKindOf(targetType) && targetType!=dragType))){ //dragging only on parent derivate type
  89                 //remove derivation event from parent specimen of dragged object
  90                 DerivationEvent eventToRemove = null;
  91                 if(dragParentSpecimen instanceof SpecimenOrObservationBase<?>){
  92                     SpecimenOrObservationBase<?> parentDragSpecimen = (SpecimenOrObservationBase<?>) dragParentSpecimen;
  93                     for(DerivationEvent event:parentDragSpecimen.getDerivationEvents()){
  94                         if(event.getDerivatives().contains(draggedSpecimen)){
  95                             eventToRemove = event;
  96                             break;
  97                         }
  98                     }
  99                     parentDragSpecimen.removeDerivationEvent(eventToRemove);
 100                 }
 101                 //add new derivation event to target
 102                 targetSpecimen.addDerivationEvent(DerivationEvent.NewSimpleInstance(targetSpecimen, draggedSpecimen, eventToRemove==null?null:eventToRemove.getType()));
 103                 return true;
 104             }
 105         }
 106
 107         // drag'n'drop for SingleRead
 108         else if(dragValue instanceof SingleRead && (targetValue instanceof Amplification || targetValue instanceof Sequence)){
 109             SingleRead singleRead = (SingleRead) dragValue;
 110             if(dragParentSpecimen instanceof Amplification){
 111                 Amplification amplification = (Amplification) dragParentSpecimen;
 112                 if(amplification.getSingleReads().size()<2){
 113                     return false;
 114                 }
 115                 else{
 116                     //remove dragged single read (if not the last one)
 117                     amplification.removeSingleRead(singleRead);
 118                 }
 119             }
 120             //drop on Sequence
 121             if(targetValue instanceof Sequence){
 122                 Sequence sequence = (Sequence)targetValue;
 123                 sequence.addSingleRead(singleRead);
 124                 //remove dragged single read
 125                 if(dragParentSpecimen instanceof Sequence){
 126                     ((Sequence) dragParentSpecimen).removeSingleRead(singleRead);
 127                 }
 128             }
 129             //drop on Amplification
 130             else if(targetValue instanceof Amplification){
 131                 Amplification amplification = (Amplification)targetValue;
 132                 amplification.addSingleRead(singleRead);
 133             }
 134             return true;
 135         }
 136
 137         // drag'n'drop for Sequence
 138         else if(dragValue instanceof Sequence && targetValue instanceof DnaSample ){
 139             Sequence sequence = (Sequence)dragValue;
 140             //remove dragged sequence
 141             if(dragParentSpecimen instanceof DnaSample){
 142                 ((DnaSample) dragParentSpecimen).removeSequence(sequence);
 143             }
 144             //drop on DnaSample
 145             ((DnaSample) targetValue).addSequence(sequence);
 146             return true;
 147         }
 148         return false;
 149     }
 150
 151 }