Make SkDrawCommands lighter weight

debugger/SkDrawCommand.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkDrawCommand.h"
@@ skipping 69 matching lines @@
 Clear::Clear(SkColor color) {
     fColor = color;
     fDrawType = DRAW_CLEAR;
     fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
 }
 
 void Clear::execute(SkCanvas* canvas) {
     canvas->clear(fColor);
 }
 
-ClipPath::ClipPath(const SkPath& path, SkRegion::Op op, bool doAA, SkBitmap& bitmap) {
+namespace {
+
+void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {
+    const SkISize& size = canvas->getDeviceSize();
+
+    static const SkScalar kInsetFrac = 0.9f; // Leave a border around object
+
+    canvas->translate(size.fWidth/2.0f, size.fHeight/2.0f);
+    if (bounds.width() > bounds.height()) {
+        canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.width()),
+                      SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.width()));
+    } else {
+        canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.height()),
+                      SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.height()));
+    }
+    canvas->translate(-bounds.centerX(), -bounds.centerY());
+}
+    
+
+void render_path(SkCanvas* canvas, const SkPath& path) {
+    canvas->clear(0xFFFFFFFF);
+    canvas->save();
+
+    const SkRect& bounds = path.getBounds();
+
+    xlate_and_scale_to_bounds(canvas, bounds);
+
+    SkPaint p;
+    p.setColor(SK_ColorBLACK);
+    p.setStyle(SkPaint::kStroke_Style);
+
+    canvas->drawPath(path, p);
+    canvas->restore();
+}
+
+void render_bitmap(SkCanvas* canvas, const SkBitmap& input, const SkRect* srcRect = NULL) {
+    const SkISize& size = canvas->getDeviceSize();
+
+    SkScalar xScale = SkIntToScalar(size.fWidth-2) / input.width();
+    SkScalar yScale = SkIntToScalar(size.fHeight-2) / input.height();
+
+    if (input.width() > input.height()) {
+        yScale *= input.height() / (float) input.width();
+    } else {
+        xScale *= input.width() / (float) input.height();
+    }
+
+    SkRect dst = SkRect::MakeXYWH(SK_Scalar1, SK_Scalar1,
+                                  xScale * input.width(),
+                                  yScale * input.height());
+    
+    canvas->clear(0xFFFFFFFF);
+    canvas->drawBitmapRect(input, NULL, dst);
+
+    if (NULL != srcRect) {
+        SkRect r = SkRect::MakeLTRB(srcRect->fLeft * xScale + SK_Scalar1,
+                                    srcRect->fTop * yScale + SK_Scalar1,
+                                    srcRect->fRight * xScale + SK_Scalar1,
+                                    srcRect->fBottom * yScale + SK_Scalar1);
+        SkPaint p;
+        p.setColor(SK_ColorRED);
+        p.setStyle(SkPaint::kStroke_Style);
+
+        canvas->drawRect(r, p);
+    }
+}
+
+void render_rrect(SkCanvas* canvas, const SkRRect& rrect) {
+    canvas->clear(0xFFFFFFFF);
+    canvas->save();
+
+    const SkRect& bounds = rrect.getBounds();
+
+    xlate_and_scale_to_bounds(canvas, bounds);
+
+    SkPaint p;
+    p.setColor(SK_ColorBLACK);
+    p.setStyle(SkPaint::kStroke_Style);
+
+    canvas->drawRRect(rrect, p);
+    canvas->restore();
+}
+    
+};
+
+
+ClipPath::ClipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
     fPath = path;
     fOp = op;
     fDoAA = doAA;
     fDrawType = CLIP_PATH;
-    fBitmap = bitmap;
 
     fInfo.push(SkObjectParser::PathToString(path));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
 void ClipPath::execute(SkCanvas* canvas) {
     canvas->clipPath(fPath, fOp, fDoAA);
 }
 
-const SkBitmap* ClipPath::getBitmap() const {
-    return &fBitmap;
+bool ClipPath::render(SkCanvas* canvas) const {
+    render_path(canvas, fPath);
+    return true;
 }
 
 ClipRegion::ClipRegion(const SkRegion& region, SkRegion::Op op) {
     fRegion = region;
     fOp = op;
     fDrawType = CLIP_REGION;
 
     fInfo.push(SkObjectParser::RegionToString(region));
     fInfo.push(SkObjectParser::RegionOpToString(op));
 }
@@ skipping 25 matching lines @@
 
     fInfo.push(SkObjectParser::RRectToString(rrect));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
 void ClipRRect::execute(SkCanvas* canvas) {
     canvas->clipRRect(fRRect, fOp, fDoAA);
 }
 
+bool ClipRRect::render(SkCanvas* canvas) const {
+    render_rrect(canvas, fRRect);
+    return true;
+}
+
 Concat::Concat(const SkMatrix& matrix) {
     fMatrix = matrix;
     fDrawType = CONCAT;
 
     fInfo.push(SkObjectParser::MatrixToString(matrix));
 }
 
 void Concat::execute(SkCanvas* canvas) {
     canvas->concat(fMatrix);
 }
 
 DrawBitmap::DrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
-                       const SkPaint* paint, SkBitmap& resizedBitmap) {
+                       const SkPaint* paint) {
     fBitmap = bitmap;
     fLeft = left;
     fTop = top;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_BITMAP;
-    fResizedBitmap = resizedBitmap;
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: "));
     fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: "));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void DrawBitmap::execute(SkCanvas* canvas) {
     canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr);
 }
 
