42eb86e Gen: re-run gen script · purego

M v4/adw/adw-about-window.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gsk"
 	"github.com/jwijenbergh/puregotk/v4/gtk"
 //
 // Applications may connect to it to override the default behavior, which is
 // to call [func@Gtk.show_uri].
-func (x *AboutWindow) ConnectActivateLink(cb func(AboutWindow, string) bool) uint32 {
+func (x *AboutWindow) ConnectActivateLink(cb *func(AboutWindow, string) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, UriVarp string) bool {
 		fa := AboutWindow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, UriVarp)
+		return cbFn(fa, UriVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-action-row.go +11 -3

 }
 // This signal is emitted after the row has been activated.
-func (x *ActionRow) ConnectActivated(cb func(ActionRow)) uint32 {
+func (x *ActionRow) ConnectActivated(cb *func(ActionRow)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ActionRow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-animation-target.go +2 -2


@@ -69,10 +69,10 @@ var xNewCallbackAnimationTarget func(uintptr, uintptr, uintptr) uintptr
69			69
70		// Creates a new `AdwAnimationTarget` that calls the given @callback during	70		// Creates a new `AdwAnimationTarget` that calls the given @callback during
71		// the animation.	71		// the animation.
72	-	func NewCallbackAnimationTarget(CallbackVar AnimationTargetFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAnimationTarget {	72	+	func NewCallbackAnimationTarget(CallbackVar AnimationTargetFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAnimationTarget {
73		var cls *CallbackAnimationTarget	73		var cls *CallbackAnimationTarget
74			74
75	-	cret := xNewCallbackAnimationTarget(purego.NewCallback(CallbackVar), UserDataVar, purego.NewCallback(DestroyVar))	75	+	cret := xNewCallbackAnimationTarget(glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(DestroyVar))
76			76
77		if cret == 0 {	77		if cret == 0 {
78		return nil	78		return nil

M v4/adw/adw-animation.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gtk"
 )
 // This signal is emitted when the animation has been completed, either on its
 // own or via calling [method@Animation.skip].
-func (x *Animation) ConnectDone(cb func(Animation)) uint32 {
+func (x *Animation) ConnectDone(cb *func(Animation)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Animation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "done", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
 }
 func init() {

M v4/adw/adw-banner.go +11 -3

 // This signal is emitted after the action button has been clicked.
 //
 // It can be used as an alternative to setting an action.
-func (x *Banner) ConnectButtonClicked(cb func(Banner)) uint32 {
+func (x *Banner) ConnectButtonClicked(cb *func(Banner)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Banner{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "button-clicked", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-carousel.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gtk"
 )
 // It can be used to implement "infinite scrolling" by amending the pages
 // after every scroll. Note that an empty carousel is indicated by
 // `(int)index == -1`.
-func (x *Carousel) ConnectPageChanged(cb func(Carousel, uint)) uint32 {
+func (x *Carousel) ConnectPageChanged(cb *func(Carousel, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "page-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, IndexVarp uint) {
 		fa := Carousel{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, IndexVarp)
+		cbFn(fa, IndexVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "page-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "page-changed", cbRefPtr)
 }
 // Gets the progress @self will snap back to after the gesture is canceled.

M v4/adw/adw-entry-row.go +22 -6

 // Emitted when the apply button is pressed.
 //
 // See [property@EntryRow:show-apply-button].
-func (x *EntryRow) ConnectApply(cb func(EntryRow)) uint32 {
+func (x *EntryRow) ConnectApply(cb *func(EntryRow)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EntryRow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "apply", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
 }
 // Emitted when the embedded entry is activated.
-func (x *EntryRow) ConnectEntryActivated(cb func(EntryRow)) uint32 {
+func (x *EntryRow) ConnectEntryActivated(cb *func(EntryRow)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "entry-activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EntryRow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "entry-activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "entry-activated", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-message-dialog.go +14 -5

 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gsk"
 	"github.com/jwijenbergh/puregotk/v4/gtk"
 //
 // The @callback will be called when the alert is dismissed. It should call
 // [method@MessageDialog.choose_finish] to obtain the result.
-func (x *MessageDialog) Choose(CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
+func (x *MessageDialog) Choose(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xMessageDialogChoose(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xMessageDialogChoose(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // if the dialog was closed by pressing &lt;kbd&gt;Escape&lt;/kbd&gt; or with a system
 // action, @response will be set to the value of
 // [property@MessageDialog:close-response].
-func (x *MessageDialog) ConnectResponse(cb func(MessageDialog, string)) uint32 {
+func (x *MessageDialog) ConnectResponse(cb *func(MessageDialog, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ResponseVarp string) {
 		fa := MessageDialog{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ResponseVarp)
+		cbFn(fa, ResponseVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "response", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-split-button.go +22 -6

 //
 // This is an action signal. Applications should never connect to this signal,
 // but use the [signal@SplitButton::clicked] signal.
-func (x *SplitButton) ConnectActivate(cb func(SplitButton)) uint32 {
+func (x *SplitButton) ConnectActivate(cb *func(SplitButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SplitButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the button has been activated (pressed and released).
-func (x *SplitButton) ConnectClicked(cb func(SplitButton)) uint32 {
+func (x *SplitButton) ConnectClicked(cb *func(SplitButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SplitButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "clicked", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-swipe-tracker.go +45 -12

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gtk"
 )
 // This signal is emitted right before a swipe will be started, after the
 // drag threshold has been passed.
-func (x *SwipeTracker) ConnectBeginSwipe(cb func(SwipeTracker)) uint32 {
+func (x *SwipeTracker) ConnectBeginSwipe(cb *func(SwipeTracker)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "begin-swipe", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SwipeTracker{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "begin-swipe", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "begin-swipe", cbRefPtr)
 }
 // This signal is emitted as soon as the gesture has stopped.
 // value to @to with an animation using @velocity as the initial velocity,
 // provided in pixels per second. [class@SpringAnimation] is usually a good
 // fit for this.
-func (x *SwipeTracker) ConnectEndSwipe(cb func(SwipeTracker, float64, float64)) uint32 {
+func (x *SwipeTracker) ConnectEndSwipe(cb *func(SwipeTracker, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "end-swipe", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, VelocityVarp float64, ToVarp float64) {
 		fa := SwipeTracker{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, VelocityVarp, ToVarp)
+		cbFn(fa, VelocityVarp, ToVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "end-swipe", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "end-swipe", cbRefPtr)
 }
 // This signal is emitted when a possible swipe is detected.
 //
 // The @direction value can be used to restrict the swipe to a certain
 // direction.
-func (x *SwipeTracker) ConnectPrepare(cb func(SwipeTracker, NavigationDirection)) uint32 {
+func (x *SwipeTracker) ConnectPrepare(cb *func(SwipeTracker, NavigationDirection)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DirectionVarp NavigationDirection) {
 		fa := SwipeTracker{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DirectionVarp)
+		cbFn(fa, DirectionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "prepare", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
 }
 // This signal is emitted every time the progress value changes.
-func (x *SwipeTracker) ConnectUpdateSwipe(cb func(SwipeTracker, float64)) uint32 {
+func (x *SwipeTracker) ConnectUpdateSwipe(cb *func(SwipeTracker, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "update-swipe", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ProgressVarp float64) {
 		fa := SwipeTracker{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ProgressVarp)
+		cbFn(fa, ProgressVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "update-swipe", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "update-swipe", cbRefPtr)
 }
 // Retrieves the orientation of the @orientable.

M v4/adw/adw-tab-bar.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gtk"
 )
 // [method@TabBar.setup_extra_drop_target].
 //
 // See [signal@Gtk.DropTarget::drop].
-func (x *TabBar) ConnectExtraDragDrop(cb func(TabBar, uintptr, uintptr) bool) uint32 {
+func (x *TabBar) ConnectExtraDragDrop(cb *func(TabBar, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, ValueVarp uintptr) bool {
 		fa := TabBar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PageVarp, ValueVarp)
+		return cbFn(fa, PageVarp, ValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
 }
 // This signal is emitted when the dropped content is preloaded.
 // [method@TabBar.setup_extra_drop_target].
 //
 // See [property@Gtk.DropTarget:value].
-func (x *TabBar) ConnectExtraDragValue(cb func(TabBar, uintptr, uintptr) gdk.DragAction) uint32 {
+func (x *TabBar) ConnectExtraDragValue(cb *func(TabBar, uintptr, uintptr) gdk.DragAction) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, ValueVarp uintptr) gdk.DragAction {
 		fa := TabBar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PageVarp, ValueVarp)
+		return cbFn(fa, PageVarp, ValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-tab-button.go +22 -6

 //
 // This is an action signal. Applications should never connect to this signal,
 // but use the [signal@TabButton::clicked] signal.
-func (x *TabButton) ConnectActivate(cb func(TabButton)) uint32 {
+func (x *TabButton) ConnectActivate(cb *func(TabButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TabButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the button has been activated (pressed and released).
-func (x *TabButton) ConnectClicked(cb func(TabButton)) uint32 {
+func (x *TabButton) ConnectClicked(cb *func(TabButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TabButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "clicked", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-tab-overview.go +34 -9

 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gtk"
 )
 //
 // The signal handler is expected to create a new page in the corresponding
 // [class@TabView] and return it.
-func (x *TabOverview) ConnectCreateTab(cb func(TabOverview) TabPage) uint32 {
+func (x *TabOverview) ConnectCreateTab(cb *func(TabOverview) TabPage) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "create-tab", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) uintptr {
 		fa := TabOverview{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		CreateTabCls := cb(fa)
+		CreateTabCls := cbFn(fa)
 		return CreateTabCls.Ptr
 	}
-	return gobject.SignalConnect(x.GoPointer(), "create-tab", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "create-tab", cbRefPtr)
 }
 // This signal is emitted when content is dropped onto a tab.
 // [method@TabOverview.setup_extra_drop_target].
 //
 // See [signal@Gtk.DropTarget::drop].
-func (x *TabOverview) ConnectExtraDragDrop(cb func(TabOverview, uintptr, uintptr) bool) uint32 {
+func (x *TabOverview) ConnectExtraDragDrop(cb *func(TabOverview, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, ValueVarp uintptr) bool {
 		fa := TabOverview{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PageVarp, ValueVarp)
+		return cbFn(fa, PageVarp, ValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
 }
 // This signal is emitted when the dropped content is preloaded.
 // [method@TabOverview.setup_extra_drop_target].
 //
 // See [property@Gtk.DropTarget:value].
-func (x *TabOverview) ConnectExtraDragValue(cb func(TabOverview, uintptr, uintptr) gdk.DragAction) uint32 {
+func (x *TabOverview) ConnectExtraDragValue(cb *func(TabOverview, uintptr, uintptr) gdk.DragAction) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, ValueVarp uintptr) gdk.DragAction {
 		fa := TabOverview{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PageVarp, ValueVarp)
+		return cbFn(fa, PageVarp, ValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-tab-view.go +78 -21

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gtk"
 )
 //
 // A typical reason to connect to this signal is to show a confirmation dialog
 // for closing a tab.
-func (x *TabView) ConnectClosePage(cb func(TabView, uintptr) bool) uint32 {
+func (x *TabView) ConnectClosePage(cb *func(TabView, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "close-page", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) bool {
 		fa := TabView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PageVarp)
+		return cbFn(fa, PageVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "close-page", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "close-page", cbRefPtr)
 }
 // Emitted when a tab should be transferred into a new window.
 //
 // The signal handler is expected to create a new window, position it as
 // needed and return its `AdwTabView` that the page will be transferred into.
-func (x *TabView) ConnectCreateWindow(cb func(TabView) TabView) uint32 {
+func (x *TabView) ConnectCreateWindow(cb *func(TabView) TabView) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) uintptr {
 		fa := TabView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		CreateWindowCls := cb(fa)
+		CreateWindowCls := cbFn(fa)
 		return CreateWindowCls.Ptr
 	}
-	return gobject.SignalConnect(x.GoPointer(), "create-window", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
 }
 // Emitted after the indicator icon on @page has been activated.
 //
 // See [property@TabPage:indicator-icon] and
 // [property@TabPage:indicator-activatable].
-func (x *TabView) ConnectIndicatorActivated(cb func(TabView, uintptr)) uint32 {
+func (x *TabView) ConnectIndicatorActivated(cb *func(TabView, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "indicator-activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) {
 		fa := TabView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PageVarp)
+		cbFn(fa, PageVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "indicator-activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "indicator-activated", cbRefPtr)
 }
 // Emitted when a page has been created or transferred to @self.
 //
 // A typical reason to connect to this signal would be to connect to page
 // signals for things such as updating window title.
-func (x *TabView) ConnectPageAttached(cb func(TabView, uintptr, int)) uint32 {
+func (x *TabView) ConnectPageAttached(cb *func(TabView, uintptr, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "page-attached", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, PositionVarp int) {
 		fa := TabView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PageVarp, PositionVarp)
+		cbFn(fa, PageVarp, PositionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "page-attached", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "page-attached", cbRefPtr)
 }
 // Emitted when a page has been removed or transferred to another view.
 // this function as the child might merely be moved to another window; use
 // child dispose handler for that or do it in sync with your
 // [method@TabView.close_page_finish] calls.
-func (x *TabView) ConnectPageDetached(cb func(TabView, uintptr, int)) uint32 {
+func (x *TabView) ConnectPageDetached(cb *func(TabView, uintptr, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "page-detached", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, PositionVarp int) {
 		fa := TabView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PageVarp, PositionVarp)
+		cbFn(fa, PageVarp, PositionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "page-detached", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "page-detached", cbRefPtr)
 }
 // Emitted after @page has been reordered to @position.
-func (x *TabView) ConnectPageReordered(cb func(TabView, uintptr, int)) uint32 {
+func (x *TabView) ConnectPageReordered(cb *func(TabView, uintptr, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, PositionVarp int) {
 		fa := TabView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PageVarp, PositionVarp)
+		cbFn(fa, PageVarp, PositionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "page-reordered", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
 }
 // Emitted when a context menu is opened or closed for @page.
 //
 // It can be used to set up menu actions before showing the menu, for example
 // disable actions not applicable to @page.
-func (x *TabView) ConnectSetupMenu(cb func(TabView, uintptr)) uint32 {
+func (x *TabView) ConnectSetupMenu(cb *func(TabView, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "setup-menu", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) {
 		fa := TabView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PageVarp)
+		cbFn(fa, PageVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "setup-menu", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "setup-menu", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/adw/adw-toast.go +22 -6

 // Emitted after the button has been clicked.
 //
 // It can be used as an alternative to setting an action.
-func (x *Toast) ConnectButtonClicked(cb func(Toast)) uint32 {
+func (x *Toast) ConnectButtonClicked(cb *func(Toast)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Toast{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "button-clicked", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
 }
 // Emitted when the toast has been dismissed.
-func (x *Toast) ConnectDismissed(cb func(Toast)) uint32 {
+func (x *Toast) ConnectDismissed(cb *func(Toast)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "dismissed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Toast{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "dismissed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "dismissed", cbRefPtr)
 }
 func init() {

M v4/gdk/gdkclipboard.go +23 -13

 package gdk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
 //
 // The clipboard will choose the most suitable mime type from the given list
 // to fulfill the request, preferring the ones listed first.
-func (x *Clipboard) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Clipboard) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xClipboardReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xClipboardReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // This is a simple wrapper around [method@Gdk.Clipboard.read_value_async].
 // Use that function or [method@Gdk.Clipboard.read_async] directly if you
 // need more control over the operation.
-func (x *Clipboard) ReadTextAsync(CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Clipboard) ReadTextAsync(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xClipboardReadTextAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xClipboardReadTextAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // This is a simple wrapper around [method@Gdk.Clipboard.read_value_async].
 // Use that function or [method@Gdk.Clipboard.read_async] directly if you
 // need more control over the operation.
-func (x *Clipboard) ReadTextureAsync(CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Clipboard) ReadTextureAsync(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xClipboardReadTextureAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xClipboardReadTextureAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // For local clipboard contents that are available in the given `GType`,
 // the value will be copied directly. Otherwise, GDK will try to use
 // [func@content_deserialize_async] to convert the clipboard's data.
-func (x *Clipboard) ReadValueAsync(TypeVar []interface{}, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Clipboard) ReadValueAsync(TypeVar []interface{}, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xClipboardReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xClipboardReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 //
 // This function is called automatically when a [class@Gtk.Application] is
 // shut down, so you likely don't need to call it.
-func (x *Clipboard) StoreAsync(IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Clipboard) StoreAsync(IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xClipboardStoreAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xClipboardStoreAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 }
 // Emitted when the clipboard changes ownership.
-func (x *Clipboard) ConnectChanged(cb func(Clipboard)) uint32 {
+func (x *Clipboard) ConnectChanged(cb *func(Clipboard)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Clipboard{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 func init() {

M v4/gdk/gdkcontentdeserializer.go +6 -6


@@ -25,9 +25,9 @@ var xContentDeserializeAsync func(uintptr, string, []interface{}, int, uintptr,
25		//	25		//
26		// When the operation is finished, @callback will be called. You must then	26		// When the operation is finished, @callback will be called. You must then
27		// call [func@Gdk.content_deserialize_finish] to get the result of the operation.	27		// call [func@Gdk.content_deserialize_finish] to get the result of the operation.
28	-	func ContentDeserializeAsync(StreamVar gio.InputStream, MimeTypeVar string, TypeVar []interface{}, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	28	+	func ContentDeserializeAsync(StreamVar gio.InputStream, MimeTypeVar string, TypeVar []interface{}, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
29			29
30	-	xContentDeserializeAsync(StreamVar.GoPointer(), MimeTypeVar, TypeVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	30	+	xContentDeserializeAsync(StreamVar.GoPointer(), MimeTypeVar, TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
31			31
32		}	32		}
33			33

@@ -48,9 +48,9 @@ func ContentDeserializeFinish(ResultVar gio.AsyncResult, ValueVar *gobject.Value
48		var xContentRegisterDeserializer func(string, []interface{}, uintptr, uintptr, uintptr)	48		var xContentRegisterDeserializer func(string, []interface{}, uintptr, uintptr, uintptr)
49			49
50		// Registers a function to deserialize object of a given type.	50		// Registers a function to deserialize object of a given type.
51	-	func ContentRegisterDeserializer(MimeTypeVar string, TypeVar []interface{}, DeserializeVar ContentDeserializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {	51	+	func ContentRegisterDeserializer(MimeTypeVar string, TypeVar []interface{}, DeserializeVar ContentDeserializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {
52			52
53	-	xContentRegisterDeserializer(MimeTypeVar, TypeVar, purego.NewCallback(DeserializeVar), DataVar, purego.NewCallback(NotifyVar))	53	+	xContentRegisterDeserializer(MimeTypeVar, TypeVar, glib.NewCallback(DeserializeVar), DataVar, glib.NewCallback(NotifyVar))
54			54
55		}	55		}
56			56

@@ -194,9 +194,9 @@ func (x *ContentDeserializer) ReturnSuccess() {
194		var xContentDeserializerSetTaskData func(uintptr, uintptr, uintptr)	194		var xContentDeserializerSetTaskData func(uintptr, uintptr, uintptr)
195			195
196		// Associate data with the current deserialization operation.	196		// Associate data with the current deserialization operation.
197	-	func (x *ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {	197	+	func (x ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {
198			198
199	-	xContentDeserializerSetTaskData(x.GoPointer(), DataVar, purego.NewCallback(NotifyVar))	199	+	xContentDeserializerSetTaskData(x.GoPointer(), DataVar, glib.NewCallback(NotifyVar))
200			200
201		}	201		}
202			202

M v4/gdk/gdkcontentprovider.go +13 -5

 // not supported, `G_IO_ERROR_NOT_SUPPORTED` will be reported.
 //
 // The given @stream will not be closed.
-func (x *ContentProvider) WriteMimeTypeAsync(MimeTypeVar string, StreamVar *gio.OutputStream, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
+func (x *ContentProvider) WriteMimeTypeAsync(MimeTypeVar string, StreamVar *gio.OutputStream, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xContentProviderWriteMimeTypeAsync(x.GoPointer(), MimeTypeVar, StreamVar.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xContentProviderWriteMimeTypeAsync(x.GoPointer(), MimeTypeVar, StreamVar.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 }
 // Emitted whenever the content provided by this provider has changed.
-func (x *ContentProvider) ConnectContentChanged(cb func(ContentProvider)) uint32 {
+func (x *ContentProvider) ConnectContentChanged(cb *func(ContentProvider)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "content-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ContentProvider{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "content-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "content-changed", cbRefPtr)
 }
 func init() {

M v4/gdk/gdkcontentserializer.go +6 -6


@@ -19,9 +19,9 @@ type ContentSerializeFunc func(uintptr)
19		var xContentRegisterSerializer func([]interface{}, string, uintptr, uintptr, uintptr)	19		var xContentRegisterSerializer func([]interface{}, string, uintptr, uintptr, uintptr)
20			20
21		// Registers a function to serialize objects of a given type.	21		// Registers a function to serialize objects of a given type.
22	-	func ContentRegisterSerializer(TypeVar []interface{}, MimeTypeVar string, SerializeVar ContentSerializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {	22	+	func ContentRegisterSerializer(TypeVar []interface{}, MimeTypeVar string, SerializeVar ContentSerializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {
23			23
24	-	xContentRegisterSerializer(TypeVar, MimeTypeVar, purego.NewCallback(SerializeVar), DataVar, purego.NewCallback(NotifyVar))	24	+	xContentRegisterSerializer(TypeVar, MimeTypeVar, glib.NewCallback(SerializeVar), DataVar, glib.NewCallback(NotifyVar))
25			25
26		}	26		}
27			27

@@ -34,9 +34,9 @@ var xContentSerializeAsync func(uintptr, string, *gobject.Value, int, uintptr, u
34		//	34		//
35		// When the operation is finished, @callback will be called. You must then	35		// When the operation is finished, @callback will be called. You must then
36		// call [func@Gdk.content_serialize_finish] to get the result of the operation.	36		// call [func@Gdk.content_serialize_finish] to get the result of the operation.
37	-	func ContentSerializeAsync(StreamVar gio.OutputStream, MimeTypeVar string, ValueVar gobject.Value, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	37	+	func ContentSerializeAsync(StreamVar gio.OutputStream, MimeTypeVar string, ValueVar gobject.Value, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
38			38
39	-	xContentSerializeAsync(StreamVar.GoPointer(), MimeTypeVar, ValueVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	39	+	xContentSerializeAsync(StreamVar.GoPointer(), MimeTypeVar, ValueVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
40			40
41		}	41		}
42			42

@@ -195,9 +195,9 @@ func (x *ContentSerializer) ReturnSuccess() {
195		var xContentSerializerSetTaskData func(uintptr, uintptr, uintptr)	195		var xContentSerializerSetTaskData func(uintptr, uintptr, uintptr)
196			196
197		// Associate data with the current serialization operation.	197		// Associate data with the current serialization operation.
198	-	func (x *ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {	198	+	func (x ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {
199			199
200	-	xContentSerializerSetTaskData(x.GoPointer(), DataVar, purego.NewCallback(NotifyVar))	200	+	xContentSerializerSetTaskData(x.GoPointer(), DataVar, glib.NewCallback(NotifyVar))
201			201
202		}	202		}
203			203

M v4/gdk/gdkdevice.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/pango"
 )
 // example, user switches from the USB mouse to a tablet); in
 // that case the logical device will change to reflect the axes
 // and keys on the new physical device.
-func (x *Device) ConnectChanged(cb func(Device)) uint32 {
+func (x *Device) ConnectChanged(cb *func(Device)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Device{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 // Emitted on pen/eraser devices whenever tools enter or leave proximity.
-func (x *Device) ConnectToolChanged(cb func(Device, uintptr)) uint32 {
+func (x *Device) ConnectToolChanged(cb *func(Device, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "tool-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ToolVarp uintptr) {
 		fa := Device{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ToolVarp)
+		cbFn(fa, ToolVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "tool-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "tool-changed", cbRefPtr)
 }
 func init() {

M v4/gdk/gdkdisplay.go +57 -15

 package gdk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
 }
 // Emitted when the connection to the windowing system for @display is closed.
-func (x *Display) ConnectClosed(cb func(Display, bool)) uint32 {
+func (x *Display) ConnectClosed(cb *func(Display, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, IsErrorVarp bool) {
 		fa := Display{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, IsErrorVarp)
+		cbFn(fa, IsErrorVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "closed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
 }
 // Emitted when the connection to the windowing system for @display is opened.
-func (x *Display) ConnectOpened(cb func(Display)) uint32 {
+func (x *Display) ConnectOpened(cb *func(Display)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "opened", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Display{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "opened", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "opened", cbRefPtr)
 }
 // Emitted whenever a new seat is made known to the windowing system.
-func (x *Display) ConnectSeatAdded(cb func(Display, uintptr)) uint32 {
+func (x *Display) ConnectSeatAdded(cb *func(Display, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "seat-added", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SeatVarp uintptr) {
 		fa := Display{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SeatVarp)
+		cbFn(fa, SeatVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "seat-added", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "seat-added", cbRefPtr)
 }
 // Emitted whenever a seat is removed by the windowing system.
-func (x *Display) ConnectSeatRemoved(cb func(Display, uintptr)) uint32 {
+func (x *Display) ConnectSeatRemoved(cb *func(Display, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "seat-removed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SeatVarp uintptr) {
 		fa := Display{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SeatVarp)
+		cbFn(fa, SeatVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "seat-removed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "seat-removed", cbRefPtr)
 }
 // Emitted whenever a setting changes its value.
-func (x *Display) ConnectSettingChanged(cb func(Display, string)) uint32 {
+func (x *Display) ConnectSettingChanged(cb *func(Display, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "setting-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SettingVarp string) {
 		fa := Display{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SettingVarp)
+		cbFn(fa, SettingVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "setting-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "setting-changed", cbRefPtr)
 }
 var xDisplayGetDefault func() uintptr

M v4/gdk/gdkdisplaymanager.go +13 -3

 package gdk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 }
 // Emitted when a display is opened.
-func (x *DisplayManager) ConnectDisplayOpened(cb func(DisplayManager, uintptr)) uint32 {
+func (x *DisplayManager) ConnectDisplayOpened(cb *func(DisplayManager, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "display-opened", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DisplayVarp uintptr) {
 		fa := DisplayManager{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DisplayVarp)
+		cbFn(fa, DisplayVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "display-opened", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "display-opened", cbRefPtr)
 }
 var xDisplayManagerGet func() uintptr

M v4/gdk/gdkdrag.go +36 -9

 package gdk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted when the drag operation is cancelled.
-func (x *Drag) ConnectCancel(cb func(Drag, DragCancelReason)) uint32 {
+func (x *Drag) ConnectCancel(cb *func(Drag, DragCancelReason)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ReasonVarp DragCancelReason) {
 		fa := Drag{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ReasonVarp)
+		cbFn(fa, ReasonVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cancel", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
 }
 // Emitted when the destination side has finished reading all data.
 //
 // The drag object can now free all miscellaneous data.
-func (x *Drag) ConnectDndFinished(cb func(Drag)) uint32 {
+func (x *Drag) ConnectDndFinished(cb *func(Drag)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "dnd-finished", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Drag{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "dnd-finished", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "dnd-finished", cbRefPtr)
 }
 // Emitted when the drop operation is performed on an accepting client.
-func (x *Drag) ConnectDropPerformed(cb func(Drag)) uint32 {
+func (x *Drag) ConnectDropPerformed(cb *func(Drag)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drop-performed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Drag{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drop-performed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drop-performed", cbRefPtr)
 }
 var xDragBegin func(uintptr, uintptr, uintptr, DragAction, float64, float64) uintptr

M v4/gdk/gdkdrop.go +4 -4


@@ -152,9 +152,9 @@ var xDropReadAsync func(uintptr, []string, int, uintptr, uintptr, uintptr)
152			152
153		// Asynchronously read the dropped data from a `GdkDrop`	153		// Asynchronously read the dropped data from a `GdkDrop`
154		// in a format that complies with one of the mime types.	154		// in a format that complies with one of the mime types.
155	-	func (x Drop) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	155	+	func (x Drop) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
156			156
157	-	xDropReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	157	+	xDropReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
158			158
159		}	159		}
160			160

@@ -198,9 +198,9 @@ var xDropReadValueAsync func(uintptr, []interface{}, int, uintptr, uintptr, uint
198		// For local drag-and-drop operations that are available in the given	198		// For local drag-and-drop operations that are available in the given
199		// `GType`, the value will be copied directly. Otherwise, GDK will	199		// `GType`, the value will be copied directly. Otherwise, GDK will
200		// try to use [func@Gdk.content_deserialize_async] to convert the data.	200		// try to use [func@Gdk.content_deserialize_async] to convert the data.
201	-	func (x Drop) ReadValueAsync(TypeVar []interface{}, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	201	+	func (x Drop) ReadValueAsync(TypeVar []interface{}, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
202			202
203	-	xDropReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	203	+	xDropReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
204			204
205		}	205		}
206			206

M v4/gdk/gdkframeclock.go +78 -21

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // This signal ends processing of the frame.
 //
 // Applications should generally not handle this signal.
-func (x *FrameClock) ConnectAfterPaint(cb func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectAfterPaint(cb *func(FrameClock)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "after-paint", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FrameClock{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "after-paint", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "after-paint", cbRefPtr)
 }
 // Begins processing of the frame.
 //
 // Applications should generally not handle this signal.
-func (x *FrameClock) ConnectBeforePaint(cb func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectBeforePaint(cb *func(FrameClock)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "before-paint", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FrameClock{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "before-paint", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "before-paint", cbRefPtr)
 }
 // Used to flush pending motion events that are being batched up and
 // compressed together.
 //
 // Applications should not handle this signal.
-func (x *FrameClock) ConnectFlushEvents(cb func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectFlushEvents(cb *func(FrameClock)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "flush-events", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FrameClock{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "flush-events", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "flush-events", cbRefPtr)
 }
 // Emitted as the second step of toolkit and application processing
 //
 // Any work to update sizes and positions of application elements
 // should be performed. GTK normally handles this internally.
-func (x *FrameClock) ConnectLayout(cb func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectLayout(cb *func(FrameClock)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FrameClock{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "layout", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
 }
 // Emitted as the third step of toolkit and application processing
 // The frame is repainted. GDK normally handles this internally and
 // emits [signal@Gdk.Surface::render] signals which are turned into
 // [signal@Gtk.Widget::snapshot] signals by GTK.
-func (x *FrameClock) ConnectPaint(cb func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectPaint(cb *func(FrameClock)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "paint", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FrameClock{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "paint", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "paint", cbRefPtr)
 }
 // Emitted after processing of the frame is finished.
 //
 // This signal is handled internally by GTK to resume normal
 // event processing. Applications should not handle this signal.
-func (x *FrameClock) ConnectResumeEvents(cb func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectResumeEvents(cb *func(FrameClock)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "resume-events", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FrameClock{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "resume-events", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "resume-events", cbRefPtr)
 }
 // Emitted as the first step of toolkit and application processing
 // Animations should be updated using [method@Gdk.FrameClock.get_frame_time].
 // Applications can connect directly to this signal, or use
 // [method@Gtk.Widget.add_tick_callback] as a more convenient interface.
-func (x *FrameClock) ConnectUpdate(cb func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectUpdate(cb *func(FrameClock)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FrameClock{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "update", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
 }
 func init() {

M v4/gdk/gdkgltexture.go +4 -4


@@ -35,10 +35,10 @@ var xNewGLTexture func(uintptr, uint, int, int, uintptr, uintptr) uintptr
35		// Note that the GL texture must not be modified until @destroy is called,	35		// Note that the GL texture must not be modified until @destroy is called,
36		// which will happen when the GdkTexture object is finalized, or due to	36		// which will happen when the GdkTexture object is finalized, or due to
37		// an explicit call of [method@Gdk.GLTexture.release].	37		// an explicit call of [method@Gdk.GLTexture.release].
38	-	func NewGLTexture(ContextVar GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar glib.DestroyNotify, DataVar uintptr) GLTexture {	38	+	func NewGLTexture(ContextVar GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar glib.DestroyNotify, DataVar uintptr) *GLTexture {
39		var cls *GLTexture	39		var cls *GLTexture
40			40
41	-	cret := xNewGLTexture(ContextVar.GoPointer(), IdVar, WidthVar, HeightVar, purego.NewCallback(DestroyVar), DataVar)	41	+	cret := xNewGLTexture(ContextVar.GoPointer(), IdVar, WidthVar, HeightVar, glib.NewCallback(DestroyVar), DataVar)
42			42
43		if cret == 0 {	43		if cret == 0 {
44		return nil	44		return nil

@@ -276,9 +276,9 @@ func (x GLTexture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancel
276		// Loads an icon asynchronously. To finish this function, see	276		// Loads an icon asynchronously. To finish this function, see
277		// g_loadable_icon_load_finish(). For the synchronous, blocking	277		// g_loadable_icon_load_finish(). For the synchronous, blocking
278		// version of this function, see g_loadable_icon_load().	278		// version of this function, see g_loadable_icon_load().
279	-	func (x GLTexture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	279	+	func (x GLTexture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
280			280
281	-	gio.XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	281	+	gio.XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
282			282
283		}	283		}
284			284

M v4/gdk/gdkmemorytexture.go +2 -2


@@ -262,9 +262,9 @@ func (x MemoryTexture) Load(SizeVar int, TypeVar string, CancellableVar gio.Ca
262		// Loads an icon asynchronously. To finish this function, see	262		// Loads an icon asynchronously. To finish this function, see
263		// g_loadable_icon_load_finish(). For the synchronous, blocking	263		// g_loadable_icon_load_finish(). For the synchronous, blocking
264		// version of this function, see g_loadable_icon_load().	264		// version of this function, see g_loadable_icon_load().
265	-	func (x MemoryTexture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	265	+	func (x MemoryTexture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
266			266
267	-	gio.XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	267	+	gio.XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
268			268
269		}	269		}
270			270

M v4/gdk/gdkmonitor.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted when the output represented by @monitor gets disconnected.
-func (x *Monitor) ConnectInvalidate(cb func(Monitor)) uint32 {
+func (x *Monitor) ConnectInvalidate(cb *func(Monitor)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "invalidate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Monitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "invalidate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "invalidate", cbRefPtr)
 }
 func init() {

M v4/gdk/gdkseat.go +46 -12

 package gdk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 }
 // Emitted when a new input device is related to this seat.
-func (x *Seat) ConnectDeviceAdded(cb func(Seat, uintptr)) uint32 {
+func (x *Seat) ConnectDeviceAdded(cb *func(Seat, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "device-added", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DeviceVarp uintptr) {
 		fa := Seat{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DeviceVarp)
+		cbFn(fa, DeviceVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "device-added", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "device-added", cbRefPtr)
 }
 // Emitted when an input device is removed (e.g. unplugged).
-func (x *Seat) ConnectDeviceRemoved(cb func(Seat, uintptr)) uint32 {
+func (x *Seat) ConnectDeviceRemoved(cb *func(Seat, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "device-removed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DeviceVarp uintptr) {
 		fa := Seat{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DeviceVarp)
+		cbFn(fa, DeviceVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "device-removed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "device-removed", cbRefPtr)
 }
 // Emitted whenever a new tool is made known to the seat.
 // [signal@Gdk.Device::tool-changed] signal accordingly.
 //
 // A same tool may be used by several devices.
-func (x *Seat) ConnectToolAdded(cb func(Seat, uintptr)) uint32 {
+func (x *Seat) ConnectToolAdded(cb *func(Seat, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "tool-added", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ToolVarp uintptr) {
 		fa := Seat{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ToolVarp)
+		cbFn(fa, ToolVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "tool-added", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "tool-added", cbRefPtr)
 }
 // Emitted whenever a tool is no longer known to this @seat.
-func (x *Seat) ConnectToolRemoved(cb func(Seat, uintptr)) uint32 {
+func (x *Seat) ConnectToolRemoved(cb *func(Seat, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "tool-removed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ToolVarp uintptr) {
 		fa := Seat{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ToolVarp)
+		cbFn(fa, ToolVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "tool-removed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "tool-removed", cbRefPtr)
 }
 func init() {

M v4/gdk/gdksurface.go +55 -15

 }
 // Emitted when @surface starts being present on the monitor.
-func (x *Surface) ConnectEnterMonitor(cb func(Surface, uintptr)) uint32 {
+func (x *Surface) ConnectEnterMonitor(cb *func(Surface, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "enter-monitor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MonitorVarp uintptr) {
 		fa := Surface{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MonitorVarp)
+		cbFn(fa, MonitorVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "enter-monitor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "enter-monitor", cbRefPtr)
 }
 // Emitted when GDK receives an input event for @surface.
-func (x *Surface) ConnectEvent(cb func(Surface, *Event) bool) uint32 {
+func (x *Surface) ConnectEvent(cb *func(Surface, *Event) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, EventVarp uintptr) bool {
 		fa := Surface{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, EventNewFromInternalPtr(EventVarp))
+		return cbFn(fa, EventNewFromInternalPtr(EventVarp))
 	}
-	return gobject.SignalConnect(x.GoPointer(), "event", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
 }
 // Emitted when the size of @surface is changed, or when relayout should
 //
 // Surface size is reported in ”application pixels”, not
 // ”device pixels” (see gdk_surface_get_scale_factor()).
-func (x *Surface) ConnectLayout(cb func(Surface, int, int)) uint32 {
+func (x *Surface) ConnectLayout(cb *func(Surface, int, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WidthVarp int, HeightVarp int) {
 		fa := Surface{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, WidthVarp, HeightVarp)
+		cbFn(fa, WidthVarp, HeightVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "layout", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
 }
 // Emitted when @surface stops being present on the monitor.
-func (x *Surface) ConnectLeaveMonitor(cb func(Surface, uintptr)) uint32 {
+func (x *Surface) ConnectLeaveMonitor(cb *func(Surface, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "leave-monitor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MonitorVarp uintptr) {
 		fa := Surface{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MonitorVarp)
+		cbFn(fa, MonitorVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "leave-monitor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "leave-monitor", cbRefPtr)
 }
 // Emitted when part of the surface needs to be redrawn.
-func (x *Surface) ConnectRender(cb func(Surface, uintptr) bool) uint32 {
+func (x *Surface) ConnectRender(cb *func(Surface, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, RegionVarp uintptr) bool {
 		fa := Surface{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, RegionVarp)
+		return cbFn(fa, RegionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "render", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
 }
 func init() {

M v4/gdk/gdktexture.go +2 -2


@@ -529,9 +529,9 @@ func (x Texture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancella
529		// Loads an icon asynchronously. To finish this function, see	529		// Loads an icon asynchronously. To finish this function, see
530		// g_loadable_icon_load_finish(). For the synchronous, blocking	530		// g_loadable_icon_load_finish(). For the synchronous, blocking
531		// version of this function, see g_loadable_icon_load().	531		// version of this function, see g_loadable_icon_load().
532	-	func (x Texture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	532	+	func (x Texture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
533			533
534	-	gio.XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	534	+	gio.XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
535			535
536		}	536		}
537			537

M v4/gdk/gdkvulkancontext.go +13 -3

 package gdk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/v4/gio"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 //
 // Usually this means that the swapchain had to be recreated,
 // for example in response to a change of the surface size.
-func (x *VulkanContext) ConnectImagesUpdated(cb func(VulkanContext)) uint32 {
+func (x *VulkanContext) ConnectImagesUpdated(cb *func(VulkanContext)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "images-updated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := VulkanContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "images-updated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "images-updated", cbRefPtr)
 }
 // Initializes the object implementing the interface.

M v4/gdkpixbuf/gdk-pixbuf-animation.go +2 -2


@@ -313,9 +313,9 @@ var xPixbufAnimationNewFromStreamAsync func(uintptr, uintptr, uintptr, uintptr)
313		// When the operation is finished, `callback` will be called in the main thread.	313		// When the operation is finished, `callback` will be called in the main thread.
314		// You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the	314		// You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the
315		// result of the operation.	315		// result of the operation.
316	-	func PixbufAnimationNewFromStreamAsync(StreamVar gio.InputStream, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	316	+	func PixbufAnimationNewFromStreamAsync(StreamVar gio.InputStream, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
317			317
318	-	xPixbufAnimationNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	318	+	xPixbufAnimationNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
319			319
320		}	320		}
321			321

M v4/gdkpixbuf/gdk-pixbuf-loader.go +44 -12

 // After this signal is emitted, applications can call
 // gdk_pixbuf_loader_get_pixbuf() to fetch the partially-loaded
 // pixbuf.
-func (x *PixbufLoader) ConnectAreaPrepared(cb func(PixbufLoader)) uint32 {
+func (x *PixbufLoader) ConnectAreaPrepared(cb *func(PixbufLoader)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "area-prepared", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := PixbufLoader{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "area-prepared", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "area-prepared", cbRefPtr)
 }
 // This signal is emitted when a significant area of the image being
 //
 // Applications can use this signal to know when to repaint
 // areas of an image that is being loaded.
-func (x *PixbufLoader) ConnectAreaUpdated(cb func(PixbufLoader, int, int, int, int)) uint32 {
+func (x *PixbufLoader) ConnectAreaUpdated(cb *func(PixbufLoader, int, int, int, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "area-updated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp int, YVarp int, WidthVarp int, HeightVarp int) {
 		fa := PixbufLoader{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp, WidthVarp, HeightVarp)
+		cbFn(fa, XVarp, YVarp, WidthVarp, HeightVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "area-updated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "area-updated", cbRefPtr)
 }
 // This signal is emitted when gdk_pixbuf_loader_close() is called.
 // It can be used by different parts of an application to receive
 // notification when an image loader is closed by the code that
 // drives it.
-func (x *PixbufLoader) ConnectClosed(cb func(PixbufLoader)) uint32 {
+func (x *PixbufLoader) ConnectClosed(cb *func(PixbufLoader)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := PixbufLoader{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "closed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
 }
 // This signal is emitted when the pixbuf loader has been fed the
 // Applications can call gdk_pixbuf_loader_set_size() in response
 // to this signal to set the desired size to which the image
 // should be scaled.
-func (x *PixbufLoader) ConnectSizePrepared(cb func(PixbufLoader, int, int)) uint32 {
+func (x *PixbufLoader) ConnectSizePrepared(cb *func(PixbufLoader, int, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "size-prepared", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WidthVarp int, HeightVarp int) {
 		fa := PixbufLoader{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, WidthVarp, HeightVarp)
+		cbFn(fa, WidthVarp, HeightVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "size-prepared", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "size-prepared", cbRefPtr)
 }
 func init() {

M v4/gdkpixbuf/gdk-pixbuf.go +18 -18


@@ -212,10 +212,10 @@ var xNewPixbufFromData func(uintptr, Colorspace, bool, int, int, int, int, uintp
212		// it is its responsibility to free the pixel array.	212		// it is its responsibility to free the pixel array.
213		//	213		//
214		// See also: [ctor@GdkPixbuf.Pixbuf.new_from_bytes]	214		// See also: [ctor@GdkPixbuf.Pixbuf.new_from_bytes]
215	-	func NewPixbufFromData(DataVar uintptr, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar PixbufDestroyNotify, DestroyFnDataVar uintptr) *Pixbuf {	215	+	func NewPixbufFromData(DataVar uintptr, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar PixbufDestroyNotify, DestroyFnDataVar uintptr) Pixbuf {
216		var cls *Pixbuf	216		var cls *Pixbuf
217			217
218	-	cret := xNewPixbufFromData(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar, purego.NewCallback(DestroyFnVar), DestroyFnDataVar)	218	+	cret := xNewPixbufFromData(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar, glib.NewCallback(DestroyFnVar), DestroyFnDataVar)
219			219
220		if cret == 0 {	220		if cret == 0 {
221		return nil	221		return nil

@@ -1138,9 +1138,9 @@ var xPixbufSaveToCallback func(uintptr, uintptr, uintptr, string, **glib.Error,
1138		// function generates.	1138		// function generates.
1139		//	1139		//
1140		// See [method@GdkPixbuf.Pixbuf.save] for more details.	1140		// See [method@GdkPixbuf.Pixbuf.save] for more details.
1141	-	func (x Pixbuf) SaveToCallback(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar *glib.Error, varArgs ...interface{}) bool {	1141	+	func (x Pixbuf) SaveToCallback(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar **glib.Error, varArgs ...interface{}) bool {
1142			1142
1143	-	cret := xPixbufSaveToCallback(x.GoPointer(), purego.NewCallback(SaveFuncVar), UserDataVar, TypeVar, ErrorVar, varArgs...)	1143	+	cret := xPixbufSaveToCallback(x.GoPointer(), glib.NewCallback(SaveFuncVar), UserDataVar, TypeVar, ErrorVar, varArgs...)
1144		return cret	1144		return cret
1145		}	1145		}
1146			1146

@@ -1154,10 +1154,10 @@ var xPixbufSaveToCallbackv func(uintptr, uintptr, uintptr, string, []string, []s
1154		// If @error is set, `FALSE` will be returned.	1154		// If @error is set, `FALSE` will be returned.
1155		//	1155		//
1156		// See [method@GdkPixbuf.Pixbuf.save_to_callback] for more details.	1156		// See [method@GdkPixbuf.Pixbuf.save_to_callback] for more details.
1157	-	func (x *Pixbuf) SaveToCallbackv(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {	1157	+	func (x Pixbuf) SaveToCallbackv(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {
1158		var cerr *glib.Error	1158		var cerr *glib.Error
1159			1159
1160	-	cret := xPixbufSaveToCallbackv(x.GoPointer(), purego.NewCallback(SaveFuncVar), UserDataVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)	1160	+	cret := xPixbufSaveToCallbackv(x.GoPointer(), glib.NewCallback(SaveFuncVar), UserDataVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)
1161		if cerr == nil {	1161		if cerr == nil {
1162		return cret, nil	1162		return cret, nil
1163		}	1163		}

@@ -1195,9 +1195,9 @@ var xPixbufSaveToStreamAsync func(uintptr, uintptr, string, uintptr, uintptr, ui
1195		//	1195		//
1196		// You can then call gdk_pixbuf_save_to_stream_finish() to get the result of	1196		// You can then call gdk_pixbuf_save_to_stream_finish() to get the result of
1197		// the operation.	1197		// the operation.
1198	-	func (x Pixbuf) SaveToStreamAsync(StreamVar gio.OutputStream, TypeVar string, CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr, varArgs ...interface{}) {	1198	+	func (x Pixbuf) SaveToStreamAsync(StreamVar gio.OutputStream, TypeVar string, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr, varArgs ...interface{}) {
1199			1199
1200	-	xPixbufSaveToStreamAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, varArgs...)	1200	+	xPixbufSaveToStreamAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, varArgs...)
1201			1201
1202		}	1202		}
1203			1203

@@ -1231,9 +1231,9 @@ var xPixbufSaveToStreamvAsync func(uintptr, uintptr, string, uintptr, uintptr, u
1231		//	1231		//
1232		// You can then call gdk_pixbuf_save_to_stream_finish() to get the result of	1232		// You can then call gdk_pixbuf_save_to_stream_finish() to get the result of
1233		// the operation.	1233		// the operation.
1234	-	func (x Pixbuf) SaveToStreamvAsync(StreamVar gio.OutputStream, TypeVar string, OptionKeysVar uintptr, OptionValuesVar uintptr, CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	1234	+	func (x Pixbuf) SaveToStreamvAsync(StreamVar gio.OutputStream, TypeVar string, OptionKeysVar uintptr, OptionValuesVar uintptr, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
1235			1235
1236	-	xPixbufSaveToStreamvAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, OptionKeysVar, OptionValuesVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1236	+	xPixbufSaveToStreamvAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, OptionKeysVar, OptionValuesVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1237			1237
1238		}	1238		}
1239			1239

@@ -1403,9 +1403,9 @@ func (x Pixbuf) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellab
1403		// Loads an icon asynchronously. To finish this function, see	1403		// Loads an icon asynchronously. To finish this function, see
1404		// g_loadable_icon_load_finish(). For the synchronous, blocking	1404		// g_loadable_icon_load_finish(). For the synchronous, blocking
1405		// version of this function, see g_loadable_icon_load().	1405		// version of this function, see g_loadable_icon_load().
1406	-	func (x Pixbuf) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	1406	+	func (x Pixbuf) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1407			1407
1408	-	gio.XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1408	+	gio.XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1409			1409
1410		}	1410		}
1411			1411

@@ -1461,9 +1461,9 @@ var xPixbufGetFileInfoAsync func(string, uintptr, uintptr, uintptr)
1461		// When the operation is finished, @callback will be called in the	1461		// When the operation is finished, @callback will be called in the
1462		// main thread. You can then call gdk_pixbuf_get_file_info_finish() to	1462		// main thread. You can then call gdk_pixbuf_get_file_info_finish() to
1463		// get the result of the operation.	1463		// get the result of the operation.
1464	-	func PixbufGetFileInfoAsync(FilenameVar string, CancellableVar *gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	1464	+	func PixbufGetFileInfoAsync(FilenameVar string, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
1465			1465
1466	-	xPixbufGetFileInfoAsync(FilenameVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1466	+	xPixbufGetFileInfoAsync(FilenameVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1467			1467
1468		}	1468		}
1469			1469

@@ -1528,9 +1528,9 @@ var xPixbufNewFromStreamAsync func(uintptr, uintptr, uintptr, uintptr)
1528		// When the operation is finished, @callback will be called in the main thread.	1528		// When the operation is finished, @callback will be called in the main thread.
1529		// You can then call gdk_pixbuf_new_from_stream_finish() to get the result of	1529		// You can then call gdk_pixbuf_new_from_stream_finish() to get the result of
1530		// the operation.	1530		// the operation.
1531	-	func PixbufNewFromStreamAsync(StreamVar gio.InputStream, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	1531	+	func PixbufNewFromStreamAsync(StreamVar gio.InputStream, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1532			1532
1533	-	xPixbufNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1533	+	xPixbufNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1534			1534
1535		}	1535		}
1536			1536

@@ -1543,9 +1543,9 @@ var xPixbufNewFromStreamAtScaleAsync func(uintptr, int, int, bool, uintptr, uint
1543		//	1543		//
1544		// When the operation is finished, @callback will be called in the main thread.	1544		// When the operation is finished, @callback will be called in the main thread.
1545		// You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.	1545		// You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
1546	-	func PixbufNewFromStreamAtScaleAsync(StreamVar gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	1546	+	func PixbufNewFromStreamAtScaleAsync(StreamVar gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1547			1547
1548	-	xPixbufNewFromStreamAtScaleAsync(StreamVar.GoPointer(), WidthVar, HeightVar, PreserveAspectRatioVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1548	+	xPixbufNewFromStreamAtScaleAsync(StreamVar.GoPointer(), WidthVar, HeightVar, PreserveAspectRatioVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1549			1549
1550		}	1550		}
1551			1551

M v4/gio/gappinfo.go +38 -14

 	GetSupportedTypes() []string
 	Launch(FilesVar *glib.List, ContextVar *AppLaunchContext) bool
 	LaunchUris(UrisVar *glib.List, ContextVar *AppLaunchContext) bool
-	LaunchUrisAsync(UrisVar *glib.List, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
+	LaunchUrisAsync(UrisVar *glib.List, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
 	LaunchUrisFinish(ResultVar AsyncResult) bool
 	RemoveSupportsType(ContentTypeVar string) bool
 	SetAsDefaultForExtension(ExtensionVar string) bool
 // waits for activation in case of D-Bus–activated applications and also provides
 // extended error information for sandboxed applications, see notes for
 // g_app_info_launch_default_for_uri_async().
-func (x *AppInfoBase) LaunchUrisAsync(UrisVar *glib.List, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *AppInfoBase) LaunchUrisAsync(UrisVar *glib.List, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGAppInfoLaunchUrisAsync(x.GoPointer(), UrisVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	XGAppInfoLaunchUrisAsync(x.GoPointer(), UrisVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // This is also useful if you want to be sure that the D-Bus–activated
 // applications are really started before termination and if you are interested
 // in receiving error information from their activation.
-func AppInfoLaunchDefaultForUriAsync(UriVar string, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func AppInfoLaunchDefaultForUriAsync(UriVar string, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xAppInfoLaunchDefaultForUriAsync(UriVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xAppInfoLaunchDefaultForUriAsync(UriVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // The #GAppLaunchContext::launch-failed signal is emitted when a #GAppInfo launch
 // fails. The startup notification id is provided, so that the launcher
 // can cancel the startup notification.
-func (x *AppLaunchContext) ConnectLaunchFailed(cb func(AppLaunchContext, string)) uint32 {
+func (x *AppLaunchContext) ConnectLaunchFailed(cb *func(AppLaunchContext, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "launch-failed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StartupNotifyIdVarp string) {
 		fa := AppLaunchContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StartupNotifyIdVarp)
+		cbFn(fa, StartupNotifyIdVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "launch-failed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "launch-failed", cbRefPtr)
 }
 // The #GAppLaunchContext::launch-started signal is emitted when a #GAppInfo is
 //
 // It is guaranteed that this signal is followed by either a #GAppLaunchContext::launched or
 // #GAppLaunchContext::launch-failed signal.
-func (x *AppLaunchContext) ConnectLaunchStarted(cb func(AppLaunchContext, uintptr, uintptr)) uint32 {
+func (x *AppLaunchContext) ConnectLaunchStarted(cb *func(AppLaunchContext, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "launch-started", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, InfoVarp uintptr, PlatformDataVarp uintptr) {
 		fa := AppLaunchContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, InfoVarp, PlatformDataVarp)
+		cbFn(fa, InfoVarp, PlatformDataVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "launch-started", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "launch-started", cbRefPtr)
 }
 // The #GAppLaunchContext::launched signal is emitted when a #GAppInfo is successfully
 // Since 2.72 the `pid` may be 0 if the process id wasn't known (for
 // example if the process was launched via D-Bus). The `pid` may not be
 // set at all in subsequent releases.
-func (x *AppLaunchContext) ConnectLaunched(cb func(AppLaunchContext, uintptr, uintptr)) uint32 {
+func (x *AppLaunchContext) ConnectLaunched(cb *func(AppLaunchContext, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "launched", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, InfoVarp uintptr, PlatformDataVarp uintptr) {
 		fa := AppLaunchContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, InfoVarp, PlatformDataVarp)
+		cbFn(fa, InfoVarp, PlatformDataVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "launched", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "launched", cbRefPtr)
 }
 func init() {

M v4/gio/gapplication.go +77 -21

 // The ::activate signal is emitted on the primary instance when an
 // activation occurs. See g_application_activate().
-func (x *Application) ConnectActivate(cb func(Application)) uint32 {
+func (x *Application) ConnectActivate(cb *func(Application)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // The ::command-line signal is emitted on the primary instance when
 // a commandline is not handled locally. See g_application_run() and
 // the #GApplicationCommandLine documentation for more information.
-func (x *Application) ConnectCommandLine(cb func(Application, uintptr) int) uint32 {
+func (x *Application) ConnectCommandLine(cb *func(Application, uintptr) int) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "command-line", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, CommandLineVarp uintptr) int {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, CommandLineVarp)
+		return cbFn(fa, CommandLineVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "command-line", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "command-line", cbRefPtr)
 }
 // The ::handle-local-options signal is emitted on the local instance
 // You can override local_command_line() if you need more powerful
 // capabilities than what is provided here, but this should not
 // normally be required.
-func (x *Application) ConnectHandleLocalOptions(cb func(Application, uintptr) int) uint32 {
+func (x *Application) ConnectHandleLocalOptions(cb *func(Application, uintptr) int) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "handle-local-options", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, OptionsVarp uintptr) int {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, OptionsVarp)
+		return cbFn(fa, OptionsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "handle-local-options", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "handle-local-options", cbRefPtr)
 }
 // The ::name-lost signal is emitted only on the registered primary instance
 // is using the %G_APPLICATION_ALLOW_REPLACEMENT flag.
 //
 // The default handler for this signal calls g_application_quit().
-func (x *Application) ConnectNameLost(cb func(Application) bool) uint32 {
+func (x *Application) ConnectNameLost(cb *func(Application) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "name-lost", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "name-lost", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "name-lost", cbRefPtr)
 }
 // The ::open signal is emitted on the primary instance when there are
 // files to open. See g_application_open() for more information.
-func (x *Application) ConnectOpen(cb func(Application, uintptr, int, string)) uint32 {
+func (x *Application) ConnectOpen(cb *func(Application, uintptr, int, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "open", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, FilesVarp uintptr, NFilesVarp int, HintVarp string) {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, FilesVarp, NFilesVarp, HintVarp)
+		cbFn(fa, FilesVarp, NFilesVarp, HintVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "open", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "open", cbRefPtr)
 }
 // The ::shutdown signal is emitted only on the registered primary instance
 // immediately after the main loop terminates.
-func (x *Application) ConnectShutdown(cb func(Application)) uint32 {
+func (x *Application) ConnectShutdown(cb *func(Application)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "shutdown", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "shutdown", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "shutdown", cbRefPtr)
 }
 // The ::startup signal is emitted on the primary instance immediately
 // after registration. See g_application_register().
-func (x *Application) ConnectStartup(cb func(Application)) uint32 {
+func (x *Application) ConnectStartup(cb *func(Application)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "startup", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "startup", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "startup", cbRefPtr)
 }
 // Emits the #GActionGroup::action-added signal on @action_group.

M v4/gio/gasyncinitable.go +5 -5


@@ -131,7 +131,7 @@ func (x *AsyncInitableIface) GoPointer() uintptr {
131		type AsyncInitable interface {	131		type AsyncInitable interface {
132		GoPointer() uintptr	132		GoPointer() uintptr
133		SetGoPointer(uintptr)	133		SetGoPointer(uintptr)
134	-	InitAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	134	+	InitAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
135		InitFinish(ResVar AsyncResult) bool	135		InitFinish(ResVar AsyncResult) bool
136		NewFinish(ResVar AsyncResult) *gobject.Object	136		NewFinish(ResVar AsyncResult) *gobject.Object
137		}	137		}

@@ -183,9 +183,9 @@ func (x *AsyncInitableBase) SetGoPointer(ptr uintptr) {
183		// in a thread, so if you want to support asynchronous initialization via	183		// in a thread, so if you want to support asynchronous initialization via
184		// threads, just implement the #GAsyncInitable interface without overriding	184		// threads, just implement the #GAsyncInitable interface without overriding
185		// any interface methods.	185		// any interface methods.
186	-	func (x AsyncInitableBase) InitAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	186	+	func (x AsyncInitableBase) InitAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
187			187
188	-	XGAsyncInitableInitAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	188	+	XGAsyncInitableInitAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
189			189
190		}	190		}
191			191

@@ -234,9 +234,9 @@ var xAsyncInitableNewvAsync func([]interface{}, uint, *gobject.Parameter, int, u
234		// When the initialization is finished, @callback will be called. You can	234		// When the initialization is finished, @callback will be called. You can
235		// then call g_async_initable_new_finish() to get the new object and check	235		// then call g_async_initable_new_finish() to get the new object and check
236		// for any errors.	236		// for any errors.
237	-	func AsyncInitableNewvAsync(ObjectTypeVar []interface{}, NParametersVar uint, ParametersVar gobject.Parameter, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	237	+	func AsyncInitableNewvAsync(ObjectTypeVar []interface{}, NParametersVar uint, ParametersVar gobject.Parameter, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
238			238
239	-	xAsyncInitableNewvAsync(ObjectTypeVar, NParametersVar, ParametersVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	239	+	xAsyncInitableNewvAsync(ObjectTypeVar, NParametersVar, ParametersVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
240			240
241		}	241		}
242			242

M v4/gio/gbufferedinputstream.go +2 -2


@@ -127,9 +127,9 @@ var xBufferedInputStreamFillAsync func(uintptr, int, int, uintptr, uintptr, uint
127		//	127		//
128		// If @count is -1 then the attempted read size is equal to the number	128		// If @count is -1 then the attempted read size is equal to the number
129		// of bytes that are required to fill the buffer.	129		// of bytes that are required to fill the buffer.
130	-	func (x BufferedInputStream) FillAsync(CountVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	130	+	func (x BufferedInputStream) FillAsync(CountVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
131			131
132	-	xBufferedInputStreamFillAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	132	+	xBufferedInputStreamFillAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
133			133
134		}	134		}
135			135

M v4/gio/gcancellable.go +13 -5

 // @callback is invoked.  This lifts a restriction in place for
 // earlier GLib versions which now makes it easier to write cleanup
 // code that unconditionally invokes e.g. g_cancellable_cancel().
-func (x *Cancellable) Connect(CallbackVar gobject.Callback, DataVar uintptr, DataDestroyFuncVar glib.DestroyNotify) uint32 {
+func (x *Cancellable) Connect(CallbackVar *gobject.Callback, DataVar uintptr, DataDestroyFuncVar *glib.DestroyNotify) uint32 {
-	cret := xCancellableConnect(x.GoPointer(), purego.NewCallback(CallbackVar), DataVar, purego.NewCallback(DataDestroyFuncVar))
+	cret := xCancellableConnect(x.GoPointer(), glib.NewCallback(CallbackVar), DataVar, glib.NewCallback(DataDestroyFuncVar))
 	return cret
 }
 // Note that the cancelled signal is emitted in the thread that
 // the user cancelled from, which may be the main thread. So, the
 // cancellable signal should not do something that can block.
-func (x *Cancellable) ConnectCancelled(cb func(Cancellable)) uint32 {
+func (x *Cancellable) ConnectCancelled(cb *func(Cancellable)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Cancellable{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cancelled", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
 }
 var xCancellableGetCurrent func() uintptr

M v4/gio/gdatainputstream.go +6 -6


@@ -171,9 +171,9 @@ var xDataInputStreamReadLineAsync func(uintptr, int, uintptr, uintptr, uintptr)
171		// When the operation is finished, @callback will be called. You	171		// When the operation is finished, @callback will be called. You
172		// can then call g_data_input_stream_read_line_finish() to get	172		// can then call g_data_input_stream_read_line_finish() to get
173		// the result of the operation.	173		// the result of the operation.
174	-	func (x DataInputStream) ReadLineAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	174	+	func (x DataInputStream) ReadLineAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
175			175
176	-	xDataInputStreamReadLineAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	176	+	xDataInputStreamReadLineAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
177			177
178		}	178		}
179			179

@@ -327,9 +327,9 @@ var xDataInputStreamReadUntilAsync func(uintptr, string, int, uintptr, uintptr,
327		// inconsistent with g_data_input_stream_read_until(). Both functions	327		// inconsistent with g_data_input_stream_read_until(). Both functions
328		// will be marked as deprecated in a future release. Use	328		// will be marked as deprecated in a future release. Use
329		// g_data_input_stream_read_upto_async() instead.	329		// g_data_input_stream_read_upto_async() instead.
330	-	func (x DataInputStream) ReadUntilAsync(StopCharsVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	330	+	func (x DataInputStream) ReadUntilAsync(StopCharsVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
331			331
332	-	xDataInputStreamReadUntilAsync(x.GoPointer(), StopCharsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	332	+	xDataInputStreamReadUntilAsync(x.GoPointer(), StopCharsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
333			333
334		}	334		}
335			335

@@ -389,9 +389,9 @@ var xDataInputStreamReadUptoAsync func(uintptr, string, int, int, uintptr, uintp
389		// When the operation is finished, @callback will be called. You	389		// When the operation is finished, @callback will be called. You
390		// can then call g_data_input_stream_read_upto_finish() to get	390		// can then call g_data_input_stream_read_upto_finish() to get
391		// the result of the operation.	391		// the result of the operation.
392	-	func (x DataInputStream) ReadUptoAsync(StopCharsVar string, StopCharsLenVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	392	+	func (x DataInputStream) ReadUptoAsync(StopCharsVar string, StopCharsLenVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
393			393
394	-	xDataInputStreamReadUptoAsync(x.GoPointer(), StopCharsVar, StopCharsLenVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	394	+	xDataInputStreamReadUptoAsync(x.GoPointer(), StopCharsVar, StopCharsLenVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
395			395
396		}	396		}
397			397

M v4/gio/gdbusaddress.go +2 -2


@@ -54,9 +54,9 @@ var xDbusAddressGetStream func(string, uintptr, uintptr, uintptr)
54		//	54		//
55		// This is an asynchronous failable function. See	55		// This is an asynchronous failable function. See
56		// g_dbus_address_get_stream_sync() for the synchronous version.	56		// g_dbus_address_get_stream_sync() for the synchronous version.
57	-	func DbusAddressGetStream(AddressVar string, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	57	+	func DbusAddressGetStream(AddressVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
58			58
59	-	xDbusAddressGetStream(AddressVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	59	+	xDbusAddressGetStream(AddressVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
60			60
61		}	61		}
62			62

M v4/gio/gdbusconnection.go +2 -2


@@ -209,9 +209,9 @@ var xBusGet func(BusType, uintptr, uintptr, uintptr)
209		//	209		//
210		// This is an asynchronous failable function. See g_bus_get_sync() for	210		// This is an asynchronous failable function. See g_bus_get_sync() for
211		// the synchronous version.	211		// the synchronous version.
212	-	func BusGet(BusTypeVar BusType, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	212	+	func BusGet(BusTypeVar BusType, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
213			213
214	-	xBusGet(BusTypeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	214	+	xBusGet(BusTypeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
215			215
216		}	216		}
217			217

M v4/gio/gdbusinterfaceskeleton.go +11 -3

 // flags set, no dedicated thread is ever used and the call will be
 // handled in the same thread as the object that @interface belongs
 // to was exported in.
-func (x *DBusInterfaceSkeleton) ConnectGAuthorizeMethod(cb func(DBusInterfaceSkeleton, uintptr) bool) uint32 {
+func (x *DBusInterfaceSkeleton) ConnectGAuthorizeMethod(cb *func(DBusInterfaceSkeleton, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "g-authorize-method", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, InvocationVarp uintptr) bool {
 		fa := DBusInterfaceSkeleton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, InvocationVarp)
+		return cbFn(fa, InvocationVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "g-authorize-method", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "g-authorize-method", cbRefPtr)
 }
 // Gets the #GDBusObject that @interface_ belongs to, if any.

M v4/gio/gdbusnameowning.go +4 -4


@@ -68,9 +68,9 @@ var xBusOwnName func(BusType, string, BusNameOwnerFlags, uintptr, uintptr, uintp
68		// to [own names][gdbus-owning-names] and export objects.	68		// to [own names][gdbus-owning-names] and export objects.
69		// Simply register objects to be exported in @bus_acquired_handler and	69		// Simply register objects to be exported in @bus_acquired_handler and
70		// unregister the objects (if any) in @name_lost_handler.	70		// unregister the objects (if any) in @name_lost_handler.
71	-	func BusOwnName(BusTypeVar BusType, NameVar string, FlagsVar BusNameOwnerFlags, BusAcquiredHandlerVar BusAcquiredCallback, NameAcquiredHandlerVar BusNameAcquiredCallback, NameLostHandlerVar BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {	71	+	func BusOwnName(BusTypeVar BusType, NameVar string, FlagsVar BusNameOwnerFlags, BusAcquiredHandlerVar BusAcquiredCallback, NameAcquiredHandlerVar BusNameAcquiredCallback, NameLostHandlerVar BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
72			72
73	-	cret := xBusOwnName(BusTypeVar, NameVar, FlagsVar, purego.NewCallback(BusAcquiredHandlerVar), purego.NewCallback(NameAcquiredHandlerVar), purego.NewCallback(NameLostHandlerVar), UserDataVar, purego.NewCallback(UserDataFreeFuncVar))	73	+	cret := xBusOwnName(BusTypeVar, NameVar, FlagsVar, glib.NewCallback(BusAcquiredHandlerVar), glib.NewCallback(NameAcquiredHandlerVar), glib.NewCallback(NameLostHandlerVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
74		return cret	74		return cret
75		}	75		}
76			76

@@ -78,9 +78,9 @@ var xBusOwnNameOnConnection func(uintptr, string, BusNameOwnerFlags, uintptr, ui
78			78
79		// Like g_bus_own_name() but takes a #GDBusConnection instead of a	79		// Like g_bus_own_name() but takes a #GDBusConnection instead of a
80		// #GBusType.	80		// #GBusType.
81	-	func BusOwnNameOnConnection(ConnectionVar *DBusConnection, NameVar string, FlagsVar BusNameOwnerFlags, NameAcquiredHandlerVar BusNameAcquiredCallback, NameLostHandlerVar BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {	81	+	func BusOwnNameOnConnection(ConnectionVar DBusConnection, NameVar string, FlagsVar BusNameOwnerFlags, NameAcquiredHandlerVar BusNameAcquiredCallback, NameLostHandlerVar BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
82			82
83	-	cret := xBusOwnNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, purego.NewCallback(NameAcquiredHandlerVar), purego.NewCallback(NameLostHandlerVar), UserDataVar, purego.NewCallback(UserDataFreeFuncVar))	83	+	cret := xBusOwnNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, glib.NewCallback(NameAcquiredHandlerVar), glib.NewCallback(NameLostHandlerVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
84		return cret	84		return cret
85		}	85		}
86			86

M v4/gio/gdbusnamewatching.go +4 -4


@@ -65,9 +65,9 @@ var xBusWatchName func(BusType, string, BusNameWatcherFlags, uintptr, uintptr, u
65		// Basically, the application should create object proxies in	65		// Basically, the application should create object proxies in
66		// @name_appeared_handler and destroy them again (if any) in	66		// @name_appeared_handler and destroy them again (if any) in
67		// @name_vanished_handler.	67		// @name_vanished_handler.
68	-	func BusWatchName(BusTypeVar BusType, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar BusNameAppearedCallback, NameVanishedHandlerVar BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {	68	+	func BusWatchName(BusTypeVar BusType, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar BusNameAppearedCallback, NameVanishedHandlerVar BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
69			69
70	-	cret := xBusWatchName(BusTypeVar, NameVar, FlagsVar, purego.NewCallback(NameAppearedHandlerVar), purego.NewCallback(NameVanishedHandlerVar), UserDataVar, purego.NewCallback(UserDataFreeFuncVar))	70	+	cret := xBusWatchName(BusTypeVar, NameVar, FlagsVar, glib.NewCallback(NameAppearedHandlerVar), glib.NewCallback(NameVanishedHandlerVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
71		return cret	71		return cret
72		}	72		}
73			73

@@ -75,9 +75,9 @@ var xBusWatchNameOnConnection func(uintptr, string, BusNameWatcherFlags, uintptr
75			75
76		// Like g_bus_watch_name() but takes a #GDBusConnection instead of a	76		// Like g_bus_watch_name() but takes a #GDBusConnection instead of a
77		// #GBusType.	77		// #GBusType.
78	-	func BusWatchNameOnConnection(ConnectionVar *DBusConnection, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar BusNameAppearedCallback, NameVanishedHandlerVar BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {	78	+	func BusWatchNameOnConnection(ConnectionVar DBusConnection, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar BusNameAppearedCallback, NameVanishedHandlerVar BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
79			79
80	-	cret := xBusWatchNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, purego.NewCallback(NameAppearedHandlerVar), purego.NewCallback(NameVanishedHandlerVar), UserDataVar, purego.NewCallback(UserDataFreeFuncVar))	80	+	cret := xBusWatchNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, glib.NewCallback(NameAppearedHandlerVar), glib.NewCallback(NameVanishedHandlerVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
81		return cret	81		return cret
82		}	82		}
83			83

M v4/gio/gdbusobjectmanagerclient.go +32 -16

 // This is a synchronous failable constructor - the calling thread is
 // blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
 // for the asynchronous version.
-func NewDBusObjectManagerClientForBusSync(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar *Cancellable) (*DBusObjectManagerClient, error) {
+func NewDBusObjectManagerClientForBusSync(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable) (*DBusObjectManagerClient, error) {
 	var cls *DBusObjectManagerClient
 	var cerr *glib.Error
-	cret := xNewDBusObjectManagerClientForBusSync(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, purego.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, purego.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
+	cret := xNewDBusObjectManagerClientForBusSync(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, glib.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
 	if cret == 0 {
 		return nil, cerr
 // This is a synchronous failable constructor - the calling thread is
 // blocked until a reply is received. See g_dbus_object_manager_client_new()
 // for the asynchronous version.
-func NewDBusObjectManagerClientSync(ConnectionVar *DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar *Cancellable) (*DBusObjectManagerClient, error) {
+func NewDBusObjectManagerClientSync(ConnectionVar *DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable) (*DBusObjectManagerClient, error) {
 	var cls *DBusObjectManagerClient
 	var cerr *glib.Error
-	cret := xNewDBusObjectManagerClientSync(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, purego.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, purego.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
+	cret := xNewDBusObjectManagerClientSync(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, glib.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
 	if cret == 0 {
 		return nil, cerr
 // This signal is emitted in the
 // [thread-default main context][g-main-context-push-thread-default]
 // that @manager was constructed in.
-func (x *DBusObjectManagerClient) ConnectInterfaceProxyPropertiesChanged(cb func(DBusObjectManagerClient, uintptr, uintptr, uintptr, uintptr)) uint32 {
+func (x *DBusObjectManagerClient) ConnectInterfaceProxyPropertiesChanged(cb *func(DBusObjectManagerClient, uintptr, uintptr, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "interface-proxy-properties-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectProxyVarp uintptr, InterfaceProxyVarp uintptr, ChangedPropertiesVarp uintptr, InvalidatedPropertiesVarp uintptr) {
 		fa := DBusObjectManagerClient{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ObjectProxyVarp, InterfaceProxyVarp, ChangedPropertiesVarp, InvalidatedPropertiesVarp)
+		cbFn(fa, ObjectProxyVarp, InterfaceProxyVarp, ChangedPropertiesVarp, InvalidatedPropertiesVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "interface-proxy-properties-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "interface-proxy-properties-changed", cbRefPtr)
 }
 // Emitted when a D-Bus signal is received on @interface_proxy.
 // This signal is emitted in the
 // [thread-default main context][g-main-context-push-thread-default]
 // that @manager was constructed in.
-func (x *DBusObjectManagerClient) ConnectInterfaceProxySignal(cb func(DBusObjectManagerClient, uintptr, uintptr, string, string, uintptr)) uint32 {
+func (x *DBusObjectManagerClient) ConnectInterfaceProxySignal(cb *func(DBusObjectManagerClient, uintptr, uintptr, string, string, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "interface-proxy-signal", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectProxyVarp uintptr, InterfaceProxyVarp uintptr, SenderNameVarp string, SignalNameVarp string, ParametersVarp uintptr) {
 		fa := DBusObjectManagerClient{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ObjectProxyVarp, InterfaceProxyVarp, SenderNameVarp, SignalNameVarp, ParametersVarp)
+		cbFn(fa, ObjectProxyVarp, InterfaceProxyVarp, SenderNameVarp, SignalNameVarp, ParametersVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "interface-proxy-signal", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "interface-proxy-signal", cbRefPtr)
 }
 // Starts asynchronous initialization of the object implementing the
 // in a thread, so if you want to support asynchronous initialization via
 // threads, just implement the #GAsyncInitable interface without overriding
 // any interface methods.
-func (x *DBusObjectManagerClient) InitAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusObjectManagerClient) InitAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGAsyncInitableInitAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	XGAsyncInitableInitAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // of the thread you are calling this method from. You can
 // then call g_dbus_object_manager_client_new_finish() to get the result. See
 // g_dbus_object_manager_client_new_sync() for the synchronous version.
-func DBusObjectManagerClientNew(ConnectionVar *DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func DBusObjectManagerClientNew(ConnectionVar *DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusObjectManagerClientNew(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, purego.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, purego.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusObjectManagerClientNew(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, glib.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // of the thread you are calling this method from. You can
 // then call g_dbus_object_manager_client_new_for_bus_finish() to get the result. See
 // g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
-func DBusObjectManagerClientNewForBus(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func DBusObjectManagerClientNewForBus(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusObjectManagerClientNewForBus(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, purego.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, purego.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusObjectManagerClientNewForBus(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, glib.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }

M v4/gio/gdbusobjectskeleton.go +11 -3

 // except that it is for the enclosing object.
 //
 // The default class handler just returns %TRUE.
-func (x *DBusObjectSkeleton) ConnectAuthorizeMethod(cb func(DBusObjectSkeleton, uintptr, uintptr) bool) uint32 {
+func (x *DBusObjectSkeleton) ConnectAuthorizeMethod(cb *func(DBusObjectSkeleton, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "authorize-method", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, InterfaceVarp uintptr, InvocationVarp uintptr) bool {
 		fa := DBusObjectSkeleton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, InterfaceVarp, InvocationVarp)
+		return cbFn(fa, InterfaceVarp, InvocationVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "authorize-method", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "authorize-method", cbRefPtr)
 }
 // Gets the D-Bus interface with name @interface_name associated with

M v4/gio/gdbusproxy.go +32 -16

 //
 // If @callback is %NULL then the D-Bus method call message will be sent with
 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
-func (x *DBusProxy) Call(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusProxy) Call(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusProxyCall(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusProxyCall(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
 //
 // This method is only available on UNIX.
-func (x *DBusProxy) CallWithUnixFdList(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusProxy) CallWithUnixFdList(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusProxyCallWithUnixFdList(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusProxyCallWithUnixFdList(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // This signal corresponds to the
 // `PropertiesChanged` D-Bus signal on the
 // `org.freedesktop.DBus.Properties` interface.
-func (x *DBusProxy) ConnectGPropertiesChanged(cb func(DBusProxy, uintptr, uintptr)) uint32 {
+func (x *DBusProxy) ConnectGPropertiesChanged(cb *func(DBusProxy, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "g-properties-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ChangedPropertiesVarp uintptr, InvalidatedPropertiesVarp uintptr) {
 		fa := DBusProxy{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ChangedPropertiesVarp, InvalidatedPropertiesVarp)
+		cbFn(fa, ChangedPropertiesVarp, InvalidatedPropertiesVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "g-properties-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "g-properties-changed", cbRefPtr)
 }
 // Emitted when a signal from the remote object and interface that @proxy is for, has been received.
 // Since 2.72 this signal supports detailed connections. You can connect to
 // the detailed signal `g-signal::x` in order to receive callbacks only when
 // signal `x` is received from the remote object.
-func (x *DBusProxy) ConnectGSignal(cb func(DBusProxy, string, string, uintptr)) uint32 {
+func (x *DBusProxy) ConnectGSignal(cb *func(DBusProxy, string, string, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "g-signal", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SenderNameVarp string, SignalNameVarp string, ParametersVarp uintptr) {
 		fa := DBusProxy{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SenderNameVarp, SignalNameVarp, ParametersVarp)
+		cbFn(fa, SenderNameVarp, SignalNameVarp, ParametersVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "g-signal", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "g-signal", cbRefPtr)
 }
 // Starts asynchronous initialization of the object implementing the
 // in a thread, so if you want to support asynchronous initialization via
 // threads, just implement the #GAsyncInitable interface without overriding
 // any interface methods.
-func (x *DBusProxy) InitAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusProxy) InitAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGAsyncInitableInitAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	XGAsyncInitableInitAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
 //
 // #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
-func DBusProxyNew(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func DBusProxyNew(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusProxyNew(ConnectionVar.GoPointer(), FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusProxyNew(ConnectionVar.GoPointer(), FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // Like g_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 //
 // #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
-func DBusProxyNewForBus(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func DBusProxyNewForBus(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusProxyNewForBus(BusTypeVar, FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusProxyNewForBus(BusTypeVar, FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }

M v4/gio/gdebugcontrollerdbus.go +11 -3

 // Signal handlers must not modify @invocation, or cause it to return a value.
 //
 // The default class handler just returns %TRUE.
-func (x *DebugControllerDBus) ConnectAuthorize(cb func(DebugControllerDBus, uintptr) bool) uint32 {
+func (x *DebugControllerDBus) ConnectAuthorize(cb *func(DebugControllerDBus, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "authorize", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, InvocationVarp uintptr) bool {
 		fa := DebugControllerDBus{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, InvocationVarp)
+		return cbFn(fa, InvocationVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "authorize", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "authorize", cbRefPtr)
 }
 // Get the value of #GDebugController:debug-enabled.

M v4/gio/gdesktopappinfo.go +6 -6


@@ -352,10 +352,10 @@ var xDesktopAppInfoLaunchUrisAsManager func(uintptr, *glib.List, uintptr, glib.S
352		// If application launching occurs via some other mechanism (eg: D-Bus	352		// If application launching occurs via some other mechanism (eg: D-Bus
353		// activation) then @spawn_flags, @user_setup, @user_setup_data,	353		// activation) then @spawn_flags, @user_setup, @user_setup_data,
354		// @pid_callback and @pid_callback_data are ignored.	354		// @pid_callback and @pid_callback_data are ignored.
355	-	func (x DesktopAppInfo) LaunchUrisAsManager(UrisVar glib.List, LaunchContextVar *AppLaunchContext, SpawnFlagsVar glib.SpawnFlags, UserSetupVar glib.SpawnChildSetupFunc, UserSetupDataVar uintptr, PidCallbackVar DesktopAppLaunchCallback, PidCallbackDataVar uintptr) (bool, error) {	355	+	func (x DesktopAppInfo) LaunchUrisAsManager(UrisVar glib.List, LaunchContextVar AppLaunchContext, SpawnFlagsVar glib.SpawnFlags, UserSetupVar glib.SpawnChildSetupFunc, UserSetupDataVar uintptr, PidCallbackVar *DesktopAppLaunchCallback, PidCallbackDataVar uintptr) (bool, error) {
356		var cerr *glib.Error	356		var cerr *glib.Error
357			357
358	-	cret := xDesktopAppInfoLaunchUrisAsManager(x.GoPointer(), UrisVar, LaunchContextVar.GoPointer(), SpawnFlagsVar, purego.NewCallback(UserSetupVar), UserSetupDataVar, purego.NewCallback(PidCallbackVar), PidCallbackDataVar, &cerr)	358	+	cret := xDesktopAppInfoLaunchUrisAsManager(x.GoPointer(), UrisVar, LaunchContextVar.GoPointer(), SpawnFlagsVar, glib.NewCallback(UserSetupVar), UserSetupDataVar, glib.NewCallback(PidCallbackVar), PidCallbackDataVar, &cerr)
359		if cerr == nil {	359		if cerr == nil {
360		return cret, nil	360		return cret, nil
361		}	361		}

@@ -371,10 +371,10 @@ var xDesktopAppInfoLaunchUrisAsManagerWithFds func(uintptr, *glib.List, uintptr,
371		//	371		//
372		// If application launching occurs via some non-spawn mechanism (e.g. D-Bus	372		// If application launching occurs via some non-spawn mechanism (e.g. D-Bus
373		// activation) then @stdin_fd, @stdout_fd and @stderr_fd are ignored.	373		// activation) then @stdin_fd, @stdout_fd and @stderr_fd are ignored.
374	-	func (x DesktopAppInfo) LaunchUrisAsManagerWithFds(UrisVar glib.List, LaunchContextVar *AppLaunchContext, SpawnFlagsVar glib.SpawnFlags, UserSetupVar glib.SpawnChildSetupFunc, UserSetupDataVar uintptr, PidCallbackVar DesktopAppLaunchCallback, PidCallbackDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {	374	+	func (x DesktopAppInfo) LaunchUrisAsManagerWithFds(UrisVar glib.List, LaunchContextVar AppLaunchContext, SpawnFlagsVar glib.SpawnFlags, UserSetupVar glib.SpawnChildSetupFunc, UserSetupDataVar uintptr, PidCallbackVar *DesktopAppLaunchCallback, PidCallbackDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {
375		var cerr *glib.Error	375		var cerr *glib.Error
376			376
377	-	cret := xDesktopAppInfoLaunchUrisAsManagerWithFds(x.GoPointer(), UrisVar, LaunchContextVar.GoPointer(), SpawnFlagsVar, purego.NewCallback(UserSetupVar), UserSetupDataVar, purego.NewCallback(PidCallbackVar), PidCallbackDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)	377	+	cret := xDesktopAppInfoLaunchUrisAsManagerWithFds(x.GoPointer(), UrisVar, LaunchContextVar.GoPointer(), SpawnFlagsVar, glib.NewCallback(UserSetupVar), UserSetupDataVar, glib.NewCallback(PidCallbackVar), PidCallbackDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)
378		if cerr == nil {	378		if cerr == nil {
379		return cret, nil	379		return cret, nil
380		}	380		}

@@ -609,9 +609,9 @@ func (x DesktopAppInfo) LaunchUris(UrisVar glib.List, ContextVar *AppLaunchCon
609		// waits for activation in case of D-Bus–activated applications and also provides	609		// waits for activation in case of D-Bus–activated applications and also provides
610		// extended error information for sandboxed applications, see notes for	610		// extended error information for sandboxed applications, see notes for
611		// g_app_info_launch_default_for_uri_async().	611		// g_app_info_launch_default_for_uri_async().
612	-	func (x DesktopAppInfo) LaunchUrisAsync(UrisVar glib.List, ContextVar AppLaunchContext, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	612	+	func (x DesktopAppInfo) LaunchUrisAsync(UrisVar glib.List, ContextVar AppLaunchContext, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
613			613
614	-	XGAppInfoLaunchUrisAsync(x.GoPointer(), UrisVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	614	+	XGAppInfoLaunchUrisAsync(x.GoPointer(), UrisVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
615			615
616		}	616		}
617			617

M v4/gio/gdrive.go +15 -15


@@ -52,9 +52,9 @@ type Drive interface {
52		CanStart() bool	52		CanStart() bool
53		CanStartDegraded() bool	53		CanStartDegraded() bool
54		CanStop() bool	54		CanStop() bool
55	-	Eject(FlagsVar MountUnmountFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	55	+	Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
56		EjectFinish(ResultVar AsyncResult) bool	56		EjectFinish(ResultVar AsyncResult) bool
57	-	EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	57	+	EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
58		EjectWithOperationFinish(ResultVar AsyncResult) bool	58		EjectWithOperationFinish(ResultVar AsyncResult) bool
59		EnumerateIdentifiers() []string	59		EnumerateIdentifiers() []string
60		GetIcon() *IconBase	60		GetIcon() *IconBase

@@ -69,11 +69,11 @@ type Drive interface {
69		IsMediaCheckAutomatic() bool	69		IsMediaCheckAutomatic() bool
70		IsMediaRemovable() bool	70		IsMediaRemovable() bool
71		IsRemovable() bool	71		IsRemovable() bool
72	-	PollForMedia(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	72	+	PollForMedia(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
73		PollForMediaFinish(ResultVar AsyncResult) bool	73		PollForMediaFinish(ResultVar AsyncResult) bool
74	-	Start(FlagsVar DriveStartFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	74	+	Start(FlagsVar DriveStartFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
75		StartFinish(ResultVar AsyncResult) bool	75		StartFinish(ResultVar AsyncResult) bool
76	-	Stop(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	76	+	Stop(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
77		StopFinish(ResultVar AsyncResult) bool	77		StopFinish(ResultVar AsyncResult) bool
78		}	78		}
79		type DriveBase struct {	79		type DriveBase struct {

@@ -128,9 +128,9 @@ func (x *DriveBase) CanStop() bool {
128		// When the operation is finished, @callback will be called.	128		// When the operation is finished, @callback will be called.
129		// You can then call g_drive_eject_finish() to obtain the	129		// You can then call g_drive_eject_finish() to obtain the
130		// result of the operation.	130		// result of the operation.
131	-	func (x DriveBase) Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	131	+	func (x DriveBase) Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
132			132
133	-	XGDriveEject(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	133	+	XGDriveEject(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
134			134
135		}	135		}
136			136

@@ -149,9 +149,9 @@ func (x *DriveBase) EjectFinish(ResultVar AsyncResult) (bool, error) {
149		// Ejects a drive. This is an asynchronous operation, and is	149		// Ejects a drive. This is an asynchronous operation, and is
150		// finished by calling g_drive_eject_with_operation_finish() with the @drive	150		// finished by calling g_drive_eject_with_operation_finish() with the @drive
151		// and #GAsyncResult data returned in the @callback.	151		// and #GAsyncResult data returned in the @callback.
152	-	func (x DriveBase) EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	152	+	func (x DriveBase) EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
153			153
154	-	XGDriveEjectWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	154	+	XGDriveEjectWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
155			155
156		}	156		}
157			157

@@ -288,9 +288,9 @@ func (x *DriveBase) IsRemovable() bool {
288		// When the operation is finished, @callback will be called.	288		// When the operation is finished, @callback will be called.
289		// You can then call g_drive_poll_for_media_finish() to obtain the	289		// You can then call g_drive_poll_for_media_finish() to obtain the
290		// result of the operation.	290		// result of the operation.
291	-	func (x DriveBase) PollForMedia(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	291	+	func (x DriveBase) PollForMedia(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
292			292
293	-	XGDrivePollForMedia(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	293	+	XGDrivePollForMedia(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
294			294
295		}	295		}
296			296

@@ -311,9 +311,9 @@ func (x *DriveBase) PollForMediaFinish(ResultVar AsyncResult) (bool, error) {
311		// When the operation is finished, @callback will be called.	311		// When the operation is finished, @callback will be called.
312		// You can then call g_drive_start_finish() to obtain the	312		// You can then call g_drive_start_finish() to obtain the
313		// result of the operation.	313		// result of the operation.
314	-	func (x DriveBase) Start(FlagsVar DriveStartFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	314	+	func (x DriveBase) Start(FlagsVar DriveStartFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
315			315
316	-	XGDriveStart(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	316	+	XGDriveStart(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
317			317
318		}	318		}
319			319

@@ -334,9 +334,9 @@ func (x *DriveBase) StartFinish(ResultVar AsyncResult) (bool, error) {
334		// When the operation is finished, @callback will be called.	334		// When the operation is finished, @callback will be called.
335		// You can then call g_drive_stop_finish() to obtain the	335		// You can then call g_drive_stop_finish() to obtain the
336		// result of the operation.	336		// result of the operation.
337	-	func (x DriveBase) Stop(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	337	+	func (x DriveBase) Stop(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
338			338
339	-	XGDriveStop(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	339	+	XGDriveStop(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
340			340
341		}	341		}
342			342

M v4/gio/gdtlsconnection.go +9 -9


@@ -42,7 +42,7 @@ type DtlsConnection interface {
42		GoPointer() uintptr	42		GoPointer() uintptr
43		SetGoPointer(uintptr)	43		SetGoPointer(uintptr)
44		Close(CancellableVar *Cancellable) bool	44		Close(CancellableVar *Cancellable) bool
45	-	CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	45	+	CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
46		CloseFinish(ResultVar AsyncResult) bool	46		CloseFinish(ResultVar AsyncResult) bool
47		EmitAcceptCertificate(PeerCertVar *TlsCertificate, ErrorsVar TlsCertificateFlags) bool	47		EmitAcceptCertificate(PeerCertVar *TlsCertificate, ErrorsVar TlsCertificateFlags) bool
48		GetCertificate() *TlsCertificate	48		GetCertificate() *TlsCertificate

@@ -57,7 +57,7 @@ type DtlsConnection interface {
57		GetRehandshakeMode() TlsRehandshakeMode	57		GetRehandshakeMode() TlsRehandshakeMode
58		GetRequireCloseNotify() bool	58		GetRequireCloseNotify() bool
59		Handshake(CancellableVar *Cancellable) bool	59		Handshake(CancellableVar *Cancellable) bool
60	-	HandshakeAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	60	+	HandshakeAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
61		HandshakeFinish(ResultVar AsyncResult) bool	61		HandshakeFinish(ResultVar AsyncResult) bool
62		SetAdvertisedProtocols(ProtocolsVar uintptr)	62		SetAdvertisedProtocols(ProtocolsVar uintptr)
63		SetCertificate(CertificateVar *TlsCertificate)	63		SetCertificate(CertificateVar *TlsCertificate)

@@ -66,7 +66,7 @@ type DtlsConnection interface {
66		SetRehandshakeMode(ModeVar TlsRehandshakeMode)	66		SetRehandshakeMode(ModeVar TlsRehandshakeMode)
67		SetRequireCloseNotify(RequireCloseNotifyVar bool)	67		SetRequireCloseNotify(RequireCloseNotifyVar bool)
68		Shutdown(ShutdownReadVar bool, ShutdownWriteVar bool, CancellableVar *Cancellable) bool	68		Shutdown(ShutdownReadVar bool, ShutdownWriteVar bool, CancellableVar *Cancellable) bool
69	-	ShutdownAsync(ShutdownReadVar bool, ShutdownWriteVar bool, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	69	+	ShutdownAsync(ShutdownReadVar bool, ShutdownWriteVar bool, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
70		ShutdownFinish(ResultVar AsyncResult) bool	70		ShutdownFinish(ResultVar AsyncResult) bool
71		}	71		}
72		type DtlsConnectionBase struct {	72		type DtlsConnectionBase struct {

@@ -113,9 +113,9 @@ func (x DtlsConnectionBase) Close(CancellableVar Cancellable) (bool, error) {
113			113
114		// Asynchronously close the DTLS connection. See g_dtls_connection_close() for	114		// Asynchronously close the DTLS connection. See g_dtls_connection_close() for
115		// more information.	115		// more information.
116	-	func (x DtlsConnectionBase) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	116	+	func (x DtlsConnectionBase) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
117			117
118	-	XGDtlsConnectionCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	118	+	XGDtlsConnectionCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
119			119
120		}	120		}
121			121

@@ -332,9 +332,9 @@ func (x DtlsConnectionBase) Handshake(CancellableVar Cancellable) (bool, error
332			332
333		// Asynchronously performs a TLS handshake on @conn. See	333		// Asynchronously performs a TLS handshake on @conn. See
334		// g_dtls_connection_handshake() for more information.	334		// g_dtls_connection_handshake() for more information.
335	-	func (x DtlsConnectionBase) HandshakeAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	335	+	func (x DtlsConnectionBase) HandshakeAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
336			336
337	-	XGDtlsConnectionHandshakeAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	337	+	XGDtlsConnectionHandshakeAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
338			338
339		}	339		}
340			340

@@ -490,9 +490,9 @@ func (x *DtlsConnectionBase) Shutdown(ShutdownReadVar bool, ShutdownWriteVar boo
490			490
491		// Asynchronously shut down part or all of the DTLS connection. See	491		// Asynchronously shut down part or all of the DTLS connection. See
492		// g_dtls_connection_shutdown() for more information.	492		// g_dtls_connection_shutdown() for more information.
493	-	func (x DtlsConnectionBase) ShutdownAsync(ShutdownReadVar bool, ShutdownWriteVar bool, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	493	+	func (x DtlsConnectionBase) ShutdownAsync(ShutdownReadVar bool, ShutdownWriteVar bool, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
494			494
495	-	XGDtlsConnectionShutdownAsync(x.GoPointer(), ShutdownReadVar, ShutdownWriteVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	495	+	XGDtlsConnectionShutdownAsync(x.GoPointer(), ShutdownReadVar, ShutdownWriteVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
496			496
497		}	497		}
498			498

M v4/gio/gfile.go +111 -111


@@ -106,33 +106,33 @@ type File interface {
106		GoPointer() uintptr	106		GoPointer() uintptr
107		SetGoPointer(uintptr)	107		SetGoPointer(uintptr)
108		AppendTo(FlagsVar FileCreateFlags, CancellableVar Cancellable) FileOutputStream	108		AppendTo(FlagsVar FileCreateFlags, CancellableVar Cancellable) FileOutputStream
109	-	AppendToAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	109	+	AppendToAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
110		AppendToFinish(ResVar AsyncResult) *FileOutputStream	110		AppendToFinish(ResVar AsyncResult) *FileOutputStream
111		BuildAttributeListForCopy(FlagsVar FileCopyFlags, CancellableVar *Cancellable) string	111		BuildAttributeListForCopy(FlagsVar FileCopyFlags, CancellableVar *Cancellable) string
112	-	Copy(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar *Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr) bool	112	+	Copy(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr) bool
113	-	CopyAsync(DestinationVar File, FlagsVar FileCopyFlags, IoPriorityVar int, CancellableVar *Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	113	+	CopyAsync(DestinationVar File, FlagsVar FileCopyFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
114		CopyAttributes(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar *Cancellable) bool	114		CopyAttributes(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar *Cancellable) bool
115		CopyFinish(ResVar AsyncResult) bool	115		CopyFinish(ResVar AsyncResult) bool
116		Create(FlagsVar FileCreateFlags, CancellableVar Cancellable) FileOutputStream	116		Create(FlagsVar FileCreateFlags, CancellableVar Cancellable) FileOutputStream
117	-	CreateAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	117	+	CreateAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
118		CreateFinish(ResVar AsyncResult) *FileOutputStream	118		CreateFinish(ResVar AsyncResult) *FileOutputStream
119		CreateReadwrite(FlagsVar FileCreateFlags, CancellableVar Cancellable) FileIOStream	119		CreateReadwrite(FlagsVar FileCreateFlags, CancellableVar Cancellable) FileIOStream
120	-	CreateReadwriteAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	120	+	CreateReadwriteAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
121		CreateReadwriteFinish(ResVar AsyncResult) *FileIOStream	121		CreateReadwriteFinish(ResVar AsyncResult) *FileIOStream
122		Delete(CancellableVar *Cancellable) bool	122		Delete(CancellableVar *Cancellable) bool
123	-	DeleteAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	123	+	DeleteAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
124		DeleteFinish(ResultVar AsyncResult) bool	124		DeleteFinish(ResultVar AsyncResult) bool
125		Dup() *FileBase	125		Dup() *FileBase
126	-	EjectMountable(FlagsVar MountUnmountFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	126	+	EjectMountable(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
127		EjectMountableFinish(ResultVar AsyncResult) bool	127		EjectMountableFinish(ResultVar AsyncResult) bool
128	-	EjectMountableWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	128	+	EjectMountableWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
129		EjectMountableWithOperationFinish(ResultVar AsyncResult) bool	129		EjectMountableWithOperationFinish(ResultVar AsyncResult) bool
130		EnumerateChildren(AttributesVar string, FlagsVar FileQueryInfoFlags, CancellableVar Cancellable) FileEnumerator	130		EnumerateChildren(AttributesVar string, FlagsVar FileQueryInfoFlags, CancellableVar Cancellable) FileEnumerator
131	-	EnumerateChildrenAsync(AttributesVar string, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	131	+	EnumerateChildrenAsync(AttributesVar string, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
132		EnumerateChildrenFinish(ResVar AsyncResult) *FileEnumerator	132		EnumerateChildrenFinish(ResVar AsyncResult) *FileEnumerator
133		Equal(File2Var File) bool	133		Equal(File2Var File) bool
134		FindEnclosingMount(CancellableVar Cancellable) MountBase	134		FindEnclosingMount(CancellableVar Cancellable) MountBase
135	-	FindEnclosingMountAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	135	+	FindEnclosingMountAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
136		FindEnclosingMountFinish(ResVar AsyncResult) *MountBase	136		FindEnclosingMountFinish(ResVar AsyncResult) *MountBase
137		GetBasename() string	137		GetBasename() string
138		GetChild(NameVar string) *FileBase	138		GetChild(NameVar string) *FileBase

@@ -149,62 +149,62 @@ type File interface {
149		Hash() uint	149		Hash() uint
150		IsNative() bool	150		IsNative() bool
151		LoadBytes(CancellableVar Cancellable, EtagOutVar string) glib.Bytes	151		LoadBytes(CancellableVar Cancellable, EtagOutVar string) glib.Bytes
152	-	LoadBytesAsync(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	152	+	LoadBytesAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
153		LoadBytesFinish(ResultVar AsyncResult, EtagOutVar string) *glib.Bytes	153		LoadBytesFinish(ResultVar AsyncResult, EtagOutVar string) *glib.Bytes
154		LoadContents(CancellableVar *Cancellable, ContentsVar []string, LengthVar uint, EtagOutVar string) bool	154		LoadContents(CancellableVar *Cancellable, ContentsVar []string, LengthVar uint, EtagOutVar string) bool
155	-	LoadContentsAsync(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	155	+	LoadContentsAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
156		LoadContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) bool	156		LoadContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) bool
157	-	LoadPartialContentsAsync(CancellableVar *Cancellable, ReadMoreCallbackVar FileReadMoreCallback, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	157	+	LoadPartialContentsAsync(CancellableVar Cancellable, ReadMoreCallbackVar FileReadMoreCallback, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
158		LoadPartialContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) bool	158		LoadPartialContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) bool
159		MakeDirectory(CancellableVar *Cancellable) bool	159		MakeDirectory(CancellableVar *Cancellable) bool
160	-	MakeDirectoryAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	160	+	MakeDirectoryAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
161		MakeDirectoryFinish(ResultVar AsyncResult) bool	161		MakeDirectoryFinish(ResultVar AsyncResult) bool
162		MakeDirectoryWithParents(CancellableVar *Cancellable) bool	162		MakeDirectoryWithParents(CancellableVar *Cancellable) bool
163		MakeSymbolicLink(SymlinkValueVar string, CancellableVar *Cancellable) bool	163		MakeSymbolicLink(SymlinkValueVar string, CancellableVar *Cancellable) bool
164	-	MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar *Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) bool	164	+	MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) bool
165	-	MeasureDiskUsageAsync(FlagsVar FileMeasureFlags, IoPriorityVar int, CancellableVar *Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	165	+	MeasureDiskUsageAsync(FlagsVar FileMeasureFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
166		MeasureDiskUsageFinish(ResultVar AsyncResult, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) bool	166		MeasureDiskUsageFinish(ResultVar AsyncResult, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) bool
167		Monitor(FlagsVar FileMonitorFlags, CancellableVar Cancellable) FileMonitor	167		Monitor(FlagsVar FileMonitorFlags, CancellableVar Cancellable) FileMonitor
168		MonitorDirectory(FlagsVar FileMonitorFlags, CancellableVar Cancellable) FileMonitor	168		MonitorDirectory(FlagsVar FileMonitorFlags, CancellableVar Cancellable) FileMonitor
169		MonitorFile(FlagsVar FileMonitorFlags, CancellableVar Cancellable) FileMonitor	169		MonitorFile(FlagsVar FileMonitorFlags, CancellableVar Cancellable) FileMonitor
170	-	MountEnclosingVolume(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	170	+	MountEnclosingVolume(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
171		MountEnclosingVolumeFinish(ResultVar AsyncResult) bool	171		MountEnclosingVolumeFinish(ResultVar AsyncResult) bool
172	-	MountMountable(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	172	+	MountMountable(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
173		MountMountableFinish(ResultVar AsyncResult) *FileBase	173		MountMountableFinish(ResultVar AsyncResult) *FileBase
174	-	Move(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar *Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr) bool	174	+	Move(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr) bool
175	-	MoveAsync(DestinationVar File, FlagsVar FileCopyFlags, IoPriorityVar int, CancellableVar *Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	175	+	MoveAsync(DestinationVar File, FlagsVar FileCopyFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
176		MoveFinish(ResultVar AsyncResult) bool	176		MoveFinish(ResultVar AsyncResult) bool
177		OpenReadwrite(CancellableVar Cancellable) FileIOStream	177		OpenReadwrite(CancellableVar Cancellable) FileIOStream
178	-	OpenReadwriteAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	178	+	OpenReadwriteAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
179		OpenReadwriteFinish(ResVar AsyncResult) *FileIOStream	179		OpenReadwriteFinish(ResVar AsyncResult) *FileIOStream
180		PeekPath() string	180		PeekPath() string
181	-	PollMountable(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	181	+	PollMountable(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
182		PollMountableFinish(ResultVar AsyncResult) bool	182		PollMountableFinish(ResultVar AsyncResult) bool
183		QueryDefaultHandler(CancellableVar Cancellable) AppInfoBase	183		QueryDefaultHandler(CancellableVar Cancellable) AppInfoBase
184	-	QueryDefaultHandlerAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	184	+	QueryDefaultHandlerAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
185		QueryDefaultHandlerFinish(ResultVar AsyncResult) *AppInfoBase	185		QueryDefaultHandlerFinish(ResultVar AsyncResult) *AppInfoBase
186		QueryExists(CancellableVar *Cancellable) bool	186		QueryExists(CancellableVar *Cancellable) bool
187		QueryFileType(FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) FileType	187		QueryFileType(FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) FileType
188		QueryFilesystemInfo(AttributesVar string, CancellableVar Cancellable) FileInfo	188		QueryFilesystemInfo(AttributesVar string, CancellableVar Cancellable) FileInfo
189	-	QueryFilesystemInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	189	+	QueryFilesystemInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
190		QueryFilesystemInfoFinish(ResVar AsyncResult) *FileInfo	190		QueryFilesystemInfoFinish(ResVar AsyncResult) *FileInfo
191		QueryInfo(AttributesVar string, FlagsVar FileQueryInfoFlags, CancellableVar Cancellable) FileInfo	191		QueryInfo(AttributesVar string, FlagsVar FileQueryInfoFlags, CancellableVar Cancellable) FileInfo
192	-	QueryInfoAsync(AttributesVar string, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	192	+	QueryInfoAsync(AttributesVar string, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
193		QueryInfoFinish(ResVar AsyncResult) *FileInfo	193		QueryInfoFinish(ResVar AsyncResult) *FileInfo
194		QuerySettableAttributes(CancellableVar Cancellable) FileAttributeInfoList	194		QuerySettableAttributes(CancellableVar Cancellable) FileAttributeInfoList
195		QueryWritableNamespaces(CancellableVar Cancellable) FileAttributeInfoList	195		QueryWritableNamespaces(CancellableVar Cancellable) FileAttributeInfoList
196		Read(CancellableVar Cancellable) FileInputStream	196		Read(CancellableVar Cancellable) FileInputStream
197	-	ReadAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	197	+	ReadAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
198		ReadFinish(ResVar AsyncResult) *FileInputStream	198		ReadFinish(ResVar AsyncResult) *FileInputStream
199		Replace(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable) FileOutputStream	199		Replace(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable) FileOutputStream
200	-	ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	200	+	ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
201		ReplaceContents(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar string, CancellableVar *Cancellable) bool	201		ReplaceContents(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar string, CancellableVar *Cancellable) bool
202	-	ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	202	+	ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
203	-	ReplaceContentsBytesAsync(ContentsVar glib.Bytes, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	203	+	ReplaceContentsBytesAsync(ContentsVar glib.Bytes, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
204		ReplaceContentsFinish(ResVar AsyncResult, NewEtagVar string) bool	204		ReplaceContentsFinish(ResVar AsyncResult, NewEtagVar string) bool
205		ReplaceFinish(ResVar AsyncResult) *FileOutputStream	205		ReplaceFinish(ResVar AsyncResult) *FileOutputStream
206		ReplaceReadwrite(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable) FileIOStream	206		ReplaceReadwrite(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable) FileIOStream
207	-	ReplaceReadwriteAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	207	+	ReplaceReadwriteAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
208		ReplaceReadwriteFinish(ResVar AsyncResult) *FileIOStream	208		ReplaceReadwriteFinish(ResVar AsyncResult) *FileIOStream
209		ResolveRelativePath(RelativePathVar string) *FileBase	209		ResolveRelativePath(RelativePathVar string) *FileBase
210		SetAttribute(AttributeVar string, TypeVar FileAttributeType, ValuePVar uintptr, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) bool	210		SetAttribute(AttributeVar string, TypeVar FileAttributeType, ValuePVar uintptr, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) bool

@@ -214,23 +214,23 @@ type File interface {
214		SetAttributeString(AttributeVar string, ValueVar string, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) bool	214		SetAttributeString(AttributeVar string, ValueVar string, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) bool
215		SetAttributeUint32(AttributeVar string, ValueVar uint32, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) bool	215		SetAttributeUint32(AttributeVar string, ValueVar uint32, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) bool
216		SetAttributeUint64(AttributeVar string, ValueVar uint64, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) bool	216		SetAttributeUint64(AttributeVar string, ValueVar uint64, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) bool
217	-	SetAttributesAsync(InfoVar FileInfo, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	217	+	SetAttributesAsync(InfoVar FileInfo, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
218		SetAttributesFinish(ResultVar AsyncResult, InfoVar **FileInfo) bool	218		SetAttributesFinish(ResultVar AsyncResult, InfoVar **FileInfo) bool
219		SetAttributesFromInfo(InfoVar FileInfo, FlagsVar FileQueryInfoFlags, CancellableVar Cancellable) bool	219		SetAttributesFromInfo(InfoVar FileInfo, FlagsVar FileQueryInfoFlags, CancellableVar Cancellable) bool
220		SetDisplayName(DisplayNameVar string, CancellableVar Cancellable) FileBase	220		SetDisplayName(DisplayNameVar string, CancellableVar Cancellable) FileBase
221	-	SetDisplayNameAsync(DisplayNameVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	221	+	SetDisplayNameAsync(DisplayNameVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
222		SetDisplayNameFinish(ResVar AsyncResult) *FileBase	222		SetDisplayNameFinish(ResVar AsyncResult) *FileBase
223	-	StartMountable(FlagsVar DriveStartFlags, StartOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	223	+	StartMountable(FlagsVar DriveStartFlags, StartOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
224		StartMountableFinish(ResultVar AsyncResult) bool	224		StartMountableFinish(ResultVar AsyncResult) bool
225	-	StopMountable(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	225	+	StopMountable(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
226		StopMountableFinish(ResultVar AsyncResult) bool	226		StopMountableFinish(ResultVar AsyncResult) bool
227		SupportsThreadContexts() bool	227		SupportsThreadContexts() bool
228		Trash(CancellableVar *Cancellable) bool	228		Trash(CancellableVar *Cancellable) bool
229	-	TrashAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	229	+	TrashAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
230		TrashFinish(ResultVar AsyncResult) bool	230		TrashFinish(ResultVar AsyncResult) bool
231	-	UnmountMountable(FlagsVar MountUnmountFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	231	+	UnmountMountable(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
232		UnmountMountableFinish(ResultVar AsyncResult) bool	232		UnmountMountableFinish(ResultVar AsyncResult) bool
233	-	UnmountMountableWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	233	+	UnmountMountableWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
234		UnmountMountableWithOperationFinish(ResultVar AsyncResult) bool	234		UnmountMountableWithOperationFinish(ResultVar AsyncResult) bool
235		}	235		}
236		type FileBase struct {	236		type FileBase struct {

@@ -288,9 +288,9 @@ func (x FileBase) AppendTo(FlagsVar FileCreateFlags, CancellableVar Cancellabl
288		// When the operation is finished, @callback will be called.	288		// When the operation is finished, @callback will be called.
289		// You can then call g_file_append_to_finish() to get the result	289		// You can then call g_file_append_to_finish() to get the result
290		// of the operation.	290		// of the operation.
291	-	func (x FileBase) AppendToAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	291	+	func (x FileBase) AppendToAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
292			292
293	-	XGFileAppendToAsync(x.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	293	+	XGFileAppendToAsync(x.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
294			294
295		}	295		}
296			296

@@ -374,10 +374,10 @@ func (x *FileBase) BuildAttributeListForCopy(FlagsVar FileCopyFlags, Cancellable
374		//	374		//
375		// If you are interested in copying the #GFile object itself (not the on-disk	375		// If you are interested in copying the #GFile object itself (not the on-disk
376		// file), see g_file_dup().	376		// file), see g_file_dup().
377	-	func (x FileBase) Copy(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr) (bool, error) {	377	+	func (x FileBase) Copy(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar Cancellable, ProgressCallbackVar *FileProgressCallback, ProgressCallbackDataVar uintptr) (bool, error) {
378		var cerr *glib.Error	378		var cerr *glib.Error
379			379
380	-	cret := XGFileCopy(x.GoPointer(), DestinationVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(ProgressCallbackVar), ProgressCallbackDataVar, &cerr)	380	+	cret := XGFileCopy(x.GoPointer(), DestinationVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(ProgressCallbackVar), ProgressCallbackDataVar, &cerr)
381		if cerr == nil {	381		if cerr == nil {
382		return cret, nil	382		return cret, nil
383		}	383		}

@@ -395,9 +395,9 @@ func (x *FileBase) Copy(DestinationVar File, FlagsVar FileCopyFlags, Cancellable
395		//	395		//
396		// When the operation is finished, @callback will be called. You can then call	396		// When the operation is finished, @callback will be called. You can then call
397		// g_file_copy_finish() to get the result of the operation.	397		// g_file_copy_finish() to get the result of the operation.
398	-	func (x FileBase) CopyAsync(DestinationVar File, FlagsVar FileCopyFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	398	+	func (x FileBase) CopyAsync(DestinationVar File, FlagsVar FileCopyFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
399			399
400	-	XGFileCopyAsync(x.GoPointer(), DestinationVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(ProgressCallbackVar), ProgressCallbackDataVar, purego.NewCallback(CallbackVar), UserDataVar)	400	+	XGFileCopyAsync(x.GoPointer(), DestinationVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(ProgressCallbackVar), ProgressCallbackDataVar, glib.NewCallback(CallbackVar), UserDataVar)
401			401
402		}	402		}
403			403

@@ -478,9 +478,9 @@ func (x FileBase) Create(FlagsVar FileCreateFlags, CancellableVar Cancellable)
478		// When the operation is finished, @callback will be called.	478		// When the operation is finished, @callback will be called.
479		// You can then call g_file_create_finish() to get the result	479		// You can then call g_file_create_finish() to get the result
480		// of the operation.	480		// of the operation.
481	-	func (x FileBase) CreateAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	481	+	func (x FileBase) CreateAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
482			482
483	-	XGFileCreateAsync(x.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	483	+	XGFileCreateAsync(x.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
484			484
485		}	485		}
486			486

@@ -554,9 +554,9 @@ func (x FileBase) CreateReadwrite(FlagsVar FileCreateFlags, CancellableVar Can
554		// When the operation is finished, @callback will be called.	554		// When the operation is finished, @callback will be called.
555		// You can then call g_file_create_readwrite_finish() to get	555		// You can then call g_file_create_readwrite_finish() to get
556		// the result of the operation.	556		// the result of the operation.
557	-	func (x FileBase) CreateReadwriteAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	557	+	func (x FileBase) CreateReadwriteAsync(FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
558			558
559	-	XGFileCreateReadwriteAsync(x.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	559	+	XGFileCreateReadwriteAsync(x.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
560			560
561		}	561		}
562			562

@@ -617,9 +617,9 @@ func (x FileBase) Delete(CancellableVar Cancellable) (bool, error) {
617		// Asynchronously delete a file. If the @file is a directory, it will	617		// Asynchronously delete a file. If the @file is a directory, it will
618		// only be deleted if it is empty. This has the same semantics as	618		// only be deleted if it is empty. This has the same semantics as
619		// g_unlink().	619		// g_unlink().
620	-	func (x FileBase) DeleteAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	620	+	func (x FileBase) DeleteAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
621			621
622	-	XGFileDeleteAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	622	+	XGFileDeleteAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
623			623
624		}	624		}
625			625

@@ -666,9 +666,9 @@ func (x FileBase) Dup() FileBase {
666		// If @cancellable is not %NULL, then the operation can be cancelled by	666		// If @cancellable is not %NULL, then the operation can be cancelled by
667		// triggering the cancellable object from another thread. If the operation	667		// triggering the cancellable object from another thread. If the operation
668		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.	668		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
669	-	func (x FileBase) EjectMountable(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	669	+	func (x FileBase) EjectMountable(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
670			670
671	-	XGFileEjectMountable(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	671	+	XGFileEjectMountable(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
672			672
673		}	673		}
674			674

@@ -693,9 +693,9 @@ func (x *FileBase) EjectMountableFinish(ResultVar AsyncResult) (bool, error) {
693		// If @cancellable is not %NULL, then the operation can be cancelled by	693		// If @cancellable is not %NULL, then the operation can be cancelled by
694		// triggering the cancellable object from another thread. If the operation	694		// triggering the cancellable object from another thread. If the operation
695		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.	695		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
696	-	func (x FileBase) EjectMountableWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	696	+	func (x FileBase) EjectMountableWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
697			697
698	-	XGFileEjectMountableWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	698	+	XGFileEjectMountableWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
699			699
700		}	700		}
701			701

@@ -765,9 +765,9 @@ func (x *FileBase) EnumerateChildren(AttributesVar string, FlagsVar FileQueryInf
765		// When the operation is finished, @callback will be called. You can	765		// When the operation is finished, @callback will be called. You can
766		// then call g_file_enumerate_children_finish() to get the result of	766		// then call g_file_enumerate_children_finish() to get the result of
767		// the operation.	767		// the operation.
768	-	func (x FileBase) EnumerateChildrenAsync(AttributesVar string, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	768	+	func (x FileBase) EnumerateChildrenAsync(AttributesVar string, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
769			769
770	-	XGFileEnumerateChildrenAsync(x.GoPointer(), AttributesVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	770	+	XGFileEnumerateChildrenAsync(x.GoPointer(), AttributesVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
771			771
772		}	772		}
773			773

@@ -839,9 +839,9 @@ func (x FileBase) FindEnclosingMount(CancellableVar Cancellable) (*MountBase,
839		// When the operation is finished, @callback will be called.	839		// When the operation is finished, @callback will be called.
840		// You can then call g_file_find_enclosing_mount_finish() to	840		// You can then call g_file_find_enclosing_mount_finish() to
841		// get the result of the operation.	841		// get the result of the operation.
842	-	func (x FileBase) FindEnclosingMountAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	842	+	func (x FileBase) FindEnclosingMountAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
843			843
844	-	XGFileFindEnclosingMountAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	844	+	XGFileFindEnclosingMountAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
845			845
846		}	846		}
847			847

@@ -1111,9 +1111,9 @@ func (x FileBase) LoadBytes(CancellableVar Cancellable, EtagOutVar string) (*g
1111		// asynchronous operation.	1111		// asynchronous operation.
1112		//	1112		//
1113		// See g_file_load_bytes() for more information.	1113		// See g_file_load_bytes() for more information.
1114	-	func (x FileBase) LoadBytesAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1114	+	func (x FileBase) LoadBytesAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1115			1115
1116	-	XGFileLoadBytesAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1116	+	XGFileLoadBytesAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1117			1117
1118		}	1118		}
1119			1119

@@ -1169,9 +1169,9 @@ func (x FileBase) LoadContents(CancellableVar Cancellable, ContentsVar []strin
1169		// If @cancellable is not %NULL, then the operation can be cancelled by	1169		// If @cancellable is not %NULL, then the operation can be cancelled by
1170		// triggering the cancellable object from another thread. If the operation	1170		// triggering the cancellable object from another thread. If the operation
1171		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.	1171		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1172	-	func (x FileBase) LoadContentsAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1172	+	func (x FileBase) LoadContentsAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1173			1173
1174	-	XGFileLoadContentsAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1174	+	XGFileLoadContentsAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1175			1175
1176		}	1176		}
1177			1177

@@ -1202,9 +1202,9 @@ func (x *FileBase) LoadContentsFinish(ResVar AsyncResult, ContentsVar []string,
1202		// If @cancellable is not %NULL, then the operation can be cancelled by	1202		// If @cancellable is not %NULL, then the operation can be cancelled by
1203		// triggering the cancellable object from another thread. If the operation	1203		// triggering the cancellable object from another thread. If the operation
1204		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.	1204		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1205	-	func (x FileBase) LoadPartialContentsAsync(CancellableVar Cancellable, ReadMoreCallbackVar FileReadMoreCallback, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1205	+	func (x FileBase) LoadPartialContentsAsync(CancellableVar Cancellable, ReadMoreCallbackVar FileReadMoreCallback, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
1206			1206
1207	-	XGFileLoadPartialContentsAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(ReadMoreCallbackVar), purego.NewCallback(CallbackVar), UserDataVar)	1207	+	XGFileLoadPartialContentsAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(ReadMoreCallbackVar), glib.NewCallback(CallbackVar), UserDataVar)
1208			1208
1209		}	1209		}
1210			1210

@@ -1250,9 +1250,9 @@ func (x FileBase) MakeDirectory(CancellableVar Cancellable) (bool, error) {
1250		}	1250		}
1251			1251
1252		// Asynchronously creates a directory.	1252		// Asynchronously creates a directory.
1253	-	func (x FileBase) MakeDirectoryAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1253	+	func (x FileBase) MakeDirectoryAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1254			1254
1255	-	XGFileMakeDirectoryAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1255	+	XGFileMakeDirectoryAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1256			1256
1257		}	1257		}
1258			1258

@@ -1328,10 +1328,10 @@ func (x FileBase) MakeSymbolicLink(SymlinkValueVar string, CancellableVar Canc
1328		// periodic progress updates while scanning. See the documentation for	1328		// periodic progress updates while scanning. See the documentation for
1329		// #GFileMeasureProgressCallback for information about when and how the	1329		// #GFileMeasureProgressCallback for information about when and how the
1330		// callback will be invoked.	1330		// callback will be invoked.
1331	-	func (x FileBase) MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) (bool, error) {	1331	+	func (x FileBase) MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar *FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) (bool, error) {
1332		var cerr *glib.Error	1332		var cerr *glib.Error
1333			1333
1334	-	cret := XGFileMeasureDiskUsage(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(ProgressCallbackVar), ProgressDataVar, DiskUsageVar, NumDirsVar, NumFilesVar, &cerr)	1334	+	cret := XGFileMeasureDiskUsage(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(ProgressCallbackVar), ProgressDataVar, DiskUsageVar, NumDirsVar, NumFilesVar, &cerr)
1335		if cerr == nil {	1335		if cerr == nil {
1336		return cret, nil	1336		return cret, nil
1337		}	1337		}

@@ -1343,9 +1343,9 @@ func (x FileBase) MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar C
1343		//	1343		//
1344		// This is the asynchronous version of g_file_measure_disk_usage(). See	1344		// This is the asynchronous version of g_file_measure_disk_usage(). See
1345		// there for more information.	1345		// there for more information.
1346	-	func (x FileBase) MeasureDiskUsageAsync(FlagsVar FileMeasureFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1346	+	func (x FileBase) MeasureDiskUsageAsync(FlagsVar FileMeasureFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
1347			1347
1348	-	XGFileMeasureDiskUsageAsync(x.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(ProgressCallbackVar), ProgressDataVar, purego.NewCallback(CallbackVar), UserDataVar)	1348	+	XGFileMeasureDiskUsageAsync(x.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(ProgressCallbackVar), ProgressDataVar, glib.NewCallback(CallbackVar), UserDataVar)
1349			1349
1350		}	1350		}
1351			1351

@@ -1459,9 +1459,9 @@ func (x FileBase) MonitorFile(FlagsVar FileMonitorFlags, CancellableVar Cancel
1459		// If @cancellable is not %NULL, then the operation can be cancelled by	1459		// If @cancellable is not %NULL, then the operation can be cancelled by
1460		// triggering the cancellable object from another thread. If the operation	1460		// triggering the cancellable object from another thread. If the operation
1461		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.	1461		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
1462	-	func (x FileBase) MountEnclosingVolume(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1462	+	func (x FileBase) MountEnclosingVolume(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
1463			1463
1464	-	XGFileMountEnclosingVolume(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1464	+	XGFileMountEnclosingVolume(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1465			1465
1466		}	1466		}
1467			1467

@@ -1488,9 +1488,9 @@ func (x *FileBase) MountEnclosingVolumeFinish(ResultVar AsyncResult) (bool, erro
1488		// When the operation is finished, @callback will be called.	1488		// When the operation is finished, @callback will be called.
1489		// You can then call g_file_mount_mountable_finish() to get	1489		// You can then call g_file_mount_mountable_finish() to get
1490		// the result of the operation.	1490		// the result of the operation.
1491	-	func (x FileBase) MountMountable(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1491	+	func (x FileBase) MountMountable(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
1492			1492
1493	-	XGFileMountMountable(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1493	+	XGFileMountMountable(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1494			1494
1495		}	1495		}
1496			1496

@@ -1549,10 +1549,10 @@ func (x FileBase) MountMountableFinish(ResultVar AsyncResult) (FileBase, error
1549		// %G_FILE_COPY_OVERWRITE is specified and the target is a file, then	1549		// %G_FILE_COPY_OVERWRITE is specified and the target is a file, then
1550		// the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native	1550		// the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native
1551		// move operation isn't available).	1551		// move operation isn't available).
1552	-	func (x FileBase) Move(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr) (bool, error) {	1552	+	func (x FileBase) Move(DestinationVar File, FlagsVar FileCopyFlags, CancellableVar Cancellable, ProgressCallbackVar *FileProgressCallback, ProgressCallbackDataVar uintptr) (bool, error) {
1553		var cerr *glib.Error	1553		var cerr *glib.Error
1554			1554
1555	-	cret := XGFileMove(x.GoPointer(), DestinationVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(ProgressCallbackVar), ProgressCallbackDataVar, &cerr)	1555	+	cret := XGFileMove(x.GoPointer(), DestinationVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(ProgressCallbackVar), ProgressCallbackDataVar, &cerr)
1556		if cerr == nil {	1556		if cerr == nil {
1557		return cret, nil	1557		return cret, nil
1558		}	1558		}

@@ -1569,9 +1569,9 @@ func (x *FileBase) Move(DestinationVar File, FlagsVar FileCopyFlags, Cancellable
1569		//	1569		//
1570		// When the operation is finished, @callback will be called. You can then call	1570		// When the operation is finished, @callback will be called. You can then call
1571		// g_file_move_finish() to get the result of the operation.	1571		// g_file_move_finish() to get the result of the operation.
1572	-	func (x FileBase) MoveAsync(DestinationVar File, FlagsVar FileCopyFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1572	+	func (x FileBase) MoveAsync(DestinationVar File, FlagsVar FileCopyFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileProgressCallback, ProgressCallbackDataVar uintptr, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
1573			1573
1574	-	XGFileMoveAsync(x.GoPointer(), DestinationVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(ProgressCallbackVar), ProgressCallbackDataVar, purego.NewCallback(CallbackVar), UserDataVar)	1574	+	XGFileMoveAsync(x.GoPointer(), DestinationVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(ProgressCallbackVar), ProgressCallbackDataVar, glib.NewCallback(CallbackVar), UserDataVar)
1575			1575
1576		}	1576		}
1577			1577

@@ -1630,9 +1630,9 @@ func (x FileBase) OpenReadwrite(CancellableVar Cancellable) (*FileIOStream, er
1630		// When the operation is finished, @callback will be called.	1630		// When the operation is finished, @callback will be called.
1631		// You can then call g_file_open_readwrite_finish() to get	1631		// You can then call g_file_open_readwrite_finish() to get
1632		// the result of the operation.	1632		// the result of the operation.
1633	-	func (x FileBase) OpenReadwriteAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1633	+	func (x FileBase) OpenReadwriteAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1634			1634
1635	-	XGFileOpenReadwriteAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1635	+	XGFileOpenReadwriteAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1636			1636
1637		}	1637		}
1638			1638

@@ -1678,9 +1678,9 @@ func (x *FileBase) PeekPath() string {
1678		// When the operation is finished, @callback will be called.	1678		// When the operation is finished, @callback will be called.
1679		// You can then call g_file_mount_mountable_finish() to get	1679		// You can then call g_file_mount_mountable_finish() to get
1680		// the result of the operation.	1680		// the result of the operation.
1681	-	func (x FileBase) PollMountable(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1681	+	func (x FileBase) PollMountable(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1682			1682
1683	-	XGFilePollMountable(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1683	+	XGFilePollMountable(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1684			1684
1685		}	1685		}
1686			1686

@@ -1724,9 +1724,9 @@ func (x FileBase) QueryDefaultHandler(CancellableVar Cancellable) (*AppInfoBas
1724		}	1724		}
1725			1725
1726		// Async version of g_file_query_default_handler().	1726		// Async version of g_file_query_default_handler().
1727	-	func (x FileBase) QueryDefaultHandlerAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1727	+	func (x FileBase) QueryDefaultHandlerAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1728			1728
1729	-	XGFileQueryDefaultHandlerAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1729	+	XGFileQueryDefaultHandlerAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1730			1730
1731		}	1731		}
1732			1732

@@ -1842,9 +1842,9 @@ func (x FileBase) QueryFilesystemInfo(AttributesVar string, CancellableVar Can
1842		// When the operation is finished, @callback will be called. You can	1842		// When the operation is finished, @callback will be called. You can
1843		// then call g_file_query_info_finish() to get the result of the	1843		// then call g_file_query_info_finish() to get the result of the
1844		// operation.	1844		// operation.
1845	-	func (x FileBase) QueryFilesystemInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1845	+	func (x FileBase) QueryFilesystemInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1846			1846
1847	-	XGFileQueryFilesystemInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1847	+	XGFileQueryFilesystemInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1848			1848
1849		}	1849		}
1850			1850

@@ -1925,9 +1925,9 @@ func (x *FileBase) QueryInfo(AttributesVar string, FlagsVar FileQueryInfoFlags,
1925		//	1925		//
1926		// When the operation is finished, @callback will be called. You can	1926		// When the operation is finished, @callback will be called. You can
1927		// then call g_file_query_info_finish() to get the result of the operation.	1927		// then call g_file_query_info_finish() to get the result of the operation.
1928	-	func (x FileBase) QueryInfoAsync(AttributesVar string, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1928	+	func (x FileBase) QueryInfoAsync(AttributesVar string, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1929			1929
1930	-	XGFileQueryInfoAsync(x.GoPointer(), AttributesVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	1930	+	XGFileQueryInfoAsync(x.GoPointer(), AttributesVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
1931			1931
1932		}	1932		}
1933			1933

@@ -2027,9 +2027,9 @@ func (x FileBase) Read(CancellableVar Cancellable) (*FileInputStream, error) {
2027		// When the operation is finished, @callback will be called.	2027		// When the operation is finished, @callback will be called.
2028		// You can then call g_file_read_finish() to get the result	2028		// You can then call g_file_read_finish() to get the result
2029		// of the operation.	2029		// of the operation.
2030	-	func (x FileBase) ReadAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2030	+	func (x FileBase) ReadAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
2031			2031
2032	-	XGFileReadAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2032	+	XGFileReadAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2033			2033
2034		}	2034		}
2035			2035

@@ -2121,9 +2121,9 @@ func (x *FileBase) Replace(EtagVar string, MakeBackupVar bool, FlagsVar FileCrea
2121		// When the operation is finished, @callback will be called.	2121		// When the operation is finished, @callback will be called.
2122		// You can then call g_file_replace_finish() to get the result	2122		// You can then call g_file_replace_finish() to get the result
2123		// of the operation.	2123		// of the operation.
2124	-	func (x FileBase) ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2124	+	func (x FileBase) ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
2125			2125
2126	-	XGFileReplaceAsync(x.GoPointer(), EtagVar, MakeBackupVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2126	+	XGFileReplaceAsync(x.GoPointer(), EtagVar, MakeBackupVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2127			2127
2128		}	2128		}
2129			2129

@@ -2173,9 +2173,9 @@ func (x *FileBase) ReplaceContents(ContentsVar string, LengthVar uint, EtagVar s
2173		// until @callback is called. See g_file_replace_contents_bytes_async()	2173		// until @callback is called. See g_file_replace_contents_bytes_async()
2174		// for a #GBytes version that will automatically hold a reference to the	2174		// for a #GBytes version that will automatically hold a reference to the
2175		// contents (without copying) for the duration of the call.	2175		// contents (without copying) for the duration of the call.
2176	-	func (x FileBase) ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2176	+	func (x FileBase) ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
2177			2177
2178	-	XGFileReplaceContentsAsync(x.GoPointer(), ContentsVar, LengthVar, EtagVar, MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2178	+	XGFileReplaceContentsAsync(x.GoPointer(), ContentsVar, LengthVar, EtagVar, MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2179			2179
2180		}	2180		}
2181			2181

@@ -2187,9 +2187,9 @@ func (x *FileBase) ReplaceContentsAsync(ContentsVar string, LengthVar uint, Etag
2187		// When this operation has completed, @callback will be called with	2187		// When this operation has completed, @callback will be called with
2188		// @user_user data, and the operation can be finalized with	2188		// @user_user data, and the operation can be finalized with
2189		// g_file_replace_contents_finish().	2189		// g_file_replace_contents_finish().
2190	-	func (x FileBase) ReplaceContentsBytesAsync(ContentsVar glib.Bytes, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2190	+	func (x FileBase) ReplaceContentsBytesAsync(ContentsVar glib.Bytes, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
2191			2191
2192	-	XGFileReplaceContentsBytesAsync(x.GoPointer(), ContentsVar, EtagVar, MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2192	+	XGFileReplaceContentsBytesAsync(x.GoPointer(), ContentsVar, EtagVar, MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2193			2193
2194		}	2194		}
2195			2195

@@ -2265,9 +2265,9 @@ func (x *FileBase) ReplaceReadwrite(EtagVar string, MakeBackupVar bool, FlagsVar
2265		// When the operation is finished, @callback will be called.	2265		// When the operation is finished, @callback will be called.
2266		// You can then call g_file_replace_readwrite_finish() to get	2266		// You can then call g_file_replace_readwrite_finish() to get
2267		// the result of the operation.	2267		// the result of the operation.
2268	-	func (x FileBase) ReplaceReadwriteAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2268	+	func (x FileBase) ReplaceReadwriteAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
2269			2269
2270	-	XGFileReplaceReadwriteAsync(x.GoPointer(), EtagVar, MakeBackupVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2270	+	XGFileReplaceReadwriteAsync(x.GoPointer(), EtagVar, MakeBackupVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2271			2271
2272		}	2272		}
2273			2273

@@ -2440,9 +2440,9 @@ func (x *FileBase) SetAttributeUint64(AttributeVar string, ValueVar uint64, Flag
2440		// When the operation is finished, @callback will be called.	2440		// When the operation is finished, @callback will be called.
2441		// You can then call g_file_set_attributes_finish() to get	2441		// You can then call g_file_set_attributes_finish() to get
2442		// the result of the operation.	2442		// the result of the operation.
2443	-	func (x FileBase) SetAttributesAsync(InfoVar FileInfo, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2443	+	func (x FileBase) SetAttributesAsync(InfoVar FileInfo, FlagsVar FileQueryInfoFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
2444			2444
2445	-	XGFileSetAttributesAsync(x.GoPointer(), InfoVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2445	+	XGFileSetAttributesAsync(x.GoPointer(), InfoVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2446			2446
2447		}	2447		}
2448			2448

@@ -2522,9 +2522,9 @@ func (x FileBase) SetDisplayName(DisplayNameVar string, CancellableVar Cancell
2522		// When the operation is finished, @callback will be called.	2522		// When the operation is finished, @callback will be called.
2523		// You can then call g_file_set_display_name_finish() to get	2523		// You can then call g_file_set_display_name_finish() to get
2524		// the result of the operation.	2524		// the result of the operation.
2525	-	func (x FileBase) SetDisplayNameAsync(DisplayNameVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2525	+	func (x FileBase) SetDisplayNameAsync(DisplayNameVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
2526			2526
2527	-	XGFileSetDisplayNameAsync(x.GoPointer(), DisplayNameVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2527	+	XGFileSetDisplayNameAsync(x.GoPointer(), DisplayNameVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2528			2528
2529		}	2529		}
2530			2530

@@ -2559,9 +2559,9 @@ func (x FileBase) SetDisplayNameFinish(ResVar AsyncResult) (FileBase, error) {
2559		// When the operation is finished, @callback will be called.	2559		// When the operation is finished, @callback will be called.
2560		// You can then call g_file_mount_mountable_finish() to get	2560		// You can then call g_file_mount_mountable_finish() to get
2561		// the result of the operation.	2561		// the result of the operation.
2562	-	func (x FileBase) StartMountable(FlagsVar DriveStartFlags, StartOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2562	+	func (x FileBase) StartMountable(FlagsVar DriveStartFlags, StartOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
2563			2563
2564	-	XGFileStartMountable(x.GoPointer(), FlagsVar, StartOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2564	+	XGFileStartMountable(x.GoPointer(), FlagsVar, StartOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2565			2565
2566		}	2566		}
2567			2567

@@ -2589,9 +2589,9 @@ func (x *FileBase) StartMountableFinish(ResultVar AsyncResult) (bool, error) {
2589		// When the operation is finished, @callback will be called.	2589		// When the operation is finished, @callback will be called.
2590		// You can then call g_file_stop_mountable_finish() to get	2590		// You can then call g_file_stop_mountable_finish() to get
2591		// the result of the operation.	2591		// the result of the operation.
2592	-	func (x FileBase) StopMountable(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2592	+	func (x FileBase) StopMountable(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
2593			2593
2594	-	XGFileStopMountable(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2594	+	XGFileStopMountable(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2595			2595
2596		}	2596		}
2597			2597

@@ -2642,9 +2642,9 @@ func (x FileBase) Trash(CancellableVar Cancellable) (bool, error) {
2642		}	2642		}
2643			2643
2644		// Asynchronously sends @file to the Trash location, if possible.	2644		// Asynchronously sends @file to the Trash location, if possible.
2645	-	func (x FileBase) TrashAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2645	+	func (x FileBase) TrashAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
2646			2646
2647	-	XGFileTrashAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2647	+	XGFileTrashAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2648			2648
2649		}	2649		}
2650			2650

@@ -2670,9 +2670,9 @@ func (x *FileBase) TrashFinish(ResultVar AsyncResult) (bool, error) {
2670		// When the operation is finished, @callback will be called.	2670		// When the operation is finished, @callback will be called.
2671		// You can then call g_file_unmount_mountable_finish() to get	2671		// You can then call g_file_unmount_mountable_finish() to get
2672		// the result of the operation.	2672		// the result of the operation.
2673	-	func (x FileBase) UnmountMountable(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2673	+	func (x FileBase) UnmountMountable(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
2674			2674
2675	-	XGFileUnmountMountable(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2675	+	XGFileUnmountMountable(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2676			2676
2677		}	2677		}
2678			2678

@@ -2700,9 +2700,9 @@ func (x *FileBase) UnmountMountableFinish(ResultVar AsyncResult) (bool, error) {
2700		// When the operation is finished, @callback will be called.	2700		// When the operation is finished, @callback will be called.
2701		// You can then call g_file_unmount_mountable_finish() to get	2701		// You can then call g_file_unmount_mountable_finish() to get
2702		// the result of the operation.	2702		// the result of the operation.
2703	-	func (x FileBase) UnmountMountableWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	2703	+	func (x FileBase) UnmountMountableWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
2704			2704
2705	-	XGFileUnmountMountableWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	2705	+	XGFileUnmountMountableWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
2706			2706
2707		}	2707		}
2708			2708

M v4/gio/gfileenumerator.go +4 -4


@@ -88,9 +88,9 @@ var xFileEnumeratorCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
88		// triggering the cancellable object from another thread. If the operation	88		// triggering the cancellable object from another thread. If the operation
89		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in	89		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in
90		// g_file_enumerator_close_finish().	90		// g_file_enumerator_close_finish().
91	-	func (x FileEnumerator) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	91	+	func (x FileEnumerator) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
92			92
93	-	xFileEnumeratorCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	93	+	xFileEnumeratorCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
94			94
95		}	95		}
96			96

@@ -288,9 +288,9 @@ var xFileEnumeratorNextFilesAsync func(uintptr, int, int, uintptr, uintptr, uint
288		// Any outstanding i/o request with higher priority (lower numerical value) will	288		// Any outstanding i/o request with higher priority (lower numerical value) will
289		// be executed before an outstanding request with lower priority. Default	289		// be executed before an outstanding request with lower priority. Default
290		// priority is %G_PRIORITY_DEFAULT.	290		// priority is %G_PRIORITY_DEFAULT.
291	-	func (x FileEnumerator) NextFilesAsync(NumFilesVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	291	+	func (x FileEnumerator) NextFilesAsync(NumFilesVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
292			292
293	-	xFileEnumeratorNextFilesAsync(x.GoPointer(), NumFilesVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	293	+	xFileEnumeratorNextFilesAsync(x.GoPointer(), NumFilesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
294			294
295		}	295		}
296			296

M v4/gio/gfileicon.go +2 -2


@@ -133,9 +133,9 @@ func (x FileIcon) Load(SizeVar int, TypeVar string, CancellableVar Cancellable
133		// Loads an icon asynchronously. To finish this function, see	133		// Loads an icon asynchronously. To finish this function, see
134		// g_loadable_icon_load_finish(). For the synchronous, blocking	134		// g_loadable_icon_load_finish(). For the synchronous, blocking
135		// version of this function, see g_loadable_icon_load().	135		// version of this function, see g_loadable_icon_load().
136	-	func (x FileIcon) LoadAsync(SizeVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	136	+	func (x FileIcon) LoadAsync(SizeVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
137			137
138	-	XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	138	+	XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
139			139
140		}	140		}
141			141

M v4/gio/gfileinputstream.go +2 -2


@@ -81,9 +81,9 @@ var xFileInputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr,
81		// If @cancellable is not %NULL, then the operation can be cancelled by	81		// If @cancellable is not %NULL, then the operation can be cancelled by
82		// triggering the cancellable object from another thread. If the operation	82		// triggering the cancellable object from another thread. If the operation
83		// was cancelled, the error %G_IO_ERROR_CANCELLED will be set	83		// was cancelled, the error %G_IO_ERROR_CANCELLED will be set
84	-	func (x FileInputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	84	+	func (x FileInputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
85			85
86	-	xFileInputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	86	+	xFileInputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
87			87
88		}	88		}
89			89

M v4/gio/gfileiostream.go +2 -2


@@ -110,9 +110,9 @@ var xFileIOStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr, uin
110		//	110		//
111		// For the synchronous version of this function, see	111		// For the synchronous version of this function, see
112		// g_file_io_stream_query_info().	112		// g_file_io_stream_query_info().
113	-	func (x FileIOStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	113	+	func (x FileIOStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
114			114
115	-	xFileIOStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	115	+	xFileIOStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
116			116
117		}	117		}
118			118

M v4/gio/gfilemonitor.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // old path, and @other_file will be set to a #GFile containing the new path.
 //
 // In all the other cases, @other_file will be set to #NULL.
-func (x *FileMonitor) ConnectChanged(cb func(FileMonitor, uintptr, uintptr, FileMonitorEvent)) uint32 {
+func (x *FileMonitor) ConnectChanged(cb *func(FileMonitor, uintptr, uintptr, FileMonitorEvent)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, FileVarp uintptr, OtherFileVarp uintptr, EventTypeVarp FileMonitorEvent) {
 		fa := FileMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, FileVarp, OtherFileVarp, EventTypeVarp)
+		cbFn(fa, FileVarp, OtherFileVarp, EventTypeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 func init() {

M v4/gio/gfilenamecompleter.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted when the file name completion information comes available.
-func (x *FilenameCompleter) ConnectGotCompletionData(cb func(FilenameCompleter)) uint32 {
+func (x *FilenameCompleter) ConnectGotCompletionData(cb *func(FilenameCompleter)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "got-completion-data", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FilenameCompleter{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "got-completion-data", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "got-completion-data", cbRefPtr)
 }
 func init() {

M v4/gio/gfileoutputstream.go +2 -2


@@ -104,9 +104,9 @@ var xFileOutputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr,
104		//	104		//
105		// For the synchronous version of this function, see	105		// For the synchronous version of this function, see
106		// g_file_output_stream_query_info().	106		// g_file_output_stream_query_info().
107	-	func (x FileOutputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	107	+	func (x FileOutputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
108			108
109	-	xFileOutputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	109	+	xFileOutputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
110			110
111		}	111		}
112			112

M v4/gio/ginputstream.go +10 -10


@@ -103,9 +103,9 @@ var xInputStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
103		// The asynchronous methods have a default fallback that uses threads to implement	103		// The asynchronous methods have a default fallback that uses threads to implement
104		// asynchronicity, so they are optional for inheriting classes. However, if you	104		// asynchronicity, so they are optional for inheriting classes. However, if you
105		// override one you must override all.	105		// override one you must override all.
106	-	func (x InputStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	106	+	func (x InputStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
107			107
108	-	xInputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	108	+	xInputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
109			109
110		}	110		}
111			111

@@ -219,9 +219,9 @@ var xInputStreamReadAllAsync func(uintptr, uintptr, uint, int, uintptr, uintptr,
219		// Any outstanding I/O request with higher priority (lower numerical	219		// Any outstanding I/O request with higher priority (lower numerical
220		// value) will be executed before an outstanding request with lower	220		// value) will be executed before an outstanding request with lower
221		// priority. Default priority is %G_PRIORITY_DEFAULT.	221		// priority. Default priority is %G_PRIORITY_DEFAULT.
222	-	func (x InputStream) ReadAllAsync(BufferVar uintptr, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	222	+	func (x InputStream) ReadAllAsync(BufferVar uintptr, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
223			223
224	-	xInputStreamReadAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	224	+	xInputStreamReadAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
225			225
226		}	226		}
227			227

@@ -272,9 +272,9 @@ var xInputStreamReadAsync func(uintptr, uintptr, uint, int, uintptr, uintptr, ui
272		// The asynchronous methods have a default fallback that uses threads to implement	272		// The asynchronous methods have a default fallback that uses threads to implement
273		// asynchronicity, so they are optional for inheriting classes. However, if you	273		// asynchronicity, so they are optional for inheriting classes. However, if you
274		// override one you must override all.	274		// override one you must override all.
275	-	func (x InputStream) ReadAsync(BufferVar uintptr, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	275	+	func (x InputStream) ReadAsync(BufferVar uintptr, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
276			276
277	-	xInputStreamReadAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	277	+	xInputStreamReadAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
278			278
279		}	279		}
280			280

@@ -336,9 +336,9 @@ var xInputStreamReadBytesAsync func(uintptr, uint, int, uintptr, uintptr, uintpt
336		// Any outstanding I/O request with higher priority (lower numerical	336		// Any outstanding I/O request with higher priority (lower numerical
337		// value) will be executed before an outstanding request with lower	337		// value) will be executed before an outstanding request with lower
338		// priority. Default priority is %G_PRIORITY_DEFAULT.	338		// priority. Default priority is %G_PRIORITY_DEFAULT.
339	-	func (x InputStream) ReadBytesAsync(CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	339	+	func (x InputStream) ReadBytesAsync(CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
340			340
341	-	xInputStreamReadBytesAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	341	+	xInputStreamReadBytesAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
342			342
343		}	343		}
344			344

@@ -438,9 +438,9 @@ var xInputStreamSkipAsync func(uintptr, uint, int, uintptr, uintptr, uintptr)
438		// The asynchronous methods have a default fallback that uses threads to	438		// The asynchronous methods have a default fallback that uses threads to
439		// implement asynchronicity, so they are optional for inheriting classes.	439		// implement asynchronicity, so they are optional for inheriting classes.
440		// However, if you override one, you must override all.	440		// However, if you override one, you must override all.
441	-	func (x InputStream) SkipAsync(CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	441	+	func (x InputStream) SkipAsync(CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
442			442
443	-	xInputStreamSkipAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	443	+	xInputStreamSkipAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
444			444
445		}	445		}
446			446

M v4/gio/gio-2.0.go +115 -57

 package gio
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 // Signal emitted when the app info database for changes (ie: newly installed
 // or removed applications).
-func (x *AppInfoMonitor) ConnectChanged(cb func(AppInfoMonitor)) uint32 {
+func (x *AppInfoMonitor) ConnectChanged(cb *func(AppInfoMonitor)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := AppInfoMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 var xAppInfoMonitorGet func() uintptr
 // Loads an icon asynchronously. To finish this function, see
 // g_loadable_icon_load_finish(). For the synchronous, blocking
 // version of this function, see g_loadable_icon_load().
-func (x *BytesIcon) LoadAsync(SizeVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *BytesIcon) LoadAsync(SizeVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 }
 // Emitted to check if @mechanism is allowed to be used.
-func (x *DBusAuthObserver) ConnectAllowMechanism(cb func(DBusAuthObserver, string) bool) uint32 {
+func (x *DBusAuthObserver) ConnectAllowMechanism(cb *func(DBusAuthObserver, string) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "allow-mechanism", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MechanismVarp string) bool {
 		fa := DBusAuthObserver{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, MechanismVarp)
+		return cbFn(fa, MechanismVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "allow-mechanism", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "allow-mechanism", cbRefPtr)
 }
 // Emitted to check if a peer that is successfully authenticated
 // is authorized.
-func (x *DBusAuthObserver) ConnectAuthorizeAuthenticatedPeer(cb func(DBusAuthObserver, uintptr, uintptr) bool) uint32 {
+func (x *DBusAuthObserver) ConnectAuthorizeAuthenticatedPeer(cb *func(DBusAuthObserver, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "authorize-authenticated-peer", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StreamVarp uintptr, CredentialsVarp uintptr) bool {
 		fa := DBusAuthObserver{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, StreamVarp, CredentialsVarp)
+		return cbFn(fa, StreamVarp, CredentialsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "authorize-authenticated-peer", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "authorize-authenticated-peer", cbRefPtr)
 }
 // The #GDBusConnection type is used for D-Bus connections to remote
 // needed. (It is not guaranteed to be called synchronously when the
 // filter is removed, and may be called after @connection has been
 // destroyed.)
-func (x *DBusConnection) AddFilter(FilterFunctionVar DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
+func (x *DBusConnection) AddFilter(FilterFunctionVar *DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
-	cret := xDBusConnectionAddFilter(x.GoPointer(), purego.NewCallback(FilterFunctionVar), UserDataVar, purego.NewCallback(UserDataFreeFuncVar))
+	cret := xDBusConnectionAddFilter(x.GoPointer(), glib.NewCallback(FilterFunctionVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
 	return cret
 }
 //
 // If @callback is %NULL then the D-Bus method call message will be sent with
 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
-func (x *DBusConnection) Call(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar *glib.Variant, ReplyTypeVar *glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusConnection) Call(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar *glib.Variant, ReplyTypeVar *glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusConnectionCall(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusConnectionCall(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
 //
 // This method is only available on UNIX.
-func (x *DBusConnection) CallWithUnixFdList(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar *glib.Variant, ReplyTypeVar *glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusConnection) CallWithUnixFdList(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar *glib.Variant, ReplyTypeVar *glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusConnectionCallWithUnixFdList(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusConnectionCallWithUnixFdList(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // then call g_dbus_connection_close_finish() to get the result of the
 // operation. See g_dbus_connection_close_sync() for the synchronous
 // version.
-func (x *DBusConnection) Close(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusConnection) Close(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusConnectionClose(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusConnectionClose(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // then call g_dbus_connection_flush_finish() to get the result of the
 // operation. See g_dbus_connection_flush_sync() for the synchronous
 // version.
-func (x *DBusConnection) Flush(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusConnection) Flush(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusConnectionFlush(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusConnectionFlush(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // as the object is exported. Also note that @vtable will be copied.
 //
 // See this [server][gdbus-server] for an example of how to use this method.
-func (x *DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar *DBusInterfaceInfo, VtableVar *DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) (uint, error) {
+func (x *DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar *DBusInterfaceInfo, VtableVar *DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
 	var cerr *glib.Error
-	cret := xDBusConnectionRegisterObject(x.GoPointer(), ObjectPathVar, InterfaceInfoVar, VtableVar, UserDataVar, purego.NewCallback(UserDataFreeFuncVar), &cerr)
+	cret := xDBusConnectionRegisterObject(x.GoPointer(), ObjectPathVar, InterfaceInfoVar, VtableVar, UserDataVar, glib.NewCallback(UserDataFreeFuncVar), &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 //
 // See this [server][gdbus-subtree-server] for an example of how to use
 // this method.
-func (x *DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar *DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) (uint, error) {
+func (x *DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar *DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
 	var cerr *glib.Error
-	cret := xDBusConnectionRegisterSubtree(x.GoPointer(), ObjectPathVar, VtableVar, FlagsVar, UserDataVar, purego.NewCallback(UserDataFreeFuncVar), &cerr)
+	cret := xDBusConnectionRegisterSubtree(x.GoPointer(), ObjectPathVar, VtableVar, FlagsVar, UserDataVar, glib.NewCallback(UserDataFreeFuncVar), &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 // See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
 // for an example of how to use this low-level API to send and receive
 // UNIX file descriptors.
-func (x *DBusConnection) SendMessageWithReply(MessageVar *DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar uint32, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusConnection) SendMessageWithReply(MessageVar *DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar uint32, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusConnectionSendMessageWithReply(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, TimeoutMsecVar, OutSerialVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusConnectionSendMessageWithReply(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, TimeoutMsecVar, OutSerialVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // to never be zero.
 //
 // This function can never fail.
-func (x *DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
+func (x *DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar *DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
-	cret := xDBusConnectionSignalSubscribe(x.GoPointer(), SenderVar, InterfaceNameVar, MemberVar, ObjectPathVar, Arg0Var, FlagsVar, purego.NewCallback(CallbackVar), UserDataVar, purego.NewCallback(UserDataFreeFuncVar))
+	cret := xDBusConnectionSignalSubscribe(x.GoPointer(), SenderVar, InterfaceNameVar, MemberVar, ObjectPathVar, Arg0Var, FlagsVar, glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
 	return cret
 }
 // Upon receiving this signal, you should give up your reference to
 // @connection. You are guaranteed that this signal is emitted only
 // once.
-func (x *DBusConnection) ConnectClosed(cb func(DBusConnection, bool, uintptr)) uint32 {
+func (x *DBusConnection) ConnectClosed(cb *func(DBusConnection, bool, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, RemotePeerVanishedVarp bool, ErrorVarp uintptr) {
 		fa := DBusConnection{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, RemotePeerVanishedVarp, ErrorVarp)
+		cbFn(fa, RemotePeerVanishedVarp, ErrorVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "closed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
 }
 // Starts asynchronous initialization of the object implementing the
 // in a thread, so if you want to support asynchronous initialization via
 // threads, just implement the #GAsyncInitable interface without overriding
 // any interface methods.
-func (x *DBusConnection) InitAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *DBusConnection) InitAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGAsyncInitableInitAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	XGAsyncInitableInitAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // This is an asynchronous failable constructor. See
 // g_dbus_connection_new_sync() for the synchronous
 // version.
-func DBusConnectionNew(StreamVar *IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func DBusConnectionNew(StreamVar *IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusConnectionNew(StreamVar.GoPointer(), GuidVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusConnectionNew(StreamVar.GoPointer(), GuidVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // This is an asynchronous failable constructor. See
 // g_dbus_connection_new_for_address_sync() for the synchronous
 // version.
-func DBusConnectionNewForAddress(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func DBusConnectionNewForAddress(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusConnectionNewForAddress(AddressVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xDBusConnectionNewForAddress(AddressVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // before incoming messages on @connection are processed. This means
 // that it's suitable to call g_dbus_connection_register_object() or
 // similar from the signal handler.
-func (x *DBusServer) ConnectNewConnection(cb func(DBusServer, uintptr) bool) uint32 {
+func (x *DBusServer) ConnectNewConnection(cb *func(DBusServer, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "new-connection", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ConnectionVarp uintptr) bool {
 		fa := DBusServer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ConnectionVarp)
+		return cbFn(fa, ConnectionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "new-connection", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "new-connection", cbRefPtr)
 }
 // Initializes the object implementing the interface.
 // type, the default is to forward them directly to
 // #GSimpleAction::change-state.  This should allow almost all users
 // of #GSimpleAction to connect only one handler or the other.
-func (x *SimpleAction) ConnectActivate(cb func(SimpleAction, uintptr)) uint32 {
+func (x *SimpleAction) ConnectActivate(cb *func(SimpleAction, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ParameterVarp uintptr) {
 		fa := SimpleAction{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ParameterVarp)
+		cbFn(fa, ParameterVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Indicates that the action just received a request to change its
 //
 // The handler need not set the state to the requested value.
 // It could set it to any value at all, or take some other action.
-func (x *SimpleAction) ConnectChangeState(cb func(SimpleAction, uintptr)) uint32 {
+func (x *SimpleAction) ConnectChangeState(cb *func(SimpleAction, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "change-state", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ValueVarp uintptr) {
 		fa := SimpleAction{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ValueVarp)
+		cbFn(fa, ValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "change-state", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "change-state", cbRefPtr)
 }
 // Activates the action.
 // Asynchronous version of g_subprocess_communicate().  Complete
 // invocation with g_subprocess_communicate_finish().
-func (x *Subprocess) CommunicateAsync(StdinBufVar *glib.Bytes, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Subprocess) CommunicateAsync(StdinBufVar *glib.Bytes, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSubprocessCommunicateAsync(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSubprocessCommunicateAsync(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // Asynchronous version of g_subprocess_communicate_utf8().  Complete
 // invocation with g_subprocess_communicate_utf8_finish().
-func (x *Subprocess) CommunicateUtf8Async(StdinBufVar string, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Subprocess) CommunicateUtf8Async(StdinBufVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSubprocessCommunicateUtf8Async(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSubprocessCommunicateUtf8Async(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // Wait for the subprocess to terminate.
 //
 // This is the asynchronous version of g_subprocess_wait().
-func (x *Subprocess) WaitAsync(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Subprocess) WaitAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSubprocessWaitAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSubprocessWaitAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // Combines g_subprocess_wait_async() with g_spawn_check_wait_status().
 //
 // This is the asynchronous version of g_subprocess_wait_check().
-func (x *Subprocess) WaitCheckAsync(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Subprocess) WaitCheckAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSubprocessWaitCheckAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSubprocessWaitCheckAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // %NULL can be given as @child_setup to disable the functionality.
 //
 // Child setup functions are only available on UNIX.
-func (x *SubprocessLauncher) SetChildSetup(ChildSetupVar glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar glib.DestroyNotify) {
+func (x *SubprocessLauncher) SetChildSetup(ChildSetupVar *glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
-	xSubprocessLauncherSetChildSetup(x.GoPointer(), purego.NewCallback(ChildSetupVar), UserDataVar, purego.NewCallback(DestroyNotifyVar))
+	xSubprocessLauncherSetChildSetup(x.GoPointer(), glib.NewCallback(ChildSetupVar), UserDataVar, glib.NewCallback(DestroyNotifyVar))
 }

M v4/gio/gioscheduler.go +2 -2


@@ -29,9 +29,9 @@ var xIoSchedulerPushJob func(uintptr, uintptr, uintptr, int, uintptr)
29		// If @cancellable is not %NULL, it can be used to cancel the I/O job	29		// If @cancellable is not %NULL, it can be used to cancel the I/O job
30		// by calling g_cancellable_cancel() or by calling	30		// by calling g_cancellable_cancel() or by calling
31		// g_io_scheduler_cancel_all_jobs().	31		// g_io_scheduler_cancel_all_jobs().
32	-	func IoSchedulerPushJob(JobFuncVar IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {	32	+	func IoSchedulerPushJob(JobFuncVar IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {
33			33
34	-	xIoSchedulerPushJob(purego.NewCallback(JobFuncVar), UserDataVar, purego.NewCallback(NotifyVar), IoPriorityVar, CancellableVar.GoPointer())	34	+	xIoSchedulerPushJob(glib.NewCallback(JobFuncVar), UserDataVar, glib.NewCallback(NotifyVar), IoPriorityVar, CancellableVar.GoPointer())
35			35
36		}	36		}
37			37

M v4/gio/giostream.go +4 -4


@@ -148,9 +148,9 @@ var xIOStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
148		// The asynchronous methods have a default fallback that uses threads	148		// The asynchronous methods have a default fallback that uses threads
149		// to implement asynchronicity, so they are optional for inheriting	149		// to implement asynchronicity, so they are optional for inheriting
150		// classes. However, if you override one you must override all.	150		// classes. However, if you override one you must override all.
151	-	func (x IOStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	151	+	func (x IOStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
152			152
153	-	xIOStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	153	+	xIOStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
154			154
155		}	155		}
156			156

@@ -247,9 +247,9 @@ var xIOStreamSpliceAsync func(uintptr, uintptr, IOStreamSpliceFlags, int, uintpt
247		// When the operation is finished @callback will be called.	247		// When the operation is finished @callback will be called.
248		// You can then call g_io_stream_splice_finish() to get the	248		// You can then call g_io_stream_splice_finish() to get the
249		// result of the operation.	249		// result of the operation.
250	-	func (x IOStream) SpliceAsync(Stream2Var IOStream, FlagsVar IOStreamSpliceFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	250	+	func (x IOStream) SpliceAsync(Stream2Var IOStream, FlagsVar IOStreamSpliceFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
251			251
252	-	xIOStreamSpliceAsync(x.GoPointer(), Stream2Var.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	252	+	xIOStreamSpliceAsync(x.GoPointer(), Stream2Var.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
253			253
254		}	254		}
255			255

M v4/gio/giotypes.go +4 -4


@@ -335,9 +335,9 @@ var xIOSchedulerJobSendToMainloop func(uintptr, uintptr, uintptr, uintptr) bool
335		// Used from an I/O job to send a callback to be run in the thread	335		// Used from an I/O job to send a callback to be run in the thread
336		// that the job was started from, waiting for the result (and thus	336		// that the job was started from, waiting for the result (and thus
337		// blocking the I/O job).	337		// blocking the I/O job).
338	-	func (x *IOSchedulerJob) SendToMainloop(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify) bool {	338	+	func (x IOSchedulerJob) SendToMainloop(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) bool {
339			339
340	-	cret := xIOSchedulerJobSendToMainloop(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar, purego.NewCallback(NotifyVar))	340	+	cret := xIOSchedulerJobSendToMainloop(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallback(NotifyVar))
341		return cret	341		return cret
342		}	342		}
343			343

@@ -352,9 +352,9 @@ var xIOSchedulerJobSendToMainloopAsync func(uintptr, uintptr, uintptr, uintptr)
352		// on to this function you have to ensure that it is not freed before	352		// on to this function you have to ensure that it is not freed before
353		// @func is called, either by passing %NULL as @notify to	353		// @func is called, either by passing %NULL as @notify to
354		// g_io_scheduler_push_job() or by using refcounting for @user_data.	354		// g_io_scheduler_push_job() or by using refcounting for @user_data.
355	-	func (x *IOSchedulerJob) SendToMainloopAsync(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify) {	355	+	func (x IOSchedulerJob) SendToMainloopAsync(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) {
356			356
357	-	xIOSchedulerJobSendToMainloopAsync(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar, purego.NewCallback(NotifyVar))	357	+	xIOSchedulerJobSendToMainloopAsync(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallback(NotifyVar))
358			358
359		}	359		}
360			360

M v4/gio/gliststore.go +6 -6


@@ -84,9 +84,9 @@ var xListStoreFindWithEqualFunc func(uintptr, uintptr, uintptr, uint) bool
84		// comparing them with @compare_func until the first occurrence of @item which	84		// comparing them with @compare_func until the first occurrence of @item which
85		// matches. If @item was not found, then @position will not be set, and this	85		// matches. If @item was not found, then @position will not be set, and this
86		// method will return %FALSE.	86		// method will return %FALSE.
87	-	func (x ListStore) FindWithEqualFunc(ItemVar gobject.Object, EqualFuncVar glib.EqualFunc, PositionVar uint) bool {	87	+	func (x ListStore) FindWithEqualFunc(ItemVar gobject.Object, EqualFuncVar *glib.EqualFunc, PositionVar uint) bool {
88			88
89	-	cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), purego.NewCallback(EqualFuncVar), PositionVar)	89	+	cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(EqualFuncVar), PositionVar)
90		return cret	90		return cret
91		}	91		}
92			92

@@ -116,9 +116,9 @@ var xListStoreInsertSorted func(uintptr, uintptr, uintptr, uintptr) uint
116		// inserting items by way of this function.	116		// inserting items by way of this function.
117		//	117		//
118		// This function takes a ref on @item.	118		// This function takes a ref on @item.
119	-	func (x ListStore) InsertSorted(ItemVar gobject.Object, CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) uint {	119	+	func (x ListStore) InsertSorted(ItemVar gobject.Object, CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) uint {
120			120
121	-	cret := xListStoreInsertSorted(x.GoPointer(), ItemVar.GoPointer(), purego.NewCallback(CompareFuncVar), UserDataVar)	121	+	cret := xListStoreInsertSorted(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)
122		return cret	122		return cret
123		}	123		}
124			124

@@ -147,9 +147,9 @@ func (x *ListStore) RemoveAll() {
147		var xListStoreSort func(uintptr, uintptr, uintptr)	147		var xListStoreSort func(uintptr, uintptr, uintptr)
148			148
149		// Sort the items in @store according to @compare_func.	149		// Sort the items in @store according to @compare_func.
150	-	func (x *ListStore) Sort(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) {	150	+	func (x ListStore) Sort(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) {
151			151
152	-	xListStoreSort(x.GoPointer(), purego.NewCallback(CompareFuncVar), UserDataVar)	152	+	xListStoreSort(x.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)
153			153
154		}	154		}
155			155

M v4/gio/gloadableicon.go +3 -3


@@ -24,7 +24,7 @@ type LoadableIcon interface {
24		GoPointer() uintptr	24		GoPointer() uintptr
25		SetGoPointer(uintptr)	25		SetGoPointer(uintptr)
26		Load(SizeVar int, TypeVar string, CancellableVar Cancellable) InputStream	26		Load(SizeVar int, TypeVar string, CancellableVar Cancellable) InputStream
27	-	LoadAsync(SizeVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	27	+	LoadAsync(SizeVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
28		LoadFinish(ResVar AsyncResult, TypeVar string) *InputStream	28		LoadFinish(ResVar AsyncResult, TypeVar string) *InputStream
29		}	29		}
30		type LoadableIconBase struct {	30		type LoadableIconBase struct {

@@ -62,9 +62,9 @@ func (x LoadableIconBase) Load(SizeVar int, TypeVar string, CancellableVar Can
62		// Loads an icon asynchronously. To finish this function, see	62		// Loads an icon asynchronously. To finish this function, see
63		// g_loadable_icon_load_finish(). For the synchronous, blocking	63		// g_loadable_icon_load_finish(). For the synchronous, blocking
64		// version of this function, see g_loadable_icon_load().	64		// version of this function, see g_loadable_icon_load().
65	-	func (x LoadableIconBase) LoadAsync(SizeVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	65	+	func (x LoadableIconBase) LoadAsync(SizeVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
66			66
67	-	XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	67	+	XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
68			68
69		}	69		}
70			70

M v4/gio/gmemoryinputstream.go +4 -4


@@ -74,10 +74,10 @@ func NewMemoryInputStreamFromBytes(BytesVar glib.Bytes) MemoryInputStream {
74		var xNewMemoryInputStreamFromData func(uintptr, int, uintptr) uintptr	74		var xNewMemoryInputStreamFromData func(uintptr, int, uintptr) uintptr
75			75
76		// Creates a new #GMemoryInputStream with data in memory of a given size.	76		// Creates a new #GMemoryInputStream with data in memory of a given size.
77	-	func NewMemoryInputStreamFromData(DataVar uintptr, LenVar int, DestroyVar glib.DestroyNotify) *MemoryInputStream {	77	+	func NewMemoryInputStreamFromData(DataVar uintptr, LenVar int, DestroyVar glib.DestroyNotify) MemoryInputStream {
78		var cls *MemoryInputStream	78		var cls *MemoryInputStream
79			79
80	-	cret := xNewMemoryInputStreamFromData(DataVar, LenVar, purego.NewCallback(DestroyVar))	80	+	cret := xNewMemoryInputStreamFromData(DataVar, LenVar, glib.NewCallback(DestroyVar))
81			81
82		if cret == 0 {	82		if cret == 0 {
83		return nil	83		return nil

@@ -99,9 +99,9 @@ func (x MemoryInputStream) AddBytes(BytesVar glib.Bytes) {
99		var xMemoryInputStreamAddData func(uintptr, uintptr, int, uintptr)	99		var xMemoryInputStreamAddData func(uintptr, uintptr, int, uintptr)
100			100
101		// Appends @data to data that can be read from the input stream	101		// Appends @data to data that can be read from the input stream
102	-	func (x *MemoryInputStream) AddData(DataVar uintptr, LenVar int, DestroyVar glib.DestroyNotify) {	102	+	func (x MemoryInputStream) AddData(DataVar uintptr, LenVar int, DestroyVar glib.DestroyNotify) {
103			103
104	-	xMemoryInputStreamAddData(x.GoPointer(), DataVar, LenVar, purego.NewCallback(DestroyVar))	104	+	xMemoryInputStreamAddData(x.GoPointer(), DataVar, LenVar, glib.NewCallback(DestroyVar))
105			105
106		}	106		}
107			107

M v4/gio/gmemoryoutputstream.go +2 -2


@@ -88,10 +88,10 @@ var xNewMemoryOutputStream func(uintptr, uint, uintptr, uintptr) uintptr
88		// data = malloc (200);	88		// data = malloc (200);
89		// stream3 = g_memory_output_stream_new (data, 200, NULL, free);	89		// stream3 = g_memory_output_stream_new (data, 200, NULL, free);
90		// ]\|	90		// ]\|
91	-	func NewMemoryOutputStream(DataVar uintptr, SizeVar uint, ReallocFunctionVar ReallocFunc, DestroyFunctionVar glib.DestroyNotify) *MemoryOutputStream {	91	+	func NewMemoryOutputStream(DataVar uintptr, SizeVar uint, ReallocFunctionVar ReallocFunc, DestroyFunctionVar glib.DestroyNotify) *MemoryOutputStream {
92		var cls *MemoryOutputStream	92		var cls *MemoryOutputStream
93			93
94	-	cret := xNewMemoryOutputStream(DataVar, SizeVar, purego.NewCallback(ReallocFunctionVar), purego.NewCallback(DestroyFunctionVar))	94	+	cret := xNewMemoryOutputStream(DataVar, SizeVar, glib.NewCallback(ReallocFunctionVar), glib.NewCallback(DestroyFunctionVar))
95			95
96		if cret == 0 {	96		if cret == 0 {
97		return nil	97		return nil

M v4/gio/gmenumodel.go +11 -3

 // Signal handlers may query the model (particularly the added items)
 // and expect to see the results of the modification that is being
 // reported.  The signal is emitted after the modification.
-func (x *MenuModel) ConnectItemsChanged(cb func(MenuModel, int, int, int)) uint32 {
+func (x *MenuModel) ConnectItemsChanged(cb *func(MenuModel, int, int, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "items-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PositionVarp int, RemovedVarp int, AddedVarp int) {
 		fa := MenuModel{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PositionVarp, RemovedVarp, AddedVarp)
+		cbFn(fa, PositionVarp, RemovedVarp, AddedVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "items-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "items-changed", cbRefPtr)
 }
 func init() {

M v4/gio/gmount.go +18 -18


@@ -42,9 +42,9 @@ type Mount interface {
42		SetGoPointer(uintptr)	42		SetGoPointer(uintptr)
43		CanEject() bool	43		CanEject() bool
44		CanUnmount() bool	44		CanUnmount() bool
45	-	Eject(FlagsVar MountUnmountFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	45	+	Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
46		EjectFinish(ResultVar AsyncResult) bool	46		EjectFinish(ResultVar AsyncResult) bool
47	-	EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	47	+	EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
48		EjectWithOperationFinish(ResultVar AsyncResult) bool	48		EjectWithOperationFinish(ResultVar AsyncResult) bool
49		GetDefaultLocation() *FileBase	49		GetDefaultLocation() *FileBase
50		GetDrive() *DriveBase	50		GetDrive() *DriveBase

@@ -55,16 +55,16 @@ type Mount interface {
55		GetSymbolicIcon() *IconBase	55		GetSymbolicIcon() *IconBase
56		GetUuid() string	56		GetUuid() string
57		GetVolume() *VolumeBase	57		GetVolume() *VolumeBase
58	-	GuessContentType(ForceRescanVar bool, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	58	+	GuessContentType(ForceRescanVar bool, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
59		GuessContentTypeFinish(ResultVar AsyncResult) uintptr	59		GuessContentTypeFinish(ResultVar AsyncResult) uintptr
60		GuessContentTypeSync(ForceRescanVar bool, CancellableVar *Cancellable) uintptr	60		GuessContentTypeSync(ForceRescanVar bool, CancellableVar *Cancellable) uintptr
61		IsShadowed() bool	61		IsShadowed() bool
62	-	Remount(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	62	+	Remount(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
63		RemountFinish(ResultVar AsyncResult) bool	63		RemountFinish(ResultVar AsyncResult) bool
64		Shadow()	64		Shadow()
65	-	Unmount(FlagsVar MountUnmountFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	65	+	Unmount(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
66		UnmountFinish(ResultVar AsyncResult) bool	66		UnmountFinish(ResultVar AsyncResult) bool
67	-	UnmountWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	67	+	UnmountWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
68		UnmountWithOperationFinish(ResultVar AsyncResult) bool	68		UnmountWithOperationFinish(ResultVar AsyncResult) bool
69		Unshadow()	69		Unshadow()
70		}	70		}

@@ -97,9 +97,9 @@ func (x *MountBase) CanUnmount() bool {
97		// Ejects a mount. This is an asynchronous operation, and is	97		// Ejects a mount. This is an asynchronous operation, and is
98		// finished by calling g_mount_eject_finish() with the @mount	98		// finished by calling g_mount_eject_finish() with the @mount
99		// and #GAsyncResult data returned in the @callback.	99		// and #GAsyncResult data returned in the @callback.
100	-	func (x MountBase) Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	100	+	func (x MountBase) Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
101			101
102	-	XGMountEject(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	102	+	XGMountEject(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
103			103
104		}	104		}
105			105

@@ -119,9 +119,9 @@ func (x *MountBase) EjectFinish(ResultVar AsyncResult) (bool, error) {
119		// Ejects a mount. This is an asynchronous operation, and is	119		// Ejects a mount. This is an asynchronous operation, and is
120		// finished by calling g_mount_eject_with_operation_finish() with the @mount	120		// finished by calling g_mount_eject_with_operation_finish() with the @mount
121		// and #GAsyncResult data returned in the @callback.	121		// and #GAsyncResult data returned in the @callback.
122	-	func (x MountBase) EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	122	+	func (x MountBase) EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
123			123
124	-	XGMountEjectWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	124	+	XGMountEjectWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
125			125
126		}	126		}
127			127

@@ -262,9 +262,9 @@ func (x MountBase) GetVolume() VolumeBase {
262		// g_mount_guess_content_type_sync() for the synchronous version), and	262		// g_mount_guess_content_type_sync() for the synchronous version), and
263		// is finished by calling g_mount_guess_content_type_finish() with the	263		// is finished by calling g_mount_guess_content_type_finish() with the
264		// @mount and #GAsyncResult data returned in the @callback.	264		// @mount and #GAsyncResult data returned in the @callback.
265	-	func (x MountBase) GuessContentType(ForceRescanVar bool, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	265	+	func (x MountBase) GuessContentType(ForceRescanVar bool, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
266			266
267	-	XGMountGuessContentType(x.GoPointer(), ForceRescanVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	267	+	XGMountGuessContentType(x.GoPointer(), ForceRescanVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
268			268
269		}	269		}
270			270

@@ -342,9 +342,9 @@ func (x *MountBase) IsShadowed() bool {
342		// take affect. While this is semantically equivalent with unmounting	342		// take affect. While this is semantically equivalent with unmounting
343		// and then remounting not all backends might need to actually be	343		// and then remounting not all backends might need to actually be
344		// unmounted.	344		// unmounted.
345	-	func (x MountBase) Remount(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	345	+	func (x MountBase) Remount(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
346			346
347	-	XGMountRemount(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	347	+	XGMountRemount(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
348			348
349		}	349		}
350			350

@@ -374,9 +374,9 @@ func (x *MountBase) Shadow() {
374		// Unmounts a mount. This is an asynchronous operation, and is	374		// Unmounts a mount. This is an asynchronous operation, and is
375		// finished by calling g_mount_unmount_finish() with the @mount	375		// finished by calling g_mount_unmount_finish() with the @mount
376		// and #GAsyncResult data returned in the @callback.	376		// and #GAsyncResult data returned in the @callback.
377	-	func (x MountBase) Unmount(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	377	+	func (x MountBase) Unmount(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
378			378
379	-	XGMountUnmount(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	379	+	XGMountUnmount(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
380			380
381		}	381		}
382			382

@@ -396,9 +396,9 @@ func (x *MountBase) UnmountFinish(ResultVar AsyncResult) (bool, error) {
396		// Unmounts a mount. This is an asynchronous operation, and is	396		// Unmounts a mount. This is an asynchronous operation, and is
397		// finished by calling g_mount_unmount_with_operation_finish() with the @mount	397		// finished by calling g_mount_unmount_with_operation_finish() with the @mount
398		// and #GAsyncResult data returned in the @callback.	398		// and #GAsyncResult data returned in the @callback.
399	-	func (x MountBase) UnmountWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	399	+	func (x MountBase) UnmountWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
400			400
401	-	XGMountUnmountWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	401	+	XGMountUnmountWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
402			402
403		}	403		}
404			404

M v4/gio/gmountoperation.go +67 -18

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // Implementations of GMountOperation should handle this signal
 // by dismissing open password dialogs.
-func (x *MountOperation) ConnectAborted(cb func(MountOperation)) uint32 {
+func (x *MountOperation) ConnectAborted(cb *func(MountOperation)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "aborted", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := MountOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "aborted", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "aborted", cbRefPtr)
 }
 // Emitted when a mount operation asks the user for a password.
 // If the message contains a line break, the first line should be
 // presented as a heading. For example, it may be used as the
 // primary text in a #GtkMessageDialog.
-func (x *MountOperation) ConnectAskPassword(cb func(MountOperation, string, string, string, AskPasswordFlags)) uint32 {
+func (x *MountOperation) ConnectAskPassword(cb *func(MountOperation, string, string, string, AskPasswordFlags)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "ask-password", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MessageVarp string, DefaultUserVarp string, DefaultDomainVarp string, FlagsVarp AskPasswordFlags) {
 		fa := MountOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MessageVarp, DefaultUserVarp, DefaultDomainVarp, FlagsVarp)
+		cbFn(fa, MessageVarp, DefaultUserVarp, DefaultDomainVarp, FlagsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "ask-password", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "ask-password", cbRefPtr)
 }
 // Emitted when asking the user a question and gives a list of
 // If the message contains a line break, the first line should be
 // presented as a heading. For example, it may be used as the
 // primary text in a #GtkMessageDialog.
-func (x *MountOperation) ConnectAskQuestion(cb func(MountOperation, string, uintptr)) uint32 {
+func (x *MountOperation) ConnectAskQuestion(cb *func(MountOperation, string, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "ask-question", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MessageVarp string, ChoicesVarp uintptr) {
 		fa := MountOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MessageVarp, ChoicesVarp)
+		cbFn(fa, MessageVarp, ChoicesVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "ask-question", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "ask-question", cbRefPtr)
 }
 // Emitted when the user has replied to the mount operation.
-func (x *MountOperation) ConnectReply(cb func(MountOperation, MountOperationResult)) uint32 {
+func (x *MountOperation) ConnectReply(cb *func(MountOperation, MountOperationResult)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "reply", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ResultVarp MountOperationResult) {
 		fa := MountOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ResultVarp)
+		cbFn(fa, ResultVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "reply", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "reply", cbRefPtr)
 }
 // Emitted when one or more processes are blocking an operation
 // If the message contains a line break, the first line should be
 // presented as a heading. For example, it may be used as the
 // primary text in a #GtkMessageDialog.
-func (x *MountOperation) ConnectShowProcesses(cb func(MountOperation, string, uintptr, uintptr)) uint32 {
+func (x *MountOperation) ConnectShowProcesses(cb *func(MountOperation, string, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "show-processes", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MessageVarp string, ProcessesVarp uintptr, ChoicesVarp uintptr) {
 		fa := MountOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MessageVarp, ProcessesVarp, ChoicesVarp)
+		cbFn(fa, MessageVarp, ProcessesVarp, ChoicesVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "show-processes", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "show-processes", cbRefPtr)
 }
 // Emitted when an unmount operation has been busy for more than some time
 // If the message contains a line break, the first line should be
 // presented as a heading. For example, it may be used as the
 // primary text in a #GtkMessageDialog.
-func (x *MountOperation) ConnectShowUnmountProgress(cb func(MountOperation, string, int64, int64)) uint32 {
+func (x *MountOperation) ConnectShowUnmountProgress(cb *func(MountOperation, string, int64, int64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "show-unmount-progress", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MessageVarp string, TimeLeftVarp int64, BytesLeftVarp int64) {
 		fa := MountOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MessageVarp, TimeLeftVarp, BytesLeftVarp)
+		cbFn(fa, MessageVarp, TimeLeftVarp, BytesLeftVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "show-unmount-progress", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "show-unmount-progress", cbRefPtr)
 }
 func init() {

M v4/gio/gnetworkmonitor.go +3 -3


@@ -29,7 +29,7 @@ type NetworkMonitor interface {
29		GoPointer() uintptr	29		GoPointer() uintptr
30		SetGoPointer(uintptr)	30		SetGoPointer(uintptr)
31		CanReach(ConnectableVar SocketConnectable, CancellableVar *Cancellable) bool	31		CanReach(ConnectableVar SocketConnectable, CancellableVar *Cancellable) bool
32	-	CanReachAsync(ConnectableVar SocketConnectable, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	32	+	CanReachAsync(ConnectableVar SocketConnectable, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
33		CanReachFinish(ResultVar AsyncResult) bool	33		CanReachFinish(ResultVar AsyncResult) bool
34		GetConnectivity() NetworkConnectivity	34		GetConnectivity() NetworkConnectivity
35		GetNetworkAvailable() bool	35		GetNetworkAvailable() bool

@@ -84,9 +84,9 @@ func (x *NetworkMonitorBase) CanReach(ConnectableVar SocketConnectable, Cancella
84		// When the operation is finished, @callback will be called.	84		// When the operation is finished, @callback will be called.
85		// You can then call g_network_monitor_can_reach_finish()	85		// You can then call g_network_monitor_can_reach_finish()
86		// to get the result of the operation.	86		// to get the result of the operation.
87	-	func (x NetworkMonitorBase) CanReachAsync(ConnectableVar SocketConnectable, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	87	+	func (x NetworkMonitorBase) CanReachAsync(ConnectableVar SocketConnectable, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
88			88
89	-	XGNetworkMonitorCanReachAsync(x.GoPointer(), ConnectableVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	89	+	XGNetworkMonitorCanReachAsync(x.GoPointer(), ConnectableVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
90			90
91		}	91		}
92			92

M v4/gio/goutputstream.go +16 -16


@@ -109,9 +109,9 @@ var xOutputStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
109		// The asynchronous methods have a default fallback that uses threads	109		// The asynchronous methods have a default fallback that uses threads
110		// to implement asynchronicity, so they are optional for inheriting	110		// to implement asynchronicity, so they are optional for inheriting
111		// classes. However, if you override one you must override all.	111		// classes. However, if you override one you must override all.
112	-	func (x OutputStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	112	+	func (x OutputStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
113			113
114	-	xOutputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	114	+	xOutputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
115			115
116		}	116		}
117			117

@@ -160,9 +160,9 @@ var xOutputStreamFlushAsync func(uintptr, int, uintptr, uintptr, uintptr)
160		// When the operation is finished @callback will be	160		// When the operation is finished @callback will be
161		// called. You can then call g_output_stream_flush_finish() to get the	161		// called. You can then call g_output_stream_flush_finish() to get the
162		// result of the operation.	162		// result of the operation.
163	-	func (x OutputStream) FlushAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	163	+	func (x OutputStream) FlushAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
164			164
165	-	xOutputStreamFlushAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	165	+	xOutputStreamFlushAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
166			166
167		}	167		}
168			168

@@ -269,9 +269,9 @@ var xOutputStreamSpliceAsync func(uintptr, uintptr, OutputStreamSpliceFlags, int
269		//	269		//
270		// For the synchronous, blocking version of this function, see	270		// For the synchronous, blocking version of this function, see
271		// g_output_stream_splice().	271		// g_output_stream_splice().
272	-	func (x OutputStream) SpliceAsync(SourceVar InputStream, FlagsVar OutputStreamSpliceFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	272	+	func (x OutputStream) SpliceAsync(SourceVar InputStream, FlagsVar OutputStreamSpliceFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
273			273
274	-	xOutputStreamSpliceAsync(x.GoPointer(), SourceVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	274	+	xOutputStreamSpliceAsync(x.GoPointer(), SourceVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
275			275
276		}	276		}
277			277

@@ -391,9 +391,9 @@ var xOutputStreamWriteAllAsync func(uintptr, uintptr, uint, int, uintptr, uintpt
391		//	391		//
392		// Note that no copy of @buffer will be made, so it must stay valid	392		// Note that no copy of @buffer will be made, so it must stay valid
393		// until @callback is called.	393		// until @callback is called.
394	-	func (x OutputStream) WriteAllAsync(BufferVar uintptr, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	394	+	func (x OutputStream) WriteAllAsync(BufferVar uintptr, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
395			395
396	-	xOutputStreamWriteAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	396	+	xOutputStreamWriteAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
397			397
398		}	398		}
399			399

@@ -457,9 +457,9 @@ var xOutputStreamWriteAsync func(uintptr, uintptr, uint, int, uintptr, uintptr,
457		// until @callback is called. See g_output_stream_write_bytes_async()	457		// until @callback is called. See g_output_stream_write_bytes_async()
458		// for a #GBytes version that will automatically hold a reference to	458		// for a #GBytes version that will automatically hold a reference to
459		// the contents (without copying) for the duration of the call.	459		// the contents (without copying) for the duration of the call.
460	-	func (x OutputStream) WriteAsync(BufferVar uintptr, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	460	+	func (x OutputStream) WriteAsync(BufferVar uintptr, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
461			461
462	-	xOutputStreamWriteAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	462	+	xOutputStreamWriteAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
463			463
464		}	464		}
465			465

@@ -502,9 +502,9 @@ var xOutputStreamWriteBytesAsync func(uintptr, *glib.Bytes, int, uintptr, uintpt
502		//	502		//
503		// For the synchronous, blocking version of this function, see	503		// For the synchronous, blocking version of this function, see
504		// g_output_stream_write_bytes().	504		// g_output_stream_write_bytes().
505	-	func (x OutputStream) WriteBytesAsync(BytesVar glib.Bytes, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	505	+	func (x OutputStream) WriteBytesAsync(BytesVar glib.Bytes, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
506			506
507	-	xOutputStreamWriteBytesAsync(x.GoPointer(), BytesVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	507	+	xOutputStreamWriteBytesAsync(x.GoPointer(), BytesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
508			508
509		}	509		}
510			510

@@ -625,9 +625,9 @@ var xOutputStreamWritevAllAsync func(uintptr, uintptr, uint, int, uintptr, uintp
625		// Note that no copy of @vectors will be made, so it must stay valid	625		// Note that no copy of @vectors will be made, so it must stay valid
626		// until @callback is called. The content of the individual elements	626		// until @callback is called. The content of the individual elements
627		// of @vectors might be changed by this function.	627		// of @vectors might be changed by this function.
628	-	func (x OutputStream) WritevAllAsync(VectorsVar uintptr, NVectorsVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	628	+	func (x OutputStream) WritevAllAsync(VectorsVar uintptr, NVectorsVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
629			629
630	-	xOutputStreamWritevAllAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	630	+	xOutputStreamWritevAllAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
631			631
632		}	632		}
633			633

@@ -686,9 +686,9 @@ var xOutputStreamWritevAsync func(uintptr, uintptr, uint, int, uintptr, uintptr,
686		//	686		//
687		// Note that no copy of @vectors will be made, so it must stay valid	687		// Note that no copy of @vectors will be made, so it must stay valid
688		// until @callback is called.	688		// until @callback is called.
689	-	func (x OutputStream) WritevAsync(VectorsVar uintptr, NVectorsVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	689	+	func (x OutputStream) WritevAsync(VectorsVar uintptr, NVectorsVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
690			690
691	-	xOutputStreamWritevAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	691	+	xOutputStreamWritevAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
692			692
693		}	693		}
694			694

M v4/gio/gpermission.go +4 -4


@@ -86,9 +86,9 @@ var xPermissionAcquireAsync func(uintptr, uintptr, uintptr, uintptr)
86		//	86		//
87		// This is the first half of the asynchronous version of	87		// This is the first half of the asynchronous version of
88		// g_permission_acquire().	88		// g_permission_acquire().
89	-	func (x Permission) AcquireAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	89	+	func (x Permission) AcquireAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
90			90
91	-	xPermissionAcquireAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	91	+	xPermissionAcquireAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
92			92
93		}	93		}
94			94

@@ -190,9 +190,9 @@ var xPermissionReleaseAsync func(uintptr, uintptr, uintptr, uintptr)
190		//	190		//
191		// This is the first half of the asynchronous version of	191		// This is the first half of the asynchronous version of
192		// g_permission_release().	192		// g_permission_release().
193	-	func (x Permission) ReleaseAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	193	+	func (x Permission) ReleaseAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
194			194
195	-	xPermissionReleaseAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	195	+	xPermissionReleaseAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
196			196
197		}	197		}
198			198

M v4/gio/gproxy.go +3 -3


@@ -28,7 +28,7 @@ type Proxy interface {
28		GoPointer() uintptr	28		GoPointer() uintptr
29		SetGoPointer(uintptr)	29		SetGoPointer(uintptr)
30		Connect(ConnectionVar IOStream, ProxyAddressVar ProxyAddress, CancellableVar Cancellable) IOStream	30		Connect(ConnectionVar IOStream, ProxyAddressVar ProxyAddress, CancellableVar Cancellable) IOStream
31	-	ConnectAsync(ConnectionVar IOStream, ProxyAddressVar ProxyAddress, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	31	+	ConnectAsync(ConnectionVar IOStream, ProxyAddressVar ProxyAddress, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
32		ConnectFinish(ResultVar AsyncResult) *IOStream	32		ConnectFinish(ResultVar AsyncResult) *IOStream
33		SupportsHostname() bool	33		SupportsHostname() bool
34		}	34		}

@@ -67,9 +67,9 @@ func (x ProxyBase) Connect(ConnectionVar IOStream, ProxyAddressVar *ProxyAddre
67		}	67		}
68			68
69		// Asynchronous version of g_proxy_connect().	69		// Asynchronous version of g_proxy_connect().
70	-	func (x ProxyBase) ConnectAsync(ConnectionVar IOStream, ProxyAddressVar ProxyAddress, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	70	+	func (x ProxyBase) ConnectAsync(ConnectionVar IOStream, ProxyAddressVar ProxyAddress, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
71			71
72	-	XGProxyConnectAsync(x.GoPointer(), ConnectionVar.GoPointer(), ProxyAddressVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	72	+	XGProxyConnectAsync(x.GoPointer(), ConnectionVar.GoPointer(), ProxyAddressVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
73			73
74		}	74		}
75			75

M v4/gio/gproxyresolver.go +3 -3


@@ -31,7 +31,7 @@ type ProxyResolver interface {
31		SetGoPointer(uintptr)	31		SetGoPointer(uintptr)
32		IsSupported() bool	32		IsSupported() bool
33		Lookup(UriVar string, CancellableVar *Cancellable) uintptr	33		Lookup(UriVar string, CancellableVar *Cancellable) uintptr
34	-	LookupAsync(UriVar string, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	34	+	LookupAsync(UriVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
35		LookupFinish(ResultVar AsyncResult) uintptr	35		LookupFinish(ResultVar AsyncResult) uintptr
36		}	36		}
37		type ProxyResolverBase struct {	37		type ProxyResolverBase struct {

@@ -83,9 +83,9 @@ func (x ProxyResolverBase) Lookup(UriVar string, CancellableVar Cancellable) (
83			83
84		// Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more	84		// Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
85		// details.	85		// details.
86	-	func (x ProxyResolverBase) LookupAsync(UriVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	86	+	func (x ProxyResolverBase) LookupAsync(UriVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
87			87
88	-	XGProxyResolverLookupAsync(x.GoPointer(), UriVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	88	+	XGProxyResolverLookupAsync(x.GoPointer(), UriVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
89			89
90		}	90		}
91			91

M v4/gio/gresolver.go +21 -13

 // Begins asynchronously reverse-resolving @address to determine its
 // associated hostname, and eventually calls @callback, which must
 // call g_resolver_lookup_by_address_finish() to get the final result.
-func (x *Resolver) LookupByAddressAsync(AddressVar *InetAddress, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Resolver) LookupByAddressAsync(AddressVar *InetAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xResolverLookupByAddressAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xResolverLookupByAddressAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // associated IP address(es), and eventually calls @callback, which
 // must call g_resolver_lookup_by_name_finish() to get the result.
 // See g_resolver_lookup_by_name() for more details.
-func (x *Resolver) LookupByNameAsync(HostnameVar string, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Resolver) LookupByNameAsync(HostnameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xResolverLookupByNameAsync(x.GoPointer(), HostnameVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xResolverLookupByNameAsync(x.GoPointer(), HostnameVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // associated IP address(es), and eventually calls @callback, which
 // must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
 // See g_resolver_lookup_by_name() for more details.
-func (x *Resolver) LookupByNameWithFlagsAsync(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Resolver) LookupByNameWithFlagsAsync(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xResolverLookupByNameWithFlagsAsync(x.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xResolverLookupByNameWithFlagsAsync(x.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // @rrname, and eventually calls @callback, which must call
 // g_resolver_lookup_records_finish() to get the final result. See
 // g_resolver_lookup_records() for more details.
-func (x *Resolver) LookupRecordsAsync(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Resolver) LookupRecordsAsync(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xResolverLookupRecordsAsync(x.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xResolverLookupRecordsAsync(x.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // @callback, which must call g_resolver_lookup_service_finish() to
 // get the final result. See g_resolver_lookup_service() for more
 // details.
-func (x *Resolver) LookupServiceAsync(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *Resolver) LookupServiceAsync(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xResolverLookupServiceAsync(x.GoPointer(), ServiceVar, ProtocolVar, DomainVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xResolverLookupServiceAsync(x.GoPointer(), ServiceVar, ProtocolVar, DomainVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // Emitted when the resolver notices that the system resolver
 // configuration has changed.
-func (x *Resolver) ConnectReload(cb func(Resolver)) uint32 {
+func (x *Resolver) ConnectReload(cb *func(Resolver)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "reload", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Resolver{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "reload", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "reload", cbRefPtr)
 }
 var xResolverFreeAddresses func(*glib.List)

M v4/gio/gsettings.go +48 -16

 // and that you can have only one binding per object property.
 // If you bind the same property twice on the same object, the second
 // binding overrides the first one.
-func (x *Settings) BindWithMapping(KeyVar string, ObjectVar *gobject.Object, PropertyVar string, FlagsVar SettingsBindFlags, GetMappingVar SettingsBindGetMapping, SetMappingVar SettingsBindSetMapping, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *Settings) BindWithMapping(KeyVar string, ObjectVar *gobject.Object, PropertyVar string, FlagsVar SettingsBindFlags, GetMappingVar *SettingsBindGetMapping, SetMappingVar *SettingsBindSetMapping, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xSettingsBindWithMapping(x.GoPointer(), KeyVar, ObjectVar.GoPointer(), PropertyVar, FlagsVar, purego.NewCallback(GetMappingVar), purego.NewCallback(SetMappingVar), UserDataVar, purego.NewCallback(DestroyVar))
+	xSettingsBindWithMapping(x.GoPointer(), KeyVar, ObjectVar.GoPointer(), PropertyVar, FlagsVar, glib.NewCallback(GetMappingVar), glib.NewCallback(SetMappingVar), UserDataVar, glib.NewCallback(DestroyVar))
 }
 // to each invocation of @mapping.  The final value of that #gpointer is
 // what is returned by this function.  %NULL is valid; it is returned
 // just as any other value would be.
-func (x *Settings) GetMapped(KeyVar string, MappingVar SettingsGetMapping, UserDataVar uintptr) uintptr {
+func (x *Settings) GetMapped(KeyVar string, MappingVar *SettingsGetMapping, UserDataVar uintptr) uintptr {
-	cret := xSettingsGetMapped(x.GoPointer(), KeyVar, purego.NewCallback(MappingVar), UserDataVar)
+	cret := xSettingsGetMapped(x.GoPointer(), KeyVar, glib.NewCallback(MappingVar), UserDataVar)
 	return cret
 }
 // The default handler for this signal invokes the "changed" signal
 // for each affected key.  If any other connected handler returns
 // %TRUE then this default functionality will be suppressed.
-func (x *Settings) ConnectChangeEvent(cb func(Settings, uintptr, int) bool) uint32 {
+func (x *Settings) ConnectChangeEvent(cb *func(Settings, uintptr, int) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "change-event", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, KeysVarp uintptr, NKeysVarp int) bool {
 		fa := Settings{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, KeysVarp, NKeysVarp)
+		return cbFn(fa, KeysVarp, NKeysVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "change-event", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "change-event", cbRefPtr)
 }
 // The "changed" signal is emitted when a key has potentially changed.
 //
 // Note that @settings only emits this signal if you have read @key at
 // least once while a signal handler was already connected for @key.
-func (x *Settings) ConnectChanged(cb func(Settings, string)) uint32 {
+func (x *Settings) ConnectChanged(cb *func(Settings, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, KeyVarp string) {
 		fa := Settings{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, KeyVarp)
+		cbFn(fa, KeyVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 // The "writable-change-event" signal is emitted once per writability
 // example, a new mandatory setting is introduced).  If any other
 // connected handler returns %TRUE then this default functionality
 // will be suppressed.
-func (x *Settings) ConnectWritableChangeEvent(cb func(Settings, uint) bool) uint32 {
+func (x *Settings) ConnectWritableChangeEvent(cb *func(Settings, uint) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "writable-change-event", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, KeyVarp uint) bool {
 		fa := Settings{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, KeyVarp)
+		return cbFn(fa, KeyVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "writable-change-event", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "writable-change-event", cbRefPtr)
 }
 // The "writable-changed" signal is emitted when the writability of a
 // This signal supports detailed connections.  You can connect to the
 // detailed signal "writable-changed::x" in order to only receive
 // callbacks when the writability of "x" changes.
-func (x *Settings) ConnectWritableChanged(cb func(Settings, string)) uint32 {
+func (x *Settings) ConnectWritableChanged(cb *func(Settings, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "writable-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, KeyVarp string) {
 		fa := Settings{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, KeyVarp)
+		cbFn(fa, KeyVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "writable-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "writable-changed", cbRefPtr)
 }
 var xSettingsListRelocatableSchemas func() uintptr

M v4/gio/gsimpleasyncresult.go +18 -18


@@ -22,9 +22,9 @@ var xSimpleAsyncReportErrorInIdle func(uintptr, uintptr, uintptr, glib.Quark, in
22		// Reports an error in an asynchronous function in an idle function by	22		// Reports an error in an asynchronous function in an idle function by
23		// directly setting the contents of the #GAsyncResult with the given error	23		// directly setting the contents of the #GAsyncResult with the given error
24		// information.	24		// information.
25	-	func SimpleAsyncReportErrorInIdle(ObjectVar *gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {	25	+	func SimpleAsyncReportErrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {
26			26
27	-	xSimpleAsyncReportErrorInIdle(ObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)	27	+	xSimpleAsyncReportErrorInIdle(ObjectVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
28			28
29		}	29		}
30			30

@@ -33,9 +33,9 @@ var xSimpleAsyncReportGerrorInIdle func(uintptr, uintptr, uintptr, *glib.Error)
33		// Reports an error in an idle function. Similar to	33		// Reports an error in an idle function. Similar to
34		// g_simple_async_report_error_in_idle(), but takes a #GError rather	34		// g_simple_async_report_error_in_idle(), but takes a #GError rather
35		// than building a new one.	35		// than building a new one.
36	-	func SimpleAsyncReportGerrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) {	36	+	func SimpleAsyncReportGerrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {
37			37
38	-	xSimpleAsyncReportGerrorInIdle(ObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, ErrorVar)	38	+	xSimpleAsyncReportGerrorInIdle(ObjectVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, ErrorVar)
39			39
40		}	40		}
41			41

@@ -44,9 +44,9 @@ var xSimpleAsyncReportTakeGerrorInIdle func(uintptr, uintptr, uintptr, *glib.Err
44		// Reports an error in an idle function. Similar to	44		// Reports an error in an idle function. Similar to
45		// g_simple_async_report_gerror_in_idle(), but takes over the caller's	45		// g_simple_async_report_gerror_in_idle(), but takes over the caller's
46		// ownership of @error, so the caller does not have to free it any more.	46		// ownership of @error, so the caller does not have to free it any more.
47	-	func SimpleAsyncReportTakeGerrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) {	47	+	func SimpleAsyncReportTakeGerrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {
48			48
49	-	xSimpleAsyncReportTakeGerrorInIdle(ObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, ErrorVar)	49	+	xSimpleAsyncReportTakeGerrorInIdle(ObjectVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, ErrorVar)
50			50
51		}	51		}
52			52

@@ -244,10 +244,10 @@ var xNewSimpleAsyncResult func(uintptr, uintptr, uintptr, uintptr) uintptr
244		// probably should) then you should provide the user's cancellable to	244		// probably should) then you should provide the user's cancellable to
245		// g_simple_async_result_set_check_cancellable() immediately after	245		// g_simple_async_result_set_check_cancellable() immediately after
246		// this function returns.	246		// this function returns.
247	-	func NewSimpleAsyncResult(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, SourceTagVar uintptr) SimpleAsyncResult {	247	+	func NewSimpleAsyncResult(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, SourceTagVar uintptr) *SimpleAsyncResult {
248		var cls *SimpleAsyncResult	248		var cls *SimpleAsyncResult
249			249
250	-	cret := xNewSimpleAsyncResult(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, SourceTagVar)	250	+	cret := xNewSimpleAsyncResult(SourceObjectVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, SourceTagVar)
251			251
252		if cret == 0 {	252		if cret == 0 {
253		return nil	253		return nil

@@ -260,10 +260,10 @@ func NewSimpleAsyncResult(SourceObjectVar *gobject.Object, CallbackVar AsyncRead
260		var xNewSimpleAsyncResultError func(uintptr, uintptr, uintptr, glib.Quark, int, string, ...interface{}) uintptr	260		var xNewSimpleAsyncResultError func(uintptr, uintptr, uintptr, glib.Quark, int, string, ...interface{}) uintptr
261			261
262		// Creates a new #GSimpleAsyncResult with a set error.	262		// Creates a new #GSimpleAsyncResult with a set error.
263	-	func NewSimpleAsyncResultError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) SimpleAsyncResult {	263	+	func NewSimpleAsyncResultError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) *SimpleAsyncResult {
264		var cls *SimpleAsyncResult	264		var cls *SimpleAsyncResult
265			265
266	-	cret := xNewSimpleAsyncResultError(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)	266	+	cret := xNewSimpleAsyncResultError(SourceObjectVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
267			267
268		if cret == 0 {	268		if cret == 0 {
269		return nil	269		return nil

@@ -276,10 +276,10 @@ func NewSimpleAsyncResultError(SourceObjectVar *gobject.Object, CallbackVar Asyn
276		var xNewSimpleAsyncResultFromError func(uintptr, uintptr, uintptr, *glib.Error) uintptr	276		var xNewSimpleAsyncResultFromError func(uintptr, uintptr, uintptr, *glib.Error) uintptr
277			277
278		// Creates a #GSimpleAsyncResult from an error condition.	278		// Creates a #GSimpleAsyncResult from an error condition.
279	-	func NewSimpleAsyncResultFromError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) *SimpleAsyncResult {	279	+	func NewSimpleAsyncResultFromError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) SimpleAsyncResult {
280		var cls *SimpleAsyncResult	280		var cls *SimpleAsyncResult
281			281
282	-	cret := xNewSimpleAsyncResultFromError(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, ErrorVar)	282	+	cret := xNewSimpleAsyncResultFromError(SourceObjectVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, ErrorVar)
283			283
284		if cret == 0 {	284		if cret == 0 {
285		return nil	285		return nil

@@ -293,10 +293,10 @@ var xNewSimpleAsyncResultTakeError func(uintptr, uintptr, uintptr, *glib.Error)
293			293
294		// Creates a #GSimpleAsyncResult from an error condition, and takes over the	294		// Creates a #GSimpleAsyncResult from an error condition, and takes over the
295		// caller's ownership of @error, so the caller does not need to free it anymore.	295		// caller's ownership of @error, so the caller does not need to free it anymore.
296	-	func NewSimpleAsyncResultTakeError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) *SimpleAsyncResult {	296	+	func NewSimpleAsyncResultTakeError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) SimpleAsyncResult {
297		var cls *SimpleAsyncResult	297		var cls *SimpleAsyncResult
298			298
299	-	cret := xNewSimpleAsyncResultTakeError(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, ErrorVar)	299	+	cret := xNewSimpleAsyncResultTakeError(SourceObjectVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, ErrorVar)
300			300
301		if cret == 0 {	301		if cret == 0 {
302		return nil	302		return nil

@@ -399,9 +399,9 @@ var xSimpleAsyncResultRunInThread func(uintptr, uintptr, int, uintptr)
399		//	399		//
400		// Calling this function takes a reference to @simple for as long as	400		// Calling this function takes a reference to @simple for as long as
401		// is needed to run the job and report its completion.	401		// is needed to run the job and report its completion.
402	-	func (x SimpleAsyncResult) RunInThread(FuncVar SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar Cancellable) {	402	+	func (x SimpleAsyncResult) RunInThread(FuncVar SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar *Cancellable) {
403			403
404	-	xSimpleAsyncResultRunInThread(x.GoPointer(), purego.NewCallback(FuncVar), IoPriorityVar, CancellableVar.GoPointer())	404	+	xSimpleAsyncResultRunInThread(x.GoPointer(), glib.NewCallback(FuncVar), IoPriorityVar, CancellableVar.GoPointer())
405			405
406		}	406		}
407			407

@@ -481,9 +481,9 @@ func (x *SimpleAsyncResult) SetOpResGboolean(OpResVar bool) {
481		var xSimpleAsyncResultSetOpResGpointer func(uintptr, uintptr, uintptr)	481		var xSimpleAsyncResultSetOpResGpointer func(uintptr, uintptr, uintptr)
482			482
483		// Sets the operation result within the asynchronous result to a pointer.	483		// Sets the operation result within the asynchronous result to a pointer.
484	-	func (x *SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar glib.DestroyNotify) {	484	+	func (x SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar glib.DestroyNotify) {
485			485
486	-	xSimpleAsyncResultSetOpResGpointer(x.GoPointer(), OpResVar, purego.NewCallback(DestroyOpResVar))	486	+	xSimpleAsyncResultSetOpResGpointer(x.GoPointer(), OpResVar, glib.NewCallback(DestroyOpResVar))
487			487
488		}	488		}
489			489

M v4/gio/gsimpleproxyresolver.go +2 -2


@@ -131,9 +131,9 @@ func (x SimpleProxyResolver) Lookup(UriVar string, CancellableVar Cancellable)
131			131
132		// Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more	132		// Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
133		// details.	133		// details.
134	-	func (x SimpleProxyResolver) LookupAsync(UriVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	134	+	func (x SimpleProxyResolver) LookupAsync(UriVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
135			135
136	-	XGProxyResolverLookupAsync(x.GoPointer(), UriVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	136	+	XGProxyResolverLookupAsync(x.GoPointer(), UriVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
137			137
138		}	138		}
139			139

M v4/gio/gsocketaddressenumerator.go +2 -2


@@ -83,9 +83,9 @@ var xSocketAddressEnumeratorNextAsync func(uintptr, uintptr, uintptr, uintptr)
83		// g_socket_address_enumerator_next_finish() to get the result.	83		// g_socket_address_enumerator_next_finish() to get the result.
84		//	84		//
85		// It is an error to call this multiple times before the previous callback has finished.	85		// It is an error to call this multiple times before the previous callback has finished.
86	-	func (x SocketAddressEnumerator) NextAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	86	+	func (x SocketAddressEnumerator) NextAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
87			87
88	-	xSocketAddressEnumeratorNextAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	88	+	xSocketAddressEnumeratorNextAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
89			89
90		}	90		}
91			91

M v4/gio/gsocketclient.go +19 -11

 // When the operation is finished @callback will be
 // called. You can then call g_socket_client_connect_finish() to get
 // the result of the operation.
-func (x *SocketClient) ConnectAsync(ConnectableVar SocketConnectable, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *SocketClient) ConnectAsync(ConnectableVar SocketConnectable, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSocketClientConnectAsync(x.GoPointer(), ConnectableVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSocketClientConnectAsync(x.GoPointer(), ConnectableVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // When the operation is finished @callback will be
 // called. You can then call g_socket_client_connect_to_host_finish() to get
 // the result of the operation.
-func (x *SocketClient) ConnectToHostAsync(HostAndPortVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *SocketClient) ConnectToHostAsync(HostAndPortVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSocketClientConnectToHostAsync(x.GoPointer(), HostAndPortVar, DefaultPortVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSocketClientConnectToHostAsync(x.GoPointer(), HostAndPortVar, DefaultPortVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // This is the asynchronous version of
 // g_socket_client_connect_to_service().
-func (x *SocketClient) ConnectToServiceAsync(DomainVar string, ServiceVar string, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *SocketClient) ConnectToServiceAsync(DomainVar string, ServiceVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSocketClientConnectToServiceAsync(x.GoPointer(), DomainVar, ServiceVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSocketClientConnectToServiceAsync(x.GoPointer(), DomainVar, ServiceVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // When the operation is finished @callback will be
 // called. You can then call g_socket_client_connect_to_uri_finish() to get
 // the result of the operation.
-func (x *SocketClient) ConnectToUriAsync(UriVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *SocketClient) ConnectToUriAsync(UriVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSocketClientConnectToUriAsync(x.GoPointer(), UriVar, DefaultPortVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSocketClientConnectToUriAsync(x.GoPointer(), UriVar, DefaultPortVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 //
 // Note that there may be additional #GSocketClientEvent values in
 // the future; unrecognized @event values should be ignored.
-func (x *SocketClient) ConnectEvent(cb func(SocketClient, SocketClientEvent, uintptr, uintptr)) uint32 {
+func (x *SocketClient) ConnectEvent(cb *func(SocketClient, SocketClientEvent, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, EventVarp SocketClientEvent, ConnectableVarp uintptr, ConnectionVarp uintptr) {
 		fa := SocketClient{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, EventVarp, ConnectableVarp, ConnectionVarp)
+		cbFn(fa, EventVarp, ConnectableVarp, ConnectionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "event", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
 }
 func init() {

M v4/gio/gsocketconnection.go +2 -2


@@ -73,9 +73,9 @@ var xSocketConnectionConnectAsync func(uintptr, uintptr, uintptr, uintptr, uintp
73		// socket if it is currently set.	73		// socket if it is currently set.
74		//	74		//
75		// Use g_socket_connection_connect_finish() to retrieve the result.	75		// Use g_socket_connection_connect_finish() to retrieve the result.
76	-	func (x SocketConnection) ConnectAsync(AddressVar SocketAddress, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	76	+	func (x SocketConnection) ConnectAsync(AddressVar SocketAddress, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
77			77
78	-	xSocketConnectionConnectAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	78	+	xSocketConnectionConnectAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
79			79
80		}	80		}
81			81

M v4/gio/gsocketlistener.go +15 -7

 // When the operation is finished @callback will be
 // called. You can then call g_socket_listener_accept_finish()
 // to get the result of the operation.
-func (x *SocketListener) AcceptAsync(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *SocketListener) AcceptAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSocketListenerAcceptAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSocketListenerAcceptAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // When the operation is finished @callback will be
 // called. You can then call g_socket_listener_accept_socket_finish()
 // to get the result of the operation.
-func (x *SocketListener) AcceptSocketAsync(CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *SocketListener) AcceptSocketAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xSocketListenerAcceptSocketAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xSocketListenerAcceptSocketAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // Note that when @listener is used to listen on both IPv4 and
 // IPv6, a separate set of signals will be emitted for each, and
 // the order they happen in is undefined.
-func (x *SocketListener) ConnectEvent(cb func(SocketListener, SocketListenerEvent, uintptr)) uint32 {
+func (x *SocketListener) ConnectEvent(cb *func(SocketListener, SocketListenerEvent, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, EventVarp SocketListenerEvent, SocketVarp uintptr) {
 		fa := SocketListener{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, EventVarp, SocketVarp)
+		cbFn(fa, EventVarp, SocketVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "event", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
 }
 func init() {

M v4/gio/gsocketservice.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // @connection will be unreffed once the signal handler returns,
 // so you need to ref it yourself if you are planning to use it.
-func (x *SocketService) ConnectIncoming(cb func(SocketService, uintptr, uintptr) bool) uint32 {
+func (x *SocketService) ConnectIncoming(cb *func(SocketService, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "incoming", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ConnectionVarp uintptr, SourceObjectVarp uintptr) bool {
 		fa := SocketService{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ConnectionVarp, SourceObjectVarp)
+		return cbFn(fa, ConnectionVarp, SourceObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "incoming", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "incoming", cbRefPtr)
 }
 func init() {

M v4/gio/gtask.go +16 -16


@@ -569,10 +569,10 @@ var xNewTask func(uintptr, uintptr, uintptr, uintptr) uintptr
569		// other objects that the task depends on have been destroyed. If you	569		// other objects that the task depends on have been destroyed. If you
570		// do not want this behavior, you can use	570		// do not want this behavior, you can use
571		// g_task_set_check_cancellable() to change it.	571		// g_task_set_check_cancellable() to change it.
572	-	func NewTask(SourceObjectVar gobject.Object, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr) *Task {	572	+	func NewTask(SourceObjectVar gobject.Object, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr) Task {
573		var cls *Task	573		var cls *Task
574			574
575	-	cret := xNewTask(SourceObjectVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), CallbackDataVar)	575	+	cret := xNewTask(SourceObjectVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), CallbackDataVar)
576			576
577		if cret == 0 {	577		if cret == 0 {
578		return nil	578		return nil

@@ -593,9 +593,9 @@ var xTaskAttachSource func(uintptr, *glib.Source, uintptr)
593		// g_task_set_name()), if one has been set.	593		// g_task_set_name()), if one has been set.
594		//	594		//
595		// This takes a reference on @task until @source is destroyed.	595		// This takes a reference on @task until @source is destroyed.
596	-	func (x Task) AttachSource(SourceVar glib.Source, CallbackVar glib.SourceFunc) {	596	+	func (x Task) AttachSource(SourceVar glib.Source, CallbackVar *glib.SourceFunc) {
597			597
598	-	xTaskAttachSource(x.GoPointer(), SourceVar, purego.NewCallback(CallbackVar))	598	+	xTaskAttachSource(x.GoPointer(), SourceVar, glib.NewCallback(CallbackVar))
599			599
600		}	600		}
601			601

@@ -896,9 +896,9 @@ var xTaskReturnPointer func(uintptr, uintptr, uintptr)
896		// g_task_return_pointer(), you cannot assume that @result is still	896		// g_task_return_pointer(), you cannot assume that @result is still
897		// valid after calling this, unless you are still holding another	897		// valid after calling this, unless you are still holding another
898		// reference on it.	898		// reference on it.
899	-	func (x *Task) ReturnPointer(ResultVar uintptr, ResultDestroyVar glib.DestroyNotify) {	899	+	func (x Task) ReturnPointer(ResultVar uintptr, ResultDestroyVar glib.DestroyNotify) {
900			900
901	-	xTaskReturnPointer(x.GoPointer(), ResultVar, purego.NewCallback(ResultDestroyVar))	901	+	xTaskReturnPointer(x.GoPointer(), ResultVar, glib.NewCallback(ResultDestroyVar))
902			902
903		}	903		}
904			904

@@ -932,9 +932,9 @@ var xTaskRunInThread func(uintptr, uintptr)
932		// do this. If you have a very large number of tasks to run (several tens of	932		// do this. If you have a very large number of tasks to run (several tens of
933		// tasks), but don't want them to all run at once, you should only queue a	933		// tasks), but don't want them to all run at once, you should only queue a
934		// limited number of them (around ten) at a time.	934		// limited number of them (around ten) at a time.
935	-	func (x *Task) RunInThread(TaskFuncVar TaskThreadFunc) {	935	+	func (x Task) RunInThread(TaskFuncVar TaskThreadFunc) {
936			936
937	-	xTaskRunInThread(x.GoPointer(), purego.NewCallback(TaskFuncVar))	937	+	xTaskRunInThread(x.GoPointer(), glib.NewCallback(TaskFuncVar))
938			938
939		}	939		}
940			940

@@ -956,9 +956,9 @@ var xTaskRunInThreadSync func(uintptr, uintptr)
956		// always do this. If you have a very large number of tasks to run,	956		// always do this. If you have a very large number of tasks to run,
957		// but don't want them to all run at once, you should only queue a	957		// but don't want them to all run at once, you should only queue a
958		// limited number of them at a time.	958		// limited number of them at a time.
959	-	func (x *Task) RunInThreadSync(TaskFuncVar TaskThreadFunc) {	959	+	func (x Task) RunInThreadSync(TaskFuncVar TaskThreadFunc) {
960			960
961	-	xTaskRunInThreadSync(x.GoPointer(), purego.NewCallback(TaskFuncVar))	961	+	xTaskRunInThreadSync(x.GoPointer(), glib.NewCallback(TaskFuncVar))
962			962
963		}	963		}
964			964

@@ -1076,9 +1076,9 @@ func (x *Task) SetSourceTag(SourceTagVar uintptr) {
1076		var xTaskSetTaskData func(uintptr, uintptr, uintptr)	1076		var xTaskSetTaskData func(uintptr, uintptr, uintptr)
1077			1077
1078		// Sets @task's task data (freeing the existing task data, if any).	1078		// Sets @task's task data (freeing the existing task data, if any).
1079	-	func (x *Task) SetTaskData(TaskDataVar uintptr, TaskDataDestroyVar glib.DestroyNotify) {	1079	+	func (x Task) SetTaskData(TaskDataVar uintptr, TaskDataDestroyVar glib.DestroyNotify) {
1080			1080
1081	-	xTaskSetTaskData(x.GoPointer(), TaskDataVar, purego.NewCallback(TaskDataDestroyVar))	1081	+	xTaskSetTaskData(x.GoPointer(), TaskDataVar, glib.NewCallback(TaskDataDestroyVar))
1082			1082
1083		}	1083		}
1084			1084

@@ -1147,9 +1147,9 @@ var xTaskReportError func(uintptr, uintptr, uintptr, uintptr, *glib.Error)
1147		// wrapper method, and deal with it appropriately if so.	1147		// wrapper method, and deal with it appropriately if so.
1148		//	1148		//
1149		// See also g_task_report_new_error().	1149		// See also g_task_report_new_error().
1150	-	func TaskReportError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, ErrorVar glib.Error) {	1150	+	func TaskReportError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, ErrorVar *glib.Error) {
1151			1151
1152	-	xTaskReportError(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), CallbackDataVar, SourceTagVar, ErrorVar)	1152	+	xTaskReportError(SourceObjectVar.GoPointer(), glib.NewCallback(CallbackVar), CallbackDataVar, SourceTagVar, ErrorVar)
1153			1153
1154		}	1154		}
1155			1155

@@ -1164,9 +1164,9 @@ var xTaskReportNewError func(uintptr, uintptr, uintptr, uintptr, glib.Quark, int
1164		// appropriately if so.	1164		// appropriately if so.
1165		//	1165		//
1166		// See also g_task_report_error().	1166		// See also g_task_report_error().
1167	-	func TaskReportNewError(SourceObjectVar *gobject.Object, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {	1167	+	func TaskReportNewError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {
1168			1168
1169	-	xTaskReportNewError(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), CallbackDataVar, SourceTagVar, DomainVar, CodeVar, FormatVar, varArgs...)	1169	+	xTaskReportNewError(SourceObjectVar.GoPointer(), glib.NewCallback(CallbackVar), CallbackDataVar, SourceTagVar, DomainVar, CodeVar, FormatVar, varArgs...)
1170			1170
1171		}	1171		}
1172			1172

M v4/gio/gthreadedsocketservice.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // incoming connection. This thread is dedicated to handling
 // @connection and may perform blocking IO. The signal handler need
 // not return until the connection is closed.
-func (x *ThreadedSocketService) ConnectRun(cb func(ThreadedSocketService, uintptr, uintptr) bool) uint32 {
+func (x *ThreadedSocketService) ConnectRun(cb *func(ThreadedSocketService, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "run", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ConnectionVarp uintptr, SourceObjectVarp uintptr) bool {
 		fa := ThreadedSocketService{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ConnectionVarp, SourceObjectVarp)
+		return cbFn(fa, ConnectionVarp, SourceObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "run", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "run", cbRefPtr)
 }
 func init() {

M v4/gio/gtlsconnection.go +13 -5

 // Asynchronously performs a TLS handshake on @conn. See
 // g_tls_connection_handshake() for more information.
-func (x *TlsConnection) HandshakeAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
+func (x *TlsConnection) HandshakeAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xTlsConnectionHandshakeAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)
+	xTlsConnectionHandshakeAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
 }
 // If you are doing I/O in another thread, you do not
 // need to worry about this, and can simply block in the signal
 // handler until the UI thread returns an answer.
-func (x *TlsConnection) ConnectAcceptCertificate(cb func(TlsConnection, uintptr, TlsCertificateFlags) bool) uint32 {
+func (x *TlsConnection) ConnectAcceptCertificate(cb *func(TlsConnection, uintptr, TlsCertificateFlags) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "accept-certificate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PeerCertVarp uintptr, ErrorsVarp TlsCertificateFlags) bool {
 		fa := TlsConnection{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PeerCertVarp, ErrorsVarp)
+		return cbFn(fa, PeerCertVarp, ErrorsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "accept-certificate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "accept-certificate", cbRefPtr)
 }
 func init() {

M v4/gio/gtlsdatabase.go +8 -8


@@ -110,9 +110,9 @@ var xTlsDatabaseLookupCertificateForHandleAsync func(uintptr, string, uintptr, T
110			110
111		// Asynchronously look up a certificate by its handle in the database. See	111		// Asynchronously look up a certificate by its handle in the database. See
112		// g_tls_database_lookup_certificate_for_handle() for more information.	112		// g_tls_database_lookup_certificate_for_handle() for more information.
113	-	func (x TlsDatabase) LookupCertificateForHandleAsync(HandleVar string, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	113	+	func (x TlsDatabase) LookupCertificateForHandleAsync(HandleVar string, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
114			114
115	-	xTlsDatabaseLookupCertificateForHandleAsync(x.GoPointer(), HandleVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	115	+	xTlsDatabaseLookupCertificateForHandleAsync(x.GoPointer(), HandleVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
116			116
117		}	117		}
118			118

@@ -185,9 +185,9 @@ var xTlsDatabaseLookupCertificateIssuerAsync func(uintptr, uintptr, uintptr, Tls
185			185
186		// Asynchronously look up the issuer of @certificate in the database. See	186		// Asynchronously look up the issuer of @certificate in the database. See
187		// g_tls_database_lookup_certificate_issuer() for more information.	187		// g_tls_database_lookup_certificate_issuer() for more information.
188	-	func (x TlsDatabase) LookupCertificateIssuerAsync(CertificateVar TlsCertificate, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	188	+	func (x TlsDatabase) LookupCertificateIssuerAsync(CertificateVar TlsCertificate, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
189			189
190	-	xTlsDatabaseLookupCertificateIssuerAsync(x.GoPointer(), CertificateVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	190	+	xTlsDatabaseLookupCertificateIssuerAsync(x.GoPointer(), CertificateVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
191			191
192		}	192		}
193			193

@@ -238,9 +238,9 @@ var xTlsDatabaseLookupCertificatesIssuedByAsync func(uintptr, uintptr, uintptr,
238		// The database may choose to hold a reference to the issuer byte array for the duration	238		// The database may choose to hold a reference to the issuer byte array for the duration
239		// of of this asynchronous operation. The byte array should not be modified during	239		// of of this asynchronous operation. The byte array should not be modified during
240		// this time.	240		// this time.
241	-	func (x TlsDatabase) LookupCertificatesIssuedByAsync(IssuerRawDnVar uintptr, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	241	+	func (x TlsDatabase) LookupCertificatesIssuedByAsync(IssuerRawDnVar uintptr, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
242			242
243	-	xTlsDatabaseLookupCertificatesIssuedByAsync(x.GoPointer(), IssuerRawDnVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	243	+	xTlsDatabaseLookupCertificatesIssuedByAsync(x.GoPointer(), IssuerRawDnVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
244			244
245		}	245		}
246			246

@@ -337,9 +337,9 @@ var xTlsDatabaseVerifyChainAsync func(uintptr, uintptr, string, uintptr, uintptr
337		// Asynchronously determines the validity of a certificate chain after	337		// Asynchronously determines the validity of a certificate chain after
338		// looking up and adding any missing certificates to the chain. See	338		// looking up and adding any missing certificates to the chain. See
339		// g_tls_database_verify_chain() for more information.	339		// g_tls_database_verify_chain() for more information.
340	-	func (x TlsDatabase) VerifyChainAsync(ChainVar TlsCertificate, PurposeVar string, IdentityVar SocketConnectable, InteractionVar TlsInteraction, FlagsVar TlsDatabaseVerifyFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	340	+	func (x TlsDatabase) VerifyChainAsync(ChainVar TlsCertificate, PurposeVar string, IdentityVar SocketConnectable, InteractionVar TlsInteraction, FlagsVar TlsDatabaseVerifyFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
341			341
342	-	xTlsDatabaseVerifyChainAsync(x.GoPointer(), ChainVar.GoPointer(), PurposeVar, IdentityVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	342	+	xTlsDatabaseVerifyChainAsync(x.GoPointer(), ChainVar.GoPointer(), PurposeVar, IdentityVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
343			343
344		}	344		}
345			345

M v4/gio/gtlsinteraction.go +4 -4


@@ -114,9 +114,9 @@ var xTlsInteractionAskPasswordAsync func(uintptr, uintptr, uintptr, uintptr, uin
114		// not support immediate cancellation.	114		// not support immediate cancellation.
115		//	115		//
116		// Certain implementations may not support immediate cancellation.	116		// Certain implementations may not support immediate cancellation.
117	-	func (x TlsInteraction) AskPasswordAsync(PasswordVar TlsPassword, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	117	+	func (x TlsInteraction) AskPasswordAsync(PasswordVar TlsPassword, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
118			118
119	-	xTlsInteractionAskPasswordAsync(x.GoPointer(), PasswordVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	119	+	xTlsInteractionAskPasswordAsync(x.GoPointer(), PasswordVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
120			120
121		}	121		}
122			122

@@ -246,9 +246,9 @@ var xTlsInteractionRequestCertificateAsync func(uintptr, uintptr, TlsCertificate
246		// also choose to provide a certificate from elsewhere. @callback will be called	246		// also choose to provide a certificate from elsewhere. @callback will be called
247		// when the operation completes. Alternatively the user may abort this certificate	247		// when the operation completes. Alternatively the user may abort this certificate
248		// request, which will usually abort the TLS connection.	248		// request, which will usually abort the TLS connection.
249	-	func (x TlsInteraction) RequestCertificateAsync(ConnectionVar TlsConnection, FlagsVar TlsCertificateRequestFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	249	+	func (x TlsInteraction) RequestCertificateAsync(ConnectionVar TlsConnection, FlagsVar TlsCertificateRequestFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
250			250
251	-	xTlsInteractionRequestCertificateAsync(x.GoPointer(), ConnectionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	251	+	xTlsInteractionRequestCertificateAsync(x.GoPointer(), ConnectionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
252			252
253		}	253		}
254			254

M v4/gio/gtlspassword.go +2 -2


@@ -141,9 +141,9 @@ var xTlsPasswordSetValueFull func(uintptr, uintptr, int, uintptr)
141		// @length if using a nul-terminated password, and @length will be	141		// @length if using a nul-terminated password, and @length will be
142		// calculated automatically. (Note that the terminating nul is not	142		// calculated automatically. (Note that the terminating nul is not
143		// considered part of the password in this case.)	143		// considered part of the password in this case.)
144	-	func (x *TlsPassword) SetValueFull(ValueVar uintptr, LengthVar int, DestroyVar glib.DestroyNotify) {	144	+	func (x TlsPassword) SetValueFull(ValueVar uintptr, LengthVar int, DestroyVar glib.DestroyNotify) {
145			145
146	-	xTlsPasswordSetValueFull(x.GoPointer(), ValueVar, LengthVar, purego.NewCallback(DestroyVar))	146	+	xTlsPasswordSetValueFull(x.GoPointer(), ValueVar, LengthVar, glib.NewCallback(DestroyVar))
147			147
148		}	148		}
149			149

M v4/gio/gunixconnection.go +4 -4


@@ -93,9 +93,9 @@ var xUnixConnectionReceiveCredentialsAsync func(uintptr, uintptr, uintptr, uintp
93		//	93		//
94		// When the operation is finished, @callback will be called. You can then call	94		// When the operation is finished, @callback will be called. You can then call
95		// g_unix_connection_receive_credentials_finish() to get the result of the operation.	95		// g_unix_connection_receive_credentials_finish() to get the result of the operation.
96	-	func (x UnixConnection) ReceiveCredentialsAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	96	+	func (x UnixConnection) ReceiveCredentialsAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
97			97
98	-	xUnixConnectionReceiveCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	98	+	xUnixConnectionReceiveCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
99			99
100		}	100		}
101			101

@@ -182,9 +182,9 @@ var xUnixConnectionSendCredentialsAsync func(uintptr, uintptr, uintptr, uintptr)
182		//	182		//
183		// When the operation is finished, @callback will be called. You can then call	183		// When the operation is finished, @callback will be called. You can then call
184		// g_unix_connection_send_credentials_finish() to get the result of the operation.	184		// g_unix_connection_send_credentials_finish() to get the result of the operation.
185	-	func (x UnixConnection) SendCredentialsAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	185	+	func (x UnixConnection) SendCredentialsAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
186			186
187	-	xUnixConnectionSendCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	187	+	xUnixConnectionSendCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
188			188
189		}	189		}
190			190

M v4/gio/gunixmounts.go +22 -6

 }
 // Emitted when the unix mount points have changed.
-func (x *UnixMountMonitor) ConnectMountpointsChanged(cb func(UnixMountMonitor)) uint32 {
+func (x *UnixMountMonitor) ConnectMountpointsChanged(cb *func(UnixMountMonitor)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mountpoints-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := UnixMountMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mountpoints-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mountpoints-changed", cbRefPtr)
 }
 // Emitted when the unix mounts have changed.
-func (x *UnixMountMonitor) ConnectMountsChanged(cb func(UnixMountMonitor)) uint32 {
+func (x *UnixMountMonitor) ConnectMountsChanged(cb *func(UnixMountMonitor)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mounts-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := UnixMountMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mounts-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mounts-changed", cbRefPtr)
 }
 var xUnixMountMonitorGet func() uintptr

M v4/gio/gvfs.go +2 -2


@@ -137,9 +137,9 @@ var xVfsRegisterUriScheme func(uintptr, string, uintptr, uintptr, uintptr, uintp
137		//	137		//
138		// It's an error to call this function twice with the same scheme. To unregister	138		// It's an error to call this function twice with the same scheme. To unregister
139		// a custom URI scheme, use g_vfs_unregister_uri_scheme().	139		// a custom URI scheme, use g_vfs_unregister_uri_scheme().
140	-	func (x *Vfs) RegisterUriScheme(SchemeVar string, UriFuncVar VfsFileLookupFunc, UriDataVar uintptr, UriDestroyVar glib.DestroyNotify, ParseNameFuncVar VfsFileLookupFunc, ParseNameDataVar uintptr, ParseNameDestroyVar glib.DestroyNotify) bool {	140	+	func (x Vfs) RegisterUriScheme(SchemeVar string, UriFuncVar VfsFileLookupFunc, UriDataVar uintptr, UriDestroyVar glib.DestroyNotify, ParseNameFuncVar VfsFileLookupFunc, ParseNameDataVar uintptr, ParseNameDestroyVar *glib.DestroyNotify) bool {
141			141
142	-	cret := xVfsRegisterUriScheme(x.GoPointer(), SchemeVar, purego.NewCallback(UriFuncVar), UriDataVar, purego.NewCallback(UriDestroyVar), purego.NewCallback(ParseNameFuncVar), ParseNameDataVar, purego.NewCallback(ParseNameDestroyVar))	142	+	cret := xVfsRegisterUriScheme(x.GoPointer(), SchemeVar, glib.NewCallback(UriFuncVar), UriDataVar, glib.NewCallback(UriDestroyVar), glib.NewCallback(ParseNameFuncVar), ParseNameDataVar, glib.NewCallback(ParseNameDestroyVar))
143		return cret	143		return cret
144		}	144		}
145			145

M v4/gio/gvolume.go +9 -9


@@ -63,9 +63,9 @@ type Volume interface {
63		SetGoPointer(uintptr)	63		SetGoPointer(uintptr)
64		CanEject() bool	64		CanEject() bool
65		CanMount() bool	65		CanMount() bool
66	-	Eject(FlagsVar MountUnmountFlags, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	66	+	Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
67		EjectFinish(ResultVar AsyncResult) bool	67		EjectFinish(ResultVar AsyncResult) bool
68	-	EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	68	+	EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
69		EjectWithOperationFinish(ResultVar AsyncResult) bool	69		EjectWithOperationFinish(ResultVar AsyncResult) bool
70		EnumerateIdentifiers() []string	70		EnumerateIdentifiers() []string
71		GetActivationRoot() *FileBase	71		GetActivationRoot() *FileBase

@@ -77,7 +77,7 @@ type Volume interface {
77		GetSortKey() string	77		GetSortKey() string
78		GetSymbolicIcon() *IconBase	78		GetSymbolicIcon() *IconBase
79		GetUuid() string	79		GetUuid() string
80	-	Mount(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	80	+	Mount(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
81		MountFinish(ResultVar AsyncResult) bool	81		MountFinish(ResultVar AsyncResult) bool
82		ShouldAutomount() bool	82		ShouldAutomount() bool
83		}	83		}

@@ -110,9 +110,9 @@ func (x *VolumeBase) CanMount() bool {
110		// Ejects a volume. This is an asynchronous operation, and is	110		// Ejects a volume. This is an asynchronous operation, and is
111		// finished by calling g_volume_eject_finish() with the @volume	111		// finished by calling g_volume_eject_finish() with the @volume
112		// and #GAsyncResult returned in the @callback.	112		// and #GAsyncResult returned in the @callback.
113	-	func (x VolumeBase) Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	113	+	func (x VolumeBase) Eject(FlagsVar MountUnmountFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
114			114
115	-	XGVolumeEject(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	115	+	XGVolumeEject(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
116			116
117		}	117		}
118			118

@@ -132,9 +132,9 @@ func (x *VolumeBase) EjectFinish(ResultVar AsyncResult) (bool, error) {
132		// Ejects a volume. This is an asynchronous operation, and is	132		// Ejects a volume. This is an asynchronous operation, and is
133		// finished by calling g_volume_eject_with_operation_finish() with the @volume	133		// finished by calling g_volume_eject_with_operation_finish() with the @volume
134		// and #GAsyncResult data returned in the @callback.	134		// and #GAsyncResult data returned in the @callback.
135	-	func (x VolumeBase) EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	135	+	func (x VolumeBase) EjectWithOperation(FlagsVar MountUnmountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
136			136
137	-	XGVolumeEjectWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	137	+	XGVolumeEjectWithOperation(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
138			138
139		}	139		}
140			140

@@ -294,9 +294,9 @@ func (x *VolumeBase) GetUuid() string {
294		// Mounts a volume. This is an asynchronous operation, and is	294		// Mounts a volume. This is an asynchronous operation, and is
295		// finished by calling g_volume_mount_finish() with the @volume	295		// finished by calling g_volume_mount_finish() with the @volume
296		// and #GAsyncResult returned in the @callback.	296		// and #GAsyncResult returned in the @callback.
297	-	func (x VolumeBase) Mount(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar *Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	297	+	func (x VolumeBase) Mount(FlagsVar MountMountFlags, MountOperationVar MountOperation, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
298			298
299	-	XGVolumeMount(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	299	+	XGVolumeMount(x.GoPointer(), FlagsVar, MountOperationVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
300			300
301		}	301		}
302			302

M v4/gio/gvolumemonitor.go +132 -36

 }
 // Emitted when a drive changes.
-func (x *VolumeMonitor) ConnectDriveChanged(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectDriveChanged(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drive-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DriveVarp)
+		cbFn(fa, DriveVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drive-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drive-changed", cbRefPtr)
 }
 // Emitted when a drive is connected to the system.
-func (x *VolumeMonitor) ConnectDriveConnected(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectDriveConnected(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drive-connected", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DriveVarp)
+		cbFn(fa, DriveVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drive-connected", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drive-connected", cbRefPtr)
 }
 // Emitted when a drive is disconnected from the system.
-func (x *VolumeMonitor) ConnectDriveDisconnected(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectDriveDisconnected(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drive-disconnected", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DriveVarp)
+		cbFn(fa, DriveVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drive-disconnected", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drive-disconnected", cbRefPtr)
 }
 // Emitted when the eject button is pressed on @drive.
-func (x *VolumeMonitor) ConnectDriveEjectButton(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectDriveEjectButton(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drive-eject-button", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DriveVarp)
+		cbFn(fa, DriveVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drive-eject-button", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drive-eject-button", cbRefPtr)
 }
 // Emitted when the stop button is pressed on @drive.
-func (x *VolumeMonitor) ConnectDriveStopButton(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectDriveStopButton(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drive-stop-button", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DriveVarp)
+		cbFn(fa, DriveVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drive-stop-button", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drive-stop-button", cbRefPtr)
 }
 // Emitted when a mount is added.
-func (x *VolumeMonitor) ConnectMountAdded(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectMountAdded(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mount-added", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MountVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MountVarp)
+		cbFn(fa, MountVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mount-added", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mount-added", cbRefPtr)
 }
 // Emitted when a mount changes.
-func (x *VolumeMonitor) ConnectMountChanged(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectMountChanged(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mount-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MountVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MountVarp)
+		cbFn(fa, MountVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mount-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mount-changed", cbRefPtr)
 }
 // May be emitted when a mount is about to be removed.
 //
 // This signal depends on the backend and is only emitted if
 // GIO was used to unmount.
-func (x *VolumeMonitor) ConnectMountPreUnmount(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectMountPreUnmount(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mount-pre-unmount", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MountVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MountVarp)
+		cbFn(fa, MountVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mount-pre-unmount", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mount-pre-unmount", cbRefPtr)
 }
 // Emitted when a mount is removed.
-func (x *VolumeMonitor) ConnectMountRemoved(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectMountRemoved(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mount-removed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MountVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MountVarp)
+		cbFn(fa, MountVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mount-removed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mount-removed", cbRefPtr)
 }
 // Emitted when a mountable volume is added to the system.
-func (x *VolumeMonitor) ConnectVolumeAdded(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectVolumeAdded(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "volume-added", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, VolumeVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, VolumeVarp)
+		cbFn(fa, VolumeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "volume-added", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "volume-added", cbRefPtr)
 }
 // Emitted when mountable volume is changed.
-func (x *VolumeMonitor) ConnectVolumeChanged(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectVolumeChanged(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "volume-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, VolumeVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, VolumeVarp)
+		cbFn(fa, VolumeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "volume-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "volume-changed", cbRefPtr)
 }
 // Emitted when a mountable volume is removed from the system.
-func (x *VolumeMonitor) ConnectVolumeRemoved(cb func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectVolumeRemoved(cb *func(VolumeMonitor, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "volume-removed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, VolumeVarp uintptr) {
 		fa := VolumeMonitor{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, VolumeVarp)
+		cbFn(fa, VolumeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "volume-removed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "volume-removed", cbRefPtr)
 }
 var xVolumeMonitorAdoptOrphanMount func(uintptr) uintptr

M v4/glib/garray.go +4 -4


@@ -115,9 +115,9 @@ var xNewBytesWithFreeFunc func(uintptr, uint, uintptr, uintptr) *Bytes
115		// been called to indicate that the bytes is no longer in use.	115		// been called to indicate that the bytes is no longer in use.
116		//	116		//
117		// @data may be %NULL if @size is 0.	117		// @data may be %NULL if @size is 0.
118	-	func NewBytesWithFreeFunc(DataVar uintptr, SizeVar uint, FreeFuncVar DestroyNotify, UserDataVar uintptr) *Bytes {	118	+	func NewBytesWithFreeFunc(DataVar uintptr, SizeVar uint, FreeFuncVar DestroyNotify, UserDataVar uintptr) Bytes {
119			119
120	-	cret := xNewBytesWithFreeFunc(DataVar, SizeVar, purego.NewCallback(FreeFuncVar), UserDataVar)	120	+	cret := xNewBytesWithFreeFunc(DataVar, SizeVar, NewCallback(FreeFuncVar), UserDataVar)
121		return cret	121		return cret
122		}	122		}
123			123

@@ -400,9 +400,9 @@ var xPtrArrayFindWithEqualFunc func(uintptr, uintptr, uintptr, uint) bool
400		// @equal_func is called with the element from the array as its first parameter,	400		// @equal_func is called with the element from the array as its first parameter,
401		// and @needle as its second parameter. If @equal_func is %NULL, pointer	401		// and @needle as its second parameter. If @equal_func is %NULL, pointer
402		// equality is used.	402		// equality is used.
403	-	func PtrArrayFindWithEqualFunc(HaystackVar uintptr, NeedleVar uintptr, EqualFuncVar EqualFunc, IndexVar uint) bool {	403	+	func PtrArrayFindWithEqualFunc(HaystackVar uintptr, NeedleVar uintptr, EqualFuncVar *EqualFunc, IndexVar uint) bool {
404			404
405	-	cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, purego.NewCallback(EqualFuncVar), IndexVar)	405	+	cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, NewCallback(EqualFuncVar), IndexVar)
406		return cret	406		return cret
407		}	407		}
408			408

M v4/glib/gasyncqueue.go +8 -8


@@ -138,9 +138,9 @@ var xAsyncQueuePushSorted func(uintptr, uintptr, uintptr, uintptr)
138		// it when it is finished.	138		// it when it is finished.
139		//	139		//
140		// For an example of @func see g_async_queue_sort().	140		// For an example of @func see g_async_queue_sort().
141	-	func (x *AsyncQueue) PushSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {	141	+	func (x AsyncQueue) PushSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
142			142
143	-	xAsyncQueuePushSorted(x.GoPointer(), DataVar, purego.NewCallback(FuncVar), UserDataVar)	143	+	xAsyncQueuePushSorted(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)
144			144
145		}	145		}
146			146

@@ -161,9 +161,9 @@ var xAsyncQueuePushSortedUnlocked func(uintptr, uintptr, uintptr, uintptr)
161		// This function must be called while holding the @queue's lock.	161		// This function must be called while holding the @queue's lock.
162		//	162		//
163		// For an example of @func see g_async_queue_sort().	163		// For an example of @func see g_async_queue_sort().
164	-	func (x *AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {	164	+	func (x AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
165			165
166	-	xAsyncQueuePushSortedUnlocked(x.GoPointer(), DataVar, purego.NewCallback(FuncVar), UserDataVar)	166	+	xAsyncQueuePushSortedUnlocked(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)
167			167
168		}	168		}
169			169

@@ -243,9 +243,9 @@ var xAsyncQueueSort func(uintptr, uintptr, uintptr)
243		// return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);	243		// return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
244		//	244		//
245		// ]\|	245		// ]\|
246	-	func (x *AsyncQueue) Sort(FuncVar CompareDataFunc, UserDataVar uintptr) {	246	+	func (x AsyncQueue) Sort(FuncVar CompareDataFunc, UserDataVar uintptr) {
247			247
248	-	xAsyncQueueSort(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	248	+	xAsyncQueueSort(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
249			249
250		}	250		}
251			251

@@ -260,9 +260,9 @@ var xAsyncQueueSortUnlocked func(uintptr, uintptr, uintptr)
260		// element.	260		// element.
261		//	261		//
262		// This function must be called while holding the @queue's lock.	262		// This function must be called while holding the @queue's lock.
263	-	func (x *AsyncQueue) SortUnlocked(FuncVar CompareDataFunc, UserDataVar uintptr) {	263	+	func (x AsyncQueue) SortUnlocked(FuncVar CompareDataFunc, UserDataVar uintptr) {
264			264
265	-	xAsyncQueueSortUnlocked(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	265	+	xAsyncQueueSortUnlocked(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
266			266
267		}	267		}
268			268

M v4/glib/gdataset.go +12 -12


@@ -59,9 +59,9 @@ var xDatalistForeach func(**Data, uintptr, uintptr)
59		// @func can make changes to @datalist, but the iteration will not	59		// @func can make changes to @datalist, but the iteration will not
60		// reflect changes made during the g_datalist_foreach() call, other	60		// reflect changes made during the g_datalist_foreach() call, other
61		// than skipping over elements that are removed.	61		// than skipping over elements that are removed.
62	-	func DatalistForeach(DatalistVar **Data, FuncVar DataForeachFunc, UserDataVar uintptr) {	62	+	func DatalistForeach(DatalistVar *Data, FuncVar DataForeachFunc, UserDataVar uintptr) {
63			63
64	-	xDatalistForeach(DatalistVar, purego.NewCallback(FuncVar), UserDataVar)	64	+	xDatalistForeach(DatalistVar, NewCallback(FuncVar), UserDataVar)
65			65
66		}	66		}
67			67

@@ -100,9 +100,9 @@ var xDatalistIdDupData func(**Data, Quark, uintptr, uintptr) uintptr
100		//	100		//
101		// This function can be useful to avoid races when multiple	101		// This function can be useful to avoid races when multiple
102		// threads are using the same datalist and the same key.	102		// threads are using the same datalist and the same key.
103	-	func DatalistIdDupData(DatalistVar **Data, KeyIdVar Quark, DupFuncVar DuplicateFunc, UserDataVar uintptr) uintptr {	103	+	func DatalistIdDupData(DatalistVar *Data, KeyIdVar Quark, DupFuncVar DuplicateFunc, UserDataVar uintptr) uintptr {
104			104
105	-	cret := xDatalistIdDupData(DatalistVar, KeyIdVar, purego.NewCallback(DupFuncVar), UserDataVar)	105	+	cret := xDatalistIdDupData(DatalistVar, KeyIdVar, NewCallback(DupFuncVar), UserDataVar)
106		return cret	106		return cret
107		}	107		}
108			108

@@ -140,9 +140,9 @@ var xDatalistIdReplaceData func(**Data, Quark, uintptr, uintptr, uintptr, uintpt
140		// Its up to the caller to free this as they wish, which may	140		// Its up to the caller to free this as they wish, which may
141		// or may not include using @old_destroy as sometimes replacement	141		// or may not include using @old_destroy as sometimes replacement
142		// should not destroy the object in the normal way.	142		// should not destroy the object in the normal way.
143	-	func DatalistIdReplaceData(DatalistVar **Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar DestroyNotify, OldDestroyVar DestroyNotify) bool {	143	+	func DatalistIdReplaceData(DatalistVar *Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar DestroyNotify, OldDestroyVar *DestroyNotify) bool {
144			144
145	-	cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, purego.NewCallback(DestroyVar), purego.NewCallback(OldDestroyVar))	145	+	cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, NewCallback(DestroyVar), NewCallback(OldDestroyVar))
146		return cret	146		return cret
147		}	147		}
148			148

@@ -152,9 +152,9 @@ var xDatalistIdSetDataFull func(**Data, Quark, uintptr, uintptr)
152		// function to be called when the element is removed from the datalist.	152		// function to be called when the element is removed from the datalist.
153		// Any previous data with the same key is removed, and its destroy	153		// Any previous data with the same key is removed, and its destroy
154		// function is called.	154		// function is called.
155	-	func DatalistIdSetDataFull(DatalistVar **Data, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar DestroyNotify) {	155	+	func DatalistIdSetDataFull(DatalistVar *Data, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar DestroyNotify) {
156			156
157	-	xDatalistIdSetDataFull(DatalistVar, KeyIdVar, DataVar, purego.NewCallback(DestroyFuncVar))	157	+	xDatalistIdSetDataFull(DatalistVar, KeyIdVar, DataVar, NewCallback(DestroyFuncVar))
158			158
159		}	159		}
160			160

@@ -211,9 +211,9 @@ var xDatasetForeach func(uintptr, uintptr, uintptr)
211		// @func can make changes to the dataset, but the iteration will not	211		// @func can make changes to the dataset, but the iteration will not
212		// reflect changes made during the g_dataset_foreach() call, other	212		// reflect changes made during the g_dataset_foreach() call, other
213		// than skipping over elements that are removed.	213		// than skipping over elements that are removed.
214	-	func DatasetForeach(DatasetLocationVar uintptr, FuncVar DataForeachFunc, UserDataVar uintptr) {	214	+	func DatasetForeach(DatasetLocationVar uintptr, FuncVar *DataForeachFunc, UserDataVar uintptr) {
215			215
216	-	xDatasetForeach(DatasetLocationVar, purego.NewCallback(FuncVar), UserDataVar)	216	+	xDatasetForeach(DatasetLocationVar, NewCallback(FuncVar), UserDataVar)
217			217
218		}	218		}
219			219

@@ -242,9 +242,9 @@ var xDatasetIdSetDataFull func(uintptr, Quark, uintptr, uintptr)
242		// the function to call when the data element is destroyed. Any	242		// the function to call when the data element is destroyed. Any
243		// previous data with the same key is removed, and its destroy function	243		// previous data with the same key is removed, and its destroy function
244		// is called.	244		// is called.
245	-	func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar DestroyNotify) {	245	+	func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {
246			246
247	-	xDatasetIdSetDataFull(DatasetLocationVar, KeyIdVar, DataVar, purego.NewCallback(DestroyFuncVar))	247	+	xDatasetIdSetDataFull(DatasetLocationVar, KeyIdVar, DataVar, NewCallback(DestroyFuncVar))
248			248
249		}	249		}
250			250

M v4/glib/ghook.go +4 -4


@@ -128,9 +128,9 @@ func (x *HookList) InvokeCheck(MayRecurseVar bool) {
128		var xHookListMarshal func(uintptr, bool, uintptr, uintptr)	128		var xHookListMarshal func(uintptr, bool, uintptr, uintptr)
129			129
130		// Calls a function on each valid #GHook.	130		// Calls a function on each valid #GHook.
131	-	func (x *HookList) Marshal(MayRecurseVar bool, MarshallerVar HookMarshaller, MarshalDataVar uintptr) {	131	+	func (x HookList) Marshal(MayRecurseVar bool, MarshallerVar HookMarshaller, MarshalDataVar uintptr) {
132			132
133	-	xHookListMarshal(x.GoPointer(), MayRecurseVar, purego.NewCallback(MarshallerVar), MarshalDataVar)	133	+	xHookListMarshal(x.GoPointer(), MayRecurseVar, NewCallback(MarshallerVar), MarshalDataVar)
134			134
135		}	135		}
136			136

@@ -138,9 +138,9 @@ var xHookListMarshalCheck func(uintptr, bool, uintptr, uintptr)
138			138
139		// Calls a function on each valid #GHook and destroys it if the	139		// Calls a function on each valid #GHook and destroys it if the
140		// function returns %FALSE.	140		// function returns %FALSE.
141	-	func (x *HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar HookCheckMarshaller, MarshalDataVar uintptr) {	141	+	func (x HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar HookCheckMarshaller, MarshalDataVar uintptr) {
142			142
143	-	xHookListMarshalCheck(x.GoPointer(), MayRecurseVar, purego.NewCallback(MarshallerVar), MarshalDataVar)	143	+	xHookListMarshalCheck(x.GoPointer(), MayRecurseVar, NewCallback(MarshallerVar), MarshalDataVar)
144			144
145		}	145		}
146			146

M v4/glib/giochannel.go +4 -4


@@ -670,9 +670,9 @@ var xIoAddWatch func(*IOChannel, IOCondition, uintptr, uintptr) uint
670			670
671		// Adds the #GIOChannel into the default main loop context	671		// Adds the #GIOChannel into the default main loop context
672		// with the default priority.	672		// with the default priority.
673	-	func IoAddWatch(ChannelVar *IOChannel, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr) uint {	673	+	func IoAddWatch(ChannelVar IOChannel, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr) uint {
674			674
675	-	cret := xIoAddWatch(ChannelVar, ConditionVar, purego.NewCallback(FuncVar), UserDataVar)	675	+	cret := xIoAddWatch(ChannelVar, ConditionVar, NewCallback(FuncVar), UserDataVar)
676		return cret	676		return cret
677		}	677		}
678			678

@@ -684,9 +684,9 @@ var xIoAddWatchFull func(*IOChannel, int, IOCondition, uintptr, uintptr, uintptr
684		// This internally creates a main loop source using g_io_create_watch()	684		// This internally creates a main loop source using g_io_create_watch()
685		// and attaches it to the main loop context with g_source_attach().	685		// and attaches it to the main loop context with g_source_attach().
686		// You can do these steps manually if you need greater control.	686		// You can do these steps manually if you need greater control.
687	-	func IoAddWatchFull(ChannelVar *IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {	687	+	func IoAddWatchFull(ChannelVar IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
688			688
689	-	cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, purego.NewCallback(FuncVar), UserDataVar, purego.NewCallback(NotifyVar))	689	+	cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, NewCallback(FuncVar), UserDataVar, NewCallback(NotifyVar))
690		return cret	690		return cret
691		}	691		}
692			692

M v4/glib/glib-unix.go +8 -8


@@ -25,9 +25,9 @@ var xUnixFdAdd func(int, IOCondition, uintptr, uintptr) uint
25		// to cancel the watch at any time that it exists.	25		// to cancel the watch at any time that it exists.
26		//	26		//
27		// The source will never close the fd -- you must do it yourself.	27		// The source will never close the fd -- you must do it yourself.
28	-	func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar UnixFDSourceFunc, UserDataVar uintptr) uint {	28	+	func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr) uint {
29			29
30	-	cret := xUnixFdAdd(FdVar, ConditionVar, purego.NewCallback(FunctionVar), UserDataVar)	30	+	cret := xUnixFdAdd(FdVar, ConditionVar, NewCallback(FunctionVar), UserDataVar)
31		return cret	31		return cret
32		}	32		}
33			33

@@ -39,9 +39,9 @@ var xUnixFdAddFull func(int, int, IOCondition, uintptr, uintptr, uintptr) uint
39		// This is the same as g_unix_fd_add(), except that it allows you to	39		// This is the same as g_unix_fd_add(), except that it allows you to
40		// specify a non-default priority and a provide a #GDestroyNotify for	40		// specify a non-default priority and a provide a #GDestroyNotify for
41		// @user_data.	41		// @user_data.
42	-	func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar UnixFDSourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {	42	+	func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar UnixFDSourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {
43			43
44	-	cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, purego.NewCallback(FunctionVar), UserDataVar, purego.NewCallback(NotifyVar))	44	+	cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, NewCallback(FunctionVar), UserDataVar, NewCallback(NotifyVar))
45		return cret	45		return cret
46		}	46		}
47			47

@@ -123,9 +123,9 @@ var xUnixSignalAdd func(int, uintptr, uintptr) uint
123		// A convenience function for g_unix_signal_source_new(), which	123		// A convenience function for g_unix_signal_source_new(), which
124		// attaches to the default #GMainContext. You can remove the watch	124		// attaches to the default #GMainContext. You can remove the watch
125		// using g_source_remove().	125		// using g_source_remove().
126	-	func UnixSignalAdd(SignumVar int, HandlerVar SourceFunc, UserDataVar uintptr) uint {	126	+	func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) uint {
127			127
128	-	cret := xUnixSignalAdd(SignumVar, purego.NewCallback(HandlerVar), UserDataVar)	128	+	cret := xUnixSignalAdd(SignumVar, NewCallback(HandlerVar), UserDataVar)
129		return cret	129		return cret
130		}	130		}
131			131

@@ -134,9 +134,9 @@ var xUnixSignalAddFull func(int, int, uintptr, uintptr, uintptr) uint
134		// A convenience function for g_unix_signal_source_new(), which	134		// A convenience function for g_unix_signal_source_new(), which
135		// attaches to the default #GMainContext. You can remove the watch	135		// attaches to the default #GMainContext. You can remove the watch
136		// using g_source_remove().	136		// using g_source_remove().
137	-	func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar SourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {	137	+	func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar SourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {
138			138
139	-	cret := xUnixSignalAddFull(PriorityVar, SignumVar, purego.NewCallback(HandlerVar), UserDataVar, purego.NewCallback(NotifyVar))	139	+	cret := xUnixSignalAddFull(PriorityVar, SignumVar, NewCallback(HandlerVar), UserDataVar, NewCallback(NotifyVar))
140		return cret	140		return cret
141		}	141		}
142			142

M v4/glib/glist.go +2 -2


@@ -26,9 +26,9 @@ var xClearList func(**List, uintptr)
26		// Clears a pointer to a #GList, freeing it and, optionally, freeing its elements using @destroy.	26		// Clears a pointer to a #GList, freeing it and, optionally, freeing its elements using @destroy.
27		//	27		//
28		// @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing.	28		// @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing.
29	-	func ClearList(ListPtrVar **List, DestroyVar DestroyNotify) {	29	+	func ClearList(ListPtrVar *List, DestroyVar DestroyNotify) {
30			30
31	-	xClearList(ListPtrVar, purego.NewCallback(DestroyVar))	31	+	xClearList(ListPtrVar, NewCallback(DestroyVar))
32			32
33		}	33		}
34			34

M v4/glib/gmain.go +28 -28


@@ -196,9 +196,9 @@ var xMainContextInvoke func(uintptr, uintptr, uintptr)
196		// Note that, as with normal idle functions, @function should probably	196		// Note that, as with normal idle functions, @function should probably
197		// return %FALSE. If it returns %TRUE, it will be continuously run in a	197		// return %FALSE. If it returns %TRUE, it will be continuously run in a
198		// loop (and may prevent this call from returning).	198		// loop (and may prevent this call from returning).
199	-	func (x *MainContext) Invoke(FunctionVar SourceFunc, DataVar uintptr) {	199	+	func (x MainContext) Invoke(FunctionVar SourceFunc, DataVar uintptr) {
200			200
201	-	xMainContextInvoke(x.GoPointer(), purego.NewCallback(FunctionVar), DataVar)	201	+	xMainContextInvoke(x.GoPointer(), NewCallback(FunctionVar), DataVar)
202			202
203		}	203		}
204			204

@@ -213,9 +213,9 @@ var xMainContextInvokeFull func(uintptr, int, uintptr, uintptr, uintptr)
213		//	213		//
214		// @notify should not assume that it is called from any particular	214		// @notify should not assume that it is called from any particular
215		// thread or with any particular context acquired.	215		// thread or with any particular context acquired.
216	-	func (x *MainContext) InvokeFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) {	216	+	func (x MainContext) InvokeFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
217			217
218	-	xMainContextInvokeFull(x.GoPointer(), PriorityVar, purego.NewCallback(FunctionVar), DataVar, purego.NewCallback(NotifyVar))	218	+	xMainContextInvokeFull(x.GoPointer(), PriorityVar, NewCallback(FunctionVar), DataVar, NewCallback(NotifyVar))
219			219
220		}	220		}
221			221

@@ -384,9 +384,9 @@ var xMainContextSetPollFunc func(uintptr, uintptr)
384		//	384		//
385		// This function could possibly be used to integrate the GLib event	385		// This function could possibly be used to integrate the GLib event
386		// loop with an external event loop.	386		// loop with an external event loop.
387	-	func (x *MainContext) SetPollFunc(FuncVar PollFunc) {	387	+	func (x MainContext) SetPollFunc(FuncVar PollFunc) {
388			388
389	-	xMainContextSetPollFunc(x.GoPointer(), purego.NewCallback(FuncVar))	389	+	xMainContextSetPollFunc(x.GoPointer(), NewCallback(FuncVar))
390			390
391		}	391		}
392			392

@@ -988,9 +988,9 @@ var xSourceSetCallback func(uintptr, uintptr, uintptr, uintptr)
988		//	988		//
989		// Note that g_source_destroy() for a currently attached source has the effect	989		// Note that g_source_destroy() for a currently attached source has the effect
990		// of also unsetting the callback.	990		// of also unsetting the callback.
991	-	func (x *Source) SetCallback(FuncVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) {	991	+	func (x Source) SetCallback(FuncVar SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
992			992
993	-	xSourceSetCallback(x.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(NotifyVar))	993	+	xSourceSetCallback(x.GoPointer(), NewCallback(FuncVar), DataVar, NewCallback(NotifyVar))
994			994
995		}	995		}
996			996

@@ -1042,9 +1042,9 @@ var xSourceSetDisposeFunction func(uintptr, uintptr)
1042		// @source is already partially freed and not valid anymore.	1042		// @source is already partially freed and not valid anymore.
1043		//	1043		//
1044		// This should only ever be called from #GSource implementations.	1044		// This should only ever be called from #GSource implementations.
1045	-	func (x *Source) SetDisposeFunction(DisposeVar SourceDisposeFunc) {	1045	+	func (x Source) SetDisposeFunction(DisposeVar SourceDisposeFunc) {
1046			1046
1047	-	xSourceSetDisposeFunction(x.GoPointer(), purego.NewCallback(DisposeVar))	1047	+	xSourceSetDisposeFunction(x.GoPointer(), NewCallback(DisposeVar))
1048			1048
1049		}	1049		}
1050			1050

@@ -1273,9 +1273,9 @@ var xChildWatchAdd func(Pid, uintptr, uintptr) uint
1273		// g_child_watch_source_new() and attaches it to the main loop context	1273		// g_child_watch_source_new() and attaches it to the main loop context
1274		// using g_source_attach(). You can do these steps manually if you	1274		// using g_source_attach(). You can do these steps manually if you
1275		// need greater control.	1275		// need greater control.
1276	-	func ChildWatchAdd(PidVar Pid, FunctionVar ChildWatchFunc, DataVar uintptr) uint {	1276	+	func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uint {
1277			1277
1278	-	cret := xChildWatchAdd(PidVar, purego.NewCallback(FunctionVar), DataVar)	1278	+	cret := xChildWatchAdd(PidVar, NewCallback(FunctionVar), DataVar)
1279		return cret	1279		return cret
1280		}	1280		}
1281			1281

@@ -1305,9 +1305,9 @@ var xChildWatchAddFull func(int, Pid, uintptr, uintptr, uintptr) uint
1305		// g_child_watch_source_new() and attaches it to the main loop context	1305		// g_child_watch_source_new() and attaches it to the main loop context
1306		// using g_source_attach(). You can do these steps manually if you	1306		// using g_source_attach(). You can do these steps manually if you
1307		// need greater control.	1307		// need greater control.
1308	-	func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar ChildWatchFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	1308	+	func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar ChildWatchFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1309			1309
1310	-	cret := xChildWatchAddFull(PriorityVar, PidVar, purego.NewCallback(FunctionVar), DataVar, purego.NewCallback(NotifyVar))	1310	+	cret := xChildWatchAddFull(PriorityVar, PidVar, NewCallback(FunctionVar), DataVar, NewCallback(NotifyVar))
1311		return cret	1311		return cret
1312		}	1312		}
1313			1313

@@ -1363,9 +1363,9 @@ var xClearHandleId func(uint, uintptr)
1363		//	1363		//
1364		// A macro is also included that allows this function to be used without	1364		// A macro is also included that allows this function to be used without
1365		// pointer casts.	1365		// pointer casts.
1366	-	func ClearHandleId(TagPtrVar uint, ClearFuncVar ClearHandleFunc) {	1366	+	func ClearHandleId(TagPtrVar uint, ClearFuncVar *ClearHandleFunc) {
1367			1367
1368	-	xClearHandleId(TagPtrVar, purego.NewCallback(ClearFuncVar))	1368	+	xClearHandleId(TagPtrVar, NewCallback(ClearFuncVar))
1369			1369
1370		}	1370		}
1371			1371

@@ -1431,9 +1431,9 @@ var xIdleAdd func(uintptr, uintptr) uint
1431		// the callback will be invoked in whichever thread is running that main	1431		// the callback will be invoked in whichever thread is running that main
1432		// context. You can do these steps manually if you need greater control or to	1432		// context. You can do these steps manually if you need greater control or to
1433		// use a custom main context.	1433		// use a custom main context.
1434	-	func IdleAdd(FunctionVar SourceFunc, DataVar uintptr) uint {	1434	+	func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {
1435			1435
1436	-	cret := xIdleAdd(purego.NewCallback(FunctionVar), DataVar)	1436	+	cret := xIdleAdd(NewCallback(FunctionVar), DataVar)
1437		return cret	1437		return cret
1438		}	1438		}
1439			1439

@@ -1453,9 +1453,9 @@ var xIdleAddFull func(int, uintptr, uintptr, uintptr) uint
1453		// the callback will be invoked in whichever thread is running that main	1453		// the callback will be invoked in whichever thread is running that main
1454		// context. You can do these steps manually if you need greater control or to	1454		// context. You can do these steps manually if you need greater control or to
1455		// use a custom main context.	1455		// use a custom main context.
1456	-	func IdleAddFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	1456	+	func IdleAddFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1457			1457
1458	-	cret := xIdleAddFull(PriorityVar, purego.NewCallback(FunctionVar), DataVar, purego.NewCallback(NotifyVar))	1458	+	cret := xIdleAddFull(PriorityVar, NewCallback(FunctionVar), DataVar, NewCallback(NotifyVar))
1459		return cret	1459		return cret
1460		}	1460		}
1461			1461

@@ -1762,9 +1762,9 @@ var xTimeoutAdd func(uint, uintptr, uintptr) uint
1762		//	1762		//
1763		// The interval given is in terms of monotonic time, not wall clock	1763		// The interval given is in terms of monotonic time, not wall clock
1764		// time. See g_get_monotonic_time().	1764		// time. See g_get_monotonic_time().
1765	-	func TimeoutAdd(IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr) uint {	1765	+	func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
1766			1766
1767	-	cret := xTimeoutAdd(IntervalVar, purego.NewCallback(FunctionVar), DataVar)	1767	+	cret := xTimeoutAdd(IntervalVar, NewCallback(FunctionVar), DataVar)
1768		return cret	1768		return cret
1769		}	1769		}
1770			1770

@@ -1794,9 +1794,9 @@ var xTimeoutAddFull func(int, uint, uintptr, uintptr, uintptr) uint
1794		//	1794		//
1795		// The interval given is in terms of monotonic time, not wall clock time.	1795		// The interval given is in terms of monotonic time, not wall clock time.
1796		// See g_get_monotonic_time().	1796		// See g_get_monotonic_time().
1797	-	func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	1797	+	func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1798			1798
1799	-	cret := xTimeoutAddFull(PriorityVar, IntervalVar, purego.NewCallback(FunctionVar), DataVar, purego.NewCallback(NotifyVar))	1799	+	cret := xTimeoutAddFull(PriorityVar, IntervalVar, NewCallback(FunctionVar), DataVar, NewCallback(NotifyVar))
1800		return cret	1800		return cret
1801		}	1801		}
1802			1802

@@ -1825,9 +1825,9 @@ var xTimeoutAddSeconds func(uint, uintptr, uintptr) uint
1825		//	1825		//
1826		// The interval given is in terms of monotonic time, not wall clock	1826		// The interval given is in terms of monotonic time, not wall clock
1827		// time. See g_get_monotonic_time().	1827		// time. See g_get_monotonic_time().
1828	-	func TimeoutAddSeconds(IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr) uint {	1828	+	func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
1829			1829
1830	-	cret := xTimeoutAddSeconds(IntervalVar, purego.NewCallback(FunctionVar), DataVar)	1830	+	cret := xTimeoutAddSeconds(IntervalVar, NewCallback(FunctionVar), DataVar)
1831		return cret	1831		return cret
1832		}	1832		}
1833			1833

@@ -1872,9 +1872,9 @@ var xTimeoutAddSecondsFull func(int, uint, uintptr, uintptr, uintptr) uint
1872		//	1872		//
1873		// The interval given is in terms of monotonic time, not wall clock	1873		// The interval given is in terms of monotonic time, not wall clock
1874		// time. See g_get_monotonic_time().	1874		// time. See g_get_monotonic_time().
1875	-	func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	1875	+	func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1876			1876
1877	-	cret := xTimeoutAddSecondsFull(PriorityVar, IntervalVar, purego.NewCallback(FunctionVar), DataVar, purego.NewCallback(NotifyVar))	1877	+	cret := xTimeoutAddSecondsFull(PriorityVar, IntervalVar, NewCallback(FunctionVar), DataVar, NewCallback(NotifyVar))
1878		return cret	1878		return cret
1879		}	1879		}
1880			1880

M v4/glib/gmarkup.go +2 -2


@@ -27,9 +27,9 @@ var xNewMarkupParseContext func(*MarkupParser, MarkupParseFlags, uintptr, uintpt
27		// a context, as long as no errors occur; once an error occurs,	27		// a context, as long as no errors occur; once an error occurs,
28		// the parse context can't continue to parse text (you have to	28		// the parse context can't continue to parse text (you have to
29		// free it and create a new parse context).	29		// free it and create a new parse context).
30	-	func NewMarkupParseContext(ParserVar MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar DestroyNotify) MarkupParseContext {	30	+	func NewMarkupParseContext(ParserVar MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar DestroyNotify) *MarkupParseContext {
31			31
32	-	cret := xNewMarkupParseContext(ParserVar, FlagsVar, UserDataVar, purego.NewCallback(UserDataDnotifyVar))	32	+	cret := xNewMarkupParseContext(ParserVar, FlagsVar, UserDataVar, NewCallback(UserDataDnotifyVar))
33		return cret	33		return cret
34		}	34		}
35			35

M v4/glib/gmem.go +2 -2


@@ -70,9 +70,9 @@ var xClearPointer func(uintptr, uintptr)
70		// compatible with being called as `GDestroyNotify` using the standard calling	70		// compatible with being called as `GDestroyNotify` using the standard calling
71		// convention for the platform that GLib was compiled for; otherwise the program	71		// convention for the platform that GLib was compiled for; otherwise the program
72		// will experience undefined behaviour.	72		// will experience undefined behaviour.
73	-	func ClearPointer(PpVar uintptr, DestroyVar DestroyNotify) {	73	+	func ClearPointer(PpVar uintptr, DestroyVar *DestroyNotify) {
74			74
75	-	xClearPointer(PpVar, purego.NewCallback(DestroyVar))	75	+	xClearPointer(PpVar, NewCallback(DestroyVar))
76			76
77		}	77		}
78			78

M v4/glib/gmessages.go +12 -12


@@ -283,9 +283,9 @@ var xLogSetDefaultHandler func(uintptr, uintptr) uintptr
283		//	283		//
284		// This has no effect if structured logging is enabled; see	284		// This has no effect if structured logging is enabled; see
285		// [Using Structured Logging][using-structured-logging].	285		// [Using Structured Logging][using-structured-logging].
286	-	func LogSetDefaultHandler(LogFuncVar LogFunc, UserDataVar uintptr) uintptr {	286	+	func LogSetDefaultHandler(LogFuncVar *LogFunc, UserDataVar uintptr) uintptr {
287			287
288	-	cret := xLogSetDefaultHandler(purego.NewCallback(LogFuncVar), UserDataVar)	288	+	cret := xLogSetDefaultHandler(NewCallback(LogFuncVar), UserDataVar)
289		return cret	289		return cret
290		}	290		}
291			291

@@ -352,9 +352,9 @@ var xLogSetHandler func(string, LogLevelFlags, uintptr, uintptr) uint
352		// \| G_LOG_FLAG_RECURSION, my_log_handler, NULL);	352		// \| G_LOG_FLAG_RECURSION, my_log_handler, NULL);
353		//	353		//
354		// ]\|	354		// ]\|
355	-	func LogSetHandler(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar LogFunc, UserDataVar uintptr) uint {	355	+	func LogSetHandler(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr) uint {
356			356
357	-	cret := xLogSetHandler(LogDomainVar, LogLevelsVar, purego.NewCallback(LogFuncVar), UserDataVar)	357	+	cret := xLogSetHandler(LogDomainVar, LogLevelsVar, NewCallback(LogFuncVar), UserDataVar)
358		return cret	358		return cret
359		}	359		}
360			360

@@ -364,9 +364,9 @@ var xLogSetHandlerFull func(string, LogLevelFlags, uintptr, uintptr, uintptr) ui
364		//	364		//
365		// This has no effect if structured logging is enabled; see	365		// This has no effect if structured logging is enabled; see
366		// [Using Structured Logging][using-structured-logging].	366		// [Using Structured Logging][using-structured-logging].
367	-	func LogSetHandlerFull(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar LogFunc, UserDataVar uintptr, DestroyVar DestroyNotify) uint {	367	+	func LogSetHandlerFull(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar LogFunc, UserDataVar uintptr, DestroyVar DestroyNotify) uint {
368			368
369	-	cret := xLogSetHandlerFull(LogDomainVar, LogLevelsVar, purego.NewCallback(LogFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	369	+	cret := xLogSetHandlerFull(LogDomainVar, LogLevelsVar, NewCallback(LogFuncVar), UserDataVar, NewCallback(DestroyVar))
370		return cret	370		return cret
371		}	371		}
372			372

@@ -381,9 +381,9 @@ var xLogSetWriterFunc func(uintptr, uintptr, uintptr)
381		// log messages are formatted and outputted.	381		// log messages are formatted and outputted.
382		//	382		//
383		// There can only be one writer function. It is an error to set more than one.	383		// There can only be one writer function. It is an error to set more than one.
384	-	func LogSetWriterFunc(FuncVar LogWriterFunc, UserDataVar uintptr, UserDataFreeVar DestroyNotify) {	384	+	func LogSetWriterFunc(FuncVar LogWriterFunc, UserDataVar uintptr, UserDataFreeVar DestroyNotify) {
385			385
386	-	xLogSetWriterFunc(purego.NewCallback(FuncVar), UserDataVar, purego.NewCallback(UserDataFreeVar))	386	+	xLogSetWriterFunc(NewCallback(FuncVar), UserDataVar, NewCallback(UserDataFreeVar))
387			387
388		}	388		}
389			389

@@ -784,9 +784,9 @@ var xSetPrintHandler func(uintptr) uintptr
784		// the message to stdout. By providing your own handler	784		// the message to stdout. By providing your own handler
785		// you can redirect the output, to a GTK+ widget or a	785		// you can redirect the output, to a GTK+ widget or a
786		// log file for example.	786		// log file for example.
787	-	func SetPrintHandler(FuncVar PrintFunc) uintptr {	787	+	func SetPrintHandler(FuncVar *PrintFunc) uintptr {
788			788
789	-	cret := xSetPrintHandler(purego.NewCallback(FuncVar))	789	+	cret := xSetPrintHandler(NewCallback(FuncVar))
790		return cret	790		return cret
791		}	791		}
792			792

@@ -799,9 +799,9 @@ var xSetPrinterrHandler func(uintptr) uintptr
799		// message to stderr. By providing your own handler you can	799		// message to stderr. By providing your own handler you can
800		// redirect the output, to a GTK+ widget or a log file for	800		// redirect the output, to a GTK+ widget or a log file for
801		// example.	801		// example.
802	-	func SetPrinterrHandler(FuncVar PrintFunc) uintptr {	802	+	func SetPrinterrHandler(FuncVar *PrintFunc) uintptr {
803			803
804	-	cret := xSetPrinterrHandler(purego.NewCallback(FuncVar))	804	+	cret := xSetPrinterrHandler(NewCallback(FuncVar))
805		return cret	805		return cret
806		}	806		}
807			807

M v4/glib/gnode.go +6 -6


@@ -62,9 +62,9 @@ var xNodeChildrenForeach func(uintptr, TraverseFlags, uintptr, uintptr)
62		// Calls a function for each of the children of a #GNode. Note that it	62		// Calls a function for each of the children of a #GNode. Note that it
63		// doesn't descend beneath the child nodes. @func must not do anything	63		// doesn't descend beneath the child nodes. @func must not do anything
64		// that would modify the structure of the tree.	64		// that would modify the structure of the tree.
65	-	func (x *Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar NodeForeachFunc, DataVar uintptr) {	65	+	func (x Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar NodeForeachFunc, DataVar uintptr) {
66			66
67	-	xNodeChildrenForeach(x.GoPointer(), FlagsVar, purego.NewCallback(FuncVar), DataVar)	67	+	xNodeChildrenForeach(x.GoPointer(), FlagsVar, NewCallback(FuncVar), DataVar)
68			68
69		}	69		}
70			70

@@ -81,9 +81,9 @@ func (x Node) Copy() Node {
81		var xNodeCopyDeep func(uintptr, uintptr, uintptr) *Node	81		var xNodeCopyDeep func(uintptr, uintptr, uintptr) *Node
82			82
83		// Recursively copies a #GNode and its data.	83		// Recursively copies a #GNode and its data.
84	-	func (x Node) CopyDeep(CopyFuncVar CopyFunc, DataVar uintptr) Node {	84	+	func (x Node) CopyDeep(CopyFuncVar CopyFunc, DataVar uintptr) *Node {
85			85
86	-	cret := xNodeCopyDeep(x.GoPointer(), purego.NewCallback(CopyFuncVar), DataVar)	86	+	cret := xNodeCopyDeep(x.GoPointer(), NewCallback(CopyFuncVar), DataVar)
87		return cret	87		return cret
88		}	88		}
89			89

@@ -270,9 +270,9 @@ var xNodeTraverse func(uintptr, TraverseType, TraverseFlags, int, uintptr, uintp
270		// It calls the given function for each node visited.	270		// It calls the given function for each node visited.
271		// The traversal can be halted at any point by returning %TRUE from @func.	271		// The traversal can be halted at any point by returning %TRUE from @func.
272		// @func must not do anything that would modify the structure of the tree.	272		// @func must not do anything that would modify the structure of the tree.
273	-	func (x *Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar NodeTraverseFunc, DataVar uintptr) {	273	+	func (x Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar NodeTraverseFunc, DataVar uintptr) {
274			274
275	-	xNodeTraverse(x.GoPointer(), OrderVar, FlagsVar, MaxDepthVar, purego.NewCallback(FuncVar), DataVar)	275	+	xNodeTraverse(x.GoPointer(), OrderVar, FlagsVar, MaxDepthVar, NewCallback(FuncVar), DataVar)
276			276
277		}	277		}
278			278

M v4/glib/goption.go +10 -10


@@ -309,9 +309,9 @@ var xOptionContextSetTranslateFunc func(uintptr, uintptr, uintptr, uintptr)
309		//	309		//
310		// If you are using gettext(), you only need to set the translation	310		// If you are using gettext(), you only need to set the translation
311		// domain, see g_option_context_set_translation_domain().	311		// domain, see g_option_context_set_translation_domain().
312	-	func (x *OptionContext) SetTranslateFunc(FuncVar TranslateFunc, DataVar uintptr, DestroyNotifyVar DestroyNotify) {	312	+	func (x OptionContext) SetTranslateFunc(FuncVar TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {
313			313
314	-	xOptionContextSetTranslateFunc(x.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DestroyNotifyVar))	314	+	xOptionContextSetTranslateFunc(x.GoPointer(), NewCallback(FuncVar), DataVar, NewCallback(DestroyNotifyVar))
315			315
316		}	316		}
317			317

@@ -365,9 +365,9 @@ func (x *OptionGroup) GoPointer() uintptr {
365		var xNewOptionGroup func(string, string, string, uintptr, uintptr) *OptionGroup	365		var xNewOptionGroup func(string, string, string, uintptr, uintptr) *OptionGroup
366			366
367		// Creates a new #GOptionGroup.	367		// Creates a new #GOptionGroup.
368	-	func NewOptionGroup(NameVar string, DescriptionVar string, HelpDescriptionVar string, UserDataVar uintptr, DestroyVar DestroyNotify) *OptionGroup {	368	+	func NewOptionGroup(NameVar string, DescriptionVar string, HelpDescriptionVar string, UserDataVar uintptr, DestroyVar DestroyNotify) OptionGroup {
369			369
370	-	cret := xNewOptionGroup(NameVar, DescriptionVar, HelpDescriptionVar, UserDataVar, purego.NewCallback(DestroyVar))	370	+	cret := xNewOptionGroup(NameVar, DescriptionVar, HelpDescriptionVar, UserDataVar, NewCallback(DestroyVar))
371		return cret	371		return cret
372		}	372		}
373			373

@@ -406,9 +406,9 @@ var xOptionGroupSetErrorHook func(uintptr, uintptr)
406		//	406		//
407		// Note that the user data to be passed to @error_func can be	407		// Note that the user data to be passed to @error_func can be
408		// specified when constructing the group with g_option_group_new().	408		// specified when constructing the group with g_option_group_new().
409	-	func (x *OptionGroup) SetErrorHook(ErrorFuncVar OptionErrorFunc) {	409	+	func (x OptionGroup) SetErrorHook(ErrorFuncVar OptionErrorFunc) {
410			410
411	-	xOptionGroupSetErrorHook(x.GoPointer(), purego.NewCallback(ErrorFuncVar))	411	+	xOptionGroupSetErrorHook(x.GoPointer(), NewCallback(ErrorFuncVar))
412			412
413		}	413		}
414			414

@@ -421,9 +421,9 @@ var xOptionGroupSetParseHooks func(uintptr, uintptr, uintptr)
421		// Note that the user data to be passed to @pre_parse_func and	421		// Note that the user data to be passed to @pre_parse_func and
422		// @post_parse_func can be specified when constructing the group	422		// @post_parse_func can be specified when constructing the group
423		// with g_option_group_new().	423		// with g_option_group_new().
424	-	func (x *OptionGroup) SetParseHooks(PreParseFuncVar OptionParseFunc, PostParseFuncVar OptionParseFunc) {	424	+	func (x OptionGroup) SetParseHooks(PreParseFuncVar OptionParseFunc, PostParseFuncVar *OptionParseFunc) {
425			425
426	-	xOptionGroupSetParseHooks(x.GoPointer(), purego.NewCallback(PreParseFuncVar), purego.NewCallback(PostParseFuncVar))	426	+	xOptionGroupSetParseHooks(x.GoPointer(), NewCallback(PreParseFuncVar), NewCallback(PostParseFuncVar))
427			427
428		}	428		}
429			429

@@ -435,9 +435,9 @@ var xOptionGroupSetTranslateFunc func(uintptr, uintptr, uintptr, uintptr)
435		//	435		//
436		// If you are using gettext(), you only need to set the translation	436		// If you are using gettext(), you only need to set the translation
437		// domain, see g_option_group_set_translation_domain().	437		// domain, see g_option_group_set_translation_domain().
438	-	func (x *OptionGroup) SetTranslateFunc(FuncVar TranslateFunc, DataVar uintptr, DestroyNotifyVar DestroyNotify) {	438	+	func (x OptionGroup) SetTranslateFunc(FuncVar TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {
439			439
440	-	xOptionGroupSetTranslateFunc(x.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DestroyNotifyVar))	440	+	xOptionGroupSetTranslateFunc(x.GoPointer(), NewCallback(FuncVar), DataVar, NewCallback(DestroyNotifyVar))
441			441
442		}	442		}
443			443

M v4/glib/gqsort.go +2 -2


@@ -12,9 +12,9 @@ var xQsortWithData func(uintptr, int, uint, uintptr, uintptr)
12		// the comparison routine accepts a user data argument.	12		// the comparison routine accepts a user data argument.
13		//	13		//
14		// This is guaranteed to be a stable sort since version 2.32.	14		// This is guaranteed to be a stable sort since version 2.32.
15	-	func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar CompareDataFunc, UserDataVar uintptr) {	15	+	func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
16			16
17	-	xQsortWithData(PbaseVar, TotalElemsVar, SizeVar, purego.NewCallback(CompareFuncVar), UserDataVar)	17	+	xQsortWithData(PbaseVar, TotalElemsVar, SizeVar, NewCallback(CompareFuncVar), UserDataVar)
18			18
19		}	19		}
20			20

M v4/glib/gqueue.go +12 -12


@@ -36,9 +36,9 @@ var xQueueClearFull func(uintptr, uintptr)
36			36
37		// Convenience method, which frees all the memory used by a #GQueue,	37		// Convenience method, which frees all the memory used by a #GQueue,
38		// and calls the provided @free_func on each item in the #GQueue.	38		// and calls the provided @free_func on each item in the #GQueue.
39	-	func (x *Queue) ClearFull(FreeFuncVar DestroyNotify) {	39	+	func (x Queue) ClearFull(FreeFuncVar DestroyNotify) {
40			40
41	-	xQueueClearFull(x.GoPointer(), purego.NewCallback(FreeFuncVar))	41	+	xQueueClearFull(x.GoPointer(), NewCallback(FreeFuncVar))
42			42
43		}	43		}
44			44

@@ -80,9 +80,9 @@ var xQueueFindCustom func(uintptr, uintptr, uintptr) *List
80		// which should return 0 when the desired element is found. The function	80		// which should return 0 when the desired element is found. The function
81		// takes two gconstpointer arguments, the #GQueue element's data as the	81		// takes two gconstpointer arguments, the #GQueue element's data as the
82		// first argument and the given user data as the second argument.	82		// first argument and the given user data as the second argument.
83	-	func (x Queue) FindCustom(DataVar uintptr, FuncVar CompareFunc) List {	83	+	func (x Queue) FindCustom(DataVar uintptr, FuncVar CompareFunc) *List {
84			84
85	-	cret := xQueueFindCustom(x.GoPointer(), DataVar, purego.NewCallback(FuncVar))	85	+	cret := xQueueFindCustom(x.GoPointer(), DataVar, NewCallback(FuncVar))
86		return cret	86		return cret
87		}	87		}
88			88

@@ -93,9 +93,9 @@ var xQueueForeach func(uintptr, uintptr, uintptr)
93		//	93		//
94		// It is safe for @func to remove the element from @queue, but it must	94		// It is safe for @func to remove the element from @queue, but it must
95		// not modify any part of the queue after that element.	95		// not modify any part of the queue after that element.
96	-	func (x *Queue) Foreach(FuncVar Func, UserDataVar uintptr) {	96	+	func (x Queue) Foreach(FuncVar Func, UserDataVar uintptr) {
97			97
98	-	xQueueForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	98	+	xQueueForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
99			99
100		}	100		}
101			101

@@ -120,9 +120,9 @@ var xQueueFreeFull func(uintptr, uintptr)
120		//	120		//
121		// @free_func should not modify the queue (eg, by removing the freed	121		// @free_func should not modify the queue (eg, by removing the freed
122		// element from it).	122		// element from it).
123	-	func (x *Queue) FreeFull(FreeFuncVar DestroyNotify) {	123	+	func (x Queue) FreeFull(FreeFuncVar DestroyNotify) {
124			124
125	-	xQueueFreeFull(x.GoPointer(), purego.NewCallback(FreeFuncVar))	125	+	xQueueFreeFull(x.GoPointer(), NewCallback(FreeFuncVar))
126			126
127		}	127		}
128			128

@@ -205,9 +205,9 @@ func (x Queue) InsertBeforeLink(SiblingVar List, LinkVar *List) {
205		var xQueueInsertSorted func(uintptr, uintptr, uintptr, uintptr)	205		var xQueueInsertSorted func(uintptr, uintptr, uintptr, uintptr)
206			206
207		// Inserts @data into @queue using @func to determine the new position.	207		// Inserts @data into @queue using @func to determine the new position.
208	-	func (x *Queue) InsertSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {	208	+	func (x Queue) InsertSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
209			209
210	-	xQueueInsertSorted(x.GoPointer(), DataVar, purego.NewCallback(FuncVar), UserDataVar)	210	+	xQueueInsertSorted(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)
211			211
212		}	212		}
213			213

@@ -421,9 +421,9 @@ func (x *Queue) Reverse() {
421		var xQueueSort func(uintptr, uintptr, uintptr)	421		var xQueueSort func(uintptr, uintptr, uintptr)
422			422
423		// Sorts @queue using @compare_func.	423		// Sorts @queue using @compare_func.
424	-	func (x *Queue) Sort(CompareFuncVar CompareDataFunc, UserDataVar uintptr) {	424	+	func (x Queue) Sort(CompareFuncVar CompareDataFunc, UserDataVar uintptr) {
425			425
426	-	xQueueSort(x.GoPointer(), purego.NewCallback(CompareFuncVar), UserDataVar)	426	+	xQueueSort(x.GoPointer(), NewCallback(CompareFuncVar), UserDataVar)
427			427
428		}	428		}
429			429

M v4/glib/grcbox.go +4 -4


@@ -88,9 +88,9 @@ var xAtomicRcBoxReleaseFull func(uintptr, uintptr)
88		// If the reference was the last one, it will call @clear_func	88		// If the reference was the last one, it will call @clear_func
89		// to clear the contents of @mem_block, and then will free the	89		// to clear the contents of @mem_block, and then will free the
90		// resources allocated for @mem_block.	90		// resources allocated for @mem_block.
91	-	func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar DestroyNotify) {	91	+	func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
92			92
93	-	xAtomicRcBoxReleaseFull(MemBlockVar, purego.NewCallback(ClearFuncVar))	93	+	xAtomicRcBoxReleaseFull(MemBlockVar, NewCallback(ClearFuncVar))
94			94
95		}	95		}
96			96

@@ -176,9 +176,9 @@ var xRcBoxReleaseFull func(uintptr, uintptr)
176		// If the reference was the last one, it will call @clear_func	176		// If the reference was the last one, it will call @clear_func
177		// to clear the contents of @mem_block, and then will free the	177		// to clear the contents of @mem_block, and then will free the
178		// resources allocated for @mem_block.	178		// resources allocated for @mem_block.
179	-	func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar DestroyNotify) {	179	+	func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
180			180
181	-	xRcBoxReleaseFull(MemBlockVar, purego.NewCallback(ClearFuncVar))	181	+	xRcBoxReleaseFull(MemBlockVar, NewCallback(ClearFuncVar))
182			182
183		}	183		}
184			184

M v4/glib/gregex.go +2 -2


@@ -741,10 +741,10 @@ var xRegexReplaceEval func(uintptr, uintptr, int, int, RegexMatchFlags, uintptr,
741		//	741		//
742		// ...	742		// ...
743		// ]\|	743		// ]\|
744	-	func (x *Regex) ReplaceEval(StringVar uintptr, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar RegexEvalCallback, UserDataVar uintptr) (string, error) {	744	+	func (x Regex) ReplaceEval(StringVar uintptr, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar RegexEvalCallback, UserDataVar uintptr) (string, error) {
745		var cerr *Error	745		var cerr *Error
746			746
747	-	cret := xRegexReplaceEval(x.GoPointer(), StringVar, StringLenVar, StartPositionVar, MatchOptionsVar, purego.NewCallback(EvalVar), UserDataVar, &cerr)	747	+	cret := xRegexReplaceEval(x.GoPointer(), StringVar, StringLenVar, StartPositionVar, MatchOptionsVar, NewCallback(EvalVar), UserDataVar, &cerr)
748		if cerr == nil {	748		if cerr == nil {
749		return cret, nil	749		return cret, nil
750		}	750		}

M v4/glib/gscanner.go +2 -2


@@ -218,9 +218,9 @@ var xScannerScopeForeachSymbol func(uintptr, uint, uintptr, uintptr)
218		// in the given scope of the #GScanner. The function is passed	218		// in the given scope of the #GScanner. The function is passed
219		// the symbol and value of each pair, and the given @user_data	219		// the symbol and value of each pair, and the given @user_data
220		// parameter.	220		// parameter.
221	-	func (x *Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar HFunc, UserDataVar uintptr) {	221	+	func (x Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar HFunc, UserDataVar uintptr) {
222			222
223	-	xScannerScopeForeachSymbol(x.GoPointer(), ScopeIdVar, purego.NewCallback(FuncVar), UserDataVar)	223	+	xScannerScopeForeachSymbol(x.GoPointer(), ScopeIdVar, NewCallback(FuncVar), UserDataVar)
224			224
225		}	225		}
226			226

M v4/glib/gsequence.go +18 -18


@@ -35,9 +35,9 @@ var xSequenceForeach func(uintptr, uintptr, uintptr)
35			35
36		// Calls @func for each item in the sequence passing @user_data	36		// Calls @func for each item in the sequence passing @user_data
37		// to the function. @func must not modify the sequence itself.	37		// to the function. @func must not modify the sequence itself.
38	-	func (x *Sequence) Foreach(FuncVar Func, UserDataVar uintptr) {	38	+	func (x Sequence) Foreach(FuncVar Func, UserDataVar uintptr) {
39			39
40	-	xSequenceForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	40	+	xSequenceForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
41			41
42		}	42		}
43			43

@@ -105,9 +105,9 @@ var xSequenceInsertSorted func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
105		// Note that when adding a large amount of data to a #GSequence,	105		// Note that when adding a large amount of data to a #GSequence,
106		// it is more efficient to do unsorted insertions and then call	106		// it is more efficient to do unsorted insertions and then call
107		// g_sequence_sort() or g_sequence_sort_iter().	107		// g_sequence_sort() or g_sequence_sort_iter().
108	-	func (x Sequence) InsertSorted(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) SequenceIter {	108	+	func (x Sequence) InsertSorted(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
109			109
110	-	cret := xSequenceInsertSorted(x.GoPointer(), DataVar, purego.NewCallback(CmpFuncVar), CmpDataVar)	110	+	cret := xSequenceInsertSorted(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)
111		return cret	111		return cret
112		}	112		}
113			113

@@ -125,9 +125,9 @@ var xSequenceInsertSortedIter func(uintptr, uintptr, uintptr, uintptr) *Sequence
125		// Note that when adding a large amount of data to a #GSequence,	125		// Note that when adding a large amount of data to a #GSequence,
126		// it is more efficient to do unsorted insertions and then call	126		// it is more efficient to do unsorted insertions and then call
127		// g_sequence_sort() or g_sequence_sort_iter().	127		// g_sequence_sort() or g_sequence_sort_iter().
128	-	func (x Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) SequenceIter {	128	+	func (x Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
129			129
130	-	cret := xSequenceInsertSortedIter(x.GoPointer(), DataVar, purego.NewCallback(IterCmpVar), CmpDataVar)	130	+	cret := xSequenceInsertSortedIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)
131		return cret	131		return cret
132		}	132		}
133			133

@@ -159,9 +159,9 @@ var xSequenceLookup func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
159		//	159		//
160		// This function will fail if the data contained in the sequence is	160		// This function will fail if the data contained in the sequence is
161		// unsorted.	161		// unsorted.
162	-	func (x Sequence) Lookup(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) SequenceIter {	162	+	func (x Sequence) Lookup(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
163			163
164	-	cret := xSequenceLookup(x.GoPointer(), DataVar, purego.NewCallback(CmpFuncVar), CmpDataVar)	164	+	cret := xSequenceLookup(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)
165		return cret	165		return cret
166		}	166		}
167			167

@@ -177,9 +177,9 @@ var xSequenceLookupIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
177		//	177		//
178		// This function will fail if the data contained in the sequence is	178		// This function will fail if the data contained in the sequence is
179		// unsorted.	179		// unsorted.
180	-	func (x Sequence) LookupIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) SequenceIter {	180	+	func (x Sequence) LookupIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
181			181
182	-	cret := xSequenceLookupIter(x.GoPointer(), DataVar, purego.NewCallback(IterCmpVar), CmpDataVar)	182	+	cret := xSequenceLookupIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)
183		return cret	183		return cret
184		}	184		}
185			185

@@ -207,9 +207,9 @@ var xSequenceSearch func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
207		//	207		//
208		// This function will fail if the data contained in the sequence is	208		// This function will fail if the data contained in the sequence is
209		// unsorted.	209		// unsorted.
210	-	func (x Sequence) Search(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) SequenceIter {	210	+	func (x Sequence) Search(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
211			211
212	-	cret := xSequenceSearch(x.GoPointer(), DataVar, purego.NewCallback(CmpFuncVar), CmpDataVar)	212	+	cret := xSequenceSearch(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)
213		return cret	213		return cret
214		}	214		}
215			215

@@ -228,9 +228,9 @@ var xSequenceSearchIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
228		//	228		//
229		// This function will fail if the data contained in the sequence is	229		// This function will fail if the data contained in the sequence is
230		// unsorted.	230		// unsorted.
231	-	func (x Sequence) SearchIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) SequenceIter {	231	+	func (x Sequence) SearchIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
232			232
233	-	cret := xSequenceSearchIter(x.GoPointer(), DataVar, purego.NewCallback(IterCmpVar), CmpDataVar)	233	+	cret := xSequenceSearchIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)
234		return cret	234		return cret
235		}	235		}
236			236

@@ -242,9 +242,9 @@ var xSequenceSort func(uintptr, uintptr, uintptr)
242		// return 0 if they are equal, a negative value if the	242		// return 0 if they are equal, a negative value if the
243		// first comes before the second, and a positive value	243		// first comes before the second, and a positive value
244		// if the second comes before the first.	244		// if the second comes before the first.
245	-	func (x *Sequence) Sort(CmpFuncVar CompareDataFunc, CmpDataVar uintptr) {	245	+	func (x Sequence) Sort(CmpFuncVar CompareDataFunc, CmpDataVar uintptr) {
246			246
247	-	xSequenceSort(x.GoPointer(), purego.NewCallback(CmpFuncVar), CmpDataVar)	247	+	xSequenceSort(x.GoPointer(), NewCallback(CmpFuncVar), CmpDataVar)
248			248
249		}	249		}
250			250

@@ -257,9 +257,9 @@ var xSequenceSortIter func(uintptr, uintptr, uintptr)
257		// return 0 if the iterators are equal, a negative value if the first	257		// return 0 if the iterators are equal, a negative value if the first
258		// iterator comes before the second, and a positive value if the second	258		// iterator comes before the second, and a positive value if the second
259		// iterator comes before the first.	259		// iterator comes before the first.
260	-	func (x *Sequence) SortIter(CmpFuncVar SequenceIterCompareFunc, CmpDataVar uintptr) {	260	+	func (x Sequence) SortIter(CmpFuncVar SequenceIterCompareFunc, CmpDataVar uintptr) {
261			261
262	-	xSequenceSortIter(x.GoPointer(), purego.NewCallback(CmpFuncVar), CmpDataVar)	262	+	xSequenceSortIter(x.GoPointer(), NewCallback(CmpFuncVar), CmpDataVar)
263			263
264		}	264		}
265			265

M v4/glib/gslist.go +2 -2


@@ -25,9 +25,9 @@ var xClearSlist func(**SList, uintptr)
25		// Clears a pointer to a #GSList, freeing it and, optionally, freeing its elements using @destroy.	25		// Clears a pointer to a #GSList, freeing it and, optionally, freeing its elements using @destroy.
26		//	26		//
27		// @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing.	27		// @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing.
28	-	func ClearSlist(SlistPtrVar **SList, DestroyVar DestroyNotify) {	28	+	func ClearSlist(SlistPtrVar *SList, DestroyVar DestroyNotify) {
29			29
30	-	xClearSlist(SlistPtrVar, purego.NewCallback(DestroyVar))	30	+	xClearSlist(SlistPtrVar, NewCallback(DestroyVar))
31			31
32		}	32		}
33			33

M v4/glib/gspawn.go +10 -10


@@ -146,10 +146,10 @@ var xSpawnAsync func(string, uintptr, uintptr, SpawnFlags, uintptr, uintptr, *Pi
146		// Note that the returned @child_pid on Windows is a handle to the child	146		// Note that the returned @child_pid on Windows is a handle to the child
147		// process and not its identifier. Process handles and process identifiers	147		// process and not its identifier. Process handles and process identifiers
148		// are different concepts on Windows.	148		// are different concepts on Windows.
149	-	func SpawnAsync(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid) (bool, error) {	149	+	func SpawnAsync(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar Pid) (bool, error) {
150		var cerr *Error	150		var cerr *Error
151			151
152	-	cret := xSpawnAsync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, purego.NewCallback(ChildSetupVar), UserDataVar, ChildPidVar, &cerr)	152	+	cret := xSpawnAsync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallback(ChildSetupVar), UserDataVar, ChildPidVar, &cerr)
153		if cerr == nil {	153		if cerr == nil {
154		return cret, nil	154		return cret, nil
155		}	155		}

@@ -163,10 +163,10 @@ var xSpawnAsyncWithFds func(string, uintptr, uintptr, SpawnFlags, uintptr, uintp
163		//	163		//
164		// Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,	164		// Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
165		// so no FD assignments are used.	165		// so no FD assignments are used.
166	-	func SpawnAsyncWithFds(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {	166	+	func SpawnAsyncWithFds(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar Pid, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {
167		var cerr *Error	167		var cerr *Error
168			168
169	-	cret := xSpawnAsyncWithFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, purego.NewCallback(ChildSetupVar), UserDataVar, ChildPidVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)	169	+	cret := xSpawnAsyncWithFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallback(ChildSetupVar), UserDataVar, ChildPidVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)
170		if cerr == nil {	170		if cerr == nil {
171		return cret, nil	171		return cret, nil
172		}	172		}

@@ -178,10 +178,10 @@ var xSpawnAsyncWithPipes func(string, uintptr, uintptr, SpawnFlags, uintptr, uin
178			178
179		// Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,	179		// Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
180		// so no FD assignments are used.	180		// so no FD assignments are used.
181	-	func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StandardInputVar int, StandardOutputVar int, StandardErrorVar int) (bool, error) {	181	+	func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar Pid, StandardInputVar int, StandardOutputVar int, StandardErrorVar int) (bool, error) {
182		var cerr *Error	182		var cerr *Error
183			183
184	-	cret := xSpawnAsyncWithPipes(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, purego.NewCallback(ChildSetupVar), UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)	184	+	cret := xSpawnAsyncWithPipes(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallback(ChildSetupVar), UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)
185		if cerr == nil {	185		if cerr == nil {
186		return cret, nil	186		return cret, nil
187		}	187		}

@@ -379,10 +379,10 @@ var xSpawnAsyncWithPipesAndFds func(string, uintptr, uintptr, SpawnFlags, uintpt
379		// graphical application too, then to ensure that the spawned program opens its	379		// graphical application too, then to ensure that the spawned program opens its
380		// windows on the right screen, you may want to use #GdkAppLaunchContext,	380		// windows on the right screen, you may want to use #GdkAppLaunchContext,
381		// #GAppLaunchContext, or set the `DISPLAY` environment variable.	381		// #GAppLaunchContext, or set the `DISPLAY` environment variable.
382	-	func SpawnAsyncWithPipesAndFds(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int, SourceFdsVar uintptr, TargetFdsVar uintptr, NFdsVar uint, ChildPidOutVar *Pid, StdinPipeOutVar int, StdoutPipeOutVar int, StderrPipeOutVar int) (bool, error) {	382	+	func SpawnAsyncWithPipesAndFds(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int, SourceFdsVar uintptr, TargetFdsVar uintptr, NFdsVar uint, ChildPidOutVar Pid, StdinPipeOutVar int, StdoutPipeOutVar int, StderrPipeOutVar int) (bool, error) {
383		var cerr *Error	383		var cerr *Error
384			384
385	-	cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, purego.NewCallback(ChildSetupVar), UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)	385	+	cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallback(ChildSetupVar), UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)
386		if cerr == nil {	386		if cerr == nil {
387		return cret, nil	387		return cret, nil
388		}	388		}

@@ -565,10 +565,10 @@ var xSpawnSync func(string, uintptr, uintptr, SpawnFlags, uintptr, uintptr, uint
565		// This function calls g_spawn_async_with_pipes() internally; see that	565		// This function calls g_spawn_async_with_pipes() internally; see that
566		// function for full details on the other parameters and details on	566		// function for full details on the other parameters and details on
567		// how these functions work on Windows.	567		// how these functions work on Windows.
568	-	func SpawnSync(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar uintptr, StandardErrorVar uintptr, WaitStatusVar int) (bool, error) {	568	+	func SpawnSync(WorkingDirectoryVar string, ArgvVar uintptr, EnvpVar uintptr, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar uintptr, StandardErrorVar uintptr, WaitStatusVar int) (bool, error) {
569		var cerr *Error	569		var cerr *Error
570			570
571	-	cret := xSpawnSync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, purego.NewCallback(ChildSetupVar), UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)	571	+	cret := xSpawnSync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallback(ChildSetupVar), UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)
572		if cerr == nil {	572		if cerr == nil {
573		return cret, nil	573		return cret, nil
574		}	574		}

M v4/glib/gtestutils.go +14 -14


@@ -377,9 +377,9 @@ var xTestAddDataFunc func(string, uintptr, uintptr)
377		// No component of @testpath may start with a dot (`.`) if the	377		// No component of @testpath may start with a dot (`.`) if the
378		// %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to	378		// %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to
379		// do so even if it isn’t.	379		// do so even if it isn’t.
380	-	func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar TestDataFunc) {	380	+	func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc) {
381			381
382	-	xTestAddDataFunc(TestpathVar, TestDataVar, purego.NewCallback(TestFuncVar))	382	+	xTestAddDataFunc(TestpathVar, TestDataVar, NewCallback(TestFuncVar))
383			383
384		}	384		}
385			385

@@ -387,9 +387,9 @@ var xTestAddDataFuncFull func(string, uintptr, uintptr, uintptr)
387			387
388		// Create a new test case, as with g_test_add_data_func(), but freeing	388		// Create a new test case, as with g_test_add_data_func(), but freeing
389		// @test_data after the test run is complete.	389		// @test_data after the test run is complete.
390	-	func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar TestDataFunc, DataFreeFuncVar DestroyNotify) {	390	+	func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar TestDataFunc, DataFreeFuncVar DestroyNotify) {
391			391
392	-	xTestAddDataFuncFull(TestpathVar, TestDataVar, purego.NewCallback(TestFuncVar), purego.NewCallback(DataFreeFuncVar))	392	+	xTestAddDataFuncFull(TestpathVar, TestDataVar, NewCallback(TestFuncVar), NewCallback(DataFreeFuncVar))
393			393
394		}	394		}
395			395

@@ -407,17 +407,17 @@ var xTestAddFunc func(string, uintptr)
407		// No component of @testpath may start with a dot (`.`) if the	407		// No component of @testpath may start with a dot (`.`) if the
408		// %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to	408		// %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to
409		// do so even if it isn’t.	409		// do so even if it isn’t.
410	-	func TestAddFunc(TestpathVar string, TestFuncVar TestFunc) {	410	+	func TestAddFunc(TestpathVar string, TestFuncVar *TestFunc) {
411			411
412	-	xTestAddFunc(TestpathVar, purego.NewCallback(TestFuncVar))	412	+	xTestAddFunc(TestpathVar, NewCallback(TestFuncVar))
413			413
414		}	414		}
415			415
416		var xTestAddVtable func(string, uint, uintptr, uintptr, uintptr, uintptr)	416		var xTestAddVtable func(string, uint, uintptr, uintptr, uintptr, uintptr)
417			417
418	-	func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar TestFixtureFunc) {	418	+	func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar *TestFixtureFunc) {
419			419
420	-	xTestAddVtable(TestpathVar, DataSizeVar, TestDataVar, purego.NewCallback(DataSetupVar), purego.NewCallback(DataTestVar), purego.NewCallback(DataTeardownVar))	420	+	xTestAddVtable(TestpathVar, DataSizeVar, TestDataVar, NewCallback(DataSetupVar), NewCallback(DataTestVar), NewCallback(DataTeardownVar))
421			421
422		}	422		}
423			423

@@ -518,9 +518,9 @@ var xTestCreateCase func(string, uint, uintptr, uintptr, uintptr, uintptr) *Test
518		// multiple tests. In this cases, g_test_create_case() will be	518		// multiple tests. In this cases, g_test_create_case() will be
519		// called with the same type of fixture (the @data_size argument), but varying	519		// called with the same type of fixture (the @data_size argument), but varying
520		// @test_name and @data_test arguments.	520		// @test_name and @data_test arguments.
521	-	func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar TestFixtureFunc) *TestCase {	521	+	func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar TestFixtureFunc) TestCase {
522			522
523	-	cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, purego.NewCallback(DataSetupVar), purego.NewCallback(DataTestVar), purego.NewCallback(DataTeardownVar))	523	+	cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, NewCallback(DataSetupVar), NewCallback(DataTestVar), NewCallback(DataTeardownVar))
524		return cret	524		return cret
525		}	525		}
526			526

@@ -798,9 +798,9 @@ var xTestLogSetFatalHandler func(uintptr, uintptr)
798		// behaviour for specific log messages, programs must install a custom log	798		// behaviour for specific log messages, programs must install a custom log
799		// writer function using g_log_set_writer_func().See	799		// writer function using g_log_set_writer_func().See
800		// [Using Structured Logging][using-structured-logging].	800		// [Using Structured Logging][using-structured-logging].
801	-	func TestLogSetFatalHandler(LogFuncVar TestLogFatalFunc, UserDataVar uintptr) {	801	+	func TestLogSetFatalHandler(LogFuncVar *TestLogFatalFunc, UserDataVar uintptr) {
802			802
803	-	xTestLogSetFatalHandler(purego.NewCallback(LogFuncVar), UserDataVar)	803	+	xTestLogSetFatalHandler(NewCallback(LogFuncVar), UserDataVar)
804			804
805		}	805		}
806			806

@@ -855,9 +855,9 @@ var xTestQueueDestroy func(uintptr, uintptr)
855		// Resources are released in reverse queue order, that means enqueueing	855		// Resources are released in reverse queue order, that means enqueueing
856		// callback A before callback B will cause B() to be called before	856		// callback A before callback B will cause B() to be called before
857		// A() during teardown.	857		// A() during teardown.
858	-	func TestQueueDestroy(DestroyFuncVar DestroyNotify, DestroyDataVar uintptr) {	858	+	func TestQueueDestroy(DestroyFuncVar *DestroyNotify, DestroyDataVar uintptr) {
859			859
860	-	xTestQueueDestroy(purego.NewCallback(DestroyFuncVar), DestroyDataVar)	860	+	xTestQueueDestroy(NewCallback(DestroyFuncVar), DestroyDataVar)
861			861
862		}	862		}
863			863

M v4/glib/gthread.go +6 -6


@@ -242,9 +242,9 @@ func (x *Once) GoPointer() uintptr {
242			242
243		var xOnceImpl func(uintptr, uintptr, uintptr) uintptr	243		var xOnceImpl func(uintptr, uintptr, uintptr) uintptr
244			244
245	-	func (x *Once) Impl(FuncVar ThreadFunc, ArgVar uintptr) uintptr {	245	+	func (x Once) Impl(FuncVar ThreadFunc, ArgVar uintptr) uintptr {
246			246
247	-	cret := xOnceImpl(x.GoPointer(), purego.NewCallback(FuncVar), ArgVar)	247	+	cret := xOnceImpl(x.GoPointer(), NewCallback(FuncVar), ArgVar)
248		return cret	248		return cret
249		}	249		}
250			250

@@ -689,9 +689,9 @@ var xNewThread func(string, uintptr, uintptr) *Thread
689		// inheriting the thread priority but were spawned with the default priority.	689		// inheriting the thread priority but were spawned with the default priority.
690		// Starting with GLib 2.64 the behaviour is now consistent between Windows and	690		// Starting with GLib 2.64 the behaviour is now consistent between Windows and
691		// POSIX and all threads inherit their parent thread's priority.	691		// POSIX and all threads inherit their parent thread's priority.
692	-	func NewThread(NameVar string, FuncVar ThreadFunc, DataVar uintptr) *Thread {	692	+	func NewThread(NameVar string, FuncVar ThreadFunc, DataVar uintptr) Thread {
693			693
694	-	cret := xNewThread(NameVar, purego.NewCallback(FuncVar), DataVar)	694	+	cret := xNewThread(NameVar, NewCallback(FuncVar), DataVar)
695		return cret	695		return cret
696		}	696		}
697			697

@@ -702,10 +702,10 @@ var xThreadTryNew func(string, uintptr, uintptr, *Error) Thread
702		//	702		//
703		// If a thread can not be created (due to resource limits),	703		// If a thread can not be created (due to resource limits),
704		// @error is set and %NULL is returned.	704		// @error is set and %NULL is returned.
705	-	func ThreadTryNew(NameVar string, FuncVar ThreadFunc, DataVar uintptr) (*Thread, error) {	705	+	func ThreadTryNew(NameVar string, FuncVar ThreadFunc, DataVar uintptr) (Thread, error) {
706		var cerr *Error	706		var cerr *Error
707			707
708	-	cret := xThreadTryNew(NameVar, purego.NewCallback(FuncVar), DataVar, &cerr)	708	+	cret := xThreadTryNew(NameVar, NewCallback(FuncVar), DataVar, &cerr)
709		if cerr == nil {	709		if cerr == nil {
710		return cret, nil	710		return cret, nil
711		}	711		}

M v4/glib/gthreadpool.go +2 -2


@@ -144,9 +144,9 @@ var xThreadPoolSetSortFunction func(uintptr, uintptr, uintptr)
144		// scheduled by the operating system and are executed at random. It	144		// scheduled by the operating system and are executed at random. It
145		// cannot be assumed that threads are executed in the order they are	145		// cannot be assumed that threads are executed in the order they are
146		// created.	146		// created.
147	-	func (x *ThreadPool) SetSortFunction(FuncVar CompareDataFunc, UserDataVar uintptr) {	147	+	func (x ThreadPool) SetSortFunction(FuncVar CompareDataFunc, UserDataVar uintptr) {
148			148
149	-	xThreadPoolSetSortFunction(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	149	+	xThreadPoolSetSortFunction(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
150			150
151		}	151		}
152			152

M v4/glib/gtree.go +16 -16


@@ -33,9 +33,9 @@ func (x *Tree) GoPointer() uintptr {
33		var xNewTree func(uintptr) *Tree	33		var xNewTree func(uintptr) *Tree
34			34
35		// Creates a new #GTree.	35		// Creates a new #GTree.
36	-	func NewTree(KeyCompareFuncVar CompareFunc) *Tree {	36	+	func NewTree(KeyCompareFuncVar CompareFunc) Tree {
37			37
38	-	cret := xNewTree(purego.NewCallback(KeyCompareFuncVar))	38	+	cret := xNewTree(NewCallback(KeyCompareFuncVar))
39		return cret	39		return cret
40		}	40		}
41			41

@@ -44,9 +44,9 @@ var xNewTreeFull func(uintptr, uintptr, uintptr, uintptr) *Tree
44		// Creates a new #GTree like g_tree_new() and allows to specify functions	44		// Creates a new #GTree like g_tree_new() and allows to specify functions
45		// to free the memory allocated for the key and value that get called when	45		// to free the memory allocated for the key and value that get called when
46		// removing the entry from the #GTree.	46		// removing the entry from the #GTree.
47	-	func NewTreeFull(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar DestroyNotify, ValueDestroyFuncVar DestroyNotify) *Tree {	47	+	func NewTreeFull(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar DestroyNotify, ValueDestroyFuncVar DestroyNotify) Tree {
48			48
49	-	cret := xNewTreeFull(purego.NewCallback(KeyCompareFuncVar), KeyCompareDataVar, purego.NewCallback(KeyDestroyFuncVar), purego.NewCallback(ValueDestroyFuncVar))	49	+	cret := xNewTreeFull(NewCallback(KeyCompareFuncVar), KeyCompareDataVar, NewCallback(KeyDestroyFuncVar), NewCallback(ValueDestroyFuncVar))
50		return cret	50		return cret
51		}	51		}
52			52

@@ -54,9 +54,9 @@ var xNewTreeWithData func(uintptr, uintptr) *Tree
54			54
55		// Creates a new #GTree with a comparison function that accepts user data.	55		// Creates a new #GTree with a comparison function that accepts user data.
56		// See g_tree_new() for more details.	56		// See g_tree_new() for more details.
57	-	func NewTreeWithData(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr) *Tree {	57	+	func NewTreeWithData(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr) Tree {
58			58
59	-	cret := xNewTreeWithData(purego.NewCallback(KeyCompareFuncVar), KeyCompareDataVar)	59	+	cret := xNewTreeWithData(NewCallback(KeyCompareFuncVar), KeyCompareDataVar)
60		return cret	60		return cret
61		}	61		}
62			62

@@ -84,9 +84,9 @@ var xTreeForeach func(uintptr, uintptr, uintptr)
84		// add/remove items). To remove all items matching a predicate, you need	84		// add/remove items). To remove all items matching a predicate, you need
85		// to add each item to a list in your #GTraverseFunc as you walk over	85		// to add each item to a list in your #GTraverseFunc as you walk over
86		// the tree, then walk the list and remove each item.	86		// the tree, then walk the list and remove each item.
87	-	func (x *Tree) Foreach(FuncVar TraverseFunc, UserDataVar uintptr) {	87	+	func (x Tree) Foreach(FuncVar TraverseFunc, UserDataVar uintptr) {
88			88
89	-	xTreeForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	89	+	xTreeForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
90			90
91		}	91		}
92			92

@@ -100,9 +100,9 @@ var xTreeForeachNode func(uintptr, uintptr, uintptr)
100		// add/remove items). To remove all items matching a predicate, you need	100		// add/remove items). To remove all items matching a predicate, you need
101		// to add each item to a list in your #GTraverseFunc as you walk over	101		// to add each item to a list in your #GTraverseFunc as you walk over
102		// the tree, then walk the list and remove each item.	102		// the tree, then walk the list and remove each item.
103	-	func (x *Tree) ForeachNode(FuncVar TraverseNodeFunc, UserDataVar uintptr) {	103	+	func (x Tree) ForeachNode(FuncVar TraverseNodeFunc, UserDataVar uintptr) {
104			104
105	-	xTreeForeachNode(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	105	+	xTreeForeachNode(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
106			106
107		}	107		}
108			108

@@ -306,9 +306,9 @@ var xTreeSearch func(uintptr, uintptr, uintptr) uintptr
306		// will proceed among the key/value pairs that have a smaller key; if	306		// will proceed among the key/value pairs that have a smaller key; if
307		// @search_func returns 1, searching will proceed among the key/value	307		// @search_func returns 1, searching will proceed among the key/value
308		// pairs that have a larger key.	308		// pairs that have a larger key.
309	-	func (x *Tree) Search(SearchFuncVar CompareFunc, UserDataVar uintptr) uintptr {	309	+	func (x Tree) Search(SearchFuncVar CompareFunc, UserDataVar uintptr) uintptr {
310			310
311	-	cret := xTreeSearch(x.GoPointer(), purego.NewCallback(SearchFuncVar), UserDataVar)	311	+	cret := xTreeSearch(x.GoPointer(), NewCallback(SearchFuncVar), UserDataVar)
312		return cret	312		return cret
313		}	313		}
314			314

@@ -323,9 +323,9 @@ var xTreeSearchNode func(uintptr, uintptr, uintptr) *TreeNode
323		// will proceed among the key/value pairs that have a smaller key; if	323		// will proceed among the key/value pairs that have a smaller key; if
324		// @search_func returns 1, searching will proceed among the key/value	324		// @search_func returns 1, searching will proceed among the key/value
325		// pairs that have a larger key.	325		// pairs that have a larger key.
326	-	func (x Tree) SearchNode(SearchFuncVar CompareFunc, UserDataVar uintptr) TreeNode {	326	+	func (x Tree) SearchNode(SearchFuncVar CompareFunc, UserDataVar uintptr) *TreeNode {
327			327
328	-	cret := xTreeSearchNode(x.GoPointer(), purego.NewCallback(SearchFuncVar), UserDataVar)	328	+	cret := xTreeSearchNode(x.GoPointer(), NewCallback(SearchFuncVar), UserDataVar)
329		return cret	329		return cret
330		}	330		}
331			331

@@ -344,9 +344,9 @@ func (x *Tree) Steal(KeyVar uintptr) bool {
344		var xTreeTraverse func(uintptr, uintptr, TraverseType, uintptr)	344		var xTreeTraverse func(uintptr, uintptr, TraverseType, uintptr)
345			345
346		// Calls the given function for each node in the #GTree.	346		// Calls the given function for each node in the #GTree.
347	-	func (x *Tree) Traverse(TraverseFuncVar TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {	347	+	func (x Tree) Traverse(TraverseFuncVar TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {
348			348
349	-	xTreeTraverse(x.GoPointer(), purego.NewCallback(TraverseFuncVar), TraverseTypeVar, UserDataVar)	349	+	xTreeTraverse(x.GoPointer(), NewCallback(TraverseFuncVar), TraverseTypeVar, UserDataVar)
350			350
351		}	351		}
352			352

M v4/glib/gutils.go +2 -2


@@ -108,9 +108,9 @@ var xAtexit func(uintptr)
108		// As can be seen from the above, for portability it's best to avoid	108		// As can be seen from the above, for portability it's best to avoid
109		// calling g_atexit() (or atexit()) except in the main executable of a	109		// calling g_atexit() (or atexit()) except in the main executable of a
110		// program.	110		// program.
111	-	func Atexit(FuncVar VoidFunc) {	111	+	func Atexit(FuncVar *VoidFunc) {
112			112
113	-	xAtexit(purego.NewCallback(FuncVar))	113	+	xAtexit(NewCallback(FuncVar))
114			114
115		}	115		}
116			116

M v4/glib/gvariant.go +2 -2


@@ -455,9 +455,9 @@ var xNewVariantFromData func(*VariantType, uintptr, uint, bool, uintptr, uintptr
455		// @type being loaded. Otherwise this function will internally create a copy of	455		// @type being loaded. Otherwise this function will internally create a copy of
456		// the memory (since GLib 2.60) or (in older versions) fail and exit the	456		// the memory (since GLib 2.60) or (in older versions) fail and exit the
457		// process.	457		// process.
458	-	func NewVariantFromData(TypeVar VariantType, DataVar uintptr, SizeVar uint, TrustedVar bool, NotifyVar DestroyNotify, UserDataVar uintptr) Variant {	458	+	func NewVariantFromData(TypeVar VariantType, DataVar uintptr, SizeVar uint, TrustedVar bool, NotifyVar DestroyNotify, UserDataVar uintptr) *Variant {
459			459
460	-	cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, purego.NewCallback(NotifyVar), UserDataVar)	460	+	cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, NewCallback(NotifyVar), UserDataVar)
461		return cret	461		return cret
462		}	462		}
463			463

M v4/glib/more.go +40 -0


@@ -2,10 +2,50 @@ package glib
2		2
3	import (	3		import (
4	"fmt"	4		"fmt"
		5	+	"sync"
5		6
		7	+	"github.com/jwijenbergh/purego"
6	"github.com/jwijenbergh/puregotk/internal/core"	8		"github.com/jwijenbergh/puregotk/internal/core"
7	)	9		)
8		10
		11	+	var callbacks = struct {
		12	+	sync.RWMutex
		13	+	refs map[uintptr]uintptr
		14	+	}{
		15	+	refs: make(map[uintptr]uintptr),
		16	+	}
		17	+
		18	+	// GetCallback retrives a callback reference by value.
		19	+	// Users should not need to call this.
		20	+	func GetCallback(cbPtr uintptr) (uintptr, bool) {
		21	+	callbacks.RLock()
		22	+	defer callbacks.RUnlock()
		23	+	refPtr, ok := callbacks.refs[cbPtr]
		24	+	return refPtr, ok
		25	+	}
		26	+
		27	+	// SaveCallback saves a reference to the callback value.
		28	+	// Users should not need to call this.
		29	+	func SaveCallback(cbPtr uintptr, refPtr uintptr) {
		30	+	callbacks.Lock()
		31	+	callbacks.refs[cbPtr] = refPtr
		32	+	callbacks.Unlock()
		33	+	}
		34	+
		35	+	// UnrefCallbackValue unreferences the provided callback by reflect.value to free a purego slot
		36	+	//
		37	+	// NOTE: Windows does not support unreferencing callbacks, so on that platform this operation is
		38	+	// a NOOP, callback memory is never freed, and there is a limit on maximum total callbacks.
		39	+	// See the purego documentation for further details.
		40	+	func UnrefCallback(fnPtr interface{}) error {
		41	+	return unrefCallback(fnPtr)
		42	+	}
		43	+
		44	+	// NewCallback is an alias to purego.NewCallback
		45	+	func NewCallback(fnPtr interface{}) uintptr {
		46	+	return purego.NewCallbackFnPtr(fnPtr)
		47	+	}
		48	+
9	func (e *Error) Error() string {	49		func (e *Error) Error() string {
10	return fmt.Sprintf("Gtk reported an error with message: '%s', domain: '%v' and code: '%v'", e.MessageGo(), e.Domain, e.Code)	50		return fmt.Sprintf("Gtk reported an error with message: '%s', domain: '%v' and code: '%v'", e.MessageGo(), e.Domain, e.Code)
11	}	51		}

A v4/glib/more_other.go +8 -0

@@ -0,0 +1,8 @@
	1	+	//go:build !windows && !darwin && !freebsd && (!linux \|\| (!amd64 && !arm64))
	2	+
	3	+	package glib
	4	+
	5	+	// unrefCallback on unsupported on other platforms
	6	+	func unrefCallback(_ interface{}) error {
	7	+	panic("glib.UnrefCallback is unsupported on this platform")
	8	+	}

A v4/glib/more_sysv.go +31 -0

@@ -0,0 +1,31 @@
	1	+	//go:build darwin \|\| freebsd \|\| (linux && (amd64 \|\| arm64))
	2	+
	3	+	package glib
	4	+
	5	+	import (
	6	+	"fmt"
	7	+	"reflect"
	8	+
	9	+	"github.com/jwijenbergh/purego"
	10	+	)
	11	+
	12	+	func unrefCallback(fnPtr interface{}) error {
	13	+	val := reflect.ValueOf(fnPtr)
	14	+	if val.IsNil() {
	15	+	return fmt.Errorf("function pointer must not be nil")
	16	+	}
	17	+	if val.Kind() != reflect.Ptr \|\| val.Elem().Kind() != reflect.Func {
	18	+	return fmt.Errorf("type must be a function pointer")
	19	+	}
	20	+	cbPtr := reflect.ValueOf(fnPtr).Pointer()
	21	+	refPtr, ok := GetCallback(cbPtr)
	22	+	if !ok {
	23	+	return purego.UnrefCallbackFnPtr(fnPtr)
	24	+	}
	25	+	defer func() {
	26	+	callbacks.Lock()
	27	+	delete(callbacks.refs, cbPtr)
	28	+	callbacks.Unlock()
	29	+	}()
	30	+	return purego.UnrefCallback(refPtr)
	31	+	}

A v4/glib/more_windows.go +6 -0

@@ -0,0 +1,6 @@
	1	+	package glib
	2	+
	3	+	// unrefCallback on Windows is a NOOP.
	4	+	func unrefCallback(_ interface{}) error {
	5	+	return nil
	6	+	}

M v4/gobject/gboxed.go +3 -2

 import (
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 )
 // This function is provided by the user and should produce a copy
 // For the general case, it is recommended to use G_DEFINE_BOXED_TYPE()
 // instead of calling g_boxed_type_register_static() directly. The macro
 // will create the appropriate `*_get_type()` function for the boxed type.
-func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar BoxedCopyFunc, BoxedFreeVar BoxedFreeFunc) []interface{} {
+func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar *BoxedCopyFunc, BoxedFreeVar *BoxedFreeFunc) []interface{} {
-	cret := xBoxedTypeRegisterStatic(NameVar, purego.NewCallback(BoxedCopyVar), purego.NewCallback(BoxedFreeVar))
+	cret := xBoxedTypeRegisterStatic(NameVar, glib.NewCallback(BoxedCopyVar), glib.NewCallback(BoxedFreeVar))
 	return cret
 }

M v4/gobject/gclosure.go +19 -18

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 )
 // The type used for callback functions in structure definitions and function
 // unspecified order. If a single call to g_closure_unref() results in
 // the closure being both invalidated and finalized, then the invalidate
 // notifiers will be run before the finalize notifiers.
-func (x *Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
+func (x *Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
-	xClosureAddFinalizeNotifier(x.GoPointer(), NotifyDataVar, purego.NewCallback(NotifyFuncVar))
+	xClosureAddFinalizeNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))
 }
 //
 // Invalidation notifiers are invoked before finalization notifiers,
 // in an unspecified order.
-func (x *Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
+func (x *Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
-	xClosureAddInvalidateNotifier(x.GoPointer(), NotifyDataVar, purego.NewCallback(NotifyFuncVar))
+	xClosureAddInvalidateNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))
 }
 // This is typically used to protect the extra arguments for the
 // duration of the callback. See g_object_watch_closure() for an
 // example of marshal guards.
-func (x *Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar ClosureNotify) {
+func (x *Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar *ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify) {
-	xClosureAddMarshalGuards(x.GoPointer(), PreMarshalDataVar, purego.NewCallback(PreMarshalNotifyVar), PostMarshalDataVar, purego.NewCallback(PostMarshalNotifyVar))
+	xClosureAddMarshalGuards(x.GoPointer(), PreMarshalDataVar, glib.NewCallback(PreMarshalNotifyVar), PostMarshalDataVar, glib.NewCallback(PostMarshalNotifyVar))
 }
 // Removes a finalization notifier.
 //
 // Notice that notifiers are automatically removed after they are run.
-func (x *Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
+func (x *Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
-	xClosureRemoveFinalizeNotifier(x.GoPointer(), NotifyDataVar, purego.NewCallback(NotifyFuncVar))
+	xClosureRemoveFinalizeNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))
 }
 // Removes an invalidation notifier.
 //
 // Notice that notifiers are automatically removed after they are run.
-func (x *Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
+func (x *Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
-	xClosureRemoveInvalidateNotifier(x.GoPointer(), NotifyDataVar, purego.NewCallback(NotifyFuncVar))
+	xClosureRemoveInvalidateNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))
 }
 // @closure-&gt;callback.
 //
 // See also: g_closure_set_meta_marshal()
-func (x *Closure) SetMarshal(MarshalVar ClosureMarshal) {
+func (x *Closure) SetMarshal(MarshalVar *ClosureMarshal) {
-	xClosureSetMarshal(x.GoPointer(), purego.NewCallback(MarshalVar))
+	xClosureSetMarshal(x.GoPointer(), glib.NewCallback(MarshalVar))
 }
 // fixed offset in the class structure.  The meta marshaller retrieves
 // the right callback and passes it to the marshaller as the
 // @marshal_data argument.
-func (x *Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar ClosureMarshal) {
+func (x *Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar *ClosureMarshal) {
-	xClosureSetMetaMarshal(x.GoPointer(), MarshalDataVar, purego.NewCallback(MetaMarshalVar))
+	xClosureSetMetaMarshal(x.GoPointer(), MarshalDataVar, glib.NewCallback(MetaMarshalVar))
 }
 // the last parameter.
 //
 // @destroy_data will be called as a finalize notifier on the #GClosure.
-func CclosureNew(CallbackFuncVar Callback, UserDataVar uintptr, DestroyDataVar ClosureNotify) *Closure {
+func CclosureNew(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {
-	cret := xCclosureNew(purego.NewCallback(CallbackFuncVar), UserDataVar, purego.NewCallback(DestroyDataVar))
+	cret := xCclosureNew(glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallback(DestroyDataVar))
 	return cret
 }
 // the first parameter.
 //
 // @destroy_data will be called as a finalize notifier on the #GClosure.
-func CclosureNewSwap(CallbackFuncVar Callback, UserDataVar uintptr, DestroyDataVar ClosureNotify) *Closure {
+func CclosureNewSwap(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {
-	cret := xCclosureNewSwap(purego.NewCallback(CallbackFuncVar), UserDataVar, purego.NewCallback(DestroyDataVar))
+	cret := xCclosureNewSwap(glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallback(DestroyDataVar))
 	return cret
 }

M v4/gobject/gobject-2.0.go +36 -18

 package gobject
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 // %G_BINDING_SYNC_CREATE is automatically specified.
 //
 // See g_object_bind_property_full() for more information.
-func (x *BindingGroup) BindFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar BindingTransformFunc, TransformFromVar BindingTransformFunc, UserDataVar uintptr, UserDataDestroyVar glib.DestroyNotify) {
+func (x *BindingGroup) BindFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, UserDataDestroyVar *glib.DestroyNotify) {
-	xBindingGroupBindFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, purego.NewCallback(TransformToVar), purego.NewCallback(TransformFromVar), UserDataVar, purego.NewCallback(UserDataDestroyVar))
+	xBindingGroupBindFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, glib.NewCallback(TransformToVar), glib.NewCallback(TransformFromVar), UserDataVar, glib.NewCallback(UserDataDestroyVar))
 }
 // on the target instance of @self.
 //
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
-func (x *SignalGroup) Connect(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
+func (x *SignalGroup) Connect(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
-	xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, purego.NewCallback(CHandlerVar), DataVar)
+	xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)
 }
 // The @c_handler will be called after the default handler of the signal.
 //
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
-func (x *SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
+func (x *SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
-	xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, purego.NewCallback(CHandlerVar), DataVar)
+	xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)
 }
 // on the target instance of @self.
 //
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
-func (x *SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, NotifyVar ClosureNotify, FlagsVar ConnectFlags) {
+func (x *SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {
-	xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, purego.NewCallback(CHandlerVar), DataVar, purego.NewCallback(NotifyVar), FlagsVar)
+	xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar, glib.NewCallback(NotifyVar), FlagsVar)
 }
 // the signal handler will automatically be removed.
 //
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
-func (x *SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {
+func (x *SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar *Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {
-	xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, purego.NewCallback(CHandlerVar), ObjectVar, FlagsVar)
+	xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), ObjectVar, FlagsVar)
 }
 // will be swapped when calling @c_handler.
 //
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
-func (x *SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
+func (x *SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
-	xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, purego.NewCallback(CHandlerVar), DataVar)
+	xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)
 }
 // other than %NULL. It is similar to #GObject::notify on `target` except it
 // will not emit when #GSignalGroup:target is %NULL and also allows for
 // receiving the #GObject without a data-race.
-func (x *SignalGroup) ConnectBind(cb func(SignalGroup, uintptr)) uint32 {
+func (x *SignalGroup) ConnectBind(cb *func(SignalGroup, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, InstanceVarp uintptr) {
 		fa := SignalGroup{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, InstanceVarp)
+		cbFn(fa, InstanceVarp)
 	}
-	return SignalConnect(x.GoPointer(), "bind", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return SignalConnect(x.GoPointer(), "bind", cbRefPtr)
 }
 // This signal is emitted when the target instance of @self is set to a
 //
 // This signal will only be emitted if the previous target of @self is
 // non-%NULL.
-func (x *SignalGroup) ConnectUnbind(cb func(SignalGroup)) uint32 {
+func (x *SignalGroup) ConnectUnbind(cb *func(SignalGroup)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SignalGroup{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return SignalConnect(x.GoPointer(), "unbind", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
 }
 func init() {

M v4/gobject/gobject.go +39 -31

 // closure. This function is useful when you have a callback closely
 // associated with a #GObject, and want the callback to no longer run
 // after the object is is freed.
-func CclosureNewObject(CallbackFuncVar Callback, ObjectVar *Object) *Closure {
+func CclosureNewObject(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {
-	cret := xCclosureNewObject(purego.NewCallback(CallbackFuncVar), ObjectVar.GoPointer())
+	cret := xCclosureNewObject(glib.NewCallback(CallbackFuncVar), ObjectVar.GoPointer())
 	return cret
 }
 // closure. This function is useful when you have a callback closely
 // associated with a #GObject, and want the callback to no longer run
 // after the object is is freed.
-func CclosureNewObjectSwap(CallbackFuncVar Callback, ObjectVar *Object) *Closure {
+func CclosureNewObjectSwap(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {
-	cret := xCclosureNewObjectSwap(purego.NewCallback(CallbackFuncVar), ObjectVar.GoPointer())
+	cret := xCclosureNewObjectSwap(glib.NewCallback(CallbackFuncVar), ObjectVar.GoPointer())
 	return cret
 }
 // disconnected.  Note that this is not currently threadsafe (ie:
 // emitting a signal while @gobject is being destroyed in another thread
 // is not safe).
-func SignalConnectObject(InstanceVar *TypeInstance, DetailedSignalVar string, CHandlerVar Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {
+func SignalConnectObject(InstanceVar *TypeInstance, DetailedSignalVar string, CHandlerVar *Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {
-	cret := xSignalConnectObject(InstanceVar, DetailedSignalVar, purego.NewCallback(CHandlerVar), GobjectVar.GoPointer(), ConnectFlagsVar)
+	cret := xSignalConnectObject(InstanceVar, DetailedSignalVar, glib.NewCallback(CHandlerVar), GobjectVar.GoPointer(), ConnectFlagsVar)
 	return cret
 }
 // of them will ever be notified until all but one are removed.  For
 // this reason, you should only ever use a toggle reference if there
 // is important state in the proxy object.
-func (x *Object) AddToggleRef(NotifyVar ToggleNotify, DataVar uintptr) {
+func (x *Object) AddToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {
-	xObjectAddToggleRef(x.GoPointer(), purego.NewCallback(NotifyVar), DataVar)
+	xObjectAddToggleRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)
 }
 // be called once, when the binding is removed. If you need different data
 // for each transformation function, please use
 // g_object_bind_property_with_closures() instead.
-func (x *Object) BindPropertyFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar BindingTransformFunc, TransformFromVar BindingTransformFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify) *Binding {
+func (x *Object) BindPropertyFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) *Binding {
 	var cls *Binding
-	cret := xObjectBindPropertyFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, purego.NewCallback(TransformToVar), purego.NewCallback(TransformFromVar), UserDataVar, purego.NewCallback(NotifyVar))
+	cret := xObjectBindPropertyFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, glib.NewCallback(TransformToVar), glib.NewCallback(TransformFromVar), UserDataVar, glib.NewCallback(NotifyVar))
 	if cret == 0 {
 		return nil
 // This function can be useful to avoid races when multiple
 // threads are using object data on the same key on the same
 // object.
-func (x *Object) DupData(KeyVar string, DupFuncVar glib.DuplicateFunc, UserDataVar uintptr) uintptr {
+func (x *Object) DupData(KeyVar string, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr {
-	cret := xObjectDupData(x.GoPointer(), KeyVar, purego.NewCallback(DupFuncVar), UserDataVar)
+	cret := xObjectDupData(x.GoPointer(), KeyVar, glib.NewCallback(DupFuncVar), UserDataVar)
 	return cret
 }
 // This function can be useful to avoid races when multiple
 // threads are using object data on the same key on the same
 // object.
-func (x *Object) DupQdata(QuarkVar glib.Quark, DupFuncVar glib.DuplicateFunc, UserDataVar uintptr) uintptr {
+func (x *Object) DupQdata(QuarkVar glib.Quark, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr {
-	cret := xObjectDupQdata(x.GoPointer(), QuarkVar, purego.NewCallback(DupFuncVar), UserDataVar)
+	cret := xObjectDupQdata(x.GoPointer(), QuarkVar, glib.NewCallback(DupFuncVar), UserDataVar)
 	return cret
 }
 // Removes a reference added with g_object_add_toggle_ref(). The
 // reference count of the object is decreased by one.
-func (x *Object) RemoveToggleRef(NotifyVar ToggleNotify, DataVar uintptr) {
+func (x *Object) RemoveToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {
-	xObjectRemoveToggleRef(x.GoPointer(), purego.NewCallback(NotifyVar), DataVar)
+	xObjectRemoveToggleRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)
 }
 //
 // See g_object_set_data() for guidance on using a small, bounded set of values
 // for @key.
-func (x *Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar glib.DestroyNotify) bool {
+func (x *Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
-	cret := xObjectReplaceData(x.GoPointer(), KeyVar, OldvalVar, NewvalVar, purego.NewCallback(DestroyVar), purego.NewCallback(OldDestroyVar))
+	cret := xObjectReplaceData(x.GoPointer(), KeyVar, OldvalVar, NewvalVar, glib.NewCallback(DestroyVar), glib.NewCallback(OldDestroyVar))
 	return cret
 }
 // It’s up to the caller to free this as needed, which may
 // or may not include using @old_destroy as sometimes replacement
 // should not destroy the object in the normal way.
-func (x *Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar glib.DestroyNotify) bool {
+func (x *Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
-	cret := xObjectReplaceQdata(x.GoPointer(), QuarkVar, OldvalVar, NewvalVar, purego.NewCallback(DestroyVar), purego.NewCallback(OldDestroyVar))
+	cret := xObjectReplaceQdata(x.GoPointer(), QuarkVar, OldvalVar, NewvalVar, glib.NewCallback(DestroyVar), glib.NewCallback(OldDestroyVar))
 	return cret
 }
 // to a different value or when the object is destroyed.
 //
 // Note that the @destroy callback is not called if @data is %NULL.
-func (x *Object) SetDataFull(KeyVar string, DataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *Object) SetDataFull(KeyVar string, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xObjectSetDataFull(x.GoPointer(), KeyVar, DataVar, purego.NewCallback(DestroyVar))
+	xObjectSetDataFull(x.GoPointer(), KeyVar, DataVar, glib.NewCallback(DestroyVar))
 }
 // called with @data as argument when the @object is finalized, or
 // the data is being overwritten by a call to g_object_set_qdata()
 // with the same @quark.
-func (x *Object) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *Object) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xObjectSetQdataFull(x.GoPointer(), QuarkVar, DataVar, purego.NewCallback(DestroyVar))
+	xObjectSetQdataFull(x.GoPointer(), QuarkVar, DataVar, glib.NewCallback(DestroyVar))
 }
 // thread-safe: they cannot safely be used in one thread if the
 // object's last g_object_unref() might happen in another thread.
 // Use #GWeakRef if thread-safety is required.
-func (x *Object) WeakRef(NotifyVar WeakNotify, DataVar uintptr) {
+func (x *Object) WeakRef(NotifyVar *WeakNotify, DataVar uintptr) {
-	xObjectWeakRef(x.GoPointer(), purego.NewCallback(NotifyVar), DataVar)
+	xObjectWeakRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)
 }
 var xObjectWeakUnref func(uintptr, uintptr, uintptr)
 // Removes a weak reference callback to an object.
-func (x *Object) WeakUnref(NotifyVar WeakNotify, DataVar uintptr) {
+func (x *Object) WeakUnref(NotifyVar *WeakNotify, DataVar uintptr) {
-	xObjectWeakUnref(x.GoPointer(), purego.NewCallback(NotifyVar), DataVar)
+	xObjectWeakUnref(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)
 }
 // It is important to note that you must use
 // [canonical parameter names][canonical-parameter-names] as
 // detail strings for the notify signal.
-func (x *Object) ConnectNotify(cb func(Object, uintptr)) uint32 {
+func (x *Object) ConnectNotify(cb *func(Object, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return SignalConnect(x.GoPointer(), "notify", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PspecVarp uintptr) {
 		fa := Object{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PspecVarp)
+		cbFn(fa, PspecVarp)
 	}
-	return SignalConnect(x.GoPointer(), "notify", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return SignalConnect(x.GoPointer(), "notify", cbRefPtr)
 }
 var xObjectCompatControl func(uint, uintptr) uint

M v4/gobject/gparam.go +2 -2


@@ -415,9 +415,9 @@ var xParamSpecSetQdataFull func(uintptr, glib.Quark, uintptr, uintptr)
415		// specified which is called with @data as argument when the @pspec is	415		// specified which is called with @data as argument when the @pspec is
416		// finalized, or the data is being overwritten by a call to	416		// finalized, or the data is being overwritten by a call to
417		// g_param_spec_set_qdata() with the same @quark.	417		// g_param_spec_set_qdata() with the same @quark.
418	-	func (x *ParamSpec) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar glib.DestroyNotify) {	418	+	func (x ParamSpec) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar glib.DestroyNotify) {
419			419
420	-	xParamSpecSetQdataFull(x.GoPointer(), QuarkVar, DataVar, purego.NewCallback(DestroyVar))	420	+	xParamSpecSetQdataFull(x.GoPointer(), QuarkVar, DataVar, glib.NewCallback(DestroyVar))
421			421
422		}	422		}
423			423

M v4/gobject/gsignal.go +14 -14


@@ -214,9 +214,9 @@ var xSignalAddEmissionHook func(uint, glib.Quark, uintptr, uintptr, uintptr) uin
214		// Adds an emission hook for a signal, which will get called for any emission	214		// Adds an emission hook for a signal, which will get called for any emission
215		// of that signal, independent of the instance. This is possible only	215		// of that signal, independent of the instance. This is possible only
216		// for signals which don't have %G_SIGNAL_NO_HOOKS flag set.	216		// for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
217	-	func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar SignalEmissionHook, HookDataVar uintptr, DataDestroyVar glib.DestroyNotify) uint32 {	217	+	func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar SignalEmissionHook, HookDataVar uintptr, DataDestroyVar glib.DestroyNotify) uint32 {
218			218
219	-	cret := xSignalAddEmissionHook(SignalIdVar, DetailVar, purego.NewCallback(HookFuncVar), HookDataVar, purego.NewCallback(DataDestroyVar))	219	+	cret := xSignalAddEmissionHook(SignalIdVar, DetailVar, glib.NewCallback(HookFuncVar), HookDataVar, glib.NewCallback(DataDestroyVar))
220		return cret	220		return cret
221		}	221		}
222			222

@@ -269,9 +269,9 @@ var xSignalConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectF
269		// which will be called when the signal handler is disconnected and no longer	269		// which will be called when the signal handler is disconnected and no longer
270		// used. Specify @connect_flags if you need `..._after()` or	270		// used. Specify @connect_flags if you need `..._after()` or
271		// `..._swapped()` variants of this function.	271		// `..._swapped()` variants of this function.
272	-	func SignalConnectData(InstanceVar *Object, DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, DestroyDataVar ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {	272	+	func SignalConnectData(InstanceVar Object, DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {
273			273
274	-	cret := xSignalConnectData(InstanceVar.GoPointer(), DetailedSignalVar, purego.NewCallback(CHandlerVar), DataVar, purego.NewCallback(DestroyDataVar), ConnectFlagsVar)	274	+	cret := xSignalConnectData(InstanceVar.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar, glib.NewCallback(DestroyDataVar), ConnectFlagsVar)
275		return cret	275		return cret
276		}	276		}
277			277

@@ -572,9 +572,9 @@ var xSignalNew func(string, []interface{}, SignalFlags, uint, uintptr, uintptr,
572		// If @c_marshaller is non-%NULL, you need to also specify a va_marshaller	572		// If @c_marshaller is non-%NULL, you need to also specify a va_marshaller
573		// using g_signal_set_va_marshaller() or the generic va_marshaller will	573		// using g_signal_set_va_marshaller() or the generic va_marshaller will
574		// be used.	574		// be used.
575	-	func SignalNew(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassOffsetVar uint, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, varArgs ...interface{}) uint {	575	+	func SignalNew(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassOffsetVar uint, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, varArgs ...interface{}) uint {
576			576
577	-	cret := xSignalNew(SignalNameVar, ItypeVar, SignalFlagsVar, ClassOffsetVar, purego.NewCallback(AccumulatorVar), AccuDataVar, CMarshallerVar, ReturnTypeVar, NParamsVar, varArgs...)	577	+	cret := xSignalNew(SignalNameVar, ItypeVar, SignalFlagsVar, ClassOffsetVar, glib.NewCallback(AccumulatorVar), AccuDataVar, CMarshallerVar, ReturnTypeVar, NParamsVar, varArgs...)
578		return cret	578		return cret
579		}	579		}
580			580

@@ -596,9 +596,9 @@ var xSignalNewClassHandler func(string, []interface{}, SignalFlags, uintptr, uin
596		//	596		//
597		// If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as	597		// If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as
598		// the marshaller for this signal.	598		// the marshaller for this signal.
599	-	func SignalNewClassHandler(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassHandlerVar Callback, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, varArgs ...interface{}) uint {	599	+	func SignalNewClassHandler(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassHandlerVar Callback, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, varArgs ...interface{}) uint {
600			600
601	-	cret := xSignalNewClassHandler(SignalNameVar, ItypeVar, SignalFlagsVar, purego.NewCallback(ClassHandlerVar), purego.NewCallback(AccumulatorVar), AccuDataVar, CMarshallerVar, ReturnTypeVar, NParamsVar, varArgs...)	601	+	cret := xSignalNewClassHandler(SignalNameVar, ItypeVar, SignalFlagsVar, glib.NewCallback(ClassHandlerVar), glib.NewCallback(AccumulatorVar), AccuDataVar, CMarshallerVar, ReturnTypeVar, NParamsVar, varArgs...)
602		return cret	602		return cret
603		}	603		}
604			604

@@ -610,9 +610,9 @@ var xSignalNewValist func(string, []interface{}, SignalFlags, *Closure, uintptr,
610		//	610		//
611		// If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as	611		// If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as
612		// the marshaller for this signal.	612		// the marshaller for this signal.
613	-	func SignalNewValist(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassClosureVar *Closure, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, ArgsVar []interface{}) uint {	613	+	func SignalNewValist(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassClosureVar Closure, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, ArgsVar []interface{}) uint {
614			614
615	-	cret := xSignalNewValist(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, purego.NewCallback(AccumulatorVar), AccuDataVar, CMarshallerVar, ReturnTypeVar, NParamsVar, ArgsVar)	615	+	cret := xSignalNewValist(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, glib.NewCallback(AccumulatorVar), AccuDataVar, CMarshallerVar, ReturnTypeVar, NParamsVar, ArgsVar)
616		return cret	616		return cret
617		}	617		}
618			618

@@ -624,9 +624,9 @@ var xSignalNewv func(string, []interface{}, SignalFlags, *Closure, uintptr, uint
624		//	624		//
625		// If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as	625		// If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as
626		// the marshaller for this signal.	626		// the marshaller for this signal.
627	-	func SignalNewv(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassClosureVar *Closure, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, ParamTypesVar uintptr) uint {	627	+	func SignalNewv(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassClosureVar Closure, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, ParamTypesVar uintptr) uint {
628			628
629	-	cret := xSignalNewv(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, purego.NewCallback(AccumulatorVar), AccuDataVar, CMarshallerVar, ReturnTypeVar, NParamsVar, ParamTypesVar)	629	+	cret := xSignalNewv(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, glib.NewCallback(AccumulatorVar), AccuDataVar, CMarshallerVar, ReturnTypeVar, NParamsVar, ParamTypesVar)
630		return cret	630		return cret
631		}	631		}
632			632

@@ -655,9 +655,9 @@ var xSignalOverrideClassHandler func(string, []interface{}, uintptr)
655		// See g_signal_chain_from_overridden() and	655		// See g_signal_chain_from_overridden() and
656		// g_signal_chain_from_overridden_handler() for how to chain up to the	656		// g_signal_chain_from_overridden_handler() for how to chain up to the
657		// parent class closure from inside the overridden one.	657		// parent class closure from inside the overridden one.
658	-	func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar []interface{}, ClassHandlerVar Callback) {	658	+	func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar []interface{}, ClassHandlerVar *Callback) {
659			659
660	-	xSignalOverrideClassHandler(SignalNameVar, InstanceTypeVar, purego.NewCallback(ClassHandlerVar))	660	+	xSignalOverrideClassHandler(SignalNameVar, InstanceTypeVar, glib.NewCallback(ClassHandlerVar))
661			661
662		}	662		}
663			663

M v4/gobject/gtype.go +10 -10


@@ -571,9 +571,9 @@ var xTypeAddClassCacheFunc func(uintptr, uintptr)
571		// passed in to figure whether they actually want to cache the class of this	571		// passed in to figure whether they actually want to cache the class of this
572		// type, since all classes are routed through the same #GTypeClassCacheFunc	572		// type, since all classes are routed through the same #GTypeClassCacheFunc
573		// chain.	573		// chain.
574	-	func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar TypeClassCacheFunc) {	574	+	func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
575			575
576	-	xTypeAddClassCacheFunc(CacheDataVar, purego.NewCallback(CacheFuncVar))	576	+	xTypeAddClassCacheFunc(CacheDataVar, glib.NewCallback(CacheFuncVar))
577			577
578		}	578		}
579			579

@@ -614,9 +614,9 @@ var xTypeAddInterfaceCheck func(uintptr, uintptr)
614		// implementation of #GObject uses this facility to check that an	614		// implementation of #GObject uses this facility to check that an
615		// object implements all of the properties that are defined on its	615		// object implements all of the properties that are defined on its
616		// interfaces.	616		// interfaces.
617	-	func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar TypeInterfaceCheckFunc) {	617	+	func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
618			618
619	-	xTypeAddInterfaceCheck(CheckDataVar, purego.NewCallback(CheckFuncVar))	619	+	xTypeAddInterfaceCheck(CheckDataVar, glib.NewCallback(CheckFuncVar))
620			620
621		}	621		}
622			622

@@ -1202,9 +1202,9 @@ var xTypeRegisterStaticSimple func([]interface{}, string, uint, uintptr, uint, u
1202		// @parent_type. The value of @flags determines the nature (e.g.	1202		// @parent_type. The value of @flags determines the nature (e.g.
1203		// abstract or not) of the type. It works by filling a #GTypeInfo	1203		// abstract or not) of the type. It works by filling a #GTypeInfo
1204		// struct and calling g_type_register_static().	1204		// struct and calling g_type_register_static().
1205	-	func TypeRegisterStaticSimple(ParentTypeVar []interface{}, TypeNameVar string, ClassSizeVar uint, ClassInitVar ClassInitFunc, InstanceSizeVar uint, InstanceInitVar InstanceInitFunc, FlagsVar TypeFlags) []interface{} {	1205	+	func TypeRegisterStaticSimple(ParentTypeVar []interface{}, TypeNameVar string, ClassSizeVar uint, ClassInitVar ClassInitFunc, InstanceSizeVar uint, InstanceInitVar InstanceInitFunc, FlagsVar TypeFlags) []interface{} {
1206			1206
1207	-	cret := xTypeRegisterStaticSimple(ParentTypeVar, TypeNameVar, ClassSizeVar, purego.NewCallback(ClassInitVar), InstanceSizeVar, purego.NewCallback(InstanceInitVar), FlagsVar)	1207	+	cret := xTypeRegisterStaticSimple(ParentTypeVar, TypeNameVar, ClassSizeVar, glib.NewCallback(ClassInitVar), InstanceSizeVar, glib.NewCallback(InstanceInitVar), FlagsVar)
1208		return cret	1208		return cret
1209		}	1209		}
1210			1210

@@ -1213,9 +1213,9 @@ var xTypeRemoveClassCacheFunc func(uintptr, uintptr)
1213		// Removes a previously installed #GTypeClassCacheFunc. The cache	1213		// Removes a previously installed #GTypeClassCacheFunc. The cache
1214		// maintained by @cache_func has to be empty when calling	1214		// maintained by @cache_func has to be empty when calling
1215		// g_type_remove_class_cache_func() to avoid leaks.	1215		// g_type_remove_class_cache_func() to avoid leaks.
1216	-	func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar TypeClassCacheFunc) {	1216	+	func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
1217			1217
1218	-	xTypeRemoveClassCacheFunc(CacheDataVar, purego.NewCallback(CacheFuncVar))	1218	+	xTypeRemoveClassCacheFunc(CacheDataVar, glib.NewCallback(CacheFuncVar))
1219			1219
1220		}	1220		}
1221			1221

@@ -1223,9 +1223,9 @@ var xTypeRemoveInterfaceCheck func(uintptr, uintptr)
1223			1223
1224		// Removes an interface check function added with	1224		// Removes an interface check function added with
1225		// g_type_add_interface_check().	1225		// g_type_add_interface_check().
1226	-	func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar TypeInterfaceCheckFunc) {	1226	+	func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
1227			1227
1228	-	xTypeRemoveInterfaceCheck(CheckDataVar, purego.NewCallback(CheckFuncVar))	1228	+	xTypeRemoveInterfaceCheck(CheckDataVar, glib.NewCallback(CheckFuncVar))
1229			1229
1230		}	1230		}
1231			1231

M v4/gobject/gvalue.go +2 -2


@@ -765,9 +765,9 @@ var xValueRegisterTransformFunc func([]interface{}, []interface{}, uintptr)
765		// Registers a value transformation function for use in g_value_transform().	765		// Registers a value transformation function for use in g_value_transform().
766		// A previously registered transformation function for @src_type and @dest_type	766		// A previously registered transformation function for @src_type and @dest_type
767		// will be replaced.	767		// will be replaced.
768	-	func ValueRegisterTransformFunc(SrcTypeVar []interface{}, DestTypeVar []interface{}, TransformFuncVar ValueTransform) {	768	+	func ValueRegisterTransformFunc(SrcTypeVar []interface{}, DestTypeVar []interface{}, TransformFuncVar *ValueTransform) {
769			769
770	-	xValueRegisterTransformFunc(SrcTypeVar, DestTypeVar, purego.NewCallback(TransformFuncVar))	770	+	xValueRegisterTransformFunc(SrcTypeVar, DestTypeVar, glib.NewCallback(TransformFuncVar))
771			771
772		}	772		}
773			773

M v4/gobject/gvaluearray.go +4 -4


@@ -107,9 +107,9 @@ var xValueArraySort func(uintptr, uintptr) *ValueArray
107		//	107		//
108		// The current implementation uses the same sorting algorithm as standard	108		// The current implementation uses the same sorting algorithm as standard
109		// C qsort() function.	109		// C qsort() function.
110	-	func (x ValueArray) Sort(CompareFuncVar glib.CompareFunc) ValueArray {	110	+	func (x ValueArray) Sort(CompareFuncVar glib.CompareFunc) *ValueArray {
111			111
112	-	cret := xValueArraySort(x.GoPointer(), purego.NewCallback(CompareFuncVar))	112	+	cret := xValueArraySort(x.GoPointer(), glib.NewCallback(CompareFuncVar))
113		return cret	113		return cret
114		}	114		}
115			115

@@ -120,9 +120,9 @@ var xValueArraySortWithData func(uintptr, uintptr, uintptr) *ValueArray
120		//	120		//
121		// The current implementation uses the same sorting algorithm as standard	121		// The current implementation uses the same sorting algorithm as standard
122		// C qsort() function.	122		// C qsort() function.
123	-	func (x ValueArray) SortWithData(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) ValueArray {	123	+	func (x ValueArray) SortWithData(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) *ValueArray {
124			124
125	-	cret := xValueArraySortWithData(x.GoPointer(), purego.NewCallback(CompareFuncVar), UserDataVar)	125	+	cret := xValueArraySortWithData(x.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)
126		return cret	126		return cret
127		}	127		}
128			128

M v4/gobject/more.go +3 -8

 import (
 	"reflect"
-	"github.com/jwijenbergh/purego"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 )
 type Ptr interface {
 	v.SetGoPointer(o.GoPointer())
 }
-func (o Object) ConnectSignal(signal string, cb func()) uint32 {
+func (o Object) ConnectSignal(signal string, cb *func()) uint32 {
-	return SignalConnect(o.GoPointer(), signal, purego.NewCallback(cb))
+	return SignalConnect(o.GoPointer(), signal, glib.NewCallback(cb))
 }
 func (o Object) DisconnectSignal(handler uint32) {
 	SignalHandlerDisconnect(&o, handler)
 }
-// NewCallback is an alias to purego.NewCallback
-func NewCallback(fn interface{}) uintptr {
-	return purego.NewCallback(fn)
-}
 // types
 const (
 	TypeInvalidVal           Type = 0

M v4/gsk/gskrendernode.go +2 -2


@@ -252,10 +252,10 @@ var xRenderNodeDeserialize func(*glib.Bytes, uintptr, uintptr) uintptr
252		// Loads data previously created via [method@Gsk.RenderNode.serialize].	252		// Loads data previously created via [method@Gsk.RenderNode.serialize].
253		//	253		//
254		// For a discussion of the supported format, see that function.	254		// For a discussion of the supported format, see that function.
255	-	func RenderNodeDeserialize(BytesVar glib.Bytes, ErrorFuncVar ParseErrorFunc, UserDataVar uintptr) RenderNode {	255	+	func RenderNodeDeserialize(BytesVar glib.Bytes, ErrorFuncVar ParseErrorFunc, UserDataVar uintptr) *RenderNode {
256		var cls *RenderNode	256		var cls *RenderNode
257			257
258	-	cret := xRenderNodeDeserialize(BytesVar, purego.NewCallback(ErrorFuncVar), UserDataVar)	258	+	cret := xRenderNodeDeserialize(BytesVar, glib.NewCallback(ErrorFuncVar), UserDataVar)
259			259
260		if cret == 0 {	260		if cret == 0 {
261		return nil	261		return nil

M v4/gtk/gtkaboutdialog.go +14 -3

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gsk"
 )
 //
 // Applications may connect to it to override the default behaviour,
 // which is to call [func@Gtk.show_uri].
-func (x *AboutDialog) ConnectActivateLink(cb func(AboutDialog, string) bool) uint32 {
+func (x *AboutDialog) ConnectActivateLink(cb *func(AboutDialog, string) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, UriVarp string) bool {
 		fa := AboutDialog{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, UriVarp)
+		return cbFn(fa, UriVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkadjustment.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // Note that the [property@Gtk.Adjustment:value] property is
 // covered by the [signal@Gtk.Adjustment::value-changed] signal.
-func (x *Adjustment) ConnectChanged(cb func(Adjustment)) uint32 {
+func (x *Adjustment) ConnectChanged(cb *func(Adjustment)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Adjustment{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 // Emitted when the value has been changed.
-func (x *Adjustment) ConnectValueChanged(cb func(Adjustment)) uint32 {
+func (x *Adjustment) ConnectValueChanged(cb *func(Adjustment)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Adjustment{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "value-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkappchooserbutton.go +36 -9

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // The `::activate` signal on `GtkAppChooserButton` is an action signal and
 // emitting it causes the button to pop up its dialog.
-func (x *AppChooserButton) ConnectActivate(cb func(AppChooserButton)) uint32 {
+func (x *AppChooserButton) ConnectActivate(cb *func(AppChooserButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := AppChooserButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the active application changes.
-func (x *AppChooserButton) ConnectChanged(cb func(AppChooserButton)) uint32 {
+func (x *AppChooserButton) ConnectChanged(cb *func(AppChooserButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := AppChooserButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 // Emitted when a custom item is activated.
 //
 // Use [method@Gtk.AppChooserButton.append_custom_item],
 // to add custom items.
-func (x *AppChooserButton) ConnectCustomItemActivated(cb func(AppChooserButton, string)) uint32 {
+func (x *AppChooserButton) ConnectCustomItemActivated(cb *func(AppChooserButton, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "custom-item-activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ItemNameVarp string) {
 		fa := AppChooserButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ItemNameVarp)
+		cbFn(fa, ItemNameVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "custom-item-activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "custom-item-activated", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkappchooserwidget.go +25 -6

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // This usually happens when the user double clicks an item, or an item
 // is selected and the user presses one of the keys Space, Shift+Space,
 // Return or Enter.
-func (x *AppChooserWidget) ConnectApplicationActivated(cb func(AppChooserWidget, uintptr)) uint32 {
+func (x *AppChooserWidget) ConnectApplicationActivated(cb *func(AppChooserWidget, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "application-activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ApplicationVarp uintptr) {
 		fa := AppChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ApplicationVarp)
+		cbFn(fa, ApplicationVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "application-activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "application-activated", cbRefPtr)
 }
 // Emitted when an application item is selected from the widget's list.
-func (x *AppChooserWidget) ConnectApplicationSelected(cb func(AppChooserWidget, uintptr)) uint32 {
+func (x *AppChooserWidget) ConnectApplicationSelected(cb *func(AppChooserWidget, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "application-selected", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ApplicationVarp uintptr) {
 		fa := AppChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ApplicationVarp)
+		cbFn(fa, ApplicationVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "application-selected", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "application-selected", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkapplication.go +33 -9

 // is `TRUE`. Applications can connect to this signal and call
 // [method@Gtk.Application.inhibit] with `GTK_APPLICATION_INHIBIT_LOGOUT`
 // to delay the end of the session until state has been saved.
-func (x *Application) ConnectQueryEnd(cb func(Application)) uint32 {
+func (x *Application) ConnectQueryEnd(cb *func(Application)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "query-end", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "query-end", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "query-end", cbRefPtr)
 }
 // Emitted when a [class@Gtk.Window] is added to `application` through
 // [method@Gtk.Application.add_window].
-func (x *Application) ConnectWindowAdded(cb func(Application, uintptr)) uint32 {
+func (x *Application) ConnectWindowAdded(cb *func(Application, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "window-added", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WindowVarp uintptr) {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, WindowVarp)
+		cbFn(fa, WindowVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "window-added", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "window-added", cbRefPtr)
 }
 // Emitted when a [class@Gtk.Window] is removed from `application`.
 //
 // This can happen as a side-effect of the window being destroyed
 // or explicitly through [method@Gtk.Application.remove_window].
-func (x *Application) ConnectWindowRemoved(cb func(Application, uintptr)) uint32 {
+func (x *Application) ConnectWindowRemoved(cb *func(Application, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "window-removed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WindowVarp uintptr) {
 		fa := Application{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, WindowVarp)
+		cbFn(fa, WindowVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "window-removed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "window-removed", cbRefPtr)
 }
 // Emits the #GActionGroup::action-added signal on @action_group.

M v4/gtk/gtkassistant.go +59 -17

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
 // Setting @page_func to %NULL will make the assistant to
 // use the default forward function, which just goes to the
 // next visible page.
-func (x *Assistant) SetForwardPageFunc(PageFuncVar AssistantPageFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *Assistant) SetForwardPageFunc(PageFuncVar *AssistantPageFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xAssistantSetForwardPageFunc(x.GoPointer(), purego.NewCallback(PageFuncVar), DataVar, purego.NewCallback(DestroyVar))
+	xAssistantSetForwardPageFunc(x.GoPointer(), glib.NewCallback(PageFuncVar), DataVar, glib.NewCallback(DestroyVar))
 }
 // %GTK_ASSISTANT_PAGE_PROGRESS after the confirmation page and handle
 // this operation within the [signal@Gtk.Assistant::prepare] signal of
 // the progress page.
-func (x *Assistant) ConnectApply(cb func(Assistant)) uint32 {
+func (x *Assistant) ConnectApply(cb *func(Assistant)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Assistant{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "apply", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
 }
 // Emitted when then the cancel button is clicked.
-func (x *Assistant) ConnectCancel(cb func(Assistant)) uint32 {
+func (x *Assistant) ConnectCancel(cb *func(Assistant)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Assistant{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cancel", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
 }
 // Emitted either when the close button of a summary page is clicked,
 // or when the apply button in the last page in the flow (of type
 // %GTK_ASSISTANT_PAGE_CONFIRM) is clicked.
-func (x *Assistant) ConnectClose(cb func(Assistant)) uint32 {
+func (x *Assistant) ConnectClose(cb *func(Assistant)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Assistant{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "close", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
 }
 // The action signal for the Escape binding.
-func (x *Assistant) ConnectEscape(cb func(Assistant)) uint32 {
+func (x *Assistant) ConnectEscape(cb *func(Assistant)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "escape", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Assistant{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "escape", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "escape", cbRefPtr)
 }
 // Emitted when a new page is set as the assistant's current page,
 //
 // A handler for this signal can do any preparations which are
 // necessary before showing @page.
-func (x *Assistant) ConnectPrepare(cb func(Assistant, uintptr)) uint32 {
+func (x *Assistant) ConnectPrepare(cb *func(Assistant, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) {
 		fa := Assistant{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PageVarp)
+		cbFn(fa, PageVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "prepare", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkatcontext.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Emitted when the attributes of the accessible for the
 // `GtkATContext` instance change.
-func (x *ATContext) ConnectStateChange(cb func(ATContext)) uint32 {
+func (x *ATContext) ConnectStateChange(cb *func(ATContext)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "state-change", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ATContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "state-change", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "state-change", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkbuilderscope.go +5 -4

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // are added. Using this method allows for better encapsulation as it
 // does not require that callback symbols be declared in the global
 // namespace.
-func (x *BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar gobject.Callback) {
+func (x *BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {
-	xBuilderCScopeAddCallbackSymbol(x.GoPointer(), CallbackNameVar, purego.NewCallback(CallbackSymbolVar))
+	xBuilderCScopeAddCallbackSymbol(x.GoPointer(), CallbackNameVar, glib.NewCallback(CallbackSymbolVar))
 }
 //
 // This is equivalent to calling [method@Gtk.BuilderCScope.add_callback_symbol]
 // for each symbol.
-func (x *BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar gobject.Callback, varArgs ...interface{}) {
+func (x *BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar *gobject.Callback, varArgs ...interface{}) {
-	xBuilderCScopeAddCallbackSymbols(x.GoPointer(), FirstCallbackNameVar, purego.NewCallback(FirstCallbackSymbolVar), varArgs...)
+	xBuilderCScopeAddCallbackSymbols(x.GoPointer(), FirstCallbackNameVar, glib.NewCallback(FirstCallbackSymbolVar), varArgs...)
 }

M v4/gtk/gtkbutton.go +22 -6

 //
 // This is an action signal. Applications should never connect
 // to this signal, but use the [signal@Gtk.Button::clicked] signal.
-func (x *Button) ConnectActivate(cb func(Button)) uint32 {
+func (x *Button) ConnectActivate(cb *func(Button)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Button{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the button has been activated (pressed and released).
-func (x *Button) ConnectClicked(cb func(Button)) uint32 {
+func (x *Button) ConnectClicked(cb *func(Button)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Button{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "clicked", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkcalendar.go +57 -15

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 }
 // Emitted when the user selects a day.
-func (x *Calendar) ConnectDaySelected(cb func(Calendar)) uint32 {
+func (x *Calendar) ConnectDaySelected(cb *func(Calendar)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "day-selected", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Calendar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "day-selected", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "day-selected", cbRefPtr)
 }
 // Emitted when the user switched to the next month.
-func (x *Calendar) ConnectNextMonth(cb func(Calendar)) uint32 {
+func (x *Calendar) ConnectNextMonth(cb *func(Calendar)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "next-month", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Calendar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "next-month", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "next-month", cbRefPtr)
 }
 // Emitted when user switched to the next year.
-func (x *Calendar) ConnectNextYear(cb func(Calendar)) uint32 {
+func (x *Calendar) ConnectNextYear(cb *func(Calendar)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "next-year", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Calendar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "next-year", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "next-year", cbRefPtr)
 }
 // Emitted when the user switched to the previous month.
-func (x *Calendar) ConnectPrevMonth(cb func(Calendar)) uint32 {
+func (x *Calendar) ConnectPrevMonth(cb *func(Calendar)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "prev-month", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Calendar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "prev-month", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "prev-month", cbRefPtr)
 }
 // Emitted when user switched to the previous year.
-func (x *Calendar) ConnectPrevYear(cb func(Calendar)) uint32 {
+func (x *Calendar) ConnectPrevYear(cb *func(Calendar)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "prev-year", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Calendar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "prev-year", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "prev-year", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkcellarea.go +50 -18

 var xCellAreaForeach func(uintptr, uintptr, uintptr)
 // Calls @callback for every `GtkCellRenderer` in @area.
-func (x *CellArea) Foreach(CallbackVar CellCallback, CallbackDataVar uintptr) {
+func (x *CellArea) Foreach(CallbackVar *CellCallback, CallbackDataVar uintptr) {
-	xCellAreaForeach(x.GoPointer(), purego.NewCallback(CallbackVar), CallbackDataVar)
+	xCellAreaForeach(x.GoPointer(), glib.NewCallback(CallbackVar), CallbackDataVar)
 }
 // Calls @callback for every `GtkCellRenderer` in @area with the
 // allocated rectangle inside @cell_area.
-func (x *CellArea) ForeachAlloc(ContextVar *CellAreaContext, WidgetVar *Widget, CellAreaVar *gdk.Rectangle, BackgroundAreaVar *gdk.Rectangle, CallbackVar CellAllocCallback, CallbackDataVar uintptr) {
+func (x *CellArea) ForeachAlloc(ContextVar *CellAreaContext, WidgetVar *Widget, CellAreaVar *gdk.Rectangle, BackgroundAreaVar *gdk.Rectangle, CallbackVar *CellAllocCallback, CallbackDataVar uintptr) {
-	xCellAreaForeachAlloc(x.GoPointer(), ContextVar.GoPointer(), WidgetVar.GoPointer(), CellAreaVar, BackgroundAreaVar, purego.NewCallback(CallbackVar), CallbackDataVar)
+	xCellAreaForeachAlloc(x.GoPointer(), ContextVar.GoPointer(), WidgetVar.GoPointer(), CellAreaVar, BackgroundAreaVar, glib.NewCallback(CallbackVar), CallbackDataVar)
 }
 // Indicates that editing has started on @renderer and that @editable
 // should be added to the owning cell-layouting widget at @cell_area.
-func (x *CellArea) ConnectAddEditable(cb func(CellArea, uintptr, uintptr, uintptr, string)) uint32 {
+func (x *CellArea) ConnectAddEditable(cb *func(CellArea, uintptr, uintptr, uintptr, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "add-editable", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, RendererVarp uintptr, EditableVarp uintptr, CellAreaVarp uintptr, PathVarp string) {
 		fa := CellArea{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, RendererVarp, EditableVarp, CellAreaVarp, PathVarp)
+		cbFn(fa, RendererVarp, EditableVarp, CellAreaVarp, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "add-editable", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "add-editable", cbRefPtr)
 }
 // This signal is emitted whenever applying attributes to @area from @model
-func (x *CellArea) ConnectApplyAttributes(cb func(CellArea, uintptr, uintptr, bool, bool)) uint32 {
+func (x *CellArea) ConnectApplyAttributes(cb *func(CellArea, uintptr, uintptr, bool, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "apply-attributes", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ModelVarp uintptr, IterVarp uintptr, IsExpanderVarp bool, IsExpandedVarp bool) {
 		fa := CellArea{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ModelVarp, IterVarp, IsExpanderVarp, IsExpandedVarp)
+		cbFn(fa, ModelVarp, IterVarp, IsExpanderVarp, IsExpandedVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "apply-attributes", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "apply-attributes", cbRefPtr)
 }
 // Indicates that focus changed on this @area. This signal
 // currently focused renderer did not change, this is
 // because focus may change to the same renderer in the
 // same cell area for a different row of data.
-func (x *CellArea) ConnectFocusChanged(cb func(CellArea, uintptr, string)) uint32 {
+func (x *CellArea) ConnectFocusChanged(cb *func(CellArea, uintptr, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "focus-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, RendererVarp uintptr, PathVarp string) {
 		fa := CellArea{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, RendererVarp, PathVarp)
+		cbFn(fa, RendererVarp, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "focus-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "focus-changed", cbRefPtr)
 }
 // Indicates that editing finished on @renderer and that @editable
 // should be removed from the owning cell-layouting widget.
-func (x *CellArea) ConnectRemoveEditable(cb func(CellArea, uintptr, uintptr)) uint32 {
+func (x *CellArea) ConnectRemoveEditable(cb *func(CellArea, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "remove-editable", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, RendererVarp uintptr, EditableVarp uintptr) {
 		fa := CellArea{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, RendererVarp, EditableVarp)
+		cbFn(fa, RendererVarp, EditableVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "remove-editable", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "remove-editable", cbRefPtr)
 }
 // Gets the ID of the @buildable object.
 // cell renderer(s) as appropriate.
 //
 // @func may be %NULL to remove a previously set function.
-func (x *CellArea) SetCellDataFunc(CellVar *CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *CellArea) SetCellDataFunc(CellVar *CellRenderer, FuncVar *CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))
+	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
 }

M v4/gtk/gtkcellareabox.go +2 -2


@@ -198,9 +198,9 @@ func (x CellAreaBox) SetAttributes(CellVar CellRenderer, varArgs ...interface{
198		// cell renderer(s) as appropriate.	198		// cell renderer(s) as appropriate.
199		//	199		//
200		// @func may be %NULL to remove a previously set function.	200		// @func may be %NULL to remove a previously set function.
201	-	func (x CellAreaBox) SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {	201	+	func (x CellAreaBox) SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
202			202
203	-	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))	203	+	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
204			204
205		}	205		}
206			206

M v4/gtk/gtkcelllayout.go +3 -3


@@ -151,7 +151,7 @@ type CellLayout interface {
151		PackStart(CellVar *CellRenderer, ExpandVar bool)	151		PackStart(CellVar *CellRenderer, ExpandVar bool)
152		Reorder(CellVar *CellRenderer, PositionVar int)	152		Reorder(CellVar *CellRenderer, PositionVar int)
153		SetAttributes(CellVar *CellRenderer, varArgs ...interface{})	153		SetAttributes(CellVar *CellRenderer, varArgs ...interface{})
154	-	SetCellDataFunc(CellVar *CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify)	154	+	SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify)
155		}	155		}
156		type CellLayoutBase struct {	156		type CellLayoutBase struct {
157		Ptr uintptr	157		Ptr uintptr

@@ -271,9 +271,9 @@ func (x CellLayoutBase) SetAttributes(CellVar CellRenderer, varArgs ...interfa
271		// cell renderer(s) as appropriate.	271		// cell renderer(s) as appropriate.
272		//	272		//
273		// @func may be %NULL to remove a previously set function.	273		// @func may be %NULL to remove a previously set function.
274	-	func (x CellLayoutBase) SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {	274	+	func (x CellLayoutBase) SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
275			275
276	-	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))	276	+	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
277			277
278		}	278		}
279			279

M v4/gtk/gtkcellrenderer.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // editing when the user presses Escape.
 //
 // See also: gtk_cell_renderer_stop_editing().
-func (x *CellRenderer) ConnectEditingCanceled(cb func(CellRenderer)) uint32 {
+func (x *CellRenderer) ConnectEditingCanceled(cb *func(CellRenderer)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "editing-canceled", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := CellRenderer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "editing-canceled", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "editing-canceled", cbRefPtr)
 }
 // This signal gets emitted when a cell starts to be edited.
 //	}
 //
 // ]|
-func (x *CellRenderer) ConnectEditingStarted(cb func(CellRenderer, uintptr, string)) uint32 {
+func (x *CellRenderer) ConnectEditingStarted(cb *func(CellRenderer, uintptr, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "editing-started", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, EditableVarp uintptr, PathVarp string) {
 		fa := CellRenderer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, EditableVarp, PathVarp)
+		cbFn(fa, EditableVarp, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "editing-started", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "editing-started", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkcellrendereraccel.go +25 -6

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Gets emitted when the user has removed the accelerator.
-func (x *CellRendererAccel) ConnectAccelCleared(cb func(CellRendererAccel, string)) uint32 {
+func (x *CellRendererAccel) ConnectAccelCleared(cb *func(CellRendererAccel, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "accel-cleared", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathStringVarp string) {
 		fa := CellRendererAccel{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PathStringVarp)
+		cbFn(fa, PathStringVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "accel-cleared", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "accel-cleared", cbRefPtr)
 }
 // Gets emitted when the user has selected a new accelerator.
-func (x *CellRendererAccel) ConnectAccelEdited(cb func(CellRendererAccel, string, uint, gdk.ModifierType, uint)) uint32 {
+func (x *CellRendererAccel) ConnectAccelEdited(cb *func(CellRendererAccel, string, uint, gdk.ModifierType, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "accel-edited", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathStringVarp string, AccelKeyVarp uint, AccelModsVarp gdk.ModifierType, HardwareKeycodeVarp uint) {
 		fa := CellRendererAccel{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PathStringVarp, AccelKeyVarp, AccelModsVarp, HardwareKeycodeVarp)
+		cbFn(fa, PathStringVarp, AccelKeyVarp, AccelModsVarp, HardwareKeycodeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "accel-edited", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "accel-edited", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkcellrenderercombo.go +14 -3

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // the tree view will immediately cease the editing operating.  This
 // means that you most probably want to refrain from changing the model
 // until the combo cell renderer emits the edited or editing_canceled signal.
-func (x *CellRendererCombo) ConnectChanged(cb func(CellRendererCombo, string, uintptr)) uint32 {
+func (x *CellRendererCombo) ConnectChanged(cb *func(CellRendererCombo, string, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathStringVarp string, NewIterVarp uintptr) {
 		fa := CellRendererCombo{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PathStringVarp, NewIterVarp)
+		cbFn(fa, PathStringVarp, NewIterVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkcellrenderertext.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // It is the responsibility of the application to update the model
 // and store @new_text at the position indicated by @path.
-func (x *CellRendererText) ConnectEdited(cb func(CellRendererText, string, string)) uint32 {
+func (x *CellRendererText) ConnectEdited(cb *func(CellRendererText, string, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "edited", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathVarp string, NewTextVarp string) {
 		fa := CellRendererText{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PathVarp, NewTextVarp)
+		cbFn(fa, PathVarp, NewTextVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "edited", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "edited", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkcellrenderertoggle.go +14 -3

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // It is the responsibility of the application to update the model
 // with the correct value to store at @path.  Often this is simply the
 // opposite of the value currently stored at @path.
-func (x *CellRendererToggle) ConnectToggled(cb func(CellRendererToggle, string)) uint32 {
+func (x *CellRendererToggle) ConnectToggled(cb *func(CellRendererToggle, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathVarp string) {
 		fa := CellRendererToggle{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PathVarp)
+		cbFn(fa, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggled", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkcellview.go +2 -2


@@ -489,9 +489,9 @@ func (x CellView) SetAttributes(CellVar CellRenderer, varArgs ...interface{})
489		// cell renderer(s) as appropriate.	489		// cell renderer(s) as appropriate.
490		//	490		//
491		// @func may be %NULL to remove a previously set function.	491		// @func may be %NULL to remove a previously set function.
492	-	func (x CellView) SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {	492	+	func (x CellView) SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
493			493
494	-	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))	494	+	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
495			495
496		}	496		}
497			497

M v4/gtk/gtkcheckbutton.go +22 -6

 //
 // Applications should never connect to this signal, but use the
 // [signal@Gtk.CheckButton::toggled] signal.
-func (x *CheckButton) ConnectActivate(cb func(CheckButton)) uint32 {
+func (x *CheckButton) ConnectActivate(cb *func(CheckButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := CheckButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the buttons's [property@Gtk.CheckButton:active]
 // property changes.
-func (x *CheckButton) ConnectToggled(cb func(CheckButton)) uint32 {
+func (x *CheckButton) ConnectToggled(cb *func(CheckButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := CheckButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggled", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkcolorbutton.go +25 -6

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // The `::activate` signal on `GtkMenuButton` is an action signal and
 // emitting it causes the button to pop up its dialog.
-func (x *ColorButton) ConnectActivate(cb func(ColorButton)) uint32 {
+func (x *ColorButton) ConnectActivate(cb *func(ColorButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ColorButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the user selects a color.
 // Note that this signal is only emitted when the user changes the color.
 // If you need to react to programmatic color changes as well, use
 // the notify::rgba signal.
-func (x *ColorButton) ConnectColorSet(cb func(ColorButton)) uint32 {
+func (x *ColorButton) ConnectColorSet(cb *func(ColorButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "color-set", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ColorButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "color-set", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "color-set", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkcolumnview.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // This allows for a convenient way to handle activation in a columnview.
 // See [method@Gtk.ListItem.set_activatable] for details on how to use this
 // signal.
-func (x *ColumnView) ConnectActivate(cb func(ColumnView, uint)) uint32 {
+func (x *ColumnView) ConnectActivate(cb *func(ColumnView, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PositionVarp uint) {
 		fa := ColumnView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PositionVarp)
+		cbFn(fa, PositionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkcombobox.go +70 -22

 //
 // If the row separator function is %NULL, no separators are drawn.
 // This is the default value.
-func (x *ComboBox) SetRowSeparatorFunc(FuncVar TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *ComboBox) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xComboBoxSetRowSeparatorFunc(x.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DestroyVar))
+	xComboBoxSetRowSeparatorFunc(x.GoPointer(), glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DestroyVar))
 }
 //
 // The `::activate` signal on `GtkComboBox` is an action signal and
 // emitting it causes the combo box to pop up its dropdown.
-func (x *ComboBox) ConnectActivate(cb func(ComboBox)) uint32 {
+func (x *ComboBox) ConnectActivate(cb *func(ComboBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ComboBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the active item is changed.
 // The can be due to the user selecting a different item from the list,
 // or due to a call to [method@Gtk.ComboBox.set_active_iter]. It will
 // also be emitted while typing into the entry of a combo box with an entry.
-func (x *ComboBox) ConnectChanged(cb func(ComboBox)) uint32 {
+func (x *ComboBox) ConnectChanged(cb *func(ComboBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ComboBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 // Emitted to allow changing how the text in a combo box's entry is displayed.
 //	}
 //
 // ```
-func (x *ComboBox) ConnectFormatEntryText(cb func(ComboBox, string) string) uint32 {
+func (x *ComboBox) ConnectFormatEntryText(cb *func(ComboBox, string) string) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "format-entry-text", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathVarp string) string {
 		fa := ComboBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PathVarp)
+		return cbFn(fa, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "format-entry-text", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "format-entry-text", cbRefPtr)
 }
 // Emitted to move the active selection.
 //
 // This is an [keybinding signal](class.SignalAction.html).
-func (x *ComboBox) ConnectMoveActive(cb func(ComboBox, ScrollType)) uint32 {
+func (x *ComboBox) ConnectMoveActive(cb *func(ComboBox, ScrollType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-active", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ScrollTypeVarp ScrollType) {
 		fa := ComboBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ScrollTypeVarp)
+		cbFn(fa, ScrollTypeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-active", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-active", cbRefPtr)
 }
 // Emitted to popdown the combo box list.
 // This is an [keybinding signal](class.SignalAction.html).
 //
 // The default bindings for this signal are Alt+Up and Escape.
-func (x *ComboBox) ConnectPopdown(cb func(ComboBox) bool) uint32 {
+func (x *ComboBox) ConnectPopdown(cb *func(ComboBox) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := ComboBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "popdown", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
 }
 // Emitted to popup the combo box list.
 // This is an [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is Alt+Down.
-func (x *ComboBox) ConnectPopup(cb func(ComboBox)) uint32 {
+func (x *ComboBox) ConnectPopup(cb *func(ComboBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ComboBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "popup", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.
 // cell renderer(s) as appropriate.
 //
 // @func may be %NULL to remove a previously set function.
-func (x *ComboBox) SetCellDataFunc(CellVar *CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *ComboBox) SetCellDataFunc(CellVar *CellRenderer, FuncVar *CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))
+	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
 }

M v4/gtk/gtkcomboboxtext.go +2 -2


@@ -511,9 +511,9 @@ func (x ComboBoxText) SetAttributes(CellVar CellRenderer, varArgs ...interface
511		// cell renderer(s) as appropriate.	511		// cell renderer(s) as appropriate.
512		//	512		//
513		// @func may be %NULL to remove a previously set function.	513		// @func may be %NULL to remove a previously set function.
514	-	func (x ComboBoxText) SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {	514	+	func (x ComboBoxText) SetCellDataFunc(CellVar CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
515			515
516	-	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))	516	+	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
517			517
518		}	518		}
519			519

M v4/gtk/gtkcssprovider.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Note that this signal may be emitted at any time as the css provider
 // may opt to defer parsing parts or all of the input to a later time
 // than when a loading function was called.
-func (x *CssProvider) ConnectParsingError(cb func(CssProvider, uintptr, uintptr)) uint32 {
+func (x *CssProvider) ConnectParsingError(cb *func(CssProvider, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "parsing-error", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SectionVarp uintptr, ErrorVarp uintptr) {
 		fa := CssProvider{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SectionVarp, ErrorVarp)
+		cbFn(fa, SectionVarp, ErrorVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "parsing-error", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "parsing-error", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkcustomfilter.go +4 -4


@@ -43,10 +43,10 @@ var xNewCustomFilter func(uintptr, uintptr, uintptr) uintptr
43		//	43		//
44		// If the filter func changes its filtering behavior,	44		// If the filter func changes its filtering behavior,
45		// gtk_filter_changed() needs to be called.	45		// gtk_filter_changed() needs to be called.
46	-	func NewCustomFilter(MatchFuncVar CustomFilterFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *CustomFilter {	46	+	func NewCustomFilter(MatchFuncVar CustomFilterFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *CustomFilter {
47		var cls *CustomFilter	47		var cls *CustomFilter
48			48
49	-	cret := xNewCustomFilter(purego.NewCallback(MatchFuncVar), UserDataVar, purego.NewCallback(UserDestroyVar))	49	+	cret := xNewCustomFilter(glib.NewCallback(MatchFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
50			50
51		if cret == 0 {	51		if cret == 0 {
52		return nil	52		return nil

@@ -67,9 +67,9 @@ var xCustomFilterSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
67		//	67		//
68		// If a previous function was set, its @user_destroy will be	68		// If a previous function was set, its @user_destroy will be
69		// called now.	69		// called now.
70	-	func (x *CustomFilter) SetFilterFunc(MatchFuncVar CustomFilterFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) {	70	+	func (x CustomFilter) SetFilterFunc(MatchFuncVar CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
71			71
72	-	xCustomFilterSetFilterFunc(x.GoPointer(), purego.NewCallback(MatchFuncVar), UserDataVar, purego.NewCallback(UserDestroyVar))	72	+	xCustomFilterSetFilterFunc(x.GoPointer(), glib.NewCallback(MatchFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
73			73
74		}	74		}
75			75

M v4/gtk/gtkcustomlayout.go +3 -2

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 )
 // A function to be used by `GtkCustomLayout` to allocate a widget.
 // Legacy layout managers map to the old `GtkWidget` size negotiation
 // virtual functions, and are meant to be used during the transition
 // from layout containers to layout manager delegates.
-func NewCustomLayout(RequestModeVar CustomRequestModeFunc, MeasureVar CustomMeasureFunc, AllocateVar CustomAllocateFunc) *CustomLayout {
+func NewCustomLayout(RequestModeVar *CustomRequestModeFunc, MeasureVar *CustomMeasureFunc, AllocateVar *CustomAllocateFunc) *CustomLayout {
 	var cls *CustomLayout
-	cret := xNewCustomLayout(purego.NewCallback(RequestModeVar), purego.NewCallback(MeasureVar), purego.NewCallback(AllocateVar))
+	cret := xNewCustomLayout(glib.NewCallback(RequestModeVar), glib.NewCallback(MeasureVar), glib.NewCallback(AllocateVar))
 	if cret == 0 {
 		return nil

M v4/gtk/gtkcustomsorter.go +4 -4


@@ -35,10 +35,10 @@ var xNewCustomSorter func(uintptr, uintptr, uintptr) uintptr
35		// @sort_func to compare items.	35		// @sort_func to compare items.
36		//	36		//
37		// If @sort_func is %NULL, all items are considered equal.	37		// If @sort_func is %NULL, all items are considered equal.
38	-	func NewCustomSorter(SortFuncVar glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *CustomSorter {	38	+	func NewCustomSorter(SortFuncVar glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *CustomSorter {
39		var cls *CustomSorter	39		var cls *CustomSorter
40			40
41	-	cret := xNewCustomSorter(purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(UserDestroyVar))	41	+	cret := xNewCustomSorter(glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
42			42
43		if cret == 0 {	43		if cret == 0 {
44		return nil	44		return nil

@@ -59,9 +59,9 @@ var xCustomSorterSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
59		//	59		//
60		// If a previous function was set, its @user_destroy will be	60		// If a previous function was set, its @user_destroy will be
61		// called now.	61		// called now.
62	-	func (x *CustomSorter) SetSortFunc(SortFuncVar glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) {	62	+	func (x CustomSorter) SetSortFunc(SortFuncVar glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
63			63
64	-	xCustomSorterSetSortFunc(x.GoPointer(), purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(UserDestroyVar))	64	+	xCustomSorterSetSortFunc(x.GoPointer(), glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
65			65
66		}	66		}
67			67

M v4/gtk/gtkdialog.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gsk"
 )
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is the Escape key.
-func (x *Dialog) ConnectClose(cb func(Dialog)) uint32 {
+func (x *Dialog) ConnectClose(cb *func(Dialog)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Dialog{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "close", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
 }
 // Emitted when an action widget is clicked.
 // delete event, and when [method@Gtk.Dialog.response] is called.
 // On a delete event, the response ID is %GTK_RESPONSE_DELETE_EVENT.
 // Otherwise, it depends on which action widget was clicked.
-func (x *Dialog) ConnectResponse(cb func(Dialog, int)) uint32 {
+func (x *Dialog) ConnectResponse(cb *func(Dialog, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ResponseIdVarp int) {
 		fa := Dialog{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ResponseIdVarp)
+		cbFn(fa, ResponseIdVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "response", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkdragsource.go +45 -12

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // It can be used to e.g. set a custom drag icon with
 // [method@Gtk.DragSource.set_icon].
-func (x *DragSource) ConnectDragBegin(cb func(DragSource, uintptr)) uint32 {
+func (x *DragSource) ConnectDragBegin(cb *func(DragSource, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DragVarp uintptr) {
 		fa := DragSource{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DragVarp)
+		cbFn(fa, DragVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-begin", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
 }
 // Emitted on the drag source when a drag has failed.
 // The signal handler may handle a failed drag operation based on
 // the type of error. It should return %TRUE if the failure has been handled
 // and the default "drag operation failed" animation should not be shown.
-func (x *DragSource) ConnectDragCancel(cb func(DragSource, uintptr, gdk.DragCancelReason) bool) uint32 {
+func (x *DragSource) ConnectDragCancel(cb *func(DragSource, uintptr, gdk.DragCancelReason) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-cancel", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DragVarp uintptr, ReasonVarp gdk.DragCancelReason) bool {
 		fa := DragSource{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, DragVarp, ReasonVarp)
+		return cbFn(fa, DragVarp, ReasonVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-cancel", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-cancel", cbRefPtr)
 }
 // Emitted on the drag source when a drag is finished.
 // A typical reason to connect to this signal is to undo
 // things done in [signal@Gtk.DragSource::prepare] or
 // [signal@Gtk.DragSource::drag-begin] handlers.
-func (x *DragSource) ConnectDragEnd(cb func(DragSource, uintptr, bool)) uint32 {
+func (x *DragSource) ConnectDragEnd(cb *func(DragSource, uintptr, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DragVarp uintptr, DeleteDataVarp bool) {
 		fa := DragSource{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DragVarp, DeleteDataVarp)
+		cbFn(fa, DragVarp, DeleteDataVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-end", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
 }
 // Emitted when a drag is about to be initiated.
 // to start. The default handler for this signal returns the value of
 // the [property@Gtk.DragSource:content] property, so if you set up that
 // property ahead of time, you don't need to connect to this signal.
-func (x *DragSource) ConnectPrepare(cb func(DragSource, float64, float64) gdk.ContentProvider) uint32 {
+func (x *DragSource) ConnectPrepare(cb *func(DragSource, float64, float64) gdk.ContentProvider) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) uintptr {
 		fa := DragSource{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		PrepareCls := cb(fa, XVarp, YVarp)
+		PrepareCls := cbFn(fa, XVarp, YVarp)
 		return PrepareCls.Ptr
 	}
-	return gobject.SignalConnect(x.GoPointer(), "prepare", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkdrawingarea.go +13 -5

 //
 // If what you are drawing does change, call [method@Gtk.Widget.queue_draw]
 // on the drawing area. This will cause a redraw and will call @draw_func again.
-func (x *DrawingArea) SetDrawFunc(DrawFuncVar DrawingAreaDrawFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *DrawingArea) SetDrawFunc(DrawFuncVar *DrawingAreaDrawFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xDrawingAreaSetDrawFunc(x.GoPointer(), purego.NewCallback(DrawFuncVar), UserDataVar, purego.NewCallback(DestroyVar))
+	xDrawingAreaSetDrawFunc(x.GoPointer(), glib.NewCallback(DrawFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
 }
 //
 // This is useful in order to keep state up to date with the widget size,
 // like for instance a backing surface.
-func (x *DrawingArea) ConnectResize(cb func(DrawingArea, int, int)) uint32 {
+func (x *DrawingArea) ConnectResize(cb *func(DrawingArea, int, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WidthVarp int, HeightVarp int) {
 		fa := DrawingArea{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, WidthVarp, HeightVarp)
+		cbFn(fa, WidthVarp, HeightVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "resize", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkdropcontrollermotion.go +34 -9

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Signals that the pointer has entered the widget.
-func (x *DropControllerMotion) ConnectEnter(cb func(DropControllerMotion, float64, float64)) uint32 {
+func (x *DropControllerMotion) ConnectEnter(cb *func(DropControllerMotion, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := DropControllerMotion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "enter", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
 }
 // Signals that the pointer has left the widget.
-func (x *DropControllerMotion) ConnectLeave(cb func(DropControllerMotion)) uint32 {
+func (x *DropControllerMotion) ConnectLeave(cb *func(DropControllerMotion)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := DropControllerMotion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "leave", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
 }
 // Emitted when the pointer moves inside the widget.
-func (x *DropControllerMotion) ConnectMotion(cb func(DropControllerMotion, float64, float64)) uint32 {
+func (x *DropControllerMotion) ConnectMotion(cb *func(DropControllerMotion, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := DropControllerMotion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "motion", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkdropdown.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // The `::activate` signal on `GtkDropDown` is an action signal and
 // emitting it causes the drop down to pop up its dropdown.
-func (x *DropDown) ConnectActivate(cb func(DropDown)) uint32 {
+func (x *DropDown) ConnectActivate(cb *func(DropDown)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := DropDown{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkdroptarget.go +56 -15

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // [property@Gtk.DropTarget:preload] property should be set and the value
 // should be inspected via the ::notify:value signal, calling
 // [method@Gtk.DropTarget.reject] if required.
-func (x *DropTarget) ConnectAccept(cb func(DropTarget, uintptr) bool) uint32 {
+func (x *DropTarget) ConnectAccept(cb *func(DropTarget, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr) bool {
 		fa := DropTarget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, DropVarp)
+		return cbFn(fa, DropVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "accept", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
 }
 // Emitted on the drop site when the user drops the data onto the widget.
 // Otherwise, the handler returns %TRUE. In this case, this handler will
 // accept the drop. The handler is responsible for using the given @value
 // and performing the drop operation.
-func (x *DropTarget) ConnectDrop(cb func(DropTarget, uintptr, float64, float64) bool) uint32 {
+func (x *DropTarget) ConnectDrop(cb *func(DropTarget, uintptr, float64, float64) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ValueVarp uintptr, XVarp float64, YVarp float64) bool {
 		fa := DropTarget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ValueVarp, XVarp, YVarp)
+		return cbFn(fa, ValueVarp, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drop", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
 }
 // Emitted on the drop site when the pointer enters the widget.
 //
 // It can be used to set up custom highlighting.
-func (x *DropTarget) ConnectEnter(cb func(DropTarget, float64, float64) gdk.DragAction) uint32 {
+func (x *DropTarget) ConnectEnter(cb *func(DropTarget, float64, float64) gdk.DragAction) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) gdk.DragAction {
 		fa := DropTarget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, XVarp, YVarp)
+		return cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "enter", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
 }
 // Emitted on the drop site when the pointer leaves the widget.
 //
 // Its main purpose it to undo things done in
 // [signal@Gtk.DropTarget::enter].
-func (x *DropTarget) ConnectLeave(cb func(DropTarget)) uint32 {
+func (x *DropTarget) ConnectLeave(cb *func(DropTarget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := DropTarget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "leave", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
 }
 // Emitted while the pointer is moving over the drop target.
-func (x *DropTarget) ConnectMotion(cb func(DropTarget, float64, float64) gdk.DragAction) uint32 {
+func (x *DropTarget) ConnectMotion(cb *func(DropTarget, float64, float64) gdk.DragAction) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) gdk.DragAction {
 		fa := DropTarget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, XVarp, YVarp)
+		return cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "motion", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkdroptargetasync.go +56 -15

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // further processing, such as inspecting the data, this function should
 // return %TRUE and proceed as is @drop was accepted and if it decides to
 // reject the drop later, it should call [method@Gtk.DropTargetAsync.reject_drop].
-func (x *DropTargetAsync) ConnectAccept(cb func(DropTargetAsync, uintptr) bool) uint32 {
+func (x *DropTargetAsync) ConnectAccept(cb *func(DropTargetAsync, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr) bool {
 		fa := DropTargetAsync{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, DropVarp)
+		return cbFn(fa, DropVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "accept", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
 }
 // Emitted on the drop site when the pointer enters the widget.
 //
 // It can be used to set up custom highlighting.
-func (x *DropTargetAsync) ConnectDragEnter(cb func(DropTargetAsync, uintptr, float64, float64) gdk.DragAction) uint32 {
+func (x *DropTargetAsync) ConnectDragEnter(cb *func(DropTargetAsync, uintptr, float64, float64) gdk.DragAction) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-enter", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr, XVarp float64, YVarp float64) gdk.DragAction {
 		fa := DropTargetAsync{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, DropVarp, XVarp, YVarp)
+		return cbFn(fa, DropVarp, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-enter", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-enter", cbRefPtr)
 }
 // Emitted on the drop site when the pointer leaves the widget.
 //
 // Its main purpose it to undo things done in
 // `GtkDropTargetAsync`::drag-enter.
-func (x *DropTargetAsync) ConnectDragLeave(cb func(DropTargetAsync, uintptr)) uint32 {
+func (x *DropTargetAsync) ConnectDragLeave(cb *func(DropTargetAsync, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-leave", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr) {
 		fa := DropTargetAsync{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DropVarp)
+		cbFn(fa, DropVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-leave", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-leave", cbRefPtr)
 }
 // Emitted while the pointer is moving over the drop target.
-func (x *DropTargetAsync) ConnectDragMotion(cb func(DropTargetAsync, uintptr, float64, float64) gdk.DragAction) uint32 {
+func (x *DropTargetAsync) ConnectDragMotion(cb *func(DropTargetAsync, uintptr, float64, float64) gdk.DragAction) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-motion", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr, XVarp float64, YVarp float64) gdk.DragAction {
 		fa := DropTargetAsync{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, DropVarp, XVarp, YVarp)
+		return cbFn(fa, DropVarp, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-motion", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-motion", cbRefPtr)
 }
 // Emitted on the drop site when the user drops the data onto the widget.
 // To receive the data, use one of the read functions provided by
 // [class@Gdk.Drop] such as [method@Gdk.Drop.read_async] or
 // [method@Gdk.Drop.read_value_async].
-func (x *DropTargetAsync) ConnectDrop(cb func(DropTargetAsync, uintptr, float64, float64) bool) uint32 {
+func (x *DropTargetAsync) ConnectDrop(cb *func(DropTargetAsync, uintptr, float64, float64) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr, XVarp float64, YVarp float64) bool {
 		fa := DropTargetAsync{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, DropVarp, XVarp, YVarp)
+		return cbFn(fa, DropVarp, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drop", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkemojichooser.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gsk"
 )
 }
 // Emitted when the user selects an Emoji.
-func (x *EmojiChooser) ConnectEmojiPicked(cb func(EmojiChooser, string)) uint32 {
+func (x *EmojiChooser) ConnectEmojiPicked(cb *func(EmojiChooser, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "emoji-picked", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, TextVarp string) {
 		fa := EmojiChooser{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, TextVarp)
+		cbFn(fa, TextVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "emoji-picked", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "emoji-picked", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkentry.go +34 -9

 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/pango"
 )
 // Emitted when the entry is activated.
 //
 // The keybindings for this signal are all forms of the Enter key.
-func (x *Entry) ConnectActivate(cb func(Entry)) uint32 {
+func (x *Entry) ConnectActivate(cb *func(Entry)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Entry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when an activatable icon is clicked.
-func (x *Entry) ConnectIconPress(cb func(Entry, EntryIconPosition)) uint32 {
+func (x *Entry) ConnectIconPress(cb *func(Entry, EntryIconPosition)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "icon-press", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, IconPosVarp EntryIconPosition) {
 		fa := Entry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, IconPosVarp)
+		cbFn(fa, IconPosVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "icon-press", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "icon-press", cbRefPtr)
 }
 // Emitted on the button release from a mouse click
 // over an activatable icon.
-func (x *Entry) ConnectIconRelease(cb func(Entry, EntryIconPosition)) uint32 {
+func (x *Entry) ConnectIconRelease(cb *func(Entry, EntryIconPosition)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "icon-release", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, IconPosVarp EntryIconPosition) {
 		fa := Entry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, IconPosVarp)
+		cbFn(fa, IconPosVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "icon-release", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "icon-release", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkentrybuffer.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // If you want access to the text after the text has been modified,
 // use %G_CONNECT_AFTER.
-func (x *EntryBuffer) ConnectDeletedText(cb func(EntryBuffer, uint, uint)) uint32 {
+func (x *EntryBuffer) ConnectDeletedText(cb *func(EntryBuffer, uint, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "deleted-text", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PositionVarp uint, NCharsVarp uint) {
 		fa := EntryBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PositionVarp, NCharsVarp)
+		cbFn(fa, PositionVarp, NCharsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "deleted-text", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "deleted-text", cbRefPtr)
 }
 // This signal is emitted after text is inserted into the buffer.
-func (x *EntryBuffer) ConnectInsertedText(cb func(EntryBuffer, uint, string, uint)) uint32 {
+func (x *EntryBuffer) ConnectInsertedText(cb *func(EntryBuffer, uint, string, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "inserted-text", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PositionVarp uint, CharsVarp string, NCharsVarp uint) {
 		fa := EntryBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PositionVarp, CharsVarp, NCharsVarp)
+		cbFn(fa, PositionVarp, CharsVarp, NCharsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "inserted-text", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "inserted-text", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkentrycompletion.go +50 -16

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 //
 // The match function is used to determine if a row should or
 // should not be in the completion list.
-func (x *EntryCompletion) SetMatchFunc(FuncVar EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar glib.DestroyNotify) {
+func (x *EntryCompletion) SetMatchFunc(FuncVar *EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar *glib.DestroyNotify) {
-	xEntryCompletionSetMatchFunc(x.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(FuncNotifyVar))
+	xEntryCompletionSetMatchFunc(x.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(FuncNotifyVar))
 }
 //
 // Note that @model is the model that was passed to
 // [method@Gtk.EntryCompletion.set_model].
-func (x *EntryCompletion) ConnectCursorOnMatch(cb func(EntryCompletion, uintptr, uintptr) bool) uint32 {
+func (x *EntryCompletion) ConnectCursorOnMatch(cb *func(EntryCompletion, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cursor-on-match", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ModelVarp uintptr, IterVarp uintptr) bool {
 		fa := EntryCompletion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ModelVarp, IterVarp)
+		return cbFn(fa, ModelVarp, IterVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cursor-on-match", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cursor-on-match", cbRefPtr)
 }
 // Emitted when the inline autocompletion is triggered.
 // smaller part of the @prefix into the entry - e.g. the entry used in
 // the `GtkFileChooser` inserts only the part of the prefix up to the
 // next '/'.
-func (x *EntryCompletion) ConnectInsertPrefix(cb func(EntryCompletion, string) bool) uint32 {
+func (x *EntryCompletion) ConnectInsertPrefix(cb *func(EntryCompletion, string) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "insert-prefix", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PrefixVarp string) bool {
 		fa := EntryCompletion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PrefixVarp)
+		return cbFn(fa, PrefixVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "insert-prefix", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "insert-prefix", cbRefPtr)
 }
 // Emitted when a match from the list is selected.
 //
 // Note that @model is the model that was passed to
 // [method@Gtk.EntryCompletion.set_model].
-func (x *EntryCompletion) ConnectMatchSelected(cb func(EntryCompletion, uintptr, uintptr) bool) uint32 {
+func (x *EntryCompletion) ConnectMatchSelected(cb *func(EntryCompletion, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "match-selected", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ModelVarp uintptr, IterVarp uintptr) bool {
 		fa := EntryCompletion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ModelVarp, IterVarp)
+		return cbFn(fa, ModelVarp, IterVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "match-selected", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "match-selected", cbRefPtr)
 }
 // Emitted when the filter model has zero
 // number of rows in completion_complete method.
 //
 // In other words when `GtkEntryCompletion` is out of suggestions.
-func (x *EntryCompletion) ConnectNoMatches(cb func(EntryCompletion)) uint32 {
+func (x *EntryCompletion) ConnectNoMatches(cb *func(EntryCompletion)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "no-matches", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EntryCompletion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "no-matches", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "no-matches", cbRefPtr)
 }
 // Gets the ID of the @buildable object.
 // cell renderer(s) as appropriate.
 //
 // @func may be %NULL to remove a previously set function.
-func (x *EntryCompletion) SetCellDataFunc(CellVar *CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *EntryCompletion) SetCellDataFunc(CellVar *CellRenderer, FuncVar *CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))
+	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
 }

M v4/gtk/gtkeventcontrollerfocus.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // in these cases, you can monitor the
 // [property@Gtk.EventControllerFocus:is-focus]
 // property for changes.
-func (x *EventControllerFocus) ConnectEnter(cb func(EventControllerFocus)) uint32 {
+func (x *EventControllerFocus) ConnectEnter(cb *func(EventControllerFocus)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EventControllerFocus{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "enter", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
 }
 // Emitted whenever the focus leaves the widget hierarchy
 // to a descendent). If you are interested in these cases, you
 // can monitor the [property@Gtk.EventControllerFocus:is-focus]
 // property for changes.
-func (x *EventControllerFocus) ConnectLeave(cb func(EventControllerFocus)) uint32 {
+func (x *EventControllerFocus) ConnectLeave(cb *func(EventControllerFocus)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EventControllerFocus{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "leave", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkeventcontrollerkey.go +45 -12

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // See [method@Gtk.EventControllerKey.set_im_context] and
 // [method@Gtk.IMContext.filter_keypress].
-func (x *EventControllerKey) ConnectImUpdate(cb func(EventControllerKey)) uint32 {
+func (x *EventControllerKey) ConnectImUpdate(cb *func(EventControllerKey)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "im-update", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EventControllerKey{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "im-update", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "im-update", cbRefPtr)
 }
 // Emitted whenever a key is pressed.
-func (x *EventControllerKey) ConnectKeyPressed(cb func(EventControllerKey, uint, uint, gdk.ModifierType) bool) uint32 {
+func (x *EventControllerKey) ConnectKeyPressed(cb *func(EventControllerKey, uint, uint, gdk.ModifierType) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "key-pressed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, KeyvalVarp uint, KeycodeVarp uint, StateVarp gdk.ModifierType) bool {
 		fa := EventControllerKey{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, KeyvalVarp, KeycodeVarp, StateVarp)
+		return cbFn(fa, KeyvalVarp, KeycodeVarp, StateVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "key-pressed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "key-pressed", cbRefPtr)
 }
 // Emitted whenever a key is released.
-func (x *EventControllerKey) ConnectKeyReleased(cb func(EventControllerKey, uint, uint, gdk.ModifierType)) uint32 {
+func (x *EventControllerKey) ConnectKeyReleased(cb *func(EventControllerKey, uint, uint, gdk.ModifierType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "key-released", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, KeyvalVarp uint, KeycodeVarp uint, StateVarp gdk.ModifierType) {
 		fa := EventControllerKey{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, KeyvalVarp, KeycodeVarp, StateVarp)
+		cbFn(fa, KeyvalVarp, KeycodeVarp, StateVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "key-released", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "key-released", cbRefPtr)
 }
 // Emitted whenever the state of modifier keys and pointer buttons change.
-func (x *EventControllerKey) ConnectModifiers(cb func(EventControllerKey, gdk.ModifierType) bool) uint32 {
+func (x *EventControllerKey) ConnectModifiers(cb *func(EventControllerKey, gdk.ModifierType) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "modifiers", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, KeyvalVarp gdk.ModifierType) bool {
 		fa := EventControllerKey{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, KeyvalVarp)
+		return cbFn(fa, KeyvalVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "modifiers", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "modifiers", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkeventcontrollerlegacy.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted for each GDK event delivered to @controller.
-func (x *EventControllerLegacy) ConnectEvent(cb func(EventControllerLegacy, uintptr) bool) uint32 {
+func (x *EventControllerLegacy) ConnectEvent(cb *func(EventControllerLegacy, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, EventVarp uintptr) bool {
 		fa := EventControllerLegacy{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, EventVarp)
+		return cbFn(fa, EventVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "event", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkeventcontrollermotion.go +34 -9

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Signals that the pointer has entered the widget.
-func (x *EventControllerMotion) ConnectEnter(cb func(EventControllerMotion, float64, float64)) uint32 {
+func (x *EventControllerMotion) ConnectEnter(cb *func(EventControllerMotion, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := EventControllerMotion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "enter", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
 }
 // Signals that the pointer has left the widget.
-func (x *EventControllerMotion) ConnectLeave(cb func(EventControllerMotion)) uint32 {
+func (x *EventControllerMotion) ConnectLeave(cb *func(EventControllerMotion)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EventControllerMotion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "leave", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
 }
 // Emitted when the pointer moves inside the widget.
-func (x *EventControllerMotion) ConnectMotion(cb func(EventControllerMotion, float64, float64)) uint32 {
+func (x *EventControllerMotion) ConnectMotion(cb *func(EventControllerMotion, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := EventControllerMotion{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "motion", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkeventcontrollerscroll.go +45 -12

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // @vel_x and @vel_y express the initial velocity that was
 // imprinted by the scroll events. @vel_x and @vel_y are expressed in
 // pixels/ms.
-func (x *EventControllerScroll) ConnectDecelerate(cb func(EventControllerScroll, float64, float64)) uint32 {
+func (x *EventControllerScroll) ConnectDecelerate(cb *func(EventControllerScroll, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, VelXVarp float64, VelYVarp float64) {
 		fa := EventControllerScroll{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, VelXVarp, VelYVarp)
+		cbFn(fa, VelXVarp, VelYVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "decelerate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
 }
 // Signals that the widget should scroll by the
 //
 // For the representation unit of the deltas, see
 // [method@Gtk.EventControllerScroll.get_unit].
-func (x *EventControllerScroll) ConnectScroll(cb func(EventControllerScroll, float64, float64) bool) uint32 {
+func (x *EventControllerScroll) ConnectScroll(cb *func(EventControllerScroll, float64, float64) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DxVarp float64, DyVarp float64) bool {
 		fa := EventControllerScroll{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, DxVarp, DyVarp)
+		return cbFn(fa, DxVarp, DyVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "scroll", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
 }
 // Signals that a new scrolling operation has begun.
 //
 // It will only be emitted on devices capable of it.
-func (x *EventControllerScroll) ConnectScrollBegin(cb func(EventControllerScroll)) uint32 {
+func (x *EventControllerScroll) ConnectScrollBegin(cb *func(EventControllerScroll)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EventControllerScroll{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "scroll-begin", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
 }
 // Signals that a scrolling operation has finished.
 //
 // It will only be emitted on devices capable of it.
-func (x *EventControllerScroll) ConnectScrollEnd(cb func(EventControllerScroll)) uint32 {
+func (x *EventControllerScroll) ConnectScrollEnd(cb *func(EventControllerScroll)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := EventControllerScroll{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "scroll-end", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkexpander.go +14 -3

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Activates the `GtkExpander`.
-func (x *Expander) ConnectActivate(cb func(Expander)) uint32 {
+func (x *Expander) ConnectActivate(cb *func(Expander)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Expander{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkexpression.go +4 -4


@@ -163,10 +163,10 @@ var xNewCClosureExpression func([]interface{}, uintptr, uint, uintptr, uintptr,
163		// This function is a variant of [ctor@Gtk.ClosureExpression.new] that	163		// This function is a variant of [ctor@Gtk.ClosureExpression.new] that
164		// creates a `GClosure` by calling g_cclosure_new() with the given	164		// creates a `GClosure` by calling g_cclosure_new() with the given
165		// `callback_func`, `user_data` and `user_destroy`.	165		// `callback_func`, `user_data` and `user_destroy`.
166	-	func NewCClosureExpression(ValueTypeVar []interface{}, MarshalVar gobject.ClosureMarshal, NParamsVar uint, ParamsVar uintptr, CallbackFuncVar gobject.Callback, UserDataVar uintptr, UserDestroyVar gobject.ClosureNotify) *CClosureExpression {	166	+	func NewCClosureExpression(ValueTypeVar []interface{}, MarshalVar gobject.ClosureMarshal, NParamsVar uint, ParamsVar uintptr, CallbackFuncVar gobject.Callback, UserDataVar uintptr, UserDestroyVar gobject.ClosureNotify) CClosureExpression {
167		var cls *CClosureExpression	167		var cls *CClosureExpression
168			168
169	-	cret := xNewCClosureExpression(ValueTypeVar, purego.NewCallback(MarshalVar), NParamsVar, ParamsVar, purego.NewCallback(CallbackFuncVar), UserDataVar, purego.NewCallback(UserDestroyVar))	169	+	cret := xNewCClosureExpression(ValueTypeVar, glib.NewCallback(MarshalVar), NParamsVar, ParamsVar, glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
170			170
171		if cret == 0 {	171		if cret == 0 {
172		return nil	172		return nil

@@ -538,9 +538,9 @@ var xExpressionWatch func(uintptr, uintptr, uintptr, uintptr, uintptr) *Expressi
538		// GTK cannot guarantee that the evaluation did indeed change when the @notify	538		// GTK cannot guarantee that the evaluation did indeed change when the @notify
539		// gets invoked, but it guarantees the opposite: When it did in fact change,	539		// gets invoked, but it guarantees the opposite: When it did in fact change,
540		// the @notify will be invoked.	540		// the @notify will be invoked.
541	-	func (x Expression) Watch(ThisVar gobject.Object, NotifyVar ExpressionNotify, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *ExpressionWatch {	541	+	func (x Expression) Watch(ThisVar gobject.Object, NotifyVar ExpressionNotify, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *ExpressionWatch {
542			542
543	-	cret := xExpressionWatch(x.GoPointer(), ThisVar.GoPointer(), purego.NewCallback(NotifyVar), UserDataVar, purego.NewCallback(UserDestroyVar))	543	+	cret := xExpressionWatch(x.GoPointer(), ThisVar.GoPointer(), glib.NewCallback(NotifyVar), UserDataVar, glib.NewCallback(UserDestroyVar))
544		return cret	544		return cret
545		}	545		}
546			546

M v4/gtk/gtkfilechooserwidget.go +134 -36

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
 // folder in the file list.
 //
 // The default binding for this signal is &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;D&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectDesktopFolder(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectDesktopFolder(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "desktop-folder", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "desktop-folder", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "desktop-folder", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // switch to the "baz" subfolder.
 //
 // The default binding for this signal is &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;Down&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectDownFolder(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectDownFolder(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "down-folder", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "down-folder", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "down-folder", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // folder in the file list.
 //
 // The default binding for this signal is &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;Home&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectHomeFolder(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectHomeFolder(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "home-folder", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "home-folder", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "home-folder", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // type `/` and immediately type a path name. On Unix systems, this is
 // bound to &lt;kbd&gt;~&lt;/kbd&gt; (tilde) with a @path string of "~" itself for
 // access to home directories.
-func (x *FileChooserWidget) ConnectLocationPopup(cb func(FileChooserWidget, string)) uint32 {
+func (x *FileChooserWidget) ConnectLocationPopup(cb *func(FileChooserWidget, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "location-popup", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathVarp string) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PathVarp)
+		cbFn(fa, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "location-popup", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "location-popup", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // when the user pastes into a `GtkFileChooserWidget`.
 //
 // The default binding for this signal is &lt;kbd&gt;Control&lt;/kbd&gt;-&lt;kbd&gt;V&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectLocationPopupOnPaste(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectLocationPopupOnPaste(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "location-popup-on-paste", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "location-popup-on-paste", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "location-popup-on-paste", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // he wishes to select.
 //
 // The default binding for this signal is &lt;kbd&gt;Control&lt;/kbd&gt;-&lt;kbd&gt;L&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectLocationTogglePopup(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectLocationTogglePopup(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "location-toggle-popup", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "location-toggle-popup", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "location-toggle-popup", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // This is used to move the focus to the places sidebar.
 //
 // The default binding for this signal is &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;P&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectPlacesShortcut(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectPlacesShortcut(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "places-shortcut", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "places-shortcut", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "places-shortcut", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // Note that in the default binding, that &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;1&lt;/kbd&gt; is
 // actually defined to switch to the bookmark at index 0, and so on
 // successively.
-func (x *FileChooserWidget) ConnectQuickBookmark(cb func(FileChooserWidget, int)) uint32 {
+func (x *FileChooserWidget) ConnectQuickBookmark(cb *func(FileChooserWidget, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "quick-bookmark", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, BookmarkIndexVarp int) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, BookmarkIndexVarp)
+		cbFn(fa, BookmarkIndexVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "quick-bookmark", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "quick-bookmark", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // This is used to make the file chooser show the Recent location.
 //
 // The default binding for this signal is &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;R&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectRecentShortcut(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectRecentShortcut(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "recent-shortcut", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "recent-shortcut", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "recent-shortcut", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // This is used to make the file chooser show the search entry.
 //
 // The default binding for this signal is &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;S&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectSearchShortcut(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectSearchShortcut(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "search-shortcut", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "search-shortcut", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "search-shortcut", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // This is used to make the file chooser display hidden files.
 //
 // The default binding for this signal is &lt;kbd&gt;Control&lt;/kbd&gt;-&lt;kbd&gt;H&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectShowHidden(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectShowHidden(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "show-hidden", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "show-hidden", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "show-hidden", cbRefPtr)
 }
 // Emitted when the user asks for it.
 // of the current folder in the file hierarchy.
 //
 // The default binding for this signal is &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;Up&lt;/kbd&gt;.
-func (x *FileChooserWidget) ConnectUpFolder(cb func(FileChooserWidget)) uint32 {
+func (x *FileChooserWidget) ConnectUpFolder(cb *func(FileChooserWidget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "up-folder", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FileChooserWidget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "up-folder", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "up-folder", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkfilter.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Depending on the @change parameter, not all items need
 // to be checked, but only some. Refer to the [enum@Gtk.FilterChange]
 // documentation for details.
-func (x *Filter) ConnectChanged(cb func(Filter, FilterChange)) uint32 {
+func (x *Filter) ConnectChanged(cb *func(Filter, FilterChange)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ChangeVarp FilterChange) {
 		fa := Filter{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ChangeVarp)
+		cbFn(fa, ChangeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkflowbox.go +96 -32

 // Note that using a model is incompatible with the filtering and sorting
 // functionality in `GtkFlowBox`. When using a model, filtering and sorting
 // should be implemented by the model.
-func (x *FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) {
+func (x *FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
-	xFlowBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), purego.NewCallback(CreateWidgetFuncVar), UserDataVar, purego.NewCallback(UserDataFreeFuncVar))
+	xFlowBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), glib.NewCallback(CreateWidgetFuncVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
 }
 //
 // Note that the selection cannot be modified from within
 // this function.
-func (x *FlowBox) SelectedForeach(FuncVar FlowBoxForeachFunc, DataVar uintptr) {
+func (x *FlowBox) SelectedForeach(FuncVar *FlowBoxForeachFunc, DataVar uintptr) {
-	xFlowBoxSelectedForeach(x.GoPointer(), purego.NewCallback(FuncVar), DataVar)
+	xFlowBoxSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
 }
 //
 // Note that using a filter function is incompatible with using a model
 // (see [method@Gtk.FlowBox.bind_model]).
-func (x *FlowBox) SetFilterFunc(FilterFuncVar FlowBoxFilterFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *FlowBox) SetFilterFunc(FilterFuncVar *FlowBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xFlowBoxSetFilterFunc(x.GoPointer(), purego.NewCallback(FilterFuncVar), UserDataVar, purego.NewCallback(DestroyVar))
+	xFlowBoxSetFilterFunc(x.GoPointer(), glib.NewCallback(FilterFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
 }
 //
 // Note that using a sort function is incompatible with using a model
 // (see [method@Gtk.FlowBox.bind_model]).
-func (x *FlowBox) SetSortFunc(SortFuncVar FlowBoxSortFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *FlowBox) SetSortFunc(SortFuncVar *FlowBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xFlowBoxSetSortFunc(x.GoPointer(), purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))
+	xFlowBoxSetSortFunc(x.GoPointer(), glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
 }
 // Emitted when the user activates the @box.
 //
 // This is a [keybinding signal](class.SignalAction.html).
-func (x *FlowBox) ConnectActivateCursorChild(cb func(FlowBox)) uint32 {
+func (x *FlowBox) ConnectActivateCursorChild(cb *func(FlowBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-cursor-child", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FlowBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-child", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-child", cbRefPtr)
 }
 // Emitted when a child has been activated by the user.
-func (x *FlowBox) ConnectChildActivated(cb func(FlowBox, uintptr)) uint32 {
+func (x *FlowBox) ConnectChildActivated(cb *func(FlowBox, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "child-activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ChildVarp uintptr) {
 		fa := FlowBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ChildVarp)
+		cbFn(fa, ChildVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "child-activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "child-activated", cbRefPtr)
 }
 // Emitted when the user initiates a cursor movement.
 //     move by individual children
 //   - &lt;kbd&gt;Home&lt;/kbd&gt;, &lt;kbd&gt;End&lt;/kbd&gt; move to the ends of the box
 //   - &lt;kbd&gt;PgUp&lt;/kbd&gt;, &lt;kbd&gt;PgDn&lt;/kbd&gt; move vertically by pages
-func (x *FlowBox) ConnectMoveCursor(cb func(FlowBox, MovementStep, int, bool, bool) bool) uint32 {
+func (x *FlowBox) ConnectMoveCursor(cb *func(FlowBox, MovementStep, int, bool, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool, ModifyVarp bool) bool {
 		fa := FlowBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, StepVarp, CountVarp, ExtendVarp, ModifyVarp)
+		return cbFn(fa, StepVarp, CountVarp, ExtendVarp, ModifyVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
 }
 // Emitted to select all children of the box,
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default bindings for this signal is &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt;.
-func (x *FlowBox) ConnectSelectAll(cb func(FlowBox)) uint32 {
+func (x *FlowBox) ConnectSelectAll(cb *func(FlowBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FlowBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
 }
 // Emitted when the set of selected children changes.
 // Use [method@Gtk.FlowBox.selected_foreach] or
 // [method@Gtk.FlowBox.get_selected_children] to obtain the
 // selected children.
-func (x *FlowBox) ConnectSelectedChildrenChanged(cb func(FlowBox)) uint32 {
+func (x *FlowBox) ConnectSelectedChildrenChanged(cb *func(FlowBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "selected-children-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FlowBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "selected-children-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "selected-children-changed", cbRefPtr)
 }
 // Emitted to toggle the selection of the child that has the focus.
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Space&lt;/kbd&gt;.
-func (x *FlowBox) ConnectToggleCursorChild(cb func(FlowBox)) uint32 {
+func (x *FlowBox) ConnectToggleCursorChild(cb *func(FlowBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-child", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FlowBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-child", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-child", cbRefPtr)
 }
 // Emitted to unselect all children of the box,
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default bindings for this signal is &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt;.
-func (x *FlowBox) ConnectUnselectAll(cb func(FlowBox)) uint32 {
+func (x *FlowBox) ConnectUnselectAll(cb *func(FlowBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FlowBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "unselect-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.
 // but it can be used by applications for their own purposes.
 //
 // The default bindings are &lt;kbd&gt;Space&lt;/kbd&gt; and &lt;kbd&gt;Enter&lt;/kbd&gt;.
-func (x *FlowBoxChild) ConnectActivate(cb func(FlowBoxChild)) uint32 {
+func (x *FlowBoxChild) ConnectActivate(cb *func(FlowBoxChild)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FlowBoxChild{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkfontbutton.go +26 -8

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 //
 // The `::activate` signal on `GtkFontButton` is an action signal and
 // emitting it causes the button to present its dialog.
-func (x *FontButton) ConnectActivate(cb func(FontButton)) uint32 {
+func (x *FontButton) ConnectActivate(cb *func(FontButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FontButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the user selects a font.
 // Note that this signal is only emitted when the user changes the font.
 // If you need to react to programmatic font changes as well, use
 // the notify::font signal.
-func (x *FontButton) ConnectFontSet(cb func(FontButton)) uint32 {
+func (x *FontButton) ConnectFontSet(cb *func(FontButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "font-set", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := FontButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "font-set", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "font-set", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.
 // Adds a filter function that decides which fonts to display
 // in the font chooser.
-func (x *FontButton) SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *FontButton) SetFilterFunc(FilterVar *FontFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	XGtkFontChooserSetFilterFunc(x.GoPointer(), purego.NewCallback(FilterVar), UserDataVar, purego.NewCallback(DestroyVar))
+	XGtkFontChooserSetFilterFunc(x.GoPointer(), glib.NewCallback(FilterVar), UserDataVar, glib.NewCallback(DestroyVar))
 }

M v4/gtk/gtkfontchooser.go +3 -3


@@ -47,7 +47,7 @@ type FontChooser interface {
47		GetLevel() FontChooserLevel	47		GetLevel() FontChooserLevel
48		GetPreviewText() string	48		GetPreviewText() string
49		GetShowPreviewEntry() bool	49		GetShowPreviewEntry() bool
50	-	SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify)	50	+	SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify)
51		SetFont(FontnameVar string)	51		SetFont(FontnameVar string)
52		SetFontDesc(FontDescVar *pango.FontDescription)	52		SetFontDesc(FontDescVar *pango.FontDescription)
53		SetFontMap(FontmapVar *pango.FontMap)	53		SetFontMap(FontmapVar *pango.FontMap)

@@ -200,9 +200,9 @@ func (x *FontChooserBase) GetShowPreviewEntry() bool {
200			200
201		// Adds a filter function that decides which fonts to display	201		// Adds a filter function that decides which fonts to display
202		// in the font chooser.	202		// in the font chooser.
203	-	func (x *FontChooserBase) SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	203	+	func (x FontChooserBase) SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
204			204
205	-	XGtkFontChooserSetFilterFunc(x.GoPointer(), purego.NewCallback(FilterVar), UserDataVar, purego.NewCallback(DestroyVar))	205	+	XGtkFontChooserSetFilterFunc(x.GoPointer(), glib.NewCallback(FilterVar), UserDataVar, glib.NewCallback(DestroyVar))
206			206
207		}	207		}
208			208

M v4/gtk/gtkfontchooserdialog.go +2 -2


@@ -335,9 +335,9 @@ func (x *FontChooserDialog) GetShowPreviewEntry() bool {
335			335
336		// Adds a filter function that decides which fonts to display	336		// Adds a filter function that decides which fonts to display
337		// in the font chooser.	337		// in the font chooser.
338	-	func (x *FontChooserDialog) SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	338	+	func (x FontChooserDialog) SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
339			339
340	-	XGtkFontChooserSetFilterFunc(x.GoPointer(), purego.NewCallback(FilterVar), UserDataVar, purego.NewCallback(DestroyVar))	340	+	XGtkFontChooserSetFilterFunc(x.GoPointer(), glib.NewCallback(FilterVar), UserDataVar, glib.NewCallback(DestroyVar))
341			341
342		}	342		}
343			343

M v4/gtk/gtkfontchooserwidget.go +2 -2


@@ -336,9 +336,9 @@ func (x *FontChooserWidget) GetShowPreviewEntry() bool {
336			336
337		// Adds a filter function that decides which fonts to display	337		// Adds a filter function that decides which fonts to display
338		// in the font chooser.	338		// in the font chooser.
339	-	func (x *FontChooserWidget) SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	339	+	func (x FontChooserWidget) SetFilterFunc(FilterVar FontFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
340			340
341	-	XGtkFontChooserSetFilterFunc(x.GoPointer(), purego.NewCallback(FilterVar), UserDataVar, purego.NewCallback(DestroyVar))	341	+	XGtkFontChooserSetFilterFunc(x.GoPointer(), glib.NewCallback(FilterVar), UserDataVar, glib.NewCallback(DestroyVar))
342			342
343		}	343		}
344			344

M v4/gtk/gtkgesture.go +55 -15

 // (eg. a third touch on a 2-touches gesture) is lifted, in that
 // situation @sequence won't pertain to the current set of active
 // touches, so don't rely on this being true.
-func (x *Gesture) ConnectBegin(cb func(Gesture, uintptr)) uint32 {
+func (x *Gesture) ConnectBegin(cb *func(Gesture, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "begin", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr) {
 		fa := Gesture{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SequenceVarp)
+		cbFn(fa, SequenceVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "begin", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "begin", cbRefPtr)
 }
 // Emitted whenever a sequence is cancelled.
 //
 // @gesture must forget everything about @sequence as in
 // response to this signal.
-func (x *Gesture) ConnectCancel(cb func(Gesture, uintptr)) uint32 {
+func (x *Gesture) ConnectCancel(cb *func(Gesture, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr) {
 		fa := Gesture{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SequenceVarp)
+		cbFn(fa, SequenceVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cancel", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
 }
 // Emitted when @gesture either stopped recognizing the event
 // pressed touch sequence that exceeds [property@Gtk.Gesture:n-points]).
 // This situation may be detected by checking through
 // [method@Gtk.Gesture.handles_sequence].
-func (x *Gesture) ConnectEnd(cb func(Gesture, uintptr)) uint32 {
+func (x *Gesture) ConnectEnd(cb *func(Gesture, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "end", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr) {
 		fa := Gesture{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SequenceVarp)
+		cbFn(fa, SequenceVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "end", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "end", cbRefPtr)
 }
 // Emitted whenever a sequence state changes.
 //
 // See [method@Gtk.Gesture.set_sequence_state] to know
 // more about the expectable sequence lifetimes.
-func (x *Gesture) ConnectSequenceStateChanged(cb func(Gesture, uintptr, EventSequenceState)) uint32 {
+func (x *Gesture) ConnectSequenceStateChanged(cb *func(Gesture, uintptr, EventSequenceState)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "sequence-state-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr, StateVarp EventSequenceState) {
 		fa := Gesture{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SequenceVarp, StateVarp)
+		cbFn(fa, SequenceVarp, StateVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "sequence-state-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "sequence-state-changed", cbRefPtr)
 }
 // Emitted whenever an event is handled while the gesture is recognized.
 //
 // @sequence is guaranteed to pertain to the set of active touches.
-func (x *Gesture) ConnectUpdate(cb func(Gesture, uintptr)) uint32 {
+func (x *Gesture) ConnectUpdate(cb *func(Gesture, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr) {
 		fa := Gesture{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SequenceVarp)
+		cbFn(fa, SequenceVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "update", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkgestureclick.go +45 -12

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted whenever a button or touch press happens.
-func (x *GestureClick) ConnectPressed(cb func(GestureClick, int, float64, float64)) uint32 {
+func (x *GestureClick) ConnectPressed(cb *func(GestureClick, int, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, NPressVarp int, XVarp float64, YVarp float64) {
 		fa := GestureClick{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, NPressVarp, XVarp, YVarp)
+		cbFn(fa, NPressVarp, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "pressed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
 }
 // Emitted when a button or touch is released.
 // this event, note that [signal@Gtk.GestureClick::stopped] may
 // have been emitted between the press and its release, @n_press
 // will only start over at the next press.
-func (x *GestureClick) ConnectReleased(cb func(GestureClick, int, float64, float64)) uint32 {
+func (x *GestureClick) ConnectReleased(cb *func(GestureClick, int, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "released", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, NPressVarp int, XVarp float64, YVarp float64) {
 		fa := GestureClick{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, NPressVarp, XVarp, YVarp)
+		cbFn(fa, NPressVarp, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "released", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "released", cbRefPtr)
 }
 // Emitted whenever any time/distance threshold has been exceeded.
-func (x *GestureClick) ConnectStopped(cb func(GestureClick)) uint32 {
+func (x *GestureClick) ConnectStopped(cb *func(GestureClick)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "stopped", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := GestureClick{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "stopped", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "stopped", cbRefPtr)
 }
 // Emitted whenever the gesture receives a release
 // Due to implicit grabs, this can only happen on situations
 // where input is grabbed elsewhere mid-press or the pressed
 // widget voluntarily relinquishes its implicit grab.
-func (x *GestureClick) ConnectUnpairedRelease(cb func(GestureClick, float64, float64, uint, uintptr)) uint32 {
+func (x *GestureClick) ConnectUnpairedRelease(cb *func(GestureClick, float64, float64, uint, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "unpaired-release", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64, ButtonVarp uint, SequenceVarp uintptr) {
 		fa := GestureClick{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp, ButtonVarp, SequenceVarp)
+		cbFn(fa, XVarp, YVarp, ButtonVarp, SequenceVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "unpaired-release", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "unpaired-release", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkgesturedrag.go +34 -9

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted whenever dragging starts.
-func (x *GestureDrag) ConnectDragBegin(cb func(GestureDrag, float64, float64)) uint32 {
+func (x *GestureDrag) ConnectDragBegin(cb *func(GestureDrag, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StartXVarp float64, StartYVarp float64) {
 		fa := GestureDrag{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StartXVarp, StartYVarp)
+		cbFn(fa, StartXVarp, StartYVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-begin", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
 }
 // Emitted whenever the dragging is finished.
-func (x *GestureDrag) ConnectDragEnd(cb func(GestureDrag, float64, float64)) uint32 {
+func (x *GestureDrag) ConnectDragEnd(cb *func(GestureDrag, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, OffsetXVarp float64, OffsetYVarp float64) {
 		fa := GestureDrag{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, OffsetXVarp, OffsetYVarp)
+		cbFn(fa, OffsetXVarp, OffsetYVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-end", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
 }
 // Emitted whenever the dragging point moves.
-func (x *GestureDrag) ConnectDragUpdate(cb func(GestureDrag, float64, float64)) uint32 {
+func (x *GestureDrag) ConnectDragUpdate(cb *func(GestureDrag, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "drag-update", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, OffsetXVarp float64, OffsetYVarp float64) {
 		fa := GestureDrag{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, OffsetXVarp, OffsetYVarp)
+		cbFn(fa, OffsetXVarp, OffsetYVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "drag-update", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "drag-update", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkgesturelongpress.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Emitted whenever a press moved too far, or was released
 // before [signal@Gtk.GestureLongPress::pressed] happened.
-func (x *GestureLongPress) ConnectCancelled(cb func(GestureLongPress)) uint32 {
+func (x *GestureLongPress) ConnectCancelled(cb *func(GestureLongPress)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := GestureLongPress{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cancelled", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
 }
 // Emitted whenever a press goes unmoved/unreleased longer than
 // what the GTK defaults tell.
-func (x *GestureLongPress) ConnectPressed(cb func(GestureLongPress, float64, float64)) uint32 {
+func (x *GestureLongPress) ConnectPressed(cb *func(GestureLongPress, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := GestureLongPress{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "pressed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkgesturepan.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted once a panning gesture along the expected axis is detected.
-func (x *GesturePan) ConnectPan(cb func(GesturePan, PanDirection, float64)) uint32 {
+func (x *GesturePan) ConnectPan(cb *func(GesturePan, PanDirection, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "pan", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DirectionVarp PanDirection, OffsetVarp float64) {
 		fa := GesturePan{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DirectionVarp, OffsetVarp)
+		cbFn(fa, DirectionVarp, OffsetVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "pan", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "pan", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkgesturerotate.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted when the angle between both tracked points changes.
-func (x *GestureRotate) ConnectAngleChanged(cb func(GestureRotate, float64, float64)) uint32 {
+func (x *GestureRotate) ConnectAngleChanged(cb *func(GestureRotate, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "angle-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, AngleVarp float64, AngleDeltaVarp float64) {
 		fa := GestureRotate{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, AngleVarp, AngleDeltaVarp)
+		cbFn(fa, AngleVarp, AngleDeltaVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "angle-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "angle-changed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkgesturestylus.go +45 -12

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted when the stylus touches the device.
-func (x *GestureStylus) ConnectDown(cb func(GestureStylus, float64, float64)) uint32 {
+func (x *GestureStylus) ConnectDown(cb *func(GestureStylus, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "down", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := GestureStylus{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "down", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "down", cbRefPtr)
 }
 // Emitted when the stylus moves while touching the device.
-func (x *GestureStylus) ConnectMotion(cb func(GestureStylus, float64, float64)) uint32 {
+func (x *GestureStylus) ConnectMotion(cb *func(GestureStylus, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := GestureStylus{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "motion", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
 }
 // Emitted when the stylus is in proximity of the device.
-func (x *GestureStylus) ConnectProximity(cb func(GestureStylus, float64, float64)) uint32 {
+func (x *GestureStylus) ConnectProximity(cb *func(GestureStylus, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "proximity", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := GestureStylus{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "proximity", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "proximity", cbRefPtr)
 }
 // Emitted when the stylus no longer touches the device.
-func (x *GestureStylus) ConnectUp(cb func(GestureStylus, float64, float64)) uint32 {
+func (x *GestureStylus) ConnectUp(cb *func(GestureStylus, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "up", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 		fa := GestureStylus{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, XVarp, YVarp)
+		cbFn(fa, XVarp, YVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "up", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "up", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkgestureswipe.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Emitted when the recognized gesture is finished.
 //
 // Velocity and direction are a product of previously recorded events.
-func (x *GestureSwipe) ConnectSwipe(cb func(GestureSwipe, float64, float64)) uint32 {
+func (x *GestureSwipe) ConnectSwipe(cb *func(GestureSwipe, float64, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "swipe", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, VelocityXVarp float64, VelocityYVarp float64) {
 		fa := GestureSwipe{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, VelocityXVarp, VelocityYVarp)
+		cbFn(fa, VelocityXVarp, VelocityYVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "swipe", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "swipe", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkgesturezoom.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted whenever the distance between both tracked sequences changes.
-func (x *GestureZoom) ConnectScaleChanged(cb func(GestureZoom, float64)) uint32 {
+func (x *GestureZoom) ConnectScaleChanged(cb *func(GestureZoom, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "scale-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ScaleVarp float64) {
 		fa := GestureZoom{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ScaleVarp)
+		cbFn(fa, ScaleVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "scale-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "scale-changed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkglarea.go +33 -9

 // If context creation fails then the signal handler can use
 // [method@Gtk.GLArea.set_error] to register a more detailed error
 // of how the construction failed.
-func (x *GLArea) ConnectCreateContext(cb func(GLArea) gdk.GLContext) uint32 {
+func (x *GLArea) ConnectCreateContext(cb *func(GLArea) gdk.GLContext) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "create-context", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) uintptr {
 		fa := GLArea{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		CreateContextCls := cb(fa)
+		CreateContextCls := cbFn(fa)
 		return CreateContextCls.Ptr
 	}
-	return gobject.SignalConnect(x.GoPointer(), "create-context", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "create-context", cbRefPtr)
 }
 // Emitted every time the contents of the `GtkGLArea` should be redrawn.
 //
 // The @context is bound to the @area prior to emitting this function,
 // and the buffers are painted to the window once the emission terminates.
-func (x *GLArea) ConnectRender(cb func(GLArea, uintptr) bool) uint32 {
+func (x *GLArea) ConnectRender(cb *func(GLArea, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr) bool {
 		fa := GLArea{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ContextVarp)
+		return cbFn(fa, ContextVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "render", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
 }
 // Emitted once when the widget is realized, and then each time the widget
 // is emitted.
 //
 // The default handler sets up the GL viewport.
-func (x *GLArea) ConnectResize(cb func(GLArea, int, int)) uint32 {
+func (x *GLArea) ConnectResize(cb *func(GLArea, int, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WidthVarp int, HeightVarp int) {
 		fa := GLArea{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, WidthVarp, HeightVarp)
+		cbFn(fa, WidthVarp, HeightVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "resize", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkgridview.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // This allows for a convenient way to handle activation in a gridview.
 // See [property@Gtk.ListItem:activatable] for details on how to use
 // this signal.
-func (x *GridView) ConnectActivate(cb func(GridView, uint)) uint32 {
+func (x *GridView) ConnectActivate(cb *func(GridView, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PositionVarp uint) {
 		fa := GridView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PositionVarp)
+		cbFn(fa, PositionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkicontheme.go +14 -3

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // This can happen becuase current icon theme is switched or
 // because GTK detects that a change has occurred in the
 // contents of the current icon theme.
-func (x *IconTheme) ConnectChanged(cb func(IconTheme)) uint32 {
+func (x *IconTheme) ConnectChanged(cb *func(IconTheme)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IconTheme{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 var xIconThemeGetForDisplay func(uintptr) uintptr

M v4/gtk/gtkiconview.go +94 -28

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
 // Calls a function for each selected icon. Note that the model or
 // selection cannot be modified from within this function.
-func (x *IconView) SelectedForeach(FuncVar IconViewForeachFunc, DataVar uintptr) {
+func (x *IconView) SelectedForeach(FuncVar *IconViewForeachFunc, DataVar uintptr) {
-	xIconViewSelectedForeach(x.GoPointer(), purego.NewCallback(FuncVar), DataVar)
+	xIconViewSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
 }
 // programmatically.
 //
 // The default bindings for this signal are Space, Return and Enter.
-func (x *IconView) ConnectActivateCursorItem(cb func(IconView) bool) uint32 {
+func (x *IconView) ConnectActivateCursorItem(cb *func(IconView) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-cursor-item", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := IconView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-item", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-item", cbRefPtr)
 }
 // The ::item-activated signal is emitted when the method
 // "activate-on-single-click" property set to %TRUE. It is also
 // emitted when a non-editable item is selected and one of the keys:
 // Space, Return or Enter is pressed.
-func (x *IconView) ConnectItemActivated(cb func(IconView, uintptr)) uint32 {
+func (x *IconView) ConnectItemActivated(cb *func(IconView, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "item-activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathVarp uintptr) {
 		fa := IconView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PathVarp)
+		cbFn(fa, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "item-activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "item-activated", cbRefPtr)
 }
 // The ::move-cursor signal is a
 // - PageUp/PageDown which move by "pages"
 // All of these will extend the selection when combined with
 // the Shift modifier.
-func (x *IconView) ConnectMoveCursor(cb func(IconView, MovementStep, int, bool, bool) bool) uint32 {
+func (x *IconView) ConnectMoveCursor(cb *func(IconView, MovementStep, int, bool, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool, ModifyVarp bool) bool {
 		fa := IconView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, StepVarp, CountVarp, ExtendVarp, ModifyVarp)
+		return cbFn(fa, StepVarp, CountVarp, ExtendVarp, ModifyVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
 }
 // A [keybinding signal][class@Gtk.SignalAction]
 // programmatically.
 //
 // The default binding for this signal is Ctrl-a.
-func (x *IconView) ConnectSelectAll(cb func(IconView)) uint32 {
+func (x *IconView) ConnectSelectAll(cb *func(IconView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IconView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
 }
 // A [keybinding signal][class@Gtk.SignalAction]
 // programmatically.
 //
 // There is no default binding for this signal.
-func (x *IconView) ConnectSelectCursorItem(cb func(IconView)) uint32 {
+func (x *IconView) ConnectSelectCursorItem(cb *func(IconView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-cursor-item", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IconView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-cursor-item", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-cursor-item", cbRefPtr)
 }
 // The ::selection-changed signal is emitted when the selection
 // (i.e. the set of selected items) changes.
-func (x *IconView) ConnectSelectionChanged(cb func(IconView)) uint32 {
+func (x *IconView) ConnectSelectionChanged(cb *func(IconView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "selection-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IconView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "selection-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "selection-changed", cbRefPtr)
 }
 // A [keybinding signal][class@Gtk.SignalAction]
 // programmatically.
 //
 // There is no default binding for this signal is Ctrl-Space.
-func (x *IconView) ConnectToggleCursorItem(cb func(IconView)) uint32 {
+func (x *IconView) ConnectToggleCursorItem(cb *func(IconView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-item", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IconView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-item", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-item", cbRefPtr)
 }
 // A [keybinding signal][class@Gtk.SignalAction]
 // programmatically.
 //
 // The default binding for this signal is Ctrl-Shift-a.
-func (x *IconView) ConnectUnselectAll(cb func(IconView)) uint32 {
+func (x *IconView) ConnectUnselectAll(cb *func(IconView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IconView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "unselect-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.
 // cell renderer(s) as appropriate.
 //
 // @func may be %NULL to remove a previously set function.
-func (x *IconView) SetCellDataFunc(CellVar *CellRenderer, FuncVar CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *IconView) SetCellDataFunc(CellVar *CellRenderer, FuncVar *CellLayoutDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))
+	XGtkCellLayoutSetCellDataFunc(x.GoPointer(), CellVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
 }

M v4/gtk/gtkimcontext.go +67 -18

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/pango"
 )
 //
 // This can be a single character immediately after a key press or
 // the final result of preediting.
-func (x *IMContext) ConnectCommit(cb func(IMContext, string)) uint32 {
+func (x *IMContext) ConnectCommit(cb *func(IMContext, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "commit", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StrVarp string) {
 		fa := IMContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StrVarp)
+		cbFn(fa, StrVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "commit", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "commit", cbRefPtr)
 }
 // The ::delete-surrounding signal is emitted when the input method
 // needs to delete all or part of the context surrounding the cursor.
-func (x *IMContext) ConnectDeleteSurrounding(cb func(IMContext, int, int) bool) uint32 {
+func (x *IMContext) ConnectDeleteSurrounding(cb *func(IMContext, int, int) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "delete-surrounding", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, OffsetVarp int, NCharsVarp int) bool {
 		fa := IMContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, OffsetVarp, NCharsVarp)
+		return cbFn(fa, OffsetVarp, NCharsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "delete-surrounding", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "delete-surrounding", cbRefPtr)
 }
 // The ::preedit-changed signal is emitted whenever the preedit sequence
 //
 // It is also emitted at the end of a preedit sequence, in which case
 // [method@Gtk.IMContext.get_preedit_string] returns the empty string.
-func (x *IMContext) ConnectPreeditChanged(cb func(IMContext)) uint32 {
+func (x *IMContext) ConnectPreeditChanged(cb *func(IMContext)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IMContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
 }
 // The ::preedit-end signal is emitted when a preediting sequence
 // has been completed or canceled.
-func (x *IMContext) ConnectPreeditEnd(cb func(IMContext)) uint32 {
+func (x *IMContext) ConnectPreeditEnd(cb *func(IMContext)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "preedit-end", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IMContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "preedit-end", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "preedit-end", cbRefPtr)
 }
 // The ::preedit-start signal is emitted when a new preediting sequence
 // starts.
-func (x *IMContext) ConnectPreeditStart(cb func(IMContext)) uint32 {
+func (x *IMContext) ConnectPreeditStart(cb *func(IMContext)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "preedit-start", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := IMContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "preedit-start", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "preedit-start", cbRefPtr)
 }
 // The ::retrieve-surrounding signal is emitted when the input method
 //
 // The callback should set the input method surrounding context by
 // calling the [method@Gtk.IMContext.set_surrounding] method.
-func (x *IMContext) ConnectRetrieveSurrounding(cb func(IMContext) bool) uint32 {
+func (x *IMContext) ConnectRetrieveSurrounding(cb *func(IMContext) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "retrieve-surrounding", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := IMContext{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "retrieve-surrounding", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "retrieve-surrounding", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkinfobar.go +25 -6

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // The ::close signal is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is the Escape key.
-func (x *InfoBar) ConnectClose(cb func(InfoBar)) uint32 {
+func (x *InfoBar) ConnectClose(cb *func(InfoBar)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := InfoBar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "close", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
 }
 // Emitted when an action widget is clicked.
 // The signal is also emitted when the application programmer
 // calls [method@Gtk.InfoBar.response]. The @response_id depends
 // on which action widget was clicked.
-func (x *InfoBar) ConnectResponse(cb func(InfoBar, int)) uint32 {
+func (x *InfoBar) ConnectResponse(cb *func(InfoBar, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ResponseIdVarp int) {
 		fa := InfoBar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ResponseIdVarp)
+		cbFn(fa, ResponseIdVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "response", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtklabel.go +47 -12

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/pango"
 )
 // if they need to control activation of URIs programmatically.
 //
 // The default bindings for this signal are all forms of the Enter key.
-func (x *Label) ConnectActivateCurrentLink(cb func(Label)) uint32 {
+func (x *Label) ConnectActivateCurrentLink(cb *func(Label)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-current-link", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Label{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-current-link", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-current-link", cbRefPtr)
 }
 // Gets emitted to activate a URI.
 //
 // Applications may connect to it to override the default behaviour,
 // which is to call gtk_show_uri().
-func (x *Label) ConnectActivateLink(cb func(Label, string) bool) uint32 {
+func (x *Label) ConnectActivateLink(cb *func(Label, string) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, UriVarp string) bool {
 		fa := Label{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, UriVarp)
+		return cbFn(fa, UriVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
 }
 // Gets emitted to copy the slection to the clipboard.
 // The ::copy-clipboard signal is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is Ctrl-c.
-func (x *Label) ConnectCopyClipboard(cb func(Label)) uint32 {
+func (x *Label) ConnectCopyClipboard(cb *func(Label)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Label{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
 }
 // Gets emitted when the user initiates a cursor movement.
 // - Arrow keys move by individual characters/lines
 // - Ctrl-arrow key combinations move by words/paragraphs
 // - Home/End keys move to the ends of the buffer
-func (x *Label) ConnectMoveCursor(cb func(Label, MovementStep, int, bool)) uint32 {
+func (x *Label) ConnectMoveCursor(cb *func(Label, MovementStep, int, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendSelectionVarp bool) {
 		fa := Label{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StepVarp, CountVarp, ExtendSelectionVarp)
+		cbFn(fa, StepVarp, CountVarp, ExtendSelectionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtklevelbar.go +14 -3

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // The signal supports detailed connections; you can connect to the
 // detailed signal "changed::x" in order to only receive callbacks when
 // the value of offset "x" changes.
-func (x *LevelBar) ConnectOffsetChanged(cb func(LevelBar, string)) uint32 {
+func (x *LevelBar) ConnectOffsetChanged(cb *func(LevelBar, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "offset-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, NameVarp string) {
 		fa := LevelBar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, NameVarp)
+		cbFn(fa, NameVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "offset-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "offset-changed", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtklinkbutton.go +13 -3

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 // To override the default behavior, you can connect to the
 // ::activate-link signal and stop the propagation of the signal
 // by returning %TRUE from your handler.
-func (x *LinkButton) ConnectActivateLink(cb func(LinkButton) bool) uint32 {
+func (x *LinkButton) ConnectActivateLink(cb *func(LinkButton) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := LinkButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtklistbox.go +109 -37

 // Note that using a model is incompatible with the filtering and sorting
 // functionality in `GtkListBox`. When using a model, filtering and sorting
 // should be implemented by the model.
-func (x *ListBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) {
+func (x *ListBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
-	xListBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), purego.NewCallback(CreateWidgetFuncVar), UserDataVar, purego.NewCallback(UserDataFreeFuncVar))
+	xListBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), glib.NewCallback(CreateWidgetFuncVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
 }
 // Calls a function for each selected child.
 //
 // Note that the selection cannot be modified from within this function.
-func (x *ListBox) SelectedForeach(FuncVar ListBoxForeachFunc, DataVar uintptr) {
+func (x *ListBox) SelectedForeach(FuncVar *ListBoxForeachFunc, DataVar uintptr) {
-	xListBoxSelectedForeach(x.GoPointer(), purego.NewCallback(FuncVar), DataVar)
+	xListBoxSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
 }
 //
 // Note that using a filter function is incompatible with using a model
 // (see [method@Gtk.ListBox.bind_model]).
-func (x *ListBox) SetFilterFunc(FilterFuncVar ListBoxFilterFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *ListBox) SetFilterFunc(FilterFuncVar *ListBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xListBoxSetFilterFunc(x.GoPointer(), purego.NewCallback(FilterFuncVar), UserDataVar, purego.NewCallback(DestroyVar))
+	xListBoxSetFilterFunc(x.GoPointer(), glib.NewCallback(FilterFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
 }
 // by [method@Gtk.ListBoxRow.changed] on the previous row, or when the previous
 // row becomes a different row). It is also called for all rows when
 // [method@Gtk.ListBox.invalidate_headers] is called.
-func (x *ListBox) SetHeaderFunc(UpdateHeaderVar ListBoxUpdateHeaderFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *ListBox) SetHeaderFunc(UpdateHeaderVar *ListBoxUpdateHeaderFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xListBoxSetHeaderFunc(x.GoPointer(), purego.NewCallback(UpdateHeaderVar), UserDataVar, purego.NewCallback(DestroyVar))
+	xListBoxSetHeaderFunc(x.GoPointer(), glib.NewCallback(UpdateHeaderVar), UserDataVar, glib.NewCallback(DestroyVar))
 }
 //
 // Note that using a sort function is incompatible with using a model
 // (see [method@Gtk.ListBox.bind_model]).
-func (x *ListBox) SetSortFunc(SortFuncVar ListBoxSortFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *ListBox) SetSortFunc(SortFuncVar *ListBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xListBoxSetSortFunc(x.GoPointer(), purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))
+	xListBoxSetSortFunc(x.GoPointer(), glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
 }
 	c.Ptr = ptr
 }
-func (x *ListBox) ConnectActivateCursorRow(cb func(ListBox)) uint32 {
+func (x *ListBox) ConnectActivateCursorRow(cb *func(ListBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-cursor-row", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ListBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-row", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-row", cbRefPtr)
 }
-func (x *ListBox) ConnectMoveCursor(cb func(ListBox, MovementStep, int, bool, bool)) uint32 {
+func (x *ListBox) ConnectMoveCursor(cb *func(ListBox, MovementStep, int, bool, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp MovementStep, P0Varp int, P1Varp bool, P2Varp bool) {
 		fa := ListBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ObjectVarp, P0Varp, P1Varp, P2Varp)
+		cbFn(fa, ObjectVarp, P0Varp, P1Varp, P2Varp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
 }
 // Emitted when a row has been activated by the user.
-func (x *ListBox) ConnectRowActivated(cb func(ListBox, uintptr)) uint32 {
+func (x *ListBox) ConnectRowActivated(cb *func(ListBox, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, RowVarp uintptr) {
 		fa := ListBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, RowVarp)
+		cbFn(fa, RowVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "row-activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
 }
 // Emitted when a new row is selected, or (with a %NULL @row)
 // When the @box is using %GTK_SELECTION_MULTIPLE, this signal will not
 // give you the full picture of selection changes, and you should use
 // the [signal@Gtk.ListBox::selected-rows-changed] signal instead.
-func (x *ListBox) ConnectRowSelected(cb func(ListBox, uintptr)) uint32 {
+func (x *ListBox) ConnectRowSelected(cb *func(ListBox, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "row-selected", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, RowVarp uintptr) {
 		fa := ListBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, RowVarp)
+		cbFn(fa, RowVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "row-selected", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "row-selected", cbRefPtr)
 }
 // Emitted to select all children of the box, if the selection
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt;.
-func (x *ListBox) ConnectSelectAll(cb func(ListBox)) uint32 {
+func (x *ListBox) ConnectSelectAll(cb *func(ListBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ListBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
 }
 // Emitted when the set of selected rows changes.
-func (x *ListBox) ConnectSelectedRowsChanged(cb func(ListBox)) uint32 {
+func (x *ListBox) ConnectSelectedRowsChanged(cb *func(ListBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "selected-rows-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ListBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "selected-rows-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "selected-rows-changed", cbRefPtr)
 }
-func (x *ListBox) ConnectToggleCursorRow(cb func(ListBox)) uint32 {
+func (x *ListBox) ConnectToggleCursorRow(cb *func(ListBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ListBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
 }
 // Emitted to unselect all children of the box, if the selection
 //
 // The default binding for this signal is
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt;.
-func (x *ListBox) ConnectUnselectAll(cb func(ListBox)) uint32 {
+func (x *ListBox) ConnectUnselectAll(cb *func(ListBox)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ListBox{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "unselect-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.
 // If you want to be notified when the user activates a row (by key or not),
 // use the [signal@Gtk.ListBox::row-activated] signal on the row’s parent
 // `GtkListBox`.
-func (x *ListBoxRow) ConnectActivate(cb func(ListBoxRow)) uint32 {
+func (x *ListBoxRow) ConnectActivate(cb *func(ListBoxRow)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ListBoxRow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkliststore.go +6 -6


@@ -566,9 +566,9 @@ func (x ListStore) FilterNew(RootVar TreePath) *TreeModelBase {
566		//	566		//
567		// If @func returns %TRUE, then the tree ceases to be walked,	567		// If @func returns %TRUE, then the tree ceases to be walked,
568		// and gtk_tree_model_foreach() returns.	568		// and gtk_tree_model_foreach() returns.
569	-	func (x *ListStore) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {	569	+	func (x ListStore) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {
570			570
571	-	XGtkTreeModelForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	571	+	XGtkTreeModelForeach(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar)
572			572
573		}	573		}
574			574

@@ -900,9 +900,9 @@ func (x *ListStore) HasDefaultSortFunc() bool {
900		// This means that once the model has been sorted, it can’t go back to the	900		// This means that once the model has been sorted, it can’t go back to the
901		// default state. In this case, when the current sort column id of @sortable	901		// default state. In this case, when the current sort column id of @sortable
902		// is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.	902		// is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
903	-	func (x *ListStore) SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	903	+	func (x ListStore) SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
904			904
905	-	XGtkTreeSortableSetDefaultSortFunc(x.GoPointer(), purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	905	+	XGtkTreeSortableSetDefaultSortFunc(x.GoPointer(), glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
906			906
907		}	907		}
908			908

@@ -924,9 +924,9 @@ func (x *ListStore) SetSortColumnId(SortColumnIdVar int, OrderVar SortType) {
924		// Sets the comparison function used when sorting to be @sort_func. If the	924		// Sets the comparison function used when sorting to be @sort_func. If the
925		// current sort column id of @sortable is the same as @sort_column_id, then	925		// current sort column id of @sortable is the same as @sort_column_id, then
926		// the model will sort using this function.	926		// the model will sort using this function.
927	-	func (x *ListStore) SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	927	+	func (x ListStore) SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
928			928
929	-	XGtkTreeSortableSetSortFunc(x.GoPointer(), SortColumnIdVar, purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	929	+	XGtkTreeSortableSetSortFunc(x.GoPointer(), SortColumnIdVar, glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
930			930
931		}	931		}
932			932

M v4/gtk/gtklistview.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // This allows for a convenient way to handle activation in a listview.
 // See [method@Gtk.ListItem.set_activatable] for details on how to use
 // this signal.
-func (x *ListView) ConnectActivate(cb func(ListView, uint)) uint32 {
+func (x *ListView) ConnectActivate(cb *func(ListView, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PositionVarp uint) {
 		fa := ListView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PositionVarp)
+		cbFn(fa, PositionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkmaplistmodel.go +4 -4


@@ -71,10 +71,10 @@ func MapListModelNewFromInternalPtr(ptr uintptr) *MapListModel {
71		var xNewMapListModel func(uintptr, uintptr, uintptr, uintptr) uintptr	71		var xNewMapListModel func(uintptr, uintptr, uintptr, uintptr) uintptr
72			72
73		// Creates a new `GtkMapListModel` for the given arguments.	73		// Creates a new `GtkMapListModel` for the given arguments.
74	-	func NewMapListModel(ModelVar gio.ListModel, MapFuncVar MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *MapListModel {	74	+	func NewMapListModel(ModelVar gio.ListModel, MapFuncVar MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *MapListModel {
75		var cls *MapListModel	75		var cls *MapListModel
76			76
77	-	cret := xNewMapListModel(ModelVar.GoPointer(), purego.NewCallback(MapFuncVar), UserDataVar, purego.NewCallback(UserDestroyVar))	77	+	cret := xNewMapListModel(ModelVar.GoPointer(), glib.NewCallback(MapFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
78			78
79		if cret == 0 {	79		if cret == 0 {
80		return nil	80		return nil

@@ -123,9 +123,9 @@ var xMapListModelSetMapFunc func(uintptr, uintptr, uintptr, uintptr)
123		// GTK makes no effort to ensure that @map_func conforms to the item type	123		// GTK makes no effort to ensure that @map_func conforms to the item type
124		// of @self. It assumes that the caller knows what they are doing and the map	124		// of @self. It assumes that the caller knows what they are doing and the map
125		// function returns items of the appropriate type.	125		// function returns items of the appropriate type.
126	-	func (x *MapListModel) SetMapFunc(MapFuncVar MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) {	126	+	func (x MapListModel) SetMapFunc(MapFuncVar MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
127			127
128	-	xMapListModelSetMapFunc(x.GoPointer(), purego.NewCallback(MapFuncVar), UserDataVar, purego.NewCallback(UserDestroyVar))	128	+	xMapListModelSetMapFunc(x.GoPointer(), glib.NewCallback(MapFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
129			129
130		}	130		}
131			131

M v4/gtk/gtkmenubutton.go +15 -5

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
 //
 // Using this function will not reset the menu widget attached to
 // @menu_button. Instead, this can be done manually in @func.
-func (x *MenuButton) SetCreatePopupFunc(FuncVar MenuButtonCreatePopupFunc, UserDataVar uintptr, DestroyNotifyVar glib.DestroyNotify) {
+func (x *MenuButton) SetCreatePopupFunc(FuncVar *MenuButtonCreatePopupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
-	xMenuButtonSetCreatePopupFunc(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar, purego.NewCallback(DestroyNotifyVar))
+	xMenuButtonSetCreatePopupFunc(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallback(DestroyNotifyVar))
 }
 //
 // The `::activate` signal on `GtkMenuButton` is an action signal and
 // emitting it causes the button to pop up its menu.
-func (x *MenuButton) ConnectActivate(cb func(MenuButton)) uint32 {
+func (x *MenuButton) ConnectActivate(cb *func(MenuButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := MenuButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtknativedialog.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // If you call [method@Gtk.NativeDialog.hide] before the user
 // responds to the dialog this signal will not be emitted.
-func (x *NativeDialog) ConnectResponse(cb func(NativeDialog, int)) uint32 {
+func (x *NativeDialog) ConnectResponse(cb *func(NativeDialog, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ResponseIdVarp int) {
 		fa := NativeDialog{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ResponseIdVarp)
+		cbFn(fa, ResponseIdVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "response", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
 }
 func init() {

M v4/gtk/gtknotebook.go +113 -30

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 	c.Ptr = ptr
 }
-func (x *Notebook) ConnectChangeCurrentPage(cb func(Notebook, int) bool) uint32 {
+func (x *Notebook) ConnectChangeCurrentPage(cb *func(Notebook, int) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp int) bool {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ObjectVarp)
+		return cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "change-current-page", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
 }
 // The ::create-window signal is emitted when a detachable
 // responsible for moving/resizing the window and adding the
 // necessary properties to the notebook (e.g. the
 // `GtkNotebook`:group-name ).
-func (x *Notebook) ConnectCreateWindow(cb func(Notebook, uintptr) Notebook) uint32 {
+func (x *Notebook) ConnectCreateWindow(cb *func(Notebook, uintptr) Notebook) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) uintptr {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		CreateWindowCls := cb(fa, PageVarp)
+		CreateWindowCls := cbFn(fa, PageVarp)
 		return CreateWindowCls.Ptr
 	}
-	return gobject.SignalConnect(x.GoPointer(), "create-window", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
 }
-func (x *Notebook) ConnectFocusTab(cb func(Notebook, NotebookTab) bool) uint32 {
+func (x *Notebook) ConnectFocusTab(cb *func(Notebook, NotebookTab) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "focus-tab", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp NotebookTab) bool {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ObjectVarp)
+		return cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "focus-tab", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "focus-tab", cbRefPtr)
 }
-func (x *Notebook) ConnectMoveFocusOut(cb func(Notebook, DirectionType)) uint32 {
+func (x *Notebook) ConnectMoveFocusOut(cb *func(Notebook, DirectionType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp DirectionType) {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ObjectVarp)
+		cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-focus-out", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
 }
 // the ::page-added signal is emitted in the notebook
 // right after a page is added to the notebook.
-func (x *Notebook) ConnectPageAdded(cb func(Notebook, uintptr, uint)) uint32 {
+func (x *Notebook) ConnectPageAdded(cb *func(Notebook, uintptr, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "page-added", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ChildVarp uintptr, PageNumVarp uint) {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ChildVarp, PageNumVarp)
+		cbFn(fa, ChildVarp, PageNumVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "page-added", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "page-added", cbRefPtr)
 }
 // the ::page-removed signal is emitted in the notebook
 // right after a page is removed from the notebook.
-func (x *Notebook) ConnectPageRemoved(cb func(Notebook, uintptr, uint)) uint32 {
+func (x *Notebook) ConnectPageRemoved(cb *func(Notebook, uintptr, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "page-removed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ChildVarp uintptr, PageNumVarp uint) {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ChildVarp, PageNumVarp)
+		cbFn(fa, ChildVarp, PageNumVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "page-removed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "page-removed", cbRefPtr)
 }
 // the ::page-reordered signal is emitted in the notebook
 // right after a page has been reordered.
-func (x *Notebook) ConnectPageReordered(cb func(Notebook, uintptr, uint)) uint32 {
+func (x *Notebook) ConnectPageReordered(cb *func(Notebook, uintptr, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ChildVarp uintptr, PageNumVarp uint) {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ChildVarp, PageNumVarp)
+		cbFn(fa, ChildVarp, PageNumVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "page-reordered", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
 }
-func (x *Notebook) ConnectReorderTab(cb func(Notebook, DirectionType, bool) bool) uint32 {
+func (x *Notebook) ConnectReorderTab(cb *func(Notebook, DirectionType, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "reorder-tab", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp DirectionType, P0Varp bool) bool {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ObjectVarp, P0Varp)
+		return cbFn(fa, ObjectVarp, P0Varp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "reorder-tab", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "reorder-tab", cbRefPtr)
 }
-func (x *Notebook) ConnectSelectPage(cb func(Notebook, bool) bool) uint32 {
+func (x *Notebook) ConnectSelectPage(cb *func(Notebook, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-page", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp bool) bool {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ObjectVarp)
+		return cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-page", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-page", cbRefPtr)
 }
 // Emitted when the user or a function changes the current page.
-func (x *Notebook) ConnectSwitchPage(cb func(Notebook, uintptr, uint)) uint32 {
+func (x *Notebook) ConnectSwitchPage(cb *func(Notebook, uintptr, uint)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "switch-page", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, PageNumVarp uint) {
 		fa := Notebook{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PageVarp, PageNumVarp)
+		cbFn(fa, PageVarp, PageNumVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "switch-page", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "switch-page", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkoverlay.go +14 -3

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // be full-width/height). If the main child is a
 // `GtkScrolledWindow`, the overlays are placed relative
 // to its contents.
-func (x *Overlay) ConnectGetChildPosition(cb func(Overlay, uintptr, uintptr) bool) uint32 {
+func (x *Overlay) ConnectGetChildPosition(cb *func(Overlay, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "get-child-position", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WidgetVarp uintptr, AllocationVarp uintptr) bool {
 		fa := Overlay{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, WidgetVarp, AllocationVarp)
+		return cbFn(fa, WidgetVarp, AllocationVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "get-child-position", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "get-child-position", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkpaned.go +69 -18

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // The default binding for this signal is &lt;kbd&gt;Return&lt;/kbd&gt; or
 // &lt;kbd&gt;Space&lt;/kbd&gt;.
-func (x *Paned) ConnectAcceptPosition(cb func(Paned) bool) uint32 {
+func (x *Paned) ConnectAcceptPosition(cb *func(Paned) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "accept-position", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := Paned{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "accept-position", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "accept-position", cbRefPtr)
 }
 // Emitted to cancel moving the position of the handle using key
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;Escape&lt;/kbd&gt;.
-func (x *Paned) ConnectCancelPosition(cb func(Paned) bool) uint32 {
+func (x *Paned) ConnectCancelPosition(cb *func(Paned) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cancel-position", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := Paned{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cancel-position", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cancel-position", cbRefPtr)
 }
 // Emitted to cycle the focus between the children of the paned.
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding is &lt;kbd&gt;F6&lt;/kbd&gt;.
-func (x *Paned) ConnectCycleChildFocus(cb func(Paned, bool) bool) uint32 {
+func (x *Paned) ConnectCycleChildFocus(cb *func(Paned, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cycle-child-focus", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ReversedVarp bool) bool {
 		fa := Paned{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ReversedVarp)
+		return cbFn(fa, ReversedVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cycle-child-focus", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cycle-child-focus", cbRefPtr)
 }
 // Emitted to cycle whether the paned should grab focus to allow
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;F8&lt;/kbd&gt;.
-func (x *Paned) ConnectCycleHandleFocus(cb func(Paned, bool) bool) uint32 {
+func (x *Paned) ConnectCycleHandleFocus(cb *func(Paned, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cycle-handle-focus", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ReversedVarp bool) bool {
 		fa := Paned{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ReversedVarp)
+		return cbFn(fa, ReversedVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cycle-handle-focus", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cycle-handle-focus", cbRefPtr)
 }
 // Emitted to move the handle with key bindings.
 //
 // This is a [keybinding signal](class.SignalAction.html).
-func (x *Paned) ConnectMoveHandle(cb func(Paned, ScrollType) bool) uint32 {
+func (x *Paned) ConnectMoveHandle(cb *func(Paned, ScrollType) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-handle", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ScrollTypeVarp ScrollType) bool {
 		fa := Paned{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ScrollTypeVarp)
+		return cbFn(fa, ScrollTypeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-handle", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-handle", cbRefPtr)
 }
 // Emitted to accept the current position of the handle and then
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding is &lt;kbd&gt;Tab&lt;/kbd&gt;.
-func (x *Paned) ConnectToggleHandleFocus(cb func(Paned) bool) uint32 {
+func (x *Paned) ConnectToggleHandleFocus(cb *func(Paned) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggle-handle-focus", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := Paned{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggle-handle-focus", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggle-handle-focus", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkpasswordentry.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Emitted when the entry is activated.
 //
 // The keybindings for this signal are all forms of the Enter key.
-func (x *PasswordEntry) ConnectActivate(cb func(PasswordEntry)) uint32 {
+func (x *PasswordEntry) ConnectActivate(cb *func(PasswordEntry)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := PasswordEntry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkpopover.go +23 -6

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gsk"
 )
 // Emitted whend the user activates the default widget.
 //
 // This is a [keybinding signal](class.SignalAction.html).
-func (x *Popover) ConnectActivateDefault(cb func(Popover)) uint32 {
+func (x *Popover) ConnectActivateDefault(cb *func(Popover)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Popover{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-default", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
 }
 // Emitted when the popover is closed.
-func (x *Popover) ConnectClosed(cb func(Popover)) uint32 {
+func (x *Popover) ConnectClosed(cb *func(Popover)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Popover{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "closed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkprinter.go +13 -5

 // Calls a function for all `GtkPrinter`s.
 //
 // If @func returns %TRUE, the enumeration is stopped.
-func EnumeratePrinters(FuncVar PrinterFunc, DataVar uintptr, DestroyVar glib.DestroyNotify, WaitVar bool) {
+func EnumeratePrinters(FuncVar *PrinterFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify, WaitVar bool) {
-	xEnumeratePrinters(purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DestroyVar), WaitVar)
+	xEnumeratePrinters(glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DestroyVar), WaitVar)
 }
 //
 // The @success parameter indicates if the information was
 // actually obtained.
-func (x *Printer) ConnectDetailsAcquired(cb func(Printer, bool)) uint32 {
+func (x *Printer) ConnectDetailsAcquired(cb *func(Printer, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "details-acquired", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SuccessVarp bool) {
 		fa := Printer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SuccessVarp)
+		cbFn(fa, SuccessVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "details-acquired", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "details-acquired", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkprintjob.go +15 -5

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/cairo"
 var xPrintJobSend func(uintptr, uintptr, uintptr, uintptr)
 // Sends the print job off to the printer.
-func (x *PrintJob) Send(CallbackVar PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar glib.DestroyNotify) {
+func (x *PrintJob) Send(CallbackVar *PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar *glib.DestroyNotify) {
-	xPrintJobSend(x.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, purego.NewCallback(DnotifyVar))
+	xPrintJobSend(x.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(DnotifyVar))
 }
 //
 // The signal handler can use [method@Gtk.PrintJob.get_status]
 // to obtain the new status.
-func (x *PrintJob) ConnectStatusChanged(cb func(PrintJob)) uint32 {
+func (x *PrintJob) ConnectStatusChanged(cb *func(PrintJob)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := PrintJob{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "status-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkprintoperation.go +123 -35

 // In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
 // showing the page setup dialog on platforms that support this, and calls @done_cb
 // from a signal handler for the ::response signal of the dialog.
-func PrintRunPageSetupDialogAsync(ParentVar *Window, PageSetupVar *PageSetup, SettingsVar *PrintSettings, DoneCbVar PageSetupDoneFunc, DataVar uintptr) {
+func PrintRunPageSetupDialogAsync(ParentVar *Window, PageSetupVar *PageSetup, SettingsVar *PrintSettings, DoneCbVar *PageSetupDoneFunc, DataVar uintptr) {
-	xPrintRunPageSetupDialogAsync(ParentVar.GoPointer(), PageSetupVar.GoPointer(), SettingsVar.GoPointer(), purego.NewCallback(DoneCbVar), DataVar)
+	xPrintRunPageSetupDialogAsync(ParentVar.GoPointer(), PageSetupVar.GoPointer(), SettingsVar.GoPointer(), glib.NewCallback(DoneCbVar), DataVar)
 }
 // [class@Gtk.PrintContext] and paginate the document accordingly,
 // and then set the number of pages with
 // [method@Gtk.PrintOperation.set_n_pages].
-func (x *PrintOperation) ConnectBeginPrint(cb func(PrintOperation, uintptr)) uint32 {
+func (x *PrintOperation) ConnectBeginPrint(cb *func(PrintOperation, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "begin-print", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr) {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ContextVarp)
+		cbFn(fa, ContextVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "begin-print", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "begin-print", cbRefPtr)
 }
 // Emitted when displaying the print dialog.
 // to stay around until the [signal@Gtk.PrintOperation::custom-widget-apply]
 // signal is emitted on the operation. Then you can read out any
 // information you need from the widgets.
-func (x *PrintOperation) ConnectCreateCustomWidget(cb func(PrintOperation) gobject.Object) uint32 {
+func (x *PrintOperation) ConnectCreateCustomWidget(cb *func(PrintOperation) gobject.Object) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "create-custom-widget", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) uintptr {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		CreateCustomWidgetCls := cb(fa)
+		CreateCustomWidgetCls := cbFn(fa)
 		return CreateCustomWidgetCls.Ptr
 	}
-	return gobject.SignalConnect(x.GoPointer(), "create-custom-widget", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "create-custom-widget", cbRefPtr)
 }
 // Emitted right before ::begin-print if you added
 // When you get this signal you should read the information from the
 // custom widgets, as the widgets are not guaranteed to be around at a
 // later time.
-func (x *PrintOperation) ConnectCustomWidgetApply(cb func(PrintOperation, uintptr)) uint32 {
+func (x *PrintOperation) ConnectCustomWidgetApply(cb *func(PrintOperation, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "custom-widget-apply", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WidgetVarp uintptr) {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, WidgetVarp)
+		cbFn(fa, WidgetVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "custom-widget-apply", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "custom-widget-apply", cbRefPtr)
 }
 // Emitted when the print operation run has finished doing
 // If you enabled print status tracking then
 // [method@Gtk.PrintOperation.is_finished] may still return %FALSE
 // after the ::done signal was emitted.
-func (x *PrintOperation) ConnectDone(cb func(PrintOperation, PrintOperationResult)) uint32 {
+func (x *PrintOperation) ConnectDone(cb *func(PrintOperation, PrintOperationResult)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ResultVarp PrintOperationResult) {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ResultVarp)
+		cbFn(fa, ResultVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "done", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
 }
 // Emitted for every page that is printed.
 // [method@Gtk.PrintOperation.set_unit] before starting the print
 // operation to set up the transformation of the cairo context
 // according to your needs.
-func (x *PrintOperation) ConnectDrawPage(cb func(PrintOperation, uintptr, int)) uint32 {
+func (x *PrintOperation) ConnectDrawPage(cb *func(PrintOperation, uintptr, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "draw-page", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr, PageNrVarp int) {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ContextVarp, PageNrVarp)
+		cbFn(fa, ContextVarp, PageNrVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "draw-page", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "draw-page", cbRefPtr)
 }
 // Emitted after all pages have been rendered.
 //
 // A handler for this signal can clean up any resources that have
 // been allocated in the [signal@Gtk.PrintOperation::begin-print] handler.
-func (x *PrintOperation) ConnectEndPrint(cb func(PrintOperation, uintptr)) uint32 {
+func (x *PrintOperation) ConnectEndPrint(cb *func(PrintOperation, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "end-print", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr) {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ContextVarp)
+		cbFn(fa, ContextVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "end-print", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "end-print", cbRefPtr)
 }
 // Emitted after the ::begin-print signal, but before the actual rendering
 // If you don't need to do pagination in chunks, you can simply do
 // it all in the ::begin-print handler, and set the number of pages
 // from there.
-func (x *PrintOperation) ConnectPaginate(cb func(PrintOperation, uintptr) bool) uint32 {
+func (x *PrintOperation) ConnectPaginate(cb *func(PrintOperation, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "paginate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr) bool {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ContextVarp)
+		return cbFn(fa, ContextVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "paginate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "paginate", cbRefPtr)
 }
 // Gets emitted when a preview is requested from the native dialog.
 // are selected for print and render them. The preview must be
 // finished by calling [method@Gtk.PrintOperationPreview.end_preview]
 // (typically in response to the user clicking a close button).
-func (x *PrintOperation) ConnectPreview(cb func(PrintOperation, uintptr, uintptr, uintptr) bool) uint32 {
+func (x *PrintOperation) ConnectPreview(cb *func(PrintOperation, uintptr, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "preview", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PreviewVarp uintptr, ContextVarp uintptr, ParentVarp uintptr) bool {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, PreviewVarp, ContextVarp, ParentVarp)
+		return cbFn(fa, PreviewVarp, ContextVarp, ParentVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "preview", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "preview", cbRefPtr)
 }
 // Emitted once for every page that is printed.
 // This gives the application a chance to modify the page setup.
 // Any changes done to @setup will be in force only for printing
 // this page.
-func (x *PrintOperation) ConnectRequestPageSetup(cb func(PrintOperation, uintptr, int, uintptr)) uint32 {
+func (x *PrintOperation) ConnectRequestPageSetup(cb *func(PrintOperation, uintptr, int, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "request-page-setup", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr, PageNrVarp int, SetupVarp uintptr) {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ContextVarp, PageNrVarp, SetupVarp)
+		cbFn(fa, ContextVarp, PageNrVarp, SetupVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "request-page-setup", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "request-page-setup", cbRefPtr)
 }
 // Emitted at between the various phases of the print operation.
 // See [enum@Gtk.PrintStatus] for the phases that are being discriminated.
 // Use [method@Gtk.PrintOperation.get_status] to find out the current
 // status.
-func (x *PrintOperation) ConnectStatusChanged(cb func(PrintOperation)) uint32 {
+func (x *PrintOperation) ConnectStatusChanged(cb *func(PrintOperation)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "status-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
 }
 // Emitted after change of selected printer.
 //
 // The actual page setup and print settings are passed to the custom
 // widget, which can actualize itself according to this change.
-func (x *PrintOperation) ConnectUpdateCustomWidget(cb func(PrintOperation, uintptr, uintptr, uintptr)) uint32 {
+func (x *PrintOperation) ConnectUpdateCustomWidget(cb *func(PrintOperation, uintptr, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "update-custom-widget", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, WidgetVarp uintptr, SetupVarp uintptr, SettingsVarp uintptr) {
 		fa := PrintOperation{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, WidgetVarp, SetupVarp, SettingsVarp)
+		cbFn(fa, WidgetVarp, SetupVarp, SettingsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "update-custom-widget", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "update-custom-widget", cbRefPtr)
 }
 // Ends a preview.

M v4/gtk/gtkprintsettings.go +2 -2


@@ -225,9 +225,9 @@ func (x PrintSettings) Copy() PrintSettings {
225		var xPrintSettingsForeach func(uintptr, uintptr, uintptr)	225		var xPrintSettingsForeach func(uintptr, uintptr, uintptr)
226			226
227		// Calls @func for each key-value pair of @settings.	227		// Calls @func for each key-value pair of @settings.
228	-	func (x *PrintSettings) Foreach(FuncVar PrintSettingsFunc, UserDataVar uintptr) {	228	+	func (x PrintSettings) Foreach(FuncVar PrintSettingsFunc, UserDataVar uintptr) {
229			229
230	-	xPrintSettingsForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	230	+	xPrintSettingsForeach(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar)
231			231
232		}	232		}
233			233

M v4/gtk/gtkrange.go +45 -12

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Emitted before clamping a value, to give the application a
 // chance to adjust the bounds.
-func (x *Range) ConnectAdjustBounds(cb func(Range, float64)) uint32 {
+func (x *Range) ConnectAdjustBounds(cb *func(Range, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "adjust-bounds", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ValueVarp float64) {
 		fa := Range{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ValueVarp)
+		cbFn(fa, ValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "adjust-bounds", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "adjust-bounds", cbRefPtr)
 }
 // Emitted when a scroll action is performed on a range.
 // the ::change-value signal is responsible for clamping the value
 // to the desired number of decimal digits; the default GTK
 // handler clamps the value based on [property@Gtk.Range:round-digits].
-func (x *Range) ConnectChangeValue(cb func(Range, ScrollType, float64) bool) uint32 {
+func (x *Range) ConnectChangeValue(cb *func(Range, ScrollType, float64) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ScrollVarp ScrollType, ValueVarp float64) bool {
 		fa := Range{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ScrollVarp, ValueVarp)
+		return cbFn(fa, ScrollVarp, ValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "change-value", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
 }
 // Virtual function that moves the slider.
 //
 // Used for keybindings.
-func (x *Range) ConnectMoveSlider(cb func(Range, ScrollType)) uint32 {
+func (x *Range) ConnectMoveSlider(cb *func(Range, ScrollType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-slider", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StepVarp ScrollType) {
 		fa := Range{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StepVarp)
+		cbFn(fa, StepVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-slider", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-slider", cbRefPtr)
 }
 // Emitted when the range value changes.
-func (x *Range) ConnectValueChanged(cb func(Range)) uint32 {
+func (x *Range) ConnectValueChanged(cb *func(Range)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Range{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "value-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkrecentmanager.go +11 -3

 //
 // This can happen either by calling [method@Gtk.RecentManager.add_item]
 // or by another application.
-func (x *RecentManager) ConnectChanged(cb func(RecentManager)) uint32 {
+func (x *RecentManager) ConnectChanged(cb *func(RecentManager)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := RecentManager{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 var xRecentManagerGetDefault func() uintptr

M v4/gtk/gtkscale.go +2 -2


@@ -298,9 +298,9 @@ var xScaleSetFormatValueFunc func(uintptr, uintptr, uintptr, uintptr)
298		// If #NULL is passed as @func, the value will be displayed on	298		// If #NULL is passed as @func, the value will be displayed on
299		// its own, rounded according to the value of the	299		// its own, rounded according to the value of the
300		// [property@GtkScale:digits] property.	300		// [property@GtkScale:digits] property.
301	-	func (x *Scale) SetFormatValueFunc(FuncVar ScaleFormatValueFunc, UserDataVar uintptr, DestroyNotifyVar glib.DestroyNotify) {	301	+	func (x Scale) SetFormatValueFunc(FuncVar ScaleFormatValueFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
302			302
303	-	xScaleSetFormatValueFunc(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar, purego.NewCallback(DestroyNotifyVar))	303	+	xScaleSetFormatValueFunc(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallback(DestroyNotifyVar))
304			304
305		}	305		}
306			306

M v4/gtk/gtkscalebutton.go +34 -9

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;Escape&lt;/kbd&gt;.
-func (x *ScaleButton) ConnectPopdown(cb func(ScaleButton)) uint32 {
+func (x *ScaleButton) ConnectPopdown(cb *func(ScaleButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ScaleButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "popdown", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
 }
 // Emitted to popup the scale widget.
 //
 // The default bindings for this signal are &lt;kbd&gt;Space&lt;/kbd&gt;,
 // &lt;kbd&gt;Enter&lt;/kbd&gt; and &lt;kbd&gt;Return&lt;/kbd&gt;.
-func (x *ScaleButton) ConnectPopup(cb func(ScaleButton)) uint32 {
+func (x *ScaleButton) ConnectPopup(cb *func(ScaleButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ScaleButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "popup", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
 }
 // Emitted when the value field has changed.
-func (x *ScaleButton) ConnectValueChanged(cb func(ScaleButton, float64)) uint32 {
+func (x *ScaleButton) ConnectValueChanged(cb *func(ScaleButton, float64)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ValueVarp float64) {
 		fa := ScaleButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ValueVarp)
+		cbFn(fa, ValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "value-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkscrolledwindow.go +47 -12

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // Note: The @pos argument is LTR/RTL aware, so callers should be
 // aware too if intending to provide behavior on horizontal edges.
-func (x *ScrolledWindow) ConnectEdgeOvershot(cb func(ScrolledWindow, PositionType)) uint32 {
+func (x *ScrolledWindow) ConnectEdgeOvershot(cb *func(ScrolledWindow, PositionType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "edge-overshot", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PosVarp PositionType) {
 		fa := ScrolledWindow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PosVarp)
+		cbFn(fa, PosVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "edge-overshot", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "edge-overshot", cbRefPtr)
 }
 // Emitted whenever user-initiated scrolling makes the scrolled
 //
 // Note: The @pos argument is LTR/RTL aware, so callers should be
 // aware too if intending to provide behavior on horizontal edges.
-func (x *ScrolledWindow) ConnectEdgeReached(cb func(ScrolledWindow, PositionType)) uint32 {
+func (x *ScrolledWindow) ConnectEdgeReached(cb *func(ScrolledWindow, PositionType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "edge-reached", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PosVarp PositionType) {
 		fa := ScrolledWindow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PosVarp)
+		cbFn(fa, PosVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "edge-reached", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "edge-reached", cbRefPtr)
 }
 // Emitted when focus is moved away from the scrolled window by a
 // The default bindings for this signal are
 // `Ctrl + Tab` to move forward and `Ctrl + Shift + Tab` to
 // move backward.
-func (x *ScrolledWindow) ConnectMoveFocusOut(cb func(ScrolledWindow, DirectionType)) uint32 {
+func (x *ScrolledWindow) ConnectMoveFocusOut(cb *func(ScrolledWindow, DirectionType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DirectionTypeVarp DirectionType) {
 		fa := ScrolledWindow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DirectionTypeVarp)
+		cbFn(fa, DirectionTypeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-focus-out", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
 }
 // Emitted when a keybinding that scrolls is pressed.
 //
 // The horizontal or vertical adjustment is updated which triggers a
 // signal that the scrolled window’s child may listen to and scroll itself.
-func (x *ScrolledWindow) ConnectScrollChild(cb func(ScrolledWindow, ScrollType, bool) bool) uint32 {
+func (x *ScrolledWindow) ConnectScrollChild(cb *func(ScrolledWindow, ScrollType, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "scroll-child", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ScrollVarp ScrollType, HorizontalVarp bool) bool {
 		fa := ScrolledWindow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ScrollVarp, HorizontalVarp)
+		return cbFn(fa, ScrollVarp, HorizontalVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "scroll-child", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "scroll-child", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtksearchentry.go +69 -18

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Emitted when the entry is activated.
 //
 // The keybindings for this signal are all forms of the Enter key.
-func (x *SearchEntry) ConnectActivate(cb func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectActivate(cb *func(SearchEntry)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SearchEntry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the user initiates a move to the next match
 // between matches.
 //
 // The default bindings for this signal is Ctrl-g.
-func (x *SearchEntry) ConnectNextMatch(cb func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectNextMatch(cb *func(SearchEntry)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "next-match", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SearchEntry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "next-match", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "next-match", cbRefPtr)
 }
 // Emitted when the user initiates a move to the previous match
 // between matches.
 //
 // The default bindings for this signal is Ctrl-Shift-g.
-func (x *SearchEntry) ConnectPreviousMatch(cb func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectPreviousMatch(cb *func(SearchEntry)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "previous-match", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SearchEntry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "previous-match", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "previous-match", cbRefPtr)
 }
 // Emitted with a delay. The length of the delay can be
 // changed with the [property@Gtk.SearchEntry:search-delay]
 // property.
-func (x *SearchEntry) ConnectSearchChanged(cb func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectSearchChanged(cb *func(SearchEntry)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "search-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SearchEntry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "search-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "search-changed", cbRefPtr)
 }
 // Emitted when the user initiated a search on the entry.
-func (x *SearchEntry) ConnectSearchStarted(cb func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectSearchStarted(cb *func(SearchEntry)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "search-started", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SearchEntry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "search-started", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "search-started", cbRefPtr)
 }
 // Emitted when the user stops a search via keyboard input.
 // the search entry in this case.
 //
 // The default bindings for this signal is Escape.
-func (x *SearchEntry) ConnectStopSearch(cb func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectStopSearch(cb *func(SearchEntry)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "stop-search", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SearchEntry{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "stop-search", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "stop-search", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkshortcutaction.go +2 -2


@@ -129,10 +129,10 @@ var xNewCallbackAction func(uintptr, uintptr, uintptr) uintptr
129			129
130		// Create a custom action that calls the given @callback when	130		// Create a custom action that calls the given @callback when
131		// activated.	131		// activated.
132	-	func NewCallbackAction(CallbackVar ShortcutFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAction {	132	+	func NewCallbackAction(CallbackVar ShortcutFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAction {
133		var cls *CallbackAction	133		var cls *CallbackAction
134			134
135	-	cret := xNewCallbackAction(purego.NewCallback(CallbackVar), DataVar, purego.NewCallback(DestroyVar))	135	+	cret := xNewCallbackAction(glib.NewCallback(CallbackVar), DataVar, glib.NewCallback(DestroyVar))
136			136
137		if cret == 0 {	137		if cret == 0 {
138		return nil	138		return nil

M v4/gtk/gtkshortcutssection.go +12 -3

 	"unsafe"
 	"github.com/jwijenbergh/purego"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 	c.Ptr = ptr
 }
-func (x *ShortcutsSection) ConnectChangeCurrentPage(cb func(ShortcutsSection, int) bool) uint32 {
+func (x *ShortcutsSection) ConnectChangeCurrentPage(cb *func(ShortcutsSection, int) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp int) bool {
 		fa := ShortcutsSection{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ObjectVarp)
+		return cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "change-current-page", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkshortcutswindow.go +25 -6

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gsk"
 )
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is the Escape key.
-func (x *ShortcutsWindow) ConnectClose(cb func(ShortcutsWindow)) uint32 {
+func (x *ShortcutsWindow) ConnectClose(cb *func(ShortcutsWindow)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ShortcutsWindow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "close", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
 }
 // Emitted when the user uses a keybinding to start a search.
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is Control-F.
-func (x *ShortcutsWindow) ConnectSearch(cb func(ShortcutsWindow)) uint32 {
+func (x *ShortcutsWindow) ConnectSearch(cb *func(ShortcutsWindow)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "search", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ShortcutsWindow{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "search", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "search", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkshow.go +2 -2


@@ -28,9 +28,9 @@ var xShowUriFull func(uintptr, string, uint32, uintptr, uintptr, uintptr)
28		//	28		//
29		// This is the recommended call to be used as it passes information	29		// This is the recommended call to be used as it passes information
30		// necessary for sandbox helpers to parent their dialogs properly.	30		// necessary for sandbox helpers to parent their dialogs properly.
31	-	func ShowUriFull(ParentVar Window, UriVar string, TimestampVar uint32, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	31	+	func ShowUriFull(ParentVar Window, UriVar string, TimestampVar uint32, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
32			32
33	-	xShowUriFull(ParentVar.GoPointer(), UriVar, TimestampVar, CancellableVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar)	33	+	xShowUriFull(ParentVar.GoPointer(), UriVar, TimestampVar, CancellableVar.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar)
34			34
35		}	35		}
36			36

M v4/gtk/gtksignallistitemfactory.go +45 -12

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // The [signal@Gtk.SignalListItemFactory::unbind] signal is the
 // opposite of this signal and can be used to undo everything done
 // in this signal.
-func (x *SignalListItemFactory) ConnectBind(cb func(SignalListItemFactory, uintptr)) uint32 {
+func (x *SignalListItemFactory) ConnectBind(cb *func(SignalListItemFactory, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp uintptr) {
 		fa := SignalListItemFactory{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ObjectVarp)
+		cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "bind", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "bind", cbRefPtr)
 }
 // Emitted when a new listitem has been created and needs to be setup for use.
 //
 // The [signal@Gtk.SignalListItemFactory::teardown] signal is the opposite
 // of this signal and can be used to undo everything done in this signal.
-func (x *SignalListItemFactory) ConnectSetup(cb func(SignalListItemFactory, uintptr)) uint32 {
+func (x *SignalListItemFactory) ConnectSetup(cb *func(SignalListItemFactory, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "setup", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp uintptr) {
 		fa := SignalListItemFactory{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ObjectVarp)
+		cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "setup", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "setup", cbRefPtr)
 }
 // Emitted when an object is about to be destroyed.
 //
 // This signal is the opposite of the [signal@Gtk.SignalListItemFactory::setup]
 // signal and should be used to undo everything done in that signal.
-func (x *SignalListItemFactory) ConnectTeardown(cb func(SignalListItemFactory, uintptr)) uint32 {
+func (x *SignalListItemFactory) ConnectTeardown(cb *func(SignalListItemFactory, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "teardown", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp uintptr) {
 		fa := SignalListItemFactory{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ObjectVarp)
+		cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "teardown", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "teardown", cbRefPtr)
 }
 // Emitted when a object has been unbound from its item, for example when
 //
 // This signal is the opposite of the [signal@Gtk.SignalListItemFactory::bind]
 // signal and should be used to undo everything done in that signal.
-func (x *SignalListItemFactory) ConnectUnbind(cb func(SignalListItemFactory, uintptr)) uint32 {
+func (x *SignalListItemFactory) ConnectUnbind(cb *func(SignalListItemFactory, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp uintptr) {
 		fa := SignalListItemFactory{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ObjectVarp)
+		cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "unbind", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
 }
 func init() {

M v4/gtk/gtksorter.go +12 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // Depending on the @change parameter, it may be possible to update
 // the sort order without a full resorting. Refer to the
 // [enum@Gtk.SorterChange] documentation for details.
-func (x *Sorter) ConnectChanged(cb func(Sorter, SorterChange)) uint32 {
+func (x *Sorter) ConnectChanged(cb *func(Sorter, SorterChange)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ChangeVarp SorterChange) {
 		fa := Sorter{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ChangeVarp)
+		cbFn(fa, ChangeVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtkspinbutton.go +58 -15

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // programmatically.
 //
 // The default bindings for this signal are Up/Down and PageUp/PageDown.
-func (x *SpinButton) ConnectChangeValue(cb func(SpinButton, ScrollType)) uint32 {
+func (x *SpinButton) ConnectChangeValue(cb *func(SpinButton, ScrollType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ScrollVarp ScrollType) {
 		fa := SpinButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ScrollVarp)
+		cbFn(fa, ScrollVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "change-value", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
 }
 // Emitted to convert the users input into a double value.
 // new value.
 //
 // The default conversion uses g_strtod().
-func (x *SpinButton) ConnectInput(cb func(SpinButton, float64) int) uint32 {
+func (x *SpinButton) ConnectInput(cb *func(SpinButton, float64) int) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, NewValueVarp float64) int {
 		fa := SpinButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, NewValueVarp)
+		return cbFn(fa, NewValueVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "input", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
 }
 // Emitted to tweak the formatting of the value for display.
 //	}
 //
 // ```
-func (x *SpinButton) ConnectOutput(cb func(SpinButton) bool) uint32 {
+func (x *SpinButton) ConnectOutput(cb *func(SpinButton) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := SpinButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "output", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
 }
 // Emitted when the value is changed.
 //
 // Also see the [signal@Gtk.SpinButton::output] signal.
-func (x *SpinButton) ConnectValueChanged(cb func(SpinButton)) uint32 {
+func (x *SpinButton) ConnectValueChanged(cb *func(SpinButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SpinButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "value-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
 }
 // Emitted right after the spinbutton wraps from its maximum
 // to its minimum value or vice-versa.
-func (x *SpinButton) ConnectWrapped(cb func(SpinButton)) uint32 {
+func (x *SpinButton) ConnectWrapped(cb *func(SpinButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := SpinButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "wrapped", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkstatusbar.go +25 -6

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 }
 // Emitted whenever a new message is popped off a statusbar's stack.
-func (x *Statusbar) ConnectTextPopped(cb func(Statusbar, uint, string)) uint32 {
+func (x *Statusbar) ConnectTextPopped(cb *func(Statusbar, uint, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "text-popped", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ContextIdVarp uint, TextVarp string) {
 		fa := Statusbar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ContextIdVarp, TextVarp)
+		cbFn(fa, ContextIdVarp, TextVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "text-popped", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "text-popped", cbRefPtr)
 }
 // Emitted whenever a new message gets pushed onto a statusbar's stack.
-func (x *Statusbar) ConnectTextPushed(cb func(Statusbar, uint, string)) uint32 {
+func (x *Statusbar) ConnectTextPushed(cb *func(Statusbar, uint, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "text-pushed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ContextIdVarp uint, TextVarp string) {
 		fa := Statusbar{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ContextIdVarp, TextVarp)
+		cbFn(fa, ContextIdVarp, TextVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "text-pushed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "text-pushed", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkswitch.go +24 -6

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 //
 // Applications should never connect to this signal,
 // but use the [property@Gtk.Switch:active] property.
-func (x *Switch) ConnectActivate(cb func(Switch)) uint32 {
+func (x *Switch) ConnectActivate(cb *func(Switch)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Switch{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted to change the underlying state.
 // Visually, the underlying state is represented by the trough color of
 // the switch, while the [property@Gtk.Switch:active] property is
 // represented by the position of the switch.
-func (x *Switch) ConnectStateSet(cb func(Switch, bool) bool) uint32 {
+func (x *Switch) ConnectStateSet(cb *func(Switch, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "state-set", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StateVarp bool) bool {
 		fa := Switch{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, StateVarp)
+		return cbFn(fa, StateVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "state-set", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "state-set", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtktext.go +124 -33

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/graphene"
 	"github.com/jwijenbergh/puregotk/v4/pango"
 //
 // The default bindings for this signal are all forms
 // of the &lt;kbd&gt;Enter&lt;/kbd&gt; key.
-func (x *Text) ConnectActivate(cb func(Text)) uint32 {
+func (x *Text) ConnectActivate(cb *func(Text)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
 }
 // Emitted when the user asks for it.
 //
 // The default bindings for this signal are
 // &lt;kbd&gt;Backspace&lt;/kbd&gt; and &lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;Backspace&lt;/kbd&gt;.
-func (x *Text) ConnectBackspace(cb func(Text)) uint32 {
+func (x *Text) ConnectBackspace(cb *func(Text)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "backspace", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
 }
 // Emitted to copy the selection to the clipboard.
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;c&lt;/kbd&gt; and
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Insert&lt;/kbd&gt;.
-func (x *Text) ConnectCopyClipboard(cb func(Text)) uint32 {
+func (x *Text) ConnectCopyClipboard(cb *func(Text)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
 }
 // Emitted to cut the selection to the clipboard.
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;x&lt;/kbd&gt; and
 // &lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;Delete&lt;/kbd&gt;.
-func (x *Text) ConnectCutClipboard(cb func(Text)) uint32 {
+func (x *Text) ConnectCutClipboard(cb *func(Text)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
 }
 // Emitted when the user initiates a text deletion.
 // The default bindings for this signal are &lt;kbd&gt;Delete&lt;/kbd&gt;
 // for deleting a character and &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Delete&lt;/kbd&gt;
 // for deleting a word.
-func (x *Text) ConnectDeleteFromCursor(cb func(Text, DeleteType, int)) uint32 {
+func (x *Text) ConnectDeleteFromCursor(cb *func(Text, DeleteType, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, TypeVarp DeleteType, CountVarp int) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, TypeVarp, CountVarp)
+		cbFn(fa, TypeVarp, CountVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
 }
 // Emitted when the user initiates the insertion of a
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // This signal has no default bindings.
-func (x *Text) ConnectInsertAtCursor(cb func(Text, string)) uint32 {
+func (x *Text) ConnectInsertAtCursor(cb *func(Text, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StringVarp string) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StringVarp)
+		cbFn(fa, StringVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
 }
 // Emitted to present the Emoji chooser for the widget.
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;.&lt;/kbd&gt; and
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;;&lt;/kbd&gt;
-func (x *Text) ConnectInsertEmoji(cb func(Text)) uint32 {
+func (x *Text) ConnectInsertEmoji(cb *func(Text)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "insert-emoji", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
 }
 // Emitted when the user initiates a cursor movement.
 //     move by individual characters/lines
 //   - &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;→&lt;/kbd&gt;, etc. move by words/paragraphs
 //   - &lt;kbd&gt;Home&lt;/kbd&gt;, &lt;kbd&gt;End&lt;/kbd&gt; move to the ends of the buffer
-func (x *Text) ConnectMoveCursor(cb func(Text, MovementStep, int, bool)) uint32 {
+func (x *Text) ConnectMoveCursor(cb *func(Text, MovementStep, int, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StepVarp, CountVarp, ExtendVarp)
+		cbFn(fa, StepVarp, CountVarp, ExtendVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
 }
 // Emitted to paste the contents of the clipboard.
 //
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;v&lt;/kbd&gt; and &lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;Insert&lt;/kbd&gt;.
-func (x *Text) ConnectPasteClipboard(cb func(Text)) uint32 {
+func (x *Text) ConnectPasteClipboard(cb *func(Text)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
 }
 // Emitted when the preedit text changes.
 // If an input method is used, the typed text will not immediately
 // be committed to the buffer. So if you are interested in the text,
 // connect to this signal.
-func (x *Text) ConnectPreeditChanged(cb func(Text, string)) uint32 {
+func (x *Text) ConnectPreeditChanged(cb *func(Text, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PreeditVarp string) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PreeditVarp)
+		cbFn(fa, PreeditVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
 }
 // Emitted to toggle the overwrite mode of the `GtkText`.
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default bindings for this signal is &lt;kbd&gt;Insert&lt;/kbd&gt;.
-func (x *Text) ConnectToggleOverwrite(cb func(Text)) uint32 {
+func (x *Text) ConnectToggleOverwrite(cb *func(Text)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Text{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtktextbuffer.go +166 -45

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // [method@Gtk.TextBuffer.apply_tag],
 // [method@Gtk.TextBuffer.insert_with_tags],
 // [method@Gtk.TextBuffer.insert_range].
-func (x *TextBuffer) ConnectApplyTag(cb func(TextBuffer, uintptr, uintptr, uintptr)) uint32 {
+func (x *TextBuffer) ConnectApplyTag(cb *func(TextBuffer, uintptr, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "apply-tag", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr, StartVarp uintptr, EndVarp uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, TagVarp, StartVarp, EndVarp)
+		cbFn(fa, TagVarp, StartVarp, EndVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "apply-tag", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "apply-tag", cbRefPtr)
 }
 // Emitted at the beginning of a single user-visible
 // [method@Gtk.TextBuffer.delete_interactive],
 // [method@Gtk.TextBuffer.backspace],
 // [method@Gtk.TextBuffer.delete_selection].
-func (x *TextBuffer) ConnectBeginUserAction(cb func(TextBuffer)) uint32 {
+func (x *TextBuffer) ConnectBeginUserAction(cb *func(TextBuffer)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "begin-user-action", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "begin-user-action", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "begin-user-action", cbRefPtr)
 }
 // Emitted when the content of a `GtkTextBuffer` has changed.
-func (x *TextBuffer) ConnectChanged(cb func(TextBuffer)) uint32 {
+func (x *TextBuffer) ConnectChanged(cb *func(TextBuffer)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 // Emitted to delete a range from a `GtkTextBuffer`.
 // the deleted text.
 //
 // See also: [method@Gtk.TextBuffer.delete].
-func (x *TextBuffer) ConnectDeleteRange(cb func(TextBuffer, uintptr, uintptr)) uint32 {
+func (x *TextBuffer) ConnectDeleteRange(cb *func(TextBuffer, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "delete-range", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StartVarp uintptr, EndVarp uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StartVarp, EndVarp)
+		cbFn(fa, StartVarp, EndVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "delete-range", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "delete-range", cbRefPtr)
 }
 // Emitted at the end of a single user-visible
 // [method@Gtk.TextBuffer.backspace],
 // [method@Gtk.TextBuffer.delete_selection],
 // [method@Gtk.TextBuffer.backspace].
-func (x *TextBuffer) ConnectEndUserAction(cb func(TextBuffer)) uint32 {
+func (x *TextBuffer) ConnectEndUserAction(cb *func(TextBuffer)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "end-user-action", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "end-user-action", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "end-user-action", cbRefPtr)
 }
 // Emitted to insert a `GtkTextChildAnchor` in a `GtkTextBuffer`.
 // it to be placed after the inserted @anchor.
 //
 // See also: [method@Gtk.TextBuffer.insert_child_anchor].
-func (x *TextBuffer) ConnectInsertChildAnchor(cb func(TextBuffer, uintptr, uintptr)) uint32 {
+func (x *TextBuffer) ConnectInsertChildAnchor(cb *func(TextBuffer, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "insert-child-anchor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, LocationVarp uintptr, AnchorVarp uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, LocationVarp, AnchorVarp)
+		cbFn(fa, LocationVarp, AnchorVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "insert-child-anchor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "insert-child-anchor", cbRefPtr)
 }
 // Emitted to insert a `GdkPaintable` in a `GtkTextBuffer`.
 // it to be placed after the inserted @paintable.
 //
 // See also: [method@Gtk.TextBuffer.insert_paintable].
-func (x *TextBuffer) ConnectInsertPaintable(cb func(TextBuffer, uintptr, uintptr)) uint32 {
+func (x *TextBuffer) ConnectInsertPaintable(cb *func(TextBuffer, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "insert-paintable", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, LocationVarp uintptr, PaintableVarp uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, LocationVarp, PaintableVarp)
+		cbFn(fa, LocationVarp, PaintableVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "insert-paintable", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "insert-paintable", cbRefPtr)
 }
 // Emitted to insert text in a `GtkTextBuffer`.
 //
 // See also: [method@Gtk.TextBuffer.insert],
 // [method@Gtk.TextBuffer.insert_range].
-func (x *TextBuffer) ConnectInsertText(cb func(TextBuffer, uintptr, string, int)) uint32 {
+func (x *TextBuffer) ConnectInsertText(cb *func(TextBuffer, uintptr, string, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "insert-text", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, LocationVarp uintptr, TextVarp string, LenVarp int) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, LocationVarp, TextVarp, LenVarp)
+		cbFn(fa, LocationVarp, TextVarp, LenVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "insert-text", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "insert-text", cbRefPtr)
 }
 // Emitted as notification after a `GtkTextMark` is deleted.
 //
 // See also: [method@Gtk.TextBuffer.delete_mark].
-func (x *TextBuffer) ConnectMarkDeleted(cb func(TextBuffer, uintptr)) uint32 {
+func (x *TextBuffer) ConnectMarkDeleted(cb *func(TextBuffer, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mark-deleted", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, MarkVarp uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, MarkVarp)
+		cbFn(fa, MarkVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mark-deleted", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mark-deleted", cbRefPtr)
 }
 // Emitted as notification after a `GtkTextMark` is set.
 // See also:
 // [method@Gtk.TextBuffer.create_mark],
 // [method@Gtk.TextBuffer.move_mark].
-func (x *TextBuffer) ConnectMarkSet(cb func(TextBuffer, uintptr, uintptr)) uint32 {
+func (x *TextBuffer) ConnectMarkSet(cb *func(TextBuffer, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mark-set", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, LocationVarp uintptr, MarkVarp uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, LocationVarp, MarkVarp)
+		cbFn(fa, LocationVarp, MarkVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mark-set", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mark-set", cbRefPtr)
 }
 // Emitted when the modified bit of a `GtkTextBuffer` flips.
 //
 // See also: [method@Gtk.TextBuffer.set_modified].
-func (x *TextBuffer) ConnectModifiedChanged(cb func(TextBuffer)) uint32 {
+func (x *TextBuffer) ConnectModifiedChanged(cb *func(TextBuffer)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "modified-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "modified-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "modified-changed", cbRefPtr)
 }
 // Emitted after paste operation has been completed.
 // This is useful to properly scroll the view to the end
 // of the pasted text. See [method@Gtk.TextBuffer.paste_clipboard]
 // for more details.
-func (x *TextBuffer) ConnectPasteDone(cb func(TextBuffer, uintptr)) uint32 {
+func (x *TextBuffer) ConnectPasteDone(cb *func(TextBuffer, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "paste-done", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ClipboardVarp uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, ClipboardVarp)
+		cbFn(fa, ClipboardVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "paste-done", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "paste-done", cbRefPtr)
 }
 // Emitted when a request has been made to redo the
 // previously undone operation.
-func (x *TextBuffer) ConnectRedo(cb func(TextBuffer)) uint32 {
+func (x *TextBuffer) ConnectRedo(cb *func(TextBuffer)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "redo", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "redo", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "redo", cbRefPtr)
 }
 // Emitted to remove all occurrences of @tag from a range
 // to revalidate them).
 //
 // See also: [method@Gtk.TextBuffer.remove_tag].
-func (x *TextBuffer) ConnectRemoveTag(cb func(TextBuffer, uintptr, uintptr, uintptr)) uint32 {
+func (x *TextBuffer) ConnectRemoveTag(cb *func(TextBuffer, uintptr, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "remove-tag", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr, StartVarp uintptr, EndVarp uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, TagVarp, StartVarp, EndVarp)
+		cbFn(fa, TagVarp, StartVarp, EndVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "remove-tag", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "remove-tag", cbRefPtr)
 }
 // Emitted when a request has been made to undo the
 // previous operation or set of operations that have
 // been grouped together.
-func (x *TextBuffer) ConnectUndo(cb func(TextBuffer)) uint32 {
+func (x *TextBuffer) ConnectUndo(cb *func(TextBuffer)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "undo", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextBuffer{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "undo", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "undo", cbRefPtr)
 }
 func init() {

M v4/gtk/gtktextiter.go +4 -4


@@ -124,9 +124,9 @@ var xTextIterBackwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
124			124
125		// Same as gtk_text_iter_forward_find_char(),	125		// Same as gtk_text_iter_forward_find_char(),
126		// but goes backward from @iter.	126		// but goes backward from @iter.
127	-	func (x TextIter) BackwardFindChar(PredVar TextCharPredicate, UserDataVar uintptr, LimitVar TextIter) bool {	127	+	func (x TextIter) BackwardFindChar(PredVar TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
128			128
129	-	cret := xTextIterBackwardFindChar(x.GoPointer(), purego.NewCallback(PredVar), UserDataVar, LimitVar)	129	+	cret := xTextIterBackwardFindChar(x.GoPointer(), glib.NewCallback(PredVar), UserDataVar, LimitVar)
130		return cret	130		return cret
131		}	131		}
132			132

@@ -539,9 +539,9 @@ var xTextIterForwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
539		// If @pred returns %TRUE, returns %TRUE and stops scanning.	539		// If @pred returns %TRUE, returns %TRUE and stops scanning.
540		// If @pred never returns %TRUE, @iter is set to @limit if	540		// If @pred never returns %TRUE, @iter is set to @limit if
541		// @limit is non-%NULL, otherwise to the end iterator.	541		// @limit is non-%NULL, otherwise to the end iterator.
542	-	func (x TextIter) ForwardFindChar(PredVar TextCharPredicate, UserDataVar uintptr, LimitVar TextIter) bool {	542	+	func (x TextIter) ForwardFindChar(PredVar TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
543			543
544	-	cret := xTextIterForwardFindChar(x.GoPointer(), purego.NewCallback(PredVar), UserDataVar, LimitVar)	544	+	cret := xTextIterForwardFindChar(x.GoPointer(), glib.NewCallback(PredVar), UserDataVar, LimitVar)
545		return cret	545		return cret
546		}	546		}
547			547

M v4/gtk/gtktexttagtable.go +38 -11

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 //
 // Note that the table may not be modified while iterating
 // over it (you can’t add/remove tags).
-func (x *TextTagTable) Foreach(FuncVar TextTagTableForeach, DataVar uintptr) {
+func (x *TextTagTable) Foreach(FuncVar *TextTagTableForeach, DataVar uintptr) {
-	xTextTagTableForeach(x.GoPointer(), purego.NewCallback(FuncVar), DataVar)
+	xTextTagTableForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
 }
 }
 // Emitted every time a new tag is added in the `GtkTextTagTable`.
-func (x *TextTagTable) ConnectTagAdded(cb func(TextTagTable, uintptr)) uint32 {
+func (x *TextTagTable) ConnectTagAdded(cb *func(TextTagTable, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "tag-added", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr) {
 		fa := TextTagTable{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, TagVarp)
+		cbFn(fa, TagVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "tag-added", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "tag-added", cbRefPtr)
 }
 // Emitted every time a tag in the `GtkTextTagTable` changes.
-func (x *TextTagTable) ConnectTagChanged(cb func(TextTagTable, uintptr, bool)) uint32 {
+func (x *TextTagTable) ConnectTagChanged(cb *func(TextTagTable, uintptr, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "tag-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr, SizeChangedVarp bool) {
 		fa := TextTagTable{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, TagVarp, SizeChangedVarp)
+		cbFn(fa, TagVarp, SizeChangedVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "tag-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "tag-changed", cbRefPtr)
 }
 // Emitted every time a tag is removed from the `GtkTextTagTable`.
 //
 // The @tag is still valid by the time the signal is emitted, but
 // it is not associated with a tag table any more.
-func (x *TextTagTable) ConnectTagRemoved(cb func(TextTagTable, uintptr)) uint32 {
+func (x *TextTagTable) ConnectTagRemoved(cb *func(TextTagTable, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "tag-removed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr) {
 		fa := TextTagTable{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, TagVarp)
+		cbFn(fa, TagVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "tag-removed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "tag-removed", cbRefPtr)
 }
 // Gets the ID of the @buildable object.

M v4/gtk/gtktextview.go +166 -45

 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/gdk"
 	"github.com/jwijenbergh/puregotk/v4/gio"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/pango"
 )
 //
 // The default bindings for this signal are
 // &lt;kbd&gt;Backspace&lt;/kbd&gt; and &lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;Backspace&lt;/kbd&gt;.
-func (x *TextView) ConnectBackspace(cb func(TextView)) uint32 {
+func (x *TextView) ConnectBackspace(cb *func(TextView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "backspace", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
 }
 // Gets emitted to copy the selection to the clipboard.
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;c&lt;/kbd&gt; and
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Insert&lt;/kbd&gt;.
-func (x *TextView) ConnectCopyClipboard(cb func(TextView)) uint32 {
+func (x *TextView) ConnectCopyClipboard(cb *func(TextView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
 }
 // Gets emitted to cut the selection to the clipboard.
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;x&lt;/kbd&gt; and
 // &lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;Delete&lt;/kbd&gt;.
-func (x *TextView) ConnectCutClipboard(cb func(TextView)) uint32 {
+func (x *TextView) ConnectCutClipboard(cb *func(TextView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
 }
 // Gets emitted when the user initiates a text deletion.
 // deleting a character, &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Delete&lt;/kbd&gt; for
 // deleting a word and &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Backspace&lt;/kbd&gt; for
 // deleting a word backwards.
-func (x *TextView) ConnectDeleteFromCursor(cb func(TextView, DeleteType, int)) uint32 {
+func (x *TextView) ConnectDeleteFromCursor(cb *func(TextView, DeleteType, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, TypeVarp DeleteType, CountVarp int) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, TypeVarp, CountVarp)
+		cbFn(fa, TypeVarp, CountVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
 }
 // Emitted when the selection needs to be extended at @location.
-func (x *TextView) ConnectExtendSelection(cb func(TextView, TextExtendSelection, uintptr, uintptr, uintptr) bool) uint32 {
+func (x *TextView) ConnectExtendSelection(cb *func(TextView, TextExtendSelection, uintptr, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "extend-selection", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, GranularityVarp TextExtendSelection, LocationVarp uintptr, StartVarp uintptr, EndVarp uintptr) bool {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, GranularityVarp, LocationVarp, StartVarp, EndVarp)
+		return cbFn(fa, GranularityVarp, LocationVarp, StartVarp, EndVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "extend-selection", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "extend-selection", cbRefPtr)
 }
 // Gets emitted when the user initiates the insertion of a
 // The ::insert-at-cursor signal is a [keybinding signal](class.SignalAction.html).
 //
 // This signal has no default bindings.
-func (x *TextView) ConnectInsertAtCursor(cb func(TextView, string)) uint32 {
+func (x *TextView) ConnectInsertAtCursor(cb *func(TextView, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StringVarp string) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StringVarp)
+		cbFn(fa, StringVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
 }
 // Gets emitted to present the Emoji chooser for the @text_view.
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;.&lt;/kbd&gt; and
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;;&lt;/kbd&gt;
-func (x *TextView) ConnectInsertEmoji(cb func(TextView)) uint32 {
+func (x *TextView) ConnectInsertEmoji(cb *func(TextView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "insert-emoji", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
 }
 // Gets emitted when the user initiates a cursor movement.
 //   - &lt;kbd&gt;PgUp&lt;/kbd&gt;, &lt;kbd&gt;PgDn&lt;/kbd&gt; move vertically by pages
 //   - &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;PgUp&lt;/kbd&gt;, &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;PgDn&lt;/kbd&gt;
 //     move horizontally by pages
-func (x *TextView) ConnectMoveCursor(cb func(TextView, MovementStep, int, bool)) uint32 {
+func (x *TextView) ConnectMoveCursor(cb *func(TextView, MovementStep, int, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendSelectionVarp bool) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StepVarp, CountVarp, ExtendSelectionVarp)
+		cbFn(fa, StepVarp, CountVarp, ExtendSelectionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
 }
 // Gets emitted to move the viewport.
 // window.
 //
 // There are no default bindings for this signal.
-func (x *TextView) ConnectMoveViewport(cb func(TextView, ScrollStep, int)) uint32 {
+func (x *TextView) ConnectMoveViewport(cb *func(TextView, ScrollStep, int)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-viewport", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StepVarp ScrollStep, CountVarp int) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, StepVarp, CountVarp)
+		cbFn(fa, StepVarp, CountVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-viewport", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-viewport", cbRefPtr)
 }
 // Gets emitted to paste the contents of the clipboard
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;v&lt;/kbd&gt; and
 // &lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;Insert&lt;/kbd&gt;.
-func (x *TextView) ConnectPasteClipboard(cb func(TextView)) uint32 {
+func (x *TextView) ConnectPasteClipboard(cb *func(TextView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
 }
 // Emitted when preedit text of the active IM changes.
 //
 // This signal is only emitted if the text at the given position
 // is actually editable.
-func (x *TextView) ConnectPreeditChanged(cb func(TextView, string)) uint32 {
+func (x *TextView) ConnectPreeditChanged(cb *func(TextView, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PreeditVarp string) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PreeditVarp)
+		cbFn(fa, PreeditVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
 }
 // Gets emitted to select or unselect the complete contents of the text view.
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;/&lt;/kbd&gt; for selecting and
 // &lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt; and
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;\&lt;/kbd&gt; for unselecting.
-func (x *TextView) ConnectSelectAll(cb func(TextView, bool)) uint32 {
+func (x *TextView) ConnectSelectAll(cb *func(TextView, bool)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, SelectVarp bool) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, SelectVarp)
+		cbFn(fa, SelectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
 }
 // Gets emitted when the user initiates settings the "anchor" mark.
 // "insert" mark.
 //
 // This signal has no default bindings.
-func (x *TextView) ConnectSetAnchor(cb func(TextView)) uint32 {
+func (x *TextView) ConnectSetAnchor(cb *func(TextView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "set-anchor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "set-anchor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "set-anchor", cbRefPtr)
 }
 // Gets emitted to toggle the `cursor-visible` property.
 // [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;F7&lt;/kbd&gt;.
-func (x *TextView) ConnectToggleCursorVisible(cb func(TextView)) uint32 {
+func (x *TextView) ConnectToggleCursorVisible(cb *func(TextView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-visible", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-visible", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-visible", cbRefPtr)
 }
 // Gets emitted to toggle the overwrite mode of the text view.
 // The ::toggle-overwrite signal is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;Insert&lt;/kbd&gt;.
-func (x *TextView) ConnectToggleOverwrite(cb func(TextView)) uint32 {
+func (x *TextView) ConnectToggleOverwrite(cb *func(TextView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TextView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtktogglebutton.go +11 -3

 }
 // Emitted whenever the `GtkToggleButton`'s state is changed.
-func (x *ToggleButton) ConnectToggled(cb func(ToggleButton)) uint32 {
+func (x *ToggleButton) ConnectToggled(cb *func(ToggleButton)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := ToggleButton{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggled", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtktreelistmodel.go +2 -2


@@ -51,10 +51,10 @@ var xNewTreeListModel func(uintptr, bool, bool, uintptr, uintptr, uintptr) uintp
51			51
52		// Creates a new empty `GtkTreeListModel` displaying @root	52		// Creates a new empty `GtkTreeListModel` displaying @root
53		// with all rows collapsed.	53		// with all rows collapsed.
54	-	func NewTreeListModel(RootVar gio.ListModel, PassthroughVar bool, AutoexpandVar bool, CreateFuncVar TreeListModelCreateModelFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *TreeListModel {	54	+	func NewTreeListModel(RootVar gio.ListModel, PassthroughVar bool, AutoexpandVar bool, CreateFuncVar TreeListModelCreateModelFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *TreeListModel {
55		var cls *TreeListModel	55		var cls *TreeListModel
56			56
57	-	cret := xNewTreeListModel(RootVar.GoPointer(), PassthroughVar, AutoexpandVar, purego.NewCallback(CreateFuncVar), UserDataVar, purego.NewCallback(UserDestroyVar))	57	+	cret := xNewTreeListModel(RootVar.GoPointer(), PassthroughVar, AutoexpandVar, glib.NewCallback(CreateFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
58			58
59		if cret == 0 {	59		if cret == 0 {
60		return nil	60		return nil

M v4/gtk/gtktreemodel.go +4 -3

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 	GoPointer() uintptr
 	SetGoPointer(uintptr)
 	FilterNew(RootVar *TreePath) *TreeModelBase
-	Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr)
+	Foreach(FuncVar *TreeModelForeachFunc, UserDataVar uintptr)
 	Get(IterVar *TreeIter, varArgs ...interface{})
 	GetColumnType(IndexVar int) []interface{}
 	GetFlags() TreeModelFlags
 //
 // If @func returns %TRUE, then the tree ceases to be walked,
 // and gtk_tree_model_foreach() returns.
-func (x *TreeModelBase) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {
+func (x *TreeModelBase) Foreach(FuncVar *TreeModelForeachFunc, UserDataVar uintptr) {
-	XGtkTreeModelForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)
+	XGtkTreeModelForeach(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar)
 }

M v4/gtk/gtktreemodelfilter.go +6 -6


@@ -214,9 +214,9 @@ var xTreeModelFilterSetModifyFunc func(uintptr, int, uintptr, uintptr, uintptr,
214		//	214		//
215		// Note that gtk_tree_model_filter_set_modify_func()	215		// Note that gtk_tree_model_filter_set_modify_func()
216		// can only be called once for a given filter model.	216		// can only be called once for a given filter model.
217	-	func (x *TreeModelFilter) SetModifyFunc(NColumnsVar int, TypesVar uintptr, FuncVar TreeModelFilterModifyFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) {	217	+	func (x TreeModelFilter) SetModifyFunc(NColumnsVar int, TypesVar uintptr, FuncVar TreeModelFilterModifyFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
218			218
219	-	xTreeModelFilterSetModifyFunc(x.GoPointer(), NColumnsVar, TypesVar, purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DestroyVar))	219	+	xTreeModelFilterSetModifyFunc(x.GoPointer(), NColumnsVar, TypesVar, glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DestroyVar))
220			220
221		}	221		}
222			222

@@ -276,9 +276,9 @@ var xTreeModelFilterSetVisibleFunc func(uintptr, uintptr, uintptr, uintptr)
276		// Note that gtk_tree_model_filter_set_visible_func() or	276		// Note that gtk_tree_model_filter_set_visible_func() or
277		// gtk_tree_model_filter_set_visible_column() can only be called	277		// gtk_tree_model_filter_set_visible_column() can only be called
278		// once for a given filter model.	278		// once for a given filter model.
279	-	func (x *TreeModelFilter) SetVisibleFunc(FuncVar TreeModelFilterVisibleFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) {	279	+	func (x TreeModelFilter) SetVisibleFunc(FuncVar TreeModelFilterVisibleFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
280			280
281	-	xTreeModelFilterSetVisibleFunc(x.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DestroyVar))	281	+	xTreeModelFilterSetVisibleFunc(x.GoPointer(), glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DestroyVar))
282			282
283		}	283		}
284			284

@@ -345,9 +345,9 @@ func (x TreeModelFilter) FilterNew(RootVar TreePath) *TreeModelBase {
345		//	345		//
346		// If @func returns %TRUE, then the tree ceases to be walked,	346		// If @func returns %TRUE, then the tree ceases to be walked,
347		// and gtk_tree_model_foreach() returns.	347		// and gtk_tree_model_foreach() returns.
348	-	func (x *TreeModelFilter) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {	348	+	func (x TreeModelFilter) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {
349			349
350	-	XGtkTreeModelForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	350	+	XGtkTreeModelForeach(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar)
351			351
352		}	352		}
353			353

M v4/gtk/gtktreemodelsort.go +6 -6


@@ -317,9 +317,9 @@ func (x TreeModelSort) FilterNew(RootVar TreePath) *TreeModelBase {
317		//	317		//
318		// If @func returns %TRUE, then the tree ceases to be walked,	318		// If @func returns %TRUE, then the tree ceases to be walked,
319		// and gtk_tree_model_foreach() returns.	319		// and gtk_tree_model_foreach() returns.
320	-	func (x *TreeModelSort) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {	320	+	func (x TreeModelSort) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {
321			321
322	-	XGtkTreeModelForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	322	+	XGtkTreeModelForeach(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar)
323			323
324		}	324		}
325			325

@@ -651,9 +651,9 @@ func (x *TreeModelSort) HasDefaultSortFunc() bool {
651		// This means that once the model has been sorted, it can’t go back to the	651		// This means that once the model has been sorted, it can’t go back to the
652		// default state. In this case, when the current sort column id of @sortable	652		// default state. In this case, when the current sort column id of @sortable
653		// is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.	653		// is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
654	-	func (x *TreeModelSort) SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	654	+	func (x TreeModelSort) SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
655			655
656	-	XGtkTreeSortableSetDefaultSortFunc(x.GoPointer(), purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	656	+	XGtkTreeSortableSetDefaultSortFunc(x.GoPointer(), glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
657			657
658		}	658		}
659			659

@@ -675,9 +675,9 @@ func (x *TreeModelSort) SetSortColumnId(SortColumnIdVar int, OrderVar SortType)
675		// Sets the comparison function used when sorting to be @sort_func. If the	675		// Sets the comparison function used when sorting to be @sort_func. If the
676		// current sort column id of @sortable is the same as @sort_column_id, then	676		// current sort column id of @sortable is the same as @sort_column_id, then
677		// the model will sort using this function.	677		// the model will sort using this function.
678	-	func (x *TreeModelSort) SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	678	+	func (x TreeModelSort) SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
679			679
680	-	XGtkTreeSortableSetSortFunc(x.GoPointer(), SortColumnIdVar, purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	680	+	XGtkTreeSortableSetSortFunc(x.GoPointer(), SortColumnIdVar, glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
681			681
682		}	682		}
683			683

M v4/gtk/gtktreeselection.go +17 -7

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 // Calls a function for each selected node. Note that you cannot modify
 // the tree or selection from within this function. As a result,
 // gtk_tree_selection_get_selected_rows() might be more useful.
-func (x *TreeSelection) SelectedForeach(FuncVar TreeSelectionForeachFunc, DataVar uintptr) {
+func (x *TreeSelection) SelectedForeach(FuncVar *TreeSelectionForeachFunc, DataVar uintptr) {
-	xTreeSelectionSelectedForeach(x.GoPointer(), purego.NewCallback(FuncVar), DataVar)
+	xTreeSelectionSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
 }
 // giving some control over which nodes are selected. The select function
 // should return %TRUE if the state of the node may be toggled, and %FALSE
 // if the state of the node should be left unchanged.
-func (x *TreeSelection) SetSelectFunction(FuncVar TreeSelectionFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *TreeSelection) SetSelectFunction(FuncVar *TreeSelectionFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xTreeSelectionSetSelectFunction(x.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DestroyVar))
+	xTreeSelectionSetSelectFunction(x.GoPointer(), glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DestroyVar))
 }
 // this signal is mostly a hint.  It may only be emitted once when a range
 // of rows are selected, and it may occasionally be emitted when nothing
 // has happened.
-func (x *TreeSelection) ConnectChanged(cb func(TreeSelection)) uint32 {
+func (x *TreeSelection) ConnectChanged(cb *func(TreeSelection)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TreeSelection{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
 }
 func init() {

M v4/gtk/gtktreesortable.go +6 -6


@@ -41,9 +41,9 @@ type TreeSortable interface {
41		SetGoPointer(uintptr)	41		SetGoPointer(uintptr)
42		GetSortColumnId(SortColumnIdVar int, OrderVar *SortType) bool	42		GetSortColumnId(SortColumnIdVar int, OrderVar *SortType) bool
43		HasDefaultSortFunc() bool	43		HasDefaultSortFunc() bool
44	-	SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify)	44	+	SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify)
45		SetSortColumnId(SortColumnIdVar int, OrderVar SortType)	45		SetSortColumnId(SortColumnIdVar int, OrderVar SortType)
46	-	SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify)	46	+	SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify)
47		SortColumnChanged()	47		SortColumnChanged()
48		}	48		}
49		type TreeSortableBase struct {	49		type TreeSortableBase struct {

@@ -86,9 +86,9 @@ func (x *TreeSortableBase) HasDefaultSortFunc() bool {
86		// This means that once the model has been sorted, it can’t go back to the	86		// This means that once the model has been sorted, it can’t go back to the
87		// default state. In this case, when the current sort column id of @sortable	87		// default state. In this case, when the current sort column id of @sortable
88		// is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.	88		// is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
89	-	func (x *TreeSortableBase) SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	89	+	func (x TreeSortableBase) SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
90			90
91	-	XGtkTreeSortableSetDefaultSortFunc(x.GoPointer(), purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	91	+	XGtkTreeSortableSetDefaultSortFunc(x.GoPointer(), glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
92			92
93		}	93		}
94			94

@@ -110,9 +110,9 @@ func (x *TreeSortableBase) SetSortColumnId(SortColumnIdVar int, OrderVar SortTyp
110		// Sets the comparison function used when sorting to be @sort_func. If the	110		// Sets the comparison function used when sorting to be @sort_func. If the
111		// current sort column id of @sortable is the same as @sort_column_id, then	111		// current sort column id of @sortable is the same as @sort_column_id, then
112		// the model will sort using this function.	112		// the model will sort using this function.
113	-	func (x *TreeSortableBase) SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	113	+	func (x TreeSortableBase) SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
114			114
115	-	XGtkTreeSortableSetSortFunc(x.GoPointer(), SortColumnIdVar, purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	115	+	XGtkTreeSortableSetSortFunc(x.GoPointer(), SortColumnIdVar, glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
116			116
117		}	117		}
118			118

M v4/gtk/gtktreestore.go +6 -6


@@ -477,9 +477,9 @@ func (x TreeStore) FilterNew(RootVar TreePath) *TreeModelBase {
477		//	477		//
478		// If @func returns %TRUE, then the tree ceases to be walked,	478		// If @func returns %TRUE, then the tree ceases to be walked,
479		// and gtk_tree_model_foreach() returns.	479		// and gtk_tree_model_foreach() returns.
480	-	func (x *TreeStore) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {	480	+	func (x TreeStore) Foreach(FuncVar TreeModelForeachFunc, UserDataVar uintptr) {
481			481
482	-	XGtkTreeModelForeach(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar)	482	+	XGtkTreeModelForeach(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar)
483			483
484		}	484		}
485			485

@@ -811,9 +811,9 @@ func (x *TreeStore) HasDefaultSortFunc() bool {
811		// This means that once the model has been sorted, it can’t go back to the	811		// This means that once the model has been sorted, it can’t go back to the
812		// default state. In this case, when the current sort column id of @sortable	812		// default state. In this case, when the current sort column id of @sortable
813		// is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.	813		// is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
814	-	func (x *TreeStore) SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	814	+	func (x TreeStore) SetDefaultSortFunc(SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
815			815
816	-	XGtkTreeSortableSetDefaultSortFunc(x.GoPointer(), purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	816	+	XGtkTreeSortableSetDefaultSortFunc(x.GoPointer(), glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
817			817
818		}	818		}
819			819

@@ -835,9 +835,9 @@ func (x *TreeStore) SetSortColumnId(SortColumnIdVar int, OrderVar SortType) {
835		// Sets the comparison function used when sorting to be @sort_func. If the	835		// Sets the comparison function used when sorting to be @sort_func. If the
836		// current sort column id of @sortable is the same as @sort_column_id, then	836		// current sort column id of @sortable is the same as @sort_column_id, then
837		// the model will sort using this function.	837		// the model will sort using this function.
838	-	func (x *TreeStore) SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {	838	+	func (x TreeStore) SetSortFunc(SortColumnIdVar int, SortFuncVar TreeIterCompareFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
839			839
840	-	XGtkTreeSortableSetSortFunc(x.GoPointer(), SortColumnIdVar, purego.NewCallback(SortFuncVar), UserDataVar, purego.NewCallback(DestroyVar))	840	+	XGtkTreeSortableSetSortFunc(x.GoPointer(), SortColumnIdVar, glib.NewCallback(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
841			841
842		}	842		}
843			843

M v4/gtk/gtktreeview.go +175 -55

 // gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
 // If @tree_view has “fixed_height” mode enabled, then the new column will have its
 // “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
-func (x *TreeView) InsertColumnWithDataFunc(PositionVar int, TitleVar string, CellVar *CellRenderer, FuncVar TreeCellDataFunc, DataVar uintptr, DnotifyVar glib.DestroyNotify) int {
+func (x *TreeView) InsertColumnWithDataFunc(PositionVar int, TitleVar string, CellVar *CellRenderer, FuncVar *TreeCellDataFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) int {
-	cret := xTreeViewInsertColumnWithDataFunc(x.GoPointer(), PositionVar, TitleVar, CellVar.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DnotifyVar))
+	cret := xTreeViewInsertColumnWithDataFunc(x.GoPointer(), PositionVar, TitleVar, CellVar.GoPointer(), glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DnotifyVar))
 	return cret
 }
 var xTreeViewMapExpandedRows func(uintptr, uintptr, uintptr)
 // Calls @func on all expanded rows.
-func (x *TreeView) MapExpandedRows(FuncVar TreeViewMappingFunc, DataVar uintptr) {
+func (x *TreeView) MapExpandedRows(FuncVar *TreeViewMappingFunc, DataVar uintptr) {
-	xTreeViewMapExpandedRows(x.GoPointer(), purego.NewCallback(FuncVar), DataVar)
+	xTreeViewMapExpandedRows(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
 }
 // are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
 // @tree_view reverts to the default behavior of allowing all columns to be
 // dropped everywhere.
-func (x *TreeView) SetColumnDragFunction(FuncVar TreeViewColumnDropFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *TreeView) SetColumnDragFunction(FuncVar *TreeViewColumnDropFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xTreeViewSetColumnDragFunction(x.GoPointer(), purego.NewCallback(FuncVar), UserDataVar, purego.NewCallback(DestroyVar))
+	xTreeViewSetColumnDragFunction(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallback(DestroyVar))
 }
 // Sets the row separator function, which is used to determine
 // whether a row should be drawn as a separator. If the row separator
 // function is %NULL, no separators are drawn. This is the default value.
-func (x *TreeView) SetRowSeparatorFunc(FuncVar TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *TreeView) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xTreeViewSetRowSeparatorFunc(x.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DestroyVar))
+	xTreeViewSetRowSeparatorFunc(x.GoPointer(), glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DestroyVar))
 }
 // Sets the compare function for the interactive search capabilities; note
 // that somewhat like strcmp() returning 0 for equality
 // `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
-func (x *TreeView) SetSearchEqualFunc(SearchEqualFuncVar TreeViewSearchEqualFunc, SearchUserDataVar uintptr, SearchDestroyVar glib.DestroyNotify) {
+func (x *TreeView) SetSearchEqualFunc(SearchEqualFuncVar *TreeViewSearchEqualFunc, SearchUserDataVar uintptr, SearchDestroyVar *glib.DestroyNotify) {
-	xTreeViewSetSearchEqualFunc(x.GoPointer(), purego.NewCallback(SearchEqualFuncVar), SearchUserDataVar, purego.NewCallback(SearchDestroyVar))
+	xTreeViewSetSearchEqualFunc(x.GoPointer(), glib.NewCallback(SearchEqualFuncVar), SearchUserDataVar, glib.NewCallback(SearchDestroyVar))
 }
 }
 // The number of columns of the treeview has changed.
-func (x *TreeView) ConnectColumnsChanged(cb func(TreeView)) uint32 {
+func (x *TreeView) ConnectColumnsChanged(cb *func(TreeView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "columns-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "columns-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "columns-changed", cbRefPtr)
 }
 // The position of the cursor (focused cell) has changed.
-func (x *TreeView) ConnectCursorChanged(cb func(TreeView)) uint32 {
+func (x *TreeView) ConnectCursorChanged(cb *func(TreeView)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "cursor-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "cursor-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "cursor-changed", cbRefPtr)
 }
-func (x *TreeView) ConnectExpandCollapseCursorRow(cb func(TreeView, bool, bool, bool) bool) uint32 {
+func (x *TreeView) ConnectExpandCollapseCursorRow(cb *func(TreeView, bool, bool, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp bool, P0Varp bool, P1Varp bool) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ObjectVarp, P0Varp, P1Varp)
+		return cbFn(fa, ObjectVarp, P0Varp, P1Varp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", cbRefPtr)
 }
 // The `GtkTreeView`::move-cursor signal is a [keybinding
 // programmatically. In contrast to gtk_tree_view_set_cursor() and
 // gtk_tree_view_set_cursor_on_cell() when moving horizontally
 // `GtkTreeView`::move-cursor does not reset the current selection.
-func (x *TreeView) ConnectMoveCursor(cb func(TreeView, MovementStep, int, bool, bool) bool) uint32 {
+func (x *TreeView) ConnectMoveCursor(cb *func(TreeView, MovementStep, int, bool, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, DirectionVarp int, ExtendVarp bool, ModifyVarp bool) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, StepVarp, DirectionVarp, ExtendVarp, ModifyVarp)
+		return cbFn(fa, StepVarp, DirectionVarp, ExtendVarp, ModifyVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
 }
 // The "row-activated" signal is emitted when the method
 // For selection handling refer to the
 // [tree widget conceptual overview](section-tree-widget.html)
 // as well as `GtkTreeSelection`.
-func (x *TreeView) ConnectRowActivated(cb func(TreeView, uintptr, uintptr)) uint32 {
+func (x *TreeView) ConnectRowActivated(cb *func(TreeView, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PathVarp uintptr, ColumnVarp uintptr) {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PathVarp, ColumnVarp)
+		cbFn(fa, PathVarp, ColumnVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "row-activated", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
 }
 // The given row has been collapsed (child nodes are hidden).
-func (x *TreeView) ConnectRowCollapsed(cb func(TreeView, uintptr, uintptr)) uint32 {
+func (x *TreeView) ConnectRowCollapsed(cb *func(TreeView, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "row-collapsed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, IterVarp, PathVarp)
+		cbFn(fa, IterVarp, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "row-collapsed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "row-collapsed", cbRefPtr)
 }
 // The given row has been expanded (child nodes are shown).
-func (x *TreeView) ConnectRowExpanded(cb func(TreeView, uintptr, uintptr)) uint32 {
+func (x *TreeView) ConnectRowExpanded(cb *func(TreeView, uintptr, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "row-expanded", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, IterVarp, PathVarp)
+		cbFn(fa, IterVarp, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "row-expanded", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "row-expanded", cbRefPtr)
 }
-func (x *TreeView) ConnectSelectAll(cb func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectSelectAll(cb *func(TreeView) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
 }
-func (x *TreeView) ConnectSelectCursorParent(cb func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectSelectCursorParent(cb *func(TreeView) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", cbRefPtr)
 }
-func (x *TreeView) ConnectSelectCursorRow(cb func(TreeView, bool) bool) uint32 {
+func (x *TreeView) ConnectSelectCursorRow(cb *func(TreeView, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "select-cursor-row", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ObjectVarp bool) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ObjectVarp)
+		return cbFn(fa, ObjectVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "select-cursor-row", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "select-cursor-row", cbRefPtr)
 }
-func (x *TreeView) ConnectStartInteractiveSearch(cb func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectStartInteractiveSearch(cb *func(TreeView) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "start-interactive-search", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "start-interactive-search", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "start-interactive-search", cbRefPtr)
 }
 // The given row is about to be collapsed (hide its children nodes). Use this
 // signal if you need to control the collapsibility of individual rows.
-func (x *TreeView) ConnectTestCollapseRow(cb func(TreeView, uintptr, uintptr) bool) uint32 {
+func (x *TreeView) ConnectTestCollapseRow(cb *func(TreeView, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "test-collapse-row", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, IterVarp, PathVarp)
+		return cbFn(fa, IterVarp, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "test-collapse-row", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "test-collapse-row", cbRefPtr)
 }
 // The given row is about to be expanded (show its children nodes). Use this
 // signal if you need to control the expandability of individual rows.
-func (x *TreeView) ConnectTestExpandRow(cb func(TreeView, uintptr, uintptr) bool) uint32 {
+func (x *TreeView) ConnectTestExpandRow(cb *func(TreeView, uintptr, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "test-expand-row", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, IterVarp, PathVarp)
+		return cbFn(fa, IterVarp, PathVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "test-expand-row", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "test-expand-row", cbRefPtr)
 }
-func (x *TreeView) ConnectToggleCursorRow(cb func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectToggleCursorRow(cb *func(TreeView) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
 }
-func (x *TreeView) ConnectUnselectAll(cb func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectUnselectAll(cb *func(TreeView) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := TreeView{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "unselect-all", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtktreeviewcolumn.go +15 -5

 package gtk
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 // setting the column value, and should set the value of @tree_column's
 // cell renderer as appropriate.  @func may be %NULL to remove an
 // older one.
-func (x *TreeViewColumn) SetCellDataFunc(CellRendererVar *CellRenderer, FuncVar TreeCellDataFunc, FuncDataVar uintptr, DestroyVar glib.DestroyNotify) {
+func (x *TreeViewColumn) SetCellDataFunc(CellRendererVar *CellRenderer, FuncVar *TreeCellDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xTreeViewColumnSetCellDataFunc(x.GoPointer(), CellRendererVar.GoPointer(), purego.NewCallback(FuncVar), FuncDataVar, purego.NewCallback(DestroyVar))
+	xTreeViewColumnSetCellDataFunc(x.GoPointer(), CellRendererVar.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
 }
 }
 // Emitted when the column's header has been clicked.
-func (x *TreeViewColumn) ConnectClicked(cb func(TreeViewColumn)) uint32 {
+func (x *TreeViewColumn) ConnectClicked(cb *func(TreeViewColumn)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := TreeViewColumn{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "clicked", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
 }
 // Gets the ID of the @buildable object.

M v4/gtk/gtkwidget.go +151 -47

 // initialization. It does not provide for user_data, if you need that,
 // you will have to use [method@GtkWidgetClass.add_shortcut] with a custom
 // shortcut.
-func (x *WidgetClass) AddBinding(KeyvalVar uint, ModsVar gdk.ModifierType, CallbackVar ShortcutFunc, FormatStringVar string, varArgs ...interface{}) {
+func (x *WidgetClass) AddBinding(KeyvalVar uint, ModsVar gdk.ModifierType, CallbackVar *ShortcutFunc, FormatStringVar string, varArgs ...interface{}) {
-	xWidgetClassAddBinding(x.GoPointer(), KeyvalVar, ModsVar, purego.NewCallback(CallbackVar), FormatStringVar, varArgs...)
+	xWidgetClassAddBinding(x.GoPointer(), KeyvalVar, ModsVar, glib.NewCallback(CallbackVar), FormatStringVar, varArgs...)
 }
 //
 // Note that this must be called from a composite widget classes
 // class initializer after calling [method@Gtk.WidgetClass.set_template].
-func (x *WidgetClass) BindTemplateCallbackFull(CallbackNameVar string, CallbackSymbolVar gobject.Callback) {
+func (x *WidgetClass) BindTemplateCallbackFull(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {
-	xWidgetClassBindTemplateCallbackFull(x.GoPointer(), CallbackNameVar, purego.NewCallback(CallbackSymbolVar))
+	xWidgetClassBindTemplateCallbackFull(x.GoPointer(), CallbackNameVar, glib.NewCallback(CallbackSymbolVar))
 }
 //
 // Actions installed by this function are stateless. The only state
 // they have is whether they are enabled or not.
-func (x *WidgetClass) InstallAction(ActionNameVar string, ParameterTypeVar string, ActivateVar WidgetActionActivateFunc) {
+func (x *WidgetClass) InstallAction(ActionNameVar string, ParameterTypeVar string, ActivateVar *WidgetActionActivateFunc) {
-	xWidgetClassInstallAction(x.GoPointer(), ActionNameVar, ParameterTypeVar, purego.NewCallback(ActivateVar))
+	xWidgetClassInstallAction(x.GoPointer(), ActionNameVar, ParameterTypeVar, glib.NewCallback(ActivateVar))
 }
 // This is a more convenient alternative to connecting directly to the
 // [signal@Gdk.FrameClock::update] signal of `GdkFrameClock`, since you
 // don't have to worry about when a `GdkFrameClock` is assigned to a widget.
-func (x *Widget) AddTickCallback(CallbackVar TickCallback, UserDataVar uintptr, NotifyVar glib.DestroyNotify) uint {
+func (x *Widget) AddTickCallback(CallbackVar *TickCallback, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) uint {
-	cret := xWidgetAddTickCallback(x.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, purego.NewCallback(NotifyVar))
+	cret := xWidgetAddTickCallback(x.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(NotifyVar))
 	return cret
 }
 // May result in finalization of the widget if all references are released.
 //
 // This signal is not suitable for saving widget state.
-func (x *Widget) ConnectDestroy(cb func(Widget)) uint32 {
+func (x *Widget) ConnectDestroy(cb *func(Widget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "destroy", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "destroy", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "destroy", cbRefPtr)
 }
 // Emitted when the text direction of a widget changes.
-func (x *Widget) ConnectDirectionChanged(cb func(Widget, TextDirection)) uint32 {
+func (x *Widget) ConnectDirectionChanged(cb *func(Widget, TextDirection)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "direction-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, PreviousDirectionVarp TextDirection) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, PreviousDirectionVarp)
+		cbFn(fa, PreviousDirectionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "direction-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "direction-changed", cbRefPtr)
 }
 // Emitted when @widget is hidden.
-func (x *Widget) ConnectHide(cb func(Widget)) uint32 {
+func (x *Widget) ConnectHide(cb *func(Widget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "hide", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "hide", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "hide", cbRefPtr)
 }
 // Emitted if keyboard navigation fails.
 //
 // See [method@Gtk.Widget.keynav_failed] for details.
-func (x *Widget) ConnectKeynavFailed(cb func(Widget, DirectionType) bool) uint32 {
+func (x *Widget) ConnectKeynavFailed(cb *func(Widget, DirectionType) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "keynav-failed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DirectionVarp DirectionType) bool {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, DirectionVarp)
+		return cbFn(fa, DirectionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "keynav-failed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "keynav-failed", cbRefPtr)
 }
 // Emitted when @widget is going to be mapped.
 // The ::map signal can be used to determine whether a widget will be drawn,
 // for instance it can resume an animation that was stopped during the
 // emission of [signal@Gtk.Widget::unmap].
-func (x *Widget) ConnectMap(cb func(Widget)) uint32 {
+func (x *Widget) ConnectMap(cb *func(Widget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "map", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "map", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "map", cbRefPtr)
 }
 // Emitted when a widget is activated via a mnemonic.
 //
 // The default handler for this signal activates @widget if @group_cycling
 // is %FALSE, or just makes @widget grab focus if @group_cycling is %TRUE.
-func (x *Widget) ConnectMnemonicActivate(cb func(Widget, bool) bool) uint32 {
+func (x *Widget) ConnectMnemonicActivate(cb *func(Widget, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "mnemonic-activate", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, GroupCyclingVarp bool) bool {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, GroupCyclingVarp)
+		return cbFn(fa, GroupCyclingVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "mnemonic-activate", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "mnemonic-activate", cbRefPtr)
 }
 // Emitted when the focus is moved.
-func (x *Widget) ConnectMoveFocus(cb func(Widget, DirectionType)) uint32 {
+func (x *Widget) ConnectMoveFocus(cb *func(Widget, DirectionType)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "move-focus", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, DirectionVarp DirectionType) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, DirectionVarp)
+		cbFn(fa, DirectionVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "move-focus", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "move-focus", cbRefPtr)
 }
 // Emitted when the widgets tooltip is about to be shown.
 //
 // The signal handler is free to manipulate @tooltip with the therefore
 // destined function calls.
-func (x *Widget) ConnectQueryTooltip(cb func(Widget, int, int, bool, uintptr) bool) uint32 {
+func (x *Widget) ConnectQueryTooltip(cb *func(Widget, int, int, bool, uintptr) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "query-tooltip", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, XVarp int, YVarp int, KeyboardModeVarp bool, TooltipVarp uintptr) bool {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, XVarp, YVarp, KeyboardModeVarp, TooltipVarp)
+		return cbFn(fa, XVarp, YVarp, KeyboardModeVarp, TooltipVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "query-tooltip", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "query-tooltip", cbRefPtr)
 }
 // Emitted when @widget is associated with a `GdkSurface`.
 //
 // This means that [method@Gtk.Widget.realize] has been called
 // or the widget has been mapped (that is, it is going to be drawn).
-func (x *Widget) ConnectRealize(cb func(Widget)) uint32 {
+func (x *Widget) ConnectRealize(cb *func(Widget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "realize", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "realize", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "realize", cbRefPtr)
 }
 // Emitted when @widget is shown.
-func (x *Widget) ConnectShow(cb func(Widget)) uint32 {
+func (x *Widget) ConnectShow(cb *func(Widget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "show", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "show", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "show", cbRefPtr)
 }
 // Emitted when the widget state changes.
 //
 // See [method@Gtk.Widget.get_state_flags].
-func (x *Widget) ConnectStateFlagsChanged(cb func(Widget, StateFlags)) uint32 {
+func (x *Widget) ConnectStateFlagsChanged(cb *func(Widget, StateFlags)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "state-flags-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, FlagsVarp StateFlags) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa, FlagsVarp)
+		cbFn(fa, FlagsVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "state-flags-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "state-flags-changed", cbRefPtr)
 }
 // Emitted when @widget is going to be unmapped.
 //
 // As ::unmap indicates that a widget will not be shown any longer,
 // it can be used to, for example, stop an animation on the widget.
-func (x *Widget) ConnectUnmap(cb func(Widget)) uint32 {
+func (x *Widget) ConnectUnmap(cb *func(Widget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "unmap", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "unmap", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "unmap", cbRefPtr)
 }
 // Emitted when the `GdkSurface` associated with @widget is destroyed.
 //
 // This means that [method@Gtk.Widget.unrealize] has been called
 // or the widget has been unmapped (that is, it is going to be hidden).
-func (x *Widget) ConnectUnrealize(cb func(Widget)) uint32 {
+func (x *Widget) ConnectUnrealize(cb *func(Widget)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "unrealize", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Widget{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "unrealize", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "unrealize", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/gtk/gtkwindow.go +55 -15

 // of @window.
 //
 // This is a [keybinding signal](class.SignalAction.html).
-func (x *Window) ConnectActivateDefault(cb func(Window)) uint32 {
+func (x *Window) ConnectActivateDefault(cb *func(Window)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Window{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-default", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
 }
 // Emitted when the user activates the currently focused
 // widget of @window.
 //
 // This is a [keybinding signal](class.SignalAction.html).
-func (x *Window) ConnectActivateFocus(cb func(Window)) uint32 {
+func (x *Window) ConnectActivateFocus(cb *func(Window)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "activate-focus", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Window{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "activate-focus", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "activate-focus", cbRefPtr)
 }
 // Emitted when the user clicks on the close button of the window.
-func (x *Window) ConnectCloseRequest(cb func(Window) bool) uint32 {
+func (x *Window) ConnectCloseRequest(cb *func(Window) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "close-request", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) bool {
 		fa := Window{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa)
+		return cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "close-request", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "close-request", cbRefPtr)
 }
 // Emitted when the user enables or disables interactive debugging.
 //
 // The default bindings for this signal are Ctrl-Shift-I
 // and Ctrl-Shift-D.
-func (x *Window) ConnectEnableDebugging(cb func(Window, bool) bool) uint32 {
+func (x *Window) ConnectEnableDebugging(cb *func(Window, bool) bool) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "enable-debugging", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr, ToggleVarp bool) bool {
 		fa := Window{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		return cb(fa, ToggleVarp)
+		return cbFn(fa, ToggleVarp)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "enable-debugging", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "enable-debugging", cbRefPtr)
 }
 // emitted when the set of accelerators or mnemonics that
 // are associated with @window changes.
-func (x *Window) ConnectKeysChanged(cb func(Window)) uint32 {
+func (x *Window) ConnectKeysChanged(cb *func(Window)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), "keys-changed", cbRefPtr)
+	}
 	fcb := func(clsPtr uintptr) {
 		fa := Window{}
 		fa.Ptr = clsPtr
+		cbFn := *cb
-		cb(fa)
+		cbFn(fa)
 	}
-	return gobject.SignalConnect(x.GoPointer(), "keys-changed", purego.NewCallback(fcb))
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), "keys-changed", cbRefPtr)
 }
 // Retrieves the `GtkAccessibleRole` for the given `GtkAccessible`.

M v4/pango/pango-attributes.go +4 -4


@@ -265,9 +265,9 @@ var xAttrListFilter func(uintptr, uintptr, uintptr) *AttrList
265		// Given a `PangoAttrList` and callback function, removes	265		// Given a `PangoAttrList` and callback function, removes
266		// any elements of @list for which @func returns %TRUE and	266		// any elements of @list for which @func returns %TRUE and
267		// inserts them into a new list.	267		// inserts them into a new list.
268	-	func (x AttrList) Filter(FuncVar AttrFilterFunc, DataVar uintptr) AttrList {	268	+	func (x AttrList) Filter(FuncVar AttrFilterFunc, DataVar uintptr) *AttrList {
269			269
270	-	cret := xAttrListFilter(x.GoPointer(), purego.NewCallback(FuncVar), DataVar)	270	+	cret := xAttrListFilter(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
271		return cret	271		return cret
272		}	272		}
273			273

@@ -1110,9 +1110,9 @@ var xAttrShapeNewWithData func(Rectangle, Rectangle, uintptr, uintptr, uintptr
1110		// Like [func@Pango.AttrShape.new], but a user data pointer	1110		// Like [func@Pango.AttrShape.new], but a user data pointer
1111		// is also provided; this pointer can be accessed when later	1111		// is also provided; this pointer can be accessed when later
1112		// rendering the glyph.	1112		// rendering the glyph.
1113	-	func AttrShapeNewWithData(InkRectVar Rectangle, LogicalRectVar Rectangle, DataVar uintptr, CopyFuncVar AttrDataCopyFunc, DestroyFuncVar glib.DestroyNotify) *Attribute {	1113	+	func AttrShapeNewWithData(InkRectVar Rectangle, LogicalRectVar Rectangle, DataVar uintptr, CopyFuncVar AttrDataCopyFunc, DestroyFuncVar glib.DestroyNotify) *Attribute {
1114			1114
1115	-	cret := xAttrShapeNewWithData(InkRectVar, LogicalRectVar, DataVar, purego.NewCallback(CopyFuncVar), purego.NewCallback(DestroyFuncVar))	1115	+	cret := xAttrShapeNewWithData(InkRectVar, LogicalRectVar, DataVar, glib.NewCallback(CopyFuncVar), glib.NewCallback(DestroyFuncVar))
1116		return cret	1116		return cret
1117		}	1117		}
1118			1118

M v4/pango/pango-fontset.go +3 -2

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/internal/core"
+	"github.com/jwijenbergh/puregotk/v4/glib"
 	"github.com/jwijenbergh/puregotk/v4/gobject"
 )
 // each one.
 //
 // If @func returns %TRUE, that stops the iteration.
-func (x *Fontset) Foreach(FuncVar FontsetForeachFunc, DataVar uintptr) {
+func (x *Fontset) Foreach(FuncVar *FontsetForeachFunc, DataVar uintptr) {
-	xFontsetForeach(x.GoPointer(), purego.NewCallback(FuncVar), DataVar)
+	xFontsetForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
 }

M v4/pangocairo/pangocairo.go +2 -2


@@ -213,9 +213,9 @@ var xContextSetShapeRenderer func(uintptr, uintptr, uintptr, uintptr)
213		// of type %PANGO_ATTR_SHAPE.	213		// of type %PANGO_ATTR_SHAPE.
214		//	214		//
215		// See `PangoCairoShapeRendererFunc` for details.	215		// See `PangoCairoShapeRendererFunc` for details.
216	-	func ContextSetShapeRenderer(ContextVar *pango.Context, FuncVar ShapeRendererFunc, DataVar uintptr, DnotifyVar glib.DestroyNotify) {	216	+	func ContextSetShapeRenderer(ContextVar pango.Context, FuncVar ShapeRendererFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) {
217			217
218	-	xContextSetShapeRenderer(ContextVar.GoPointer(), purego.NewCallback(FuncVar), DataVar, purego.NewCallback(DnotifyVar))	218	+	xContextSetShapeRenderer(ContextVar.GoPointer(), glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DnotifyVar))
219			219
220		}	220		}
221			221