add gradients and drawPaint 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 "SkGradientShader.h"
 #include "SkImage.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPictureRecorder.h"
 #include "SkPixelRef.h"
 #include "SkRRect.h"
 #include "SkString.h"
 #include "SkSurface.h"
 #include "SkTextBlob.h"
@@ skipping 35 matching lines @@
     lua_setmetatable(L, -2);
     return addr;
 }
 
 template <typename T> void push_obj(lua_State* L, const T& obj) {
     new (lua_newuserdata(L, sizeof(T))) T(obj);
     luaL_getmetatable(L, get_mtname<T>());
     lua_setmetatable(L, -2);
 }
 
-template <typename T> void push_ref(lua_State* L, T* ref) {
+template <typename T> T* push_ref(lua_State* L, T* ref) {
     *(T**)lua_newuserdata(L, sizeof(T*)) = SkSafeRef(ref);
     luaL_getmetatable(L, get_mtname<T>());
     lua_setmetatable(L, -2);
+    return ref;
 }
 
 template <typename T> T* get_ref(lua_State* L, int index) {
     return *(T**)luaL_checkudata(L, index, get_mtname<T>());
 }
 
 template <typename T> T* get_obj(lua_State* L, int index) {
     return (T*)luaL_checkudata(L, index, get_mtname<T>());
 }
 
@@ skipping 348 matching lines @@
 static int lcanvas_clear(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->clear(0);
     return 0;
 }
 
 static int lcanvas_drawColor(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->drawColor(lua2color(L, 2));
     return 0;
 }
 
+static int lcanvas_drawPaint(lua_State* L) {
+    get_ref<SkCanvas>(L, 1)->drawPaint(*get_obj<SkPaint>(L, 2));
+    return 0;
+}
+
 static int lcanvas_drawRect(lua_State* L) {
     SkRect rect;
     get_ref<SkCanvas>(L, 1)->drawRect(*lua2rect(L, 2, &rect),
                                       *get_obj<SkPaint>(L, 3));
     return 0;
 }
 
 static int lcanvas_drawOval(lua_State* L) {
     SkRect rect;
     get_ref<SkCanvas>(L, 1)->drawOval(*lua2rect(L, 2, &rect),
@@ skipping 183 matching lines @@
 }
 
 static int lcanvas_newSurface(lua_State* L) {
     int width = lua2int_def(L, 2, 0);
     int height = lua2int_def(L, 2, 0);
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     SkSurface* surface = get_ref<SkCanvas>(L, 1)->newSurface(info);
     if (NULL == surface) {
         lua_pushnil(L);
     } else {
-        push_ref(L, surface);
-        surface->unref();
+        push_ref(L, surface)->unref();
     }
     return 1;
 }
 
 static int lcanvas_gc(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->unref();
     return 0;
 }
 
 const struct luaL_Reg gSkCanvas_Methods[] = {
     { "clear", lcanvas_clear },
     { "drawColor", lcanvas_drawColor },
+    { "drawPaint", lcanvas_drawPaint },
     { "drawRect", lcanvas_drawRect },
     { "drawOval", lcanvas_drawOval },
     { "drawCircle", lcanvas_drawCircle },
     { "drawImage", lcanvas_drawImage },
     { "drawImageRect", lcanvas_drawImageRect },
     { "drawPath", lcanvas_drawPath },
     { "drawPicture", lcanvas_drawPicture },
     { "drawText", lcanvas_drawText },
     { "getSaveCount", lcanvas_getSaveCount },
     { "getTotalMatrix", lcanvas_getTotalMatrix },
@@ skipping 332 matching lines @@
 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;
 }
 
+static int lpaint_setShader(lua_State* L) {
+    SkPaint* paint = get_obj<SkPaint>(L, 1);
+    paint->setShader(get_ref<SkShader>(L, 2));
+    return 0;
+}
+
 static int lpaint_getPathEffect(lua_State* L) {
     const SkPaint* paint = get_obj<SkPaint>(L, 1);
     SkPathEffect* pe = paint->getPathEffect();
     if (pe) {
         push_ref(L, pe);
         return 1;
     }
     return 0;
 }
 
@@ skipping 38 matching lines @@
     { "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 },
+    { "setShader", lpaint_setShader },
     { "getPathEffect", lpaint_getPathEffect },
     { "__gc", lpaint_gc },
     { NULL, NULL }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const char* mode2string(SkShader::TileMode mode) {
     static const char* gNames[] = { "clamp", "repeat", "mirror" };
     SkASSERT((unsigned)mode < SK_ARRAY_COUNT(gNames));
@@ skipping 474 matching lines @@
         // know that it is supposed to be treated as a canvas...
     }
     return 1;
 }
 
 static int lsurface_newImageSnapshot(lua_State* L) {
     SkImage* image = get_ref<SkSurface>(L, 1)->newImageSnapshot();
     if (NULL == image) {
         lua_pushnil(L);
     } else {
-        push_ref(L, image);
-        image->unref();
+        push_ref(L, image)->unref();
     }
     return 1;
 }
 
 static int lsurface_newSurface(lua_State* L) {
     int width = lua2int_def(L, 2, 0);
     int height = lua2int_def(L, 3, 0);
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     SkSurface* surface = get_ref<SkSurface>(L, 1)->newSurface(info);
     if (NULL == surface) {
         lua_pushnil(L);
     } else {
-        push_ref(L, surface);
-        surface->unref();
+        push_ref(L, surface)->unref();
     }
     return 1;
 }
 
 static int lsurface_gc(lua_State* L) {
     get_ref<SkSurface>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkSurface_Methods[] = {
@@ skipping 35 matching lines @@
     push_ref(L, canvas);
     return 1;
 }
 
 static int lpicturerecorder_endRecording(lua_State* L) {
     SkPicture* pic = get_obj<SkPictureRecorder>(L, 1)->endRecording();
     if (NULL == pic) {
         lua_pushnil(L);
         return 1;
     }
-    push_ref(L, pic);
-    pic->unref();   // lua is the only owner, so we unref ours
+    push_ref(L, pic)->unref();
     return 1;
 }
 
 static int lpicturerecorder_gc(lua_State* L) {
     get_obj<SkPictureRecorder>(L, 1)->~SkPictureRecorder();
     return 0;
 }
 
 static const struct luaL_Reg gSkPictureRecorder_Methods[] = {
     { "beginRecording", lpicturerecorder_beginRecording },
@@ skipping 73 matching lines @@
     const char* file = NULL;
     if (lua_gettop(L) > 0 && lua_isstring(L, 1)) {
         file = lua_tolstring(L, 1, NULL);
     }
 
     SkDocument* doc = SkDocument::CreatePDF(file);
     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();
+        push_ref(L, 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();
+        push_ref(L, imf)->unref();
     }
     return 1;
 }
+
+static int lsk_newLinearGradient(lua_State* L) {
+    SkScalar x0 = lua2scalar_def(L, 1, 0);
+    SkScalar y0 = lua2scalar_def(L, 2, 0);
+    SkColor  c0 = lua2color(L, 3);
+    SkScalar x1 = lua2scalar_def(L, 4, 0);
+    SkScalar y1 = lua2scalar_def(L, 5, 0);
+    SkColor  c1 = lua2color(L, 6);
+
+    SkPoint pts[] = { { x0, y0 }, { x1, y1 } };
+    SkColor colors[] = { c0, c1 };
+    SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
+    if (NULL == s) {
+        lua_pushnil(L);
+    } else {
+        push_ref(L, s)->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 24 matching lines @@
             style = lua_tointegerx(L, 2, NULL) & SkTypeface::kBoldItalic;
         }
     }
 
     SkTypeface* face = SkTypeface::CreateFromName(name,
                                                   (SkTypeface::Style)style);
 //    SkDebugf("---- name <%s> style=%d, face=%p ref=%d\n", name, style, face, face->getRefCnt());
     if (NULL == face) {
         face = SkTypeface::RefDefault();
     }
-    push_ref(L, face);
-    face->unref();
+    push_ref(L, face)->unref();
     return 1;
 }
 
 static int lsk_newRasterSurface(lua_State* L) {
     int width = lua2int_def(L, 2, 0);
     int height = lua2int_def(L, 2, 0);
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     SkSurface* surface = SkSurface::NewRaster(info);
     if (NULL == surface) {
         lua_pushnil(L);
     } else {
-        push_ref(L, surface);
-        surface->unref();
+        push_ref(L, surface)->unref();
     }
     return 1;
 }
 
 static int lsk_loadImage(lua_State* L) {
     if (lua_gettop(L) > 0 && lua_isstring(L, 1)) {
         const char* name = lua_tolstring(L, 1, NULL);
         SkAutoDataUnref data(SkData::NewFromFileName(name));
         if (data.get()) {
             SkImage* image = SkImage::NewFromGenerator(
                 SkDecodingImageGenerator::Create(data, SkDecodingImageGenerator::Options()));
 
             if (image) {
-                push_ref(L, image);
-                image->unref();
+                push_ref(L, image)->unref();
                 return 1;
             }
         }
     }
     return 0;
 }
 
 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, "newLinearGradient", lsk_newLinearGradient);
     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
 }
 
@@ skipping 22 matching lines @@
     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;
 }