SkCanvasStateUtils.cpp File Reference

#include "include/utils/SkCanvasStateUtils.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColorType.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/private/base/SkMalloc.h"
#include "src/core/SkDevice.h"
#include "src/core/SkWriter32.h"
#include "src/utils/SkCanvasStack.h"
#include <cstddef>
#include <cstdint>
#include <utility>

Go to the source code of this file.

Classes
struct	ClipRect
struct	SkMCState
struct	SkCanvasLayerState
class	SkCanvasState
class	SkCanvasState_v1

Typedefs
typedef int32_t	RasterConfig
typedef int32_t	CanvasBackend

Enumerations
enum	RasterConfigs { kUnknown_RasterConfig = 0 , kRGB_565_RasterConfig = 1 , kARGB_8888_RasterConfig = 2 }
enum	CanvasBackends { kUnknown_CanvasBackend = 0 , kRaster_CanvasBackend = 1 , kGPU_CanvasBackend = 2 , kPDF_CanvasBackend = 3 }

Functions
static void	setup_MC_state (SkMCState *state, const SkMatrix &matrix, const SkIRect &clip)
static void	setup_canvas_from_MC_state (const SkMCState &state, SkCanvas *canvas)
static std::unique_ptr< SkCanvas >	make_canvas_from_canvas_layer (const SkCanvasLayerState &layerState)

Typedef Documentation

CanvasBackend

typedef int32_t CanvasBackend

Definition at line 55 of file SkCanvasStateUtils.cpp.

RasterConfig

typedef int32_t RasterConfig

Definition at line 47 of file SkCanvasStateUtils.cpp.

Enumeration Type Documentation

CanvasBackends

enum CanvasBackends

Enumerator
kUnknown_CanvasBackend
kRaster_CanvasBackend
kGPU_CanvasBackend
kPDF_CanvasBackend

Definition at line 49 of file SkCanvasStateUtils.cpp.

                    {
    kUnknown_CanvasBackend = 0,
    kRaster_CanvasBackend  = 1,
    kGPU_CanvasBackend     = 2,
    kPDF_CanvasBackend     = 3
};

RasterConfigs

enum RasterConfigs

Enumerator
kUnknown_RasterConfig
kRGB_565_RasterConfig
kARGB_8888_RasterConfig

Definition at line 42 of file SkCanvasStateUtils.cpp.

                   {
  kUnknown_RasterConfig   = 0,
  kRGB_565_RasterConfig   = 1,
  kARGB_8888_RasterConfig = 2
};

Function Documentation

make_canvas_from_canvas_layer()

static std::unique_ptr< SkCanvas > make_canvas_from_canvas_layer ( const SkCanvasLayerState &  layerState )

static

Definition at line 271 of file SkCanvasStateUtils.cpp.

                                                                    {
    SkASSERT(kRaster_CanvasBackend == layerState.type);
 
    SkBitmap bitmap;
    SkColorType colorType =
        layerState.raster.config == kARGB_8888_RasterConfig ? kN32_SkColorType :
        layerState.raster.config == kRGB_565_RasterConfig ? kRGB_565_SkColorType :
        kUnknown_SkColorType;
 
    if (colorType == kUnknown_SkColorType) {
        return nullptr;
    }
 
    bitmap.installPixels(SkImageInfo::Make(layerState.width, layerState.height,
                                           colorType, kPremul_SkAlphaType),
                         layerState.raster.pixels, (size_t) layerState.raster.rowBytes);
 
    SkASSERT(!bitmap.empty());
    SkASSERT(!bitmap.isNull());
 
    std::unique_ptr<SkCanvas> canvas(new SkCanvas(bitmap));
 
    // setup the matrix and clip
    setup_canvas_from_MC_state(layerState.mcState, canvas.get());
 
    return canvas;
}

setup_canvas_from_MC_state()

static void setup_canvas_from_MC_state ( const SkMCState &  state, SkCanvas *  canvas  )

static

Definition at line 243 of file SkCanvasStateUtils.cpp.

                                                                                 {
    // reconstruct the matrix
    SkMatrix matrix;
    for (int i = 0; i < 9; i++) {
        matrix.set(i, state.matrix[i]);
    }
 
    // only realy support 1 rect, so if the caller (legacy?) sent us more, we just take the bounds
    // of what they sent.
    SkIRect bounds = SkIRect::MakeEmpty();
    if (state.clipRectCount > 0) {
        bounds.setLTRB(state.clipRects[0].left,
                       state.clipRects[0].top,
                       state.clipRects[0].right,
                       state.clipRects[0].bottom);
        for (int i = 1; i < state.clipRectCount; ++i) {
            bounds.join({state.clipRects[i].left,
                         state.clipRects[i].top,
                         state.clipRects[i].right,
                         state.clipRects[i].bottom});
        }
    }
 
    canvas->clipRect(SkRect::Make(bounds));
    canvas->concat(matrix);
}

setup_MC_state()

static void setup_MC_state ( SkMCState *  state, const SkMatrix &  matrix, const SkIRect &  clip  )

static

Definition at line 153 of file SkCanvasStateUtils.cpp.

                                                                                          {
    // initialize the struct
    state->clipRectCount = 0;
 
    // capture the matrix
    for (int i = 0; i < 9; i++) {
        state->matrix[i] = matrix.get(i);
    }
 
    /*
     *  We only support a single clipRect, so we take the clip's bounds. Clients have long made
     *  this assumption anyway, so this restriction is fine.
     */
    SkSWriter32<sizeof(ClipRect)> clipWriter;
 
    if (!clip.isEmpty()) {
        state->clipRectCount = 1;
        state->clipRects = (ClipRect*)sk_malloc_throw(sizeof(ClipRect));
        state->clipRects->left = clip.fLeft;
        state->clipRects->top = clip.fTop;
        state->clipRects->right = clip.fRight;
        state->clipRects->bottom = clip.fBottom;
    }
}