xbintsc 0.5.23 → 0.5.32

package/runtime/ext_gui/paint.cpp

@@ -1,5 +1,9 @@
 /*
  * xbintsc GUI engine — display list construction.
+ *
+ * The tree walk lives here. Background layers are in `paint_background.cpp`,
+ * filter/shadow approximations in `paint_effects.cpp` and `clip-path`
+ * triangulation in `paint_clip.cpp`.
  */
 
 #include "paint.h"
@@ -8,6 +12,7 @@
 #include <cstdio>
 #include <utility>
 
+#include "paint_internal.h"
 #include "style.h"
 
 namespace xtgui {
@@ -43,50 +48,14 @@ FontSpec specOf(const XtStyle &style) {
   return spec;
 }
 
-void addRect(DisplayList &out, float x, float y, float width, float height, float radius,
-             const Color &color, const PaintClip &clip, const Matrix2D &transform) {
-  if (width <= 0.0f || height <= 0.0f || color.a <= 0.0f) return;
-  PaintRect rect;
-  rect.x = x;
-  rect.y = y;
-  rect.width = width;
-  rect.height = height;
-  rect.radius = radius;
-  rect.color = color;
-  rect.transform = transform;
-  out.rects.push_back(rect);
-  out.ops.push_back(PaintOp{PaintKind::Rect, (uint32_t)(out.rects.size() - 1), clip});
-}
-
-void addTextRuns(const LayoutBox *box, const XtStyle &style, DisplayList &out,
-                 const PaintClip &clip) {
-  if (box->fragments.empty() || style.color.a <= 0.0f) return;
-  FontSpec spec = specOf(style);
-  float ascent = 0;
-  xt_text_metrics(spec, &ascent, nullptr, nullptr);
-  if (ascent <= 0.0f) ascent = style.font_size * 0.8f;
-  for (const TextFragment &fragment : box->fragments) {
-    if (fragment.text.empty()) continue;
-    PaintText run;
-    run.x = fragment.x;
-    run.baseline = fragment.y + ascent;
-    run.width = fragment.width;
-    run.height = fragment.height;
-    run.color = style.color;
-    run.text = fragment.text;
-    run.font = spec;
-    run.transform = box->world;
-    out.texts.push_back(std::move(run));
-    out.ops.push_back(PaintOp{PaintKind::Text, (uint32_t)(out.texts.size() - 1), clip});
-  }
-}
-
-void addImage(const PaintImage &image, DisplayList &out, const PaintClip &clip) {
-  out.images.push_back(image);
-  out.ops.push_back(PaintOp{PaintKind::Image, (uint32_t)(out.images.size() - 1), clip});
+int zIndexOf(const LayoutBox *box) {
+  if (box->style == nullptr || !box->style->has_z_index) return 0;
+  return box->style->z_index;
 }
 
-void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip);
+void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
+              const paint_detail::FilterChain &parentChain, float viewportWidth,
+              float viewportHeight);
 
 /** The clip a box imposes on its content: its padding box, intersected with the
  * clip already in effect. Only `overflow: hidden/scroll/auto` clips. A
@@ -106,23 +75,32 @@ PaintClip clipForChildren(const LayoutBox *box, const PaintClip &parent) {
     width = bounds.width;
     height = bounds.height;
   }
-  if (!parent.active) return PaintClip{true, x, y, width, height};
+  PaintClip result = parent;
+  result.active = true;
+  if (!parent.active) {
+    result.x = x;
+    result.y = y;
+    result.width = width;
+    result.height = height;
+    return result;
+  }
   float x0 = std::max(x, parent.x);
   float y0 = std::max(y, parent.y);
   float x1 = std::min(x + width, parent.x + parent.width);
   float y1 = std::min(y + height, parent.y + parent.height);
-  return PaintClip{true, x0, y0, std::max(0.0f, x1 - x0), std::max(0.0f, y1 - y0)};
-}
-
-int zIndexOf(const LayoutBox *box) {
-  if (box->style == nullptr || !box->style->has_z_index) return 0;
-  return box->style->z_index;
+  result.x = x0;
+  result.y = y0;
+  result.width = std::max(0.0f, x1 - x0);
+  result.height = std::max(0.0f, y1 - y0);
+  return result;
 }
 
 /** Paint `box`'s children following z-index: negative z first (ascending), then
  * auto/zero in document order, then positive z (ascending), so higher stacks
  * paint last. */
