Action to do on drag start.

@param startPoint Point where the drag was started.
@param evt The event object
@return {@code true} to start the drag operation
165601
protected boolean startDrag(SVGPoint startPoint, Event evt) {
    if (listener != null) {
      return listener.startDrag(startPoint, evt);
    }
    return true;
  }
1001509
@Handler
    public void onStart(Start event) {
        synchronized (this) {
            if (runner != null && !runner.isInterrupted()) {
                return;
            }
            runner = new Thread(this, Components.simpleObjectName(this));
            runner.start();
        }
    }
1327096
function(evt) {
        evt.preventDefault();
        evt.stopPropagation();

        //Detect if finger moves too much for it to be considered a tap
        var {x1, y1, time} = tapStart;
        var x2 = evt.touches[0].pageX;
        var y2 = evt.touches[0].pageY;
        var dx = x2 - x1;
        var dy = y2 - y1;
        tapDiff = Math.sqrt(dx * dx + dy * dy);

        //Detect if it's moved too little in too short a time to be considered a pan
        if((new Date() - tapStart.timeStart < tapDuration) && tapDiff <= 2){
          return;
        }

        if (debug) { timedLog("panmove"); }
        if (!transform.x1 && !transform.y1) {
          return;
        }
        if (evt.touches && evt.touches.length > 1) {
          return handlers.handleTouchRepositioning(evt);
        }
        if (debug) { timedLog("panmove - continued"); }

        var x = evt.clientX || evt.touches[0].pageX,
          y = evt.clientY || evt.touches[0].pageY;

        transform.modified = true;
        positionable.handleTranslation(x - transform.x1 + mark.x, y - transform.y1 + mark.y);
      }
862508
function JssorSliderDragEndEventHandler(position, virtualPosition, startPosition, virtualStartPosition, event) {
    //position: real position of the carousel
    //startPosition: real position that drag starts at
    //virtualPosition: virtual position of the carousel
    //virtualStartPosition; virtual position that drag starts at
    //event: native event fired by browser

    var args = [position, virtualPosition, startPosition, virtualStartPosition, "event"];
    console.log(" args: " + args.join(","));
    console.log("$LastDragSucceeded: " + jssor_1_slider.$LastDragSucceeded());
}
469606
function(evt) {
        if (this.started && !OpenLayers.Event.isMultiTouch(evt)) {
            this.started = false;
            this.pinching = false;
            this.callback("done", [evt, this.start, this.last]);
            this.start = null;
            this.last = null;
            return false;
        }
        return true;
    }
647973
function () {
        var self = this, startPos;

        setTimeout(function () {
          self.classes.add('in');
          self.fire('open');
        }, 0);

        self._super();

        if (self.statusbar) {
          self.statusbar.postRender();
        }

        self.focus();

        this.dragHelper = new DragHelper(self._id + '-dragh', {
          start: function () {
            startPos = {
              x: self.layoutRect().x,
              y: self.layoutRect().y
            };
          },

          drag: function (e) {
            self.moveTo(startPos.x + e.deltaX, startPos.y + e.deltaY);
          }
        });

        self.on('submit', function (e) {
          if (!e.isDefaultPrevented()) {
            self.close();
          }
        });

        windows.push(self);
        toggleFullScreenState(true);
      }
573921
function setStartPoint() {
            if (!startPoint || !startPoint.tagName || (startPoint.tagName.toLowerCase() !== 'td' && startPoint.tagName.toLowerCase() !== 'th')) {
                console.error('Impossible to identify start Cell point.', startPoint);
                return;
            }
            _startPoint.colPos = startPoint.cellIndex;
            if (!startPoint.parentElement || !startPoint.parentElement.tagName || startPoint.parentElement.tagName.toLowerCase() !== 'tr') {
                console.error('Impossible to identify start Row point.', startPoint);
                return;
            }
            _startPoint.rowPos = startPoint.parentElement.rowIndex;
        }
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);
            }
        }
