xbintsc 0.3.69 → 0.3.81

package/runtime/ext_gui/style_values.cpp

@@ -347,6 +347,23 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     if (parseEnum(value, names, 4, &index)) style->flex_direction = (FlexDirection)index;
     return;
   }
+  if (property == "flex-wrap") {
+    static const char *const names[] = {"nowrap", "wrap", "wrap-reverse"};
+    int index = 0;
+    if (parseEnum(value, names, 3, &index)) style->flex_wrap = (FlexWrap)index;
+    return;
+  }
+  if (property == "flex-flow") {
+    /* `flex-flow: <direction> || <wrap>` in either order. */
+    for (const std::string &token : xt_css_split_whitespace(value)) {
+      static const char *const dirs[] = {"row", "row-reverse", "column", "column-reverse"};
+      static const char *const wraps[] = {"nowrap", "wrap", "wrap-reverse"};
+      int index = 0;
+      if (parseEnum(token, dirs, 4, &index)) style->flex_direction = (FlexDirection)index;
+      else if (parseEnum(token, wraps, 3, &index)) style->flex_wrap = (FlexWrap)index;
+    }
+    return;
+  }
   if (property == "justify-content") {
     static const char *const names[] = {"flex-start", "flex-end", "center", "space-between",
                                         "space-around", "space-evenly"};
@@ -360,10 +377,20 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     if (parseEnum(value, names, 5, &index)) style->align_items = (AlignItems)index;
     return;
   }
-  if (property == "gap" || property == "row-gap" || property == "column-gap") {
+  if (property == "align-content") {
+    static const char *const names[] = {"stretch", "flex-start", "flex-end", "center",
+                                        "space-between", "space-around"};
+    int index = 0;
+    if (parseEnum(value, names, 6, &index)) style->align_content = (AlignContent)index;
+    return;
+  }
+  if (property == "gap") {
     assignLength(&style->gap, value);
+    style->row_gap = style->column_gap = style->gap;
     return;
   }
+  if (property == "row-gap") { assignLength(&style->row_gap, value); return; }
+  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;
@@ -414,6 +441,49 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     return;
   }
 
+  if (property == "transform") {
+    std::vector<TransformOp> ops;
+    if (xt_transform_parse(value, &ops)) style->transform = ops;
+    return;
+  }
+  if (property == "transform-origin") {
+    /* 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);
+    Length values[2] = {Length{50.0f, Unit::Percent}, Length{50.0f, Unit::Percent}};
+    bool vertical[2] = {false, false};
+    size_t used = 0;
+    for (const std::string &part : parts) {
+      if (used >= 2) break;
+      std::string keyword = xt_css_lower(part);
+      Length length = xt_css_parse_length(keyword);
+      if (length.unit == Unit::Invalid || length.unit == Unit::Auto || length.unit == Unit::None) {
+        if (keyword == "left" || keyword == "top") length = {0.0f, Unit::Percent};
+        else if (keyword == "center") length = {50.0f, Unit::Percent};
+        else if (keyword == "right" || keyword == "bottom") length = {100.0f, Unit::Percent};
+        else return;
+        vertical[used] = keyword == "top" || keyword == "bottom";
+      }
+      values[used++] = length;
+    }
+    if (used == 0) return;
+    Length x = values[0];
+    Length y = used > 1 ? values[1] : Length{50.0f, Unit::Percent};
+    if (used > 1) {
+      if (vertical[0] && !vertical[1]) {
+        x = values[1];
+        y = values[0];
+      }
+    } else if (vertical[0]) {
+      /* `top`/`bottom` on their own keep x centred. */
+      x = Length{50.0f, Unit::Percent};
+      y = values[0];
+    }
+    style->transform_origin_x = x;
+    style->transform_origin_y = y;
+    return;
+  }
   if (property == "opacity") {
     float number = 0;
     if (xt_css_parse_number(value, &number)) style->opacity = number < 0 ? 0 : (number > 1 ? 1 : number);
@@ -433,6 +503,18 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     }
     return;
   }
