Implement Scene.commands modifier for configuring menu bar items

On macOS, menu bar items are displayed in the native macOS menu bar, and on
Linux they're displayed within the app under the title bar.

Author: stackotter

Examples/Sources/CounterExample/CounterApp.swift

@@ -30,5 +30,30 @@ struct CounterApp: App {
             }
         }
         .defaultSize(width: 400, height: 200)
+        .commands {
+            CommandMenu("Help") {
+                Text("Need help?")
+                Button("User guide") {
+                    print("User guide")
+                }
+                Menu("Export as...") {
+                    Button("PNG") {
+                        print("Export as PNG")
+                    }
+                    Button("JPEG") {
+                        print("Export as JPEG")
+                    }
+                }
+            }
+
+            CommandMenu("Window") {
+                Button("Maximize") {
+                    print("Maximize")
+                }
+                Button("Minimize") {
+                    print("Minimize")
+                }
+            }
+        }
     }
 }

Sources/AppKitBackend/AppKitBackend.swift

@@ -52,6 +52,7 @@ public final class AppKitBackend: AppBackend {
             defer: true
         )
         window.delegate = window.resizeDelegate
+
         return window
     }
 
@@ -99,6 +100,71 @@ public final class AppKitBackend: AppBackend {
         window.makeKeyAndOrderFront(nil)
     }
 
