SkRasterHandleAllocator Class Reference

#include <SkRasterHandleAllocator.h>

Inheritance diagram for SkRasterHandleAllocator:

Classes
struct	Rec

Public Types
typedef void *	Handle

Public Member Functions
virtual	~SkRasterHandleAllocator ()=default
virtual bool	allocHandle (const SkImageInfo &, Rec *)=0
virtual void	updateHandle (Handle, const SkMatrix &, const SkIRect &)=0

Static Public Member Functions
static std::unique_ptr< SkCanvas >	MakeCanvas (std::unique_ptr< SkRasterHandleAllocator >, const SkImageInfo &, const Rec *rec=nullptr, const SkSurfaceProps *props=nullptr)

Protected Member Functions
	SkRasterHandleAllocator ()=default
	SkRasterHandleAllocator (const SkRasterHandleAllocator &)=delete
SkRasterHandleAllocator &	operator= (const SkRasterHandleAllocator &)=delete

Friends
class	SkBitmapDevice

Detailed Description

If a client wants to control the allocation of raster layers in a canvas, it should subclass SkRasterHandleAllocator. This allocator performs two tasks:

1. controls how the memory for the pixels is allocated
2. associates a "handle" to a private object that can track the matrix/clip of the SkCanvas

This example allocates a canvas, and defers to the allocator to create the base layer.

std::unique_ptr<SkCanvas> canvas = SkRasterHandleAllocator::MakeCanvas(
        SkImageInfo::Make(...),
        std::make_unique<MySubclassRasterHandleAllocator>(...),
        nullptr);

If you have already allocated the base layer (and its handle, release-proc etc.) then you can pass those in using the last parameter to MakeCanvas().

Regardless of how the base layer is allocated, each time canvas->saveLayer() is called, your allocator's allocHandle() will be called.

Definition at line 37 of file SkRasterHandleAllocator.h.

Member Typedef Documentation

Handle

typedef void* SkRasterHandleAllocator::Handle

Definition at line 42 of file SkRasterHandleAllocator.h.

Constructor & Destructor Documentation

~SkRasterHandleAllocator()

virtual SkRasterHandleAllocator::~SkRasterHandleAllocator ( )

virtualdefault

SkRasterHandleAllocator() [1/2]

SkRasterHandleAllocator::SkRasterHandleAllocator ( )

protecteddefault

SkRasterHandleAllocator() [2/2]

SkRasterHandleAllocator::SkRasterHandleAllocator ( const SkRasterHandleAllocator &  )

protecteddelete

Member Function Documentation

allocHandle()

virtual bool SkRasterHandleAllocator::allocHandle ( const SkImageInfo &  , Rec *    )

pure virtual

Given a requested info, allocate the corresponding pixels/rowbytes, and whatever handle is desired to give clients access to those pixels. The rec also contains a proc and context which will be called when this allocation goes out of scope.

e.g. when canvas->saveLayer() is called, the allocator will be called to allocate the pixels for the layer. When canvas->restore() is called, the fReleaseProc will be called.

Implemented in SkiaAllocator.

MakeCanvas()

std::unique_ptr< SkCanvas > SkRasterHandleAllocator::MakeCanvas ( std::unique_ptr< SkRasterHandleAllocator >  alloc, const SkImageInfo &  info, const Rec *  rec = nullptr, const SkSurfaceProps *  props = nullptr  )

static

This creates a canvas which will use the allocator to manage pixel allocations, including all calls to saveLayer().

If rec is non-null, then it will be used as the base-layer of pixels/handle. If rec is null, then the allocator will be called for the base-layer as well.

Definition at line 2871 of file SkCanvas.cpp.

                                                                 {
    if (!alloc || !SkSurfaceValidateRasterInfo(info, rec ? rec->fRowBytes : kIgnoreRowBytesValue)) {
        return nullptr;
    }
 
    SkBitmap bm;
    Handle hndl;
 
    if (rec) {
        hndl = install(&bm, info, *rec) ? rec->fHandle : nullptr;
    } else {
        hndl = alloc->allocBitmap(info, &bm);
    }
    return hndl ? std::unique_ptr<SkCanvas>(new SkCanvas(bm, std::move(alloc), hndl, props))
                : nullptr;
}

operator=()

SkRasterHandleAllocator & SkRasterHandleAllocator::operator= ( const SkRasterHandleAllocator &  )

protecteddelete

updateHandle()

virtual void SkRasterHandleAllocator::updateHandle ( Handle  , const SkMatrix &  , const SkIRect &    )

pure virtual

Clients access the handle for a given layer by calling SkCanvas::accessTopRasterHandle(). To allow the handle to reflect the current matrix/clip in the canvs, updateHandle() is is called. The subclass is responsible to update the handle as it sees fit.

Implemented in SkiaAllocator.

Friends And Related Function Documentation

SkBitmapDevice

friend class SkBitmapDevice

friend

Definition at line 89 of file SkRasterHandleAllocator.h.

---

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

• third_party/skia/include/core/SkRasterHandleAllocator.h
• third_party/skia/src/core/SkCanvas.cpp