De-virtualize SkCanvas matrix ops.
This moves the matrix management logic into non-virtual SkCanvas
methods, and turns the virtuals into protected notifiers.
R=reed@google.com, robertphillips@google.com, bsalomon@google.com
BUG=skia:2297
Author: fmalita@chromium.org
Review URL: https://codereview.chromium.org/195793012
git-svn-id: http://skia.googlecode.com/svn/trunk@13799 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/core/SkBBoxHierarchyRecord.cpp b/src/core/SkBBoxHierarchyRecord.cpp
index e1be2e1..eadd206 100644
--- a/src/core/SkBBoxHierarchyRecord.cpp
+++ b/src/core/SkBBoxHierarchyRecord.cpp
@@ -43,39 +43,34 @@
this->INHERITED::willRestore();
}
-bool SkBBoxHierarchyRecord::translate(SkScalar dx, SkScalar dy) {
- bool result = INHERITED::translate(dx, dy);
+void SkBBoxHierarchyRecord::didTranslate(SkScalar dx, SkScalar dy) {
fStateTree->appendTransform(getTotalMatrix());
- return result;
+ INHERITED::didTranslate(dx, dy);
}
-bool SkBBoxHierarchyRecord::scale(SkScalar sx, SkScalar sy) {
- bool result = INHERITED::scale(sx, sy);
+void SkBBoxHierarchyRecord::didScale(SkScalar sx, SkScalar sy) {
fStateTree->appendTransform(getTotalMatrix());
- return result;
+ INHERITED::didScale(sx, sy);
}
-bool SkBBoxHierarchyRecord::rotate(SkScalar degrees) {
- bool result = INHERITED::rotate(degrees);
+void SkBBoxHierarchyRecord::didRotate(SkScalar degrees) {
fStateTree->appendTransform(getTotalMatrix());
- return result;
+ INHERITED::didRotate(degrees);
}
-bool SkBBoxHierarchyRecord::skew(SkScalar sx, SkScalar sy) {
- bool result = INHERITED::skew(sx, sy);
+void SkBBoxHierarchyRecord::didSkew(SkScalar sx, SkScalar sy) {
fStateTree->appendTransform(getTotalMatrix());
- return result;
+ INHERITED::didSkew(sx, sy);
}
-bool SkBBoxHierarchyRecord::concat(const SkMatrix& matrix) {
- bool result = INHERITED::concat(matrix);
+void SkBBoxHierarchyRecord::didConcat(const SkMatrix& matrix) {
fStateTree->appendTransform(getTotalMatrix());
- return result;
+ INHERITED::didConcat(matrix);
}
-void SkBBoxHierarchyRecord::setMatrix(const SkMatrix& matrix) {
- INHERITED::setMatrix(matrix);
+void SkBBoxHierarchyRecord::didSetMatrix(const SkMatrix& matrix) {
fStateTree->appendTransform(getTotalMatrix());
+ INHERITED::didSetMatrix(matrix);
}
void SkBBoxHierarchyRecord::onClipRect(const SkRect& rect,
diff --git a/src/core/SkBBoxHierarchyRecord.h b/src/core/SkBBoxHierarchyRecord.h
index fdfc9f7..08de7db 100644
--- a/src/core/SkBBoxHierarchyRecord.h
+++ b/src/core/SkBBoxHierarchyRecord.h
@@ -23,13 +23,6 @@
virtual void handleBBox(const SkRect& bounds) SK_OVERRIDE;
- virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
- virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
- virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
- virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE;
- virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE;
- virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
-
// Implementation of the SkBBoxHierarchyClient interface
virtual bool shouldRewind(void* data) SK_OVERRIDE;
@@ -38,6 +31,13 @@
virtual SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
virtual void willRestore() SK_OVERRIDE;
+ virtual void didTranslate(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didScale(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didRotate(SkScalar) SK_OVERRIDE;
+ virtual void didSkew(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didConcat(const SkMatrix&) SK_OVERRIDE;
+ virtual void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+
virtual void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
virtual void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
virtual void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 6f33280..1443f5e 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -1216,45 +1216,82 @@
}
/////////////////////////////////////////////////////////////////////////////
+void SkCanvas::didTranslate(SkScalar, SkScalar) {
+ // Do nothing. Subclasses may do something.
+}
bool SkCanvas::translate(SkScalar dx, SkScalar dy) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- return fMCRec->fMatrix->preTranslate(dx, dy);
+ bool res = fMCRec->fMatrix->preTranslate(dx, dy);
+
+ this->didTranslate(dx, dy);
+ return res;
+}
+
+void SkCanvas::didScale(SkScalar, SkScalar) {
+ // Do nothing. Subclasses may do something.
}
bool SkCanvas::scale(SkScalar sx, SkScalar sy) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- return fMCRec->fMatrix->preScale(sx, sy);
+ bool res = fMCRec->fMatrix->preScale(sx, sy);
+
+ this->didScale(sx, sy);
+ return res;
+}
+
+void SkCanvas::didRotate(SkScalar) {
+ // Do nothing. Subclasses may do something.
}
bool SkCanvas::rotate(SkScalar degrees) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- return fMCRec->fMatrix->preRotate(degrees);
+ bool res = fMCRec->fMatrix->preRotate(degrees);
+
+ this->didRotate(degrees);
+ return res;
+}
+
+void SkCanvas::didSkew(SkScalar, SkScalar) {
+ // Do nothing. Subclasses may do something.
}
bool SkCanvas::skew(SkScalar sx, SkScalar sy) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- return fMCRec->fMatrix->preSkew(sx, sy);
+ bool res = fMCRec->fMatrix->preSkew(sx, sy);
+
+ this->didSkew(sx, sy);
+ return res;
+}
+
+void SkCanvas::didConcat(const SkMatrix&) {
+ // Do nothing. Subclasses may do something.
}
bool SkCanvas::concat(const SkMatrix& matrix) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- return fMCRec->fMatrix->preConcat(matrix);
+ bool res = fMCRec->fMatrix->preConcat(matrix);
+
+ this->didConcat(matrix);
+ return res;
+}
+
+void SkCanvas::didSetMatrix(const SkMatrix&) {
+ // Do nothing. Subclasses may do something.
}
void SkCanvas::setMatrix(const SkMatrix& matrix) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
*fMCRec->fMatrix = matrix;
+ this->didSetMatrix(matrix);
}
-// this is not virtual, so it must call a virtual method so that subclasses
-// will see its action
void SkCanvas::resetMatrix() {
SkMatrix matrix;
diff --git a/src/core/SkPictureRecord.cpp b/src/core/SkPictureRecord.cpp
index a85ea8d..55670ba 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -664,7 +664,7 @@
this->validate(initialOffset, size);
}
-bool SkPictureRecord::translate(SkScalar dx, SkScalar dy) {
+void SkPictureRecord::didTranslate(SkScalar dx, SkScalar dy) {
#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
fMCMgr.translate(dx, dy);
#else
@@ -675,10 +675,10 @@
this->addScalar(dy);
this->validate(initialOffset, size);
#endif
- return this->INHERITED::translate(dx, dy);
+ this->INHERITED::didTranslate(dx, dy);
}
-bool SkPictureRecord::scale(SkScalar sx, SkScalar sy) {
+void SkPictureRecord::didScale(SkScalar sx, SkScalar sy) {
#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
fMCMgr.scale(sx, sy);
@@ -690,10 +690,10 @@
this->addScalar(sy);
this->validate(initialOffset, size);
#endif
- return this->INHERITED::scale(sx, sy);
+ this->INHERITED::didScale(sx, sy);
}
-bool SkPictureRecord::rotate(SkScalar degrees) {
+void SkPictureRecord::didRotate(SkScalar degrees) {
#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
fMCMgr.rotate(degrees);
@@ -704,10 +704,10 @@
this->addScalar(degrees);
this->validate(initialOffset, size);
#endif
- return this->INHERITED::rotate(degrees);
+ this->INHERITED::didRotate(degrees);
}
-bool SkPictureRecord::skew(SkScalar sx, SkScalar sy) {
+void SkPictureRecord::didSkew(SkScalar sx, SkScalar sy) {
#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
fMCMgr.skew(sx, sy);
@@ -719,17 +719,17 @@
this->addScalar(sy);
this->validate(initialOffset, size);
#endif
- return this->INHERITED::skew(sx, sy);
+ this->INHERITED::didSkew(sx, sy);
}
-bool SkPictureRecord::concat(const SkMatrix& matrix) {
+void SkPictureRecord::didConcat(const SkMatrix& matrix) {
#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
fMCMgr.concat(matrix);
#else
this->recordConcat(matrix);
#endif
- return this->INHERITED::concat(matrix);
+ this->INHERITED::didConcat(matrix);
}
void SkPictureRecord::recordConcat(const SkMatrix& matrix) {
@@ -741,7 +741,7 @@
this->validate(initialOffset, size);
}
-void SkPictureRecord::setMatrix(const SkMatrix& matrix) {
+void SkPictureRecord::didSetMatrix(const SkMatrix& matrix) {
#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
fMCMgr.setMatrix(matrix);
@@ -753,7 +753,7 @@
this->addMatrix(matrix);
this->validate(initialOffset, size);
#endif
- this->INHERITED::setMatrix(matrix);
+ this->INHERITED::didSetMatrix(matrix);
}
static bool regionOpExpands(SkRegion::Op op) {
diff --git a/src/core/SkPictureRecord.h b/src/core/SkPictureRecord.h
index d1d6362..c0b0eb1 100644
--- a/src/core/SkPictureRecord.h
+++ b/src/core/SkPictureRecord.h
@@ -37,12 +37,6 @@
SkPictureRecord(const SkISize& dimensions, uint32_t recordFlags);
virtual ~SkPictureRecord();
- virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
- virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
- virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
- virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE;
- virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE;
- virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
virtual void clear(SkColor) SK_OVERRIDE;
virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(PointMode, size_t count, const SkPoint pts[],
@@ -229,6 +223,13 @@
virtual SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
virtual void willRestore() SK_OVERRIDE;
+ virtual void didTranslate(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didScale(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didRotate(SkScalar) SK_OVERRIDE;
+ virtual void didSkew(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didConcat(const SkMatrix&) SK_OVERRIDE;
+ virtual void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+
virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
virtual void onPushCull(const SkRect&) SK_OVERRIDE;
virtual void onPopCull() SK_OVERRIDE;
diff --git a/src/pipe/SkGPipeWrite.cpp b/src/pipe/SkGPipeWrite.cpp
index 7f2f1a1..6377785 100644
--- a/src/pipe/SkGPipeWrite.cpp
+++ b/src/pipe/SkGPipeWrite.cpp
@@ -230,12 +230,6 @@
// overrides from SkCanvas
virtual bool isDrawingToLayer() const SK_OVERRIDE;
- virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
- virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
- virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
- virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE;
- virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE;
- virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
virtual void clear(SkColor) SK_OVERRIDE;
virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(PointMode, size_t count, const SkPoint pts[],
@@ -287,6 +281,13 @@
virtual SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
virtual void willRestore() SK_OVERRIDE;
+ virtual void didTranslate(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didScale(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didRotate(SkScalar) SK_OVERRIDE;
+ virtual void didSkew(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didConcat(const SkMatrix&) SK_OVERRIDE;
+ virtual void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+
virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
virtual void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
@@ -571,7 +572,7 @@
return kNoSaveLayer != fFirstSaveLayerStackLevel;
}
-bool SkGPipeCanvas::translate(SkScalar dx, SkScalar dy) {
+void SkGPipeCanvas::didTranslate(SkScalar dx, SkScalar dy) {
if (dx || dy) {
NOTIFY_SETUP(this);
if (this->needOpBytes(2 * sizeof(SkScalar))) {
@@ -580,10 +581,10 @@
fWriter.writeScalar(dy);
}
}
- return this->INHERITED::translate(dx, dy);
+ this->INHERITED::didTranslate(dx, dy);
}
-bool SkGPipeCanvas::scale(SkScalar sx, SkScalar sy) {
+void SkGPipeCanvas::didScale(SkScalar sx, SkScalar sy) {
if (sx || sy) {
NOTIFY_SETUP(this);
if (this->needOpBytes(2 * sizeof(SkScalar))) {
@@ -592,10 +593,10 @@
fWriter.writeScalar(sy);
}
}
- return this->INHERITED::scale(sx, sy);
+ this->INHERITED::didScale(sx, sy);
}
-bool SkGPipeCanvas::rotate(SkScalar degrees) {
+void SkGPipeCanvas::didRotate(SkScalar degrees) {
if (degrees) {
NOTIFY_SETUP(this);
if (this->needOpBytes(sizeof(SkScalar))) {
@@ -603,10 +604,10 @@
fWriter.writeScalar(degrees);
}
}
- return this->INHERITED::rotate(degrees);
+ this->INHERITED::didRotate(degrees);
}
-bool SkGPipeCanvas::skew(SkScalar sx, SkScalar sy) {
+void SkGPipeCanvas::didSkew(SkScalar sx, SkScalar sy) {
if (sx || sy) {
NOTIFY_SETUP(this);
if (this->needOpBytes(2 * sizeof(SkScalar))) {
@@ -615,10 +616,10 @@
fWriter.writeScalar(sy);
}
}
- return this->INHERITED::skew(sx, sy);
+ this->INHERITED::didSkew(sx, sy);
}
-bool SkGPipeCanvas::concat(const SkMatrix& matrix) {
+void SkGPipeCanvas::didConcat(const SkMatrix& matrix) {
if (!matrix.isIdentity()) {
NOTIFY_SETUP(this);
if (this->needOpBytes(matrix.writeToMemory(NULL))) {
@@ -626,16 +627,16 @@
fWriter.writeMatrix(matrix);
}
}
- return this->INHERITED::concat(matrix);
+ this->INHERITED::didConcat(matrix);
}
-void SkGPipeCanvas::setMatrix(const SkMatrix& matrix) {
+void SkGPipeCanvas::didSetMatrix(const SkMatrix& matrix) {
NOTIFY_SETUP(this);
if (this->needOpBytes(matrix.writeToMemory(NULL))) {
this->writeOp(kSetMatrix_DrawOp);
fWriter.writeMatrix(matrix);
}
- this->INHERITED::setMatrix(matrix);
+ this->INHERITED::didSetMatrix(matrix);
}
void SkGPipeCanvas::onClipRect(const SkRect& rect, SkRegion::Op rgnOp,
diff --git a/src/utils/SkCanvasStack.cpp b/src/utils/SkCanvasStack.cpp
index d85f34b..87e8f65 100644
--- a/src/utils/SkCanvasStack.cpp
+++ b/src/utils/SkCanvasStack.cpp
@@ -65,7 +65,7 @@
* canvas unlike all other matrix operations (i.e. translate, scale, etc) which
* just pre-concatenate with the existing matrix.
*/
-void SkCanvasStack::setMatrix(const SkMatrix& matrix) {
+void SkCanvasStack::didSetMatrix(const SkMatrix& matrix) {
SkASSERT(fList.count() == fCanvasData.count());
for (int i = 0; i < fList.count(); ++i) {
@@ -74,7 +74,7 @@
SkIntToScalar(-fCanvasData[i].origin.y()));
fList[i]->setMatrix(tempMatrix);
}
- this->SkCanvas::setMatrix(matrix);
+ this->SkCanvas::didSetMatrix(matrix);
}
void SkCanvasStack::onClipRect(const SkRect& r, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
diff --git a/src/utils/SkCanvasStack.h b/src/utils/SkCanvasStack.h
index ba2fed4..028e526 100644
--- a/src/utils/SkCanvasStack.h
+++ b/src/utils/SkCanvasStack.h
@@ -29,9 +29,9 @@
virtual void addCanvas(SkCanvas*) SK_OVERRIDE { SkDEBUGFAIL("Invalid Op"); }
virtual void removeCanvas(SkCanvas*) SK_OVERRIDE { SkDEBUGFAIL("Invalid Op"); }
- virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
-
protected:
+ virtual void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+
virtual void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
virtual void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
virtual void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index 07bd6ac..cc7011e 100644
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -759,45 +759,40 @@
return this->drawingCanvas()->isDrawingToLayer();
}
-bool SkDeferredCanvas::translate(SkScalar dx, SkScalar dy) {
+void SkDeferredCanvas::didTranslate(SkScalar dx, SkScalar dy) {
this->drawingCanvas()->translate(dx, dy);
- bool val = this->INHERITED::translate(dx, dy);
this->recordedDrawCommand();
- return val;
+ this->INHERITED::didTranslate(dx, dy);
}
-bool SkDeferredCanvas::scale(SkScalar sx, SkScalar sy) {
+void SkDeferredCanvas::didScale(SkScalar sx, SkScalar sy) {
this->drawingCanvas()->scale(sx, sy);
- bool val = this->INHERITED::scale(sx, sy);
this->recordedDrawCommand();
- return val;
+ this->INHERITED::didScale(sx, sy);
}
-bool SkDeferredCanvas::rotate(SkScalar degrees) {
+void SkDeferredCanvas::didRotate(SkScalar degrees) {
this->drawingCanvas()->rotate(degrees);
- bool val = this->INHERITED::rotate(degrees);
this->recordedDrawCommand();
- return val;
+ this->INHERITED::didRotate(degrees);
}
-bool SkDeferredCanvas::skew(SkScalar sx, SkScalar sy) {
+void SkDeferredCanvas::didSkew(SkScalar sx, SkScalar sy) {
this->drawingCanvas()->skew(sx, sy);
- bool val = this->INHERITED::skew(sx, sy);
this->recordedDrawCommand();
- return val;
+ this->INHERITED::didSkew(sx, sy);
}
-bool SkDeferredCanvas::concat(const SkMatrix& matrix) {
+void SkDeferredCanvas::didConcat(const SkMatrix& matrix) {
this->drawingCanvas()->concat(matrix);
- bool val = this->INHERITED::concat(matrix);
this->recordedDrawCommand();
- return val;
+ this->INHERITED::didConcat(matrix);
}
-void SkDeferredCanvas::setMatrix(const SkMatrix& matrix) {
+void SkDeferredCanvas::didSetMatrix(const SkMatrix& matrix) {
this->drawingCanvas()->setMatrix(matrix);
- this->INHERITED::setMatrix(matrix);
this->recordedDrawCommand();
+ this->INHERITED::didSetMatrix(matrix);
}
void SkDeferredCanvas::onClipRect(const SkRect& rect,
diff --git a/src/utils/SkDumpCanvas.cpp b/src/utils/SkDumpCanvas.cpp
index af59cd6..7445940 100644
--- a/src/utils/SkDumpCanvas.cpp
+++ b/src/utils/SkDumpCanvas.cpp
@@ -222,41 +222,41 @@
this->INHERITED::willRestore();
}
-bool SkDumpCanvas::translate(SkScalar dx, SkScalar dy) {
+void SkDumpCanvas::didTranslate(SkScalar dx, SkScalar dy) {
this->dump(kMatrix_Verb, NULL, "translate(%g %g)",
SkScalarToFloat(dx), SkScalarToFloat(dy));
- return this->INHERITED::translate(dx, dy);
+ this->INHERITED::didTranslate(dx, dy);
}
-bool SkDumpCanvas::scale(SkScalar sx, SkScalar sy) {
+void SkDumpCanvas::didScale(SkScalar sx, SkScalar sy) {
this->dump(kMatrix_Verb, NULL, "scale(%g %g)",
SkScalarToFloat(sx), SkScalarToFloat(sy));
- return this->INHERITED::scale(sx, sy);
+ this->INHERITED::didScale(sx, sy);
}
-bool SkDumpCanvas::rotate(SkScalar degrees) {
+void SkDumpCanvas::didRotate(SkScalar degrees) {
this->dump(kMatrix_Verb, NULL, "rotate(%g)", SkScalarToFloat(degrees));
- return this->INHERITED::rotate(degrees);
+ this->INHERITED::didRotate(degrees);
}
-bool SkDumpCanvas::skew(SkScalar sx, SkScalar sy) {
+void SkDumpCanvas::didSkew(SkScalar sx, SkScalar sy) {
this->dump(kMatrix_Verb, NULL, "skew(%g %g)",
SkScalarToFloat(sx), SkScalarToFloat(sy));
- return this->INHERITED::skew(sx, sy);
+ this->INHERITED::didSkew(sx, sy);
}
-bool SkDumpCanvas::concat(const SkMatrix& matrix) {
+void SkDumpCanvas::didConcat(const SkMatrix& matrix) {
SkString str;
matrix.toString(&str);
this->dump(kMatrix_Verb, NULL, "concat(%s)", str.c_str());
- return this->INHERITED::concat(matrix);
+ this->INHERITED::didConcat(matrix);
}
-void SkDumpCanvas::setMatrix(const SkMatrix& matrix) {
+void SkDumpCanvas::didSetMatrix(const SkMatrix& matrix) {
SkString str;
matrix.toString(&str);
this->dump(kMatrix_Verb, NULL, "setMatrix(%s)", str.c_str());
- this->INHERITED::setMatrix(matrix);
+ this->INHERITED::didSetMatrix(matrix);
}
///////////////////////////////////////////////////////////////////////////////
diff --git a/src/utils/SkLuaCanvas.cpp b/src/utils/SkLuaCanvas.cpp
index 2c8b9fa..9289bee 100644
--- a/src/utils/SkLuaCanvas.cpp
+++ b/src/utils/SkLuaCanvas.cpp
@@ -106,40 +106,40 @@
this->INHERITED::willRestore();
}
-bool SkLuaCanvas::translate(SkScalar dx, SkScalar dy) {
+void SkLuaCanvas::didTranslate(SkScalar dx, SkScalar dy) {
AUTO_LUA("translate");
lua.pushScalar(dx, "dx");
lua.pushScalar(dy, "dy");
- return this->INHERITED::translate(dx, dy);
+ this->INHERITED::didTranslate(dx, dy);
}
-bool SkLuaCanvas::scale(SkScalar sx, SkScalar sy) {
+void SkLuaCanvas::didScale(SkScalar sx, SkScalar sy) {
AUTO_LUA("scale");
lua.pushScalar(sx, "sx");
lua.pushScalar(sy, "sy");
- return this->INHERITED::scale(sx, sy);
+ this->INHERITED::didScale(sx, sy);
}
-bool SkLuaCanvas::rotate(SkScalar degrees) {
+void SkLuaCanvas::didRotate(SkScalar degrees) {
AUTO_LUA("rotate");
lua.pushScalar(degrees, "degrees");
- return this->INHERITED::rotate(degrees);
+ this->INHERITED::didRotate(degrees);
}
-bool SkLuaCanvas::skew(SkScalar kx, SkScalar ky) {
+void SkLuaCanvas::didSkew(SkScalar kx, SkScalar ky) {
AUTO_LUA("skew");
lua.pushScalar(kx, "kx");
lua.pushScalar(ky, "ky");
- return this->INHERITED::skew(kx, ky);
+ this->INHERITED::didSkew(kx, ky);
}
-bool SkLuaCanvas::concat(const SkMatrix& matrix) {
+void SkLuaCanvas::didConcat(const SkMatrix& matrix) {
AUTO_LUA("concat");
- return this->INHERITED::concat(matrix);
+ this->INHERITED::didConcat(matrix);
}
-void SkLuaCanvas::setMatrix(const SkMatrix& matrix) {
- this->INHERITED::setMatrix(matrix);
+void SkLuaCanvas::didSetMatrix(const SkMatrix& matrix) {
+ this->INHERITED::didSetMatrix(matrix);
}
void SkLuaCanvas::onClipRect(const SkRect& r, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
diff --git a/src/utils/SkNWayCanvas.cpp b/src/utils/SkNWayCanvas.cpp
index 58b5e6e..b127f21 100644
--- a/src/utils/SkNWayCanvas.cpp
+++ b/src/utils/SkNWayCanvas.cpp
@@ -86,52 +86,52 @@
this->INHERITED::willRestore();
}
-bool SkNWayCanvas::translate(SkScalar dx, SkScalar dy) {
+void SkNWayCanvas::didTranslate(SkScalar dx, SkScalar dy) {
Iter iter(fList);
while (iter.next()) {
iter->translate(dx, dy);
}
- return this->INHERITED::translate(dx, dy);
+ this->INHERITED::didTranslate(dx, dy);
}
-bool SkNWayCanvas::scale(SkScalar sx, SkScalar sy) {
+void SkNWayCanvas::didScale(SkScalar sx, SkScalar sy) {
Iter iter(fList);
while (iter.next()) {
iter->scale(sx, sy);
}
- return this->INHERITED::scale(sx, sy);
+ this->INHERITED::didScale(sx, sy);
}
-bool SkNWayCanvas::rotate(SkScalar degrees) {
+void SkNWayCanvas::didRotate(SkScalar degrees) {
Iter iter(fList);
while (iter.next()) {
iter->rotate(degrees);
}
- return this->INHERITED::rotate(degrees);
+ this->INHERITED::didRotate(degrees);
}
-bool SkNWayCanvas::skew(SkScalar sx, SkScalar sy) {
+void SkNWayCanvas::didSkew(SkScalar sx, SkScalar sy) {
Iter iter(fList);
while (iter.next()) {
iter->skew(sx, sy);
}
- return this->INHERITED::skew(sx, sy);
+ this->INHERITED::didSkew(sx, sy);
}
-bool SkNWayCanvas::concat(const SkMatrix& matrix) {
+void SkNWayCanvas::didConcat(const SkMatrix& matrix) {
Iter iter(fList);
while (iter.next()) {
iter->concat(matrix);
}
- return this->INHERITED::concat(matrix);
+ this->INHERITED::didConcat(matrix);
}
-void SkNWayCanvas::setMatrix(const SkMatrix& matrix) {
+void SkNWayCanvas::didSetMatrix(const SkMatrix& matrix) {
Iter iter(fList);
while (iter.next()) {
iter->setMatrix(matrix);
}
- this->INHERITED::setMatrix(matrix);
+ this->INHERITED::didSetMatrix(matrix);
}
void SkNWayCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
diff --git a/src/utils/SkProxyCanvas.cpp b/src/utils/SkProxyCanvas.cpp
index a32819d..037ddd0 100644
--- a/src/utils/SkProxyCanvas.cpp
+++ b/src/utils/SkProxyCanvas.cpp
@@ -39,28 +39,34 @@
this->INHERITED::willRestore();
}
-bool SkProxyCanvas::translate(SkScalar dx, SkScalar dy) {
- return fProxy->translate(dx, dy);
+void SkProxyCanvas::didTranslate(SkScalar dx, SkScalar dy) {
+ fProxy->translate(dx, dy);
+ this->INHERITED::didTranslate(dx, dy);
}
-bool SkProxyCanvas::scale(SkScalar sx, SkScalar sy) {
- return fProxy->scale(sx, sy);
+void SkProxyCanvas::didScale(SkScalar sx, SkScalar sy) {
+ fProxy->scale(sx, sy);
+ this->INHERITED::didScale(sx, sy);
}
-bool SkProxyCanvas::rotate(SkScalar degrees) {
- return fProxy->rotate(degrees);
+void SkProxyCanvas::didRotate(SkScalar degrees) {
+ fProxy->rotate(degrees);
+ this->INHERITED::didRotate(degrees);
}
-bool SkProxyCanvas::skew(SkScalar sx, SkScalar sy) {
- return fProxy->skew(sx, sy);
+void SkProxyCanvas::didSkew(SkScalar sx, SkScalar sy) {
+ fProxy->skew(sx, sy);
+ this->INHERITED::didSkew(sx, sy);
}
-bool SkProxyCanvas::concat(const SkMatrix& matrix) {
- return fProxy->concat(matrix);
+void SkProxyCanvas::didConcat(const SkMatrix& matrix) {
+ fProxy->concat(matrix);
+ this->INHERITED::didConcat(matrix);
}
-void SkProxyCanvas::setMatrix(const SkMatrix& matrix) {
+void SkProxyCanvas::didSetMatrix(const SkMatrix& matrix) {
fProxy->setMatrix(matrix);
+ this->INHERITED::didSetMatrix(matrix);
}
void SkProxyCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
diff --git a/src/utils/debugger/SkDebugCanvas.cpp b/src/utils/debugger/SkDebugCanvas.cpp
index 279976a..88bee50 100644
--- a/src/utils/debugger/SkDebugCanvas.cpp
+++ b/src/utils/debugger/SkDebugCanvas.cpp
@@ -409,9 +409,9 @@
this->addDrawCommand(new SkClipRegionCommand(region, op));
}
-bool SkDebugCanvas::concat(const SkMatrix& matrix) {
+void SkDebugCanvas::didConcat(const SkMatrix& matrix) {
addDrawCommand(new SkConcatCommand(matrix));
- return true;
+ this->INHERITED::didConcat(matrix);
}
void SkDebugCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar left,
@@ -535,9 +535,9 @@
this->INHERITED::willRestore();
}
-bool SkDebugCanvas::rotate(SkScalar degrees) {
+void SkDebugCanvas::didRotate(SkScalar degrees) {
addDrawCommand(new SkRotateCommand(degrees));
- return true;
+ this->INHERITED::didRotate(degrees);
}
void SkDebugCanvas::willSave(SaveFlags flags) {
@@ -553,23 +553,24 @@
return kNoLayer_SaveLayerStrategy;
}
-bool SkDebugCanvas::scale(SkScalar sx, SkScalar sy) {
+void SkDebugCanvas::didScale(SkScalar sx, SkScalar sy) {
addDrawCommand(new SkScaleCommand(sx, sy));
- return true;
+ this->INHERITED::didScale(sx, sy);
}
-void SkDebugCanvas::setMatrix(const SkMatrix& matrix) {
+void SkDebugCanvas::didSetMatrix(const SkMatrix& matrix) {
addDrawCommand(new SkSetMatrixCommand(matrix));
+ this->INHERITED::didSetMatrix(matrix);
}
-bool SkDebugCanvas::skew(SkScalar sx, SkScalar sy) {
+void SkDebugCanvas::didSkew(SkScalar sx, SkScalar sy) {
addDrawCommand(new SkSkewCommand(sx, sy));
- return true;
+ this->INHERITED::didSkew(sx, sy);
}
-bool SkDebugCanvas::translate(SkScalar dx, SkScalar dy) {
+void SkDebugCanvas::didTranslate(SkScalar dx, SkScalar dy) {
addDrawCommand(new SkTranslateCommand(dx, dy));
- return true;
+ this->INHERITED::didTranslate(dx, dy);
}
void SkDebugCanvas::toggleCommand(int index, bool toggle) {
diff --git a/src/utils/debugger/SkDebugCanvas.h b/src/utils/debugger/SkDebugCanvas.h
index bf3758d..1191a76 100644
--- a/src/utils/debugger/SkDebugCanvas.h
+++ b/src/utils/debugger/SkDebugCanvas.h
@@ -145,8 +145,6 @@
virtual void clear(SkColor) SK_OVERRIDE;
- virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE;
-
virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
const SkPaint*) SK_OVERRIDE;
@@ -206,16 +204,6 @@
const uint16_t indices[], int indexCount,
const SkPaint&) SK_OVERRIDE;
- virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
-
- virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
-
- virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
-
- virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE;
-
- virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
-
static const int kVizImageHeight = 256;
static const int kVizImageWidth = 256;
@@ -246,6 +234,13 @@
virtual SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
virtual void willRestore() SK_OVERRIDE;
+ virtual void didTranslate(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didScale(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didRotate(SkScalar) SK_OVERRIDE;
+ virtual void didSkew(SkScalar, SkScalar) SK_OVERRIDE;
+ virtual void didConcat(const SkMatrix&) SK_OVERRIDE;
+ virtual void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+
virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
virtual void onPushCull(const SkRect& cullRect) SK_OVERRIDE;
virtual void onPopCull() SK_OVERRIDE;