CSSThemeCompiler: #Constants, font-size and box semantics matching the build-time compiler

maven/core-unittests/src/test/java/com/codename1/testing/TestCodenameOneImplementation.java

@@ -3243,7 +3243,26 @@ public Object createTestFont(int charWidth, int height) {
 
     @Override
     public Object createFont(int face, int style, int size) {
-        return new TestFont(defaultFont.charWidth, defaultFont.height);
+        TestFont font = new TestFont(defaultFont.charWidth, defaultFont.height);
+        font.face = face;
+        font.style = style;
+        font.size = size;
+        return font;
+    }
+
+    @Override
+    public int getStyle(Object nativeFont) {
+        return nativeFont instanceof TestFont ? ((TestFont) nativeFont).style : 0;
+    }
+
+    @Override
+    public int getFace(Object nativeFont) {
+        return nativeFont instanceof TestFont ? ((TestFont) nativeFont).face : 0;
+    }
+
+    @Override
+    public int getSize(Object nativeFont) {
+        return nativeFont instanceof TestFont ? ((TestFont) nativeFont).size : 0;
     }
 
     @Override
@@ -5637,6 +5656,10 @@ public String toString() {
     public static final class TestFont {
         final int charWidth;
         final int height;
+        /// What a system font was created with; a real port reports these from its native font.
+        int face;
+        int style;
+        int size = com.codename1.ui.Font.SIZE_MEDIUM;
 
         TestFont(int charWidth, int height) {
             this.charWidth = charWidth;

maven/css-compiler/src/main/java/com/codename1/designer/css/CSSTheme.java

@@ -3246,6 +3246,12 @@ public void updateResources() {
                     }
                 } else if (lu.getLexicalUnitType() == LexicalUnit.SAC_INTEGER) {
                     res.setThemeProperty(themeName, "@"+constantKey, String.valueOf(((ScaledUnit)lu).getIntegerValue()));
+                } else if (lu.getLexicalUnitType() == LexicalUnit.SAC_REAL) {
+                    // A decimal such as `switchTrackScaleY: 1.5` was silently dropped, so the
+                    // built theme fell back to the default the runtime compiler did not.
+                    String real = String.valueOf(lu.getFloatValue());
+                    res.setThemeProperty(themeName, "@"+constantKey,
+                            real.endsWith(".0") ? real.substring(0, real.length() - 2) : real);
                 } else if (lu.getLexicalUnitType() == LexicalUnit.SAC_RGBCOLOR
                         || (lu.getLexicalUnitType() == LexicalUnit.SAC_FUNCTION
                                 && ("rgb".equals(lu.getFunctionName())
@@ -6825,6 +6831,13 @@ public com.codename1.ui.Font getThemeFont(Map<String,LexicalUnit> styles) {
                                 ttfSizeType = TTF_SIZE_TYPE_LARGE;
                                 sysSize = Font.SIZE_LARGE;
                                 break outer;
+                            case "medium":
+                                // Without this case `medium` fell through to the pixel branch
+                                // and stored a zero-size font.
+                                iFontSizeType = Font.SIZE_MEDIUM;
+                                ttfSizeType = TTF_SIZE_TYPE_MEDIUM;
+                                sysSize = Font.SIZE_MEDIUM;
+                                break outer;
 
                         }
                     }
@@ -6953,6 +6966,8 @@ public com.codename1.ui.Font getThemeFont(Map<String,LexicalUnit> styles) {
                         case "arial" :
                         case "cursive" :
                         case "fantasy" :
+                        // The platform's own UI font: a generic family, as in the runtime compiler.
+                        case "system-ui" :
                             iFontFace = Font.FACE_SYSTEM;
                             break loop;
                         case "monospace" :
@@ -9348,6 +9363,21 @@ static String getARGBHexString(LexicalUnit color) {
         return "#" + leftPad(Integer.toHexString(getColorInt(color)), 6) + leftPad(Integer.toHexString(getColorAlphaInt(color)), 2);
     }
 
+    /// One `rgb()` channel: `50%` is half of 255, which getIntegerValue() read as 0, so every
+    /// percentage color came out black.
+    private static int rgbChannel(ScaledUnit channel) {
+        if (channel.getLexicalUnitType() == LexicalUnit.SAC_PERCENTAGE) {
+            return clampChannel(Math.round(channel.getFloatValue() * 255f / 100f));
+        }
+        return clampChannel(channel.getIntegerValue());
+    }
+
+    /// Out of range is clamped, as CSS specifies: `200%` or `300` is 255, not a value `%02X`
+    /// would write as three digits, breaking the six-digit color.
+    private static int clampChannel(int value) {
+        return Math.max(0, Math.min(255, value));
+    }
+
     static String getColorString(LexicalUnit color) {
         return getColorString(color, false);
     }
@@ -9388,9 +9418,9 @@ static String getColorString(LexicalUnit color, boolean premultiplied) {
                     blue = (ScaledUnit)blue.getNextLexicalUnit();
                 }
                 return String.format( "%02X%02X%02X",
-                        red.getIntegerValue(),
-                        green.getIntegerValue(),
-                        blue.getIntegerValue());
+                        rgbChannel(red),
+                        rgbChannel(green),
+                        rgbChannel(blue));
 
             }
             case LexicalUnit.SAC_FUNCTION: {
@@ -9435,9 +9465,9 @@ static String getColorString(LexicalUnit color, boolean premultiplied) {
                             throw new RuntimeException("Failed to parse color " + color + ". Received null alpha parameter:" + color);
                         }
                     }
-                    int r = (int)(red.getIntegerValue() * (premultiplied?(1-alpha.getNumericValue()):1));
-                    int g = (int)(green.getIntegerValue() * (premultiplied?(1-alpha.getNumericValue()):1));
-                    int b = (int)(blue.getIntegerValue() * (premultiplied?(1-alpha.getNumericValue()):1));
+                    int r = (int)(rgbChannel(red) * (premultiplied?(1-alpha.getNumericValue()):1));
+                    int g = (int)(rgbChannel(green) * (premultiplied?(1-alpha.getNumericValue()):1));
+                    int b = (int)(rgbChannel(blue) * (premultiplied?(1-alpha.getNumericValue()):1));
 
 
                     return String.format( "%02X%02X%02X",

maven/css-compiler/src/test/java/com/codename1/designer/css/RuntimeCompilerParityTest.java

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.designer.css;
+
+import com.codename1.ui.css.CSSThemeCompiler;
+import com.codename1.ui.util.MutableResource;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Hashtable;
+
+/**
+ * The runtime compiler in core ({@link CSSThemeCompiler}, used for live reload and by
+ * applications that build a theme on the device) against this one, on the declarations both
+ * support: the same sheet has to store the same constants, padding, margin and unit metadata.
+ */
+public class RuntimeCompilerParityTest {
+
+    private static final String CSS = "#Constants {\n"
+            + "    includeNativeBool: true;\n"
+            + "    customMessage: \"Hello\";\n"
+            + "    quotedFlagBool: 'false';\n"
+            + "    accentColor: #ff2d95;\n"
+            + "    shortColor: #abc;\n"
+            + "    switchTrackScaleY: 1.5;\n"
+            + "    pctColor: rgb(100%, 0%, 50%);\n"
+            + "    clampColor: rgb(200%, 300, 0);\n"
+            + "}\n"
+            + "Label { padding: 1px 2px 3px 4px; margin: 1mm 2mm; }\n"
+            + "One { padding: 5px; margin: 0.5mm; }\n"
+            + "Three { padding: 1mm 2px 3mm; }\n"
+            + "Mixed { padding: 1mm 2px 3pt 4mm; margin: 1px 2mm 3px 4mm; }\n"
+            + "Mixed.pressed { padding: 2mm 1mm; }\n"
+            + "Mixed.selected { margin: 3pt; }\n";
+
+    @BeforeAll
+    static void installHeadlessImplementation() throws Exception {
+        HeadlessTestSupport.installHeadlessImplementation();
+    }
+
+    @Test
+    void constantsMatch() throws Exception {
+        Hashtable standard = compileStandard(CSS);
+        Hashtable runtime = compileRuntime(CSS);
+        for (String key : new String[]{"@includeNativeBool", "@customMessage", "@quotedFlagBool"}) {
+            assertEquals(standard.get(key), runtime.get(key), key);
+        }
+        // Hex case differs between the compilers for every color, not just constants (the
+        // build-time one writes upper case); both are read with Integer.parseInt(value, 16).
+        for (String key : new String[]{"@accentColor", "@shortColor", "@pctColor", "@clampColor"}) {
+            assertEquals(Integer.valueOf(Integer.parseInt((String) standard.get(key), 16)),
+                    Integer.valueOf(Integer.parseInt((String) runtime.get(key), 16)), key);
+        }
+        assertEquals("true", runtime.get("@includeNativeBool"), "@includeNativeBool");
+        assertEquals("Hello", runtime.get("@customMessage"), "@customMessage");
+    }
+
+    @Test
+    void spacingMatches() throws Exception {
+        Hashtable standard = compileStandard(CSS);
+        Hashtable runtime = compileRuntime(CSS);
+        String[] keys = {
+                "Label.padding", "Label.margin", "Label.padUnit", "Label.marUnit",
+                "One.padding", "One.margin", "One.padUnit", "One.marUnit",
+                "Three.padding", "Three.padUnit",
+                "Mixed.padding", "Mixed.margin", "Mixed.padUnit", "Mixed.marUnit",
+                "Mixed.press#padding", "Mixed.press#padUnit",
+                "Mixed.sel#margin", "Mixed.sel#marUnit"};
+        for (String key : keys) {
+            Object expected = standard.get(key);
+            Object actual = runtime.get(key);
+            if (expected == null || actual == null) {
+                throw new AssertionError(key + " standard=" + expected + " runtime=" + actual);
+            }
+            if (expected instanceof byte[]) {
+                if (!Arrays.equals((byte[]) expected, (byte[]) actual)) {
+                    throw new AssertionError(key + " units standard=" + Arrays.toString((byte[]) expected)
+                            + " runtime=" + Arrays.toString((byte[]) actual));
+                }
+            } else if (!Arrays.equals(floats((String) expected), floats((String) actual))) {
+                throw new AssertionError(key + " standard=" + expected + " runtime=" + actual);
+            }
+        }
+    }
+
+    private static float[] floats(String box) {
+        String[] parts = box.split(",");
+        float[] out = new float[parts.length];
+        for (int i = 0; i < parts.length; i++) {
+            out[i] = Float.parseFloat(parts[i].trim());
+        }
+        return out;
+    }
+
+    private static Hashtable compileRuntime(String css) {
+        MutableResource resource = new MutableResource();
+        new CSSThemeCompiler().compile(css, resource, "Theme");
+        return resource.getTheme("Theme");
+    }
+
+    private static Hashtable compileStandard(String css) throws Exception {
+        Path cssFile = Files.createTempFile("cn1-parity", ".css");
+        Path resFile = Files.createTempFile("cn1-parity", ".res");
+        try {
+            Files.write(cssFile, css.getBytes(StandardCharsets.UTF_8));
+            CSSTheme theme = CSSTheme.load(cssFile.toUri().toURL());
+            theme.resourceFile = resFile.toFile();
+            theme.res = new com.codename1.ui.util.EditableResourcesForCSS(resFile.toFile());
+            theme.res.setTheme("Theme", new Hashtable());
+            theme.updateResources();
+            return theme.res.getTheme("Theme");
+        } finally {
+            deleteIfExists(cssFile);
+            deleteIfExists(resFile);
+        }
+    }
+
+    private static void deleteIfExists(Path path) {
+        try {
+            Files.deleteIfExists(path);
+        } catch (IOException ignored) {
+        }
+    }
+
+    private static void assertEquals(Object expected, Object actual, String message) {
+        if (expected == null ? actual != null : !expected.equals(actual)) {
+            throw new AssertionError(message + " expected=" + expected + " actual=" + actual);
+        }
+    }
+}

scripts/flutter-bench/baseline/pr/5976.json

@@ -8,7 +8,7 @@
       "tolerance": {
        "value": 0.005
       },
-      "value": 13238731
+      "value": 13304997
      },
      "reason": "JavaScript sizes on run 38943915580 (13,338,532 / 108,835,838 bytes) are above a baseline taken on the Flutter branch before later master merges; desktop-compat-layer's run 38946610873, which does not contain this PR, is further above it (13,356,239 / 108,853,545). The Flutter benchmark has no master run to separate this PR's share, which is ParparVM's JS output for float rounding (Math.fround) and the single-rounding long-to-float.",
      "runs": 1,

scripts/flutter-bench/baseline/pr/6032.json

@@ -0,0 +1,33 @@
+{
+ "pr": 6032,
+ "rebaseline": {
+  "linux": {
+   "gallery": {
+    "code_bytes": {
+     "from": {
+      "value": 14523602
+     },
+     "reason": "CSSThemeCompiler (runtime CSS theme compiler in core) gained build-compiler parity: state inheritance, per-side insets, media prefixes, var() bindings, the CSS named-color table",
+     "runs": 1,
+     "value": 14592242
+    },
+    "install_bytes": {
+     "from": {
+      "value": 116342496
+     },
+     "reason": "CSSThemeCompiler (runtime CSS theme compiler in core) gained build-compiler parity: state inheritance, per-side insets, media prefixes, var() bindings, the CSS named-color table",
+     "runs": 1,
+     "value": 116468448
+    },
+    "wire_bytes": {
+     "from": {
+      "value": 84685068
+     },
+     "reason": "CSSThemeCompiler (runtime CSS theme compiler in core) gained build-compiler parity: state inheritance, per-side insets, media prefixes, var() bindings, the CSS named-color table",
+     "runs": 1,
+     "value": 84687971
+    }
+   }
+  }
+ }
+}