xbintsc 0.5.36 → 0.5.37

package/runtime/ext_gui/canvas_raster.cpp

@@ -37,11 +37,15 @@ struct Crossing {
 /** Resolve `paint` at a device-space pixel centre. Gradients are defined in
  * user space, so the pixel is mapped back through the inverse transform. */
 void paint_color_at(const CanvasPaint &paint, float x, float y, float out[4]) {
-  if (paint.gradient != nullptr) {
+  if (paint.pattern != nullptr || paint.gradient != nullptr) {
     const CanvasTransform &inverse = paint.inverse;
     float userX = inverse.a * x + inverse.c * y + inverse.e;
     float userY = inverse.b * x + inverse.d * y + inverse.f;
-    if (paint.gradient->color_at(userX, userY, out)) return;
+    if (paint.pattern != nullptr) {
+      if (paint.pattern->color_at(userX, userY, out)) return;
+    } else if (paint.gradient->color_at(userX, userY, out)) {
+      return;
+    }
   }
   if (paint.color != nullptr) {
     for (int i = 0; i < 4; i++) out[i] = paint.color[i];
@@ -100,7 +104,7 @@ static void add_span(float *row, int rowOriginX, float xa, float xb, float weigh
 
 void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
                 const std::vector<std::vector<CanvasPoint>> &loops, const CanvasPaint &paint,
-                float alpha) {
+                float alpha, bool even_odd) {
   if (width <= 0 || height <= 0 || loops.empty()) return;
   bool havePoint = false;
   float minX = 0.0f, maxX = 0.0f, minY = 0.0f, maxY = 0.0f;
@@ -154,6 +158,14 @@ void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
       if (crossings.empty()) continue;
       std::sort(crossings.begin(), crossings.end(),
                 [](const Crossing &a, const Crossing &b) { return a.x < b.x; });
+      if (even_odd) {
+        /* Every second crossing toggles the covered span, regardless of the
+         * direction each contour is wound. */
+        for (size_t i = 0; i + 1 < crossings.size(); i += 2) {
+          add_span(row, x0, crossings[i].x, crossings[i + 1].x, weight, x0, x1);
+        }
+        continue;
+      }
       int winding = 0;
       float spanStart = 0.0f;
       for (const Crossing &crossing : crossings) {
@@ -179,8 +191,10 @@ void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
 }
 
 void fill_loop(std::vector<unsigned char> &pixels, int width, int height,
-               const std::vector<CanvasPoint> &loop, const CanvasPaint &paint, float alpha) {
-  fill_loops(pixels, width, height, std::vector<std::vector<CanvasPoint>>{loop}, paint, alpha);
+               const std::vector<CanvasPoint> &loop, const CanvasPaint &paint, float alpha,
+               bool even_odd) {
+  fill_loops(pixels, width, height, std::vector<std::vector<CanvasPoint>>{loop}, paint, alpha,
+             even_odd);
 }
 
 void fill_rect(std::vector<unsigned char> &pixels, int width, int height, float x0, float y0,
@@ -331,16 +345,24 @@ void draw_image_affine(std::vector<unsigned char> &pixels, int width, int height
 
 void blit_glyph(std::vector<unsigned char> &pixels, int width, int height,
                 const std::vector<unsigned char> &glyph, int glyphWidth, int glyphHeight, int left,
-                int top, float x, float baselineY, const CanvasPaint &paint, float alpha) {
-  int originX = (int)std::lround(x) + left;
+                int top, float x, float baselineY, float scale_x, const CanvasPaint &paint,
+                float alpha) {
+  if (glyphWidth <= 0 || glyphHeight <= 0) return;
+  if (scale_x <= 0.0f) scale_x = 1.0f;
+  bool condense = scale_x < 0.999f;
+  int drawWidth = condense ? std::max(1, (int)std::lround((float)glyphWidth * scale_x))
+                           : glyphWidth;
+  int originX = (int)std::lround(x) + (int)std::lround((float)left * scale_x);
   int originY = (int)std::lround(baselineY) - top;
   for (int gy = 0; gy < glyphHeight; gy++) {
     int py = originY + gy;
     if (py < 0 || py >= height) continue;
-    for (int gx = 0; gx < glyphWidth; gx++) {
+    for (int gx = 0; gx < drawWidth; gx++) {
       int px = originX + gx;
       if (px < 0 || px >= width) continue;
-      float coverage = glyph[(size_t)gy * (size_t)glyphWidth + (size_t)gx] / 255.0f;
+      /* Nearest sample from the glyph coverage mask when condensing. */
+      int sourceX = condense ? std::min(glyphWidth - 1, (int)((float)gx / scale_x)) : gx;
+      float coverage = glyph[(size_t)gy * (size_t)glyphWidth + (size_t)sourceX] / 255.0f;
       if (coverage <= 0.0f) continue;
       float color[4];
       paint_color_at(paint, (float)px + 0.5f, (float)py + 0.5f, color);

package/runtime/ext_gui/canvas_style.cpp

@@ -112,11 +112,13 @@ bool positive_finite(float value) { return std::isfinite(value) && value >= 0.0f
 void Canvas2D::set_fill_style(const std::string &css) {
   parse_color_into(css, state_.fill_color, &state_.fill_style);
   state_.fill_gradient = 0;
+  state_.fill_pattern = 0;
 }
 
 void Canvas2D::set_stroke_style(const std::string &css) {
   parse_color_into(css, state_.stroke_color, &state_.stroke_style);
   state_.stroke_gradient = 0;
+  state_.stroke_pattern = 0;
 }
 
 void Canvas2D::set_fill_gradient(uint64_t id) {
@@ -124,7 +126,7 @@ void Canvas2D::set_fill_gradient(uint64_t id) {
     state_.fill_gradient = 0;
     return;
   }
-  if (find_gradient(id) != nullptr) state_.fill_gradient = id;
+  if (find_gradient(id) != nullptr) { state_.fill_gradient = id; state_.fill_pattern = 0; }
 }
 
 void Canvas2D::set_stroke_gradient(uint64_t id) {
@@ -132,7 +134,7 @@ void Canvas2D::set_stroke_gradient(uint64_t id) {
     state_.stroke_gradient = 0;
     return;
   }
-  if (find_gradient(id) != nullptr) state_.stroke_gradient = id;
+  if (find_gradient(id) != nullptr) { state_.stroke_gradient = id; state_.stroke_pattern = 0; }
 }
 
 void Canvas2D::set_global_alpha(float alpha) {

package/runtime/ext_gui/dom.h

@@ -31,6 +31,10 @@ struct Node {
   NodeType type = NodeType::Element;
   std::string tag;   // lowercased element name (empty for document/text)
   std::string text;  // text content (text nodes only)
+  /* `createElementNS` keeps the namespace and the qualified name's prefix.
+   * Ordinary HTML elements leave both empty and report the XHTML namespace. */
+  std::string ns;
+  std::string ns_prefix;
   std::vector<Attr> attrs;
   Node *parent = nullptr;
   std::vector<std::unique_ptr<Node>> children;

package/runtime/ext_gui/dom_api.cpp

@@ -32,6 +32,7 @@ xt_value g_document_proto = XT_UNDEFINED;
 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_computed_style_proto = XT_UNDEFINED;
 xt_value g_canvas_proto = XT_UNDEFINED;
 xt_value g_canvas_gradient_proto = XT_UNDEFINED;
 

package/runtime/ext_gui/dom_api_canvas.cpp

@@ -41,10 +41,34 @@ std::string string_arg(int32_t argc, xt_value *argv, int32_t index) {
   return to_string_value(xt_arg(argc, argv, index));
 }
 
+/* Defined with the path bindings below; the transform methods accept a matrix
+ * argument too. */
+/** `transform(a, b, c, d, e, f)` or `transform(matrix)` where `matrix` is a
+ * `DOMMatrix`, `{ a, b, c, d, e, f }` or a six-element array. */
+bool canvas_matrix_arg(int32_t argc, xt_value *argv, int32_t index, float values[6]) {
+  if (index >= argc) return false;
+  xt_value value = xt_arg(argc, argv, index);
+  if (XT_IS_ARRAY(value)) {
+    if (xt_to_number(xt_array_length(value)) < 6) return false;
+    for (int i = 0; i < 6; i++) values[i] = (float)xt_to_number(xt_array_get(value, xt_number(i)));
+    return true;
+  }
+  if (!XT_IS_OBJECT(value)) return false;
+  static const char *const names[6] = {"a", "b", "c", "d", "e", "f"};
+  for (int i = 0; i < 6; i++) {
+    xt_value member = xt_object_get_cstr(value, names[i]);
+    if (!XT_IS_NUMBER(member)) return false;
+    values[i] = (float)xt_to_number(member);
+  }
+  return true;
+}
+
 }  // namespace
 
 xtgui::Canvas2D *canvas_from_context(xt_value self) { return context_canvas(self); }
 
+xt_value canvas_context_attributes(xt_value requested, bool alpha);
+
 double canvas_number_arg(int32_t argc, xt_value *argv, int32_t index, double fallback) {
   return number_arg(argc, argv, index, fallback);
 }
@@ -75,18 +99,70 @@ METHOD(node_get_context) {
   if (node == nullptr) return xt_canvas_pending_context(self, win);
   if (!node->isElement() || !node->isTag("canvas")) return XT_NULL;
   if (xt_gui_webgl_find(win, node) != nullptr) return XT_NULL;  // already a WebGL canvas
-  xtgui::Canvas2D *canvas = xt_gui_canvas_get(win, node);
-  if (canvas == nullptr) return XT_NULL;
   xt_value cached = xt_object_get_cstr(self, "__xt_gui_ctx");
   if (XT_IS_OBJECT(cached)) return cached;
+  xtgui::Canvas2D *canvas = xt_gui_canvas_get(win, node);
+  if (canvas == nullptr) return XT_NULL;
+  /* The second argument only takes effect when the context is created; a later
+   * `getContext("2d", ...)` returns the existing context unchanged. `alpha` is
+   * the one attribute with an observable effect on the bitmap. */
+  xt_value attributes = xt_arg(argc, argv, 1);
+  bool alpha = true;
+  if (XT_IS_OBJECT(attributes)) {
+    xt_value value = xt_object_get_cstr(attributes, "alpha");
+    if (XT_IS_BOOL(value)) alpha = value_truthy(value);
+  }
+  canvas->set_alpha(alpha);
   xt_value ctx = xt_object_new_with_proto(canvas_proto());
   xt_object_set(ctx, xt_string_from_cstr("__xt_gui_canvas"), xt_number((double)canvas->id()));
   /* Keep the element handle alive (and reachable) from the context. */
   xt_object_set(ctx, xt_string_from_cstr("__xt_gui_node"), self);
+  xt_object_set(ctx, xt_string_from_cstr("__xt_gui_ctx_attributes"),
+                canvas_context_attributes(attributes, alpha));
   xt_object_set(self, xt_string_from_cstr("__xt_gui_ctx"), ctx);
   return ctx;
 }
 
+/** The attributes object `getContextAttributes()` reports. Options the engine
+ * does not implement keep their specification default, so a feature test sees
+ * an honest answer instead of `undefined`. */
+xt_value canvas_context_attributes(xt_value requested, bool alpha) {
+  xt_value result = xt_object_new();
+  struct Attribute {
+    const char *name;
+    bool fallback;
+  };
+  const Attribute defaults[] = {
+      {"alpha", alpha},           {"antialias", true},
+      {"depth", true},            {"stencil", false},
+      {"premultipliedAlpha", true}, {"preserveDrawingBuffer", false},
+      {"desynchronized", false},  {"willReadFrequently", false},
+      {"failIfMajorPerformanceCaveat", false},
+  };
+  for (const Attribute &attribute : defaults) {
+    xt_value value = XT_UNDEFINED;
+    if (XT_IS_OBJECT(requested)) value = xt_object_get_cstr(requested, attribute.name);
+    if (XT_IS_BOOL(value)) {
+      xt_object_set(result, xt_string_from_cstr(attribute.name), value);
+    } else {
+      xt_object_set(result, xt_string_from_cstr(attribute.name),
+                    attribute.fallback ? XT_TRUE : XT_FALSE);
+    }
+  }
+  xt_object_set(result, xt_string_from_cstr("powerPreference"),
+                xt_string_from_cstr("default"));
+  xt_object_set(result, xt_string_from_cstr("colorSpace"), xt_string_from_cstr("srgb"));
+  return result;
+}
+
+METHOD(canvas_get_context_attributes) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value stored = xt_object_get_cstr(self, "__xt_gui_ctx_attributes");
+  return XT_IS_OBJECT(stored) ? stored : canvas_context_attributes(XT_UNDEFINED, true);
+}
+
 METHOD(canvas_get_canvas) {
   (void)env;
   (void)argc;
@@ -103,6 +179,9 @@ METHOD(canvas_fill_style_get) {
   if (canvas->fill_gradient_id() != 0) {
     return canvas_gradient_handle(self, canvas, canvas->fill_gradient_id());
   }
+  if (canvas->fill_pattern_id() != 0) {
+    return canvas_pattern_handle(self, canvas, canvas->fill_pattern_id());
+  }
   return xt_string_from_cstr(canvas->fill_style().c_str());
 }
 
@@ -116,6 +195,11 @@ METHOD(canvas_fill_style_set) {
       canvas->set_fill_gradient(gradient);
       return XT_UNDEFINED;
     }
+    uint64_t pattern = canvas_pattern_id(xt_arg(argc, argv, 0), canvas);
+    if (pattern != 0) {
+      canvas->set_fill_pattern(pattern);
+      return XT_UNDEFINED;
+    }
   }
   canvas->set_fill_style(string_arg(argc, argv, 0));
   return XT_UNDEFINED;
@@ -130,6 +214,9 @@ METHOD(canvas_stroke_style_get) {
   if (canvas->stroke_gradient_id() != 0) {
     return canvas_gradient_handle(self, canvas, canvas->stroke_gradient_id());
   }
+  if (canvas->stroke_pattern_id() != 0) {
+    return canvas_pattern_handle(self, canvas, canvas->stroke_pattern_id());
+  }
   return xt_string_from_cstr(canvas->stroke_style().c_str());
 }
 
@@ -143,6 +230,11 @@ METHOD(canvas_stroke_style_set) {
       canvas->set_stroke_gradient(gradient);
       return XT_UNDEFINED;
     }
+    uint64_t pattern = canvas_pattern_id(xt_arg(argc, argv, 0), canvas);
+    if (pattern != 0) {
+      canvas->set_stroke_pattern(pattern);
+      return XT_UNDEFINED;
+    }
   }
   canvas->set_stroke_style(string_arg(argc, argv, 0));
   return XT_UNDEFINED;
@@ -269,23 +361,33 @@ METHOD(canvas_scale) {
 METHOD(canvas_transform) {
   (void)env;
   xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr)
-    canvas->transform((float)number_arg(argc, argv, 0, 1.0), (float)number_arg(argc, argv, 1, 0.0),
-                      (float)number_arg(argc, argv, 2, 0.0), (float)number_arg(argc, argv, 3, 1.0),
-                      (float)number_arg(argc, argv, 4, 0.0), (float)number_arg(argc, argv, 5, 0.0));
+  if (canvas == nullptr) return XT_UNDEFINED;
+  float values[6];
+  if (canvas_matrix_arg(argc, argv, 0, values)) {
+    canvas->transform(values[0], values[1], values[2], values[3], values[4], values[5]);
+    return XT_UNDEFINED;
+  }
+  canvas->transform((float)number_arg(argc, argv, 0, 1.0), (float)number_arg(argc, argv, 1, 0.0),
+                    (float)number_arg(argc, argv, 2, 0.0), (float)number_arg(argc, argv, 3, 1.0),
+                    (float)number_arg(argc, argv, 4, 0.0), (float)number_arg(argc, argv, 5, 0.0));
   return XT_UNDEFINED;
 }
 
 METHOD(canvas_set_transform) {
   (void)env;
   xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr)
-    canvas->set_transform((float)number_arg(argc, argv, 0, 1.0),
-                          (float)number_arg(argc, argv, 1, 0.0),
-                          (float)number_arg(argc, argv, 2, 0.0),
-                          (float)number_arg(argc, argv, 3, 1.0),
-                          (float)number_arg(argc, argv, 4, 0.0),
-                          (float)number_arg(argc, argv, 5, 0.0));
+  if (canvas == nullptr) return XT_UNDEFINED;
+  float values[6];
+  if (canvas_matrix_arg(argc, argv, 0, values)) {
+    canvas->set_transform(values[0], values[1], values[2], values[3], values[4], values[5]);
+    return XT_UNDEFINED;
+  }
+  canvas->set_transform((float)number_arg(argc, argv, 0, 1.0),
+                        (float)number_arg(argc, argv, 1, 0.0),
+                        (float)number_arg(argc, argv, 2, 0.0),
+                        (float)number_arg(argc, argv, 3, 1.0),
+                        (float)number_arg(argc, argv, 4, 0.0),
+                        (float)number_arg(argc, argv, 5, 0.0));
   return XT_UNDEFINED;
 }
 
@@ -298,104 +400,6 @@ METHOD(canvas_reset_transform) {
   return XT_UNDEFINED;
 }
 
-/* -- paths ---------------------------------------------------------------- */
-
-METHOD(canvas_begin_path) {
-  (void)env;
-  (void)argc;
-  (void)argv;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr) canvas->begin_path();
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_close_path) {
-  (void)env;
-  (void)argc;
-  (void)argv;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr) canvas->close_path();
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_move_to) {
-  (void)env;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr)
-    canvas->move_to((float)number_arg(argc, argv, 0, 0.0), (float)number_arg(argc, argv, 1, 0.0));
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_line_to) {
-  (void)env;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr)
-    canvas->line_to((float)number_arg(argc, argv, 0, 0.0), (float)number_arg(argc, argv, 1, 0.0));
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_rect) {
-  (void)env;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr)
-    canvas->rect((float)number_arg(argc, argv, 0, 0.0), (float)number_arg(argc, argv, 1, 0.0),
-                 (float)number_arg(argc, argv, 2, 0.0), (float)number_arg(argc, argv, 3, 0.0));
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_arc) {
-  (void)env;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr) {
-    canvas->arc((float)number_arg(argc, argv, 0, 0.0), (float)number_arg(argc, argv, 1, 0.0),
-                (float)number_arg(argc, argv, 2, 0.0), (float)number_arg(argc, argv, 3, 0.0),
-                (float)number_arg(argc, argv, 4, 0.0), value_truthy(xt_arg(argc, argv, 5)));
-  }
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_quadratic_curve_to) {
-  (void)env;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr)
-    canvas->quadratic_curve_to((float)number_arg(argc, argv, 0, 0.0),
-                               (float)number_arg(argc, argv, 1, 0.0),
-                               (float)number_arg(argc, argv, 2, 0.0),
-                               (float)number_arg(argc, argv, 3, 0.0));
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_bezier_curve_to) {
-  (void)env;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr)
-    canvas->bezier_curve_to((float)number_arg(argc, argv, 0, 0.0),
-                            (float)number_arg(argc, argv, 1, 0.0),
-                            (float)number_arg(argc, argv, 2, 0.0),
-                            (float)number_arg(argc, argv, 3, 0.0),
-                            (float)number_arg(argc, argv, 4, 0.0),
-                            (float)number_arg(argc, argv, 5, 0.0));
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_fill) {
-  (void)env;
-  (void)argc;
-  (void)argv;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr) canvas->fill();
-  return XT_UNDEFINED;
-}
-
-METHOD(canvas_stroke) {
-  (void)env;
-  (void)argc;
-  (void)argv;
-  xtgui::Canvas2D *canvas = context_canvas(self);
-  if (canvas != nullptr) canvas->stroke();
-  return XT_UNDEFINED;
-}
-
 METHOD(canvas_clear_rect) {
   (void)env;
   xtgui::Canvas2D *canvas = context_canvas(self);
@@ -440,7 +444,8 @@ METHOD(canvas_fill_text) {
   xtgui::Canvas2D *canvas = context_canvas(self);
   if (canvas != nullptr)
     canvas->fill_text(string_arg(argc, argv, 0), (float)number_arg(argc, argv, 1, 0.0),
-                      (float)number_arg(argc, argv, 2, 0.0));
+                      (float)number_arg(argc, argv, 2, 0.0),
+                      (float)number_arg(argc, argv, 3, 0.0));
   return XT_UNDEFINED;
 }
 
@@ -449,7 +454,8 @@ METHOD(canvas_stroke_text) {
   xtgui::Canvas2D *canvas = context_canvas(self);
   if (canvas != nullptr)
     canvas->stroke_text(string_arg(argc, argv, 0), (float)number_arg(argc, argv, 1, 0.0),
-                        (float)number_arg(argc, argv, 2, 0.0));
+                        (float)number_arg(argc, argv, 2, 0.0),
+                        (float)number_arg(argc, argv, 3, 0.0));
   return XT_UNDEFINED;
 }
 
