add blurimagefilter to lua

src/utils/SkLua.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLua.h"
 
 #if SK_SUPPORT_GPU
 #include "GrReducedClip.h"
 #endif
 
+#include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
 #include "SkDocument.h"
 #include "SkImage.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPictureRecorder.h"
 #include "SkPixelRef.h"
@@ skipping 12 matching lines @@
 // return the metatable name for a given class
 template <typename T> const char* get_mtname();
 #define DEF_MTNAME(T)                           \
     template <> const char* get_mtname<T>() {   \
         return #T "_LuaMetaTableName";          \
     }
 
 DEF_MTNAME(SkCanvas)
 DEF_MTNAME(SkDocument)
 DEF_MTNAME(SkImage)
+DEF_MTNAME(SkImageFilter)
 DEF_MTNAME(SkMatrix)
 DEF_MTNAME(SkRRect)
 DEF_MTNAME(SkPath)
 DEF_MTNAME(SkPaint)
 DEF_MTNAME(SkPathEffect)
 DEF_MTNAME(SkPicture)
 DEF_MTNAME(SkPictureRecorder)
 DEF_MTNAME(SkShader)
 DEF_MTNAME(SkSurface)
 DEF_MTNAME(SkTextBlob)
@@ skipping 339 matching lines @@
     SkScalar value;
     if (lua_isnil(L, -1)) {
         value = def;
     } else {
         value = lua2scalar(L, -1);
     }
     lua_pop(L, 1);
     return value;
 }
 
+static SkScalar byte2unit(U8CPU byte) {
+    return byte / 255.0f;
+}
+
 static U8CPU unit2byte(SkScalar x) {
     if (x <= 0) {
         return 0;
     } else if (x >= 1) {
         return 255;
     } else {
         return SkScalarRoundToInt(x * 255);
     }
 }
 
@@ skipping 364 matching lines @@
 static int lpaint_isAutohinted(lua_State* L) {
     lua_pushboolean(L, get_obj<SkPaint>(L, 1)->isAutohinted());
     return 1;
 }
 
 static int lpaint_isVerticalText(lua_State* L) {
     lua_pushboolean(L, get_obj<SkPaint>(L, 1)->isVerticalText());
     return 1;
 }
 
+static int lpaint_getAlpha(lua_State* L) {
+    SkLua(L).pushScalar(byte2unit(get_obj<SkPaint>(L, 1)->getAlpha()));
+    return 1;
+}
+
+static int lpaint_setAlpha(lua_State* L) {
+    get_obj<SkPaint>(L, 1)->setAlpha(unit2byte(lua2scalar(L, 2)));
+    return 0;
+}
+
 static int lpaint_getColor(lua_State* L) {
     SkLua(L).pushColor(get_obj<SkPaint>(L, 1)->getColor());
     return 1;
 }
 
 static int lpaint_setColor(lua_State* L) {
     get_obj<SkPaint>(L, 1)->setColor(lua2color(L, 2));
     return 0;
 }
 
@@ skipping 153 matching lines @@
     setfield_scalar(L, "bottom", fm.fBottom);
     setfield_scalar(L, "leading", fm.fLeading);
     SkLua(L).pushScalar(height);
     return 2;
 }
 
 static int lpaint_getEffects(lua_State* L) {
     const SkPaint* paint = get_obj<SkPaint>(L, 1);
 
     lua_newtable(L);
-    setfield_bool_if(L, "looper", !!paint->getLooper());
-    setfield_bool_if(L, "pathEffect", !!paint->getPathEffect());
-    setfield_bool_if(L, "rasterizer", !!paint->getRasterizer());
-    setfield_bool_if(L, "maskFilter", !!paint->getMaskFilter());
-    setfield_bool_if(L, "shader", !!paint->getShader());
+    setfield_bool_if(L, "looper",      !!paint->getLooper());
+    setfield_bool_if(L, "pathEffect",  !!paint->getPathEffect());
+    setfield_bool_if(L, "rasterizer",  !!paint->getRasterizer());
+    setfield_bool_if(L, "maskFilter",  !!paint->getMaskFilter());
+    setfield_bool_if(L, "shader",      !!paint->getShader());
     setfield_bool_if(L, "colorFilter", !!paint->getColorFilter());
     setfield_bool_if(L, "imageFilter", !!paint->getImageFilter());
-    setfield_bool_if(L, "xfermode", !!paint->getXfermode());
+    setfield_bool_if(L, "xfermode",    !!paint->getXfermode());
     return 1;
 }
 
