vaev: Update from upstream.

Author: sleepy-monax

src/apps/hideo-spreadsheet/app.h

@@ -81,7 +81,7 @@ struct Sheet {
     usize freezedRows = 0;
     usize freezedCols = 0;
     Vec<Row> rows = {{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}};
-    Vec<Col> cols = {{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}};
+    Vec<Col> cols = {{}, {}, {}, {}, {}, {}, {}, {}};
     Map<Pos, Cell> cells = {};
 
     void recompute() {

src/libs/karm-print/paper.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <karm-base/distinct.h>
+#include <karm-base/res.h>
 #include <karm-base/string.h>
 
 namespace Karm::Print {
@@ -115,4 +116,14 @@ static constexpr Array PAPER_STOCKS = {
     ENVELOPE_SERIES,
 };
 
+static inline Res<PaperStock> findPaperStock(Str name) {
+    for (auto const &series : PAPER_STOCKS) {
+        for (auto const &stock : series) {
+            if (eqCi(stock.name, name))
+                return Ok(stock);
+        }
+    }
+    return Error::invalidData("unknown paper stock");
+}
+
 } // namespace Karm::Print

src/libs/karm-print/pdf.h

@@ -19,6 +19,12 @@ struct PdfPrinter : public Printer {
         _density = density;
     }
 
+    PdfPrinter(Math::Vec2i size, Density density = Density::DEFAULT) {
+        _paperSize.width = size.x;
+        _paperSize.height = size.y;
+        _density = density;
+    }
+
     Gfx::Canvas &beginPage() override {
         _pages.emplaceBack();
         _canvas = Pdf::Canvas{last(_pages), _paperSize};

src/web/vaev-css/lexer.h

@@ -53,7 +53,7 @@ struct Token {
     using enum Type;
 
     Type type;
-    Str data;
+    String data;
 
 #define ITER(ID, NAME) \
     static Token NAME(Str data = "") { return {ID, data}; }
@@ -62,7 +62,7 @@ struct Token {
 
     Token() : type(NIL) {}
 
-    Token(Type type, Str data = "")
+    Token(Type type, String data = ""s)
         : type(type), data(data) {}
 
     explicit operator bool() const {

src/web/vaev-driver/render.cpp

@@ -51,7 +51,7 @@ static void _collectStyle(Markup::Node const &node, Style::StyleBook &sb) {
     }
 }
 
-RenderResult render(Markup::Document const &dom, Style::Media const &media, Vec2Px viewport) {
+RenderResult render(Markup::Document const &dom, Style::Media const &media, Layout::Viewport viewport) {
     Style::StyleBook stylebook;
     stylebook.add(
         fetchStylesheet("bundle://vaev-driver/user-agent.css"_url)
@@ -68,9 +68,7 @@ RenderResult render(Markup::Document const &dom, Style::Media const &media, Vec2
     Style::Computer computer{media, stylebook};
     Layout::Tree tree = {
         Layout::build(computer, dom),
-        {
-            .small = viewport,
-        }
+        viewport,
     };
 
     elapsed = Sys::now() - start;
@@ -79,25 +77,18 @@ RenderResult render(Markup::Document const &dom, Style::Media const &media, Vec2
 
     start = Sys::now();
 
-    Layout::Viewport vp{.small = viewport};
-
-    elapsed = Sys::now() - start;
-
-    logDebugIf(DEBUG_RENDER, "layout tree measure time: {}", elapsed);
-
-    start = Sys::now();
-
     Layout::layout(
         tree,
         tree.root,
         {
             .commit = Layout::Commit::YES,
-            .knownSize = {vp.small.width, NONE},
-            .availableSpace = {vp.small.width, 0_px},
-            .containingBlock = {vp.small.width, vp.small.height},
+            .knownSize = {viewport.small.width, NONE},
+            .availableSpace = {viewport.small.width, 0_px},
+            .containingBlock = {viewport.small.width, viewport.small.height},
         }
     );
-    Layout::layoutPositioned(tree, tree.root, {vp.small.width, vp.small.height});
+
+    Layout::layoutPositioned(tree, tree.root, {viewport.small.width, viewport.small.height});
 
     auto sceneRoot = makeStrong<Scene::Stack>();
 
@@ -119,7 +110,7 @@ RenderResult render(Markup::Document const &dom, Style::Media const &media, Vec2
     };
 }
 
-RenderResult render(Markup::Document &dom, Style::Media const &media, Print::PaperStock paper) {
+Vec<Scene::Page> print(Markup::Document &dom, Style::Media const &media) {
     Style::StyleBook stylebook;
     stylebook.add(
         fetchStylesheet("bundle://vaev-driver/user-agent.css"_url)
@@ -135,8 +126,8 @@ RenderResult render(Markup::Document &dom, Style::Media const &media, Print::Pap
 
     Layout::Viewport vp{
         .small = {
-            Px{paper.width},
-            Px{paper.height},
+            Px{media.width},
+            Px{media.height},
         },
     };
 
@@ -156,15 +147,11 @@ RenderResult render(Markup::Document &dom, Style::Media const &media, Print::Pap
         }
     );
 
-    auto sceneRoot = makeStrong<Scene::Page>();
-    Layout::paint(tree.root, *sceneRoot);
-    sceneRoot->prepare();
+    Vec<Scene::Page> pages;
+    Layout::paint(tree.root, pages.emplaceBack());
+    last(pages).prepare();
 
-    return {
-        std::move(stylebook),
-        makeStrong<Layout::Box>(std::move(tree.root)),
-        sceneRoot,
-    };
+    return pages;
 }
 
 } // namespace Vaev::Driver

src/web/vaev-driver/render.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <karm-scene/base.h>
+#include <karm-scene/page.h>
 #include <vaev-base/length.h>
 #include <vaev-layout/box.h>
 #include <vaev-markup/dom.h>
@@ -14,8 +15,8 @@ struct RenderResult {
     Strong<Scene::Node> scene;
 };
 
-RenderResult render(Markup::Document const &dom, Style::Media const &media, Vec2Px viewport);
+RenderResult render(Markup::Document const &dom, Style::Media const &media, Layout::Viewport viewport);
 
-RenderResult render(Markup::Document &dom, Style::Media const &media, Print::PaperStock paper);
+Vec<Scene::Page> print(Markup::Document &dom, Style::Media const &media);
 
 } // namespace Vaev::Driver

src/web/vaev-layout/base.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <vaev-base/length.h>
+#include <vaev-base/resolution.h>
 #include <vaev-base/writing.h>
 
 namespace Vaev::Layout {
@@ -13,7 +14,7 @@ enum struct IntrinsicSize {
 };
 
 struct Viewport {
-    Px dpi = 96_px;
+    Resolution dpi = Resolution::fromDpi(96);
     // https://drafts.csswg.org/css-values/#small-viewport-size
     RectPx small;
     // https://drafts.csswg.org/css-values/#large-viewport-size

src/web/vaev-layout/values.cpp

@@ -195,22 +195,22 @@ Px Resolver::resolve(Length value) {
     // Absolute
     // https://drafts.csswg.org/css-values/#absolute-lengths
     case Length::CM:
-        return Px::fromFloatNearest(value.val() * viewport.dpi.cast<f64>() / 2.54);
+        return Px::fromFloatNearest(value.val() * viewport.dpi.toDpi() / 2.54);
 
     case Length::MM:
-        return Px::fromFloatNearest(value.val() * viewport.dpi.cast<f64>() / 25.4);
+        return Px::fromFloatNearest(value.val() * viewport.dpi.toDpi() / 25.4);
 
     case Length::Q:
-        return Px::fromFloatNearest(value.val() * viewport.dpi.cast<f64>() / 101.6);
+        return Px::fromFloatNearest(value.val() * viewport.dpi.toDpi() / 101.6);
 
     case Length::IN:
-        return Px::fromFloatNearest(value.val() * viewport.dpi.cast<f64>());
+        return Px::fromFloatNearest(value.val() * viewport.dpi.toDpi());
 
     case Length::PT:
-        return Px::fromFloatNearest(value.val() * viewport.dpi.cast<f64>() / 72.0);
+        return Px::fromFloatNearest(value.val() * viewport.dpi.toDpi() / 72.0);
 
     case Length::PC:
-        return Px::fromFloatNearest(value.val() * viewport.dpi.cast<f64>() / 6.0);
+        return Px::fromFloatNearest(value.val() * viewport.dpi.toDpi() / 6.0);
 
     case Length::PX:
         return Px::fromFloatNearest(value.val());

src/web/vaev-style/computed.h

@@ -19,6 +19,7 @@
 #include <vaev-base/text.h>
 #include <vaev-base/visibility.h>
 #include <vaev-base/z-index.h>
+#include <vaev-css/parser.h>
 
 namespace Vaev::Style {
 
@@ -64,6 +65,8 @@ struct Computed {
     Cow<FlexProps> flex;
     Cow<BreakProps> break_;
 
+    Cow<Map<String, Css::Content>> variables;
+
     Float float_ = Float::NONE;
     Clear clear = Clear::NONE;
 
@@ -74,6 +77,7 @@ struct Computed {
         color = parent.color;
         font = parent.font;
         text = parent.text;
+        variables = parent.variables;
     }
 
     void repr(Io::Emit &e) const {
@@ -103,6 +107,7 @@ struct Computed {
         e(" float: {}", float_);
         e(" clear: {}", clear);
         e(" zIndex: {}", zIndex);
+        e(" variables: {}", variables);
         e(")");
     }
 };

src/web/vaev-style/computer.cpp

@@ -7,7 +7,8 @@ Computed const &Computed::initial() {
     static Computed computed = [] {
         Computed res{};
         StyleProp::any([&]<typename T>(Meta::Type<T>) {
-            T{}.apply(res);
+            if constexpr (requires { T::initial(); })
+                T{}.apply(res);
         });
         return res;
     }();
@@ -31,6 +32,61 @@ void Computer::_evalRule(Rule const &rule, Markup::Element const &el, MatchingRu
     });
 }
 
+static Css::Content expandVariables(Cursor<Css::Sst> &cursor, Map<String, Css::Content> computedVars) {
+    // replacing the var with its value in the cascade
+    Css::Content computedDecl = {};
+    while (not cursor.ended()) {
+        if (cursor.peek() == Css::Sst::FUNC and cursor.peek().prefix == Css::Token::function("var(")) {
+
+            auto const varName = cursor->content[0].token.data;
+            // if the variable is defined in the cascade
+            if (computedVars.has(varName)) {
+                computedDecl.pushBack(computedVars.get(varName));
+            } else {
+                if (cursor->content.len() > 2) {
+                    // using the default value
+                    Cursor<Css::Sst> cur = cursor->content;
+                    cur.next(2);
+                    eatWhitespace(cur);
+                    auto defaultValue = expandVariables(cur, computedVars);
+                    computedDecl.pushBack(defaultValue);
+                } else {
+                    // invalid property
+                    logWarn("variable not found: {} {}", varName, cursor->content);
+                }
+            }
+            cursor.next();
+        } else if (cursor.peek() == Css::Sst::FUNC) {
+            Cursor<Css::Sst> cur = cursor->content;
+            computedDecl.pushBack(cursor.peek());
+            computedDecl[computedDecl.len() - 1].content = expandVariables(cur, computedVars);
+            cursor.next();
+        } else {
+            computedDecl.pushBack(cursor.peek());
+            cursor.next();
+        }
+    }
+    return computedDecl;
+}
+
+static Res<StyleProp> resolve(DeferredProp const &prop, Map<String, Css::Content> computedVars) {
+    Cursor<Css::Sst> cursor = prop.value;
+
+    auto computedDecl = expandVariables(cursor, computedVars);
+
+    // building the declaration
+    Css::Sst decl{Css::Sst::DECL};
+    decl.token = Css::Token::ident(prop.propName);
+    decl.content = computedDecl;
+
+    // parsing the declaration
+    Res<StyleProp> computed = parseDeclaration<StyleProp>(decl, false);
+    if (not computed) {
+        logWarn("failed to parse declaration: {}", computed.none());
+    }
+    return computed;
+}
+
 Strong<Computed> Computer::computeFor(Computed const &parent, Markup::Element const &el) {
     MatchingRules matchingRules;
 
@@ -51,6 +107,7 @@ Strong<Computed> Computer::computeFor(Computed const &parent, Markup::Element co
 
     // Get the style attribute if any
     auto styleAttr = el.getAttribute(Html::STYLE_ATTR);
+
     StyleRule styleRule{
         .selector = UNIVERSAL,
         .props = parseDeclarations<StyleProp>(styleAttr ? *styleAttr : ""),
@@ -62,7 +119,15 @@ Strong<Computed> Computer::computeFor(Computed const &parent, Markup::Element co
     computed->inherit(parent);
 
     for (auto const &styleRule : matchingRules) {
-        for (auto const &prop : styleRule->props) {
+        for (auto &prop : styleRule->props) {
+            if (auto deferred = prop.is<DeferredProp>()) {
+                auto resolved = resolve(prop.unwrap<DeferredProp>(), computed->variables.cow());
+
+                if (not resolved) {
+                    continue;
+                }
+                resolved.unwrap().apply(*computed);
+            }
             if (prop.important == Important::NO)
                 prop.apply(*computed);
         }