SkPDFUtils Namespace Reference

Functions
const char *	BlendModeName (SkBlendMode)
std::unique_ptr< SkPDFArray >	RectToArray (const SkRect &rect)
std::unique_ptr< SkPDFArray >	MatrixToArray (const SkMatrix &matrix)
void	MoveTo (SkScalar x, SkScalar y, SkWStream *content)
void	AppendLine (SkScalar x, SkScalar y, SkWStream *content)
void	AppendRectangle (const SkRect &rect, SkWStream *content)
void	EmitPath (const SkPath &path, SkPaint::Style paintStyle, bool doConsumeDegerates, SkWStream *content, SkScalar tolerance=0.25f)
void	EmitPath (const SkPath &path, SkPaint::Style paintStyle, SkWStream *content, SkScalar tolerance=0.25f)
void	ClosePath (SkWStream *content)
void	PaintPath (SkPaint::Style style, SkPathFillType fill, SkWStream *content)
void	StrokePath (SkWStream *content)
void	ApplyGraphicState (int objectIndex, SkWStream *content)
void	ApplyPattern (int objectIndex, SkWStream *content)
size_t	ColorToDecimal (uint8_t value, char result[5])
size_t	ColorToDecimalF (float value, char result[kFloatColorDecimalCount+2])
void	AppendColorComponent (uint8_t value, SkWStream *wStream)
void	AppendColorComponentF (float value, SkWStream *wStream)
void	AppendScalar (SkScalar value, SkWStream *stream)
void	WriteUInt16BE (SkWStream *wStream, uint16_t value)
void	WriteUInt8 (SkWStream *wStream, uint8_t value)
void	WriteUTF16beHex (SkWStream *wStream, SkUnichar utf32)
SkMatrix	GetShaderLocalMatrix (const SkShader *shader)
bool	InverseTransformBBox (const SkMatrix &matrix, SkRect *bbox)
void	PopulateTilingPatternDict (SkPDFDict *pattern, SkRect &bbox, std::unique_ptr< SkPDFDict > resources, const SkMatrix &matrix)
bool	ToBitmap (const SkImage *img, SkBitmap *dst)
void	AppendTransform (const SkMatrix &, SkWStream *)
void	GetDateTime (SkPDF::DateTime *)

Variables
static constexpr unsigned	kFloatColorDecimalCount = 4

Function Documentation

AppendColorComponent()

void SkPDFUtils::AppendColorComponent ( uint8_t  value, SkWStream *  wStream  )

inline

Definition at line 75 of file SkPDFUtils.h.

                                                                    {
    char buffer[5];
    size_t len = SkPDFUtils::ColorToDecimal(value, buffer);
    wStream->write(buffer, len);
}

AppendColorComponentF()

void SkPDFUtils::AppendColorComponentF ( float  value, SkWStream *  wStream  )

inline

Definition at line 80 of file SkPDFUtils.h.

                                                                   {
    char buffer[kFloatColorDecimalCount + 2];
    size_t len = SkPDFUtils::ColorToDecimalF(value, buffer);
    wStream->write(buffer, len);
}

AppendLine()

void SkPDFUtils::AppendLine	(	SkScalar	x,
		SkScalar	y,
		SkWStream *	content
	)

Definition at line 75 of file SkPDFUtils.cpp.

                                                                      {
    SkPDFUtils::AppendScalar(x, content);
    content->writeText(" ");
    SkPDFUtils::AppendScalar(y, content);
    content->writeText(" l\n");
}

AppendRectangle()

void SkPDFUtils::AppendRectangle	(	const SkRect &	rect,
		SkWStream *	content
	)

Definition at line 111 of file SkPDFUtils.cpp.

                                                                       {
    // Skia has 0,0 at top left, pdf at bottom left.  Do the right thing.
    SkScalar bottom = std::min(rect.fBottom, rect.fTop);
 
    SkPDFUtils::AppendScalar(rect.fLeft, content);
    content->writeText(" ");
    SkPDFUtils::AppendScalar(bottom, content);
    content->writeText(" ");
    SkPDFUtils::AppendScalar(rect.width(), content);
    content->writeText(" ");
    SkPDFUtils::AppendScalar(rect.height(), content);
    content->writeText(" re\n");
}

