AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

revert 5578 -- broke pipe

Browse Source 
git-svn-id: http://skia.googlecode.com/svn/trunk@5579 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
reed@google.com 2012-09-18 13:20:52 +00:00
parent f1ab723033
commit c75c36a14b
27 changed files with 143 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
debugger/SkDebugCanvas.cpp
View File

@ -183,8 +183,8 @@ void SkDebugCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar left,
addDrawCommand(new DrawBitmap(bitmap, left, top, paint));
}
void SkDebugCanvas::drawBitmapRectToRect(const SkBitmap& bitmap,
const SkRect* src, const SkRect& dst, const SkPaint* paint) {
void SkDebugCanvas::drawBitmapRect(const SkBitmap& bitmap,
const SkIRect* src, const SkRect& dst, const SkPaint* paint) {
addDrawCommand(new DrawBitmapRect(bitmap, src, dst, paint));
}

4
debugger/SkDebugCanvas.h
View File

@ -135,8 +135,8 @@ public:
virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapRect(const SkBitmap&, const SkIRect* src,
const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
const SkPaint*) SK_OVERRIDE;

4
debugger/SkDrawCommand.cpp
View File

@ -180,7 +180,7 @@ void DrawBitmapNine::execute(SkCanvas* canvas) {
canvas->drawBitmapNine(*this->fBitmap, *this->fCenter, *this->fDst, this->fPaint);
}
DrawBitmapRect::DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
DrawBitmapRect::DrawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) {
this->fBitmap = &bitmap;
this->fSrc = src;
@ -189,7 +189,7 @@ DrawBitmapRect::DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
this->fDrawType = DRAW_BITMAP_RECT;
this->fInfo.push(SkObjectParser::BitmapToString(bitmap));
if (src) this->fInfo.push(SkObjectParser::RectToString(*src));
if (src) this->fInfo.push(SkObjectParser::IRectToString(*src));
this->fInfo.push(SkObjectParser::RectToString(dst));
if (paint) this->fInfo.push(SkObjectParser::PaintToString(*paint));
}

4
debugger/SkDrawCommand.h
View File

@ -134,11 +134,11 @@ private:
class DrawBitmapRect : public SkDrawCommand {
public:
DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
DrawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint);
virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
private:
const SkRect* fSrc;
const SkIRect* fSrc;
const SkPaint* fPaint;
const SkBitmap* fBitmap;
const SkRect* fDst;

39
gm/aaclip.cpp
View File

@ -9,6 +9,43 @@
#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());
@ -145,7 +182,7 @@ static void draw_rect_tests (SkCanvas* canvas) {
class AAClipGM : public GM {
public:
AAClipGM() {
test_premul();
}
protected:

100
gm/bitmaprect.cpp
View File

@ -1,100 +0,0 @@
/*
* 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);

24
gm/techtalk1.cpp
View File

@ -8,6 +8,7 @@
#include "gm.h"
#include "SkColorPriv.h"
#include "SkGradientShader.h"
#include "SkGeometry.h"
#include "SkShader.h"
@ -311,6 +312,25 @@ static void draw_text(SkCanvas* canvas, bool showGL, int flags) {
}
}
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;
@ -320,6 +340,7 @@ static const struct {
{ draw_oval, "Ovals" },
{ draw_image, "Images" },
{ draw_text, "Text" },
{ draw_grad, "Gradient" },
};
class TalkGM : public skiagm::GM {
@ -393,6 +414,9 @@ ADD_GM(TalkGM, (3, true))
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);

1
gyp/gmslides.gypi
View File

@ -8,7 +8,6 @@
'../gm/bitmapcopy.cpp',
'../gm/bitmapmatrix.cpp',
'../gm/bitmapfilters.cpp',
'../gm/bitmaprect.cpp',
'../gm/bitmapscroll.cpp',
'../gm/blend.cpp',
'../gm/blurs.cpp',

23
include/core/SkCanvas.h
View File

@ -644,26 +644,9 @@ public:
image will be drawn
@param paint The paint used to draw the bitmap, or NULL
*/
virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst,
const SkPaint* paint);
virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint = NULL);
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);
@ -1010,7 +993,7 @@ private:
// 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 SkRect* src,
void internalDrawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint);
void internalDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
const SkRect& dst, const SkPaint* paint);

2
include/utils/SkDeferredCanvas.h
View File

@ -138,7 +138,7 @@ public:
virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left,
SkScalar top, const SkPaint* paint)
SK_OVERRIDE;
virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint)
SK_OVERRIDE;

2
include/utils/SkDumpCanvas.h
View File

@ -87,7 +87,7 @@ public:
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 drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
const SkPaint* paint) SK_OVERRIDE;

2
include/utils/SkNWayCanvas.h
View File

@ -45,7 +45,7 @@ public:
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 drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
const SkPaint*) SK_OVERRIDE;

2
include/utils/SkProxyCanvas.h
View File

@ -50,7 +50,7 @@ public:
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 drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* 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;

4
src/core/SkBBoxRecord.cpp
View File

