#include <SkPDFDevice.h>

Inheritance diagram for SkPDFDevice:

Public Member Functions
	SkPDFDevice (SkISize pageSize, SkPDFDocument *document, const SkMatrix &initialTransform=SkMatrix::I())

sk_sp< SkPDFDevice >	makeCongruentDevice ()

	~SkPDFDevice () override

void	drawPaint (const SkPaint &paint) override

void	drawPoints (SkCanvas::PointMode mode, size_t count, const SkPoint[], const SkPaint &paint) override

void	drawRect (const SkRect &r, const SkPaint &paint) override

void	drawOval (const SkRect &oval, const SkPaint &paint) override

void	drawRRect (const SkRRect &rr, const SkPaint &paint) override

void	drawPath (const SkPath &origpath, const SkPaint &paint, bool pathIsMutable) override

void	drawImageRect (const SkImage , const SkRect src, const SkRect &dst, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint) override

void	drawVertices (const SkVertices *, sk_sp< SkBlender >, const SkPaint &, bool) override

void	drawMesh (const SkMesh &, sk_sp< SkBlender >, const SkPaint &) override

void	drawAnnotation (const SkRect &, const char key[], SkData *value) override

void	drawDevice (SkDevice *, const SkSamplingOptions &, const SkPaint &) override

void	drawSpecial (SkSpecialImage *, const SkMatrix &, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint) override

sk_sp< SkSurface >	makeSurface (const SkImageInfo &, const SkSurfaceProps &) override

sk_sp< SkDevice >	createDevice (const CreateInfo &, const SkPaint *) override

void	drawSprite (const SkBitmap &bitmap, int x, int y, const SkPaint &paint)

std::unique_ptr< SkPDFDict >	makeResourceDict ()

std::unique_ptr< SkStreamAsset >	content ()

const SkMatrix &	initialTransform () const

Public Member Functions inherited from SkClipStackDevice
	SkClipStackDevice (const SkImageInfo &info, const SkSurfaceProps &props)

SkClipStack &	cs ()

const SkClipStack &	cs () const

void	pushClipStack () override

void	popClipStack () override

void	clipRect (const SkRect &rect, SkClipOp, bool aa) override

void	clipRRect (const SkRRect &rrect, SkClipOp, bool aa) override

void	clipPath (const SkPath &path, SkClipOp, bool aa) override

void	clipRegion (const SkRegion &deviceRgn, SkClipOp) override

void	replaceClip (const SkIRect &rect) override

bool	isClipAntiAliased () const override

bool	isClipWideOpen () const override

bool	isClipEmpty () const override

bool	isClipRect () const override

void	android_utils_clipAsRgn (SkRegion *) const override

SkIRect	devClipBounds () const override

Public Member Functions inherited from SkDevice
	SkDevice (const SkImageInfo &, const SkSurfaceProps &)

const SkImageInfo &	imageInfo () const

int	width () const

int	height () const

bool	isOpaque () const

SkIRect	bounds () const

SkISize	size () const

const SkSurfaceProps &	surfaceProps () const

SkScalerContextFlags	scalerContextFlags () const

virtual SkStrikeDeviceInfo	strikeDeviceInfo () const

bool	writePixels (const SkPixmap &src, int x, int y)

bool	readPixels (const SkPixmap &dst, int x, int y)

bool	accessPixels (SkPixmap *pmap)

bool	peekPixels (SkPixmap *)

const SkM44 &	localToDevice44 () const

const SkMatrix &	localToDevice () const

const SkM44 &	deviceToGlobal () const

const SkM44 &	globalToDevice () const

SkIPoint	getOrigin () const

bool	isPixelAlignedToGlobal () const

SkMatrix	getRelativeTransform (const SkDevice &) const

void	setLocalToDevice (const SkM44 &localToDevice)

void	setGlobalCTM (const SkM44 &ctm)

void	getGlobalBounds (SkIRect *bounds) const

SkIRect	getGlobalBounds () const

void	clipShader (sk_sp< SkShader > sh, SkClipOp op)

virtual bool	android_utils_clipWithStencil ()

virtual bool	useDrawCoverageMaskForMaskFilters () const

