Remove references to old SkPaint::Hinting.

Also fix bug recently introduced that made
unlinkable words use the last link found.

TBR=reed@google.com

Docs-Preview: https://skia.org/?cl=170266
Bug: skia:
Change-Id: I8b83bcb479bd3f79699a1c74818a817190fd42a5
Reviewed-on: https://skia-review.googlesource.com/c/170266
Commit-Queue: Cary Clark <caryclark@skia.org>
Auto-Submit: Cary Clark <caryclark@skia.org>
Reviewed-by: Cary Clark <caryclark@skia.org>

2018-11-09 21:33:54 +00:00

290 KiB

Raw Blame History

SkPath Reference

class SkPath {
public:
    enum Direction : int {
        kCW_Direction,
        kCCW_Direction,
    };

    SkPath();
    SkPath(const SkPath& path);
    ~SkPath();
    SkPath& operator=(const SkPath& path);
    friend bool operator==(const SkPath& a, const SkPath& b);
    friend bool operator!=(const SkPath& a, const SkPath& b);
    bool isInterpolatable(const SkPath& compare) const;
    bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const;
    bool unique() const;

    enum FillType {
        kWinding_FillType,
        kEvenOdd_FillType,
        kInverseWinding_FillType,
        kInverseEvenOdd_FillType,
    };

    FillType getFillType() const;
    void setFillType(FillType ft);
    bool isInverseFillType() const;
    void toggleInverseFillType();

    enum Convexity : uint8_t {
        kUnknown_Convexity,
        kConvex_Convexity,
        kConcave_Convexity,
    };

    Convexity getConvexity() const;
    Convexity getConvexityOrUnknown() const;
    void setConvexity(Convexity convexity);
    bool isConvex() const;
    bool isOval(SkRect* bounds) const;
    bool isRRect(SkRRect* rrect) const;
    SkPath& reset();
    SkPath& rewind();
    bool isEmpty() const;
    bool isLastContourClosed() const;
    bool isFinite() const;
    bool isVolatile() const;
    void setIsVolatile(bool isVolatile);
    static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2, bool exact);
    static bool IsQuadDegenerate(const SkPoint& p1, const SkPoint& p2,
                                 const SkPoint& p3, bool exact);
    static bool IsCubicDegenerate(const SkPoint& p1, const SkPoint& p2,
                                  const SkPoint& p3, const SkPoint& p4, bool exact);
    bool isLine(SkPoint line[2]) const;
    int countPoints() const;
    SkPoint getPoint(int index) const;
    int getPoints(SkPoint points[], int max) const;
    int countVerbs() const;
    int getVerbs(uint8_t verbs[], int max) const;
    void swap(SkPath& other);
    const SkRect& getBounds() const;
    void updateBoundsCache() const;
    SkRect computeTightBounds() const;
    bool conservativelyContainsRect(const SkRect& rect) const;
    void incReserve(int extraPtCount);
    void shrinkToFit();
    SkPath& moveTo(SkScalar x, SkScalar y);
    SkPath& moveTo(const SkPoint& p);
    SkPath& rMoveTo(SkScalar dx, SkScalar dy);
    SkPath& lineTo(SkScalar x, SkScalar y);
    SkPath& lineTo(const SkPoint& p);
    SkPath& rLineTo(SkScalar dx, SkScalar dy);
    SkPath& quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2);
    SkPath& quadTo(const SkPoint& p1, const SkPoint& p2);
    SkPath& rQuadTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2);
    SkPath& conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                    SkScalar w);
    SkPath& conicTo(const SkPoint& p1, const SkPoint& p2, SkScalar w);
    SkPath& rConicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2,
                     SkScalar w);
    SkPath& cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                    SkScalar x3, SkScalar y3);
    SkPath& cubicTo(const SkPoint& p1, const SkPoint& p2, const SkPoint& p3);
    SkPath& rCubicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2,
                     SkScalar dx3, SkScalar dy3);
    SkPath& arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool forceMoveTo);
    SkPath& arcTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar radius);
    SkPath& arcTo(const SkPoint p1, const SkPoint p2, SkScalar radius);

    enum ArcSize {
        kSmall_ArcSize,
        kLarge_ArcSize,
    };

    SkPath& arcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc,
                  Direction sweep, SkScalar x, SkScalar y);
    SkPath& arcTo(const SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, Direction sweep,
               const SkPoint xy);
    SkPath& rArcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc,
                   Direction sweep, SkScalar dx, SkScalar dy);
    SkPath& close();
    static bool IsInverseFillType(FillType fill);
    static FillType ConvertToNonInverseFillType(FillType fill);
    static int ConvertConicToQuads(const SkPoint& p0, const SkPoint& p1, const SkPoint& p2,
                                   SkScalar w, SkPoint pts[], int pow2);
    bool isRect(SkRect* rect, bool* isClosed = nullptr, Direction* direction = nullptr) const;
    bool isNestedFillRects(SkRect rect[2], Direction dirs[2] = nullptr) const;
    SkPath& addRect(const SkRect& rect, Direction dir = kCW_Direction);
    SkPath& addRect(const SkRect& rect, Direction dir, unsigned start);
    SkPath& addRect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom,
                    Direction dir = kCW_Direction);
    SkPath& addOval(const SkRect& oval, Direction dir = kCW_Direction);
    SkPath& addOval(const SkRect& oval, Direction dir, unsigned start);
    SkPath& addCircle(SkScalar x, SkScalar y, SkScalar radius,
                      Direction dir = kCW_Direction);
    SkPath& addArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle);
    SkPath& addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry,
                         Direction dir = kCW_Direction);
    SkPath& addRoundRect(const SkRect& rect, const SkScalar radii[],
                         Direction dir = kCW_Direction);
    SkPath& addRRect(const SkRRect& rrect, Direction dir = kCW_Direction);
    SkPath& addRRect(const SkRRect& rrect, Direction dir, unsigned start);
    SkPath& addPoly(const SkPoint pts[], int count, bool close);
    SkPath& addPoly(const std::initializer_list<SkPoint>& list, bool close);

    enum AddPathMode {
        kAppend_AddPathMode,
        kExtend_AddPathMode,
    };

    SkPath& addPath(const SkPath& src, SkScalar dx, SkScalar dy,
                    AddPathMode mode = kAppend_AddPathMode);
    SkPath& addPath(const SkPath& src, AddPathMode mode = kAppend_AddPathMode);
    SkPath& addPath(const SkPath& src, const SkMatrix& matrix,
                    AddPathMode mode = kAppend_AddPathMode);
    SkPath& reverseAddPath(const SkPath& src);
    void offset(SkScalar dx, SkScalar dy, SkPath* dst) const;
    void offset(SkScalar dx, SkScalar dy);
    void transform(const SkMatrix& matrix, SkPath* dst) const;
    void transform(const SkMatrix& matrix);
    bool getLastPt(SkPoint* lastPt) const;
    void setLastPt(SkScalar x, SkScalar y);
    void setLastPt(const SkPoint& p);

    enum SegmentMask {
        kLine_SegmentMask = 1 << 0,
        kQuad_SegmentMask = 1 << 1,
        kConic_SegmentMask = 1 << 2,
        kCubic_SegmentMask = 1 << 3,
    };

    uint32_t getSegmentMasks() const;

    enum Verb {
        kMove_Verb,
        kLine_Verb,
        kQuad_Verb,
        kConic_Verb,
        kCubic_Verb,
        kClose_Verb,
        kDone_Verb,
    };

    class Iter {
    public:
        Iter();
        Iter(const SkPath& path, bool forceClose);
        void setPath(const SkPath& path, bool forceClose);
        Verb next(SkPoint pts[4], bool doConsumeDegenerates = true, bool exact = false);
        SkScalar conicWeight() const;
        bool isCloseLine() const;
        bool isClosedContour() const;
    };

    class RawIter {
    public:
        RawIter();
        RawIter(const SkPath& path);
        void setPath(const SkPath& path);
        Verb next(SkPoint pts[4]);
        Verb peek() const;
        SkScalar conicWeight() const;
    };

    bool contains(SkScalar x, SkScalar y) const;
    void dump(SkWStream* stream, bool forceClose, bool dumpAsHex) const;
    void dump() const;
    void dumpHex() const;
    size_t writeToMemory(void* buffer) const;
    sk_sp<SkData> serialize() const;
    size_t readFromMemory(const void* buffer, size_t length);
    uint32_t getGenerationID() const;
    bool isValid() const;
    bool isValid() const;
    bool pathRefIsValid() const;
};

