The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/utils/debugger/SkDrawCommand.h

gfx/skia/trunk/src/utils/debugger/SkDrawCommand.h

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:69f8b2394ad7
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 #ifndef SKDRAWCOMMAND_H_
10 #define SKDRAWCOMMAND_H_
11
12 #include "SkPictureFlat.h"
13 #include "SkCanvas.h"
14 #include "SkString.h"
15
16 class SK_API SkDrawCommand {
17 public:
18 /* TODO(chudy): Remove subclasses. */
19 SkDrawCommand(DrawType drawType);
20 SkDrawCommand();
21
22 virtual ~SkDrawCommand();
23
24 virtual SkString toString();
25
26 virtual const char* toCString() {
27 return GetCommandString(fDrawType);
28 }
29
30 bool isVisible() const {
31 return fVisible;
32 }
33
34 void setVisible(bool toggle) {
35 fVisible = toggle;
36 }
37
38 SkTDArray<SkString*>* Info() {return &fInfo; };
39 virtual void execute(SkCanvas* canvas) = 0;
40 virtual void vizExecute(SkCanvas* canvas) { };
41 /** Does nothing by default, but used by save() and restore()-type
42 subclasses to track unresolved save() calls. */
43 virtual void trackSaveState(int* state) { };
44
45 // The next "active" system is only used by save, saveLayer, restore,
46 // pushCull and popCull. It is used in two ways:
47 // To determine which saveLayers are currently active (at a
48 // given point in the rendering).
49 // save just return a kPushLayer action but don't track active state
50 // restore just return a kPopLayer action
51 // saveLayers return kPushLayer but also track the active state
52 // To determine which culls are currently active (at a given point)
53 // in the rendering).
54 // pushCull returns a kPushCull action
55 // popCull returns a kPopCull action
56 enum Action {
57 kNone_Action,
58 kPopLayer_Action,
59 kPushLayer_Action,
60 kPopCull_Action,
61 kPushCull_Action
62 };
63 virtual Action action() const { return kNone_Action; }
64 virtual void setActive(bool active) {}
65 virtual bool active() const { return false; }
66
67 DrawType getType() { return fDrawType; };
68
69 virtual bool render(SkCanvas* canvas) const { return false; }
70
71 static const char* GetCommandString(DrawType type);
72
73 protected:
74 DrawType fDrawType;
75 SkTDArray<SkString*> fInfo;
76
77 private:
78 bool fVisible;
79 };
80
81 class SkRestoreCommand : public SkDrawCommand {
82 public:
83 SkRestoreCommand();
84 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
85 virtual void trackSaveState(int* state) SK_OVERRIDE;
86 virtual Action action() const SK_OVERRIDE { return kPopLayer_Action; }
87
88 private:
89 typedef SkDrawCommand INHERITED;
90 };
91
92 class SkClearCommand : public SkDrawCommand {
93 public:
94 SkClearCommand(SkColor color);
95 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
96 private:
97 SkColor fColor;
98
99 typedef SkDrawCommand INHERITED;
100 };
101
102 class SkClipPathCommand : public SkDrawCommand {
103 public:
104 SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA);
105 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
106 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
107 private:
108 SkPath fPath;
109 SkRegion::Op fOp;
110 bool fDoAA;
111
112 typedef SkDrawCommand INHERITED;
113 };
114
115 class SkClipRegionCommand : public SkDrawCommand {
116 public:
117 SkClipRegionCommand(const SkRegion& region, SkRegion::Op op);
118 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
119 private:
120 SkRegion fRegion;
121 SkRegion::Op fOp;
122
123 typedef SkDrawCommand INHERITED;
124 };
125
126 class SkClipRectCommand : public SkDrawCommand {
127 public:
128 SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA);
129 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
130
131 const SkRect& rect() const { return fRect; }
132 SkRegion::Op op() const { return fOp; }
133 bool doAA() const { return fDoAA; }
134
135 private:
136 SkRect fRect;
137 SkRegion::Op fOp;
138 bool fDoAA;
139
140 typedef SkDrawCommand INHERITED;
141 };
142
143 class SkClipRRectCommand : public SkDrawCommand {
144 public:
145 SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA);
146 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
147 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
148
149 const SkRRect& rrect() const { return fRRect; }
150 SkRegion::Op op() const { return fOp; }
151 bool doAA() const { return fDoAA; }
152
153 private:
154 SkRRect fRRect;
155 SkRegion::Op fOp;
156 bool fDoAA;
157
158 typedef SkDrawCommand INHERITED;
159 };
160
161 class SkConcatCommand : public SkDrawCommand {
162 public:
163 SkConcatCommand(const SkMatrix& matrix);
164 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
165 private:
166 SkMatrix fMatrix;
167
168 typedef SkDrawCommand INHERITED;
169 };
170
171 class SkDrawBitmapCommand : public SkDrawCommand {
172 public:
173 SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
174 const SkPaint* paint);
175 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
176 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
177 private:
178 SkBitmap fBitmap;
179 SkScalar fLeft;
180 SkScalar fTop;
181 SkPaint fPaint;
182 SkPaint* fPaintPtr;
183
184 typedef SkDrawCommand INHERITED;
185 };
186
187 class SkDrawBitmapMatrixCommand : public SkDrawCommand {
188 public:
189 SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, const SkMatrix& matrix,
190 const SkPaint* paint);
191 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
192 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
193 private:
194 SkBitmap fBitmap;
195 SkMatrix fMatrix;
196 SkPaint fPaint;
197 SkPaint* fPaintPtr;
198
199 typedef SkDrawCommand INHERITED;
200 };
201
202 class SkDrawBitmapNineCommand : public SkDrawCommand {
203 public:
204 SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
205 const SkRect& dst, const SkPaint* paint);
206 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
207 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
208 private:
209 SkBitmap fBitmap;
210 SkIRect fCenter;
211 SkRect fDst;
212 SkPaint fPaint;
213 SkPaint* fPaintPtr;
214
215 typedef SkDrawCommand INHERITED;
216 };
217
218 class SkDrawBitmapRectCommand : public SkDrawCommand {
219 public:
220 SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,
221 const SkRect& dst, const SkPaint* paint,
222 SkCanvas::DrawBitmapRectFlags flags);
223 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
224 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
225
226 const SkBitmap& bitmap() const { return fBitmap; }
227
228 // The non-const 'paint' method allows modification of this object's
229 // SkPaint. For this reason the ctor and setPaint method make a local copy.
230 // The 'fPaintPtr' member acts a signal that the local SkPaint is valid
231 // (since only an SkPaint* is passed into the ctor).
232 const SkPaint* paint() const { return fPaintPtr; }
233 SkPaint* paint() { return fPaintPtr; }
234
235 void setPaint(const SkPaint& paint) { fPaint = paint; fPaintPtr = &fPaint; }
236
237 const SkRect* srcRect() const { return fSrc.isEmpty() ? NULL : &fSrc; }
238 void setSrcRect(const SkRect& src) { fSrc = src; }
239
240 const SkRect& dstRect() const { return fDst; }
241 void setDstRect(const SkRect& dst) { fDst = dst; }
242
243 SkCanvas::DrawBitmapRectFlags flags() const { return fFlags; }
244 void setFlags(SkCanvas::DrawBitmapRectFlags flags) { fFlags = flags; }
245
246 private:
247 SkBitmap fBitmap;
248 SkRect fSrc;
249 SkRect fDst;
250 SkPaint fPaint;
251 SkPaint* fPaintPtr;
252 SkCanvas::DrawBitmapRectFlags fFlags;
253
254 typedef SkDrawCommand INHERITED;
255 };
256
257 class SkDrawDataCommand : public SkDrawCommand {
258 public:
259 SkDrawDataCommand(const void* data, size_t length);
260 virtual ~SkDrawDataCommand() { delete [] fData; }
261 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
262 private:
263 char* fData;
264 size_t fLength;
265
266 typedef SkDrawCommand INHERITED;
267 };
268
269 class SkBeginCommentGroupCommand : public SkDrawCommand {
270 public:
271 SkBeginCommentGroupCommand(const char* description);
272 virtual void execute(SkCanvas* canvas) SK_OVERRIDE {
273 canvas->beginCommentGroup(fDescription.c_str());
274 };
275 private:
276 SkString fDescription;
277
278 typedef SkDrawCommand INHERITED;
279 };
280
281 class SkCommentCommand : public SkDrawCommand {
282 public:
283 SkCommentCommand(const char* kywd, const char* value);
284 virtual void execute(SkCanvas* canvas) SK_OVERRIDE {
285 canvas->addComment(fKywd.c_str(), fValue.c_str());
286 };
287 private:
288 SkString fKywd;
289 SkString fValue;
290
291 typedef SkDrawCommand INHERITED;
292 };
293
294 class SkEndCommentGroupCommand : public SkDrawCommand {
295 public:
296 SkEndCommentGroupCommand();
297 virtual void execute(SkCanvas* canvas) SK_OVERRIDE {
298 canvas->endCommentGroup();
299 };
300 private:
301 typedef SkDrawCommand INHERITED;
302 };
303
304 class SkDrawOvalCommand : public SkDrawCommand {
305 public:
306 SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint);
307 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
308 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
309 private:
310 SkRect fOval;
311 SkPaint fPaint;
312
313 typedef SkDrawCommand INHERITED;
314 };
315
316 class SkDrawPaintCommand : public SkDrawCommand {
317 public:
318 SkDrawPaintCommand(const SkPaint& paint);
319 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
320 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
321 private:
322 SkPaint fPaint;
323
324 typedef SkDrawCommand INHERITED;
325 };
326
327 class SkDrawPathCommand : public SkDrawCommand {
328 public:
329 SkDrawPathCommand(const SkPath& path, const SkPaint& paint);
330 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
331 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
332
333 private:
334 SkPath fPath;
335 SkPaint fPaint;
336
337 typedef SkDrawCommand INHERITED;
338 };
339
340 class SkDrawPictureCommand : public SkDrawCommand {
341 public:
342 SkDrawPictureCommand(SkPicture& picture);
343 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
344 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
345
346 private:
347 SkPicture fPicture;
348
349 typedef SkDrawCommand INHERITED;
350 };
351
352 class SkDrawPointsCommand : public SkDrawCommand {
353 public:
354 SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[],
355 const SkPaint& paint);
356 virtual ~SkDrawPointsCommand() { delete [] fPts; }
357 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
358 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
359 private:
360 SkCanvas::PointMode fMode;
361 size_t fCount;
362 SkPoint* fPts;
363 SkPaint fPaint;
364
365 typedef SkDrawCommand INHERITED;
366 };
367
368 class SkDrawTextCommand : public SkDrawCommand {
369 public:
370 SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y,
371 const SkPaint& paint);
372 virtual ~SkDrawTextCommand() { delete [] fText; }
373 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
374 private:
375 char* fText;
376 size_t fByteLength;
377 SkScalar fX;
378 SkScalar fY;
379 SkPaint fPaint;
380
381 typedef SkDrawCommand INHERITED;
382 };
383
384 class SkDrawPosTextCommand : public SkDrawCommand {
385 public:
386 SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[],
387 const SkPaint& paint);
388 virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; }
389 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
390 private:
391 char* fText;
392 size_t fByteLength;
393 SkPoint* fPos;
394 SkPaint fPaint;
395
396 typedef SkDrawCommand INHERITED;
397 };
398
399 class SkDrawTextOnPathCommand : public SkDrawCommand {
400 public:
401 SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& path,
402 const SkMatrix* matrix, const SkPaint& paint);
403 virtual ~SkDrawTextOnPathCommand() { delete [] fText; }
404 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
405 private:
406 char* fText;
407 size_t fByteLength;
408 SkPath fPath;
409 SkMatrix fMatrix;
410 SkPaint fPaint;
411
412 typedef SkDrawCommand INHERITED;
413 };
414
415 class SkDrawPosTextHCommand : public SkDrawCommand {
416 public:
417 SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[],
418 SkScalar constY, const SkPaint& paint);
419 virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; }
420 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
421 private:
422 SkScalar* fXpos;
423 char* fText;
424 size_t fByteLength;
425 SkScalar fConstY;
426 SkPaint fPaint;
427
428 typedef SkDrawCommand INHERITED;
429 };
430
431 class SkDrawRectCommand : public SkDrawCommand {
432 public:
433 SkDrawRectCommand(const SkRect& rect, const SkPaint& paint);
434 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
435
436 const SkRect& rect() const { return fRect; }
437 const SkPaint& paint() const { return fPaint; }
438 private:
439 SkRect fRect;
440 SkPaint fPaint;
441
442 typedef SkDrawCommand INHERITED;
443 };
444
445 class SkDrawRRectCommand : public SkDrawCommand {
446 public:
447 SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint);
448 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
449 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
450 private:
451 SkRRect fRRect;
452 SkPaint fPaint;
453
454 typedef SkDrawCommand INHERITED;
455 };
456
457 class SkDrawDRRectCommand : public SkDrawCommand {
458 public:
459 SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner,
460 const SkPaint& paint);
461 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
462 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
463 private:
464 SkRRect fOuter;
465 SkRRect fInner;
466 SkPaint fPaint;
467
468 typedef SkDrawCommand INHERITED;
469 };
470
471 class SkDrawSpriteCommand : public SkDrawCommand {
472 public:
473 SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint);
474 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
475 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
476 private:
477 SkBitmap fBitmap;
478 int fLeft;
479 int fTop;
480 SkPaint fPaint;
481 SkPaint* fPaintPtr;
482
483 typedef SkDrawCommand INHERITED;
484 };
485
486 class SkDrawVerticesCommand : public SkDrawCommand {
487 public:
488 SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount,
489 const SkPoint vertices[], const SkPoint texs[],
490 const SkColor colors[], SkXfermode* xfermode,
491 const uint16_t indices[], int indexCount,
492 const SkPaint& paint);
493 virtual ~SkDrawVerticesCommand();
494 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
495 private:
496 SkCanvas::VertexMode fVmode;
497 int fVertexCount;
498 SkPoint* fVertices;
499 SkPoint* fTexs;
500 SkColor* fColors;
501 SkXfermode* fXfermode;
502 uint16_t* fIndices;
503 int fIndexCount;
504 SkPaint fPaint;
505
506 typedef SkDrawCommand INHERITED;
507 };
508
509 class SkRotateCommand : public SkDrawCommand {
510 public:
511 SkRotateCommand(SkScalar degrees);
512 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
513 private:
514 SkScalar fDegrees;
515
516 typedef SkDrawCommand INHERITED;
517 };
518
519 class SkSaveCommand : public SkDrawCommand {
520 public:
521 SkSaveCommand(SkCanvas::SaveFlags flags);
522 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
523 virtual void trackSaveState(int* state) SK_OVERRIDE;
524 virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; }
525 private:
526 SkCanvas::SaveFlags fFlags;
527
528 typedef SkDrawCommand INHERITED;
529 };
530
531 class SkSaveLayerCommand : public SkDrawCommand {
532 public:
533 SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint,
534 SkCanvas::SaveFlags flags);
535 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
536 virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE;
537 virtual void trackSaveState(int* state) SK_OVERRIDE;
538 virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; }
539 virtual void setActive(bool active) SK_OVERRIDE { fActive = active; }
540 virtual bool active() const SK_OVERRIDE { return fActive; }
541
542 const SkPaint* paint() const { return fPaintPtr; }
543
544 private:
545 SkRect fBounds;
546 SkPaint fPaint;
547 SkPaint* fPaintPtr;
548 SkCanvas::SaveFlags fFlags;
549
550 bool fActive;
551
552 typedef SkDrawCommand INHERITED;
553 };
554
555 class SkScaleCommand : public SkDrawCommand {
556 public:
557 SkScaleCommand(SkScalar sx, SkScalar sy);
558 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
559
560 SkScalar x() const { return fSx; }
561 SkScalar y() const { return fSy; }
562
563 private:
564 SkScalar fSx;
565 SkScalar fSy;
566
567 typedef SkDrawCommand INHERITED;
568 };
569
570 class SkSetMatrixCommand : public SkDrawCommand {
571 public:
572 SkSetMatrixCommand(const SkMatrix& matrix);
573 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
574 private:
575 SkMatrix fMatrix;
576
577 typedef SkDrawCommand INHERITED;
578 };
579
580 class SkSkewCommand : public SkDrawCommand {
581 public:
582 SkSkewCommand(SkScalar sx, SkScalar sy);
583 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
584 private:
585 SkScalar fSx;
586 SkScalar fSy;
587
588 typedef SkDrawCommand INHERITED;
589 };
590
591 class SkTranslateCommand : public SkDrawCommand {
592 public:
593 SkTranslateCommand(SkScalar dx, SkScalar dy);
594 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
595
596 SkScalar x() const { return fDx; }
597 SkScalar y() const { return fDy; }
598
599 private:
600 SkScalar fDx;
601 SkScalar fDy;
602
603 typedef SkDrawCommand INHERITED;
604 };
605
606 class SkPushCullCommand : public SkDrawCommand {
607 public:
608 SkPushCullCommand(const SkRect&);
609 virtual void execute(SkCanvas*) SK_OVERRIDE;
610 virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE;
611 virtual Action action() const { return kPushCull_Action; }
612 virtual void setActive(bool active) { fActive = active; }
613 virtual bool active() const { return fActive; }
614 private:
615 SkRect fCullRect;
616 bool fActive;
617
618 typedef SkDrawCommand INHERITED;
619 };
620
621 class SkPopCullCommand : public SkDrawCommand {
622 public:
623 SkPopCullCommand();
624 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
625 virtual Action action() const { return kPopCull_Action; }
626 private:
627 typedef SkDrawCommand INHERITED;
628 };
629
630 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial