Move mouse to (x, y)

        **中文文档**

        移动鼠标到 (x, y) 的坐标处。
326141
def move_to(self, x, y, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.m.move(x, y)
        self.delay(post_dl)
328409
function (position, callback) {
            var lastPosition = this._lastMousePosition;
            lastPosition.x = position.x;
            lastPosition.y = position.y;
            this._sendEvent('mousemove', position.x, position.y);
            this._callCallback(callback);
        }
1139981
public void moveRectangleTo(Rectangle rect, float x, float y) {
		float width = rect.getWidth();
		float height = rect.getHeight();
		rect.setLeft(x);
		rect.setBottom(y);
		rect.setRight(rect.getLeft() + width);
		rect.setTop(rect.getBottom() + height);
	}
440169
def move_to(x, y):
    
    for b in _button_state:
        if _button_state[b]:
            e = Quartz.CGEventCreateMouseEvent(
                None,
                _button_mapping[b][3], # Drag Event
                (x, y),
                _button_mapping[b][0])
            break
    else:
        e = Quartz.CGEventCreateMouseEvent(
            None,
            Quartz.kCGEventMouseMoved,
            (x, y),
            Quartz.kCGMouseButtonLeft)
    Quartz.CGEventPost(Quartz.kCGHIDEventTap, e)
1062656
function handlePointMove(e, x, y) {
        var self = e.target,
            bezierEditor = self.bezierEditor;

        // Helper function to redraw curve
        function mouseMoveRedraw() {
            if (!bezierEditor.dragElement) {
                animationRequest = null;
                return;
            }

            // Update code
            bezierEditor._commitTimingFunction();

            bezierEditor._updateCanvas();
            animationRequest = window.requestAnimationFrame(mouseMoveRedraw);
        }

        // This is a dragging state, but left button is no longer down, so mouse
        // exited element, was released, and re-entered element. Treat like a drop.
        if (bezierEditor.dragElement && (e.which !== 1)) {
            bezierEditor.dragElement = null;
            bezierEditor._commitTimingFunction();
            bezierEditor._updateCanvas();
            bezierEditor = null;
            return;
        }

        // Constrain time (x-axis) to 0 to 1 range. Progression (y-axis) is
        // theoretically not constrained, although canvas to drawing curve is
        // arbitrarily constrained to -0.5 to 1.5 range.
        x = Math.min(Math.max(0, x), WIDTH_MAIN);

        if (bezierEditor.dragElement) {
            $(bezierEditor.dragElement).css({
                left: x + "px",
                top:  y + "px"
            });
        }

        // update coords
        bezierEditor._cubicBezierCoords = bezierEditor.bezierCanvas
            .offsetsToCoordinates(bezierEditor.P1)
            .concat(bezierEditor.bezierCanvas.offsetsToCoordinates(bezierEditor.P2));

        if (!animationRequest) {
            animationRequest = window.requestAnimationFrame(mouseMoveRedraw);
        }
    }
93432
def click(self, x, y):
        
        print 'click at', x, y
        self._input_left_mouse(x, y)
477541
def mouseDrag(self, x, y, step=1):
        
        log.debug('mouseDrag %d,%d', x, y)
        if x < self.x:
            xsteps = [self.x - i for i in range(step, self.x - x + 1, step)]
        else:
            xsteps = range(self.x, x, step)

        if y < self.y:
            ysteps = [self.y - i for i in range(step, self.y - y + 1, step)]
        else:
            ysteps = range(self.y, y, step)

        for ypos in ysteps:
            time.sleep(.2)
            self.mouseMove(self.x, ypos)

        for xpos in xsteps:
            time.sleep(.2)
            self.mouseMove(xpos, self.y)

        self.mouseMove(x, y)

        return self
1228923
public function moveCursorRel($x, $y)
    {
        $yChar = ($y < 0) ? "A" : "B"; // up / down
        $xChar = ($x < 0) ? "D" : "C"; // left / right
        fwrite(STDOUT, "\e[" . abs($x) . $xChar);
        fwrite(STDOUT, "\e[" . abs($y) . $yChar);
    }
1040466
private static Coordinate moveCoordinate(Coordinate inputCoordinate, double[] shadowOffset) {
        return new Coordinate(inputCoordinate.x + shadowOffset[0], inputCoordinate.y + shadowOffset[1], 0);
    }
640440
function translate(x, y) {
         this.pos.x += x;
         this.pos.y += y;

         this._bounds.translate(x, y);

         return this;
       }
118874
def move_mouse(x_delta, y_delta)
      send_request RequestMessage.new(mouse_event_message: MouseEvent.new(x_delta: x_delta, y_delta: y_delta))
    end
375920
function mouseActionLocal(angleXY) {
    rotator.yaw = -angleXY[0];
    rotator.pitch = angleXY[1];
    rotator.updateRotMtx();
}
1338140
def moveTo(self, newX=0, newY=0):
        
        self.x = newX
        self.y = newY
388873
def move_mouse(self, x, y, screen=0):
        
        # todo: apparently the "screen" argument is not behaving properly
        #       and sometimes even making the interpreter crash..
        #       Figure out why (changed API / using wrong header?)

        # >>> xdo.move_mouse(3000,200,1)

        # X Error of failed request:  BadWindow (invalid Window parameter)
        #   Major opcode of failed request:  41 (X_WarpPointer)
        #   Resource id in failed request:  0x2a4fca0
        #   Serial number of failed request:  25
        #   Current serial number in output stream:  26

        # Just to be safe..
        # screen = 0

        x = ctypes.c_int(x)
        y = ctypes.c_int(y)
        screen = ctypes.c_int(screen)

        _libxdo.xdo_move_mouse(self._xdo, x, y, screen)
135359
def move_to(self, x, y):
        
        self._drawing_operations.append(_MoveTo.new(self, x, y))
        return self
791726
def move_to(self, x, y):
        
        cairo.cairo_move_to(self._pointer, x, y)
        self._check_status()
736911
def move_line(x, y, speed = 1):
    

    _x, _y = win32api.GetCursorPos()
    if x - _x:
        m = (y - _y) / (x - _x)
        c = y - (m * x)
        for a in range(_x, x + 1, speed) if _x < x else range(_x, x - 1, -speed):
            b = int(m * a + c)
            move(a, b)
            time.sleep(0.01)
    else:
        for b in range(_y, y + 1, speed) if _y <= y else range(_y, y - 1, -speed):
            move(x, b)
            time.sleep(0.01)
    move(x, y)