Paths contain geometry. Paths may be empty, or contain one or more Verbs that outline a figure. Path always starts with a move verb to a Cartesian_Coordinate, and may be followed by additional verbs that add lines or curves. Adding a close verb makes the geometry into a continuous loop, a closed contour. Paths may contain any number of contours, each beginning with a move verb.

Path contours may contain only a move verb, or may also contain lines, Quadratic_Beziers, Conics, and Cubic_Beziers. Path contours may be open or closed.

When used to draw a filled area, Path describes whether the fill is inside or outside the geometry. Path also describes the winding rule used to fill overlapping contours.

Internally, Path lazily computes metrics likes bounds and convexity. Call SkPath::updateBoundsCache to make Path thread safe.

    enum Verb {
        kMove_Verb,
        kLine_Verb,
        kQuad_Verb,
        kConic_Verb,
        kCubic_Verb,
        kClose_Verb,
        kDone_Verb,
    };

Verb instructs Path how to interpret one or more Point and optional Conic_Weight; manage Contour, and terminate Path.

Constants

Each Verb has zero or more Points stored in Path. Path iterator returns complete curve descriptions, duplicating shared Points for consecutive entries.

Const	Value	Description
`SkPath::kMove_Verb`	0	Consecutive kMove_Verb are preserved but all but the last kMove_Verb is ignored. kMove_Verb after other Verbs implicitly closes the previous Contour if SkPaint::kFill_Style is set when drawn; otherwise, stroke is drawn open. kMove_Verb as the last Verb is preserved but ignored.
`SkPath::kLine_Verb`	1	Line is a straight segment from Point to Point. Consecutive kLine_Verb extend Contour. kLine_Verb at same position as prior kMove_Verb is preserved, and draws Point if SkPaint::kStroke_Style is set, and SkPaint::Cap is SkPaint::kSquare_Cap or SkPaint::kRound_Cap. kLine_Verb at same position as prior line or curve Verb is preserved but is ignored.
`SkPath::kQuad_Verb`	2	Adds Quad from Last_Point, using control Point, and end Point. Quad is a parabolic section within tangents from Last_Point to control Point, and control Point to end Point.
`SkPath::kConic_Verb`	3	Adds Conic from Last_Point, using control Point, end Point, and Conic_Weight. Conic is a elliptical, parabolic, or hyperbolic section within tangents from Last_Point to control Point, and control Point to end Point, constrained by Conic_Weight. Conic_Weight less than one is elliptical; equal to one is parabolic (and identical to Quad); greater than one hyperbolic.
`SkPath::kCubic_Verb`	4	Adds Cubic from Last_Point, using two control Points, and end Point. Cubic is a third-order Bezier_Curve section within tangents from Last_Point to first control Point, and from second control Point to end Point.
`SkPath::kClose_Verb`	5	Closes Contour, connecting Last_Point to kMove_Verb Point. Consecutive kClose_Verb are preserved but only first has an effect. kClose_Verb after kMove_Verb has no effect.
`SkPath::kDone_Verb`	6	Not in Verb_Array, but returned by Path iterator.

Verb	Allocated Points	Iterated Points	Weights
kMove_Verb	1	1	0
kLine_Verb	1	2	0
kQuad_Verb	2	3	0
kConic_Verb	2	3	1
kCubic_Verb	3	4	0
kClose_Verb	0	1	0
kDone_Verb	--	0	0

Example

Example Output

verb count: 7
verbs: kMove_Verb kLine_Verb kQuad_Verb kClose_Verb kMove_Verb kCubic_Verb kConic_Verb

    enum Direction : int {
        kCW_Direction,
        kCCW_Direction,
    };

Direction describes whether Contour is clockwise or counterclockwise. When Path contains multiple overlapping Contours, Direction together with Fill_Type determines whether overlaps are filled or form holes.

Direction also determines how Contour is measured. For instance, dashing measures along Path to determine where to start and stop stroke; Direction will change dashed results as it steps clockwise or counterclockwise.

Closed Contours like Rect, Round_Rect, Circle, and Oval added with kCW_Direction travel clockwise; the same added with kCCW_Direction travel counterclockwise.

