void setupShapePaint(SkCanvas* canvas, GrColor color, SkXfermode::Mode mode, SkPaint* paint) {
paint->setColor(color);
if (mode == SkXfermode::kPlus_Mode) {
// Check for overflow, otherwise we might get confusing AA artifacts.
int maxSum = SkTMax(SkTMax(SkColorGetA(kBGColor) + SkColorGetA(color),
SkColorGetR(kBGColor) + SkColorGetR(color)),
SkTMax(SkColorGetG(kBGColor) + SkColorGetG(color),
SkColorGetB(kBGColor) + SkColorGetB(color)));
if (maxSum > 255) {
SkPaint dimPaint;
dimPaint.setAntiAlias(false);
dimPaint.setXfermode(SkXfermode::Create(SkXfermode::kDstIn_Mode));
if (255 != paint->getAlpha()) {
// Dim the src and dst colors.
dimPaint.setARGB(255 * 255 / maxSum, 0, 0, 0);
paint->setAlpha(255 * paint->getAlpha() / maxSum);
} else {
// Just clear the dst, we need to preserve the paint's opacity.
dimPaint.setARGB(0, 0, 0, 0);
}
canvas->drawRectCoords(-kShapeSpacing/2, -kShapeSpacing/2,
kShapeSpacing/2 + 3 * kShapeTypeSpacing,
kShapeSpacing/2, dimPaint);
}
}
}
void BaseRenderer::renderTiledContent(TileRenderInfo& renderInfo)
{
const bool visualIndicator = TilesManager::instance()->getShowVisualIndicator();
const SkSize& tileSize = renderInfo.tileSize;
SkCanvas canvas;
setupCanvas(renderInfo, &canvas);
if (!canvas.getDevice()) {
// TODO: consider ALOGE
ALOGV("Error: No Device");
return;
}
double before;
if (visualIndicator) {
canvas.save();
before = currentTimeMS();
}
canvas.translate(-renderInfo.x * tileSize.width(), -renderInfo.y * tileSize.height());
canvas.scale(renderInfo.scale, renderInfo.scale);
if (renderInfo.tilePainter == NULL) {
ALOGV("Error: No tilePainter");
return;
}
renderInfo.tilePainter->paint(&canvas);
if (renderInfo.baseTile && renderInfo.baseTile->backTexture())
checkForPureColor(renderInfo, &canvas);
else
renderInfo.isPureColor = false;
if (visualIndicator) {
double after = currentTimeMS();
canvas.restore();
unsigned int updateCount = renderInfo.tilePainter->getUpdateCount() & UPDATE_COUNT_MASK;
const int color = updateCount & UPDATE_COUNT_ALPHA_MASK;
// only color the invalidated area
SkPaint paint;
paint.setARGB(color, 0, 255, 0);
SkIRect rect;
rect.set(0, 0, tileSize.width(), tileSize.height());
canvas.drawIRect(rect, paint);
drawTileInfo(&canvas, renderInfo, updateCount, after - before);
// paint the tile boundaries
paint.setARGB(64, 255, 0, 0);
paint.setStrokeWidth(3);
canvas.drawLine(0, 0, tileSize.width(), tileSize.height(), paint);
paint.setARGB(64, 0, 255, 0);
canvas.drawLine(0, tileSize.height(), tileSize.width(), 0, paint);
paint.setARGB(128, 0, 0, 255);
canvas.drawLine(tileSize.width(), 0, tileSize.width(), tileSize.height(), paint);
}
renderingComplete(renderInfo, &canvas);
}
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 writeFrames() {
const int scale = 5;
for (int index = 0; index < (int) SK_ARRAY_COUNT(frameSizes); ++index) {
SkDRect bounds;
bool boundsSet = false;
int frameSize = frameSizes[index];
for (int fIndex = 0; fIndex < frameSize; ++fIndex) {
const SkDConic& dC = frames[index][fIndex];
SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
{dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
{dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
SkDRect dBounds;
dBounds.setBounds(dConic);
if (!boundsSet) {
bounds = dBounds;
boundsSet = true;
} else {
bounds.add((SkDPoint&) dBounds.fLeft);
bounds.add((SkDPoint&) dBounds.fRight);
}
}
bounds.fLeft -= 10;
bounds.fTop -= 10;
bounds.fRight += 10;
bounds.fBottom += 10;
SkBitmap bitmap;
bitmap.tryAllocPixels(SkImageInfo::MakeN32Premul(
SkScalarRoundToInt(SkDoubleToScalar(bounds.width())),
SkScalarRoundToInt(SkDoubleToScalar(bounds.height()))));
SkCanvas canvas(bitmap);
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
canvas.translate(SkDoubleToScalar(-bounds.fLeft), SkDoubleToScalar(-bounds.fTop));
canvas.drawColor(SK_ColorWHITE);
for (int fIndex = 0; fIndex < frameSize; ++fIndex) {
const SkDConic& dC = frames[index][fIndex];
SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
{dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
{dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
SkPath path;
path.moveTo(dConic.fPts[0].asSkPoint());
path.conicTo(dConic.fPts[1].asSkPoint(), dConic.fPts[2].asSkPoint(), dConic.fWeight);
if (fIndex < 2) {
paint.setARGB(0x80, 0xFF, 0, 0);
} else {
paint.setARGB(0x80, 0, 0, 0xFF);
}
canvas.drawPath(path, paint);
}
SkString filename("c:\\Users\\caryclark\\Documents\\");
filename.appendf("f%d.png", index);
SkImageEncoder::EncodeFile(filename.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
}
}
void LayerAndroid::contentDraw(SkCanvas* canvas, PaintStyle style)
{
if (m_maskLayer && m_maskLayer->m_content) {
// TODO: we should use a shader instead of doing
// the masking in software
if (m_originalLayer)
m_originalLayer->m_content->draw(canvas);
else if (m_content)
m_content->draw(canvas);
SkPaint maskPaint;
maskPaint.setXfermodeMode(SkXfermode::kDstIn_Mode);
int count = canvas->saveLayer(0, &maskPaint, SkCanvas::kHasAlphaLayer_SaveFlag);
m_maskLayer->m_content->draw(canvas);
canvas->restoreToCount(count);
} else if (m_content)
m_content->draw(canvas);
if (TilesManager::instance()->getShowVisualIndicator()) {
float w = getSize().width();
float h = getSize().height();
SkPaint paint;
if (style == MergedLayers)
paint.setARGB(255, 255, 255, 0);
else if (style == UnmergedLayers)
paint.setARGB(255, 255, 0, 0);
else if (style == FlattenedLayers)
paint.setARGB(255, 255, 0, 255);
canvas->drawLine(0, 0, w, h, paint);
canvas->drawLine(0, h, w, 0, paint);
canvas->drawLine(0, 0, 0, h-1, paint);
canvas->drawLine(0, h-1, w-1, h-1, paint);
canvas->drawLine(w-1, h-1, w-1, 0, paint);
canvas->drawLine(w-1, 0, 0, 0, paint);
static SkTypeface* s_typeface = 0;
if (!s_typeface)
s_typeface = SkTypeface::CreateFromName("", SkTypeface::kBold);
paint.setARGB(255, 0, 0, 255);
paint.setTextSize(17);
char str[256];
snprintf(str, 256, "%d", uniqueId());
paint.setTypeface(s_typeface);
canvas->drawText(str, strlen(str), 2, h - 2, paint);
}
if (m_fixedPosition)
return m_fixedPosition->contentDraw(canvas, style);
}
void onDraw(SkCanvas* canvas) override {
const SkAlpha kAlphaValue[] = { 0xFF, 0x40 };
const SkScalar margin = 15;
canvas->translate(margin, margin);
SkPaint paint;
for (int p = 0; p < fPaths.count(); ++p) {
canvas->save();
for (size_t a = 0; a < SK_ARRAY_COUNT(kAlphaValue); ++a) {
paint.setARGB(kAlphaValue[a], 0, 0, 0);
for (int aa = 0; aa < 2; ++aa) {
paint.setAntiAlias(SkToBool(aa));
for (int fh = 0; fh < 2; ++fh) {
paint.setStyle(fh ? SkPaint::kStroke_Style : SkPaint::kFill_Style);
const SkRect& bounds = fPaths[p].getBounds();
canvas->save();
canvas->translate(-bounds.fLeft, -bounds.fTop);
canvas->drawPath(fPaths[p], paint);
canvas->restore();
canvas->translate(110, 0);
}
}
}
canvas->restore();
canvas->translate(0, 110);
}
canvas->restore();
this->drawGiantCircle(canvas);
}
SkBitmap
skiaCreateSampleImage(caskbench_context_t *ctx)
{
int i, x, y;
SkBitmap bitmap;
bitmap.setConfig(SkBitmap::kARGB_8888_Config, 160, 40);
SkImageInfo info = SkImageInfo::Make(160, 40,
kBGRA_8888_SkColorType,
kPremul_SkAlphaType);
bitmap.allocPixels(info);
SkBitmapDevice device(bitmap);
SkCanvas canvas(&device);
SkPaint paint;
SkRect r;
canvas.clear(0);
x = 5;
for (i=0; i<16; i++) {
paint.setARGB(255, 255/(i+1), 255, 16*i);
x += 10;
y = (i%2)*10;
r.set(x, y, x+10, y+10);
canvas.drawRect(r, paint);
}
canvas.flush();
return bitmap;
}
void render() {
#if USE_SKIA_OPENGL
bbutil_clear();
#endif
/************************** BEGIN USER RENDER CODE ***************************/
// Clear the entire canvas to a solid colour
SkPaint clearColor;
clearColor.setARGB(255,0xdd,0xdd,0xdd);
SkRect fullScreen;
fullScreen.set(0,0,width,height);
canvas->drawRect(fullScreen, clearColor);
// Draw the current demo
if (demos[currentIndex])
demos[currentIndex]->onDraw();
/**************************** END USER RENDER CODE ***************************/
// Draw the contents of the canvas to the screen
#if USE_SKIA_OPENGL
device->flush();
bbutil_swap(0);
#else
bbutil_swap(currentSurface);
currentSurface = 1 - currentSurface;
canvas->setBitmapDevice(drawingSurface[currentSurface]);
#endif
}
virtual void onDrawContent(SkCanvas* canvas) {
const char* str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
SkPaint paint;
SkScalar x = SkIntToScalar(10);
SkScalar y = SkIntToScalar(20);
paint.setFlags(0x105);
paint.setARGB(fByte, 0xFF, 0xFF, 0xFF);
paint.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3),
SkBlurMaskFilter::kNormal_BlurStyle));
paint.getMaskFilter()->unref();
SkRandom rand;
for (int ps = 6; ps <= 35; ps++) {
paint.setColor(rand.nextU() | (0xFF << 24));
paint.setTextSize(SkIntToScalar(ps));
paint.setTextSize(SkIntToScalar(24));
canvas->drawText(str, strlen(str), x, y, paint);
y += paint.getFontMetrics(NULL);
}
if (false) { // avoid bit rot, suppress warning
check_for_nonwhite(canvas->getDevice()->accessBitmap(false), fByte);
SkDebugf("------ byte %x\n", fByte);
}
if (false) {
fByte += 1;
fByte &= 0xFF;
this->inval(NULL);
}
}
void LayerAndroid::onDraw(SkCanvas* canvas, SkScalar opacity) {
if (m_haveClip) {
SkRect r;
r.set(0, 0, getSize().width(), getSize().height());
canvas->clipRect(r);
}
if (!prepareContext())
return;
// we just have this save/restore for opacity...
SkAutoCanvasRestore restore(canvas, true);
int canvasOpacity = SkScalarRound(opacity * 255);
if (canvasOpacity < 255)
canvas->setDrawFilter(new OpacityDrawFilter(canvasOpacity));
canvas->drawPicture(*m_recordingPicture);
#if ENABLE(WEBGL)
if (m_context.get()) {
m_context->paint(canvas);
}
#endif
if (m_extra)
m_extra->draw(canvas, this);
#ifdef LAYER_DEBUG
float w = getSize().width();
float h = getSize().height();
SkPaint paint;
paint.setARGB(128, 255, 0, 0);
canvas->drawLine(0, 0, w, h, paint);
canvas->drawLine(0, h, w, 0, paint);
paint.setARGB(128, 0, 255, 0);
canvas->drawLine(0, 0, 0, h, paint);
canvas->drawLine(0, h, w, h, paint);
canvas->drawLine(w, h, w, 0, paint);
canvas->drawLine(w, 0, 0, 0, paint);
if (m_isFixed) {
SkRect layerRect = computeLayerRect(this);
SkPaint paint;
paint.setARGB(128, 0, 0, 255);
canvas->drawRect(layerRect, paint);
}
#endif
}
void BaseRenderer::drawTileInfo(SkCanvas* canvas,
const TileRenderInfo& renderInfo, int updateCount, double renderDuration)
{
static SkTypeface* s_typeface = 0;
if (!s_typeface)
s_typeface = SkTypeface::CreateFromName("", SkTypeface::kBold);
SkPaint paint;
paint.setTextSize(17);
char str[256];
snprintf(str, 256, " (%d,%d) %.2fx %d %.1fms", renderInfo.x, renderInfo.y,
renderInfo.scale, updateCount, renderDuration);
paint.setARGB(128, 255, 255, 255);
canvas->drawRectCoords(0, 0, renderInfo.tileSize.fWidth, 17, paint);
paint.setARGB(255, 255, 0, 0);
paint.setTypeface(s_typeface);
canvas->drawText(str, strlen(str), 20, 15, paint);
}
void FixedPositioning::contentDraw(SkCanvas* canvas, Layer::PaintStyle style)
{
if (TilesManager::instance()->getShowVisualIndicator()) {
SkPaint paint;
paint.setARGB(80, 255, 0, 0);
canvas->drawRect(m_fixedRect, paint);
}
}
static void draw_scene(SkCanvas* canvas, const SkHighContrastConfig& config) {
SkRect bounds = SkRect::MakeLTRB(0.0f, 0.0f, 1.0f, 1.0f);
SkPaint xferPaint;
xferPaint.setColorFilter(SkHighContrastFilter::Make(config));
canvas->saveLayer(&bounds, &xferPaint);
SkPaint paint;
bounds = SkRect::MakeLTRB(0.1f, 0.2f, 0.9f, 0.4f);
paint.setARGB(0xff, 0x66, 0x11, 0x11);
canvas->drawRect(bounds, paint);
SkFont font;
font.setSize(0.15f);
font.setEdging(SkFont::Edging::kAlias);
paint.setARGB(0xff, 0xbb, 0x77, 0x77);
canvas->drawString("A", 0.15f, 0.35f, font, paint);
bounds = SkRect::MakeLTRB(0.1f, 0.8f, 0.9f, 1.0f);
paint.setARGB(0xff, 0xcc, 0xcc, 0xff);
canvas->drawRect(bounds, paint);
paint.setARGB(0xff, 0x88, 0x88, 0xbb);
canvas->drawString("Z", 0.75f, 0.95f, font, paint);
bounds = SkRect::MakeLTRB(0.1f, 0.4f, 0.9f, 0.6f);
SkPoint pts[] = { { 0, 0 }, { 1, 0 } };
SkColor colors[] = { SK_ColorWHITE, SK_ColorBLACK };
SkScalar pos[] = { 0.2f, 0.8f };
paint.setShader(SkGradientShader::MakeLinear(
pts, colors, pos,
SK_ARRAY_COUNT(colors), SkTileMode::kClamp));
canvas->drawRect(bounds, paint);
bounds = SkRect::MakeLTRB(0.1f, 0.6f, 0.9f, 0.8f);
SkColor colors2[] = { SK_ColorGREEN, SK_ColorWHITE };
paint.setShader(SkGradientShader::MakeLinear(
pts, colors2, pos,
SK_ARRAY_COUNT(colors2), SkTileMode::kClamp));
canvas->drawRect(bounds, paint);
canvas->restore();
}
static void writePng(const SkConic& c, const SkConic ch[2], const char* name) {
const int scale = 10;
SkConic conic, chopped[2];
for (int index = 0; index < 3; ++index) {
conic.fPts[index].fX = c.fPts[index].fX * scale;
conic.fPts[index].fY = c.fPts[index].fY * scale;
for (int chIndex = 0; chIndex < 2; ++chIndex) {
chopped[chIndex].fPts[index].fX = ch[chIndex].fPts[index].fX * scale;
chopped[chIndex].fPts[index].fY = ch[chIndex].fPts[index].fY * scale;
}
}
conic.fW = c.fW;
chopped[0].fW = ch[0].fW;
chopped[1].fW = ch[1].fW;
SkBitmap bitmap;
SkRect bounds;
conic.computeTightBounds(&bounds);
bounds.outset(10, 10);
bitmap.tryAllocPixels(SkImageInfo::MakeN32Premul(
SkScalarRoundToInt(bounds.width()), SkScalarRoundToInt(bounds.height())));
SkCanvas canvas(bitmap);
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
canvas.translate(-bounds.fLeft, -bounds.fTop);
canvas.drawColor(SK_ColorWHITE);
SkPath path;
path.moveTo(conic.fPts[0]);
path.conicTo(conic.fPts[1], conic.fPts[2], conic.fW);
paint.setARGB(0x80, 0xFF, 0, 0);
canvas.drawPath(path, paint);
path.reset();
path.moveTo(chopped[0].fPts[0]);
path.conicTo(chopped[0].fPts[1], chopped[0].fPts[2], chopped[0].fW);
path.moveTo(chopped[1].fPts[0]);
path.conicTo(chopped[1].fPts[1], chopped[1].fPts[2], chopped[1].fW);
paint.setARGB(0x80, 0, 0, 0xFF);
canvas.drawPath(path, paint);
SkString filename("c:\\Users\\caryclark\\Documents\\");
filename.appendf("%s.png", name);
SkImageEncoder::EncodeFile(filename.c_str(), bitmap,
SkImageEncoder::kPNG_Type, 100);
}
static void writeDPng(const SkDConic& dC, const char* name) {
const int scale = 5;
SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
{dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
{dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
SkBitmap bitmap;
SkDRect bounds;
bounds.setBounds(dConic);
bounds.fLeft -= 10;
bounds.fTop -= 10;
bounds.fRight += 10;
bounds.fBottom += 10;
bitmap.tryAllocPixels(SkImageInfo::MakeN32Premul(
SkScalarRoundToInt(SkDoubleToScalar(bounds.width())),
SkScalarRoundToInt(SkDoubleToScalar(bounds.height()))));
SkCanvas canvas(bitmap);
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
canvas.translate(SkDoubleToScalar(-bounds.fLeft), SkDoubleToScalar(-bounds.fTop));
canvas.drawColor(SK_ColorWHITE);
SkPath path;
path.moveTo(dConic.fPts[0].asSkPoint());
path.conicTo(dConic.fPts[1].asSkPoint(), dConic.fPts[2].asSkPoint(), dConic.fWeight);
paint.setARGB(0x80, 0xFF, 0, 0);
canvas.drawPath(path, paint);
path.reset();
const int chops = 2;
for (int tIndex = 0; tIndex < chops; ++tIndex) {
SkDConic chopped = dConic.subDivide(tIndex / (double) chops,
(tIndex + 1) / (double) chops);
path.moveTo(chopped.fPts[0].asSkPoint());
path.conicTo(chopped.fPts[1].asSkPoint(), chopped.fPts[2].asSkPoint(), chopped.fWeight);
}
paint.setARGB(0x80, 0, 0, 0xFF);
canvas.drawPath(path, paint);
SkString filename("c:\\Users\\caryclark\\Documents\\");
filename.appendf("%s.png", name);
SkImageEncoder::EncodeFile(filename.c_str(), bitmap,
SkImageEncoder::kPNG_Type, 100);
}
void onDraw(SkCanvas* canvas) override {
canvas->save();
canvas->scale(1, -1);
canvas->translate(0, -kHeight);
for (int p = 0; p < fPaths.count(); ++p) {
SkPaint paint;
paint.setARGB(0xff, 0, 0, 0);
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(0);
canvas->drawPath(fPaths[p], paint);
}
canvas->restore();
}
void onDraw(SkCanvas* canvas) override {
static const SkAlpha kAlphaValue[] = { 0xFF, 0x40 };
static const SkScalar kWidths[] = { 0, 0.5f, 1.5f };
enum {
kMargin = 5,
};
int wrapX = canvas->getDeviceSize().fWidth - kMargin;
SkScalar maxH = 0;
canvas->translate(SkIntToScalar(kMargin), SkIntToScalar(kMargin));
canvas->save();
SkScalar x = SkIntToScalar(kMargin);
for (int p = 0; p < fPaths.count(); ++p) {
for (size_t a = 0; a < SK_ARRAY_COUNT(kAlphaValue); ++a) {
for (int aa = 0; aa < 2; ++aa) {
for (size_t w = 0; w < SK_ARRAY_COUNT(kWidths); w++) {
const SkRect& bounds = fPaths[p].getBounds();
if (x + bounds.width() > wrapX) {
canvas->restore();
canvas->translate(0, maxH + SkIntToScalar(kMargin));
canvas->save();
maxH = 0;
x = SkIntToScalar(kMargin);
}
SkPaint paint;
paint.setARGB(kAlphaValue[a], 0, 0, 0);
paint.setAntiAlias(SkToBool(aa));
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(kWidths[w]);
canvas->save();
canvas->translate(-bounds.fLeft, -bounds.fTop);
canvas->drawPath(fPaths[p], paint);
canvas->restore();
maxH = SkMaxScalar(maxH, bounds.height());
SkScalar dx = bounds.width() + SkIntToScalar(kMargin);
x += dx;
canvas->translate(dx, 0);
}
}
}
}
canvas->restore();
}
void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
canvas->translate(0, 50);
paint.setColor(SK_ColorBLUE);
paint.setPathEffect(make_pe(2, fPhase));
canvas->drawPath(fPath, paint);
canvas->translate(0, 50);
paint.setARGB(0xFF, 0, 0xBB, 0);
paint.setPathEffect(make_pe(3, fPhase));
canvas->drawPath(fPath, paint);
canvas->translate(0, 50);
paint.setARGB(0xFF, 0, 0, 0);
paint.setPathEffect(make_warp_pe(fPhase));
TestRastBuilder testRastBuilder;
paint.setRasterizer(testRastBuilder.detach());
canvas->drawPath(fPath, paint);
}
bool RenderThemeChromiumSkia::paintMenuList(RenderObject* o, const RenderObject::PaintInfo& i, const IntRect& rect)
{
SkCanvas* const canvas = i.context->platformContext()->canvas();
const int right = rect.x() + rect.width();
const int middle = rect.y() + rect.height() / 2;
paintButtonLike(this, o, i, rect);
SkPaint paint;
paint.setARGB(0xff, 0, 0, 0);
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kFill_Style);
SkPath path;
path.moveTo(right - 13, middle - 3);
path.rLineTo(6, 0);
path.rLineTo(-3, 6);
path.close();
canvas->drawPath(path, paint);
return false;
}
void onDrawContent(SkCanvas* canvas) override {
const char* str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
SkPaint paint;
SkScalar x = SkIntToScalar(10);
SkScalar y = SkIntToScalar(20);
paint.setFlags(0x105);
paint.setARGB(fByte, 0xFF, 0xFF, 0xFF);
paint.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3))));
paint.getMaskFilter()->unref();
SkRandom rand;
for (int ps = 6; ps <= 35; ps++) {
paint.setColor(rand.nextU() | (0xFF << 24));
paint.setTextSize(SkIntToScalar(ps));
paint.setTextSize(SkIntToScalar(24));
canvas->drawText(str, strlen(str), x, y, paint);
y += paint.getFontMetrics(nullptr);
}
}
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);
}
}
}
}
virtual void onDraw(SkCanvas* canvas)
{
this->drawBG(canvas);
if (true)
{
canvas->drawColor(SK_ColorWHITE);
SkPixelXorXfermode mode(SK_ColorWHITE);
SkPaint paint;
paint.setColor(SK_ColorRED);
paint.setXfermode(&mode);
paint.setStrokeWidth(SkIntToScalar(8));
canvas->drawLine(SkIntToScalar(100), SkIntToScalar(100),
SkIntToScalar(200), SkIntToScalar(200), paint);
canvas->drawLine(SkIntToScalar(100), SkIntToScalar(200),
SkIntToScalar(200), SkIntToScalar(100), paint);
// return;
}
gPhase -= SK_Scalar1;
this->inval(NULL);
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SkIntToScalar(5));
canvas->drawPath(fPath, paint);
paint.setStrokeWidth(0);
paint.setColor(SK_ColorWHITE);
paint.setPathEffect(make_pe(1))->unref();
canvas->drawPath(fPath, paint);
canvas->translate(0, SkIntToScalar(50));
paint.setColor(SK_ColorBLUE);
paint.setPathEffect(make_pe(2))->unref();
canvas->drawPath(fPath, paint);
canvas->translate(0, SkIntToScalar(50));
paint.setARGB(0xFF, 0, 0xBB, 0);
paint.setPathEffect(make_pe(3))->unref();
canvas->drawPath(fPath, paint);
canvas->translate(0, SkIntToScalar(50));
paint.setARGB(0xFF, 0, 0, 0);
paint.setPathEffect(make_warp_pe())->unref();
paint.setRasterizer(new testrast)->unref();
canvas->drawPath(fPath, paint);
{
SkRect oval;
oval.set(SkIntToScalar(50), SkIntToScalar(100),
SkIntToScalar(150), SkIntToScalar(150));
canvas->drawRoundRect(oval, SkIntToScalar(8), SkIntToScalar(8), paint);
}
{
SkRect bounds;
SkPaint paint;
paint.setAntiAlias(true);
paint.setAlpha(0x80);
paint.setColorFilter(
SkColorFilter::CreateModeFilter(
SkColorSetARGB(0x44, 0, 0xFF, 0), SkXfermode::kSrcATop_Mode))->unref();
bounds.set(SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(150), SkIntToScalar(70));
canvas->saveLayer(&bounds, &paint,
(SkCanvas::SaveFlags)(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag));
paint.setColorFilter(NULL);
paint.setColor(SK_ColorRED);
canvas->drawOval(bounds, paint);
paint.setColor(SK_ColorBLUE);
paint.setAlpha(0x80);
bounds.inset(SkIntToScalar(10), SkIntToScalar(10));
canvas->drawOval(bounds, paint);
canvas->restore();
}
}