Search documentation of wx

# View Source wxGraphicsPath (wx v2.4.3.1)

A `wxGraphicsPath` is a native representation of a geometric path.

The contents are specific and private to the respective renderer. Instances are reference counted and can therefore be assigned as usual. The only way to get a valid instance is by using `wxGraphicsContext:createPath/1` or `wxGraphicsRenderer:createPath/1`.

This class is derived, and can use functions, from:

- `wxGraphicsObject`

wxWidgets docs: wxGraphicsPath

# Summary

## Types

wxGraphicsPath()

## Functions

addArc(This, C, R, StartAngle, EndAngle, Clockwise)
addArc(This, X, Y, R, StartAngle, EndAngle, Clockwise)

Adds an arc of a circle.

addArcToPoint(This, X1, Y1, X2, Y2, R)

Adds an arc (of a circle with radius `r`) that is tangent to the line connecting current point and (`x1`, `y1`) and to the line connecting (`x1`, `y1`) and (`x2`, `y2`).

addCircle(This, X, Y, R)

Appends a circle around (`x`,`y`) with radius `r` as a new closed subpath.

addCurveToPoint(This, C1, C2, E)

Adds a cubic bezier curve from the current point, using two control points and an end point.

addCurveToPoint(This, Cx1, Cy1, Cx2, Cy2, X, Y)

Adds a cubic bezier curve from the current point, using two control points and an end point.

addEllipse(This, X, Y, W, H)

Appends an ellipse fitting into the passed in rectangle as a new closed subpath.

addLineToPoint(This, P)

Adds a straight line from the current point to `p`.

addLineToPoint(This, X, Y)

Adds a straight line from the current point to (`x`,`y`).

addPath(This, Path)

Adds another path onto the current path.

addQuadCurveToPoint(This, Cx, Cy, X, Y)

Adds a quadratic bezier curve from the current point, using a control point and an end point.

addRectangle(This, X, Y, W, H)

Appends a rectangle as a new closed subpath.

addRoundedRectangle(This, X, Y, W, H, Radius)

Appends a rounded rectangle as a new closed subpath.

closeSubpath(This)

Closes the current sub-path.

contains(This, C)

Equivalent to `contains(This, C, [])`.

contains/3

Return: true if the point is within the path.

contains/4

Return: true if the point is within the path.

getBox(This)

Gets the bounding box enclosing all points (possibly including control points).

getCurrentPoint(This)

Gets the last point of the current path, (0,0) if not yet set.

moveToPoint(This, P)

Begins a new subpath at `p`.

moveToPoint(This, X, Y)

Begins a new subpath at (`x`,`y`).

transform(This, Matrix)

Transforms each point of this path by the matrix.

# Types

# wxGraphicsPath()

    -type wxGraphicsPath() :: wx:wx_object().

# Functions

# addArc(This, C, R, StartAngle, EndAngle, Clockwise)

    -spec addArc(This, C, R, StartAngle, EndAngle, Clockwise) -> ok
                    when
                        This :: wxGraphicsPath(),
                        C :: {X :: float(), Y :: float()},
                        R :: number(),
                        StartAngle :: number(),
                        EndAngle :: number(),
                        Clockwise :: boolean().

# addArc(This, X, Y, R, StartAngle, EndAngle, Clockwise)

    -spec addArc(This, X, Y, R, StartAngle, EndAngle, Clockwise) -> ok
                    when
                        This :: wxGraphicsPath(),
                        X :: number(),
                        Y :: number(),
                        R :: number(),
                        StartAngle :: number(),
                        EndAngle :: number(),
                        Clockwise :: boolean().

Adds an arc of a circle.

The circle is defined by the coordinates of its centre (`x`, `y`) or `c` and its radius `r`. The arc goes from the starting angle `startAngle` to `endAngle` either clockwise or counter-clockwise depending on the value of `clockwise` argument.

