tweak dragging

src/dnd/ElementDragging.ts

@@ -24,9 +24,8 @@ export default abstract class ElementDragging {
   destroy() {
   }
 
-  setIgnoreMove(bool: boolean) {
-    // optional. used for optimization
-  }
+  // if given true, should prevent dragstart+dragmove+dragend from firing
+  abstract setIgnoreMove(bool: boolean)
 
   setMirrorIsVisible(bool: boolean) {
     // optional if subclass doesn't want to support a mirror

src/interactions-external/DumbElementDragging.ts

@@ -13,6 +13,7 @@ export default class DumbElementDragging extends ElementDragging {
   options: any
   pointer: PointerDragging
   currentMirrorEl: HTMLElement
+  shouldIgnoreMove: boolean = false
 
   constructor(options) {
     super()
@@ -32,16 +33,28 @@ export default class DumbElementDragging extends ElementDragging {
 
   handlePointerDown = (ev: PointerDragEvent) => {
     this.emitter.trigger('pointerdown', ev)
-    this.emitter.trigger('dragstart', ev)
+
+    if (!this.shouldIgnoreMove) {
+      this.emitter.trigger('dragstart', ev)
+    }
   }
 
   handlePointerMove = (ev: PointerDragEvent) => {
-    this.emitter.trigger('dragmove', ev)
+    if (!this.shouldIgnoreMove) {
+      this.emitter.trigger('dragmove', ev)
+    }
   }
 
   handlePointerUp = (ev: PointerDragEvent) => {
     this.emitter.trigger('pointerup', ev)
-    this.emitter.trigger('dragend', ev)
+
+    if (!this.shouldIgnoreMove) {
+      this.emitter.trigger('dragend', ev)
+    }
+  }
+
+  setIgnoreMove(bool: boolean) {
+    this.shouldIgnoreMove = bool
   }
 
   setMirrorIsVisible(bool: boolean) {

src/interactions-external/ExternalElementDragging.ts

@@ -19,7 +19,7 @@ export default class ExternalElementDragging {
 
   constructor(dragging: ElementDragging, rawEventCreationData?) {
     let hitDragging = this.hitDragging = new HitDragging(dragging, globalContext.componentHash)
-    hitDragging.dieIfNoInitial = false
+    hitDragging.requireInitial = false
     hitDragging.emitter.on('dragstart', this.onDragStart)
     hitDragging.emitter.on('hitover', this.onHitOver)
     hitDragging.emitter.on('hitout', this.onHitOut)

src/interactions/EventDragging.ts

@@ -25,7 +25,7 @@ export default class EventDragging {
     this.dragging.touchScrollAllowed = false
 
     let hitDragging = this.hitDragging = new HitDragging(this.dragging, globalContext.componentHash)
-    hitDragging.subjectCenter = true
+    hitDragging.useSubjectCenter = true
     hitDragging.emitter.on('pointerdown', this.onPointerDown)
     hitDragging.emitter.on('dragstart', this.onDragStart)
     hitDragging.emitter.on('hitover', this.onHitOver)

src/interactions/HitDragging.ts

@@ -29,15 +29,14 @@ export default class HitDragging {
   emitter: EmitterMixin
 
   // options that can be set by caller
-  subjectCenter: boolean = false
-  dieIfNoInitial: boolean = true
+  useSubjectCenter: boolean = false
+  requireInitial: boolean = true
 
   // internal state
   initialHit: Hit
   movingHit: Hit
   finalHit: Hit // won't ever be populated if shouldIgnoreMove
   coordAdjust: any
-  isIgnoringMove: boolean = false
 
   constructor(dragging: ElementDragging, droppable: DateComponent | DateComponentHash) {
 
@@ -58,6 +57,8 @@ export default class HitDragging {
   }
 
   handlePointerDown = (ev: PointerDragEvent) => {
+    let { dragging } = this
+
     this.initialHit = null
     this.movingHit = null
     this.finalHit = null
@@ -65,14 +66,10 @@ export default class HitDragging {
     this.prepareComponents()
     this.processFirstCoord(ev)
 
-    let { dragging } = this
-
-    if (this.initialHit || !this.dieIfNoInitial) {
-      this.isIgnoringMove = false
+    if (this.initialHit || !this.requireInitial) {
       dragging.setIgnoreMove(false)
       this.emitter.trigger('pointerdown', ev)
     } else {
-      this.isIgnoringMove = true
       dragging.setIgnoreMove(true)
     }
   }
@@ -93,7 +90,7 @@ export default class HitDragging {
     let initialHit = this.initialHit = this.queryHit(adjustedPoint.left, adjustedPoint.top)
 
     if (initialHit) {
-      if (this.subjectCenter && subjectRect) {
+      if (this.useSubjectCenter && subjectRect) {
         let slicedSubjectRect = intersectRects(subjectRect, initialHit.rect)
         if (slicedSubjectRect) {
           adjustedPoint = getRectCenter(slicedSubjectRect)
@@ -107,23 +104,17 @@ export default class HitDragging {
   }
 
   handleDragStart = (ev: PointerDragEvent) => {
-    if (!this.isIgnoringMove) {
-      this.emitter.trigger('dragstart', ev)
-      this.handleMove(ev)
-    }
+    this.emitter.trigger('dragstart', ev)
+    this.handleMove(ev)
   }
 
   handleDragMove = (ev: PointerDragEvent) => {
-    if (!this.isIgnoringMove) {
-      this.emitter.trigger('dragmove', ev)
-      this.handleMove(ev)
-    }
+    this.emitter.trigger('dragmove', ev)
+    this.handleMove(ev)
   }
 
   handlePointerUp = (ev: PointerDragEvent) => {
-    if (!this.isIgnoringMove) { // cancelled in handlePointerDown?
-      this.emitter.trigger('pointerup', ev)
-    }
+    this.emitter.trigger('pointerup', ev)
   }
 
   handleDragEnd = (ev: PointerDragEvent) => {