Dragging is moving while touching.

@this Gesture
@param   {function} register - Hammer register function.
@param   {function} slot - Function to call when the event occurs.
@param   {any} args - Any argument to send to the slot.
@returns {undefined}
500242
function onDrag( register, slot, args ) {
    const that = this;

    register( 'hammer.pan', function ( evt ) {
        if ( evt.isFinal ) return false;
        setHammerXY( that.$, evt );
        if ( typeof that._dragX === 'undefined' ) {
            that._dragX = evt.x;
            that._dragY = evt.y;
            that._dragStart = true;
        }
        setHammerVxVy.call( that, that.$, evt );
        const domEvt = evt.srcEvent;
        slot( {
            x: evt.x,
            y: evt.y,
            x0: evt.x0,
            y0: evt.y0,
            vx: evt.vx,
            vy: evt.vy,
            sx: evt.velocityX,
            sy: evt.velocityY,
            event: evt,
            target: evt.target,
            buttons: getButtons( evt ),
            preventDefault: domEvt.preventDefault.bind( domEvt ),
            stopPropagation: domEvt.stopImmediatePropagation.bind( domEvt )
        }, args );
        return true;
    } );
}
1027387
def drag(*args, function = move):
    

    x, y = win32api.GetCursorPos()
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, x, y, 0, 0)
    function(*args)
    x, y = win32api.GetCursorPos()
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, x, y, 0, 0)
1268905
function onDrag(target, innerTarget, dir, listener) { // eslint-disable-line max-params
	const hasPointerEvent = undefined !== target.onpointerup;
	const hasTouchEvent   = undefined !== target.ontouchstart;
	const pointerDown = hasPointerEvent ? 'pointerdown' : hasTouchEvent ? 'touchstart' : 'mousedown';
	const pointerMove = hasPointerEvent ? 'pointermove' : hasTouchEvent ? 'touchmove' : 'mousemove';
	const pointerUp   = hasPointerEvent ? 'pointerup'   : hasTouchEvent ? 'touchend' : 'mouseup';

	// ...
	const dirIsInline = /^(ltr|rtl)$/i.test(dir);
	const dirIsStart  = /^(ltr|ttb)$/i.test(dir);

	// ...
	const axisProp = dirIsInline ? 'clientX' : 'clientY';

	let window, start, end;

	// on pointer down
	target.addEventListener(pointerDown, onpointerdown);

	function onpointerdown(event) {
		// window
		window = target.ownerDocument.defaultView;

		// client boundaries
		const rect = innerTarget.getBoundingClientRect();

		// the container start and end coordinates
		start = dirIsInline ? rect.left : rect.top;
		end   = dirIsInline ? rect.right : rect.bottom;

		onpointermove(event);

		window.addEventListener(pointerMove, onpointermove);
		window.addEventListener(pointerUp, onpointerup);
	}

	function onpointermove(event) {
		// prevent browser actions on this event
		event.preventDefault();

		// the pointer coordinate
		const position = axisProp in event ? event[axisProp] : event.touches && event.touches[0] && event.touches[0][axisProp] || 0;

		// the percentage of the pointer along the container
		const percentage = (dirIsStart ? position - start : end - position) / (end - start);

		// call the listener with percentage
		listener(percentage);
	}

	function onpointerup() {
		window.removeEventListener(pointerMove, onpointermove);
		window.removeEventListener(pointerUp, onpointerup);
	}
}
1372444
function register(handle) {
  if (Array.isArray(handle)) {
    handle.forEach(item => {
      utils.register(item);
    });
  } else {
    utils.register(handle);
  }
}
908455
function (point, win, last) {
		var el = elementFromPoint(point, win);
		
		if (last !== el && el && last) {
			var options = syn.helpers.extend({}, point);

			// QUESTION: Should we also be sending a pointerleave event?
			options.relatedTarget = el;
			if(syn.support.pointerEvents){
				syn.trigger(last, 'pointerout', options);
				syn.trigger(last, 'pointerleave', options);
			}
			syn.trigger(last, "mouseout", options);
			syn.trigger(last, "mouseleave", options);

			options.relatedTarget = last;
			if(syn.support.pointerEvents){
				syn.trigger(el, 'pointerover', options);
				syn.trigger(el, 'pointerenter', options);
			}
			syn.trigger(el, "mouseover", options);
			syn.trigger(el, "mouseenter", options);
		}

		if(syn.support.pointerEvents){syn.trigger(el || win, "pointermove", point);}
		if(syn.support.touchEvents){syn.trigger(el || win, "touchmove", point);}
		
		//console.log("DRAGGED: " + DragonDrop.html5drag);
		
		/* 
			The following code needs some explanation. Firefox and Chrome DO NOT issue mousemove events during HTML5-dragdrops
			However, they do issue mousemoves during jQuery-dragdrops. I am making the assumption here (which may or may not 
			be valid - let me know if it is wrong and I'll adjust,) that all PointerEvent-type browsers DO NOT issue
			mousemoves during HTML5-dragdrop, but DO issue during jQuery.
		*/
		if(DragonDrop.html5drag){
			if(!syn.support.pointerEvents){ syn.trigger(el || win, "mousemove", point); }	
		}else{
			syn.trigger(el || win, "mousemove", point);
		}
		
		
		return el;
	}
