SkDebugCanvas.h revision 8f90a892c5130d4d26b5588e1ff151d01a40688a
1
2/*
3 * Copyright 2012 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10#ifndef SKDEBUGCANVAS_H_
11#define SKDEBUGCANVAS_H_
12
13#include "SkCanvas.h"
14#include "SkDrawCommand.h"
15#include "SkPicture.h"
16#include "SkTArray.h"
17#include "SkString.h"
18
19class SkTexOverrideFilter;
20
21class SK_API SkDebugCanvas : public SkCanvas {
22public:
23    SkDebugCanvas(int width, int height);
24    virtual ~SkDebugCanvas();
25
26    void toggleFilter(bool toggle);
27
28    /**
29     * Enable or disable overdraw visualization
30     */
31    void setOverdrawViz(bool overdrawViz) { fOverdrawViz = overdrawViz; }
32
33    /**
34     * Enable or disable texure filtering override
35     */
36    void overrideTexFiltering(bool overrideTexFiltering, SkPaint::FilterLevel level);
37
38    /**
39        Executes all draw calls to the canvas.
40        @param canvas  The canvas being drawn to
41     */
42    void draw(SkCanvas* canvas);
43
44    /**
45        Executes the draw calls up to the specified index.
46        @param canvas  The canvas being drawn to
47        @param index  The index of the final command being executed
48     */
49    void drawTo(SkCanvas* canvas, int index);
50
51    /**
52        Returns the most recently calculated transformation matrix
53     */
54    const SkMatrix& getCurrentMatrix() {
55        return fMatrix;
56    }
57
58    /**
59        Returns the most recently calculated clip
60     */
61    const SkIRect& getCurrentClip() {
62        return fClip;
63    }
64
65    /**
66        Returns the index of the last draw command to write to the pixel at (x,y)
67     */
68    int getCommandAtPoint(int x, int y, int index);
69
70    /**
71        Removes the command at the specified index
72        @param index  The index of the command to delete
73     */
74    void deleteDrawCommandAt(int index);
75
76    /**
77        Returns the draw command at the given index.
78        @param index  The index of the command
79     */
80    SkDrawCommand* getDrawCommandAt(int index);
81
82    /**
83        Sets the draw command for a given index.
84        @param index  The index to overwrite
85        @param command The new command
86     */
87    void setDrawCommandAt(int index, SkDrawCommand* command);
88
89    /**
90        Returns information about the command at the given index.
91        @param index  The index of the command
92     */
93    SkTDArray<SkString*>* getCommandInfo(int index);
94
95    /**
96        Returns the visibility of the command at the given index.
97        @param index  The index of the command
98     */
99    bool getDrawCommandVisibilityAt(int index);
100
101    /**
102        Returns the vector of draw commands
103     */
104    SK_ATTR_DEPRECATED("please use getDrawCommandAt and getSize instead")
105    const SkTDArray<SkDrawCommand*>& getDrawCommands() const;
106
107    /**
108        Returns the vector of draw commands. Do not use this entry
109        point - it is going away!
110     */
111    SkTDArray<SkDrawCommand*>& getDrawCommands();
112
113    /**
114     * Returns the string vector of draw commands
115     */
116    SkTArray<SkString>* getDrawCommandsAsStrings() const;
117
118    /**
119        Returns length of draw command vector.
120     */
121    int getSize() const {
122        return fCommandVector.count();
123    }
124
125    /**
126        Toggles the visibility / execution of the draw command at index i with
127        the value of toggle.
128     */
129    void toggleCommand(int index, bool toggle);
130
131    void setBounds(int width, int height) {
132        fWidth = width;
133        fHeight = height;
134    }
135
136    void setUserMatrix(SkMatrix matrix) {
137        fUserMatrix = matrix;
138    }
139
140////////////////////////////////////////////////////////////////////////////////
141// Inherited from SkCanvas
142////////////////////////////////////////////////////////////////////////////////
143
144    virtual void clear(SkColor) SK_OVERRIDE;
145
146    virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE;
147
148    virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
149                            const SkPaint*) SK_OVERRIDE;
150
151    virtual void drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
152                                      const SkRect& dst, const SkPaint* paint,
153                                      DrawBitmapRectFlags flags) SK_OVERRIDE;
154
155    virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
156                                  const SkPaint*) SK_OVERRIDE;
157
158    virtual void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
159                                const SkRect& dst, const SkPaint*) SK_OVERRIDE;
160
161    virtual void drawData(const void*, size_t) SK_OVERRIDE;
162
163    virtual void beginCommentGroup(const char* description) SK_OVERRIDE;
164
165    virtual void addComment(const char* kywd, const char* value) SK_OVERRIDE;
166
167    virtual void endCommentGroup() SK_OVERRIDE;
168
169    virtual void drawOval(const SkRect& oval, const SkPaint&) SK_OVERRIDE;
170
171    virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
172
173    virtual void drawPath(const SkPath& path, const SkPaint&) SK_OVERRIDE;
174
175    virtual void drawPicture(SkPicture& picture) SK_OVERRIDE;
176
177    virtual void drawPoints(PointMode, size_t count, const SkPoint pts[],
178                            const SkPaint&) SK_OVERRIDE;
179
180    virtual void drawPosText(const void* text, size_t byteLength,
181                             const SkPoint pos[], const SkPaint&) SK_OVERRIDE;
182
183    virtual void drawPosTextH(const void* text, size_t byteLength,
184                              const SkScalar xpos[], SkScalar constY,
185                              const SkPaint&) SK_OVERRIDE;
186
187    virtual void drawRect(const SkRect& rect, const SkPaint&) SK_OVERRIDE;
188
189    virtual void drawRRect(const SkRRect& rrect, const SkPaint& paint) SK_OVERRIDE;
190
191    virtual void drawSprite(const SkBitmap&, int left, int top,
192                            const SkPaint*) SK_OVERRIDE;
193
194    virtual void drawText(const void* text, size_t byteLength, SkScalar x,
195                          SkScalar y, const SkPaint&) SK_OVERRIDE;
196
197    virtual void drawTextOnPath(const void* text, size_t byteLength,
198                                const SkPath& path, const SkMatrix* matrix,
199                                const SkPaint&) SK_OVERRIDE;
200
201    virtual void drawVertices(VertexMode, int vertexCount,
202                              const SkPoint vertices[], const SkPoint texs[],
203                              const SkColor colors[], SkXfermode*,
204                              const uint16_t indices[], int indexCount,
205                              const SkPaint&) SK_OVERRIDE;
206
207    virtual void restore() SK_OVERRIDE;
208
209    virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
210
211    virtual int save(SaveFlags) SK_OVERRIDE;
212
213    virtual int saveLayer(const SkRect* bounds, const SkPaint*, SaveFlags) SK_OVERRIDE;
214
215    virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
216
217    virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
218
219    virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE;
220
221    virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
222
223    static const int kVizImageHeight = 256;
224    static const int kVizImageWidth = 256;
225
226    virtual bool isClipEmpty() const SK_OVERRIDE { return false; }
227    virtual ClipType getClipType() const SK_OVERRIDE {
228        return kRect_ClipType;
229    }
230    virtual bool getClipBounds(SkRect* bounds) const SK_OVERRIDE {
231        if (NULL != bounds) {
232            bounds->setXYWH(0, 0,
233                            SkIntToScalar(this->imageInfo().fWidth),
234                            SkIntToScalar(this->imageInfo().fHeight));
235        }
236        return true;
237    }
238    virtual bool getClipDeviceBounds(SkIRect* bounds) const SK_OVERRIDE {
239        if (NULL != bounds) {
240            bounds->setLargest();
241        }
242        return true;
243    }
244
245protected:
246    virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
247    virtual void onPushCull(const SkRect& cullRect) SK_OVERRIDE;
248    virtual void onPopCull() SK_OVERRIDE;
249
250    virtual void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
251    virtual void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
252    virtual void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
253    virtual void onClipRegion(const SkRegion& region, SkRegion::Op) SK_OVERRIDE;
254
255private:
256    SkTDArray<SkDrawCommand*> fCommandVector;
257    int fWidth;
258    int fHeight;
259    bool fFilter;
260    int fIndex;
261    SkMatrix fUserMatrix;
262    SkMatrix fMatrix;
263    SkIRect fClip;
264
265    bool fOverdrawViz;
266    SkDrawFilter* fOverdrawFilter;
267
268    bool fOverrideTexFiltering;
269    SkTexOverrideFilter* fTexOverrideFilter;
270
271    /**
272        Number of unmatched save() calls at any point during a draw.
273        If there are any saveLayer() calls outstanding, we need to resolve
274        all of them, which in practice means resolving all save() calls,
275        to avoid corruption of our canvas.
276    */
277    int fOutstandingSaveCount;
278
279    /**
280        Adds the command to the classes vector of commands.
281        @param command  The draw command for execution
282     */
283    void addDrawCommand(SkDrawCommand* command);
284
285    /**
286        Applies any panning and zooming the user has specified before
287        drawing anything else into the canvas.
288     */
289    void applyUserTransform(SkCanvas* canvas);
290
291    typedef SkCanvas INHERITED;
292};
293
294#endif
295