vaev-layout,style: Add SVG groups and integration with transforms.

Author: pauloamed

src/vaev-dom/defs/ns-svg-attr-names.inc

@@ -77,6 +77,9 @@ ATTR(SYSTEM_LANGUAGE, systemLanguage)
 ATTR(TABLE_VALUES, tableValues)
 ATTR(TARGET_X, targetX)
 ATTR(TARGET_Y, targetY)
+ATTR(TRANSFORM, transform)
+ATTR(TRANSFORM_ORIGIN, transform-origin)
+ATTR(TRANSFORM_BOX, transform-box)
 ATTR(TEXT_LENGTH, textLength)
 ATTR(VERSION, version)
 ATTR(VIEW_BOX, viewBox)

src/vaev-layout/base.cpp

@@ -286,21 +286,31 @@ export struct InlineBox {
     }
 };
 
-struct SVGRoot {
-    using Element = Union<SVG::Shape, SVGRoot, ::Box<Box>>;
-    Vec<Element> elements;
+struct SVGRoot;
+
+namespace SVG {
+
+struct Group {
+    using Element = Union<Shape, SVGRoot, Karm::Box<Vaev::Layout::Box>, Group>;
+    Vec<Element> elements = {};
 
-    Opt<ViewBox> viewBox;
     Rc<Style::SpecifiedValues> style;
 
-    void add(Element&& element) {
-        elements.pushBack(std::move(element));
-    }
+    Group(Rc<Style::SpecifiedValues> style)
+        : style(style) {}
+
+    void add(Element&& element);
+    void add(Vaev::Layout::Box&& box);
+
+    void repr(Io::Emit& e) const;
+};
+} // namespace SVG
 
-    void add(Box&& box);
+struct SVGRoot : SVG::Group {
+    Opt<ViewBox> viewBox;
 
     SVGRoot(Rc<Style::SpecifiedValues> style)
-        : viewBox(style->svg->viewBox), style(style) {}
+        : SVG::Group(style), viewBox(style->svg->viewBox) {}
 
     void repr(Io::Emit& e) const {
         e("(SVG {} viewBox:{}", SVG::buildRectangle(*style), viewBox);
@@ -313,6 +323,16 @@ struct SVGRoot {
     }
 };
 
+void SVG::Group::repr(Io::Emit& e) const {
+    e("(Group {} ");
+    e.indentNewline();
+    for (auto const& el : elements) {
+        e("{}", el);
+        e.newline();
+    }
+    e(")");
+}
+
 export using Content = Union<
     None,
     Vec<Box>,
@@ -392,8 +412,12 @@ struct Box : Meta::NoCopy {
     }
 };
 
-void SVGRoot::add(Box&& box) {
-    add(makeBox<Box>(std::move(box)));
+void SVG::Group::add(Element&& element) {
+    elements.pushBack(std::move(element));
+}
+
+void SVG::Group::add(Vaev::Layout::Box&& box) {
+    add(Element{makeBox<Vaev::Layout::Box>(std::move(box))});
 }
 
 void InlineBox::add(Box&& b) {
@@ -452,28 +476,62 @@ export struct Metrics {
 };
 
 export struct Frag;
+struct SVGRootFrag;
 
-struct SVGRootFrag {
-    using Element = Union<SVG::ShapeFrag, SVGRootFrag, ::Box<Frag>>;
+namespace SVG {
+
+struct GroupFrag : SVG::Frag {
+    using Element = Union<SVG::ShapeFrag, SVGRootFrag, ::Box<Vaev::Layout::Frag>, GroupFrag>;
     Vec<Element> elements = {};
 
+    RectAu _objectBoundingBox{};
+    RectAu _strokeBoundingBox{};
+
+    Karm::Cursor<Group> box;
+
+    GroupFrag(Karm::Cursor<Group> group)
+        : box(group) {}
+
+    static void computeBoundingBoxes(SVG::GroupFrag* group);
+
+    RectAu objectBoundingBox() override {
+        return _objectBoundingBox;
+    }
+
+    RectAu strokeBoundingBox() override {
+        return _strokeBoundingBox;
+    }
+
+    Style::SpecifiedValues const& style() override {
+        return *box->style;
+    }
+
+    void add(Element&& element);
+
+    void repr(Io::Emit& e) const {
+        e("(GroupFrag)");
+    }
+};
+} // namespace SVG
+
+struct SVGRootFrag : SVG::GroupFrag {
     // NOTE: SVG viewports have these intrinsic transformations; choosing to store these transforms is more compliant
     // and somewhat rendering-friendly but makes it harder to debug
     Math::Trans2f transf;
     SVG::Rectangle<Au> boundingBox;
 
+    SVGRootFrag(Karm::Cursor<SVG::Group> group, Math::Trans2f transf, SVG::Rectangle<Au> boundingBox)
+        : SVG::GroupFrag(group), transf(transf), boundingBox(boundingBox) {
+    }
+
     static SVGRootFrag build(SVGRoot const& box, Vec2Au position, Vec2Au viewportSize) {
         SVG::Rectangle<Karm::Au> rect{position.x, position.y, viewportSize.x, viewportSize.y};
 
         Math::Trans2f transf =
             box.viewBox ? SVG::computeEquivalentTransformOfSVGViewport(*box.viewBox, position, viewportSize)
                         : Math::Trans2f::translate(position.cast<f64>());
 
-        return {{}, transf, rect};
-    }
-
-    void add(Element&& el) {
-        elements.pushBack(std::move(el));
+        return SVGRootFrag{&box, transf, rect};
     }
 
     void repr(Io::Emit& e) const {
@@ -532,16 +590,72 @@ export struct Frag {
     }
 };
 
+void SVG::GroupFrag::add(Element&& el) {
+    elements.pushBack(std::move(el));
+}
+
 void SVGRootFrag::offsetBoxFrags(Vec2Au d) {
     for (auto& element : elements) {
-        if (auto frag = element.is<::Box<Frag>>()) {
+        if (auto frag = element.is<::Box<Vaev::Layout::Frag>>()) {
             (*frag)->offset(d);
         } else if (auto nestedRoot = element.is<SVGRootFrag>()) {
             nestedRoot->offsetBoxFrags(d);
         }
     }
 }
 
+void SVG::GroupFrag::computeBoundingBoxes(SVG::GroupFrag* group) {
+    if(group->elements.len() == 0)
+        return;
+
+    // FIXME: this could be implemented in the Union type
+    auto upcast = [&](Element const& element, auto upcaster) {
+        return element.visit(upcaster);
+    };
+
+    auto toSVGFrag = [&]<typename T>(T const& el) -> SVG::Frag* {
+        if constexpr (Meta::Derive<T, SVG::Frag>) {
+            return (SVG::Frag*)(&el);
+        }
+        return nullptr;
+    };
+
+    auto toSVGGroupFrag = [&]<typename T>(T const& el) -> SVG::GroupFrag* {
+        if constexpr (Meta::Derive<T, SVG::GroupFrag>) {
+            return (SVG::GroupFrag*)(&el);
+        }
+        return nullptr;
+    };
+
+    auto getElementBoundingBoxes = [&](Element const& element) -> Pair<RectAu> {
+        if (auto frag = element.is<::Box<Vaev::Layout::Frag>>()) {
+            return {
+                (*frag)->metrics.borderBox(),
+                (*frag)->metrics.borderBox()
+            };
+        } else if (auto svgFrag = upcast(element, toSVGFrag)) {
+            if (auto svgGroupFrag = upcast(element, toSVGGroupFrag)) {
+                computeBoundingBoxes(svgGroupFrag);
+            }
+            return {
+                svgFrag->objectBoundingBox(),
+                svgFrag->strokeBoundingBox()
+            };
+        } else
+            unreachable();
+    };
+
+    auto [objectBoundingBox, strokeBoundingBox] = getElementBoundingBoxes(group->elements[0]);
+    for(usize i = 1; i < group->elements.len(); i++) {
+        auto [nextObjectBoundingBox, nextStrokeBoundingBox] = getElementBoundingBoxes(group->elements[i]);
+        objectBoundingBox = objectBoundingBox.mergeWith(nextObjectBoundingBox);
+        strokeBoundingBox = strokeBoundingBox.mergeWith(nextStrokeBoundingBox);
+    }
+
+    group->_objectBoundingBox = objectBoundingBox;
+    group->_strokeBoundingBox = strokeBoundingBox;
+}
+
 // MARK: Input & Output --------------------------------------------------------
 
 export enum struct IntrinsicSize {

src/vaev-layout/builder.cpp

@@ -389,18 +389,20 @@ static void _buildInputProse(BuilderContext bc, Gc::Ref<Dom::Element> el) {
     bc.content() = InlineBox{prose};
 }
 
-void buildSVGChildren(Gc::Ref<Dom::Element> el, SVGRoot& svgRoot);
 static void buildBlockFlowFromElement(BuilderContext bc, Gc::Ref<Dom::Element> el);
+void buildSVGAggregate(Gc::Ref<Dom::Element> el, SVG::Group* group);
 
-void buildSVGElement(Gc::Ref<Dom::Element> el, SVGRoot& svgRoot) {
+void buildSVGElement(Gc::Ref<Dom::Element> el, SVG::Group* group) {
     if (SVG::isShape(el->tagName)) {
-        svgRoot.add(SVG::Shape::build(el->specifiedValues(), el->tagName));
+        group->add(SVG::Shape::build(el->specifiedValues(), el->tagName));
     } else if (el->tagName == Svg::G) {
-        buildSVGChildren(el, svgRoot);
+        SVG::Group nestedGroup{el->specifiedValues()};
+        buildSVGAggregate(el, &nestedGroup);
+        group->add(std::move(nestedGroup));
     } else if (el->tagName == Svg::SVG) {
         SVGRoot newSvgRoot{el->specifiedValues()};
-        buildSVGChildren(el, newSvgRoot);
-        svgRoot.add(std::move(newSvgRoot));
+        buildSVGAggregate(el, &newSvgRoot);
+        group->add(std::move(newSvgRoot));
     } else if (el->tagName == Svg::FOREIGN_OBJECT) {
         Box box{el->specifiedValues(), el->computedValues()->fontFace, el};
 
@@ -418,25 +420,25 @@ void buildSVGElement(Gc::Ref<Dom::Element> el, SVGRoot& svgRoot) {
 
         buildBlockFlowFromElement(bc, *el);
 
-        svgRoot.add(std::move(box));
+        group->add(std::move(box));
     } else {
         // TODO
         logWarn("cannot build element into svg tree: {}", el->tagName);
     }
 }
 
-void buildSVGChildren(Gc::Ref<Dom::Element> el, SVGRoot& svgRoot) {
+void buildSVGAggregate(Gc::Ref<Dom::Element> el, SVG::Group* group) {
     for (auto child = el->firstChild(); child; child = child->nextSibling()) {
         if (auto el = child->is<Dom::Element>()) {
-            buildSVGElement(*el, svgRoot);
+            buildSVGElement(*el, group);
         }
         // TODO: process text into svg tree
     }
 }
 
 SVGRoot _buildSVG(Gc::Ref<Dom::Element> el) {
     SVGRoot svgRoot{el->specifiedValues()};
-    buildSVGChildren(el, svgRoot);
+    buildSVGAggregate(el, &svgRoot);
     return svgRoot;
 }