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