add SkPath as real lua object

src/utils/SkLuaCanvas.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 "SkLuaCanvas.h"
 #include "SkRRect.h"
 
@@ skipping 19 matching lines @@
 
 // sets [1]...[count] in the table on the top of the stack
 static void setfield_arrayf(lua_State* L, const SkScalar array[], int count) {
     for (int i = 0; i < count; ++i) {
         lua_pushnumber(L, SkScalarToDouble(i + 1));     // key
         lua_pushnumber(L, SkScalarToDouble(array[i]));  // value
         lua_settable(L, -3);
     }
 }
 
-static void setfield_rect(lua_State* L, const char key[], const SkRect& r) {
+static void push_rect(lua_State* L, const SkRect& r) {
     lua_newtable(L);
     setfield_number(L, "left", r.fLeft);
     setfield_number(L, "top", r.fTop);
     setfield_number(L, "right", r.fRight);
     setfield_number(L, "bottom", r.fBottom);
+}
+
+static void setfield_rect(lua_State* L, const char key[], const SkRect& r) {
+    push_rect(L, r);
     lua_setfield(L, -2, key);
 }
 
 static const char* rrect_type(const SkRRect& rr) {
     switch (rr.getType()) {
         case SkRRect::kUnknown_Type: return "unknown";
         case SkRRect::kEmpty_Type: return "empty";
         case SkRRect::kRect_Type: return "rect";
         case SkRRect::kOval_Type: return "oval";
         case SkRRect::kSimple_Type: return "simple";
@@ skipping 109 matching lines @@
     { "__gc", lcanvas_gc },
     { NULL, NULL }
 };
 
 static void ensure_canvas_metatable(lua_State* L) {
     static bool gOnce;
     if (gOnce) {
         return;
     }
     gOnce = true;
-
+    
     luaL_newmetatable(L, gCanvasMetaTableName);
     lua_pushvalue(L, -1);
     lua_setfield(L, -2, "__index");
-
+    
     luaL_setfuncs(L, gLuaCanvasMethods, 0);
     lua_settop(L, -2);  // pop off the meta-table
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
+static const char gPathMetaTableName[] = "SkPath_MetaTable";
+
+static int lpath_getBounds(lua_State* L) {
+    SkPath* p = (SkPath*)luaL_checkudata(L, 1, gPathMetaTableName);
+    push_rect(L, p->getBounds());
+    return 1;
+}
+
+static int lpath_isEmpty(lua_State* L) {
+    SkPath* p = (SkPath*)luaL_checkudata(L, 1, gPathMetaTableName);
+    lua_pushboolean(L, p->isEmpty());
+    return 1;
+}
+
+static int lpath_isRect(lua_State* L) {
+    SkPath* p = (SkPath*)luaL_checkudata(L, 1, gPathMetaTableName);
+    SkRect r;
+    bool pred = p->isRect(&r);
+    int ret_count = 1;
+    lua_pushboolean(L, pred);
+    if (pred) {
+        push_rect(L, r);
+        ret_count += 1;
+    }
+    return ret_count;
+}
+
+static const char* dir2string(SkPath::Direction dir) {
+    static const char* gStr[] = {
+        "unknown", "cw", "ccw"
+    };
+    SkASSERT((unsigned)dir < SK_ARRAY_COUNT(gStr));
+    return gStr[dir];
+}
+
+static int lpath_isNestedRects(lua_State* L) {
+    SkPath* p = (SkPath*)luaL_checkudata(L, 1, gPathMetaTableName);
+    SkRect rects[2];
+    SkPath::Direction dirs[2];
+    bool pred = p->isNestedRects(rects, dirs);
+    int ret_count = 1;
+    lua_pushboolean(L, pred);
+    if (pred) {
+        push_rect(L, rects[0]);
+        push_rect(L, rects[1]);
+        lua_pushstring(L, dir2string(dirs[0]));
+        lua_pushstring(L, dir2string(dirs[0]));
+        ret_count += 4;
+    }
+    return ret_count;
+    return 1;
+}
+
+static int lpath_gc(lua_State* L) {
+    SkPath* p = (SkPath*)luaL_checkudata(L, 1, gPathMetaTableName);
+    p->~SkPath();
+    return 0;
+}
+
+static const struct luaL_Reg gLuaPathMethods[] = {
+    { "getBounds", lpath_getBounds },
+    { "isEmpty", lpath_isEmpty },
+    { "isRect", lpath_isRect },
+    { "isNestedRects", lpath_isNestedRects },
+    { "__gc", lpath_gc },
+    { NULL, NULL }
+};
+
+static void ensure_path_metatable(lua_State* L) {
+    static bool gOnce;
+    if (gOnce) {
+        return;
+    }
+    gOnce = true;
+    
+    luaL_newmetatable(L, gPathMetaTableName);
+    lua_pushvalue(L, -1);
+    lua_setfield(L, -2, "__index");
+    
+    luaL_setfuncs(L, gLuaPathMethods, 0);
+    lua_settop(L, -2);  // pop off the meta-table
+}
+
+static void push_path(lua_State* L, const SkPath& src) {
+    ensure_path_metatable(L);
+    
+    SkPath* path = (SkPath*)lua_newuserdata(L, sizeof(SkPath));
+    new (path) SkPath(src);
+
+    luaL_getmetatable(L, gPathMetaTableName);
+    lua_setmetatable(L, -2);
+}
+
+static void setfield_path(lua_State* L, const char key[], const SkPath& path) {
+    push_path(L, path);
+    lua_setfield(L, -2, key);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 void SkLuaCanvas::pushThis() {
     ensure_canvas_metatable(fL);
 
     SkCanvas** canvasPtr = (SkCanvas**)lua_newuserdata(fL, sizeof(SkCanvas*));
     luaL_getmetatable(fL, gCanvasMetaTableName);
     lua_setmetatable(fL, -2);
 
     this->ref();
     *canvasPtr = this;
 }
@@ skipping 81 matching lines @@
 
 bool SkLuaCanvas::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
     AUTO_LUA("clipRRect");
     setfield_rrect(fL, "rrect", rrect);
     setfield_bool(fL, "aa", doAA);
     return this->INHERITED::clipRRect(rrect, op, doAA);
 }
 
 bool SkLuaCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
     AUTO_LUA("clipPath");
+    setfield_path(fL, "path", path);
     setfield_bool(fL, "aa", doAA);
     return this->INHERITED::clipPath(path, op, doAA);
 }
 
 bool SkLuaCanvas::clipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
     AUTO_LUA("clipRegion");
     return this->INHERITED::clipRegion(deviceRgn, op);
 }
 
 void SkLuaCanvas::drawPaint(const SkPaint& paint) {
@@ skipping 20 matching lines @@
 }
 
 void SkLuaCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
     AUTO_LUA("drawRRect");
     setfield_rrect(fL, "rrect", rrect);
     setfield_paint(fL, paint);
 }
 
 void SkLuaCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
     AUTO_LUA("drawPath");
