Copy and adapt existing Gtk wrapper to create a Gtk3 wrapper (for supporting older Linux)

Author: stackotter

Package.swift

@@ -216,6 +216,25 @@ let package = Package(
                 "XMLCoder", .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
             ]
         ),
+        .systemLibrary(
+            name: "CGtk3",
+            pkgConfig: "gtk+-3.0",
+            providers: [
+                .brew(["gtk+3"]),
+                .apt(["libgtk-3-dev clang"]),
+            ]
+        ),
+        .target(
+            name: "Gtk3",
+            dependencies: ["CGtk3"],
+            exclude: ["LICENSE.md"],
+            swiftSettings: gtkSwiftSettings
+        ),
+        .executableTarget(
+            name: "Gtk3Example",
+            dependencies: ["Gtk3"],
+            resources: [.copy("GTK.png")]
+        ),
         .macro(
             name: "HotReloadingMacrosPlugin",
             dependencies: [

Sources/CGtk3/header.h

@@ -0,0 +1,5 @@
+#include <float.h>
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <pango/pango.h>
+#include <pango/pangocairo.h>

Sources/CGtk3/module.modulemap

@@ -0,0 +1,8 @@
+module CGtk3 [system] {
+  header "header.h"
+  link "gtk-3"
+  link "pango-1.0"
+  link "pangocairo-1.0"
+
+  export *
+}

Sources/Gtk/Generated/Image.swift

@@ -97,23 +97,6 @@ public class Image: Widget {
         widgetPointer = gtk_image_new_from_paintable(paintable)
     }
 
-    /// Creates a new `GtkImage` displaying @pixbuf.
-    ///
-    /// The `GtkImage` does not assume a reference to the pixbuf; you still
-    /// need to unref it if you own references. `GtkImage` will add its own
-    /// reference rather than adopting yours.
-    ///
-    /// This is a helper for [ctor@Gtk.Image.new_from_paintable], and you can't
-    /// get back the exact pixbuf once this is called, only a texture.
-    ///
-    /// Note that this function just creates an `GtkImage` from the pixbuf.
-    /// The `GtkImage` created will not react to state changes. Should you
-    /// want that, you should use [ctor@Gtk.Image.new_from_icon_name].
-    public init(pixbuf: OpaquePointer) {
-        super.init()
-        widgetPointer = gtk_image_new_from_pixbuf(pixbuf)
-    }
-
     /// Creates a new `GtkImage` displaying the resource file @resource_path.
     ///
     /// If the file isn’t found or can’t be loaded, the resulting `GtkImage` will

Sources/Gtk/Generated/Label.swift

@@ -348,139 +348,127 @@ public class Label: Widget {
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::mnemonic-widget", handler: gCallback(handler12)) {
-            [weak self] (_: OpaquePointer) in
-            guard let self = self else { return }
-            self.notifyMnemonicWidget?(self)
-        }
-
-        let handler13:
-            @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
-                { _, value1, data in
-                    SignalBox1<OpaquePointer>.run(data, value1)
-                }
-
-        addSignal(name: "notify::natural-wrap-mode", handler: gCallback(handler13)) {
+        addSignal(name: "notify::natural-wrap-mode", handler: gCallback(handler12)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyNaturalWrapMode?(self)
         }
 
-        let handler14:
+        let handler13:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::selectable", handler: gCallback(handler14)) {
+        addSignal(name: "notify::selectable", handler: gCallback(handler13)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifySelectable?(self)
         }
 
-        let handler15:
+        let handler14:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::single-line-mode", handler: gCallback(handler15)) {
+        addSignal(name: "notify::single-line-mode", handler: gCallback(handler14)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifySingleLineMode?(self)
         }
 
-        let handler16:
+        let handler15:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::tabs", handler: gCallback(handler16)) {
+        addSignal(name: "notify::tabs", handler: gCallback(handler15)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyTabs?(self)
         }
 
-        let handler17:
+        let handler16:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::use-markup", handler: gCallback(handler17)) {
+        addSignal(name: "notify::use-markup", handler: gCallback(handler16)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyUseMarkup?(self)
         }
 
-        let handler18:
+        let handler17:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::use-underline", handler: gCallback(handler18)) {
+        addSignal(name: "notify::use-underline", handler: gCallback(handler17)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyUseUnderline?(self)
         }
 
-        let handler19:
+        let handler18:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::width-chars", handler: gCallback(handler19)) {
+        addSignal(name: "notify::width-chars", handler: gCallback(handler18)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyWidthChars?(self)
         }
 
-        let handler20:
+        let handler19:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::wrap", handler: gCallback(handler20)) {
+        addSignal(name: "notify::wrap", handler: gCallback(handler19)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyWrap?(self)
         }
 
-        let handler21:
+        let handler20:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::wrap-mode", handler: gCallback(handler21)) {
+        addSignal(name: "notify::wrap-mode", handler: gCallback(handler20)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyWrapMode?(self)
         }
 
-        let handler22:
+        let handler21:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::xalign", handler: gCallback(handler22)) {
+        addSignal(name: "notify::xalign", handler: gCallback(handler21)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyXalign?(self)
         }
 
-        let handler23:
+        let handler22:
             @convention(c) (UnsafeMutableRawPointer, OpaquePointer, UnsafeMutableRawPointer) -> Void =
                 { _, value1, data in
                     SignalBox1<OpaquePointer>.run(data, value1)
                 }
 
-        addSignal(name: "notify::yalign", handler: gCallback(handler23)) {
+        addSignal(name: "notify::yalign", handler: gCallback(handler22)) {
             [weak self] (_: OpaquePointer) in
             guard let self = self else { return }
             self.notifyYalign?(self)
@@ -630,8 +618,6 @@ public class Label: Widget {
 
     public var notifyMnemonicKeyval: ((Label) -> Void)?
 
-    public var notifyMnemonicWidget: ((Label) -> Void)?
-
     public var notifyNaturalWrapMode: ((Label) -> Void)?
 
     public var notifySelectable: ((Label) -> Void)?

Sources/Gtk/Generated/Picture.swift

@@ -71,17 +71,6 @@ public class Picture: Widget {
         widgetPointer = gtk_picture_new_for_paintable(paintable)
     }
 
-    /// Creates a new `GtkPicture` displaying @pixbuf.
-    ///
-    /// This is a utility function that calls [ctor@Gtk.Picture.new_for_paintable],
-    /// See that function for details.
-    ///
-    /// The pixbuf must not be modified after passing it to this function.
-    public init(pixbuf: OpaquePointer) {
-        super.init()
-        widgetPointer = gtk_picture_new_for_pixbuf(pixbuf)
-    }
-
     /// Creates a new `GtkPicture` displaying the resource at @resource_path.
     ///
     /// This is a utility function that calls [ctor@Gtk.Picture.new_for_file].

Sources/Gtk/Widgets/Fixed.swift

@@ -67,6 +67,7 @@ public class Fixed: Widget {
     public func removeAllChildren() {
         for child in children {
             gtk_fixed_remove(castedPointer(), child.widgetPointer)
+            child.parentWidget = nil
         }
         children = []
     }