Constants

Const	Value	Description
`SkPath::kCW_Direction`	0	contour travels clockwise
`SkPath::kCCW_Direction`	1	contour travels counterclockwise

Example

Return Value

empty SkPath

Example

Example Output

path is empty

Parameters

path SkPath to copy by value

Return Value

copy of SkPath

Example

Modifying one path does not effect another, even if they started as copies of each other.

Example Output

path verbs: 2
path2 verbs: 3
after reset
path verbs: 0
path2 verbs: 3

Example

delete calls Path destructor, but copy of original in path2 is unaffected.

Parameters

path verb array, SkPoint array, weights, and SkPath::FillType to copy

Return Value

SkPath copied by value

Example

Example Output

path1 bounds = 10, 20, 30, 40
path2 bounds = 10, 20, 30, 40

Parameters

`a`	SkPath to compare
`b`	SkPath to compare

Return Value

true if SkPath pair are equivalent

Example

rewind() removes Verb_Array but leaves storage; since storage is not compared, Path pair are equivalent.

Example Output

empty one == two
moveTo one != two
rewind one == two
reset one == two

Parameters

`a`	SkPath to compare
`b`	SkPath to compare

Return Value

true if SkPath pair are not equivalent

Example

Path pair are equal though their convexity is not equal.

Example Output

empty one == two
add rect one == two
setConvexity one == two
convexity !=

bool isInterpolatable(const SkPath& compare) const

Returns true if SkPath contain equal verbs and equal weights. If SkPath contain one or more conics, the weights must match.

conicTo() may add different verbs depending on conic weight, so it is not trivial to interpolate a pair of SkPath containing conics with different conic weight values.

Parameters

compare SkPath to compare

Return Value

true if SkPath verb array and weights are equivalent

Example

Example Output

paths are interpolatable

Parameters

`ending`	Point_Array averaged with this Point_Array
`weight`	contribution of this Point_Array, and one minus contribution of ending Point_Array
`out`	Path replaced by interpolated averages

Return Value

true if Paths contain same number of Points

Example

The top row has two clockwise rectangles. The second row has one clockwise and one counterclockwise rectangle. The even-odd variants draw the same. The winding variants draw the top rectangle overlap, which has a winding of 2, the same as the outer parts of the top rectangles, which have a winding of 1.

Constants

Const	Value	Description
`SkPath::kWinding_FillType`	0	is enclosed by a non-zero sum of Contour Directions
`SkPath::kEvenOdd_FillType`	1	is enclosed by an odd number of Contours
`SkPath::kInverseWinding_FillType`	2	is enclosed by a zero sum of Contour Directions
`SkPath::kInverseEvenOdd_FillType`	3	is enclosed by an even number of Contours

Example

Return Value

one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType,

kInverseEvenOdd_FillType

Example

Example Output

default path fill type is kWinding_FillType

Parameters

`ft`	one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType,

kInverseEvenOdd_FillType

Example

If empty Path is set to inverse FillType, it fills all pixels.

Return Value

true if FillType is kInverseWinding_FillType or kInverseEvenOdd_FillType

Example

Example Output

default path fill type is inverse: false

FillType	toggled FillType
kWinding_FillType	kInverseWinding_FillType
kEvenOdd_FillType	kInverseEvenOdd_FillType
kInverseWinding_FillType	kWinding_FillType
kInverseEvenOdd_FillType	kEvenOdd_FillType

Example

Path drawn normally and through its inverse touches every pixel once.

Constants

Const	Value	Description
`SkPath::kUnknown_Convexity`	0	indicates Convexity has not been determined
`SkPath::kConvex_Convexity`	1	one Contour made of a simple geometry without indentations
`SkPath::kConcave_Convexity`	2	more than one Contour, or a geometry with indentations

Example

Return Value

computed or stored SkPath::Convexity

Example

Return Value

stored SkPath::Convexity

Example

Convexity is unknown unless getConvexity is called without a subsequent call that alters the path.

Parameters

convexity one of: kUnknown_Convexity, kConvex_Convexity, or kConcave_Convexity

Example

Return Value

true if SkPath::Convexity stored or computed is kConvex_Convexity

Example

Concave shape is erroneously considered convex after a forced call to setConvexity.

Parameters

bounds storage for bounding SkRect of oval; may be nullptr

Return Value

true if SkPath is recognized as an oval or circle

Example

Parameters

rrect storage for bounding SkRect of SkRRect; may be nullptr

Return Value

true if SkPath contains only SkRRect

Example

Draw rounded rectangle and its bounds.

Return Value

reference to SkPath

Example

Return Value

reference to SkPath

Example

Although path1 retains its internal storage, it is indistinguishable from a newly initialized path.

Return Value

true if the path contains no SkPath::Verb array

Example

Example Output

initial path is empty
after moveTo path is not empty
after rewind path is empty
after lineTo path is not empty
after reset path is empty

Return Value

true if the last contour ends with a kClose_Verb

Example

close() has no effect if Path is empty; isLastContourClosed() returns false until Path has geometry followed by close().

Example Output

initial last contour is not closed
after close last contour is not closed
after lineTo last contour is not closed
after close last contour is closed

Return Value

true if all SkPoint values are finite

Example

Example Output

initial path is finite
after line path is finite
after scale path is not finite

Return Value

true if caller will alter SkPath after drawing

Example

Example Output

volatile by default is false

Parameters

isVolatile true if caller will alter SkPath after drawing

Example

Parameters

`p1`	line start point
`p2`	line end point
`exact`	if false, allow nearly equals

Return Value

true if line is degenerate; its length is effectively zero

Example

As single precision floats, 100 and 100.000001 have the same bit representation, and are exactly equal. 100 and 100.0001 have different bit representations, and are not exactly equal, but are nearly equal.

Example Output

line from (100,100) to (100,100) is degenerate, nearly
line from (100,100) to (100,100) is degenerate, exactly
line from (100,100) to (100.0001,100.0001) is degenerate, nearly
line from (100,100) to (100.0001,100.0001) is not degenerate, exactly

Parameters

`p1`	quad start point
`p2`	quad control point
`p3`	quad end point
`exact`	if true, returns true only if p1, p2, and p3 are equal;

if false, returns true if p1, p2, and p3 are equal or nearly equal

Return Value

