SkPathRef::Editor Class Reference

#include <SkPathRef.h>

Public Member Functions
	Editor (sk_sp< SkPathRef > *pathRef, int incReserveVerbs=0, int incReservePoints=0, int incReserveConics=0)
	~Editor ()
SkPoint *	writablePoints ()
const SkPoint *	points () const
SkPoint *	atPoint (int i)
const SkPoint *	atPoint (int i) const
SkPoint *	growForVerb (int verb, SkScalar weight=0)
SkPoint *	growForRepeatedVerb (int verb, int numVbs, SkScalar **weights=nullptr)
std::tuple< SkPoint *, SkScalar * >	growForVerbsInPath (const SkPathRef &path)
void	resetToSize (int newVerbCnt, int newPointCnt, int newConicCount)
SkPathRef *	pathRef ()
void	setIsOval (bool isCCW, unsigned start, bool isClosed)
void	setIsRRect (bool isCCW, unsigned start)
void	setIsArc (const SkArc &arc)
void	setBounds (const SkRect &rect)

Detailed Description

Definition at line 93 of file SkPathRef.h.

Constructor & Destructor Documentation

Editor()

SkPathRef::Editor::Editor	(	sk_sp< SkPathRef > *	pathRef,
		int	incReserveVerbs = 0,
		int	incReservePoints = 0,
		int	incReserveConics = 0
	)

Definition at line 27 of file SkPathRef.cpp.

{
    SkASSERT(incReserveVerbs >= 0);
    SkASSERT(incReservePoints >= 0);
 
    if ((*pathRef)->unique()) {
        (*pathRef)->incReserve(incReserveVerbs, incReservePoints, incReserveConics);
    } else {
        SkPathRef* copy;
        // No need to copy if the existing ref is the empty ref (because it doesn't contain
        // anything).
        if (!(*pathRef)->isInitialEmptyPathRef()) {
            copy = new SkPathRef;
            copy->copy(**pathRef, incReserveVerbs, incReservePoints, incReserveConics);
        } else {
            // Size previously empty paths to exactly fit the supplied hints. The assumpion is
            // the caller knows the exact size they want (as happens in chrome when deserializing
            // paths).
            copy = new SkPathRef(incReserveVerbs, incReservePoints, incReserveConics);
        }
        pathRef->reset(copy);
    }
    fPathRef = pathRef->get();
    fPathRef->callGenIDChangeListeners();
    fPathRef->fGenerationID = 0;
    fPathRef->fBoundsIsDirty = true;
    SkDEBUGCODE(fPathRef->fEditorsAttached++;)
}

~Editor()

SkPathRef::Editor::~Editor ( )

inline

Definition at line 100 of file SkPathRef.h.

{ SkDEBUGCODE(fPathRef->fEditorsAttached--;) }

Member Function Documentation

atPoint() [1/2]

SkPoint * SkPathRef::Editor::atPoint ( int  i )

inline

Gets the ith point. Shortcut for this->points() + i

Definition at line 111 of file SkPathRef.h.

{ return fPathRef->getWritablePoints() + i; }

atPoint() [2/2]

const SkPoint * SkPathRef::Editor::atPoint ( int  i ) const

inline

Definition at line 112 of file SkPathRef.h.

{ return &fPathRef->fPoints[i]; }

growForRepeatedVerb()

SkPoint * SkPathRef::Editor::growForRepeatedVerb ( int  verb, int  numVbs, SkScalar **  weights = nullptr  )

inline

Allocates space for multiple instances of a particular verb and the requisite points & weights. The return pointer points at the first new point (indexed normally []). If 'verb' is kConic_Verb, 'weights' will return a pointer to the space for the conic weights (indexed normally).

Definition at line 131 of file SkPathRef.h.

                                                                   {
            return fPathRef->growForRepeatedVerb(verb, numVbs, weights);
        }

growForVerb()

SkPoint * SkPathRef::Editor::growForVerb ( int  verb, SkScalar  weight = 0  )

inline

Adds the verb and allocates space for the number of points indicated by the verb. The return value is a pointer to where the points for the verb should be written. 'weight' is only used if 'verb' is kConic_Verb

Definition at line 119 of file SkPathRef.h.

                                                              {
            SkDEBUGCODE(fPathRef->validate();)
            return fPathRef->growForVerb(verb, weight);
        }

growForVerbsInPath()

std::tuple< SkPoint *, SkScalar * > SkPathRef::Editor::growForVerbsInPath ( const SkPathRef &  path )

inline

Concatenates all verbs from 'path' onto the pathRef's verbs array. Increases the point count by the number of points in 'path', and the conic weight count by the number of conics in 'path'.

Returns pointers to the uninitialized points and conic weights data.

Definition at line 144 of file SkPathRef.h.

                                                                                {
            return fPathRef->growForVerbsInPath(path);
        }

pathRef()

SkPathRef * SkPathRef::Editor::pathRef ( )

inline

Gets the path ref that is wrapped in the Editor.

Definition at line 159 of file SkPathRef.h.

{ return fPathRef; }

points()

const SkPoint * SkPathRef::Editor::points ( ) const

inline

Definition at line 106 of file SkPathRef.h.

{ return fPathRef->points(); }

resetToSize()

void SkPathRef::Editor::resetToSize ( int  newVerbCnt, int  newPointCnt, int  newConicCount  )

inline

Resets the path ref to a new verb and point count. The new verbs and points are uninitialized.

Definition at line 152 of file SkPathRef.h.

                                                                             {
            fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount);
        }

setBounds()

void SkPathRef::Editor::setBounds ( const SkRect &  rect )

inline

Definition at line 173 of file SkPathRef.h.

{ fPathRef->setBounds(rect); }

setIsArc()

void SkPathRef::Editor::setIsArc ( const SkArc &  arc )

inline

Definition at line 169 of file SkPathRef.h.

                                        {
            fPathRef->setIsArc(arc);
        }

setIsOval()

void SkPathRef::Editor::setIsOval ( bool  isCCW, unsigned  start, bool  isClosed  )

inline

Definition at line 161 of file SkPathRef.h.

                                                                  {
            fPathRef->setIsOval(isCCW, start, isClosed);
        }

setIsRRect()

void SkPathRef::Editor::setIsRRect ( bool  isCCW, unsigned  start  )

inline

Definition at line 165 of file SkPathRef.h.

                                                    {
            fPathRef->setIsRRect(isCCW, start);
        }

writablePoints()

SkPoint * SkPathRef::Editor::writablePoints ( )

inline

Returns the array of points.

Definition at line 105 of file SkPathRef.h.

{ return fPathRef->getWritablePoints(); }

---

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

• third_party/skia/include/private/SkPathRef.h
• third_party/skia/src/core/SkPathRef.cpp