SkDashImpl Class Reference

#include <SkDashImpl.h>

Inheritance diagram for SkDashImpl:

Public Member Functions
	SkDashImpl (const SkScalar intervals[], int count, SkScalar phase)
Public Member Functions inherited from SkPathEffectBase
	SkPathEffectBase ()
bool	asPoints (PointData *results, const SkPath &src, const SkStrokeRec &, const SkMatrix &, const SkRect *cullR) const
SkFlattenable::Type	getFlattenableType () const override
virtual bool	onNeedsCTM () const
Public Member Functions inherited from SkPathEffect
DashType	asADash (DashInfo *info) const
bool	filterPath (SkPath *dst, const SkPath &src, SkStrokeRec *, const SkRect *cullR) const
bool	filterPath (SkPath *dst, const SkPath &src, SkStrokeRec *, const SkRect *cullR, const SkMatrix &ctm) const
bool	needsCTM () const
Public Member Functions inherited from SkFlattenable
	SkFlattenable ()
virtual Factory	getFactory () const =0
virtual const char *	getTypeName () const =0
sk_sp< SkData >	serialize (const SkSerialProcs *=nullptr) const
size_t	serialize (void *memory, size_t memory_size, const SkSerialProcs *=nullptr) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Protected Member Functions
	~SkDashImpl () override
void	flatten (SkWriteBuffer &) const override
bool	onFilterPath (SkPath *dst, const SkPath &src, SkStrokeRec *, const SkRect *, const SkMatrix &) const override
bool	onAsPoints (PointData *results, const SkPath &src, const SkStrokeRec &, const SkMatrix &, const SkRect *) const override
DashType	onAsADash (DashInfo *info) const override

Private Member Functions
bool	computeFastBounds (SkRect *bounds) const override

Additional Inherited Members
Public Types inherited from SkPathEffect
enum	DashType { kNone_DashType , kDash_DashType }
Public Types inherited from SkFlattenable
enum	Type {   kSkColorFilter_Type , kSkBlender_Type , kSkDrawable_Type , kSkDrawLooper_Type ,   kSkImageFilter_Type , kSkMaskFilter_Type , kSkPathEffect_Type , kSkShader_Type }
typedef sk_sp< SkFlattenable >(*	Factory) (SkReadBuffer &)
Static Public Member Functions inherited from SkPathEffectBase
static sk_sp< SkPathEffect >	Deserialize (const void *data, size_t size, const SkDeserialProcs *procs=nullptr)
static void	RegisterFlattenables ()
Static Public Member Functions inherited from SkPathEffect
static sk_sp< SkPathEffect >	MakeSum (sk_sp< SkPathEffect > first, sk_sp< SkPathEffect > second)
static sk_sp< SkPathEffect >	MakeCompose (sk_sp< SkPathEffect > outer, sk_sp< SkPathEffect > inner)
static SkFlattenable::Type	GetFlattenableType ()
static sk_sp< SkPathEffect >	Deserialize (const void *data, size_t size, const SkDeserialProcs *procs=nullptr)
Static Public Member Functions inherited from SkFlattenable
static Factory	NameToFactory (const char name[])
static const char *	FactoryToName (Factory)
static void	Register (const char name[], Factory)
static sk_sp< SkFlattenable >	Deserialize (Type, const void *data, size_t length, const SkDeserialProcs *procs=nullptr)

Detailed Description

Definition at line 13 of file SkDashImpl.h.

Constructor & Destructor Documentation

SkDashImpl()

SkDashImpl::SkDashImpl	(	const SkScalar	intervals[],
		int	count,
		SkScalar	phase
	)

Definition at line 34 of file SkDashPathEffect.cpp.

        : fPhase(0)
        , fInitialDashLength(-1)
        , fInitialDashIndex(0)
        , fIntervalLength(0) {
    SkASSERT(intervals);
    SkASSERT(count > 1 && SkIsAlign2(count));
 
    fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count);
    fCount = count;
    for (int i = 0; i < count; i++) {
        fIntervals[i] = intervals[i];
    }
 
    // set the internal data members
    SkDashPath::CalcDashParameters(phase, fIntervals, fCount,
            &fInitialDashLength, &fInitialDashIndex, &fIntervalLength, &fPhase);
}

~SkDashImpl()

SkDashImpl::~SkDashImpl ( )

overrideprotected

Definition at line 53 of file SkDashPathEffect.cpp.

                        {
    sk_free(fIntervals);
}

Member Function Documentation

computeFastBounds()

bool SkDashImpl::computeFastBounds ( SkRect *  bounds ) const

inlineoverrideprivatevirtual

Implements SkPathEffectBase.