AppendScalar()

void SkPDFUtils::AppendScalar ( SkScalar  value, SkWStream *  stream  )

inline

Definition at line 86 of file SkPDFUtils.h.

                                                            {
    char result[kMaximumSkFloatToDecimalLength];
    size_t len = SkFloatToDecimal(value, result);
    SkASSERT(len < kMaximumSkFloatToDecimalLength);
    stream->write(result, len);
}

AppendTransform()

void SkPDFUtils::AppendTransform	(	const SkMatrix &	matrix,
		SkWStream *	content
	)

Definition at line 392 of file SkPDFUtils.cpp.

                                                                           {
    SkScalar values[6];
    if (!matrix.asAffine(values)) {
        SkMatrix::SetAffineIdentity(values);
    }
    for (SkScalar v : values) {
        SkPDFUtils::AppendScalar(v, content);
        content->writeText(" ");
    }
    content->writeText("cm\n");
}

ApplyGraphicState()

void SkPDFUtils::ApplyGraphicState	(	int	objectIndex,
		SkWStream *	content
	)

Definition at line 247 of file SkPDFUtils.cpp.

                                                                      {
    SkPDFWriteResourceName(content, SkPDFResourceType::kExtGState, objectIndex);
    content->writeText(" gs\n");
}

ApplyPattern()

void SkPDFUtils::ApplyPattern	(	int	objectIndex,
		SkWStream *	content
	)

Definition at line 252 of file SkPDFUtils.cpp.

                                                                 {
    // Select Pattern color space (CS, cs) and set pattern object as current
    // color (SCN, scn)
    content->writeText("/Pattern CS/Pattern cs");
    SkPDFWriteResourceName(content, SkPDFResourceType::kPattern, objectIndex);
    content->writeText(" SCN");
    SkPDFWriteResourceName(content, SkPDFResourceType::kPattern, objectIndex);
    content->writeText(" scn\n");
}

BlendModeName()

const char * SkPDFUtils::BlendModeName

(

SkBlendMode

mode

)

Definition at line 30 of file SkPDFUtils.cpp.

                                                      {
    // PDF32000.book section 11.3.5 "Blend Mode"
    switch (mode) {
        case SkBlendMode::kSrcOver:     return "Normal";
        case SkBlendMode::kXor:         return "Normal";  // (unsupported mode)
        case SkBlendMode::kPlus:        return "Normal";  // (unsupported mode)
        case SkBlendMode::kScreen:      return "Screen";
        case SkBlendMode::kOverlay:     return "Overlay";
        case SkBlendMode::kDarken:      return "Darken";
        case SkBlendMode::kLighten:     return "Lighten";
        case SkBlendMode::kColorDodge:  return "ColorDodge";
        case SkBlendMode::kColorBurn:   return "ColorBurn";
        case SkBlendMode::kHardLight:   return "HardLight";
        case SkBlendMode::kSoftLight:   return "SoftLight";
        case SkBlendMode::kDifference:  return "Difference";
        case SkBlendMode::kExclusion:   return "Exclusion";
        case SkBlendMode::kMultiply:    return "Multiply";
        case SkBlendMode::kHue:         return "Hue";
        case SkBlendMode::kSaturation:  return "Saturation";
        case SkBlendMode::kColor:       return "Color";
        case SkBlendMode::kLuminosity:  return "Luminosity";
        // Other blendmodes are handled in SkPDFDevice::setUpContentEntry.
        default:                        return nullptr;
    }
}

ClosePath()

void SkPDFUtils::ClosePath

(

SkWStream *

content

)

Definition at line 220 of file SkPDFUtils.cpp.

                                             {
    content->writeText("h\n");
}

ColorToDecimal()

size_t SkPDFUtils::ColorToDecimal	(	uint8_t	value,
		char	result[5]
	)

Definition at line 300 of file SkPDFUtils.cpp.

                                                               {
    if (value == 255 || value == 0) {
        result[0] = value ? '1' : '0';
        result[1] = '\0';
        return 1;
    }
    // int x = 0.5 + (1000.0 / 255.0) * value;
    int x = SkFixedRoundToInt((SK_Fixed1 * 1000 / 255) * value);
    return print_permil_as_decimal(x, result, 3);
}