true if quad is degenerate; its length is effectively zero

Example

As single precision floats: 100, 100.00001, and 100.00002 have different bit representations but nearly the same value. Translating all three by 1000 gives them the same bit representation; the fractional portion of the number can not be represented by the float and is lost.

Example Output

quad (100,100), (100.00001,100.00001), (100.00002,100.00002) is degenerate, nearly
quad (1100,1100), (1100,1100), (1100,1100) is degenerate, nearly
quad (100,100), (100.00001,100.00001), (100.00002,100.00002) is not degenerate, exactly
quad (1100,1100), (1100,1100), (1100,1100) is degenerate, exactly

Parameters

`p1`	cubic start point
`p2`	cubic control point 1
`p3`	cubic control point 2
`p4`	cubic end point
`exact`	if true, returns true only if p1, p2, p3, and p4 are equal;

if false, returns true if p1, p2, p3, and p4 are equal or nearly equal

Return Value

true if cubic is degenerate; its length is effectively zero

Example

Example Output

0.00024414062 is degenerate
0.00024414065 is length

bool isLine(SkPoint line[2]) const

Returns true if SkPath contains only one line; SkPath::Verb array has two entries: kMove_Verb, kLine_Verb. If SkPath contains one line and line is not nullptr, line is set to line start point and line end point. Returns false if SkPath is not one line; line is unaltered.

Parameters

line storage for line. May be nullptr

Return Value

true if SkPath contains exactly one line

Example

Example Output

empty is not line
zero line is line (0,0) (0,0)
line is line (10,10) (20,20)
second move is not line

Point_Array contains Points satisfying the allocated Points for each Verb in Verb_Array. For instance, Path containing one Contour with Line and Quad is described by Verb_Array: kMove_Verb, kLine_Verb, kQuad_Verb; and one Point for move, one Point for Line, two Points for Quad; totaling four Points.

Point_Array may be read directly from Path with getPoints, or inspected with getPoint, with Iter, or with RawIter.

int getPoints(SkPoint points[], int max) const

Returns number of points in SkPath. Up to max points are copied. points may be nullptr; then, max must be zero. If max is greater than number of points, excess points storage is unaltered.

Parameters

`points`	storage for SkPath SkPoint array. May be nullptr
`max`	maximum to copy; must be greater than or equal to zero

Return Value

SkPath SkPoint array length

Example

Example Output

no points point count: 3
zero max point count: 3
too small point count: 3  (0,0) (20,20)
just right point count: 3  (0,0) (20,20) (-10,-10)

Return Value

SkPath SkPoint array length

Example

Example Output

empty point count: 0
zero line point count: 2
line point count: 2
second move point count: 3

Parameters

index SkPoint array element selector

Return Value

SkPoint array value or (0, 0)

Example

Example Output

point 0: (-10,-10)
point 1: (10,10)

Return Value

length of verb array

Example

Example Output

empty verb count: 0
round rect verb count: 10

Parameters

`verbs`	storage for verbs, may be nullptr
`max`	maximum number to copy into verbs

Return Value

the actual number of verbs in the path

Example

Example Output

no verbs verb count: 3
zero max verb count: 3
too small verb count: 3  move line
just right verb count: 3  move line line

Parameters

other SkPath exchanged by value

Example

Example Output

path1 bounds = 0, 0, 0, 0
path2 bounds = 10, 20, 30, 40

Return Value

bounds of all SkPoint in SkPoint array

Example

Bounds of upright Circle can be predicted from center and radius. Bounds of rotated Circle includes control Points outside of filled area.

Example Output

empty bounds = 0, 0, 0, 0
circle bounds = 25, 20, 75, 70
rotated circle bounds = 14.6447, 9.64466, 85.3553, 80.3553

Example

Example Output

#Volatile
uncached avg: 0.18048 ms
cached avg: 0.182784 ms

Return Value

tight bounds of curves in SkPath

Example

Example Output

empty bounds = 0, 0, 0, 0
circle bounds = 25, 20, 75, 70
rotated circle bounds = 25, 20, 75, 70

Parameters

rect SkRect, line, or SkPoint checked for containment

Return Value

true if rect is contained

Example

Rect is drawn in blue if it is contained by red Path.

Parameters

extraPtCount number of additional SkPoint to allocate

Example

Parameters

`x`	x-axis value of contour start
`y`	y-axis value of contour start

Return Value

reference to SkPath

Example

Parameters

`p`	contour start

Return Value

reference to SkPath

Example

Parameters

`dx`	offset from last point to contour start on x-axis
`dy`	offset from last point to contour start on y-axis

Return Value

reference to SkPath

Example

Parameters

`x`	end of added line on x-axis
`y`	end of added line on y-axis

Return Value

reference to SkPath

Example

Parameters

`p`	end SkPoint of added line

Return Value

reference to SkPath

Example

Parameters

`dx`	offset from last point to line end on x-axis
`dy`	offset from last point to line end on y-axis

Return Value

reference to SkPath

Example

Quad is a special case of Conic where Conic_Weight is set to one.

Quad is always contained by the triangle connecting its three Points. Quad begins tangent to the line between start Point and control Point, and ends tangent to the line between control Point and end Point.

Example

SkPath& quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)

Adds quad from last point towards (x1, y1), to (x2, y2). If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding quad.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kQuad_Verb to verb array; and (x1, y1), (x2, y2) to SkPoint array.

Parameters

`x1`	control SkPoint of quad on x-axis
`y1`	control SkPoint of quad on y-axis
`x2`	end SkPoint of quad on x-axis
`y2`	end SkPoint of quad on y-axis

Return Value

reference to SkPath

Example

Parameters

`p1`	control SkPoint of added quad
`p2`	end SkPoint of added quad

Return Value

reference to SkPath

Example

Parameters

`dx1`	offset from last point to quad control on x-axis
`dy1`	offset from last point to quad control on y-axis
`dx2`	offset from last point to quad end on x-axis
`dy2`	offset from last point to quad end on y-axis

Return Value

reference to SkPath

Example

When Conic_Weight is one, Quad is added to path; the two are identical.

Example Output

move {0, 0},
quad {0, 0}, {20, 30}, {50, 60},
done

If weight is less than one, Conic is an elliptical segment.

Example

A 90 degree circular arc has the weight 1 / sqrt(2).

Example Output

