| /* |
| * Copyright 2014 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkCanvas.h" |
| #include "SkData.h" |
| #include "SkImage.h" |
| #include "SkMaskFilter.h" |
| #include "SkMatrix.h" |
| #include "SkPaint.h" |
| #include "SkPath.h" |
| #include "SkPictureRecorder.h" |
| #include "SkSurface.h" |
| |
| #include "sk_canvas.h" |
| #include "sk_data.h" |
| #include "sk_image.h" |
| #include "sk_paint.h" |
| #include "sk_path.h" |
| #include "sk_surface.h" |
| #include "sk_types_priv.h" |
| |
| const struct { |
| sk_colortype_t fC; |
| SkColorType fSK; |
| } gColorTypeMap[] = { |
| { UNKNOWN_SK_COLORTYPE, kUnknown_SkColorType }, |
| { RGBA_8888_SK_COLORTYPE, kRGBA_8888_SkColorType }, |
| { BGRA_8888_SK_COLORTYPE, kBGRA_8888_SkColorType }, |
| { ALPHA_8_SK_COLORTYPE, kAlpha_8_SkColorType }, |
| }; |
| |
| const struct { |
| sk_alphatype_t fC; |
| SkAlphaType fSK; |
| } gAlphaTypeMap[] = { |
| { OPAQUE_SK_ALPHATYPE, kOpaque_SkAlphaType }, |
| { PREMUL_SK_ALPHATYPE, kPremul_SkAlphaType }, |
| { UNPREMUL_SK_ALPHATYPE, kUnpremul_SkAlphaType }, |
| }; |
| |
| static bool from_c_colortype(sk_colortype_t cCT, SkColorType* skCT) { |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypeMap); ++i) { |
| if (gColorTypeMap[i].fC == cCT) { |
| if (skCT) { |
| *skCT = gColorTypeMap[i].fSK; |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static bool to_c_colortype(SkColorType skCT, sk_colortype_t* cCT) { |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypeMap); ++i) { |
| if (gColorTypeMap[i].fSK == skCT) { |
| if (cCT) { |
| *cCT = gColorTypeMap[i].fC; |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static bool from_c_alphatype(sk_alphatype_t cAT, SkAlphaType* skAT) { |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gAlphaTypeMap); ++i) { |
| if (gAlphaTypeMap[i].fC == cAT) { |
| if (skAT) { |
| *skAT = gAlphaTypeMap[i].fSK; |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static bool from_c_info(const sk_imageinfo_t& cinfo, SkImageInfo* info) { |
| SkColorType ct; |
| SkAlphaType at; |
| |
| if (!from_c_colortype(cinfo.colorType, &ct)) { |
| // optionally report error to client? |
| return false; |
| } |
| if (!from_c_alphatype(cinfo.alphaType, &at)) { |
| // optionally report error to client? |
| return false; |
| } |
| if (info) { |
| *info = SkImageInfo::Make(cinfo.width, cinfo.height, ct, at); |
| } |
| return true; |
| } |
| |
| const struct { |
| sk_pixelgeometry_t fC; |
| SkPixelGeometry fSK; |
| } gPixelGeometryMap[] = { |
| { UNKNOWN_SK_PIXELGEOMETRY, kUnknown_SkPixelGeometry }, |
| { RGB_H_SK_PIXELGEOMETRY, kRGB_H_SkPixelGeometry }, |
| { BGR_H_SK_PIXELGEOMETRY, kBGR_H_SkPixelGeometry }, |
| { RGB_V_SK_PIXELGEOMETRY, kRGB_V_SkPixelGeometry }, |
| { BGR_V_SK_PIXELGEOMETRY, kBGR_V_SkPixelGeometry }, |
| }; |
| |
| |
| static bool from_c_pixelgeometry(sk_pixelgeometry_t cGeom, SkPixelGeometry* skGeom) { |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gPixelGeometryMap); ++i) { |
| if (gPixelGeometryMap[i].fC == cGeom) { |
| if (skGeom) { |
| *skGeom = gPixelGeometryMap[i].fSK; |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static void from_c_matrix(const sk_matrix_t* cmatrix, SkMatrix* matrix) { |
| matrix->setAll(cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2], |
| cmatrix->mat[3], cmatrix->mat[4], cmatrix->mat[5], |
| cmatrix->mat[6], cmatrix->mat[7], cmatrix->mat[8]); |
| } |
| |
| const struct { |
| sk_path_direction_t fC; |
| SkPath::Direction fSk; |
| } gPathDirMap[] = { |
| { CW_SK_PATH_DIRECTION, SkPath::kCW_Direction }, |
| { CCW_SK_PATH_DIRECTION, SkPath::kCCW_Direction }, |
| }; |
| |
| static bool from_c_path_direction(sk_path_direction_t cdir, SkPath::Direction* dir) { |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gPathDirMap); ++i) { |
| if (gPathDirMap[i].fC == cdir) { |
| if (dir) { |
| *dir = gPathDirMap[i].fSk; |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static SkData* AsData(const sk_data_t* cdata) { |
| return reinterpret_cast<SkData*>(const_cast<sk_data_t*>(cdata)); |
| } |
| |
| static sk_data_t* ToData(SkData* data) { |
| return reinterpret_cast<sk_data_t*>(data); |
| } |
| |
| static sk_rect_t ToRect(const SkRect& rect) { |
| return reinterpret_cast<const sk_rect_t&>(rect); |
| } |
| |
| static const SkRect& AsRect(const sk_rect_t& crect) { |
| return reinterpret_cast<const SkRect&>(crect); |
| } |
| |
| static const SkPath& AsPath(const sk_path_t& cpath) { |
| return reinterpret_cast<const SkPath&>(cpath); |
| } |
| |
| static SkPath* as_path(sk_path_t* cpath) { |
| return reinterpret_cast<SkPath*>(cpath); |
| } |
| |
| static const SkImage* AsImage(const sk_image_t* cimage) { |
| return reinterpret_cast<const SkImage*>(cimage); |
| } |
| |
| static sk_image_t* ToImage(SkImage* cimage) { |
| return reinterpret_cast<sk_image_t*>(cimage); |
| } |
| |
| static sk_canvas_t* ToCanvas(SkCanvas* canvas) { |
| return reinterpret_cast<sk_canvas_t*>(canvas); |
| } |
| |
| static SkCanvas* AsCanvas(sk_canvas_t* ccanvas) { |
| return reinterpret_cast<SkCanvas*>(ccanvas); |
| } |
| |
| static SkPictureRecorder* AsPictureRecorder(sk_picture_recorder_t* crec) { |
| return reinterpret_cast<SkPictureRecorder*>(crec); |
| } |
| |
| static sk_picture_recorder_t* ToPictureRecorder(SkPictureRecorder* rec) { |
| return reinterpret_cast<sk_picture_recorder_t*>(rec); |
| } |
| |
| static const SkPicture* AsPicture(const sk_picture_t* cpic) { |
| return reinterpret_cast<const SkPicture*>(cpic); |
| } |
| |
| static SkPicture* AsPicture(sk_picture_t* cpic) { |
| return reinterpret_cast<SkPicture*>(cpic); |
| } |
| |
| static sk_picture_t* ToPicture(SkPicture* pic) { |
| return reinterpret_cast<sk_picture_t*>(pic); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sk_colortype_t sk_colortype_get_default_8888() { |
| sk_colortype_t ct; |
| if (!to_c_colortype(kN32_SkColorType, &ct)) { |
| ct = UNKNOWN_SK_COLORTYPE; |
| } |
| return ct; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sk_image_t* sk_image_new_raster_copy(const sk_imageinfo_t* cinfo, const void* pixels, |
| size_t rowBytes) { |
| SkImageInfo info; |
| if (!from_c_info(*cinfo, &info)) { |
| return NULL; |
| } |
| return (sk_image_t*)SkImage::NewRasterCopy(info, pixels, rowBytes); |
| } |
| |
| sk_image_t* sk_image_new_from_encoded(const sk_data_t* cdata, const sk_irect_t* subset) { |
| return ToImage(SkImage::NewFromEncoded(AsData(cdata), |
| reinterpret_cast<const SkIRect*>(subset))); |
| } |
| |
| sk_data_t* sk_image_encode(const sk_image_t* cimage) { |
| return ToData(AsImage(cimage)->encode()); |
| } |
| |
| void sk_image_ref(const sk_image_t* cimage) { |
| AsImage(cimage)->ref(); |
| } |
| |
| void sk_image_unref(const sk_image_t* cimage) { |
| AsImage(cimage)->unref(); |
| } |
| |
| int sk_image_get_width(const sk_image_t* cimage) { |
| return AsImage(cimage)->width(); |
| } |
| |
| int sk_image_get_height(const sk_image_t* cimage) { |
| return AsImage(cimage)->height(); |
| } |
| |
| uint32_t sk_image_get_unique_id(const sk_image_t* cimage) { |
| return AsImage(cimage)->uniqueID(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sk_path_t* sk_path_new() { return (sk_path_t*)new SkPath; } |
| |
| void sk_path_delete(sk_path_t* cpath) { delete as_path(cpath); } |
| |
| void sk_path_move_to(sk_path_t* cpath, float x, float y) { |
| as_path(cpath)->moveTo(x, y); |
| } |
| |
| void sk_path_line_to(sk_path_t* cpath, float x, float y) { |
| as_path(cpath)->lineTo(x, y); |
| } |
| |
| void sk_path_quad_to(sk_path_t* cpath, float x0, float y0, float x1, float y1) { |
| as_path(cpath)->quadTo(x0, y0, x1, y1); |
| } |
| |
| void sk_path_conic_to(sk_path_t* cpath, float x0, float y0, float x1, float y1, float w) { |
| as_path(cpath)->conicTo(x0, y0, x1, y1, w); |
| } |
| |
| void sk_path_cubic_to(sk_path_t* cpath, float x0, float y0, float x1, float y1, float x2, float y2) { |
| as_path(cpath)->cubicTo(x0, y0, x1, y1, x2, y2); |
| } |
| |
| void sk_path_close(sk_path_t* cpath) { |
| as_path(cpath)->close(); |
| } |
| |
| void sk_path_add_rect(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir) { |
| SkPath::Direction dir; |
| if (!from_c_path_direction(cdir, &dir)) { |
| return; |
| } |
| as_path(cpath)->addRect(AsRect(*crect), dir); |
| } |
| |
| void sk_path_add_oval(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir) { |
| SkPath::Direction dir; |
| if (!from_c_path_direction(cdir, &dir)) { |
| return; |
| } |
| as_path(cpath)->addOval(AsRect(*crect), dir); |
| } |
| |
| bool sk_path_get_bounds(const sk_path_t* cpath, sk_rect_t* crect) { |
| const SkPath& path = AsPath(*cpath); |
| |
| if (path.isEmpty()) { |
| if (crect) { |
| *crect = ToRect(SkRect::MakeEmpty()); |
| } |
| return false; |
| } |
| |
| if (crect) { |
| *crect = ToRect(path.getBounds()); |
| } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void sk_canvas_save(sk_canvas_t* ccanvas) { |
| AsCanvas(ccanvas)->save(); |
| } |
| |
| void sk_canvas_save_layer(sk_canvas_t* ccanvas, const sk_rect_t* crect, const sk_paint_t* cpaint) { |
| AsCanvas(ccanvas)->drawRect(AsRect(*crect), AsPaint(*cpaint)); |
| } |
| |
| void sk_canvas_restore(sk_canvas_t* ccanvas) { |
| AsCanvas(ccanvas)->restore(); |
| } |
| |
| void sk_canvas_translate(sk_canvas_t* ccanvas, float dx, float dy) { |
| AsCanvas(ccanvas)->translate(dx, dy); |
| } |
| |
| void sk_canvas_scale(sk_canvas_t* ccanvas, float sx, float sy) { |
| AsCanvas(ccanvas)->scale(sx, sy); |
| } |
| |
| void sk_canvas_rotate_degress(sk_canvas_t* ccanvas, float degrees) { |
| AsCanvas(ccanvas)->rotate(degrees); |
| } |
| |
| void sk_canvas_rotate_radians(sk_canvas_t* ccanvas, float radians) { |
| AsCanvas(ccanvas)->rotate(SkRadiansToDegrees(radians)); |
| } |
| |
| void sk_canvas_skew(sk_canvas_t* ccanvas, float sx, float sy) { |
| AsCanvas(ccanvas)->skew(sx, sy); |
| } |
| |
| void sk_canvas_concat(sk_canvas_t* ccanvas, const sk_matrix_t* cmatrix) { |
| SkASSERT(cmatrix); |
| SkMatrix matrix; |
| from_c_matrix(cmatrix, &matrix); |
| AsCanvas(ccanvas)->concat(matrix); |
| } |
| |
| void sk_canvas_clip_rect(sk_canvas_t* ccanvas, const sk_rect_t* crect) { |
| AsCanvas(ccanvas)->clipRect(AsRect(*crect)); |
| } |
| |
| void sk_canvas_clip_path(sk_canvas_t* ccanvas, const sk_path_t* cpath) { |
| AsCanvas(ccanvas)->clipPath(AsPath(*cpath)); |
| } |
| |
| void sk_canvas_draw_paint(sk_canvas_t* ccanvas, const sk_paint_t* cpaint) { |
| AsCanvas(ccanvas)->drawPaint(AsPaint(*cpaint)); |
| } |
| |
| void sk_canvas_draw_rect(sk_canvas_t* ccanvas, const sk_rect_t* crect, const sk_paint_t* cpaint) { |
| AsCanvas(ccanvas)->drawRect(AsRect(*crect), AsPaint(*cpaint)); |
| } |
| |
| void sk_canvas_draw_circle(sk_canvas_t* ccanvas, float cx, float cy, float rad, |
| const sk_paint_t* cpaint) { |
| AsCanvas(ccanvas)->drawCircle(cx, cy, rad, AsPaint(*cpaint)); |
| } |
| |
| void sk_canvas_draw_oval(sk_canvas_t* ccanvas, const sk_rect_t* crect, const sk_paint_t* cpaint) { |
| AsCanvas(ccanvas)->drawOval(AsRect(*crect), AsPaint(*cpaint)); |
| } |
| |
| void sk_canvas_draw_path(sk_canvas_t* ccanvas, const sk_path_t* cpath, const sk_paint_t* cpaint) { |
| AsCanvas(ccanvas)->drawPath(AsPath(*cpath), AsPaint(*cpaint)); |
| } |
| |
| void sk_canvas_draw_image(sk_canvas_t* ccanvas, const sk_image_t* cimage, float x, float y, |
| const sk_paint_t* cpaint) { |
| AsCanvas(ccanvas)->drawImage(AsImage(cimage), x, y, AsPaint(cpaint)); |
| } |
| |
| void sk_canvas_draw_image_rect(sk_canvas_t* ccanvas, const sk_image_t* cimage, |
| const sk_rect_t* csrcR, const sk_rect_t* cdstR, |
| const sk_paint_t* cpaint) { |
| SkCanvas* canvas = AsCanvas(ccanvas); |
| const SkImage* image = AsImage(cimage); |
| const SkRect& dst = AsRect(*cdstR); |
| const SkPaint* paint = AsPaint(cpaint); |
| |
| if (csrcR) { |
| canvas->drawImageRect(image, AsRect(*csrcR), dst, paint); |
| } else { |
| canvas->drawImageRect(image, dst, paint); |
| } |
| } |
| |
| void sk_canvas_draw_picture(sk_canvas_t* ccanvas, const sk_picture_t* cpicture, |
| const sk_matrix_t* cmatrix, const sk_paint_t* cpaint) { |
| const SkMatrix* matrixPtr = NULL; |
| SkMatrix matrix; |
| if (cmatrix) { |
| from_c_matrix(cmatrix, &matrix); |
| matrixPtr = &matrix; |
| } |
| AsCanvas(ccanvas)->drawPicture(AsPicture(cpicture), matrixPtr, AsPaint(cpaint)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sk_surface_t* sk_surface_new_raster(const sk_imageinfo_t* cinfo, |
| const sk_surfaceprops_t* props) { |
| SkImageInfo info; |
| if (!from_c_info(*cinfo, &info)) { |
| return NULL; |
| } |
| SkPixelGeometry geo = kUnknown_SkPixelGeometry; |
| if (props && !from_c_pixelgeometry(props->pixelGeometry, &geo)) { |
| return NULL; |
| } |
| |
| SkSurfaceProps surfProps(0, geo); |
| return (sk_surface_t*)SkSurface::NewRaster(info, &surfProps); |
| } |
| |
| sk_surface_t* sk_surface_new_raster_direct(const sk_imageinfo_t* cinfo, void* pixels, |
| size_t rowBytes, |
| const sk_surfaceprops_t* props) { |
| SkImageInfo info; |
| if (!from_c_info(*cinfo, &info)) { |
| return NULL; |
| } |
| SkPixelGeometry geo = kUnknown_SkPixelGeometry; |
| if (props && !from_c_pixelgeometry(props->pixelGeometry, &geo)) { |
| return NULL; |
| } |
| |
| SkSurfaceProps surfProps(0, geo); |
| return (sk_surface_t*)SkSurface::NewRasterDirect(info, pixels, rowBytes, &surfProps); |
| } |
| |
| void sk_surface_unref(sk_surface_t* csurf) { |
| SkSafeUnref((SkSurface*)csurf); |
| } |
| |
| sk_canvas_t* sk_surface_get_canvas(sk_surface_t* csurf) { |
| SkSurface* surf = (SkSurface*)csurf; |
| return (sk_canvas_t*)surf->getCanvas(); |
| } |
| |
| sk_image_t* sk_surface_new_image_snapshot(sk_surface_t* csurf) { |
| SkSurface* surf = (SkSurface*)csurf; |
| return (sk_image_t*)surf->newImageSnapshot(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sk_picture_recorder_t* sk_picture_recorder_new() { |
| return ToPictureRecorder(new SkPictureRecorder); |
| } |
| |
| void sk_picture_recorder_delete(sk_picture_recorder_t* crec) { |
| delete AsPictureRecorder(crec); |
| } |
| |
| sk_canvas_t* sk_picture_recorder_begin_recording(sk_picture_recorder_t* crec, |
| const sk_rect_t* cbounds) { |
| return ToCanvas(AsPictureRecorder(crec)->beginRecording(AsRect(*cbounds))); |
| } |
| |
| sk_picture_t* sk_picture_recorder_end_recording(sk_picture_recorder_t* crec) { |
| return ToPicture(AsPictureRecorder(crec)->endRecording()); |
| } |
| |
| void sk_picture_ref(sk_picture_t* cpic) { |
| SkSafeRef(AsPicture(cpic)); |
| } |
| |
| void sk_picture_unref(sk_picture_t* cpic) { |
| SkSafeUnref(AsPicture(cpic)); |
| } |
| |
| uint32_t sk_picture_get_unique_id(sk_picture_t* cpic) { |
| return AsPicture(cpic)->uniqueID(); |
| } |
| |
| sk_rect_t sk_picture_get_bounds(sk_picture_t* cpic) { |
| return ToRect(AsPicture(cpic)->cullRect()); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| #include "../../include/effects/SkGradientShader.h" |
| #include "sk_shader.h" |
| |
| const struct { |
| sk_shader_tilemode_t fC; |
| SkShader::TileMode fSK; |
| } gTileModeMap[] = { |
| { CLAMP_SK_SHADER_TILEMODE, SkShader::kClamp_TileMode }, |
| { REPEAT_SK_SHADER_TILEMODE, SkShader::kRepeat_TileMode }, |
| { MIRROR_SK_SHADER_TILEMODE, SkShader::kMirror_TileMode }, |
| }; |
| |
| static bool from_c_tilemode(sk_shader_tilemode_t cMode, SkShader::TileMode* skMode) { |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gTileModeMap); ++i) { |
| if (cMode == gTileModeMap[i].fC) { |
| if (skMode) { |
| *skMode = gTileModeMap[i].fSK; |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void sk_shader_ref(sk_shader_t* cshader) { |
| SkSafeRef(AsShader(cshader)); |
| } |
| |
| void sk_shader_unref(sk_shader_t* cshader) { |
| SkSafeUnref(AsShader(cshader)); |
| } |
| |
| sk_shader_t* sk_shader_new_linear_gradient(const sk_point_t pts[2], |
| const sk_color_t colors[], |
| const float colorPos[], |
| int colorCount, |
| sk_shader_tilemode_t cmode, |
| const sk_matrix_t* cmatrix) { |
| SkShader::TileMode mode; |
| if (!from_c_tilemode(cmode, &mode)) { |
| return NULL; |
| } |
| SkMatrix matrix; |
| if (cmatrix) { |
| from_c_matrix(cmatrix, &matrix); |
| } else { |
| matrix.setIdentity(); |
| } |
| return (sk_shader_t*)SkGradientShader::MakeLinear(reinterpret_cast<const SkPoint*>(pts), |
| reinterpret_cast<const SkColor*>(colors), |
| colorPos, colorCount, |
| mode, 0, &matrix).release(); |
| } |
| |
| static const SkPoint& to_skpoint(const sk_point_t& p) { |
| return reinterpret_cast<const SkPoint&>(p); |
| } |
| |
| sk_shader_t* sk_shader_new_radial_gradient(const sk_point_t* ccenter, |
| float radius, |
| const sk_color_t colors[], |
| const float colorPos[], |
| int colorCount, |
| sk_shader_tilemode_t cmode, |
| const sk_matrix_t* cmatrix) { |
| SkShader::TileMode mode; |
| if (!from_c_tilemode(cmode, &mode)) { |
| return NULL; |
| } |
| SkMatrix matrix; |
| if (cmatrix) { |
| from_c_matrix(cmatrix, &matrix); |
| } else { |
| matrix.setIdentity(); |
| } |
| SkPoint center = to_skpoint(*ccenter); |
| return (sk_shader_t*)SkGradientShader::MakeRadial(center, (SkScalar)radius, |
| reinterpret_cast<const SkColor*>(colors), |
| reinterpret_cast<const SkScalar*>(colorPos), |
| colorCount, mode, 0, &matrix).release(); |
| } |
| |
| sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* ccenter, |
| const sk_color_t colors[], |
| const float colorPos[], |
| int colorCount, |
| const sk_matrix_t* cmatrix) { |
| SkMatrix matrix; |
| if (cmatrix) { |
| from_c_matrix(cmatrix, &matrix); |
| } else { |
| matrix.setIdentity(); |
| } |
| return (sk_shader_t*)SkGradientShader::MakeSweep((SkScalar)(ccenter->x), |
| (SkScalar)(ccenter->y), |
| reinterpret_cast<const SkColor*>(colors), |
| reinterpret_cast<const SkScalar*>(colorPos), |
| colorCount, 0, &matrix).release(); |
| } |
| |
| sk_shader_t* sk_shader_new_two_point_conical_gradient(const sk_point_t* start, |
| float startRadius, |
| const sk_point_t* end, |
| float endRadius, |
| const sk_color_t colors[], |
| const float colorPos[], |
| int colorCount, |
| sk_shader_tilemode_t cmode, |
| const sk_matrix_t* cmatrix) { |
| SkShader::TileMode mode; |
| if (!from_c_tilemode(cmode, &mode)) { |
| return NULL; |
| } |
| SkMatrix matrix; |
| if (cmatrix) { |
| from_c_matrix(cmatrix, &matrix); |
| } else { |
| matrix.setIdentity(); |
| } |
| SkPoint skstart = to_skpoint(*start); |
| SkPoint skend = to_skpoint(*end); |
| return (sk_shader_t*)SkGradientShader::MakeTwoPointConical(skstart, (SkScalar)startRadius, |
| skend, (SkScalar)endRadius, |
| reinterpret_cast<const SkColor*>(colors), |
| reinterpret_cast<const SkScalar*>(colorPos), |
| colorCount, mode, 0, &matrix).release(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| #include "../../include/effects/SkBlurMaskFilter.h" |
| #include "sk_maskfilter.h" |
| |
| const struct { |
| sk_blurstyle_t fC; |
| SkBlurStyle fSk; |
| } gBlurStylePairs[] = { |
| { NORMAL_SK_BLUR_STYLE, kNormal_SkBlurStyle }, |
| { SOLID_SK_BLUR_STYLE, kSolid_SkBlurStyle }, |
| { OUTER_SK_BLUR_STYLE, kOuter_SkBlurStyle }, |
| { INNER_SK_BLUR_STYLE, kInner_SkBlurStyle }, |
| }; |
| |
| static bool find_blurstyle(sk_blurstyle_t csrc, SkBlurStyle* dst) { |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gBlurStylePairs); ++i) { |
| if (gBlurStylePairs[i].fC == csrc) { |
| if (dst) { |
| *dst = gBlurStylePairs[i].fSk; |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void sk_maskfilter_ref(sk_maskfilter_t* cfilter) { |
| SkSafeRef(AsMaskFilter(cfilter)); |
| } |
| |
| void sk_maskfilter_unref(sk_maskfilter_t* cfilter) { |
| SkSafeUnref(AsMaskFilter(cfilter)); |
| } |
| |
| sk_maskfilter_t* sk_maskfilter_new_blur(sk_blurstyle_t cstyle, float sigma) { |
| SkBlurStyle style; |
| if (!find_blurstyle(cstyle, &style)) { |
| return NULL; |
| } |
| return ToMaskFilter(SkBlurMaskFilter::Create(style, sigma)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sk_data_t* sk_data_new_with_copy(const void* src, size_t length) { |
| return ToData(SkData::NewWithCopy(src, length)); |
| } |
| |
| sk_data_t* sk_data_new_from_malloc(const void* memory, size_t length) { |
| return ToData(SkData::NewFromMalloc(memory, length)); |
| } |
| |
| sk_data_t* sk_data_new_subset(const sk_data_t* csrc, size_t offset, size_t length) { |
| return ToData(SkData::NewSubset(AsData(csrc), offset, length)); |
| } |
| |
| void sk_data_ref(const sk_data_t* cdata) { |
| SkSafeRef(AsData(cdata)); |
| } |
| |
| void sk_data_unref(const sk_data_t* cdata) { |
| SkSafeUnref(AsData(cdata)); |
| } |
| |
| size_t sk_data_get_size(const sk_data_t* cdata) { |
| return AsData(cdata)->size(); |
| } |
| |
| const void* sk_data_get_data(const sk_data_t* cdata) { |
| return AsData(cdata)->data(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |