Implement Menu view (a button which triggers a pop-up menu containing actions)

The pop-up changes to fit in with the current Environment.colorScheme when
using GtkBackend and AppKitBackend, but not Gtk3Backend. Hopefully I can
figure out how to implement menu styling for Gtk3Backend eventually (got
everything working except the hover state).

Author: stackotter

Sources/AppKitBackend/AppKitBackend.swift

@@ -10,6 +10,8 @@ public final class AppKitBackend: AppBackend {
 
     public typealias Widget = NSView
 
+    public typealias Menu = NSMenu
+
     public let defaultTableRowContentHeight = 20
     public let defaultTableCellVerticalPadding = 4
     public let defaultPaddingAmount = 10
@@ -766,6 +768,68 @@ public final class AppKitBackend: AppBackend {
             progressBar.stopAnimation(nil)
         }
     }
+
+    public func createPopoverMenu() -> Menu {
+        return NSMenu()
+    }
+
+    public func updatePopoverMenu(
+        _ menu: Menu,
+        items: [(String, () -> Void)],
+        environment: Environment
+    ) {
+        menu.appearance = environment.colorScheme.nsAppearance
+        menu.items = items.map { (label, action) in
+            let wrappedAction = Action(action)
+            let menuItem = NSCustomMenuItem(
+                title: label,
+                action: #selector(wrappedAction.run),
+                keyEquivalent: ""
+            )
+            menuItem.target = wrappedAction
+            menuItem.actionWrapper = wrappedAction
+            return menuItem
+        }
+    }
+
+    public func showPopoverMenu(
+        _ menu: Menu, at position: SIMD2<Int>, relativeTo widget: Widget,
+        closeHandler handleClose: @escaping () -> Void
+    ) {
+        // NSMenu.popUp(position:at:in:) blocks until the pop up is closed, and has to
+        // run on the main thread, so I'm not exactly sure how it doesn't break things,
+        // but it hasn't broken anything yet.
+        menu.popUp(
+            positioning: nil,
+            at: NSPoint(x: CGFloat(position.x + 2), y: CGFloat(position.y + 8)),
+            in: widget
+        )
+        handleClose()
+    }
+}
+
+final class NSCustomMenuItem: NSMenuItem {
+    /// This property's only purpose is to keep a strong reference to the wrapped
+    /// action so that it sticks around for long enough to be useful.
+    var actionWrapper: Action?
+}
+
+// TODO: Update all controls to use this style of action passing, seems way nicer
+//   than the existing associated keys based approach. And probably more efficient too.
+// Source: https://stackoverflow.com/a/36983811
+final class Action: NSObject {
+    private let action: () -> Void
+
+    init(_ action: @escaping () -> Void) {
+        self.action = action
+        super.init()
+    }
+
+    @objc func run() {
+        print("Running action")
+        action()
+    }
+
 }
 
 class NSCustomTableView: NSTableView {

Sources/Gtk/Generated/Popover.swift

@@ -0,0 +1,222 @@
+import CGtk
+
+/// `GtkPopover` is a bubble-like context popup.
+///
+/// ![An example GtkPopover](popover.png)
+///
+/// It is primarily meant to provide context-dependent information
+/// or options. Popovers are attached to a parent widget. By default,
+/// they point to the whole widget area, although this behavior can be
+/// changed with [method@Gtk.Popover.set_pointing_to].
+///
+/// The position of a popover relative to the widget it is attached to
+/// can also be changed with [method@Gtk.Popover.set_position]
+///
+/// By default, `GtkPopover` performs a grab, in order to ensure input
+/// events get redirected to it while it is shown, and also so the popover
+/// is dismissed in the expected situations (clicks outside the popover,
+/// or the Escape key being pressed). If no such modal behavior is desired
+/// on a popover, [method@Gtk.Popover.set_autohide] may be called on it to
+/// tweak its behavior.
+///
+/// ## GtkPopover as menu replacement
+///
+/// `GtkPopover` is often used to replace menus. The best way to do this
+/// is to use the [class@Gtk.PopoverMenu] subclass which supports being
+/// populated from a `GMenuModel` with [ctor@Gtk.PopoverMenu.new_from_model].
+///
+/// ```xml
+/// <section><attribute name="display-hint">horizontal-buttons</attribute><item><attribute name="label">Cut</attribute><attribute name="action">app.cut</attribute><attribute name="verb-icon">edit-cut-symbolic</attribute></item><item><attribute name="label">Copy</attribute><attribute name="action">app.copy</attribute><attribute name="verb-icon">edit-copy-symbolic</attribute></item><item><attribute name="label">Paste</attribute><attribute name="action">app.paste</attribute><attribute name="verb-icon">edit-paste-symbolic</attribute></item></section>
+/// ```
+///
+/// # CSS nodes
+///
+/// ```
+/// popover.background[.menu]
+/// ├── arrow
+/// ╰── contents
+/// ╰── <child>
+/// ```
+///
+/// `GtkPopover` has a main node with name `popover`, an arrow with name `arrow`,
+/// and another node for the content named `contents`. The `popover` node always
+/// gets the `.background` style class. It also gets the `.menu` style class
+/// if the popover is menu-like, e.g. is a [class@Gtk.PopoverMenu].
+///
+/// Particular uses of `GtkPopover`, such as touch selection popups or
+/// magnifiers in `GtkEntry` or `GtkTextView` get style classes like
+/// `.touch-selection` or `.magnifier` to differentiate from plain popovers.
+///
+/// When styling a popover directly, the `popover` node should usually
+/// not have any background. The visible part of the popover can have
+/// a shadow. To specify it in CSS, set the box-shadow of the `contents` node.
+///
+/// Note that, in order to accomplish appropriate arrow visuals, `GtkPopover`
+/// uses custom drawing for the `arrow` node. This makes it possible for the
+/// arrow to change its shape dynamically, but it also limits the possibilities
+/// of styling it using CSS. In particular, the `arrow` gets drawn over the
+/// `content` node's border and shadow, so they look like one shape, which
+/// means that the border width of the `content` node and the `arrow` node should
+/// be the same. The arrow also does not support any border shape other than
+/// solid, no border-radius, only one border width (border-bottom-width is
+/// used) and no box-shadow.
+public class Popover: Widget, Native, ShortcutManager {
+    /// Creates a new `GtkPopover`.
+    override public init() {
+        super.init()
+        widgetPointer = gtk_popover_new()
+    }
+
+    override func didMoveToParent() {
+        removeSignals()
+
+        super.didMoveToParent()
+
+        addSignal(name: "activate-default") { [weak self] () in
+            guard let self = self else { return }
+            self.activateDefault?(self)
+        }
+
+        addSignal(name: "closed") { [weak self] () in
+            guard let self = self else { return }
+            self.closed?(self)
+        }
+
+        let handler2:
+            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
+                { _, value1, data in
+                    SignalBox1<OpaquePointer>.run(data, value1)
+                }
+
+        addSignal(name: "notify::autohide", handler: gCallback(handler2)) {
+            [weak self] (_: OpaquePointer) in
+            guard let self = self else { return }
+            self.notifyAutohide?(self)
+        }
+
+        let handler3:
+            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
+                { _, value1, data in
+                    SignalBox1<OpaquePointer>.run(data, value1)
+                }
+
+        addSignal(name: "notify::cascade-popdown", handler: gCallback(handler3)) {
+            [weak self] (_: OpaquePointer) in
+            guard let self = self else { return }
+            self.notifyCascadePopdown?(self)
+        }
+
+        let handler4:
+            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
+                { _, value1, data in
+                    SignalBox1<OpaquePointer>.run(data, value1)
+                }
+
+        addSignal(name: "notify::child", handler: gCallback(handler4)) {
+            [weak self] (_: OpaquePointer) in
+            guard let self = self else { return }
+            self.notifyChild?(self)
+        }
+
+        let handler5:
+            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
+                { _, value1, data in
+                    SignalBox1<OpaquePointer>.run(data, value1)
+                }
+
+        addSignal(name: "notify::default-widget", handler: gCallback(handler5)) {
+            [weak self] (_: OpaquePointer) in
+            guard let self = self else { return }
+            self.notifyDefaultWidget?(self)
+        }
+
+        let handler6:
+            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
+                { _, value1, data in
+                    SignalBox1<OpaquePointer>.run(data, value1)
+                }
+
+        addSignal(name: "notify::has-arrow", handler: gCallback(handler6)) {
+            [weak self] (_: OpaquePointer) in
+            guard let self = self else { return }
+            self.notifyHasArrow?(self)
+        }
+
+        let handler7:
+            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
+                { _, value1, data in
+                    SignalBox1<OpaquePointer>.run(data, value1)
+                }
+
+        addSignal(name: "notify::mnemonics-visible", handler: gCallback(handler7)) {
+            [weak self] (_: OpaquePointer) in
+            guard let self = self else { return }
+            self.notifyMnemonicsVisible?(self)
+        }
+
+        let handler8:
+            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
+                { _, value1, data in
+                    SignalBox1<OpaquePointer>.run(data, value1)
+                }
+
+        addSignal(name: "notify::pointing-to", handler: gCallback(handler8)) {
+            [weak self] (_: OpaquePointer) in
+            guard let self = self else { return }
+            self.notifyPointingTo?(self)
+        }
+
+        let handler9:
+            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
+                { _, value1, data in
+                    SignalBox1<OpaquePointer>.run(data, value1)
+                }
+
+        addSignal(name: "notify::position", handler: gCallback(handler9)) {
+            [weak self] (_: OpaquePointer) in
+            guard let self = self else { return }
+            self.notifyPosition?(self)
+        }
+    }
+
+    /// Whether to dismiss the popover on outside clicks.
+    @GObjectProperty(named: "autohide") public var autohide: Bool
+
+    /// Whether the popover pops down after a child popover.
+    ///
+    /// This is used to implement the expected behavior of submenus.
+    @GObjectProperty(named: "cascade-popdown") public var cascadePopdown: Bool
+
+    /// Whether to draw an arrow.
+    @GObjectProperty(named: "has-arrow") public var hasArrow: Bool
+
+    /// Whether mnemonics are currently visible in this popover.
+    @GObjectProperty(named: "mnemonics-visible") public var mnemonicsVisible: Bool
+
+    /// How to place the popover, relative to its parent.
+    @GObjectProperty(named: "position") public var position: PositionType
+
+    /// Emitted whend the user activates the default widget.
+    ///
+    /// This is a [keybinding signal](class.SignalAction.html).
+    public var activateDefault: ((Popover) -> Void)?
+
+    /// Emitted when the popover is closed.
+    public var closed: ((Popover) -> Void)?
+
+    public var notifyAutohide: ((Popover) -> Void)?
+
+    public var notifyCascadePopdown: ((Popover) -> Void)?
+
+    public var notifyChild: ((Popover) -> Void)?
+
+    public var notifyDefaultWidget: ((Popover) -> Void)?
+
+    public var notifyHasArrow: ((Popover) -> Void)?
+
+    public var notifyMnemonicsVisible: ((Popover) -> Void)?
+
+    public var notifyPointingTo: ((Popover) -> Void)?
+
+    public var notifyPosition: ((Popover) -> Void)?
+}