-    setfield_rect(fL, "bounds", path.getBounds());
-    setfield_bool(fL, "isRect", path.isRect(NULL));
-    setfield_bool(fL, "isOval", path.isOval(NULL));
+    setfield_path(fL, "path", path);
     setfield_paint(fL, paint);
 }
 
 void SkLuaCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
                                const SkPaint* paint) {
     AUTO_LUA("drawBitmap");
     if (paint) {
         setfield_paint(fL, *paint, kImage_PaintUsage);
     }
 }
@@ skipping 38 matching lines @@
                                  const SkScalar xpos[], SkScalar constY,
                                  const SkPaint& paint) {
     AUTO_LUA("drawPosTextH");
     setfield_paint(fL, paint, kText_PaintUsage);
 }
 
 void SkLuaCanvas::drawTextOnPath(const void* text, size_t byteLength,
                                    const SkPath& path, const SkMatrix* matrix,
                                    const SkPaint& paint) {
     AUTO_LUA("drawTextOnPath");
+    setfield_path(fL, "path", path);
     setfield_paint(fL, paint, kText_PaintUsage);
 }
 
 void SkLuaCanvas::drawPicture(SkPicture& picture) {
     AUTO_LUA("drawPicture");
     // call through so we can see the nested picture ops
     this->INHERITED::drawPicture(picture);
 }
 
 void SkLuaCanvas::drawVertices(VertexMode vmode, int vertexCount,
                                  const SkPoint vertices[], const SkPoint texs[],
                                  const SkColor colors[], SkXfermode* xmode,
                                  const uint16_t indices[], int indexCount,
                                  const SkPaint& paint) {
     AUTO_LUA("drawVertices");
     setfield_paint(fL, paint);
 }
 
 void SkLuaCanvas::drawData(const void* data, size_t length) {
     AUTO_LUA("drawData");
 }