xbintsc 0.5.21 → 0.5.23

package/runtime/ext_gui/canvas_style.cpp

@@ -0,0 +1,240 @@
+/*
+ * xbintsc GUI engine — Canvas2D drawing-state parsing.
+ *
+ * The state object itself lives in `canvas.h`; this unit parses the strings the
+ * DOM setters receive (CSS colours, the `font` shorthand, `lineCap`/`lineJoin`
+ * keywords) and validates the dash list. Keeping the parsing out of
+ * `canvas.cpp` leaves that unit free to own the path and draw entry points.
+ */
+
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "canvas.h"
+#include "css.h"
+
+namespace xtgui {
+
+namespace {
+
+std::string lower_ascii(const std::string &value) {
+  std::string out = value;
+  for (char &c : out) {
+    if (c >= 'A' && c <= 'Z') c = (char)(c - 'A' + 'a');
+  }
+  return out;
+}
+
+bool parse_font_size_token(const std::string &token, float fallback, float *out) {
+  std::string lower = lower_ascii(token);
+  struct Suffix {
+    const char *text;
+    float factor;
+  };
+  static const Suffix suffixes[] = {{"px", 1.0f},  {"pt", 96.0f / 72.0f}, {"pc", 16.0f},
+                                    {"in", 96.0f}, {"cm", 96.0f / 2.54f}, {"mm", 96.0f / 25.4f},
+                                    {"q", 96.0f / 101.6f}, {"em", 0.0f}, {"rem", 0.0f}};
+  for (const Suffix &suffix : suffixes) {
+    size_t length = std::strlen(suffix.text);
+    if (lower.size() <= length || lower.compare(lower.size() - length, length, suffix.text) != 0)
+      continue;
+    char *end = nullptr;
+    float value = std::strtof(lower.c_str(), &end);
+    if (end == lower.c_str()) return false;
+    if (suffix.factor == 0.0f) {
+      *out = value * fallback;
+    } else {
+      *out = value * suffix.factor;
+    }
+    return true;
+  }
+  return false;
+}
+
+/** Parse the CSS `font` shorthand into a `FontSpec` (the pieces Canvas2D
+ * understands; unknown tokens are ignored). */
+FontSpec parse_font_string(const std::string &text) {
+  FontSpec spec;
+  spec.family = "sans-serif";
+  spec.pixel_size = 10.0f;
+  spec.weight = 400;
+  spec.italic = false;
+  std::vector<std::string> tokens = xt_css_split_whitespace(text);
+  std::vector<std::string> family;
+  float size = 10.0f;
+  bool have_size = false;
+  for (const std::string &token : tokens) {
+    std::string lower = lower_ascii(token);
+    float parsed = 0.0f;
+    if (!have_size && parse_font_size_token(lower, 16.0f, &parsed)) {
+      size = parsed;
+      have_size = true;
+      continue;
+    }
+    if (lower == "italic" || lower == "oblique") {
+      spec.italic = true;
+      continue;
+    }
+    if (lower == "bold" || lower == "bolder") {
+      spec.weight = 700;
+      continue;
+    }
+    if (lower == "lighter") {
+      spec.weight = 300;
+      continue;
+    }
+    if (lower == "normal" || lower == "small-caps") continue;
+    if (!lower.empty() && lower.back() == ',') lower.pop_back();
+    if (!lower.empty()) family.push_back(lower);
+  }
+  spec.pixel_size = size;
+  if (!family.empty()) spec.family = family[0];
+  return spec;
+}
+
+void parse_color_into(const std::string &css, float color[4], std::string *stored) {
+  Color parsed = xt_css_parse_color(css);
+  if (!parsed.valid) return;
+  color[0] = parsed.r;
+  color[1] = parsed.g;
+  color[2] = parsed.b;
+  color[3] = parsed.a;
+  *stored = css;
+}
+
+bool positive_finite(float value) { return std::isfinite(value) && value >= 0.0f; }
+
+}  // namespace
+
+void Canvas2D::set_fill_style(const std::string &css) {
+  parse_color_into(css, state_.fill_color, &state_.fill_style);
+  state_.fill_gradient = 0;
+}
+
+void Canvas2D::set_stroke_style(const std::string &css) {
+  parse_color_into(css, state_.stroke_color, &state_.stroke_style);
+  state_.stroke_gradient = 0;
+}
+
+void Canvas2D::set_fill_gradient(uint64_t id) {
+  if (id == 0) {
+    state_.fill_gradient = 0;
+    return;
+  }
+  if (find_gradient(id) != nullptr) state_.fill_gradient = id;
+}
+
+void Canvas2D::set_stroke_gradient(uint64_t id) {
+  if (id == 0) {
+    state_.stroke_gradient = 0;
+    return;
+  }
+  if (find_gradient(id) != nullptr) state_.stroke_gradient = id;
+}
+
+void Canvas2D::set_global_alpha(float alpha) {
+  if (!std::isfinite(alpha)) return;
+  if (alpha < 0.0f) alpha = 0.0f;
+  if (alpha > 1.0f) alpha = 1.0f;
+  state_.global_alpha = alpha;
+}
+
+void Canvas2D::set_font(const std::string &font) {
+  state_.font = parse_font_string(font);
+  state_.font_string = font;
+}
+
+void Canvas2D::set_text_align(const std::string &value) {
+  std::string lower = lower_ascii(value);
+  if (lower == "start" || lower == "left") {
+    state_.text_align = 0;
+  } else if (lower == "center") {
+    state_.text_align = 1;
+  } else if (lower == "right" || lower == "end") {
+    state_.text_align = 2;
+  } else {
+    return;
+  }
+  state_.text_align_string = lower;
+}
+
+void Canvas2D::set_text_baseline(const std::string &value) {
+  std::string lower = lower_ascii(value);
+  if (lower == "alphabetic") {
+    state_.text_baseline = 0;
+  } else if (lower == "top") {
+    state_.text_baseline = 1;
+  } else if (lower == "middle") {
+    state_.text_baseline = 2;
+  } else if (lower == "bottom") {
+    state_.text_baseline = 3;
+  } else if (lower == "hanging") {
+    state_.text_baseline = 4;
+  } else if (lower == "ideographic") {
+    state_.text_baseline = 5;
+  } else {
+    return;
+  }
+  state_.text_baseline_string = lower;
+}
+
+void Canvas2D::set_line_cap(const std::string &value) {
+  std::string lower = lower_ascii(value);
+  if (lower == "butt") {
+    state_.line_cap = 0;
+  } else if (lower == "round") {
+    state_.line_cap = 1;
+  } else if (lower == "square") {
+    state_.line_cap = 2;
+  } else {
+    return;
+  }
+  state_.line_cap_string = lower;
+}
+
+void Canvas2D::set_line_join(const std::string &value) {
+  std::string lower = lower_ascii(value);
+  if (lower == "miter") {
+    state_.line_join = 0;
+  } else if (lower == "round") {
+    state_.line_join = 1;
+  } else if (lower == "bevel") {
+    state_.line_join = 2;
+  } else {
+    return;
+  }
+  state_.line_join_string = lower;
+}
+
+void Canvas2D::set_miter_limit(float limit) {
+  if (!std::isfinite(limit) || limit <= 0.0f) return;
+  state_.miter_limit = limit;
+}
+
+void Canvas2D::set_line_dash(const std::vector<float> &segments) {
+  if (segments.empty()) {
+    state_.line_dash.clear();
+    return;
+  }
+  for (float segment : segments) {
+    /* The spec ignores a list containing a negative or non-finite value. */
+    if (!positive_finite(segment)) return;
+  }
+  std::vector<float> pattern = segments;
+  if (pattern.size() % 2 == 1) {
+    const size_t count = pattern.size();
+    for (size_t i = 0; i < count; i++) pattern.push_back(pattern[i]);
+  }
+  float total = 0.0f;
+  for (float segment : pattern) total += segment;
+  if (total <= 0.0f) {
+    state_.line_dash.clear();
+    return;
+  }
+  state_.line_dash = std::move(pattern);
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/dom_api.cpp

@@ -33,6 +33,7 @@ xt_value g_event_proto = XT_UNDEFINED;
 xt_value g_class_list_proto = XT_UNDEFINED;
 xt_value g_style_proto = XT_UNDEFINED;
 xt_value g_canvas_proto = XT_UNDEFINED;
+xt_value g_canvas_gradient_proto = XT_UNDEFINED;
 
 /* -- small helpers -------------------------------------------------------- */
 

package/runtime/ext_gui/dom_api_canvas.cpp

@@ -43,6 +43,16 @@ std::string string_arg(int32_t argc, xt_value *argv, int32_t index) {
 
 }  // namespace
 
+xtgui::Canvas2D *canvas_from_context(xt_value self) { return context_canvas(self); }
+
+double canvas_number_arg(int32_t argc, xt_value *argv, int32_t index, double fallback) {
+  return number_arg(argc, argv, index, fallback);
+}
+
+std::string canvas_string_arg(int32_t argc, xt_value *argv, int32_t index) {
+  return string_arg(argc, argv, index);
+}
+
 METHOD(node_get_context) {
   (void)env;
   std::string mode = string_arg(argc, argv, 0);
@@ -152,13 +162,25 @@ METHOD(canvas_fill_style_get) {
   (void)argc;
   (void)argv;
   xtgui::Canvas2D *canvas = context_canvas(self);
-  return xt_string_from_cstr(canvas != nullptr ? canvas->fill_style().c_str() : "#000000");
+  if (canvas == nullptr) return xt_string_from_cstr("#000000");
+  if (canvas->fill_gradient_id() != 0) {
+    return canvas_gradient_handle(self, canvas, canvas->fill_gradient_id());
+  }
+  return xt_string_from_cstr(canvas->fill_style().c_str());
 }
 
 METHOD(canvas_fill_style_set) {
   (void)env;
   xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr) canvas->set_fill_style(string_arg(argc, argv, 0));
+  if (canvas == nullptr) return XT_UNDEFINED;
+  if (argc > 0) {
+    uint64_t gradient = canvas_gradient_id(xt_arg(argc, argv, 0), canvas);
+    if (gradient != 0) {
+      canvas->set_fill_gradient(gradient);
+      return XT_UNDEFINED;
+    }
+  }
+  canvas->set_fill_style(string_arg(argc, argv, 0));
   return XT_UNDEFINED;
 }
 
@@ -167,13 +189,25 @@ METHOD(canvas_stroke_style_get) {
   (void)argc;
   (void)argv;
   xtgui::Canvas2D *canvas = context_canvas(self);
-  return xt_string_from_cstr(canvas != nullptr ? canvas->stroke_style().c_str() : "#000000");
+  if (canvas == nullptr) return xt_string_from_cstr("#000000");
+  if (canvas->stroke_gradient_id() != 0) {
+    return canvas_gradient_handle(self, canvas, canvas->stroke_gradient_id());
+  }
+  return xt_string_from_cstr(canvas->stroke_style().c_str());
 }
 
 METHOD(canvas_stroke_style_set) {
   (void)env;
   xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr) canvas->set_stroke_style(string_arg(argc, argv, 0));
+  if (canvas == nullptr) return XT_UNDEFINED;
+  if (argc > 0) {
+    uint64_t gradient = canvas_gradient_id(xt_arg(argc, argv, 0), canvas);
+    if (gradient != 0) {
+      canvas->set_stroke_gradient(gradient);
+      return XT_UNDEFINED;
+    }
+  }
+  canvas->set_stroke_style(string_arg(argc, argv, 0));
   return XT_UNDEFINED;
 }
 

package/runtime/ext_gui/dom_api_canvas_extra.cpp

@@ -0,0 +1,232 @@
+/*
+ * xbintsc GUI engine — the newer half of the Canvas2D DOM surface.
+ *
+ * `dom_api_canvas.cpp` owns the original path/rect/text/image bindings and the
+ * shared context helpers; this unit adds gradients, ellipses, rounded
+ * rectangles, line caps/joins, dash patterns and `getTransform`. Keeping them
+ * separate keeps both translation units under the repository's file budget.
+ */
+
+#include "dom_api_internal.h"
+
+#include <cmath>
+#include <string>
+#include <vector>
+
+#include "canvas.h"
+#include "css.h"
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+namespace domapi {
+
+xt_value canvas_gradient_handle(xt_value context, const xtgui::Canvas2D *canvas, uint64_t id) {
+  const std::string key = "__xt_gui_grad_" + std::to_string(id);
+  xt_value cached = xt_object_get_cstr(context, key.c_str());
+  if (XT_IS_OBJECT(cached)) return cached;
+  xt_value handle = xt_object_new_with_proto(canvas_gradient_proto());
+  if (canvas != nullptr) {
+    xt_object_set(handle, xt_string_from_cstr("__xt_gui_canvas"), xt_number((double)canvas->id()));
+  }
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_gradient"), xt_number((double)id));
+  xt_object_set(context, xt_string_from_cstr(key.c_str()), handle);
+  return handle;
+}
+
+uint64_t canvas_gradient_id(xt_value handle, const xtgui::Canvas2D *canvas) {
+  if (canvas == nullptr || !XT_IS_OBJECT(handle)) return 0;
+  xt_value canvasId = xt_object_get_cstr(handle, "__xt_gui_canvas");
+  xt_value gradientId = xt_object_get_cstr(handle, "__xt_gui_gradient");
+  if (!XT_IS_NUMBER(canvasId) || !XT_IS_NUMBER(gradientId)) return 0;
+  if ((uint64_t)xt_to_number(canvasId) != canvas->id()) return 0;
+  uint64_t id = (uint64_t)xt_to_number(gradientId);
+  return canvas->find_gradient(id) == nullptr ? 0 : id;
+}
+
+/* -- gradients ------------------------------------------------------------ */
+
+METHOD(canvas_create_linear_gradient) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr) return XT_NULL;
+  xtgui::CanvasGradient *gradient = canvas->create_linear_gradient(
+      (float)canvas_number_arg(argc, argv, 0, 0.0), (float)canvas_number_arg(argc, argv, 1, 0.0),
+      (float)canvas_number_arg(argc, argv, 2, 0.0), (float)canvas_number_arg(argc, argv, 3, 0.0));
+  return canvas_gradient_handle(self, canvas, gradient->id());
+}
+
+METHOD(canvas_create_radial_gradient) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr) return XT_NULL;
+  xtgui::CanvasGradient *gradient = canvas->create_radial_gradient(
+      (float)canvas_number_arg(argc, argv, 0, 0.0), (float)canvas_number_arg(argc, argv, 1, 0.0),
+      (float)canvas_number_arg(argc, argv, 2, 0.0), (float)canvas_number_arg(argc, argv, 3, 0.0),
+      (float)canvas_number_arg(argc, argv, 4, 0.0), (float)canvas_number_arg(argc, argv, 5, 0.0));
+  return canvas_gradient_handle(self, canvas, gradient->id());
+}
+
+METHOD(canvas_gradient_add_color_stop) {
+  (void)env;
+  xt_value canvasId = xt_object_get_cstr(self, "__xt_gui_canvas");
+  xt_value gradientId = xt_object_get_cstr(self, "__xt_gui_gradient");
+  if (!XT_IS_NUMBER(canvasId) || !XT_IS_NUMBER(gradientId)) return XT_UNDEFINED;
+  xtgui::Canvas2D *canvas = xtgui::xt_canvas_by_id((uint64_t)xt_to_number(canvasId));
+  if (canvas == nullptr) return XT_UNDEFINED;
+  xtgui::CanvasGradient *gradient = canvas->find_gradient((uint64_t)xt_to_number(gradientId));
+  if (gradient == nullptr) return XT_UNDEFINED;
+  xtgui::Color color = xtgui::xt_css_parse_color(canvas_string_arg(argc, argv, 1));
+  if (!color.valid) return XT_UNDEFINED;
+  float rgba[4] = {color.r, color.g, color.b, color.a};
+  gradient->add_color_stop((float)canvas_number_arg(argc, argv, 0, 0.0), rgba);
+  return XT_UNDEFINED;
+}
+
+/* -- paths ---------------------------------------------------------------- */
+
+METHOD(canvas_ellipse) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) {
+    canvas->ellipse((float)canvas_number_arg(argc, argv, 0, 0.0),
+                    (float)canvas_number_arg(argc, argv, 1, 0.0),
+                    (float)canvas_number_arg(argc, argv, 2, 0.0),
+                    (float)canvas_number_arg(argc, argv, 3, 0.0),
+                    (float)canvas_number_arg(argc, argv, 4, 0.0),
+                    (float)canvas_number_arg(argc, argv, 5, 0.0),
+                    (float)canvas_number_arg(argc, argv, 6, 0.0),
+                    value_truthy(xt_arg(argc, argv, 7)));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_round_rect) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) {
+    canvas->round_rect((float)canvas_number_arg(argc, argv, 0, 0.0),
+                       (float)canvas_number_arg(argc, argv, 1, 0.0),
+                       (float)canvas_number_arg(argc, argv, 2, 0.0),
+                       (float)canvas_number_arg(argc, argv, 3, 0.0),
+                       (float)canvas_number_arg(argc, argv, 4, 0.0));
+  }
+  return XT_UNDEFINED;
+}
+
+/* -- line styles ---------------------------------------------------------- */
+
+METHOD(canvas_line_cap_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_string_from_cstr(canvas != nullptr ? canvas->line_cap().c_str() : "butt");
+}
+
+METHOD(canvas_line_cap_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_line_cap(canvas_string_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_line_join_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_string_from_cstr(canvas != nullptr ? canvas->line_join().c_str() : "miter");
+}
+
+METHOD(canvas_line_join_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_line_join(canvas_string_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_miter_limit_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_number(canvas != nullptr ? canvas->miter_limit() : 10.0);
+}
+
+METHOD(canvas_miter_limit_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_miter_limit((float)canvas_number_arg(argc, argv, 0, 10.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_line_dash_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  xt_value result = xt_array_new(0, nullptr);
+  if (canvas != nullptr) {
+    for (float entry : canvas->line_dash()) xt_array_push(result, xt_number(entry));
+  }
+  return result;
+}
+
+METHOD(canvas_line_dash_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr) return XT_UNDEFINED;
+  std::vector<float> pattern;
+  if (argc > 0) {
+    xt_value value = xt_arg(argc, argv, 0);
+    if (XT_IS_ARRAY(value)) {
+      int32_t size = xt_array_size(value);
+      for (int32_t i = 0; i < size; i++) {
+        pattern.push_back((float)xt_to_number(xt_array_get(value, xt_number((double)i))));
+      }
+    }
+  }
+  canvas->set_line_dash(pattern);
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_line_dash_offset_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_number(canvas != nullptr ? canvas->line_dash_offset() : 0.0);
+}
+
+METHOD(canvas_line_dash_offset_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) {
+    canvas->set_line_dash_offset((float)canvas_number_arg(argc, argv, 0, 0.0));
+  }
+  return XT_UNDEFINED;
+}
+
+/* -- transform ------------------------------------------------------------ */
+
+METHOD(canvas_get_transform) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  const xtgui::CanvasTransform transform =
+      canvas != nullptr ? canvas->current_transform() : xtgui::CanvasTransform();
+  xt_value result = xt_object_new();
+  xt_object_set(result, xt_string_from_cstr("a"), xt_number(transform.a));
+  xt_object_set(result, xt_string_from_cstr("b"), xt_number(transform.b));
+  xt_object_set(result, xt_string_from_cstr("c"), xt_number(transform.c));
+  xt_object_set(result, xt_string_from_cstr("d"), xt_number(transform.d));
+  xt_object_set(result, xt_string_from_cstr("e"), xt_number(transform.e));
+  xt_object_set(result, xt_string_from_cstr("f"), xt_number(transform.f));
+  xt_object_set(result, xt_string_from_cstr("is2D"), xt_bool(true));
+  return result;
+}
+
+}  // namespace domapi
+
+#undef METHOD

