static void convolve_gaussian(GrDrawContext* drawContext, GrRenderTarget* rt, const GrClip& clip, const SkRect& srcRect, const SkRect& dstRect, GrTexture* texture, Gr1DKernelEffect::Direction direction, int radius, float sigma, bool cropToSrcRect) { float bounds[2] = { 0.0f, 1.0f }; if (!cropToSrcRect) { convolve_gaussian_1d(drawContext, rt, clip, srcRect, dstRect, texture, direction, radius, sigma, false, bounds); return; } SkRect lowerSrcRect = srcRect, lowerDstRect = dstRect; SkRect middleSrcRect = srcRect, middleDstRect = dstRect; SkRect upperSrcRect = srcRect, upperDstRect = dstRect; SkScalar size; SkScalar rad = SkIntToScalar(radius); if (direction == Gr1DKernelEffect::kX_Direction) { bounds[0] = SkScalarToFloat(srcRect.left()) / texture->width(); bounds[1] = SkScalarToFloat(srcRect.right()) / texture->width(); size = srcRect.width(); lowerSrcRect.fRight = srcRect.left() + rad; lowerDstRect.fRight = dstRect.left() + rad; upperSrcRect.fLeft = srcRect.right() - rad; upperDstRect.fLeft = dstRect.right() - rad; middleSrcRect.inset(rad, 0); middleDstRect.inset(rad, 0); } else { bounds[0] = SkScalarToFloat(srcRect.top()) / texture->height(); bounds[1] = SkScalarToFloat(srcRect.bottom()) / texture->height(); size = srcRect.height(); lowerSrcRect.fBottom = srcRect.top() + rad; lowerDstRect.fBottom = dstRect.top() + rad; upperSrcRect.fTop = srcRect.bottom() - rad; upperDstRect.fTop = dstRect.bottom() - rad; middleSrcRect.inset(0, rad); middleDstRect.inset(0, rad); } if (radius >= size * SK_ScalarHalf) { // Blur radius covers srcRect; use bounds over entire draw convolve_gaussian_1d(drawContext, rt, clip, srcRect, dstRect, texture, direction, radius, sigma, true, bounds); } else { // Draw upper and lower margins with bounds; middle without. convolve_gaussian_1d(drawContext, rt, clip, lowerSrcRect, lowerDstRect, texture, direction, radius, sigma, true, bounds); convolve_gaussian_1d(drawContext, rt, clip, upperSrcRect, upperDstRect, texture, direction, radius, sigma, true, bounds); convolve_gaussian_1d(drawContext, rt, clip, middleSrcRect, middleDstRect, texture, direction, radius, sigma, false, bounds); } }
SkRect VideoLayerAndroid::calVideoRect(const SkRect& rect) { SkRect videoRect = rect; VideoLayerManager* manager = TilesManager::instance()->videoLayerManager(); float aspectRatio = manager->getAspectRatio(uniqueId()); float deltaY = rect.height() - rect.width() / aspectRatio; if (deltaY >= 0) videoRect.inset(0, deltaY / 2); else { float deltaX = rect.width() - rect.height() * aspectRatio; if (deltaX >= 0) videoRect.inset(deltaX / 2, 0); } return videoRect; }
bool MediaLayer::drawGL(GLWebViewState* glWebViewState, SkMatrix& matrix) { TilesManager::instance()->shader()->clip(drawClip()); // when the plugin gains focus webkit applies an outline to the // widget, which causes the layer to expand to accommodate the // outline. Therefore, we shrink the rect by the outline's dimensions // to ensure the plugin does not draw outside of its bounds. SkRect mediaBounds; mediaBounds.set(0, 0, getSize().width(), getSize().height()); mediaBounds.inset(m_outlineSize, m_outlineSize); // check to see if we need to create a content or video texture m_mediaTexture->initNativeWindowIfNeeded(); // the layer's shader draws the content inverted so we must undo // that change in the transformation matrix TransformationMatrix m = m_drawTransform; if (!m_mediaTexture->isContentInverted()) { m.flipY(); m.translate(0, -getSize().height()); } // draw any content or video if present m_mediaTexture->draw(m, m_drawTransform, mediaBounds); return drawChildrenGL(glWebViewState, matrix); }
virtual void onDrawContent(SkCanvas* canvas) { canvas->drawColor(SK_ColorWHITE); canvas->translate(SkIntToScalar(20), SkIntToScalar(20)); static const CanvasProc gProc[] = { show_text, show_thick, show_hair, show_fill }; SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) }; SkPath clipPath; r.inset(SK_Scalar1 / 4, SK_Scalar1 / 4); clipPath.addRoundRect(r, SkIntToScalar(20), SkIntToScalar(20)); // clipPath.toggleInverseFillType(); for (int aa = 0; aa <= 1; ++aa) { canvas->save(); for (size_t i = 0; i < SK_ARRAY_COUNT(gProc); ++i) { canvas->save(); canvas->clipPath(clipPath, SkRegion::kIntersect_Op, true); // canvas->drawColor(SK_ColorWHITE); gProc[i](canvas, SkToBool(aa)); canvas->restore(); canvas->translate(W * SK_Scalar1 * 8 / 7, 0); } canvas->restore(); canvas->translate(0, H * SK_Scalar1 * 8 / 7); } }
virtual void onDraw(SkCanvas* canvas) { switch (fStyle) { case kRect_Style: canvas->drawRect(fRect, fPaint); break; case kOval_Style: canvas->drawOval(fRect, fPaint); break; case kRRect_Style: { SkScalar rx = fRect.width() / 5; SkScalar ry = fRect.height() / 5; if (rx < ry) { ry = rx; } else { rx = ry; } canvas->drawRoundRect(fRect, rx, ry, fPaint); break; } case kFrame_Style: { SkPath path; path.addOval(fRect, SkPath::kCW_Direction); SkRect r = fRect; r.inset(fRect.width()/6, 0); path.addOval(r, SkPath::kCCW_Direction); canvas->drawPath(path, fPaint); break; } } }
void onDraw(SkCanvas* canvas) override { canvas->translate(20, 20); SkRect r = SkRect::MakeWH(1000, 1000); SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(15); const SkScalar inset = paint.getStrokeWidth() + 4; const SkScalar sweepAngle = 345; SkRandom rand; SkScalar sign = 1; while (r.width() > paint.getStrokeWidth() * 3) { paint.setColor(sk_tool_utils::color_to_565(rand.nextU() | (0xFF << 24))); SkScalar startAngle = rand.nextUScalar1() * 360; SkScalar speed = SkScalarSqrt(16 / r.width()) * 0.5f; startAngle += fRotate * 360 * speed * sign; SkPath path; path.addArc(r, startAngle, sweepAngle); canvas->drawPath(path, paint); r.inset(inset, inset); sign = -sign; } }
static void draw_2_bitmaps(SkCanvas* canvas, const SkBitmap& bm, bool doClip, int dx, int dy, SkImageFilter* filter = NULL) { SkAutoCanvasRestore acr(canvas, true); SkPaint paint; SkRect clipR = SkRect::MakeXYWH(SkIntToScalar(dx), SkIntToScalar(dy), SkIntToScalar(bm.width()), SkIntToScalar(bm.height())); paint.setImageFilter(filter); clipR.inset(5, 5); if (doClip) { canvas->save(); canvas->clipRect(clipR); } canvas->drawSprite(bm, dx, dy, &paint); if (doClip) { canvas->restore(); } canvas->translate(SkIntToScalar(bm.width() + 20), 0); if (doClip) { canvas->save(); canvas->clipRect(clipR); } canvas->drawBitmap(bm, SkIntToScalar(dx), SkIntToScalar(dy), &paint); if (doClip) { canvas->restore(); } }
static void patheffect_slide(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); SkPath path; path.moveTo(20, 20); path.lineTo(70, 120); path.lineTo(120, 30); path.lineTo(170, 80); path.lineTo(240, 50); size_t i; canvas->save(); for (i = 0; i < SK_ARRAY_COUNT(gPE); i++) { gPE[i](&paint); canvas->drawPath(path, paint); canvas->translate(0, 75); } canvas->restore(); path.reset(); SkRect r = { 0, 0, 250, 120 }; path.addOval(r, SkPath::kCW_Direction); r.inset(50, 50); path.addRect(r, SkPath::kCCW_Direction); canvas->translate(320, 20); for (i = 0; i < SK_ARRAY_COUNT(gPE2); i++) { gPE2[i](&paint); canvas->drawPath(path, paint); canvas->translate(0, 160); } }
static SkScalar drawCell(SkCanvas* canvas, SkXfermode* mode, SkAlpha a0, SkAlpha a1) { SkPaint paint; paint.setAntiAlias(true); SkRect r = SkRect::MakeWH(W, H); r.inset(W/10, H/10); paint.setColor(SK_ColorBLUE); paint.setAlpha(a0); canvas->drawOval(r, paint); paint.setColor(SK_ColorRED); paint.setAlpha(a1); paint.setXfermode(mode); SkScalar offset = SK_Scalar1 / 3; SkRect rect = SkRect::MakeXYWH(W / 4 + offset, H / 4 + offset, W / 2, H / 2); canvas->drawRect(rect, paint); return H; }
void FatBits::drawLine(SkCanvas* canvas, SkPoint pts[]) { SkPaint paint; fInverse.mapPoints(pts, 2); if (fGrid) { apply_grid(pts, 2); } erase(fMinSurface); this->setupPaint(&paint); paint.setColor(FAT_PIXEL_COLOR); if (fUseClip) { fMinSurface->getCanvas()->save(); SkRect r = fClipRect; r.inset(SK_Scalar1/3, SK_Scalar1/3); fMinSurface->getCanvas()->clipRect(r, SkRegion::kIntersect_Op, true); } fMinSurface->getCanvas()->drawLine(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, paint); if (fUseClip) { fMinSurface->getCanvas()->restore(); } this->copyMinToMax(); SkCanvas* max = fMaxSurface->getCanvas(); fMatrix.mapPoints(pts, 2); this->drawLineSkeleton(max, pts); fMaxSurface->draw(canvas, 0, 0, NULL); }
static void draw_rect(SkCanvas* canvas, bool showGL, int flags) { SkPaint paint; paint.setAntiAlias(true); SkRect r = SkRect::MakeLTRB(50, 70, 250, 370); setFade(&paint, showGL); canvas->drawRect(r, paint); if (showGL) { show_mesh(canvas, r); } canvas->translate(320, 0); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(25); canvas->drawRect(r, paint); if (showGL) { SkScalar rad = paint.getStrokeWidth() / 2; SkPoint pts[8]; r.outset(rad, rad); r.toQuad(&pts[0]); r.inset(rad*2, rad*2); r.toQuad(&pts[4]); const uint16_t indices[] = { 0, 4, 1, 5, 2, 6, 3, 7, 0, 4 }; show_mesh(canvas, pts, indices, SK_ARRAY_COUNT(indices)); } }
static SkScalar drawCell(SkCanvas* canvas, SkXfermode* mode, SkAlpha a0, SkAlpha a1) { SkPaint paint; paint.setAntiAlias(true); SkRect r = SkRect::MakeWH(W, H); r.inset(W/10, H/10); paint.setColor(SK_ColorBLUE); paint.setAlpha(a0); canvas->drawOval(r, paint); paint.setColor(SK_ColorRED); paint.setAlpha(a1); paint.setXfermode(mode); for (int angle = 0; angle < 24; ++angle) { SkScalar x = SkScalarCos(SkIntToScalar(angle) * (SK_ScalarPI * 2) / 24) * gWidth; SkScalar y = SkScalarSin(SkIntToScalar(angle) * (SK_ScalarPI * 2) / 24) * gHeight; paint.setStrokeWidth(SK_Scalar1 * angle * 2 / 24); canvas->drawLine(W/2, H/2, W/2 + x, H/2 + y, paint); } return H; }
// found and fixed for webkit: mishandling when we hit recursion limit on // mostly degenerate cubic flatness test DEF_TEST(Paint_regression_cubic, reporter) { SkPath path, stroke; SkPaint paint; path.moveTo(460.2881309415525f, 303.250847066498f); path.cubicTo(463.36378422175284f, 302.1169735073363f, 456.32239330810046f, 304.720354932878f, 453.15255460013304f, 305.788586869862f); SkRect fillR, strokeR; fillR = path.getBounds(); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SkIntToScalar(2)); paint.getFillPath(path, &stroke); strokeR = stroke.getBounds(); SkRect maxR = fillR; SkScalar miter = SkMaxScalar(SK_Scalar1, paint.getStrokeMiter()); SkScalar inset = paint.getStrokeJoin() == SkPaint::kMiter_Join ? SkScalarMul(paint.getStrokeWidth(), miter) : paint.getStrokeWidth(); maxR.inset(-inset, -inset); // test that our stroke didn't explode REPORTER_ASSERT(reporter, maxR.contains(strokeR)); }
static void lettersToBitmap2(SkBitmap* dst, const char chars[], const SkPaint& original, SkBitmap::Config config) { SkPath path; SkScalar x = 0; SkScalar width; SkPath p; for (size_t i = 0; i < strlen(chars); i++) { original.getTextPath(&chars[i], 1, x, 0, &p); path.addPath(p); original.getTextWidths(&chars[i], 1, &width); x += width; } SkRect bounds = path.getBounds(); SkScalar sw = -original.getStrokeWidth(); bounds.inset(sw, sw); path.offset(-bounds.fLeft, -bounds.fTop); bounds.offset(-bounds.fLeft, -bounds.fTop); int w = SkScalarRound(bounds.width()); int h = SkScalarRound(bounds.height()); SkPaint paint(original); paint.setAntiAlias(true); paint.setXfermodeMode(SkXfermode::kDstATop_Mode); paint.setColor(original.getColor()); paint.setStyle(SkPaint::kStroke_Style); dst->setConfig(config, w, h); dst->allocPixels(); dst->eraseColor(SK_ColorWHITE); SkCanvas canvas(*dst); canvas.drawPath(path, paint); }
void draw(SkCanvas* canvas, const SkRect& rect, const SkSize& deviceSize, SkPaint::FilterLevel filterLevel, SkImageFilter* input = NULL) { SkRect dstRect; canvas->getTotalMatrix().mapRect(&dstRect, rect); canvas->save(); SkScalar deviceScaleX = SkScalarDiv(deviceSize.width(), dstRect.width()); SkScalar deviceScaleY = SkScalarDiv(deviceSize.height(), dstRect.height()); canvas->translate(rect.x(), rect.y()); canvas->scale(deviceScaleX, deviceScaleY); canvas->translate(-rect.x(), -rect.y()); SkMatrix matrix; matrix.setScale(SkScalarInvert(deviceScaleX), SkScalarInvert(deviceScaleY)); SkAutoTUnref<SkImageFilter> imageFilter( SkMatrixImageFilter::Create(matrix, filterLevel, input)); SkPaint filteredPaint; filteredPaint.setImageFilter(imageFilter.get()); canvas->saveLayer(&rect, &filteredPaint); SkPaint paint; paint.setColor(0xFF00FF00); SkRect ovalRect = rect; ovalRect.inset(SkIntToScalar(4), SkIntToScalar(4)); canvas->drawOval(ovalRect, paint); canvas->restore(); // for saveLayer canvas->restore(); }
static SkBitmap make_bmp(int w, int h) { SkBitmap bmp; bmp.allocN32Pixels(w, h, true); SkCanvas canvas(bmp); SkScalar wScalar = SkIntToScalar(w); SkScalar hScalar = SkIntToScalar(h); SkPoint pt = { wScalar / 2, hScalar / 2 }; SkScalar radius = 3 * SkMaxScalar(wScalar, hScalar); SkColor colors[] = {SK_ColorDKGRAY, ToolUtils::color_to_565(0xFF222255), ToolUtils::color_to_565(0xFF331133), ToolUtils::color_to_565(0xFF884422), ToolUtils::color_to_565(0xFF000022), SK_ColorWHITE, ToolUtils::color_to_565(0xFFAABBCC)}; SkScalar pos[] = {0, SK_Scalar1 / 6, 2 * SK_Scalar1 / 6, 3 * SK_Scalar1 / 6, 4 * SK_Scalar1 / 6, 5 * SK_Scalar1 / 6, SK_Scalar1}; SkPaint paint; SkRect rect = SkRect::MakeWH(wScalar, hScalar); SkMatrix mat = SkMatrix::I(); for (int i = 0; i < 4; ++i) { paint.setShader(SkGradientShader::MakeRadial( pt, radius, colors, pos, SK_ARRAY_COUNT(colors), SkTileMode::kRepeat, 0, &mat)); canvas.drawRect(rect, paint); rect.inset(wScalar / 8, hScalar / 8); mat.preTranslate(6 * wScalar, 6 * hScalar); mat.postScale(SK_Scalar1 / 3, SK_Scalar1 / 3); } SkFont font(ToolUtils::create_portable_typeface(), wScalar / 2.2f); paint.setShader(nullptr); paint.setColor(SK_ColorLTGRAY); constexpr char kTxt[] = "Skia"; SkPoint texPos = { wScalar / 17, hScalar / 2 + font.getSize() / 2.5f }; canvas.drawSimpleText(kTxt, SK_ARRAY_COUNT(kTxt)-1, SkTextEncoding::kUTF8, texPos.fX, texPos.fY, font, paint); paint.setColor(SK_ColorBLACK); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SK_Scalar1); canvas.drawSimpleText(kTxt, SK_ARRAY_COUNT(kTxt)-1, SkTextEncoding::kUTF8, texPos.fX, texPos.fY, font, paint); return bmp; }
static void draw0(SkCanvas* canvas) { SkPaint p; p.setAntiAlias(true); SkRect r = SkRect::MakeWH(FILTER_WIDTH, FILTER_HEIGHT); r.inset(SK_Scalar1 * 12, SK_Scalar1 * 12); p.setColor(SK_ColorRED); canvas->drawOval(r, p); }
void GLEllipticalRRectEffect::onSetData(const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& effect) { const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>(); const SkRRect& rrect = erre.getRRect(); // If we're using a scale factor to work around precision issues, choose the largest radius // as the scale factor. The inv radii need to be pre-adjusted by the scale factor. if (rrect != fPrevRRect) { SkRect rect = rrect.getBounds(); const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner); SkASSERT(r0.fX >= kRadiusMin); SkASSERT(r0.fY >= kRadiusMin); switch (erre.getRRect().getType()) { case SkRRect::kSimple_Type: rect.inset(r0.fX, r0.fY); if (fScaleUniform.isValid()) { if (r0.fX > r0.fY) { pdman.set2f(fInvRadiiSqdUniform, 1.f, (r0.fX * r0.fX) / (r0.fY * r0.fY)); pdman.set2f(fScaleUniform, r0.fX, 1.f / r0.fX); } else { pdman.set2f(fInvRadiiSqdUniform, (r0.fY * r0.fY) / (r0.fX * r0.fX), 1.f); pdman.set2f(fScaleUniform, r0.fY, 1.f / r0.fY); } } else { pdman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX), 1.f / (r0.fY * r0.fY)); } break; case SkRRect::kNinePatch_Type: { const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner); SkASSERT(r1.fX >= kRadiusMin); SkASSERT(r1.fY >= kRadiusMin); rect.fLeft += r0.fX; rect.fTop += r0.fY; rect.fRight -= r1.fX; rect.fBottom -= r1.fY; if (fScaleUniform.isValid()) { float scale = SkTMax(SkTMax(r0.fX, r0.fY), SkTMax(r1.fX, r1.fY)); float scaleSqd = scale * scale; pdman.set4f(fInvRadiiSqdUniform, scaleSqd / (r0.fX * r0.fX), scaleSqd / (r0.fY * r0.fY), scaleSqd / (r1.fX * r1.fX), scaleSqd / (r1.fY * r1.fY)); pdman.set2f(fScaleUniform, scale, 1.f / scale); } else { pdman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX), 1.f / (r0.fY * r0.fY), 1.f / (r1.fX * r1.fX), 1.f / (r1.fY * r1.fY)); } break; } default: SK_ABORT("RRect should always be simple or nine-patch."); } pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom); fPrevRRect = rrect; } }
static SkBitmap make_bmp(int w, int h) { SkBitmap bmp; bmp.allocN32Pixels(w, h, true); SkCanvas canvas(bmp); SkScalar wScalar = SkIntToScalar(w); SkScalar hScalar = SkIntToScalar(h); SkPoint pt = { wScalar / 2, hScalar / 2 }; SkScalar radius = 3 * SkMaxScalar(wScalar, hScalar); SkColor colors[] = { sk_tool_utils::color_to_565(SK_ColorDKGRAY), sk_tool_utils::color_to_565(0xFF222255), sk_tool_utils::color_to_565(0xFF331133), sk_tool_utils::color_to_565(0xFF884422), sk_tool_utils::color_to_565(0xFF000022), SK_ColorWHITE, sk_tool_utils::color_to_565(0xFFAABBCC) }; SkScalar pos[] = {0, SK_Scalar1 / 6, 2 * SK_Scalar1 / 6, 3 * SK_Scalar1 / 6, 4 * SK_Scalar1 / 6, 5 * SK_Scalar1 / 6, SK_Scalar1}; SkPaint paint; SkRect rect = SkRect::MakeWH(wScalar, hScalar); SkMatrix mat = SkMatrix::I(); for (int i = 0; i < 4; ++i) { paint.setShader(SkGradientShader::CreateRadial( pt, radius, colors, pos, SK_ARRAY_COUNT(colors), SkShader::kRepeat_TileMode, 0, &mat))->unref(); canvas.drawRect(rect, paint); rect.inset(wScalar / 8, hScalar / 8); mat.preTranslate(6 * wScalar, 6 * hScalar); mat.postScale(SK_Scalar1 / 3, SK_Scalar1 / 3); } paint.setAntiAlias(true); sk_tool_utils::set_portable_typeface(&paint); paint.setTextSize(wScalar / 2.2f); paint.setShader(0); paint.setColor(sk_tool_utils::color_to_565(SK_ColorLTGRAY)); static const char kTxt[] = "Skia"; SkPoint texPos = { wScalar / 17, hScalar / 2 + paint.getTextSize() / 2.5f }; canvas.drawText(kTxt, SK_ARRAY_COUNT(kTxt)-1, texPos.fX, texPos.fY, paint); paint.setColor(SK_ColorBLACK); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SK_Scalar1); canvas.drawText(kTxt, SK_ARRAY_COUNT(kTxt)-1, texPos.fX, texPos.fY, paint); return bmp; }
virtual void onDraw(SkCanvas* canvas) { canvas->drawColor(SK_ColorGRAY); SkPaint paint; paint.setTypeface(fTypeface); const char* text = "hamburgerfons"; // draw text at different point sizes const int textSize[] = { 10, 30, 50 }; const int textYOffset[] = { 10, 40, 100}; SkASSERT(sizeof(textSize) == sizeof(textYOffset)); for (size_t y = 0; y < sizeof(textSize) / sizeof(int); ++y) { paint.setTextSize(SkIntToScalar(textSize[y])); canvas->drawText(text, strlen(text), 10, SkIntToScalar(textYOffset[y]), paint); } // setup work needed to draw text with different clips canvas->translate(10, 160); paint.setTextSize(40); // compute the bounds of the text SkRect bounds; paint.measureText(text, strlen(text), &bounds); const SkScalar boundsHalfWidth = bounds.width() * SK_ScalarHalf; const SkScalar boundsHalfHeight = bounds.height() * SK_ScalarHalf; const SkScalar boundsQuarterWidth = boundsHalfWidth * SK_ScalarHalf; const SkScalar boundsQuarterHeight = boundsHalfHeight * SK_ScalarHalf; SkRect upperLeftClip = SkRect::MakeXYWH(bounds.left(), bounds.top(), boundsHalfWidth, boundsHalfHeight); SkRect lowerRightClip = SkRect::MakeXYWH(bounds.centerX(), bounds.centerY(), boundsHalfWidth, boundsHalfHeight); SkRect interiorClip = bounds; interiorClip.inset(boundsQuarterWidth, boundsQuarterHeight); const SkRect clipRects[] = { bounds, upperLeftClip, lowerRightClip, interiorClip }; SkPaint clipHairline; clipHairline.setColor(SK_ColorWHITE); clipHairline.setStyle(SkPaint::kStroke_Style); for (size_t x = 0; x < sizeof(clipRects) / sizeof(SkRect); ++x) { canvas->save(); canvas->drawRect(clipRects[x], clipHairline); paint.setAlpha(0x20); canvas->drawText(text, strlen(text), 0, 0, paint); canvas->clipRect(clipRects[x]); paint.setAlpha(0xFF); canvas->drawText(text, strlen(text), 0, 0, paint); canvas->restore(); canvas->translate(0, bounds.height() + SkIntToScalar(25)); } }
static void draw_box_frame(SkCanvas* canvas, int width, int height) { SkPaint p; p.setStyle(SkPaint::kStroke_Style); p.setColor(SK_ColorRED); SkRect r = SkRect::MakeIWH(width, height); r.inset(0.5f, 0.5f); canvas->drawRect(r, p); canvas->drawLine(r.left(), r.top(), r.right(), r.bottom(), p); canvas->drawLine(r.left(), r.bottom(), r.right(), r.top(), p); }
// Two pictures with a rect clip on the second one static void rect_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) { canvas->drawPicture(pictures[0]); SkRect rect = pictures[0]->cullRect(); rect.inset(kInset, kInset); canvas->clipRect(rect); canvas->drawPicture(pictures[1]); }
virtual void onDrawContent(SkCanvas* canvas) { #if 1 SkAAClip aaclip; SkPath path; SkRect bounds; bounds.set(0, 0, 20, 20); bounds.inset(SK_ScalarHalf, SK_ScalarHalf); // path.addRect(bounds); // path.addOval(bounds); path.addRoundRect(bounds, 4, 4); aaclip.setPath(path); canvas->translate(30, 30); drawClip(canvas, aaclip); SkAAClip aaclip2; path.offset(10, 10); aaclip2.setPath(path); canvas->translate(30, 0); drawClip(canvas, aaclip2); SkAAClip aaclip3; aaclip3.op(aaclip, aaclip2, SkRegion::kIntersect_Op); canvas->translate(30, 0); drawClip(canvas, aaclip3); #endif #if 0 SkRect r; r.set(0, 0, this->width(), this->height()); r.inset(20, 20); canvas->clipRect(r); SkPath path; path.addRect(r); SkPaint paint; paint.setAntiAlias(true); paint.setColor(SK_ColorRED); canvas->drawPath(path, paint); #endif }
// Creates a bitmap and a matching image. static sk_sp<SkImage> makebm(SkCanvas* origCanvas, SkBitmap* resultBM, int w, int h) { SkImageInfo info = SkImageInfo::MakeN32Premul(w, h); auto surface(sk_tool_utils::makeSurface(origCanvas, info)); SkCanvas* canvas = surface->getCanvas(); canvas->clear(SK_ColorTRANSPARENT); SkScalar wScalar = SkIntToScalar(w); SkScalar hScalar = SkIntToScalar(h); SkPoint pt = { wScalar / 2, hScalar / 2 }; SkScalar radius = 4 * SkMaxScalar(wScalar, hScalar); SkColor colors[] = { SK_ColorRED, SK_ColorYELLOW, SK_ColorGREEN, SK_ColorMAGENTA, SK_ColorBLUE, SK_ColorCYAN, SK_ColorRED}; SkScalar pos[] = {0, SK_Scalar1 / 6, 2 * SK_Scalar1 / 6, 3 * SK_Scalar1 / 6, 4 * SK_Scalar1 / 6, 5 * SK_Scalar1 / 6, SK_Scalar1}; SkPaint paint; SkRect rect = SkRect::MakeWH(wScalar, hScalar); SkMatrix mat = SkMatrix::I(); for (int i = 0; i < 4; ++i) { paint.setShader(SkGradientShader::MakeRadial( pt, radius, colors, pos, SK_ARRAY_COUNT(colors), SkShader::kRepeat_TileMode, 0, &mat)); canvas->drawRect(rect, paint); rect.inset(wScalar / 8, hScalar / 8); mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4); } auto image = surface->makeImageSnapshot(); SkBitmap tempBM; image->asLegacyBitmap(&tempBM); // Let backends know we won't change this, so they don't have to deep copy it defensively. tempBM.setImmutable(); *resultBM = tempBM; return image; }
void drawBorders(SkCanvas* canvas) { SkPaint p; p.setStyle(SkPaint::kStroke_Style); p.setColor(SK_ColorBLUE); SkRect r = SkRect::MakeWH(fCell.width() * 2, fCell.height() * 2); r.inset(SK_ScalarHalf, SK_ScalarHalf); canvas->drawRect(r, p); canvas->drawLine(r.left(), r.centerY(), r.right(), r.centerY(), p); canvas->drawLine(r.centerX(), r.top(), r.centerX(), r.bottom(), p); }
static void outer_frame(SkCanvas* canvas, const SkIRect& rect) { SkRect r; r.set(rect); r.inset(-SK_ScalarHalf, -SK_ScalarHalf); SkPaint paint; paint.setColor(SK_ColorGRAY); paint.setStyle(SkPaint::kStroke_Style); canvas->drawRect(r, paint); }
AAClipBuilderBench(void* param, bool doPath, bool doAA) : INHERITED(param) { fDoPath = doPath; fDoAA = doAA; fName.printf("aaclip_build_%s_%s", doPath ? "path" : "rect", doAA ? "AA" : "BW"); fRegion.setRect(0, 0, 640, 480); fRect.set(fRegion.getBounds()); fRect.inset(SK_Scalar1/4, SK_Scalar1/4); fPath.addRoundRect(fRect, SkIntToScalar(20), SkIntToScalar(20)); }
virtual bool onIRect(const SkIRect& r) { SkRect rr; rr.set(SkIntToScalar(r.fLeft), SkIntToScalar(r.fTop), SkIntToScalar(r.fRight), SkIntToScalar(r.fBottom)); SkPaint p; p.setStyle(SkPaint::kStroke_Style); p.setColor(SK_ColorYELLOW); #if 0 rr.inset(SK_ScalarHalf, SK_ScalarHalf); #else rr.inset(-SK_ScalarHalf, -SK_ScalarHalf); #endif fCanvas.drawRect(rr, p); return true; }
static void draw(SkCanvas* canvas, SkRect& target, int x, int y) { SkPaint borderPaint; borderPaint.setColor(SkColorSetRGB(0x0, 0xDD, 0x0)); borderPaint.setAntiAlias(true); SkPaint backgroundPaint; backgroundPaint.setColor(SkColorSetRGB(0xDD, 0x0, 0x0)); backgroundPaint.setAntiAlias(true); SkPaint foregroundPaint; foregroundPaint.setColor(SkColorSetRGB(0x0, 0x0, 0xDD)); foregroundPaint.setAntiAlias(true); canvas->save(); canvas->translate(SkIntToScalar(x), SkIntToScalar(y)); target.inset(SkIntToScalar(-2), SkIntToScalar(-2)); canvas->drawRect(target, borderPaint); target.inset(SkIntToScalar(2), SkIntToScalar(2)); canvas->drawRect(target, backgroundPaint); canvas->clipRect(target, SkRegion::kIntersect_Op, true); target.inset(SkIntToScalar(-4), SkIntToScalar(-4)); canvas->drawRect(target, foregroundPaint); canvas->restore(); }
virtual void onDraw(SkCanvas* canvas) { canvas->clear(0x00000000); SkRect srcRect = SkRect::MakeWH(96, 96); SkSize deviceSize = SkSize::Make(16, 16); draw(canvas, srcRect, deviceSize, SkPaint::kNone_FilterLevel); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, deviceSize, SkPaint::kLow_FilterLevel); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, deviceSize, SkPaint::kMedium_FilterLevel); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, deviceSize, SkPaint::kHigh_FilterLevel); SkBitmap bitmap; bitmap.allocN32Pixels(16, 16); bitmap.eraseARGB(0x00, 0x00, 0x00, 0x00); { SkBitmapDevice bitmapDevice(bitmap); SkCanvas bitmapCanvas(&bitmapDevice); SkPaint paint; paint.setColor(0xFF00FF00); SkRect ovalRect = SkRect::MakeWH(16, 16); ovalRect.inset(SkScalarDiv(2.0f, 3.0f), SkScalarDiv(2.0f, 3.0f)); bitmapCanvas.drawOval(ovalRect, paint); } SkRect inRect = SkRect::MakeXYWH(-4, -4, 20, 20); SkRect outRect = SkRect::MakeXYWH(-24, -24, 120, 120); SkAutoTUnref<SkBitmapSource> source(SkBitmapSource::Create(bitmap, inRect, outRect)); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, deviceSize, SkPaint::kHigh_FilterLevel, source.get()); }