xbintsc 0.5.20 → 0.5.21

package/runtime/ext_gui/inline_svg.cpp

@@ -0,0 +1,219 @@
+/*
+ * xbintsc GUI engine — inline `<svg>` serialization. See `inline_svg.h`.
+ */
+
+#include "inline_svg.h"
+
+#include <cctype>
+#include <string>
+#include <unordered_map>
+
+namespace xtgui {
+namespace {
+
+/** SVG element names that are case-sensitive and contain an upper-case letter.
+ * The HTML parser lowercases tag names, so the serializer maps them back;
+ * everything not listed is already lower case in SVG (`path`, `rect`, `g`,
+ * `defs`, `stop`, …). */
+const std::unordered_map<std::string, const char *> &canonicalTags() {
+  static const std::unordered_map<std::string, const char *> tags = {
+      {"altglyph", "altGlyph"},
+      {"altglyphdef", "altGlyphDef"},
+      {"altglyphitem", "altGlyphItem"},
+      {"animatecolor", "animateColor"},
+      {"animatemotion", "animateMotion"},
+      {"animatetransform", "animateTransform"},
+      {"clippath", "clipPath"},
+      {"feblend", "feBlend"},
+      {"fecolormatrix", "feColorMatrix"},
+      {"fecomponenttransfer", "feComponentTransfer"},
+      {"fecomposite", "feComposite"},
+      {"feconvolvematrix", "feConvolveMatrix"},
+      {"fediffuselighting", "feDiffuseLighting"},
+      {"fedisplacementmap", "feDisplacementMap"},
+      {"fedistantlight", "feDistantLight"},
+      {"fedropshadow", "feDropShadow"},
+      {"feflood", "feFlood"},
+      {"fefunca", "feFuncA"},
+      {"fefuncb", "feFuncB"},
+      {"fefuncg", "feFuncG"},
+      {"fefuncr", "feFuncR"},
+      {"fegaussianblur", "feGaussianBlur"},
+      {"feimage", "feImage"},
+      {"femerge", "feMerge"},
+      {"femergenode", "feMergeNode"},
+      {"femorphology", "feMorphology"},
+      {"feoffset", "feOffset"},
+      {"fepointlight", "fePointLight"},
+      {"fespecularlighting", "feSpecularLighting"},
+      {"fespotlight", "feSpotLight"},
+      {"fetile", "feTile"},
+      {"feturbulence", "feTurbulence"},
+      {"foreignobject", "foreignObject"},
+      {"glyphref", "glyphRef"},
+      {"lineargradient", "linearGradient"},
+      {"radialgradient", "radialGradient"},
+      {"textpath", "textPath"},
+  };
+  return tags;
+}
+
+/** The same for attributes: NanoSVG compares these names exactly, and the HTML
+ * parser delivers them in lower case. The table also covers the common SVG
+ * attributes NanoSVG does not read, so the markup it is handed stays faithful
+ * to what a browser would parse. */
+const std::unordered_map<std::string, const char *> &canonicalAttrs() {
+  static const std::unordered_map<std::string, const char *> attrs = {
+      {"attributename", "attributeName"},
+      {"attributetype", "attributeType"},
+      {"basefrequency", "baseFrequency"},
+      {"baseprofile", "baseProfile"},
+      {"calcmode", "calcMode"},
+      {"clippathunits", "clipPathUnits"},
+      {"contentscripttype", "contentScriptType"},
+      {"contentstyletype", "contentStyleType"},
+      {"diffuseconstant", "diffuseConstant"},
+      {"edgemode", "edgeMode"},
+      {"filterunits", "filterUnits"},
+      {"gradienttransform", "gradientTransform"},
+      {"gradientunits", "gradientUnits"},
+      {"kernelmatrix", "kernelMatrix"},
+      {"kernelunitlength", "kernelUnitLength"},
+      {"keypoints", "keyPoints"},
+      {"keysplines", "keySplines"},
+      {"keytimes", "keyTimes"},
+      {"lengthadjust", "lengthAdjust"},
+      {"limitingconeangle", "limitingConeAngle"},
+      {"markerheight", "markerHeight"},
+      {"markerunits", "markerUnits"},
+      {"markerwidth", "markerWidth"},
+      {"maskcontentunits", "maskContentUnits"},
+      {"maskunits", "maskUnits"},
+      {"numoctaves", "numOctaves"},
+      {"pathlength", "pathLength"},
+      {"patterncontentunits", "patternContentUnits"},
+      {"patterntransform", "patternTransform"},
+      {"patternunits", "patternUnits"},
+      {"pointsatx", "pointsAtX"},
+      {"pointsaty", "pointsAtY"},
+      {"pointsatz", "pointsAtZ"},
+      {"preserveaspectratio", "preserveAspectRatio"},
+      {"primitiveunits", "primitiveUnits"},
+      {"refx", "refX"},
+      {"refy", "refY"},
+      {"repeatcount", "repeatCount"},
+      {"repeatdur", "repeatDur"},
+      {"requiredextensions", "requiredExtensions"},
+      {"requiredfeatures", "requiredFeatures"},
+      {"specularconstant", "specularConstant"},
+      {"specularexponent", "specularExponent"},
+      {"spreadmethod", "spreadMethod"},
+      {"startoffset", "startOffset"},
+      {"stddeviation", "stdDeviation"},
+      {"stitchtiles", "stitchTiles"},
+      {"surfacescale", "surfaceScale"},
+      {"systemlanguage", "systemLanguage"},
+      {"tablevalues", "tableValues"},
+      {"targetx", "targetX"},
+      {"targety", "targetY"},
+      {"textlength", "textLength"},
+      {"transformorigin", "transformOrigin"},
+      {"viewbox", "viewBox"},
+      {"viewtarget", "viewTarget"},
+      {"xchannelselector", "xChannelSelector"},
+      {"ychannelselector", "yChannelSelector"},
+      {"zoomandpan", "zoomAndPan"},
+  };
+  return attrs;
+}
+
+void escapeAttribute(const std::string &value, std::string *out) {
+  for (char c : value) {
+    switch (c) {
+      case '&': out->append("&amp;"); break;
+      case '<': out->append("&lt;"); break;
+      case '>': out->append("&gt;"); break;
+      case '"': out->append("&quot;"); break;
+      default: out->push_back(c); break;
+    }
+  }
+}
+
+std::string canonicalTag(const std::string &tag) {
+  const auto &tags = canonicalTags();
+  auto found = tags.find(tag);
+  return found == tags.end() ? tag : std::string(found->second);
+}
+
+const char *canonicalAttr(const std::string &name) {
+  const auto &attrs = canonicalAttrs();
+  auto found = attrs.find(name);
+  return found == attrs.end() ? nullptr : found->second;
+}
+
+bool isNamespaceAttr(const std::string &name) {
+  return name == "xmlns" || name.compare(0, 6, "xmlns:") == 0;
+}
+
+/** HTML-only attributes that must not reach the SVG reader (inline `style` and
+ * `class` are legitimate on SVG elements and stay). */
+bool isHtmlAttr(const std::string &name) {
+  return name == "tabindex" || name == "role" || name == "contenteditable";
+}
+
+void serializeNode(const Node *node, std::string *out);
+
+void serializeStyleText(const Node *node, std::string *out) {
+  for (const std::unique_ptr<Node> &child : node->children) {
+    if (child->isText()) {
+      out->append(child->text);
+    } else if (child->isElement()) {
+      serializeNode(child.get(), out);
+    }
+  }
+}
+
+void serializeNode(const Node *node, std::string *out) {
+  if (node == nullptr || !node->isElement()) return;
+  std::string tag = canonicalTag(node->tag);
+  out->push_back('<');
+  out->append(tag);
+  if (node->isTag("svg")) out->append(" xmlns=\"http://www.w3.org/2000/svg\"");
+  for (const Attr &attr : node->attrs) {
+    if (isNamespaceAttr(attr.name) || isHtmlAttr(attr.name)) continue;
+    /* The root's xmlns is emitted above, so a second copy would be an XML
+     * duplicate-attribute error. */
+    const char *name = canonicalAttr(attr.name);
+    out->push_back(' ');
+    out->append(name != nullptr ? name : attr.name);
+    out->append("=\"");
+    escapeAttribute(attr.value, out);
+    out->push_back('"');
+  }
+  out->push_back('>');
+  if (node->isTag("style")) {
+    serializeStyleText(node, out);
+  } else {
+    for (const std::unique_ptr<Node> &child : node->children) {
+      if (child->isElement()) serializeNode(child.get(), out);
+    }
+  }
+  out->append("</");
+  out->append(tag);
+  out->push_back('>');
+}
+
+}  // namespace
+
+bool xt_inline_svg_is_root(const Node *node) {
+  return node != nullptr && node->isElement() && node->isTag("svg");
+}
+
+std::string xt_inline_svg_serialize(const Node *node) {
+  if (!xt_inline_svg_is_root(node)) return std::string();
+  std::string out;
+  serializeNode(node, &out);
+  return out;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/inline_svg.h

@@ -0,0 +1,41 @@
+/*
+ * xbintsc GUI engine — inline `<svg>` elements.
+ *
+ * An SVG that arrives as a file is decoded by `svg.h` (`<img src="logo.svg">`).
+ * An inline `<svg>` tree is already part of the document, so this module turns
+ * the subtree back into a standalone SVG document and hands it to the same
+ * NanoSVG parser/rasteriser. Layout then treats `<svg>` as a replaced element
+ * (its intrinsic size comes from the parsed document) and paint emits an image
+ * op carrying the markup, so the renderer rasterises it at the drawn device
+ * pixel size — vector art stays crisp exactly like an SVG file.
+ *
+ * The HTML parser lowercases element and attribute names (so `viewBox` arrives
+ * as `viewbox`), while NanoSVG matches SVG's case-sensitive spellings. The
+ * serializer therefore restores the canonical names of the elements and
+ * attributes NanoSVG understands, and drops the HTML-only ones that would
+ * confuse the XML reader.
+ */
+#ifndef XT_GUI_INLINE_SVG_H
+#define XT_GUI_INLINE_SVG_H
+
+#include <string>
+
+#include "dom.h"
+#include "svg.h"
+
+namespace xtgui {
+
+/** True when `node` is an `<svg>` element (an inline SVG root). */
+bool xt_inline_svg_is_root(const Node *node);
+
+/** Serialize an `<svg>` DOM subtree into a standalone SVG document: the root
+ * element, its descendants (including `<defs>`, gradients and `<style>` text)
+ * and the canonical `width`/`height`/`viewBox`/`gradient*` spellings NanoSVG
+ * expects. Text outside `<style>` is dropped (NanoSVG renders shapes, not
+ * `<text>`), and HTML-only attributes are skipped. Returns an empty string when
+ * `node` is not an `<svg>` element. */
+std::string xt_inline_svg_serialize(const Node *node);
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_INLINE_SVG_H */

package/runtime/ext_gui/layout.cpp

@@ -19,6 +19,7 @@
 #include <cstring>
 
 #include "image.h"
+#include "inline_svg.h"
 #include "style_internal.h"
 
 namespace xtgui {
@@ -104,7 +105,24 @@ std::unique_ptr<LayoutBox> buildBoxTree(const Node *node,
         }
       }
     }
+  } else if (node->isElement() && node->isTag("svg")) {
+    /* An inline `<svg>` is a replaced element: the subtree is vector art, not
+     * HTML boxes. Serialize it once, take the intrinsic size from the parsed
+     * document (width/height attributes, else the viewBox, else 300x150), and
+     * let paint/rasterisation handle the children — the normal box walk must
+     * not descend into them. */
+    box->is_inline_svg = true;
+    box->svg_markup = xt_inline_svg_serialize(node);
+    int width = 0;
+    int height = 0;
+    if (xt_svg_markup_size(box->svg_markup, &width, &height)) {
+      box->intrinsic_width = (float)width;
+      box->intrinsic_height = (float)height;
+    }
+    if (box->intrinsic_width <= 0.0f) box->intrinsic_width = 300.0f;
+    if (box->intrinsic_height <= 0.0f) box->intrinsic_height = 150.0f;
   }
+  if (box->is_inline_svg) return box;
   for (const std::unique_ptr<Node> &child : node->children) {
     std::unique_ptr<LayoutBox> childBox =
         buildBoxTree(child.get(), styles, style, media, canvases);

package/runtime/ext_gui/layout.h

@@ -83,6 +83,13 @@ struct LayoutBox {
   bool is_canvas = false;
   uint64_t canvas_id = 0;
 
+  /* Inline `<svg>`: a replaced element whose pixels are the serialized subtree
+   * (`svg_markup`), rasterised like an SVG file at the drawn device size. The
+   * normal box walk does not descend into its children — they are vector art,
+   * not HTML boxes. */
+  bool is_inline_svg = false;
+  std::string svg_markup;
+
   Display display = Display::Inline;
 
   /* Resolved (px) box edges. */

package/runtime/ext_gui/layout_flow.cpp

@@ -44,7 +44,8 @@ float Layouter::verticalEdges(const LayoutBox *box) const {
 float Layouter::preferredContentWidth(const LayoutBox *box, float available) const {
   const XtStyle &style = *box->style;
   if (!isAuto(style.width)) return px(style.width, available, style.font_size, 0.0f);
-  if ((box->is_image || box->is_canvas) && box->intrinsic_width > 0) return box->intrinsic_width;
+  if ((box->is_image || box->is_canvas || box->is_inline_svg) && box->intrinsic_width > 0)
+    return box->intrinsic_width;
   float best = 0;
   for (const std::unique_ptr<LayoutBox> &child : box->children) {
     if (child->display == Display::None) continue;
@@ -225,8 +226,8 @@ float Layouter::layoutBlock(LayoutBox *box, float x, float y, float availableWid
     if (contentHeight < 0) contentHeight = 0;
   }
   /* Replaced elements keep their aspect ratio when only one axis is set. */
-  if ((box->is_image || box->is_canvas) && forcedContentHeight < 0 && isAuto(style.height) &&
-      box->intrinsic_width > 0 && box->intrinsic_height > 0) {
+  if ((box->is_image || box->is_canvas || box->is_inline_svg) && forcedContentHeight < 0 &&
+      isAuto(style.height) && box->intrinsic_width > 0 && box->intrinsic_height > 0) {
     contentHeight = contentWidth * box->intrinsic_height / box->intrinsic_width;
   }
   box->content_height = contentHeight;

package/runtime/ext_gui/paint.cpp

@@ -187,6 +187,16 @@ void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip) {
         image.media_id = box->media_id;
         image.transform = matrix;
         addImage(image, out, clip);
+      } else if (box->is_inline_svg && !box->svg_markup.empty() && box->content_width > 0.0f &&
+                 box->content_height > 0.0f) {
+        PaintImage image;
+        image.x = box->content_x;
+        image.y = box->content_y;
+        image.width = box->content_width;
+        image.height = box->content_height;
+        image.svg = box->svg_markup;
+        image.transform = matrix;
+        addImage(image, out, clip);
       } else if (box->is_image && !box->image_src.empty() && box->content_width > 0.0f &&
                  box->content_height > 0.0f) {
         PaintImage image;
@@ -243,6 +253,10 @@ std::string DisplayList::dump() const {
         std::snprintf(buffer, sizeof(buffer), "image x=%.1f y=%.1f w=%.1f h=%.1f media=%llu",
                       image.x, image.y, image.width, image.height,
                       (unsigned long long)image.media_id);
+      } else if (!image.svg.empty()) {
+        std::snprintf(buffer, sizeof(buffer),
+                      "image x=%.1f y=%.1f w=%.1f h=%.1f inline-svg=%zu", image.x, image.y,
+                      image.width, image.height, image.svg.size());
       } else if (image.canvas_id != 0) {
         std::snprintf(buffer, sizeof(buffer), "image x=%.1f y=%.1f w=%.1f h=%.1f canvas=%llu",
                       image.x, image.y, image.width, image.height,

package/runtime/ext_gui/paint.h

@@ -51,13 +51,17 @@ struct PaintText {
 /** An image to draw, scaled into the given rectangle (viewport-relative).
  * A non-zero `media_id` names a live `<video>` frame owned by the media
  * subsystem; a non-zero `canvas_id` names a live `<canvas>` bitmap owned by the
- * DOM; `src` is then empty and the renderer binds that subsystem's texture. */
+ * DOM; `src` is then empty and the renderer binds that subsystem's texture.
+ * A non-empty `svg` carries the serialized `<svg>` subtree of an inline SVG
+ * element, which the renderer rasterises at the drawn device size (there is no
+ * file to load). */
 struct PaintImage {
   float x = 0;
   float y = 0;
   float width = 0;
   float height = 0;
   std::string src;
+  std::string svg;
   uint64_t media_id = 0;
   uint64_t canvas_id = 0;
   Matrix2D transform;

package/runtime/ext_gui/renderer_image.cpp

@@ -12,6 +12,7 @@
 #include "canvas.h"
 #include "image.h"
 #include "media.h"
+#include "svg.h"
 
 #include "renderer_shaders.h"
 
@@ -227,6 +228,32 @@ SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *
   return pipeline;
 }
 
+/** Create an RGBA texture holding `image` and upload its pixels. Returns null
+ * (after reporting the SDL error) when either step fails. */
+SDL_GPUTexture *createImageTexture(SDL_GPUDevice *device, const xtgui::Image &image) {
+  SDL_GPUTextureCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.type = SDL_GPU_TEXTURETYPE_2D;
+  info.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
+  info.width = (Uint32)image.width;
+  info.height = (Uint32)image.height;
+  info.layer_count_or_depth = 1;
+  info.num_levels = 1;
+  info.sample_count = SDL_GPU_SAMPLECOUNT_1;
+  SDL_GPUTexture *texture = SDL_CreateGPUTexture(device, &info);
+  if (texture == nullptr) {
+    fprintf(stderr, "xt_gui: image texture creation failed: %s\n", SDL_GetError());
+    return nullptr;
+  }
+  uint32_t bytes = (uint32_t)(image.pixels.size());
+  if (!uploadPixels(device, texture, image.width, image.height, image.pixels.data(), bytes)) {
+    SDL_ReleaseGPUTexture(device, texture);
+    return nullptr;
+  }
+  return texture;
+}
+
 /** Decode `src` (cached) and upload it as an RGBA texture. Vector sources are
  * rasterised at the drawn pixel size and cached by that size; bitmaps decode at
  * their intrinsic size and are cached by path. */
@@ -246,30 +273,29 @@ SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src
     return nullptr;
   }
 
-  SDL_GPUTextureCreateInfo info;
-  memset(&info, 0, sizeof(info));
-  info.type = SDL_GPU_TEXTURETYPE_2D;
-  info.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
-  info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
-  info.width = (Uint32)image->width;
-  info.height = (Uint32)image->height;
-  info.layer_count_or_depth = 1;
-  info.num_levels = 1;
-  info.sample_count = SDL_GPU_SAMPLECOUNT_1;
-  SDL_GPUTexture *texture = SDL_CreateGPUTexture(device, &info);
-  if (texture == nullptr) {
-    fprintf(stderr, "xt_gui: image texture creation failed: %s\n", SDL_GetError());
-    g_image_textures.emplace(key, nullptr);
-    return nullptr;
-  }
+  SDL_GPUTexture *texture = createImageTexture(device, *image);
+  g_image_textures.emplace(key, texture);
+  return texture;
+}
 
-  uint32_t bytes = (uint32_t)(image->pixels.size());
-  if (!uploadPixels(device, texture, image->width, image->height, image->pixels.data(), bytes)) {
-    SDL_ReleaseGPUTexture(device, texture);
+/** Rasterise the serialized subtree of an inline `<svg>` at the drawn pixel
+ * size and upload it. The markup is the cache key: a static document therefore
+ * rasterises once per drawn size, and an edited one gets a fresh texture. */
+SDL_GPUTexture *ensureInlineSvgTexture(SDL_GPUDevice *device, const std::string &markup,
+                                       int pixel_width, int pixel_height) {
+  std::string key = "inline-svg@" + std::to_string(pixel_width) + "x" +
+                    std::to_string(pixel_height) + ":" + markup;
+  auto found = g_image_textures.find(key);
+  if (found != g_image_textures.end()) return found->second;
+
+  xtgui::Image image;
+  if (!xtgui::xt_svg_markup_render(markup, pixel_width, pixel_height, &image)) {
+    fprintf(stderr, "xt_gui: could not rasterise inline SVG\n");
     g_image_textures.emplace(key, nullptr);
     return nullptr;
   }
 
+  SDL_GPUTexture *texture = createImageTexture(device, image);
   g_image_textures.emplace(key, texture);
   return texture;
 }
@@ -298,18 +324,20 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
   for (size_t index = 0; index < list.images.size(); index++) {
     const xtgui::PaintImage &image = list.images[index];
     if (image.width <= 0.0f || image.height <= 0.0f) continue;
+    /* Draw-time device pixels: an SVG (file or inline) is rasterised at this
+     * size so it stays crisp on HiDPI and when scaled. */
+    int pixel_width = (int)(image.width * scale + 0.5f);
+    int pixel_height = (int)(image.height * scale + 0.5f);
+    if (pixel_width < 1) pixel_width = 1;
+    if (pixel_height < 1) pixel_height = 1;
     SDL_GPUTexture *texture = nullptr;
     if (image.canvas_id != 0) {
       texture = ensureCanvasTexture(device, image.canvas_id);
     } else if (image.media_id != 0) {
       texture = ensureMediaTexture(device, image.media_id);
+    } else if (!image.svg.empty()) {
+      texture = ensureInlineSvgTexture(device, image.svg, pixel_width, pixel_height);
     } else {
-      /* Draw-time device pixels: an SVG is rasterised at this size so it stays
-       * crisp on HiDPI and when scaled. */
-      int pixel_width = (int)(image.width * scale + 0.5f);
-      int pixel_height = (int)(image.height * scale + 0.5f);
-      if (pixel_width < 1) pixel_width = 1;
-      if (pixel_height < 1) pixel_height = 1;
       texture = ensureImageTexture(device, image.src, pixel_width, pixel_height);
     }
     if (texture == nullptr) continue;

package/runtime/ext_gui/style_ua.cpp

@@ -40,6 +40,9 @@ void xt_style_apply_user_agent(const Node *node, XtStyle *style) {
     style->display = Display::InlineBlock;
   }
   if (tag == "img") style->display = Display::InlineBlock;
+  /* An inline `<svg>` is a replaced inline-block too: its intrinsic size comes
+   * from the SVG document and its subtree is vector art, not HTML boxes. */
+  if (tag == "svg") style->display = Display::InlineBlock;
   /* `<video>` mirrors `<img>` (a replaced inline-block; 300x150 by default from
    * layout), while `<audio>` and its `<source>`/`<track>` children have no
    * rendered box of their own. */