package/runtime/ext_gui/dom_api_internal.h

@@ -28,6 +28,7 @@ extern xt_value g_event_proto;
 extern xt_value g_class_list_proto;
 extern xt_value g_style_proto;
 extern xt_value g_canvas_proto;
+extern xt_value g_canvas_gradient_proto;
 
 xt_value node_proto();
 xt_value document_proto();
@@ -35,6 +36,20 @@ xt_value event_proto();
 xt_value class_list_proto();
 xt_value style_proto();
 xt_value canvas_proto();
+xt_value canvas_gradient_proto();
+
+/* -- canvas helpers shared by `dom_api_canvas*.cpp` ----------------------- */
+
+/** The engine canvas behind a 2D context handle, or null when stale/foreign. */
+xtgui::Canvas2D *canvas_from_context(xt_value self);
+double canvas_number_arg(int32_t argc, xt_value *argv, int32_t index, double fallback);
+std::string canvas_string_arg(int32_t argc, xt_value *argv, int32_t index);
+/** The cached `CanvasGradient` handle for `id` on `canvas`; cached on the
+ * context so `ctx.fillStyle === gradient` holds after `fillStyle = gradient`. */
+xt_value canvas_gradient_handle(xt_value context, const xtgui::Canvas2D *canvas, uint64_t id);
+/** The gradient id stored on a handle, or 0 when it is not a gradient for
+ * `canvas` (stale or created by another canvas). */
+uint64_t canvas_gradient_id(xt_value handle, const xtgui::Canvas2D *canvas);
 
 /* -- cross-unit helpers --------------------------------------------------- */
 