Definition at line 31 of file SkDashImpl.h.

                                                          {
        // Dashing a path returns a subset of the input path so just return true and leave
        // bounds unmodified
        return true;
    }

flatten()

void SkDashImpl::flatten ( SkWriteBuffer &  ) const

overrideprotectedvirtual

Override this if your subclass needs to record data that it will need to recreate itself from its CreateProc (returned by getFactory()).

DEPRECATED public : will move to protected ... use serialize() instead

Reimplemented from SkFlattenable.

Definition at line 386 of file SkDashPathEffect.cpp.

                                                    {
    buffer.writeScalar(fPhase);
    buffer.writeScalarArray(fIntervals, fCount);
}

onAsADash()

SkPathEffect::DashType SkDashImpl::onAsADash ( DashInfo *  info ) const

overrideprotectedvirtual

Reimplemented from SkPathEffectBase.

Definition at line 375 of file SkDashPathEffect.cpp.

                                                               {
    if (info) {
        if (info->fCount >= fCount && info->fIntervals) {
            memcpy(info->fIntervals, fIntervals, fCount * sizeof(SkScalar));
        }
        info->fCount = fCount;
        info->fPhase = fPhase;
    }
    return kDash_DashType;
}

onAsPoints()

bool SkDashImpl::onAsPoints ( PointData *  results, const SkPath &  src, const SkStrokeRec &  rec, const SkMatrix &  matrix, const SkRect *  cullRect  ) const

overrideprotectedvirtual

Reimplemented from SkPathEffectBase.