The angles are measured in radians but, contrary to the usual mathematical convention, are always `clockwise` from the horizontal axis.

If for clockwise arc `endAngle` is less than `startAngle` it will be progressively increased by 2pi until it is greater than `startAngle`. If for counter-clockwise arc `endAngle` is greater than `startAngle` it will be progressively decreased by 2pi until it is less than `startAngle`.

If there is a current point set, an initial line segment will be added to the path to connect the current point to the beginning of the arc.

# addArcToPoint(This, X1, Y1, X2, Y2, R)

    -spec addArcToPoint(This, X1, Y1, X2, Y2, R) -> ok
                           when
                               This :: wxGraphicsPath(),
                               X1 :: number(),
                               Y1 :: number(),
                               X2 :: number(),
                               Y2 :: number(),
                               R :: number().

Adds an arc (of a circle with radius `r`) that is tangent to the line connecting current point and (`x1`, `y1`) and to the line connecting (`x1`, `y1`) and (`x2`, `y2`).

If the current point and the starting point of the arc are different, a straight line connecting these points is also appended. If there is no current point before the call to `addArcToPoint/6` this function will behave as if preceded by a call to MoveToPoint(0, 0). After this call the current point will be at the ending point of the arc.

# addCircle(This, X, Y, R)

    -spec addCircle(This, X, Y, R) -> ok
                       when This :: wxGraphicsPath(), X :: number(), Y :: number(), R :: number().

Appends a circle around (`x`,`y`) with radius `r` as a new closed subpath.

After this call the current point will be at (x+`r`, `y`).

# addCurveToPoint(This, C1, C2, E)

    -spec addCurveToPoint(This, C1, C2, E) -> ok
                             when
                                 This :: wxGraphicsPath(),
                                 C1 :: {X :: float(), Y :: float()},
                                 C2 :: {X :: float(), Y :: float()},
                                 E :: {X :: float(), Y :: float()}.

Adds a cubic bezier curve from the current point, using two control points and an end point.

If there is no current point before the call to `addCurveToPoint/7` this function will behave as if preceded by a call to MoveToPoint(`c1`).

# addCurveToPoint(This, Cx1, Cy1, Cx2, Cy2, X, Y)

    -spec addCurveToPoint(This, Cx1, Cy1, Cx2, Cy2, X, Y) -> ok
                             when
                                 This :: wxGraphicsPath(),
                                 Cx1 :: number(),
                                 Cy1 :: number(),
                                 Cx2 :: number(),
                                 Cy2 :: number(),
                                 X :: number(),
                                 Y :: number().

Adds a cubic bezier curve from the current point, using two control points and an end point.

If there is no current point before the call to `addCurveToPoint/7` this function will behave as if preceded by a call to MoveToPoint(`cx1`, `cy1`).

# addEllipse(This, X, Y, W, H)

    -spec addEllipse(This, X, Y, W, H) -> ok
                        when
                            This :: wxGraphicsPath(),
                            X :: number(),
                            Y :: number(),
                            W :: number(),
                            H :: number().

Appends an ellipse fitting into the passed in rectangle as a new closed subpath.

After this call the current point will be at (x+`w`, y+`h/2`).

# addLineToPoint(This, P)

    -spec addLineToPoint(This, P) -> ok when This :: wxGraphicsPath(), P :: {X :: float(), Y :: float()}.

Adds a straight line from the current point to `p`.

If current point is not yet set before the call to `addLineToPoint/3` this function will behave as `moveToPoint/3`.

# addLineToPoint(This, X, Y)

    -spec addLineToPoint(This, X, Y) -> ok when This :: wxGraphicsPath(), X :: number(), Y :: number().

Adds a straight line from the current point to (`x`,`y`).

If current point is not yet set before the call to `addLineToPoint/3` this function will behave as `moveToPoint/3`.

# addPath(This, Path)

    -spec addPath(This, Path) -> ok when This :: wxGraphicsPath(), Path :: wxGraphicsPath().