@@ -516,4 +522,4 @@ METHOD(canvas_get_image_data) {
 
 }  // namespace domapi
 
-#undef METHOD
+#undef METHOD

package/runtime/ext_gui/dom_api_canvas_extra.cpp

@@ -100,15 +100,70 @@ METHOD(canvas_ellipse) {
   return XT_UNDEFINED;
 }
 
+namespace {
+
+/** One corner radius: a number, or a `{ x, y }` pair (the engine draws circular
+ * corners, so such a pair contributes its `x` radius). */
+bool canvas_radius_value(xt_value value, float *out) {
+  if (XT_IS_NUMBER(value)) {
+    *out = (float)xt_to_number(value);
+    return true;
+  }
+  if (XT_IS_OBJECT(value)) {
+    xt_value x = xt_object_get_cstr(value, "x");
+    xt_value y = xt_object_get_cstr(value, "y");
+    if (XT_IS_NUMBER(x)) {
+      *out = (float)xt_to_number(x);
+      return true;
+    }
+    if (XT_IS_NUMBER(y)) {
+      *out = (float)xt_to_number(y);
+      return true;
+    }
+  }
+  return false;
+}
+
+/** `roundRect`'s fifth argument: one radius or a list of 1–4 radii in CSS order
+ * (top-left, top-right, bottom-right, bottom-left). */
+bool canvas_radii_arg(xt_value value, float radii[4]) {
+  radii[0] = radii[1] = radii[2] = radii[3] = 0.0f;
+  if (canvas_radius_value(value, &radii[0])) {
+    radii[1] = radii[2] = radii[3] = radii[0];
+    return true;
+  }
+  if (!XT_IS_ARRAY(value)) return false;
+  int32_t count = (int32_t)xt_to_number(xt_array_length(value));
+  if (count <= 0) return false;
+  if (count > 4) count = 4;
+  for (int32_t i = 0; i < count; i++) {
+    if (!canvas_radius_value(xt_array_get(value, xt_number((double)i)), &radii[i])) return false;
+  }
+  /* CSS expansion: [a] [a,b] [a,b,c] to four corners. */
+  if (count == 1) {
+    radii[1] = radii[2] = radii[3] = radii[0];
+  } else if (count == 2) {
+    radii[2] = radii[0];
+    radii[3] = radii[1];
+  } else if (count == 3) {
+    radii[3] = radii[1];
+  }
+  return true;
+}
+
+}  // namespace
+
 METHOD(canvas_round_rect) {
   (void)env;
   xtgui::Canvas2D *canvas = canvas_from_context(self);
   if (canvas != nullptr) {
+    float radii[4];
+    canvas_radii_arg(xt_arg(argc, argv, 4), radii);
     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));
+                       (float)canvas_number_arg(argc, argv, 3, 0.0), radii[0], radii[1],
+                       radii[2], radii[3]);
   }
   return XT_UNDEFINED;
 }