virtual bool	isNoPixelsDevice () const

virtual void *	getRasterHandle () const

virtual GrRecordingContext *	recordingContext () const

virtual skgpu::graphite::Recorder *	recorder () const

virtual skgpu::ganesh::Device *	asGaneshDevice ()

virtual skgpu::graphite::Device *	asGraphiteDevice ()

virtual void	setImmutable ()

void	drawGlyphRunList (SkCanvas *, const sktext::GlyphRunList &glyphRunList, const SkPaint &paint)

virtual sk_sp< sktext::gpu::Slug >	convertGlyphRunListToSlug (const sktext::GlyphRunList &glyphRunList, const SkPaint &paint)

virtual void	drawSlug (SkCanvas , const sktext::gpu::Slug slug, const SkPaint &paint)

virtual void	drawRegion (const SkRegion &r, const SkPaint &paint)

virtual void	drawArc (const SkRect &oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint &paint)

virtual void	drawDRRect (const SkRRect &outer, const SkRRect &inner, const SkPaint &)

virtual bool	shouldDrawAsTiledImageRect () const

virtual bool	drawAsTiledImageRect (SkCanvas , const SkImage , const SkRect *src, const SkRect &dst, const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint)

virtual void	drawImageLattice (const SkImage *, const SkCanvas::Lattice &, const SkRect &dst, SkFilterMode, const SkPaint &)

virtual void	drawShadow (const SkPath &, const SkDrawShadowRec &)

virtual void	drawPatch (const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], sk_sp< SkBlender >, const SkPaint &paint)

virtual void	drawAtlas (const SkRSXform[], const SkRect[], const SkColor[], int count, sk_sp< SkBlender >, const SkPaint &)

virtual void	drawEdgeAAQuad (const SkRect &rect, const SkPoint clip[4], SkCanvas::QuadAAFlags aaFlags, const SkColor4f &color, SkBlendMode mode)

virtual void	drawEdgeAAImageSet (const SkCanvas::ImageSetEntry[], int count, const SkPoint dstClips[], const SkMatrix preViewMatrices[], const SkSamplingOptions &, const SkPaint &, SkCanvas::SrcRectConstraint)

virtual void	drawDrawable (SkCanvas , SkDrawable , const SkMatrix *)

virtual sk_sp< SkSpecialImage >	snapSpecial (const SkIRect &subset, bool forceCopy=false)

virtual sk_sp< SkSpecialImage >	snapSpecialScaled (const SkIRect &subset, const SkISize &dstDims)

sk_sp< SkSpecialImage >	snapSpecial ()

virtual void	drawCoverageMask (const SkSpecialImage *, const SkMatrix &maskToDevice, const SkSamplingOptions &, const SkPaint &)

virtual bool	drawBlurredRRect (const SkRRect &, const SkPaint &, float deviceSigma)

void	drawFilteredImage (const skif::Mapping &mapping, SkSpecialImage src, SkColorType ct, const SkImageFilter , const SkSamplingOptions &, const SkPaint &)

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Protected Member Functions
sk_sp< SkSpecialImage >	makeSpecial (const SkBitmap &) override

sk_sp< SkSpecialImage >	makeSpecial (const SkImage *) override

Protected Member Functions inherited from SkDevice
void	setDeviceCoordinateSystem (const SkM44 &deviceToGlobal, const SkM44 &globalToDevice, const SkM44 &localToDevice, int bufferOriginX, int bufferOriginY)

void	setOrigin (const SkM44 &globalCTM, int x, int y)

bool	checkLocalToDeviceDirty ()

Private Member Functions
void	onDrawGlyphRunList (SkCanvas *, const sktext::GlyphRunList &, const SkPaint &paint) override

Friends
class	ScopedContentEntry

Detailed Description

An SkPDFDevice is the drawing context for a page or layer of PDF content.

Definition at line 50 of file SkPDFDevice.h.

Constructor & Destructor Documentation

◆ SkPDFDevice()

SkPDFDevice::SkPDFDevice	(	SkISize	pageSize,
		SkPDFDocument *	document,
		const SkMatrix &	initialTransform = `SkMatrix::I()`
	)