move {0, 0},
conic {0, 0}, {20, 0}, {20, 20}, weight = 0.707107
done

If weight is greater than one, Conic is a hyperbolic segment. As weight gets large, a hyperbolic segment can be approximated by straight lines connecting the control Point with the end Points.

Example

Example Output

move {0, 0},
line {0, 0}, {20, 0},
line {20, 0}, {20, 20},
done

SkPath& conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w)

Adds conic from last point towards (x1, y1), to (x2, y2), weighted by w. If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding conic.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed.

If w is finite and not one, appends kConic_Verb to verb array; and (x1, y1), (x2, y2) to SkPoint array; and w to conic weights.

If w is one, appends kQuad_Verb to verb array, and (x1, y1), (x2, y2) to SkPoint array.

If w is not finite, appends kLine_Verb twice to verb array, and (x1, y1), (x2, y2) to SkPoint array.

Parameters

`x1`	control SkPoint of conic on x-axis
`y1`	control SkPoint of conic on y-axis
`x2`	end SkPoint of conic on x-axis
`y2`	end SkPoint of conic on y-axis
`w`	weight of added conic

Return Value

reference to SkPath

Example

As weight increases, curve is pulled towards control point. The bottom two curves are elliptical; the next is parabolic; the top curve is hyperbolic.

Parameters

`p1`	control SkPoint of added conic
`p2`	end SkPoint of added conic
`w`	weight of added conic

Return Value

reference to SkPath

Example

Conics and arcs use identical representations. As the arc sweep increases the Conic_Weight also increases, but remains smaller than one.

Parameters

`dx1`	offset from last point to conic control on x-axis
`dy1`	offset from last point to conic control on y-axis
`dx2`	offset from last point to conic end on x-axis
`dy2`	offset from last point to conic end on y-axis
`w`	weight of added conic

Return Value

reference to SkPath

Example

SkPath& cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)

Adds cubic from last point towards (x1, y1), then towards (x2, y2), ending at (x3, y3). If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding cubic.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kCubic_Verb to verb array; and (x1, y1), (x2, y2), (x3, y3) to SkPoint array.

Parameters

`x1`	first control SkPoint of cubic on x-axis
`y1`	first control SkPoint of cubic on y-axis
`x2`	second control SkPoint of cubic on x-axis
`y2`	second control SkPoint of cubic on y-axis
`x3`	end SkPoint of cubic on x-axis
`y3`	end SkPoint of cubic on y-axis

Return Value

reference to SkPath

Example

Parameters

`p1`	first control SkPoint of cubic
`p2`	second control SkPoint of cubic
`p3`	end SkPoint of cubic

Return Value

reference to SkPath

Example

Parameters

`dx1`	offset from last point to first cubic control on x-axis
`dy1`	offset from last point to first cubic control on y-axis
`dx2`	offset from last point to second cubic control on x-axis
`dy2`	offset from last point to second cubic control on y-axis
`dx3`	offset from last point to cubic end on x-axis
`dy3`	offset from last point to cubic end on y-axis

Return Value

reference to SkPath

Example

In the example above:

1 describes an arc from an oval, a starting angle, and a sweep angle.

2 is similar to 1, but does not require building a path to draw.

3 is similar to 1, but always begins new Contour.

4 describes an arc from a pair of tangent lines and a radius.

5 describes an arc from Oval center, arc start Point and arc end Point.

6 describes an arc from a pair of tangent lines and a Conic_Weight.

SkPath& arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool forceMoveTo)

Appends arc to SkPath. Arc added is part of ellipse bounded by oval, from startAngle through sweepAngle. Both startAngle and sweepAngle are measured in degrees, where zero degrees is aligned with the positive x-axis, and positive sweeps extends arc clockwise.

arcTo() adds line connecting SkPath last SkPoint to initial arc SkPoint if forceMoveTo is false and SkPath is not empty. Otherwise, added contour begins with first point of arc. Angles greater than -360 and less than 360 are treated modulo 360.

Parameters

`oval`	bounds of ellipse containing arc
`startAngle`	starting angle of arc in degrees
`sweepAngle`	sweep, in degrees. Positive is clockwise; treated modulo 360
`forceMoveTo`	true to start a new contour with arc

Return Value

reference to SkPath

Example

arcTo continues a previous contour when forceMoveTo is false and when Path is not empty.

Parameters

`x1`	x-axis value common to pair of tangents
`y1`	y-axis value common to pair of tangents
`x2`	x-axis value end of second tangent
`y2`	y-axis value end of second tangent
`radius`	distance from arc to circle center

Return Value

reference to SkPath

Example

arcTo is represented by Line and circular Conic in Path.

Example Output

move to (156,20)
line (156,20),(79.2893,20)
conic (79.2893,20),(200,20),(114.645,105.355) weight 0.382683

Parameters

`p1`	SkPoint common to pair of tangents
`p2`	end of second tangent
`radius`	distance from arc to circle center

Return Value

reference to SkPath

Example

Because tangent lines are parallel, arcTo appends line from last Path Point to p1, but does not append a circular Conic.

Example Output

move to (156,20)
line (156,20),(200,20)

Constants

Const	Value	Description
`SkPath::kSmall_ArcSize`	0	smaller of Arc pair
`SkPath::kLarge_ArcSize`	1	larger of Arc pair

Example

Arc begins at top of Oval pair and ends at bottom. Arc can take four routes to get there. Two routes are large, and two routes are counterclockwise. The one route both large and counterclockwise is blue.

Parameters

`rx`	radius on x-axis before x-axis rotation
`ry`	radius on y-axis before x-axis rotation
`xAxisRotate`	x-axis rotation in degrees; positive values are clockwise
`largeArc`	chooses smaller or larger arc
`sweep`	chooses clockwise or counterclockwise arc
`x`	end of arc
`y`	end of arc

Return Value

reference to SkPath

Example

Parameters

`r`	radii on axes before x-axis rotation
`xAxisRotate`	x-axis rotation in degrees; positive values are clockwise
`largeArc`	chooses smaller or larger arc
`sweep`	chooses clockwise or counterclockwise arc
`xy`	end of arc

Return Value

reference to SkPath

Example

Parameters

