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