+static int lpaint_getImageFilter(lua_State* L) {
+    const SkPaint* paint = get_obj<SkPaint>(L, 1);
+    SkImageFilter* imf = paint->getImageFilter();
+    if (imf) {
+        push_ref(L, imf);
+        return 1;
+    }
+    return 0;
+}
+
+static int lpaint_setImageFilter(lua_State* L) {
+    SkPaint* paint = get_obj<SkPaint>(L, 1);
+    paint->setImageFilter(get_ref<SkImageFilter>(L, 2));
+    return 0;
+}
+
 static int lpaint_getShader(lua_State* L) {
     const SkPaint* paint = get_obj<SkPaint>(L, 1);
     SkShader* shader = paint->getShader();
     if (shader) {
         push_ref(L, shader);
         return 1;
     }
     return 0;
 }
 
@@ skipping 20 matching lines @@
     { "isStrikeThruText", lpaint_isStrikeThruText },
     { "isFakeBoldText", lpaint_isFakeBoldText },
     { "isLinearText", lpaint_isLinearText },
     { "isSubpixelText", lpaint_isSubpixelText },
     { "setSubpixelText", lpaint_setSubpixelText },
     { "isDevKernText", lpaint_isDevKernText },
     { "isLCDRenderText", lpaint_isLCDRenderText },
     { "isEmbeddedBitmapText", lpaint_isEmbeddedBitmapText },
     { "isAutohinted", lpaint_isAutohinted },
     { "isVerticalText", lpaint_isVerticalText },
+    { "getAlpha", lpaint_getAlpha },
+    { "setAlpha", lpaint_setAlpha },
     { "getColor", lpaint_getColor },
     { "setColor", lpaint_setColor },
     { "getTextSize", lpaint_getTextSize },
     { "setTextSize", lpaint_setTextSize },
     { "getTextScaleX", lpaint_getTextScaleX },
     { "getTextSkewX", lpaint_getTextSkewX },
     { "getTypeface", lpaint_getTypeface },
     { "setTypeface", lpaint_setTypeface },
     { "getHinting", lpaint_getHinting },
     { "getFontID", lpaint_getFontID },
     { "getTextAlign", lpaint_getTextAlign },
     { "setTextAlign", lpaint_setTextAlign },
     { "getStroke", lpaint_getStroke },
     { "setStroke", lpaint_setStroke },
     { "getStrokeCap", lpaint_getStrokeCap },
     { "getStrokeJoin", lpaint_getStrokeJoin },
     { "getTextEncoding", lpaint_getTextEncoding },
     { "getStrokeWidth", lpaint_getStrokeWidth },
     { "setStrokeWidth", lpaint_setStrokeWidth },
     { "getStrokeMiter", lpaint_getStrokeMiter },
     { "measureText", lpaint_measureText },
     { "getFontMetrics", lpaint_getFontMetrics },
     { "getEffects", lpaint_getEffects },
