xbintsc 0.5.51 → 0.5.52

package/runtime/ext_gui/css.cpp

@@ -112,6 +112,163 @@ static std::vector<std::string> splitFunctionArgs(const std::string &text) {
   return args;
 }
 
+/** A scalar token (`12px`, `50%`, `1.5`) as a `Length`. Absolute lengths are
+ * converted to pixels here; relative units stay symbolic so layout can resolve
+ * them against the element that uses them. */
+static Length makeScalarLength(double number, const std::string &rawUnit) {
+  Length length;
+  std::string unit = xt_css_lower(xt_css_trim(rawUnit));
+  length.value = (float)number;
+  if (unit.empty() || unit == "px") length.unit = Unit::Px;
+  else if (unit == "%") length.unit = Unit::Percent;
+  else if (unit == "em") length.unit = Unit::Em;
+  else if (unit == "rem") length.unit = Unit::Rem;
+  else if (unit == "vw") length.unit = Unit::Vw;
+  else if (unit == "vh") length.unit = Unit::Vh;
+  else if (unit == "pt") { length.value = (float)number * (96.0f / 72.0f); length.unit = Unit::Px; }
+  else if (unit == "pc") { length.value = (float)number * 16.0f; length.unit = Unit::Px; }
+  else if (unit == "in") { length.value = (float)number * 96.0f; length.unit = Unit::Px; }
+  else if (unit == "cm") { length.value = (float)number * (96.0f / 2.54f); length.unit = Unit::Px; }
+  else if (unit == "mm") { length.value = (float)number * (96.0f / 25.4f); length.unit = Unit::Px; }
+  else if (unit == "q") { length.value = (float)number * (96.0f / 101.6f); length.unit = Unit::Px; }
+  else length.unit = Unit::Invalid;
+  return length;
+}
+
+static Length parseFunctionLength(const std::string &name, const std::string &inner);
+static bool parseMathExpression(const std::string &text, Length *out);
+
+/** Recursive-descent parser for `calc()` arithmetic (`+ - * /`, parentheses,
+ * nested `calc`/`min`/`max`/`clamp` and unit-bearing numbers). The expression
+ * tree stays unresolved: `xt_style_resolve_absolute` walks it once the
+ * containing block and font size are known. */
+struct MathParser {
+  explicit MathParser(const std::string &text) : text_(text) {}
+
+  bool parse(Length *out) {
+    if (!parseSum(out)) return false;
+    skip();
+    return index_ == text_.size();
+  }
+
+ private:
+  void skip() {
+    while (index_ < text_.size() && xt_is_css_space(text_[index_])) index_++;
+  }
+
+  bool parseSum(Length *out) {
+    Length left;
+    if (!parseProduct(&left)) return false;
+    for (;;) {
+      skip();
+      if (index_ >= text_.size() || (text_[index_] != '+' && text_[index_] != '-')) break;
+      char op = text_[index_++];
+      Length right;
+      if (!parseProduct(&right)) return false;
+      Length node;
+      node.unit = Unit::Calc;
+      node.op = op;
+      node.args.push_back(left);
+      node.args.push_back(right);
+      left = node;
+    }
+    *out = left;
+    return true;
+  }
+
+  bool parseProduct(Length *out) {
+    Length left;
+    if (!parseOperand(&left)) return false;
+    for (;;) {
+      skip();
+      if (index_ >= text_.size() || (text_[index_] != '*' && text_[index_] != '/')) break;
+      char op = text_[index_++];
+      Length right;
+      if (!parseOperand(&right)) return false;
+      Length node;
+      node.unit = Unit::Calc;
+      node.op = op;
+      node.args.push_back(left);
+      node.args.push_back(right);
+      left = node;
+    }
+    *out = left;
+    return true;
+  }
+
+  bool parseOperand(Length *out) {
+    skip();
+    if (index_ >= text_.size()) return false;
+    if (text_[index_] == '(') {
+      index_++;
+      if (!parseSum(out)) return false;
+      skip();
+      if (index_ >= text_.size() || text_[index_] != ')') return false;
+      index_++;
+      return true;
+    }
+    if (std::isalpha((unsigned char)text_[index_])) return parseFunction(out);
+    return parseNumber(out);
+  }
+
+  bool parseFunction(Length *out) {
+    size_t nameStart = index_;
+    while (index_ < text_.size() &&
+           (std::isalpha((unsigned char)text_[index_]) || text_[index_] == '-'))
+      index_++;
+    std::string name = xt_css_lower(text_.substr(nameStart, index_ - nameStart));
+    skip();
+    if (index_ >= text_.size() || text_[index_] != '(') return false;
+    size_t open = index_;
+    int depth = 0;
+    size_t close = std::string::npos;
+    for (; index_ < text_.size(); index_++) {
+      if (text_[index_] == '(') depth++;
+      else if (text_[index_] == ')') {
+        depth--;
+        if (depth == 0) {
+          close = index_;
+          break;
+        }
+      }
+    }
+    if (close == std::string::npos) return false;
+    std::string inner = text_.substr(open + 1, close - open - 1);
+    index_ = close + 1;
+    if (name == "calc") return parseMathExpression(inner, out);
+    if (name == "min" || name == "max" || name == "clamp" || name == "env") {
+      *out = parseFunctionLength(name, inner);
+      return out->unit != Unit::Invalid;
+    }
+    return false;
+  }
+
+  bool parseNumber(Length *out) {
+    skip();
+    const char *begin = text_.c_str() + index_;
+    char *end = nullptr;
+    double number = std::strtod(begin, &end);
+    if (end == begin || end == nullptr) return false;
+    index_ = (size_t)(end - text_.c_str());
+    size_t unitStart = index_;
+    while (index_ < text_.size() &&
+           (std::isalpha((unsigned char)text_[index_]) || text_[index_] == '%'))
+      index_++;
+    std::string unit = text_.substr(unitStart, index_ - unitStart);
+    *out = makeScalarLength(number, unit);
+    if (unit.empty()) out->unit = Unit::Number;
+    return out->unit != Unit::Invalid;
+  }
+
+  const std::string &text_;
+  size_t index_ = 0;
+};
+
+static bool parseMathExpression(const std::string &text, Length *out) {
+  MathParser parser(text);
+  return parser.parse(out);
+}
+
 /** `clamp(min, value, max)`, `min(...)` and `max(...)` over lengths. The
  * arguments stay unresolved; layout resolves them against the element's em and
  * the viewport. `env(safe-area-inset-*)` has no notch information in a desktop
@@ -135,8 +292,8 @@ static Length parseFunctionLength(const std::string &name, const std::string &in
   }
   result.unit = name == "clamp" ? Unit::Clamp : (name == "min" ? Unit::Min : Unit::Max);
   for (const std::string &arg : args) {
-    Length value = xt_css_parse_length(arg);
-    if (value.unit == Unit::Invalid) {
+    Length value;
+    if (!parseMathExpression(arg, &value)) {
       result.unit = Unit::Invalid;
       result.args.clear();
       return result;
@@ -163,34 +320,28 @@ Length xt_css_parse_length(const std::string &value) {
   }
   size_t open = text.find('(');
   if (open != std::string::npos && !text.empty() && text.back() == ')') {
-    std::string name = text.substr(0, open);
+    std::string name = xt_css_trim(text.substr(0, open));
+    std::string inner = text.substr(open + 1, text.size() - open - 2);
+    if (name == "calc") {
+      Length parsed;
+      if (!parseMathExpression(inner, &parsed)) parsed.unit = Unit::Invalid;
+      return parsed;
+    }
     if (name == "clamp" || name == "min" || name == "max" || name == "env") {
-      return parseFunctionLength(name, text.substr(open + 1, text.size() - open - 2));
+      return parseFunctionLength(name, inner);
     }
   }
+  /* A scalar keeps the historical `px` default for a unitless token; only
+   * arithmetic treats `2` as a number. */
   char *end = nullptr;