`rx`	radius before x-axis rotation
`ry`	radius before x-axis rotation
`xAxisRotate`	x-axis rotation in degrees; positive values are clockwise
`largeArc`	chooses smaller or larger Arc
`sweep`	chooses clockwise or counterclockwise Arc
`dx`	x-axis offset end of Arc from last Path Point
`dy`	y-axis offset end of Arc from last Path Point

Return Value

reference to Path

Example

Return Value

reference to SkPath

Example

Parameters

fill one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType, kInverseEvenOdd_FillType

Return Value

true if Path fills outside its bounds

Example

Example Output

IsInverseFillType(kWinding_FillType) == false
IsInverseFillType(kEvenOdd_FillType) == false
IsInverseFillType(kInverseWinding_FillType) == true
IsInverseFillType(kInverseEvenOdd_FillType) == true

Parameters

fill one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType, kInverseEvenOdd_FillType

Return Value

fill, or kWinding_FillType or kEvenOdd_FillType if fill is inverted

Example

Example Output

ConvertToNonInverseFillType(kWinding_FillType) == kWinding_FillType
ConvertToNonInverseFillType(kEvenOdd_FillType) == kEvenOdd_FillType
ConvertToNonInverseFillType(kInverseWinding_FillType) == kWinding_FillType
ConvertToNonInverseFillType(kInverseEvenOdd_FillType) == kEvenOdd_FillType

Parameters

`p0`	Conic start Point
`p1`	Conic control Point
`p2`	Conic end Point
`w`	Conic weight
`pts`	storage for Quad array
`pow2`	Quad count, as power of two, normally 0 to 5 (1 to 32 Quad curves)

Return Value

number of Quad curves written to pts

Example

A pair of Quad curves are drawn in red on top of the elliptical Conic curve in black. The middle curve is nearly circular. The top-right curve is parabolic, which can be drawn exactly with a single Quad.

Parameters

`rect`	storage for bounds of SkRect; may be nullptr
`isClosed`	storage set to true if SkPath is closed; may be nullptr
`direction`	storage set to SkRect direction; may be nullptr

Return Value

true if SkPath contains SkRect

Example

After addRect, isRect returns true. Following moveTo permits isRect to return true, but following lineTo does not. addPoly returns true even though rect is not closed, and one side of rect is made up of consecutive line segments.

Example Output

empty is not rect
addRect is rect (10, 20, 30, 40); is closed; direction CW
moveTo is rect (10, 20, 30, 40); is closed; direction CW
lineTo is not rect
addPoly is rect (0, 0, 80, 80); is not closed; direction CCW

Parameters

`rect`	storage for SkRect pair; may be nullptr
`dirs`	storage for SkPath::Direction pair; may be nullptr

Return Value

true if SkPath contains nested SkRect pair

Example

Example Output

outer (7.5, 17.5, 32.5, 42.5); direction CW
inner (12.5, 22.5, 27.5, 37.5); direction CCW

Parameters

`rect`	SkRect to add as a closed contour
`dir`	SkPath::Direction to wind added contour

Return Value

reference to SkPath

Example

The left Rect dashes starting at the top-left corner, to the right. The right Rect dashes starting at the top-left corner, towards the bottom.

Parameters

`rect`	Rect to add as a closed contour
`dir`	Direction to wind added contour
`start`	initial corner of Rect to add

Return Value

reference to Path

Example

The arrow is just after the initial corner and points towards the next corner appended to Path.

Parameters

`left`	smaller x-axis value of SkRect
`top`	smaller y-axis value of SkRect
`right`	larger x-axis value of SkRect
`bottom`	larger y-axis value of SkRect
`dir`	SkPath::Direction to wind added contour

Return Value

reference to SkPath

Example

The left Rect dashes start at the top-left corner, and continue to the right. The right Rect dashes start at the top-left corner, and continue down.

Parameters

`oval`	bounds of ellipse added
`dir`	SkPath::Direction to wind ellipse

Return Value

reference to SkPath

Example

Parameters

`oval`	bounds of ellipse added
`dir`	Direction to wind ellipse
`start`	index of initial point of ellipse

Return Value

reference to Path

Example

Parameters

`x`	center of Circle
`y`	center of Circle
`radius`	distance from center to edge
`dir`	Direction to wind Circle

Return Value

reference to Path

Example

Parameters

`oval`	bounds of ellipse containing arc
`startAngle`	starting angle of arc in degrees
`sweepAngle`	sweep, in degrees. Positive is clockwise; treated modulo 360

Return Value

reference to SkPath

Example

The middle row of the left and right columns draw differently from the entries above and below because sweepAngle is outside of the range of +/-360, and startAngle modulo 90 is not zero.

Parameters

`rect`	bounds of SkRRect
`rx`	x-axis radius of rounded corners on the SkRRect
`ry`	y-axis radius of rounded corners on the SkRRect
`dir`	SkPath::Direction to wind SkRRect

Return Value

reference to SkPath

Example

If either radius is zero, path contains Rect and is drawn red. If sides are only radii, path contains Oval and is drawn blue. All remaining path draws are convex, and are drawn in gray; no paths constructed from addRoundRect are concave, so none are drawn in green.

Parameters

`rect`	bounds of Round_Rect
`radii`	array of 8 SkScalar values, a radius pair for each corner
`dir`	Direction to wind Round_Rect

Return Value

reference to Path

Example

Parameters

`rrect`	bounds and radii of rounded rectangle
`dir`	SkPath::Direction to wind SkRRect

Return Value

reference to SkPath

Example

Parameters

`rrect`	bounds and radii of rounded rectangle
`dir`	Direction to wind Round_Rect
`start`	index of initial point of Round_Rect

Return Value

reference to Path

Example

Parameters

`pts`	array of line sharing end and start SkPoint
`count`	length of SkPoint array
`close`	true to add line connecting contour end and start

Return Value

reference to SkPath

Example

Parameters

`list`	array of SkPoint
`close`	true to add line connecting contour end and start

Return Value

reference to SkPath

Example

Constants

Const	Value	Description
`SkPath::kAppend_AddPathMode`	#Line # appended to destination unaltered ##	Path Verbs, Points, and Conic_Weights are appended to destination unaltered. Since Path Verb_Array begins with kMove_Verb if src is not empty, this starts a new Contour.
`SkPath::kExtend_AddPathMode`	#Line # add line if prior Contour is not closed ##	If destination is closed or empty, start a new Contour. If destination is not empty, add Line from Last_Point to added Path first Point. Skip added Path initial kMove_Verb, then append remaining Verbs, Points, and Conic_Weights.

