From 0444bfe06ebd4394e5399892037882e5c461f4d3 Mon Sep 17 00:00:00 2001 From: Matthew Leibowitz Date: Wed, 12 Oct 2016 00:15:44 +0200 Subject: [PATCH] Updated the C API with all the changes to the C++ API --- include/c/gr_context.h | 2 +- include/c/sk_canvas.h | 10 ++++----- include/c/sk_document.h | 2 +- include/c/sk_imagefilter.h | 8 ++++++- include/c/sk_paint.h | 8 +++---- include/c/sk_types.h | 54 ++++++++++++++++++++++++++++++++++++++++++++-- src/c/gr_context.cpp | 4 ++-- src/c/sk_canvas.cpp | 26 +++++++++++----------- src/c/sk_codec.cpp | 8 ++----- src/c/sk_document.cpp | 8 +++---- src/c/sk_enums.cpp | 43 ++++++++++++++++++++++++++++++++---- src/c/sk_imagefilter.cpp | 20 +++++++++++++++-- src/c/sk_paint.cpp | 12 ++++------- src/c/sk_stream.cpp | 4 ++-- src/c/sk_types_priv.h | 19 +++++++--------- 15 files changed, 161 insertions(+), 67 deletions(-) diff --git a/include/c/gr_context.h b/include/c/gr_context.h index 57d0eac..e143eea 100644 --- a/include/c/gr_context.h +++ b/include/c/gr_context.h @@ -24,7 +24,7 @@ SK_API void gr_context_get_resource_cache_limits(gr_context_t* context, int* max SK_API void gr_context_set_resource_cache_limits(gr_context_t* context, int maxResources, size_t maxResourceBytes); SK_API void gr_context_get_resource_cache_usage(gr_context_t* context, int* maxResources, size_t* maxResourceBytes); SK_API int gr_context_get_recommended_sample_count(gr_context_t* context, gr_pixelconfig_t config, float dpi); -SK_API void gr_context_flush(gr_context_t* context, gr_context_flushbits_t flags); +SK_API void gr_context_flush(gr_context_t* context); SK_API const gr_glinterface_t* gr_glinterface_default_interface(); SK_API const gr_glinterface_t* gr_glinterface_create_native_interface(); diff --git a/include/c/sk_canvas.h b/include/c/sk_canvas.h index b39d0e9..abb56f5 100644 --- a/include/c/sk_canvas.h +++ b/include/c/sk_canvas.h @@ -185,7 +185,7 @@ SK_API void sk_canvas_restore_to_count(sk_canvas_t*, int saveCount); /** Draws with the specified color and mode. **/ -SK_API void sk_canvas_draw_color(sk_canvas_t* ccanvas, sk_color_t color, sk_xfermode_mode_t mode); +SK_API void sk_canvas_draw_color(sk_canvas_t* ccanvas, sk_color_t color, sk_blendmode_t mode); /** Draw a series of points, interpreted based on the sk_point_mode_t mode. For all modes, the count parameter is interpreted as the total number of @@ -308,11 +308,11 @@ SK_API void sk_canvas_draw_round_rect(sk_canvas_t*, const sk_rect_t*, float rx, /** Modify the current clip with the specified rectangle. */ -SK_API void sk_canvas_clip_rect_with_operation(sk_canvas_t* t, const sk_rect_t* crect, sk_region_op_t op, bool doAA); +SK_API void sk_canvas_clip_rect_with_operation(sk_canvas_t* t, const sk_rect_t* crect, sk_clipop_t op, bool doAA); /** Modify the current clip with the specified path. */ -SK_API void sk_canvas_clip_path_with_operation(sk_canvas_t* t, const sk_path_t* crect, sk_region_op_t op, bool doAA); +SK_API void sk_canvas_clip_path_with_operation(sk_canvas_t* t, const sk_path_t* crect, sk_clipop_t op, bool doAA); /** Return the bounds of the current clip (in local coordinates) in the @@ -337,8 +337,8 @@ SK_API void sk_canvas_flush(sk_canvas_t* ccanvas); SK_API sk_canvas_t* sk_canvas_new_from_bitmap(const sk_bitmap_t* bitmap); -SK_API void sk_canvas_draw_bitmap_lattice(sk_canvas_t* t, const sk_bitmap_t* bitmap, const int* xDivs, int xCount, const int* yDivs, int yCount, const sk_rect_t* dst, const sk_paint_t* paint); -SK_API void sk_canvas_draw_image_lattice(sk_canvas_t* t, const sk_image_t* image, const int* xDivs, int xCount, const int* yDivs, int yCount, const sk_rect_t* dst, const sk_paint_t* paint); +SK_API void sk_canvas_draw_bitmap_lattice(sk_canvas_t* t, const sk_bitmap_t* bitmap, const sk_lattice_t* lattice, const sk_rect_t* dst, const sk_paint_t* paint); +SK_API void sk_canvas_draw_image_lattice(sk_canvas_t* t, const sk_image_t* image, const sk_lattice_t* lattice, const sk_rect_t* dst, const sk_paint_t* paint); SK_C_PLUS_PLUS_END_GUARD diff --git a/include/c/sk_document.h b/include/c/sk_document.h index 4e652aa..72bb02c 100644 --- a/include/c/sk_document.h +++ b/include/c/sk_document.h @@ -25,7 +25,7 @@ SK_API sk_document_t* sk_document_create_pdf_from_filename(const char* path, flo SK_API sk_canvas_t* sk_document_begin_page(sk_document_t* document, float width, float height, const sk_rect_t* content); SK_API void sk_document_end_page(sk_document_t* document); -SK_API bool sk_document_close(sk_document_t* document); +SK_API void sk_document_close(sk_document_t* document); SK_API void sk_document_abort(sk_document_t* document); // TODO: setMetadata diff --git a/include/c/sk_imagefilter.h b/include/c/sk_imagefilter.h index 70184c8..0f719cc 100644 --- a/include/c/sk_imagefilter.h +++ b/include/c/sk_imagefilter.h @@ -157,7 +157,13 @@ SK_API sk_imagefilter_t* sk_imagefilter_new_tile( const sk_rect_t* dst, sk_imagefilter_t* input); SK_API sk_imagefilter_t* sk_imagefilter_new_xfermode( - sk_xfermode_mode_t mode, + sk_blendmode_t mode, + sk_imagefilter_t* background, + sk_imagefilter_t* foreground /*NULL*/, + const sk_imagefilter_croprect_t* cropRect /*NULL*/); +SK_API sk_imagefilter_t* sk_imagefilter_new_arithmetic( + float k1, float k2, float k3, float k4, + bool enforcePMColor, sk_imagefilter_t* background, sk_imagefilter_t* foreground /*NULL*/, const sk_imagefilter_croprect_t* cropRect /*NULL*/); diff --git a/include/c/sk_paint.h b/include/c/sk_paint.h index 6f5a99e..8353ef3 100644 --- a/include/c/sk_paint.h +++ b/include/c/sk_paint.h @@ -112,9 +112,9 @@ SK_API void sk_paint_set_shader(sk_paint_t*, sk_shader_t*); */ SK_API void sk_paint_set_maskfilter(sk_paint_t*, sk_maskfilter_t*); /** - * Set the paint's xfermode to the specified parameter. + * Set the paint's blend mode to the specified parameter. */ -SK_API void sk_paint_set_xfermode_mode(sk_paint_t*, sk_xfermode_mode_t); +SK_API void sk_paint_set_blendmode(sk_paint_t*, sk_blendmode_t); /** * Return true iff the paint has dithering enabled. */ @@ -158,9 +158,9 @@ SK_API void sk_paint_set_imagefilter(sk_paint_t*, sk_imagefilter_t*); */ SK_API sk_imagefilter_t* sk_paint_get_imagefilter(sk_paint_t*); /** - * Get the paint's xfermode object. + * Get the paint's blend mode. */ -SK_API sk_xfermode_mode_t sk_paint_get_xfermode_mode(sk_paint_t*); +SK_API sk_blendmode_t sk_paint_get_blendmode(sk_paint_t*); /** * Set the paint's filter quality. */ diff --git a/include/c/sk_types.h b/include/c/sk_types.h index cff0f25..358b205 100644 --- a/include/c/sk_types.h +++ b/include/c/sk_types.h @@ -216,6 +216,38 @@ typedef enum { LUMINOSITY_SK_XFERMODE_MODE, } sk_xfermode_mode_t; +typedef enum { + CLEAR_SK_BLENDMODE, + SRC_SK_BLENDMODE, + DST_SK_BLENDMODE, + SRCOVER_SK_BLENDMODE, + DSTOVER_SK_BLENDMODE, + SRCIN_SK_BLENDMODE, + DSTIN_SK_BLENDMODE, + SRCOUT_SK_BLENDMODE, + DSTOUT_SK_BLENDMODE, + SRCATOP_SK_BLENDMODE, + DSTATOP_SK_BLENDMODE, + XOR_SK_BLENDMODE, + PLUS_SK_BLENDMODE, + MODULATE_SK_BLENDMODE, + SCREEN_SK_BLENDMODE, + OVERLAY_SK_BLENDMODE, + DARKEN_SK_BLENDMODE, + LIGHTEN_SK_BLENDMODE, + COLORDODGE_SK_BLENDMODE, + COLORBURN_SK_BLENDMODE, + HARDLIGHT_SK_BLENDMODE, + SOFTLIGHT_SK_BLENDMODE, + DIFFERENCE_SK_BLENDMODE, + EXCLUSION_SK_BLENDMODE, + MULTIPLY_SK_BLENDMODE, + HUE_SK_BLENDMODE, + SATURATION_SK_BLENDMODE, + COLOR_SK_BLENDMODE, + LUMINOSITY_SK_BLENDMODE, +} sk_blendmode_t; + ////////////////////////////////////////////////////////////////////////////////////////// typedef struct { @@ -406,6 +438,11 @@ typedef enum { REPLACE_SK_REGION_OP, //!< replace the dst region with the op region } sk_region_op_t; +typedef enum { + DIFFERENCE_SK_CLIPOP, + INTERSECT_SK_CLIPOP, +} sk_clipop_t; + /** * Enum describing format of encoded data. */ @@ -453,8 +490,7 @@ typedef enum { typedef struct { sk_codec_zero_initialized_t fZeroInitialized; - sk_irect_t fSubset; - bool fHasSubset; + sk_irect_t* fSubset; } sk_codec_options_t; // The verbs that can be foudn on a path @@ -638,6 +674,20 @@ typedef enum { CONCAVE_SK_PATH_CONVEXITY, } sk_path_convexity_t; +typedef enum { + DEFAULT_SK_LATTICE_FLAGS, + TRANSPARENT_SK_LATTICE_FLAGS = 1 << 0, +} sk_lattice_flags_t; + +typedef struct { + const int* fXDivs; + const int* fYDivs; + const sk_lattice_flags_t* fFlags; + int fXCount; + int fYCount; + const sk_irect_t* fBounds; +} sk_lattice_t; + SK_C_PLUS_PLUS_END_GUARD #endif diff --git a/src/c/gr_context.cpp b/src/c/gr_context.cpp index 8fec79c..dda1d12 100644 --- a/src/c/gr_context.cpp +++ b/src/c/gr_context.cpp @@ -49,8 +49,8 @@ int gr_context_get_recommended_sample_count(gr_context_t* context, gr_pixelconfi return AsGrContext(context)->getRecommendedSampleCount((GrPixelConfig)config, dpi); } -void gr_context_flush(gr_context_t* context, gr_context_flushbits_t flags) { - AsGrContext(context)->flush((GrContext::FlushBits)flags); +void gr_context_flush(gr_context_t* context) { + AsGrContext(context)->flush(); } diff --git a/src/c/sk_canvas.cpp b/src/c/sk_canvas.cpp index 4f0f450..5e98e71 100644 --- a/src/c/sk_canvas.cpp +++ b/src/c/sk_canvas.cpp @@ -27,8 +27,8 @@ void sk_canvas_restore_to_count(sk_canvas_t* ccanvas, int saveCount) { AsCanvas(ccanvas)->restoreToCount(saveCount); } -void sk_canvas_draw_color(sk_canvas_t* ccanvas, sk_color_t color, sk_xfermode_mode_t cmode) { - AsCanvas(ccanvas)->drawColor(color, (SkXfermode::Mode)cmode); +void sk_canvas_draw_color(sk_canvas_t* ccanvas, sk_color_t color, sk_blendmode_t cmode) { + AsCanvas(ccanvas)->drawColor(color, (SkBlendMode)cmode); } void sk_canvas_draw_points(sk_canvas_t* ccanvas, sk_point_mode_t pointMode, size_t count, const sk_point_t points [], const sk_paint_t* cpaint) @@ -111,12 +111,12 @@ void sk_canvas_draw_round_rect(sk_canvas_t* ccanvas, const sk_rect_t* crect, flo AsCanvas(ccanvas)->drawRoundRect(AsRect(*crect), rx, ry, AsPaint(*cpaint)); } -void sk_canvas_clip_rect_with_operation(sk_canvas_t* ccanvas, const sk_rect_t* crect, sk_region_op_t op, bool doAA) { - AsCanvas(ccanvas)->clipRect(AsRect(*crect), (SkRegion::Op)op, doAA); +void sk_canvas_clip_rect_with_operation(sk_canvas_t* ccanvas, const sk_rect_t* crect, sk_clipop_t op, bool doAA) { + AsCanvas(ccanvas)->clipRect(AsRect(*crect), (SkClipOp)op, doAA); } -void sk_canvas_clip_path_with_operation(sk_canvas_t* ccanvas, const sk_path_t* cpath, sk_region_op_t op, bool doAA) { - AsCanvas(ccanvas)->clipPath(AsPath(*cpath), (SkRegion::Op)op, doAA); +void sk_canvas_clip_path_with_operation(sk_canvas_t* ccanvas, const sk_path_t* cpath, sk_clipop_t op, bool doAA) { + AsCanvas(ccanvas)->clipPath(AsPath(*cpath), (SkClipOp)op, doAA); } bool sk_canvas_get_clip_bounds(sk_canvas_t* ccanvas, sk_rect_t* cbounds) { @@ -236,19 +236,17 @@ sk_canvas_t* sk_canvas_new_from_bitmap(const sk_bitmap_t* bitmap) { void sk_canvas_draw_bitmap_lattice(sk_canvas_t* ccanvas, const sk_bitmap_t* bitmap, - const int* xDivs, int xCount, const int* yDivs, int yCount, - const sk_rect_t* dst, + const sk_lattice_t* lattice, + const sk_rect_t* dst, const sk_paint_t* paint) { - SkCanvas::Lattice lattice = { xDivs, xCount, yDivs, yCount }; - AsCanvas(ccanvas)->drawBitmapLattice(AsBitmap(*bitmap), lattice, AsRect(*dst), AsPaint(paint)); + AsCanvas(ccanvas)->drawBitmapLattice(AsBitmap(*bitmap), AsLattice(*lattice), AsRect(*dst), AsPaint(paint)); } void sk_canvas_draw_image_lattice(sk_canvas_t* ccanvas, const sk_image_t* image, - const int* xDivs, int xCount, const int* yDivs, int yCount, - const sk_rect_t* dst, + const sk_lattice_t* lattice, + const sk_rect_t* dst, const sk_paint_t* paint) { - SkCanvas::Lattice lattice = { xDivs, xCount, yDivs, yCount }; - AsCanvas(ccanvas)->drawImageLattice(AsImage(image), lattice, AsRect(*dst), AsPaint(paint)); + AsCanvas(ccanvas)->drawImageLattice(AsImage(image), AsLattice(*lattice), AsRect(*dst), AsPaint(paint)); } diff --git a/src/c/sk_codec.cpp b/src/c/sk_codec.cpp index 1e4fc2a..7936564 100644 --- a/src/c/sk_codec.cpp +++ b/src/c/sk_codec.cpp @@ -23,7 +23,7 @@ sk_codec_t* sk_codec_new_from_stream(sk_stream_t* stream) sk_codec_t* sk_codec_new_from_data(sk_data_t* data) { - return ToCodec(SkCodec::NewFromData(AsData(data))); + return ToCodec(SkCodec::NewFromData(sk_ref_sp(AsData(data)))); } void sk_codec_destroy(sk_codec_t* codec) @@ -60,11 +60,7 @@ sk_codec_result_t sk_codec_get_pixels(sk_codec_t* codec, const sk_imageinfo_t* c { SkImageInfo info; from_c(*cinfo, &info); - SkCodec::Options options; - if (!from_c(*coptions, &options)) { - return INVALID_PARAMETERS_SK_CODEC_RESULT; - } - return (sk_codec_result_t)AsCodec(codec)->getPixels(info, pixels, rowBytes, &options, ctable, ctableCount); + return (sk_codec_result_t)AsCodec(codec)->getPixels(info, pixels, rowBytes, AsCodecOptions(coptions), ctable, ctableCount); } sk_codec_result_t sk_codec_get_pixels_using_defaults(sk_codec_t* codec, const sk_imageinfo_t* cinfo, void* pixels, size_t rowBytes) diff --git a/src/c/sk_document.cpp b/src/c/sk_document.cpp index 3d51567..fcd6b31 100644 --- a/src/c/sk_document.cpp +++ b/src/c/sk_document.cpp @@ -16,11 +16,11 @@ void sk_document_unref(sk_document_t* document) { } sk_document_t* sk_document_create_pdf_from_stream(sk_wstream_t* stream, float dpi) { - return ToDocument(SkDocument::CreatePDF(AsWStream(stream), dpi)); + return ToDocument(SkDocument::MakePDF(AsWStream(stream), dpi).release()); } sk_document_t* sk_document_create_pdf_from_filename(const char* path, float dpi) { - return ToDocument(SkDocument::CreatePDF(path, dpi)); + return ToDocument(SkDocument::MakePDF(path, dpi).release()); } //sk_document_t* sk_document_create_xps_from_stream(sk_wstream_t* stream, float dpi) { @@ -39,8 +39,8 @@ void sk_document_end_page(sk_document_t* document) { AsDocument(document)->endPage(); } -bool sk_document_close(sk_document_t* document) { - return AsDocument(document)->close(); +void sk_document_close(sk_document_t* document) { + AsDocument(document)->close(); } void sk_document_abort(sk_document_t* document) { diff --git a/src/c/sk_enums.cpp b/src/c/sk_enums.cpp index 0450149..f94d033 100644 --- a/src/c/sk_enums.cpp +++ b/src/c/sk_enums.cpp @@ -138,6 +138,37 @@ static_assert ((int)SkXfermode::Mode::kSaturation_Mode == (int)SATURATION_SK_X static_assert ((int)SkXfermode::Mode::kColor_Mode == (int)COLOR_SK_XFERMODE_MODE, ASSERT_MSG(SkXfermode::Mode, sk_xfermode_mode_t)); static_assert ((int)SkXfermode::Mode::kLuminosity_Mode == (int)LUMINOSITY_SK_XFERMODE_MODE, ASSERT_MSG(SkXfermode::Mode, sk_xfermode_mode_t)); +// sk_blendmode_t +static_assert ((int)SkBlendMode::kClear == (int)CLEAR_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kSrc == (int)SRC_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kDst == (int)DST_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kSrcOver == (int)SRCOVER_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kDstOver == (int)DSTOVER_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kSrcIn == (int)SRCIN_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kDstIn == (int)DSTIN_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kSrcOut == (int)SRCOUT_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kDstOut == (int)DSTOUT_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kSrcATop == (int)SRCATOP_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kDstATop == (int)DSTATOP_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kXor == (int)XOR_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kPlus == (int)PLUS_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kModulate == (int)MODULATE_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kScreen == (int)SCREEN_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kOverlay == (int)OVERLAY_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kDarken == (int)DARKEN_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kLighten == (int)LIGHTEN_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kColorDodge == (int)COLORDODGE_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kColorBurn == (int)COLORBURN_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kHardLight == (int)HARDLIGHT_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kSoftLight == (int)SOFTLIGHT_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kDifference == (int)DIFFERENCE_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kExclusion == (int)EXCLUSION_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kMultiply == (int)MULTIPLY_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kHue == (int)HUE_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kSaturation == (int)SATURATION_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kColor == (int)COLOR_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); +static_assert ((int)SkBlendMode::kLuminosity == (int)LUMINOSITY_SK_BLENDMODE, ASSERT_MSG(SkBlendMode, sk_blendmode_t)); + // sk_colortype_t static_assert ((int)SkColorType::kUnknown_SkColorType == (int)UNKNOWN_SK_COLORTYPE, ASSERT_MSG(SkColorType, sk_colortype_t)); static_assert ((int)SkColorType::kAlpha_8_SkColorType == (int)ALPHA_8_SK_COLORTYPE, ASSERT_MSG(SkColorType, sk_colortype_t)); @@ -191,6 +222,10 @@ static_assert ((int)SkRegion::Op::kXOR_Op == (int)XOR_SK_REGION_ static_assert ((int)SkRegion::Op::kReverseDifference_Op == (int)REVERSE_DIFFERENCE_SK_REGION_OP, ASSERT_MSG(SkRegion::Op, sk_region_op_t)); static_assert ((int)SkRegion::Op::kReplace_Op == (int)REPLACE_SK_REGION_OP, ASSERT_MSG(SkRegion::Op, sk_region_op_t)); +// sk_clipop_t +static_assert ((int)SkClipOp::kDifference_SkClipOp == (int)DIFFERENCE_SK_CLIPOP, ASSERT_MSG(SkClipOp, sk_clipop_t)); +static_assert ((int)SkClipOp::kIntersect_SkClipOp == (int)INTERSECT_SK_CLIPOP, ASSERT_MSG(SkClipOp, sk_clipop_t)); + // sk_encoded_format_t static_assert ((int)SkEncodedFormat::kUnknown_SkEncodedFormat == (int)UNKNOWN_SK_ENCODED_FORMAT, ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t)); static_assert ((int)SkEncodedFormat::kBMP_SkEncodedFormat == (int)BMP_SK_ENCODED_FORMAT, ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t)); @@ -287,10 +322,6 @@ static_assert ((int)GrBackend::kVulkan_GrBackend == (int)VULKAN_GR_BACKEND, static_assert ((bool)SkBudgeted::kNo == (bool)false, ASSERT_MSG(SkBudgeted, bool)); static_assert ((bool)SkBudgeted::kYes == (bool)true, ASSERT_MSG(SkBudgeted, bool)); -// gr_context_flushbits_t -static_assert ((int)0 == (int)NONE_GR_CONTEXT_FLUSHBITS, ASSERT_MSG(GrContext::FlushBits, gr_context_flushbits_t)); -static_assert ((int)GrContext::FlushBits::kDiscard_FlushBit == (int)DISCARD_GR_CONTEXT_FLUSHBITS, ASSERT_MSG(GrContext::FlushBits, gr_context_flushbits_t)); - // sk_pathop_t static_assert ((int)SkPathOp::kDifference_SkPathOp == (int)DIFFERENCE_SK_PATHOP, ASSERT_MSG(SkPathOp, sk_pathop_t)); static_assert ((int)SkPathOp::kIntersect_SkPathOp == (int)INTERSECT_SK_PATHOP, ASSERT_MSG(SkPathOp, sk_pathop_t)); @@ -303,4 +334,8 @@ static_assert ((int)SkPath::Convexity::kUnknown_Convexity == (int)UNKNOWN_SK_P static_assert ((int)SkPath::Convexity::kConvex_Convexity == (int)CONVEX_SK_PATH_CONVEXITY, ASSERT_MSG(SkPath::Convexity, sk_path_convexity_t)); static_assert ((int)SkPath::Convexity::kConcave_Convexity == (int)CONCAVE_SK_PATH_CONVEXITY, ASSERT_MSG(SkPath::Convexity, sk_path_convexity_t)); +// gr_backendtexture_flags_t +static_assert ((int)0 == (int)DEFAULT_SK_LATTICE_FLAGS, ASSERT_MSG(GrBackendTextureFlags, sk_lattice_flags_t)); +static_assert ((int)SkCanvas::Lattice::Flags::kTransparent_Flags == (int)TRANSPARENT_SK_LATTICE_FLAGS, ASSERT_MSG(GrBackendTextureFlags, sk_lattice_flags_t)); + #endif diff --git a/src/c/sk_imagefilter.cpp b/src/c/sk_imagefilter.cpp index 6e6db0a..26e465c 100644 --- a/src/c/sk_imagefilter.cpp +++ b/src/c/sk_imagefilter.cpp @@ -411,13 +411,29 @@ sk_imagefilter_t* sk_imagefilter_new_tile( } sk_imagefilter_t* sk_imagefilter_new_xfermode( - sk_xfermode_mode_t cmode, + sk_blendmode_t cmode, sk_imagefilter_t* background, sk_imagefilter_t* foreground /*NULL*/, const sk_imagefilter_croprect_t* cropRect /*NULL*/) { sk_sp filter = SkXfermodeImageFilter::Make( - SkXfermode::Make((SkXfermode::Mode)cmode), + (SkBlendMode)cmode, + sk_ref_sp(AsImageFilter(background)), + sk_ref_sp(AsImageFilter(foreground)), + AsImageFilterCropRect(cropRect)); + return ToImageFilter(filter.release()); +} + +SK_API sk_imagefilter_t* sk_imagefilter_new_arithmetic( + float k1, float k2, float k3, float k4, + bool enforcePMColor, + sk_imagefilter_t* background, + sk_imagefilter_t* foreground /*NULL*/, + const sk_imagefilter_croprect_t* cropRect /*NULL*/) { + + sk_sp filter = SkXfermodeImageFilter::MakeArithmetic( + k1, k2, k3, k4, + enforcePMColor, sk_ref_sp(AsImageFilter(background)), sk_ref_sp(AsImageFilter(foreground)), AsImageFilterCropRect(cropRect)); diff --git a/src/c/sk_paint.cpp b/src/c/sk_paint.cpp index 763feec..24a2121 100644 --- a/src/c/sk_paint.cpp +++ b/src/c/sk_paint.cpp @@ -85,9 +85,9 @@ void sk_paint_set_stroke_join(sk_paint_t* cpaint, sk_stroke_join_t cjoin) { AsPaint(cpaint)->setStrokeJoin((SkPaint::Join)cjoin); } -void sk_paint_set_xfermode_mode(sk_paint_t* paint, sk_xfermode_mode_t mode) { +void sk_paint_set_blendmode(sk_paint_t* paint, sk_blendmode_t mode) { SkASSERT(paint); - AsPaint(paint)->setXfermodeMode((SkXfermode::Mode)mode); + AsPaint(paint)->setBlendMode((SkBlendMode)mode); } bool sk_paint_is_dither(const sk_paint_t* cpaint) { @@ -130,13 +130,9 @@ sk_imagefilter_t* sk_paint_get_imagefilter(sk_paint_t* cpaint) { return ToImageFilter(AsPaint(cpaint)->getImageFilter()); } -sk_xfermode_mode_t sk_paint_get_xfermode_mode(sk_paint_t* paint) { +sk_blendmode_t sk_paint_get_blendmode(sk_paint_t* paint) { SkASSERT(paint); - SkXfermode::Mode mode; - if (SkXfermode::AsMode(AsPaint(paint)->getXfermode(), &mode)) { - return (sk_xfermode_mode_t)mode; - } - return SRCOVER_SK_XFERMODE_MODE; + return (sk_blendmode_t)AsPaint(paint)->getBlendMode(); } void sk_paint_set_filter_quality(sk_paint_t* cpaint, sk_filter_quality_t filterQuality) diff --git a/src/c/sk_stream.cpp b/src/c/sk_stream.cpp index 9192c68..aff6385 100644 --- a/src/c/sk_stream.cpp +++ b/src/c/sk_stream.cpp @@ -45,7 +45,7 @@ sk_stream_memorystream_t* sk_memorystream_new_with_data (const void* data, size_ } sk_stream_memorystream_t* sk_memorystream_new_with_skdata (sk_data_t* data) { - return ToMemoryStream(new SkMemoryStream(AsData(data))); + return ToMemoryStream(new SkMemoryStream(sk_ref_sp(AsData(data)))); } void sk_memorystream_set_memory (sk_stream_memorystream_t* cmemorystream, const void* data, size_t length, bool copyData) { @@ -152,7 +152,7 @@ sk_wstream_dynamicmemorystream_t* sk_dynamicmemorywstream_new() sk_data_t* sk_dynamicmemorywstream_copy_to_data(sk_wstream_dynamicmemorystream_t* cstream) { - return ToData(AsDynamicMemoryWStream(cstream)->copyToData()); + return ToData(AsDynamicMemoryWStream(cstream)->snapshotAsData().release()); } sk_stream_asset_t* sk_dynamicmemorywstream_detach_as_stream(sk_wstream_dynamicmemorystream_t* cstream) diff --git a/src/c/sk_types_priv.h b/src/c/sk_types_priv.h index 5b452f4..b9bb8aa 100644 --- a/src/c/sk_types_priv.h +++ b/src/c/sk_types_priv.h @@ -196,6 +196,10 @@ static inline sk_codec_t* ToCodec(SkCodec* codec) { return reinterpret_cast(codec); } +static inline const SkCodec::Options* AsCodecOptions(const sk_codec_options_t* t) { + return reinterpret_cast(t); +} + static inline SkTypeface* AsTypeface(sk_typeface_t* typeface) { return reinterpret_cast(typeface); } @@ -496,6 +500,10 @@ static inline SkOpBuilder* AsOpBuilder(sk_opbuilder_t* p) { return reinterpret_cast(p); } +static inline const SkCanvas::Lattice& AsLattice(const sk_lattice_t& p) { + return reinterpret_cast(p); +} + static inline void from_c(const sk_matrix_t* cmatrix, SkMatrix* matrix) { matrix->setAll( cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2], @@ -507,17 +515,6 @@ static inline void from_sk(const SkMatrix* matrix, sk_matrix_t* cmatrix) { matrix->get9(cmatrix->mat); } -static inline bool from_c(const sk_codec_options_t& coptions, SkCodec::Options* options) { - if (options) { - *options = SkCodec::Options(); - options->fZeroInitialized = (SkCodec::ZeroInitialized)coptions.fZeroInitialized; - if (coptions.fHasSubset) { - options->fSubset = AsIRect((sk_irect_t*)&coptions.fSubset); - } - } - return true; -} - static inline bool from_c(const sk_imageinfo_t& cinfo, SkImageInfo* info) { if (info) { *info = SkImageInfo::Make( -- 2.7.4