ColorToDecimalF()

size_t SkPDFUtils::ColorToDecimalF	(	float	value,
		char	result[kFloatColorDecimalCount+2]
	)

Definition at line 289 of file SkPDFUtils.cpp.

                                                                                        {
    static constexpr int kFactor = int_pow(10, kFloatColorDecimalCount);
    int x = sk_float_round2int(value * kFactor);
    if (x >= kFactor || x <= 0) {  // clamp to 0-1
        result[0] = x > 0 ? '1' : '0';
        result[1] = '\0';
        return 1;
    }
    return print_permil_as_decimal(x, result, kFloatColorDecimalCount);
}

EmitPath() [1/2]

void SkPDFUtils::EmitPath	(	const SkPath &	path,
		SkPaint::Style	paintStyle,
		bool	doConsumeDegerates,
		SkWStream *	content,
		SkScalar	tolerance = 0.25f
	)

Definition at line 125 of file SkPDFUtils.cpp.

                                              {
    if (path.isEmpty() && SkPaint::kFill_Style == paintStyle) {
        SkPDFUtils::AppendRectangle({0, 0, 0, 0}, content);
        return;
    }
    // Filling a path with no area results in a drawing in PDF renderers but
    // Chrome expects to be able to draw some such entities with no visible
    // result, so we detect those cases and discard the drawing for them.
    // Specifically: moveTo(X), lineTo(Y) and moveTo(X), lineTo(X), lineTo(Y).
 
    SkRect rect;
    bool isClosed; // Both closure and direction need to be checked.
    SkPathDirection direction;
    if (path.isRect(&rect, &isClosed, &direction) &&
        isClosed &&
        (SkPathDirection::kCW == direction ||
         SkPathFillType::kEvenOdd == path.getFillType()))
    {
        SkPDFUtils::AppendRectangle(rect, content);
        return;
    }
 
    enum SkipFillState {
        kEmpty_SkipFillState,
        kSingleLine_SkipFillState,
        kNonSingleLine_SkipFillState,
    };
    SkipFillState fillState = kEmpty_SkipFillState;
    //if (paintStyle != SkPaint::kFill_Style) {
    //    fillState = kNonSingleLine_SkipFillState;
    //}
    SkPoint lastMovePt = SkPoint::Make(0,0);
    SkDynamicMemoryWStream currentSegment;
    SkPoint args[4];
    SkPath::Iter iter(path, false);
    for (SkPath::Verb verb = iter.next(args);
         verb != SkPath::kDone_Verb;
         verb = iter.next(args)) {
        // args gets all the points, even the implicit first point.
        switch (verb) {
            case SkPath::kMove_Verb:
                MoveTo(args[0].fX, args[0].fY, &currentSegment);
                lastMovePt = args[0];
                fillState = kEmpty_SkipFillState;
                break;
            case SkPath::kLine_Verb:
                if (!doConsumeDegerates || !SkPathPriv::AllPointsEq(args, 2)) {
                    AppendLine(args[1].fX, args[1].fY, &currentSegment);
                    if ((fillState == kEmpty_SkipFillState) && (args[0] != lastMovePt)) {
                        fillState = kSingleLine_SkipFillState;
                        break;
                    }
                    fillState = kNonSingleLine_SkipFillState;
                }
                break;
            case SkPath::kQuad_Verb:
                if (!doConsumeDegerates || !SkPathPriv::AllPointsEq(args, 3)) {
                    append_quad(args, &currentSegment);
                    fillState = kNonSingleLine_SkipFillState;
                }
                break;
            case SkPath::kConic_Verb:
                if (!doConsumeDegerates || !SkPathPriv::AllPointsEq(args, 3)) {
                    SkAutoConicToQuads converter;
                    const SkPoint* quads = converter.computeQuads(args, iter.conicWeight(), tolerance);
                    for (int i = 0; i < converter.countQuads(); ++i) {
                        append_quad(&quads[i * 2], &currentSegment);
                    }
                    fillState = kNonSingleLine_SkipFillState;
                }
                break;
            case SkPath::kCubic_Verb:
                if (!doConsumeDegerates || !SkPathPriv::AllPointsEq(args, 4)) {
                    append_cubic(args[1].fX, args[1].fY, args[2].fX, args[2].fY,
                                 args[3].fX, args[3].fY, &currentSegment);
                    fillState = kNonSingleLine_SkipFillState;
                }
                break;
            case SkPath::kClose_Verb:
                ClosePath(&currentSegment);
                currentSegment.writeToStream(content);
                currentSegment.reset();
                break;
            default:
                SkASSERT(false);
                break;
        }
    }
    if (currentSegment.bytesWritten() > 0) {
        currentSegment.writeToStream(content);
    }
}

