blob: 9d0e3509f19814db00ae0284201cbd34bee60fbe [file] [log] [blame]
/*
* Copyright 2013 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 "SkFontMgr.h"
#include "SkGraphics.h"
#include "SkTypeface.h"
#ifdef SK_BUILD_FOR_WIN
#include "SkTypeface_win.h"
#endif
// limit this just so we don't take too long to draw
#define MAX_FAMILIES 30
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);
return x + paint.measureText(text.c_str(), text.size());
}
static SkScalar drawCharacter(SkCanvas* canvas, uint32_t character, SkScalar x,
SkScalar y, SkPaint& paint, SkFontMgr* fm,
const char* fontName, const char* bcp47[], int bcp47Count,
const SkFontStyle& fontStyle) {
// find typeface containing the requested character and draw it
SkString ch;
ch.appendUnichar(character);
SkTypeface* typeface = fm->matchFamilyStyleCharacter(fontName, fontStyle,
bcp47, bcp47Count, character);
SkSafeUnref(paint.setTypeface(typeface));
x = drawString(canvas, ch, x, y, paint) + 20;
if (NULL == typeface) {
return x;
}
// repeat the process, but this time use the family name of the typeface
// from the first pass. This emulates the behavior in Blink where it
// it expects to get the same glyph when following this pattern.
SkString familyName;
typeface->getFamilyName(&familyName);
SkTypeface* typefaceCopy = fm->legacyCreateTypeface(familyName.c_str(), typeface->style());
SkSafeUnref(paint.setTypeface(typefaceCopy));
return drawString(canvas, ch, x, y, paint) + 20;
}
static const char* zh = "zh";
static const char* ja = "ja";
class FontMgrGM : public skiagm::GM {
public:
FontMgrGM(SkFontMgr* fontMgr = NULL) {
SkGraphics::SetFontCacheLimit(16 * 1024 * 1024);
fName.set("fontmgr_iter");
if (fontMgr) {
fName.append("_factory");
fFM.reset(fontMgr);
} else {
fFM.reset(SkFontMgr::RefDefault());
}
}
protected:
SkString onShortName() SK_OVERRIDE {
return fName;
}
SkISize onISize() SK_OVERRIDE {
return SkISize::Make(1536, 768);
}
void onDraw(SkCanvas* canvas) SK_OVERRIDE {
SkScalar y = 20;
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
paint.setSubpixelText(true);
paint.setTextSize(17);
SkFontMgr* fm = fFM;
int count = SkMin32(fm->countFamilies(), MAX_FAMILIES);
for (int i = 0; i < count; ++i) {
SkString fname;
fm->getFamilyName(i, &fname);
paint.setTypeface(NULL);
(void)drawString(canvas, fname, 20, y, paint);
SkScalar x = 220;
SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
for (int j = 0; j < set->count(); ++j) {
SkString sname;
SkFontStyle fs;
set->getStyle(j, &fs, &sname);
sname.appendf(" [%d %d %d]", fs.weight(), fs.width(), fs.isItalic());
SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
x = drawString(canvas, sname, x, y, paint) + 20;
// check to see that we get different glyphs in japanese and chinese
x = drawCharacter(canvas, 0x5203, x, y, paint, fm, fName.c_str(), &zh, 1, fs);
x = drawCharacter(canvas, 0x5203, x, y, paint, fm, fName.c_str(), &ja, 1, fs);
// check that emoji characters are found
x = drawCharacter(canvas, 0x1f601, x, y, paint, fm, fName.c_str(), NULL, 0, fs);
}
y += 24;
}
}
uint32_t onGetFlags() const SK_OVERRIDE {
// fontdescriptors (and therefore serialization) don't yet understand
// these new styles, so skip tests that exercise that for now.
// If certain fonts are picked up (e.g. Microsoft Jhenghei 20MB for Regular, 12MB for Bold),
// the resulting pdf can be ~700MB and crashes Chrome's PDF viewer.
return kSkipPicture_Flag | kSkipPipe_Flag | kSkipPDF_Flag;
}
private:
SkAutoTUnref<SkFontMgr> fFM;
SkString fName;
typedef GM INHERITED;
};
class FontMgrMatchGM : public skiagm::GM {
SkAutoTUnref<SkFontMgr> fFM;
public:
FontMgrMatchGM() : fFM(SkFontMgr::RefDefault()) {
SkGraphics::SetFontCacheLimit(16 * 1024 * 1024);
}
protected:
SkString onShortName() SK_OVERRIDE {
return SkString("fontmgr_match");
}
SkISize onISize() SK_OVERRIDE {
return SkISize::Make(640, 1024);
}
void iterateFamily(SkCanvas* canvas, const SkPaint& paint,
SkFontStyleSet* fset) {
SkPaint p(paint);
SkScalar y = 0;
for (int j = 0; j < fset->count(); ++j) {
SkString sname;
SkFontStyle fs;
fset->getStyle(j, &fs, &sname);
sname.appendf(" [%d %d]", fs.weight(), fs.width());
SkSafeUnref(p.setTypeface(fset->createTypeface(j)));
(void)drawString(canvas, sname, 0, y, p);
y += 24;
}
}
void exploreFamily(SkCanvas* canvas, const SkPaint& paint,
SkFontStyleSet* fset) {
SkPaint p(paint);
SkScalar y = 0;
for (int weight = 100; weight <= 900; weight += 200) {
for (int width = 1; width <= 9; width += 2) {
SkFontStyle fs(weight, width, SkFontStyle::kUpright_Slant);
SkTypeface* face = fset->matchStyle(fs);
if (face) {
SkString str;
str.printf("request [%d %d]", fs.weight(), fs.width());
p.setTypeface(face)->unref();
(void)drawString(canvas, str, 0, y, p);
y += 24;
}
}
}
}
void onDraw(SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
paint.setSubpixelText(true);
paint.setTextSize(17);
static const char* gNames[] = {
"Helvetica Neue", "Arial"
};
SkAutoTUnref<SkFontStyleSet> fset;
for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
fset.reset(fFM->matchFamily(gNames[i]));
if (fset->count() > 0) {
break;
}
}
if (NULL == fset.get()) {
return;
}
canvas->translate(20, 40);
this->exploreFamily(canvas, paint, fset);
canvas->translate(150, 0);
this->iterateFamily(canvas, paint, fset);
}
uint32_t onGetFlags() const SK_OVERRIDE {
// fontdescriptors (and therefore serialization) don't yet understand
// these new styles, so skip tests that exercise that for now.
return kSkipPicture_Flag | kSkipPipe_Flag;
}
private:
typedef GM INHERITED;
};
class FontMgrBoundsGM : public skiagm::GM {
public:
FontMgrBoundsGM(double scale, double skew)
: fScaleX(SkDoubleToScalar(scale))
, fSkewX(SkDoubleToScalar(skew))
{
fName.set("fontmgr_bounds");
if (scale != 1 || skew != 0) {
fName.appendf("_%g_%g", scale, skew);
}
fFM.reset(SkFontMgr::RefDefault());
}
static void show_bounds(SkCanvas* canvas, const SkPaint& paint, SkScalar x, SkScalar y,
SkColor boundsColor) {
const char str[] = "jyHO[]{}@-_&%$";
for (int i = 0; str[i]; ++i) {
canvas->drawText(&str[i], 1, x, y, paint);
}
SkRect r = paint.getFontBounds();
r.offset(x, y);
SkPaint p(paint);
p.setColor(boundsColor);
canvas->drawRect(r, p);
}
protected:
SkString onShortName() SK_OVERRIDE {
return fName;
}
SkISize onISize() SK_OVERRIDE {
return SkISize::Make(1024, 850);
}
void onDraw(SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
paint.setAntiAlias(true);
paint.setSubpixelText(true);
paint.setTextSize(100);
paint.setStyle(SkPaint::kStroke_Style);
paint.setTextScaleX(fScaleX);
paint.setTextSkewX(fSkewX);
const SkColor boundsColors[2] = { SK_ColorRED, SK_ColorBLUE };
SkFontMgr* fm = fFM;
int count = SkMin32(fm->countFamilies(), 32);
int index = 0;
SkScalar x = 0, y = 0;
canvas->translate(80, 120);
for (int i = 0; i < count; ++i) {
SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
for (int j = 0; j < set->count(); ++j) {
SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
if (paint.getTypeface()) {
show_bounds(canvas, paint, x, y, boundsColors[index & 1]);
index += 1;
x += 160;
if (0 == (index % 6)) {
x = 0;
y += 160;
}
if (index >= 30) {
return;
}
}
}
}
}
uint32_t onGetFlags() const SK_OVERRIDE {
// fontdescriptors (and therefore serialization) don't yet understand
// these new styles, so skip tests that exercise that for now.
// If certain fonts are picked up (e.g. Microsoft Jhenghei 20MB for Regular, 12MB for Bold),
// the resulting pdf can be ~700MB and crashes Chrome's PDF viewer.
return kSkipPicture_Flag | kSkipPipe_Flag | kSkipPDF_Flag;
}
private:
SkAutoTUnref<SkFontMgr> fFM;
SkString fName;
SkScalar fScaleX, fSkewX;
typedef GM INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
DEF_GM( return SkNEW(FontMgrGM); )
DEF_GM( return SkNEW(FontMgrMatchGM); )
DEF_GM( return SkNEW(FontMgrBoundsGM(1.0, 0)); )
DEF_GM( return SkNEW(FontMgrBoundsGM(0.75, 0)); )
DEF_GM( return SkNEW(FontMgrBoundsGM(1.0, -0.25)); )
#ifdef SK_BUILD_FOR_WIN
DEF_GM( return SkNEW_ARGS(FontMgrGM, (SkFontMgr_New_DirectWrite())); )
#endif