void GMSampleView::onDrawContent(SkCanvas* canvas) { SkPictureRecorder recorder; SkCanvas* origCanvas = canvas; if (false) { SkISize size = fGM->getISize(); canvas = recorder.beginRecording(SkRect::MakeIWH(size.width(), size.height())); } { SkAutoCanvasRestore acr(canvas, fShowSize); fGM->drawContent(canvas); } if (origCanvas != canvas) { sk_sp<SkPicture> pic = recorder.finishRecordingAsPicture(); if (false) { pic = round_trip_serialize(pic.get()); } origCanvas->drawPicture(pic); canvas = origCanvas; } if (fShowSize) { SkISize size = fGM->getISize(); SkRect r = SkRect::MakeWH(SkIntToScalar(size.width()), SkIntToScalar(size.height())); SkPaint paint; paint.setColor(0x40FF8833); canvas->drawRect(r, paint); } }
virtual void onDraw(SkCanvas* canvas) { const char* lcd_text = "LCD"; const char* gray_text = "GRAY"; SkPaint paint; paint.setAntiAlias(true); paint.setLCDRenderText(true); const struct { SkPoint fLoc; SkScalar fTextSize; SkScalar fScale; const char* fText; } rec[] = { { { 10, 50 }, kLCDTextSizeLimit - 1, 1, lcd_text }, { { 160, 50 }, kLCDTextSizeLimit + 1, 1, gray_text }, { { 10, 100 }, kLCDTextSizeLimit / 2, 1.99f, lcd_text }, { { 160, 100 }, kLCDTextSizeLimit / 2, 2.01f, gray_text }, }; for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) { const SkPoint loc = rec[i].fLoc; SkAutoCanvasRestore acr(canvas, true); paint.setTextSize(rec[i].fTextSize); ScaleAbout(canvas, rec[i].fScale, rec[i].fScale, loc.x(), loc.y()); canvas->drawString(rec[i].fText, loc.x(), loc.y(), paint); } }
bool LayerAndroid::drawCanvas(SkCanvas* canvas, bool drawChildren, PaintStyle style) { if (!m_visible) return false; bool askScreenUpdate = false; { SkAutoCanvasRestore acr(canvas, true); SkRect r; r.set(m_clippingRect.x(), m_clippingRect.y(), m_clippingRect.x() + m_clippingRect.width(), m_clippingRect.y() + m_clippingRect.height()); canvas->clipRect(r); SkMatrix matrix; GLUtils::toSkMatrix(matrix, m_drawTransform); SkMatrix canvasMatrix = canvas->getTotalMatrix(); matrix.postConcat(canvasMatrix); canvas->setMatrix(matrix); onDraw(canvas, m_drawOpacity, 0, style); } if (!drawChildren) return false; // When the layer is dirty, the UI thread should be notified to redraw. askScreenUpdate |= drawChildrenCanvas(canvas, style); return askScreenUpdate; }
void SkAnimatedImage::onDraw(SkCanvas* canvas) { auto image = SkMakeImageFromRasterBitmap(fDisplayFrame.fBitmap, kNever_SkCopyPixelsMode); if (fSimple) { canvas->drawImage(image, 0, 0); return; } SkRect bounds = this->getBounds(); if (fPostProcess) { canvas->saveLayer(&bounds, nullptr); } { SkAutoCanvasRestore acr(canvas, fPostProcess); canvas->concat(fMatrix); SkPaint paint; paint.setFilterQuality(kLow_SkFilterQuality); canvas->drawImage(image, 0, 0, &paint); } if (fPostProcess) { canvas->drawPicture(fPostProcess); canvas->restore(); } }
void drawSet(SkCanvas* canvas, const SkBitmap& orig) { SkAutoCanvasRestore acr(canvas, true); drawLevels(canvas, orig, [](const SkPixmap& prev, const SkPixmap& curr) { SkBitmap bm; bm.installPixels(curr); return bm; }); const SkBitmapScaler::ResizeMethod methods[] = { SkBitmapScaler::RESIZE_BOX, SkBitmapScaler::RESIZE_TRIANGLE, SkBitmapScaler::RESIZE_LANCZOS3, SkBitmapScaler::RESIZE_HAMMING, SkBitmapScaler::RESIZE_MITCHELL, }; SkPixmap basePM; orig.lockPixels(); orig.peekPixels(&basePM); for (auto method : methods) { canvas->translate(orig.width()/2 + 8.0f, 0); drawLevels(canvas, orig, [basePM, method](const SkPixmap& prev, const SkPixmap& curr) { SkBitmap bm; SkBitmapScaler::Resize(&bm, prev, method, curr.width(), curr.height()); return bm; }); } }
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(); } }
void onDraw(SkCanvas* canvas) override { SkAutoCanvasRestore acr(canvas, false); SkPaint paint; paint.setAntiAlias(true); if (fInterp) { SkScalar values[5]; SkInterpolator::Result res = fInterp->timeToValues(fTime, values); fColor = floats_to_color(values); canvas->save(); canvas->rotate(values[4], fR.centerX(), fR.centerY()); switch (res) { case SkInterpolator::kFreezeEnd_Result: delete fInterp; fInterp = nullptr; break; default: break; } } paint.setColor(fColor); canvas->drawRect(fR, paint); }
virtual void onDraw(SkCanvas* canvas) { // this->drawSizeBounds(canvas, 0xFFCCCCCC); static SkImageFilter* (*gFilterProc[])() = { make0, make1, make2, make3, make4, make5, make6, make7 }; const SkRect bounds = SkRect::MakeWH(FILTER_WIDTH, FILTER_HEIGHT); const SkScalar dx = bounds.width() * 8 / 7; const SkScalar dy = bounds.height() * 8 / 7; canvas->translate(SkIntToScalar(8), SkIntToScalar(8)); for (int i = 0; i < (int)SK_ARRAY_COUNT(gFilterProc); ++i) { int ix = i % 4; int iy = i / 4; SkAutoCanvasRestore acr(canvas, true); canvas->translate(ix * dx, iy * dy); SkPaint p; p.setStyle(SkPaint::kStroke_Style); canvas->drawRect(bounds, p); SkPaint paint; paint.setImageFilter(gFilterProc[i]())->unref(); canvas->saveLayer(&bounds, &paint); draw0(canvas); } }
void drawHere(SkCanvas* canvas, SkFilterQuality filter, SkScalar dx, SkScalar dy) { SkCanvas* origCanvas = canvas; SkAutoCanvasRestore acr(canvas, true); SkISize size = SkISize::Make(fImage->width(), fImage->height()); SkAutoTUnref<SkSurface> surface; if (fShowFatBits) { // scale up so we don't clip rotations SkImageInfo info = SkImageInfo::MakeN32(fImage->width() * 2, fImage->height() * 2, kOpaque_SkAlphaType); surface.reset(make_surface(canvas, info)); canvas = surface->getCanvas(); canvas->drawColor(SK_ColorWHITE); size.set(info.width(), info.height()); } else { canvas->translate(SkScalarHalf(fCell.width() - fImage->width()), SkScalarHalf(fCell.height() - fImage->height())); } this->drawTheImage(canvas, size, filter, dx, dy); if (surface) { SkAutoTUnref<SkImage> orig(surface->newImageSnapshot()); SkAutoTUnref<SkImage> zoomed(zoom_up(orig)); origCanvas->drawImage(zoomed, SkScalarHalf(fCell.width() - zoomed->width()), SkScalarHalf(fCell.height() - zoomed->height())); } }
void drawGlyphs(SkCanvas* canvas) override { for (int i = 0; i < kNumPaths; ++i) { SkAutoCanvasRestore acr(canvas, true); canvas->concat(fFrontMatrices[i]); canvas->drawPath(fGlyphs[i].fPath, fGlyphs[i].fPaint); } }
virtual void onDraw(SkCanvas* canvas) { SkBlurDrawLooper* shadowLoopers[5]; shadowLoopers[0] = new SkBlurDrawLooper (SkIntToScalar(10), SkIntToScalar(5), SkIntToScalar(10), 0xFF0000FF, SkBlurDrawLooper::kIgnoreTransform_BlurFlag | SkBlurDrawLooper::kOverrideColor_BlurFlag | SkBlurDrawLooper::kHighQuality_BlurFlag ); SkAutoUnref aurL0(shadowLoopers[0]); shadowLoopers[1] = new SkBlurDrawLooper (SkIntToScalar(10), SkIntToScalar(5), SkIntToScalar(10), 0xFF0000FF, SkBlurDrawLooper::kIgnoreTransform_BlurFlag | SkBlurDrawLooper::kOverrideColor_BlurFlag ); SkAutoUnref aurL1(shadowLoopers[1]); shadowLoopers[2] = new SkBlurDrawLooper (SkIntToScalar(5), SkIntToScalar(5), SkIntToScalar(10), 0xFF000000, SkBlurDrawLooper::kIgnoreTransform_BlurFlag | SkBlurDrawLooper::kHighQuality_BlurFlag ); SkAutoUnref aurL2(shadowLoopers[2]); shadowLoopers[3] = new SkBlurDrawLooper (SkIntToScalar(5), SkIntToScalar(-5), SkIntToScalar(-10), 0x7FFF0000, SkBlurDrawLooper::kIgnoreTransform_BlurFlag | SkBlurDrawLooper::kOverrideColor_BlurFlag | SkBlurDrawLooper::kHighQuality_BlurFlag ); SkAutoUnref aurL3(shadowLoopers[3]); shadowLoopers[4] = new SkBlurDrawLooper (SkIntToScalar(0), SkIntToScalar(5), SkIntToScalar(5), 0xFF000000, SkBlurDrawLooper::kIgnoreTransform_BlurFlag | SkBlurDrawLooper::kOverrideColor_BlurFlag | SkBlurDrawLooper::kHighQuality_BlurFlag ); SkAutoUnref aurL4(shadowLoopers[4]); static const struct { SkColor fColor; SkScalar fStrokeWidth; } gRec[] = { { SK_ColorRED, -SK_Scalar1 }, { SK_ColorGREEN, SkIntToScalar(4) }, }; SkPaint paint; paint.setAntiAlias(true); for (size_t i = 0; i < SK_ARRAY_COUNT(shadowLoopers); ++i) { SkAutoCanvasRestore acr(canvas, true); paint.setLooper(shadowLoopers[i]); canvas->translate(SkIntToScalar(i*40), SkIntToScalar(0)); setup(&paint, gRec[0].fColor, gRec[0].fStrokeWidth); canvas->drawRect(fRect, paint); canvas->translate(SkIntToScalar(0), SkIntToScalar(40)); setup(&paint, gRec[1].fColor, gRec[1].fStrokeWidth); canvas->drawPath(fCirclePath, paint); } }
void yieldLocksForPreparedTransactions(OperationContext* opCtx) { // Create a new opCtx because we need an empty locker to refresh the locks. auto newClient = opCtx->getServiceContext()->makeClient("prepared-txns-yield-locks"); AlternativeClientRegion acr(newClient); auto newOpCtx = cc().makeOperationContext(); // Scan the sessions again to get the list of all sessions with prepared transaction // to yield their locks. SessionKiller::Matcher matcherAllSessions( KillAllSessionsByPatternSet{makeKillAllSessionsByPattern(newOpCtx.get())}); killSessionsAction( newOpCtx.get(), matcherAllSessions, [](const ObservableSession& session) { return TransactionParticipant::get(session.get())->transactionIsPrepared(); }, [](OperationContext* killerOpCtx, const SessionToKill& session) { auto const txnParticipant = TransactionParticipant::get(session.get()); // Yield locks for prepared transactions. // When scanning and killing operations, all prepared transactions are included in the // list. Even though new sessions may be created after the scan, none of them can become // prepared during stepdown, since the RSTL has been enqueued, preventing any new // writes. if (txnParticipant->transactionIsPrepared()) { LOG(3) << "Yielding locks of prepared transaction. SessionId: " << session.getSessionId().getId() << " TxnNumber: " << txnParticipant->getActiveTxnNumber(); txnParticipant->refreshLocksForPreparedTransaction(killerOpCtx, true); } }); }
bool Surface::paint(SkCanvas* canvas) { if (singleLayer()) { getFirstLayer()->contentDraw(canvas, Layer::UnmergedLayers); // TODO: double buffer by disabling SurfaceCollection swaps and position // updates until painting complete // In single surface mode, draw layer content onto the base layer if (isBase() && getFirstLayer()->countChildren() && getFirstLayer()->state()->isSingleSurfaceRenderingMode()) { for (int i = 0; i < getFirstLayer()->countChildren(); i++) getFirstLayer()->getChild(i)->drawCanvas(canvas, true, Layer::FlattenedLayers); } } else { SkAutoCanvasRestore acr(canvas, true); SkMatrix matrix; GLUtils::toSkMatrix(matrix, m_drawTransform); SkMatrix inverse; inverse.reset(); matrix.invert(&inverse); SkMatrix canvasMatrix = canvas->getTotalMatrix(); inverse.postConcat(canvasMatrix); canvas->setMatrix(inverse); for (unsigned int i=0; i<m_layers.size(); i++) m_layers[i]->drawCanvas(canvas, false, Layer::MergedLayers); } return true; }
void SkPicturePlayback::draw(SkCanvas* canvas, SkPicture::AbortCallback* callback, const SkReadBuffer* buffer) { AutoResetOpID aroi(this); SkASSERT(0 == fCurOffset); SkAutoTDelete<SkReadBuffer> reader; if (buffer) { reader.reset(buffer->clone(fPictureData->opData()->bytes(), fPictureData->opData()->size())); } else { reader.reset(new SkReadBuffer(fPictureData->opData()->bytes(), fPictureData->opData()->size())); } // Record this, so we can concat w/ it if we encounter a setMatrix() SkMatrix initialMatrix = canvas->getTotalMatrix(); SkAutoCanvasRestore acr(canvas, false); while (!reader->eof()) { if (callback && callback->abort()) { return; } fCurOffset = reader->offset(); uint32_t size; DrawType op = ReadOpAndSize(reader, &size); this->handleOp(reader, op, size, canvas, initialMatrix); } }
static void test_discarded_image(skiatest::Reporter* reporter, const SkMatrix& transform, sk_sp<SkImage> (*buildImage)()) { auto surface(SkSurface::MakeRasterN32Premul(10, 10)); SkCanvas* canvas = surface->getCanvas(); // SkBitmapCache is global, so other threads could be evicting our bitmaps. Loop a few times // to mitigate this risk. const unsigned kRepeatCount = 42; for (unsigned i = 0; i < kRepeatCount; ++i) { SkAutoCanvasRestore acr(canvas, true); sk_sp<SkImage> image(buildImage()); // always use high quality to ensure caching when scaled SkPaint paint; paint.setFilterQuality(kHigh_SkFilterQuality); // draw the image (with a transform, to tickle different code paths) to ensure // any associated resources get cached canvas->concat(transform); canvas->drawImage(image, 0, 0, &paint); const auto desc = SkBitmapCacheDesc::Make(image.get()); // delete the image image.reset(nullptr); // all resources should have been purged SkBitmap result; REPORTER_ASSERT(reporter, !SkBitmapCache::Find(desc, &result)); } }
void SkPicturePlayback::draw(SkCanvas* canvas, SkPicture::AbortCallback* callback, SkReadBuffer* buffer) { AutoResetOpID aroi(this); SkASSERT(0 == fCurOffset); SkReadBuffer reader(fPictureData->opData()->bytes(), fPictureData->opData()->size()); // Record this, so we can concat w/ it if we encounter a setMatrix() SkMatrix initialMatrix = canvas->getTotalMatrix(); SkAutoCanvasRestore acr(canvas, false); while (!reader.eof()) { if (callback && callback->abort()) { return; } fCurOffset = reader.offset(); uint32_t size; DrawType op = ReadOpAndSize(&reader, &size); if (!reader.validate(op > UNUSED && op <= LAST_DRAWTYPE_ENUM)) { return; } this->handleOp(&reader, op, size, canvas, initialMatrix); } // need to propagate invalid state to the parent reader if (buffer) { buffer->validate(reader.isValid()); } }
static SkScalar draw_row(SkCanvas* canvas, const SkBitmap& bm) { //此为canvas的save操作 //在超过了作用域之后,会自动调用restore函数 SkAutoCanvasRestore acr(canvas, true); SkPaint paint; SkScalar x = 0; const int scale = 64; //开启抗锯齿 : 见百度百科 paint.setAntiAlias(true); //绘制行首文字 : 见结果图每行行头文字 const char* name = gConfigNames[bm.config()]; canvas->drawText(name, strlen(name), x, SkIntToScalar(bm.height())*scale*5/8, paint); //平移到(48, 0)???为何是48--牛群 canvas->translate(SkIntToScalar(192), 0); //缩放 : x,y轴乘各乘以一个系数, 进行放大或缩小.: 此处因为4个像素很小,所以进行了放大. canvas->scale(SkIntToScalar(scale), SkIntToScalar(scale)); /*逐个画每行的6个方块*/ //画前三个, 正常的, 滤镜的, 滤镜+防抖动的. x += draw_set(canvas, bm, 0, &paint); //画笔复原 paint.reset(); /*开启透明, 画后三个, 正常的, 滤镜的, 滤镜+防抖动的. */ paint.setAlpha(0x80); draw_set(canvas, bm, x, &paint); return x * scale / 3; }
void drawSets(SkCanvas* canvas) const { SkAutoCanvasRestore acr(canvas, true); const SkFilterQuality filters[] = { kNone_SkFilterQuality, kLow_SkFilterQuality, kMedium_SkFilterQuality, kHigh_SkFilterQuality }; const bool AAs[] = { false, true }; SkPaint paint; for (int i = 0; i < fSets.count(); ++i) { auto& set = fSets[i]; SkPoint lastPt; for (size_t j = 0; j < SK_ARRAY_COUNT(AAs); ++j) { paint.setAntiAlias(AAs[j]); for (size_t k = 0; k < SK_ARRAY_COUNT(filters); ++k) { paint.setFilterQuality(filters[k]); lastPt = drawSet(canvas, set, paint); canvas->translate((kSegLen + 4) * set.fVector.y(), (kSegLen + 4) * set.fVector.x()); } } canvas->translate(lastPt.x() + kSegLen, - SkIntToScalar(kSegLen + 4) * SK_ARRAY_COUNT(filters) * SK_ARRAY_COUNT(AAs)); } }
virtual void onDrawContent(SkCanvas* canvas) { if (fData.count() <= 0) return; SkAutoCanvasRestore acr(canvas, true); canvas->translate(fStateOffset, 0); int lastFrameBound = fFrameBounds[fAtomsToRead]; int toBeRead = fAtomBounds[fAtomsToRead] - lastFrameBound; int firstChunk = (fAtomsToRead > 0) ? fAtomBounds[fAtomsToRead - 1] - lastFrameBound: 0; if (toBeRead > 0) { SkDumpCanvas* dumpCanvas = new SkDumpCanvas(fDumper); SkGPipeReader* dumpReader = new SkGPipeReader(dumpCanvas); SkGPipeReader* reader = new SkGPipeReader(canvas); fDumper->disable(); int offset = 0; size_t bytesRead; SkGPipeReader::Status s; //Read the first chunk if (offset < firstChunk && firstChunk < toBeRead) { s = dumpReader->playback(fData.begin() + offset, firstChunk - offset); SkASSERT(SkGPipeReader::kError_Status != s); s = reader->playback(fData.begin() + offset, firstChunk - offset, 0, &bytesRead); SkASSERT(SkGPipeReader::kError_Status != s); if (SkGPipeReader::kDone_Status == s){ delete dumpReader; delete dumpCanvas; dumpCanvas = new SkDumpCanvas(fDumper); dumpReader = new SkGPipeReader(dumpCanvas); delete reader; reader = new SkGPipeReader(canvas); } offset += bytesRead; } SkASSERT(offset == firstChunk); //Then read the current atom fDumper->enable(); s = dumpReader->playback(fData.begin() + offset, toBeRead - offset, SkGPipeReader::kReadAtom_PlaybackFlag); SkASSERT(SkGPipeReader::kError_Status != s); s = reader->playback(fData.begin() + offset, toBeRead - offset, SkGPipeReader::kReadAtom_PlaybackFlag, &bytesRead); SkASSERT(SkGPipeReader::kError_Status != s); delete reader; delete dumpReader; delete dumpCanvas; if (fDisplayClip) { SkPaint p; p.setColor(0x440000AA); SkPath path; canvas->getTotalClip().getBoundaryPath(&path); canvas->drawPath(path, p); } } }
virtual void onDraw(SkCanvas* originalCanvas) { SkISize size = this->getISize(); SkBitmap bitmap; bitmap.allocN32Pixels(size.width(), size.height()); SkDeviceProperties properties = SkDeviceProperties::Make( SkDeviceProperties::Geometry::Make(SkDeviceProperties::Geometry::kVertical_Orientation, SkDeviceProperties::Geometry::kBGR_Layout), SK_Scalar1); SkBitmapDevice device(bitmap, properties); SkCanvas canvas(&device); canvas.drawColor(SK_ColorWHITE); 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); sk_tool_utils::set_portable_typeface(&paint, "Times Roman", SkTypeface::kNormal); const char* text = "Hamburgefons ooo mmm"; const size_t textLen = strlen(text); for (int j = 0; j < 2; ++j) { for (int i = 0; i < 6; ++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); } originalCanvas->drawBitmap(bitmap, 0, 0); }
static void draw_cell(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& mat, SkScalar dx, SkFilterQuality lvl) { SkPaint paint; paint.setFilterQuality(lvl); SkAutoCanvasRestore acr(canvas, true); canvas->translate(dx, 0); canvas->concat(mat); canvas->drawBitmap(bm, 0, 0, &paint); }
virtual void drawGlyphs(SkCanvas* canvas) { for (Glyph& glyph : fGlyphs) { SkAutoCanvasRestore acr(canvas, true); canvas->translate(glyph.fPosition.x(), glyph.fPosition.y()); canvas->scale(glyph.fZoom, glyph.fZoom); canvas->rotate(glyph.fSpin); canvas->translate(-glyph.fMidpt.x(), -glyph.fMidpt.y()); canvas->drawPath(glyph.fPath, glyph.fPaint); } }
void drawSet(SkCanvas* canvas, SkPaint* paint) { SkAutoCanvasRestore acr(canvas, true); for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) { paint->setStyle(gRec[i].fStyle); paint->setStrokeJoin(gRec[i].fJoin); paint->setStrokeWidth(SkIntToScalar(gRec[i].fStrokeWidth)); canvas->drawPath(fPath, *paint); canvas->translate(fWidth * 5 / 4, 0); } }
static void drawJpeg(SkCanvas* canvas, const SkISize& size) { SkAutoDataUnref data(fileToData("/Users/mike/Downloads/skia.google.jpeg")); SkImage* image = SkImage::NewEncodedData(data); if (image) { SkAutoCanvasRestore acr(canvas, true); canvas->scale(size.width() * 1.0f / image->width(), size.height() * 1.0f / image->height()); image->draw(canvas,0, 0, NULL); image->unref(); } }
void SkDrawable::draw(SkCanvas* canvas, const SkMatrix* matrix) { SkAutoCanvasRestore acr(canvas, true); if (matrix) { canvas->concat(*matrix); } this->onDraw(canvas); if (false) { draw_bbox(canvas, this->getBounds()); } }
void SkLayer::draw(SkCanvas* canvas, SkScalar opacity) { #if 0 SkString str1, str2; // this->getMatrix().toDumpString(&str1); // this->getChildrenMatrix().toDumpString(&str2); SkDebugf("--- drawlayer %p opacity %g size [%g %g] pos [%g %g] matrix %s children %s\n", this, opacity * this->getOpacity(), m_size.width(), m_size.height(), m_position.fX, m_position.fY, str1.c_str(), str2.c_str()); #endif opacity = SkScalarMul(opacity, this->getOpacity()); if (opacity <= 0) { // SkDebugf("---- abort drawing %p opacity %g\n", this, opacity); return; } SkAutoCanvasRestore acr(canvas, true); // apply our local transform { SkMatrix tmp; this->getLocalTransform(&tmp); if (this->isInheritFromRootTransform()) { // should we also apply the root's childrenMatrix? canvas->setMatrix(getRootLayer()->getMatrix()); } canvas->concat(tmp); } this->onDraw(canvas, opacity); #ifdef DEBUG_DRAW_LAYER_BOUNDS { SkRect r = SkRect::MakeSize(this->getSize()); SkPaint p; p.setAntiAlias(true); p.setStyle(SkPaint::kStroke_Style); p.setStrokeWidth(SkIntToScalar(2)); p.setColor(0xFFFF44DD); canvas->drawRect(r, p); canvas->drawLine(r.fLeft, r.fTop, r.fRight, r.fBottom, p); canvas->drawLine(r.fLeft, r.fBottom, r.fRight, r.fTop, p); } #endif int count = this->countChildren(); if (count > 0) { canvas->concat(this->getChildrenMatrix()); for (int i = 0; i < count; i++) { this->getChild(i)->draw(canvas, opacity); } } }
bool SkWindow::update(SkIRect* updateArea) { if (!fDirtyRgn.isEmpty()) { SkBitmap bm = this->getBitmap(); #if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN) char* buffer = (char*)GXBeginDraw(); SkASSERT(buffer); RECT rect; GetWindowRect((HWND)((SkOSWindow*)this)->getHWND(), &rect); buffer += rect.top * gDisplayProps.cbyPitch + rect.left * gDisplayProps.cbxPitch; bm.setPixels(buffer); #endif SkAutoTUnref<SkSurface> surface(this->createSurface()); SkCanvas* canvas = surface->getCanvas(); canvas->clipRegion(fDirtyRgn); if (updateArea) *updateArea = fDirtyRgn.getBounds(); SkAutoCanvasRestore acr(canvas, true); canvas->concat(fMatrix); // empty this now, so we can correctly record any inval calls that // might be made during the draw call. fDirtyRgn.setEmpty(); #ifdef SK_SIMULATE_FAILED_MALLOC gEnableControlledThrow = true; #endif #ifdef SK_BUILD_FOR_WIN32 //try { this->draw(canvas); //} //catch (...) { //} #else this->draw(canvas); #endif #ifdef SK_SIMULATE_FAILED_MALLOC gEnableControlledThrow = false; #endif #if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN) GXEndDraw(); #endif return true; } return false; }
void testImage(SkCanvas* canvas, SkImage* image) { SkAutoCanvasRestore acr(canvas, true); canvas->drawImage(image, 0, 0); canvas->translate(0, 120); const SkShader::TileMode tile = SkShader::kRepeat_TileMode; const SkMatrix localM = SkMatrix::MakeTrans(-50, -50); SkPaint paint; paint.setShader(image->makeShader(tile, tile, &localM)); paint.setAntiAlias(true); canvas->drawCircle(50, 50, 50, paint); }
void MaskEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const { SkAutoCanvasRestore acr(canvas, false); canvas->saveLayer(this->bounds(), nullptr); // Note: the paint overrides in ctx don't apply to the mask. fMaskNode->render(canvas); SkPaint p; p.setBlendMode(fMaskMode == Mode::kNormal ? SkBlendMode::kSrcIn : SkBlendMode::kSrcOut); canvas->saveLayer(this->bounds(), &p); this->INHERITED::onRender(canvas, ctx); }
Status CollectionBulkLoaderImpl::_runTaskReleaseResourcesOnFailure(const F& task) noexcept { AlternativeClientRegion acr(_client); auto guard = makeGuard([this] { _releaseResources(); }); try { const auto status = task(); if (status.isOK()) { guard.dismiss(); } return status; } catch (...) { std::terminate(); } }