Adds another path onto the current path.

After this call the current point will be at the added path's current point. For Direct2D the path being appended shouldn't contain a started non-empty subpath when this function is called.

# addQuadCurveToPoint(This, Cx, Cy, X, Y)

    -spec addQuadCurveToPoint(This, Cx, Cy, X, Y) -> ok
                                 when
                                     This :: wxGraphicsPath(),
                                     Cx :: number(),
                                     Cy :: number(),
                                     X :: number(),
                                     Y :: number().

Adds a quadratic bezier curve from the current point, using a control point and an end point.

If there is no current point before the call to `addQuadCurveToPoint/5` this function will behave as if preceded by a call to MoveToPoint(`cx`, `cy`).

# addRectangle(This, X, Y, W, H)

    -spec addRectangle(This, X, Y, W, H) -> ok
                          when
                              This :: wxGraphicsPath(),
                              X :: number(),
                              Y :: number(),
                              W :: number(),
                              H :: number().

Appends a rectangle as a new closed subpath.

After this call the current point will be at (`x`, `y`).

# addRoundedRectangle(This, X, Y, W, H, Radius)

    -spec addRoundedRectangle(This, X, Y, W, H, Radius) -> ok
                                 when
                                     This :: wxGraphicsPath(),
                                     X :: number(),
                                     Y :: number(),
                                     W :: number(),
                                     H :: number(),
                                     Radius :: number().

Appends a rounded rectangle as a new closed subpath.

If `radius` equals 0 this function will behave as `addRectangle/5`, otherwise after this call the current point will be at (x+`w`, y+`h/2`).

# closeSubpath(This)

    -spec closeSubpath(This) -> ok when This :: wxGraphicsPath().

Closes the current sub-path.

After this call the current point will be at the joined endpoint of the sub-path.

# contains(This, C)

    -spec contains(This, C) -> boolean() when This :: wxGraphicsPath(), C :: {X :: float(), Y :: float()}.

Equivalent to `contains(This, C, [])`.

# contains/3

    -spec contains(This, X, Y) -> boolean() when This :: wxGraphicsPath(), X :: number(), Y :: number();
                  (This, C, [Option]) -> boolean()
                      when
                          This :: wxGraphicsPath(),
                          C :: {X :: float(), Y :: float()},
                          Option :: {fillStyle, wx:wx_enum()}.

Return: true if the point is within the path.

# contains/4

    -spec contains(This, X, Y, [Option]) -> boolean()
                      when
                          This :: wxGraphicsPath(),
                          X :: number(),
                          Y :: number(),
                          Option :: {fillStyle, wx:wx_enum()}.

Return: true if the point is within the path.

# getBox(This)

    -spec getBox(This) -> {X :: float(), Y :: float(), W :: float(), H :: float()}
                    when This :: wxGraphicsPath().

Gets the bounding box enclosing all points (possibly including control points).

# getCurrentPoint(This)

    -spec getCurrentPoint(This) -> {X :: float(), Y :: float()} when This :: wxGraphicsPath().

Gets the last point of the current path, (0,0) if not yet set.

# moveToPoint(This, P)

    -spec moveToPoint(This, P) -> ok when This :: wxGraphicsPath(), P :: {X :: float(), Y :: float()}.

Begins a new subpath at `p`.

# moveToPoint(This, X, Y)

    -spec moveToPoint(This, X, Y) -> ok when This :: wxGraphicsPath(), X :: number(), Y :: number().

Begins a new subpath at (`x`,`y`).

# transform(This, Matrix)

    -spec transform(This, Matrix) -> ok
                       when This :: wxGraphicsPath(), Matrix :: wxGraphicsMatrix:wxGraphicsMatrix().

Transforms each point of this path by the matrix.

For Direct2D the current path shouldn't contain a started non-empty subpath when this function is called.