EmitPath() [2/2]

void SkPDFUtils::EmitPath ( const SkPath &  path, SkPaint::Style  paintStyle, SkWStream *  content, SkScalar  tolerance = 0.25f  )

inline

Definition at line 59 of file SkPDFUtils.h.

                                                                     {
    SkPDFUtils::EmitPath(path, paintStyle, true, content, tolerance);
}

GetDateTime()

void SkPDFUtils::GetDateTime

(

SkPDF::DateTime *

dt

)

Definition at line 424 of file SkPDFUtils.cpp.

                                              {
    if (dt) {
        time_t m_time;
        time(&m_time);
        struct tm tstruct;
        gmtime_r(&m_time, &tstruct);
        dt->fTimeZoneMinutes = 0;
        dt->fYear       = tstruct.tm_year + 1900;
        dt->fMonth      = SkToU8(tstruct.tm_mon + 1);
        dt->fDayOfWeek  = SkToU8(tstruct.tm_wday);
        dt->fDay        = SkToU8(tstruct.tm_mday);
        dt->fHour       = SkToU8(tstruct.tm_hour);
        dt->fMinute     = SkToU8(tstruct.tm_min);
        dt->fSecond     = SkToU8(tstruct.tm_sec);
    }
}

GetShaderLocalMatrix()

SkMatrix SkPDFUtils::GetShaderLocalMatrix ( const SkShader *  shader )

inline

Definition at line 117 of file SkPDFUtils.h.

                                                             {
    SkMatrix localMatrix;
    if (sk_sp<SkShader> s = as_SB(shader)->makeAsALocalMatrixShader(&localMatrix)) {
        return localMatrix;
    }
    return SkMatrix::I();
}

InverseTransformBBox()

bool SkPDFUtils::InverseTransformBBox	(	const SkMatrix &	matrix,
		SkRect *	bbox
	)

Definition at line 311 of file SkPDFUtils.cpp.

                                                                          {
    SkMatrix inverse;
    if (!matrix.invert(&inverse)) {
        return false;
    }
    inverse.mapRect(bbox);
    return true;
}

MatrixToArray()

std::unique_ptr< SkPDFArray > SkPDFUtils::MatrixToArray

(

const SkMatrix &

matrix

)

Definition at line 60 of file SkPDFUtils.cpp.

                                                                          {
    SkScalar a[6];
    if (!matrix.asAffine(a)) {
        SkMatrix::SetAffineIdentity(a);
    }
    return SkPDFMakeArray(a[0], a[1], a[2], a[3], a[4], a[5]);
}

MoveTo()

void SkPDFUtils::MoveTo	(	SkScalar	x,
		SkScalar	y,
		SkWStream *	content
	)

Definition at line 68 of file SkPDFUtils.cpp.

                                                                  {
    SkPDFUtils::AppendScalar(x, content);
    content->writeText(" ");
    SkPDFUtils::AppendScalar(y, content);
    content->writeText(" m\n");
}

PaintPath()

void SkPDFUtils::PaintPath	(	SkPaint::Style	style,
		SkPathFillType	fill,
		SkWStream *	content
	)

Definition at line 224 of file SkPDFUtils.cpp.

                                                                                      {
    if (style == SkPaint::kFill_Style) {
        content->writeText("f");
    } else if (style == SkPaint::kStrokeAndFill_Style) {
        content->writeText("B");
    } else if (style == SkPaint::kStroke_Style) {
        content->writeText("S");
    }
 
    if (style != SkPaint::kStroke_Style) {
        NOT_IMPLEMENTED(fill == SkPathFillType::kInverseEvenOdd, false);
        NOT_IMPLEMENTED(fill == SkPathFillType::kInverseWinding, false);
        if (fill == SkPathFillType::kEvenOdd) {
            content->writeText("*");
        }
    }
    content->writeText("\n");
}

