debugger/SkDrawCommand.h - Issue 16638014: Expose debugger backend classes externally.

Side by Side Diff: debugger/SkDrawCommand.h

Issue 16638014: Expose debugger backend classes externally. (Closed) Base URL: https://skia.googlecode.com/svn/trunk

Patch Set: Relocated to src/utils/debugger/ Created 7 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
	(Empty)
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 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 Restore : public SkDrawCommand {

58 public:

59 Restore();

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 Clear : public SkDrawCommand {

68 public:

69 Clear(SkColor color);

70 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

71 private:

72 SkColor fColor;

73

74 typedef SkDrawCommand INHERITED;

75 };

76

77 class ClipPath : public SkDrawCommand {

78 public:

79 ClipPath(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 ClipRegion : public SkDrawCommand {

91 public:

92 ClipRegion(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 ClipRect : public SkDrawCommand {

102 public:

103 ClipRect(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 ClipRRect : public SkDrawCommand {

119 public:

120 ClipRRect(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 Concat : public SkDrawCommand {

137 public:

138 Concat(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 DrawBitmap : public SkDrawCommand {

147 public:

148 DrawBitmap(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 DrawBitmapMatrix : public SkDrawCommand {

163 public:

164 DrawBitmapMatrix(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 DrawBitmapNine : public SkDrawCommand {

178 public:

179 DrawBitmapNine(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 DrawBitmapRect : public SkDrawCommand {

194 public:

195 DrawBitmapRect(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 DrawData : public SkDrawCommand {

228 public:

229 DrawData(const void* data, size_t length);

230 virtual ~DrawData() { 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 BeginCommentGroup : public SkDrawCommand {

240 public:

241 BeginCommentGroup(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 Comment : public SkDrawCommand {

252 public:

253 Comment(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 EndCommentGroup : public SkDrawCommand {

265 public:

266 EndCommentGroup();

267 virtual void execute(SkCanvas* canvas) SK_OVERRIDE {

268 canvas->endCommentGroup();

269 };

270 private:

271 typedef SkDrawCommand INHERITED;

272 };

273

274 class DrawOval : public SkDrawCommand {

275 public:

276 DrawOval(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 DrawPaint : public SkDrawCommand {

287 public:

288 DrawPaint(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 DrawPath : public SkDrawCommand {

298 public:

299 DrawPath(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 DrawPicture : public SkDrawCommand {

311 public:

312 DrawPicture(SkPicture& picture);

313 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

314 private:

315 SkPicture fPicture;

316

317 typedef SkDrawCommand INHERITED;

318 };

319

320 class DrawPoints : public SkDrawCommand {

321 public:

322 DrawPoints(SkCanvas::PointMode mode, size_t count, const SkPoint pts[],

323 const SkPaint& paint);

324 virtual ~DrawPoints() { 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 /* TODO(chudy): DrawText is a predefined macro and was breaking something

337 * in the windows build of the debugger.

338 */

339 class DrawTextC : public SkDrawCommand {

340 public:

341 DrawTextC(const void* text, size_t byteLength, SkScalar x, SkScalar y,

342 const SkPaint& paint);

343 virtual ~DrawTextC() { delete [] fText; }

344 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

345 private:

346 char* fText;

347 size_t fByteLength;

348 SkScalar fX;

349 SkScalar fY;

350 SkPaint fPaint;

351

352 typedef SkDrawCommand INHERITED;

353 };

354

355 class DrawPosText : public SkDrawCommand {

356 public:

357 DrawPosText(const void* text, size_t byteLength, const SkPoint pos[],

358 const SkPaint& paint);

359 virtual ~DrawPosText() { delete [] fPos; delete [] fText; }

360 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

361 private:

362 char* fText;

363 size_t fByteLength;

364 SkPoint* fPos;

365 SkPaint fPaint;

366

367 typedef SkDrawCommand INHERITED;

368 };

369

370 class DrawTextOnPath : public SkDrawCommand {

371 public:

372 DrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,

373 const SkMatrix* matrix, const SkPaint& paint);

374 virtual ~DrawTextOnPath() { delete [] fText; }

375 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

376 private:

377 char* fText;

378 size_t fByteLength;

379 SkPath fPath;

380 SkMatrix fMatrix;

381 SkPaint fPaint;

382

383 typedef SkDrawCommand INHERITED;

384 };

385

386 class DrawPosTextH : public SkDrawCommand {

387 public:

388 DrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],

389 SkScalar constY, const SkPaint& paint);

390 virtual ~DrawPosTextH() { delete [] fXpos; delete [] fText; }

391 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

392 private:

393 SkScalar* fXpos;

394 char* fText;

395 size_t fByteLength;

396 SkScalar fConstY;

397 SkPaint fPaint;

398

399 typedef SkDrawCommand INHERITED;

400 };

401

402 class DrawRectC : public SkDrawCommand {

403 public:

404 DrawRectC(const SkRect& rect, const SkPaint& paint);

405 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

406

407 const SkRect& rect() const { return fRect; }

408 const SkPaint& paint() const { return fPaint; }

409 private:

410 SkRect fRect;

411 SkPaint fPaint;

412

413 typedef SkDrawCommand INHERITED;

414 };

415

416 class DrawRRect : public SkDrawCommand {

417 public:

418 DrawRRect(const SkRRect& rrect, const SkPaint& paint);

419 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

420 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

421 private:

422 SkRRect fRRect;

423 SkPaint fPaint;

424

425 typedef SkDrawCommand INHERITED;

426 };

427

428 class DrawSprite : public SkDrawCommand {

429 public:

430 DrawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint);

431 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

432 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

433 private:

434 SkBitmap fBitmap;

435 int fLeft;

436 int fTop;

437 SkPaint fPaint;

438 SkPaint* fPaintPtr;

439

440 typedef SkDrawCommand INHERITED;

441 };

442

443 class DrawVertices : public SkDrawCommand {

444 public:

445 DrawVertices(SkCanvas::VertexMode vmode, int vertexCount,

446 const SkPoint vertices[], const SkPoint texs[],

447 const SkColor colors[], SkXfermode* xfermode,

448 const uint16_t indices[], int indexCount,

449 const SkPaint& paint);

450 virtual ~DrawVertices();

451 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

452 private:

453 SkCanvas::VertexMode fVmode;

454 int fVertexCount;

455 SkPoint* fVertices;

456 SkPoint* fTexs;

457 SkColor* fColors;

458 SkXfermode* fXfermode;

459 uint16_t* fIndices;

460 int fIndexCount;

461 SkPaint fPaint;

462

463 typedef SkDrawCommand INHERITED;

464 };

465

466 class Rotate : public SkDrawCommand {

467 public:

468 Rotate(SkScalar degrees);

469 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

470 private:

471 SkScalar fDegrees;

472

473 typedef SkDrawCommand INHERITED;

474 };

475

476 class Save : public SkDrawCommand {

477 public:

478 Save(SkCanvas::SaveFlags flags);

479 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

480 virtual void trackSaveState(int* state) SK_OVERRIDE;

481 private:

482 SkCanvas::SaveFlags fFlags;

483

484 typedef SkDrawCommand INHERITED;

485 };

486

487 class SaveLayer : public SkDrawCommand {

488 public:

489 SaveLayer(const SkRect* bounds, const SkPaint* paint,

490 SkCanvas::SaveFlags flags);

491 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

492 virtual void trackSaveState(int* state) SK_OVERRIDE;

493

494 const SkPaint* paint() const { return fPaintPtr; }

495

496 private:

497 SkRect fBounds;

498 SkPaint fPaint;

499 SkPaint* fPaintPtr;

500 SkCanvas::SaveFlags fFlags;

501

502 typedef SkDrawCommand INHERITED;

503 };

504

505 class Scale : public SkDrawCommand {

506 public:

507 Scale(SkScalar sx, SkScalar sy);

508 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

509

510 SkScalar x() const { return fSx; }

511 SkScalar y() const { return fSy; }

512

513 private:

514 SkScalar fSx;

515 SkScalar fSy;

516

517 typedef SkDrawCommand INHERITED;

518 };

519

520 class SetMatrix : public SkDrawCommand {

521 public:

522 SetMatrix(const SkMatrix& matrix);

523 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

524 private:

525 SkMatrix fMatrix;

526

527 typedef SkDrawCommand INHERITED;

528 };

529

530 class Skew : public SkDrawCommand {

531 public:

532 Skew(SkScalar sx, SkScalar sy);

533 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

534 private:

535 SkScalar fSx;

536 SkScalar fSy;

537

538 typedef SkDrawCommand INHERITED;

539 };

540

541 class Translate : public SkDrawCommand {

542 public:

543 Translate(SkScalar dx, SkScalar dy);

544 virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

545

546 SkScalar x() const { return fDx; }

547 SkScalar y() const { return fDy; }

548

549 private:

550 SkScalar fDx;

551 SkScalar fDy;

552

553 typedef SkDrawCommand INHERITED;

554 };

555

556 #endif

OLD	NEW

« no previous file with comments | « debugger/SkDebugCanvas.cpp ('k') | debugger/SkDrawCommand.cpp » ('j') | no next file with comments »