523524
function(evt) {
    L.DomEvent.stop(evt);
    // undo container transform
    this._path._resetTransform();
    // apply matrix
    this._transformPoints(this._matrix);

    this._path._map
      .off('mousemove', this._onDrag, this)
      .off('mouseup', this._onDragEnd, this);

    // consistency
    this._path.fire('dragend', {
      distance: Math.sqrt(
        L.LineUtil._sqDist(this._dragStartPoint, evt.containerPoint)
      )
    });

    this._matrix = null;
    this._startPoint = null;
    this._dragStartPoint = null;
  }
764324
protected void _initPathStartPoint() {
		_touch();
		if (m_moveToPoint == null)
			m_moveToPoint = new Point(m_description);
		else
			m_moveToPoint.assignVertexDescription(m_description);
	}
1204644
function(e) {
        if (this._dragging) return;
        this._dragging = true;

        // TODO: remove this and instead lock on pointer control events in future
        Crafty.s("Mouse").bind("MouseMove", this._ondrag);
        Crafty.s("Mouse").bind("MouseUp", this._onup);

        // if event undefined, use the last known position of the mouse
        this.trigger("StartDrag", e || Crafty.s("Mouse").lastMouseEvent);
        return this;
    }
824403
def canvasPressEvent(self, e):
        
        self.start_point = self.toMapCoordinates(e.pos())
        self.end_point = self.start_point
        self.is_emitting_point = True

        self.show_rectangle(self.start_point, self.end_point)
335446
function(evt) {
    this._startPoint = evt.containerPoint.clone();
    this._dragStartPoint = evt.containerPoint.clone();
    this._matrix = [1, 0, 0, 1, 0, 0];

    this._path._map
      .on('mousemove', this._onDrag, this)
      .on('mouseup', this._onDragEnd, this)
    this._path._dragMoved = false;
  }
749173
function(e, oDD) {
            //this._activateShim();

            this.currentTarget = YAHOO.util.Event.getTarget(e);

            this.dragCurrent = oDD;

            var el = oDD.getEl();

            // track start position
            this.startX = YAHOO.util.Event.getPageX(e);
            this.startY = YAHOO.util.Event.getPageY(e);

            this.deltaX = this.startX - el.offsetLeft;
            this.deltaY = this.startY - el.offsetTop;

            this.dragThreshMet = false;

            this.clickTimeout = setTimeout( 
                    function() { 
                        var DDM = YAHOO.util.DDM;
                        DDM.startDrag(DDM.startX, DDM.startY);
                        DDM.fromTimeout = true;
                    }, 
                    this.clickTimeThresh );
        }
587501
@Handler
    public void onStart(Start event) {
        synchronized (this) {
            if (runner != null) {
                return;
            }
            buffers = new ManagedBufferPool<>(ManagedBuffer::new,
                () -> {
                    return ByteBuffer.allocateDirect(bufferSize);
                }, 2);
            runner = new Thread(this, Components.simpleObjectName(this));
            // Because this cannot reliably be stopped, it doesn't prevent
            // shutdown.
            runner.setDaemon(true);
            runner.start();
        }
    }
937437
@Override public boolean onTouchEvent(MotionEvent ev) {
    int actionMasked = MotionEventCompat.getActionMasked(ev);
    if ((actionMasked & MotionEventCompat.ACTION_MASK) == MotionEvent.ACTION_DOWN) {
      activePointerId = MotionEventCompat.getPointerId(ev, actionMasked);
    }
    if (activePointerId == INVALID_POINTER) {
      return false;
    }
    viewDragHelper.processTouchEvent(ev);
    if (isClosed()) {
      return false;
    }
    boolean isDragViewHit = isViewHit(dragView, (int) ev.getX(), (int) ev.getY());
    boolean isSecondViewHit = isViewHit(secondView, (int) ev.getX(), (int) ev.getY());
    analyzeTouchToMaximizeIfNeeded(ev, isDragViewHit);
    if (isMaximized()) {
      dragView.dispatchTouchEvent(ev);
    } else {
      dragView.dispatchTouchEvent(cloneMotionEventWithAction(ev, MotionEvent.ACTION_CANCEL));
    }
    return isDragViewHit || isSecondViewHit;
  }
190056
protected boolean duringDrag(SVGPoint startPoint, SVGPoint dragPoint, Event evt, boolean inside) {
    if (listener != null) {
      return listener.duringDrag(startPoint, dragPoint, evt, inside);
    }
    return true;
  }