1087102
async def delTrigger(self, iden):
        '''
        
        '''
        trig = self.cell.triggers.get(iden)
        self._trig_auth_check(trig.get('useriden'))
        self.cell.triggers.delete(iden)
1242974
function leftButtonStartDrag(cm,event,pos,behavior){var display=cm.display,moved=false;var dragEnd=operation(cm,function(e){if(webkit){display.scroller.draggable=false;}cm.state.draggingText=false;off(document,"mouseup",dragEnd);off(document,"mousemove",mouseMove);off(display.scroller,"dragstart",dragStart);off(display.scroller,"drop",dragEnd);if(!moved){e_preventDefault(e);if(!behavior.addNew){extendSelection(cm.doc,pos,null,null,behavior.extend);}// Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
if(webkit||ie&&ie_version==9){setTimeout(function(){document.body.focus();display.input.focus();},20);}else{display.input.focus();}}});var mouseMove=function mouseMove(e2){moved=moved||Math.abs(event.clientX-e2.clientX)+Math.abs(event.clientY-e2.clientY)>=10;};var dragStart=function dragStart(){return moved=true;};// Let the drag handler handle this.
if(webkit){display.scroller.draggable=true;}cm.state.draggingText=dragEnd;dragEnd.copy=!behavior.moveOnDrag;// IE's approach to draggable
if(display.scroller.dragDrop){display.scroller.dragDrop();}on(document,"mouseup",dragEnd);on(document,"mousemove",mouseMove);on(display.scroller,"dragstart",dragStart);on(display.scroller,"drop",dragEnd);delayBlurEvent(cm);setTimeout(function(){return display.input.focus();},20);}
1036034
function(type, event, ui) {
		ui = ui || this._uiHash();
		$.ui.plugin.call(this, type, [event, ui]);
		if(type == "drag") this.positionAbs = this._convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins
		return $.Widget.prototype._trigger.call(this, type, event, ui);
	}
874701
def elicit_slot!(slot_to_elicit, skip_render: false)
      directives << {
        type: "Dialog.ElicitSlot",
        slotToElicit: slot_to_elicit
      }

      if skip_render
        @slots_to_not_render_elicitation << slot_to_elicit
      end
    end
50999
function startDetect(inst, eventData) {
    // already busy with a Hammer.gesture detection on an element
    if(this.current) {
      return;
    }

    this.stopped = false;

    // holds current session
    this.current = {
      inst              : inst, // reference to HammerInstance we're working for
      startEvent        : Utils.extend({}, eventData), // start eventData for distances, timing etc
      lastEvent         : false, // last eventData
      lastVelocityEvent : false, // last eventData for velocity.
      velocity          : false, // current velocity
      name              : '' // current gesture we're in/detected, can be 'tap', 'hold' etc
    };

    this.detect(eventData);
  }