Parameters

pageSize	Page size in point units. 1 point == 127/360 mm == 1/72 inch
document	A non-null pointer back to the PDFDocument object. The document is responsible for de-duplicating across pages (via the SkPDFDocument) and for early serializing of large immutable objects, such as images (via SkPDFDocument::serialize()).
initialTransform	Transform to be applied to the entire page.

Definition at line 322 of file SkPDFDevice.cpp.

        : SkClipStackDevice(SkImageInfo::MakeUnknown(pageSize.width(), pageSize.height()),
                            SkSurfaceProps())
        , fInitialTransform(transform)
        , fNodeId(0)
        , fDocument(doc) {
    SkASSERT(!pageSize.isEmpty());
}

◆ ~SkPDFDevice()

SkPDFDevice::~SkPDFDevice ( )

overridedefault

Member Function Documentation

◆ content()

std::unique_ptr< SkStreamAsset > SkPDFDevice::content ( )

Returns a SkStream with the page contents.

Definition at line 1047 of file SkPDFDevice.cpp.

                                                  {
    if (fActiveStackState.fContentStream) {
        fActiveStackState.drainStack();
        fActiveStackState = SkPDFGraphicStackState();
    }
    if (fContent.bytesWritten() == 0) {
        return std::make_unique<SkMemoryStream>();
    }
    SkDynamicMemoryWStream buffer;
    if (fInitialTransform.getType() != SkMatrix::kIdentity_Mask) {
        SkPDFUtils::AppendTransform(fInitialTransform, &buffer);
    }
    if (fNeedsExtraSave) {
        buffer.writeText("q\n");
    }
    fContent.writeToAndReset(&buffer);
    if (fNeedsExtraSave) {
        buffer.writeText("Q\n");
    }
    fNeedsExtraSave = false;
    return std::unique_ptr<SkStreamAsset>(buffer.detachAsStream());
}

◆ createDevice()

sk_sp< SkDevice > SkPDFDevice::createDevice	(	const CreateInfo &	,
		const SkPaint *
	)

overridevirtual

Create a new device based on CreateInfo. If the paint is not null, then it represents a preview of how the new device will be composed with its creator device (this).

The subclass may be handed this device in drawDevice(), so it must always return a device that it knows how to draw, and that it knows how to identify if it is not of the same subclass (since drawDevice is passed a SkDevice*). If the subclass cannot fulfill that contract (e.g. PDF cannot support some settings on the paint) it should return NULL, and the caller may then decide to explicitly create a bitmapdevice, knowing that later it could not call drawDevice with it (but it could call drawSprite or drawBitmap).

Reimplemented from SkDevice.

Definition at line 224 of file SkPDFDevice.cpp.

                                                                                            {
    // PDF does not support image filters, so render them on CPU.
    // Note that this rendering is done at "screen" resolution (100dpi), not
    // printer resolution.
 
    // TODO: It may be possible to express some filters natively using PDF
    // to improve quality and file size (https://bug.skia.org/3043)
    if ((layerPaint && (layerPaint->getImageFilter() || layerPaint->getColorFilter()))
        || (cinfo.fInfo.colorSpace() && !cinfo.fInfo.colorSpace()->isSRGB())) {
        // need to return a raster device, which we will detect in drawDevice()
        return SkBitmapDevice::Create(cinfo.fInfo,
                                      SkSurfaceProps());
    }
    return sk_make_sp<SkPDFDevice>(cinfo.fInfo.dimensions(), fDocument);
}

◆ drawAnnotation()