Definition at line 182 of file SkDashPathEffect.cpp.

                                                                                  {
    // width < 0 -> fill && width == 0 -> hairline so requiring width > 0 rules both out
    if (0 >= rec.getWidth()) {
        return false;
    }
 
    // TODO: this next test could be eased up. We could allow any number of
    // intervals as long as all the ons match and all the offs match.
    // Additionally, they do not necessarily need to be integers.
    // We cannot allow arbitrary intervals since we want the returned points
    // to be uniformly sized.
    if (fCount != 2 ||
        !SkScalarNearlyEqual(fIntervals[0], fIntervals[1]) ||
        !SkScalarIsInt(fIntervals[0]) ||
        !SkScalarIsInt(fIntervals[1])) {
        return false;
    }
 
    SkPoint pts[2];
 
    if (!src.isLine(pts)) {
        return false;
    }
 
    // TODO: this test could be eased up to allow circles
    if (SkPaint::kButt_Cap != rec.getCap()) {
        return false;
    }
 
    // TODO: this test could be eased up for circles. Rotations could be allowed.
    if (!matrix.rectStaysRect()) {
        return false;
    }
 
    // See if the line can be limited to something plausible.
    if (!cull_line(pts, rec, matrix, cullRect, fIntervalLength)) {
        return false;
    }
 
    SkScalar length = SkPoint::Distance(pts[1], pts[0]);
 
    SkVector tangent = pts[1] - pts[0];
    if (tangent.isZero()) {
        return false;
    }
 
    tangent.scale(SkScalarInvert(length));
 
    // TODO: make this test for horizontal & vertical lines more robust
    bool isXAxis = true;
    if (SkScalarNearlyEqual(SK_Scalar1, tangent.fX) ||
        SkScalarNearlyEqual(-SK_Scalar1, tangent.fX)) {
        results->fSize.set(SkScalarHalf(fIntervals[0]), SkScalarHalf(rec.getWidth()));
    } else if (SkScalarNearlyEqual(SK_Scalar1, tangent.fY) ||
               SkScalarNearlyEqual(-SK_Scalar1, tangent.fY)) {
        results->fSize.set(SkScalarHalf(rec.getWidth()), SkScalarHalf(fIntervals[0]));
        isXAxis = false;
    } else if (SkPaint::kRound_Cap != rec.getCap()) {
        // Angled lines don't have axis-aligned boxes.
        return false;
    }
 
    if (results) {
        results->fFlags = 0;
        SkScalar clampedInitialDashLength = std::min(length, fInitialDashLength);
 
        if (SkPaint::kRound_Cap == rec.getCap()) {
            results->fFlags |= PointData::kCircles_PointFlag;
        }
 
        results->fNumPoints = 0;
        SkScalar len2 = length;
        if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) {
            SkASSERT(len2 >= clampedInitialDashLength);
            if (0 == fInitialDashIndex) {
                if (clampedInitialDashLength > 0) {
                    if (clampedInitialDashLength >= fIntervals[0]) {
                        ++results->fNumPoints;  // partial first dash
                    }
                    len2 -= clampedInitialDashLength;
                }
                len2 -= fIntervals[1];  // also skip first space
                if (len2 < 0) {
                    len2 = 0;
                }
            } else {
                len2 -= clampedInitialDashLength; // skip initial partial empty
            }
        }
        // Too many midpoints can cause results->fNumPoints to overflow or
        // otherwise cause the results->fPoints allocation below to OOM.
        // Cap it to a sane value.
        SkScalar numIntervals = len2 / fIntervalLength;
        if (!SkIsFinite(numIntervals) || numIntervals > SkDashPath::kMaxDashCount) {
            return false;
        }
        int numMidPoints = SkScalarFloorToInt(numIntervals);
        results->fNumPoints += numMidPoints;
        len2 -= numMidPoints * fIntervalLength;
        bool partialLast = false;
        if (len2 > 0) {
            if (len2 < fIntervals[0]) {
                partialLast = true;
            } else {
                ++numMidPoints;
                ++results->fNumPoints;
            }
        }
 
        results->fPoints = new SkPoint[results->fNumPoints];
 
        SkScalar    distance = 0;
        int         curPt = 0;
 
        if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) {
            SkASSERT(clampedInitialDashLength <= length);
 
            if (0 == fInitialDashIndex) {
                if (clampedInitialDashLength > 0) {
                    // partial first block
                    SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles
                    SkScalar x = pts[0].fX + tangent.fX * SkScalarHalf(clampedInitialDashLength);
                    SkScalar y = pts[0].fY + tangent.fY * SkScalarHalf(clampedInitialDashLength);
                    SkScalar halfWidth, halfHeight;
                    if (isXAxis) {
                        halfWidth = SkScalarHalf(clampedInitialDashLength);
                        halfHeight = SkScalarHalf(rec.getWidth());
                    } else {
                        halfWidth = SkScalarHalf(rec.getWidth());
                        halfHeight = SkScalarHalf(clampedInitialDashLength);
                    }
                    if (clampedInitialDashLength < fIntervals[0]) {
                        // This one will not be like the others
                        results->fFirst.addRect(x - halfWidth, y - halfHeight,
                                                x + halfWidth, y + halfHeight);
                    } else {
                        SkASSERT(curPt < results->fNumPoints);
                        results->fPoints[curPt].set(x, y);
                        ++curPt;
                    }
 
                    distance += clampedInitialDashLength;
                }
 
                distance += fIntervals[1];  // skip over the next blank block too
            } else {
                distance += clampedInitialDashLength;
            }
        }
 
        if (0 != numMidPoints) {
            distance += SkScalarHalf(fIntervals[0]);
 
            for (int i = 0; i < numMidPoints; ++i) {
                SkScalar x = pts[0].fX + tangent.fX * distance;
                SkScalar y = pts[0].fY + tangent.fY * distance;
 
                SkASSERT(curPt < results->fNumPoints);
                results->fPoints[curPt].set(x, y);
                ++curPt;
 
                distance += fIntervalLength;
            }
 
            distance -= SkScalarHalf(fIntervals[0]);
        }
 
        if (partialLast) {
            // partial final block
            SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles
            SkScalar temp = length - distance;
            SkASSERT(temp < fIntervals[0]);
            SkScalar x = pts[0].fX + tangent.fX * (distance + SkScalarHalf(temp));
            SkScalar y = pts[0].fY + tangent.fY * (distance + SkScalarHalf(temp));
            SkScalar halfWidth, halfHeight;
            if (isXAxis) {
                halfWidth = SkScalarHalf(temp);
                halfHeight = SkScalarHalf(rec.getWidth());
            } else {
                halfWidth = SkScalarHalf(rec.getWidth());
                halfHeight = SkScalarHalf(temp);
            }
            results->fLast.addRect(x - halfWidth, y - halfHeight,
                                   x + halfWidth, y + halfHeight);
        }
 
        SkASSERT(curPt == results->fNumPoints);
    }
 
    return true;
}

onFilterPath()

bool SkDashImpl::onFilterPath ( SkPath *  , const SkPath &  , SkStrokeRec *  , const SkRect *  , const SkMatrix &    ) const

overrideprotectedvirtual

Filter the input path.

The CTM parameter is provided for path effects that can use the information. The output of path effects must always be in the original (input) coordinate system, regardless of whether the path effect uses the CTM or not.

Implements SkPathEffectBase.

Definition at line 57 of file SkDashPathEffect.cpp.

                                                                             {
    return SkDashPath::InternalFilter(dst, src, rec, cullRect, fIntervals, fCount,
                                      fInitialDashLength, fInitialDashIndex, fIntervalLength,
                                      fPhase);
}

---

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

• third_party/skia/src/effects/SkDashImpl.h
• third_party/skia/src/effects/SkDashPathEffect.cpp