Resets the loc of the dragger to place where dragging started.

        This could be used in a test situation if the dragger was dragged to an incorrect location.
430822
def resetToPreviousLoc(self):
        
        self.rect.left = self.startDraggingX
        self.rect.top = self.startDraggingY
922218
def reset(self):
        
        # Store positionned pieces on the board.
        self.pieces = set()

        # Squares on the board already occupied by a piece.
        self.occupancy = self.new_vector()

        # Territory susceptible to attacke, i.e. squares reachable by at least
        # a piece.
        self.exposed_territory = self.new_vector()
405824
def update_position(self, loc):
        """"""
        # This ensures that the new value of the location is set before
        # any other updates take place.
        self._loc = loc
        super(SkewXTick, self).update_position(loc)
592240
public void reset() {
		tracker.reset();
		keyToWorld.reset();
		currToKey.reset();
		first = true;
		tick = 0;
	}
439095
function() {
    if (!this._poly.dragging) {
      this._poly.dragging = new L.Handler.PathDrag(this._poly);
    }
    this._poly.dragging.enable();
    this._poly
      .on('dragstart', this._onStartDragFeature, this)
      .on('dragend', this._onStopDragFeature, this);
  }
235404
public void resetCoordinator() {

        final boolean isTracingEnabled = TraceComponent.isAnyTracingEnabled();

        if (isTracingEnabled && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "Resetting uow coordinator to null");
        }

        uowCoord = null;

    }
607853
def reset(self):
        
        super(SinonSpy, self).unwrap()
        super(SinonSpy, self).wrap2spy()
985114
def move(self, loc, yoff=None):
        
        from .Geometry import Location
        self._lock.acquire()
        if isinstance(loc, Location):
            mouse.move(loc.x, loc.y)
        elif yoff is not None:
            xoff = loc
            mouse.move(xoff, yoff)
        else:
            raise ValueError("Invalid argument. Expected either move(loc) or move(xoff, yoff).")
        self._last_position = loc
        self._lock.release()
737826
@Override
    public void reset()
    {
        if (null != m_startPoints)
        {
            final IControlHandleList handles = m_connector.getPointHandles();

            final Point2DArray points = m_connector.getLine().getPoint2DArray();

            for (int i = 0, j = 0; i < handles.size(); i++, j += 2)
            {
                final double px = m_startPoints.get(j);

                final double py = m_startPoints.get(j + 1);

                final IControlHandle h = handles.getHandle(i);

                final IPrimitive<?> prim = h.getControl();

                prim.setX(px);

                prim.setY(py);

                final Point2D point = points.get(i);

                point.setX(px);

                point.setY(py);
            }
        }
        m_connector.getLine().refresh();

        m_wiresManager.getLayer().getLayer().batch();
    }
475833
function () {
            if (!this._draggable) {
                return;
            }

            this._draggable.$removeListeners({
                "dragstart" : {
                    fn : this._onDragStart,
                    scope : this
                },
                "move" : {
                    fn : this._onDragMove,
                    scope : this
                },
                "dragend" : {
                    fn : this._onDragEnd,
                    scope : this
                }
            });
            this._draggable.$dispose();
            this._draggable = null;
        }
781950
public void resetAll()
    {
        currentLocationOnPage = 0;

        componentIndex = 0;
        currentComponent = this.getComponent(componentIndex);
        componentStartYLocation = 0;
        componentPageHeight = 0;

        currentPageIndex = 0;

        remainingComponentHeight = 0;
        if (currentComponent != null)
            remainingComponentHeight = currentComponent.getHeight();
        remainingPageHeight = pageHeight;
    }
640961
def reset(self):
        
        self.grid = [[0 for dummy_l in range(self.grid_width)] for dummy_l in range(self.grid_height)]
875597
def reset(self):
        '''  '''

        # reset the main stream
        if self.stream:
            self.stream.reset()

        # reset the initial stream (otherwise old 'adds' remain in the new stream)
        if self.initial_stream:
            self.initial_stream.reset()
1075432
public function reset() {
    $this->token = NULL;
    $this->lookahead = NULL;

    $this->position = -1;
    $this->moveNext();
  }
1070682
private void clearDrag() {

        if (m_dragHelper != null) {
            removeDragHelperStyles(m_dragHelper);
            m_dragHelper = null;
        }
        // preventing issue where mouse out was never triggered after drag and drop
        m_moveButton.clearHoverState();
        CmsButtonBarHandler.INSTANCE.closeAll();
    }
1062945
def reset(self):
        
        self.connection.rebuild_index(
            self.index, coll_name=self.target_coll_name)
520008
public final void update(final float position) {
        if (reset) {
            reset = false;
            distance = 0;
            thresholdReachedPosition = -1;
            dragStartTime = -1;
            dragStartPosition = position;
            reachedThreshold = false;
            minDragDistance = 0;
            maxDragDistance = 0;
        }

        if (!reachedThreshold) {
            if (reachedThreshold(position - dragStartPosition)) {
                dragStartTime = System.currentTimeMillis();
                reachedThreshold = true;
                thresholdReachedPosition = position;
            }
        } else {
            float newDistance = position - thresholdReachedPosition;

            if (minDragDistance != 0 && minDragDistance > newDistance) {
                newDistance = minDragDistance;
                thresholdReachedPosition = position - minDragDistance;
            }

            if (maxDragDistance != 0 && maxDragDistance < newDistance) {
                newDistance = maxDragDistance;
                thresholdReachedPosition = position - maxDragDistance;
            }

            distance = newDistance;
        }
    }