828350
function bindSwipeMove() {
      var _this2 = this;

      Binder.on(MOVE_EVENTS, Components.Html.wrapper, throttle(function (event) {
        _this2.move(event);
      }, Glide.settings.throttle), capture);
    }
695276
function setup() {
  if(Hammer.READY) {
    return;
  }

  // find what eventtypes we add listeners to
  Hammer.event.determineEventTypes();

  // Register all gestures inside Hammer.gestures
  Hammer.utils.each(Hammer.gestures, function(gesture){
    Hammer.detection.register(gesture);
  });

  // Add touch events on the document
  Hammer.event.onTouch(Hammer.DOCUMENT, Hammer.EVENT_MOVE, Hammer.detection.detect);
  Hammer.event.onTouch(Hammer.DOCUMENT, Hammer.EVENT_END, Hammer.detection.detect);

  // Hammer is ready...!
  Hammer.READY = true;
}
1248115
function registerInteractionHandler(fnHandler) {
			var aSuppressHandler = [],
				oParentDOM = this.$parent.get(0),
				oBlockLayerDOM = this.$blockLayer.get(0);

			for (var i = 0; i < aPreventedEvents.length; i++) {
				// Add event listeners with "useCapture" settings to suppress events before dispatching/bubbling starts
				oParentDOM.addEventListener(aPreventedEvents[i], fnHandler, {
					capture: true,
					passive: false
				});
				aSuppressHandler.push(EventTriggerHook.suppress(aPreventedEvents[i], oParentDOM, oBlockLayerDOM));
			}
			//for jQuery triggered events we also need the keydown handler
			this.$blockLayer.bind('keydown', fnHandler);

			return aSuppressHandler;
		}
897053
function getCurrentTarget( slot ) {
  if( !G.target ) return null;
  for( var i = 0 ; i < G.target.length ; i++ ) {
    var target = G.target[i];
    if( !slot || typeof target.slots[slot] === 'function' ) return target;
  }
  return null;
}
323554
public void f(int i, Object... args) {
    setIndex(i);
    setArguments(args);
    if (args.length == 1 && args[0] instanceof JavaScriptObject) {
      if (JsUtils.isElement((JavaScriptObject) args[0])) {
        setElement((com.google.gwt.dom.client.Element) args[0]);
        f(getElement(), i);
      } else if (JsUtils.isEvent((JavaScriptObject) args[0])) {
        setEvent((Event) args[0]);
        f(getEvent());
      } else {
        f();
      }
    }
  }
991651
function dragInit(event) {
            var isTouch = event.type === 'touchstart',
                source = event.data.source,
                isSlidee = source === 'slidee';

            // Ignore other than left mouse button
            if (isTouch || event.which <= 1) {
                stopDefault(event);

                // Update a dragging object
                dragging.source   = source;
                dragging.$source  = $(event.target);
                dragging.init     = 0;
                dragging.released = 0;
                dragging.touch    = isTouch;
                dragging.initLoc  = (isTouch ? event.originalEvent.touches[0] : event)[o.horizontal ? 'pageX' : 'pageY'];
                dragging.initPos  = isSlidee ? pos.cur : hPos.cur;
                dragging.start    = +new Date();
                dragging.time     = 0;
                dragging.path     = 0;
                dragging.pathMin  = isSlidee ? -dragging.initLoc : -hPos.cur;
                dragging.pathMax  = isSlidee ? document[o.horizontal ? 'width' : 'height'] - dragging.initLoc : hPos.end - hPos.cur;

                // Add dragging class
                (isSlidee ? $slidee : $handle).addClass(o.draggedClass);

                // Bind dragging events
                $doc.on(isTouch ? dragTouchEvents : dragMouseEvents, dragHandler);
            }
        }
231650
function trigger(touches, element, type) {
        return Simulator.events[Simulator.type].trigger(touches, element, type);
    }