-void paintChildren(const LayoutBox *box, DisplayList &out, const PaintClip &clip) {
+void paintChildren(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
+                   const paint_detail::FilterChain &chain, float viewportWidth,
+                   float viewportHeight) {
   std::vector<const LayoutBox *> children;
   for (const std::unique_ptr<LayoutBox> &child : box->children) {
     if (child->display == Display::None || child->style == nullptr) continue;
@@ -131,41 +109,78 @@ void paintChildren(const LayoutBox *box, DisplayList &out, const PaintClip &clip
   std::stable_sort(children.begin(), children.end(), [](const LayoutBox *a, const LayoutBox *b) {
     return zIndexOf(a) < zIndexOf(b);
   });
-  for (const LayoutBox *child : children) paintBox(child, out, clip);
+  for (const LayoutBox *child : children)
+    paintBox(child, out, clip, chain, viewportWidth, viewportHeight);
 }
 
-void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip) {
+void addTextRuns(const LayoutBox *box, const XtStyle &style, DisplayList &out,
+                 const PaintClip &clip, const paint_detail::FilterChain &chain,
+                 float viewportWidth, float viewportHeight) {
+  if (box->fragments.empty() || style.color.a <= 0.0f) return;
+  FontSpec spec = specOf(style);
+  float ascent = 0;
+  xt_text_metrics(spec, &ascent, nullptr, nullptr);
+  if (ascent <= 0.0f) ascent = style.font_size * 0.8f;
+  Color base = paint_detail::filterColor(chain, style.color);
+  for (const TextFragment &fragment : box->fragments) {
+    if (fragment.text.empty()) continue;
+    paint_detail::addTextRun(out, fragment.x, fragment.y + ascent, fragment.width,
+                             fragment.height, fragment.text, spec, base, box->world, clip, style,
+                             chain, viewportWidth, viewportHeight);
+  }
+}
+
+void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
+              const paint_detail::FilterChain &parentChain, float viewportWidth,
+              float viewportHeight) {
   if (box == nullptr) return;
   const XtStyle *style = box->style;
 
-  /* A fully transparent box paints nothing — not itself, and not its subtree. */
-  if (style != nullptr && style->opacity <= 0.0f) return;
+  /* A fully transparent or hidden box paints nothing — not itself, and not its
+   * subtree. */
+  if (style != nullptr && (style->opacity <= 0.0f || !style->visible)) return;
+
+  /* A text box points at its parent element's style; its filters were already
+   * folded into `parentChain`, so applying them again would double them. */
+  paint_detail::FilterChain chain = parentChain;
+  if (style != nullptr && !box->is_text && !style->filters.empty()) {
+    chain = paint_detail::extendFilter(parentChain, style->filters, *style, viewportWidth,
+                                       viewportHeight);
+  }
+
+  PaintClip own = clip;
+  if (style != nullptr && box->display != Display::None && !box->is_text) {
+    if (style->clip_path.type != ClipPathSpec::Type::None) {
+      int index = paint_detail::addClipPathForBox(out, *box, *style, viewportWidth, viewportHeight);
+      own = paint_detail::addClipPath(own, index);
+    }
+  }
 
   if (style != nullptr && box->display != Display::None) {
     if (box->is_text) {
-      addTextRuns(box, *style, out, clip);
+      addTextRuns(box, *style, out, own, chain, viewportWidth, viewportHeight);
     } else {
-      /* Background first, then the border ring, then replaced content. Children
-       * are clipped by this box's padding box when it establishes one. Every
-       * shape carries the box's `transform` matrix for the renderer. */
+      /* Drop shadows sit behind the box's own background but above earlier
+       * siblings. */
+      paint_detail::addBoxDropShadows(out, *box, *style, chain, own);
+      paint_detail::paintBackgrounds(out, *box, *style, chain, own, viewportWidth,
+                                     viewportHeight);
       const Matrix2D &matrix = box->world;
-      if (style->has_background) {
-        addRect(out, box->x, box->y, box->width, box->height, style->border_radius,
-                style->background, clip, matrix);
-      }
       if (style->border_style != BorderStyle::None && style->has_border_color) {
-        const Color bc = style->border_color;
+        const Color bc = paint_detail::filterColor(chain, style->border_color);
         float top = box->border_top;
         float right = box->border_right;
         float bottom = box->border_bottom;
         float left = box->border_left;
         float inner_height = box->height - top - bottom;
-        addRect(out, box->x, box->y, box->width, top, 0.0f, bc, clip, matrix);
-        addRect(out, box->x, box->y + box->height - bottom, box->width, bottom, 0.0f, bc, clip,
-                matrix);
-        addRect(out, box->x, box->y + top, left, inner_height, 0.0f, bc, clip, matrix);
-        addRect(out, box->x + box->width - right, box->y + top, right, inner_height, 0.0f, bc,
-                clip, matrix);
+        paint_detail::addRectFiltered(out, box->x, box->y, box->width, top, 0.0f, bc, own,
+                                      matrix, chain);
+        paint_detail::addRectFiltered(out, box->x, box->y + box->height - bottom, box->width,
+                                      bottom, 0.0f, bc, own, matrix, chain);
+        paint_detail::addRectFiltered(out, box->x, box->y + top, left, inner_height, 0.0f, bc,
+                                      own, matrix, chain);
+        paint_detail::addRectFiltered(out, box->x + box->width - right, box->y + top, right,
+                                      inner_height, 0.0f, bc, own, matrix, chain);
       }
       if (box->is_canvas && box->canvas_id != 0 && box->content_width > 0.0f &&
           box->content_height > 0.0f) {
@@ -176,7 +191,7 @@ void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip) {
         image.height = box->content_height;
         image.canvas_id = box->canvas_id;
         image.transform = matrix;
-        addImage(image, out, clip);
+        paint_detail::addImage(out, image, own, chain);
       } else if (box->is_media && box->media_id != 0 && box->content_width > 0.0f &&
                  box->content_height > 0.0f) {
         PaintImage image;
@@ -186,7 +201,7 @@ void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip) {
         image.height = box->content_height;
         image.media_id = box->media_id;
         image.transform = matrix;
-        addImage(image, out, clip);
+        paint_detail::addImage(out, image, own, chain);
       } else if (box->is_inline_svg && !box->svg_markup.empty() && box->content_width > 0.0f &&
                  box->content_height > 0.0f) {
         PaintImage image;
@@ -196,7 +211,7 @@ void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip) {
         image.height = box->content_height;
         image.svg = box->svg_markup;
         image.transform = matrix;
-        addImage(image, out, clip);
+        paint_detail::addImage(out, image, own, chain);
       } else if (box->is_image && !box->image_src.empty() && box->content_width > 0.0f &&
                  box->content_height > 0.0f) {
         PaintImage image;
@@ -206,24 +221,34 @@ void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip) {
         image.height = box->content_height;
         image.src = box->image_src;
         image.transform = matrix;
-        addImage(image, out, clip);
+        paint_detail::addImage(out, image, own, chain);
       }
     }
   }
 
-  paintChildren(box, out, clipForChildren(box, clip));
+  /* Drop shadows belong to the box that declared them: its silhouette has
+   * already been emitted, so descendants must not repeat it. */
+  paint_detail::FilterChain childChain = chain;
+  childChain.shadows.clear();
+  paintChildren(box, out, clipForChildren(box, own), childChain, viewportWidth, viewportHeight);
 }
 
 }  // namespace
 
-void xt_paint_build(const LayoutBox *root, DisplayList &out) {
+void xt_paint_build(const LayoutBox *root, DisplayList &out, float viewportWidth,
+                    float viewportHeight) {
   PaintClip none;
-  paintBox(root, out, none);
+  paint_detail::FilterChain chain;
+  if (root != nullptr && viewportWidth <= 0.0f) {
+    viewportWidth = root->cb_width;
+    viewportHeight = root->cb_height;
+  }
+  paintBox(root, out, none, chain, viewportWidth, viewportHeight);
 }
 
 std::string DisplayList::dump() const {
   std::string text;
-  char buffer[288];
+  char buffer[320];
   for (const PaintOp &op : ops) {
     std::string prefix;
     if (op.clip.active) {
@@ -231,6 +256,14 @@ std::string DisplayList::dump() const {
                     op.clip.width, op.clip.height);
       prefix = buffer;
     }
+    if (op.clip.path_count > 0) {
+      prefix += "clip-path=";
+      for (int i = 0; i < op.clip.path_count; i++) {
+        if (i > 0) prefix += ",";
+        prefix += std::to_string(op.clip.paths[i]);
+      }
+      prefix += " ";
+    }
     std::string suffix;
     if (op.kind == PaintKind::Rect) {
       suffix = transformSuffix(rects[op.index].transform);
@@ -246,6 +279,7 @@ std::string DisplayList::dump() const {
                     "text x=%.1f baseline=%.1f size=%.1f color=%s \"%s\"", run.x, run.baseline,
                     run.font.pixel_size, formatColor(run.color).c_str(), run.text.c_str());
       text += prefix + buffer;
+      if (run.shadow) text += " shadow=1";
     } else {
       const PaintImage &image = images[op.index];
       suffix = transformSuffix(image.transform);

package/runtime/ext_gui/paint.h

@@ -46,6 +46,9 @@ struct PaintText {
   std::string text;
   FontSpec font;
   Matrix2D transform;
+  /** Set on a `text-shadow` copy (diagnostics only; the renderer draws it like
+   * any other glyph run). */
+  bool shadow = false;
 };
 
 /** An image to draw, scaled into the given rectangle (viewport-relative).
@@ -65,17 +68,38 @@ struct PaintImage {
   uint64_t media_id = 0;
   uint64_t canvas_id = 0;
   Matrix2D transform;
+  /** Modulating colour for the image shader (white normally; a filter's
+   * multiplicative effect may tint it). */
+  Color tint{1.0f, 1.0f, 1.0f, 1.0f};
+};
+
+/** One triangle of a clip path in device-space logical pixels. The paint pass
+ * triangulates (possibly concave) polygons once so the renderer can clip
+ * convex shape/glyph quads by a simple half-plane test per triangle. */
+struct ClipTriangle {
+  float x[3] = {0, 0, 0};
+  float y[3] = {0, 0, 0};
+};
+
+/** A resolved `clip-path` polygon plus its triangulation. */
+struct ClipPathGeometry {
+  std::vector<float> points;  // x, y pairs (diagnostics)
+  std::vector<ClipTriangle> triangles;
 };
 
 /** The clip rectangle in effect for a painted shape (device-space logical
  * pixels — a transformed subtree contributes the bounding box of its clip).
- * `width <= 0` means "no clip". */
+ * `width <= 0` means "no clip". `paths` index `DisplayList::clip_paths`; at most
+ * two nested `clip-path` shapes are kept (CSS would intersect every ancestor;
+ * deeper nesting is rare and the outermost two are the ones a UI uses). */
 struct PaintClip {
   bool active = false;
   float x = 0;
   float y = 0;
   float width = 0;
   float height = 0;
+  int path_count = 0;
+  int paths[2] = {-1, -1};
 };
 
 enum class PaintKind { Rect, Text, Image };
@@ -95,20 +119,26 @@ struct DisplayList {
   /** Shapes in painter order (backgrounds/borders first, then children, then
    * stacked siblings), each with the clip rectangle that bounds it. */
   std::vector<PaintOp> ops;
+  /** Device-space clip-path polygons shared by an element's ops. */
+  std::vector<ClipPathGeometry> clip_paths;
 
   void clear() {
     rects.clear();
     texts.clear();
     images.clear();
     ops.clear();
+    clip_paths.clear();
   }
   bool empty() const { return rects.empty() && texts.empty() && images.empty(); }
   /** Human-readable dump, one shape per line, in painter order (diagnostics/tests). */
   std::string dump() const;
 };
 
-/** Build the display list for a laid-out tree and append it to `out`. */
-void xt_paint_build(const LayoutBox *root, DisplayList &out);
+/** Build the display list for a laid-out tree and append it to `out`. The
+ * viewport size resolves `vw`/`vh` units inside `clip-path` and shadows; pass 0
+ * to take it from the root box's containing block. */
+void xt_paint_build(const LayoutBox *root, DisplayList &out, float viewportWidth = 0.0f,
+                    float viewportHeight = 0.0f);
 
 }  // namespace xtgui
 

package/runtime/ext_gui/paint_background.cpp

@@ -0,0 +1,229 @@
+/*
+ * xbintsc GUI engine — background layer painting.
+ *
+ * The renderer has one rounded-rectangle pipeline and no gradient shader, so a
+ * gradient is emitted as a run of solid bands: 18 strips for a linear gradient
+ * and 32 concentric ellipses for a radial one. Radial ellipses use the shape
+ * pipeline's transform slot (a unit circle scaled to the ellipse radii), which
+ * keeps the distance-field antialiasing intact.
+ */
+
+#include "paint_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+namespace xtgui {
+namespace paint_detail {
+
+namespace {
+
+Color gradientColorAt(const BackgroundLayer &layer, float t) {
+  const std::vector<BackgroundGradientStop> &stops = layer.stops;
+  if (stops.empty()) return Color();
+  if (t <= stops.front().offset) return stops.front().color;
+  if (t >= stops.back().offset) return stops.back().color;
+  for (size_t i = 1; i < stops.size(); i++) {
+    if (t > stops[i].offset) continue;
+    float span = stops[i].offset - stops[i - 1].offset;
+    float u = span > 0.00001f ? (t - stops[i - 1].offset) / span : 0.0f;
+    Color a = stops[i - 1].color;
+    Color b = stops[i].color;
+    Color out;
+    out.r = a.r + (b.r - a.r) * u;
+    out.g = a.g + (b.g - a.g) * u;
+    out.b = a.b + (b.b - a.b) * u;
+    out.a = a.a + (b.a - a.a) * u;
+    out.valid = true;
+    return out;
+  }
+  return stops.back().color;
+}
+
+/** Intersect `clip` with the box's border box (backgrounds never paint outside
+ * it, even when the box is not an overflow container). */
+PaintClip boxClip(const PaintClip &clip, const LayoutBox &box) {
+  float bx = box.x;
+  float by = box.y;
+  float bw = box.width;
+  float bh = box.height;
+  if (box.has_transform) {
+    LayoutRect bounds = xt_layout_transform_rect(box.world, bx, by, bw, bh);
+    bx = bounds.x;
+    by = bounds.y;
+    bw = bounds.width;
+    bh = bounds.height;
+  }
+  PaintClip out = clip;
+  if (!out.active) {
+    out.active = true;
+    out.x = bx;
+    out.y = by;
+    out.width = bw;
+    out.height = bh;
+    return out;
+  }
+  float x0 = std::max(out.x, bx);
+  float y0 = std::max(out.y, by);
+  float x1 = std::min(out.x + out.width, bx + bw);
+  float y1 = std::min(out.y + out.height, by + bh);
+  out.x = x0;
+  out.y = y0;
+  out.width = std::max(0.0f, x1 - x0);
+  out.height = std::max(0.0f, y1 - y0);
+  return out;
+}
+
+void paintLinear(const LayoutBox &box, const BackgroundLayer &layer, const FilterChain &chain,
+                 const PaintClip &clip, DisplayList &out) {
+  if (layer.stops.size() < 2 || box.width <= 0.0f || box.height <= 0.0f) return;
+  const int strips = 18;
+  bool horizontal = (layer.angle > 80.0f && layer.angle < 100.0f) ||
+                    (layer.angle > 260.0f && layer.angle < 280.0f);
+  bool reverse = (layer.angle > 260.0f && layer.angle < 280.0f) || layer.angle < 10.0f ||
+                 layer.angle > 350.0f;
+  for (int i = 0; i < strips; i++) {
+    float t = ((float)i + 0.5f) / (float)strips;
+    Color color = gradientColorAt(layer, reverse ? 1.0f - t : t);
+    color = filterColor(chain, color);
+    if (color.a <= 0.0f) continue;
+    if (horizontal) {
+      addRect(out, box.x + box.width * (float)i / (float)strips, box.y,
+              box.width / (float)strips + 0.4f, box.height, 0.0f, color, clip, box.world);
+    } else {
+      addRect(out, box.x, box.y + box.height * (float)i / (float)strips, box.width,
+              box.height / (float)strips + 0.4f, 0.0f, color, clip, box.world);
+    }
+  }
+}
+
+/** Default radii for `closest-side` / `farthest-side` / corner keywords. */
+void radialRadii(const LayoutBox &box, const BackgroundLayer &layer, const XtStyle &style,
+                 float viewportWidth, float viewportHeight, float *cx, float *cy, float *rx,
+                 float *ry) {
+  float centerX = box.x + resolveLength(layer.center_x, box.width, style.font_size, viewportWidth,
+                                        viewportHeight);
+  float centerY = box.y + resolveLength(layer.center_y, box.height, style.font_size, viewportWidth,
+                                        viewportHeight);
+  float left = centerX - box.x;
+  float right = box.x + box.width - centerX;
+  float top = centerY - box.y;
+  float bottom = box.y + box.height - centerY;
+  left = std::max(0.0f, left);
+  right = std::max(0.0f, right);
+  top = std::max(0.0f, top);
+  bottom = std::max(0.0f, bottom);
+
+  if (layer.size == RadialSize::Explicit) {
+    float radiusX =
+        resolveLength(layer.radius_x, box.width, style.font_size, viewportWidth, viewportHeight);
+    float radiusY = layer.circle
+                        ? radiusX
+                        : resolveLength(layer.radius_y, box.height, style.font_size, viewportWidth,
+                                        viewportHeight);
+    *cx = centerX;
+    *cy = centerY;
+    *rx = std::max(0.0f, radiusX);
+    *ry = std::max(0.0f, radiusY);
+    return;
+  }
+
+  if (layer.circle) {
+    float radius = 0.0f;
+    switch (layer.size) {
+      case RadialSize::ClosestSide:
+        radius = std::min(std::min(left, right), std::min(top, bottom));
+        break;
+      case RadialSize::FarthestSide:
+        radius = std::max(std::max(left, right), std::max(top, bottom));
+        break;
+      case RadialSize::ClosestCorner:
+        radius = std::sqrt(std::min(left, right) * std::min(left, right) +
+                           std::min(top, bottom) * std::min(top, bottom));
+        break;
+      case RadialSize::FarthestCorner:
+      default:
+        radius = std::sqrt(std::max(left, right) * std::max(left, right) +
+                           std::max(top, bottom) * std::max(top, bottom));
+        break;
+    }
+    *rx = *ry = radius;
+  } else {
+    switch (layer.size) {
+      case RadialSize::ClosestCorner:
+      case RadialSize::ClosestSide:
+        *rx = std::min(left, right);
+        *ry = std::min(top, bottom);
+        break;
+      case RadialSize::FarthestSide:
+      case RadialSize::FarthestCorner:
+      default:
+        *rx = std::max(left, right);
+        *ry = std::max(top, bottom);
+        break;
+    }
+  }
+  *cx = centerX;
+  *cy = centerY;
+}
+
+/** One filled ellipse: a unit-radius rounded rect mapped by a local scale. */
+void addEllipse(DisplayList &out, float cx, float cy, float rx, float ry, const Color &color,
+                const PaintClip &clip, const Matrix2D &world) {
+  if (rx <= 0.0f || ry <= 0.0f || color.a <= 0.0f) return;
+  Matrix2D local = Matrix2D::translate(cx, cy)
+                       .multiply(Matrix2D::scale(rx, ry))
+                       .multiply(Matrix2D::translate(-cx, -cy));
+  addRect(out, cx - 1.0f, cy - 1.0f, 2.0f, 2.0f, 1.0f, color, clip, world.multiply(local));
+}
+
+void paintRadial(const LayoutBox &box, const XtStyle &style, const BackgroundLayer &layer,
+                 const FilterChain &chain, const PaintClip &clip, float viewportWidth,
+                 float viewportHeight, DisplayList &out) {
+  if (layer.stops.size() < 2 || box.width <= 0.0f || box.height <= 0.0f) return;
+  float cx = 0.0f;
+  float cy = 0.0f;
+  float rx = 0.0f;
+  float ry = 0.0f;
+  radialRadii(box, layer, style, viewportWidth, viewportHeight, &cx, &cy, &rx, &ry);
+  if (rx <= 0.0f || ry <= 0.0f) return;
+  const int bands = 32;
+  for (int i = bands; i >= 1; i--) {
+    float t = (float)i / (float)bands;
+    Color color = filterColor(chain, gradientColorAt(layer, t));
+    if (color.a <= 0.0f) continue;
+    addEllipse(out, cx, cy, rx * t, ry * t, color, clip, box.world);
+  }
+  /* Exact centre colour (the innermost band samples just off zero). */
+  Color center = filterColor(chain, gradientColorAt(layer, 0.0f));
+  addEllipse(out, cx, cy, 0.6f, 0.6f, center, clip, box.world);
+}
+
+}  // namespace
+
+void paintBackgrounds(DisplayList &out, const LayoutBox &box, const XtStyle &style,
+                      const FilterChain &chain, const PaintClip &clip, float viewportWidth,
+                      float viewportHeight) {
+  PaintClip layerClip = boxClip(clip, box);
+  if (layerClip.width <= 0.0f || layerClip.height <= 0.0f) return;
+  if (style.has_background) {
+    /* The rectangle is already the border box, so the incoming clip is enough;
+     * narrowing it to the box again would only change the reported clip (and
+     * would clip a filtered/rounded fill differently from before M19). */
+    addRectFiltered(out, box.x, box.y, box.width, box.height, style.border_radius,
+                    style.background, clip, box.world, chain);
+  }
+  /* CSS paints the first layer on top, so walk the list backwards. */
+  for (size_t i = style.background_layers.size(); i-- > 0;) {
+    const BackgroundLayer &layer = style.background_layers[i];
+    if (layer.kind == BackgroundKind::Linear) {
+      paintLinear(box, layer, chain, layerClip, out);
+    } else {
+      paintRadial(box, style, layer, chain, layerClip, viewportWidth, viewportHeight, out);
+    }
+  }
+}
+
+}  // namespace paint_detail
+}  // namespace xtgui