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); 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 353 typedef SkDrawCommand INHERITED; 354}; 355 356class SkDrawPointsCommand : public SkDrawCommand { 357public: 358 SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[], 359 const SkPaint& paint); 360 virtual ~SkDrawPointsCommand() { delete [] fPts; } 361 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 362 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 363private: 364 SkCanvas::PointMode fMode; 365 size_t fCount; 366 SkPoint* fPts; 367 SkPaint fPaint; 368 369 typedef SkDrawCommand INHERITED; 370}; 371 372class SkDrawTextCommand : public SkDrawCommand { 373public: 374 SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y, 375 const SkPaint& paint); 376 virtual ~SkDrawTextCommand() { delete [] fText; } 377 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 378private: 379 char* fText; 380 size_t fByteLength; 381 SkScalar fX; 382 SkScalar fY; 383 SkPaint fPaint; 384 385 typedef SkDrawCommand INHERITED; 386}; 387 388class SkDrawPosTextCommand : public SkDrawCommand { 389public: 390 SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[], 391 const SkPaint& paint); 392 virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; } 393 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 394private: 395 char* fText; 396 size_t fByteLength; 397 SkPoint* fPos; 398 SkPaint fPaint; 399 400 typedef SkDrawCommand INHERITED; 401}; 402 403class SkDrawTextOnPathCommand : public SkDrawCommand { 404public: 405 SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& path, 406 const SkMatrix* matrix, const SkPaint& paint); 407 virtual ~SkDrawTextOnPathCommand() { delete [] fText; } 408 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 409private: 410 char* fText; 411 size_t fByteLength; 412 SkPath fPath; 413 SkMatrix fMatrix; 414 SkPaint fPaint; 415 416 typedef SkDrawCommand INHERITED; 417}; 418 419class SkDrawPosTextHCommand : public SkDrawCommand { 420public: 421 SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[], 422 SkScalar constY, const SkPaint& paint); 423 virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; } 424 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 425private: 426 SkScalar* fXpos; 427 char* fText; 428 size_t fByteLength; 429 SkScalar fConstY; 430 SkPaint fPaint; 431 432 typedef SkDrawCommand INHERITED; 433}; 434 435class SkDrawRectCommand : public SkDrawCommand { 436public: 437 SkDrawRectCommand(const SkRect& rect, const SkPaint& paint); 438 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 439 440 const SkRect& rect() const { return fRect; } 441 const SkPaint& paint() const { return fPaint; } 442private: 443 SkRect fRect; 444 SkPaint fPaint; 445 446 typedef SkDrawCommand INHERITED; 447}; 448 449class SkDrawRRectCommand : public SkDrawCommand { 450public: 451 SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint); 452 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 453 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 454private: 455 SkRRect fRRect; 456 SkPaint fPaint; 457 458 typedef SkDrawCommand INHERITED; 459}; 460 461class SkDrawDRRectCommand : public SkDrawCommand { 462public: 463 SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner, 464 const SkPaint& paint); 465 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 466 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 467private: 468 SkRRect fOuter; 469 SkRRect fInner; 470 SkPaint fPaint; 471 472 typedef SkDrawCommand INHERITED; 473}; 474 475class SkDrawSpriteCommand : public SkDrawCommand { 476public: 477 SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint); 478 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 479 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 480private: 481 SkBitmap fBitmap; 482 int fLeft; 483 int fTop; 484 SkPaint fPaint; 485 SkPaint* fPaintPtr; 486 487 typedef SkDrawCommand INHERITED; 488}; 489 490class SkDrawVerticesCommand : public SkDrawCommand { 491public: 492 SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, 493 const SkPoint vertices[], const SkPoint texs[], 494 const SkColor colors[], SkXfermode* xfermode, 495 const uint16_t indices[], int indexCount, 496 const SkPaint& paint); 497 virtual ~SkDrawVerticesCommand(); 498 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 499private: 500 SkCanvas::VertexMode fVmode; 501 int fVertexCount; 502 SkPoint* fVertices; 503 SkPoint* fTexs; 504 SkColor* fColors; 505 SkXfermode* fXfermode; 506 uint16_t* fIndices; 507 int fIndexCount; 508 SkPaint fPaint; 509 510 typedef SkDrawCommand INHERITED; 511}; 512 513class SkRotateCommand : public SkDrawCommand { 514public: 515 SkRotateCommand(SkScalar degrees); 516 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 517private: 518 SkScalar fDegrees; 519 520 typedef SkDrawCommand INHERITED; 521}; 522 523class SkSaveCommand : public SkDrawCommand { 524public: 525 SkSaveCommand(SkCanvas::SaveFlags flags); 526 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 527 virtual void trackSaveState(int* state) SK_OVERRIDE; 528 virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; } 529private: 530 SkCanvas::SaveFlags fFlags; 531 532 typedef SkDrawCommand INHERITED; 533}; 534 535class SkSaveLayerCommand : public SkDrawCommand { 536public: 537 SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, 538 SkCanvas::SaveFlags flags); 539 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 540 virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE; 541 virtual void trackSaveState(int* state) SK_OVERRIDE; 542 virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; } 543 virtual void setActive(bool active) SK_OVERRIDE { fActive = active; } 544 virtual bool active() const SK_OVERRIDE { return fActive; } 545 546 const SkPaint* paint() const { return fPaintPtr; } 547 548private: 549 SkRect fBounds; 550 SkPaint fPaint; 551 SkPaint* fPaintPtr; 552 SkCanvas::SaveFlags fFlags; 553 554 bool fActive; 555 556 typedef SkDrawCommand INHERITED; 557}; 558 559class SkScaleCommand : public SkDrawCommand { 560public: 561 SkScaleCommand(SkScalar sx, SkScalar sy); 562 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 563 564 SkScalar x() const { return fSx; } 565 SkScalar y() const { return fSy; } 566 567private: 568 SkScalar fSx; 569 SkScalar fSy; 570 571 typedef SkDrawCommand INHERITED; 572}; 573 574class SkSetMatrixCommand : public SkDrawCommand { 575public: 576 SkSetMatrixCommand(const SkMatrix& matrix); 577 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 578private: 579 SkMatrix fMatrix; 580 581 typedef SkDrawCommand INHERITED; 582}; 583 584class SkSkewCommand : public SkDrawCommand { 585public: 586 SkSkewCommand(SkScalar sx, SkScalar sy); 587 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 588private: 589 SkScalar fSx; 590 SkScalar fSy; 591 592 typedef SkDrawCommand INHERITED; 593}; 594 595class SkTranslateCommand : public SkDrawCommand { 596public: 597 SkTranslateCommand(SkScalar dx, SkScalar dy); 598 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 599 600 SkScalar x() const { return fDx; } 601 SkScalar y() const { return fDy; } 602 603private: 604 SkScalar fDx; 605 SkScalar fDy; 606 607 typedef SkDrawCommand INHERITED; 608}; 609 610class SkPushCullCommand : public SkDrawCommand { 611public: 612 SkPushCullCommand(const SkRect&); 613 virtual void execute(SkCanvas*) SK_OVERRIDE; 614 virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE; 615 virtual Action action() const { return kPushCull_Action; } 616 virtual void setActive(bool active) { fActive = active; } 617 virtual bool active() const { return fActive; } 618private: 619 SkRect fCullRect; 620 bool fActive; 621 622 typedef SkDrawCommand INHERITED; 623}; 624 625class SkPopCullCommand : public SkDrawCommand { 626public: 627 SkPopCullCommand(); 628 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 629 virtual Action action() const { return kPopCull_Action; } 630private: 631 typedef SkDrawCommand INHERITED; 632}; 633 634#endif 635