-const SkBitmap* DrawBitmap::getBitmap() const {
-    return &fResizedBitmap;
+bool DrawBitmap::render(SkCanvas* canvas) const {
+    render_bitmap(canvas, fBitmap);
+    return true;
 }
 
 DrawBitmapMatrix::DrawBitmapMatrix(const SkBitmap& bitmap,
                                    const SkMatrix& matrix,
-                                   const SkPaint* paint,
-                                   SkBitmap& resizedBitmap) {
+                                   const SkPaint* paint) {
     fBitmap = bitmap;
     fMatrix = matrix;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_BITMAP_MATRIX;
-    fResizedBitmap = resizedBitmap;
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::MatrixToString(matrix));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void DrawBitmapMatrix::execute(SkCanvas* canvas) {
     canvas->drawBitmapMatrix(fBitmap, fMatrix, fPaintPtr);
 }
 
-const SkBitmap* DrawBitmapMatrix::getBitmap() const {
-    return &fResizedBitmap;
+bool DrawBitmapMatrix::render(SkCanvas* canvas) const {
+    render_bitmap(canvas, fBitmap);
+    return true;
 }
 
 DrawBitmapNine::DrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
-                               const SkRect& dst, const SkPaint* paint,
-                               SkBitmap& resizedBitmap) {
+                               const SkRect& dst, const SkPaint* paint) {
     fBitmap = bitmap;
     fCenter = center;
     fDst = dst;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_BITMAP_NINE;
-    fResizedBitmap = resizedBitmap;
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::IRectToString(center));
     fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void DrawBitmapNine::execute(SkCanvas* canvas) {
     canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr);
 }
 
