addDrawCommand(new DrawBitmap(bitmap, left, top, paint));
}
-void SkDebugCanvas::drawBitmapRect(const SkBitmap& bitmap,
- const SkIRect* src, const SkRect& dst, const SkPaint* paint) {
+void SkDebugCanvas::drawBitmapRectToRect(const SkBitmap& bitmap,
+ const SkRect* src, const SkRect& dst, const SkPaint* paint) {
addDrawCommand(new DrawBitmapRect(bitmap, src, dst, paint));
}
virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
const SkPaint*) SK_OVERRIDE;
- virtual void drawBitmapRect(const SkBitmap&, const SkIRect* src,
- const SkRect& dst, const SkPaint*) SK_OVERRIDE;
+ virtual void drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
+ const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
const SkPaint*) SK_OVERRIDE;
canvas->drawBitmapNine(*this->fBitmap, *this->fCenter, *this->fDst, this->fPaint);
}
-DrawBitmapRect::DrawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+DrawBitmapRect::DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
this->fBitmap = &bitmap;
this->fSrc = src;
this->fDrawType = DRAW_BITMAP_RECT;
this->fInfo.push(SkObjectParser::BitmapToString(bitmap));
- if (src) this->fInfo.push(SkObjectParser::IRectToString(*src));
+ if (src) this->fInfo.push(SkObjectParser::RectToString(*src));
this->fInfo.push(SkObjectParser::RectToString(dst));
if (paint) this->fInfo.push(SkObjectParser::PaintToString(*paint));
}
class DrawBitmapRect : public SkDrawCommand {
public:
- DrawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+ DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint);
virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
private:
- const SkIRect* fSrc;
+ const SkRect* fSrc;
const SkPaint* fPaint;
const SkBitmap* fBitmap;
const SkRect* fDst;
#include "SkCanvas.h"
#include "SkPath.h"
-#if 0
-def unpremul(x,alpha):
-assert x <= alpha
-if alpha == 0:
-return 0
-else:
-return math.floor(x*MAXVAL/alpha)
-
-def premul(X,alpha):
-return math.ceil(X*alpha/MAXVAL)
-#endif
-
-static int premul(int r, int a) {
- SkASSERT(a >= 0 && a <= 255);
- SkASSERT(r >= 0 && r <= 255);
- return (int)ceil(r * a / 255.0);
-}
-
-static int unpremul(int r, int a) {
- SkASSERT(a >= 0 && a <= 255);
- SkASSERT(r >= 0 && r <= a);
- if (0 == a) {
- return 0;
- }
- return (int)floor(r * 255.0 / a);
-}
-
-static void test_premul() {
- for (int a = 0; a <= 255; ++a) {
- for (int r = 0; r <= a; ++r) {
- int tmpr = unpremul(r, a);
- int newr = premul(tmpr, a);
- SkASSERT(newr == r);
- }
- }
-}
-
static SkCanvas* MakeCanvas(const SkIRect& bounds) {
SkBitmap bm;
bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height());
class AAClipGM : public GM {
public:
AAClipGM() {
- test_premul();
+
}
protected:
--- /dev/null
+
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "gm.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkGraphics.h"
+#include "SkPath.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+
+static void make_bitmap(SkBitmap* bitmap) {
+ SkCanvas canvas;
+
+ {
+ bitmap->setConfig(SkBitmap::kARGB_8888_Config, 64, 64);
+ bitmap->allocPixels();
+ canvas.setBitmapDevice(*bitmap);
+ }
+
+ canvas.drawColor(SK_ColorRED);
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ const SkPoint pts[] = { { 0, 0 }, { 64, 64 } };
+ const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
+ paint.setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2,
+ SkShader::kClamp_TileMode))->unref();
+ canvas.drawCircle(32, 32, 32, paint);
+}
+
+class DrawBitmapRect2 : public skiagm::GM {
+ bool fUseIRect;
+public:
+ DrawBitmapRect2(bool useIRect) : fUseIRect(useIRect) {
+ }
+
+protected:
+ virtual SkString onShortName() SK_OVERRIDE {
+ SkString str;
+ str.printf("bitmaprect_%s", fUseIRect ? "i" : "s");
+ return str;
+ }
+
+ virtual SkISize onISize() SK_OVERRIDE {
+ return SkISize::Make(640, 480);
+ }
+
+ virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ canvas->drawColor(0xFFCCCCCC);
+
+ const SkIRect src[] = {
+ { 0, 0, 32, 32 },
+ { 0, 0, 80, 80 },
+ { 32, 32, 96, 96 },
+ { -32, -32, 32, 32, }
+ };
+
+ SkPaint paint;
+ paint.setStyle(SkPaint::kStroke_Style);
+// paint.setColor(SK_ColorGREEN);
+
+ SkBitmap bitmap;
+ make_bitmap(&bitmap);
+
+ SkRect dstR = { 0, 200, 128, 380 };
+
+ canvas->translate(16, 40);
+ for (size_t i = 0; i < SK_ARRAY_COUNT(src); i++) {
+ SkRect srcR;
+ srcR.set(src[i]);
+
+ canvas->drawBitmap(bitmap, 0, 0, &paint);
+ if (fUseIRect) {
+ canvas->drawBitmapRectToRect(bitmap, &srcR, dstR, &paint);
+ } else {
+ canvas->drawBitmapRect(bitmap, &src[i], dstR, &paint);
+ }
+
+ canvas->drawRect(dstR, paint);
+ canvas->drawRect(srcR, paint);
+
+ canvas->translate(160, 0);
+ }
+ }
+
+private:
+ typedef skiagm::GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static skiagm::GM* MyFactory0(void*) { return new DrawBitmapRect2(false); }
+static skiagm::GM* MyFactory1(void*) { return new DrawBitmapRect2(true); }
+
+static skiagm::GMRegistry reg0(MyFactory0);
+static skiagm::GMRegistry reg1(MyFactory1);
if ((ERROR_NONE == testErrors) && doPipe &&
!(gmFlags & GM::kSkipPipe_Flag)) {
+ SkDebugf("test_pipe\n");
testErrors |= test_pipe_playback(gm, config,
forwardRenderedBitmap,
readPath, diffPath);
#include "gm.h"
#include "SkColorPriv.h"
-#include "SkGradientShader.h"
#include "SkGeometry.h"
#include "SkShader.h"
}
}
-static void draw_grad(SkCanvas* canvas, bool showGL, int) {
- SkPoint gradient_bounds[2];
- gradient_bounds[0].iset(0, 0);
- gradient_bounds[1].iset(0, 480);
-
- SkColor colors[2];
- colors[0] = 0xFFAB3300; // top
- colors[1] = 0xFF4F0000; // bottom
-
- SkShader* shader = SkGradientShader::CreateLinear(gradient_bounds,
- colors, NULL, 2, SkShader::kClamp_TileMode, NULL);
-
- SkPaint paint;
- paint.setShader(shader)->unref();
- paint.setDither(showGL);
-
- canvas->drawPaint(paint);
-}
-
static const struct {
DrawProc fProc;
const char* fName;
{ draw_oval, "Ovals" },
{ draw_image, "Images" },
{ draw_text, "Text" },
- { draw_grad, "Gradient" },
};
class TalkGM : public skiagm::GM {
ADD_GM(TalkGM, (4, false))
ADD_GM(TalkGM, (4, true))
-ADD_GM(TalkGM, (5, false))
-ADD_GM(TalkGM, (5, true))
-
//static GM* MyFactory(void*) { return new TalkGM(0, false); }
//static GMRegistry reg(MyFactory);
'../gm/bitmapcopy.cpp',
'../gm/bitmapmatrix.cpp',
'../gm/bitmapfilters.cpp',
+ '../gm/bitmaprect.cpp',
'../gm/bitmapscroll.cpp',
'../gm/blend.cpp',
'../gm/blurs.cpp',
image will be drawn
@param paint The paint used to draw the bitmap, or NULL
*/
- virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
- const SkRect& dst, const SkPaint* paint = NULL);
+ virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
+ const SkRect& dst,
+ const SkPaint* paint);
+
+ void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst,
+ const SkPaint* paint) {
+ this->drawBitmapRectToRect(bitmap, NULL, dst, paint);
+ }
+ void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* isrc,
+ const SkRect& dst, const SkPaint* paint = NULL) {
+ SkRect realSrcStorage;
+ SkRect* realSrcPtr = NULL;
+ if (isrc) {
+ realSrcStorage.set(*isrc);
+ realSrcPtr = &realSrcStorage;
+ }
+ this->drawBitmapRectToRect(bitmap, realSrcPtr, dst, paint);
+ }
+
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
const SkPaint* paint = NULL);
// canvas apis, without confusing subclasses (like SkPictureRecording)
void internalDrawBitmap(const SkBitmap&, const SkIRect*, const SkMatrix& m,
const SkPaint* paint);
- void internalDrawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+ void internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint);
void internalDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
const SkRect& dst, const SkPaint* paint);
virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left,
SkScalar top, const SkPaint* paint)
SK_OVERRIDE;
- virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+ virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint)
SK_OVERRIDE;
virtual void drawPath(const SkPath& path, const SkPaint& paint) SK_OVERRIDE;
virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint* paint) SK_OVERRIDE;
- virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+ virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
const SkPaint* paint) SK_OVERRIDE;
virtual void drawPath(const SkPath& path, const SkPaint&) SK_OVERRIDE;
virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint*) SK_OVERRIDE;
- virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+ virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
const SkPaint*) SK_OVERRIDE;
virtual void drawPath(const SkPath& path, const SkPaint& paint) SK_OVERRIDE;
virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint* paint = NULL) SK_OVERRIDE;
- virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+ virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint = NULL) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
const SkPaint* paint = NULL) SK_OVERRIDE;
}
}
-void SkBBoxRecord::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+void SkBBoxRecord::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
if (this->transformBounds(dst, paint)) {
- INHERITED::drawBitmapRect(bitmap, src, dst, paint);
+ INHERITED::drawBitmapRectToRect(bitmap, src, dst, paint);
}
}
const SkPaint& paint) SK_OVERRIDE;
virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint* paint = NULL) SK_OVERRIDE;
- virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+ virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& mat,
const SkPaint* paint) SK_OVERRIDE;
}
// this one is non-virtual, so it can be called safely by other canvas apis
-void SkCanvas::internalDrawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+void SkCanvas::internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
if (bitmap.width() == 0 || bitmap.height() == 0 || dst.isEmpty()) {
return;
}
- // do this now, to avoid the cost of calling extract for RLE bitmaps
if (NULL == paint || paint->canComputeFastBounds()) {
SkRect storage;
const SkRect* bounds = &dst;
}
}
- const SkBitmap* bitmapPtr = &bitmap;
-
SkMatrix matrix;
- SkRect tmpSrc;
- if (src) {
- tmpSrc.set(*src);
- // if the extract process clipped off the top or left of the
- // original, we adjust for that here to get the position right.
- if (tmpSrc.fLeft > 0) {
- tmpSrc.fRight -= tmpSrc.fLeft;
- tmpSrc.fLeft = 0;
- }
- if (tmpSrc.fTop > 0) {
- tmpSrc.fBottom -= tmpSrc.fTop;
- tmpSrc.fTop = 0;
+ // Compute matrix from the two rectangles
+ {
+ SkRect tmpSrc;
+ if (src) {
+ tmpSrc = *src;
+ // if the extract process clipped off the top or left of the
+ // original, we adjust for that here to get the position right.
+ if (tmpSrc.fLeft > 0) {
+ tmpSrc.fRight -= tmpSrc.fLeft;
+ tmpSrc.fLeft = 0;
+ }
+ if (tmpSrc.fTop > 0) {
+ tmpSrc.fBottom -= tmpSrc.fTop;
+ tmpSrc.fTop = 0;
+ }
+ } else {
+ tmpSrc.set(0, 0, SkIntToScalar(bitmap.width()),
+ SkIntToScalar(bitmap.height()));
}
- } else {
- tmpSrc.set(0, 0, SkIntToScalar(bitmap.width()),
- SkIntToScalar(bitmap.height()));
+ matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
}
- matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
// ensure that src is "valid" before we pass it to our internal routines
// and to SkDevice. i.e. sure it is contained inside the original bitmap.
- SkIRect tmpISrc;
+ SkIRect isrcStorage;
+ SkIRect* isrcPtr = NULL;
if (src) {
- tmpISrc.set(0, 0, bitmap.width(), bitmap.height());
- if (!tmpISrc.intersect(*src)) {
+ src->roundOut(&isrcStorage);
+ if (!isrcStorage.intersect(0, 0, bitmap.width(), bitmap.height())) {
return;
}
- src = &tmpISrc;
+ isrcPtr = &isrcStorage;
}
- this->internalDrawBitmap(*bitmapPtr, src, matrix, paint);
+ this->internalDrawBitmap(bitmap, isrcPtr, matrix, paint);
}
-void SkCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
- const SkRect& dst, const SkPaint* paint) {
+void SkCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
+ const SkRect& dst, const SkPaint* paint) {
SkDEBUGCODE(bitmap.validate();)
this->internalDrawBitmapRect(bitmap, src, dst, paint);
}
c.fRight = SkPin32(center.fRight, c.fLeft, w);
c.fBottom = SkPin32(center.fBottom, c.fTop, h);
- const int32_t srcX[4] = { 0, c.fLeft, c.fRight, w };
- const int32_t srcY[4] = { 0, c.fTop, c.fBottom, h };
+ const SkScalar srcX[4] = {
+ 0, SkIntToScalar(c.fLeft), SkIntToScalar(c.fRight), w
+ };
+ const SkScalar srcY[4] = {
+ 0, SkIntToScalar(c.fTop), SkIntToScalar(c.fBottom), h
+ };
SkScalar dstX[4] = {
dst.fLeft, dst.fLeft + SkIntToScalar(c.fLeft),
dst.fRight - SkIntToScalar(w - c.fRight), dst.fRight
dstY[2] = dstY[1];
}
- SkIRect s;
- SkRect d;
for (int y = 0; y < 3; y++) {
+ SkRect s, d;
+
s.fTop = srcY[y];
s.fBottom = srcY[y+1];
d.fTop = dstY[y];
// V4 : move SkPictInfo to be the header
// V5 : don't read/write FunctionPtr on cross-process (we can detect that)
// V6 : added serialization of SkPath's bounds (and packed its flags tighter)
-#define PICTURE_VERSION 6
+// V7 : changed drawBitmapRect(IRect) to drawBitmapRectToRect(Rect)
+#define PICTURE_VERSION 7
SkPicture::SkPicture(SkStream* stream, bool* success) : SkRefCnt() {
if (success) {
DRAW_BITMAP,
DRAW_BITMAP_MATRIX,
DRAW_BITMAP_NINE,
- DRAW_BITMAP_RECT,
+ DRAW_BITMAP_RECT_TO_RECT,
DRAW_CLEAR,
DRAW_DATA,
DRAW_PAINT,
const SkPoint& loc = reader.skipT<SkPoint>();
canvas.drawBitmap(bitmap, loc.fX, loc.fY, paint);
} break;
- case DRAW_BITMAP_RECT: {
+ case DRAW_BITMAP_RECT_TO_RECT: {
const SkPaint* paint = getPaint(reader);
const SkBitmap& bitmap = getBitmap(reader);
- const SkIRect* src = this->getIRectPtr(reader); // may be null
+ const SkRect* src = this->getRectPtr(reader); // may be null
const SkRect& dst = reader.skipT<SkRect>(); // required
- canvas.drawBitmapRect(bitmap, src, dst, paint);
+ canvas.drawBitmapRectToRect(bitmap, src, dst, paint);
} break;
case DRAW_BITMAP_MATRIX: {
const SkPaint* paint = getPaint(reader);
validate();
}
-void SkPictureRecord::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+void SkPictureRecord::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
- addDraw(DRAW_BITMAP_RECT);
+ addDraw(DRAW_BITMAP_RECT_TO_RECT);
addPaintPtr(paint);
addBitmap(bitmap);
- addIRectPtr(src); // may be null
+ addRectPtr(src); // may be null
addRect(dst);
validate();
}
virtual void drawPath(const SkPath& path, const SkPaint&) SK_OVERRIDE;
virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
const SkPaint*) SK_OVERRIDE;
- virtual void drawBitmapRect(const SkBitmap&, const SkIRect* src,
- const SkRect& dst, const SkPaint*) SK_OVERRIDE;
+ virtual void drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
+ const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
kDrawBitmap_DrawOp,
kDrawBitmapMatrix_DrawOp,
kDrawBitmapNine_DrawOp,
- kDrawBitmapRect_DrawOp,
+ kDrawBitmapRectToRect_DrawOp,
kDrawClear_DrawOp,
kDrawData_DrawOp,
kDrawPaint_DrawOp,
unsigned flags = DrawOp_unpackFlags(op32);
bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag);
bool hasSrc = SkToBool(flags & kDrawBitmap_HasSrcRect_DrawOpFlag);
- const SkIRect* src;
+ const SkRect* src;
if (hasSrc) {
- src = skip<SkIRect>(reader);
+ src = skip<SkRect>(reader);
} else {
src = NULL;
}
const SkRect* dst = skip<SkRect>(reader);
- canvas->drawBitmapRect(*holder.getBitmap(), src, *dst, hasPaint ? &state->paint() : NULL);
+ canvas->drawBitmapRectToRect(*holder.getBitmap(), src, *dst, hasPaint ? &state->paint() : NULL);
}
static void drawSprite_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
virtual void drawPath(const SkPath& path, const SkPaint&) SK_OVERRIDE;
virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
const SkPaint*) SK_OVERRIDE;
- virtual void drawBitmapRect(const SkBitmap&, const SkIRect* src,
+ virtual void drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
const SkPaint*) SK_OVERRIDE;
}
}
-void SkGPipeCanvas::drawBitmapRect(const SkBitmap& bm, const SkIRect* src,
+void SkGPipeCanvas::drawBitmapRectToRect(const SkBitmap& bm, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
NOTIFY_SETUP(this);
size_t opBytesNeeded = sizeof(SkRect);
flags = 0;
}
- if (this->commonDrawBitmap(bm, kDrawBitmapRect_DrawOp, flags, opBytesNeeded, paint)) {
+ if (this->commonDrawBitmap(bm, kDrawBitmapRectToRect_DrawOp, flags, opBytesNeeded, paint)) {
if (hasSrc) {
- fWriter.write32(src->fLeft);
- fWriter.write32(src->fTop);
- fWriter.write32(src->fRight);
- fWriter.write32(src->fBottom);
+ fWriter.writeRect(*src);
}
fWriter.writeRect(dst);
}
this->recordedDrawCommand();
}
-void SkDeferredCanvas::drawBitmapRect(const SkBitmap& bitmap,
- const SkIRect* src,
- const SkRect& dst,
- const SkPaint* paint) {
+void SkDeferredCanvas::drawBitmapRectToRect(const SkBitmap& bitmap,
+ const SkRect* src,
+ const SkRect& dst,
+ const SkPaint* paint) {
if (fDeferredDrawing &&
this->isFullFrame(&dst, paint) &&
isPaintOpaque(paint, &bitmap)) {
}
AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
- this->drawingCanvas()->drawBitmapRect(bitmap, src, dst, paint);
+ this->drawingCanvas()->drawBitmapRectToRect(bitmap, src, dst, paint);
this->recordedDrawCommand();
}
SkScalarToFloat(x), SkScalarToFloat(y));
}
-void SkDumpCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
- const SkRect& dst, const SkPaint* paint) {
+void SkDumpCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
+ const SkRect& dst, const SkPaint* paint) {
SkString bs, rs;
toString(bitmap, &bs);
toString(dst, &rs);
// show the src-rect only if its not everything
if (src && (src->fLeft > 0 || src->fTop > 0 ||
- src->fRight < bitmap.width() ||
- src->fBottom < bitmap.height())) {
+ src->fRight < SkIntToScalar(bitmap.width()) ||
+ src->fBottom < SkIntToScalar(bitmap.height()))) {
SkString ss;
toString(*src, &ss);
rs.prependf("%s ", ss.c_str());
}
- this->dump(kDrawBitmap_Verb, paint, "drawBitmapRect(%s %s)",
+ this->dump(kDrawBitmap_Verb, paint, "drawBitmapRectToRect(%s %s)",
bs.c_str(), rs.c_str());
}
}
}
-void SkNWayCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+void SkNWayCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
Iter iter(fList);
while (iter.next()) {
- iter->drawBitmapRect(bitmap, src, dst, paint);
+ iter->drawBitmapRectToRect(bitmap, src, dst, paint);
}
}
fProxy->drawBitmap(bitmap, x, y, paint);
}
-void SkProxyCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
+void SkProxyCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
- fProxy->drawBitmapRect(bitmap, src, dst, paint);
+ fProxy->drawBitmapRectToRect(bitmap, src, dst, paint);
}
void SkProxyCanvas::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,