+    { "getImageFilter", lpaint_getImageFilter },
+    { "setImageFilter", lpaint_setImageFilter },
     { "getShader", lpaint_getShader },
     { "getPathEffect", lpaint_getPathEffect },
     { "__gc", lpaint_gc },
     { NULL, NULL }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const char* mode2string(SkShader::TileMode mode) {
     static const char* gNames[] = { "clamp", "repeat", "mirror" };
@@ skipping 104 matching lines @@
 }
 
 static const struct luaL_Reg gSkPathEffect_Methods[] = {
     { "asADash",        lpatheffect_asADash },
     { "__gc",           lpatheffect_gc },
     { NULL, NULL }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static int lpimagefilter_gc(lua_State* L) {
+    get_ref<SkImageFilter>(L, 1)->unref();
+    return 0;
+}
+
+static const struct luaL_Reg gSkImageFilter_Methods[] = {
+    { "__gc",       lpimagefilter_gc },
+    { NULL, NULL }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
 static int lmatrix_getType(lua_State* L) {
     SkMatrix::TypeMask mask = get_obj<SkMatrix>(L, 1)->getType();
 
     lua_newtable(L);
     setfield_boolean(L, "translate",   SkToBool(mask & SkMatrix::kTranslate_Mask));
     setfield_boolean(L, "scale",       SkToBool(mask & SkMatrix::kScale_Mask));
     setfield_boolean(L, "affine",      SkToBool(mask & SkMatrix::kAffine_Mask));
     setfield_boolean(L, "perspective", SkToBool(mask & SkMatrix::kPerspective_Mask));
     return 1;
 }
@@ skipping 511 matching lines @@
     if (NULL == doc) {
         // do I need to push a nil on the stack and return 1?
         return 0;
     } else {
         push_ref(L, doc);
         doc->unref();
         return 1;
     }
 }
 
+static int lsk_newBlurImageFilter(lua_State* L) {
+    SkScalar sigmaX = lua2scalar_def(L, 1, 0);
+    SkScalar sigmaY = lua2scalar_def(L, 2, 0);
+    SkImageFilter* imf = SkBlurImageFilter::Create(sigmaX, sigmaY);
+    if (NULL == imf) {
+        lua_pushnil(L);
+    } else {
+        push_ref(L, imf);
+        imf->unref();
+    }
+    return 1;
+}
+
 static int lsk_newMatrix(lua_State* L) {
     push_new<SkMatrix>(L)->reset();
     return 1;
 }
 
 static int lsk_newPaint(lua_State* L) {
     push_new<SkPaint>(L);
     return 1;
 }
 
@@ skipping 68 matching lines @@
 }
 
 static void register_Sk(lua_State* L) {
     lua_newtable(L);
     lua_pushvalue(L, -1);
     lua_setglobal(L, "Sk");
     // the Sk table is still on top
 
     setfield_function(L, "newDocumentPDF", lsk_newDocumentPDF);
     setfield_function(L, "loadImage", lsk_loadImage);
+    setfield_function(L, "newBlurImageFilter", lsk_newBlurImageFilter);
     setfield_function(L, "newMatrix", lsk_newMatrix);
     setfield_function(L, "newPaint", lsk_newPaint);
     setfield_function(L, "newPath", lsk_newPath);
     setfield_function(L, "newPictureRecorder", lsk_newPictureRecorder);
     setfield_function(L, "newRRect", lsk_newRRect);
     setfield_function(L, "newRasterSurface", lsk_newRasterSurface);
     setfield_function(L, "newTypeface", lsk_newTypeface);
     lua_pop(L, 1);  // pop off the Sk table
 }
 
 #define REG_CLASS(L, C)                             \
     do {                                            \
         luaL_newmetatable(L, get_mtname<C>());      \
         lua_pushvalue(L, -1);                       \
         lua_setfield(L, -2, "__index");             \
         luaL_setfuncs(L, g##C##_Methods, 0);        \
         lua_pop(L, 1); /* pop off the meta-table */ \
     } while (0)
 
 void SkLua::Load(lua_State* L) {
     register_Sk(L);
     REG_CLASS(L, SkCanvas);
     REG_CLASS(L, SkDocument);
     REG_CLASS(L, SkImage);
+    REG_CLASS(L, SkImageFilter);
     REG_CLASS(L, SkPaint);
     REG_CLASS(L, SkPath);
     REG_CLASS(L, SkPathEffect);
     REG_CLASS(L, SkPicture);
     REG_CLASS(L, SkPictureRecorder);
     REG_CLASS(L, SkRRect);
     REG_CLASS(L, SkShader);
     REG_CLASS(L, SkSurface);
     REG_CLASS(L, SkTypeface);
     REG_CLASS(L, SkMatrix);
 }
 
 extern "C" int luaopen_skia(lua_State* L);
 extern "C" int luaopen_skia(lua_State* L) {
     SkLua::Load(L);
     return 0;
 }