}
void onDraw(int loops, SkCanvas* canvas) override {
- SkISize dim = canvas->getDeviceSize();
+ SkISize dim = canvas->getBaseLayerSize();
if (fFlags & kScale_Flag) {
const SkScalar x = SkIntToScalar(dim.fWidth) / 2;
const SkScalar y = SkIntToScalar(dim.fHeight) / 2;
void onDraw(int loops, SkCanvas* canvas) override {
bool sizeChanged = false;
- if (canvas->getDeviceSize() != fSize) {
- fSize = canvas->getDeviceSize();
+ if (canvas->getBaseLayerSize() != fSize) {
+ fSize = canvas->getBaseLayerSize();
sizeChanged = true;
}
clearPaint.setColor(0xFF000000);
clearPaint.setAntiAlias(true);
- SkISize size = canvas->getDeviceSize();
+ SkISize size = canvas->getBaseLayerSize();
SkScalar maxTransX, maxTransY;
SkPaint paint;
paint.setFilterQuality(kMedium_SkFilterQuality);
-
+ paint.setColor(SK_ColorWHITE);
for (int i = 0; i < loops; i++) {
// Touch surface so mips are dirtied
- fSurface->getCanvas()->drawPoint(0, 0, SK_ColorWHITE);
+ fSurface->getCanvas()->drawPoint(0, 0, paint);
// Draw reduced version of surface to original canvas, to trigger mip generation
canvas->save();
void onDraw(int loops, SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
- SkISize size = canvas->getDeviceSize();
+ SkISize size = canvas->getBaseLayerSize();
int offX = (size.width() - kWindowSize) / kNumStepsX;
int offY = (size.height() - kWindowSize) / kNumStepsY;
}
void onDraw(int loops, SkCanvas* canvas) override {
- SkISize size = canvas->getDeviceSize();
+ SkISize size = canvas->getBaseLayerSize();
canvas->clear(0xFFFF0000);
void onDraw(int loops, SkCanvas* canvas) override {
const char* text = "Hamburgefons";
size_t len = strlen(text);
- SkISize size = canvas->getDeviceSize();
+ SkISize size = canvas->getBaseLayerSize();
SkRandom random;
for (int i = 0; i < loops; ++i) {
SkPaint paint;
canvas->translate(0, y);
canvas->rotate(1);
- canvas->drawRectCoords(20, 20, 200, 200, p);
+ canvas->drawRect({ 20, 20, 200, 200 }, p);
canvas->restore();
y += 200;
canvas->translate(0, y);
canvas->rotate(1);
- canvas->drawRectCoords(20, 20, 20.2f, 200, p);
- canvas->drawRectCoords(20, 200, 200, 200.1f, p);
+ canvas->drawRect({ 20, 20, 20.2f, 200 }, p);
+ canvas->drawRect({ 20, 200, 200, 200.1f }, p);
canvas->drawCircle(100, 100, 30, p);
canvas->restore();
// Just clear the dst, we need to preserve the paint's opacity.
dimPaint.setARGB(0, 0, 0, 0);
}
- canvas->drawRectCoords(-kShapeSpacing/2, -kShapeSpacing/2,
- kShapeSpacing/2 + 3 * kShapeTypeSpacing,
- kShapeSpacing/2, dimPaint);
+ canvas->drawRect({ -kShapeSpacing/2, -kShapeSpacing/2,
+ kShapeSpacing/2 + 3 * kShapeTypeSpacing, kShapeSpacing/2 },
+ dimPaint);
}
}
}
switch (shape) {
case kSquare_Shape:
- canvas->drawRectCoords(-kShapeSize/2, -kShapeSize/2, kShapeSize/2, kShapeSize/2,
- shapePaint);
+ canvas->drawRect({ -kShapeSize/2, -kShapeSize/2, kShapeSize/2, kShapeSize/2 },
+ shapePaint);
break;
case kDiamond_Shape:
canvas->save();
canvas->rotate(45);
- canvas->drawRectCoords(-kShapeSize/2, -kShapeSize/2, kShapeSize/2, kShapeSize/2,
- shapePaint);
+ canvas->drawRect({ -kShapeSize/2, -kShapeSize/2, kShapeSize/2, kShapeSize/2 },
+ shapePaint);
canvas->restore();
break;
static void draw_checks(SkCanvas* canvas, int width, int height) {
SkPaint paint;
paint.setColor(SK_ColorRED);
- canvas->drawRectCoords(SkIntToScalar(0), SkIntToScalar(0),
- SkIntToScalar(width / 2), SkIntToScalar(height / 2), paint);
+ canvas->drawRect(SkRect::MakeIWH(width/2, height/2), paint);
paint.setColor(SK_ColorGREEN);
- canvas->drawRectCoords(SkIntToScalar(width / 2), SkIntToScalar(0),
- SkIntToScalar(width), SkIntToScalar(height / 2), paint);
+ canvas->drawRect({ SkIntToScalar(width/2), 0, SkIntToScalar(width), SkIntToScalar(height/2) },
+ paint);
paint.setColor(SK_ColorBLUE);
- canvas->drawRectCoords(SkIntToScalar(0), SkIntToScalar(height / 2),
- SkIntToScalar(width / 2), SkIntToScalar(height), paint);
+ canvas->drawRect({ 0, SkIntToScalar(height/2), SkIntToScalar(width/2), SkIntToScalar(height) },
+ paint);
paint.setColor(SK_ColorYELLOW);
- canvas->drawRectCoords(SkIntToScalar(width / 2), SkIntToScalar(height / 2),
- SkIntToScalar(width), SkIntToScalar(height), paint);
+ canvas->drawRect({ SkIntToScalar(width/2), SkIntToScalar(height/2), SkIntToScalar(width),
+ SkIntToScalar(height) }, paint);
}
class BitmapCopyGM : public GM {
void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setColor(SK_ColorGREEN);
- canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), paint);
+ canvas->drawRect(SkRect::MakeWH(100, 100), paint);
paint.setShader(fShader);
- canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), paint);
+ canvas->drawRect(SkRect::MakeWH(100, 100), paint);
}
protected:
SkPaint bgPaint;
bgPaint.setAlpha(0x15);
- SkISize size = canvas->getDeviceSize();
+ SkISize size = canvas->getBaseLayerSize();
canvas->drawBitmapRect(fBmp, SkRect::MakeIWH(size.fWidth, size.fHeight), &bgPaint);
constexpr char kTxt[] = "Clip Me!";
paint.setTextSize(SkIntToScalar(72));
paint.setLooper(fLooper);
- canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50),
- SkIntToScalar(30), paint);
-
- canvas->drawRectCoords(SkIntToScalar(150), SkIntToScalar(50),
- SkIntToScalar(200), SkIntToScalar(100), paint);
-
- canvas->drawText("Looper", 6, SkIntToScalar(230), SkIntToScalar(100),
- paint);
+ canvas->drawCircle(50, 50, 30, paint);
+ canvas->drawRect({ 150, 50, 200, 100 }, paint);
+ canvas->drawText("Looper", 6, 230, 100, paint);
}
private:
SkScalar strokeWidth,
SkPaint::Style strokeStyle) {
// There's a black pixel at 40, 40 for reference.
- canvas->drawPoint(40.0f, 40.0f, SK_ColorBLACK);
-
- // Two reference images.
- canvas->translate(50.0f, 50.0f);
- drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
-
- canvas->translate(0.0f, 50.0f);
- drawTestCase(canvas, 3.0f, strokeWidth, strokeStyle);
-
- // Uniform scaling test.
- canvas->translate(0.0f, 100.0f);
- canvas->save();
- canvas->scale(3.0f, 3.0f);
- drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
- canvas->restore();
-
- // Non-uniform scaling test.
- canvas->translate(0.0f, 100.0f);
- canvas->save();
- canvas->scale(3.0f, 6.0f);
- drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
- canvas->restore();
-
- // Skew test.
- canvas->translate(0.0f, 80.0f);
- canvas->save();
- canvas->scale(3.0f, 3.0f);
- SkMatrix skew;
- skew.setIdentity();
- skew.setSkewX(8.0f / 25.0f);
- skew.setSkewY(2.0f / 25.0f);
- canvas->concat(skew);
- drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
- canvas->restore();
-
- // Perspective test.
- canvas->translate(0.0f, 80.0f);
- canvas->save();
- SkMatrix perspective;
- perspective.setIdentity();
- perspective.setPerspX(-SkScalarInvert(340));
- perspective.setSkewX(8.0f / 25.0f);
- perspective.setSkewY(2.0f / 25.0f);
-
- canvas->concat(perspective);
- drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
- canvas->restore();
+ canvas->drawPoint(40, 40, SkPaint());
+
+ // Two reference images.
+ canvas->translate(50.0f, 50.0f);
+ drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
+
+ canvas->translate(0.0f, 50.0f);
+ drawTestCase(canvas, 3.0f, strokeWidth, strokeStyle);
+
+ // Uniform scaling test.
+ canvas->translate(0.0f, 100.0f);
+ canvas->save();
+ canvas->scale(3.0f, 3.0f);
+ drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
+ canvas->restore();
+
+ // Non-uniform scaling test.
+ canvas->translate(0.0f, 100.0f);
+ canvas->save();
+ canvas->scale(3.0f, 6.0f);
+ drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
+ canvas->restore();
+
+ // Skew test.
+ canvas->translate(0.0f, 80.0f);
+ canvas->save();
+ canvas->scale(3.0f, 3.0f);
+ SkMatrix skew;
+ skew.setIdentity();
+ skew.setSkewX(8.0f / 25.0f);
+ skew.setSkewY(2.0f / 25.0f);
+ canvas->concat(skew);
+ drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
+ canvas->restore();
+
+ // Perspective test.
+ canvas->translate(0.0f, 80.0f);
+ canvas->save();
+ SkMatrix perspective;
+ perspective.setIdentity();
+ perspective.setPerspX(-SkScalarInvert(340));
+ perspective.setSkewX(8.0f / 25.0f);
+ perspective.setSkewY(2.0f / 25.0f);
+
+ canvas->concat(perspective);
+ drawTestCase(canvas, 1.0f, strokeWidth, strokeStyle);
+ canvas->restore();
}
static void drawTestCase(SkCanvas* canvas,
paint.setColor(SK_ColorBLACK);
surface->getCanvas()->drawLine(start.x(), start.y(), end.x(), end.y(), paint);
- surface->getCanvas()->drawPoint(start.x(), start.y(), color);
- surface->getCanvas()->drawPoint(end.x(), end.y(), color);
+
+ paint.reset();
+ paint.setColor(color);
+ const SkPoint pts[] = { start, end };
+ surface->getCanvas()->drawPoints(SkCanvas::kPoints_PointMode, 2, pts, paint);
return surface->makeImageSnapshot();
}
// Draw background rect
SkPaint backgroundPaint;
backgroundPaint.setColor(backgroundColor);
- canvas->drawRectCoords(0, 0, SkIntToScalar(kColWidth), SkIntToScalar(kHeight),
- backgroundPaint);
+ canvas->drawRect(SkRect::MakeIWH(kColWidth, kHeight), backgroundPaint);
SkScalar y = fTextHeight;
for (size_t m = 0; m < SK_ARRAY_COUNT(gModes); m++) {
SkPaint paint;
class PointSnapGM : public PixelSnapGM {
protected:
SkString onShortName() override { return SkString("pixel_snap_point"); }
- void drawElement(SkCanvas* canvas) override { canvas->drawPoint(1, 1, SK_ColorBLUE); }
+ void drawElement(SkCanvas* canvas) override {
+ const SkPoint pt = { 1, 1 };
+ SkPaint paint;
+ paint.setColor(SK_ColorBLUE);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 1, &pt, paint);
+ }
private:
typedef PixelSnapGM INHERITED;
// order lines (green), points (blue), rect(red).
SkRect rect = SkRect::MakeXYWH(3, 3, 1, 1);
paint.setColor(SK_ColorGREEN);
- canvas->drawLine(3, 3, 0, 3, paint);
- canvas->drawLine(3, 3, 3, 0, paint);
- canvas->drawLine(4, 3, 7, 3, paint);
- canvas->drawLine(4, 3, 4, 0, paint);
- canvas->drawLine(3, 4, 0, 4, paint);
- canvas->drawLine(3, 4, 3, 7, paint);
- canvas->drawLine(4, 4, 7, 4, paint);
- canvas->drawLine(4, 4, 4, 7, paint);
- canvas->drawPoint(4, 3, SK_ColorBLUE);
- canvas->drawPoint(4, 4, SK_ColorBLUE);
- canvas->drawPoint(3, 3, SK_ColorBLUE);
- canvas->drawPoint(3, 4, SK_ColorBLUE);
+ const SkPoint lines[] = {
+ { 3, 3 }, { 0, 3 },
+ { 3, 3 }, { 3, 0 },
+ { 4, 3 }, { 7, 3 },
+ { 4, 3 }, { 4, 0 },
+ { 3, 4 }, { 0, 4 },
+ { 3, 4 }, { 3, 7 },
+ { 4, 4 }, { 7, 4 },
+ { 4, 4 }, { 4, 7 },
+ };
+ canvas->drawPoints(SkCanvas::kLines_PointMode, SK_ARRAY_COUNT(lines), lines, paint);
+
+ const SkPoint pts[] = {
+ { 4, 3 }, { 4, 4, }, { 3, 3 }, { 3, 4 },
+ };
+ paint.setColor(SK_ColorBLUE);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, SK_ARRAY_COUNT(pts), pts, paint);
+
paint.setColor(SK_ColorRED);
canvas->drawRect(rect, paint);
}
paint->setColor(sk_tool_utils::color_to_565(SK_ColorGRAY));
paint->setStyle(SkPaint::kStroke_Style);
- const SkScalar D = SkIntToScalar(64);
- canvas->drawRectCoords(0, 0, D, D, *paint);
+ const SkScalar D = 64;
+ canvas->drawRect(SkRect::MakeWH(D, D), *paint);
canvas->drawLine(0, 0, D, D, *paint);
canvas->drawLine(0, D, D, 0, *paint);
SkCanvas* canvas = surf->getCanvas();
canvas->clear(SK_ColorRED);
- canvas->drawPoint(1.5f, 1.5f, SK_ColorGREEN);
- canvas->drawPoint(2.5f, 1.5f, SK_ColorBLUE);
- canvas->drawPoint(1.5f, 2.5f, SK_ColorCYAN);
- canvas->drawPoint(2.5f, 2.5f, SK_ColorGRAY);
-
+ const struct {
+ SkPoint fPt;
+ SkColor fColor;
+ } rec[] = {
+ { { 1.5f, 1.5f }, SK_ColorGREEN },
+ { { 2.5f, 1.5f }, SK_ColorBLUE },
+ { { 1.5f, 2.5f }, SK_ColorCYAN },
+ { { 2.5f, 2.5f }, SK_ColorGRAY },
+ };
+ SkPaint paint;
+ for (const auto& r : rec) {
+ paint.setColor(r.fColor);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 1, &r.fPt, paint);
+ }
return surf->makeImageSnapshot();
} else {
SkBitmap bm;
paint.setShader(SkShader::MakeBitmapShader(fBitmap, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &mat));
- canvas->drawRectCoords(8,8,1008, 608, paint);
+ canvas->drawRect({ 8, 8, 1008, 608 }, paint);
}
private:
"SK_SUPPORT_LEGACY_SHADER_ISABITMAP",
"SK_SUPPORT_LEGACY_EMBOSSMASKFILTER",
"SK_SUPPORT_EXOTIC_CLIPOPS",
+ "SK_SUPPORT_LEGACY_CANVAS_HELPERS",
]
*/
virtual SkISize getBaseLayerSize() const;
+#ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
/**
* DEPRECATED: call getBaseLayerSize
*/
SkISize getDeviceSize() const { return this->getBaseLayerSize(); }
+#endif
/**
* Create a new surface matching the specified info, one that attempts to
return !bounds->isEmpty();
}
+#ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
/** Fill the entire canvas' bitmap (restricted to the current clip) with the
specified ARGB color, using the specified mode.
@param a the alpha component (0..255) of the color to fill the canvas
@param mode the mode to apply the color in (defaults to SrcOver)
*/
void drawARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b, SkBlendMode mode = SkBlendMode::kSrcOver);
+#endif
/** Fill the entire canvas' bitmap (restricted to the current clip) with the
specified color and mode.
*/
void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint);
- /** Helper method for drawing a single point. See drawPoints() for a more
- details.
- */
+ /** Helper method for drawing a single point. See drawPoints() for more details.
+ */
void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint);
+#ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
/** Draws a single pixel in the specified color.
@param x The X coordinate of which pixel to draw
@param y The Y coordiante of which pixel to draw
@param color The color to draw
*/
void drawPoint(SkScalar x, SkScalar y, SkColor color);
+#endif
/** Draw a line segment with the specified start and stop x,y coordinates,
using the specified paint. NOTE: since a line is always "framed", the
@param y1 The y-coordinate of the end point of the line
@param paint The paint used to draw the line
*/
- void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1,
- const SkPaint& paint);
+ void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint& paint);
/** Draw the specified rectangle using the specified paint. The rectangle
will be filled or stroked based on the Style in the paint.
this->drawRect(r, paint);
}
+#ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
/** Draw the specified rectangle using the specified paint. The rectangle
will be filled or framed based on the Style in the paint.
@param left The left side of the rectangle to be drawn
*/
void drawRectCoords(SkScalar left, SkScalar top, SkScalar right,
SkScalar bottom, const SkPaint& paint);
+#endif
/** Draw the outline of the specified region using the specified paint.
@param region The region to be drawn
@param radius The radius of the cirle to be drawn
@param paint The paint used to draw the circle
*/
- void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius,
- const SkPaint& paint);
+ void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint& paint);
/** Draw the specified arc, which will be scaled to fit inside the
specified oval. Sweep angles are not treated as modulo 360 and thus can
@param ry The y-radius of the oval used to round the corners
@param paint The paint used to draw the roundRect
*/
- void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry,
- const SkPaint& paint);
+ void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, const SkPaint& paint);
/** Draw the specified path using the specified paint. The path will be
filled or framed based on the Style in the paint.
"SK_NO_ANALYTIC_AA",
"SK_SUPPORT_LEGACY_BITMAP_SETPIXELREF",
"SK_SUPPORT_LEGACY_CLIPOP_EXOTIC_NAMES",
+ "SK_SUPPORT_LEGACY_CANVAS_HELPERS",
]
################################################################################
void onDrawContent(SkCanvas* canvas) override {
bool sizeChanged = false;
- if (canvas->getDeviceSize() != fSize) {
- fSize = canvas->getDeviceSize();
+ if (canvas->getBaseLayerSize() != fSize) {
+ fSize = canvas->getBaseLayerSize();
sizeChanged = true;
}
} break;
}
- SkISize size = canvas->getDeviceSize();
+ SkISize size = canvas->getBaseLayerSize();
SkRect bigR = SkRect::MakeWH(SkIntToScalar(size.width()), SkIntToScalar(size.height()));
SkPaint p;
}
void onDrawContent(SkCanvas* canvas) override {
- SkISize dsize = canvas->getDeviceSize();
+ SkISize dsize = canvas->getBaseLayerSize();
canvas->clear(0xFFF0E0F0);
for (int i = 0; i < N; ++i) {
paint->setColor(SK_ColorGRAY);
paint->setStyle(SkPaint::kStroke_Style);
const SkScalar D = SkIntToScalar(64);
- canvas->drawRectCoords(0, 0, D, D, *paint);
+ canvas->drawRect(SkRect::MakeWH(D, D), *paint);
canvas->drawLine(0, 0, D, D, *paint);
canvas->drawLine(0, D, D, 0, *paint);
void onDrawContent(SkCanvas* canvas) override {
canvas->drawBitmap(fBitmap, 0, 0);
- canvas->translate(SkIntToScalar(20), SkIntToScalar(120));
+ canvas->translate(20, 120);
SkPaint paint;
SkRect r;
paint.setColor(SK_ColorGREEN);
- canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), paint);
+ canvas->drawRect(SkRect::MakeWH(100, 100), paint);
paint.setShader(fShader);
- canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), paint);
+ canvas->drawRect(SkRect::MakeWH(100, 100), paint);
canvas->translate(SkIntToScalar(110), 0);
// methods, rather than actually drawing themselves.
//////////////////////////////////////////////////////////////////////////////
+#ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
void SkCanvas::drawARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b, SkBlendMode mode) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawARGB()");
SkPaint paint;
paint.setBlendMode(mode);
this->drawPaint(paint);
}
+#endif
void SkCanvas::drawColor(SkColor c, SkBlendMode mode) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawColor()");
void SkCanvas::drawPoint(SkScalar x, SkScalar y, const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawPoint(SkPaint)");
- SkPoint pt;
-
- pt.set(x, y);
+ const SkPoint pt = { x, y };
this->drawPoints(kPoints_PointMode, 1, &pt, paint);
}
+#ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
void SkCanvas::drawPoint(SkScalar x, SkScalar y, SkColor color) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawPoint(SkColor)");
SkPoint pt;
paint.setColor(color);
this->drawPoints(kPoints_PointMode, 1, &pt, paint);
}
+#endif
-void SkCanvas::drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1,
- const SkPaint& paint) {
+void SkCanvas::drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawLine()");
SkPoint pts[2];
this->drawPoints(kLines_PointMode, 2, pts, paint);
}
+#ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
void SkCanvas::drawRectCoords(SkScalar left, SkScalar top,
SkScalar right, SkScalar bottom,
const SkPaint& paint) {
r.set(left, top, right, bottom);
this->drawRect(r, paint);
}
+#endif
-void SkCanvas::drawCircle(SkScalar cx, SkScalar cy, SkScalar radius,
- const SkPaint& paint) {
+void SkCanvas::drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint& paint) {
TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawCircle()");
if (radius < 0) {
radius = 0;
void SkCanvasStack::pushCanvas(std::unique_ptr<SkCanvas> canvas, const SkIPoint& origin) {
if (canvas) {
// compute the bounds of this canvas
- const SkIRect canvasBounds = SkIRect::MakeSize(canvas->getDeviceSize());
+ const SkIRect canvasBounds = SkIRect::MakeSize(canvas->getBaseLayerSize());
// push the canvas onto the stack
this->INHERITED::addCanvas(canvas.get());
// Record a set of canvas draw commands
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(1000.0f, 1000.0f);
- canvas->drawPoint(42.0f, 17.0f, SK_ColorGREEN);
SkPaint paint;
+ paint.setColor(SK_ColorGREEN);
+ canvas->drawPoint(42.0f, 17.0f, paint);
paint.setColor(SK_ColorRED);
canvas->drawPaint(paint);
SkPaint textPaint;
SkBits2Float(0x41000000), SkBits2Float(0x431e0000), SkBits2Float(0x3f3504f3));
path.close();
canvas->clipPath(path, true);
- canvas->drawRectCoords(0, 0, 250, 250, paint);
+ canvas->drawRect(SkRect::MakeWH(250, 250), paint);
}
static void test_mask_overflow() {
SkPaint paint;
paint.setAntiAlias(true);
surface->getCanvas()->clipPath(path, true);
- surface->getCanvas()->drawRectCoords(0, 0, 100, 100, paint);
+ surface->getCanvas()->drawRect(SkRect::MakeWH(100, 100), paint);
}
static void test_path_crbugskia6003() {
path.lineTo(SkBits2Float(0x4325e666), SkBits2Float(0x42a1999a)); // 165.9f, 80.8f
path.close();
canvas->clipPath(path, true);
- canvas->drawRectCoords(0, 0, 500, 500, paint);
+ canvas->drawRect(SkRect::MakeWH(500, 500), paint);
}
static void test_fuzz_crbug_662730(skiatest::Reporter* reporter) {
REPORTER_ASSERT(reporter, empty->uniqueID() != SK_InvalidGenID);
SkCanvas* canvas = recorder.beginRecording(1, 1);
- canvas->drawARGB(255, 255, 255, 255);
+ canvas->drawColor(SK_ColorWHITE);
sk_sp<SkPicture> hasData(recorder.finishRecordingAsPicture());
// picture should have a non-zero id after recording
REPORTER_ASSERT(reporter, hasData->uniqueID() != SK_InvalidGenID);
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(100, 100);
- canvas->drawARGB(0, 0, 0, 0);
+ canvas->drawColor(0);
canvas->saveLayer(0, &semiTransparent);
canvas->drawBitmap(blueBM, 25, 25);
rect.fLeft, rect.fTop));
// we should change the genID iff pixels were actually written.
- SkIRect canvasRect = SkIRect::MakeSize(canvas.getDeviceSize());
+ SkIRect canvasRect = SkIRect::MakeSize(canvas.getBaseLayerSize());
SkIRect writeRect = SkIRect::MakeXYWH(rect.fLeft, rect.fTop,
bmp.width(), bmp.height());
bool intersects = SkIRect::Intersects(canvasRect, writeRect) ;
}
paint.setColor(0xFF000000);
paint.setStrokeWidth(3.0f);
- canvas->drawRectCoords(ox, oy - gammaHeight, ox + gammaWidth, oy, paint);
+ canvas->drawRect({ ox, oy - gammaHeight, ox + gammaWidth, oy }, paint);
}
/**
namespace {
void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {
- const SkISize& size = canvas->getDeviceSize();
+ const SkISize& size = canvas->getBaseLayerSize();
static const SkScalar kInsetFrac = 0.9f; // Leave a border around object
}
void render_bitmap(SkCanvas* canvas, const SkBitmap& input, const SkRect* srcRect = nullptr) {
- const SkISize& size = canvas->getDeviceSize();
+ const SkISize& size = canvas->getBaseLayerSize();
SkScalar xScale = SkIntToScalar(size.fWidth-2) / input.width();
SkScalar yScale = SkIntToScalar(size.fHeight-2) / input.height();
static const int kGraphPadding = 3;
static const SkScalar kBaseMS = 1000.f / 60.f; // ms/frame to hit 60 fps
- SkISize canvasSize = canvas->getDeviceSize();
+ SkISize canvasSize = canvas->getBaseLayerSize();
SkRect rect = SkRect::MakeXYWH(SkIntToScalar(canvasSize.fWidth-kDisplayWidth-kDisplayPadding),
SkIntToScalar(kDisplayPadding),
SkIntToScalar(kDisplayWidth), SkIntToScalar(kDisplayHeight));