skia2/gm/lcdtext.cpp
mtklein 72c9faab45 Fix up all the easy virtual ... SK_OVERRIDE cases.
This fixes every case where virtual and SK_OVERRIDE were on the same line,
which should be the bulk of cases.  We'll have to manually clean up the rest
over time unless I level up in regexes.

for f in (find . -type f); perl -p -i -e 's/virtual (.*)SK_OVERRIDE/\1SK_OVERRIDE/g' $f; end

BUG=skia:

Review URL: https://codereview.chromium.org/806653007
2015-01-09 10:06:40 -08:00

211 lines
6.3 KiB
C++

/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
/* Tests text rendering with LCD and subpixel rendering turned on and off.
*/
#include "gm.h"
#include "SkCanvas.h"
#include "SkPicture.h"
#include "SkPictureImageFilter.h"
#include "SkPictureRecorder.h"
#include "SkSurface.h"
class LcdTextGM : public skiagm::GM {
public:
LcdTextGM() {
const int pointSize = 36;
textHeight = SkIntToScalar(pointSize);
}
protected:
SkString onShortName() {
return SkString("lcdtext");
}
SkISize onISize() { return SkISize::Make(640, 480); }
virtual void onDraw(SkCanvas* canvas) {
y = textHeight;
drawText(canvas, SkString("TEXT: SubpixelTrue LCDRenderTrue"),
true, true);
drawText(canvas, SkString("TEXT: SubpixelTrue LCDRenderFalse"),
true, false);
drawText(canvas, SkString("TEXT: SubpixelFalse LCDRenderTrue"),
false, true);
drawText(canvas, SkString("TEXT: SubpixelFalse LCDRenderFalse"),
false, false);
}
void drawText(SkCanvas* canvas, const SkString& string,
bool subpixelTextEnabled, bool lcdRenderTextEnabled) {
SkPaint paint;
paint.setColor(SK_ColorBLACK);
paint.setDither(true);
paint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&paint);
paint.setSubpixelText(subpixelTextEnabled);
paint.setLCDRenderText(lcdRenderTextEnabled);
paint.setTextSize(textHeight);
canvas->drawText(string.c_str(), string.size(), 0, y, paint);
y += textHeight;
}
private:
typedef skiagm::GM INHERITED;
SkScalar y, textHeight;
};
/*
* Skia will automatically disable LCD requests if the total size exceeds some limit
* (hard coded in this test for now, as it is now avaiable as an API)
*
* Test this both by changing "textsize" and by changing the computed size (textsize * CTM)
*/
class LcdTextSizeGM : public skiagm::GM {
enum {
kLCDTextSizeLimit = 48
};
static void ScaleAbout(SkCanvas* canvas, SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
SkMatrix m;
m.setScale(sx, sy, px, py);
canvas->concat(m);
}
public:
LcdTextSizeGM() {}
protected:
SkString onShortName() {
return SkString("lcdtextsize");
}
SkISize onISize() { return SkISize::Make(320, 120); }
virtual void onDraw(SkCanvas* canvas) {
const char* lcd_text = "LCD";
const char* gray_text = "GRAY";
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
const struct {
SkPoint fLoc;
SkScalar fTextSize;
SkScalar fScale;
const char* fText;
} rec[] = {
{ { 10, 50 }, kLCDTextSizeLimit - 1, 1, lcd_text },
{ { 160, 50 }, kLCDTextSizeLimit + 1, 1, gray_text },
{ { 10, 100 }, kLCDTextSizeLimit / 2, 1.99f, lcd_text },
{ { 160, 100 }, kLCDTextSizeLimit / 2, 2.01f, gray_text },
};
for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) {
const SkPoint loc = rec[i].fLoc;
SkAutoCanvasRestore acr(canvas, true);
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);
}
}
private:
typedef skiagm::GM INHERITED;
};
// ensure that we respect the SkPixelGeometry in SurfaceProps
class LcdTextProps : public skiagm::GM {
static void DrawText(SkCanvas* canvas) {
canvas->drawColor(SK_ColorWHITE);
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
paint.setTextSize(30);
canvas->drawText("Base", 4, 4, 30, paint);
canvas->saveLayer(NULL, NULL);
canvas->drawText("Layer", 5, 4, 70, paint);
canvas->restore();
}
static SkSurface* MakeSurface(SkCanvas* canvas, const SkImageInfo& info, SkPixelGeometry geo) {
SkSurfaceProps props = SkSurfaceProps(0, geo);
SkSurface* surface = canvas->newSurface(info, &props);
if (!surface) {
surface = SkSurface::NewRaster(info, &props);
}
return surface;
}
protected:
SkString onShortName() SK_OVERRIDE {
return SkString("lcdtextprops");
}
SkISize onISize() SK_OVERRIDE { return SkISize::Make(230, 230); }
uint32_t onGetFlags() const SK_OVERRIDE {
return kSkip565_Flag;
}
void onOnceBeforeDraw() SK_OVERRIDE {
fInfo = SkImageInfo::MakeN32Premul(100, 100);
SkPictureRecorder recorder;
DrawText(recorder.beginRecording(SkIntToScalar(fInfo.width()),
SkIntToScalar(fInfo.height())));
SkAutoTUnref<SkPicture> pic(recorder.endRecording());
SkAutoTUnref<SkImageFilter> filter(SkPictureImageFilter::Create(pic.get()));
fFilterPaint.setImageFilter(filter.get());
}
void onDraw(SkCanvas* canvas) SK_OVERRIDE {
const SkPixelGeometry geos[] = {
kRGB_H_SkPixelGeometry,
kUnknown_SkPixelGeometry,
};
for (size_t i = 0; i < SK_ARRAY_COUNT(geos); ++i) {
SkAutoTUnref<SkSurface> surf(MakeSurface(canvas, fInfo, geos[i]));
DrawText(surf->getCanvas());
surf->draw(canvas, SkIntToScalar(i * (fInfo.width() + 10)), 0, NULL);
}
for (size_t i = 0; i < SK_ARRAY_COUNT(geos); ++i) {
SkAutoTUnref<SkSurface> surf(MakeSurface(canvas, fInfo, geos[i]));
surf->getCanvas()->saveLayer(NULL, &fFilterPaint);
surf->getCanvas()->restore();
surf->draw(canvas,
SkIntToScalar(i * (fInfo.width() + 10)),
SkIntToScalar(fInfo.height() + 10),
NULL);
}
}
private:
SkPaint fFilterPaint;
SkImageInfo fInfo;
typedef skiagm::GM INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
DEF_GM( return new LcdTextGM; )
DEF_GM( return new LcdTextSizeGM; )
// Temporarily disabled (dftext interference)
// DEF_GM( return new LcdTextProps; )