SkDrawCommand.h revision eed779d866e1e239bfb9ebc6a225b7345a41adf9
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; 319private: 320 SkPicture fPicture; 321 322 typedef SkDrawCommand INHERITED; 323}; 324 325class SkDrawPointsCommand : public SkDrawCommand { 326public: 327 SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[], 328 const SkPaint& paint); 329 virtual ~SkDrawPointsCommand() { delete [] fPts; } 330 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 331 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 332private: 333 SkCanvas::PointMode fMode; 334 size_t fCount; 335 SkPoint* fPts; 336 SkPaint fPaint; 337 338 typedef SkDrawCommand INHERITED; 339}; 340 341class SkDrawTextCommand : public SkDrawCommand { 342public: 343 SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y, 344 const SkPaint& paint); 345 virtual ~SkDrawTextCommand() { delete [] fText; } 346 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 347private: 348 char* fText; 349 size_t fByteLength; 350 SkScalar fX; 351 SkScalar fY; 352 SkPaint fPaint; 353 354 typedef SkDrawCommand INHERITED; 355}; 356 357class SkDrawPosTextCommand : public SkDrawCommand { 358public: 359 SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[], 360 const SkPaint& paint); 361 virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; } 362 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 363private: 364 char* fText; 365 size_t fByteLength; 366 SkPoint* fPos; 367 SkPaint fPaint; 368 369 typedef SkDrawCommand INHERITED; 370}; 371 372class SkDrawTextOnPathCommand : public SkDrawCommand { 373public: 374 SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& path, 375 const SkMatrix* matrix, const SkPaint& paint); 376 virtual ~SkDrawTextOnPathCommand() { delete [] fText; } 377 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 378private: 379 char* fText; 380 size_t fByteLength; 381 SkPath fPath; 382 SkMatrix fMatrix; 383 SkPaint fPaint; 384 385 typedef SkDrawCommand INHERITED; 386}; 387 388class SkDrawPosTextHCommand : public SkDrawCommand { 389public: 390 SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[], 391 SkScalar constY, const SkPaint& paint); 392 virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; } 393 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 394private: 395 SkScalar* fXpos; 396 char* fText; 397 size_t fByteLength; 398 SkScalar fConstY; 399 SkPaint fPaint; 400 401 typedef SkDrawCommand INHERITED; 402}; 403 404class SkDrawRectCommand : public SkDrawCommand { 405public: 406 SkDrawRectCommand(const SkRect& rect, const SkPaint& paint); 407 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 408 409 const SkRect& rect() const { return fRect; } 410 const SkPaint& paint() const { return fPaint; } 411private: 412 SkRect fRect; 413 SkPaint fPaint; 414 415 typedef SkDrawCommand INHERITED; 416}; 417 418class SkDrawRRectCommand : public SkDrawCommand { 419public: 420 SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint); 421 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 422 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 423private: 424 SkRRect fRRect; 425 SkPaint fPaint; 426 427 typedef SkDrawCommand INHERITED; 428}; 429 430class SkDrawSpriteCommand : public SkDrawCommand { 431public: 432 SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint); 433 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 434 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 435private: 436 SkBitmap fBitmap; 437 int fLeft; 438 int fTop; 439 SkPaint fPaint; 440 SkPaint* fPaintPtr; 441 442 typedef SkDrawCommand INHERITED; 443}; 444 445class SkDrawVerticesCommand : public SkDrawCommand { 446public: 447 SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, 448 const SkPoint vertices[], const SkPoint texs[], 449 const SkColor colors[], SkXfermode* xfermode, 450 const uint16_t indices[], int indexCount, 451 const SkPaint& paint); 452 virtual ~SkDrawVerticesCommand(); 453 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 454private: 455 SkCanvas::VertexMode fVmode; 456 int fVertexCount; 457 SkPoint* fVertices; 458 SkPoint* fTexs; 459 SkColor* fColors; 460 SkXfermode* fXfermode; 461 uint16_t* fIndices; 462 int fIndexCount; 463 SkPaint fPaint; 464 465 typedef SkDrawCommand INHERITED; 466}; 467 468class SkRotateCommand : public SkDrawCommand { 469public: 470 SkRotateCommand(SkScalar degrees); 471 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 472private: 473 SkScalar fDegrees; 474 475 typedef SkDrawCommand INHERITED; 476}; 477 478class SkSaveCommand : public SkDrawCommand { 479public: 480 SkSaveCommand(SkCanvas::SaveFlags flags); 481 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 482 virtual void trackSaveState(int* state) SK_OVERRIDE; 483private: 484 SkCanvas::SaveFlags fFlags; 485 486 typedef SkDrawCommand INHERITED; 487}; 488 489class SkSaveLayerCommand : public SkDrawCommand { 490public: 491 SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, 492 SkCanvas::SaveFlags flags); 493 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 494 virtual void trackSaveState(int* state) SK_OVERRIDE; 495 496 const SkPaint* paint() const { return fPaintPtr; } 497 498private: 499 SkRect fBounds; 500 SkPaint fPaint; 501 SkPaint* fPaintPtr; 502 SkCanvas::SaveFlags fFlags; 503 504 typedef SkDrawCommand INHERITED; 505}; 506 507class SkScaleCommand : public SkDrawCommand { 508public: 509 SkScaleCommand(SkScalar sx, SkScalar sy); 510 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 511 512 SkScalar x() const { return fSx; } 513 SkScalar y() const { return fSy; } 514 515private: 516 SkScalar fSx; 517 SkScalar fSy; 518 519 typedef SkDrawCommand INHERITED; 520}; 521 522class SkSetMatrixCommand : public SkDrawCommand { 523public: 524 SkSetMatrixCommand(const SkMatrix& matrix); 525 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 526private: 527 SkMatrix fMatrix; 528 529 typedef SkDrawCommand INHERITED; 530}; 531 532class SkSkewCommand : public SkDrawCommand { 533public: 534 SkSkewCommand(SkScalar sx, SkScalar sy); 535 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 536private: 537 SkScalar fSx; 538 SkScalar fSy; 539 540 typedef SkDrawCommand INHERITED; 541}; 542 543class SkTranslateCommand : public SkDrawCommand { 544public: 545 SkTranslateCommand(SkScalar dx, SkScalar dy); 546 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; 547 548 SkScalar x() const { return fDx; } 549 SkScalar y() const { return fDy; } 550 551private: 552 SkScalar fDx; 553 SkScalar fDy; 554 555 typedef SkDrawCommand INHERITED; 556}; 557 558#endif 559