xbintsc 0.5.21 → 0.5.22

package/runtime/ext_gui/canvas.cpp

@@ -12,12 +12,10 @@
 #include <algorithm>
 #include <atomic>
 #include <cmath>
-#include <cstdlib>
 #include <cstring>
 #include <unordered_map>
 
 #include "canvas_internal.h"
-#include "css.h"
 
 namespace xtgui {
 
@@ -32,99 +30,12 @@ std::unordered_map<uint64_t, Canvas2D *> &canvas_registry() {
   return registry;
 }
 
-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") {
-      spec.weight = 700;
-      continue;
-    }
-    if (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;
-}
-
 CanvasPoint lerp(const CanvasPoint &a, const CanvasPoint &b, float t) {
   return CanvasPoint{a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t};
 }
 
+constexpr float kPi = 3.14159265358979323846f;
+
 }  // namespace
 
 Canvas2D* xt_canvas_by_id(uint64_t id) {
@@ -137,6 +48,20 @@ float CanvasTransform::scale() const {
   return std::sqrt(determinant);
 }
 
+CanvasTransform CanvasTransform::inverted() const {
+  const float determinant = a * d - b * c;
+  if (std::fabs(determinant) < 1e-9f) return CanvasTransform();
+  const float inv = 1.0f / determinant;
+  CanvasTransform result;
+  result.a = d * inv;
+  result.b = -b * inv;
+  result.c = -c * inv;
+  result.d = a * inv;
+  result.e = (c * f - d * e) * inv;
+  result.f = (b * e - a * f) * inv;
+  return result;
+}
+
 Canvas2D::Canvas2D(int width, int height) : id_(g_next_canvas_id.fetch_add(1)) {
   resize(width, height);
   canvas_registry()[id_] = this;
@@ -178,14 +103,17 @@ void Canvas2D::rotate(float radians) {
 void Canvas2D::scale(float sx, float sy) { transform(sx, 0.0f, 0.0f, sy, 0.0f, 0.0f); }
 
 void Canvas2D::transform(float a, float b, float c, float d, float e, float f) {
+  /* Post-multiply: the new matrix applies *after* the current one, so
+   * `translate(x, y); rotate(a)` rotates around the translated origin (the
+   * canvas rules) instead of rotating the translation itself. */
   const CanvasTransform &m = state_.transform;
   CanvasTransform next;
-  next.a = a * m.a + c * m.b;
-  next.b = b * m.a + d * m.b;
-  next.c = a * m.c + c * m.d;
-  next.d = b * m.c + d * m.d;
-  next.e = a * m.e + c * m.f + e;
-  next.f = b * m.e + d * m.f + f;
+  next.a = m.a * a + m.c * b;
+  next.b = m.b * a + m.d * b;
+  next.c = m.a * c + m.c * d;
+  next.d = m.b * c + m.d * d;
+  next.e = m.a * e + m.c * f + m.e;
+  next.f = m.b * e + m.d * f + m.f;
   state_.transform = next;
 }
 
@@ -193,59 +121,6 @@ void Canvas2D::set_transform(float a, float b, float c, float d, float e, float
   state_.transform = CanvasTransform{a, b, c, d, e, f};
 }
 
-void Canvas2D::set_fill_style(const std::string &css) {
-  parse_color_into(css, state_.fill_color, &state_.fill_style);
-}
-
-void Canvas2D::set_stroke_style(const std::string &css) {
-  parse_color_into(css, state_.stroke_color, &state_.stroke_style);
-}
-
-void Canvas2D::set_global_alpha(float alpha) {
-  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::begin_path() { path_.clear(); }
 
 void Canvas2D::move_to(float x, float y) { path_.push_back(CanvasSubpath{CanvasPoint{x, y}}); }
@@ -287,19 +162,74 @@ void Canvas2D::flatten_arc(float cx, float cy, float radius, float start, float
   }
 }
 
-void Canvas2D::arc(float cx, float cy, float radius, float start, float end, bool ccw) {
-  CanvasSubpath arcPoints;
-  flatten_arc(cx, cy, radius, start, end, ccw, &arcPoints);
-  if (arcPoints.empty()) return;
+void Canvas2D::append_path_points(const CanvasSubpath &points) {
+  if (points.empty()) return;
   if (path_.empty() || path_.back().empty()) {
-    path_.push_back(CanvasSubpath{arcPoints.front()});
+    path_.push_back(CanvasSubpath{points.front()});
   } else {
     CanvasPoint last = path_.back().back();
-    if (last.x != arcPoints.front().x || last.y != arcPoints.front().y) {
-      path_.back().push_back(arcPoints.front());
+    if (last.x != points.front().x || last.y != points.front().y) {
+      path_.back().push_back(points.front());
     }
   }
-  for (size_t i = 1; i < arcPoints.size(); i++) path_.back().push_back(arcPoints[i]);
+  for (size_t i = 1; i < points.size(); i++) path_.back().push_back(points[i]);
+}
+
+void Canvas2D::arc(float cx, float cy, float radius, float start, float end, bool ccw) {
+  CanvasSubpath arcPoints;
+  flatten_arc(cx, cy, radius, start, end, ccw, &arcPoints);
+  append_path_points(arcPoints);
+}
+
+void Canvas2D::ellipse(float cx, float cy, float rx, float ry, float rotation, float start,
+                       float end, bool counterclockwise) {
+  float sweep = end - start;
+  if (counterclockwise) {
+    while (sweep > 0.0f) sweep -= 2.0f * kPi;
+    while (sweep < -2.0f * kPi) sweep += 2.0f * kPi;
+  } else {
+    while (sweep < 0.0f) sweep += 2.0f * kPi;
+    while (sweep > 2.0f * kPi) sweep -= 2.0f * kPi;
+  }
+  int segments = (int)std::ceil(std::fabs(sweep) / (kPi / 32.0f));
+  if (segments < 1) segments = 1;
+  if (segments > 2048) segments = 2048;
+  const float cosRotation = std::cos(rotation);
+  const float sinRotation = std::sin(rotation);
+  CanvasSubpath points;
+  points.reserve((size_t)segments + 1);
+  for (int i = 0; i <= segments; i++) {
+    float angle = start + sweep * ((float)i / (float)segments);
+    float px = rx * std::cos(angle);
+    float py = ry * std::sin(angle);
+    points.push_back(CanvasPoint{cx + px * cosRotation - py * sinRotation,
+                                 cy + px * sinRotation + py * cosRotation});
+  }
+  append_path_points(points);
+}
+
+void Canvas2D::round_rect(float x, float y, float width, float height, float radius) {
+  if (width < 0.0f) {
+    x += width;
+    width = -width;
+  }
+  if (height < 0.0f) {
+    y += height;
+    height = -height;
+  }
+  float maxRadius = std::min(width, height) * 0.5f;
+  if (radius < 0.0f) radius = 0.0f;
+  if (radius > maxRadius) radius = maxRadius;
+  move_to(x + radius, y);
+  line_to(x + width - radius, y);
+  quadratic_curve_to(x + width, y, x + width, y + radius);
+  line_to(x + width, y + height - radius);
+  quadratic_curve_to(x + width, y + height, x + width - radius, y + height);
+  line_to(x + radius, y + height);
+  quadratic_curve_to(x, y + height, x, y + height - radius);
+  line_to(x, y + radius);
+  quadratic_curve_to(x, y, x + radius, y);
+  close_path();
 }
 
 void Canvas2D::quadratic_curve_to(float cpx, float cpy, float x, float y) {
@@ -353,6 +283,22 @@ std::vector<CanvasSubpath> Canvas2D::device_subpaths() const {
   return result;
 }
 
+CanvasPaint Canvas2D::make_paint(uint64_t gradient_id, const float color[4]) const {
+  CanvasPaint paint;
+  paint.color = color;
+  paint.gradient = gradient_id == 0 ? nullptr : find_gradient(gradient_id);
+  paint.inverse = state_.transform.inverted();
+  return paint;
+}
+
+CanvasPaint Canvas2D::fill_paint() const {
+  return make_paint(state_.fill_gradient, state_.fill_color);
+}
+
+CanvasPaint Canvas2D::stroke_paint() const {
+  return make_paint(state_.stroke_gradient, state_.stroke_color);
+}
+
 void Canvas2D::fill() {
   std::vector<CanvasSubpath> subpaths = device_subpaths();
   std::vector<CanvasSubpath> loops;
@@ -361,50 +307,19 @@ void Canvas2D::fill() {
     loops.push_back(std::move(subpath));
   }
   if (loops.empty()) return;
-  canvas_detail::fill_loops(image_.pixels, image_.width, image_.height, loops, state_.fill_color,
+  canvas_detail::fill_loops(image_.pixels, image_.width, image_.height, loops, fill_paint(),
                             state_.global_alpha);
   generation_++;
 }
 
-void Canvas2D::stroke_subpath(const CanvasSubpath &points, bool closed, const float color[4]) {
-  if (points.size() < 2) return;
-  float half = state_.line_width * state_.transform.scale() * 0.5f;
-  if (half <= 0.0f) half = 0.5f;
-  size_t segmentCount = points.size() - 1;
-  for (size_t i = 0; i < segmentCount; i++) {
-    const CanvasPoint &p = points[i];
-    const CanvasPoint &q = points[i + 1];
-    float dx = q.x - p.x;
-    float dy = q.y - p.y;
-    float length = std::sqrt(dx * dx + dy * dy);
-    if (length <= 0.0001f) continue;
-    float nx = -dy / length * half;
-    float ny = dx / length * half;
-    CanvasSubpath quad{CanvasPoint{p.x + nx, p.y + ny}, CanvasPoint{q.x + nx, q.y + ny},
-                       CanvasPoint{q.x - nx, q.y - ny}, CanvasPoint{p.x - nx, p.y - ny}};
-    canvas_detail::fill_loop(image_.pixels, image_.width, image_.height, quad, color,
-                             state_.global_alpha);
-  }
-  (void)closed;
-  for (const CanvasPoint &p : points) {
-    CanvasSubpath disc;
-    const int segments = 16;
-    for (int i = 0; i < segments; i++) {
-      float angle = 2.0f * 3.14159265358979323846f * ((float)i / (float)segments);
-      disc.push_back(CanvasPoint{p.x + half * std::cos(angle), p.y + half * std::sin(angle)});
-    }
-    canvas_detail::fill_loop(image_.pixels, image_.width, image_.height, disc, color,
-                             state_.global_alpha);
-  }
-}
-
 void Canvas2D::stroke() {
   std::vector<CanvasSubpath> subpaths = device_subpaths();
+  const CanvasPaint paint = stroke_paint();
   for (const CanvasSubpath &subpath : subpaths) {
     if (subpath.size() < 2) continue;
     bool closed = subpath.size() >= 3 && subpath.front().x == subpath.back().x &&
                   subpath.front().y == subpath.back().y;
-    stroke_subpath(subpath, closed, state_.stroke_color);
+    stroke_subpath(subpath, closed, paint);
   }
   generation_++;
 }
@@ -423,7 +338,7 @@ void Canvas2D::fill_rect(float x, float y, float width, float height) {
     to_device(x, y, &x0, &y0);
     to_device(x + width, y + height, &x1, &y1);
     canvas_detail::fill_rect(image_.pixels, image_.width, image_.height, x0, y0, x1, y1,
-                             state_.fill_color, state_.global_alpha);
+                             fill_paint(), state_.global_alpha);
   } else {
     CanvasSubpath loop;
     const float corners[4][2] = {
@@ -433,7 +348,7 @@ void Canvas2D::fill_rect(float x, float y, float width, float height) {
       to_device(corner[0], corner[1], &point.x, &point.y);
       loop.push_back(point);
     }
-    canvas_detail::fill_loop(image_.pixels, image_.width, image_.height, loop, state_.fill_color,
+    canvas_detail::fill_loop(image_.pixels, image_.width, image_.height, loop, fill_paint(),
                              state_.global_alpha);
   }
   generation_++;
@@ -448,7 +363,7 @@ void Canvas2D::stroke_rect(float x, float y, float width, float height) {
     to_device(corner[0], corner[1], &point.x, &point.y);
     loop.push_back(point);
   }
-  stroke_subpath(loop, true, state_.stroke_color);
+  stroke_subpath(loop, true, stroke_paint());
   generation_++;
 }
 
@@ -456,7 +371,7 @@ float Canvas2D::measure_text(const std::string &text) const {
   return xt_text_measure_width(text, state_.font);
 }
 
-void Canvas2D::paint_text(const std::string &text, float x, float y, const float color[4],
+void Canvas2D::paint_text(const std::string &text, float x, float y, const CanvasPaint &paint,
                           bool stroke) {
   Font *font = xt_text_resolve(state_.font);
   if (font == nullptr) return;
@@ -510,7 +425,7 @@ void Canvas2D::paint_text(const std::string &text, float x, float y, const float
     GlyphImage image;
     if (xt_text_rasterize(face, glyph.glyph, image) && image.width > 0 && image.height > 0) {
       canvas_detail::blit_glyph(image_.pixels, image_.width, image_.height, image.pixels, image.width,
-                                image.height, image.left, image.top, deviceX, deviceY, color,
+                                image.height, image.left, image.top, deviceX, deviceY, paint,
                                 state_.global_alpha);
     }
     penX += glyph.x_advance;
@@ -520,11 +435,11 @@ void Canvas2D::paint_text(const std::string &text, float x, float y, const float
 }
 
 void Canvas2D::fill_text(const std::string &text, float x, float y) {
-  paint_text(text, x, y, state_.fill_color, false);
+  paint_text(text, x, y, fill_paint(), false);
 }
 
 void Canvas2D::stroke_text(const std::string &text, float x, float y) {
-  paint_text(text, x, y, state_.stroke_color, true);
+  paint_text(text, x, y, stroke_paint(), true);
 }
 
 void Canvas2D::draw_image(const Image &source, float dx, float dy, float dw, float dh, float sx,

package/runtime/ext_gui/canvas.h

@@ -19,7 +19,9 @@
 #define XT_GUI_CANVAS_H
 
 #include <cstdint>
+#include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "image.h"
@@ -40,6 +42,8 @@ struct CanvasTransform {
   bool axis_aligned() const { return b == 0.0f && c == 0.0f; }
   /** Approximate uniform scale, used to size stroked lines and text. */
   float scale() const;
+  /** The inverse transform (device -> user space); identity when singular. */
+  CanvasTransform inverted() const;
 };
 
 /** A point in device (canvas) space. */
@@ -51,6 +55,51 @@ struct CanvasPoint {
 /** One subpath of the current path (device space). */
 using CanvasSubpath = std::vector<CanvasPoint>;
 
+/**
+ * A `CanvasGradient` handle: the colour stops plus the geometric definition of
+ * a linear or radial gradient. Gradients are owned by the canvas that created
+ * them, so a stale context handle resolves to no gradient instead of a dangling
+ * pointer. The DOM layer copies only the id around; the stops stay live, which
+ * is what makes `addColorStop` after `fillStyle = gradient` affect later fills.
+ */
+class CanvasGradient {
+ public:
+  enum class Type { Linear, Radial };
+
+  CanvasGradient(uint64_t id, Type type, float x0, float y0, float x1, float y1, float r0,
+                 float r1);
+
+  uint64_t id() const { return id_; }
+  Type type() const { return type_; }
+
+  /** Add a colour stop (offset clamped to 0..1, stops kept sorted by offset). */
+  void add_color_stop(float offset, const float color[4]);
+  /** Sample the gradient at a user-space point. A gradient with no stops is
+   * transparent black, so this always fills `out`. */
+  bool color_at(float x, float y, float out[4]) const;
+
+ private:
+  struct Stop {
+    float offset = 0.0f;
+    float color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+  };
+
+  uint64_t id_ = 0;
+  Type type_ = Type::Linear;
+  float x0_ = 0.0f, y0_ = 0.0f, x1_ = 0.0f, y1_ = 0.0f;
+  float r0_ = 0.0f, r1_ = 0.0f;
+  std::vector<Stop> stops_;
+};
+
+/** What a fill or stroke paints with: a solid colour, or a gradient sampled
+ * through the inverse of the current transform. `color` points into the
+ * canvas state and stays valid for the duration of one draw call. */
+struct CanvasPaint {
+  const float *color = nullptr;
+  const CanvasGradient *gradient = nullptr;
+  CanvasTransform inverse;
+};
+
 class Canvas2D {
  public:
   Canvas2D(int width, int height);
@@ -77,14 +126,30 @@ class Canvas2D {
   void transform(float a, float b, float c, float d, float e, float f);
   void set_transform(float a, float b, float c, float d, float e, float f);
   void reset_transform() { state_.transform = CanvasTransform(); }
+  const CanvasTransform &current_transform() const { return state_.transform; }
 
   /* -- style ------------------------------------------------------------- */
   void set_fill_style(const std::string &css);
   const std::string &fill_style() const { return state_.fill_style; }
   void set_stroke_style(const std::string &css);
   const std::string &stroke_style() const { return state_.stroke_style; }
+  /** Use a gradient created by this canvas (`0` restores the solid colour). */
+  void set_fill_gradient(uint64_t id);
+  void set_stroke_gradient(uint64_t id);
+  uint64_t fill_gradient_id() const { return state_.fill_gradient; }
+  uint64_t stroke_gradient_id() const { return state_.stroke_gradient; }
   void set_line_width(float width) { state_.line_width = width > 0.0f ? width : 0.0f; }
   float line_width() const { return state_.line_width; }
+  void set_line_cap(const std::string &value);
+  const std::string &line_cap() const { return state_.line_cap_string; }
+  void set_line_join(const std::string &value);
+  const std::string &line_join() const { return state_.line_join_string; }
+  void set_miter_limit(float limit);
+  float miter_limit() const { return state_.miter_limit; }
+  void set_line_dash(const std::vector<float> &segments);
+  const std::vector<float> &line_dash() const { return state_.line_dash; }
+  void set_line_dash_offset(float offset) { state_.line_dash_offset = offset; }
+  float line_dash_offset() const { return state_.line_dash_offset; }
   void set_global_alpha(float alpha);
   float global_alpha() const { return state_.global_alpha; }
   void set_font(const std::string &font);
@@ -94,13 +159,22 @@ class Canvas2D {
   void set_text_baseline(const std::string &value);
   const std::string &text_baseline() const { return state_.text_baseline_string; }
 
+  /* -- gradients --------------------------------------------------------- */
+  CanvasGradient *create_linear_gradient(float x0, float y0, float x1, float y1);
+  CanvasGradient *create_radial_gradient(float x0, float y0, float r0, float x1, float y1,
+                                         float r1);
+  CanvasGradient *find_gradient(uint64_t id) const;
+
   /* -- paths ------------------------------------------------------------- */
   void begin_path();
   void close_path();
   void move_to(float x, float y);
   void line_to(float x, float y);
   void rect(float x, float y, float width, float height);
+  void round_rect(float x, float y, float width, float height, float radius);
   void arc(float cx, float cy, float radius, float start, float end, bool counterclockwise);
+  void ellipse(float cx, float cy, float rx, float ry, float rotation, float start, float end,
+               bool counterclockwise);
   void quadratic_curve_to(float cpx, float cpy, float x, float y);
   void bezier_curve_to(float c1x, float c1y, float c2x, float c2y, float x, float y);
   void fill();
@@ -132,6 +206,11 @@ class Canvas2D {
     CanvasTransform transform;
     float line_width = 1.0f;
     float global_alpha = 1.0f;
+    int line_cap = 0;        // 0 butt, 1 round, 2 square
+    int line_join = 0;       // 0 miter, 1 round, 2 bevel
+    float miter_limit = 10.0f;
+    std::vector<float> line_dash;
+    float line_dash_offset = 0.0f;
     FontSpec font;
     std::string font_string = "10px sans-serif";
     int text_align = 0;      // 0 start/left, 1 center, 2 right/end
@@ -142,6 +221,10 @@ class Canvas2D {
     std::string stroke_style = "#000000";
     float fill_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
     float stroke_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+    uint64_t fill_gradient = 0;
+    uint64_t stroke_gradient = 0;
+    std::string line_cap_string = "butt";
+    std::string line_join_string = "miter";
   };
 
   /** Transform a user-space point into device space. */
@@ -151,8 +234,23 @@ class Canvas2D {
   /** Add one device-space polygon loop to `out`. */
   void flatten_arc(float cx, float cy, float radius, float start, float end, bool ccw,
                    CanvasSubpath *out) const;
-  void stroke_subpath(const CanvasSubpath &points, bool closed, const float color[4]);
-  void paint_text(const std::string &text, float x, float y, const float color[4], bool stroke);
+  /** Append a flattened arc to the current subpath, moving/line-to its start as
+   * the canvas path rules require. Shared by `arc` and `ellipse`. */
+  void append_path_points(const CanvasSubpath &points);
+  /** Paint descriptors for the current state. */
+  CanvasPaint fill_paint() const;
+  CanvasPaint stroke_paint() const;
+  CanvasPaint make_paint(uint64_t gradient_id, const float color[4]) const;
+  void stroke_subpath(const CanvasSubpath &points, bool closed, const CanvasPaint &paint);
+  /** Stroke one polyline with caps and joins; `half` is half the device-space
+   * line width. Used by `stroke_subpath` for both solid and dashed paths. */
+  void stroke_polyline(const CanvasSubpath &points, bool closed, float half,
+                       const CanvasPaint &paint);
+  /** Split `points` into the "on" pieces of the current dash pattern. */
+  void dash_polyline(const CanvasSubpath &points, bool closed,
+                     std::vector<CanvasSubpath> *out) const;
+  void paint_text(const std::string &text, float x, float y, const CanvasPaint &paint,
+                  bool stroke);
 
   Image image_;
   uint64_t id_ = 0;
@@ -160,6 +258,7 @@ class Canvas2D {
   State state_;
   std::vector<State> stack_;
   std::vector<CanvasSubpath> path_;
+  std::unordered_map<uint64_t, std::unique_ptr<CanvasGradient>> gradients_;
 };
 
 /** The canvas with the given process-wide id, or null. Used by the renderer. */