SkStroke Class Reference

#include <SkStroke.h>

Public Member Functions
	SkStroke ()
	SkStroke (const SkPaint &)
	SkStroke (const SkPaint &, SkScalar width)
SkPaint::Cap	getCap () const
void	setCap (SkPaint::Cap)
SkPaint::Join	getJoin () const
void	setJoin (SkPaint::Join)
void	setMiterLimit (SkScalar)
void	setWidth (SkScalar)
bool	getDoFill () const
void	setDoFill (bool doFill)
SkScalar	getResScale () const
void	setResScale (SkScalar rs)
void	strokeRect (const SkRect &rect, SkPath *result, SkPathDirection=SkPathDirection::kCW) const
void	strokePath (const SkPath &path, SkPath *) const

Friends
class	SkPaint

Detailed Description

SkStroke is the utility class that constructs paths by stroking geometries (lines, rects, ovals, roundrects, paths). This is invoked when a geometry or text is drawn in a canvas with the kStroke_Mask bit set in the paint.

Definition at line 36 of file SkStroke.h.

Constructor & Destructor Documentation

SkStroke() [1/3]

SkStroke::SkStroke

(

)

Definition at line 1358 of file SkStroke.cpp.

                   {
    fWidth      = SK_Scalar1;
    fMiterLimit = SkPaintDefaults_MiterLimit;
    fResScale   = 1;
    fCap        = SkPaint::kDefault_Cap;
    fJoin       = SkPaint::kDefault_Join;
    fDoFill     = false;
}

SkStroke() [2/3]

SkStroke::SkStroke

(

const SkPaint &

p

)

Definition at line 1367 of file SkStroke.cpp.

                                   {
    fWidth      = p.getStrokeWidth();
    fMiterLimit = p.getStrokeMiter();
    fResScale   = 1;
    fCap        = (uint8_t)p.getStrokeCap();
    fJoin       = (uint8_t)p.getStrokeJoin();
    fDoFill     = SkToU8(p.getStyle() == SkPaint::kStrokeAndFill_Style);
}

SkStroke() [3/3]

SkStroke::SkStroke	(	const SkPaint &	p,
		SkScalar	width
	)

Definition at line 1376 of file SkStroke.cpp.

                                                   {
    fWidth      = width;
    fMiterLimit = p.getStrokeMiter();
    fResScale   = 1;
    fCap        = (uint8_t)p.getStrokeCap();
    fJoin       = (uint8_t)p.getStrokeJoin();
    fDoFill     = SkToU8(p.getStyle() == SkPaint::kStrokeAndFill_Style);
}

Member Function Documentation

getCap()

SkPaint::Cap SkStroke::getCap ( ) const

inline

Definition at line 42 of file SkStroke.h.

{ return (SkPaint::Cap)fCap; }

getDoFill()

bool SkStroke::getDoFill ( ) const

inline

Definition at line 51 of file SkStroke.h.

{ return SkToBool(fDoFill); }

getJoin()

SkPaint::Join SkStroke::getJoin ( ) const

inline

Definition at line 45 of file SkStroke.h.

{ return (SkPaint::Join)fJoin; }

getResScale()

SkScalar SkStroke::getResScale ( ) const

inline

ResScale is the "intended" resolution for the output. Default is 1.0. Larger values (res > 1) indicate that the result should be more precise, since it will be zoomed up, and small errors will be magnified. Smaller values (0 < res < 1) indicate that the result can be less precise, since it will be zoomed down, and small errors may be invisible.

Definition at line 62 of file SkStroke.h.

{ return fResScale; }

setCap()

void SkStroke::setCap

(

SkPaint::Cap

cap

)

Definition at line 1395 of file SkStroke.cpp.

                                    {
    SkASSERT((unsigned)cap < SkPaint::kCapCount);
    fCap = SkToU8(cap);
}

setDoFill()

void SkStroke::setDoFill ( bool  doFill )

inline

Definition at line 52 of file SkStroke.h.

{ fDoFill = SkToU8(doFill); }

setJoin()

void SkStroke::setJoin

(

SkPaint::Join

join

)

Definition at line 1400 of file SkStroke.cpp.

                                       {
    SkASSERT((unsigned)join < SkPaint::kJoinCount);
    fJoin = SkToU8(join);
}

setMiterLimit()

void SkStroke::setMiterLimit

(

SkScalar

miterLimit

)

Definition at line 1390 of file SkStroke.cpp.

                                                {
    SkASSERT(miterLimit >= 0);
    fMiterLimit = miterLimit;
}

setResScale()

void SkStroke::setResScale ( SkScalar  rs )

inline

Definition at line 63 of file SkStroke.h.

                                  {
        SkASSERT(rs > 0 && std::isfinite(rs));
        fResScale = rs;
    }

setWidth()

void SkStroke::setWidth

(

SkScalar

width

)

Definition at line 1385 of file SkStroke.cpp.

                                      {
    SkASSERT(width >= 0);
    fWidth = width;
}

strokePath()

void SkStroke::strokePath	(	const SkPath &	path,
		SkPath *	dst
	)		const