PopulateTilingPatternDict()

void SkPDFUtils::PopulateTilingPatternDict	(	SkPDFDict *	pattern,
		SkRect &	bbox,
		std::unique_ptr< SkPDFDict >	resources,
		const SkMatrix &	matrix
	)

Definition at line 320 of file SkPDFUtils.cpp.

                                                                   {
    const int kTiling_PatternType = 1;
    const int kColoredTilingPattern_PaintType = 1;
    const int kConstantSpacing_TilingType = 1;
 
    pattern->insertName("Type", "Pattern");
    pattern->insertInt("PatternType", kTiling_PatternType);
    pattern->insertInt("PaintType", kColoredTilingPattern_PaintType);
    pattern->insertInt("TilingType", kConstantSpacing_TilingType);
    pattern->insertObject("BBox", SkPDFUtils::RectToArray(bbox));
    pattern->insertScalar("XStep", bbox.width());
    pattern->insertScalar("YStep", bbox.height());
    pattern->insertObject("Resources", std::move(resources));
    if (!matrix.isIdentity()) {
        pattern->insertObject("Matrix", SkPDFUtils::MatrixToArray(matrix));
    }
}

RectToArray()

std::unique_ptr< SkPDFArray > SkPDFUtils::RectToArray

(

const SkRect &

rect

)

Definition at line 56 of file SkPDFUtils.cpp.

                                                                 {
    return SkPDFMakeArray(r.left(), r.top(), r.right(), r.bottom());
}

StrokePath()

void SkPDFUtils::StrokePath

(

SkWStream *

content

)

Definition at line 243 of file SkPDFUtils.cpp.

                                              {
    SkPDFUtils::PaintPath(SkPaint::kStroke_Style, SkPathFillType::kWinding, content);
}

ToBitmap()

bool SkPDFUtils::ToBitmap	(	const SkImage *	img,
		SkBitmap *	dst
	)

Definition at line 341 of file SkPDFUtils.cpp.

                                                           {
    SkASSERT(img);
    SkASSERT(dst);
    SkBitmap bitmap;
    // TODO: support GPU images
    if(as_IB(img)->getROPixels(nullptr, &bitmap)) {
        SkASSERT(bitmap.dimensions() == img->dimensions());
        SkASSERT(!bitmap.drawsNothing());
        *dst = std::move(bitmap);
        return true;
    }
    return false;
}

WriteUInt16BE()

void SkPDFUtils::WriteUInt16BE ( SkWStream *  wStream, uint16_t  value  )

inline

Definition at line 93 of file SkPDFUtils.h.

                                                              {
    char result[4] = { SkHexadecimalDigits::gUpper[       value >> 12 ],
                       SkHexadecimalDigits::gUpper[0xF & (value >> 8 )],
                       SkHexadecimalDigits::gUpper[0xF & (value >> 4 )],
                       SkHexadecimalDigits::gUpper[0xF & (value      )] };
    wStream->write(result, 4);
}

WriteUInt8()

void SkPDFUtils::WriteUInt8 ( SkWStream *  wStream, uint8_t  value  )

inline

Definition at line 101 of file SkPDFUtils.h.

                                                          {
    char result[2] = { SkHexadecimalDigits::gUpper[value >> 4],
                       SkHexadecimalDigits::gUpper[value & 0xF] };
    wStream->write(result, 2);
}

WriteUTF16beHex()

void SkPDFUtils::WriteUTF16beHex ( SkWStream *  wStream, SkUnichar  utf32  )

inline

Definition at line 107 of file SkPDFUtils.h.

                                                                 {
    uint16_t utf16[2] = {0, 0};
    size_t len = SkUTF::ToUTF16(utf32, utf16);
    SkASSERT(len == 1 || len == 2);
    SkPDFUtils::WriteUInt16BE(wStream, utf16[0]);
    if (len == 2) {
        SkPDFUtils::WriteUInt16BE(wStream, utf16[1]);
    }
}

Variable Documentation

kFloatColorDecimalCount

constexpr unsigned SkPDFUtils::kFloatColorDecimalCount = 4

staticconstexpr

Definition at line 73 of file SkPDFUtils.h.