Example

test is built from path, open on the top row, and closed on the bottom row. The left column uses kAppend_AddPathMode; the right uses kExtend_AddPathMode. The top right composition is made up of one contour; the other three have two.

Parameters

`src`	SkPath verbs, SkPoint, and conic weights to add
`dx`	offset added to src SkPoint array x-axis coordinates
`dy`	offset added to src SkPoint array y-axis coordinates
`mode`	kAppend_AddPathMode or kExtend_AddPathMode

Return Value

reference to SkPath

Example

Parameters

`src`	SkPath verbs, SkPoint, and conic weights to add
`mode`	kAppend_AddPathMode or kExtend_AddPathMode

Return Value

reference to SkPath

Example

Parameters

`src`	SkPath verbs, SkPoint, and conic weights to add
`matrix`	transform applied to src
`mode`	kAppend_AddPathMode or kExtend_AddPathMode

Return Value

reference to SkPath

Example

Parameters

src SkPath verbs, SkPoint, and conic weights to add

Return Value

reference to SkPath

Example

Parameters

`dx`	offset added to SkPoint array x-axis coordinates
`dy`	offset added to SkPoint array y-axis coordinates
`dst`	overwritten, translated copy of SkPath; may be nullptr

Example

Parameters

`dx`	offset added to SkPoint array x-axis coordinates
`dy`	offset added to SkPoint array y-axis coordinates

Example

Parameters

`matrix`	SkMatrix to apply to SkPath
`dst`	overwritten, transformed copy of SkPath; may be nullptr

Example

Parameters

matrix SkMatrix to apply to SkPath

Example

Parameters

lastPt storage for final SkPoint in SkPoint array; may be nullptr

Return Value

true if SkPoint array contains one or more SkPoint

Example

Example Output

last point: 35.2786, 52.9772

Parameters

`x`	set x-axis value of last point
`y`	set y-axis value of last point

Example

Parameters

`p`	set value of last point

Example

Constants

Const	Value	Description
`SkPath::kLine_SegmentMask`	1	Set if Verb_Array contains kLine_Verb.
`SkPath::kQuad_SegmentMask`	2	Set if Verb_Array contains kQuad_Verb. Note that conicTo may add a Quad.
`SkPath::kConic_SegmentMask`	4	Set if Verb_Array contains kConic_Verb.
`SkPath::kCubic_SegmentMask`	8	Set if Verb_Array contains kCubic_Verb.

Example

When conicTo has a weight of one, Quad is added to Path.

Example Output

Path kConic_SegmentMask is clear
Path kQuad_SegmentMask is set

Return Value

SegmentMask bits or zero

Example

Example Output

mask quad set

Parameters

`x`	x-axis value of containment test
`y`	y-axis value of containment test

Return Value

true if Point is in Path

Example

Parameters

`stream`	writable SkWStream receiving SkPath text representation; may be nullptr
`forceClose`	true if missing kClose_Verb is output
`dumpAsHex`	true if SkScalar values are written as hexadecimal

Example

Example Output

path.setFillType(SkPath::kWinding_FillType);
path.moveTo(0, 0);
path.quadTo(20, 30, 40, 50);
path.setFillType(SkPath::kWinding_FillType);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
path.quadTo(SkBits2Float(0x41a00000), SkBits2Float(0x41f00000), SkBits2Float(0x42200000), SkBits2Float(0x42480000));  // 20, 30, 40, 50
path.setFillType(SkPath::kWinding_FillType);
path.moveTo(0, 0);
path.quadTo(20, 30, 40, 50);
path.lineTo(0, 0);
path.close();
path.setFillType(SkPath::kWinding_FillType);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
path.quadTo(SkBits2Float(0x41a00000), SkBits2Float(0x41f00000), SkBits2Float(0x42200000), SkBits2Float(0x42480000));  // 20, 30, 40, 50
path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
path.close();

Example

Example Output

path.setFillType(SkPath::kWinding_FillType);
path.moveTo(0, 0);
path.lineTo(0.857143f, 0.666667f);
path is not equal to copy

Example

Example Output

path.setFillType(SkPath::kWinding_FillType);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
path.lineTo(SkBits2Float(0x3f5b6db7), SkBits2Float(0x3f2aaaab));  // 0.857143f, 0.666667f
path is equal to copy

Parameters

buffer storage for SkPath; may be nullptr

Return Value

size of storage required for SkPath; always a multiple of 4

Example

Example Output

path is equal to copy

Return Value

SkPath data wrapped in SkData buffer

Example

Example Output

path is equal to copy

Parameters

`buffer`	storage for SkPath
`length`	buffer size in bytes; must be multiple of 4

Return Value

number of bytes read, or zero on failure

Example

Example Output

length = 32; returned by readFromMemory = 0
length = 40; returned by readFromMemory = 36

Return Value

non-zero, globally unique value

Example

Example Output

empty genID = 1
1st lineTo genID = 2
empty genID = 1
2nd lineTo genID = 3

Return Value

true if SkPath data is consistent

bool pathRefIsValid() const

To be deprecated soon.

    class Iter {
    public:
        Iter();
        Iter(const SkPath& path, bool forceClose);
        void setPath(const SkPath& path, bool forceClose);
        Verb next(SkPoint pts[4], bool doConsumeDegenerates = true, bool exact = false);
        SkScalar conicWeight() const;
        bool isCloseLine() const;
        bool isClosedContour() const;
    };

Iterates through Verb_Array, and associated Point_Array and Conic_Weight. Provides options to treat open Contours as closed, and to ignore degenerate data.

Example

Ignoring the actual Verbs and replacing them with Quads rounds the path of the glyph.

Return Value

SkPath::Iter of empty SkPath

Example

Example Output

iter is done
iter is done

Parameters

`path`	SkPath to iterate
`forceClose`	true if open contours generate kClose_Verb

Return Value

SkPath::Iter of path

Example

Example Output

open:
kMove_Verb {0, 0},
kQuad_Verb {0, 0}, {10, 20}, {30, 40},
kDone_Verb
closed:
kMove_Verb {0, 0},
kQuad_Verb {0, 0}, {10, 20}, {30, 40},
kLine_Verb {30, 40}, {0, 0},
kClose_Verb {0, 0},
kDone_Verb

