Turn on the desktop native themes, and fix what turning them on exposed

.github/workflows/pr.yml

@@ -35,6 +35,9 @@ on:
       - 'scripts/check-native-warnings.py'
       - 'scripts/check-native-warnings.sh'
       - 'scripts/native-warnings/**'
+      # Same reason: the C++ linkage gate runs from this workflow and nowhere else, so
+      # ignoring scripts/** would let a change that weakens it merge unexercised.
+      - 'scripts/check-native-cpp-linkage.py'
       # The build hint gates are run from this workflow and nowhere else, and one
       # of them holds an empty baseline. Ignoring the whole directory meant a
       # change that breaks a gate, or that adds a line to the baseline, could
@@ -94,6 +97,9 @@ on:
       - 'scripts/check-native-warnings.py'
       - 'scripts/check-native-warnings.sh'
       - 'scripts/native-warnings/**'
+      # Same reason: the C++ linkage gate runs from this workflow and nowhere else, so
+      # ignoring scripts/** would let a change that weakens it merge unexercised.
+      - 'scripts/check-native-cpp-linkage.py'
       # The build hint gates are run from this workflow and nowhere else, and one
       # of them holds an empty baseline. Ignoring the whole directory meant a
       # change that breaks a gate, or that adds a line to the baseline, could
@@ -566,6 +572,15 @@ jobs:
           mvn -B -q -f maven/pom.xml -pl windows,linux -am -DskipTests \
             -Dcn1.binaries="${CN1_BINARIES}" compile
           scripts/check-native-signatures.sh --require-all
+      # Linkage, which the signature gate above cannot see: it verifies that a
+      # native's NAME matches its Java method, and a mangled C++ symbol has the
+      # right name too. Needs no compiler and no build output, so it sits on its
+      # own step rather than behind the compile above.
+      - name: Check native C++ linkage
+        if: ${{ matrix.java-version == 8 }}
+        run: |
+          python3 scripts/check-native-cpp-linkage.py --self-test
+          python3 scripts/check-native-cpp-linkage.py
       # The native warning gate itself runs on the macOS/Windows/Linux legs that
       # actually compile C; what runs HERE is its parser, against a hand-authored
       # fixture, plus a structural check on the checked-in baselines. Both need no

.github/workflows/scripts-android.yml

@@ -317,7 +317,14 @@ jobs:
         uses: actions/upload-artifact@v7
         with:
           name: android-instrumentation-logs