@ -101,10 +101,10 @@ void SkBBoxRecord::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar to
}
}
void SkBBoxRecord::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
void SkBBoxRecord::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) {
if (this->transformBounds(dst, paint)) {
INHERITED::drawBitmapRectToRect(bitmap, src, dst, paint);
INHERITED::drawBitmapRect(bitmap, src, dst, paint);
}
}

2
src/core/SkBBoxRecord.h
View File

@ -38,7 +38,7 @@ public:
const SkPaint& paint) SK_OVERRIDE;
virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint* paint = NULL) SK_OVERRIDE;
virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& mat,
const SkPaint* paint) SK_OVERRIDE;

67
src/core/SkCanvas.cpp
View File

@ -1576,12 +1576,13 @@ void SkCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
}
// this one is non-virtual, so it can be called safely by other canvas apis
void SkCanvas::internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
void SkCanvas::internalDrawBitmapRect(const SkBitmap& bitmap, const SkIRect* 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;
@ -1593,45 +1594,43 @@ void SkCanvas::internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
}
}
const SkBitmap* bitmapPtr = &bitmap;
SkMatrix matrix;
// 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()));
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;
}
matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
if (tmpSrc.fTop > 0) {
tmpSrc.fBottom -= tmpSrc.fTop;
tmpSrc.fTop = 0;
}
} else {
tmpSrc.set(0, 0, SkIntToScalar(bitmap.width()),
SkIntToScalar(bitmap.height()));
}
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 isrcStorage;
SkIRect* isrcPtr = NULL;
SkIRect tmpISrc;
if (src) {
src->roundOut(&isrcStorage);
if (!isrcStorage.intersect(0, 0, bitmap.width(), bitmap.height())) {
tmpISrc.set(0, 0, bitmap.width(), bitmap.height());
if (!tmpISrc.intersect(*src)) {
return;
}
isrcPtr = &isrcStorage;
src = &tmpISrc;
}
this->internalDrawBitmap(bitmap, isrcPtr, matrix, paint);
this->internalDrawBitmap(*bitmapPtr, src, matrix, paint);
}
void SkCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
void SkCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) {
SkDEBUGCODE(bitmap.validate();)
this->internalDrawBitmapRect(bitmap, src, dst, paint);
}
@ -1679,12 +1678,8 @@ void SkCanvas::internalDrawBitmapNine(const SkBitmap& bitmap,
c.fRight = SkPin32(center.fRight, c.fLeft, w);
c.fBottom = SkPin32(center.fBottom, c.fTop, 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
};
const int32_t srcX[4] = { 0, c.fLeft, c.fRight, w };
const int32_t srcY[4] = { 0, c.fTop, c.fBottom, h };
SkScalar dstX[4] = {
dst.fLeft, dst.fLeft + SkIntToScalar(c.fLeft),
dst.fRight - SkIntToScalar(w - c.fRight), dst.fRight
@ -1704,9 +1699,9 @@ void SkCanvas::internalDrawBitmapNine(const SkBitmap& bitmap,
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];

3
src/core/SkPicture.cpp
View File

@ -240,8 +240,7 @@ void SkPicture::draw(SkCanvas* surface) {
// 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)
// V7 : changed drawBitmapRect(IRect) to drawBitmapRectToRect(Rect)
#define PICTURE_VERSION 7
#define PICTURE_VERSION 6
SkPicture::SkPicture(SkStream* stream, bool* success) : SkRefCnt() {
if (success) {

2
src/core/SkPictureFlat.h
View File

@ -33,7 +33,7 @@ enum DrawType {
DRAW_BITMAP,
DRAW_BITMAP_MATRIX,
DRAW_BITMAP_NINE,
DRAW_BITMAP_RECT_TO_RECT,
DRAW_BITMAP_RECT,
DRAW_CLEAR,
DRAW_DATA,
DRAW_PAINT,

6
src/core/SkPicturePlayback.cpp
View File

@ -672,12 +672,12 @@ void SkPicturePlayback::draw(SkCanvas& canvas) {
const SkPoint& loc = reader.skipT<SkPoint>();
canvas.drawBitmap(bitmap, loc.fX, loc.fY, paint);
} break;
case DRAW_BITMAP_RECT_TO_RECT: {
case DRAW_BITMAP_RECT: {
const SkPaint* paint = getPaint(reader);
const SkBitmap& bitmap = getBitmap(reader);
const SkRect* src = this->getRectPtr(reader); // may be null
const SkIRect* src = this->getIRectPtr(reader); // may be null
const SkRect& dst = reader.skipT<SkRect>(); // required
canvas.drawBitmapRectToRect(bitmap, src, dst, paint);
canvas.drawBitmapRect(bitmap, src, dst, paint);
} break;
case DRAW_BITMAP_MATRIX: {
const SkPaint* paint = getPaint(reader);

6
src/core/SkPictureRecord.cpp
View File

@ -426,12 +426,12 @@ void SkPictureRecord::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar
validate();
}
void SkPictureRecord::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
void SkPictureRecord::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) {
addDraw(DRAW_BITMAP_RECT_TO_RECT);
addDraw(DRAW_BITMAP_RECT);
addPaintPtr(paint);
addBitmap(bitmap);
addRectPtr(src); // may be null
addIRectPtr(src); // may be null
addRect(dst);
validate();
}

4
src/core/SkPictureRecord.h
View File

@ -46,8 +46,8 @@ public:
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 drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapRect(const SkBitmap&, const SkIRect* 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,

2
src/pipe/SkGPipePriv.h
View File

@ -41,7 +41,7 @@ enum DrawOps {
kDrawBitmap_DrawOp,
kDrawBitmapMatrix_DrawOp,
kDrawBitmapNine_DrawOp,
kDrawBitmapRectToRect_DrawOp,
kDrawBitmapRect_DrawOp,
kDrawClear_DrawOp,
kDrawData_DrawOp,
kDrawPaint_DrawOp,

11
src/pipe/SkGPipeWrite.cpp
View File

@ -221,7 +221,7 @@ public:
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 drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
virtual void drawBitmapRect(const SkBitmap&, const SkIRect* src,
const SkRect& dst, const SkPaint*) SK_OVERRIDE;
virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
const SkPaint*) SK_OVERRIDE;
@ -732,7 +732,7 @@ void SkGPipeCanvas::drawBitmap(const SkBitmap& bm, SkScalar left, SkScalar top,
}
}
void SkGPipeCanvas::drawBitmapRectToRect(const SkBitmap& bm, const SkRect* src,
void SkGPipeCanvas::drawBitmapRect(const SkBitmap& bm, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) {
NOTIFY_SETUP(this);
size_t opBytesNeeded = sizeof(SkRect);
@ -745,9 +745,12 @@ void SkGPipeCanvas::drawBitmapRectToRect(const SkBitmap& bm, const SkRect* src,
flags = 0;
}
if (this->commonDrawBitmap(bm, kDrawBitmapRectToRect_DrawOp, flags, opBytesNeeded, paint)) {
if (this->commonDrawBitmap(bm, kDrawBitmapRect_DrawOp, flags, opBytesNeeded, paint)) {
if (hasSrc) {
fWriter.writeRect(*src);
fWriter.write32(src->fLeft);
fWriter.write32(src->fTop);
fWriter.write32(src->fRight);
fWriter.write32(src->fBottom);
}
fWriter.writeRect(dst);
}

10
src/utils/SkDeferredCanvas.cpp
View File

@ -856,10 +856,10 @@ void SkDeferredCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar left,
this->recordedDrawCommand();
}
void SkDeferredCanvas::drawBitmapRectToRect(const SkBitmap& bitmap,
const SkRect* src,
const SkRect& dst,
const SkPaint* paint) {
void SkDeferredCanvas::drawBitmapRect(const SkBitmap& bitmap,
const SkIRect* src,
const SkRect& dst,
const SkPaint* paint) {
if (fDeferredDrawing &&
this->isFullFrame(&dst, paint) &&
isPaintOpaque(paint, &bitmap)) {
@ -867,7 +867,7 @@ void SkDeferredCanvas::drawBitmapRectToRect(const SkBitmap& bitmap,
}
AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
this->drawingCanvas()->drawBitmapRectToRect(bitmap, src, dst, paint);
this->drawingCanvas()->drawBitmapRect(bitmap, src, dst, paint);
this->recordedDrawCommand();
}

10
src/utils/SkDumpCanvas.cpp
View File

@ -318,21 +318,21 @@ void SkDumpCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
SkScalarToFloat(x), SkScalarToFloat(y));
}
void SkDumpCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint) {
void SkDumpCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* 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 < SkIntToScalar(bitmap.width()) ||
src->fBottom < SkIntToScalar(bitmap.height()))) {
src->fRight < bitmap.width() ||
src->fBottom < bitmap.height())) {
SkString ss;
toString(*src, &ss);
rs.prependf("%s ", ss.c_str());
}
this->dump(kDrawBitmap_Verb, paint, "drawBitmapRectToRect(%s %s)",
this->dump(kDrawBitmap_Verb, paint, "drawBitmapRect(%s %s)",
bs.c_str(), rs.c_str());
}

4
src/utils/SkNWayCanvas.cpp
View File

@ -194,11 +194,11 @@ void SkNWayCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
}
}
void SkNWayCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
void SkNWayCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) {
Iter iter(fList);
while (iter.next()) {
iter->drawBitmapRectToRect(bitmap, src, dst, paint);
iter->drawBitmapRect(bitmap, src, dst, paint);
}
}

4
src/utils/SkProxyCanvas.cpp
View File

@ -92,9 +92,9 @@ void SkProxyCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
fProxy->drawBitmap(bitmap, x, y, paint);
}
void SkProxyCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
void SkProxyCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
const SkRect& dst, const SkPaint* paint) {
fProxy->drawBitmapRectToRect(bitmap, src, dst, paint);
fProxy->drawBitmapRect(bitmap, src, dst, paint);
}
void SkProxyCanvas::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,