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