SubsetVerbs Class Reference

#include <SubsetPath.h>

Inheritance diagram for SubsetVerbs:

Public Member Functions
	SubsetVerbs (const SkPath &path)
Public Member Functions inherited from SubsetPath
	SubsetPath (const SkPath &path)
virtual	~SubsetPath ()
bool	subset (bool testFailed, SkPath *sub)

Protected Member Functions
SkPath	getSubsetPath () const override
Protected Member Functions inherited from SubsetPath
int	range (int *end) const
virtual SkPath	getSubsetPath () const =0

Additional Inherited Members
Protected Attributes inherited from SubsetPath
const SkPath &	fPath
SkTDArray< bool >	fSelected
int	fSubset
int	fTries

Detailed Description

Definition at line 59 of file SubsetPath.h.

Constructor & Destructor Documentation

SubsetVerbs()

SubsetVerbs::SubsetVerbs

(

const SkPath &

path

)

Definition at line 152 of file SubsetPath.cpp.

        : SubsetPath(path) {
    int verbCount = 0;
    for (auto [verb, pts, w] : SkPathPriv::Iterate(fPath)) {
        switch (verb) {
            case SkPathVerb::kMove:
                break;
            case SkPathVerb::kLine:
            case SkPathVerb::kQuad:
            case SkPathVerb::kConic:
            case SkPathVerb::kCubic:
                ++verbCount;
                break;
            case SkPathVerb::kClose:
                break;
            default:
                SkDEBUGFAIL("bad verb");
                return;
        }
    }
    for (int index = 0; index < verbCount; ++index) {
        *fSelected.append() = true;
    }
    fTries = verbCount;
}

Member Function Documentation

getSubsetPath()

SkPath SubsetVerbs::getSubsetPath ( ) const

overrideprotectedvirtual

Implements SubsetPath.

Definition at line 178 of file SubsetPath.cpp.

                                        {
    SkPath result;
    result.setFillType(fPath.getFillType());
    if (!fSelected.size()) {
        return result;
    }
    int verbIndex = 0;
    bool addMoveTo = true;
    bool addLineTo = false;
    for (auto [verb, pts, w] : SkPathPriv::Iterate(fPath)) {
        bool enabled = SkPathVerb::kLine <= verb && verb <= SkPathVerb::kCubic
            ? fSelected[verbIndex++] : false;
        if (enabled) {
            if (addMoveTo) {
                result.moveTo(pts[0]);
                addMoveTo = false;
            } else if (addLineTo) {
                result.lineTo(pts[0]);
                addLineTo = false;
            }
        }
        switch (verb) {
            case SkPathVerb::kMove:
                break;
            case SkPathVerb::kLine:
                if (enabled) {
                    result.lineTo(pts[1]);
                }
                break;
            case SkPathVerb::kQuad:
                if (enabled) {
                    result.quadTo(pts[1], pts[2]);
                }
                break;
            case SkPathVerb::kConic:
                if (enabled) {
                    result.conicTo(pts[1], pts[2], *w);
                }
                break;
            case SkPathVerb::kCubic:
                 if (enabled) {
                    result.cubicTo(pts[1], pts[2], pts[3]);
                }
                break;
            case SkPathVerb::kClose:
                result.close();
                addMoveTo = true;
                addLineTo = false;
                continue;
            default:
                SkDEBUGFAIL("bad verb");
                return result;
        }
        addLineTo = !enabled;
    }
    return result;
}

---

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

• third_party/skia/tests/SubsetPath.h
• third_party/skia/tests/SubsetPath.cpp