paint.setColor(0xFF884422);
paint.setTextSize(SkIntToScalar(96));
const char* str = "g";
- canvas.drawText(str, strlen(str), SkIntToScalar(15), SkIntToScalar(55), paint);
+ canvas.drawString(str, SkIntToScalar(15), SkIntToScalar(55), paint);
}
void makeCheckerboard() {
for (int ps = 9; ps <= 24; ps += 2) {
paint.setTextSize(SkIntToScalar(ps));
- canvas->drawText(fText.c_str(), fText.size(),
+ canvas->drawString(fText,
0, SkIntToScalar(20), paint);
}
}
paint.setColor(0xFF884422);
paint.setTextSize(SkIntToScalar(96));
const char* str = "g";
- surface->getCanvas()->drawText(str, strlen(str), 15, 55, paint);
+ surface->getCanvas()->drawString(str, 15, 55, paint);
return surface->makeImageSnapshot();
}
for (int i = 0; i < loops; i++) {
SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
- canvas->drawText(fText.c_str(), fText.size(), x, y, paint);
+ canvas->drawString(fText, x, y, paint);
}
paint.setTextSize(SkIntToScalar(48));
for (int i = 0; i < loops / 4 ; i++) {
SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
- canvas->drawText(fText.c_str(), fText.size(), x, y, paint);
+ canvas->drawString(fText, x, y, paint);
}
}
} else {
SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
- canvas->drawText(fText.c_str(), fText.size(), x, y, paint);
+ canvas->drawString(fText, x, y, paint);
}
}
}
paint.setColor(0xFF884422);
paint.setTextSize(SkIntToScalar(kBitmapSize/2));
const char* str = "g";
- canvas.drawText(str, strlen(str), SkIntToScalar(kBitmapSize/8),
+ canvas.drawString(str, SkIntToScalar(kBitmapSize/8),
SkIntToScalar(kBitmapSize/4), paint);
}
canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
paint.setColor(SK_ColorBLACK);
paint.setTextSize(SkIntToScalar(kBitmapSize/3));
- canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
+ canvas->drawString("Picture", SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
}
static sk_sp<SkColorFilter> make_color_filter() {
if (kShape_Pass == drawingPass) {
fLabelPaint.setTextAlign(SkPaint::kCenter_Align);
- canvas->drawText("Src Unknown", sizeof("Src Unknown") - 1,
+ canvas->drawString("Src Unknown",
kLabelSpacing + kShapeTypeSpacing * 1.5f + kShapeSpacing / 2,
kSubtitleSpacing / 2 + fLabelPaint.getTextSize() / 3, fLabelPaint);
- canvas->drawText("Src Opaque", sizeof("Src Opaque") - 1,
+ canvas->drawString("Src Opaque",
kLabelSpacing + kShapeTypeSpacing * 1.5f + kShapeSpacing / 2 +
kPaintSpacing, kSubtitleSpacing / 2 + fLabelPaint.getTextSize() / 3,
fLabelPaint);
titlePaint.setTextSize(9 * titlePaint.getTextSize() / 8);
titlePaint.setFakeBoldText(true);
titlePaint.setTextAlign(SkPaint::kCenter_Align);
- canvas->drawText("Porter Duff", sizeof("Porter Duff") - 1,
+ canvas->drawString("Porter Duff",
kLabelSpacing + 4 * kShapeTypeSpacing,
kTitleSpacing / 2 + titlePaint.getTextSize() / 3, titlePaint);
- canvas->drawText("Advanced", sizeof("Advanced") - 1,
+ canvas->drawString("Advanced",
kXfermodeTypeSpacing + kLabelSpacing + 4 * kShapeTypeSpacing,
kTitleSpacing / 2 + titlePaint.getTextSize() / 3, titlePaint);
void drawModeName(SkCanvas* canvas, SkBlendMode mode) {
const char* modeName = SkBlendMode_Name(mode);
fLabelPaint.setTextAlign(SkPaint::kRight_Align);
- canvas->drawText(modeName, strlen(modeName), kLabelSpacing - kShapeSize / 4,
+ canvas->drawString(modeName, kLabelSpacing - kShapeSize / 4,
fLabelPaint.getTextSize() / 4, fLabelPaint);
}
const char text[]) {
SkASSERT(src.colorType() == colorType);
canvas->drawBitmap(src, 0.0f, 0.0f);
- canvas->drawText(text, strlen(text), 0.0f, 12.0f, p);
+ canvas->drawString(text, 0.0f, 12.0f, p);
}
DEF_SIMPLE_GM(all_bitmap_configs, canvas, SCALE, 6 * SCALE) {
SkPaint paint;
SkRect bounds;
paint.measureText(errorText.c_str(), errorText.size(), &bounds);
- canvas->drawText(errorText.c_str(), errorText.size(), kOffset, bounds.height() + kOffset,
+ canvas->drawString(errorText, kOffset, bounds.height() + kOffset,
paint);
}
}
SkString str;
str.appendScalar(k[i]);
SkScalar width = paint.measureText(str.c_str(), str.size());
- canvas->drawText(str.c_str(), str.size(), x, y + paint.getTextSize(), paint);
+ canvas->drawString(str, x, y + paint.getTextSize(), paint);
x += width + SkIntToScalar(10);
}
}
paint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&paint);
SkString str(enforcePMColor ? "enforcePM" : "no enforcePM");
- canvas->drawText(str.c_str(), str.size(), 0, paint.getTextSize(), paint);
+ canvas->drawString(str, 0, paint.getTextSize(), paint);
}
canvas->translate(0, HH + 12);
}
};
paint.setColor(SK_ColorRED);
- canvas->drawText("/", 1, pos.fX, pos.fY, paint);
+ canvas->drawString("/", pos.fX, pos.fY, paint);
paint.setColor(SK_ColorBLUE);
canvas->drawPosText("\\", 1, &pos, paint);
SkScalar textWidth = paint.measureText(name, strlen(name));
SkScalar x = (width - textWidth) / SkScalar(2);
SkScalar y = paint.getFontSpacing() / SkScalar(2);
- canvas->drawText(name, strlen(name), x, y, paint);
+ canvas->drawString(name, x, y, paint);
// Draw destination bitmap
canvas->translate(0, vertOffset);
paint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&paint);
const char* name = sk_tool_utils::colortype_name(bm.colorType());
- canvas->drawText(name, strlen(name), x, SkIntToScalar(bm.height())*scale*5/8,
+ canvas->drawString(name, x, SkIntToScalar(bm.height())*scale*5/8,
paint);
canvas->translate(SkIntToScalar(48), 0);
SkScalar x = SkIntToScalar(70);
SkScalar y = SkIntToScalar(400);
paint.setColor(SK_ColorBLACK);
- canvas->drawText("Hamburgefons Style", 18, x, y, paint);
- canvas->drawText("Hamburgefons Style", 18,
+ canvas->drawString("Hamburgefons Style", x, y, paint);
+ canvas->drawString("Hamburgefons Style",
x, y + SkIntToScalar(50), paint);
paint.setMaskFilter(nullptr);
paint.setColor(SK_ColorWHITE);
x -= SkIntToScalar(2);
y -= SkIntToScalar(2);
- canvas->drawText("Hamburgefons Style", 18, x, y, paint);
+ canvas->drawString("Hamburgefons Style", x, y, paint);
}
canvas->restore();
flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
bmpPaint.setShader(SkShader::MakeBitmapShader(fBmp, kTM, kTM, &lm));
bmpPaint.setFilterQuality(kQualities[q].fQuality);
canvas->drawRect(rect, bmpPaint);
- canvas->drawText(kQualities[q].fName, strlen(kQualities[q].fName), 20, 40, textPaint);
+ canvas->drawString(kQualities[q].fName, 20, 40, textPaint);
canvas->translate(250, 0);
}
paint.setTextSize(textSize);
paint.getFontMetrics(&metrics);
y += -metrics.fAscent;
- canvas->drawText(text, strlen(text), 10, y, paint);
+ canvas->drawString(text, 10, y, paint);
y += metrics.fDescent + metrics.fLeading;
}
shaderPaint.setTextSize(30);
shaderPaint.getFontMetrics(&metrics);
y += -metrics.fAscent;
- canvas->drawText(text, strlen(text), 380, y, shaderPaint);
+ canvas->drawString(text, 380, y, shaderPaint);
y += metrics.fDescent + metrics.fLeading;
}
}
canvas->save();
canvas->drawRect(clipRect, clipHairline);
paint.setAlpha(0x20);
- canvas->drawText(text, strlen(text), 0, 0, paint);
+ canvas->drawString(text, 0, 0, paint);
canvas->clipRect(clipRect);
paint.setAlpha(0xFF);
- canvas->drawText(text, strlen(text), 0, 0, paint);
+ canvas->drawString(text, 0, 0, paint);
canvas->restore();
canvas->translate(0, SkIntToScalar(25));
}
}
#if 1
const char* label = SkBlendMode_Name(gModes[i]);
- canvas->drawText(label, strlen(label), x + w/2, y - labelP.getTextSize()/2, labelP);
+ canvas->drawString(label, x + w/2, y - labelP.getTextSize()/2, labelP);
#endif
x += w + SkIntToScalar(10);
if ((i % W) == W - 1) {
canvas->clear(sk_tool_utils::color_to_565(SK_ColorLTGRAY));
paint.setColor(SK_ColorRED);
- canvas->drawText("R", 1, 8.0f, 20.0f, paint);
+ canvas->drawString("R", 8.0f, 20.0f, paint);
paint.setColor(SK_ColorGREEN);
- canvas->drawText("G", 1, 24.0f, 20.0f, paint);
+ canvas->drawString("G", 24.0f, 20.0f, paint);
paint.setColor(SK_ColorBLUE);
- canvas->drawText("B", 1, 40.0f, 20.0f, paint);
+ canvas->drawString("B", 40.0f, 20.0f, paint);
paint.setColor(SK_ColorCYAN);
- canvas->drawText("C", 1, 56.0f, 20.0f, paint);
+ canvas->drawString("C", 56.0f, 20.0f, paint);
paint.setColor(SK_ColorMAGENTA);
- canvas->drawText("M", 1, 72.0f, 20.0f, paint);
+ canvas->drawString("M", 72.0f, 20.0f, paint);
paint.setColor(SK_ColorYELLOW);
- canvas->drawText("Y", 1, 88.0f, 20.0f, paint);
+ canvas->drawString("Y", 88.0f, 20.0f, paint);
paint.setColor(SK_ColorBLACK);
- canvas->drawText("K", 1, 104.0f, 20.0f, paint);
+ canvas->drawString("K", 104.0f, 20.0f, paint);
}
SkScalar txtX = SkIntToScalar(45);
paint.setColor(gClipAColor);
const char* aTxt = doInvA ? "InvA " : "A ";
- canvas->drawText(aTxt, strlen(aTxt), txtX, SkIntToScalar(220), paint);
+ canvas->drawString(aTxt, txtX, SkIntToScalar(220), paint);
txtX += paint.measureText(aTxt, strlen(aTxt));
paint.setColor(SK_ColorBLACK);
- canvas->drawText(gOps[op].fName, strlen(gOps[op].fName),
- txtX, SkIntToScalar(220), paint);
+ canvas->drawString(gOps[op].fName, txtX, SkIntToScalar(220), paint);
txtX += paint.measureText(gOps[op].fName, strlen(gOps[op].fName));
paint.setColor(gClipBColor);
const char* bTxt = doInvB ? "InvB " : "B ";
- canvas->drawText(bTxt, strlen(bTxt), txtX, SkIntToScalar(220), paint);
+ canvas->drawString(bTxt, txtX, SkIntToScalar(220), paint);
canvas->translate(SkIntToScalar(250),0);
}
doAAB ? "A" : "B",
doInvB ? "I" : "N");
- canvas->drawText(str.c_str(), strlen(str.c_str()), txtX, SkIntToScalar(130),
- paint);
+ canvas->drawString(str.c_str(), txtX, SkIntToScalar(130), paint);
if (doInvB) {
canvas->translate(SkIntToScalar(150),0);
} else {
// get the bounds of the text in order to position it
labelPaint.measureText(inputLabel.c_str(), inputLabel.size(),
&inputLabelBounds);
- canvas->drawText(inputLabel.c_str(), inputLabel.size(),
+ canvas->drawString(inputLabel,
renderRect.fRight + kPad,
-inputLabelBounds.fTop, labelPaint);
// update the bounds to reflect the offset we used to draw it.
SkRect procLabelBounds;
labelPaint.measureText(procLabel.c_str(), procLabel.size(),
&procLabelBounds);
- canvas->drawText(procLabel.c_str(), procLabel.size(),
+ canvas->drawString(procLabel,
renderRect.fRight + kPad,
inputLabelBounds.fBottom + 2.f - procLabelBounds.fTop,
labelPaint);
titlePaint.setTextSize(15 * SK_Scalar1);
const char title[] = "Cubic Drawn Into Rectangle Clips With "
"Indicated Style, Fill and Linecaps, with stroke width 10";
- canvas->drawText(title, strlen(title),
- 20 * SK_Scalar1,
- 20 * SK_Scalar1,
- titlePaint);
+ canvas->drawString(title,
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
SkRandom rand;
SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
labelPaint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelPaint);
labelPaint.setTextSize(10 * SK_Scalar1);
- canvas->drawText(gStyles[style].fName,
- strlen(gStyles[style].fName),
- 0, rect.height() + 12 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gFills[fill].fName,
- strlen(gFills[fill].fName),
- 0, rect.height() + 24 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gCaps[cap].fName,
- strlen(gCaps[cap].fName),
- 0, rect.height() + 36 * SK_Scalar1,
- labelPaint);
+ canvas->drawString(gStyles[style].fName,
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gFills[fill].fName,
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gCaps[cap].fName,
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
}
canvas->restore();
}
titlePaint.setTextSize(15 * SK_Scalar1);
const char title[] = "Cubic Closed Drawn Into Rectangle Clips With "
"Indicated Style, Fill and Linecaps, with stroke width 10";
- canvas->drawText(title, strlen(title),
- 20 * SK_Scalar1,
- 20 * SK_Scalar1,
- titlePaint);
+ canvas->drawString(title,
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
SkRandom rand;
SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
labelPaint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelPaint);
labelPaint.setTextSize(10 * SK_Scalar1);
- canvas->drawText(gStyles[style].fName,
- strlen(gStyles[style].fName),
- 0, rect.height() + 12 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gFills[fill].fName,
- strlen(gFills[fill].fName),
- 0, rect.height() + 24 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gCaps[cap].fName,
- strlen(gCaps[cap].fName),
- 0, rect.height() + 36 * SK_Scalar1,
- labelPaint);
+ canvas->drawString(gStyles[style].fName,
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gFills[fill].fName,
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gCaps[cap].fName,
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
}
canvas->restore();
}
sk_tool_utils::set_portable_typeface(&p);
const SkScalar intervals[] = { 12, 12 };
p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0));
- canvas->drawText("Sausages", 8, 10, 90, p);
+ canvas->drawString("Sausages", 10, 90, p);
canvas->drawLine(8, 120, 456, 120, p);
}
const char title[] = "Random Paths Drawn Into Rectangle Clips With "
"Indicated Style, Fill and Linecaps, "
"with Stroke width 6";
- canvas->drawText(title, strlen(title),
- 20 * SK_Scalar1,
- 20 * SK_Scalar1,
- titlePaint);
+ canvas->drawString(title,
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
SkRandom rand;
SkRect rect = SkRect::MakeWH(220*SK_Scalar1, 50*SK_Scalar1);
labelPaint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelPaint);
labelPaint.setTextSize(10 * SK_Scalar1);
- canvas->drawText(style.fName,
- strlen(style.fName),
- 0, rect.height() + 12 * SK_Scalar1,
- labelPaint);
- canvas->drawText(fill.fName,
- strlen(fill.fName),
- 0, rect.height() + 24 * SK_Scalar1,
- labelPaint);
- canvas->drawText(cap.fName,
- strlen(cap.fName),
- 0, rect.height() + 36 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gSegmentNames[s1],
- strlen(gSegmentNames[s1]),
- 0, rect.height() + 48 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gSegmentNames[s2],
- strlen(gSegmentNames[s2]),
- 0, rect.height() + 60 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gSegmentNames[s3],
- strlen(gSegmentNames[s3]),
- 0, rect.height() + 72 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gSegmentNames[s4],
- strlen(gSegmentNames[s4]),
- 0, rect.height() + 84 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gSegmentNames[s5],
- strlen(gSegmentNames[s5]),
- 0, rect.height() + 96 * SK_Scalar1,
- labelPaint);
+ canvas->drawString(style.fName,
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(fill.fName,
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(cap.fName,
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gSegmentNames[s1],
+ 0, rect.height() + 48 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gSegmentNames[s2],
+ 0, rect.height() + 60 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gSegmentNames[s3],
+ 0, rect.height() + 72 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gSegmentNames[s4],
+ 0, rect.height() + 84 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gSegmentNames[s5],
+ 0, rect.height() + 96 * SK_Scalar1,
+ labelPaint);
}
canvas->restore();
}
if (fEmojiTypeface) {
paint.setTypeface(fEmojiTypeface);
paint.setTextSize(SkIntToScalar(19));
- canvas->drawText(fEmojiText, strlen(fEmojiText), 670, 90, paint);
+ canvas->drawString(fEmojiText, 670, 90, paint);
}
#if SK_SUPPORT_GPU
// render offscreen buffer
paint.setTextSize(fTextSize);
setTypeface(&paint, "serif", SkFontStyle());
- canvas.drawText("Hamburgefons", 12, fTextSize/2, 1.2f*fTextSize, paint);
+ canvas.drawString("Hamburgefons", fTextSize/2, 1.2f*fTextSize, paint);
setTypeface(&paint, "serif", SkFontStyle::FromOldStyle(SkTypeface::kBold));
- canvas.drawText("Hamburgefons", 12, fTextSize/2, 2.4f*fTextSize, paint);
+ canvas.drawString("Hamburgefons", fTextSize/2, 2.4f*fTextSize, paint);
setTypeface(&paint, "serif", SkFontStyle::FromOldStyle(SkTypeface::kItalic));
- canvas.drawText("Hamburgefons", 12, fTextSize/2, 3.6f*fTextSize, paint);
+ canvas.drawString("Hamburgefons", fTextSize/2, 3.6f*fTextSize, paint);
setTypeface(&paint, "serif", SkFontStyle::FromOldStyle(SkTypeface::kBoldItalic));
- canvas.drawText("Hamburgefons", 12, fTextSize/2, 4.8f*fTextSize, paint);
+ canvas.drawString("Hamburgefons", fTextSize/2, 4.8f*fTextSize, paint);
}
private:
typedef DownsampleBitmapGM INHERITED;
for (int i = 0; i < numModes; ++i) {
const char* label = SkBlendMode_Name(gModes[i]);
- canvas->drawText(label, strlen(label),
+ canvas->drawString(label,
i*(target.width()+kPad)+kPad, SkIntToScalar(kTextPad),
textP);
}
sk_tool_utils::set_portable_typeface(&blackPaint);
SkString title;
title.printf("Bitmap size: %d x %d", gBmpSize, gBmpSize);
- canvas->drawText(title.c_str(), title.size(), 0,
+ canvas->drawString(title, 0,
titleHeight, blackPaint);
canvas->translate(0, SK_Scalar1 * kPadY / 2 + titleHeight);
blackPaint.setTextSize(SK_Scalar1 * 10);
SkScalar baseline = dstRect.height() +
blackPaint.getTextSize() + SK_Scalar1 * 3;
- canvas->drawText(label.c_str(), label.size(),
+ canvas->drawString(label,
0, baseline,
blackPaint);
blackPaint.setStyle(SkPaint::kStroke_Style);
canvas->drawCircle(50, 50, 30, paint);
canvas->drawRect({ 150, 50, 200, 100 }, paint);
- canvas->drawText("Looper", 6, 230, 100, paint);
+ canvas->drawString("Looper", 230, 100, paint);
}
private:
paint.setTextAlign(SkPaint::kCenter_Align);
canvas->save();
canvas->clipRect(r);
- canvas->drawText("Text", 4, r.centerX(), r.centerY(), paint);
+ canvas->drawString("Text", r.centerX(), r.centerY(), paint);
canvas->restore();
}
paint->setTextSize(100.f);
paint->setFakeBoldText(true);
sk_tool_utils::set_portable_typeface(paint);
- canvas->drawText(text, strlen(text), 0.f, 100.f, *paint);
+ canvas->drawString(text, 0.f, 100.f, *paint);
}
default:
break;
titlePaint.setTextSize(15 * SK_Scalar1);
const char title[] = "Empty Paths Drawn Into Rectangle Clips With "
"Indicated Style and Fill";
- canvas->drawText(title, strlen(title),
- 20 * SK_Scalar1,
- 20 * SK_Scalar1,
- titlePaint);
+ canvas->drawString(title,
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
SkRandom rand;
SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
labelPaint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelPaint);
labelPaint.setTextSize(12 * SK_Scalar1);
- canvas->drawText(gStyles[style].fName,
- strlen(gStyles[style].fName),
- 0, rect.height() + 15 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gFills[fill].fName,
- strlen(gFills[fill].fName),
- 0, rect.height() + 28 * SK_Scalar1,
- labelPaint);
+ canvas->drawString(gStyles[style].fName,
+ 0, rect.height() + 15 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gFills[fill].fName,
+ 0, rect.height() + 28 * SK_Scalar1,
+ labelPaint);
}
}
canvas->restore();
paint.setTextSize(fTextSize);
setTypeface(&paint, "serif", SkFontStyle());
- canvas.drawText("Hamburgefons", 12, fTextSize/2, 1.2f*fTextSize, paint);
+ canvas.drawString("Hamburgefons", fTextSize/2, 1.2f*fTextSize, paint);
setTypeface(&paint, "serif", SkFontStyle::FromOldStyle(SkTypeface::kBold));
- canvas.drawText("Hamburgefons", 12, fTextSize/2, 2.4f*fTextSize, paint);
+ canvas.drawString("Hamburgefons", fTextSize/2, 2.4f*fTextSize, paint);
setTypeface(&paint, "serif", SkFontStyle::FromOldStyle(SkTypeface::kItalic));
- canvas.drawText("Hamburgefons", 12, fTextSize/2, 3.6f*fTextSize, paint);
+ canvas.drawString("Hamburgefons", fTextSize/2, 3.6f*fTextSize, paint);
setTypeface(&paint, "serif", SkFontStyle::FromOldStyle(SkTypeface::kBoldItalic));
- canvas.drawText("Hamburgefons", 12, fTextSize/2, 4.8f*fTextSize, paint);
+ canvas.drawString("Hamburgefons", fTextSize/2, 4.8f*fTextSize, paint);
}
private:
typedef FilterBitmapGM INHERITED;
static SkScalar draw_string(SkCanvas* canvas, const SkString& text, SkScalar x,
SkScalar y, const SkPaint& paint) {
- canvas->drawText(text.c_str(), text.size(), x, y, paint);
+ canvas->drawString(text, x, y, paint);
return x + paint.measureText(text.c_str(), text.size());
}
static SkScalar drawString(SkCanvas* canvas, const SkString& text, SkScalar x,
SkScalar y, const SkPaint& paint) {
- canvas->drawText(text.c_str(), text.size(), x, y, paint);
+ canvas->drawString(text, x, y, paint);
return x + paint.measureText(text.c_str(), text.size());
}
auto nextRect = [&](const char* label, const char* label2) {
canvas->drawRect(r, p);
- canvas->drawText(label, strlen(label), 0, sz + textPaint.getFontSpacing(), textPaint);
+ canvas->drawString(label, 0, sz + textPaint.getFontSpacing(), textPaint);
if (label2) {
- canvas->drawText(label2, strlen(label2), 0, sz + 2 * textPaint.getFontSpacing(),
+ canvas->drawString(label2, 0, sz + 2 * textPaint.getFontSpacing(),
textPaint);
}
advance();
auto nextBitmap = [&](const SkBitmap& bmp, const char* label) {
canvas->drawBitmap(bmp, 0, 0);
- canvas->drawText(label, strlen(label), 0, sz + textPaint.getFontSpacing(), textPaint);
+ canvas->drawString(label, 0, sz + textPaint.getFontSpacing(), textPaint);
advance();
};
SkString srcText = SkStringPrintf("%08X", srcColor);
SkString dstText = SkStringPrintf("%08X", dstColor);
- canvas->drawText(srcText.c_str(), srcText.size(), 0, sz + textPaint.getFontSpacing(),
+ canvas->drawString(srcText, 0, sz + textPaint.getFontSpacing(),
textPaint);
const char* modeName = SkBlendMode_Name(mode);
- canvas->drawText(modeName, strlen(modeName), 0, sz + 2 * textPaint.getFontSpacing(),
+ canvas->drawString(modeName, 0, sz + 2 * textPaint.getFontSpacing(),
textPaint);
- canvas->drawText(dstText.c_str(), dstText.size(), 0, sz + 3 * textPaint.getFontSpacing(),
+ canvas->drawString(dstText, 0, sz + 3 * textPaint.getFontSpacing(),
textPaint);
advance();
};
wideGamutCanvas->clear(SK_ColorBLACK);
renderer->draw(wideGamutCanvas);
- canvas->drawText(renderer->label(), strlen(renderer->label()), x, y + textHeight,
- textPaint);
+ canvas->drawString(renderer->label(), x, y + textHeight, textPaint);
// Re-interpret the off-screen images, so we can see the raw data (eg, Wide gamut squares
// will look desaturated, relative to sRGB).
paint.setColor(SK_ColorRED);
sk_tool_utils::set_portable_typeface(&paint);
constexpr char kTxt[] = "GPU Only";
- bmpCanvas.drawText(kTxt, strlen(kTxt), 20, 40, paint);
+ bmpCanvas.drawString(kTxt, 20, 40, paint);
SkMatrix localM;
localM.setRotate(35.f);
localM.postTranslate(10.f, 0.f);
paint.setShader(make_chrome_solid());
paint.setTextSize(SkIntToScalar(500));
- canvas->drawText("I", 1, 0, 100, paint);
+ canvas->drawString("I", 0, 100, paint);
}
private:
typedef GM INHERITED;
sk_tool_utils::set_portable_typeface(&paint);
paint.setStyle(SkPaint::kFill_Style);
- canvas->drawText("Normal Fill Text", 16, 0, 50, paint);
+ canvas->drawString("Normal Fill Text", 0, 50, paint);
paint.setStyle(SkPaint::kStroke_Style);
- canvas->drawText("Normal Stroke Text", 18, 0, 100, paint);
+ canvas->drawString("Normal Stroke Text", 0, 100, paint);
// Minimal repro doesn't require AA, LCD, or a nondefault typeface
paint.setShader(make_chrome_solid());
paint.setStyle(SkPaint::kFill_Style);
- canvas->drawText("Gradient Fill Text", 18, 0, 150, paint);
+ canvas->drawString("Gradient Fill Text", 0, 150, paint);
paint.setStyle(SkPaint::kStroke_Style);
- canvas->drawText("Gradient Stroke Text", 20, 0, 200, paint);
+ canvas->drawString("Gradient Stroke Text", 0, 200, paint);
}
private:
typedef GM INHERITED;
paint.setARGB(0xff, 0xbb, 0x77, 0x77);
paint.setTextSize(0.15f);
- canvas->drawText("A", 1, 0.15f, 0.35f, paint);
+ canvas->drawString("A", 0.15f, 0.35f, paint);
bounds = SkRect::MakeLTRB(0.1f, 0.8f, 0.9f, 1.0f);
paint.setARGB(0xff, 0xcc, 0xcc, 0xff);
paint.setARGB(0xff, 0x88, 0x88, 0xbb);
paint.setTextSize(0.15f);
- canvas->drawText("Z", 1, 0.75f, 0.95f, paint);
+ canvas->drawString("Z", 0.75f, 0.95f, paint);
bounds = SkRect::MakeLTRB(0.1f, 0.4f, 0.9f, 0.6f);
SkPoint pts[] = { { 0, 0 }, { 1, 0 } };
sk_tool_utils::set_portable_typeface(&textPaint);
textPaint.setTextSize(8);
- canvas->drawText(kLabel1, strlen(kLabel1), 10, 60, textPaint);
- canvas->drawText(kLabel2, strlen(kLabel2), 10, 140, textPaint);
- canvas->drawText(kLabel3, strlen(kLabel3), 10, 220, textPaint);
- canvas->drawText(kLabel4, strlen(kLabel4), 10, 300, textPaint);
- canvas->drawText(kLabel5, strlen(kLabel5), 10, 380, textPaint);
- canvas->drawText(kLabel6, strlen(kLabel6), 10, 460, textPaint);
- canvas->drawText(kLabel7, strlen(kLabel7), 10, 540, textPaint);
-
- canvas->drawText(kLabel8, strlen(kLabel8), 80, 10, textPaint);
- canvas->drawText(kLabel9, strlen(kLabel9), 160, 10, textPaint);
- canvas->drawText(kLabel10, strlen(kLabel10), 265, 10, textPaint);
+ canvas->drawString(kLabel1, 10, 60, textPaint);
+ canvas->drawString(kLabel2, 10, 140, textPaint);
+ canvas->drawString(kLabel3, 10, 220, textPaint);
+ canvas->drawString(kLabel4, 10, 300, textPaint);
+ canvas->drawString(kLabel5, 10, 380, textPaint);
+ canvas->drawString(kLabel6, 10, 460, textPaint);
+ canvas->drawString(kLabel7, 10, 540, textPaint);
+
+ canvas->drawString(kLabel8, 80, 10, textPaint);
+ canvas->drawString(kLabel9, 160, 10, textPaint);
+ canvas->drawString(kLabel10, 265, 10, textPaint);
canvas->translate(80, 20);
int y = rand.nextULessThan(HEIGHT);
textPaint.setColor(sk_tool_utils::color_to_565(rand.nextBits(24) | 0xFF000000));
textPaint.setTextSize(rand.nextRangeScalar(0, 300));
- canvas->drawText(str, strlen(str), SkIntToScalar(x),
+ canvas->drawString(str, SkIntToScalar(x),
SkIntToScalar(y), textPaint);
}
canvas->restore();
textPaint.setTextSize(textSize);
for (int i = 0; i < testStringCount; i++) {
- canvas->drawText(kTestStrings[i],
- strlen(kTestStrings[i]),
- SkIntToScalar(x * dx),
- SkIntToScalar(y * dy + textSize * i + textSize),
- textPaint);
+ canvas->drawString(kTestStrings[i],
+ SkIntToScalar(x * dx),
+ SkIntToScalar(y * dy + textSize * i + textSize),
+ textPaint);
}
canvas->restore();
}
int posY = 0;
for (unsigned i = 0; i < SK_ARRAY_COUNT(str); i++) {
posY += 100;
- canvas->drawText(str[i], strlen(str[i]), SkIntToScalar(0),
+ canvas->drawString(str[i], SkIntToScalar(0),
SkIntToScalar(posY), textPaint);
}
canvas->restore();
sk_tool_utils::set_portable_typeface(&paint);
paint.setTextSize(r.height()/2);
paint.setTextAlign(SkPaint::kCenter_Align);
- canvas->drawText("Text", 4, r.centerX(), r.centerY(), paint);
+ canvas->drawString("Text", r.centerX(), r.centerY(), paint);
}
static void draw_bitmap(SkCanvas* canvas, const SkRect& r, sk_sp<SkImageFilter> imf) {
SkAutoCanvasRestore acr(canvas, true);
for (size_t i = 0; i < SK_ARRAY_COUNT(flags); ++i) {
paint.setFlags(flags[i]);
- canvas->drawText("Hamburgefons", 11, 0, 0, paint);
+ canvas->drawString("Hamburgefon", 0, 0, paint);
canvas->translate(0, 40);
}
}
sk_tool_utils::set_portable_typeface(&paint);
paint.setTextSize(r.height()/2);
paint.setTextAlign(SkPaint::kCenter_Align);
- canvas->drawText("Text", 4, r.centerX(), r.centerY(), paint);
+ canvas->drawString("Text", r.centerX(), r.centerY(), paint);
}
static void draw_bitmap(SkCanvas* canvas, const SkRect& r, sk_sp<SkImageFilter> imf) {
paint.setColor(sk_tool_utils::color_to_565(rand.nextBits(24) | 0xFF000000));
paint.setTextSize(rand.nextRangeScalar(0, 300));
paint.setAntiAlias(true);
- canvas->drawText(str, strlen(str), SkIntToScalar(x),
+ canvas->drawString(str, SkIntToScalar(x),
SkIntToScalar(y), paint);
}
canvas->restore();
int posY = 0;
for (unsigned i = 0; i < SK_ARRAY_COUNT(str); i++) {
posY += 100;
- canvas->drawText(str[i], strlen(str[i]), SkIntToScalar(0),
+ canvas->drawString(str[i], SkIntToScalar(0),
SkIntToScalar(posY), textPaint);
}
canvas->restore();
sk_tool_utils::set_portable_typeface(&paint);
paint.setTextSize(SkIntToScalar(25));
paint.setColor(SK_ColorBLACK);
- canvas->drawText(text, strlen(text), x, y, paint);
+ canvas->drawString(text, x, y, paint);
}
typedef GM INHERITED;
paint.setShader(make_shader(r));
}
SkString string(SkBlendMode_Name(gModes[m]));
- canvas->drawText(string.c_str(), string.size(), 0, y, paint);
+ canvas->drawString(string, 0, y, paint);
y+=fTextHeight;
}
}
paint.setLCDRenderText(lcdRenderTextEnabled);
paint.setTextSize(textHeight);
- canvas->drawText(string.c_str(), string.size(), 0, y, paint);
+ canvas->drawString(string, 0, y, paint);
y += textHeight;
}
paint.setTextSize(rec[i].fTextSize);
ScaleAbout(canvas, rec[i].fScale, rec[i].fScale, loc.x(), loc.y());
- canvas->drawText(rec[i].fText, strlen(rec[i].fText), loc.x(), loc.y(), paint);
+ canvas->drawString(rec[i].fText, loc.x(), loc.y(), paint);
}
}
paint.setLCDRenderText(true);
paint.setTextSize(20);
- canvas->drawText("Hamburgefons", 12, 30, 30, paint);
+ canvas->drawString("Hamburgefons", 30, 30, paint);
const bool gPreserveLCDText[] = { false, true };
if (preserve) {
SkPaint noLCD = paint;
noLCD.setLCDRenderText(false);
- canvas->drawText("LCD not supported", 17, 30, 60, noLCD);
+ canvas->drawString("LCD not supported", 30, 60, noLCD);
} else {
- canvas->drawText("Hamburgefons", 12, 30, 60, paint);
+ canvas->drawString("Hamburgefons", 30, 60, paint);
}
SkPaint p;
p.setColor(0xFFCCCCCC);
canvas->drawRect(SkRect::MakeLTRB(25, 70, 200, 100), p);
- canvas->drawText("Hamburgefons", 12, 30, 90, paint);
+ canvas->drawString("Hamburgefons", 30, 90, paint);
canvas->restore();
canvas->translate(0, 80);
canvas->translate(0.0f, LABEL_SIZE);
SkString label;
label.appendf("useNormalSource: %d", useNormalSource);
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
{
canvas->translate(0.0f, LABEL_SIZE);
SkString label;
label.appendf("useDiffuseShader: %d", useDiffuseShader);
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
{
canvas->translate(0.0f, LABEL_SIZE);
SkString label;
label.appendf("useTranslucentPaint: %d", useTranslucentPaint);
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
{
canvas->translate(0.0f, LABEL_SIZE);
SkString label;
label.appendf("useTranslucentShader: %d", useTranslucentShader);
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
canvas->restore();
label.append("roundedOut");
break;
}
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
{
canvas->translate(0.0f, LABEL_SIZE);
SkString label;
label.appendf("bevelHeight: %.1f", bevelHeight);
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
canvas->restore();
canvas->translate(0.0f, LABEL_SIZE);
SkString label;
label.appendf("bevelType: linear");
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
{
canvas->translate(0.0f, LABEL_SIZE);
SkString label;
label.appendf("bevelHeight: %.1f", 7.0f);
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
{
canvas->translate(0.0f, LABEL_SIZE);
SkString label;
label.appendf("rotated");
- canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
+ canvas->drawString(label, 0.0f, 0.0f, labelPaint);
}
canvas->restore();
const char titleClose[] = "Line Closed Drawn Into Rectangle Clips With "
"Indicated Style, Fill and Linecaps, with stroke width 10";
const char* title = doClose ? titleClose : titleNoClose;
- canvas->drawText(title, strlen(title),
- 20 * SK_Scalar1,
- 20 * SK_Scalar1,
- titlePaint);
+ canvas->drawString(title,
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
SkRandom rand;
SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
labelPaint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelPaint);
labelPaint.setTextSize(10 * SK_Scalar1);
- canvas->drawText(gStyles[style].fName,
- strlen(gStyles[style].fName),
- 0, rect.height() + 12 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gFills[fill].fName,
- strlen(gFills[fill].fName),
- 0, rect.height() + 24 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gCaps[cap].fName,
- strlen(gCaps[cap].fName),
- 0, rect.height() + 36 * SK_Scalar1,
- labelPaint);
+ canvas->drawString(gStyles[style].fName,
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gFills[fill].fName,
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gCaps[cap].fName,
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
}
canvas->restore();
}
paint.setShader(SkGradientShader::MakeLinear(
pts, fColors, pos, 2, SkShader::kClamp_TileMode));
const char* str = "e";
- canvas.drawText(str, strlen(str), SkIntToScalar(-10), SkIntToScalar(80), paint);
+ canvas.drawString(str, SkIntToScalar(-10), SkIntToScalar(80), paint);
// ... tag the data as sRGB, so color-aware devices do gamut adjustment, etc...
fBitmap.setInfo(SkImageInfo::MakeS32(80, 80, kPremul_SkAlphaType));
paint.setTextSize(30);
SkString str;
str.printf("scale %g %g", dst.width() / img->width(), dst.height() / img->height());
-// canvas->drawText(str.c_str(), str.size(), 300, 100, paint);
+// canvas->drawString(str, 300, 100, paint);
canvas->translate(20, 20);
for (int i = 0; i < 4; ++i) {
const char* str2 = "XYZ";
paint.setColor(0xFFFFFFFF);
paint.setTextSize(64);
- canvas.drawText(str1, strlen(str1), 10, 55, paint);
- canvas.drawText(str2, strlen(str2), 10, 110, paint);
+ canvas.drawString(str1, 10, 55, paint);
+ canvas.drawString(str2, 10, 110, paint);
}
SkISize onISize() override {
canvas->scale(1.0, 0.5);
p.setColor(0xF0000080);
- canvas->drawText(text, strlen(text), 30, 700, p);
+ canvas->drawString(text, 30, 700, p);
}
paint.setColor(0xFFFFFFFF);
paint.setTextSize(SkIntToScalar(96));
const char* str = "e";
- canvas->drawText(str, strlen(str), SkIntToScalar(20), SkIntToScalar(70), paint);
+ canvas->drawString(str, SkIntToScalar(20), SkIntToScalar(70), paint);
return recorder.finishRecordingAsPicture();
}
// this has to be small enough that it doesn't become a path
paint.setTextSize(SkIntToScalar(36));
const char* str = "e";
- canvas->drawText(str, strlen(str), SkIntToScalar(20), SkIntToScalar(70), paint);
+ canvas->drawString(str, SkIntToScalar(20), SkIntToScalar(70), paint);
return recorder.finishRecordingAsPicture();
}
canvas->translate(0, SkIntToScalar(kLabelOffsetY));
for (int i = 0; i <= kSubPixelSteps; ++i) {
offset.printf("%d", i);
- canvas->drawText(offset.c_str(), offset.size(),
+ canvas->drawString(offset,
0, i * kTrans + labelPaint.getTextSize(),
labelPaint);
}
canvas->translate(SkIntToScalar(kLabelOffsetX), 0);
for (int i = 0; i <= kSubPixelSteps; ++i) {
offset.printf("%d", i);
- canvas->drawText(offset.c_str(), offset.size(),
+ canvas->drawString(offset,
i * SkIntToScalar(kTrans), labelPaint.getTextSize(),
labelPaint);
}
}
void SkJSCanvas::fillText(const char text[], double x, double y) {
- fTarget->drawText(text, strlen(text),
- SkDoubleToScalar(x), SkDoubleToScalar(y), fFillPaint);
+ fTarget->drawString(text, SkDoubleToScalar(x), SkDoubleToScalar(y), fFillPaint);
}
///////////////////////////////////////////////////////////////////////////////
titlePaint.setTextSize(15 * SK_Scalar1);
const char title[] = "Quad Drawn Into Rectangle Clips With "
"Indicated Style, Fill and Linecaps, with stroke width 10";
- canvas->drawText(title, strlen(title),
- 20 * SK_Scalar1,
- 20 * SK_Scalar1,
- titlePaint);
+ canvas->drawString(title,
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
SkRandom rand;
SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
labelPaint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelPaint);
labelPaint.setTextSize(10 * SK_Scalar1);
- canvas->drawText(gStyles[style].fName,
- strlen(gStyles[style].fName),
- 0, rect.height() + 12 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gFills[fill].fName,
- strlen(gFills[fill].fName),
- 0, rect.height() + 24 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gCaps[cap].fName,
- strlen(gCaps[cap].fName),
- 0, rect.height() + 36 * SK_Scalar1,
- labelPaint);
+ canvas->drawString(gStyles[style].fName,
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gFills[fill].fName,
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gCaps[cap].fName,
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
}
canvas->restore();
}
titlePaint.setTextSize(15 * SK_Scalar1);
const char title[] = "Quad Closed Drawn Into Rectangle Clips With "
"Indicated Style, Fill and Linecaps, with stroke width 10";
- canvas->drawText(title, strlen(title),
- 20 * SK_Scalar1,
- 20 * SK_Scalar1,
- titlePaint);
+ canvas->drawString(title,
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
SkRandom rand;
SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
labelPaint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelPaint);
labelPaint.setTextSize(10 * SK_Scalar1);
- canvas->drawText(gStyles[style].fName,
- strlen(gStyles[style].fName),
- 0, rect.height() + 12 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gFills[fill].fName,
- strlen(gFills[fill].fName),
- 0, rect.height() + 24 * SK_Scalar1,
- labelPaint);
- canvas->drawText(gCaps[cap].fName,
- strlen(gCaps[cap].fName),
- 0, rect.height() + 36 * SK_Scalar1,
- labelPaint);
+ canvas->drawString(gStyles[style].fName,
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gFills[fill].fName,
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawString(gCaps[cap].fName,
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
}
canvas->restore();
}
SkPaint paint;
paint.setAntiAlias(true);
const char* kMsg = "Could not create rectangle texture image.";
- canvas->drawText(kMsg, strlen(kMsg), 10, 100, paint);
+ canvas->drawString(kMsg, 10, 100, paint);
return;
}
canvas->clipPath(path, true); // AA is on
- canvas->drawText("M", 1,
+ canvas->drawString("M",
SkIntToScalar(100), SkIntToScalar(100),
paint);
paint2.setStyle(SkPaint::kStroke_Style);
paint2.setStrokeWidth(1);
sk_tool_utils::set_portable_typeface(&paint2);
- canvas->drawText("M", 1,
+ canvas->drawString("M",
SkIntToScalar(100), SkIntToScalar(100),
paint2);
canvas->translate(0, bmp.height() + labelPaint.getTextSize() + 15.f);
constexpr char kLabelLabel[] = "localM / canvasM";
- canvas->drawText(kLabelLabel, strlen(kLabelLabel), 0, 0, labelPaint);
+ canvas->drawString(kLabelLabel, 0, 0, labelPaint);
canvas->translate(0, 15.f);
canvas->save();
SkScalar maxLabelW = 0;
canvas->translate(0, kPadY / 2 + kPointSize);
for (int lm = 0; lm < localMatrices.count(); ++lm) {
- canvas->drawText(matrices[lm].fLabel, strlen(matrices[lm].fLabel),
+ canvas->drawString(matrices[lm].fLabel,
0, labelPaint.getTextSize() - 1, labelPaint);
SkScalar labelW = labelPaint.measureText(matrices[lm].fLabel,
strlen(matrices[lm].fLabel));
for (int m = 0; m < matrices.count(); ++m) {
columnH = 0;
canvas->save();
- canvas->drawText(matrices[m].fLabel, strlen(matrices[m].fLabel),
+ canvas->drawString(matrices[m].fLabel,
0, labelPaint.getTextSize() - 1, labelPaint);
canvas->translate(0, kPadY / 2 + kPointSize);
columnH += kPadY / 2 + kPointSize;
SkScalar y = columnH + kPadY / 2;
SkScalar fillX = -outlinePaint.measureText(kFillLabel, strlen(kFillLabel)) - kPadX;
SkScalar strokeX = kPadX;
- canvas->drawText(kFillLabel, strlen(kFillLabel), fillX, y, labelPaint);
- canvas->drawText(kStrokeLabel, strlen(kStrokeLabel), strokeX, y, labelPaint);
+ canvas->drawString(kFillLabel, fillX, y, labelPaint);
+ canvas->drawString(kStrokeLabel, strokeX, y, labelPaint);
}
}
}
int xOff = 0;
for (size_t op = 0; op < SK_ARRAY_COUNT(gOps); op++) {
- canvas->drawText(gOps[op].fName, strlen(gOps[op].fName),
+ canvas->drawString(gOps[op].fName,
SkIntToScalar(75), SkIntToScalar(50),
textPaint);
sk_tool_utils::set_portable_typeface(&type);
type.setColor(color);
const char text[] = "HELLO WORLD";
- canvas->drawText(text, strlen(text), 32, size / 2 + Y, type);
+ canvas->drawString(text, 32, size / 2 + Y, type);
SkScalar lineSpacing = type.getFontSpacing();
exercise_draw_pos_text(canvas, text, 32, size / 2 + Y + lineSpacing, type);
exercise_draw_pos_text_h(canvas, text, 32,
static void draw_text(SkCanvas* canvas, const SkPaint& paint) {
SkPaint p(paint);
p.setTextSize(H/4);
- canvas->drawText("Hamburge", 8, 0, H*2/3, p);
+ canvas->drawString("Hamburge", 0, H*2/3, p);
}
class SrcModeGM : public skiagm::GM {
if (strokeWidth > 0) {
p.setStyle(SkPaint::kFill_Style);
- canvas->drawText("P", 1, loc.fX, loc.fY - 225, p);
+ canvas->drawString("P", loc.fX, loc.fY - 225, p);
canvas->drawPosText("P", 1, &loc, p);
}
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(strokeWidth);
- canvas->drawText("P", 1, loc.fX, loc.fY - 225, p);
+ canvas->drawString("P", loc.fX, loc.fY - 225, p);
canvas->drawPosText("P", 1, &loc, p);
}
paint.setTextSize(32);
paint.setTextAlign(SkPaint::kCenter_Align);
sk_tool_utils::set_portable_typeface(&paint);
- canvas->drawText(label, strlen(label), W / 2, H * 3 / 4, paint);
+ canvas->drawString(label, W / 2, H * 3 / 4, paint);
}
class SurfacePropsGM : public skiagm::GM {
// paint.setMaskFilter(nullptr);
// paint.setColor(SK_ColorBLACK);
- canvas->drawText(str.c_str(), str.size(), x, y, paint);
+ canvas->drawString(str, x, y, paint);
y += paint.getFontSpacing();
}
str.printf("[%s,%s]", gModeNames[kx], gModeNames[ky]);
p.setTextAlign(SkPaint::kCenter_Align);
- canvas->drawText(str.c_str(), str.size(), x + r.width()/2, y, p);
+ canvas->drawString(str, x + r.width()/2, y, p);
x += r.width() * 4 / 3;
}
p.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&p);
str.printf("%s, %s", gConfigNames[i], gFilterNames[j]);
- canvas->drawText(str.c_str(), str.size(), x, y + r.height() * 2 / 3, p);
+ canvas->drawString(str, x, y + r.height() * 2 / 3, p);
}
y += r.height() * 4 / 3;
for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
SkString str(gModeNames[kx]);
- canvas->drawText(str.c_str(), str.size(), x + r.width()/2, y, p);
+ canvas->drawString(str, x + r.width()/2, y, p);
x += r.width() * 4 / 3;
}
x = SkIntToScalar(16) + w;
SkString str(gModeNames[ky]);
- canvas->drawText(str.c_str(), str.size(), x, y + h/2, p);
+ canvas->drawString(str, x, y + h/2, p);
x += SkIntToScalar(50);
for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
str.printf("[%s,%s]", gModeNames[kx], gModeNames[ky]);
p.setTextAlign(SkPaint::kCenter_Align);
- canvas->drawText(str.c_str(), str.size(), scale*(x + r.width()/2), y, p);
+ canvas->drawString(str, scale*(x + r.width()/2), y, p);
x += r.width() * 4 / 3;
}
p.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&p);
str.printf("%s, %s", gColorTypeNames[i], gFilterNames[j]);
- canvas->drawText(str.c_str(), str.size(), scale*x, scale*(y + r.height() * 2 / 3), p);
+ canvas->drawString(str, scale*x, scale*(y + r.height() * 2 / 3), p);
}
y += r.height() * 4 / 3;
for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
SkString str(gModeNames[kx]);
- canvas->drawText(str.c_str(), str.size(), x + r.width()/2, y, p);
+ canvas->drawString(str, x + r.width()/2, y, p);
x += r.width() * 4 / 3;
}
x = SkIntToScalar(16) + w;
SkString str(gModeNames[ky]);
- canvas->drawText(str.c_str(), str.size(), x, y + h/2, p);
+ canvas->drawString(str, x, y + h/2, p);
x += SkIntToScalar(50);
for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
canvas->save();
canvas->clipRect(fClipRects[i]);
canvas->translate(fPositions[i].fX, fPositions[i].fY);
- canvas->drawText(fStrings[i].c_str(), fStrings[i].size(), 0, 0, fPaint);
+ canvas->drawString(fStrings[i], 0, 0, fPaint);
canvas->restore();
}
paint.setTypeface(std::move(family));
paint.setTextSize(textHeight);
- canvas->drawText(string.c_str(), string.size(), y,
+ canvas->drawString(string, y,
SkIntToScalar(alignment == SkPaint::kLeft_Align ? 10 : 240),
paint);
y += textHeight;
canvas->clipRect(SkRect::Make(kCoverRect));
canvas->clear(SK_ColorWHITE);
- canvas->drawText(errorMsg.c_str(), errorMsg.size(), SkIntToScalar(kCoverRect.centerX()),
+ canvas->drawString(errorMsg, SkIntToScalar(kCoverRect.centerX()),
SkIntToScalar(kCoverRect.centerY() - 10), paint);
}
#if 1
const char* label = SkBlendMode_Name(gModes[i].fMode);
- canvas->drawText(label, strlen(label),
+ canvas->drawString(label,
x + w/2, y - labelP.getTextSize()/2, labelP);
#endif
x += w + SkIntToScalar(10);
canvas->restore();
#if 1
- canvas->drawText(SkBlendMode_Name(mode), strlen(SkBlendMode_Name(mode)),
- x + w/2, y - labelP.getTextSize()/2, labelP);
+ canvas->drawString(SkBlendMode_Name(mode),
+ x + w/2, y - labelP.getTextSize()/2, labelP);
#endif
x += w + SkIntToScalar(10);
if ((m % W) == W - 1) {
for (size_t s = 0; s < SK_ARRAY_COUNT(kStrokes); ++s) {
for (size_t m = 0; m <= (size_t)SkBlendMode::kLastMode; ++m) {
SkBlendMode mode = static_cast<SkBlendMode>(m);
- canvas->drawText(SkBlendMode_Name(mode),
- strlen(SkBlendMode_Name(mode)),
+ canvas->drawString(SkBlendMode_Name(mode),
SkIntToScalar(x),
SkIntToScalar(y + kSize + 3) + labelP.getTextSize(),
labelP);
void drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint& paint);
+ /** Draw null-terminated UTF-8 string, with origin at (x,y), using the specified paint.
+ The origin is interpreted based on the Align setting in the paint.
+ @param string The null-terminated string to be drawn
+ @param x The x-coordinate of the origin of the string being drawn
+ @param y The y-coordinate of the origin of the string being drawn
+ @param paint The paint used for the string (e.g. color, size, style)
+ */
+ void drawString(const char* string, SkScalar x, SkScalar y, const SkPaint& paint) {
+ if (!string) {
+ return;
+ }
+ this->drawText(string, strlen(string), x, y, paint);
+ }
+
+ /** Draw string, with origin at (x,y), using the specified paint.
+ The origin is interpreted based on the Align setting in the paint.
+ @param string The string to be drawn
+ @param x The x-coordinate of the origin of the string being drawn
+ @param y The y-coordinate of the origin of the string being drawn
+ @param paint The paint used for the string (e.g. color, size, style)
+ */
+ void drawString(const SkString& string, SkScalar x, SkScalar y, const SkPaint& paint);
+
/** Draw the text, with each character/glyph origin specified by the pos[]
array. The origin is interpreted by the Align setting in the paint.
@param text The text to be drawn
paint.setTypeface(fFace);
apply_shader(&paint, SkScalarToFloat(fInterp));
- canvas->drawText(str.c_str(), str.size(), x, y, paint);
+ canvas->drawString(str, x, y, paint);
// drawdots(canvas, paint);
for (int i = 0; i < fCount; ++i) {
if (draw_this_name(fNames[i], fMatchStr)) {
canvas->drawRect(this->bounds(loc), paint);
- canvas->drawText(fNames[i].c_str(), fNames[i].size(), loc.x(), loc.y(), fNamePaint);
+ canvas->drawString(fNames[i], loc.x(), loc.y(), fNamePaint);
this->next(&loc);
}
}
canvas->drawLine(fBounds.fLeft - 5, fYLo, fBounds.fRight + 5, fYLo, paints.fIndicator);
SkString label;
label.printf("%0.3g", fValLo);
- canvas->drawText(label.c_str(), label.size(), fBounds.fLeft + 5, fYLo - 5, paints.fValue);
- canvas->drawText(fName.c_str(), fName.size(), fBounds.fLeft, fBounds.bottom() + 11,
+ canvas->drawString(label, fBounds.fLeft + 5, fYLo - 5, paints.fValue);
+ canvas->drawString(fName, fBounds.fLeft, fBounds.bottom() + 11,
paints.fLabel);
}
};
if (yPos < fYLo + 10) {
yPos = fYLo + 10;
}
- canvas->drawText(label.c_str(), label.size(), fBounds.fLeft + 5, yPos - 5, paints.fValue);
+ canvas->drawString(label, fBounds.fLeft + 5, yPos - 5, paints.fValue);
SkRect fill = { fBounds.fLeft, fYLo, fBounds.fRight, yPos };
canvas->drawRect(fill, paints.fFill);
}
SkScalar bottomOffset = this->height() - 10;
for (int index = kKeyCommandCount - 1; index >= 0; --index) {
bottomOffset -= 15;
- canvas->drawText(kKeyCommandList[index].fDescriptionL,
- strlen(kKeyCommandList[index].fDescriptionL), this->width() - 160, bottomOffset,
+ canvas->drawString(kKeyCommandList[index].fDescriptionL,
+ this->width() - 160, bottomOffset,
fLegendLeftPaint);
- canvas->drawText(kKeyCommandList[index].fDescriptionR,
- strlen(kKeyCommandList[index].fDescriptionR), this->width() - 20, bottomOffset,
+ canvas->drawString(kKeyCommandList[index].fDescriptionR,
+ this->width() - 20, bottomOffset,
fLegendRightPaint);
}
}
gLightingColors[index].fAdd));
#endif
- canvas->drawText(str.c_str(), str.size(), x, y, paint);
+ canvas->drawString(str, x, y, paint);
SkRect oval = { x, y - SkIntToScalar(40), x + SkIntToScalar(40), y };
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawOval(oval, paint);
canvas->restore();
paint.setTextSize(16);
-// canvas->drawText(outString.c_str(), outString.size(), 512.f, 540.f, paint);
- canvas->drawText(modeString.c_str(), modeString.size(), 768.f, 540.f, paint);
+// canvas->drawString(outString, 512.f, 540.f, paint);
+ canvas->drawString(modeString, 768.f, 540.f, paint);
}
bool onAnimate(const SkAnimTimer& timer) override {
str.appendScalar(start);
str.append(", ");
str.appendScalar(sweep);
- canvas->drawText(str.c_str(), str.size(), rect.centerX(),
+ canvas->drawString(str, rect.centerX(),
rect.fBottom + paint.getTextSize() * 5/4, paint);
}
labelPaint.setColor(0xFFFFFFFF);
labelPaint.setTextSize(12.0f);
- canvas->drawText(label.c_str(), label.size(), 0, kLabelHeight - 6.0f, labelPaint);
+ canvas->drawString(label, 0, kLabelHeight - 6.0f, labelPaint);
}
SkString fName;
SkCanvas canvas(*bm);
- canvas.drawText(gText, strlen(gText), 0, paint.getTextSize()*4/5, paint);
+ canvas.drawString(gText, 0, paint.getTextSize()*4/5, paint);
}
class BitmapRectView2 : public SampleView {
SkScalar x = SkIntToScalar(70);
SkScalar y = SkIntToScalar(400);
paint.setColor(SK_ColorBLACK);
- canvas->drawText("Hamburgefons Style", 18, x, y, paint);
- canvas->drawText("Hamburgefons Style", 18, x, y + SkIntToScalar(50), paint);
+ canvas->drawString("Hamburgefons Style", x, y, paint);
+ canvas->drawString("Hamburgefons Style", x, y + SkIntToScalar(50), paint);
paint.setMaskFilter(nullptr);
paint.setColor(SK_ColorWHITE);
x -= SkIntToScalar(2);
y -= SkIntToScalar(2);
- canvas->drawText("Hamburgefons Style", 18, x, y, paint);
+ canvas->drawString("Hamburgefons Style", x, y, paint);
}
canvas->restore();
flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
for (int i = 0; i < 200; ++i) {
paint.setColor((SK_A32_MASK << SK_A32_SHIFT) | rand.nextU());
- canvas->drawText("Hamburgefons", 12,
+ canvas->drawString("Hamburgefons",
rand.nextSScalar1() * W, rand.nextSScalar1() * H + 20,
paint);
}
SkScalar txtX = SkIntToScalar(55);
paint.setColor(colorA);
const char* aTxt = invA ? "InverseA " : "A ";
- canvas->drawText(aTxt, strlen(aTxt), txtX, SkIntToScalar(220), paint);
+ canvas->drawString(aTxt, txtX, SkIntToScalar(220), paint);
txtX += paint.measureText(aTxt, strlen(aTxt));
paint.setColor(SK_ColorBLACK);
- canvas->drawText(gOps[op].fName, strlen(gOps[op].fName),
+ canvas->drawString(gOps[op].fName,
txtX, SkIntToScalar(220), paint);
txtX += paint.measureText(gOps[op].fName, strlen(gOps[op].fName));
paint.setColor(colorB);
- canvas->drawText("B", 1, txtX, SkIntToScalar(220), paint);
+ canvas->drawString("B", txtX, SkIntToScalar(220), paint);
canvas->translate(SkIntToScalar(250),0);
}
SkPaint paint;
paint.setAntiAlias(true);
paint.setColor(SK_ColorBLACK);
- canvas->drawText(txt.c_str(), txt.size(), l + w/2 + w*DELTA_SCALE*delta, t + h + SK_Scalar1 * 10, paint);
+ canvas->drawString(txt, l + w/2 + w*DELTA_SCALE*delta, t + h + SK_Scalar1 * 10, paint);
}
bool onAnimate(const SkAnimTimer& timer) override {
paint.setAntiAlias(true);
paint.setTextSize(16);
paint.setColor(SK_ColorBLUE);
- canvas->drawText(str.c_str(), str.size(), 10, 16, paint);
+ canvas->drawString(str, 10, 16, paint);
}
}
paint.setAntiAlias(true);
const char* name = sk_tool_utils::colortype_name(bm.colorType());
- canvas->drawText(name, strlen(name), x, SkIntToScalar(bm.height())*scale*5/8,
+ canvas->drawString(name, x, SkIntToScalar(bm.height())*scale*5/8,
paint);
canvas->translate(SkIntToScalar(48), 0);
s.appendS32(paint.isDither());
s.append(" filter=");
s.appendS32(paint.getFilterQuality() != kNone_SkFilterQuality);
- canvas->drawText(s.c_str(), s.size(), x + W/2,
+ canvas->drawString(s, x + W/2,
y - p.getTextSize(), p);
}
if (k+j == 2) {
SkString s;
s.append(" depth=");
s.appendS32(fBitmaps[i].colorType() == kRGB_565_SkColorType ? 16 : 32);
- canvas->drawText(s.c_str(), s.size(), x + W + SkIntToScalar(4),
+ canvas->drawString(s, x + W + SkIntToScalar(4),
y + H/2, p);
}
}
paint.setColor(0xFF884422);
paint.setTextSize(SkIntToScalar(kBitmapSize/2));
const char* str = "g";
- canvas.drawText(str, strlen(str), SkIntToScalar(kBitmapSize/8),
+ canvas.drawString(str, SkIntToScalar(kBitmapSize/8),
SkIntToScalar(kBitmapSize/4), paint);
}
canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
paint.setColor(SK_ColorBLACK);
paint.setTextSize(SkIntToScalar(kBitmapSize/3));
- canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
+ canvas->drawString("Picture", SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
}
static void rand_color_table(uint8_t* table) {
paint.setTextSize(36);
SkString str;
str.appendScalar(fScale);
- canvas->drawText(str.c_str(), str.size(), textX, 100, paint);
+ canvas->drawString(str, textX, 100, paint);
str.reset(); str.appendScalar(fAngle);
- canvas->drawText(str.c_str(), str.size(), textX, 150, paint);
+ canvas->drawString(str, textX, 150, paint);
str.reset(); str.appendScalar(trans[0]);
- canvas->drawText(str.c_str(), str.size(), textX, 200, paint);
+ canvas->drawString(str, textX, 200, paint);
str.reset(); str.appendScalar(trans[1]);
- canvas->drawText(str.c_str(), str.size(), textX, 250, paint);
+ canvas->drawString(str, textX, 250, paint);
}
bool onAnimate(const SkAnimTimer& timer) override {
}
canvas->drawBitmap( fBM, 100, 100, &paint );
canvas->restore();
- canvas->drawText( text, strlen(text), 100, 400, paint );
+ canvas->drawString(text, 100, 400, paint );
this->inval(nullptr);
}
float y = D/2 - (fm.fAscent + fm.fDescent)/2;
SkString str;
str.appendS32(count);
- canvas->drawText(str.c_str(), str.size(),
+ canvas->drawString(str,
x, y,
*paint);
label.appendS32(index);
SkRect dot = SkRect::MakeXYWH(pos.x() - 2, pos.y() - 2, 4, 4);
canvas->drawRect(dot, labelP);
- canvas->drawText(label.c_str(), label.size(),
+ canvas->drawString(label,
pos.x() - tan.x() * 1.25f, pos.y() - tan.y() * 1.25f, labelP);
}
}
if (0 == index % 10) {
SkString label;
label.appendS32(index);
- canvas->drawText(label.c_str(), label.size(),
+ canvas->drawString(label,
pos.x() + tan.x() * 1.25f, pos.y() + tan.y() * 1.25f, paint);
}
}
paint.setColor(0xFF000000);
paint.setTextSize(11.0f);
paint.setStyle(SkPaint::kFill_Style);
- canvas->drawText(label.c_str(), label.size(), bounds.fLeft + 5, yPos - 5, paint);
+ canvas->drawString(label, bounds.fLeft + 5, yPos - 5, paint);
paint.setTextSize(13.0f);
- canvas->drawText(name, strlen(name), bounds.fLeft, bounds.bottom() + 11, paint);
+ canvas->drawString(name, bounds.fLeft, bounds.bottom() + 11, paint);
}
void setForGeometry() {
100.0f * totArea / ((float)kWidth*kHeight),
fCurRandRect,
kNumRandRects);
- canvas->drawText(str.c_str(), str.size(), 50, kHeight + 50, blackBigFont);
+ canvas->drawString(str, 50, kHeight + 50, blackBigFont);
str.printf("Press \'j\' to toggle rectanizer");
- canvas->drawText(str.c_str(), str.size(), 50, kHeight + 100, blackBigFont);
+ canvas->drawString(str, 50, kHeight + 100, blackBigFont);
str.printf("Press \'h\' to toggle rects");
- canvas->drawText(str.c_str(), str.size(), 50, kHeight + 150, blackBigFont);
+ canvas->drawString(str, 50, kHeight + 150, blackBigFont);
this->inval(nullptr);
}
paint.setAntiAlias(true);
paint.setTextSize(SkIntToScalar(20));
paint.setColor(hilite ? SK_ColorRED : 0x40FF0000);
- canvas->drawText(text, strlen(text), loc.fX, loc.fY, paint);
+ canvas->drawString(text, loc.fX, loc.fY, paint);
}
void drawPredicates(SkCanvas* canvas, const SkPoint pts[]) {
canvas->translate(0, SkIntToScalar(200));
for (size_t op = 0; op < SK_ARRAY_COUNT(gOps); op++) {
- canvas->drawText(gOps[op].fName, strlen(gOps[op].fName), SkIntToScalar(75), SkIntToScalar(50), textPaint);
+ canvas->drawString(gOps[op].fName, SkIntToScalar(75), SkIntToScalar(50), textPaint);
this->drawRgnOped(canvas, gOps[op].fOp, gOps[op].fColor);
paint.setColor(SK_ColorBLACK);
canvas->drawRect(SkRect::MakeXYWH(0, 0, 200, 24), paint);
paint.setColor(SK_ColorWHITE);
- canvas->drawText(outString.c_str(), outString.size(), 5, 15, paint);
+ canvas->drawString(outString, 5, 15, paint);
this->inval(nullptr);
}
if (x) {
paint.setMaskFilter(SkBlurMaskFilter::Make(gStyle[x - 1], sigma));
}
- canvas->drawText("Title Bar", 9, x*SkIntToScalar(100), y*SkIntToScalar(30), paint);
+ canvas->drawString("Title Bar", x*SkIntToScalar(100), y*SkIntToScalar(30), paint);
sigma *= 0.75f;
}
canvas->drawBitmapRect( fBM, r, &paint );
}
- canvas->drawText( "AA Scaled", strlen("AA Scaled"), fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fSize + 10), fCurPos.fY + fSize/2, paint );
+ canvas->drawString( "AA Scaled", fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fSize + 10), fCurPos.fY + fSize/2, paint );
paint.setAntiAlias(false);
for (size_t i = 0; i < SK_ARRAY_COUNT(gQualitys); ++i) {
SkRect r = SkRect::MakeXYWH( fCurPos.fX + i * (fSize + 10), fCurPos.fY + fSize + 10, fSize, fSize );
canvas->drawBitmapRect( fBM, r, &paint );
}
- canvas->drawText( "Scaled", strlen("Scaled"), fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fSize + 10), fCurPos.fY + fSize + 10 + fSize/2, paint );
+ canvas->drawString( "Scaled", fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fSize + 10), fCurPos.fY + fSize + 10 + fSize/2, paint );
paint.setAntiAlias(true);
for (size_t i = 0; i < SK_ARRAY_COUNT(gQualitys); ++i) {
canvas->drawBitmap( fBM, fCurPos.fX + i * (fBM.width() + 10), fCurPos.fY + 2*(fSize + 10), &paint );
}
- canvas->drawText( "AA No Scale", strlen("AA No Scale"), fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fBM.width() + 10), fCurPos.fY + 2*(fSize + 10) + fSize/2, paint );
+ canvas->drawString( "AA No Scale", fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fBM.width() + 10), fCurPos.fY + 2*(fSize + 10) + fSize/2, paint );
paint.setAntiAlias(false);
for (size_t i = 0; i < SK_ARRAY_COUNT(gQualitys); ++i) {
canvas->drawBitmap( fBM, fCurPos.fX + i * (fBM.width() + 10), fCurPos.fY + 2*(fSize + 10) + fBM.height() + 10, &paint );
}
- canvas->drawText( "No Scale", strlen("No Scale"), fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fBM.width() + 10), fCurPos.fY + 2*(fSize + 10) + fBM.height() + 10 + fSize/2, paint );
+ canvas->drawString( "No Scale", fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fBM.width() + 10), fCurPos.fY + 2*(fSize + 10) + fBM.height() + 10 + fSize/2, paint );
fCurPos.fX += fHorizontalVelocity;
paint.setFlags(paint.getFlags() | SkPaint::kAntiAlias_Flag
| SkPaint::kDevKernText_Flag);
paint.setTextSize(SkIntToScalar(14));
- canvas.drawText(s, strlen(s), SkIntToScalar(8), SkIntToScalar(14), paint);
+ canvas.drawString(s, SkIntToScalar(8), SkIntToScalar(14), paint);
}
static void fill_pts(SkPoint pts[], size_t n, SkRandom* rand) {
// canvas->translate(0, SkIntToScalar(50));
- // canvas->drawText(style, strlen(style), SkIntToScalar(20), SkIntToScalar(20), paint);
+ // canvas->drawString(style, SkIntToScalar(20), SkIntToScalar(20), paint);
paint.setTypeface(SkTypeface::MakeFromFile("/skimages/samplefont.ttf"));
paint.setAntiAlias(true);
paint.setColor(rand.nextU() | (0xFF << 24));
paint.setTextSize(SkIntToScalar(ps));
paint.setTextSize(SkIntToScalar(24));
- canvas->drawText(str, strlen(str), x, y, paint);
+ canvas->drawString(str, x, y, paint);
y += paint.getFontMetrics(nullptr);
}
}
str.printf("[%s,%s]", gModeNames[kx], gModeNames[ky]);
p.setTextAlign(SkPaint::kCenter_Align);
- textCanvas->drawText(str.c_str(), str.size(), x + r.width()/2, y, p);
+ textCanvas->drawString(str, x + r.width()/2, y, p);
x += r.width() * 4 / 3;
}
p.setAntiAlias(true);
p.setLooper(fLooper);
str.printf("%s, %s", gConfigNames[i], gFilterNames[j]);
- textCanvas->drawText(str.c_str(), str.size(), x, y + r.height() * 2 / 3, p);
+ textCanvas->drawString(str, x, y + r.height() * 2 / 3, p);
}
y += r.height() * 4 / 3;
} else {
failure.printf("Failed to decode %s", fCurrFile.c_str());
}
- canvas->drawText(failure.c_str(), failure.size(), 0, height, paint);
+ canvas->drawString(failure, 0, height, paint);
return;
}
SkString header(SkOSPath::Basename(fCurrFile.c_str()));
header.appendf(" [%dx%d] %s", fBitmap.width(), fBitmap.height(),
(fPremul ? "premultiplied" : "unpremultiplied"));
- canvas->drawText(header.c_str(), header.size(), 0, height, paint);
+ canvas->drawString(header, 0, height, paint);
canvas->translate(0, height);
// Help messages
header.printf("Press '%c' to move to the next image.'", fNextImageChar);
- canvas->drawText(header.c_str(), header.size(), 0, height, paint);
+ canvas->drawString(header, 0, height, paint);
canvas->translate(0, height);
header.printf("Press '%c' to toggle premultiplied decode.", fTogglePremulChar);
- canvas->drawText(header.c_str(), header.size(), 0, height, paint);
+ canvas->drawString(header, 0, height, paint);
// Now draw the image itself.
canvas->translate(height * 2, height * 2);
paint.setTextSize(16);
paint.setTextAlign(SkPaint::kCenter_Align);
paint.setLCDRenderText(true);
- canvas->drawText(fLabel.c_str(), fLabel.size(), r.centerX(), r.fTop + 0.68f * r.height(), paint);
+ canvas->drawString(fLabel, r.centerX(), r.fTop + 0.68f * r.height(), paint);
}
Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
canvas->drawRect(r, p);
const char* label = SkBlendMode_Name(gModes[i]);
- canvas->drawText(label, strlen(label),
+ canvas->drawString(label,
x + w/2, y - labelP.getTextSize()/2, labelP);
x += w + SkIntToScalar(10);
if ((i % W) == W - 1) {
#include "SkShadowPaintFilterCanvas.h"
#include "SkShadowShader.h"
#include "SkSpecialImage.h"
+#include "SkString.h"
#include "SkSurface_Base.h"
#include "SkTextBlob.h"
#include "SkTextFormatParams.h"
fMCRec->fFilter = drawFilter;
}
+void SkCanvas::drawString(const SkString& string, SkScalar x, SkScalar y, const SkPaint& paint) {
+ this->drawText(string.c_str(), string.size(), x, y, paint);
+}
+
// These will become non-virtual, so they always call the (virtual) onDraw... method
void SkCanvas::drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint& paint) {
SkString num;
num.printf("%d", this->origEdgeID(cur));
- canvas->drawText(num.c_str(), num.size(), mid.fX, mid.fY, paint);
+ canvas->drawString(num, mid.fX, mid.fY, paint);
if (fPts.count()) {
draw_arrow(canvas, tess.point(fPts[cur].fIndex), fPts[cur].fBisector,
SkString num;
num.printf("%d", i);
- canvas->drawText(num.c_str(), num.size(),
+ canvas->drawString(num,
this->point(i).fX, this->point(i).fY+(kPointRadius/2.0f),
paint);
}
SkScalar oddballs[] = { 0.0f, (float)INFINITY, (float)NAN, 34359738368.0f };
for (auto x : oddballs) {
- canvas->drawText("a", 1, +x, 0.0f, SkPaint());
- canvas->drawText("a", 1, -x, 0.0f, SkPaint());
+ canvas->drawString("a", +x, 0.0f, SkPaint());
+ canvas->drawString("a", -x, 0.0f, SkPaint());
}
for (auto y : oddballs) {
- canvas->drawText("a", 1, 0.0f, +y, SkPaint());
- canvas->drawText("a", 1, 0.0f, -y, SkPaint());
+ canvas->drawString("a", 0.0f, +y, SkPaint());
+ canvas->drawString("a", 0.0f, -y, SkPaint());
}
}
canvas->drawPaint(paint);
SkPaint textPaint;
textPaint.setColor(SK_ColorBLUE);
- canvas->drawText("TEXT", 4, 467.0f, 100.0f, textPaint);
+ canvas->drawString("TEXT", 467.0f, 100.0f, textPaint);
// Draw some drawables as well
sk_sp<SkDrawable> drawable(new IntDrawable(1, 2, 3, 4));
// Test: origTypeface and streamTypeface from orig data draw the same
drawBG(&origCanvas);
- origCanvas.drawText("A", 1, point.fX, point.fY, paint);
+ origCanvas.drawString("A", point.fX, point.fY, paint);
sk_sp<SkTypeface> typeface(paint.getTypeface() ? paint.refTypeface()
: SkTypeface::MakeDefault());
SkScalar ypos = SkIntToScalar(height);
untiledCanvas.save();
untiledCanvas.scale(SkIntToScalar(scale), SkIntToScalar(scale));
- untiledCanvas.drawText(text, strlen(text), 0, ypos, paint);
+ untiledCanvas.drawString(text, 0, ypos, paint);
untiledCanvas.restore();
for (int y = 0; y < height; y += tileSize) {
for (int x = 0; x < width; x += tileSize) {
tiledCanvas.save();
tiledCanvas.clipRect(SkRect::Make(SkIRect::MakeXYWH(x, y, tileSize, tileSize)));
tiledCanvas.scale(SkIntToScalar(scale), SkIntToScalar(scale));
- tiledCanvas.drawText(text, strlen(text), 0, ypos, paint);
+ tiledCanvas.drawString(text, 0, ypos, paint);
tiledCanvas.restore();
}
}
canvas->translate(20.0f, 10.0f);
canvas->rotate(30.0f);
const char text[] = "HELLO";
- canvas->drawText(text, strlen(text), 0, 0, SkPaint());
+ canvas->drawString(text, 0, 0, SkPaint());
}
static bool contains(const uint8_t* result, size_t size, const char expectation[]) {
SkPaint paint;
paint.setTypeface(SkTypeface::MakeFromName("Arial",
SkFontStyle::FromOldStyle(SkTypeface::kItalic)));
- canvas->drawText("Q", 1, 0, 10, paint);
+ canvas->drawString("Q", 0, 10, paint);
sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
SkDynamicMemoryWStream stream;
picture->serialize(&stream);
canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
paint.setColor(SK_ColorBLACK);
paint.setTextSize(SkIntToScalar(kBitmapSize/3));
- canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
+ canvas->drawString("Picture", SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
}
DEF_TEST(Serialization, reporter) {
EXPECT_COPY_ON_WRITE(drawBitmap(testBitmap, 0, 0))
EXPECT_COPY_ON_WRITE(drawBitmapRect(testBitmap, testRect, nullptr))
EXPECT_COPY_ON_WRITE(drawBitmapNine(testBitmap, testIRect, testRect, nullptr))
- EXPECT_COPY_ON_WRITE(drawText(testText.c_str(), testText.size(), 0, 1, testPaint))
+ EXPECT_COPY_ON_WRITE(drawString(testText, 0, 1, testPaint))
EXPECT_COPY_ON_WRITE(drawPosText(testText.c_str(), testText.size(), testPoints2, \
testPaint))
EXPECT_COPY_ON_WRITE(drawTextOnPath(testText.c_str(), testText.size(), testPath, nullptr, \
paint.setTextSize(75.0f);
canvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, rgb, paint);
if (label) {
- canvas->drawText("R", 1, rgb[0].fX + 5.0f, rgb[0].fY + 75.0f, paint);
- canvas->drawText("G", 1, rgb[1].fX + 5.0f, rgb[1].fY - 5.0f, paint);
- canvas->drawText("B", 1, rgb[2].fX - 75.0f, rgb[2].fY - 5.0f, paint);
+ canvas->drawString("R", rgb[0].fX + 5.0f, rgb[0].fY + 75.0f, paint);
+ canvas->drawString("G", rgb[1].fX + 5.0f, rgb[1].fY - 5.0f, paint);
+ canvas->drawString("B", rgb[2].fX - 75.0f, rgb[2].fY - 5.0f, paint);
}
}
paint.setTextSize(SkIntToScalar(textSize));
canvas.clear(0x00000000);
- canvas.drawText(str, strlen(str), SkIntToScalar(x), SkIntToScalar(y), paint);
+ canvas.drawString(str, SkIntToScalar(x), SkIntToScalar(y), paint);
// Tag data as sRGB (without doing any color space conversion). Color-space aware configs
// will process this correctly but legacy configs will render as if this returned N32.
if (kGrouped_HelpMode == fHelpMode && lastGroup != cmd.fGroup) {
// Group change. Advance and print header:
y += paint.getTextSize();
- canvas->drawText(cmd.fGroup.c_str(), cmd.fGroup.size(), x, y, groupPaint);
+ canvas->drawString(cmd.fGroup, x, y, groupPaint);
y += groupPaint.getTextSize() + 2;
lastGroup = cmd.fGroup;
}
- canvas->drawText(cmd.fKeyName.c_str(), cmd.fKeyName.size(), x, y, paint);
+ canvas->drawString(cmd.fKeyName, x, y, paint);
SkString text = SkStringPrintf(": %s", cmd.fDescription.c_str());
- canvas->drawText(text.c_str(), text.size(), x + keyWidth, y, paint);
+ canvas->drawString(text, x + keyWidth, y, paint);
y += paint.getTextSize() + 2;
}
}