Definition at line 1433 of file SkStroke.cpp.

                                                              {
    SkASSERT(dst);
 
    SkScalar radius = SkScalarHalf(fWidth);
 
    AutoTmpPath tmp(src, &dst);
 
    if (radius <= 0) {
        return;
    }
 
    // If src is really a rect, call our specialty strokeRect() method
    {
        SkRect rect;
        bool isClosed = false;
        SkPathDirection dir;
        if (src.isRect(&rect, &isClosed, &dir) && isClosed) {
            this->strokeRect(rect, dst, dir);
            // our answer should preserve the inverseness of the src
            if (src.isInverseFillType()) {
                SkASSERT(!dst->isInverseFillType());
                dst->toggleInverseFillType();
            }
            return;
        }
    }
 
    // We can always ignore centers for stroke and fill convex line-only paths
    // TODO: remove the line-only restriction
    bool ignoreCenter = fDoFill && (src.getSegmentMasks() == SkPath::kLine_SegmentMask) &&
                        src.isLastContourClosed() && src.isConvex();
 
    SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(), this->getJoin(),
                            fResScale, ignoreCenter);
    SkPath::Iter    iter(src, false);
    SkPath::Verb    lastSegment = SkPath::kMove_Verb;
 
    for (;;) {
        SkPoint  pts[4];
        switch (iter.next(pts)) {
            case SkPath::kMove_Verb:
                stroker.moveTo(pts[0]);
                break;
            case SkPath::kLine_Verb:
                stroker.lineTo(pts[1], &iter);
                lastSegment = SkPath::kLine_Verb;
                break;
            case SkPath::kQuad_Verb:
                stroker.quadTo(pts[1], pts[2]);
                lastSegment = SkPath::kQuad_Verb;
                break;
            case SkPath::kConic_Verb: {
                stroker.conicTo(pts[1], pts[2], iter.conicWeight());
                lastSegment = SkPath::kConic_Verb;
            } break;
            case SkPath::kCubic_Verb:
                stroker.cubicTo(pts[1], pts[2], pts[3]);
                lastSegment = SkPath::kCubic_Verb;
                break;
            case SkPath::kClose_Verb:
                if (SkPaint::kButt_Cap != this->getCap()) {
                    /* If the stroke consists of a moveTo followed by a close, treat it
                       as if it were followed by a zero-length line. Lines without length
                       can have square and round end caps. */
                    if (stroker.hasOnlyMoveTo()) {
                        stroker.lineTo(stroker.moveToPt());
                        goto ZERO_LENGTH;
                    }
                    /* If the stroke consists of a moveTo followed by one or more zero-length
                       verbs, then followed by a close, treat is as if it were followed by a
                       zero-length line. Lines without length can have square & round end caps. */
                    if (stroker.isCurrentContourEmpty()) {
                ZERO_LENGTH:
                        lastSegment = SkPath::kLine_Verb;
                        break;
                    }
                }
                stroker.close(lastSegment == SkPath::kLine_Verb);
                break;
            case SkPath::kDone_Verb:
                goto DONE;
        }
    }
DONE:
    stroker.done(dst, lastSegment == SkPath::kLine_Verb);
 
    if (fDoFill && !ignoreCenter) {
        if (SkPathPriv::ComputeFirstDirection(src) == SkPathFirstDirection::kCCW) {
            dst->reverseAddPath(src);
        } else {
            dst->addPath(src);
        }
    } else {
        //  Seems like we can assume that a 2-point src would always result in
        //  a convex stroke, but testing has proved otherwise.
        //  TODO: fix the stroker to make this assumption true (without making
        //  it slower that the work that will be done in computeConvexity())
#if 0
        // this test results in a non-convex stroke :(
        static void test(SkCanvas* canvas) {
            SkPoint pts[] = { 146.333328,  192.333328, 300.333344, 293.333344 };
            SkPaint paint;
            paint.setStrokeWidth(7);
            paint.setStrokeCap(SkPaint::kRound_Cap);
            canvas->drawLine(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, paint);
        }
#endif
#if 0
        if (2 == src.countPoints()) {
            dst->setIsConvex(true);
        }
#endif
    }
 
    // our answer should preserve the inverseness of the src
    if (src.isInverseFillType()) {
        SkASSERT(!dst->isInverseFillType());
        dst->toggleInverseFillType();
    }
}

strokeRect()

void SkStroke::strokeRect	(	const SkRect &	rect,
		SkPath *	result,
		SkPathDirection	dir = SkPathDirection::kCW
	)		const

Stroke the specified rect, winding it in the specified direction..

Definition at line 1584 of file SkStroke.cpp.

                                                     {
    SkASSERT(dst != nullptr);
    dst->reset();
 
    SkScalar radius = SkScalarHalf(fWidth);
    if (radius <= 0) {
        return;
    }
 
    SkScalar rw = origRect.width();
    SkScalar rh = origRect.height();
    if ((rw < 0) ^ (rh < 0)) {
        dir = reverse_direction(dir);
    }
    SkRect rect(origRect);
    rect.sort();
    // reassign these, now that we know they'll be >= 0
    rw = rect.width();
    rh = rect.height();
 
    SkRect r(rect);
    r.outset(radius, radius);
 
    SkPaint::Join join = (SkPaint::Join)fJoin;
    if (SkPaint::kMiter_Join == join && fMiterLimit < SK_ScalarSqrt2) {
        join = SkPaint::kBevel_Join;
    }
 
    switch (join) {
        case SkPaint::kMiter_Join:
            dst->addRect(r, dir);
            break;
        case SkPaint::kBevel_Join:
            addBevel(dst, rect, r, dir);
            break;
        case SkPaint::kRound_Join:
            dst->addRoundRect(r, radius, radius, dir);
            break;
        default:
            break;
    }
 
    if (fWidth < std::min(rw, rh) && !fDoFill) {
        r = rect;
        r.inset(radius, radius);
        dst->addRect(r, reverse_direction(dir));
    }
}

Friends And Related Function Documentation

SkPaint

friend class SkPaint

friend

Definition at line 83 of file SkStroke.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/core/SkStroke.h
• third_party/skia/src/core/SkStroke.cpp