ShaderView()
{
SkImageDecoder::DecodeFile("/cover.png", &fBitmap);
SkPoint pts[2];
SkColor colors[2];
pts[0].set(0, 0);
pts[1].set(SkIntToScalar(100), 0);
colors[0] = SK_ColorRED;
colors[1] = SK_ColorBLUE;
SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
pts[0].set(0, 0);
pts[1].set(0, SkIntToScalar(100));
colors[0] = SK_ColorBLACK;
colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
SkXfermode* mode = SkPorterDuff::CreateXfermode(SkPorterDuff::kDstIn_Mode);
fShader = new SkComposeShader(shaderA, shaderB, mode);
shaderA->unref();
shaderB->unref();
mode->unref();
}
virtual void onDraw(SkCanvas* canvas) {
SkPoint pts[2] = {
{ 0, 0 },
{ SkIntToScalar(100), SkIntToScalar(100) }
};
SkShader::TileMode tm = SkShader::kClamp_TileMode;
SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
SkPaint paint;
paint.setAntiAlias(true);
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
canvas->save();
for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
SkMatrix scale = SkMatrix::I();
if (i == 5) { // if the clamp case
scale.setScale(0.5f, 0.5f);
scale.postTranslate(25.f, 25.f);
}
SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, scale);
paint.setShader(shader);
canvas->drawRect(r, paint);
shader->unref();
canvas->translate(0, SkIntToScalar(120));
}
canvas->restore();
canvas->translate(SkIntToScalar(120), 0);
}
}
static cairo_status_t
_cairo_skia_context_set_source (void *abstract_cr,
cairo_pattern_t *source)
{
cairo_skia_context_t *cr = (cairo_skia_context_t *) abstract_cr;
SkColor color;
if (cr->source != NULL) {
if (cr->source_image != NULL) {
_cairo_surface_release_source_image (cr->source, cr->source_image, cr->source_extra);
cr->source_image = NULL;
}
cairo_surface_destroy (cr->source);
cr->source = NULL;
}
if (pattern_to_sk_color (source, color)) {
cr->paint->setColor (color);
} else {
SkShader *shader = source_to_sk_shader (cr, source);
if (shader == NULL) {
UNSUPPORTED;
return CAIRO_STATUS_SUCCESS;
}
cr->paint->setShader (shader);
shader->unref ();
cr->paint->setFilterBitmap (pattern_filter_to_sk (source));
}
/* XXX change notification */
return CAIRO_STATUS_SUCCESS;
}
static void gradient_slide(SkCanvas* canvas) {
SkPoint pts[2] = {
{ 0, 0 },
{ SkIntToScalar(100), SkIntToScalar(100) }
};
SkShader::TileMode tm = SkShader::kClamp_TileMode;
SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
SkPaint paint;
paint.setAntiAlias(true);
paint.setDither(true);
canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
canvas->save();
for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
SkShader* shader = gGradMakers[j](pts, gGradData[i], tm);
paint.setShader(shader);
canvas->drawRect(r, paint);
shader->unref();
canvas->translate(0, SkIntToScalar(120));
}
canvas->restore();
canvas->translate(SkIntToScalar(120), 0);
}
}
virtual void onDraw(SkCanvas* canvas) {
SkPoint pts[2] = {
{ 0, 0 },
{ SkIntToScalar(100), SkIntToScalar(100) }
};
SkShader::TileMode tm = SkShader::kClamp_TileMode;
SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
SkPaint paint;
paint.setAntiAlias(true);
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
canvas->save();
for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
// apply an increasing y perspective as we move to the right
SkMatrix perspective;
perspective.setIdentity();
perspective.setPerspY(SkScalarDiv(SkIntToScalar((unsigned) i+1),
SkIntToScalar(500)));
perspective.setSkewX(SkScalarDiv(SkIntToScalar((unsigned) i+1),
SkIntToScalar(10)));
shader->setLocalMatrix(perspective);
paint.setShader(shader);
canvas->drawRect(r, paint);
shader->unref();
canvas->translate(0, SkIntToScalar(120));
}
canvas->restore();
canvas->translate(SkIntToScalar(120), 0);
}
}
int
sk_test_linear_gradient(caskbench_context_t *ctx)
{
int w = ctx->canvas_width;
int h = ctx->canvas_height;
int stops = 10;
SkPoint pts[2];
pts[0].iset(0, 0);
pts[1].iset(100, 100);
SkColor colors[10];
SkScalar pos[10];
for (int i = 0; i < stops; i++) {
pos[i] = i / SkIntToScalar(stops - 1);
colors[i] = skiaRandomColor();
}
SkShader *shader = SkGradientShader::CreateLinear(pts, colors, pos, stops,
SkShader::kClamp_TileMode);
ctx->skia_paint->setShader(shader);
shapes_t shape;
shape_copy(&ctx->shape_defaults, &shape);
for (int i=0; i<ctx->size; i++) {
double x1 = (double)rnd()/RAND_MAX * w;
double x2 = (double)rnd()/RAND_MAX * w;
double y1 = (double)rnd()/RAND_MAX * h;
double y2 = (double)rnd()/RAND_MAX * h;
double xx = MIN(x1, x2);
double yy = MIN(x1, x2);
double ww = abs(x2 - x1);
double hh = abs(y2 - y1);
ctx->skia_canvas->save();
ctx->skia_canvas->translate(SkDoubleToScalar(xx), SkDoubleToScalar(yy));
ctx->skia_canvas->scale(SkDoubleToScalar(ww/100), SkDoubleToScalar(hh/100));
// transform(shape.width/100, 0, 0, shape.height/100, 0, 0)
shape.x = 0;
shape.y = 0;
shape.width = 100;
shape.height = 100;
shape.fill_type = CB_FILL_LINEAR_GRADIENT;
ctx->skia_paint->setStyle(SkPaint::kFill_Style);
ctx->skia_paint->setShader(shader);
skiaDrawRectangle(ctx, &shape);
ctx->skia_canvas->restore();
}
if (shader)
shader->unref();
return 1;
}
static void paintButtonLike(RenderTheme* theme, RenderObject* o, const RenderObject::PaintInfo& i, const IntRect& rect)
{
SkCanvas* const canvas = i.context->platformContext()->canvas();
SkPaint paint;
SkRect skrect;
const int right = rect.x() + rect.width();
const int bottom = rect.y() + rect.height();
SkColor baseColor = SkColorSetARGB(0xff, 0xdd, 0xdd, 0xdd);
if (o->style()->hasBackground())
baseColor = o->style()->backgroundColor().rgb();
double h, s, l;
Color(baseColor).getHSL(h, s, l);
// Our standard gradient is from 0xdd to 0xf8. This is the amount of
// increased luminance between those values.
SkColor lightColor(brightenColor(h, s, l, 0.105));
// If the button is too small, fallback to drawing a single, solid color
if (rect.width() < 5 || rect.height() < 5) {
paint.setColor(baseColor);
skrect.set(rect.x(), rect.y(), right, bottom);
canvas->drawRect(skrect, paint);
return;
}
const int borderAlpha = theme->isHovered(o) ? 0x80 : 0x55;
paint.setARGB(borderAlpha, 0, 0, 0);
canvas->drawLine(rect.x() + 1, rect.y(), right - 1, rect.y(), paint);
canvas->drawLine(right - 1, rect.y() + 1, right - 1, bottom - 1, paint);
canvas->drawLine(rect.x() + 1, bottom - 1, right - 1, bottom - 1, paint);
canvas->drawLine(rect.x(), rect.y() + 1, rect.x(), bottom - 1, paint);
paint.setARGB(0xff, 0, 0, 0);
SkPoint p[2];
const int lightEnd = theme->isPressed(o) ? 1 : 0;
const int darkEnd = !lightEnd;
p[lightEnd].set(SkIntToScalar(rect.x()), SkIntToScalar(rect.y()));
p[darkEnd].set(SkIntToScalar(rect.x()), SkIntToScalar(bottom - 1));
SkColor colors[2];
colors[0] = lightColor;
colors[1] = baseColor;
SkShader* shader = SkGradientShader::CreateLinear(
p, colors, NULL, 2, SkShader::kClamp_TileMode, NULL);
paint.setStyle(SkPaint::kFill_Style);
paint.setShader(shader);
shader->unref();
skrect.set(rect.x() + 1, rect.y() + 1, right - 1, bottom - 1);
canvas->drawRect(skrect, paint);
paint.setShader(NULL);
paint.setColor(brightenColor(h, s, l, -0.0588));
canvas->drawPoint(rect.x() + 1, rect.y() + 1, paint);
canvas->drawPoint(right - 2, rect.y() + 1, paint);
canvas->drawPoint(rect.x() + 1, bottom - 2, paint);
canvas->drawPoint(right - 2, bottom - 2, paint);
}
static void test_gradient(skiatest::Reporter* reporter)
{
SkPoint pts[2];
pts[0].iset(0, 0);
pts[1].iset(1, 0);
SkColor colors[2];
SkScalar pos[2] = {SkIntToScalar(0), SkIntToScalar(1)};
int count = 2;
SkShader::TileMode mode = SkShader::kClamp_TileMode;
// test 1: all opaque
colors[0] = SkColorSetARGB(0xFF, 0, 0, 0);
colors[1] = SkColorSetARGB(0xFF, 0, 0, 0);
SkShader* grad = SkGradientShader::CreateLinear(pts, colors, pos, count,
mode);
REPORTER_ASSERT(reporter, grad);
REPORTER_ASSERT(reporter, grad->isOpaque());
grad->unref();
// test 2: all 0 alpha
colors[0] = SkColorSetARGB(0, 0, 0, 0);
colors[1] = SkColorSetARGB(0, 0, 0, 0);
grad = SkGradientShader::CreateLinear(pts, colors, pos, count, mode);
REPORTER_ASSERT(reporter, grad);
REPORTER_ASSERT(reporter, !grad->isOpaque());
grad->unref();
// test 3: one opaque, one transparent
colors[0] = SkColorSetARGB(0xFF, 0, 0, 0);
colors[1] = SkColorSetARGB(0x40, 0, 0, 0);
grad = SkGradientShader::CreateLinear(pts, colors, pos, count, mode);
REPORTER_ASSERT(reporter, grad);
REPORTER_ASSERT(reporter, !grad->isOpaque());
grad->unref();
// test 4: test 3, swapped
colors[0] = SkColorSetARGB(0x40, 0, 0, 0);
colors[1] = SkColorSetARGB(0xFF, 0, 0, 0);
grad = SkGradientShader::CreateLinear(pts, colors, pos, count, mode);
REPORTER_ASSERT(reporter, grad);
REPORTER_ASSERT(reporter, !grad->isOpaque());
grad->unref();
}
static cairo_int_status_t
_cairo_skia_surface_paint (void *asurface,
cairo_operator_t op,
const cairo_pattern_t *source,
cairo_clip_t *clip)
{
cairo_skia_surface_t *surface = (cairo_skia_surface_t *) asurface;
cairo_image_surface_t *image = NULL;
cairo_status_t status;
void *image_extra;
SkColor color;
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
if (unlikely (status))
return (cairo_int_status_t) status;
if (pattern_to_sk_color (source, color)) {
surface->canvas->drawColor (color, operator_to_sk (op));
return CAIRO_INT_STATUS_SUCCESS;
}
SkMatrix bitmapMatrix;
SkBitmap *bitmap = pattern_to_sk_bitmap (surface, source, &bitmapMatrix,
&image, &image_extra);
SkShader *shader = NULL;
if (!bitmap)
shader = pattern_to_sk_shader (surface, source, &image, &image_extra);
if (!bitmap && !shader)
return UNSUPPORTED("pattern to bitmap and shader conversion");
SkPaint paint;
paint.setFilterBitmap (pattern_filter_to_sk (source));
paint.setXfermodeMode (operator_to_sk (op));
if (shader) {
paint.setShader (shader);
surface->canvas->drawPaint (paint);
} else {
surface->canvas->drawBitmapMatrix (*bitmap, bitmapMatrix, &paint);
}
if (bitmap)
delete bitmap;
if (shader)
shader->unref ();
if (image != NULL) {
_cairo_surface_release_source_image (&surface->base,
image, image_extra);
}
return CAIRO_INT_STATUS_SUCCESS;
}
void make_bitmap() {
fBitmap.allocN32Pixels(80, 80);
SkCanvas canvas(fBitmap);
canvas.clear(0x00000000);
SkPaint paint;
paint.setAntiAlias(true);
SkShader* shader = MakeLinear();
paint.setShader(shader);
SkRect r = { 0, 0, SkIntToScalar(80), SkIntToScalar(80) };
canvas.drawRect(r, paint);
shader->unref();
}
static void test_bitmap(skiatest::Reporter* reporter) {
SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
SkBitmap bmp;
bmp.setConfig(info);
// test 1: bitmap without pixel data
SkShader* shader = SkShader::CreateBitmapShader(bmp,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
REPORTER_ASSERT(reporter, shader);
REPORTER_ASSERT(reporter, !shader->isOpaque());
shader->unref();
// From this point on, we have pixels
bmp.allocPixels(info);
// test 2: not opaque by default
shader = SkShader::CreateBitmapShader(bmp,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
REPORTER_ASSERT(reporter, shader);
REPORTER_ASSERT(reporter, !shader->isOpaque());
shader->unref();
// test 3: explicitly opaque
bmp.setAlphaType(kOpaque_SkAlphaType);
shader = SkShader::CreateBitmapShader(bmp,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
REPORTER_ASSERT(reporter, shader);
REPORTER_ASSERT(reporter, shader->isOpaque());
shader->unref();
// test 4: explicitly not opaque
bmp.setAlphaType(kPremul_SkAlphaType);
shader = SkShader::CreateBitmapShader(bmp,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
REPORTER_ASSERT(reporter, shader);
REPORTER_ASSERT(reporter, !shader->isOpaque());
shader->unref();
}
static SkShader* make_bitmapfade(const SkBitmap& bm)
{
SkPoint pts[2];
SkColor colors[2];
pts[0].set(0, 0);
pts[1].set(0, SkIntToScalar(bm.height()));
colors[0] = SK_ColorBLACK;
colors[1] = SkColorSetARGB(0, 0, 0, 0);
SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
SkShader* shaderB = SkShader::CreateBitmapShader(bm,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
SkXfermode* mode = SkPorterDuff::CreateXfermode(SkPorterDuff::kDstIn_Mode);
SkShader* shader = new SkComposeShader(shaderB, shaderA, mode);
shaderA->unref();
shaderB->unref();
mode->unref();
return shader;
}
static cairo_int_status_t
_cairo_skia_surface_fill (void *asurface,
cairo_operator_t op,
const cairo_pattern_t *source,
cairo_path_fixed_t *path,
cairo_fill_rule_t fill_rule,
double tolerance,
cairo_antialias_t antialias,
cairo_clip_t *clip)
{
cairo_skia_surface_t *surface = (cairo_skia_surface_t *) asurface;
cairo_image_surface_t *image = NULL;
cairo_status_t status;
void *image_extra;
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
if (unlikely (status))
return (cairo_int_status_t) status;
SkPaint paint;
paint.setStyle (SkPaint::kFill_Style);
SkColor color;
if (pattern_to_sk_color (source, color)) {
paint.setColor (color);
} else {
SkShader *shader = pattern_to_sk_shader (surface,
source, &image, &image_extra);
if (shader == NULL)
return UNSUPPORTED("pattern to shader conversion");
paint.setShader (shader);
shader->unref ();
paint.setFilterBitmap (pattern_filter_to_sk (source));
}
paint.setXfermodeMode (operator_to_sk (op));
paint.setAntiAlias (antialias != CAIRO_ANTIALIAS_NONE);
surface->canvas->drawPath (path_to_sk (path, fill_rule), paint);
if (image != NULL) {
_cairo_surface_release_source_image (&surface->base,
image, image_extra);
}
return CAIRO_INT_STATUS_SUCCESS;
}
void
sk_set_fill_style(caskbench_context_t *ctx, const shapes_t *shape)
{
SkShader* shader = NULL;
switch (shape->fill_type) {
case CB_FILL_NONE:
ctx->skia_paint->setStyle(SkPaint::kStroke_Style);
break;
case CB_FILL_SOLID:
if (shape->stroke_width <= 0)
ctx->skia_paint->setStyle(SkPaint::kFill_Style);
else
ctx->skia_paint->setStyle(SkPaint::kStrokeAndFill_Style);
break;
case CB_FILL_LINEAR_GRADIENT:
if(shape->shape_type == CB_SHAPE_STAR || shape->shape_type == CB_SHAPE_CIRCLE)
shader = skiaCreateLinearGradientShader(shape->y-shape->radius, shape->y + shape->radius);
else
shader = skiaCreateLinearGradientShader(shape->y, shape->y + shape->height);
ctx->skia_paint->setStyle(SkPaint::kFill_Style);
ctx->skia_paint->setShader(shader);
break;
case CB_FILL_RADIAL_GRADIENT:
shader = skiaCreateRadialGradientShader(shape);
ctx->skia_paint->setStyle(SkPaint::kFill_Style);
ctx->skia_paint->setShader(shader);
break;
case CB_FILL_IMAGE_PATTERN:
if (ctx->stock_image_path) {
shader = skiaCreateBitmapShader(ctx->stock_image_path);
ctx->skia_paint->setStyle(SkPaint::kFill_Style);
ctx->skia_paint->setShader(shader);
}
break;
#if 0
case CB_FILL_HERRINGBONE_PATTERN: /* TODO */
break;
#endif
default:
break;
}
if (shader)
shader->unref();
}
virtual void onDraw(SkCanvas* canvas) {
this->drawBG(canvas);
SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(300) };
SkPaint paint;
paint.setAntiAlias(true);
SkPoint center;
center.iset(0, 300);
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
SkShader* shader = SkGradientShader::CreateRadial(
SkPoint(center),
SkIntToScalar(200), gColors, NULL, 5,
SkShader::kClamp_TileMode, NULL);
paint.setShader(shader);
canvas->drawRect(r, paint);
shader->unref();
}
static cairo_status_t
_cairo_skia_context_set_source_surface (void *abstract_cr,
cairo_surface_t *surface,
double x,
double y)
{
cairo_skia_context_t *cr = (cairo_skia_context_t *) abstract_cr;
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
cairo_status_t status;
if (surface->type == CAIRO_SURFACE_TYPE_SKIA) {
cairo_skia_surface_t *esurf = (cairo_skia_surface_t *) surface;
SkShader *shader;
shader = SkShader::CreateBitmapShader (*esurf->bitmap,
SkShader::kClamp_TileMode, /* XXX */
SkShader::kClamp_TileMode);
cr->paint->setShader (shader);
shader->unref ();
cr->paint->setFilterLevel (true ?
(SkPaint::kLow_FilterLevel) : (SkPaint::kNone_FilterLevel));
return CAIRO_STATUS_SUCCESS;
}
pattern = cairo_pattern_create_for_surface (surface);
if (unlikely (pattern->status))
return pattern->status;
cairo_matrix_init_translate (&matrix, -x, -y);
cairo_pattern_set_matrix (pattern, &matrix);
status = _cairo_skia_context_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
return status;
}
virtual ~ClampView() {
fGrad->unref();
}
void onDraw(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
const struct {
SkXfermode::Mode fMode;
const char* fLabel;
int fSourceTypeMask; // The source types to use this
// mode with. See draw_mode for
// an explanation of each type.
// PDF has to play some tricks
// to support the base modes,
// test those more extensively.
} gModes[] = {
{ SkXfermode::kClear_Mode, "Clear", kAll_SrcType },
{ SkXfermode::kSrc_Mode, "Src", kAll_SrcType },
{ SkXfermode::kDst_Mode, "Dst", kAll_SrcType },
{ SkXfermode::kSrcOver_Mode, "SrcOver", kAll_SrcType },
{ SkXfermode::kDstOver_Mode, "DstOver", kAll_SrcType },
{ SkXfermode::kSrcIn_Mode, "SrcIn", kAll_SrcType },
{ SkXfermode::kDstIn_Mode, "DstIn", kAll_SrcType },
{ SkXfermode::kSrcOut_Mode, "SrcOut", kAll_SrcType },
{ SkXfermode::kDstOut_Mode, "DstOut", kAll_SrcType },
{ SkXfermode::kSrcATop_Mode, "SrcATop", kAll_SrcType },
{ SkXfermode::kDstATop_Mode, "DstATop", kAll_SrcType },
{ SkXfermode::kXor_Mode, "Xor", kBasic_SrcType },
{ SkXfermode::kPlus_Mode, "Plus", kBasic_SrcType },
{ SkXfermode::kModulate_Mode, "Modulate", kAll_SrcType },
{ SkXfermode::kScreen_Mode, "Screen", kBasic_SrcType },
{ SkXfermode::kOverlay_Mode, "Overlay", kBasic_SrcType },
{ SkXfermode::kDarken_Mode, "Darken", kBasic_SrcType },
{ SkXfermode::kLighten_Mode, "Lighten", kBasic_SrcType },
{ SkXfermode::kColorDodge_Mode, "ColorDodge", kBasic_SrcType },
{ SkXfermode::kColorBurn_Mode, "ColorBurn", kBasic_SrcType },
{ SkXfermode::kHardLight_Mode, "HardLight", kBasic_SrcType },
{ SkXfermode::kSoftLight_Mode, "SoftLight", kBasic_SrcType },
{ SkXfermode::kDifference_Mode, "Difference", kBasic_SrcType },
{ SkXfermode::kExclusion_Mode, "Exclusion", kBasic_SrcType },
{ SkXfermode::kMultiply_Mode, "Multiply", kAll_SrcType },
{ SkXfermode::kHue_Mode, "Hue", kBasic_SrcType },
{ SkXfermode::kSaturation_Mode, "Saturation", kBasic_SrcType },
{ SkXfermode::kColor_Mode, "Color", kBasic_SrcType },
{ SkXfermode::kLuminosity_Mode, "Luminosity", kBasic_SrcType },
};
const SkScalar w = SkIntToScalar(W);
const SkScalar h = SkIntToScalar(H);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&m);
SkPaint labelP;
labelP.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelP);
labelP.setTextAlign(SkPaint::kCenter_Align);
const int W = 5;
SkScalar x0 = 0;
SkScalar y0 = 0;
for (int sourceType = 1; sourceType & kAll_SrcType; sourceType <<= 1) {
SkScalar x = x0, y = y0;
for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
if ((gModes[i].fSourceTypeMask & sourceType) == 0) {
continue;
}
SkXfermode* mode = SkXfermode::Create(gModes[i].fMode);
SkAutoUnref aur(mode);
SkRect r;
r.set(x, y, x+w, y+h);
SkPaint p;
p.setStyle(SkPaint::kFill_Style);
p.setShader(s);
canvas->drawRect(r, p);
canvas->saveLayer(&r, NULL);
draw_mode(canvas, mode, static_cast<SrcType>(sourceType),
r.fLeft, r.fTop);
canvas->restore();
r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
p.setStyle(SkPaint::kStroke_Style);
p.setShader(NULL);
canvas->drawRect(r, p);
#if 1
canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
x + w/2, y - labelP.getTextSize()/2, labelP);
#endif
x += w + SkIntToScalar(10);
if ((i % W) == W - 1) {
x = x0;
y += h + SkIntToScalar(30);
}
}
if (y < 320) {
if (x > x0) {
y += h + SkIntToScalar(30);
}
y0 = y;
} else {
x0 += SkIntToScalar(400);
y0 = 0;
}
}
s->unref();
}
virtual void onDraw(SkCanvas* canvas) {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
this->drawBG(canvas);
const struct {
SkXfermode::Mode fMode;
const char* fLabel;
} gModes[] = {
{ SkXfermode::kClear_Mode, "Clear" },
{ SkXfermode::kSrc_Mode, "Src" },
{ SkXfermode::kDst_Mode, "Dst" },
{ SkXfermode::kSrcOver_Mode, "SrcOver" },
{ SkXfermode::kDstOver_Mode, "DstOver" },
{ SkXfermode::kSrcIn_Mode, "SrcIn" },
{ SkXfermode::kDstIn_Mode, "DstIn" },
{ SkXfermode::kSrcOut_Mode, "SrcOut" },
{ SkXfermode::kDstOut_Mode, "DstOut" },
{ SkXfermode::kSrcATop_Mode, "SrcATop" },
{ SkXfermode::kDstATop_Mode, "DstATop" },
{ SkXfermode::kXor_Mode, "Xor" },
{ SkXfermode::kPlus_Mode, "Plus" },
{ SkXfermode::kMultiply_Mode, "Multiply" },
{ SkXfermode::kScreen_Mode, "Screen" },
{ SkXfermode::kOverlay_Mode, "Overlay" },
{ SkXfermode::kDarken_Mode, "Darken" },
{ SkXfermode::kLighten_Mode, "Lighten" },
{ SkXfermode::kColorDodge_Mode, "ColorDodge" },
{ SkXfermode::kColorBurn_Mode, "ColorBurn" },
{ SkXfermode::kHardLight_Mode, "HardLight" },
{ SkXfermode::kSoftLight_Mode, "SoftLight" },
{ SkXfermode::kDifference_Mode, "Difference" },
{ SkXfermode::kExclusion_Mode, "Exclusion" },
};
const SkScalar w = SkIntToScalar(W);
const SkScalar h = SkIntToScalar(H);
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
SkPaint labelP;
labelP.setAntiAlias(true);
labelP.setTextAlign(SkPaint::kCenter_Align);
const int W = 5;
SkScalar x0 = 0;
for (int twice = 0; twice < 2; twice++) {
SkScalar x = x0, y = 0;
for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
SkXfermode* mode = SkXfermode::Create(gModes[i].fMode);
SkAutoUnref aur(mode);
SkRect r;
r.set(x, y, x+w, y+h);
SkPaint p;
p.setStyle(SkPaint::kFill_Style);
p.setShader(s);
canvas->drawRect(r, p);
canvas->saveLayer(&r, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
draw_mode(canvas, mode, twice ? 0x88 : 0xFF, r.fLeft, r.fTop);
canvas->restore();
r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
p.setStyle(SkPaint::kStroke_Style);
p.setShader(NULL);
canvas->drawRect(r, p);
#if 1
canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
x + w/2, y - labelP.getTextSize()/2, labelP);
#endif
x += w + SkIntToScalar(10);
if ((i % W) == W - 1) {
x = x0;
y += h + SkIntToScalar(30);
}
}
x0 += SkIntToScalar(400);
}
s->unref();
}
static cairo_int_status_t
_cairo_skia_surface_stroke (void *asurface,
cairo_operator_t op,
const cairo_pattern_t *source,
cairo_path_fixed_t *path,
cairo_stroke_style_t *style,
cairo_matrix_t *ctm,
cairo_matrix_t *ctm_inverse,
double tolerance,
cairo_antialias_t antialias,
cairo_clip_t *clip)
{
cairo_skia_surface_t *surface = (cairo_skia_surface_t *) asurface;
cairo_image_surface_t *image = NULL;
cairo_status_t status;
void *image_extra;
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
if (unlikely (status))
return (cairo_int_status_t) status;
SkPaint paint;
paint.setStyle (SkPaint::kStroke_Style);
SkColor color;
if (pattern_to_sk_color (source, color)) {
paint.setColor (color);
} else {
SkShader *shader = pattern_to_sk_shader (surface,
source, &image, &image_extra);
if (shader == NULL)
return UNSUPPORTED("pattern to shader conversion");
paint.setShader (shader);
shader->unref ();
paint.setFilterBitmap (pattern_filter_to_sk (source));
}
paint.setXfermodeMode (operator_to_sk (op));
paint.setAntiAlias (antialias != CAIRO_ANTIALIAS_NONE);
/* Convert the various stroke rendering bits */
paint.setStrokeWidth (SkFloatToScalar (style->line_width));
paint.setStrokeMiter (SkFloatToScalar (style->miter_limit));
static const SkPaint::Cap capMap[] = {
SkPaint::kButt_Cap,
SkPaint::kRound_Cap,
SkPaint::kSquare_Cap
};
paint.setStrokeCap (capMap[style->line_cap]);
static const SkPaint::Join joinMap[] = {
SkPaint::kMiter_Join,
SkPaint::kRound_Join,
SkPaint::kBevel_Join
};
paint.setStrokeJoin (joinMap[style->line_join]);
/* If we have a dash pattern, we need to
* create a SkDashPathEffect and set it on the Paint.
*/
if (style->dash != NULL) {
SkScalar intervals_static[20];
SkScalar *intervals = intervals_static;
int loop = 0;
unsigned int dash_count = style->num_dashes;
if ((dash_count & 1) != 0) {
loop = 1;
dash_count <<= 1;
}
if (dash_count > 20)
intervals = new SkScalar[dash_count];
unsigned int i = 0;
do {
for (unsigned int j = 0; i < style->num_dashes; j++)
intervals[i++] = SkFloatToScalar (style->dash[j]);
} while (loop--);
SkDashPathEffect *dash = new SkDashPathEffect (intervals,
dash_count,
SkFloatToScalar (style->dash_offset));
paint.setPathEffect (dash);
dash->unref ();
}
surface->canvas->save (SkCanvas::kMatrix_SaveFlag);
surface->canvas->concat (matrix_to_sk (*ctm));
surface->canvas->drawPath (path_to_sk (path, ctm_inverse), paint);
surface->canvas->restore ();
if (image != NULL) {
_cairo_surface_release_source_image (&surface->base,
image, image_extra);
}
return CAIRO_INT_STATUS_SUCCESS;
}
virtual void onDrawContent(SkCanvas* canvas) {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
if (false) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextSize(50);
paint.setTypeface(SkTypeface::CreateFromName("Arial Unicode MS", SkTypeface::kNormal));
SkSafeUnref(paint.getTypeface());
char buffer[10];
size_t len = SkUTF8_FromUnichar(0x8500, buffer);
canvas->drawText(buffer, len, 40, 40, paint);
return;
}
if (false) {
SkPaint paint;
paint.setAntiAlias(true);
SkRect r0 = { 0, 0, 10.5f, 20 };
SkRect r1 = { 10.5f, 10, 20, 30 };
paint.setColor(SK_ColorRED);
canvas->drawRect(r0, paint);
paint.setColor(SK_ColorBLUE);
canvas->drawRect(r1, paint);
return;
}
const struct {
SkXfermode::Mode fMode;
const char* fLabel;
} gModes[] = {
{ SkXfermode::kClear_Mode, "Clear" },
{ SkXfermode::kSrc_Mode, "Src" },
{ SkXfermode::kDst_Mode, "Dst" },
{ SkXfermode::kSrcOver_Mode, "SrcOver" },
{ SkXfermode::kDstOver_Mode, "DstOver" },
{ SkXfermode::kSrcIn_Mode, "SrcIn" },
{ SkXfermode::kDstIn_Mode, "DstIn" },
{ SkXfermode::kSrcOut_Mode, "SrcOut" },
{ SkXfermode::kDstOut_Mode, "DstOut" },
{ SkXfermode::kSrcATop_Mode, "SrcATop" },
{ SkXfermode::kDstATop_Mode, "DstATop" },
{ SkXfermode::kXor_Mode, "Xor" },
{ SkXfermode::kPlus_Mode, "Plus" },
/*{ SkXfermode::kModulate_Mode, "Modulate" },
{ SkXfermode::kScreen_Mode, "Screen" },
{ SkXfermode::kOverlay_Mode, "Overlay" },
{ SkXfermode::kDarken_Mode, "Darken" },
{ SkXfermode::kLighten_Mode, "Lighten" },
{ SkXfermode::kColorDodge_Mode, "ColorDodge" },
{ SkXfermode::kColorBurn_Mode, "ColorBurn" },
{ SkXfermode::kHardLight_Mode, "HardLight" },
{ SkXfermode::kSoftLight_Mode, "SoftLight" },
{ SkXfermode::kDifference_Mode, "Difference" },
{ SkXfermode::kExclusion_Mode, "Exclusion" },*/
};
const SkScalar w = SkIntToScalar(W);
const SkScalar h = SkIntToScalar(H);
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
SkPaint labelP;
labelP.setAntiAlias(true);
labelP.setLCDRenderText(true);
labelP.setTextAlign(SkPaint::kCenter_Align);
setNamedTypeface(&labelP, "Menlo Regular");
const int W = 5;
SkScalar x0 = 0;
for (int twice = 0; twice < 2; twice++) {
SkScalar x = x0, y = 0;
for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
SkXfermode* mode = SkXfermode::Create(gModes[i].fMode);
SkAutoUnref aur(mode);
SkRect r;
r.set(x, y, x+w, y+h);
SkPaint p;
p.setStyle(SkPaint::kFill_Style);
p.setShader(s);
canvas->drawRect(r, p);
canvas->saveLayer(&r, NULL);
draw_mode(canvas, mode, twice ? 0x88 : 0xFF, r.fLeft, r.fTop);
canvas->restore();
r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
p.setStyle(SkPaint::kStroke_Style);
p.setShader(NULL);
canvas->drawRect(r, p);
canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
x + w/2, y - labelP.getTextSize()/2, labelP);
x += w + SkIntToScalar(10);
if ((i % W) == W - 1) {
x = x0;
y += h + SkIntToScalar(30);
}
}
x0 += SkIntToScalar(400);
}
s->unref();
}
void onDraw(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
const SkScalar w = SkIntToScalar(W);
const SkScalar h = SkIntToScalar(H);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode,
&m);
SkPaint labelP;
labelP.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&labelP);
labelP.setTextAlign(SkPaint::kCenter_Align);
const int W = 5;
SkScalar x0 = 0;
SkScalar y0 = 0;
for (int sourceType = 1; sourceType & kAll_SrcType; sourceType <<= 1) {
SkScalar x = x0, y = y0;
for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
if ((gModes[i].fSourceTypeMask & sourceType) == 0) {
continue;
}
SkAutoTUnref<SkXfermode> mode;
if (gModes[i].fSourceTypeMask & kCustomMask) {
mode.reset(make_custom(gModes[i].fSourceTypeMask & kCustomMask));
} else {
mode.reset(SkXfermode::Create(gModes[i].fMode));
}
SkRect r;
r.set(x, y, x+w, y+h);
SkPaint p;
p.setStyle(SkPaint::kFill_Style);
p.setShader(s);
canvas->drawRect(r, p);
canvas->saveLayer(&r, nullptr);
draw_mode(canvas, mode, static_cast<SrcType>(sourceType),
r.fLeft, r.fTop);
canvas->restore();
r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
p.setStyle(SkPaint::kStroke_Style);
p.setShader(nullptr);
canvas->drawRect(r, p);
#if 1
canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
x + w/2, y - labelP.getTextSize()/2, labelP);
#endif
x += w + SkIntToScalar(10);
if ((i % W) == W - 1) {
x = x0;
y += h + SkIntToScalar(30);
}
}
if (y < 320) {
if (x > x0) {
y += h + SkIntToScalar(30);
}
y0 = y;
} else {
x0 += SkIntToScalar(400);
y0 = 0;
}
}
s->unref();
}
void GraphicsContext::drawLineForMisspellingOrBadGrammar(const IntPoint& pt,
int width,
bool grammar)
{
if (paintingDisabled())
return;
// Create the pattern we'll use to draw the underline.
static SkBitmap* misspellBitmap = 0;
if (!misspellBitmap) {
// We use a 2-pixel-high misspelling indicator because that seems to be
// what WebKit is designed for, and how much room there is in a typical
// page for it.
const int rowPixels = 32; // Must be multiple of 4 for pattern below.
const int colPixels = 2;
misspellBitmap = new SkBitmap;
misspellBitmap->setConfig(SkBitmap::kARGB_8888_Config,
rowPixels, colPixels);
misspellBitmap->allocPixels();
misspellBitmap->eraseARGB(0, 0, 0, 0);
const uint32_t lineColor = 0xFFFF0000; // Opaque red.
const uint32_t antiColor = 0x60600000; // Semitransparent red.
// Pattern: X o o X o o X
// o X o o X o
uint32_t* row1 = misspellBitmap->getAddr32(0, 0);
uint32_t* row2 = misspellBitmap->getAddr32(0, 1);
for (int x = 0; x < rowPixels; x++) {
switch (x % 4) {
case 0:
row1[x] = lineColor;
break;
case 1:
row1[x] = antiColor;
row2[x] = antiColor;
break;
case 2:
row2[x] = lineColor;
break;
case 3:
row1[x] = antiColor;
row2[x] = antiColor;
break;
}
}
}
// Offset it vertically by 1 so that there's some space under the text.
SkScalar originX = SkIntToScalar(pt.x());
SkScalar originY = SkIntToScalar(pt.y()) + 1;
// Make a shader for the bitmap with an origin of the box we'll draw. This
// shader is refcounted and will have an initial refcount of 1.
SkShader* shader = SkShader::CreateBitmapShader(
*misspellBitmap, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix matrix;
matrix.reset();
matrix.postTranslate(originX, originY);
shader->setLocalMatrix(matrix);
// Assign the shader to the paint & release our reference. The paint will
// now own the shader and the shader will be destroyed when the paint goes
// out of scope.
SkPaint paint;
paint.setShader(shader);
shader->unref();
SkRect rect;
rect.set(originX,
originY,
originX + SkIntToScalar(width),
originY + SkIntToScalar(misspellBitmap->height()));
platformContext()->canvas()->drawRect(rect, paint);
}
bool RenderThemeChromiumSkia::paintMediaSliderTrack(RenderObject* object, const RenderObject::PaintInfo& paintInfo, const IntRect& rect)
{
#if ENABLE(VIDEO)
HTMLMediaElement* mediaElement = mediaElementParent(object->node());
if (!mediaElement)
return false;
SkCanvas* canvas = paintInfo.context->platformContext()->canvas();
SkRect backgroundRect;
backgroundRect.set(rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
SkPaint paint;
paint.setAntiAlias(true);
// Draw the border of the time bar. The border only has one single color,
// width and radius. So use the property of the left border.
SkColor borderColor = object->style()->borderLeftColor().rgb();
int borderWidth = object->style()->borderLeftWidth();
IntSize borderRadius = object->style()->borderTopLeftRadius();
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(borderWidth);
paint.setColor(borderColor);
canvas->drawRoundRect(backgroundRect, borderRadius.width(), borderRadius.height(), paint);
// Draw the background of the time bar.
SkColor backgroundColor = object->style()->backgroundColor().rgb();
paint.setStyle(SkPaint::kFill_Style);
paint.setColor(backgroundColor);
canvas->drawRoundRect(backgroundRect, borderRadius.width(), borderRadius.height(), paint);
if (backgroundRect.width() >= 3 && backgroundRect.height() >= 3)
{
// Draw the buffered ranges.
// FIXME: Draw multiple ranges if there are multiple buffered ranges.
SkRect bufferedRect;
bufferedRect.set(backgroundRect.fLeft + 2, backgroundRect.fTop + 2,
backgroundRect.fRight - 1, backgroundRect.fBottom - 1);
int width = static_cast<int>(bufferedRect.width() * mediaElement->percentLoaded());
bufferedRect.fRight = bufferedRect.fLeft + width;
SkPoint points[2] = { { 0, bufferedRect.fTop }, { 0, bufferedRect.fBottom } };
SkColor startColor = object->style()->color().rgb();
SkColor endColor = SkColorSetRGB(SkColorGetR(startColor) / 2,
SkColorGetG(startColor) / 2,
SkColorGetB(startColor) / 2);
SkColor colors[2] = { startColor, endColor };
SkShader* gradient = SkGradientShader::CreateLinear(points, colors, 0,
sizeof(points) / sizeof(points[0]),
SkShader::kMirror_TileMode, 0);
paint.reset();
paint.setShader(gradient);
paint.setAntiAlias(true);
// Check for round rect with zero width or height, otherwise Skia will assert
if (bufferedRect.width() > 0 && bufferedRect.height() > 0)
canvas->drawRoundRect(bufferedRect, borderRadius.width(), borderRadius.height(), paint);
gradient->unref();
}
return true;
#else
UNUSED_PARAM(object);
UNUSED_PARAM(paintInfo);
UNUSED_PARAM(rect);
return false;
#endif
}
void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& pt, float width, DocumentMarkerLineStyle style)
{
if (paintingDisabled())
return;
// Create the pattern we'll use to draw the underline.
int index = style == DocumentMarkerGrammarLineStyle ? 1 : 0;
static SkBitmap* misspellBitmap[2] = { 0, 0 };
if (!misspellBitmap[index]) {
#if PLATFORM(CHROMIUM) && OS(DARWIN)
// Match the artwork used by the Mac.
const int rowPixels = 4;
const int colPixels = 3;
#else
// We use a 2-pixel-high misspelling indicator because that seems to be
// what WebKit is designed for, and how much room there is in a typical
// page for it.
const int rowPixels = 32; // Must be multiple of 4 for pattern below.
const int colPixels = 2;
#endif
misspellBitmap[index] = new SkBitmap;
misspellBitmap[index]->setConfig(SkBitmap::kARGB_8888_Config,
rowPixels, colPixels);
misspellBitmap[index]->allocPixels();
misspellBitmap[index]->eraseARGB(0, 0, 0, 0);
#if PLATFORM(CHROMIUM) && OS(DARWIN)
const uint32_t colors[2][6] = {
{ 0x2A2A0600, 0x57571000, 0xA8A81B00, 0xBFBF1F00, 0x70701200, 0xE0E02400 },
{ 0x2A001503, 0x57002A08, 0xA800540D, 0xBF005F0F, 0x70003809, 0xE0007012 }
};
const uint32_t transparentColor = 0x00000000;
// Pattern: a b a a b a
// c d c c d c
// e f e e f e
for (int x = 0; x < colPixels; ++x) {
uint32_t* row = misspellBitmap[index]->getAddr32(0, x);
row[0] = colors[index][x * 2];
row[1] = colors[index][x * 2 + 1];
row[2] = colors[index][x * 2];
row[3] = transparentColor;
}
#else
static const uint32_t lineColors[2] = {
0xFF << SK_A32_SHIFT | 0xFF << SK_R32_SHIFT, // Opaque red.
0xFF << SK_A32_SHIFT | 0xC0 << SK_R32_SHIFT | 0xC0 << SK_G32_SHIFT | 0xC0 << SK_B32_SHIFT, // Opaque gray.
};
static const uint32_t antiColors[2] = {
0x60 << SK_A32_SHIFT | 0x60 << SK_R32_SHIFT, // Semitransparent red
0xFF << SK_A32_SHIFT | 0xC0 << SK_R32_SHIFT | 0xC0 << SK_G32_SHIFT | 0xC0 << SK_B32_SHIFT, // Semitransparent gray
};
const uint32_t lineColor = lineColors[index];
const uint32_t antiColor = antiColors[index];
// Pattern: X o o X o o X
// o X o o X o
uint32_t* row1 = misspellBitmap[index]->getAddr32(0, 0);
uint32_t* row2 = misspellBitmap[index]->getAddr32(0, 1);
for (int x = 0; x < rowPixels; x++) {
switch (x % 4) {
case 0:
row1[x] = lineColor;
break;
case 1:
row1[x] = antiColor;
row2[x] = antiColor;
break;
case 2:
row2[x] = lineColor;
break;
case 3:
row1[x] = antiColor;
row2[x] = antiColor;
break;
}
}
#endif
}
SkScalar originX = WebCoreFloatToSkScalar(pt.x());
#if PLATFORM(CHROMIUM) && OS(DARWIN)
SkScalar originY = WebCoreFloatToSkScalar(pt.y());
// Make sure to draw only complete dots.
int rowPixels = misspellBitmap[index]->width();
float widthMod = fmodf(width, rowPixels);
if (rowPixels - widthMod > 1)
width -= widthMod;
#else
// Offset it vertically by 1 so that there's some space under the text.
SkScalar originY = WebCoreFloatToSkScalar(pt.y()) + 1;
#endif
// Make a shader for the bitmap with an origin of the box we'll draw. This
// shader is refcounted and will have an initial refcount of 1.
SkShader* shader = SkShader::CreateBitmapShader(
*misspellBitmap[index], SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix matrix;
matrix.reset();
matrix.postTranslate(originX, originY);
shader->setLocalMatrix(matrix);
// Assign the shader to the paint & release our reference. The paint will
// now own the shader and the shader will be destroyed when the paint goes
// out of scope.
SkPaint paint;
paint.setShader(shader);
shader->unref();
SkRect rect;
rect.set(originX,
originY,
originX + WebCoreFloatToSkScalar(width),
originY + SkIntToScalar(misspellBitmap[index]->height()));
platformContext()->canvas()->drawRect(rect, paint);
platformContext()->didDrawRect(rect, paint);
}
virtual ~AvoidView() {
fShader->unref();
}
virtual ~GradientBench() {
fShader->unref();
}
virtual void onDrawContent(SkCanvas* canvas) {
canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
SkPaint bluePaint;
bluePaint.setARGB(0xff, 0x0, 0x0, 0xff);
SkPaint bmpPaint;
SkShader* bmpShader = SkShader::CreateBitmapShader(fBitmap, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
bmpPaint.setShader(bmpShader);
bmpShader->unref();
bluePaint.setStrokeWidth(3);
bmpPaint.setStrokeWidth(3);
SkPaint paints[] = { bluePaint, bmpPaint };
SkRect rect;
SkScalar dx = SkIntToScalar(80);
SkScalar dy = SkIntToScalar(100);
SkMatrix matrix;
for (size_t p = 0; p < SK_ARRAY_COUNT(paints); ++p) {
for (int stroke = 0; stroke < 2; ++stroke) {
paints[p].setStyle(stroke ? SkPaint::kStroke_Style : SkPaint::kFill_Style);
for (int a = 0; a < 3; ++ a) {
paints[p].setAntiAlias(a > 0);
paints[p].setAlpha(a > 1 ? 0x80 : 0xff);
canvas->save();
rect = SkRect::MakeLTRB(SkFloatToScalar(0.f),
SkFloatToScalar(0.f),
SkFloatToScalar(40.f),
SkFloatToScalar(40.f));
canvas->drawRect(rect, paints[p]);
canvas->translate(dx, 0);
rect = SkRect::MakeLTRB(SkFloatToScalar(0.5f),
SkFloatToScalar(0.5f),
SkFloatToScalar(40.5f),
SkFloatToScalar(40.5f));
canvas->drawRect(rect, paints[p]);
canvas->translate(dx, 0);
rect = SkRect::MakeLTRB(SkFloatToScalar(0.5f),
SkFloatToScalar(0.5f),
SkFloatToScalar(40.f),
SkFloatToScalar(40.f));
canvas->drawRect(rect, paints[p]);
canvas->translate(dx, 0);
rect = SkRect::MakeLTRB(SkFloatToScalar(0.75f),
SkFloatToScalar(0.75f),
SkFloatToScalar(40.75f),
SkFloatToScalar(40.75f));
canvas->drawRect(rect, paints[p]);
canvas->translate(dx, 0);
canvas->save();
canvas->translate(SkFloatToScalar(.33f), SkFloatToScalar(.67f));
rect = SkRect::MakeLTRB(SkFloatToScalar(0.0f),
SkFloatToScalar(0.0f),
SkFloatToScalar(40.0f),
SkFloatToScalar(40.0f));
canvas->drawRect(rect, paints[p]);
canvas->restore();
canvas->translate(dx, 0);
canvas->save();
matrix.setRotate(SkFloatToScalar(45.f));
canvas->concat(matrix);
canvas->translate(SkFloatToScalar(20.0f / sqrtf(2.f)),
SkFloatToScalar(20.0f / sqrtf(2.f)));
rect = SkRect::MakeLTRB(SkFloatToScalar(-20.0f),
SkFloatToScalar(-20.0f),
SkFloatToScalar(20.0f),
SkFloatToScalar(20.0f));
canvas->drawRect(rect, paints[p]);
canvas->restore();
canvas->translate(dx, 0);
canvas->save();
canvas->rotate(SkFloatToScalar(90.f));
rect = SkRect::MakeLTRB(SkFloatToScalar(0.0f),
SkFloatToScalar(0.0f),
SkFloatToScalar(40.0f),
SkFloatToScalar(-40.0f));
canvas->drawRect(rect, paints[p]);
canvas->restore();
canvas->translate(dx, 0);
canvas->save();
canvas->rotate(SkFloatToScalar(90.f));
rect = SkRect::MakeLTRB(SkFloatToScalar(0.5f),
SkFloatToScalar(0.5f),
SkFloatToScalar(40.5f),
SkFloatToScalar(-40.5f));
canvas->drawRect(rect, paints[p]);
canvas->restore();
canvas->translate(dx, 0);
canvas->save();
matrix.setScale(SkFloatToScalar(-1.f), SkFloatToScalar(-1.f));
canvas->concat(matrix);
rect = SkRect::MakeLTRB(SkFloatToScalar(0.5f),
SkFloatToScalar(0.5f),
SkFloatToScalar(-40.5f),
SkFloatToScalar(-40.5f));
canvas->drawRect(rect, paints[p]);
canvas->restore();
canvas->translate(dx, 0);
canvas->save();
matrix.setScale(SkFloatToScalar(2.1f), SkFloatToScalar(4.1f));
canvas->concat(matrix);
rect = SkRect::MakeLTRB(SkFloatToScalar(0.1f),
SkFloatToScalar(0.1f),
SkFloatToScalar(19.1f),
SkFloatToScalar(9.1f));
canvas->drawRect(rect, paints[p]);
canvas->restore();
canvas->translate(dx, 0);
canvas->restore();
canvas->translate(0, dy);
}
}
}
}
