static inline void getSkiaBoundsForGlyph(SkPaint& paint, Glyph glyph, SkRect& bounds) { paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); SkPath path; paint.getTextPath(&glyph, sizeof(glyph), 0, 0, &path); bounds = path.getBounds(); if (!paint.isSubpixelText()) { SkIRect ir; bounds.round(&ir); bounds.set(ir); } }
void onDraw(SkCanvas* canvas) override { createShader(); createMaskFilter(); canvas->save(); // draw a letter "M" with a green & red striped texture and a // stipple mask with a round rect soft clip SkPaint paint; paint.setAntiAlias(true); paint.setTextSize(72); paint.setShader(fShader.get()); paint.setMaskFilter(fMaskFilter.get()); sk_tool_utils::set_portable_typeface(&paint); SkRect temp; temp.set(SkIntToScalar(115), SkIntToScalar(75), SkIntToScalar(144), SkIntToScalar(110)); SkPath path; path.addRoundRect(temp, SkIntToScalar(5), SkIntToScalar(5)); canvas->clipPath(path, SkRegion::kReplace_Op, true); // AA is on canvas->drawText("M", 1, SkIntToScalar(100), SkIntToScalar(100), paint); canvas->restore(); // Now draw stroked versions of the "M" and the round rect so we can // see what is going on SkPaint paint2; paint2.setColor(SK_ColorBLACK); paint2.setAntiAlias(true); paint2.setTextSize(72); paint2.setStyle(SkPaint::kStroke_Style); paint2.setStrokeWidth(1); sk_tool_utils::set_portable_typeface(&paint2); canvas->drawText("M", 1, SkIntToScalar(100), SkIntToScalar(100), paint2); paint2.setColor(sk_tool_utils::color_to_565(SK_ColorGRAY)); canvas->drawPath(path, paint2); }
virtual void onDraw(SkCanvas* canvas) { this->drawBG(canvas); SkPaint paint; // test handling of obscene cubic values (currently broken) if (false) { SkPoint pts[4]; pts[0].set(1.61061274e+09, 6291456); pts[1].set(-7.18397061e+15, -1.53091184e+13); pts[2].set(-1.30077315e+16, -2.77196141e+13); pts[3].set(-1.30077315e+16, -2.77196162e+13); SkPath path; path.moveTo(pts[0]); path.cubicTo(pts[1], pts[2], pts[3]); canvas->drawPath(path, paint); } canvas->translate(200, 20); canvas->rotate(30); paint.setAntiAlias(true); paint.setTypeface(SkTypeface::CreateFromName("Times Roman", SkTypeface::kNormal))->safeUnref(); // const char* text = "abcdefghijklmnopqrstuvwxyz"; const char* text = "HnHnHnHnHnHnHnHnH"; size_t textLen = strlen(text); SkScalar x = SkIntToScalar(10); SkScalar y = SkIntToScalar(20); { SkPaint p; p.setColor(SK_ColorRED); SkRect r; r.set(0, 0, x, y*20); canvas->drawRect(r, p); } int index = 0; for (int ps = 9; ps <= 24; ps++) { textLen = strlen(text); paint.setTextSize(SkIntToScalar(ps)); canvas->drawText(text, textLen, x, y, paint); y += paint.getFontMetrics(NULL); index += 1; } }
void Path::addArc(const FloatPoint& p, float r, float sa, float ea, bool clockwise) { SkScalar cx = SkFloatToScalar(p.x()); SkScalar cy = SkFloatToScalar(p.y()); SkScalar radius = SkFloatToScalar(r); SkRect oval; oval.set(cx - radius, cy - radius, cx + radius, cy + radius); float sweep = ea - sa; bool prependOval = false; /* Note if clockwise and the sign of the sweep disagree. This particular logic was deduced from http://canvex.lazyilluminati.com/misc/arc.html */ if (clockwise && (sweep > 0 || sweep < -g2PI)) { sweep = fmodf(sweep, g2PI) - g2PI; } else if (!clockwise && (sweep < 0 || sweep > g2PI)) { sweep = fmodf(sweep, g2PI) + g2PI; } // If the abs(sweep) >= 2PI, then we need to add a circle before we call // arcTo, since it treats the sweep mod 2PI. We don't have a prepend call, // so we just remember this, and at the end create a new path with an oval // and our current path, and then swap then. // if (sweep >= g2PI || sweep <= -g2PI) { prependOval = true; // SkDebugf("addArc sa=%g ea=%g cw=%d sweep %g treat as circle\n", sa, ea, clockwise, sweep); // now reduce sweep to just the amount we need, so that the current // point is left where the caller expects it. sweep = fmodf(sweep, g2PI); } sa = fast_mod(sa, g2PI); SkScalar startDegrees = SkFloatToScalar(sa * g180OverPI); SkScalar sweepDegrees = SkFloatToScalar(sweep * g180OverPI); // SkDebugf("addArc sa=%g ea=%g cw=%d sweep=%g ssweep=%g\n", sa, ea, clockwise, sweep, SkScalarToFloat(sweepDegrees)); m_path->arcTo(oval, startDegrees, sweepDegrees, false); if (prependOval) { SkPath tmp; tmp.addOval(oval); tmp.addPath(*m_path); m_path->swap(tmp); } }
void SkDebugCanvas::drawTo(SkCanvas* canvas, int index) { int counter = 0; SkASSERT(!fCommandVector.isEmpty()); SkASSERT(index < fCommandVector.count()); int i; // This only works assuming the canvas and device are the same ones that // were previously drawn into because they need to preserve all saves // and restores. if (fIndex < index) { i = fIndex + 1; } else { for (int j = 0; j < fOutstandingSaveCount; j++) { canvas->restore(); } i = 0; canvas->clear(SK_ColorTRANSPARENT); canvas->resetMatrix(); SkRect rect = SkRect::MakeWH(SkIntToScalar(fWidth), SkIntToScalar(fHeight)); canvas->clipRect(rect, SkRegion::kReplace_Op ); applyUserTransform(canvas); fOutstandingSaveCount = 0; } for (; i <= index; i++) { if (i == index && fFilter) { SkPaint p; p.setColor(0xAAFFFFFF); canvas->save(); canvas->resetMatrix(); SkRect mask; mask.set(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(fWidth), SkIntToScalar(fHeight)); canvas->clipRect(mask, SkRegion::kReplace_Op, false); canvas->drawRectCoords(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(fWidth), SkIntToScalar(fHeight), p); canvas->restore(); } if (fCommandVector[i]->isVisible()) { fCommandVector[i]->execute(canvas); fCommandVector[i]->trackSaveState(&fOutstandingSaveCount); } } fMatrix = canvas->getTotalMatrix(); fClip = canvas->getTotalClip().getBounds(); fIndex = index; }
void drawOrig(SkCanvas* canvas, bool bg) { SkRect r; SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); if (bg) paint.setColor(0xFFBBBBBB); SkRegion rgn; build_base_rgn(&rgn); paint_rgn(canvas, rgn, paint); r.set(fRect); canvas->drawRect(r, paint); }
static void paint_rgn(SkCanvas* canvas, const SkRegion& rgn, const SkPaint& paint) { SkRegion scaled; scale_rgn(&scaled, rgn, 0.5f); SkRegion::Iterator iter(rgn); for (; !iter.done(); iter.next()) { SkRect r; r.set(iter.rect()); canvas->drawRect(r, paint); } }
void EmojiFont::Draw(SkCanvas* canvas, uint16_t glyphID, SkScalar x, SkScalar y, const SkPaint& paint) { if (glyphID < kGlyphBase) { SkDebugf("-------- bad glyph passed to EmojiFont::Draw %d\n", glyphID); } const SkBitmap* bitmap = get_bitmap(glyphID - kGlyphBase); if (bitmap && !bitmap->empty()) { SkRect dst; SkScalar size = paint.getTextSize(); y += SkScalarMul(size, gBaselinePercentDrop); dst.set(x, y - size, x + size, y); canvas->drawBitmapRect(*bitmap, NULL, dst, &paint); } }
void SkSliderView::onDraw(SkCanvas* canvas) { this->INHERITED::onDraw(canvas); U16CPU value = SkMax32(0, SkMin32(fValue, fMax)); SkRect r; SkPaint p; r.set(0, 0, this->width(), this->height()); p.setAntiAliasOn(true); p.setStyle(SkPaint::kStroke_Style); p.setStrokeWidth(SK_Scalar1); r.inset(SK_Scalar1/2, SK_Scalar1/2); canvas->drawRect(r, p); if (fMax) { SkFixed percent = SkFixedDiv(value, fMax); r.inset(SK_Scalar1/2, SK_Scalar1/2); r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent)); p.setStyle(SkPaint::kFill_Style); setgrad(&p, r); canvas->drawRect(r, p); } #if 0 r.set(0, 0, this->width(), this->height()); r.inset(SK_Scalar1, SK_Scalar1); r.inset(r.width()/2, 0); p.setColor(SK_ColorBLACK); canvas->drawLine(*(SkPoint*)&r.fLeft, *(SkPoint*)&r.fRight, p); #endif }
PathTexture* OvalShapeCache::getOval(float width, float height, SkPaint* paint) { OvalShapeCacheEntry entry(width, height, paint); PathTexture* texture = get(entry); if (!texture) { SkPath path; SkRect r; r.set(0.0f, 0.0f, width, height); path.addOval(r, SkPath::kCW_Direction); texture = addTexture(entry, &path, paint); } return texture; }
void onDrawContent(SkCanvas* canvas) override { SkRect oval = fOval; oval.offset(fCenter.fX - oval.centerX(), fCenter.fY - oval.centerY()); SkPaint p; p.setAntiAlias(true); p.setStyle(SkPaint::kStroke_Style); canvas->drawOval(oval, p); SkRect r; r.set(SkIntToScalar(200), SkIntToScalar(200), SkIntToScalar(300), SkIntToScalar(300)); canvas->clipRect(r); p.setStyle(SkPaint::kFill_Style); p.setColor(SK_ColorRED); canvas->drawRect(r, p); p.setColor(0x800000FF); r.set(SkIntToScalar(150), SkIntToScalar(10), SkIntToScalar(250), SkIntToScalar(400)); canvas->drawOval(oval, p); }
void roundRect(SkCanvas *canvas, SkIRect irect, SkColor color) { SkRect rect; SkScalar radius = SkIntToScalar(5); SkPaint paint; rect.set(irect); paint.setColor(color); paint.setStyle(SkPaint::kFill_Style); canvas->drawRoundRect(rect, radius, radius, paint); paint.setColor(edgeColor); paint.setStyle(SkPaint::kStroke_Style); canvas->drawRoundRect(rect, radius, radius, paint); }
void WebThemeControlDRT::roundRect(SkColor color) { SkRect rect; SkScalar radius = SkIntToScalar(5); SkPaint paint; rect.set(m_irect); paint.setColor(color); paint.setStyle(SkPaint::kFill_Style); m_canvas->drawRoundRect(rect, radius, radius, paint); paint.setColor(m_edgeColor); paint.setStyle(SkPaint::kStroke_Style); m_canvas->drawRoundRect(rect, radius, radius, paint); }
void FindOnPage::draw(SkCanvas* canvas, LayerAndroid* layer) { if (!m_hasCurrentLocation || !m_matches || !m_matches->size()) return; int layerId = layer->uniqueId(); if (m_findIndex >= m_matches->size()) m_findIndex = 0; const MatchInfo& matchInfo = (*m_matches)[m_findIndex]; const SkRegion& currentMatchRegion = matchInfo.getLocation(); // Set up the paints used for drawing the matches if (!m_isFindPaintSetUp) setUpFindPaint(); // Draw the current match if (matchInfo.layerId() == layerId) { drawMatch(currentMatchRegion, canvas, true); // Now draw the picture, so that it shows up on top of the rectangle int saveCount = canvas->save(); SkPath matchPath; currentMatchRegion.getBoundaryPath(&matchPath); canvas->clipPath(matchPath); canvas->drawPicture(*matchInfo.getPicture()); canvas->restoreToCount(saveCount); } // Draw the rest unsigned numberOfMatches = m_matches->size(); if (numberOfMatches > 1 && numberOfMatches < MAX_NUMBER_OF_MATCHES_TO_DRAW) { for(unsigned i = 0; i < numberOfMatches; i++) { // The current match has already been drawn if (i == m_findIndex) continue; if ((*m_matches)[i].layerId() != layerId) continue; const SkRegion& region = (*m_matches)[i].getLocation(); // Do not draw matches which intersect the current one, or if it is // offscreen /*SAMSUNG CHANGE*/ //if (currentMatchRegion.intersects(region)) // continue; SkRect bounds; bounds.set(region.getBounds()); if (canvas->quickReject(bounds, SkCanvas::kAA_EdgeType)) continue; drawMatch(region, canvas, false); } } }
/* 0x1F * x + 0x1F * (32 - x) */ void drawRings(SkCanvas* canvas) { canvas->scale(SkIntToScalar(1)/2, SkIntToScalar(1)/2); SkRect r; SkScalar x = SkIntToScalar(10); SkScalar y = SkIntToScalar(10); r.set(x, y, x + SkIntToScalar(100), y + SkIntToScalar(100)); SkPaint paint; // paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SkScalarHalf(SkIntToScalar(3))); paint.setColor(0xFFFF8800); // paint.setColor(0xFFFFFFFF); canvas->drawRect(r, paint); }
PathTexture* RoundRectShapeCache::getRoundRect(float width, float height, float rx, float ry, SkPaint* paint) { RoundRectShapeCacheEntry entry(width, height, rx, ry, paint); PathTexture* texture = get(entry); if (!texture) { SkPath path; SkRect r; r.set(0.0f, 0.0f, width, height); path.addRoundRect(r, rx, ry, SkPath::kCW_Direction); texture = addTexture(entry, &path, paint); } return texture; }
BitmapRectView() { this->setBGColor(SK_ColorGRAY); this->resetBounce(); fSrcLimit.set(-SCALAR_SIZE/4, -SCALAR_SIZE/4, SCALAR_SIZE*5/4, SCALAR_SIZE*5/4); fDstR[0] = SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(100), SkIntToScalar(250), SkIntToScalar(300)); fDstR[1] = fDstR[0]; fDstR[1].offset(fDstR[0].width() * 5/4, 0); fSrcPts[0].set(32, 32); fSrcPts[1].set(90, 90); }
static void copybits(SkCanvas* canvas, const SkBitmap& bm, const SkRect& dst, const SkPaint& paint) { SkRect src; SkMatrix matrix; src.set(0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height())); if (matrix.setRectToRect(src, dst)) { SkPaint p(paint); SkShader* shader = SkShader::CreateBitmapShader(bm, false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode); p.setShader(shader)->unref(); shader->setLocalMatrix(matrix); canvas->drawRect(dst, p); } }
void onDraw(SkCanvas* canvas) override { SkPaint paint; paint.setAntiAlias(true); paint.setLCDRenderText(true); SkAutoTUnref<SkFontMgr> fontMgr(SkFontMgr::RefDefault()); SkAutoTDelete<SkStreamAsset> distortable(GetResourceAsStream("/fonts/Distortable.ttf")); if (!distortable) { return; } const char* text = "abc"; const size_t textLen = strlen(text); for (int j = 0; j < 2; ++j) { for (int i = 0; i < 5; ++i) { SkScalar x = SkIntToScalar(10); SkScalar y = SkIntToScalar(20); SkFourByteTag tag = SkSetFourByteTag('w','g','h','t'); SkScalar styleValue = SkDoubleToScalar(0.5 + (5*j + i) * ((2.0 - 0.5) / (2 * 5))); SkFontMgr::FontParameters::Axis axes[] = { { tag, styleValue } }; paint.setTypeface(sk_sp<SkTypeface>(fontMgr->createFromStream( distortable->duplicate(), SkFontMgr::FontParameters().setAxes(axes, 1)))); SkAutoCanvasRestore acr(canvas, true); canvas->translate(SkIntToScalar(30 + i * 100), SkIntToScalar(20)); rotate_about(canvas, SkIntToScalar(i * 5), x, y * 10); { SkPaint p; p.setAntiAlias(true); SkRect r; r.set(x - SkIntToScalar(3), SkIntToScalar(15), x - SkIntToScalar(1), SkIntToScalar(280)); canvas->drawRect(r, p); } for (int ps = 6; ps <= 22; ps++) { paint.setTextSize(SkIntToScalar(ps)); canvas->drawText(text, textLen, x, y, paint); y += paint.getFontMetrics(nullptr); } } canvas->translate(0, SkIntToScalar(360)); paint.setSubpixelText(true); } }
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 }
virtual void onDrawContent(SkCanvas* canvas) { fSweep = SampleCode::GetAnimScalar(SkIntToScalar(360)/24, SkIntToScalar(360)); // fSweep = SkFloatToScalar(359.99f); SkRect r; SkPaint paint; paint.setAntiAlias(true); paint.setStrokeWidth(SkIntToScalar(2)); paint.setStyle(SkPaint::kStroke_Style); r.set(0, 0, SkIntToScalar(200), SkIntToScalar(200)); r.offset(SkIntToScalar(20), SkIntToScalar(20)); if (false) { const SkScalar d = SkIntToScalar(3); const SkScalar rad[] = { d, d, d, d, d, d, d, d }; SkPath path; path.addRoundRect(r, rad); canvas->drawPath(path, paint); return; } drawRectWithLines(canvas, r, paint); // printf("----- sweep %g %X\n", SkScalarToFloat(fSweep), SkDegreesToRadians(fSweep)); paint.setStyle(SkPaint::kFill_Style); paint.setColor(0x800000FF); canvas->drawArc(r, 0, fSweep, true, paint); paint.setColor(0x800FF000); canvas->drawArc(r, 0, fSweep, false, paint); paint.setStyle(SkPaint::kStroke_Style); paint.setColor(SK_ColorRED); canvas->drawArc(r, 0, fSweep, true, paint); paint.setStrokeWidth(0); paint.setColor(SK_ColorBLUE); canvas->drawArc(r, 0, fSweep, false, paint); drawArcs(canvas); this->inval(NULL); }
void SkProgressView::onDraw(SkCanvas* canvas) { if (fMax == 0) return; SkFixed percent; if (fInterp) { SkScalar x; if (fInterp->timeToValues(SkTime::GetMSecs(), &x) == SkInterpolator::kFreezeEnd_Result) { delete fInterp; fInterp = NULL; } percent = (SkFixed)x; // now its 16.8 percent = SkMax32(0, SkMin32(percent, fMax << 8)); // now its pinned percent = SkFixedDiv(percent, fMax << 8); // now its 0.16 this->inval(NULL); } else { U16CPU value = SkMax32(0, SkMin32(fValue, fMax)); percent = SkFixedDiv(value, fMax); } SkRect r; SkPaint p; r.set(0, 0, this->width(), this->height()); p.setAntiAlias(true); r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent)); p.setStyle(SkPaint::kFill_Style); p.setColor(SK_ColorDKGRAY); p.setShader(fOnShader); canvas->drawRect(r, p); p.setColor(SK_ColorWHITE); p.setShader(fOffShader); r.fLeft = r.fRight; r.fRight = this->width() - SK_Scalar1; if (r.width() > 0) canvas->drawRect(r, p); }
static void draw_sweep(SkCanvas* c, int width, int height, SkScalar angle) { SkRect r; SkPaint p; p.setAntiAlias(true); // p.setDither(true); p.setStrokeWidth(SkIntToScalar(width/10)); p.setStyle(SkPaint::kStroke_Style); r.set(0, 0, SkIntToScalar(width), SkIntToScalar(height)); // SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN, SK_ColorCYAN }; SkColor colors[] = { 0x4c737373, 0x4c737373, 0xffffd300 }; SkShader* s = SkGradientShader::CreateSweep(r.centerX(), r.centerY(), colors, NULL, SK_ARRAY_COUNT(colors)); p.setShader(s)->unref(); SkAutoCanvasRestore acr(c, true); c->translate(r.centerX(), r.centerY()); c->rotate(angle); c->translate(-r.centerX(), -r.centerY()); SkRect bounds = r; r.inset(p.getStrokeWidth(), p.getStrokeWidth()); SkRect innerBounds = r; if (true) { c->drawOval(r, p); } else { SkScalar x = r.centerX(); SkScalar y = r.centerY(); SkScalar radius = r.width() / 2; SkScalar thickness = p.getStrokeWidth(); SkScalar sweep = SkFloatToScalar(360.0f); SkPath path; path.moveTo(x + radius, y); // outer top path.lineTo(x + radius + thickness, y); // outer arc path.arcTo(bounds, 0, sweep, false); // inner arc path.arcTo(innerBounds, sweep, -sweep, false); path.close(); } }
void Path::addEllipse(const FloatPoint& p, float radiusX, float radiusY, float startAngle, float endAngle, bool anticlockwise) { ASSERT(ellipseIsRenderable(startAngle, endAngle)); ASSERT(startAngle >= 0 && startAngle < twoPiFloat); ASSERT((anticlockwise && (startAngle - endAngle) >= 0) || (!anticlockwise && (endAngle - startAngle) >= 0)); SkScalar cx = WebCoreFloatToSkScalar(p.x()); SkScalar cy = WebCoreFloatToSkScalar(p.y()); SkScalar radiusXScalar = WebCoreFloatToSkScalar(radiusX); SkScalar radiusYScalar = WebCoreFloatToSkScalar(radiusY); SkRect oval; oval.set(cx - radiusXScalar, cy - radiusYScalar, cx + radiusXScalar, cy + radiusYScalar); float sweep = endAngle - startAngle; SkScalar startDegrees = WebCoreFloatToSkScalar(startAngle * 180 / piFloat); SkScalar sweepDegrees = WebCoreFloatToSkScalar(sweep * 180 / piFloat); SkScalar s360 = SkIntToScalar(360); // We can't use SkPath::addOval(), because addOval() makes a new sub-path. // addOval() calls moveTo() and close() internally. // Use s180, not s360, because SkPath::arcTo(oval, angle, s360, false) draws // nothing. SkScalar s180 = SkIntToScalar(180); if (SkScalarNearlyEqual(sweepDegrees, s360)) { // SkPath::arcTo can't handle the sweepAngle that is equal to or greater // than 2Pi. m_path.arcTo(oval, startDegrees, s180, false); m_path.arcTo(oval, startDegrees + s180, s180, false); return; } if (SkScalarNearlyEqual(sweepDegrees, -s360)) { m_path.arcTo(oval, startDegrees, -s180, false); m_path.arcTo(oval, startDegrees - s180, -s180, false); return; } m_path.arcTo(oval, startDegrees, sweepDegrees, false); }
static void* draw_proc(void* context) { const int OVALW = 32; const int OVALH = 32; const SkBitmap* bm = static_cast<const SkBitmap*>(context); SkFlipPixelRef* ref = static_cast<SkFlipPixelRef*>(bm->pixelRef()); const int DSCALE = 1; SkScalar dx = SkIntToScalar(7) / DSCALE; SkScalar dy = SkIntToScalar(5) / DSCALE; SkScalar x = 0; SkScalar y = 0; SkPaint paint; paint.setAntiAlias(true); paint.setColor(SK_ColorRED); SkRect oval; oval.setEmpty(); SkRect clipR = SkRect::MakeWH(SkIntToScalar(bm->width()), SkIntToScalar(bm->height())); clipR.inset(SK_Scalar1/4, SK_Scalar1/4); while (!gDone) { ref->inval(oval, true); oval.set(x, y, x + SkIntToScalar(OVALW), y + SkIntToScalar(OVALH)); ref->inval(oval, true); SkAutoFlipUpdate update(ref); if (!update.dirty().isEmpty()) { // this must be local to the loop, since it needs to forget the pixels // its writing to after each iteration, since we do the swap SkCanvas canvas(update.bitmap()); canvas.clipRegion(update.dirty()); canvas.drawColor(0, SkXfermode::kClear_Mode); canvas.clipRect(clipR, SkRegion::kIntersect_Op, true); canvas.drawOval(oval, paint); } bounce(&x, &dx, WIDTH-OVALW); bounce(&y, &dy, HEIGHT-OVALH); } return NULL; }
void onDraw(SkCanvas* canvas) override { SkPaint paint; paint.setAntiAlias(true); paint.setLCDRenderText(true); SkAutoTDelete<SkStreamAsset> distortable(GetResourceAsStream("/fonts/Distortable.ttf")); if (!distortable) { return; } const char* text = "abc"; const size_t textLen = strlen(text); for (int j = 0; j < 2; ++j) { for (int i = 0; i < 5; ++i) { SkScalar x = SkIntToScalar(10); SkScalar y = SkIntToScalar(20); SkFixed axis = SkDoubleToFixed(0.5 + (5*j + i) * ((2.0 - 0.5) / (2 * 5))); SkAutoTUnref<SkTypeface> typeface(SkTypeface::CreateFromFontData( new SkFontData(distortable->duplicate(), 0, &axis, 1))); paint.setTypeface(typeface); SkAutoCanvasRestore acr(canvas, true); canvas->translate(SkIntToScalar(30 + i * 100), SkIntToScalar(20)); rotate_about(canvas, SkIntToScalar(i * 5), x, y * 10); { SkPaint p; p.setAntiAlias(true); SkRect r; r.set(x - SkIntToScalar(3), SkIntToScalar(15), x - SkIntToScalar(1), SkIntToScalar(280)); canvas->drawRect(r, p); } for (int ps = 6; ps <= 22; ps++) { paint.setTextSize(SkIntToScalar(ps)); canvas->drawText(text, textLen, x, y, paint); y += paint.getFontMetrics(nullptr); } } canvas->translate(0, SkIntToScalar(360)); paint.setSubpixelText(true); } }
virtual void onDraw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); paint.setLCDRenderText(true); //With freetype the default (normal hinting) can be really ugly. //Most distros now set slight (vertical hinting only) in any event. paint.setHinting(SkPaint::kSlight_Hinting); SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromName("Times Roman", SkTypeface::kNormal))); const char* text = "Hamburgefons ooo mmm"; const size_t textLen = strlen(text); for (int j = 0; j < 2; ++j) { // This used to do 6 iterations but it causes the N4 to crash in the MSAA4 config. for (int i = 0; i < 5; ++i) { SkScalar x = SkIntToScalar(10); SkScalar y = SkIntToScalar(20); SkAutoCanvasRestore acr(canvas, true); canvas->translate(SkIntToScalar(50 + i * 230), SkIntToScalar(20)); rotate_about(canvas, SkIntToScalar(i * 5), x, y * 10); { SkPaint p; p.setAntiAlias(true); SkRect r; r.set(x - SkIntToScalar(3), SkIntToScalar(15), x - SkIntToScalar(1), SkIntToScalar(280)); canvas->drawRect(r, p); } int index = 0; for (int ps = 6; ps <= 22; ps++) { paint.setTextSize(SkIntToScalar(ps)); canvas->drawText(text, textLen, x, y, paint); y += paint.getFontMetrics(NULL); index += 1; } } canvas->translate(0, SkIntToScalar(360)); paint.setSubpixelText(true); } }
static void draw_into_bitmap(const SkBitmap& bm) { const int w = bm.width(); const int h = bm.height(); SkCanvas canvas(bm); SkPaint p; p.setAntiAlias(true); p.setColor(SK_ColorRED); canvas.drawCircle(SkIntToScalar(w)/2, SkIntToScalar(h)/2, SkIntToScalar(SkMin32(w, h))*3/8, p); SkRect r; r.set(0, 0, SkIntToScalar(w), SkIntToScalar(h)); p.setStyle(SkPaint::kStroke_Style); p.setStrokeWidth(SkIntToScalar(4)); p.setColor(SK_ColorBLUE); canvas.drawRect(r, p); }
virtual void getWarpParams(WarpFrameT& warpFrame, SkMatrix& warpMatrix) const { SkPath bSkeleton, tSkeleton; //ring outside SkRect r; r.set(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(330), SkIntToScalar(120)); bSkeleton.addOval(r, SkPath::kCCW_Direction); warpFrame.push_back(bSkeleton); { //top bSkeleton.offset(SkIntToScalar(0), SkIntToScalar(-100), &tSkeleton); warpFrame.push_back(tSkeleton); } }
bool RenderThemeChromiumSkia::paintSliderTrack(RenderObject*, const RenderObject::PaintInfo& i, const IntRect& rect) { // Just paint a grey box for now (matches the color of a scrollbar background. SkCanvas* const canvas = i.context->platformContext()->canvas(); int verticalCenter = rect.y() + rect.height() / 2; int top = std::max(rect.y(), verticalCenter - 2); int bottom = std::min(rect.y() + rect.height(), verticalCenter + 2); SkPaint paint; const SkColor grey = SkColorSetARGB(0xff, 0xe3, 0xdd, 0xd8); paint.setColor(grey); SkRect skrect; skrect.set(rect.x(), top, rect.x() + rect.width(), bottom); canvas->drawRect(skrect, paint); return false; }