@@ -195,6 +210,22 @@ METHOD(canvas_fill_text);
 METHOD(canvas_stroke_text);
 METHOD(canvas_draw_image);
 METHOD(canvas_get_image_data);
+METHOD(canvas_ellipse);
+METHOD(canvas_round_rect);
+METHOD(canvas_line_cap_get);
+METHOD(canvas_line_cap_set);
+METHOD(canvas_line_join_get);
+METHOD(canvas_line_join_set);
+METHOD(canvas_miter_limit_get);
+METHOD(canvas_miter_limit_set);
+METHOD(canvas_line_dash_get);
+METHOD(canvas_line_dash_set);
+METHOD(canvas_line_dash_offset_get);
+METHOD(canvas_line_dash_offset_set);
+METHOD(canvas_get_transform);
+METHOD(canvas_create_linear_gradient);
+METHOD(canvas_create_radial_gradient);
+METHOD(canvas_gradient_add_color_stop);
 
 /* classList methods */
 METHOD(class_list_add);

package/runtime/ext_gui/dom_api_proto.cpp

@@ -181,6 +181,14 @@ xt_value canvas_proto() {
   define_setter(proto, "textAlign", (void *)canvas_text_align_set);
   define_getter(proto, "textBaseline", (void *)canvas_text_baseline_get);
   define_setter(proto, "textBaseline", (void *)canvas_text_baseline_set);
+  define_getter(proto, "lineCap", (void *)canvas_line_cap_get);
+  define_setter(proto, "lineCap", (void *)canvas_line_cap_set);
+  define_getter(proto, "lineJoin", (void *)canvas_line_join_get);
+  define_setter(proto, "lineJoin", (void *)canvas_line_join_set);
+  define_getter(proto, "miterLimit", (void *)canvas_miter_limit_get);
+  define_setter(proto, "miterLimit", (void *)canvas_miter_limit_set);
+  define_getter(proto, "lineDashOffset", (void *)canvas_line_dash_offset_get);
+  define_setter(proto, "lineDashOffset", (void *)canvas_line_dash_offset_set);
   /* Methods. */
   define_method(proto, "save", (void *)canvas_save);
   define_method(proto, "restore", (void *)canvas_restore);
@@ -195,7 +203,9 @@ xt_value canvas_proto() {
   define_method(proto, "moveTo", (void *)canvas_move_to);
   define_method(proto, "lineTo", (void *)canvas_line_to);
   define_method(proto, "rect", (void *)canvas_rect);
+  define_method(proto, "roundRect", (void *)canvas_round_rect);
   define_method(proto, "arc", (void *)canvas_arc);
+  define_method(proto, "ellipse", (void *)canvas_ellipse);
   define_method(proto, "quadraticCurveTo", (void *)canvas_quadratic_curve_to);
   define_method(proto, "bezierCurveTo", (void *)canvas_bezier_curve_to);
   define_method(proto, "fill", (void *)canvas_fill);
@@ -208,8 +218,22 @@ xt_value canvas_proto() {
   define_method(proto, "strokeText", (void *)canvas_stroke_text);
   define_method(proto, "drawImage", (void *)canvas_draw_image);
   define_method(proto, "getImageData", (void *)canvas_get_image_data);
+  define_method(proto, "setLineDash", (void *)canvas_line_dash_set);
+  define_method(proto, "getLineDash", (void *)canvas_line_dash_get);
+  define_method(proto, "getTransform", (void *)canvas_get_transform);
+  define_method(proto, "createLinearGradient", (void *)canvas_create_linear_gradient);
+  define_method(proto, "createRadialGradient", (void *)canvas_create_radial_gradient);
   g_canvas_proto = proto;
   return proto;
 }
 
+xt_value canvas_gradient_proto() {
+  xt_gc_add_root(&g_canvas_gradient_proto);
+  if (XT_IS_OBJECT(g_canvas_gradient_proto)) return g_canvas_gradient_proto;
+  xt_value proto = xt_object_new();
+  define_method(proto, "addColorStop", (void *)canvas_gradient_add_color_stop);
+  g_canvas_gradient_proto = proto;
+  return proto;
+}
+
 }  // namespace domapi