skia2/tools/android/SkAndroidSDKCanvas.cpp

358 lines
13 KiB
C++

/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkAndroidSDKCanvas.h"
#include "SkColorFilter.h"
#include "SkDrawLooper.h"
#include "SkPaint.h"
#include "SkPathEffect.h"
#include "SkShader.h"
#include "SkSurface.h"
#include "SkTLazy.h"
namespace {
/** Discard SkShaders not exposed by the Android Java API. */
void CheckShader(SkPaint* paint) {
SkShader* shader = paint->getShader();
if (!shader) {
return;
}
if (shader->isABitmap()) {
return;
}
if (shader->asACompose(nullptr)) {
return;
}
SkShader::GradientType gtype = shader->asAGradient(nullptr);
if (gtype == SkShader::kLinear_GradientType ||
gtype == SkShader::kRadial_GradientType ||
gtype == SkShader::kSweep_GradientType) {
return;
}
paint->setShader(nullptr);
}
void Filter(SkPaint* paint) {
uint32_t flags = paint->getFlags();
flags &= ~SkPaint::kLCDRenderText_Flag;
paint->setFlags(flags);
// Android doesn't support Xfermodes above kLighten_Mode
SkXfermode::Mode mode;
SkXfermode::AsMode(paint->getXfermode(), &mode);
if (mode > SkXfermode::kLighten_Mode) {
paint->setXfermode(nullptr);
}
// Force bilinear scaling or none
if (paint->getFilterQuality() != kNone_SkFilterQuality) {
paint->setFilterQuality(kLow_SkFilterQuality);
}
CheckShader(paint);
// Android SDK only supports mode & matrix color filters
// (and, again, no modes above kLighten_Mode).
SkColorFilter* cf = paint->getColorFilter();
if (cf) {
SkColor color;
SkXfermode::Mode mode;
SkScalar srcColorMatrix[20];
bool isMode = cf->asColorMode(&color, &mode);
if (isMode && mode > SkXfermode::kLighten_Mode) {
paint->setColorFilter(
SkColorFilter::MakeModeFilter(color, SkXfermode::kSrcOver_Mode));
} else if (!isMode && !cf->asColorMatrix(srcColorMatrix)) {
paint->setColorFilter(nullptr);
}
}
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
SkPathEffect* pe = paint->getPathEffect();
if (pe && !pe->exposedInAndroidJavaAPI()) {
paint->setPathEffect(nullptr);
}
#endif
// TODO: Android doesn't support all the flags that can be passed to
// blur filters; we need plumbing to get them out.
paint->setImageFilter(nullptr);
paint->setLooper(nullptr);
};
} // namespace
#define FILTER(p) \
SkPaint filteredPaint(p); \
Filter(&filteredPaint);
#define FILTER_PTR(p) \
SkTLazy<SkPaint> lazyPaint; \
SkPaint* filteredPaint = (SkPaint*) p; \
if (p) { \
filteredPaint = lazyPaint.set(*p); \
Filter(filteredPaint); \
}
SkAndroidSDKCanvas::SkAndroidSDKCanvas() : fProxyTarget(nullptr) { }
void SkAndroidSDKCanvas::reset(SkCanvas* newTarget) { fProxyTarget = newTarget; }
void SkAndroidSDKCanvas::onDrawPaint(const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawPaint(filteredPaint);
}
void SkAndroidSDKCanvas::onDrawPoints(PointMode pMode,
size_t count,
const SkPoint pts[],
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawPoints(pMode, count, pts, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawOval(const SkRect& r, const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawOval(r, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawRect(const SkRect& r, const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawRect(r, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawRRect(const SkRRect& r, const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawRRect(r, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawPath(path, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawBitmap(const SkBitmap& bitmap,
SkScalar left,
SkScalar top,
const SkPaint* paint) {
FILTER_PTR(paint);
fProxyTarget->drawBitmap(bitmap, left, top, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawBitmapRect(const SkBitmap& bitmap,
const SkRect* src,
const SkRect& dst,
const SkPaint* paint,
SkCanvas::SrcRectConstraint constraint) {
FILTER_PTR(paint);
fProxyTarget->legacy_drawBitmapRect(bitmap, src, dst, filteredPaint, constraint);
}
void SkAndroidSDKCanvas::onDrawBitmapNine(const SkBitmap& bitmap,
const SkIRect& center,
const SkRect& dst,
const SkPaint* paint) {
FILTER_PTR(paint);
fProxyTarget->drawBitmapNine(bitmap, center, dst, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawVertices(VertexMode vMode,
int vertexCount,
const SkPoint vertices[],
const SkPoint texs[], const SkColor colors[], SkXfermode* xMode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawVertices(vMode, vertexCount, vertices, texs, colors,
xMode, indices, indexCount, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawDRRect(const SkRRect& outer,
const SkRRect& inner,
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawDRRect(outer, inner, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawText(const void* text,
size_t byteLength,
SkScalar x,
SkScalar y,
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawText(text, byteLength, x, y, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawPosText(const void* text,
size_t byteLength,
const SkPoint pos[],
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawPosText(text, byteLength, pos, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawPosTextH(const void* text,
size_t byteLength,
const SkScalar xpos[],
SkScalar constY,
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawPosTextH(text, byteLength, xpos, constY, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawTextOnPath(const void* text,
size_t byteLength,
const SkPath& path,
const SkMatrix* matrix,
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawTextOnPath(text, byteLength, path, matrix, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawTextBlob(const SkTextBlob* blob,
SkScalar x,
SkScalar y,
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawTextBlob(blob, x, y, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawPatch(const SkPoint cubics[12],
const SkColor colors[4],
const SkPoint texCoords[4],
SkXfermode* xmode,
const SkPaint& paint) {
FILTER(paint);
fProxyTarget->drawPatch(cubics, colors, texCoords, xmode, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawImage(const SkImage* image,
SkScalar x,
SkScalar y,
const SkPaint* paint) {
FILTER_PTR(paint);
fProxyTarget->drawImage(image, x, y, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawImageRect(const SkImage* image,
const SkRect* in,
const SkRect& out,
const SkPaint* paint,
SrcRectConstraint constraint) {
FILTER_PTR(paint);
fProxyTarget->legacy_drawImageRect(image, in, out, filteredPaint, constraint);
}
void SkAndroidSDKCanvas::onDrawPicture(const SkPicture* picture,
const SkMatrix* matrix,
const SkPaint* paint) {
FILTER_PTR(paint);
fProxyTarget->drawPicture(picture, matrix, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawAtlas(const SkImage* atlas,
const SkRSXform xform[],
const SkRect tex[],
const SkColor colors[],
int count,
SkXfermode::Mode mode,
const SkRect* cullRect,
const SkPaint* paint) {
FILTER_PTR(paint);
fProxyTarget->drawAtlas(atlas, xform, tex, colors, count, mode, cullRect,
filteredPaint);
}
void SkAndroidSDKCanvas::onDrawImageNine(const SkImage* image,
const SkIRect& center,
const SkRect& dst,
const SkPaint* paint) {
FILTER_PTR(paint);
fProxyTarget->drawImageNine(image, center, dst, filteredPaint);
}
void SkAndroidSDKCanvas::onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) {
fProxyTarget->drawDrawable(drawable, matrix);
}
SkISize SkAndroidSDKCanvas::getBaseLayerSize() const {
return fProxyTarget->getBaseLayerSize();
}
bool SkAndroidSDKCanvas::getClipBounds(SkRect* rect) const {
return fProxyTarget->getClipBounds(rect);
}
bool SkAndroidSDKCanvas::getClipDeviceBounds(SkIRect* rect) const {
return fProxyTarget->getClipDeviceBounds(rect);
}
bool SkAndroidSDKCanvas::isClipEmpty() const { return fProxyTarget->isClipEmpty(); }
bool SkAndroidSDKCanvas::isClipRect() const { return fProxyTarget->isClipRect(); }
sk_sp<SkSurface> SkAndroidSDKCanvas::onNewSurface(const SkImageInfo& info,
const SkSurfaceProps& props) {
return fProxyTarget->makeSurface(info, &props);
}
bool SkAndroidSDKCanvas::onPeekPixels(SkPixmap* pmap) {
return fProxyTarget->peekPixels(pmap);
}
bool SkAndroidSDKCanvas::onAccessTopLayerPixels(SkPixmap* pmap) {
SkASSERT(pmap);
SkImageInfo info;
size_t rowBytes;
const void* addr = fProxyTarget->accessTopLayerPixels(&info, &rowBytes, nullptr);
if (addr) {
pmap->reset(info, addr, rowBytes);
return true;
}
return false;
}
void SkAndroidSDKCanvas::willSave() {
fProxyTarget->save();
}
SkCanvas::SaveLayerStrategy SkAndroidSDKCanvas::getSaveLayerStrategy(const SaveLayerRec& rec) {
fProxyTarget->saveLayer(rec);
return SkCanvas::kNoLayer_SaveLayerStrategy;
}
void SkAndroidSDKCanvas::willRestore() {
fProxyTarget->restore();
}
void SkAndroidSDKCanvas::didRestore() { }
void SkAndroidSDKCanvas::didConcat(const SkMatrix& m) {
fProxyTarget->concat(m);
}
void SkAndroidSDKCanvas::didSetMatrix(const SkMatrix& m) {
fProxyTarget->setMatrix(m);
}
void SkAndroidSDKCanvas::onClipRect(const SkRect& rect,
SkRegion::Op op,
ClipEdgeStyle style) {
fProxyTarget->clipRect(rect, op, style);
}
void SkAndroidSDKCanvas::onClipRRect(const SkRRect& rrect,
SkRegion::Op op,
ClipEdgeStyle style) {
fProxyTarget->clipRRect(rrect, op, style);
}
void SkAndroidSDKCanvas::onClipPath(const SkPath& path,
SkRegion::Op op,
ClipEdgeStyle style) {
fProxyTarget->clipPath(path, op, style);
}
void SkAndroidSDKCanvas::onClipRegion(const SkRegion& region, SkRegion::Op op) {
fProxyTarget->clipRegion(region, op);
}
void SkAndroidSDKCanvas::onDiscard() { fProxyTarget->discard(); }