SkPDFGraphicStackState.cpp File Reference

#include "src/pdf/SkPDFGraphicStackState.h"
#include "include/core/SkClipOp.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkRect.h"
#include "include/core/SkStream.h"
#include "include/pathops/SkPathOps.h"
#include "include/private/base/SkAssert.h"
#include "src/pdf/SkPDFUtils.h"
#include "src/utils/SkClipStackUtils.h"

Go to the source code of this file.

Functions
static void	emit_pdf_color (SkColor4f color, SkWStream *result)
static SkRect	rect_intersect (SkRect u, SkRect v)
static bool	is_rect (const SkClipStack &clipStack, const SkRect &bounds, SkRect *dst)
static bool	is_complex_clip (const SkClipStack &stack)
template<typename F >
static void	apply_clip (const SkClipStack &stack, const SkRect &outerBounds, F fn)
static void	append_clip_path (const SkPath &clipPath, SkWStream *wStream)
static void	append_clip (const SkClipStack &clipStack, const SkIRect &bounds, SkWStream *wStream)

Function Documentation

append_clip()

static void append_clip ( const SkClipStack &  clipStack, const SkIRect &  bounds, SkWStream *  wStream  )

static

Definition at line 114 of file SkPDFGraphicStackState.cpp.

                                            {
    // The bounds are slightly outset to ensure this is correct in the
    // face of floating-point accuracy and possible SkRegion bitmap
    // approximations.
    SkRect outsetBounds = SkRect::Make(bounds.makeOutset(1, 1));
 
    SkRect clipStackRect;
    if (is_rect(clipStack, outsetBounds, &clipStackRect)) {
        SkPDFUtils::AppendRectangle(clipStackRect, wStream);
        wStream->writeText("W* n\n");
        return;
    }
 
    if (is_complex_clip(clipStack)) {
        SkPath clipPath;
        SkClipStack_AsPath(clipStack, &clipPath);
        if (Op(clipPath, SkPath::Rect(outsetBounds), kIntersect_SkPathOp, &clipPath)) {
            append_clip_path(clipPath, wStream);
        }
        // If Op() fails (pathological case; e.g. input values are
        // extremely large or NaN), emit no clip at all.
    } else {
        apply_clip(clipStack, outsetBounds, [wStream](const SkPath& path) {
            append_clip_path(path, wStream);
        });
    }
}

append_clip_path()

static void append_clip_path ( const SkPath &  clipPath, SkWStream *  wStream  )

static

Definition at line 102 of file SkPDFGraphicStackState.cpp.

                                                                         {
    SkPDFUtils::EmitPath(clipPath, SkPaint::kFill_Style, wStream);
    SkPathFillType clipFill = clipPath.getFillType();
    NOT_IMPLEMENTED(clipFill == SkPathFillType::kInverseEvenOdd, false);
    NOT_IMPLEMENTED(clipFill == SkPathFillType::kInverseWinding, false);
    if (clipFill == SkPathFillType::kEvenOdd) {
        wStream->writeText("W* n\n");
    } else {
        wStream->writeText("W n\n");
    }
}

apply_clip()

template<typename F >

static void apply_clip ( const SkClipStack &  stack, const SkRect &  outerBounds, F  fn  )

static

Definition at line 74 of file SkPDFGraphicStackState.cpp.

                                                                                  {
    // assumes clipstack is not complex.
    constexpr SkRect kHuge{-30000, -30000, 30000, 30000};
    SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
    SkRect bounds = outerBounds;
    while (const SkClipStack::Element* element = iter.next()) {
        SkPath operand;
        element->asDeviceSpacePath(&operand);
        SkPathOp op;
        switch (element->getOp()) {
            case SkClipOp::kDifference: op = kDifference_SkPathOp; break;
            case SkClipOp::kIntersect:  op = kIntersect_SkPathOp;  break;
            default: SkASSERT(false); return;
        }
        if (op == kDifference_SkPathOp  ||
            operand.isInverseFillType() ||
            !kHuge.contains(operand.getBounds()))
        {
            Op(SkPath::Rect(bounds), operand, op, &operand);
        }
        SkASSERT(!operand.isInverseFillType());
        fn(operand);
        if (!bounds.intersect(operand.getBounds())) {
            return; // return early;
        }
    }
}

emit_pdf_color()

static void emit_pdf_color ( SkColor4f  color, SkWStream *  result  )

static

Definition at line 17 of file SkPDFGraphicStackState.cpp.

                                                               {
    SkASSERT(color.fA == 1);  // We handle alpha elsewhere.
    SkPDFUtils::AppendColorComponentF(color.fR, result);
    result->writeText(" ");
    SkPDFUtils::AppendColorComponentF(color.fG, result);
    result->writeText(" ");
    SkPDFUtils::AppendColorComponentF(color.fB, result);
    result->writeText(" ");
}

is_complex_clip()

static bool is_complex_clip ( const SkClipStack &  stack )

static

Definition at line 61 of file SkPDFGraphicStackState.cpp.

                                                      {
    SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
    while (const SkClipStack::Element* element = iter.next()) {
        if (element->isReplaceOp() ||
            (element->getOp() != SkClipOp::kDifference &&
             element->getOp() != SkClipOp::kIntersect)) {
            return true;
        }
    }
    return false;
}

is_rect()

static bool is_rect ( const SkClipStack &  clipStack, const SkRect &  bounds, SkRect *  dst  )

static

Definition at line 34 of file SkPDFGraphicStackState.cpp.

                                                                                     {
    SkRect currentClip = bounds;
    SkClipStack::Iter iter(clipStack, SkClipStack::Iter::kBottom_IterStart);
    while (const SkClipStack::Element* element = iter.next()) {
        SkRect elementRect{0, 0, 0, 0};
        switch (element->getDeviceSpaceType()) {
            case SkClipStack::Element::DeviceSpaceType::kEmpty:
                break;
            case SkClipStack::Element::DeviceSpaceType::kRect:
                elementRect = element->getDeviceSpaceRect();
                break;
            default:
                return false;
        }
        if (element->isReplaceOp()) {
            currentClip = rect_intersect(bounds, elementRect);
        } else if (element->getOp() == SkClipOp::kIntersect) {
            currentClip = rect_intersect(currentClip, elementRect);
        } else {
            return false;
        }
    }
    *dst = currentClip;
    return true;
}

rect_intersect()

static SkRect rect_intersect ( SkRect  u, SkRect  v  )

static

Definition at line 27 of file SkPDFGraphicStackState.cpp.

                                                 {
    if (u.isEmpty() || v.isEmpty()) { return {0, 0, 0, 0}; }
    return u.intersect(v) ? u : SkRect{0, 0, 0, 0};
}