moved signals to Gtk/Widgets/Window

Author: MiaKoring

Sources/Gtk/Widgets/Window.swift

@@ -82,5 +82,75 @@ open class Window: Widget {
 
     public func present() {
         gtk_window_present(castedPointer())
+        
+        addSignal(name: "close-request") { [weak self] () in
+            guard let self = self else { return }
+            self.onCloseRequest?(self)
+        }
+    }
+
+    public func setEscapeKeyPressedHandler(to handler: (() -> Void)?) {
+        if let data = escapeKeyHandlerData {
+            Unmanaged<ValueBox<() -> Void>>.fromOpaque(data).release()
+            escapeKeyHandlerData = nil
+        }
+        
+        if let oldController = escapeKeyEventController {
+            gtk_widget_remove_controller(widgetPointer, oldController)
+            escapeKeyEventController = nil
+        }
+        
+        escapeKeyPressed = handler
+        
+        guard handler != nil else { return }
+        
+        let keyEventController = gtk_event_controller_key_new()
+        gtk_event_controller_set_propagation_phase(keyEventController, GTK_PHASE_BUBBLE)
+        
+        let thunk: @convention(c) (
+            UnsafeMutableRawPointer?, guint, guint, GdkModifierType, gpointer?
+        ) -> gboolean = { _, keyval, _, _, userData in
+            if keyval == GDK_KEY_Escape {
+                guard let userData else { return 1 }
+                let box = Unmanaged<ValueBox<() -> Void>>.fromOpaque(userData).takeUnretainedValue()
+                box.value()
+                return 1
+            }
+            return 0
+        }
+        
+        let boxedHandler = Unmanaged.passRetained(
+            ValueBox(value: handler!)
+        ).toOpaque()
+        
+        g_signal_connect_data(
+            UnsafeMutableRawPointer(keyEventController),
+            "key-pressed",
+            unsafeBitCast(thunk, to: GCallback.self),
+            boxedHandler,
+            { data, _ in
+                if let data {
+                    Unmanaged<ValueBox<() -> Void>>.fromOpaque(data).release()
+                }
+            },
+            .init(0)
+        )
+        
+        gtk_widget_add_controller(widgetPointer, keyEventController)
+        escapeKeyEventController = keyEventController
+        escapeKeyHandlerData = boxedHandler
+    }
+    
+    private var escapeKeyEventController: OpaquePointer?
+    private var escapeKeyHandlerData: UnsafeMutableRawPointer?
+    
+    public var onCloseRequest: ((Window) -> Int32)?
+    public var escapeKeyPressed: (() -> Void)?
+}
+
+final class ValueBox<T> {
+    let value: T
+    init(value: T) {
+        self.value = value
     }
 }

Sources/GtkBackend/GtkBackend.swift

@@ -64,31 +64,7 @@ public final class GtkBackend: AppBackend {
     private var sheetContexts: [OpaquePointer: SheetContext] = [:]
     private var connectedCloseHandlers: Set<OpaquePointer> = []
 
-    // C thunk for GtkWindow::close-request
-    private static let closeRequestThunk:
-        @convention(c) (
-            UnsafeMutableRawPointer?, UnsafeMutableRawPointer?
-        ) -> Int32 = { instance, userData in
-            // TRUE (1) = consume event (prevent native close)
-            guard let instance, let userData else { return 1 }
-            let backend = Unmanaged<GtkBackend>.fromOpaque(userData).takeUnretainedValue()
-            let key = OpaquePointer(instance)
-            guard let ctx = backend.sheetContexts[key] else { return 1 }
-
-            if ctx.interactiveDismissDisabled { return 1 }
-
-            if ctx.isProgrammaticDismiss {
-                ctx.isProgrammaticDismiss = false
-                return 1
-            }
-
-            backend.runInMainThread {
-                ctx.onDismiss()
-            }
-            return 1
-        }
-
-    // C-convention thunk for key-pressed
+   /* // C-convention thunk for key-pressed
     private let escapeKeyPressedThunk:
         @convention(c) (
             UnsafeMutableRawPointer?, guint, guint, GdkModifierType, gpointer?
@@ -102,7 +78,7 @@ public final class GtkBackend: AppBackend {
             }
             return 0
         }
-
+*/
     // A separate initializer to satisfy ``AppBackend``'s requirements.
     public convenience init() {
         self.init(appIdentifier: nil)
@@ -1643,17 +1619,21 @@ public final class GtkBackend: AppBackend {
         sheet.css.set(property: .cornerRadius(defaultSheetCornerRadius))
 
         if connectedCloseHandlers.insert(key).inserted {
-            let handler: GCallback = unsafeBitCast(Self.closeRequestThunk, to: GCallback.self)
-            g_signal_connect_data(
-                UnsafeMutableRawPointer(sheet.gobjectPointer),
-                "close-request",
-                handler,
-                Unmanaged.passUnretained(self).toOpaque(),
-                nil,
-                GConnectFlags(0)
-            )
+            sheet.onCloseRequest = {[weak self] _ in
+                if ctx.interactiveDismissDisabled { return 1 }
+
+                if ctx.isProgrammaticDismiss {
+                    ctx.isProgrammaticDismiss = false
+                    return 1
+                }
+
+                self?.runInMainThread {
+                    ctx.onDismiss()
+                }
+                return 1
+            }
 
-            let escapeHandler = gtk_event_controller_key_new()
+           /* let escapeHandler = gtk_event_controller_key_new()
             gtk_event_controller_set_propagation_phase(escapeHandler, GTK_PHASE_BUBBLE)
             g_signal_connect_data(
                 UnsafeMutableRawPointer(escapeHandler),
@@ -1673,8 +1653,15 @@ public final class GtkBackend: AppBackend {
                     }
                 },
                 .init(0)
-            )
-            gtk_widget_add_controller(sheet.widgetPointer, escapeHandler)
+            )*/
+            sheet.setEscapeKeyPressedHandler {
+                print("escapeKeyPressed")
+                if ctx.interactiveDismissDisabled { return }
+                self.runInMainThread {
+                    ctx.onDismiss()
+                }
+            }
+            
         }
     }
 
@@ -1736,10 +1723,3 @@ extension UnsafeMutablePointer {
 class CustomListBox: ListBox {
     var cachedSelection: Int? = nil
 }
-
-final class ValueBox<T> {
-    let value: T
-    init(value: T) {
-        self.value = value
-    }
-}