void SkPDFDevice::drawAnnotation	(	const SkRect &	rect,
		const char	key[],
		SkData *	value
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 342 of file SkPDFDevice.cpp.

                                                                                    {
    if (!value || !fDocument->hasCurrentPage()) {
        return;
    }
    // Annotations are specified in absolute coordinates, so the page xform maps from device space
    // to the global space, and applies the document transform.
    SkMatrix pageXform = this->deviceToGlobal().asM33();
    pageXform.postConcat(fDocument->currentPageTransform());
    if (rect.isEmpty()) {
        if (!strcmp(key, SkPDFGetNodeIdKey())) {
            int nodeID;
            if (value->size() != sizeof(nodeID)) { return; }
            memcpy(&nodeID, value->data(), sizeof(nodeID));
            fNodeId = nodeID;
            return;
        }
        if (!strcmp(SkAnnotationKeys::Define_Named_Dest_Key(), key)) {
            SkPoint p = this->localToDevice().mapXY(rect.x(), rect.y());
            pageXform.mapPoints(&p, 1);
            auto pg = fDocument->currentPage();
            fDocument->fNamedDestinations.push_back(SkPDFNamedDestination{sk_ref_sp(value), p, pg});
        }
        return;
    }
    // Convert to path to handle non-90-degree rotations.
    SkPath path = SkPath::Rect(rect).makeTransform(this->localToDevice());
    SkPath clip;
    SkClipStack_AsPath(this->cs(), &clip);
    Op(clip, path, kIntersect_SkPathOp, &path);
    // PDF wants a rectangle only.
    SkRect transformedRect = pageXform.mapRect(path.getBounds());
    if (transformedRect.isEmpty()) {
        return;
    }
 
    SkPDFLink::Type linkType = SkPDFLink::Type::kNone;
    if (!strcmp(SkAnnotationKeys::URL_Key(), key)) {
        linkType = SkPDFLink::Type::kUrl;
    } else if (!strcmp(SkAnnotationKeys::Link_Named_Dest_Key(), key)) {
        linkType = SkPDFLink::Type::kNamedDestination;
    }
 
    if (linkType != SkPDFLink::Type::kNone) {
        std::unique_ptr<SkPDFLink> link = std::make_unique<SkPDFLink>(
            linkType, value, transformedRect, fNodeId);
        fDocument->fCurrentPageLinks.push_back(std::move(link));
    }
}

◆ drawDevice()

void SkPDFDevice::drawDevice	(	SkDevice *	device,
		const SkSamplingOptions &	sampling,
		const SkPaint &	paint
	)

overridevirtual

The SkDevice passed will be an SkDevice which was returned by a call to onCreateDevice on this device with kNeverTile_TileExpectation.

The default implementation calls snapSpecial() and drawSpecial() with the relative transform from the input device to this device. The provided SkPaint cannot have a mask filter or image filter, and any shader is ignored.

Reimplemented from SkDevice.

Definition at line 1719 of file SkPDFDevice.cpp.

                                                   {
    SkASSERT(!paint.getImageFilter());
    SkASSERT(!paint.getMaskFilter());
 
    // Check if the source device is really a bitmapdevice (because that's what we returned
    // from createDevice (an image filter would go through drawSpecial, but createDevice uses
    // a raster device to apply color filters, too).
    SkPixmap pmap;
    if (device->peekPixels(&pmap)) {
        this->SkClipStackDevice::drawDevice(device, sampling, paint);
        return;
    }
 
    // our onCreateCompatibleDevice() always creates SkPDFDevice subclasses.
    SkPDFDevice* pdfDevice = static_cast<SkPDFDevice*>(device);
 
    if (pdfDevice->isContentEmpty()) {
        return;
    }
 
    SkMatrix matrix = device->getRelativeTransform(*this);
    ScopedContentEntry content(this, &this->cs(), matrix, paint);
    if (!content) {
        return;
    }
    SkPath shape = SkPath::Rect(SkRect::Make(device->imageInfo().dimensions()));
    shape.transform(matrix);
    if (content.needShape()) {
        content.setShape(shape);
    }
    if (!content.needSource()) {
        return;
    }
    this->drawFormXObject(pdfDevice->makeFormXObjectFromDevice(), content.stream(), &shape);
}

◆ drawImageRect()

void SkPDFDevice::drawImageRect	(	const SkImage *	image,
		const SkRect *	src,
		const SkRect &	dst,
		const SkSamplingOptions &	sampling,
		const SkPaint &	paint,
		SkCanvas::SrcRectConstraint
	)

overridevirtual

Implements SkDevice.

Definition at line 643 of file SkPDFDevice.cpp.

                                                           {
    SkASSERT(image);
    this->internalDrawImageRect(SkKeyedImage(sk_ref_sp(const_cast<SkImage*>(image))),
                                src, dst, sampling, paint, this->localToDevice());
}

◆ drawMesh()

void SkPDFDevice::drawMesh	(	const SkMesh &	,
		sk_sp< SkBlender >	,
		const SkPaint &
	)

overridevirtual

Implements SkDevice.

Definition at line 997 of file SkPDFDevice.cpp.

                                                                          {
    if (this->hasEmptyClip()) {
        return;
    }
    // TODO: implement drawMesh
}

◆ drawOval()

void SkPDFDevice::drawOval	(	const SkRect &	oval,
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 497 of file SkPDFDevice.cpp.

                                                                   {
    this->internalDrawPath(this->cs(), this->localToDevice(), SkPath::Oval(oval), paint, true);
}

◆ drawPaint()

void SkPDFDevice::drawPaint ( const SkPaint & paint )

overridevirtual

These are called inside the per-device-layer loop for each draw call. When these are called, we have already applied any saveLayer operations, and are handling any looping from the paint.

Implements SkDevice.

Definition at line 391 of file SkPDFDevice.cpp.

                                                   {
    SkMatrix inverse;
    if (!this->localToDevice().invert(&inverse)) {
        return;
    }
    SkRect bbox = this->cs().bounds(this->bounds());
    inverse.mapRect(&bbox);
    bbox.roundOut(&bbox);
    if (this->hasEmptyClip()) {
        return;
    }
    SkPaint newPaint = srcPaint;
    newPaint.setStyle(SkPaint::kFill_Style);
    this->drawRect(bbox, newPaint);
}

◆ drawPath()

void SkPDFDevice::drawPath	(	const SkPath &	path,
		const SkPaint &	paint,
		bool	pathIsMutable
	)

overridevirtual

If pathIsMutable, then the implementation is allowed to cast path to a non-const pointer and modify it in place (as an optimization). Canvas may do this to implement helpers such as drawOval, by placing a temp path on the stack to hold the representation of the oval.

Implements SkDevice.

Definition at line 501 of file SkPDFDevice.cpp.

                                                                                       {
    this->internalDrawPath(this->cs(), this->localToDevice(), path, paint, pathIsMutable);
}

◆ drawPoints()

void SkPDFDevice::drawPoints	(	SkCanvas::PointMode	mode,
		size_t	count,
		const SkPoint	[],
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 407 of file SkPDFDevice.cpp.

                                                      {
    if (this->hasEmptyClip()) {
        return;
    }
    if (count == 0) {
        return;
    }
    SkTCopyOnFirstWrite<SkPaint> paint(clean_paint(srcPaint));
 
 
 
    if (SkCanvas::kPoints_PointMode != mode) {
        set_style(&paint, SkPaint::kStroke_Style);
    }
 
    // SkDraw::drawPoints converts to multiple calls to fDevice->drawPath.
    // We only use this when there's a path effect or perspective because of the overhead
    // of multiple calls to setUpContentEntry it causes.
    if (paint->getPathEffect() || this->localToDevice().hasPerspective()) {
        draw_points(mode, count, points, *paint, this->devClipBounds(), this);
        return;
    }
 
 
    if (mode == SkCanvas::kPoints_PointMode && paint->getStrokeCap() != SkPaint::kRound_Cap) {
        if (paint->getStrokeWidth()) {
            // PDF won't draw a single point with square/butt caps because the
            // orientation is ambiguous.  Draw a rectangle instead.
            set_style(&paint, SkPaint::kFill_Style);
            SkScalar strokeWidth = paint->getStrokeWidth();
            SkScalar halfStroke = SkScalarHalf(strokeWidth);
            for (size_t i = 0; i < count; i++) {
                SkRect r = SkRect::MakeXYWH(points[i].fX, points[i].fY, 0, 0);
                r.inset(-halfStroke, -halfStroke);
                this->drawRect(r, *paint);
            }
            return;
        } else {
            if (paint->getStrokeCap() != SkPaint::kRound_Cap) {
                paint.writable()->setStrokeCap(SkPaint::kRound_Cap);
            }
        }
    }
 
    ScopedContentEntry content(this, *paint);
    if (!content) {
        return;
    }
    SkDynamicMemoryWStream* contentStream = content.stream();
    switch (mode) {
        case SkCanvas::kPolygon_PointMode:
            SkPDFUtils::MoveTo(points[0].fX, points[0].fY, contentStream);
            for (size_t i = 1; i < count; i++) {
                SkPDFUtils::AppendLine(points[i].fX, points[i].fY, contentStream);
            }
            SkPDFUtils::StrokePath(contentStream);
            break;
        case SkCanvas::kLines_PointMode:
            for (size_t i = 0; i < count/2; i++) {
                SkPDFUtils::MoveTo(points[i * 2].fX, points[i * 2].fY, contentStream);
                SkPDFUtils::AppendLine(points[i * 2 + 1].fX, points[i * 2 + 1].fY, contentStream);
                SkPDFUtils::StrokePath(contentStream);
            }
            break;
        case SkCanvas::kPoints_PointMode:
            SkASSERT(paint->getStrokeCap() == SkPaint::kRound_Cap);
            for (size_t i = 0; i < count; i++) {
                SkPDFUtils::MoveTo(points[i].fX, points[i].fY, contentStream);
                SkPDFUtils::ClosePath(contentStream);
                SkPDFUtils::StrokePath(contentStream);
            }
            break;
        default:
            SkASSERT(false);
    }
}

◆ drawRect()

void SkPDFDevice::drawRect	(	const SkRect &	r,
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 487 of file SkPDFDevice.cpp.

                                                                   {
    SkRect r = rect;
    r.sort();
    this->internalDrawPath(this->cs(), this->localToDevice(), SkPath::Rect(r), paint, true);
}

◆ drawRRect()

void SkPDFDevice::drawRRect	(	const SkRRect &	rr,
		const SkPaint &	paint
	)

overridevirtual

Implements SkDevice.

Definition at line 493 of file SkPDFDevice.cpp.

                                                                      {
    this->internalDrawPath(this->cs(), this->localToDevice(), SkPath::RRect(rrect), paint, true);
}

◆ drawSpecial()

void SkPDFDevice::drawSpecial	(	SkSpecialImage *	,
		const SkMatrix &	localToDevice,
		const SkSamplingOptions &	,
		const SkPaint &	,
		SkCanvas::SrcRectConstraint	constraint
	)

overridevirtual

Draw the special image's subset to this device, subject to the given matrix transform instead of the device's current local to device matrix.

If 'constraint' is kFast, the rendered geometry of the image still reflects the extent of the SkSpecialImage's subset, but it's assumed that the pixel data beyond the subset is valid (e.g. SkSpecialImage::makeSubset() was called to crop a larger image).

Reimplemented from SkDevice.

Definition at line 1756 of file SkPDFDevice.cpp.

                                                         {
    if (this->hasEmptyClip()) {
        return;
    }
    SkASSERT(!srcImg->isGaneshBacked() && !srcImg->isGraphiteBacked());
    SkASSERT(!paint.getMaskFilter() && !paint.getImageFilter());
 
    SkBitmap resultBM;
    if (SkSpecialImages::AsBitmap(srcImg, &resultBM)) {
        auto r = SkRect::MakeWH(resultBM.width(), resultBM.height());
        this->internalDrawImageRect(SkKeyedImage(resultBM), nullptr, r, sampling, paint,
                                    localToDevice);
    }
}

◆ drawSprite()

void SkPDFDevice::drawSprite	(	const SkBitmap &	bitmap,
		int	x,
		int	y,
		const SkPaint &	paint
	)

Definition at line 654 of file SkPDFDevice.cpp.

                                                                                   {
    SkASSERT(!bm.drawsNothing());
    auto r = SkRect::MakeXYWH(x, y, bm.width(), bm.height());
    this->internalDrawImageRect(SkKeyedImage(bm), nullptr, r, SkSamplingOptions(), paint,
                                SkMatrix::I());
}

◆ drawVertices()

void SkPDFDevice::drawVertices	(	const SkVertices *	,
		sk_sp< SkBlender >	,
		const SkPaint &	,
		bool	skipColorXform
	)

overridevirtual

If skipColorXform is true, then the implementation should assume that the provided vertex colors are already in the destination color space.

Implements SkDevice.

Definition at line 990 of file SkPDFDevice.cpp.

                                                                                        {
    if (this->hasEmptyClip()) {
        return;
    }
    // TODO: implement drawVertices
}

◆ initialTransform()

const SkMatrix & SkPDFDevice::initialTransform ( ) const

inline

Definition at line 115 of file SkPDFDevice.h.

115{ return fInitialTransform; }

◆ makeCongruentDevice()

sk_sp< SkPDFDevice > SkPDFDevice::makeCongruentDevice ( )

inline

Definition at line 65 of file SkPDFDevice.h.

                                             {
        return sk_make_sp<SkPDFDevice>(this->size(), fDocument);
    }

◆ makeResourceDict()

std::unique_ptr< SkPDFDict > SkPDFDevice::makeResourceDict ( )

Create the resource dictionary for this device. Destructive.

Definition at line 1040 of file SkPDFDevice.cpp.

                                                       {
    return SkPDFMakeResourceDict(sort(fGraphicStateResources),
                                 sort(fShaderResources),
                                 sort(fXObjectResources),
                                 sort(fFontResources));
}

◆ makeSpecial() [1/2]

sk_sp< SkSpecialImage > SkPDFDevice::makeSpecial ( const SkBitmap & bitmap )

overrideprotectedvirtual

Reimplemented from SkDevice.

Definition at line 1773 of file SkPDFDevice.cpp.

                                                                     {
    return SkSpecialImages::MakeFromRaster(bitmap.bounds(), bitmap, this->surfaceProps());
}

◆ makeSpecial() [2/2]

sk_sp< SkSpecialImage > SkPDFDevice::makeSpecial ( const SkImage * image )

overrideprotectedvirtual

Reimplemented from SkDevice.

Definition at line 1777 of file SkPDFDevice.cpp.

                                                                   {
    return SkSpecialImages::MakeFromRaster(
            image->bounds(), image->makeNonTextureImage(), this->surfaceProps());
}

◆ makeSurface()

sk_sp< SkSurface > SkPDFDevice::makeSurface	(	const SkImageInfo &	info,
		const SkSurfaceProps &	props
	)

overridevirtual

Reimplemented from SkDevice.

Definition at line 1025 of file SkPDFDevice.cpp.

                                                                                              {
    return SkSurfaces::Raster(info, &props);
}

◆ onDrawGlyphRunList()

void SkPDFDevice::onDrawGlyphRunList	(	SkCanvas *	,
		const sktext::GlyphRunList &	glyphRunList,
		const SkPaint &	paint
	)

overrideprivatevirtual

Implements SkDevice.

Definition at line 981 of file SkPDFDevice.cpp.

                                                           {
    SkASSERT(!glyphRunList.hasRSXForm());
    for (const sktext::GlyphRun& glyphRun : glyphRunList) {
        this->internalDrawGlyphRun(glyphRun, glyphRunList.origin(), paint);
    }
}

Friends And Related Symbol Documentation

◆ ScopedContentEntry

friend class ScopedContentEntry

friend

Definition at line 124 of file SkPDFDevice.h.

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

third_party/skia/src/pdf/SkPDFDevice.h
third_party/skia/src/pdf/SkPDFDevice.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ SkPDFDevice()

◆ ~SkPDFDevice()

Member Function Documentation

◆ content()

◆ createDevice()

◆ drawAnnotation()

◆ drawDevice()

◆ drawImageRect()

◆ drawMesh()

◆ drawOval()

◆ drawPaint()

◆ drawPath()

◆ drawPoints()

◆ drawRect()

◆ drawRRect()

◆ drawSpecial()

◆ drawSprite()

◆ drawVertices()

◆ initialTransform()

◆ makeCongruentDevice()

◆ makeResourceDict()

◆ makeSpecial() [1/2]

◆ makeSpecial() [2/2]

◆ makeSurface()

◆ onDrawGlyphRunList()

Friends And Related Symbol Documentation

◆ ScopedContentEntry