-          path: artifacts/connectedAndroidTest*.log
+          # The comparison also writes a PNG for every screenshot that did not match a
+          # stored golden, including one that has no golden at all. Uploading only the log
+          # left those on the runner, so there was no way to seed an Android golden from
+          # CI -- a new suite test could be added, captured and reported as missing here
+          # forever, and the only route to a golden was an emulator on somebody's desk.
+          path: |
+            artifacts/connectedAndroidTest*.log
+            artifacts/*.png
           if-no-files-found: warn
           retention-days: 14
           compression-level: 6
@@ -326,7 +333,10 @@ jobs:
         uses: actions/upload-artifact@v7
         with:
           name: android-instrumentation-logs-${{ matrix.id }}
-          path: artifacts/connectedAndroidTest*.log
+          # Same reason as the default leg above.
+          path: |
+            artifacts/connectedAndroidTest*.log
+            artifacts/*.png
           if-no-files-found: warn
           retention-days: 14
           compression-level: 6

CLAUDE.md

@@ -482,6 +482,33 @@ calls -- is a warning: it is dead code, not a broken build. Note the offline gat
 reads `target/classes`, so **a stale port build reports natives that no longer
 exist**; rebuild the module before believing a finding.
 
+#### The right name is not enough in C++
+
+A native defined in a `.cpp` or `.mm` file gets its name **mangled** unless it is
+declared `extern "C"`. The file compiles, the symbol it exports is not the one the
+generated code calls, and the link fails on the device in a file nobody touched --
+naming a symbol that is visibly right there in the source.
+
+`NativeSignatureVerifier` cannot see it. It checks that a native's *name* matches
+its Java method, and a mangled function has the right name too; linkage is not part
+of a name. #5845 shipped exactly this in `cn1_windows_window.cpp` and only a real
+Windows build caught it.
+
+`scripts/check-native-cpp-linkage.py` closes that, over every tracked `.cpp`, `.cc`,
+`.cxx` and `.mm`. It needs no compiler and no build output. Like the control-character
+gate it has **no baseline and no exclusions**: a native without C linkage is never
+intentional, and the fix is always one line. The script is re-included in `pr.yml`'s
+`paths` (both triggers) so a change that weakens the gate cannot merge unexercised.
+
+```bash
+scripts/check-native-cpp-linkage.py            # every tracked C++ translation unit
+scripts/check-native-cpp-linkage.py PATH ...   # just these
+```
+
+Note what it deliberately does not report: a port-internal C++ helper, whose mangling
+is correct, and a prototype, which needs no linkage of its own -- only a *definition*
+whose symbol the generated code will call.
+
 #### A framework an app gets by accident is a framework it can lose
 
 The iOS port referenced the `UTType` class while `ByteCodeTranslator` linked

CodenameOne/src/com/codename1/components/FloatingActionButton.java

@@ -461,6 +461,11 @@ public void released(int x, int y) {
             }
             final Container con = createPopupContent(subMenu);
             Dialog d = new Dialog();
+            // Framework chrome, never an operating system window: this popup is POSITIONED by the
+            // framework, and native window mode documents those margins as ignored, so in a window
+            // it comes out centred and loses the placement that is its whole point. See
+            // TooltipManager for the full note.
+            d.setNativeWindowMode(false);
             d.setDialogUIID("Container");
             d.getContentPane().setUIID("Container");
             d.setLayout(new BorderLayout());

CodenameOne/src/com/codename1/components/GroupBox.java

@@ -0,0 +1,175 @@
+/*
+ * 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 Codename One 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.components;
+
+import com.codename1.ui.Container;
+import com.codename1.ui.Label;
+import com.codename1.ui.layouts.BorderLayout;
+import com.codename1.ui.layouts.Layout;
+
+/// A titled frame around a group of related controls.
+///
+/// The desktop equivalent of a section header, and the one piece of grouping chrome all
+/// three desktop toolkits agree on: `NSBox` with a title, `GtkFrame` with a label widget,
+/// and WinUI's headered content. On a phone the same grouping is expressed by a gap and a
+/// heading, which is why Codename One never had this -- and why a desktop form built out of
+/// plain containers reads as one undifferentiated column of controls.
+///
+/// Two UIIDs: `GroupBox` styles the frame (its border is the box) and `GroupBoxTitle`
+/// styles the caption. A theme that wants the caption to sit *in* the top edge rather than
+/// above it does that with a negative top margin on `GroupBoxTitle`; nothing here hard-codes
+/// a position, because the three platforms disagree about it.
+///
+/// ```java
+/// GroupBox appearance = new GroupBox("Appearance");
+/// appearance.add(new CheckBox("Use the system accent colour"))
+///           .add(new CheckBox("Reduce transparency"));
+/// ```
+///
+/// The content is an ordinary `Container`, so `add`, `remove` and the layout all behave as
+/// they would anywhere else -- `#getContentPane()` is there for the rare caller that wants
+/// the inner container itself.
+public class GroupBox extends Container {
+    private final Label title = new Label("", "GroupBoxTitle");
+    private final Container content;
+
+    /// An untitled group whose content stacks vertically.
+    public GroupBox() {
+        this("", com.codename1.ui.layouts.BoxLayout.y());
+    }
+
+    /// A titled group whose content stacks vertically.
+    ///
+    /// #### Parameters
+    ///
+    /// - `titleText`: the caption
+    public GroupBox(String titleText) {
+        this(titleText, com.codename1.ui.layouts.BoxLayout.y());
+    }
+
+    /// A titled group with a layout of its own.
+    ///
+    /// #### Parameters
+    ///
+    /// - `titleText`: the caption
+    ///
+    /// - `contentLayout`: the layout for the grouped controls
+    public GroupBox(String titleText, Layout contentLayout) {
+        super(new BorderLayout());
+        setUIID("GroupBox");
+        content = new Container(contentLayout);
+        content.setUIID("Container");
+        title.setText(titleText);
+        // An empty caption must not reserve a strip: an untitled group is a plain box, and a
+        // blank label with the title style's padding would leave a gap nothing explains.
+        title.setHidden(titleText == null || titleText.length() == 0);
+        // super, explicitly: the overrides below route an ordinary add into the content pane,
+        // which is what every caller means -- and would put the caption and the content pane
+        // itself inside the content pane if these two went through them.
+        super.addComponent(BorderLayout.NORTH, title);
+        super.addComponent(BorderLayout.CENTER, content);
+    }
+
+    /// The caption.
+    ///
+    /// #### Returns
+    ///
+    /// the title text, never null
+    public String getTitle() {
+        return title.getText();
+    }
+
+    /// Sets the caption. Setting it empty removes the caption strip entirely.
+    ///
+    /// #### Parameters
+    ///
+    /// - `titleText`: the caption
+    public void setTitle(String titleText) {
+        title.setText(titleText == null ? "" : titleText);
+        title.setHidden(title.getText().length() == 0);
+    }
+
+    /// The caption component, for a caller that needs to style or replace its icon.
+    ///
+    /// #### Returns
+    ///
+    /// the title label
+    public Label getTitleComponent() {
+        return title;
+    }
+
+    /// The container the grouped controls live in.
+    ///
+    /// #### Returns
+    ///
+    /// the content container
+    public Container getContentPane() {
+        return content;
+    }
+
+    /// @inheritDoc
+    ///
+    /// Routed into the content pane, so an ordinary add means "add to the group" rather than
+    /// "add beside the caption". `Container#add(Component)` is final and delegates here, so
+    /// overriding this covers the chaining form too.
+    @Override
+    public void addComponent(com.codename1.ui.Component cmp) {
+        if (content == null) {
+            // During the super constructor, before the content pane exists.
+            super.addComponent(cmp);
+            return;
+        }
+        content.addComponent(cmp);
+    }
+
+    /// @inheritDoc
+    ///
+    /// The constraint belongs to the CONTENT layout, not to the BorderLayout that positions
+    /// the caption. That layout is an implementation detail, and a caller passing
+    /// `BorderLayout.SOUTH` means "below the other controls in this group", never "outside the
+    /// box, under the frame".
+    @Override
+    public void addComponent(Object constraints, com.codename1.ui.Component cmp) {
+        if (content == null) {
+            super.addComponent(constraints, cmp);
+            return;
+        }
+        content.addComponent(constraints, cmp);
+    }
+
+    /// @inheritDoc
+    @Override
+    public void removeComponent(com.codename1.ui.Component cmp) {
+        if (cmp == title || cmp == content) { //NOPMD CompareObjectsWithEquals
+            super.removeComponent(cmp);
+            return;
+        }
+        content.removeComponent(cmp);
+    }
+
+    /// @inheritDoc
+    @Override
+    public void removeAll() {
+        content.removeAll();
+    }
+}