SkDrawCommand.h revision 5a4c233a3657d12d836de388b41e30405b4ab976
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 "SkCanvas.h" 13#include "SkString.h" 14 15class SK_API SkDrawCommand { 16public: 17 enum OpType { 18 kBeginCommentGroup_OpType, 19 kClipPath_OpType, 20 kClipRegion_OpType, 21 kClipRect_OpType, 22 kClipRRect_OpType, 23 kComment_OpType, 24 kConcat_OpType, 25 kDrawBitmap_OpType, 26 kDrawBitmapNine_OpType, 27 kDrawBitmapRect_OpType, 28 kDrawClear_OpType, 29 kDrawDRRect_OpType, 30 kDrawOval_OpType, 31 kDrawPaint_OpType, 32 kDrawPatch_OpType, 33 kDrawPath_OpType, 34 kDrawPicture_OpType, 35 kDrawPoints_OpType, 36 kDrawPosText_OpType, 37 kDrawPosTextH_OpType, 38 kDrawRect_OpType, 39 kDrawRRect_OpType, 40 kDrawSprite_OpType, 41 kDrawText_OpType, 42 kDrawTextBlob_OpType, 43 kDrawTextOnPath_OpType, 44 kDrawVertices_OpType, 45 kEndCommentGroup_OpType, 46 kRestore_OpType, 47 kSave_OpType, 48 kSaveLayer_OpType, 49 kSetMatrix_OpType, 50 51 kLast_OpType = kSetMatrix_OpType 52 }; 53 54 static const int kOpTypeCount = kLast_OpType + 1; 55 56 SkDrawCommand(OpType opType); 57 58 virtual ~SkDrawCommand(); 59 60 virtual SkString toString() const; 61 62 void setOffset(size_t offset) { fOffset = offset; } 63 size_t offset() const { return fOffset; } 64 65 virtual const char* toCString() const { 66 return GetCommandString(fOpType); 67 } 68 69 bool isVisible() const { 70 return fVisible; 71 } 72 73 void setVisible(bool toggle) { 74 fVisible = toggle; 75 } 76 77 const SkTDArray<SkString*>* Info() const { return &fInfo; } 78 virtual void execute(SkCanvas*) const = 0; 79 virtual void vizExecute(SkCanvas*) const {} 80 81 virtual void setUserMatrix(const SkMatrix&) {} 82 83 // The next "active" system is only used by save, saveLayer, and restore. 84 // It is used to determine which saveLayers are currently active (at a 85 // given point in the rendering). 86 // saves just return a kPushLayer action but don't track active state 87 // restores just return a kPopLayer action 88 // saveLayers return kPushLayer but also track the active state 89 enum Action { 90 kNone_Action, 91 kPopLayer_Action, 92 kPushLayer_Action, 93 }; 94 virtual Action action() const { return kNone_Action; } 95 virtual void setActive(bool active) {} 96 virtual bool active() const { return false; } 97 98 OpType getType() const { return fOpType; } 99 100 virtual bool render(SkCanvas* canvas) const { return false; } 101 102 static const char* GetCommandString(OpType type); 103 104protected: 105 SkTDArray<SkString*> fInfo; 106 107private: 108 OpType fOpType; 109 size_t fOffset; 110 bool fVisible; 111}; 112 113class SkRestoreCommand : public SkDrawCommand { 114public: 115 SkRestoreCommand(); 116 void execute(SkCanvas* canvas) const SK_OVERRIDE; 117 Action action() const SK_OVERRIDE { return kPopLayer_Action; } 118 119private: 120 typedef SkDrawCommand INHERITED; 121}; 122 123class SkClearCommand : public SkDrawCommand { 124public: 125 SkClearCommand(SkColor color); 126 void execute(SkCanvas* canvas) const SK_OVERRIDE; 127private: 128 SkColor fColor; 129 130 typedef SkDrawCommand INHERITED; 131}; 132 133class SkClipPathCommand : public SkDrawCommand { 134public: 135 SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA); 136 void execute(SkCanvas* canvas) const SK_OVERRIDE; 137 bool render(SkCanvas* canvas) const SK_OVERRIDE; 138private: 139 SkPath fPath; 140 SkRegion::Op fOp; 141 bool fDoAA; 142 143 typedef SkDrawCommand INHERITED; 144}; 145 146class SkClipRegionCommand : public SkDrawCommand { 147public: 148 SkClipRegionCommand(const SkRegion& region, SkRegion::Op op); 149 void execute(SkCanvas* canvas) const SK_OVERRIDE; 150private: 151 SkRegion fRegion; 152 SkRegion::Op fOp; 153 154 typedef SkDrawCommand INHERITED; 155}; 156 157class SkClipRectCommand : public SkDrawCommand { 158public: 159 SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA); 160 void execute(SkCanvas* canvas) const SK_OVERRIDE; 161 162 const SkRect& rect() const { return fRect; } 163 SkRegion::Op op() const { return fOp; } 164 bool doAA() const { return fDoAA; } 165 166private: 167 SkRect fRect; 168 SkRegion::Op fOp; 169 bool fDoAA; 170 171 typedef SkDrawCommand INHERITED; 172}; 173 174class SkClipRRectCommand : public SkDrawCommand { 175public: 176 SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA); 177 void execute(SkCanvas* canvas) const SK_OVERRIDE; 178 bool render(SkCanvas* canvas) const SK_OVERRIDE; 179 180 const SkRRect& rrect() const { return fRRect; } 181 SkRegion::Op op() const { return fOp; } 182 bool doAA() const { return fDoAA; } 183 184private: 185 SkRRect fRRect; 186 SkRegion::Op fOp; 187 bool fDoAA; 188 189 typedef SkDrawCommand INHERITED; 190}; 191 192class SkConcatCommand : public SkDrawCommand { 193public: 194 SkConcatCommand(const SkMatrix& matrix); 195 void execute(SkCanvas* canvas) const SK_OVERRIDE; 196private: 197 SkMatrix fMatrix; 198 199 typedef SkDrawCommand INHERITED; 200}; 201 202class SkDrawBitmapCommand : public SkDrawCommand { 203public: 204 SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, 205 const SkPaint* paint); 206 void execute(SkCanvas* canvas) const SK_OVERRIDE; 207 bool render(SkCanvas* canvas) const SK_OVERRIDE; 208private: 209 SkBitmap fBitmap; 210 SkScalar fLeft; 211 SkScalar fTop; 212 SkPaint fPaint; 213 SkPaint* fPaintPtr; 214 215 typedef SkDrawCommand INHERITED; 216}; 217 218class SkDrawBitmapNineCommand : public SkDrawCommand { 219public: 220 SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center, 221 const SkRect& dst, const SkPaint* paint); 222 void execute(SkCanvas* canvas) const SK_OVERRIDE; 223 bool render(SkCanvas* canvas) const SK_OVERRIDE; 224private: 225 SkBitmap fBitmap; 226 SkIRect fCenter; 227 SkRect fDst; 228 SkPaint fPaint; 229 SkPaint* fPaintPtr; 230 231 typedef SkDrawCommand INHERITED; 232}; 233 234class SkDrawBitmapRectCommand : public SkDrawCommand { 235public: 236 SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src, 237 const SkRect& dst, const SkPaint* paint, 238 SkCanvas::DrawBitmapRectFlags flags); 239 void execute(SkCanvas* canvas) const SK_OVERRIDE; 240 bool render(SkCanvas* canvas) const SK_OVERRIDE; 241 242 const SkBitmap& bitmap() const { return fBitmap; } 243 244 // The non-const 'paint' method allows modification of this object's 245 // SkPaint. For this reason the ctor and setPaint method make a local copy. 246 // The 'fPaintPtr' member acts a signal that the local SkPaint is valid 247 // (since only an SkPaint* is passed into the ctor). 248 const SkPaint* paint() const { return fPaintPtr; } 249 SkPaint* paint() { return fPaintPtr; } 250 251 void setPaint(const SkPaint& paint) { fPaint = paint; fPaintPtr = &fPaint; } 252 253 const SkRect* srcRect() const { return fSrc.isEmpty() ? NULL : &fSrc; } 254 void setSrcRect(const SkRect& src) { fSrc = src; } 255 256 const SkRect& dstRect() const { return fDst; } 257 void setDstRect(const SkRect& dst) { fDst = dst; } 258 259 SkCanvas::DrawBitmapRectFlags flags() const { return fFlags; } 260 void setFlags(SkCanvas::DrawBitmapRectFlags flags) { fFlags = flags; } 261 262private: 263 SkBitmap fBitmap; 264 SkRect fSrc; 265 SkRect fDst; 266 SkPaint fPaint; 267 SkPaint* fPaintPtr; 268 SkCanvas::DrawBitmapRectFlags fFlags; 269 270 typedef SkDrawCommand INHERITED; 271}; 272 273class SkBeginCommentGroupCommand : public SkDrawCommand { 274public: 275 SkBeginCommentGroupCommand(const char* description); 276 void execute(SkCanvas* canvas) const 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 void execute(SkCanvas* canvas) const 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 void execute(SkCanvas* canvas) const 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 void execute(SkCanvas* canvas) const SK_OVERRIDE; 312 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 void execute(SkCanvas* canvas) const SK_OVERRIDE; 324 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 void execute(SkCanvas* canvas) const SK_OVERRIDE; 335 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 void execute(SkCanvas* canvas) const SK_OVERRIDE; 348 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 void execute(SkCanvas* canvas) const SK_OVERRIDE; 366 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 void execute(SkCanvas* canvas) const 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 void execute(SkCanvas* canvas) const 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 void execute(SkCanvas* canvas) const 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 void execute(SkCanvas* canvas) const 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 void execute(SkCanvas* canvas) const SK_OVERRIDE; 444 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 SkDrawPatchCommand : public SkDrawCommand { 456public: 457 SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4], 458 const SkPoint texCoords[4], SkXfermode* xmode, 459 const SkPaint& paint); 460 void execute(SkCanvas* canvas) const SK_OVERRIDE; 461 462private: 463 SkPoint fCubics[12]; 464 SkColor fColors[4]; 465 SkPoint fTexCoords[4]; 466 SkAutoTUnref<SkXfermode> fXfermode; 467 SkPaint fPaint; 468 469 typedef SkDrawCommand INHERITED; 470}; 471 472 473class SkDrawRectCommand : public SkDrawCommand { 474public: 475 SkDrawRectCommand(const SkRect& rect, const SkPaint& paint); 476 void execute(SkCanvas* canvas) const SK_OVERRIDE; 477 478 const SkRect& rect() const { return fRect; } 479 const SkPaint& paint() const { return fPaint; } 480private: 481 SkRect fRect; 482 SkPaint fPaint; 483 484 typedef SkDrawCommand INHERITED; 485}; 486 487class SkDrawRRectCommand : public SkDrawCommand { 488public: 489 SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint); 490 void execute(SkCanvas* canvas) const SK_OVERRIDE; 491 bool render(SkCanvas* canvas) const SK_OVERRIDE; 492private: 493 SkRRect fRRect; 494 SkPaint fPaint; 495 496 typedef SkDrawCommand INHERITED; 497}; 498 499class SkDrawDRRectCommand : public SkDrawCommand { 500public: 501 SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner, 502 const SkPaint& paint); 503 void execute(SkCanvas* canvas) const SK_OVERRIDE; 504 bool render(SkCanvas* canvas) const SK_OVERRIDE; 505private: 506 SkRRect fOuter; 507 SkRRect fInner; 508 SkPaint fPaint; 509 510 typedef SkDrawCommand INHERITED; 511}; 512 513class SkDrawSpriteCommand : public SkDrawCommand { 514public: 515 SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint); 516 void execute(SkCanvas* canvas) const SK_OVERRIDE; 517 bool render(SkCanvas* canvas) const SK_OVERRIDE; 518private: 519 SkBitmap fBitmap; 520 int fLeft; 521 int fTop; 522 SkPaint fPaint; 523 SkPaint* fPaintPtr; 524 525 typedef SkDrawCommand INHERITED; 526}; 527 528class SkDrawVerticesCommand : public SkDrawCommand { 529public: 530 SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, 531 const SkPoint vertices[], const SkPoint texs[], 532 const SkColor colors[], SkXfermode* xfermode, 533 const uint16_t indices[], int indexCount, 534 const SkPaint& paint); 535 virtual ~SkDrawVerticesCommand(); 536 void execute(SkCanvas* canvas) const SK_OVERRIDE; 537private: 538 SkCanvas::VertexMode fVmode; 539 int fVertexCount; 540 SkPoint* fVertices; 541 SkPoint* fTexs; 542 SkColor* fColors; 543 SkXfermode* fXfermode; 544 uint16_t* fIndices; 545 int fIndexCount; 546 SkPaint fPaint; 547 548 typedef SkDrawCommand INHERITED; 549}; 550 551class SkSaveCommand : public SkDrawCommand { 552public: 553 SkSaveCommand(); 554 void execute(SkCanvas* canvas) const SK_OVERRIDE; 555 Action action() const SK_OVERRIDE { return kPushLayer_Action; } 556private: 557 typedef SkDrawCommand INHERITED; 558}; 559 560class SkSaveLayerCommand : public SkDrawCommand { 561public: 562 SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, 563 SkCanvas::SaveFlags flags); 564 void execute(SkCanvas* canvas) const SK_OVERRIDE; 565 void vizExecute(SkCanvas* canvas) const SK_OVERRIDE; 566 Action action() const SK_OVERRIDE{ return kPushLayer_Action; } 567 void setActive(bool active) SK_OVERRIDE { fActive = active; } 568 bool active() const SK_OVERRIDE { return fActive; } 569 570 const SkPaint* paint() const { return fPaintPtr; } 571 572private: 573 SkRect fBounds; 574 SkPaint fPaint; 575 SkPaint* fPaintPtr; 576 SkCanvas::SaveFlags fFlags; 577 578 bool fActive; 579 580 typedef SkDrawCommand INHERITED; 581}; 582 583class SkSetMatrixCommand : public SkDrawCommand { 584public: 585 SkSetMatrixCommand(const SkMatrix& matrix); 586 void setUserMatrix(const SkMatrix&) SK_OVERRIDE; 587 void execute(SkCanvas* canvas) const SK_OVERRIDE; 588private: 589 SkMatrix fUserMatrix; 590 SkMatrix fMatrix; 591 592 typedef SkDrawCommand INHERITED; 593}; 594 595#endif 596