+  if (property == "float") {
+    static const char *const names[] = {"none", "left", "right"};
+    int index = 0;
+    if (parseEnum(value, names, 3, &index)) style->float_side = (FloatSide)index;
+    return;
+  }
+  if (property == "clear") {
+    static const char *const names[] = {"none", "left", "right", "both"};
+    int index = 0;
+    if (parseEnum(value, names, 4, &index)) style->clear = (Clear)index;
+    return;
+  }
   if (property == "transition") {
     parseTransitionShorthand(value, &style->transitions);
     return;

package/runtime/ext_gui/svg.cpp

@@ -0,0 +1,182 @@
+/*
+ * xbintsc GUI engine — SVG decoding. See `svg.h` for the contract.
+ *
+ * The heavy lifting is the vendored NanoSVG library (`nanosvg.h` +
+ * `nanosvgrast.h`, zlib licence, fetched verbatim). This file is only the glue:
+ * path detection, a parsed-document cache and the scale-to-fit call. NanoSVG
+ * emits straight (non-premultiplied) RGBA8, which is exactly the `Image`
+ * layout the rest of the engine expects.
+ */
+
+#include "svg.h"
+
+#define NANOSVG_IMPLEMENTATION
+#define NANOSVGRAST_IMPLEMENTATION
+/* NanoSVG is vendored verbatim, so silence the one warning it raises under
+ * `-Wall` instead of patching the upstream sources. */
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wsign-compare"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+#include "nanosvg.h"
+#include "nanosvgrast.h"
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+#include <algorithm>
+#include <cctype>
+#include <cstdio>
+#include <fstream>
+#include <string>
+#include <unordered_map>
+
+namespace xtgui {
+namespace {
+
+/** NanoSVG's default when the SVG declares neither width/height nor a viewBox
+ * (SVG 1.1 says a replaced element falls back to 300x150). */
+constexpr float kDefaultWidth = 300.0f;
+constexpr float kDefaultHeight = 150.0f;
+/** Refuse to allocate a monstrous texture if an `<img>` is scaled absurdly. */
+constexpr int kMaxDimension = 8192;
+
+std::string lowercase(std::string value) {
+  for (char &c : value) c = (char)std::tolower((unsigned char)c);
+  return value;
+}
+
+/** True when the file name ends in `.svg` (case-insensitive). */
+bool hasSvgExtension(const std::string &path) {
+  if (path.size() < 4) return false;
+  return lowercase(path.substr(path.size() - 4)) == ".svg";
+}
+
+/** Cheap content sniff for a file whose extension is not enough (no extension,
+ * or a generated temporary). Looks for `<svg` in the first chunk, which is
+ * present after any XML declaration, doctype or leading comment of a sane
+ * size. */
+bool prefixLooksLikeSvg(const std::string &path) {
+  std::ifstream in(path, std::ios::binary);
+  if (!in) return false;
+  char buffer[1024];
+  in.read(buffer, sizeof(buffer));
+  std::streamsize size = in.gcount();
+  if (size <= 0) return false;
+  std::string prefix(buffer, (size_t)size);
+  return prefix.find("<svg") != std::string::npos;
+}
+
+std::unordered_map<std::string, NSVGimage *> &parsedCache() {
+  static std::unordered_map<std::string, NSVGimage *> cache;
+  return cache;
+}
+
+/** Remember the extension/sniff verdict so a raster image is not reopened on
+ * every frame (the loader asks for every `<img>` each time it paints). */
+std::unordered_map<std::string, bool> &detectCache() {
+  static std::unordered_map<std::string, bool> cache;
+  return cache;
+}
+
+NSVGrasterizer *&rasterizer() {
+  static NSVGrasterizer *value = nullptr;
+  return value;
+}
+
+/** Parse `path` once and remember the result (including failures, so a missing
+ * file is not retried every frame). */
+NSVGimage *parseCached(const std::string &path) {
+  auto &cache = parsedCache();
+  auto found = cache.find(path);
+  if (found != cache.end()) return found->second;
+  NSVGimage *image = nsvgParseFromFile(path.c_str(), "px", 96.0f);
+  cache.emplace(path, image);
+  return image;
+}
+
+float intrinsicWidth(const NSVGimage *image) {
+  return image->width > 0.0f ? image->width : kDefaultWidth;
+}
+
+float intrinsicHeight(const NSVGimage *image) {
+  return image->height > 0.0f ? image->height : kDefaultHeight;
+}
+
+}  // namespace
+
+bool xt_svg_is_svg(const std::string &path) {
+  auto &cache = detectCache();
+  auto found = cache.find(path);
+  if (found != cache.end()) return found->second;
+  bool result = hasSvgExtension(path) || prefixLooksLikeSvg(path);
+  cache.emplace(path, result);
+  return result;
+}
+
+bool xt_svg_size(const std::string &path, int *width, int *height) {
+  NSVGimage *image = parseCached(path);
+  if (image == nullptr) return false;
+  float w = intrinsicWidth(image);
+  float h = intrinsicHeight(image);
+  if (w <= 0.0f || h <= 0.0f) return false;
+  if (width != nullptr) *width = (int)(w + 0.5f);
+  if (height != nullptr) *height = (int)(h + 0.5f);
+  return true;
+}
+
+bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
+  if (out == nullptr) return false;
+  NSVGimage *image = parseCached(path);
+  if (image == nullptr) return false;
+
+  float source_width = intrinsicWidth(image);
+  float source_height = intrinsicHeight(image);
+  int target_width = width > 0 ? width : (int)(source_width + 0.5f);
+  int target_height = height > 0 ? height : (int)(source_height + 0.5f);
+  if (target_width <= 0 || target_height <= 0) return false;
+  target_width = std::min(target_width, kMaxDimension);
+  target_height = std::min(target_height, kMaxDimension);
+
+  /* Rasterise at the source aspect ratio, at the larger of the two axis scales
+   * (so neither axis is under-sampled), then let the quad stretch the texture
+   * to the box — exactly how a bitmap would behave under CSS `object-fit:
+   * fill`. The common case (layout preserved the aspect ratio) makes this equal
+   * to the requested size. */
+  float scale = std::max((float)target_width / source_width, (float)target_height / source_height);
+  scale = std::min(scale, (float)kMaxDimension / source_width);
+  scale = std::min(scale, (float)kMaxDimension / source_height);
+  int raster_width = (int)(source_width * scale + 0.5f);
+  int raster_height = (int)(source_height * scale + 0.5f);
+  if (raster_width < 1 || raster_height < 1) return false;
+
+  NSVGrasterizer *&rast = rasterizer();
+  if (rast == nullptr) rast = nsvgCreateRasterizer();
+  if (rast == nullptr) return false;
+
+  out->width = raster_width;
+  out->height = raster_height;
+  out->pixels.assign((size_t)raster_width * (size_t)raster_height * 4u, 0);
+  nsvgRasterize(rast, image, 0.0f, 0.0f, scale, out->pixels.data(), raster_width, raster_height,
+                raster_width * 4);
+  return true;
+}
+
+void xt_svg_shutdown() {
+  for (auto &entry : parsedCache()) {
+    if (entry.second != nullptr) nsvgDelete(entry.second);
+  }
+  parsedCache().clear();
+  detectCache().clear();
+  if (rasterizer() != nullptr) {
+    nsvgDeleteRasterizer(rasterizer());
+    rasterizer() = nullptr;
+  }
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/svg.h

@@ -0,0 +1,46 @@
+/*
+ * xbintsc GUI engine — SVG decoding (NanoSVG wrapper).
+ *
+ * An SVG file is not a raster, so `stb_image` cannot decode it. This module
+ * sits next to `image.{h,cpp}` and turns an SVG file into the same RGBA8
+ * `Image` the rest of the image pipeline already consumes: parse once (cached
+ * per path) and rasterise into a texture-sized buffer on demand. The parse and
+ * the anti-aliased scanline rasteriser are the vendored NanoSVG library
+ * (`nanosvg.h` + `nanosvgrast.h`) — the same class of low-level, third-party
+ * image library `stb_image` is (see doc/gui.md).
+ *
+ * Only *files* are handled: `<img src="logo.svg">`. Inline `<svg>` trees in a
+ * document are still ordinary unknown elements to the HTML parser and generate
+ * no boxes.
+ */
+#ifndef XT_GUI_SVG_H
+#define XT_GUI_SVG_H
+
+#include <string>
+
+#include "image.h"
+
+namespace xtgui {
+
+/** True when `path` names an SVG file: a `.svg` extension (case-insensitive),
+ * or a small prefix of the contents that looks like an SVG root element. */
+bool xt_svg_is_svg(const std::string &path);
+
+/** Read the intrinsic size from an SVG file without rasterising it. Returns
+ * false when the file is missing or cannot be parsed. Cached per path. */
+bool xt_svg_size(const std::string &path, int *width, int *height);
+
+/** Rasterise `path` to RGBA8. `width`/`height` are the requested pixel size;
+ * when either is `<= 0` the intrinsic SVG size is used. The viewBox is scaled
+ * uniformly at the larger of the two axis scales (preserving the SVG's aspect
+ * ratio, so the caller's quad may stretch it exactly as it would a bitmap) and
+ * clamped so neither axis exceeds 8192px. Returns false on parse/rasteriser
+ * failure. The parse is cached per path; each rasterisation is fresh. */
+bool xt_svg_render(const std::string &path, int width, int height, Image *out);
+
+/** Drop the parsed-document cache (called on engine shutdown). */
+void xt_svg_shutdown();
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_SVG_H */

package/runtime/ext_gui/text.cpp

@@ -4,6 +4,15 @@
  * HarfBuzz does shaping (ligatures/kerning/complex scripts), FreeType owns the
  * glyph outlines and the vertical metrics. We create one HarfBuzz font per
  * (file, pixel size) and scale it so that advances come back in 26.6 pixels.
+ *
+ * A run is shaped with a *single* face, but that face rarely covers every
+ * codepoint in it — a CJK face such as Microsoft YaHei / PingFang / Noto Sans
+ * CJK has no geometric shapes (U+25AE ▮, U+25AF ▯, …), and a Latin face has no
+ * CJK. Each codepoint therefore resolves to the first face in a small fallback
+ * chain that has it, the run is shaped in segments (one per face), and each
+ * shaped glyph carries the face it came from so the rasteriser draws it from
+ * the right atlas entry. Without this a missing glyph came back as `.notdef`
+ * (glyph 0) and the renderer silently dropped it.
  */
 
 #include "text.h"
@@ -22,6 +31,7 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace xtgui {
 
@@ -30,6 +40,8 @@ namespace xtgui {
 struct Font {
   FT_Face ft_face = nullptr;
   hb_font_t *hb_font = nullptr;
+  std::string path;
+  bool monospace = false;
   float pixel_size = 16.0f;
   float ascent = 0;
   float descent = 0;
@@ -85,13 +97,33 @@ const char *const kMonoCandidates[] = {
     "C:\\Windows\\Fonts\\cour.ttf",
 };
 
+/* Faces tried after the primary one for codepoints it does not cover. Symbol
+ * faces come first (they carry the geometric shapes, arrows, box drawing and
+ * dingbats the CJK/Latin primary often lacks), then the other family class so
+ * a monospace run still gets CJK and a sans run still gets monospace-only
+ * codepoints. The primary and duplicates are dropped when the chain is built. */
+const char *const kSymbolCandidates[] = {
+    nullptr,
+    "C:\\Windows\\Fonts\\seguisym.ttf",  /* Segoe UI Symbol */
+    "C:\\Windows\\Fonts\\arialuni.ttf",  /* Arial Unicode MS */
+    "/System/Library/Fonts/Apple Symbols.ttf",
+    "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
+    "/usr/share/fonts/truetype/noto/NotoSansSymbols2-Regular.ttf",
+    "/usr/share/fonts/truetype/noto/NotoSansSymbols-Regular.ttf",
+    "/usr/share/fonts/truetype/ancient-scripts/Symbola_hint.ttf",
+    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+};
+
 struct Engine {
   bool initialized = false;
   FT_Library ft = nullptr;
   bool ft_ok = false;
   std::string sans_path;
   std::string mono_path;
+  std::vector<std::string> sans_fallbacks;
+  std::vector<std::string> mono_fallbacks;
   std::unordered_map<std::string, std::unique_ptr<Font>> cache;  // key -> face (may be null)
+  std::unordered_map<std::string, std::vector<Font *>> fallbacks;  // class+size -> faces
   std::unordered_map<std::string, hb_face_t *> hb_faces;         // path -> face
 };
 
@@ -182,6 +214,25 @@ const char *firstExisting(const char *const *candidates, size_t count) {
   return nullptr;
 }
 
+void addFallbackPath(std::vector<std::string> &paths, const char *path) {
+  if (path == nullptr || !fileExists(path)) return;
+  for (const std::string &entry : paths) {
+    if (entry == path) return;
+  }
+  paths.push_back(path);
+}
+
+/* The chain for a primary face: every existing symbol face, then the other
+ * family class (CJK coverage for a monospace primary and vice versa). The
+ * primary itself is skipped because it is tried first, per codepoint. */
+void buildFallbackChain(std::vector<std::string> &paths, const std::string &primary,
+                        const std::string &otherClass) {
+  for (const char *candidate : kSymbolCandidates) {
+    if (candidate != nullptr && primary != candidate) addFallbackPath(paths, candidate);
+  }
+  if (!otherClass.empty() && otherClass != primary) addFallbackPath(paths, otherClass.c_str());
+}
+
 void ensureInitialized() {
   Engine &e = engine();
   if (e.initialized) return;
@@ -214,6 +265,9 @@ void ensureInitialized() {
   }
   /* No dedicated monospace face: reuse the sans face so metrics stay real. */
   if (e.mono_path.empty()) e.mono_path = e.sans_path;
+
+  buildFallbackChain(e.sans_fallbacks, e.sans_path, e.mono_path);
+  buildFallbackChain(e.mono_fallbacks, e.mono_path, e.sans_path);
 }
 
 hb_face_t *hbFaceForPath(const std::string &path) {
@@ -230,7 +284,7 @@ hb_face_t *hbFaceForPath(const std::string &path) {
   return face;
 }
 
-std::unique_ptr<Font> createFont(const std::string &path, float pixel_size) {
+std::unique_ptr<Font> createFont(const std::string &path, float pixel_size, bool monospace) {
   Engine &e = engine();
   if (!e.ft_ok || path.empty()) return nullptr;
 
@@ -240,6 +294,8 @@ std::unique_ptr<Font> createFont(const std::string &path, float pixel_size) {
 
   auto font = std::make_unique<Font>();
   font->ft_face = face;
+  font->path = path;
+  font->monospace = monospace;
   font->pixel_size = pixel_size;
 
   FT_Size_Metrics metrics = face->size->metrics;
@@ -259,43 +315,63 @@ std::unique_ptr<Font> createFont(const std::string &path, float pixel_size) {
   return font;
 }
 
-}  // namespace
-
-Font *xt_text_resolve(const FontSpec &spec) {
-  ensureInitialized();
+/* Resolve one face by path, keyed by path+class+size so the primary resolved
+ * through a `FontSpec` and the same face resolved as a fallback share one
+ * `Font` (and one glyph-atlas key). */
+Font *resolveFacePath(const std::string &path, float pixel_size, bool monospace) {
   Engine &e = engine();
-  if (!e.ft_ok) return nullptr;
-
-  bool mono = isMonospaceFamily(spec.family);
-  const std::string &path = mono ? e.mono_path : e.sans_path;
-  if (path.empty()) return nullptr;
-
-  char key[80];
-  std::snprintf(key, sizeof(key), "%c|%.2f", mono ? 'm' : 's', (double)spec.pixel_size);
+  if (!e.ft_ok || path.empty()) return nullptr;
+  char key[512];
+  std::snprintf(key, sizeof(key), "p|%c|%.2f|%s", monospace ? 'm' : 's', (double)pixel_size,
+                path.c_str());
   auto it = e.cache.find(key);
   if (it != e.cache.end()) return it->second.get();
-
-  std::unique_ptr<Font> font = createFont(path, spec.pixel_size);
+  std::unique_ptr<Font> font = createFont(path, pixel_size, monospace);
   Font *raw = font.get();
   e.cache.emplace(key, std::move(font));
   return raw;
 }
 
-float xt_text_measure_width(const std::string &utf8, const FontSpec &spec) {
-  Font *font = xt_text_resolve(spec);
-  if (font == nullptr) return approximateWidth(utf8, spec.pixel_size, spec.family);
-  std::vector<ShapedGlyph> glyphs;
-  return xt_text_shape_run(utf8, font, glyphs);
+/* The resolved fallback faces for a primary, in order, cached per class+size. */
+const std::vector<Font *> &fallbackFaces(Font *font) {
+  static const std::vector<Font *> kEmpty;
+  if (font == nullptr) return kEmpty;
+  Engine &e = engine();
+  char key[80];
+  std::snprintf(key, sizeof(key), "f|%c|%.2f", font->monospace ? 'm' : 's',
+                (double)font->pixel_size);
+  auto it = e.fallbacks.find(key);
+  if (it != e.fallbacks.end()) return it->second;
+
+  const std::vector<std::string> &paths =
+      font->monospace ? e.mono_fallbacks : e.sans_fallbacks;
+  std::vector<Font *> faces;
+  for (const std::string &path : paths) {
+    Font *face = resolveFacePath(path, font->pixel_size, font->monospace);
+    if (face != nullptr) faces.push_back(face);
+  }
+  return e.fallbacks.emplace(key, std::move(faces)).first->second;
 }
 
-float xt_text_shape_run(const std::string &utf8, Font *font, std::vector<ShapedGlyph> &out) {
-  if (font == nullptr) return 0;
+/* The face that draws `code_point`: the primary when it has the glyph, else the
+ * first fallback that does, else the primary (so `.notdef` is still skipped). */
+Font *faceForCodePoint(Font *primary, uint32_t code_point) {
+  if (primary != nullptr && FT_Get_Char_Index(primary->ft_face, code_point) != 0) return primary;
+  for (Font *fallback : fallbackFaces(primary)) {
+    if (FT_Get_Char_Index(fallback->ft_face, code_point) != 0) return fallback;
+  }
+  return primary;
+}
+
+/* Shape one face's segment of a run and append its glyphs. */
+float shapeSegment(const std::string &segment, Font *font, std::vector<ShapedGlyph> &out) {
+  if (font == nullptr || segment.empty()) return 0;
   float total = 0;
   if (font->hb_font == nullptr) {
     /* HarfBuzz unavailable: fall back to FreeType's per-codepoint advances. */
     size_t index = 0;
-    while (index < utf8.size()) {
-      uint32_t code_point = decodeUtf8(utf8, index);
+    while (index < segment.size()) {
+      uint32_t code_point = decodeUtf8(segment, index);
       FT_UInt glyph = FT_Get_Char_Index(font->ft_face, code_point);
       float advance = 0;
       if (FT_Load_Glyph(font->ft_face, glyph, FT_LOAD_DEFAULT) == 0) {
@@ -304,6 +380,7 @@ float xt_text_shape_run(const std::string &utf8, Font *font, std::vector<ShapedG
       ShapedGlyph shaped;
       shaped.glyph = glyph;
       shaped.x_advance = advance;
+      shaped.font = font;
       total += advance;
       out.push_back(shaped);
     }
@@ -311,7 +388,7 @@ float xt_text_shape_run(const std::string &utf8, Font *font, std::vector<ShapedG
   }
 
   hb_buffer_t *buffer = hb_buffer_create();
-  hb_buffer_add_utf8(buffer, utf8.c_str(), (int)utf8.size(), 0, -1);
+  hb_buffer_add_utf8(buffer, segment.c_str(), (int)segment.size(), 0, -1);
   hb_buffer_guess_segment_properties(buffer);
   hb_shape(font->hb_font, buffer, nullptr, 0);
   unsigned count = hb_buffer_get_length(buffer);
@@ -323,6 +400,7 @@ float xt_text_shape_run(const std::string &utf8, Font *font, std::vector<ShapedG
     shaped.x_advance = positions[i].x_advance / 64.0f;
     shaped.x_offset = positions[i].x_offset / 64.0f;
     shaped.y_offset = positions[i].y_offset / 64.0f;
+    shaped.font = font;
     total += shaped.x_advance;
     out.push_back(shaped);
   }
@@ -330,6 +408,56 @@ float xt_text_shape_run(const std::string &utf8, Font *font, std::vector<ShapedG
   return total;
 }
 
+}  // namespace
+
+Font *xt_text_resolve(const FontSpec &spec) {
+  ensureInitialized();
+  Engine &e = engine();
+  if (!e.ft_ok) return nullptr;
+
+  bool mono = isMonospaceFamily(spec.family);
+  const std::string &path = mono ? e.mono_path : e.sans_path;
+  if (path.empty()) return nullptr;
+  return resolveFacePath(path, spec.pixel_size, mono);
+}
+
+Font *xt_text_scale(Font *font, float pixel_size) {
+  if (font == nullptr) return nullptr;
+  return resolveFacePath(font->path, pixel_size, font->monospace);
+}
+
+float xt_text_measure_width(const std::string &utf8, const FontSpec &spec) {
+  Font *font = xt_text_resolve(spec);
+  if (font == nullptr) return approximateWidth(utf8, spec.pixel_size, spec.family);
+  std::vector<ShapedGlyph> glyphs;
+  return xt_text_shape_run(utf8, font, glyphs);
+}
+
+float xt_text_shape_run(const std::string &utf8, Font *font, std::vector<ShapedGlyph> &out) {
+  if (font == nullptr) return 0;
+  float total = 0;
+  size_t index = 0;
+  size_t segment_start = 0;
+  Font *segment_font = nullptr;
+  while (index < utf8.size()) {
+    size_t char_start = index;
+    uint32_t code_point = decodeUtf8(utf8, index);
+    Font *chosen = faceForCodePoint(font, code_point);
+    if (segment_font == nullptr) {
+      segment_font = chosen;
+      segment_start = char_start;
+    } else if (chosen != segment_font) {
+      total += shapeSegment(utf8.substr(segment_start, char_start - segment_start), segment_font, out);
+      segment_font = chosen;
+      segment_start = char_start;
+    }
+  }
+  if (segment_font != nullptr) {
+    total += shapeSegment(utf8.substr(segment_start), segment_font, out);
+  }
+  return total;
+}
+
 bool xt_text_rasterize(Font *font, uint32_t glyph, GlyphImage &out) {
   out.width = 0;
   out.height = 0;
@@ -374,6 +502,7 @@ bool xt_text_ready() {
 
 void xt_text_shutdown() {
   Engine &e = engine();
+  e.fallbacks.clear();
   e.cache.clear();
   for (auto &entry : e.hb_faces) {
     if (entry.second != nullptr) hb_face_destroy(entry.second);
@@ -387,6 +516,8 @@ void xt_text_shutdown() {
   e.initialized = false;
   e.sans_path.clear();
   e.mono_path.clear();
+  e.sans_fallbacks.clear();
+  e.mono_fallbacks.clear();
 }
 
 }  // namespace xtgui

package/runtime/ext_gui/text.h

@@ -29,12 +29,15 @@ struct FontSpec {
 /** Opaque loaded face (defined in text.cpp). */
 struct Font;
 
-/** A positioned, shaped glyph (pixels). */
+/** A positioned, shaped glyph (pixels). `font` is the face the glyph id
+ * belongs to — the primary face or, for a codepoint it does not cover, a
+ * fallback face — so the rasteriser can load the right face. */
 struct ShapedGlyph {
   uint32_t glyph = 0;
   float x_advance = 0;
   float x_offset = 0;
   float y_offset = 0;
+  Font *font = nullptr;
 };
 
 /** An 8-bit grayscale glyph bitmap, as produced by FreeType. */
@@ -51,9 +54,15 @@ struct GlyphImage {
 Font *xt_text_resolve(const FontSpec &spec);
 
 /** Shape `utf8` with `font`, appending glyphs to `out`; returns the total
- * advance width in pixels. `out` is not cleared. */
+ * advance width in pixels. `out` is not cleared. Codepoints `font` does not
+ * cover are shaped with the first fallback face that has them, and each
+ * glyph's `font` says which face it belongs to. */
 float xt_text_shape_run(const std::string &utf8, Font *font, std::vector<ShapedGlyph> &out);
 
+/** The same face as `font` at a different pixel size (used to rasterise glyphs
+ * at the display's scale factor), or null when it cannot be loaded. */
+Font *xt_text_scale(Font *font, float pixel_size);
+
 /** Rasterise `glyph` from `font` into a grayscale bitmap. Returns false when
  * the glyph has no outline (e.g. a space) or cannot be rendered. */
 bool xt_text_rasterize(Font *font, uint32_t glyph, GlyphImage &out);