xbintsc 0.5.45 → 0.5.52

package/runtime/ext_gui/style_values.cpp

@@ -124,52 +124,15 @@ static bool assignLength(Length *target, const std::string &value) {
 }
 
 
-float xt_style_resolve_absolute(const Length &length, float base, float em, float root, float vw,
-                                float vh) {
-  switch (length.unit) {
-    case Unit::Clamp: {
-      if (length.args.size() < 3) return 0.0f;
-      float low = xt_style_resolve_absolute(length.args[0], base, em, root, vw, vh);
-      float value = xt_style_resolve_absolute(length.args[1], base, em, root, vw, vh);
-      float high = xt_style_resolve_absolute(length.args[2], base, em, root, vw, vh);
-      return value < low ? low : (value > high ? high : value);
-    }
-    case Unit::Min: {
-      float best = 0.0f;
-      bool first = true;
-      for (const Length &arg : length.args) {
-        float value = xt_style_resolve_absolute(arg, base, em, root, vw, vh);
-        if (first || value < best) best = value;
-        first = false;
-      }
-      return best;
-    }
-    case Unit::Max: {
-      float best = 0.0f;
-      bool first = true;
-      for (const Length &arg : length.args) {
-        float value = xt_style_resolve_absolute(arg, base, em, root, vw, vh);
-        if (first || value > best) best = value;
-        first = false;
-      }
-      return best;
-    }
-    case Unit::Px:
-    case Unit::Number:
-      return length.value;
-    case Unit::Percent:
-      return base * length.value / 100.0f;
-    case Unit::Em:
-      return em * length.value;
-    case Unit::Rem:
-      return root * length.value;
-    case Unit::Vw:
-      return vw * length.value / 100.0f;
-    case Unit::Vh:
-      return vh * length.value / 100.0f;
-    default:
-      return 0.0f;
-  }
+/** A unitless declaration value, accepting `calc()` arithmetic (which resolves
+ * against the element's font and the viewport). */
+static bool parseNumeric(const std::string &value, const ApplyContext &context, float *out) {
+  if (xt_css_parse_number(value, out)) return true;
+  Length length = xt_css_parse_length(value);
+  if (length.unit != Unit::Calc) return false;
+  *out = xt_style_resolve_absolute(length, 0.0f, context.parentFontSize, context.rootFontSize,
+                                   context.viewportWidth, context.viewportHeight);
+  return true;
 }
 
 static bool parseEnum(const std::string &value, const char *const *names, int count, int *out) {
@@ -193,15 +156,31 @@ static bool assignColor(Color *target, bool *has, const std::string &value) {
 
 /* -- declaration application ---------------------------------------------- */
 
-void xt_style_apply_declaration(XtStyle *style, const std::string &property,
+void xt_style_apply_declaration(XtStyle *style, const std::string &rawProperty,
                                 const std::string &rawValue, const ApplyContext &context) {
   std::string value = xt_css_trim(rawValue);
+  /* Vendor aliases of properties the engine does implement. */
+  std::string property = rawProperty;
+  if (property == "-webkit-backdrop-filter") property = "backdrop-filter";
+  else if (property == "-webkit-user-select") property = "user-select";
 
   if (property == "display") {
+    std::string text = xt_css_lower(value);
+    style->inline_level = false;
+    if (text == "inline-flex") {
+      style->display = Display::Flex;
+      style->inline_level = true;
+      return;
+    }
+    if (text == "inline-grid") {
+      style->display = Display::Grid;
+      style->inline_level = true;
+      return;
+    }
     static const char *const names[] = {"none", "block", "inline", "inline-block", "flex", "grid",
                                         "list-item"};
     int index = 0;
-    if (parseEnum(value, names, 7, &index)) style->display = (Display)index;
+    if (parseEnum(text, names, 7, &index)) style->display = (Display)index;
     return;
   }
   if (property == "visibility") {
@@ -245,12 +224,36 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     return;
   }
 
-  if (property == "margin") { parseEdgeLengths(value, &style->margin); return; }
+  if (property == "margin") {
+    if (parseEdgeLengths(value, &style->margin)) {
+      style->margin_top_auto = style->margin.top.unit == Unit::Auto;
+      style->margin_right_auto = style->margin.right.unit == Unit::Auto;
+      style->margin_bottom_auto = style->margin.bottom.unit == Unit::Auto;
+      style->margin_left_auto = style->margin.left.unit == Unit::Auto;
+    }
+    return;
+  }
   if (property == "padding") { parseEdgeLengths(value, &style->padding); return; }
-  if (property == "margin-top") { setEdge(&style->margin, "top", xt_css_parse_length(value)); return; }
-  if (property == "margin-right") { setEdge(&style->margin, "right", xt_css_parse_length(value)); return; }
-  if (property == "margin-bottom") { setEdge(&style->margin, "bottom", xt_css_parse_length(value)); return; }
-  if (property == "margin-left") { setEdge(&style->margin, "left", xt_css_parse_length(value)); return; }
+  if (property == "margin-top") {
+    setEdge(&style->margin, "top", xt_css_parse_length(value));
+    style->margin_top_auto = style->margin.top.unit == Unit::Auto;
+    return;
+  }
+  if (property == "margin-right") {
+    setEdge(&style->margin, "right", xt_css_parse_length(value));
+    style->margin_right_auto = style->margin.right.unit == Unit::Auto;
+    return;
+  }
+  if (property == "margin-bottom") {
+    setEdge(&style->margin, "bottom", xt_css_parse_length(value));
+    style->margin_bottom_auto = style->margin.bottom.unit == Unit::Auto;
+    return;
+  }
+  if (property == "margin-left") {
+    setEdge(&style->margin, "left", xt_css_parse_length(value));
+    style->margin_left_auto = style->margin.left.unit == Unit::Auto;
+    return;
+  }
   if (property == "padding-top") { setEdge(&style->padding, "top", xt_css_parse_length(value)); return; }
   if (property == "padding-right") { setEdge(&style->padding, "right", xt_css_parse_length(value)); return; }
   if (property == "padding-bottom") { setEdge(&style->padding, "bottom", xt_css_parse_length(value)); return; }
@@ -262,8 +265,12 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
   if (property == "border-bottom-width") { setEdge(&style->border_width, "bottom", xt_css_parse_length(value)); return; }
   if (property == "border-left-width") { setEdge(&style->border_width, "left", xt_css_parse_length(value)); return; }
   if (property == "border-radius") {
+    /* `%` stays symbolic: layout resolves it against the box's smaller side. */
     Length length = xt_css_parse_length(value);
-    if (length.unit == Unit::Px || length.unit == Unit::Number) style->border_radius = length.value;
+    if (length.unit != Unit::Invalid && length.unit != Unit::Auto &&
+        length.unit != Unit::None) {
+      style->border_radius = length;
+    }
     return;
   }
   if (property == "border-style" || property == "border-top-style" || property == "border-right-style" ||
@@ -280,9 +287,10 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
   }
   if (property == "border" || property == "border-top" || property == "border-right" ||
       property == "border-bottom" || property == "border-left") {
-    for (const std::string &token : xt_css_split_whitespace(value)) {
+    for (const std::string &token : splitEdgeTokens(value)) {
       Length length = xt_css_parse_length(token);
-      if (length.unit == Unit::Px || length.unit == Unit::Number) {
+      if (length.unit != Unit::Invalid && length.unit != Unit::Auto &&
+          length.unit != Unit::None) {
         if (property == "border") style->border_width.set(length);
         else setEdge(&style->border_width, property.substr(7), length);
         continue;
@@ -308,6 +316,7 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     return;
   }
   if (property == "background-color") { assignColor(&style->background, &style->has_background, value); return; }
+  if (property == "background-size") { xt_style_apply_background_size(style, value); return; }
   if (property == "background-image") {
     xt_style_apply_background_image(style, value);
     return;
@@ -398,6 +407,9 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     if (parseEnum(value, names, 5, &index)) style->white_space = (WhiteSpace)index;
     return;
   }
+  if (xt_style_apply_text_property(style, property, value, context)) return;
+  if (xt_style_apply_ui_property(style, property, value)) return;
+  if (xt_style_apply_svg_property(style, property, value)) return;
 
   if (xt_style_apply_grid_property(style, property, value)) return;
 
@@ -447,12 +459,12 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
   if (property == "column-gap") { assignLength(&style->column_gap, value); return; }
   if (property == "flex-grow") {
     float number = 0;
-    if (xt_css_parse_number(value, &number)) style->flex_grow = number;
+    if (parseNumeric(value, context, &number)) style->flex_grow = number;
     return;
   }
   if (property == "flex-shrink") {
     float number = 0;
-    if (xt_css_parse_number(value, &number)) style->flex_shrink = number;
+    if (parseNumeric(value, context, &number)) style->flex_shrink = number;
     return;
   }
   if (property == "flex-basis") { assignLength(&style->flex_basis, value); return; }
@@ -476,7 +488,7 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
       style->flex_basis = {0.0f, Unit::Auto};
       return;
     }
-    std::vector<std::string> parts = xt_css_split_whitespace(text);
+    std::vector<std::string> parts = splitEdgeTokens(text);
     style->flex_grow = 0;
     style->flex_shrink = 1;
     style->flex_basis = {0.0f, Unit::Auto};
@@ -504,7 +516,7 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     /* One or two values plus an optional z offset (ignored: the engine is 2D).
      * The keywords carry an axis, so `top` alone means `center top` and
      * `top center` is the same as `center top`. */
-    std::vector<std::string> parts = xt_css_split_whitespace(value);
+    std::vector<std::string> parts = splitEdgeTokens(value);
     Length values[2] = {Length{50.0f, Unit::Percent}, Length{50.0f, Unit::Percent}};
     bool vertical[2] = {false, false};
     size_t used = 0;
@@ -540,7 +552,8 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
   }
   if (property == "opacity") {
     float number = 0;
-    if (xt_css_parse_number(value, &number)) style->opacity = number < 0 ? 0 : (number > 1 ? 1 : number);
+    if (parseNumeric(value, context, &number))
+      style->opacity = number < 0 ? 0 : (number > 1 ? 1 : number);
     return;
   }
   if (property == "mix-blend-mode") {
@@ -561,7 +574,7 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
   }
   if (property == "z-index") {
     float number = 0;
-    if (xt_css_parse_number(value, &number)) {
+    if (parseNumeric(value, context, &number)) {
       style->z_index = (int)number;
       style->has_z_index = true;
     }
@@ -580,6 +593,7 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     return;
   }
   if (xt_style_apply_transition(style, property, value)) return;
+  if (xt_style_apply_animation(style, property, value)) return;
 
 }
 

package/runtime/ext_gui/style_values_internal.h

@@ -4,6 +4,7 @@
 #include <string>
 
 struct XtStyle;
+struct ApplyContext;
 
 namespace xtgui {
 
@@ -30,6 +31,28 @@ bool xt_style_apply_grid_property(XtStyle *style, const std::string &property,
 bool xt_style_apply_transition(XtStyle *style, const std::string &property,
                                const std::string &value);
 
+/** Apply an `animation`/`animation-*` declaration. */
+bool xt_style_apply_animation(XtStyle *style, const std::string &property,
+                              const std::string &value);
+
+/** Apply text declarations (`letter-spacing`, `text-transform`,
+ * `writing-mode`, `vertical-align`, the `font` shorthand, …). */
+bool xt_style_apply_text_property(XtStyle *style, const std::string &property,
+                                  const std::string &value, const ApplyContext &context);
+
+/** Apply UI/interaction declarations (`outline`, `cursor`, `isolation`, and
+ * the platform hints the engine accepts but does not act on). */
+bool xt_style_apply_ui_property(XtStyle *style, const std::string &property,
+                                const std::string &value);
+
+/** Record an SVG presentation property (`fill`, `stroke`, …) for the inline
+ * `<svg>` serializer. Returns false for unrelated properties. */
+bool xt_style_apply_svg_property(XtStyle *style, const std::string &property,
+                                 const std::string &value);
+
+/** Apply `background-size` (a comma-separated list, one per layer). */
+bool xt_style_apply_background_size(XtStyle *style, const std::string &value);
+
 }  // namespace xtgui
 
 #endif /* XT_GUI_STYLE_VALUES_INTERNAL_H */