-  float number = strtof(text.c_str(), &end);
-  if (end == text.c_str()) {
+  double number = std::strtod(text.c_str(), &end);
+  if (end == text.c_str() || end == nullptr) {
     length.unit = Unit::Invalid;
     return length;
   }
   std::string unit = end;
   while (!unit.empty() && xt_is_css_space(unit[0])) unit.erase(unit.begin());
-  length.value = number;
-  if (unit.empty() || unit == "px") length.unit = Unit::Px;
-  else if (unit == "%") length.unit = Unit::Percent;
-  else if (unit == "em") length.unit = Unit::Em;
-  else if (unit == "rem") length.unit = Unit::Rem;
-  else if (unit == "vw") length.unit = Unit::Vw;
-  else if (unit == "vh") length.unit = Unit::Vh;
-  else if (unit == "pt") { length.value = number * (96.0f / 72.0f); length.unit = Unit::Px; }
-  else if (unit == "pc") { length.value = number * 16.0f; length.unit = Unit::Px; }
-  else if (unit == "in") { length.value = number * 96.0f; length.unit = Unit::Px; }
-  else if (unit == "cm") { length.value = number * (96.0f / 2.54f); length.unit = Unit::Px; }
-  else if (unit == "mm") { length.value = number * (96.0f / 25.4f); length.unit = Unit::Px; }
-  else if (unit == "q") { length.value = number * (96.0f / 101.6f); length.unit = Unit::Px; }
-  else length.unit = Unit::Invalid;
-  return length;
+  return makeScalarLength(number, unit);
 }
 
 namespace {

package/runtime/ext_gui/css.h

@@ -17,14 +17,35 @@
 
 namespace xtgui {
 
-enum class Unit { Auto, None, Px, Percent, Em, Rem, Vw, Vh, Number, Clamp, Min, Max, Invalid };
+enum class Unit {
+  Auto,
+  None,
+  Px,
+  Percent,
+  Em,
+  Rem,
+  Vw,
+  Vh,
+  Number,
+  Clamp,
+  Min,
+  Max,
+  /** A `calc()` sub-expression: `args[0] <op> args[1]`. Nested arithmetic keeps
+   * its operands unresolved, so only the units actually present are resolved
+   * against the element (a `calc(100% - 2em)` depends on both the containing
+   * block and the font size). */
+  Calc,
+  Invalid
+};
 
 struct Length {
   float value = 0.0f;
   Unit unit = Unit::Auto;
-  /* Arguments of `clamp(...)`, `min(...)` and `max(...)`; empty for a scalar
-   * length. Kept unresolved so vw/vh/em are resolved against the element that
-   * uses the length, not the viewport at parse time. */
+  /** `+`, `-`, `*` or `/` for `Unit::Calc`; zero otherwise. */
+  char op = 0;
+  /* Arguments of `clamp(...)`, `min(...)`, `max(...)` and `calc(...)`; empty for
+   * a scalar length. Kept unresolved so vw/vh/em are resolved against the
+   * element that uses the length, not the viewport at parse time. */
   std::vector<Length> args = {};
 };
 
@@ -79,21 +100,71 @@ struct Rule {
   std::string media;
 };
 
+/** One step of an `@keyframes` rule: a normalised offset (0..1) and the
+ * declarations that apply there. */
+struct Keyframe {
+  float offset = 0.0f;
+  std::vector<Declaration> declarations;
+};
+
+/** One `@keyframes <name>` block. Offsets are kept sorted so the animation
+ * engine can bracket a progress with two adjacent steps. */
+struct KeyframesRule {
+  std::string name;
+  std::vector<Keyframe> keyframes;
+};
+
+/** One `@font-face` source: a local file URL plus the optional `format(...)`
+ * hint. `local(...)` sources are dropped at parse time (the runtime has no
+ * name-to-file font lookup for them). */
+struct FontFaceSource {
+  std::string url;
+  std::string format;
+};
+
+/** One author `@font-face` rule. The runtime resolves the sources to a real
+ * font file when the document loads; the declared family name is what CSS
+ * matches, even when it differs from the font's internal name. */
+struct FontFaceRule {
+  std::string family;
+  std::vector<FontFaceSource> sources;
+  /** `font-weight` descriptor. A range (`100 900`) is kept as min/max; when the
+   * descriptor is absent the font's OS/2 weight is used. */
+  bool has_weight = false;
+  int weight_min = 400;
+  int weight_max = 400;
+  /** `font-style` descriptor; absent means the font's own italic flag. */
+  bool has_italic = false;
+  bool italic = false;
+};
+
 struct StyleSheet {
   std::vector<Rule> rules;
+  /** `@keyframes` blocks, in declaration order. */
+  std::vector<KeyframesRule> keyframes;
+  /** `@font-face` blocks, in declaration order. */
+  std::vector<FontFaceRule> font_faces;
   /* Facts the cascade can act on once per sheet instead of once per element (a
    * `@media` block, a `::before` rule or a `transition` declaration used to be
    * discovered by scanning every rule for every node). */
   bool has_pseudo_elements = false;
   bool has_hover = false;
   bool has_focus = false;
+  bool has_active = false;
   bool has_transitions = false;
+  bool has_animations = false;
 };
 
+/** Look up the last `@keyframes` rule with `name` (later blocks replace
+ * earlier ones), or null when the sheet has no such animation. */
+const KeyframesRule *xt_css_find_keyframes(const StyleSheet &sheet, const std::string &name);
+
 /** Dynamic element state consulted by `:hover` / `:focus` while matching. */
 struct MatchState {
   const Node *hover = nullptr;
   const Node *focus = nullptr;
+  /** The element currently held down by the primary pointer (`:active`). */
+  const Node *active = nullptr;
 };
 
 StyleSheet xt_css_parse_stylesheet(const std::string &text);

package/runtime/ext_gui/css_match.cpp

@@ -93,6 +93,10 @@ bool matchPseudo(const Node *node, const std::string &pseudo, const MatchState &
   if (pseudo == "root") return node->parent != nullptr && node->parent->isDocument();
   if (pseudo == "hover") return isHoverTarget(node, state.hover);
   if (pseudo == "focus") return node == state.focus;
+  /* The engine has no keyboard modality tracking, so focus-visible is the same
+   * as focus (a mouse click also shows the focus ring). */
+  if (pseudo == "focus-visible") return node == state.focus;
+  if (pseudo == "active") return isHoverTarget(node, state.active);
   if (pseudo == "empty") {
     for (const std::unique_ptr<Node> &child : node->children) {
       if (child->isElement()) return false;

package/runtime/ext_gui/css_sheet.cpp

@@ -8,6 +8,11 @@
 
 #include "css_internal.h"
 
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+#include <utility>
+
 namespace xtgui {
 
 namespace {
@@ -92,6 +97,202 @@ std::string stripImportant(std::string value, bool *important) {
   return value;
 }
 
+/** Strip matching quotes from an at-rule prelude name. */
+std::string unquote(std::string text) {
+  text = xt_css_trim(text);
+  if (text.size() >= 2 && (text.front() == '"' || text.front() == '\'') &&
+      text.back() == text.front()) {
+    text = text.substr(1, text.size() - 2);
+  }
+  return text;
+}
+
+bool parseKeyframeOffset(const std::string &text, float *offset) {
+  std::string token = xt_css_lower(xt_css_trim(text));
+  if (token == "from") {
+    *offset = 0.0f;
+    return true;
+  }
+  if (token == "to") {
+    *offset = 1.0f;
+    return true;
+  }
+  if (!token.empty() && token.back() == '%') {
+    float value = 0.0f;
+    if (!xt_css_parse_number(token.substr(0, token.size() - 1), &value)) return false;
+    *offset = value / 100.0f;
+    return true;
+  }
+  return false;
+}
+
+/** Parse the body of an `@keyframes` block into one rule. A selector list such
+ * as `0%, 50%` creates one step per offset with the same declarations. */
+void parseKeyframesBlock(const std::string &block, const std::string &prelude,
+                         StyleSheet *sheet) {
+  KeyframesRule rule;
+  rule.name = unquote(prelude);
+  if (rule.name.empty()) return;
+  size_t index = 0;
+  while (index < block.size()) {
+    while (index < block.size() && xt_is_css_space(block[index])) index++;
+    if (index >= block.size()) break;
+    size_t brace = block.find('{', index);
+    if (brace == std::string::npos) break;
+    size_t close = findBlockEnd(block, brace);
+    if (close == std::string::npos) break;
+    std::string selectors = block.substr(index, brace - index);
+    std::vector<Declaration> declarations =
+        xt_css_parse_declarations(block.substr(brace + 1, close - brace - 1));
+    for (const std::string &part : xt_css_split_commas(selectors)) {
+      float offset = 0.0f;
+      if (!parseKeyframeOffset(part, &offset)) continue;
+      Keyframe keyframe;
+      keyframe.offset = offset;
+      keyframe.declarations = declarations;
+      rule.keyframes.push_back(std::move(keyframe));
+    }
+    index = close + 1;
+  }
+  if (rule.keyframes.empty()) return;
+  std::stable_sort(rule.keyframes.begin(), rule.keyframes.end(),
+                   [](const Keyframe &a, const Keyframe &b) { return a.offset < b.offset; });
+  sheet->keyframes.push_back(std::move(rule));
+}
+
+/** Locate `name(` in a lower-cased value, returning the index of `(`. A match
+ * inside another identifier (`myurl(`) is rejected. */
+size_t findFunction(const std::string &lower, const char *name, size_t from) {
+  const size_t length = std::strlen(name);
+  size_t pos = lower.find(name, from);
+  while (pos != std::string::npos) {
+    const bool boundary =
+        pos == 0 || !(std::isalnum((unsigned char)lower[pos - 1]) || lower[pos - 1] == '-' ||
+                      lower[pos - 1] == '_');
+    size_t open = pos + length;
+    while (open < lower.size() && std::isspace((unsigned char)lower[open])) open++;
+    if (boundary && open < lower.size() && lower[open] == '(') return open;
+    pos = lower.find(name, pos + length);
+  }
+  return std::string::npos;
+}
+
+/** Extract the argument of a function whose `(` is at `open_paren`. Handles
+ * quotes and nested parentheses; trims the result. */
+bool functionArgument(const std::string &text, size_t open_paren, std::string *out,
+                      size_t *close_paren) {
+  int depth = 0;
+  char quote = 0;
+  for (size_t i = open_paren; i < text.size(); i++) {
+    const char c = text[i];
+    if (quote != 0) {
+      if (c == quote && (i == 0 || text[i - 1] != '\\')) quote = 0;
+      continue;
+    }
+    if (c == '"' || c == '\'') {
+      quote = c;
+    } else if (c == '(') {
+      depth++;
+    } else if (c == ')') {
+      depth--;
+      if (depth == 0) {
+        *out = xt_css_trim(text.substr(open_paren + 1, i - open_paren - 1));
+        *close_paren = i;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/** Parse the `src` descriptor: keep every `url(...)` source in order and drop
+ * `local(...)`. The `format(...)` hint is retained for diagnostics/future
+ * format selection; the runtime simply tries the sources in order. */
+void parseFontFaceSources(const std::string &value, FontFaceRule *rule) {
+  rule->sources.clear();
+  for (const std::string &part : xt_css_split_commas(value)) {
+    const std::string lower = xt_css_lower(part);
+    const size_t open = findFunction(lower, "url", 0);
+    if (open == std::string::npos) continue;
+    std::string url;
+    size_t close = 0;
+    if (!functionArgument(part, open, &url, &close)) continue;
+    url = unquote(url);
+    if (url.empty()) continue;
+    FontFaceSource source;
+    source.url = url;
+    const size_t format_open = findFunction(lower, "format", close + 1);
+    if (format_open != std::string::npos) {
+      std::string format;
+      size_t format_close = 0;
+      if (functionArgument(part, format_open, &format, &format_close)) {
+        source.format = unquote(format);
+      }
+    }
+    rule->sources.push_back(std::move(source));
+  }
+}
+
+/** `font-weight: normal | bold | <number> [<number>]`, with the range clamped. */
+bool parseFontWeightDescriptor(const std::string &value, int *minimum, int *maximum) {
+  const std::string text = xt_css_lower(xt_css_trim(value));
+  if (text.empty()) return false;
+  if (text == "normal") {
+    *minimum = 400;
+    *maximum = 400;
+    return true;
+  }
+  if (text == "bold") {
+    *minimum = 700;
+    *maximum = 700;
+    return true;
+  }
+  std::vector<int> weights;
+  for (const std::string &token : xt_css_split_whitespace(text)) {
+    float number = 0.0f;
+    if (!xt_css_parse_number(token, &number)) continue;
+    int weight = (int)(number + 0.5f);
+    weights.push_back(std::min(1000, std::max(1, weight)));
+  }
+  if (weights.empty()) return false;
+  *minimum = weights.front();
+  *maximum = weights.back();
+  if (*minimum > *maximum) std::swap(*minimum, *maximum);
+  return true;
+}
+
+/** Parse one `@font-face` block. A rule without a family name or a local source
+ * is ignored. */
+void parseFontFaceBlock(const std::string &block, StyleSheet *sheet) {
+  FontFaceRule rule;
+  for (const Declaration &declaration : xt_css_parse_declarations(block)) {
+    if (declaration.property == "font-family") {
+      rule.family = unquote(xt_css_trim(declaration.value));
+    } else if (declaration.property == "src") {
+      parseFontFaceSources(declaration.value, &rule);
+    } else if (declaration.property == "font-weight") {
+      int minimum = 400;
+      int maximum = 400;
+      if (parseFontWeightDescriptor(declaration.value, &minimum, &maximum)) {
+        rule.has_weight = true;
+        rule.weight_min = minimum;
+        rule.weight_max = maximum;
+      }
+    } else if (declaration.property == "font-style") {
+      const std::string text = xt_css_lower(xt_css_trim(declaration.value));
+      if (text == "normal") {
+        rule.has_italic = true;
+        rule.italic = false;
+      } else if (text == "italic" || text.rfind("oblique", 0) == 0) {
+        rule.has_italic = true;
+        rule.italic = true;
+      }
+    }
+  }
+  if (rule.family.empty() || rule.sources.empty()) return;
+  sheet->font_faces.push_back(std::move(rule));
+}
+
 /** Parse one rule list, carrying the enclosing `@media` prelude. */
 void parseRules(const std::string &text, const std::string &media, int *order,
                 StyleSheet *sheet) {
@@ -116,9 +317,14 @@ void parseRules(const std::string &text, const std::string &media, int *order,
           std::string query = xt_css_trim(text.substr(nameEnd, brace - nameEnd));
           std::string nested = combineMedia(media, query);
           parseRules(text.substr(brace + 1, close - brace - 1), nested, order, sheet);
+        } else if (name == "font-face") {
+          parseFontFaceBlock(text.substr(brace + 1, close - brace - 1), sheet);
+        } else if (name.size() >= 9 && name.compare(name.size() - 9, 9, "keyframes") == 0) {
+          parseKeyframesBlock(text.substr(brace + 1, close - brace - 1),
+                              text.substr(nameEnd, brace - nameEnd), sheet);
         }
-        /* Other block at-rules (`@supports`, `@keyframes`, `@font-face`, …) are
-         * not part of the engine's subset: ignore the whole block. */
+        /* Other block at-rules (`@supports`, …) are not part of the engine's
+         * subset: ignore the whole block. */
         index = close + 1;
       } else {
         index = (semi == std::string::npos) ? text.size() : semi + 1;
@@ -152,11 +358,13 @@ void computeSheetFlags(StyleSheet *sheet) {
         for (const std::string &pseudo : compound.pseudoClasses) {
           if (pseudo.find("hover") != std::string::npos) sheet->has_hover = true;
           if (pseudo.find("focus") != std::string::npos) sheet->has_focus = true;
+          if (pseudo == "active") sheet->has_active = true;
         }
       }
     }
     for (const Declaration &declaration : rule.declarations) {
       if (declaration.property.compare(0, 10, "transition") == 0) sheet->has_transitions = true;
+      if (declaration.property.compare(0, 9, "animation") == 0) sheet->has_animations = true;
     }
   }
 }
@@ -183,6 +391,14 @@ std::vector<Declaration> xt_css_parse_declarations(const std::string &text) {
   return declarations;
 }
 
+const KeyframesRule *xt_css_find_keyframes(const StyleSheet &sheet, const std::string &name) {
+  /* Later `@keyframes` blocks with the same name replace earlier ones. */
+  for (size_t i = sheet.keyframes.size(); i-- > 0;) {
+    if (sheet.keyframes[i].name == name) return &sheet.keyframes[i];
+  }
+  return nullptr;
+}
+
 StyleSheet xt_css_parse_stylesheet(const std::string &text) {
   StyleSheet sheet;
   std::string clean = stripComments(text);