xbintsc 0.5.31 → 0.5.36

package/runtime/ext_gui/style.h

@@ -10,6 +10,7 @@
 #ifndef XT_GUI_STYLE_H
 #define XT_GUI_STYLE_H
 
+#include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -20,7 +21,8 @@
 
 namespace xtgui {
 
-enum class Display { None, Block, Inline, InlineBlock, Flex, ListItem };
+enum class Display { None, Block, Inline, InlineBlock, Flex, Grid, ListItem };
+enum class BoxSizing { ContentBox, BorderBox };
 enum class Position { Static, Relative, Absolute, Fixed };
 enum class FlexDirection { Row, RowReverse, Column, ColumnReverse };
 enum class FlexWrap { NoWrap, Wrap, WrapReverse };
@@ -44,6 +46,93 @@ struct TransitionSpec {
   TimingFunction timing = TimingFunction::Ease;
 };
 
+/** One track of a `grid-template-columns` / `grid-template-rows` list.
+ * `min`/`max` keep their CSS unit (`auto` for an intrinsic bound); `fr` is the
+ * flex fraction of a `minmax(..., <n>fr)` or `<n>fr` track. */
+struct GridTrack {
+  Length min{0.0f, Unit::Auto};
+  Length max{0.0f, Unit::Auto};
+  float fr = 0.0f;
+};
+
+struct BackgroundGradientStop {
+  float offset = 0.0f;
+  Color color;
+};
+
+enum class BackgroundKind { Linear, Radial };
+
+/** How a radial layer's radii are chosen when it has no explicit lengths. */
+enum class RadialSize { ClosestSide, FarthestSide, ClosestCorner, FarthestCorner, Explicit };
+
+/** One `background-image` layer. Layers are painted bottom-up: the first one in
+ * the declaration is the topmost, as in CSS. A gradient is approximated with
+ * solid bands through the rectangle pipeline (there is no gradient shader). */
+struct BackgroundLayer {
+  BackgroundKind kind = BackgroundKind::Linear;
+  /* linear */
+  float angle = 180.0f;  // CSS degrees: 0 = to top, 90 = to right, 180 = to bottom
+  /* radial */
+  bool circle = false;
+  bool has_shape = false;
+  RadialSize size = RadialSize::FarthestCorner;
+  Length center_x{50.0f, Unit::Percent};
+  Length center_y{50.0f, Unit::Percent};
+  Length radius_x{0.0f, Unit::Auto};  // Explicit radii only
+  Length radius_y{0.0f, Unit::Auto};
+  std::vector<BackgroundGradientStop> stops;
+};
+
+/** `clip-path` shapes. Lengths stay unresolved until paint knows the box. */
+struct ClipPathSpec {
+  enum class Type { None, Inset, Circle, Ellipse, Polygon } type = Type::None;
+  Length inset_top;
+  Length inset_right;
+  Length inset_bottom;
+  Length inset_left;
+  Length inset_radius{0.0f, Unit::Px};
+  Length center_x{50.0f, Unit::Percent};
+  Length center_y{50.0f, Unit::Percent};
+  Length radius_x{50.0f, Unit::Percent};
+  Length radius_y{50.0f, Unit::Percent};
+  bool radius_explicit = false;
+  /** Flat `x0, y0, x1, y1, …` list, resolved against the border box. */
+  std::vector<Length> polygon;
+};
+
+enum class FilterKind {
+  Blur,
+  Brightness,
+  Contrast,
+  Grayscale,
+  Sepia,
+  Invert,
+  Saturate,
+  HueRotate,
+  Opacity,
+  DropShadow
+};
+
+/** One `filter` / `backdrop-filter` function. */
+struct FilterOp {
+  FilterKind kind = FilterKind::Brightness;
+  float amount = 1.0f;
+  Length dx;
+  Length dy;
+  Length blur;
+  Color color;
+  bool has_color = false;
+};
+
+/** One `text-shadow` entry. */
+struct TextShadow {
+  Length dx;
+  Length dy;
+  Length blur;
+  Color color;  // `has_color == false` means currentColor
+  bool has_color = false;
+};
+
 struct Edges {
   Length top;
   Length right;
@@ -55,6 +144,10 @@ struct Edges {
 
 struct XtStyle {
   Display display = Display::Inline;
+  BoxSizing box_sizing = BoxSizing::ContentBox;
+  /* CSS custom properties (`--name`) are inherited and substituted into the
+   * values of the other declarations during the cascade. */
+  std::unordered_map<std::string, std::string> variables;
   Position position = Position::Static;
   Edges margin;
   Edges padding;
@@ -75,9 +168,25 @@ struct XtStyle {
   Length bottom;
   Length left;
 
+  bool visible = true;           // inherited `visibility`
+  bool pointer_events = true;    // inherited `pointer-events`
   Color color;             // inherited; defaults to black
   Color background;        // transparent by default
   bool has_background = false;
+  /** `background-image` layers, in declaration order (first = topmost). */
+  std::vector<BackgroundLayer> background_layers;
+  /** `clip-path`; `Type::None` leaves the box unclipped. */
+  ClipPathSpec clip_path;
+  /** `filter` / `backdrop-filter` function lists (not inherited). */
+  std::vector<FilterOp> filters;
+  std::vector<FilterOp> backdrop_filters;
+  /** `text-shadow` entries (inherited, as in CSS). */
+  std::vector<TextShadow> text_shadow;
+  /** Generated `content` of a `::before`/`::after` box. The cascade resolves
+   * `attr()` and string escapes before layout; `has_content` distinguishes
+   * `content: ""` from no generated box. */
+  std::string content;
+  bool has_content = false;
 
   float font_size = 16.0f;             // inherited
   int font_weight = 400;               // inherited
@@ -93,6 +202,19 @@ struct XtStyle {
   JustifyContent justify_content = JustifyContent::FlexStart;
   AlignItems align_items = AlignItems::Stretch;
   AlignContent align_content = AlignContent::Stretch;
+  /* Grid (a focused subset: explicit/implicit rows and columns, gap, item
+   * alignment and simple line placement). */
+  std::vector<GridTrack> grid_columns;
+  std::vector<GridTrack> grid_rows;
+  AlignItems justify_items = AlignItems::Stretch;
+  bool has_justify_self = false;
+  AlignItems justify_self = AlignItems::Stretch;
+  bool has_align_self = false;
+  AlignItems align_self = AlignItems::Stretch;
+  int grid_column_start = 0;
+  int grid_column_end = 0;
+  int grid_row_start = 0;
+  int grid_row_end = 0;
   Length gap;
   Length row_gap;
   Length column_gap;
@@ -121,11 +243,30 @@ struct XtStyle {
 /** Initial (non-inherited) style; inherited fields are overridden from the parent. */
 XtStyle xt_style_initial();
 
+/** Owns the synthetic `::before`/`::after` nodes of one style computation. The
+ * arena is rebuilt on every restyle, so generated content always reflects the
+ * latest DOM and CSS. */
+class PseudoNodeSet {
+ public:
+  /** Release the previous generation (the caller must already have cleared the
+   * element → pseudo pointers it handed out). */
+  void clear();
+  Node *create(Node *origin, PseudoElement side);
+  size_t size() const { return nodes_.size(); }
+
+ private:
+  std::vector<std::unique_ptr<Node>> nodes_;
+};
+
 /** Cascade UA + author + inline declarations into `out` for the document root.
- * `state` supplies `:hover`/`:focus` for dynamic selector matching. */
+ * `state` supplies `:hover`/`:focus` for dynamic selector matching. When
+ * `pseudos` is non-null, `::before`/`::after` styles are computed too and each
+ * element's transient `pseudo_before`/`pseudo_after` pointers are published for
+ * layout. */
 void xt_style_compute(const Node *root, const StyleSheet &sheet,
                       std::unordered_map<const Node *, XtStyle> &out, float viewportWidth,
-                      float viewportHeight, const MatchState &state = MatchState());
+                      float viewportHeight, const MatchState &state = MatchState(),
+                      PseudoNodeSet *pseudos = nullptr);
 
 /** Format a computed property for diagnostics/tests (`computedStyle(sel, prop)`). */
 std::string xt_style_property_to_string(const XtStyle &style, const std::string &property);

package/runtime/ext_gui/style_print.cpp

@@ -38,6 +38,18 @@ static std::string formatLength(const Length &length) {
       return formatNumber(length.value) + "vw";
     case Unit::Vh:
       return formatNumber(length.value) + "vh";
+    case Unit::Clamp:
+    case Unit::Min:
+    case Unit::Max: {
+      const char *name = length.unit == Unit::Clamp ? "clamp" : (length.unit == Unit::Min ? "min" : "max");
+      std::string text = std::string(name) + "(";
+      for (size_t i = 0; i < length.args.size(); i++) {
+        if (i > 0) text += ", ";
+        text += xt_style_length_to_string(length.args[i]);
+      }
+      text += ")";
+      return text;
+    }
     default:
       return "";
   }
@@ -56,9 +68,116 @@ static std::string formatColor(const Color &color) {
   return buffer;
 }
 
+static std::string quoteText(const std::string &text) {
+  std::string out = "\"";
+  for (char c : text) {
+    if (c == '"' || c == '\\') out.push_back('\\');
+    out.push_back(c);
+  }
+  out.push_back('"');
+  return out;
+}
+
+static std::string formatFilterList(const std::vector<FilterOp> &filters) {
+  if (filters.empty()) return "none";
+  std::string out;
+  for (const FilterOp &filter : filters) {
+    if (!out.empty()) out += " ";
+    switch (filter.kind) {
+      case FilterKind::Blur:
+        out += "blur(" + formatLength(filter.blur) + ")";
+        break;
+      case FilterKind::Brightness:
+        out += "brightness(" + formatNumber(filter.amount) + ")";
+        break;
+      case FilterKind::Contrast:
+        out += "contrast(" + formatNumber(filter.amount) + ")";
+        break;
+      case FilterKind::Grayscale:
+        out += "grayscale(" + formatNumber(filter.amount) + ")";
+        break;
+      case FilterKind::Sepia:
+        out += "sepia(" + formatNumber(filter.amount) + ")";
+        break;
+      case FilterKind::Invert:
+        out += "invert(" + formatNumber(filter.amount) + ")";
+        break;
+      case FilterKind::Saturate:
+        out += "saturate(" + formatNumber(filter.amount) + ")";
+        break;
+      case FilterKind::HueRotate:
+        out += "hue-rotate(" + formatNumber(filter.amount) + "deg)";
+        break;
+      case FilterKind::Opacity:
+        out += "opacity(" + formatNumber(filter.amount) + ")";
+        break;
+      case FilterKind::DropShadow:
+        out += "drop-shadow(" + formatLength(filter.dx) + " " + formatLength(filter.dy);
+        if (filter.blur.unit != Unit::Px || filter.blur.value != 0.0f)
+          out += " " + formatLength(filter.blur);
+        if (filter.has_color) out += " " + formatColor(filter.color);
+        out += ")";
+        break;
+    }
+  }
+  return out;
+}
+
+static std::string formatTextShadows(const std::vector<TextShadow> &shadows) {
+  if (shadows.empty()) return "none";
+  std::string out;
+  for (const TextShadow &shadow : shadows) {
+    if (!out.empty()) out += ", ";
+    out += formatLength(shadow.dx) + " " + formatLength(shadow.dy);
+    if (shadow.blur.unit != Unit::Px || shadow.blur.value != 0.0f)
+      out += " " + formatLength(shadow.blur);
+    if (shadow.has_color) out += " " + formatColor(shadow.color);
+  }
+  return out;
+}
+
+static std::string formatClipPath(const ClipPathSpec &clip) {
+  switch (clip.type) {
+    case ClipPathSpec::Type::None:
+      return "none";
+    case ClipPathSpec::Type::Inset: {
+      std::string out = "inset(" + formatLength(clip.inset_top) + " " +
+                        formatLength(clip.inset_right) + " " + formatLength(clip.inset_bottom) +
+                        " " + formatLength(clip.inset_left);
+      if (clip.inset_radius.unit != Unit::Px || clip.inset_radius.value != 0.0f)
+        out += " round " + formatLength(clip.inset_radius);
+      return out + ")";
+    }
+    case ClipPathSpec::Type::Circle:
+    case ClipPathSpec::Type::Ellipse: {
+      bool circle = clip.type == ClipPathSpec::Type::Circle;
+      std::string out = std::string(circle ? "circle(" : "ellipse(");
+      if (clip.radius_explicit) {
+        if (circle) out += formatLength(clip.radius_x);
+        else out += formatLength(clip.radius_x) + " " + formatLength(clip.radius_y);
+        out += " at ";
+      } else {
+        out += "at ";
+      }
+      out += formatLength(clip.center_x) + " " + formatLength(clip.center_y) + ")";
+      return out;
+    }
+    case ClipPathSpec::Type::Polygon: {
+      std::string out = "polygon(";
+      for (size_t i = 0; i + 1 < clip.polygon.size(); i += 2) {
+        if (i > 0) out += ", ";
+        out += formatLength(clip.polygon[i]) + " " + formatLength(clip.polygon[i + 1]);
+      }
+      return out + ")";
+    }
+  }
+  return "none";
+}
+
 std::string xt_style_property_to_string(const XtStyle &style, const std::string &rawProperty) {
   std::string property = xt_css_lower(xt_css_trim(rawProperty));
-  static const char *const displayNames[] = {"none", "block", "inline", "inline-block", "flex", "list-item"};
+  static const char *const displayNames[] = {"none", "block", "inline", "inline-block", "flex",
+                                             "grid", "list-item"};
   static const char *const positionNames[] = {"static", "relative", "absolute", "fixed"};
   static const char *const flexNames[] = {"row", "row-reverse", "column", "column-reverse"};
   static const char *const wrapNames[] = {"nowrap", "wrap", "wrap-reverse"};
@@ -118,6 +237,20 @@ std::string xt_style_property_to_string(const XtStyle &style, const std::string
   if (property == "border-radius") return formatNumber(style.border_radius) + "px";
   if (property == "opacity") return formatNumber(style.opacity);
   if (property == "z-index") return style.has_z_index ? formatNumber((float)style.z_index) : "auto";
+  if (property == "content") return style.has_content ? quoteText(style.content) : "none";
+  if (property == "clip-path") return formatClipPath(style.clip_path);
+  if (property == "filter") return formatFilterList(style.filters);
+  if (property == "backdrop-filter") return formatFilterList(style.backdrop_filters);
+  if (property == "text-shadow") return formatTextShadows(style.text_shadow);
+  if (property == "background-image") {
+    if (style.background_layers.empty()) return "none";
+    std::string out;
+    for (const BackgroundLayer &layer : style.background_layers) {
+      if (!out.empty()) out += ", ";
+      out += layer.kind == BackgroundKind::Linear ? "linear-gradient()" : "radial-gradient()";
+    }
+    return out;
+  }
   if (property == "transform") return xt_transform_to_string(style.transform);
   if (property == "transform-origin") {
     return formatLength(style.transform_origin_x) + " " + formatLength(style.transform_origin_y);