add maskfilter to c api

src/c/sk_surface.cpp

 /*
  * 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 "sk_canvas.h"
 #include "sk_image.h"
 #include "sk_paint.h"
 #include "sk_path.h"
 #include "sk_surface.h"
 
 #include "SkCanvas.h"
 #include "SkImage.h"
+#include "SkMaskFilter.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPictureRecorder.h"
 #include "SkSurface.h"
 
 const struct {
     sk_colortype_t  fC;
     SkColorType     fSK;
 } gColorTypeMap[] = {
@@ skipping 129 matching lines @@
 }
 
 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 SkMaskFilter* AsMaskFilter(sk_maskfilter_t* cfilter) {
+    return reinterpret_cast<SkMaskFilter*>(cfilter);
+}
+
+static sk_maskfilter_t* ToMaskFilter(SkMaskFilter* filter) {
+    return reinterpret_cast<sk_maskfilter_t*>(filter);
+}
+
 static SkShader* AsShader(sk_shader_t* cshader) {
     return reinterpret_cast<SkShader*>(cshader);
 }
 
 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);
@@ skipping 75 matching lines @@
 }
 
 void sk_paint_set_color(sk_paint_t* cpaint, sk_color_t c) {
     AsPaint(cpaint)->setColor(c);
 }
 
 void sk_paint_set_shader(sk_paint_t* cpaint, sk_shader_t* cshader) {
     AsPaint(cpaint)->setShader(AsShader(cshader));
 }
 
+void sk_paint_set_maskfilter(sk_paint_t* cpaint, sk_maskfilter_t* cfilter) {
+    AsPaint(cpaint)->setMaskFilter(AsMaskFilter(cfilter));
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 sk_path_t* sk_path_new() {
     return (sk_path_t*)SkNEW(SkPath);
 }
 
 void sk_path_delete(sk_path_t* cpath) {
     SkDELETE(as_path(cpath));
 }
 
@@ skipping 258 matching lines @@
     } else {
         matrix.setIdentity();
     }
     SkShader* s = SkGradientShader::CreateLinear(reinterpret_cast<const SkPoint*>(pts),
                                                  reinterpret_cast<const SkColor*>(colors),
                                                  colorPos, colorCount, mode, 0, &matrix);
     return (sk_shader_t*)s;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
+
+#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));
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 void sk_test_capi(SkCanvas* canvas) {
     sk_imageinfo_t cinfo;
     cinfo.width = 100;
     cinfo.height = 100;
     cinfo.colorType = (sk_colortype_t)kN32_SkColorType;
     cinfo.alphaType = (sk_alphatype_t)kPremul_SkAlphaType;
     
     sk_surface_t* csurface = sk_surface_new_raster(&cinfo);
@@ skipping 24 matching lines @@
     sk_image_t* cimage = sk_surface_new_image_snapshot(csurface);
     
     // HERE WE CROSS THE C..C++ boundary
     canvas->drawImage((const SkImage*)cimage, 20, 20, NULL);
     
     sk_path_delete(cpath);
     sk_paint_delete(cpaint);
     sk_image_unref(cimage);
     sk_surface_unref(csurface);
 }