Applies a translation transformation to the CanvasContext.

@param float $x Distance to move in the horizontal direction in pixels.
@param float $y Distance to move in the vertical direction in pixels.
519976
public function translate($x, $y) 
    {
        $this->transform = $this->transform->translate($x, $y);
    }
122761
public void paint (Graphics2D gfx, int x, int y)
    {
        AffineTransform otrans = gfx.getTransform();
        gfx.translate(x, y);
        gfx.transform(_transform);
        _base.paint(gfx, 0, 0);
        gfx.setTransform(otrans);
    }
1297912
public void translate(float x, float y, float z) {
        getTransform().translate(x, y, z);
        if (mTransformCache.translate(x, y, z)) {
            onTransformChanged();
        }
    }
1173945
function(x, y) {
            OpenLayers.Geometry.Point.prototype.move.apply(this, arguments);
            this._rotationHandle && this._rotationHandle.geometry.move(x, y);
            this._handle.geometry.move(x, y);
        }
1349142
public function goToXY($x, $y)
    {
        if ($this->x < $x) {
            while ($this->x < $x) {
                echo self::RIGHT_KEYPRESS;
                $this->x++;
            }
        }

        if ($this->x > $x) {
            while ($this->x > $x) {
                echo self::LEFT_KEYPRESS;
                $this->x--;
            }
        }

        if ($this->y > $y) {
            while ($this->y > $y) {
                echo self::UP_KEYPRESS;
                $this->y--;
            }
        }

        if ($this->y < $y) {
            while ($this->y < $y) {
                echo self::DOWN_KEYPRESS;
                $this->y++;
            }
        }
    }
412544
public function translate($x, $y)
    {
        if(!$x && !$y)
        {
            return $this;
        }
        
        for($i=0; $i<$this->numberOfPoints; $i++)
        {
            $this->points[$i] = $this->points[$i]->translate($x, $y);
        }

        return $this;
    }
266068
protected function setPixel(int $x, int $y, array $rgb):void{
		\imagefilledrectangle(
			$this->image,
			$x * $this->scale,
			$y * $this->scale,
			($x + 1) * $this->scale,
			($y + 1) * $this->scale,
			\imagecolorallocate($this->image, ...$rgb)
		);
	}
640440
function translate(x, y) {
         this.pos.x += x;
         this.pos.y += y;

         this._bounds.translate(x, y);

         return this;
       }
1272943
public static function CHtoWGSlat($y, $x)
    {

        // Converts military to civil and  to unit = 1000km
        // Auxiliary values (% Bern)
        $y_aux = ($y - 600000) / 1000000;
        $x_aux = ($x - 200000) / 1000000;

        // Process lat
        $lat = 16.9023892
            + 3.238272 * $x_aux
            - 0.270978 * pow($y_aux, 2)
            - 0.002528 * pow($x_aux, 2)
            - 0.0447 * pow($y_aux, 2) * $x_aux
            - 0.0140 * pow($x_aux, 3);

        // Unit 10000" to 1 " and converts seconds to degrees (dec)
        $lat = $lat * 100 / 36;

        return $lat;

    }
765473
public Translation from(float x, float y, float z)
	{
		fromX = x;
		fromY = y;
		fromZ = z;
		return this;
	}
1162345
public function rotatedText($x, $y, $txt, $angle)
    {
        //Text rotated around its origin
        $this->rotate($angle, $x, $y);
        $this->Text($x, $y, $txt);
        $this->rotate(0);
    }
1359190
def _translate(self, x, y):
        """"""
        # we add our position relative to our parent and then call then next parent up
        return self.parent._translate((x + self.x), (y + self.y))
342884
public function setTranslate($xT, $yT)
    {
        // Matrix for Translate
        $tm[0]=1;
        $tm[1]=0;
        $tm[2]=0;
        $tm[3]=1;
        $tm[4]=$xT*$this->k;
        $tm[5]=-$yT*$this->k;

        // apply the Transform Matric
        $this->_out(sprintf('%.3F %.3F %.3F %.3F %.3F %.3F cm', $tm[0], $tm[1], $tm[2], $tm[3], $tm[4], $tm[5]));
    }
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);
	}
1051638
public function moveTo($x,$y)
	{
		$this->_oldX = $x;
		$this->_oldY = $y;
		$this->_polygonPath[] = $x;
		$this->_polygonPath[] = $y;
		return $this;
	}
224484
public function setMargin( $x, $y )
	{
		$this->marginX	= abs( (int)$x );
		$this->marginY	= abs( (int)$y );
	}
872976
private void setTranslate(float x, float y) {
        if (Math.abs(x) > 1 || Math.abs(y) > 1) {
            throw new IllegalArgumentException("Parallax effect cannot translate more than 100% of its off-screen size");
        }

        float xScale, yScale;

        if (mScaledIntensities) {
            // Set both scales to their offset values
            xScale = mXOffset;
            yScale = mYOffset;
        } else {
            // Set both scales to the max offset (should be negative, so smaller absolute value)
            xScale = Math.max(mXOffset, mYOffset);
            yScale = Math.max(mXOffset, mYOffset);
        }

        // Make sure below maximum jump limit
        if (mMaximumJump > 0) {
            // Limit x jump
            if (x - mXTranslation / xScale > mMaximumJump) {
                x = mXTranslation / xScale + mMaximumJump;
            } else if (x - mXTranslation / xScale < -mMaximumJump) {
                x = mXTranslation / xScale - mMaximumJump;
            }

            // Limit y jump
            if (y - mYTranslation / yScale > mMaximumJump) {
                y = mYTranslation / yScale + mMaximumJump;
            } else if (y - mYTranslation / yScale < -mMaximumJump) {
                y = mYTranslation / yScale - mMaximumJump;
            }
        }

        mXTranslation = x * xScale;
        mYTranslation = y * yScale;

        configureMatrix();
    }