/* * Copyright 2011 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #ifndef SkDeferredCanvas_DEFINED #define SkDeferredCanvas_DEFINED #include "SkCanvas.h" #include "SkDevice.h" #include "SkPicture.h" #include "SkPixelRef.h" /** \class SkDeferredCanvas Subclass of SkCanvas that encapsulates an SkPicture for deferred drawing. The main difference between this class and SkPictureRecord (the canvas provided by SkPicture) is that this is a full drop-in replacement for SkCanvas, while SkPictureRecord only supports draw operations. SkDeferredCanvas will transparently trigger the flushing of deferred draw operations when an attempt is made to access the pixel data. */ class SK_API SkDeferredCanvas : public SkCanvas { public: class DeviceContext; SkDeferredCanvas(); /** Construct a canvas with the specified device to draw into. Equivalent to calling default constructor, then setDevice. @param device Specifies a device for the canvas to draw into. */ explicit SkDeferredCanvas(SkDevice* device); /** Construct a canvas with the specified device to draw into, and * a device context. Equivalent to calling default constructor, then * setDevice. * @param device Specifies a device for the canvas to draw into. * @param deviceContext interface for the device's the graphics context */ explicit SkDeferredCanvas(SkDevice* device, DeviceContext* deviceContext); virtual ~SkDeferredCanvas(); /** * Specify a device to be used by this canvas. Calling setDevice will * release the previously set device, if any. * * @param device The device that the canvas will raw into * @return The device argument, for convenience. */ virtual SkDevice* setDevice(SkDevice* device); /** * Specify a deviceContext to be used by this canvas. Calling * setDeviceContext will release the previously set deviceContext, if any. * A deviceContext must be specified if the device uses a graphics context * that requires some form of state initialization prior to drawing * and/or explicit flushing to synchronize the execution of rendering * operations. * Note: Must be called after the device is set with setDevice. * * @deviceContext interface for the device's the graphics context * @return The deviceContext argument, for convenience. */ DeviceContext* setDeviceContext(DeviceContext* deviceContext); /** * Enable or disable deferred drawing. When deferral is disabled, * pending draw operations are immediately flushed and from then on, * the SkDeferredCanvas behaves just like a regular SkCanvas. * This method must not be called while the save/restore stack is in use. * @param deferred true/false */ void setDeferredDrawing(bool deferred); // Overrides of the SkCanvas interface virtual int save(SaveFlags flags) SK_OVERRIDE; virtual int saveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags) SK_OVERRIDE; virtual void restore() SK_OVERRIDE; virtual bool isDrawingToLayer() const SK_OVERRIDE; virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE; virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE; virtual bool rotate(SkScalar degrees) SK_OVERRIDE; virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE; virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE; virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE; virtual bool clipRect(const SkRect& rect, SkRegion::Op op, bool doAntiAlias) SK_OVERRIDE; virtual bool clipPath(const SkPath& path, SkRegion::Op op, bool doAntiAlias) SK_OVERRIDE; virtual bool clipRegion(const SkRegion& deviceRgn, SkRegion::Op op) SK_OVERRIDE; virtual void clear(SkColor) SK_OVERRIDE; virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE; virtual void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint) SK_OVERRIDE; virtual void drawRect(const SkRect& rect, const SkPaint& paint) SK_OVERRIDE; virtual void drawPath(const SkPath& path, const SkPaint& paint) SK_OVERRIDE; virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint) SK_OVERRIDE; virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src, const SkRect& dst, const SkPaint* paint) SK_OVERRIDE; virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m, const SkPaint* paint) SK_OVERRIDE; virtual void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst, const SkPaint* paint) SK_OVERRIDE; virtual void drawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint) SK_OVERRIDE; virtual void drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE; virtual void drawPosText(const void* text, size_t byteLength, const SkPoint pos[], const SkPaint& paint) SK_OVERRIDE; virtual void drawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, const SkPaint& paint) SK_OVERRIDE; virtual void drawTextOnPath(const void* text, size_t byteLength, const SkPath& path, const SkMatrix* matrix, const SkPaint& paint) SK_OVERRIDE; virtual void drawPicture(SkPicture& picture) SK_OVERRIDE; virtual void drawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[], const SkPoint texs[], const SkColor colors[], SkXfermode* xmode, const uint16_t indices[], int indexCount, const SkPaint& paint) SK_OVERRIDE; virtual SkBounder* setBounder(SkBounder* bounder) SK_OVERRIDE; virtual SkDrawFilter* setDrawFilter(SkDrawFilter* filter) SK_OVERRIDE; private: void flushIfNeeded(const SkBitmap& bitmap); public: class DeviceContext : public SkRefCnt { public: virtual void prepareForDraw() {} }; public: class DeferredDevice : public SkDevice { public: /** * Constructor * @param immediateDevice device to be drawn to when flushing * deferred operations * @param deviceContext callback interface for managing graphics * context state, can be NULL. */ DeferredDevice(SkDevice* immediateDevice, DeviceContext* deviceContext = NULL); ~DeferredDevice(); /** * Sets the device context to be use with the device. * @param deviceContext callback interface for managing graphics * context state, can be NULL. */ void setDeviceContext(DeviceContext* deviceContext); /** * Returns the recording canvas. */ SkCanvas* recordingCanvas() const {return fRecordingCanvas;} /** * Returns the immediate (non deferred) canvas. */ SkCanvas* immediateCanvas() const {return fImmediateCanvas;} /** * Returns the immediate (non deferred) device. */ SkDevice* immediateDevice() const {return fImmediateDevice;} /** * Returns true if an opaque draw operation covering the entire canvas * was performed since the last call to isFreshFrame(). */ bool isFreshFrame(); void flushPending(); void contentsCleared(); void flushIfNeeded(const SkBitmap& bitmap); virtual uint32_t getDeviceCapabilities() SK_OVERRIDE; virtual int width() const SK_OVERRIDE; virtual int height() const SK_OVERRIDE; virtual SkGpuRenderTarget* accessRenderTarget() SK_OVERRIDE; virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config, int width, int height, bool isOpaque, Usage usage) SK_OVERRIDE; virtual void writePixels(const SkBitmap& bitmap, int x, int y, SkCanvas::Config8888 config8888) SK_OVERRIDE; protected: virtual const SkBitmap& onAccessBitmap(SkBitmap*) SK_OVERRIDE; virtual bool onReadPixels(const SkBitmap& bitmap, int x, int y, SkCanvas::Config8888 config8888) SK_OVERRIDE; // The following methods are no-ops on a deferred device virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE {return false;} virtual void setMatrixClip(const SkMatrix&, const SkRegion&, const SkClipStack&) SK_OVERRIDE {} virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&, const SkClipStack&) SK_OVERRIDE {} // None of the following drawing methods should ever get called on the // deferred device virtual void clear(SkColor color) {SkASSERT(0);} virtual void drawPaint(const SkDraw&, const SkPaint& paint) {SkASSERT(0);} virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count, const SkPoint[], const SkPaint& paint) {SkASSERT(0);} virtual void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint) {SkASSERT(0);} virtual void drawPath(const SkDraw&, const SkPath& path, const SkPaint& paint, const SkMatrix* prePathMatrix = NULL, bool pathIsMutable = false) {SkASSERT(0);} virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap, const SkIRect* srcRectOrNull, const SkMatrix& matrix, const SkPaint& paint) {SkASSERT(0);} virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap, int x, int y, const SkPaint& paint) {SkASSERT(0);} virtual void drawText(const SkDraw&, const void* text, size_t len, SkScalar x, SkScalar y, const SkPaint& paint) {SkASSERT(0);} virtual void drawPosText(const SkDraw&, const void* text, size_t len, const SkScalar pos[], SkScalar constY, int scalarsPerPos, const SkPaint& paint) {SkASSERT(0);} virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len, const SkPath& path, const SkMatrix* matrix, const SkPaint& paint) {SkASSERT(0);} virtual void drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len, const SkPoint pos[], const SkPaint& paint, const SkPath& path, const SkMatrix* matrix) {SkASSERT(0);} virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount, const SkPoint verts[], const SkPoint texs[], const SkColor colors[], SkXfermode* xmode, const uint16_t indices[], int indexCount, const SkPaint& paint) {SkASSERT(0);} virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y, const SkPaint&) {SkASSERT(0);} private: virtual void flush(); SkPicture fPicture; SkDevice* fImmediateDevice; SkCanvas* fImmediateCanvas; SkCanvas* fRecordingCanvas; DeviceContext* fDeviceContext; bool fFreshFrame; }; DeferredDevice* getDeferredDevice() const; protected: virtual SkCanvas* canvasForDrawIter(); private: SkCanvas* drawingCanvas() const; bool isFullFrame(const SkRect*, const SkPaint*) const; void validate() const; void init(); bool fDeferredDrawing; typedef SkCanvas INHERITED; }; #endif