-const SkBitmap* DrawBitmapNine::getBitmap() const {
-    return &fResizedBitmap;
+bool DrawBitmapNine::render(SkCanvas* canvas) const {
+    render_bitmap(canvas, fBitmap);
+    return true;
 }
 
 DrawBitmapRect::DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
-                               const SkRect& dst, const SkPaint* paint,
-                               SkBitmap& resizedBitmap) {
+                               const SkRect& dst, const SkPaint* paint) {
     fBitmap = bitmap;
     if (NULL != src) {
         fSrc = *src;
     } else {
         fSrc.setEmpty();
     }
     fDst = dst;
 
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_BITMAP_RECT_TO_RECT;
-    fResizedBitmap = resizedBitmap;
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     if (NULL != src) {
         fInfo.push(SkObjectParser::RectToString(*src, "Src: "));
     }
     fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void DrawBitmapRect::execute(SkCanvas* canvas) {
     canvas->drawBitmapRectToRect(fBitmap, this->srcRect(), fDst, fPaintPtr);
 }
 
-const SkBitmap* DrawBitmapRect::getBitmap() const {
-    return &fResizedBitmap;
+bool DrawBitmapRect::render(SkCanvas* canvas) const {
+    render_bitmap(canvas, fBitmap, this->srcRect());
+    return true;
 }
 
 DrawData::DrawData(const void* data, size_t length) {
     fData = new char[length];
     memcpy(fData, data, length);
     fLength = length;
     fDrawType = DRAW_DATA;
 
     // TODO: add display of actual data?
     SkString* str = new SkString;
@@ skipping 31 matching lines @@
     fDrawType = DRAW_OVAL;
 
     fInfo.push(SkObjectParser::RectToString(oval));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void DrawOval::execute(SkCanvas* canvas) {
     canvas->drawOval(fOval, fPaint);
 }
 
+bool DrawOval::render(SkCanvas* canvas) const {
+    canvas->clear(0xFFFFFFFF);
+    canvas->save();
+
+    xlate_and_scale_to_bounds(canvas, fOval);
+
+    SkPaint p;
+    p.setColor(SK_ColorBLACK);
+    p.setStyle(SkPaint::kStroke_Style);
+
+    canvas->drawOval(fOval, p);
+    canvas->restore();
+
+    return true;
+}
+
 DrawPaint::DrawPaint(const SkPaint& paint) {
     fPaint = paint;
     fDrawType = DRAW_PAINT;
 
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void DrawPaint::execute(SkCanvas* canvas) {
     canvas->drawPaint(fPaint);
 }
 
-DrawPath::DrawPath(const SkPath& path, const SkPaint& paint, SkBitmap& bitmap) {
+bool DrawPaint::render(SkCanvas* canvas) const {
+    canvas->clear(0xFFFFFFFF);
+    canvas->drawPaint(fPaint);
+    return true;
+}
+
+DrawPath::DrawPath(const SkPath& path, const SkPaint& paint) {
     fPath = path;
     fPaint = paint;
-    fBitmap = bitmap;
     fDrawType = DRAW_PATH;
 
     fInfo.push(SkObjectParser::PathToString(path));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void DrawPath::execute(SkCanvas* canvas) {
     canvas->drawPath(fPath, fPaint);
 }
 
-const SkBitmap* DrawPath::getBitmap() const {
-    return &fBitmap;
+bool DrawPath::render(SkCanvas* canvas) const {
+    render_path(canvas, fPath);
+    return true;
 }
 
 DrawPicture::DrawPicture(SkPicture& picture) :
     fPicture(picture) {
     fDrawType = DRAW_PICTURE;
     fInfo.push(SkObjectParser::CustomTextToString("To be implemented."));
 }
 
 void DrawPicture::execute(SkCanvas* canvas) {
     canvas->drawPicture(fPicture);
@@ skipping 12 matching lines @@
     fInfo.push(SkObjectParser::ScalarToString(SkIntToScalar((unsigned int)count),
                                               "Points: "));
     fInfo.push(SkObjectParser::PointModeToString(mode));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void DrawPoints::execute(SkCanvas* canvas) {
     canvas->drawPoints(fMode, fCount, fPts, fPaint);
 }
 
+bool DrawPoints::render(SkCanvas* canvas) const {
+    canvas->clear(0xFFFFFFFF);
+    canvas->save();
+
+    SkRect bounds;
+
+    bounds.setEmpty();
+    for (unsigned int i = 0; i < fCount; ++i) {
+        bounds.growToInclude(fPts[i].fX, fPts[i].fY);
+    }
+    
+    xlate_and_scale_to_bounds(canvas, bounds);
+
+    SkPaint p;
+    p.setColor(SK_ColorBLACK);
+    p.setStyle(SkPaint::kStroke_Style);
+
+    canvas->drawPoints(fMode, fCount, fPts, p);
+    canvas->restore();
+
+    return true;
+}
+
 DrawPosText::DrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                          const SkPaint& paint) {
     size_t numPts = paint.countText(text, byteLength);
 
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
 
     fPos = new SkPoint[numPts];
     memcpy(fPos, pos, numPts * sizeof(SkPoint));
@@ skipping 57 matching lines @@
     fDrawType = DRAW_RRECT;
 
     fInfo.push(SkObjectParser::RRectToString(rrect));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void DrawRRect::execute(SkCanvas* canvas) {
     canvas->drawRRect(fRRect, fPaint);
 }
 
+bool DrawRRect::render(SkCanvas* canvas) const {
+    render_rrect(canvas, fRRect);
+    return true;
+}
+
 DrawSprite::DrawSprite(const SkBitmap& bitmap, int left, int top,
-                       const SkPaint* paint, SkBitmap& resizedBitmap) {
+                       const SkPaint* paint) {
     fBitmap = bitmap;
     fLeft = left;
     fTop = top;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_SPRITE;
-    fResizedBitmap = resizedBitmap;
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::IntToString(left, "Left: "));
     fInfo.push(SkObjectParser::IntToString(top, "Top: "));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void DrawSprite::execute(SkCanvas* canvas) {
     canvas->drawSprite(fBitmap, fLeft, fTop, fPaintPtr);
 }
 
-const SkBitmap* DrawSprite::getBitmap() const {
-    return &fResizedBitmap;
+bool DrawSprite::render(SkCanvas* canvas) const {
+    render_bitmap(canvas, fBitmap);
+    return true;
 }
 
 DrawTextC::DrawTextC(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                      const SkPaint& paint) {
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
     fX = x;
     fY = y;
     fPaint = paint;
@@ skipping 215 matching lines @@
     fDy = dy;
     fDrawType = TRANSLATE;
 
     fInfo.push(SkObjectParser::ScalarToString(dx, "SkScalar dx: "));
     fInfo.push(SkObjectParser::ScalarToString(dy, "SkScalar dy: "));
 }
 
 void Translate::execute(SkCanvas* canvas) {
     canvas->translate(fDx, fDy);
 }