Parameters

`path`	SkPath to iterate
`forceClose`	true if open contours generate kClose_Verb

Example

Example Output

quad open:
kMove_Verb {0, 0},
kQuad_Verb {0, 0}, {10, 20}, {30, 40},
kDone_Verb
conic closed:
kMove_Verb {0, 0},
kConic_Verb {0, 0}, {1, 2}, {3, 4}, weight = 0.5
kLine_Verb {3, 4}, {0, 0},
kClose_Verb {0, 0},
kDone_Verb

Parameters

`pts`	storage for SkPoint data describing returned SkPath::Verb
`doConsumeDegenerates`	if true, skip degenerate verbs
`exact`	skip zero length curves

Return Value

next SkPath::Verb from verb array

Example

skip degenerate skips the first in a kMove_Verb pair, the kMove_Verb followed by the kClose_Verb, the zero length Line and the very small Line.

skip degenerate if exact skips the same as skip degenerate, but shows the very small Line.

skip none shows all of the Verbs and Points in Path.

Example Output

skip degenerate:
kMove_Verb {20, 20},
kQuad_Verb {20, 20}, {10, 20}, {30, 40},
kDone_Verb
skip degenerate if exact:
kMove_Verb {20, 20},
kQuad_Verb {20, 20}, {10, 20}, {30, 40},
kMove_Verb {30, 30},
kLine_Verb {30, 30}, {30.00001, 30},
kDone_Verb
skip none:
kMove_Verb {10, 10},
kMove_Verb {20, 20},
kQuad_Verb {20, 20}, {10, 20}, {30, 40},
kMove_Verb {1, 1},
kClose_Verb {1, 1},
kMove_Verb {30, 30},
kLine_Verb {30, 30}, {30, 30},
kMove_Verb {30, 30},
kLine_Verb {30, 30}, {30.00001, 30},
kDone_Verb

Return Value

conic weight for conic SkPoint returned by next()

Example

Example Output

first verb is move
next verb is conic
conic points: {0,0}, {1,2}, {3,4}
conic weight: 0.5

Return Value

true if last kLine_Verb was generated by kClose_Verb

Example

Example Output

1st verb is move
moveTo point: {6,7}
2nd verb is conic
3rd verb is line
line points: {3,4}, {6,7}
line generated by close
4th verb is close

Return Value

true if contour is closed

Example

Example Output

without close(), forceClose is false: isClosedContour returns false
with close(),    forceClose is false: isClosedContour returns true
without close(), forceClose is true : isClosedContour returns true
with close(),    forceClose is true : isClosedContour returns true

Return Value

RawIter of empty SkPath

RawIter(const SkPath& path)

Sets RawIter to return elements of verb array, SkPoint array, and conic weight in path.

Parameters

path SkPath to iterate

Return Value

RawIter of path

void setPath(const SkPath& path)

Sets SkPath::Iter to return elements of verb array, SkPoint array, and conic weight in path.

Parameters

path SkPath to iterate

Verb next(SkPoint pts[4])

Returns next SkPath::Verb in verb array, and advances RawIter. When verb array is exhausted, returns kDone_Verb. Zero to four SkPoint are stored in pts, depending on the returned SkPath::Verb.

Parameters

pts storage for SkPoint data describing returned SkPath::Verb

Return Value

next SkPath::Verb from verb array

Example

Example Output

kMove_Verb {50, 60},
kQuad_Verb {50, 60}, {10, 20}, {30, 40},
kClose_Verb {50, 60},
kMove_Verb {50, 60},
kLine_Verb {50, 60}, {30, 30},
kConic_Verb {30, 30}, {1, 2}, {3, 4}, weight = 0.5
kCubic_Verb {3, 4}, {-1, -2}, {-3, -4}, {-5, -6},
kDone_Verb

Return Value

next SkPath::Verb from verb array

Example

Example Output

#Volatile
peek Move == verb Move
peek Quad == verb Quad
peek Conic == verb Conic
peek Cubic == verb Cubic
peek Done == verb Done
peek Done == verb Done

Return Value

conic weight for conic SkPoint returned by next()

Example

Example Output

first verb is move
next verb is conic
conic points: {0,0}, {1,2}, {3,4}
conic weight: 0.5

start	Point
0	oval.centerX(), oval.fTop
1	oval.fRight, oval.centerY()
2	oval.centerX(), oval.fBottom
3	oval.fLeft, oval.centerY()

radii index	location
0	x-axis radius of top-left corner
1	y-axis radius of top-left corner
2	x-axis radius of top-right corner
3	y-axis radius of top-right corner
4	x-axis radius of bottom-right corner
5	y-axis radius of bottom-right corner
6	x-axis radius of bottom-left corner
7	y-axis radius of bottom-left corner

FillType	is inverse
kWinding_FillType	false
kEvenOdd_FillType	false
kInverseWinding_FillType	true
kInverseEvenOdd_FillType	true

start	location
0	right of top-left corner
1	left of top-right corner
2	bottom of top-right corner
3	top of bottom-right corner
4	left of bottom-right corner
5	right of bottom-left corner
6	top of bottom-left corner
7	bottom of top-left corner

FillType	contains() returns true if Point is enclosed by
kWinding_FillType	a non-zero sum of Contour Directions.
kEvenOdd_FillType	an odd number of Contours.
kInverseWinding_FillType	a zero sum of Contour Directions.
kInverseEvenOdd_FillType	and even number of Contours.

290 KiB Raw Blame History

SkPath Reference

Constants

Example

Example Output

Constants

Example

See Also

Return Value

Example

Example Output

See Also

Parameters

Return Value

Example

Example Output

See Also

Example

See Also

Parameters

Return Value

Example

Example Output

See Also

Parameters

Return Value

Example

Example Output

See Also

Parameters

Return Value

Example

Example Output

Parameters

Return Value

Example

Example Output

See Also

Parameters

Return Value

Example

See Also

Example

Constants

Example

See Also

Return Value

Example

Example Output

See Also

Parameters

Example

See Also

Return Value

Example

Example Output

See Also

Example

See Also

Constants

Example

See Also

Return Value

Example

See Also

Return Value

Example

See Also

Parameters

Example

See Also

Return Value

Example

See Also

Parameters

Return Value

Example

See Also

Parameters

Return Value

290 KiB

Raw Blame History