#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

virtual SkIRect	devClipBounds () const =0

virtual void	pushClipStack ()=0

virtual void	popClipStack ()=0

virtual void	clipRect (const SkRect &rect, SkClipOp op, bool aa)=0

virtual void	clipRRect (const SkRRect &rrect, SkClipOp op, bool aa)=0

virtual void	clipPath (const SkPath &path, SkClipOp op, bool aa)=0

virtual void	clipRegion (const SkRegion &region, SkClipOp op)=0

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

virtual void	replaceClip (const SkIRect &rect)=0

virtual bool	isClipAntiAliased () const =0

virtual bool	isClipEmpty () const =0

virtual bool	isClipRect () const =0

virtual bool	isClipWideOpen () const =0

virtual void	android_utils_clipAsRgn (SkRegion *) const =0

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 ()

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

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

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	drawPaint (const SkPaint &paint)=0

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

virtual void	drawRect (const SkRect &r, const SkPaint &paint)=0

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

virtual void	drawOval (const SkRect &oval, const SkPaint &paint)=0

virtual void	drawArc (const SkArc &arc, const SkPaint &paint)

virtual void	drawRRect (const SkRRect &rr, const SkPaint &paint)=0

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

virtual void	drawPath (const SkPath &path, const SkPaint &paint, bool pathIsMutable=false)=0

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

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	drawVertices (const SkVertices *, sk_sp< SkBlender >, const SkPaint &, bool skipColorXform=false)=0

virtual void	drawMesh (const SkMesh &mesh, sk_sp< SkBlender >, const SkPaint &)=0

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	drawAnnotation (const SkRect &, const char[], SkData *)

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	drawDevice (SkDevice *, const SkSamplingOptions &, const SkPaint &)

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

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
virtual sk_sp< SkSpecialImage >	makeSpecial (const SkBitmap &)

virtual sk_sp< SkSpecialImage >	makeSpecial (const SkImage *)

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 ()

Friends
class	ScopedContentEntry

Detailed Description

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

Definition at line 59 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 354 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 1079 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 256 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 374 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 1751 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 675 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 1029 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 529 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 423 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 533 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 439 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 519 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 525 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 1788 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 686 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 1022 of file SkPDFDevice.cpp.

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

◆ initialTransform()

const SkMatrix & SkPDFDevice::initialTransform ( ) const

inline

Definition at line 124 of file SkPDFDevice.h.

124{ return fInitialTransform; }

◆ makeCongruentDevice()

sk_sp< SkPDFDevice > SkPDFDevice::makeCongruentDevice ( )

inline

Definition at line 74 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 1072 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 1805 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 1809 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 1057 of file SkPDFDevice.cpp.

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

Friends And Related Function Documentation

◆ ScopedContentEntry

friend class ScopedContentEntry

friend

Definition at line 133 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

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()

Friends And Related Function Documentation

◆ ScopedContentEntry