+    private static func renderSubmenu(_ submenu: ResolvedMenu.Submenu) -> NSMenuItem {
+        let renderedMenu = NSMenu()
+        for item in submenu.content.items {
+            switch item {
+                case .button(let label, let action):
+                    // Custom subclass is used to keep strong reference to action
+                    // wrapper.
+                    let renderedItem = NSCustomMenuItem(
+                        title: label,
+                        action: nil,
+                        keyEquivalent: ""
+                    )
+                    if let action {
+                        let wrappedAction = Action(action)
+                        renderedItem.actionWrapper = wrappedAction
+                        renderedItem.action = #selector(wrappedAction.run)
+                        renderedItem.target = wrappedAction
+                    }
+                    renderedMenu.addItem(renderedItem)
+                case .submenu(let submenu):
+                    renderedMenu.addItem(renderSubmenu(submenu))
+            }
+        }
+
+        let menuItem = NSMenuItem()
+        menuItem.title = submenu.label
+        menuItem.submenu = renderedMenu
+        return menuItem
+    }
+
+    /// The submenu pointed to by `helpMenu` still appears in `menuBar`. It's
+    /// whichever submenu has the name 'Help'.
+    private static func renderMenuBar(
+        _ submenus: [ResolvedMenu.Submenu]
+    ) -> (menuBar: NSMenu, helpMenu: NSMenu?) {
+        let menuBar = NSMenu()
+
+        // The first menu item is special and always takes on the name of the
+        // app. For now just create a dummy item for it.
+        let dummy = NSMenuItem()
+        dummy.submenu = NSMenu()
+        menuBar.addItem(dummy)
+
+        var helpMenu: NSMenu?
+        for submenu in submenus {
+            let renderedSubmenu = renderSubmenu(submenu)
+            menuBar.addItem(renderedSubmenu)
+
+            if submenu.label == "Help" {
+                helpMenu = renderedSubmenu.submenu
+            }
+        }
+
+        return (menuBar, helpMenu)
+    }
+
+    public func setApplicationMenu(_ submenus: [ResolvedMenu.Submenu]) {
+        let (menuBar, helpMenu) = Self.renderMenuBar(submenus)
+        NSApplication.shared.mainMenu = menuBar
+
+        // We point the app's `helpMenu` at whichever submenu is named 'Help'
+        // (if any) so that AppKit can install its help menu search function.
+        NSApplication.shared.helpMenu = helpMenu
+    }
+
     public func runInMainThread(action: @escaping () -> Void) {
         DispatchQueue.main.async {
             action()
@@ -826,10 +892,8 @@ final class Action: NSObject {
     }
 
     @objc func run() {
-        print("Running action")
         action()
     }
-
 }
 
 class NSCustomTableView: NSTableView {

Sources/Gtk/Application.swift

@@ -4,11 +4,29 @@
 
 import CGtk
 
-public class Application {
-    let applicationPointer: UnsafeMutablePointer<GtkApplication>
+public class Application: GActionMap {
+    public let applicationPointer: UnsafeMutablePointer<GtkApplication>
     private(set) var applicationWindow: ApplicationWindow?
     private var windowCallback: ((ApplicationWindow) -> Void)?
 
+    public var actionMapPointer: OpaquePointer {
+        OpaquePointer(applicationPointer)
+    }
+
+    private var _menuBarModel: GMenu?
+    public var menuBarModel: GMenu? {
+        get {
+            _menuBarModel
+        }
+        set {
+            gtk_application_set_menubar(
+                applicationPointer,
+                (newValue?.pointer).map(UnsafeMutablePointer.init)
+            )
+            _menuBarModel = newValue
+        }
+    }
+
     public init(applicationId: String) {
         // Ignore the deprecation warning, making the change breaks support for platforms such as
         // Ubuntu (before Lunar). This is due to Ubuntu coming with an older version of Gtk in apt.

Sources/Gtk/Utility/GAction.swift

@@ -0,0 +1,5 @@
+import CGtk
+
+public protocol GAction {
+    var actionPointer: OpaquePointer { get }
+}

Sources/Gtk/Utility/GActionMap.swift

@@ -0,0 +1,16 @@
+import CGtk
+
+public protocol GActionMap {
+    var actionMapPointer: OpaquePointer { get }
+}
+
+extension GActionMap {
+    public func addAction(_ action: any GAction) {
+        g_action_map_add_action(actionMapPointer, action.actionPointer)
+    }
+
+    public func addAction(named name: String, action: @escaping () -> Void) {
+        let simpleAction = GSimpleAction(name: name, action: action)
+        addAction(simpleAction)
+    }
+}

Sources/Gtk/Utility/GMenu.swift

@@ -0,0 +1,23 @@
+import CGtk
+
+public class GMenu {
+    var pointer: OpaquePointer
+    var actionMap: any GActionMap
+
+    public init(actionMap: any GActionMap) {
+        pointer = g_menu_new()
+        self.actionMap = actionMap
+    }
+
+    public func appendItem(label: String, actionName: String) {
+        g_menu_append(pointer, label, actionName)
+    }
+
+    public func appendSubmenu(label: String, content: GMenu) {
+        g_menu_append_submenu(
+            pointer,
+            label,
+            UnsafeMutablePointer(content.pointer)
+        )
+    }
+}

Sources/Gtk/Utility/GSimpleAction.swift

@@ -0,0 +1,48 @@
+import CGtk
+
+public class GSimpleAction: GAction, GObjectRepresentable {
+    public var actionPointer: OpaquePointer
+
+    public var gobjectPointer: UnsafeMutablePointer<GObject> {
+        UnsafeMutablePointer<GObject>(actionPointer)
+    }
+
+    @GObjectProperty(named: "enabled") var enabled: Bool
+
+    private class Action {
+        var run: () -> Void
+
+        init(_ action: @escaping () -> Void) {
+            run = action
+        }
+    }
+
+    public init(name: String, action: @escaping () -> Void) {
+        actionPointer = g_simple_action_new(name, nil)
+
+        let wrappedAction = Action(action)
+
+        let handler:
+            @convention(c) (
+                UnsafeMutableRawPointer,
+                OpaquePointer,
+                UnsafeMutableRawPointer
+            ) -> Void =
+                { _, _, data in
+                    let action = Unmanaged<Action>.fromOpaque(data)
+                        .takeUnretainedValue()
+                    action.run()
+                }
+
+        g_signal_connect_data(
+            UnsafeMutableRawPointer(actionPointer),
+            "activate",
+            gCallback(handler),
+            Unmanaged<Action>.passRetained(wrappedAction).toOpaque(),
+            { data, _ in
+                Unmanaged<Action>.fromOpaque(data!).release()
+            },
+            G_CONNECT_AFTER
+        )
+    }
+}

Sources/Gtk/Widgets/ApplicationWindow.swift

@@ -9,4 +9,6 @@ public class ApplicationWindow: Window {
         super.init()
         widgetPointer = gtk_application_window_new(application.applicationPointer)
     }
+
+    @GObjectProperty(named: "show-menubar") public var showMenuBar: Bool
 }

Sources/Gtk/Widgets/Widget.swift

@@ -7,7 +7,7 @@ import Foundation
 
 open class Widget: GObjectRepresentable {
     private var signals: [(UInt, Any)] = []
-    var widgetPointer: UnsafeMutablePointer<GtkWidget>?
+    public var widgetPointer: UnsafeMutablePointer<GtkWidget>?
 
     public var gobjectPointer: UnsafeMutablePointer<GObject> {
         return widgetPointer!.cast()

Sources/Gtk/Widgets/Window.swift

@@ -51,12 +51,6 @@ public class Window: Widget {
 
     @GObjectProperty(named: "resizable") public var resizable: Bool
 
-    private var _titleBar: Widget?
-    public var titlebar: Widget? {
-        get { return _titleBar }
-        set { gtk_window_set_titlebar(castedPointer(), newValue?.widgetPointer) }
-    }
-
     public func setMinimumSize(to minimumSize: Size) {
         gtk_widget_set_size_request(
             castedPointer(),