add the following fields to the lua accumulate table: - rrect.rect - rrect[1..8] for radii - rrect.…

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"
 
 extern "C" {
     #include "lua.h"
 }
 
 static void setfield_string(lua_State* L, const char key[], const char value[]) {
     lua_pushstring(L, value);
     lua_setfield(L, -2, key);
 }
 
 static void setfield_number(lua_State* L, const char key[], double value) {
     lua_pushnumber(L, value);
     lua_setfield(L, -2, key);
 }
 
 static void setfield_bool(lua_State* L, const char key[], bool value) {
     lua_pushboolean(L, value);
     lua_setfield(L, -2, key);
 }
 
+// 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) {
     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);
     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";
+        case SkRRect::kComplex_Type: return "complex";
+    }
+    SkASSERT(!"never get here");
+    return "";
+}
+
+static void setfield_rrect(lua_State* L, const char key[], const SkRRect& rr) {
+    lua_newtable(L);
+    setfield_rect(L, "rect", rr.getBounds());
+    setfield_string(L, "type", rrect_type(rr));
+
+    SkVector rad[4] = {
+        rr.radii(SkRRect::kUpperLeft_Corner),
+        rr.radii(SkRRect::kUpperRight_Corner),
+        rr.radii(SkRRect::kLowerRight_Corner),
+        rr.radii(SkRRect::kLowerLeft_Corner),
+    };
+    setfield_arrayf(L, &rad[0].fX, 8);
+    lua_setfield(L, -2, key);
+}
+
 enum PaintUsage {
     kText_PaintUsage,
     kImage_PaintUsage,
     kGeometry_PaintUsage
 };
 
 static const char* color2string(SkColor c, SkString* str) {
     str->printf("0x%08X", c);
     return str->c_str();
 }
@@ skipping 116 matching lines @@
 
 bool SkLuaCanvas::clipRect(const SkRect& r, SkRegion::Op op, bool doAA) {
     AUTO_LUA("clipRect");
     setfield_rect(fL, "rect", r);
     setfield_bool(fL, "aa", doAA);
     return this->INHERITED::clipRect(r, op, doAA);
 }
 
 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_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) {
     AUTO_LUA("drawPaint");
     setfield_paint(fL, paint);
 }
 
 void SkLuaCanvas::drawPoints(PointMode mode, size_t count,
                                const SkPoint pts[], const SkPaint& paint) {
     AUTO_LUA("drawPoints");
     setfield_paint(fL, paint);
 }
 
 void SkLuaCanvas::drawOval(const SkRect& rect, const SkPaint& paint) {
     AUTO_LUA("drawOval");
-    setfield_rect(fL, "rect", rect);
+    setfield_rect(fL, "oval", rect);
     setfield_paint(fL, paint);
 }
 
 void SkLuaCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
     AUTO_LUA("drawRect");
     setfield_rect(fL, "rect", rect);
     setfield_paint(fL, paint);
 }
 
 void SkLuaCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
     AUTO_LUA("drawRRect");
-    setfield_rect(fL, "rect", rrect.getBounds());
+    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_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 59 matching lines @@
                                  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");
 }