759f3c2 build(gen) regenerate bindings with bug fixes · purego

M v4/adw/adw-about-dialog.go +7 -3

 //
 // Applications may connect to it to override the default behavior, 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, UriVarp string) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, UriVarp string) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/adw/adw-action-row.go +7 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/adw/adw-alert-dialog.go +14 -6

 // 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@AlertDialog:close-response].
-func (x *AlertDialog) ConnectResponse(cb *func(AlertDialog, string)) uint32 {
+func (x *AlertDialog) ConnectResponse(cb *func(AlertDialog, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResponseVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // ConnectResponseWithDetail connects to the "response" signal with a detail string.
 // The detail is appended as "response::<detail>".
-func (x *AlertDialog) ConnectResponseWithDetail(detail string, cb *func(AlertDialog, string)) uint32 {
+func (x *AlertDialog) ConnectResponseWithDetail(detail string, cb *func(AlertDialog, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	signalName := fmt.Sprintf("response::%s", detail)
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResponseVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/adw/adw-banner.go +7 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/adw/adw-bottom-sheet.go +7 -3

 // Emitted when the close button or shortcut is used while
 // [property@Dialog:can-close] is set to `FALSE`.
-func (x *BottomSheet) ConnectCloseAttempt(cb *func(BottomSheet)) uint32 {
+func (x *BottomSheet) ConnectCloseAttempt(cb *func(BottomSheet)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "close-attempt", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "close-attempt", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "close-attempt", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "close-attempt", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the progress @self will snap back to after the gesture is canceled.

M v4/adw/adw-breakpoint.go +14 -6

 // Emitted when the breakpoint is applied.
 //
 // This signal is emitted after the setters have been applied.
-func (x *Breakpoint) ConnectApply(cb *func(Breakpoint)) uint32 {
+func (x *Breakpoint) ConnectApply(cb *func(Breakpoint)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the breakpoint is unapplied.
 //
 // This signal is emitted before resetting the setter values.
-func (x *Breakpoint) ConnectUnapply(cb *func(Breakpoint)) uint32 {
+func (x *Breakpoint) ConnectUnapply(cb *func(Breakpoint)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unapply", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unapply", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unapply", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unapply", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the ID of the @buildable object.

M v4/adw/adw-button-row.go +7 -3

 }
 // This signal is emitted after the row has been activated.
-func (x *ButtonRow) ConnectActivated(cb *func(ButtonRow)) uint32 {
+func (x *ButtonRow) ConnectActivated(cb *func(ButtonRow)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // ::: note
 //
 //	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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "page-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "page-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, IndexVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "page-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "page-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the progress @self will snap back to after the gesture is canceled.

M v4/adw/adw-dialog.go +14 -6

 // Emitted when the close button or shortcut is used, or
 // [method@Dialog.close] is called while [property@Dialog:can-close] is set to
 // `FALSE`.
-func (x *Dialog) ConnectCloseAttempt(cb *func(Dialog)) uint32 {
+func (x *Dialog) ConnectCloseAttempt(cb *func(Dialog)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "close-attempt", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "close-attempt", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "close-attempt", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "close-attempt", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the dialog is successfully closed.
-func (x *Dialog) ConnectClosed(cb *func(Dialog)) uint32 {
+func (x *Dialog) ConnectClosed(cb *func(Dialog)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/adw/adw-entry-row.go +14 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the embedded entry is activated.
-func (x *EntryRow) ConnectEntryActivated(cb *func(EntryRow)) uint32 {
+func (x *EntryRow) ConnectEntryActivated(cb *func(EntryRow)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "entry-activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "entry-activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "entry-activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "entry-activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResponseVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // ConnectResponseWithDetail connects to the "response" signal with a detail string.
 // The detail is appended as "response::<detail>".
-func (x *MessageDialog) ConnectResponseWithDetail(detail string, cb *func(MessageDialog, string)) uint32 {
+func (x *MessageDialog) ConnectResponseWithDetail(detail string, cb *func(MessageDialog, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	signalName := fmt.Sprintf("response::%s", detail)
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResponseVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/adw/adw-navigation-view.go +56 -24

 //
 // It will always be preceded by [signal@NavigationPage::hiding] or
 // [signal@NavigationPage::showing].
-func (x *NavigationPage) ConnectHidden(cb *func(NavigationPage)) uint32 {
+func (x *NavigationPage) ConnectHidden(cb *func(NavigationPage)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "hidden", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "hidden", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "hidden", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "hidden", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the page starts hiding at the beginning of the navigation view
 //
 // It will always be followed by [signal@NavigationPage::hidden] or
 // [signal@NavigationPage::shown].
-func (x *NavigationPage) ConnectHiding(cb *func(NavigationPage)) uint32 {
+func (x *NavigationPage) ConnectHiding(cb *func(NavigationPage)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "hiding", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "hiding", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "hiding", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "hiding", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the page shows at the beginning of the navigation view
 //
 // It will always be followed by [signal@NavigationPage::shown] or
 // [signal@NavigationPage::hidden].
-func (x *NavigationPage) ConnectShowing(cb *func(NavigationPage)) uint32 {
+func (x *NavigationPage) ConnectShowing(cb *func(NavigationPage)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "showing", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "showing", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "showing", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "showing", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the navigation view transition has been completed and the page
 //
 // It will always be preceded by [signal@NavigationPage::showing] or
 // [signal@NavigationPage::hiding].
-func (x *NavigationPage) ConnectShown(cb *func(NavigationPage)) uint32 {
+func (x *NavigationPage) ConnectShown(cb *func(NavigationPage)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "shown", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "shown", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "shown", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "shown", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.
 // from a forward stack.
 //
 // Instead, it should be done in the [signal@NavigationView::pushed] handler.
-func (x *NavigationView) ConnectGetNextPage(cb *func(NavigationView) NavigationPage) uint32 {
+func (x *NavigationView) ConnectGetNextPage(cb *func(NavigationView) NavigationPage) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "get-next-page", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "get-next-page", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) uintptr {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "get-next-page", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "get-next-page", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted after @page has been popped from the navigation stack.
 // When using [method@NavigationView.pop_to_page] or
 // [method@NavigationView.pop_to_tag], this signal is emitted for each of the
 // popped pages.
-func (x *NavigationView) ConnectPopped(cb *func(NavigationView, uintptr)) uint32 {
+func (x *NavigationView) ConnectPopped(cb *func(NavigationView, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "popped", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "popped", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "popped", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "popped", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted after a page has been pushed to the navigation stack.
 //
 // See [method@NavigationView.push].
-func (x *NavigationView) ConnectPushed(cb *func(NavigationView)) uint32 {
+func (x *NavigationView) ConnectPushed(cb *func(NavigationView)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "pushed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "pushed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "pushed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "pushed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted after the navigation stack has been replaced.
 //
 // See [method@NavigationView.replace].
-func (x *NavigationView) ConnectReplaced(cb *func(NavigationView)) uint32 {
+func (x *NavigationView) ConnectReplaced(cb *func(NavigationView)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "replaced", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "replaced", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "replaced", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "replaced", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the progress @self will snap back to after the gesture is canceled.

M v4/adw/adw-spin-row.go +21 -9

 // The default conversion uses [func@GLib.strtod].
 //
 // See [signal@Gtk.SpinButton::input].
-func (x *SpinRow) ConnectInput(cb *func(SpinRow, *float64) int) uint32 {
+func (x *SpinRow) ConnectInput(cb *func(SpinRow, *float64) int) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, NewValueVarp *float64) int {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted to tweak the formatting of the value for display.
 //
 // See [signal@Gtk.SpinButton::output].
-func (x *SpinRow) ConnectOutput(cb *func(SpinRow) bool) uint32 {
+func (x *SpinRow) ConnectOutput(cb *func(SpinRow) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted right after the spinbutton wraps.
 //
 // See [signal@Gtk.SpinButton::wrapped].
-func (x *SpinRow) ConnectWrapped(cb *func(SpinRow)) uint32 {
+func (x *SpinRow) ConnectWrapped(cb *func(SpinRow)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/adw/adw-split-button.go +14 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "begin-swipe", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "begin-swipe", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "begin-swipe", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "begin-swipe", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "end-swipe", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "end-swipe", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, VelocityVarp float64, ToVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "end-swipe", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "end-swipe", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DirectionVarp NavigationDirection) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "update-swipe", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "update-swipe", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ProgressVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "update-swipe", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "update-swipe", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Retrieves the orientation of the @orientable.

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

 // [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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, ValueVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, ValueVarp uintptr) gdk.DragAction {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/adw/adw-tab-button.go +14 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "create-tab", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "create-tab", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) uintptr {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "create-tab", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "create-tab", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, ValueVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "extra-drag-drop", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, ValueVarp uintptr) gdk.DragAction {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "extra-drag-value", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // The signal handler should return `GDK_EVENT_STOP` to stop propagation or
 // `GDK_EVENT_CONTINUE` to invoke the default handler.
-func (x *TabView) ConnectClosePage(cb *func(TabView, uintptr) bool) uint32 {
+func (x *TabView) ConnectClosePage(cb *func(TabView, uintptr) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "close-page", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "close-page", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "close-page", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "close-page", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) uintptr {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "indicator-activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "indicator-activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "indicator-activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "indicator-activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "page-attached", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "page-attached", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, PositionVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "page-attached", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "page-attached", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "page-detached", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "page-detached", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, PositionVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "page-detached", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "page-detached", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, PositionVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "setup-menu", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "setup-menu", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "setup-menu", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "setup-menu", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/adw/adw-toast.go +14 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "button-clicked", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the toast has been dismissed.
-func (x *Toast) ConnectDismissed(cb *func(Toast)) uint32 {
+func (x *Toast) ConnectDismissed(cb *func(Toast)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "dismissed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "dismissed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "dismissed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "dismissed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/cairo/main.go +1 -1


@@ -185,7 +185,7 @@ func (x *RectangleInt) GoPointer() uintptr {
185		type Glyph struct {	185		type Glyph struct {
186		_ structs.HostLayout	186		_ structs.HostLayout
187			187
188	-	Index uint32	188	+	Index uint
189			189
190		X float64	190		X float64
191			191

M v4/gdk/gdkclipboard.go +7 -3

 }
 // Emitted when the clipboard changes ownership.
-func (x *Clipboard) ConnectChanged(cb *func(Clipboard)) uint32 {
+func (x *Clipboard) ConnectChanged(cb *func(Clipboard)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gdk/gdkcontentprovider.go +7 -3

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "content-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "content-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "content-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "content-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "tool-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "tool-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ToolVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "tool-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "tool-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, IsErrorVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "opened", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "opened", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "opened", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "opened", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "seat-added", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "seat-added", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SeatVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "seat-added", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "seat-added", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "seat-removed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "seat-removed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SeatVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "seat-removed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "seat-removed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted whenever a setting changes its value.
-func (x *Display) ConnectSettingChanged(cb *func(Display, string)) uint32 {
+func (x *Display) ConnectSettingChanged(cb *func(Display, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "setting-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "setting-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SettingVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "setting-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "setting-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xDisplayGetDefault func() uintptr

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

 }
 // Emitted when a display is opened.
-func (x *DisplayManager) ConnectDisplayOpened(cb *func(DisplayManager, uintptr)) uint32 {
+func (x *DisplayManager) ConnectDisplayOpened(cb *func(DisplayManager, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "display-opened", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "display-opened", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DisplayVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "display-opened", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "display-opened", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xDisplayManagerGet func() uintptr

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

 }
 // Emitted when the drag operation is cancelled.
-func (x *Drag) ConnectCancel(cb *func(Drag, DragCancelReason)) uint32 {
+func (x *Drag) ConnectCancel(cb *func(Drag, DragCancelReason)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ReasonVarp DragCancelReason) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "dnd-finished", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "dnd-finished", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "dnd-finished", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "dnd-finished", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drop-performed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drop-performed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drop-performed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drop-performed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xDragBegin func(uintptr, uintptr, uintptr, DragAction, float64, float64) uintptr

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "after-paint", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "after-paint", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "after-paint", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "after-paint", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "before-paint", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "before-paint", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "before-paint", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "before-paint", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "flush-events", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "flush-events", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "flush-events", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "flush-events", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted as the third step of toolkit and application processing
 // emits [signal@Gdk.Surface::render] signals which are turned into
 // [GtkWidget::snapshot](../gtk4/signal.Widget.snapshot.html) signals
 // by GTK.
-func (x *FrameClock) ConnectPaint(cb *func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectPaint(cb *func(FrameClock)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "paint", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "paint", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "paint", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "paint", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "resume-events", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "resume-events", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "resume-events", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "resume-events", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted as the first step of toolkit and application processing
 // Applications can connect directly to this signal, or use
 // [gtk_widget_add_tick_callback()](../gtk4/method.Widget.add_tick_callback.html)
 // as a more convenient interface.
-func (x *FrameClock) ConnectUpdate(cb *func(FrameClock)) uint32 {
+func (x *FrameClock) ConnectUpdate(cb *func(FrameClock)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // Emitted when the output represented by @monitor gets disconnected.
-func (x *Monitor) ConnectInvalidate(cb *func(Monitor)) uint32 {
+func (x *Monitor) ConnectInvalidate(cb *func(Monitor)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "invalidate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "invalidate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "invalidate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "invalidate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "device-added", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "device-added", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DeviceVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "device-added", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "device-added", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "device-removed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "device-removed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DeviceVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "device-removed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "device-removed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "tool-added", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "tool-added", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ToolVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "tool-added", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "tool-added", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "tool-removed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "tool-removed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ToolVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "tool-removed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "tool-removed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gdk/gdksurface.go +35 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "enter-monitor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "enter-monitor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MonitorVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "enter-monitor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "enter-monitor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, EventVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WidthVarp int, HeightVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "layout", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "leave-monitor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "leave-monitor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MonitorVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "leave-monitor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "leave-monitor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, RegionVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "images-updated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "images-updated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "images-updated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "images-updated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gdkpixbuf/gdk-pixbuf-loader.go +28 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "area-prepared", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "area-prepared", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "area-prepared", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "area-prepared", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "area-updated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "area-updated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp int, YVarp int, WidthVarp int, HeightVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "area-updated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "area-updated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "size-prepared", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "size-prepared", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WidthVarp int, HeightVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "size-prepared", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "size-prepared", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gio/gappinfo.go +28 -12

 // Signal emitted when the app info database changes, when applications are
 // installed or removed.
-func (x *AppInfoMonitor) ConnectChanged(cb *func(AppInfoMonitor)) uint32 {
+func (x *AppInfoMonitor) ConnectChanged(cb *func(AppInfoMonitor)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xAppInfoMonitorGet func() uintptr
 // Because a launch operation may involve spawning multiple instances of the
 // target application, you should expect this signal to be emitted multiple
 // times, one for each spawned instance.
-func (x *AppLaunchContext) ConnectLaunchFailed(cb *func(AppLaunchContext, string)) uint32 {
+func (x *AppLaunchContext) ConnectLaunchFailed(cb *func(AppLaunchContext, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "launch-failed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "launch-failed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StartupNotifyIdVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "launch-failed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "launch-failed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // The [signal@Gio.AppLaunchContext::launch-started] signal is emitted when a
 // Because a launch operation may involve spawning multiple instances of the
 // target application, you should expect this signal to be emitted multiple
 // times, one for each spawned instance.
-func (x *AppLaunchContext) ConnectLaunchStarted(cb *func(AppLaunchContext, uintptr, uintptr)) uint32 {
+func (x *AppLaunchContext) ConnectLaunchStarted(cb *func(AppLaunchContext, uintptr, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "launch-started", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "launch-started", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, InfoVarp uintptr, PlatformDataVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "launch-started", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "launch-started", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // The [signal@Gio.AppLaunchContext::launched] signal is emitted when a
 // is emitted, GLib will call [func@GLib.spawn_close_pid]. If you need to
 // keep the [alias@GLib.Pid] after the signal has been emitted, then you can
 // duplicate `pid` using `DuplicateHandle()`.
-func (x *AppLaunchContext) ConnectLaunched(cb *func(AppLaunchContext, uintptr, uintptr)) uint32 {
+func (x *AppLaunchContext) ConnectLaunched(cb *func(AppLaunchContext, uintptr, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "launched", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "launched", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, InfoVarp uintptr, PlatformDataVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "launched", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "launched", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gio/gapplication.go +49 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "command-line", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "command-line", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, CommandLineVarp uintptr) int {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "command-line", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "command-line", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "handle-local-options", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "handle-local-options", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, OptionsVarp uintptr) int {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "handle-local-options", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "handle-local-options", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "name-lost", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "name-lost", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "name-lost", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "name-lost", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "open", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "open", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, FilesVarp uintptr, NFilesVarp int, HintVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "open", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "open", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "shutdown", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "shutdown", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "shutdown", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "shutdown", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "startup", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "startup", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "startup", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "startup", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emits the [signal@Gio.ActionGroup::action-added] signal on @action_group.

M v4/gio/gcancellable.go +11 -7

 }
-var xCancellableConnect func(uintptr, uintptr, uintptr, uintptr) uint32
+var xCancellableConnect func(uintptr, uintptr, uintptr, uintptr) uint
 // Convenience function to connect to the #GCancellable::cancelled
 // signal. Also handles the race condition that may happen
 //   - [method@Gio.Cancellable.reset]
 //   - [method@Gio.Cancellable.make_pollfd]
 //   - [method@Gio.Cancellable.release_fd]
-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) uint {
 	var CallbackVarRef uintptr
 	if CallbackVar != nil {
 	return cret
 }
-var xCancellableDisconnect func(uintptr, uint32)
+var xCancellableDisconnect func(uintptr, uint)
 // Disconnects a handler from a cancellable instance similar to
 // g_signal_handler_disconnect().  Additionally, in the event that a
 //
 // If @cancellable is %NULL or @handler_id is `0` this function does
 // nothing.
-func (x *Cancellable) Disconnect(HandlerIdVar uint32) {
+func (x *Cancellable) Disconnect(HandlerIdVar uint) {
 	xCancellableDisconnect(x.GoPointer(), HandlerIdVar)
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xCancellableGetCurrent func() uintptr

M v4/gio/gdbusauthobserver.go +14 -6

 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "allow-mechanism", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "allow-mechanism", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MechanismVarp string) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "allow-mechanism", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "allow-mechanism", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "authorize-authenticated-peer", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "authorize-authenticated-peer", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StreamVarp uintptr, CredentialsVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "authorize-authenticated-peer", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "authorize-authenticated-peer", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gio/gdbusconnection.go +7 -3

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, RemotePeerVanishedVarp bool, ErrorVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Starts asynchronous initialization of the object implementing the

M v4/gio/gdbusinterfaceskeleton.go +7 -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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "g-authorize-method", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "g-authorize-method", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, InvocationVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "g-authorize-method", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "g-authorize-method", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the #GDBusObject that @interface_ belongs to, if any.

M v4/gio/gdbusobjectmanagerclient.go +14 -6

 // This signal is emitted in the thread-default main context
 // (see [method@GLib.MainContext.push_thread_default])
 // that @manager was constructed in.
-func (x *DBusObjectManagerClient) ConnectInterfaceProxyPropertiesChanged(cb *func(DBusObjectManagerClient, uintptr, uintptr, uintptr, []string)) uint32 {
+func (x *DBusObjectManagerClient) ConnectInterfaceProxyPropertiesChanged(cb *func(DBusObjectManagerClient, uintptr, uintptr, uintptr, []string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "interface-proxy-properties-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "interface-proxy-properties-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ObjectProxyVarp uintptr, InterfaceProxyVarp uintptr, ChangedPropertiesVarp uintptr, InvalidatedPropertiesVarp []string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "interface-proxy-properties-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "interface-proxy-properties-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a D-Bus signal is received on @interface_proxy.
 // This signal is emitted in the thread-default main context
 // (see [method@GLib.MainContext.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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "interface-proxy-signal", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "interface-proxy-signal", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ObjectProxyVarp uintptr, InterfaceProxyVarp uintptr, SenderNameVarp string, SignalNameVarp string, ParametersVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "interface-proxy-signal", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "interface-proxy-signal", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Starts asynchronous initialization of the object implementing the

M v4/gio/gdbusobjectskeleton.go +7 -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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "authorize-method", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "authorize-method", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, InterfaceVarp uintptr, InvocationVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "authorize-method", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "authorize-method", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the D-Bus interface with name @interface_name associated with

M v4/gio/gdbusproxy.go +21 -9

 // This signal corresponds to the
 // `PropertiesChanged` D-Bus signal on the
 // `org.freedesktop.DBus.Properties` interface.
-func (x *DBusProxy) ConnectGPropertiesChanged(cb *func(DBusProxy, uintptr, []string)) uint32 {
+func (x *DBusProxy) ConnectGPropertiesChanged(cb *func(DBusProxy, uintptr, []string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "g-properties-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "g-properties-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ChangedPropertiesVarp uintptr, InvalidatedPropertiesVarp []string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "g-properties-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "g-properties-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "g-signal", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "g-signal", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SenderNameVarp string, SignalNameVarp string, ParametersVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "g-signal", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "g-signal", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // ConnectGSignalWithDetail connects to the "g-signal" signal with a detail string.
 // The detail is appended as "g-signal::<detail>".
-func (x *DBusProxy) ConnectGSignalWithDetail(detail string, cb *func(DBusProxy, string, string, uintptr)) uint32 {
+func (x *DBusProxy) ConnectGSignalWithDetail(detail string, cb *func(DBusProxy, string, string, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	signalName := fmt.Sprintf("g-signal::%s", detail)
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SenderNameVarp string, SignalNameVarp string, ParametersVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Starts asynchronous initialization of the object implementing the

M v4/gio/gdbusserver.go +7 -3

 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "new-connection", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "new-connection", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ConnectionVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "new-connection", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "new-connection", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Initializes the object implementing the interface.

M v4/gio/gdebugcontrollerdbus.go +7 -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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "authorize", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "authorize", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, InvocationVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "authorize", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "authorize", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Get the value of #GDebugController:debug-enabled.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, FileVarp uintptr, OtherFileVarp uintptr, EventTypeVarp FileMonitorEvent) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // Emitted when the file name completion information comes available.
-func (x *FilenameCompleter) ConnectGotCompletionData(cb *func(FilenameCompleter)) uint32 {
+func (x *FilenameCompleter) ConnectGotCompletionData(cb *func(FilenameCompleter)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "got-completion-data", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "got-completion-data", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "got-completion-data", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "got-completion-data", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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


@@ -389,10 +389,10 @@ func (x *MemoryOutputStream) GetPropertyData() uintptr {
389			389
390		// GetPropertyDataSize gets the "data-size" property.	390		// GetPropertyDataSize gets the "data-size" property.
391		// Size of data written to the buffer.	391		// Size of data written to the buffer.
392	-	func (x *MemoryOutputStream) GetPropertyDataSize() uint32 {	392	+	func (x *MemoryOutputStream) GetPropertyDataSize() uint {
393		var v gobject.Value	393		var v gobject.Value
394		x.GetProperty("data-size", &v)	394		x.GetProperty("data-size", &v)
395	-	return v.GetUlong()	395	+	return v.GetUint()
396		}	396		}
397			397
398		// SetPropertyDestroyFunction sets the "destroy-function" property.	398		// SetPropertyDestroyFunction sets the "destroy-function" property.

@@ -431,19 +431,19 @@ func (x *MemoryOutputStream) GetPropertyReallocFunction() uintptr {
431			431
432		// SetPropertySize sets the "size" property.	432		// SetPropertySize sets the "size" property.
433		// Current size of the data buffer.	433		// Current size of the data buffer.
434	-	func (x *MemoryOutputStream) SetPropertySize(value uint32) {	434	+	func (x *MemoryOutputStream) SetPropertySize(value uint) {
435		var v gobject.Value	435		var v gobject.Value
436	-	v.Init(gobject.TypeUlongVal)	436	+	v.Init(gobject.TypeUintVal)
437	-	v.SetUlong(value)	437	+	v.SetUint(value)
438		x.SetProperty("size", &v)	438		x.SetProperty("size", &v)
439		}	439		}
440			440
441		// GetPropertySize gets the "size" property.	441		// GetPropertySize gets the "size" property.
442		// Current size of the data buffer.	442		// Current size of the data buffer.
443	-	func (x *MemoryOutputStream) GetPropertySize() uint32 {	443	+	func (x *MemoryOutputStream) GetPropertySize() uint {
444		var v gobject.Value	444		var v gobject.Value
445		x.GetProperty("size", &v)	445		x.GetProperty("size", &v)
446	-	return v.GetUlong()	446	+	return v.GetUint()
447		}	447		}
448			448
449		// Checks if @stream is actually pollable. Some classes may implement	449		// Checks if @stream is actually pollable. Some classes may implement

M v4/gio/gmenumodel.go +7 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "items-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "items-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PositionVarp int, RemovedVarp int, AddedVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "items-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "items-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "aborted", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "aborted", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "aborted", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "aborted", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "ask-password", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "ask-password", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MessageVarp string, DefaultUserVarp string, DefaultDomainVarp string, FlagsVarp AskPasswordFlags) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "ask-password", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "ask-password", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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, []string)) uint32 {
+func (x *MountOperation) ConnectAskQuestion(cb *func(MountOperation, string, []string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "ask-question", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "ask-question", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MessageVarp string, ChoicesVarp []string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "ask-question", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "ask-question", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "reply", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "reply", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResultVarp MountOperationResult) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "reply", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "reply", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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, []glib.Pid, []string)) uint32 {
+func (x *MountOperation) ConnectShowProcesses(cb *func(MountOperation, string, []glib.Pid, []string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "show-processes", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "show-processes", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MessageVarp string, ProcessesVarp []glib.Pid, ChoicesVarp []string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "show-processes", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "show-processes", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "show-unmount-progress", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "show-unmount-progress", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MessageVarp string, TimeLeftVarp int64, BytesLeftVarp int64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "show-unmount-progress", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "show-unmount-progress", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gio/gresolver.go +7 -3

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "reload", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "reload", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "reload", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "reload", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xResolverFreeAddresses func(*glib.List)

M v4/gio/gsettings.go +42 -18

 // The default handler for this signal invokes the [signal@Gio.Settings::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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "change-event", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "change-event", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, KeysVarp uintptr, NKeysVarp int) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "change-event", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "change-event", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, KeyVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // ConnectChangedWithDetail connects to the "changed" signal with a detail string.
 // The detail is appended as "changed::<detail>".
-func (x *Settings) ConnectChangedWithDetail(detail string, cb *func(Settings, string)) uint32 {
+func (x *Settings) ConnectChangedWithDetail(detail string, cb *func(Settings, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	signalName := fmt.Sprintf("changed::%s", detail)
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, KeyVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted once per writability change event that affects this settings object.
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "writable-change-event", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "writable-change-event", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, KeyVarp uint) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "writable-change-event", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "writable-change-event", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the writability of a key has potentially changed.
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "writable-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "writable-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, KeyVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "writable-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "writable-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // ConnectWritableChangedWithDetail connects to the "writable-changed" signal with a detail string.
 // The detail is appended as "writable-changed::<detail>".
-func (x *Settings) ConnectWritableChangedWithDetail(detail string, cb *func(Settings, string)) uint32 {
+func (x *Settings) ConnectWritableChangedWithDetail(detail string, cb *func(Settings, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	signalName := fmt.Sprintf("writable-changed::%s", detail)
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, KeyVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xSettingsListRelocatableSchemas func() []string

M v4/gio/gsimpleaction.go +14 -6

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ParameterVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "change-state", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "change-state", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ValueVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "change-state", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "change-state", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Activates the action.

M v4/gio/gsocketclient.go +7 -3

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, EventVarp SocketClientEvent, ConnectableVarp uintptr, ConnectionVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, EventVarp SocketListenerEvent, SocketVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 //
 // @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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "incoming", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "incoming", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ConnectionVarp uintptr, SourceObjectVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "incoming", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "incoming", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "run", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "run", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ConnectionVarp uintptr, SourceObjectVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "run", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "run", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gio/gtlscertificate.go +28 -4

 	if ptr == 0 {
 		return nil
 	}
-	return unsafe.Slice((*byte)(unsafe.Pointer(ptr)), 0)[:0]
+	// GByteArray layout: { guint8 *data; guint len; }
+	dataPtr := *(*uintptr)(unsafe.Pointer(ptr))
+	length := *(*uint32)(unsafe.Pointer(ptr + unsafe.Sizeof(uintptr(0))))
+	if length == 0 || dataPtr == 0 {
+		return nil
+	}
+	return unsafe.Slice((*byte)(unsafe.Pointer(dataPtr)), length)
 }
 // SetPropertyCertificatePem sets the "certificate-pem" property.
 	if ptr == 0 {
 		return nil
 	}
-	return unsafe.Slice((*uintptr)(unsafe.Pointer(ptr)), 0)[:0]
+	// GPtrArray layout: { gpointer *pdata; guint len; }
+	dataPtr := *(*uintptr)(unsafe.Pointer(ptr))
+	length := *(*uint32)(unsafe.Pointer(ptr + unsafe.Sizeof(uintptr(0))))
+	if length == 0 || dataPtr == 0 {
+		return nil
+	}
+	return unsafe.Slice((*uintptr)(unsafe.Pointer(dataPtr)), length)
 }
 // GetPropertyIpAddresses gets the "ip-addresses" property.
 	if ptr == 0 {
 		return nil
 	}
-	return unsafe.Slice((*uintptr)(unsafe.Pointer(ptr)), 0)[:0]
+	// GPtrArray layout: { gpointer *pdata; guint len; }
+	dataPtr := *(*uintptr)(unsafe.Pointer(ptr))
+	length := *(*uint32)(unsafe.Pointer(ptr + unsafe.Sizeof(uintptr(0))))
+	if length == 0 || dataPtr == 0 {
+		return nil
+	}
+	return unsafe.Slice((*uintptr)(unsafe.Pointer(dataPtr)), length)
 }
 // GetPropertyIssuerName gets the "issuer-name" property.
 	if ptr == 0 {
 		return nil
 	}
-	return unsafe.Slice((*byte)(unsafe.Pointer(ptr)), 0)[:0]
+	// GByteArray layout: { guint8 *data; guint len; }
+	dataPtr := *(*uintptr)(unsafe.Pointer(ptr))
+	length := *(*uint32)(unsafe.Pointer(ptr + unsafe.Sizeof(uintptr(0))))
+	if length == 0 || dataPtr == 0 {
+		return nil
+	}
+	return unsafe.Slice((*byte)(unsafe.Pointer(dataPtr)), length)
 }
 // SetPropertyPrivateKeyPem sets the "private-key-pem" property.

M v4/gio/gtlsconnection.go +7 -3

 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "accept-certificate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "accept-certificate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PeerCertVarp uintptr, ErrorsVarp TlsCertificateFlags) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "accept-certificate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "accept-certificate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gio/gunixsocketaddress.go +7 -1

 	if ptr == 0 {
 		return nil
 	}
-	return unsafe.Slice((*byte)(unsafe.Pointer(ptr)), 0)[:0]
+	// GByteArray layout: { guint8 *data; guint len; }
+	dataPtr := *(*uintptr)(unsafe.Pointer(ptr))
+	length := *(*uint32)(unsafe.Pointer(ptr + unsafe.Sizeof(uintptr(0))))
+	if length == 0 || dataPtr == 0 {
+		return nil
+	}
+	return unsafe.Slice((*byte)(unsafe.Pointer(dataPtr)), length)
 }
 // Creates a #GSocketAddressEnumerator for @connectable.

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

 }
 // Emitted when a drive changes.
-func (x *VolumeMonitor) ConnectDriveChanged(cb *func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectDriveChanged(cb *func(VolumeMonitor, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drive-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drive-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drive-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drive-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drive-connected", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drive-connected", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drive-connected", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drive-connected", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drive-disconnected", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drive-disconnected", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drive-disconnected", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drive-disconnected", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drive-eject-button", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drive-eject-button", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drive-eject-button", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drive-eject-button", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drive-stop-button", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drive-stop-button", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DriveVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drive-stop-button", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drive-stop-button", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a mount is added.
-func (x *VolumeMonitor) ConnectMountAdded(cb *func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectMountAdded(cb *func(VolumeMonitor, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "mount-added", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "mount-added", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MountVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "mount-added", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "mount-added", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a mount changes.
-func (x *VolumeMonitor) ConnectMountChanged(cb *func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectMountChanged(cb *func(VolumeMonitor, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "mount-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "mount-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MountVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "mount-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "mount-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "mount-pre-unmount", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "mount-pre-unmount", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MountVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "mount-pre-unmount", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "mount-pre-unmount", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a mount is removed.
-func (x *VolumeMonitor) ConnectMountRemoved(cb *func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectMountRemoved(cb *func(VolumeMonitor, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "mount-removed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "mount-removed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MountVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "mount-removed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "mount-removed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "volume-added", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "volume-added", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, VolumeVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "volume-added", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "volume-added", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when mountable volume is changed.
-func (x *VolumeMonitor) ConnectVolumeChanged(cb *func(VolumeMonitor, uintptr)) uint32 {
+func (x *VolumeMonitor) ConnectVolumeChanged(cb *func(VolumeMonitor, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "volume-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "volume-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, VolumeVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "volume-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "volume-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "volume-removed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "volume-removed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, VolumeVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "volume-removed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "volume-removed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xVolumeMonitorAdoptOrphanMount func(uintptr) uintptr

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


@@ -70,7 +70,7 @@ func Dgettext(DomainVar *string, MsgidVar string) string {
70		return cret	70		return cret
71		}	71		}
72			72
73	-	var xDngettext func(uintptr, string, string, uint32) string	73	+	var xDngettext func(uintptr, string, string, uint) string
74			74
75		// This function is a wrapper of dngettext() which does not translate	75		// This function is a wrapper of dngettext() which does not translate
76		// the message if the default domain as set with textdomain() has no	76		// the message if the default domain as set with textdomain() has no

@@ -78,7 +78,7 @@ var xDngettext func(uintptr, string, string, uint32) string
78		//	78		//
79		// See g_dgettext() for details of how this differs from dngettext()	79		// See g_dgettext() for details of how this differs from dngettext()
80		// proper.	80		// proper.
81	-	func Dngettext(DomainVar *string, MsgidVar string, MsgidPluralVar string, NVar uint32) string {	81	+	func Dngettext(DomainVar *string, MsgidVar string, MsgidPluralVar string, NVar uint) string {
82			82
83		DomainVarPtr, DomainVarBytes := core.NullableStringToPtr(DomainVar)	83		DomainVarPtr, DomainVarBytes := core.NullableStringToPtr(DomainVar)
84			84

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


@@ -46,7 +46,7 @@ type Hook struct {
46			46
47		RefCount uint	47		RefCount uint
48			48
49	-	HookId uint32	49	+	HookId uint
50			50
51		Flags uint	51		Flags uint
52			52

@@ -74,7 +74,7 @@ func (x Hook) CompareIds(SiblingVar Hook) int {
74		type HookList struct {	74		type HookList struct {
75		_ structs.HostLayout	75		_ structs.HostLayout
76			76
77	-	SeqId uint32	77	+	SeqId uint
78			78
79		HookSize uint	79		HookSize uint
80			80

@@ -202,10 +202,10 @@ const (
202		GHookFlagMaskValue HookFlagMask = 15	202		GHookFlagMaskValue HookFlagMask = 15
203		)	203		)
204			204
205	-	var xHookDestroy func(*HookList, uint32) bool	205	+	var xHookDestroy func(*HookList, uint) bool
206			206
207		// Destroys a #GHook, given its ID.	207		// Destroys a #GHook, given its ID.
208	-	func HookDestroy(HookListVar *HookList, HookIdVar uint32) bool {	208	+	func HookDestroy(HookListVar *HookList, HookIdVar uint) bool {
209			209
210		cret := xHookDestroy(HookListVar, HookIdVar)	210		cret := xHookDestroy(HookListVar, HookIdVar)
211			211

M v4/glib/gstring.go +1 -5


@@ -80,11 +80,7 @@ var xNewStringTake func(uintptr) *String
80		// allocated and will eventually be freed with g_free().	80		// allocated and will eventually be freed with g_free().
81		func NewStringTake(InitVar string) String {	81		func NewStringTake(InitVar string) String {
82			82
83	-	InitVarPtr, InitVarBytes := core.NullableStringToPtr(InitVar)	83	+	cret := xNewStringTake(core.GStrdupNullable(InitVar))
84	-
85	-	cret := xNewStringTake(InitVarPtr)
86	-
87	-	runtime.KeepAlive(InitVarBytes)
88			84
89		return cret	85		return cret
90		}	86		}

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


@@ -106,7 +106,7 @@ func (x StrvBuilder) Ref() StrvBuilder {
106		return cret	106		return cret
107		}	107		}
108			108
109	-	var xStrvBuilderTake func(uintptr, string)	109	+	var xStrvBuilderTake func(uintptr, uintptr)
110			110
111		// Add a string to the end of the array. After @value belongs to the	111		// Add a string to the end of the array. After @value belongs to the
112		// #GStrvBuilder and may no longer be modified by the caller.	112		// #GStrvBuilder and may no longer be modified by the caller.

@@ -114,7 +114,7 @@ var xStrvBuilderTake func(uintptr, string)
114		// Since 2.80	114		// Since 2.80
115		func (x *StrvBuilder) Take(ValueVar string) {	115		func (x *StrvBuilder) Take(ValueVar string) {
116			116
117	-	xStrvBuilderTake(x.GoPointer(), ValueVar)	117	+	xStrvBuilderTake(x.GoPointer(), core.GStrdup(ValueVar))
118			118
119		}	119		}
120			120

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


@@ -1830,11 +1830,11 @@ func (x ThreadFunctions) GetPrivateSet() func(Private, uintptr) {
1830			1830
1831		// OverrideThreadCreate sets the "thread_create" callback function.	1831		// OverrideThreadCreate sets the "thread_create" callback function.
1832		// virtual function pointer for g_thread_create()	1832		// virtual function pointer for g_thread_create()
1833	-	func (x ThreadFunctions) OverrideThreadCreate(cb func(ThreadFunc, uintptr, uint32, bool, bool, ThreadPriority, uintptr)) {	1833	+	func (x ThreadFunctions) OverrideThreadCreate(cb func(ThreadFunc, uintptr, uint, bool, bool, ThreadPriority, uintptr)) {
1834		if cb == nil {	1834		if cb == nil {
1835		x.xThreadCreate = 0	1835		x.xThreadCreate = 0
1836		} else {	1836		} else {
1837	-	x.xThreadCreate = purego.NewCallback(func(FuncVarp uintptr, DataVarp uintptr, StackSizeVarp uint32, JoinableVarp bool, BoundVarp bool, PriorityVarp ThreadPriority, ThreadVarp uintptr) {	1837	+	x.xThreadCreate = purego.NewCallback(func(FuncVarp uintptr, DataVarp uintptr, StackSizeVarp uint, JoinableVarp bool, BoundVarp bool, PriorityVarp ThreadPriority, ThreadVarp uintptr) {
1838		cb((*ThreadFunc)(unsafe.Pointer(FuncVarp)), DataVarp, StackSizeVarp, JoinableVarp, BoundVarp, PriorityVarp, ThreadVarp)	1838		cb((*ThreadFunc)(unsafe.Pointer(FuncVarp)), DataVarp, StackSizeVarp, JoinableVarp, BoundVarp, PriorityVarp, ThreadVarp)
1839		})	1839		})
1840		}	1840		}

@@ -1842,13 +1842,13 @@ func (x ThreadFunctions) OverrideThreadCreate(cb func(ThreadFunc, uintptr, uin
1842			1842
1843		// GetThreadCreate gets the "thread_create" callback function.	1843		// GetThreadCreate gets the "thread_create" callback function.
1844		// virtual function pointer for g_thread_create()	1844		// virtual function pointer for g_thread_create()
1845	-	func (x ThreadFunctions) GetThreadCreate() func(ThreadFunc, uintptr, uint32, bool, bool, ThreadPriority, uintptr) {	1845	+	func (x ThreadFunctions) GetThreadCreate() func(ThreadFunc, uintptr, uint, bool, bool, ThreadPriority, uintptr) {
1846		if x.xThreadCreate == 0 {	1846		if x.xThreadCreate == 0 {
1847		return nil	1847		return nil
1848		}	1848		}
1849	-	var rawCallback func(FuncVarp uintptr, DataVarp uintptr, StackSizeVarp uint32, JoinableVarp bool, BoundVarp bool, PriorityVarp ThreadPriority, ThreadVarp uintptr)	1849	+	var rawCallback func(FuncVarp uintptr, DataVarp uintptr, StackSizeVarp uint, JoinableVarp bool, BoundVarp bool, PriorityVarp ThreadPriority, ThreadVarp uintptr)
1850		purego.RegisterFunc(&rawCallback, x.xThreadCreate)	1850		purego.RegisterFunc(&rawCallback, x.xThreadCreate)
1851	-	return func(FuncVar *ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority, ThreadVar uintptr) {	1851	+	return func(FuncVar *ThreadFunc, DataVar uintptr, StackSizeVar uint, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority, ThreadVar uintptr) {
1852		rawCallback(NewCallback(FuncVar), DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, ThreadVar)	1852		rawCallback(NewCallback(FuncVar), DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, ThreadVar)
1853		}	1853		}
1854		}	1854		}

@@ -2314,10 +2314,10 @@ func ThreadCreate(FuncVar ThreadFunc, DataVar uintptr, JoinableVar bool) (Thre
2314			2314
2315		}	2315		}
2316			2316
2317	-	var xThreadCreateFull func(uintptr, uintptr, uint32, bool, bool, ThreadPriority, *Error) Thread	2317	+	var xThreadCreateFull func(uintptr, uintptr, uint, bool, bool, ThreadPriority, *Error) Thread
2318			2318
2319		// This function creates a new thread.	2319		// This function creates a new thread.
2320	-	func ThreadCreateFull(FuncVar ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (Thread, error) {	2320	+	func ThreadCreateFull(FuncVar ThreadFunc, DataVar uintptr, StackSizeVar uint, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (Thread, error) {
2321		var cerr *Error	2321		var cerr *Error
2322			2322
2323		var FuncVarRef uintptr	2323		var FuncVarRef uintptr

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


@@ -42,7 +42,7 @@ func (x *Timer) Destroy() {
42			42
43		}	43		}
44			44
45	-	var xTimerElapsed func(uintptr, uint32) float64	45	+	var xTimerElapsed func(uintptr, uint) float64
46			46
47		// If @timer has been started but not stopped, obtains the time since	47		// If @timer has been started but not stopped, obtains the time since
48		// the timer was started. If @timer has been stopped, obtains the	48		// the timer was started. If @timer has been stopped, obtains the

@@ -50,7 +50,7 @@ var xTimerElapsed func(uintptr, uint32) float64
50		// stopped. The return value is the number of seconds elapsed,	50		// stopped. The return value is the number of seconds elapsed,
51		// including any fractional part. The @microseconds out parameter is	51		// including any fractional part. The @microseconds out parameter is
52		// essentially useless.	52		// essentially useless.
53	-	func (x *Timer) Elapsed(MicrosecondsVar uint32) float64 {	53	+	func (x *Timer) Elapsed(MicrosecondsVar uint) float64 {
54			54
55		cret := xTimerElapsed(x.GoPointer(), MicrosecondsVar)	55		cret := xTimerElapsed(x.GoPointer(), MicrosecondsVar)
56			56

@@ -132,7 +132,7 @@ func TimeValFromIso8601(IsoDateVar string, TimeVar *TimeVal) bool {
132		return cret	132		return cret
133		}	133		}
134			134
135	-	var xUsleep func(uint32)	135	+	var xUsleep func(uint)
136			136
137		// Pauses the current thread for the given number of microseconds.	137		// Pauses the current thread for the given number of microseconds.
138		//	138		//

@@ -140,7 +140,7 @@ var xUsleep func(uint32)
140		// %G_USEC_PER_SEC macro). g_usleep() may have limited precision,	140		// %G_USEC_PER_SEC macro). g_usleep() may have limited precision,
141		// depending on hardware and operating system; don't rely on the exact	141		// depending on hardware and operating system; don't rely on the exact
142		// length of the sleep.	142		// length of the sleep.
143	-	func Usleep(MicrosecondsVar uint32) {	143	+	func Usleep(MicrosecondsVar uint) {
144			144
145		xUsleep(MicrosecondsVar)	145		xUsleep(MicrosecondsVar)
146			146

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


@@ -106,20 +106,20 @@ type TranslateFunc func(string, uintptr) string
106		type TimeVal struct {	106		type TimeVal struct {
107		_ structs.HostLayout	107		_ structs.HostLayout
108			108
109	-	TvSec int32	109	+	TvSec int
110			110
111	-	TvUsec int32	111	+	TvUsec int
112		}	112		}
113			113
114		func (x *TimeVal) GoPointer() uintptr {	114		func (x *TimeVal) GoPointer() uintptr {
115		return uintptr(unsafe.Pointer(x))	115		return uintptr(unsafe.Pointer(x))
116		}	116		}
117			117
118	-	var xTimeValAdd func(uintptr, int32)	118	+	var xTimeValAdd func(uintptr, int)
119			119
120		// Adds the given number of microseconds to @time_. @microseconds can	120		// Adds the given number of microseconds to @time_. @microseconds can
121		// also be negative to decrease the value of @time_.	121		// also be negative to decrease the value of @time_.
122	-	func (x *TimeVal) Add(MicrosecondsVar int32) {	122	+	func (x *TimeVal) Add(MicrosecondsVar int) {
123			123
124		xTimeValAdd(x.GoPointer(), MicrosecondsVar)	124		xTimeValAdd(x.GoPointer(), MicrosecondsVar)
125			125

M v4/glib/gunicode.go +22 -22


@@ -615,12 +615,12 @@ const (
615		GUnicodeSpaceSeparatorValue UnicodeType = 29	615		GUnicodeSpaceSeparatorValue UnicodeType = 29
616		)	616		)
617			617
618	-	var xUcs4ToUtf16 func([]uint32, int32, int32, int32, **Error) uint16	618	+	var xUcs4ToUtf16 func([]uint32, int, int, int, **Error) uint16
619			619
620		// Convert a string from UCS-4 to UTF-16.	620		// Convert a string from UCS-4 to UTF-16.
621		//	621		//
622		// A nul character (U+0000) will be added to the result after the converted text.	622		// A nul character (U+0000) will be added to the result after the converted text.
623	-	func Ucs4ToUtf16(StrVar []uint32, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint16, error) {	623	+	func Ucs4ToUtf16(StrVar []uint32, LenVar int, ItemsReadVar int, ItemsWrittenVar int) (uint16, error) {
624		var cerr *Error	624		var cerr *Error
625			625
626		cret := xUcs4ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	626		cret := xUcs4ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -632,13 +632,13 @@ func Ucs4ToUtf16(StrVar []uint32, LenVar int32, ItemsReadVar *int32, ItemsWritte
632			632
633		}	633		}
634			634
635	-	var xUcs4ToUtf8 func([]uint32, int32, int32, int32, **Error) string	635	+	var xUcs4ToUtf8 func([]uint32, int, int, int, **Error) string
636			636
637		// Convert a string from a 32-bit fixed width representation as UCS-4.	637		// Convert a string from a 32-bit fixed width representation as UCS-4.
638		// to UTF-8.	638		// to UTF-8.
639		//	639		//
640		// The result will be terminated with a nul byte.	640		// The result will be terminated with a nul byte.
641	-	func Ucs4ToUtf8(StrVar []uint32, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (string, error) {	641	+	func Ucs4ToUtf8(StrVar []uint32, LenVar int, ItemsReadVar int, ItemsWrittenVar int) (string, error) {
642		var cerr *Error	642		var cerr *Error
643			643
644		cret := xUcs4ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	644		cret := xUcs4ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -1164,12 +1164,12 @@ func UnicodeScriptToIso15924(ScriptVar UnicodeScript) uint32 {
1164		return cret	1164		return cret
1165		}	1165		}
1166			1166
1167	-	var xUtf16ToUcs4 func([]uint16, int32, int32, int32, **Error) uint32	1167	+	var xUtf16ToUcs4 func([]uint16, int, int, int, **Error) uint32
1168			1168
1169		// Convert a string from UTF-16 to UCS-4.	1169		// Convert a string from UTF-16 to UCS-4.
1170		//	1170		//
1171		// The result will be nul-terminated.	1171		// The result will be nul-terminated.
1172	-	func Utf16ToUcs4(StrVar []uint16, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint32, error) {	1172	+	func Utf16ToUcs4(StrVar []uint16, LenVar int, ItemsReadVar int, ItemsWrittenVar int) (uint32, error) {
1173		var cerr *Error	1173		var cerr *Error
1174			1174
1175		cret := xUtf16ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1175		cret := xUtf16ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -1181,7 +1181,7 @@ func Utf16ToUcs4(StrVar []uint16, LenVar int32, ItemsReadVar *int32, ItemsWritte
1181			1181
1182		}	1182		}
1183			1183
1184	-	var xUtf16ToUtf8 func([]uint16, int32, int32, int32, **Error) string	1184	+	var xUtf16ToUtf8 func([]uint16, int, int, int, **Error) string
1185			1185
1186		// Convert a string from UTF-16 to UTF-8.	1186		// Convert a string from UTF-16 to UTF-8.
1187		//	1187		//

@@ -1197,7 +1197,7 @@ var xUtf16ToUtf8 func([]uint16, int32, int32, int32, **Error) string
1197		// validation done by this function is to ensure that the input can	1197		// validation done by this function is to ensure that the input can
1198		// be correctly interpreted as UTF-16, i.e. it doesn’t contain	1198		// be correctly interpreted as UTF-16, i.e. it doesn’t contain
1199		// unpaired surrogates or partial character sequences.	1199		// unpaired surrogates or partial character sequences.
1200	-	func Utf16ToUtf8(StrVar []uint16, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (string, error) {	1200	+	func Utf16ToUtf8(StrVar []uint16, LenVar int, ItemsReadVar int, ItemsWrittenVar int) (string, error) {
1201		var cerr *Error	1201		var cerr *Error
1202			1202
1203		cret := xUtf16ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1203		cret := xUtf16ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -1418,7 +1418,7 @@ func Utf8Normalize(StrVar string, LenVar int, ModeVar NormalizeMode) string {
1418		return cret	1418		return cret
1419		}	1419		}
1420			1420
1421	-	var xUtf8OffsetToPointer func(string, int32) string	1421	+	var xUtf8OffsetToPointer func(string, int) string
1422			1422
1423		// Converts from an integer character offset to a pointer to a position	1423		// Converts from an integer character offset to a pointer to a position
1424		// within the string.	1424		// within the string.

@@ -1433,21 +1433,21 @@ var xUtf8OffsetToPointer func(string, int32) string
1433		// before calling that function. Call [func@GLib.utf8_strlen] when unsure.	1433		// before calling that function. Call [func@GLib.utf8_strlen] when unsure.
1434		// This limitation exists as this function is called frequently during	1434		// This limitation exists as this function is called frequently during
1435		// text rendering and therefore has to be as fast as possible.	1435		// text rendering and therefore has to be as fast as possible.
1436	-	func Utf8OffsetToPointer(StrVar string, OffsetVar int32) string {	1436	+	func Utf8OffsetToPointer(StrVar string, OffsetVar int) string {
1437			1437
1438		cret := xUtf8OffsetToPointer(StrVar, OffsetVar)	1438		cret := xUtf8OffsetToPointer(StrVar, OffsetVar)
1439			1439
1440		return cret	1440		return cret
1441		}	1441		}
1442			1442
1443	-	var xUtf8PointerToOffset func(string, string) int32	1443	+	var xUtf8PointerToOffset func(string, string) int
1444			1444
1445		// Converts from a pointer to position within a string to an integer	1445		// Converts from a pointer to position within a string to an integer
1446		// character offset.	1446		// character offset.
1447		//	1447		//
1448		// Since 2.10, this function allows @pos to be before @str, and returns	1448		// Since 2.10, this function allows @pos to be before @str, and returns
1449		// a negative offset in this case.	1449		// a negative offset in this case.
1450	-	func Utf8PointerToOffset(StrVar string, PosVar string) int32 {	1450	+	func Utf8PointerToOffset(StrVar string, PosVar string) int {
1451			1451
1452		cret := xUtf8PointerToOffset(StrVar, PosVar)	1452		cret := xUtf8PointerToOffset(StrVar, PosVar)
1453			1453

@@ -1496,12 +1496,12 @@ func Utf8Strdown(StrVar string, LenVar int) string {
1496		return cret	1496		return cret
1497		}	1497		}
1498			1498
1499	-	var xUtf8Strlen func(string, int) int32	1499	+	var xUtf8Strlen func(string, int) int
1500			1500
1501		// Computes the length of the string in characters, not including	1501		// Computes the length of the string in characters, not including
1502		// the terminating nul character. If the @max’th byte falls in the	1502		// the terminating nul character. If the @max’th byte falls in the
1503		// middle of a character, the last (partial) character is not counted.	1503		// middle of a character, the last (partial) character is not counted.
1504	-	func Utf8Strlen(PVar string, MaxVar int) int32 {	1504	+	func Utf8Strlen(PVar string, MaxVar int) int {
1505			1505
1506		cret := xUtf8Strlen(PVar, MaxVar)	1506		cret := xUtf8Strlen(PVar, MaxVar)
1507			1507

@@ -1576,27 +1576,27 @@ func Utf8Strup(StrVar string, LenVar int) string {
1576		return cret	1576		return cret
1577		}	1577		}
1578			1578
1579	-	var xUtf8Substring func(string, int32, int32) string	1579	+	var xUtf8Substring func(string, int, int) string
1580			1580
1581		// Copies a substring out of a UTF-8 encoded string.	1581		// Copies a substring out of a UTF-8 encoded string.
1582		// The substring will contain @end_pos - @start_pos characters.	1582		// The substring will contain @end_pos - @start_pos characters.
1583		//	1583		//
1584		// Since GLib 2.72, `-1` can be passed to @end_pos to indicate the	1584		// Since GLib 2.72, `-1` can be passed to @end_pos to indicate the
1585		// end of the string.	1585		// end of the string.
1586	-	func Utf8Substring(StrVar string, StartPosVar int32, EndPosVar int32) string {	1586	+	func Utf8Substring(StrVar string, StartPosVar int, EndPosVar int) string {
1587			1587
1588		cret := xUtf8Substring(StrVar, StartPosVar, EndPosVar)	1588		cret := xUtf8Substring(StrVar, StartPosVar, EndPosVar)
1589			1589
1590		return cret	1590		return cret
1591		}	1591		}
1592			1592
1593	-	var xUtf8ToUcs4 func(string, int32, int32, int32, **Error) uint32	1593	+	var xUtf8ToUcs4 func(string, int, int, int, **Error) uint32
1594			1594
1595		// Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4.	1595		// Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4.
1596		//	1596		//
1597		// A trailing nul character (U+0000) will be added to the string after the	1597		// A trailing nul character (U+0000) will be added to the string after the
1598		// converted text.	1598		// converted text.
1599	-	func Utf8ToUcs4(StrVar string, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint32, error) {	1599	+	func Utf8ToUcs4(StrVar string, LenVar int, ItemsReadVar int, ItemsWrittenVar int) (uint32, error) {
1600		var cerr *Error	1600		var cerr *Error
1601			1601
1602		cret := xUtf8ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1602		cret := xUtf8ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -1608,7 +1608,7 @@ func Utf8ToUcs4(StrVar string, LenVar int32, ItemsReadVar *int32, ItemsWrittenVa
1608			1608
1609		}	1609		}
1610			1610
1611	-	var xUtf8ToUcs4Fast func(string, int32, *int32) uint32	1611	+	var xUtf8ToUcs4Fast func(string, int, *int) uint32
1612			1612
1613		// Convert a string from UTF-8 to a 32-bit fixed width	1613		// Convert a string from UTF-8 to a 32-bit fixed width
1614		// representation as UCS-4, assuming valid UTF-8 input.	1614		// representation as UCS-4, assuming valid UTF-8 input.

@@ -1616,19 +1616,19 @@ var xUtf8ToUcs4Fast func(string, int32, *int32) uint32
1616		// This function is roughly twice as fast as [func@GLib.utf8_to_ucs4]	1616		// This function is roughly twice as fast as [func@GLib.utf8_to_ucs4]
1617		// but does no error checking on the input. A trailing nul character (U+0000)	1617		// but does no error checking on the input. A trailing nul character (U+0000)
1618		// will be added to the string after the converted text.	1618		// will be added to the string after the converted text.
1619	-	func Utf8ToUcs4Fast(StrVar string, LenVar int32, ItemsWrittenVar *int32) uint32 {	1619	+	func Utf8ToUcs4Fast(StrVar string, LenVar int, ItemsWrittenVar *int) uint32 {
1620			1620
1621		cret := xUtf8ToUcs4Fast(StrVar, LenVar, ItemsWrittenVar)	1621		cret := xUtf8ToUcs4Fast(StrVar, LenVar, ItemsWrittenVar)
1622			1622
1623		return cret	1623		return cret
1624		}	1624		}
1625			1625
1626	-	var xUtf8ToUtf16 func(string, int32, int32, int32, **Error) uint16	1626	+	var xUtf8ToUtf16 func(string, int, int, int, **Error) uint16
1627			1627
1628		// Convert a string from UTF-8 to UTF-16.	1628		// Convert a string from UTF-8 to UTF-16.
1629		//	1629		//
1630		// A nul character (U+0000) will be added to the result after the converted text.	1630		// A nul character (U+0000) will be added to the result after the converted text.
1631	-	func Utf8ToUtf16(StrVar string, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint16, error) {	1631	+	func Utf8ToUtf16(StrVar string, LenVar int, ItemsReadVar int, ItemsWrittenVar int) (uint16, error) {
1632		var cerr *Error	1632		var cerr *Error
1633			1633
1634		cret := xUtf8ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1634		cret := xUtf8ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

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


@@ -141,38 +141,38 @@ func Atexit(FuncVar *VoidFunc) {
141			141
142		}	142		}
143			143
144	-	var xBitNthLsf func(uint32, int) int	144	+	var xBitNthLsf func(uint, int) int
145			145
146		// Find the position of the first bit set in @mask, searching	146		// Find the position of the first bit set in @mask, searching
147		// from (but not including) @nth_bit upwards. Bits are numbered	147		// from (but not including) @nth_bit upwards. Bits are numbered
148		// from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,	148		// from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
149		// usually). To start searching from the 0th bit, set @nth_bit to -1.	149		// usually). To start searching from the 0th bit, set @nth_bit to -1.
150	-	func BitNthLsf(MaskVar uint32, NthBitVar int) int {	150	+	func BitNthLsf(MaskVar uint, NthBitVar int) int {
151			151
152		cret := xBitNthLsf(MaskVar, NthBitVar)	152		cret := xBitNthLsf(MaskVar, NthBitVar)
153			153
154		return cret	154		return cret
155		}	155		}
156			156
157	-	var xBitNthMsf func(uint32, int) int	157	+	var xBitNthMsf func(uint, int) int
158			158
159		// Find the position of the first bit set in @mask, searching	159		// Find the position of the first bit set in @mask, searching
160		// from (but not including) @nth_bit downwards. Bits are numbered	160		// from (but not including) @nth_bit downwards. Bits are numbered
161		// from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,	161		// from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
162		// usually). To start searching from the last bit, set @nth_bit to	162		// usually). To start searching from the last bit, set @nth_bit to
163		// -1 or GLIB_SIZEOF_LONG * 8.	163		// -1 or GLIB_SIZEOF_LONG * 8.
164	-	func BitNthMsf(MaskVar uint32, NthBitVar int) int {	164	+	func BitNthMsf(MaskVar uint, NthBitVar int) int {
165			165
166		cret := xBitNthMsf(MaskVar, NthBitVar)	166		cret := xBitNthMsf(MaskVar, NthBitVar)
167			167
168		return cret	168		return cret
169		}	169		}
170			170
171	-	var xBitStorage func(uint32) uint	171	+	var xBitStorage func(uint) uint
172			172
173		// Gets the number of bits used to hold @number,	173		// Gets the number of bits used to hold @number,
174		// e.g. if @number is 4, 3 bits are needed.	174		// e.g. if @number is 4, 3 bits are needed.
175	-	func BitStorage(NumberVar uint32) uint {	175	+	func BitStorage(NumberVar uint) uint {
176			176
177		cret := xBitStorage(NumberVar)	177		cret := xBitStorage(NumberVar)
178			178

@@ -718,7 +718,7 @@ func SetPrgname(PrgnameVar string) {
718			718
719		}	719		}
720			720
721	-	var xSnprintf func(string, uint32, string, ...interface{}) int	721	+	var xSnprintf func(string, uint, string, ...interface{}) int
722			722
723		// A safer form of the standard sprintf() function. The output is guaranteed	723		// A safer form of the standard sprintf() function. The output is guaranteed
724		// to not exceed @n characters (including the terminating nul character), so	724		// to not exceed @n characters (including the terminating nul character), so

@@ -737,14 +737,14 @@ var xSnprintf func(string, uint32, string, ...interface{}) int
737		//	737		//
738		// The format string may contain positional parameters, as specified in	738		// The format string may contain positional parameters, as specified in
739		// the Single Unix Specification.	739		// the Single Unix Specification.
740	-	func Snprintf(StringVar string, NVar uint32, FormatVar string, varArgs ...interface{}) int {	740	+	func Snprintf(StringVar string, NVar uint, FormatVar string, varArgs ...interface{}) int {
741			741
742		cret := xSnprintf(StringVar, NVar, FormatVar, varArgs...)	742		cret := xSnprintf(StringVar, NVar, FormatVar, varArgs...)
743			743
744		return cret	744		return cret
745		}	745		}
746			746
747	-	var xVsnprintf func(string, uint32, string, []interface{}) int	747	+	var xVsnprintf func(string, uint, string, []interface{}) int
748			748
749		// A safer form of the standard `vsprintf()` function. The output is guaranteed	749		// A safer form of the standard `vsprintf()` function. The output is guaranteed
750		// to not exceed @n characters (including the terminating nul character), so	750		// to not exceed @n characters (including the terminating nul character), so

@@ -763,7 +763,7 @@ var xVsnprintf func(string, uint32, string, []interface{}) int
763		//	763		//
764		// The format string may contain positional parameters, as specified in	764		// The format string may contain positional parameters, as specified in
765		// the Single Unix Specification.	765		// the Single Unix Specification.
766	-	func Vsnprintf(StringVar string, NVar uint32, FormatVar string, ArgsVar []interface{}) int {	766	+	func Vsnprintf(StringVar string, NVar uint, FormatVar string, ArgsVar []interface{}) int {
767			767
768		cret := xVsnprintf(StringVar, NVar, FormatVar, ArgsVar)	768		cret := xVsnprintf(StringVar, NVar, FormatVar, ArgsVar)
769			769

M v4/glib/more.go +25 -4


@@ -11,11 +11,13 @@ import (
11			11
12		var callbacks = struct {	12		var callbacks = struct {
13		sync.RWMutex	13		sync.RWMutex
14	-	refs map[uintptr]uintptr	14	+	refs map[uintptr]uintptr
15	-	closures map[uintptr]interface{}	15	+	closures map[uintptr]interface{}
			16	+	handlerToCallback map[uint]uintptr
16		}{	17		}{
17	-	refs: make(map[uintptr]uintptr),	18	+	refs: make(map[uintptr]uintptr),
18	-	closures: make(map[uintptr]interface{}),	19	+	closures: make(map[uintptr]interface{}),
			20	+	handlerToCallback: make(map[uint]uintptr),
19		}	21		}
20			22
21		// GetCallback retrives a callback reference by value.	23		// GetCallback retrives a callback reference by value.

@@ -55,6 +57,25 @@ func RemoveCallback(cbPtr uintptr) {
55		callbacks.Unlock()	57		callbacks.Unlock()
56		}	58		}
57			59
			60	+	// SaveHandlerMapping records a signal handler ID → callback pointer mapping
			61	+	// so that DisconnectSignal can clean up the callback registry.
			62	+	func SaveHandlerMapping(handlerID uint, cbPtr uintptr) {
			63	+	callbacks.Lock()
			64	+	callbacks.handlerToCallback[handlerID] = cbPtr
			65	+	callbacks.Unlock()
			66	+	}
			67	+
			68	+	// RemoveCallbackByHandler removes a callback from the registry using a signal handler ID.
			69	+	func RemoveCallbackByHandler(handlerID uint) {
			70	+	callbacks.Lock()
			71	+	if cbPtr, ok := callbacks.handlerToCallback[handlerID]; ok {
			72	+	delete(callbacks.refs, cbPtr)
			73	+	delete(callbacks.closures, cbPtr)
			74	+	delete(callbacks.handlerToCallback, handlerID)
			75	+	}
			76	+	callbacks.Unlock()
			77	+	}
			78	+
58		// UnrefCallbackValue unreferences the provided callback by reflect.value to free a purego slot	79		// UnrefCallbackValue unreferences the provided callback by reflect.value to free a purego slot
59		//	80		//
60		// NOTE: Windows does not support unreferencing callbacks, so on that platform this operation is	81		// NOTE: Windows does not support unreferencing callbacks, so on that platform this operation is

M v4/gobject/gobject.go +16 -8

 }
-var xSignalConnectObject func(*TypeInstance, string, uintptr, uintptr, ConnectFlags) uint32
+var xSignalConnectObject func(*TypeInstance, string, uintptr, uintptr, ConnectFlags) uint
 // This is similar to g_signal_connect_data(), but uses a closure which
 // ensures that the @gobject stays alive during the call to @c_handler
 //
 // Refer to the [signals documentation](signals.html) for more
 // details.
-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) uint {
 	var CHandlerVarRef uintptr
 	if CHandlerVar != nil {
 // It is important to note that you must use
 // [canonical parameter names][class@GObject.ParamSpec#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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return SignalConnect(x.GoPointer(), "notify", cbRefPtr)
+		handlerID := SignalConnect(x.GoPointer(), "notify", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PspecVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return SignalConnect(x.GoPointer(), "notify", cbRefPtr)
+	handlerID := SignalConnect(x.GoPointer(), "notify", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // ConnectNotifyWithDetail connects to the "notify" signal with a detail string.
 // The detail is appended as "notify::<detail>".
-func (x *Object) ConnectNotifyWithDetail(detail string, cb *func(Object, uintptr)) uint32 {
+func (x *Object) ConnectNotifyWithDetail(detail string, cb *func(Object, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	signalName := fmt.Sprintf("notify::%s", detail)
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		handlerID := SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PspecVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	handlerID := SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xObjectCompatControl func(uint, uintptr) uint

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


@@ -277,12 +277,12 @@ func NewParamSpecInt64(NameVar string, NickVar string, BlurbVar string, Minimu
277		return cls	277		return cls
278		}	278		}
279			279
280	-	var xNewParamSpecLong func(string, uintptr, uintptr, int32, int32, int32, ParamFlags) uintptr	280	+	var xNewParamSpecLong func(string, uintptr, uintptr, int, int, int, ParamFlags) uintptr
281			281
282		// Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.	282		// Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
283		//	283		//
284		// See g_param_spec_internal() for details on property names.	284		// See g_param_spec_internal() for details on property names.
285	-	func NewParamSpecLong(NameVar string, NickVar string, BlurbVar string, MinimumVar int32, MaximumVar int32, DefaultValueVar int32, FlagsVar ParamFlags) *ParamSpec {	285	+	func NewParamSpecLong(NameVar string, NickVar string, BlurbVar string, MinimumVar int, MaximumVar int, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec {
286		var cls *ParamSpec	286		var cls *ParamSpec
287			287
288		NickVarPtr, NickVarBytes := core.NullableStringToPtr(NickVar)	288		NickVarPtr, NickVarBytes := core.NullableStringToPtr(NickVar)

@@ -510,13 +510,13 @@ func ParamSpecUint64(NameVar string, NickVar string, BlurbVar string, MinimumV
510		return cls	510		return cls
511		}	511		}
512			512
513	-	var xParamSpecUlong func(string, uintptr, uintptr, uint32, uint32, uint32, ParamFlags) uintptr	513	+	var xParamSpecUlong func(string, uintptr, uintptr, uint, uint, uint, ParamFlags) uintptr
514			514
515		// Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG	515		// Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
516		// property.	516		// property.
517		//	517		//
518		// See g_param_spec_internal() for details on property names.	518		// See g_param_spec_internal() for details on property names.
519	-	func ParamSpecUlong(NameVar string, NickVar string, BlurbVar string, MinimumVar uint32, MaximumVar uint32, DefaultValueVar uint32, FlagsVar ParamFlags) *ParamSpec {	519	+	func ParamSpecUlong(NameVar string, NickVar string, BlurbVar string, MinimumVar uint, MaximumVar uint, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec {
520		var cls *ParamSpec	520		var cls *ParamSpec
521			521
522		NickVarPtr, NickVarBytes := core.NullableStringToPtr(NickVar)	522		NickVarPtr, NickVarBytes := core.NullableStringToPtr(NickVar)

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


@@ -172,7 +172,7 @@ const (
172		GSignalMatchUnblockedValue SignalMatchType = 32	172		GSignalMatchUnblockedValue SignalMatchType = 32
173		)	173		)
174			174
175	-	var xClearSignalHandler func(uint32, uintptr)	175	+	var xClearSignalHandler func(uint, uintptr)
176			176
177		// Disconnects a handler from @instance so it will not be called during	177		// Disconnects a handler from @instance so it will not be called during
178		// any future or currently ongoing emissions of the signal it has been	178		// any future or currently ongoing emissions of the signal it has been

@@ -182,7 +182,7 @@ var xClearSignalHandler func(uint32, uintptr)
182		//	182		//
183		// There is also a macro version of this function so that the code	183		// There is also a macro version of this function so that the code
184		// will be inlined.	184		// will be inlined.
185	-	func ClearSignalHandler(HandlerIdPtrVar uint32, InstanceVar *Object) {	185	+	func ClearSignalHandler(HandlerIdPtrVar uint, InstanceVar *Object) {
186			186
187		xClearSignalHandler(HandlerIdPtrVar, InstanceVar.GoPointer())	187		xClearSignalHandler(HandlerIdPtrVar, InstanceVar.GoPointer())
188			188

@@ -223,12 +223,12 @@ func SignalAccumulatorTrueHandled(IhintVar *SignalInvocationHint, ReturnAccuVar
223		return cret	223		return cret
224		}	224		}
225			225
226	-	var xSignalAddEmissionHook func(uint, glib.Quark, uintptr, uintptr, uintptr) uint32	226	+	var xSignalAddEmissionHook func(uint, glib.Quark, uintptr, uintptr, uintptr) uint
227			227
228		// Adds an emission hook for a signal, which will get called for any emission	228		// Adds an emission hook for a signal, which will get called for any emission
229		// of that signal, independent of the instance. This is possible only	229		// of that signal, independent of the instance. This is possible only
230		// for signals which don't have %G_SIGNAL_NO_HOOKS flag set.	230		// for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
231	-	func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar SignalEmissionHook, HookDataVar uintptr, DataDestroyVar glib.DestroyNotify) uint32 {	231	+	func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar SignalEmissionHook, HookDataVar uintptr, DataDestroyVar glib.DestroyNotify) uint {
232			232
233		var HookFuncVarRef uintptr	233		var HookFuncVarRef uintptr
234		if HookFuncVar != nil {	234		if HookFuncVar != nil {

@@ -289,7 +289,7 @@ func SignalChainFromOverriddenHandler(InstanceVar *TypeInstance, varArgs ...inte
289			289
290		}	290		}
291			291
292	-	var xSignalConnectClosure func(uintptr, string, *Closure, bool) uint32	292	+	var xSignalConnectClosure func(uintptr, string, *Closure, bool) uint
293			293
294		// Connects a closure to a signal for a particular object.	294		// Connects a closure to a signal for a particular object.
295		//	295		//

@@ -303,14 +303,14 @@ var xSignalConnectClosure func(uintptr, string, *Closure, bool) uint32
303		//	303		//
304		// Refer to the [signals documentation](signals.html) for more	304		// Refer to the [signals documentation](signals.html) for more
305		// details.	305		// details.
306	-	func SignalConnectClosure(InstanceVar Object, DetailedSignalVar string, ClosureVar Closure, AfterVar bool) uint32 {	306	+	func SignalConnectClosure(InstanceVar Object, DetailedSignalVar string, ClosureVar Closure, AfterVar bool) uint {
307			307
308		cret := xSignalConnectClosure(InstanceVar.GoPointer(), DetailedSignalVar, ClosureVar, AfterVar)	308		cret := xSignalConnectClosure(InstanceVar.GoPointer(), DetailedSignalVar, ClosureVar, AfterVar)
309			309
310		return cret	310		return cret
311		}	311		}
312			312
313	-	var xSignalConnectClosureById func(uintptr, uint, glib.Quark, *Closure, bool) uint32	313	+	var xSignalConnectClosureById func(uintptr, uint, glib.Quark, *Closure, bool) uint
314			314
315		// Connects a closure to a signal for a particular object.	315		// Connects a closure to a signal for a particular object.
316		//	316		//

@@ -324,14 +324,14 @@ var xSignalConnectClosureById func(uintptr, uint, glib.Quark, *Closure, bool) ui
324		//	324		//
325		// Refer to the [signals documentation](signals.html) for more	325		// Refer to the [signals documentation](signals.html) for more
326		// details.	326		// details.
327	-	func SignalConnectClosureById(InstanceVar Object, SignalIdVar uint, DetailVar glib.Quark, ClosureVar Closure, AfterVar bool) uint32 {	327	+	func SignalConnectClosureById(InstanceVar Object, SignalIdVar uint, DetailVar glib.Quark, ClosureVar Closure, AfterVar bool) uint {
328			328
329		cret := xSignalConnectClosureById(InstanceVar.GoPointer(), SignalIdVar, DetailVar, ClosureVar, AfterVar)	329		cret := xSignalConnectClosureById(InstanceVar.GoPointer(), SignalIdVar, DetailVar, ClosureVar, AfterVar)
330			330
331		return cret	331		return cret
332		}	332		}
333			333
334	-	var xSignalConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectFlags) uint32	334	+	var xSignalConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectFlags) uint
335			335
336		// Connects a #GCallback function to a signal for a particular object. Similar	336		// Connects a #GCallback function to a signal for a particular object. Similar
337		// to g_signal_connect(), but allows to provide a #GClosureNotify for the data	337		// to g_signal_connect(), but allows to provide a #GClosureNotify for the data

@@ -346,7 +346,7 @@ var xSignalConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectF
346		//	346		//
347		// Refer to the [signals documentation](signals.html) for more	347		// Refer to the [signals documentation](signals.html) for more
348		// details.	348		// details.
349	-	func SignalConnectData(InstanceVar Object, DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {	349	+	func SignalConnectData(InstanceVar Object, DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint {
350			350
351		var CHandlerVarRef uintptr	351		var CHandlerVarRef uintptr
352		if CHandlerVar != nil {	352		if CHandlerVar != nil {

@@ -445,7 +445,7 @@ func SignalGetInvocationHint(InstanceVar Object) SignalInvocationHint {
445		return cret	445		return cret
446		}	446		}
447			447
448	-	var xSignalHandlerBlock func(uintptr, uint32)	448	+	var xSignalHandlerBlock func(uintptr, uint)
449			449
450		// Blocks a handler of an instance so it will not be called during any	450		// Blocks a handler of an instance so it will not be called during any
451		// signal emissions unless it is unblocked again. Thus "blocking" a	451		// signal emissions unless it is unblocked again. Thus "blocking" a

@@ -455,13 +455,13 @@ var xSignalHandlerBlock func(uintptr, uint32)
455		//	455		//
456		// The @handler_id has to be a valid signal handler id, connected to a	456		// The @handler_id has to be a valid signal handler id, connected to a
457		// signal of @instance.	457		// signal of @instance.
458	-	func SignalHandlerBlock(InstanceVar *Object, HandlerIdVar uint32) {	458	+	func SignalHandlerBlock(InstanceVar *Object, HandlerIdVar uint) {
459			459
460		xSignalHandlerBlock(InstanceVar.GoPointer(), HandlerIdVar)	460		xSignalHandlerBlock(InstanceVar.GoPointer(), HandlerIdVar)
461			461
462		}	462		}
463			463
464	-	var xSignalHandlerDisconnect func(uintptr, uint32)	464	+	var xSignalHandlerDisconnect func(uintptr, uint)
465			465
466		// Disconnects a handler from an instance so it will not be called during	466		// Disconnects a handler from an instance so it will not be called during
467		// any future or currently ongoing emissions of the signal it has been	467		// any future or currently ongoing emissions of the signal it has been

@@ -469,37 +469,37 @@ var xSignalHandlerDisconnect func(uintptr, uint32)
469		//	469		//
470		// The @handler_id has to be a valid signal handler id, connected to a	470		// The @handler_id has to be a valid signal handler id, connected to a
471		// signal of @instance.	471		// signal of @instance.
472	-	func SignalHandlerDisconnect(InstanceVar *Object, HandlerIdVar uint32) {	472	+	func SignalHandlerDisconnect(InstanceVar *Object, HandlerIdVar uint) {
473			473
474		xSignalHandlerDisconnect(InstanceVar.GoPointer(), HandlerIdVar)	474		xSignalHandlerDisconnect(InstanceVar.GoPointer(), HandlerIdVar)
475			475
476		}	476		}
477			477
478	-	var xSignalHandlerFind func(uintptr, SignalMatchType, uint, glib.Quark, *Closure, uintptr, uintptr) uint32	478	+	var xSignalHandlerFind func(uintptr, SignalMatchType, uint, glib.Quark, *Closure, uintptr, uintptr) uint
479			479
480		// Finds the first signal handler that matches certain selection criteria.	480		// Finds the first signal handler that matches certain selection criteria.
481		// The criteria mask is passed as an OR-ed combination of #GSignalMatchType	481		// The criteria mask is passed as an OR-ed combination of #GSignalMatchType
482		// flags, and the criteria values are passed as arguments.	482		// flags, and the criteria values are passed as arguments.
483		// The match @mask has to be non-0 for successful matches.	483		// The match @mask has to be non-0 for successful matches.
484		// If no handler was found, 0 is returned.	484		// If no handler was found, 0 is returned.
485	-	func SignalHandlerFind(InstanceVar Object, MaskVar SignalMatchType, SignalIdVar uint, DetailVar glib.Quark, ClosureVar Closure, FuncVar uintptr, DataVar uintptr) uint32 {	485	+	func SignalHandlerFind(InstanceVar Object, MaskVar SignalMatchType, SignalIdVar uint, DetailVar glib.Quark, ClosureVar Closure, FuncVar uintptr, DataVar uintptr) uint {
486			486
487		cret := xSignalHandlerFind(InstanceVar.GoPointer(), MaskVar, SignalIdVar, DetailVar, ClosureVar, FuncVar, DataVar)	487		cret := xSignalHandlerFind(InstanceVar.GoPointer(), MaskVar, SignalIdVar, DetailVar, ClosureVar, FuncVar, DataVar)
488			488
489		return cret	489		return cret
490		}	490		}
491			491
492	-	var xSignalHandlerIsConnected func(uintptr, uint32) bool	492	+	var xSignalHandlerIsConnected func(uintptr, uint) bool
493			493
494		// Returns whether @handler_id is the ID of a handler connected to @instance.	494		// Returns whether @handler_id is the ID of a handler connected to @instance.
495	-	func SignalHandlerIsConnected(InstanceVar *Object, HandlerIdVar uint32) bool {	495	+	func SignalHandlerIsConnected(InstanceVar *Object, HandlerIdVar uint) bool {
496			496
497		cret := xSignalHandlerIsConnected(InstanceVar.GoPointer(), HandlerIdVar)	497		cret := xSignalHandlerIsConnected(InstanceVar.GoPointer(), HandlerIdVar)
498			498
499		return cret	499		return cret
500		}	500		}
501			501
502	-	var xSignalHandlerUnblock func(uintptr, uint32)	502	+	var xSignalHandlerUnblock func(uintptr, uint)
503			503
504		// Undoes the effect of a previous g_signal_handler_block() call. A	504		// Undoes the effect of a previous g_signal_handler_block() call. A
505		// blocked handler is skipped during signal emissions and will not be	505		// blocked handler is skipped during signal emissions and will not be

@@ -514,7 +514,7 @@ var xSignalHandlerUnblock func(uintptr, uint32)
514		//	514		//
515		// The @handler_id has to be a valid id of a signal handler that is	515		// The @handler_id has to be a valid id of a signal handler that is
516		// connected to a signal of @instance and is currently blocked.	516		// connected to a signal of @instance and is currently blocked.
517	-	func SignalHandlerUnblock(InstanceVar *Object, HandlerIdVar uint32) {	517	+	func SignalHandlerUnblock(InstanceVar *Object, HandlerIdVar uint) {
518			518
519		xSignalHandlerUnblock(InstanceVar.GoPointer(), HandlerIdVar)	519		xSignalHandlerUnblock(InstanceVar.GoPointer(), HandlerIdVar)
520			520

@@ -917,10 +917,10 @@ func NewSignalQuery(SignalIdVar uint, QueryVar *SignalQuery) {
917			917
918		}	918		}
919			919
920	-	var xSignalRemoveEmissionHook func(uint, uint32)	920	+	var xSignalRemoveEmissionHook func(uint, uint)
921			921
922		// Deletes an emission hook.	922		// Deletes an emission hook.
923	-	func SignalRemoveEmissionHook(SignalIdVar uint, HookIdVar uint32) {	923	+	func SignalRemoveEmissionHook(SignalIdVar uint, HookIdVar uint) {
924			924
925		xSignalRemoveEmissionHook(SignalIdVar, HookIdVar)	925		xSignalRemoveEmissionHook(SignalIdVar, HookIdVar)
926			926

M v4/gobject/gsignalgroup.go +14 -6

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+		handlerID := SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, InstanceVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+	handlerID := SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+		handlerID := SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+	handlerID := SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gobject/gvalue.go +9 -13

 	return cret
 }
-var xValueGetLong func(uintptr) int32
+var xValueGetLong func(uintptr) int
 // Get the contents of a %G_TYPE_LONG #GValue.
-func (x *Value) GetLong() int32 {
+func (x *Value) GetLong() int {
 	cret := xValueGetLong(x.GoPointer())
 	return cret
 }
-var xValueGetUlong func(uintptr) uint32
+var xValueGetUlong func(uintptr) uint
 // Get the contents of a %G_TYPE_ULONG #GValue.
-func (x *Value) GetUlong() uint32 {
+func (x *Value) GetUlong() uint {
 	cret := xValueGetUlong(x.GoPointer())
 }
-var xValueSetLong func(uintptr, int32)
+var xValueSetLong func(uintptr, int)
 // Set the contents of a %G_TYPE_LONG #GValue to @v_long.
-func (x *Value) SetLong(VLongVar int32) {
+func (x *Value) SetLong(VLongVar int) {
 	xValueSetLong(x.GoPointer(), VLongVar)
 }
-var xValueSetUlong func(uintptr, uint32)
+var xValueSetUlong func(uintptr, uint)
 // Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
-func (x *Value) SetUlong(VUlongVar uint32) {
+func (x *Value) SetUlong(VUlongVar uint) {
 	xValueSetUlong(x.GoPointer(), VUlongVar)
 // Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
 func (x *Value) TakeString(VStringVar *string) {
-	VStringVarPtr, VStringVarBytes := core.NullableStringToPtr(VStringVar)
+	xValueTakeString(x.GoPointer(), core.GStrdupNullable(VStringVar))
-	xValueTakeString(x.GoPointer(), VStringVarPtr)
-	runtime.KeepAlive(VStringVarBytes)
 }

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

 	xObjectRefSink(a)
 }
-func SignalConnect(a uintptr, b string, c uintptr) uint32 {
+func SignalConnect(a uintptr, b string, c uintptr) uint {
 	return xSignalConnectData(a, b, c, 0, 0, 0)
 }
 	v.SetGoPointer(o.GoPointer())
 }
-func (o Object) ConnectSignal(signal string, cb *func()) uint32 {
+func (o Object) ConnectSignal(signal string, cb *func()) uint {
 	return SignalConnect(o.GoPointer(), signal, glib.NewCallback(cb))
 }
-func (o Object) DisconnectSignal(handler uint32) {
+func (o Object) DisconnectSignal(handler uint) {
 	SignalHandlerDisconnect(&o, handler)
+	glib.RemoveCallbackByHandler(handler)
 }
 // types

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


@@ -822,7 +822,7 @@ func DebugNodeNewFromInternalPtr(ptr uintptr) *DebugNode {
822		return cls	822		return cls
823		}	823		}
824			824
825	-	var xNewDebugNode func(uintptr, string) uintptr	825	+	var xNewDebugNode func(uintptr, uintptr) uintptr
826			826
827		// Creates a `GskRenderNode` that will add debug information about	827		// Creates a `GskRenderNode` that will add debug information about
828		// the given @child.	828		// the given @child.

@@ -831,7 +831,7 @@ var xNewDebugNode func(uintptr, string) uintptr
831		func NewDebugNode(ChildVar RenderNode, MessageVar string) DebugNode {	831		func NewDebugNode(ChildVar RenderNode, MessageVar string) DebugNode {
832		var cls *DebugNode	832		var cls *DebugNode
833			833
834	-	cret := xNewDebugNode(ChildVar.GoPointer(), MessageVar)	834	+	cret := xNewDebugNode(ChildVar.GoPointer(), core.GStrdup(MessageVar))
835			835
836		if cret == 0 {	836		if cret == 0 {
837		return nil	837		return nil

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

 //
 // Applications may connect to it to override the default behaviour,
 // which is to call [method@Gtk.FileLauncher.launch].
-func (x *AboutDialog) ConnectActivateLink(cb *func(AboutDialog, string) bool) uint32 {
+func (x *AboutDialog) ConnectActivateLink(cb *func(AboutDialog, string) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, UriVarp string) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the value has been changed.
-func (x *Adjustment) ConnectValueChanged(cb *func(Adjustment)) uint32 {
+func (x *Adjustment) ConnectValueChanged(cb *func(Adjustment)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtkappchooserbutton.go +28 -12

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the active application changes.
-func (x *AppChooserButton) ConnectChanged(cb *func(AppChooserButton)) uint32 {
+func (x *AppChooserButton) ConnectChanged(cb *func(AppChooserButton)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "custom-item-activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "custom-item-activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ItemNameVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "custom-item-activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "custom-item-activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // ConnectCustomItemActivatedWithDetail connects to the "custom-item-activated" signal with a detail string.
 // The detail is appended as "custom-item-activated::<detail>".
-func (x *AppChooserButton) ConnectCustomItemActivatedWithDetail(detail string, cb *func(AppChooserButton, string)) uint32 {
+func (x *AppChooserButton) ConnectCustomItemActivatedWithDetail(detail string, cb *func(AppChooserButton, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	signalName := fmt.Sprintf("custom-item-activated::%s", detail)
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ItemNameVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "application-activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "application-activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ApplicationVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "application-activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "application-activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "application-selected", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "application-selected", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ApplicationVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "application-selected", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "application-selected", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // Applications can connect to this signal and call
 // [method@Gtk.Application.inhibit] with [flags@Gtk.ApplicationInhibitFlags.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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "query-end", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "query-end", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "query-end", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "query-end", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a window is added to an application.
 //
 // See [method@Gtk.Application.add_window].
-func (x *Application) ConnectWindowAdded(cb *func(Application, uintptr)) uint32 {
+func (x *Application) ConnectWindowAdded(cb *func(Application, uintptr)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "window-added", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "window-added", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WindowVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "window-added", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "window-added", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a window is removed from an 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "window-removed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "window-removed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WindowVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "window-removed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "window-removed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emits the [signal@Gio.ActionGroup::action-added] signal on @action_group.

M v4/gtk/gtkassistant.go +35 -15

 // %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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "apply", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when then the cancel button is clicked.
-func (x *Assistant) ConnectCancel(cb *func(Assistant)) uint32 {
+func (x *Assistant) ConnectCancel(cb *func(Assistant)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // The action signal for the Escape binding.
-func (x *Assistant) ConnectEscape(cb *func(Assistant)) uint32 {
+func (x *Assistant) ConnectEscape(cb *func(Assistant)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "escape", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "escape", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "escape", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "escape", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "state-change", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "state-change", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "state-change", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "state-change", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 //
 // The default bindings for this signal are all forms of the
 // &lt;kbd&gt;␣&lt;/kbd&gt; and &lt;kbd&gt;Enter&lt;/kbd&gt; keys.
-func (x *Button) ConnectActivate(cb *func(Button)) uint32 {
+func (x *Button) ConnectActivate(cb *func(Button)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 }
 // Emitted when the user selects a day.
-func (x *Calendar) ConnectDaySelected(cb *func(Calendar)) uint32 {
+func (x *Calendar) ConnectDaySelected(cb *func(Calendar)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "day-selected", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "day-selected", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "day-selected", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "day-selected", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the user switches to the next month.
-func (x *Calendar) ConnectNextMonth(cb *func(Calendar)) uint32 {
+func (x *Calendar) ConnectNextMonth(cb *func(Calendar)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "next-month", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "next-month", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "next-month", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "next-month", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when user switches to the next year.
-func (x *Calendar) ConnectNextYear(cb *func(Calendar)) uint32 {
+func (x *Calendar) ConnectNextYear(cb *func(Calendar)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "next-year", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "next-year", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "next-year", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "next-year", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the user switches to the previous month.
-func (x *Calendar) ConnectPrevMonth(cb *func(Calendar)) uint32 {
+func (x *Calendar) ConnectPrevMonth(cb *func(Calendar)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "prev-month", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "prev-month", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "prev-month", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "prev-month", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when user switches to the previous year.
-func (x *Calendar) ConnectPrevYear(cb *func(Calendar)) uint32 {
+func (x *Calendar) ConnectPrevYear(cb *func(Calendar)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "prev-year", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "prev-year", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "prev-year", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "prev-year", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkcellarea.go +28 -12

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "add-editable", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "add-editable", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, RendererVarp uintptr, EditableVarp uintptr, CellAreaVarp uintptr, PathVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "add-editable", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "add-editable", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "apply-attributes", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "apply-attributes", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ModelVarp uintptr, IterVarp uintptr, IsExpanderVarp bool, IsExpandedVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "apply-attributes", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "apply-attributes", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "focus-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "focus-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, RendererVarp uintptr, PathVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "focus-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "focus-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "remove-editable", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "remove-editable", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, RendererVarp uintptr, EditableVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "remove-editable", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "remove-editable", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the ID of the @buildable object.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "editing-canceled", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "editing-canceled", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "editing-canceled", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "editing-canceled", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "editing-started", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "editing-started", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, EditableVarp uintptr, PathVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "editing-started", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "editing-started", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "accel-cleared", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "accel-cleared", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathStringVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "accel-cleared", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "accel-cleared", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "accel-edited", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "accel-edited", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathStringVarp string, AccelKeyVarp uint, AccelModsVarp gdk.ModifierType, HardwareKeycodeVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "accel-edited", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "accel-edited", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathStringVarp string, NewIterVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "edited", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "edited", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathVarp string, NewTextVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "edited", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "edited", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 //
 // The default bindings for this signal are all forms of the
 // &lt;kbd&gt;␣&lt;/kbd&gt; and &lt;kbd&gt;Enter&lt;/kbd&gt; keys.
-func (x *CheckButton) ConnectActivate(cb *func(CheckButton)) uint32 {
+func (x *CheckButton) ConnectActivate(cb *func(CheckButton)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "color-set", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "color-set", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "color-set", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "color-set", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkcolordialogbutton.go +7 -3

 //
 // The `::activate` signal on `GtkColorDialogButton` is an action signal
 // and emitting it causes the button to pop up its dialog.
-func (x *ColorDialogButton) ConnectActivate(cb *func(ColorDialogButton)) uint32 {
+func (x *ColorDialogButton) ConnectActivate(cb *func(ColorDialogButton)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PositionVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkcombobox.go +42 -18

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "format-entry-text", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "format-entry-text", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathVarp string) string {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "format-entry-text", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "format-entry-text", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-active", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-active", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ScrollTypeVarp ScrollType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-active", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-active", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "parsing-error", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "parsing-error", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SectionVarp uintptr, ErrorVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "parsing-error", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "parsing-error", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResponseIdVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DragVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-cancel", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-cancel", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DragVarp uintptr, ReasonVarp gdk.DragCancelReason) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-cancel", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-cancel", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DragVarp uintptr, DeleteDataVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) uintptr {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "prepare", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtkdrawingarea.go +7 -3

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WidthVarp int, HeightVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Signals that the pointer has left the widget.
-func (x *DropControllerMotion) ConnectLeave(cb *func(DropControllerMotion)) uint32 {
+func (x *DropControllerMotion) ConnectLeave(cb *func(DropControllerMotion)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // [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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ValueVarp uintptr, XVarp float64, YVarp float64) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) gdk.DragAction {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) gdk.DragAction {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "accept", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-enter", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-enter", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr, XVarp float64, YVarp float64) gdk.DragAction {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-enter", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-enter", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-leave", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-leave", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-leave", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-leave", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-motion", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-motion", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr, XVarp float64, YVarp float64) gdk.DragAction {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-motion", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-motion", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DropVarp uintptr, XVarp float64, YVarp float64) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drop", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // Emitted when the user selects an Emoji.
-func (x *EmojiChooser) ConnectEmojiPicked(cb *func(EmojiChooser, string)) uint32 {
+func (x *EmojiChooser) ConnectEmojiPicked(cb *func(EmojiChooser, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "emoji-picked", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "emoji-picked", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TextVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "emoji-picked", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "emoji-picked", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when an activatable icon is clicked.
-func (x *Entry) ConnectIconPress(cb *func(Entry, EntryIconPosition)) uint32 {
+func (x *Entry) ConnectIconPress(cb *func(Entry, EntryIconPosition)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "icon-press", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "icon-press", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, IconPosVarp EntryIconPosition) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "icon-press", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "icon-press", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "icon-release", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "icon-release", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, IconPosVarp EntryIconPosition) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "icon-release", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "icon-release", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "deleted-text", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "deleted-text", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PositionVarp uint, NCharsVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "deleted-text", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "deleted-text", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "inserted-text", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "inserted-text", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PositionVarp uint, CharsVarp string, NCharsVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "inserted-text", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "inserted-text", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtkentrycompletion.go +28 -12

 //
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cursor-on-match", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cursor-on-match", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ModelVarp uintptr, IterVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cursor-on-match", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cursor-on-match", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "insert-prefix", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "insert-prefix", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PrefixVarp string) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "insert-prefix", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "insert-prefix", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "match-selected", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "match-selected", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ModelVarp uintptr, IterVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "match-selected", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "match-selected", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "no-matches", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "no-matches", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "no-matches", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "no-matches", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the ID of the @buildable object.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "im-update", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "im-update", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "im-update", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "im-update", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "key-pressed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "key-pressed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, KeyvalVarp uint, KeycodeVarp uint, StateVarp gdk.ModifierType) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "key-pressed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "key-pressed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "key-released", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "key-released", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, KeyvalVarp uint, KeycodeVarp uint, StateVarp gdk.ModifierType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "key-released", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "key-released", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "modifiers", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "modifiers", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StateVarp gdk.ModifierType) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "modifiers", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "modifiers", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, EventVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "event", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "enter", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Signals that the pointer has left the widget.
-func (x *EventControllerMotion) ConnectLeave(cb *func(EventControllerMotion)) uint32 {
+func (x *EventControllerMotion) ConnectLeave(cb *func(EventControllerMotion)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "leave", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // @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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, VelXVarp float64, VelYVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DxVarp float64, DyVarp float64) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // Activates the `GtkExpander`.
-func (x *Expander) ConnectActivate(cb *func(Expander)) uint32 {
+func (x *Expander) ConnectActivate(cb *func(Expander)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "desktop-folder", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "desktop-folder", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "desktop-folder", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "desktop-folder", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "down-folder", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "down-folder", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "down-folder", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "down-folder", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "home-folder", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "home-folder", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "home-folder", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "home-folder", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "location-popup", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "location-popup", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "location-popup", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "location-popup", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "location-popup-on-paste", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "location-popup-on-paste", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "location-popup-on-paste", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "location-popup-on-paste", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "location-toggle-popup", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "location-toggle-popup", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "location-toggle-popup", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "location-toggle-popup", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "places-shortcut", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "places-shortcut", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "places-shortcut", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "places-shortcut", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "quick-bookmark", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "quick-bookmark", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, BookmarkIndexVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "quick-bookmark", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "quick-bookmark", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "recent-shortcut", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "recent-shortcut", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "recent-shortcut", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "recent-shortcut", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "search-shortcut", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "search-shortcut", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "search-shortcut", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "search-shortcut", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "show-hidden", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "show-hidden", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "show-hidden", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "show-hidden", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "up-folder", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "up-folder", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "up-folder", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "up-folder", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ChangeVarp FilterChange) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtkflowbox.go +56 -24

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-cursor-child", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-cursor-child", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-child", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-cursor-child", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "child-activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "child-activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ChildVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "child-activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "child-activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool, ModifyVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "selected-children-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "selected-children-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "selected-children-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "selected-children-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-child", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-child", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-child", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-child", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkfontbutton.go +14 -6

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "font-set", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "font-set", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "font-set", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "font-set", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkfontdialogbutton.go +7 -3

 //
 // The `::activate` signal on `GtkFontDialogButton` is an action signal
 // and emitting it causes the button to pop up its dialog.
-func (x *FontDialogButton) ConnectActivate(cb *func(FontDialogButton)) uint32 {
+func (x *FontDialogButton) ConnectActivate(cb *func(FontDialogButton)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkgesture.go +35 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "begin", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "begin", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "begin", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "begin", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cancel", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "end", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "end", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "end", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "end", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "sequence-state-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "sequence-state-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr, StateVarp EventSequenceState) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "sequence-state-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "sequence-state-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SequenceVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "update", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, NPressVarp int, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "released", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "released", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, NPressVarp int, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "released", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "released", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted whenever any time/distance threshold has been exceeded.
-func (x *GestureClick) ConnectStopped(cb *func(GestureClick)) uint32 {
+func (x *GestureClick) ConnectStopped(cb *func(GestureClick)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "stopped", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "stopped", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "stopped", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "stopped", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unpaired-release", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unpaired-release", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64, ButtonVarp uint, SequenceVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unpaired-release", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unpaired-release", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // Emitted whenever dragging starts.
-func (x *GestureDrag) ConnectDragBegin(cb *func(GestureDrag, float64, float64)) uint32 {
+func (x *GestureDrag) ConnectDragBegin(cb *func(GestureDrag, float64, float64)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StartXVarp float64, StartYVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-begin", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, OffsetXVarp float64, OffsetYVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-end", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "drag-update", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "drag-update", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, OffsetXVarp float64, OffsetYVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "drag-update", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "drag-update", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cancelled", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "pressed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "pan", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "pan", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DirectionVarp PanDirection, OffsetVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "pan", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "pan", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "angle-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "angle-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, AngleVarp float64, AngleDeltaVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "angle-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "angle-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "down", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "down", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "down", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "down", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "motion", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "proximity", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "proximity", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "proximity", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "proximity", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "up", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "up", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp float64, YVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "up", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "up", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "swipe", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "swipe", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, VelocityXVarp float64, VelocityYVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "swipe", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "swipe", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "scale-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "scale-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ScaleVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "scale-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "scale-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtkglarea.go +21 -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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "create-context", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "create-context", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) uintptr {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "create-context", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "create-context", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "render", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WidthVarp int, HeightVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "resize", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PositionVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // This can happen because 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xIconThemeGetForDisplay func(uintptr) uintptr

M v4/gtk/gtkiconview.go +56 -24

 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-cursor-item", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-cursor-item", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-item", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-cursor-item", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "item-activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "item-activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "item-activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "item-activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool, ModifyVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-cursor-item", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-item", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-cursor-item", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-item", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "selection-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "selection-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "selection-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "selection-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-item", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-item", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-item", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-item", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "commit", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "commit", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StrVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "commit", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "commit", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "delete-surrounding", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "delete-surrounding", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, OffsetVarp int, NCharsVarp int) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "delete-surrounding", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "delete-surrounding", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "preedit-end", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-end", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "preedit-end", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-end", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "preedit-start", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-start", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "preedit-start", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-start", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "retrieve-surrounding", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "retrieve-surrounding", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "retrieve-surrounding", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "retrieve-surrounding", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResponseIdVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // if they need to control activation of URIs programmatically.
 //
 // The default bindings for this signal are all forms of the &lt;kbd&gt;Enter&lt;/kbd&gt; key.
-func (x *Label) ConnectActivateCurrentLink(cb *func(Label)) uint32 {
+func (x *Label) ConnectActivateCurrentLink(cb *func(Label)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-current-link", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-current-link", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-current-link", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-current-link", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets emitted to activate a URI.
 //
 // Applications may connect to it to override the default behaviour,
 // which is to call [method@Gtk.FileLauncher.launch].
-func (x *Label) ConnectActivateLink(cb *func(Label, string) bool) uint32 {
+func (x *Label) ConnectActivateLink(cb *func(Label, string) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, UriVarp string) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets emitted to copy the selection to the clipboard.
 // The `::copy-clipboard` signal is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;c&lt;/kbd&gt;.
-func (x *Label) ConnectCopyClipboard(cb *func(Label)) uint32 {
+func (x *Label) ConnectCopyClipboard(cb *func(Label)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets 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; and &lt;kbd&gt;End&lt;/kbd&gt; 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendSelectionVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "offset-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "offset-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, NameVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "offset-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "offset-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // ConnectOffsetChangedWithDetail connects to the "offset-changed" signal with a detail string.
 // The detail is appended as "offset-changed::<detail>".
-func (x *LevelBar) ConnectOffsetChangedWithDetail(detail string, cb *func(LevelBar, string)) uint32 {
+func (x *LevelBar) ConnectOffsetChangedWithDetail(detail string, cb *func(LevelBar, string)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	signalName := fmt.Sprintf("offset-changed::%s", detail)
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, NameVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-link", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtklistbox.go +63 -27

 }
 // Emitted when the cursor row is activated.
-func (x *ListBox) ConnectActivateCursorRow(cb *func(ListBox)) uint32 {
+func (x *ListBox) ConnectActivateCursorRow(cb *func(ListBox)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-cursor-row", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-cursor-row", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-cursor-row", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-cursor-row", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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 *ListBox) ConnectMoveCursor(cb *func(ListBox, MovementStep, int, bool, bool)) uint32 {
+func (x *ListBox) ConnectMoveCursor(cb *func(ListBox, MovementStep, int, bool, bool)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool, ModifyVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, RowVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "row-selected", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "row-selected", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, RowVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "row-selected", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "row-selected", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the set of selected rows changes.
-func (x *ListBox) ConnectSelectedRowsChanged(cb *func(ListBox)) uint32 {
+func (x *ListBox) ConnectSelectedRowsChanged(cb *func(ListBox)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "selected-rows-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "selected-rows-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "selected-rows-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "selected-rows-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the cursor row is toggled.
 //
 // The default bindings for this signal is &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;␣&lt;/kbd&gt;.
-func (x *ListBox) ConnectToggleCursorRow(cb *func(ListBox)) uint32 {
+func (x *ListBox) ConnectToggleCursorRow(cb *func(ListBox)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PositionVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkmenubutton.go +7 -3

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResponseIdVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt;,
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt;,
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt; and &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt;.
-func (x *Notebook) ConnectChangeCurrentPage(cb *func(Notebook, int) bool) uint32 {
+func (x *Notebook) ConnectChangeCurrentPage(cb *func(Notebook, int) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp int) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr) uintptr {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "create-window", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a tab should be focused.
-func (x *Notebook) ConnectFocusTab(cb *func(Notebook, NotebookTab) bool) uint32 {
+func (x *Notebook) ConnectFocusTab(cb *func(Notebook, NotebookTab) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "focus-tab", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "focus-tab", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TabVarp NotebookTab) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "focus-tab", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "focus-tab", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when focus was moved out.
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt;,
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;←&lt;/kbd&gt;, &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;→&lt;/kbd&gt;,
 // &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 *Notebook) ConnectMoveFocusOut(cb *func(Notebook, DirectionType)) uint32 {
+func (x *Notebook) ConnectMoveFocusOut(cb *func(Notebook, DirectionType)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DirectionVarp DirectionType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "page-added", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "page-added", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ChildVarp uintptr, PageNumVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "page-added", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "page-added", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "page-removed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "page-removed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ChildVarp uintptr, PageNumVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "page-removed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "page-removed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ChildVarp uintptr, PageNumVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "page-reordered", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the tab should be reordered.
 // &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt;, &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt;,
 // &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;←&lt;/kbd&gt;, &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;→&lt;/kbd&gt;,
 // &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;↑&lt;/kbd&gt; and &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;↓&lt;/kbd&gt;.
-func (x *Notebook) ConnectReorderTab(cb *func(Notebook, DirectionType, bool) bool) uint32 {
+func (x *Notebook) ConnectReorderTab(cb *func(Notebook, DirectionType, bool) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "reorder-tab", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "reorder-tab", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DirectionVarp DirectionType, MoveToLastVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "reorder-tab", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "reorder-tab", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a page should be selected.
 //
 // The default binding for this signal is &lt;kbd&gt;␣&lt;/kbd&gt;.
-func (x *Notebook) ConnectSelectPage(cb *func(Notebook, bool) bool) uint32 {
+func (x *Notebook) ConnectSelectPage(cb *func(Notebook, bool) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-page", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-page", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MoveFocusVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-page", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-page", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "switch-page", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "switch-page", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PageVarp uintptr, PageNumVarp uint) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "switch-page", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "switch-page", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "get-child-position", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "get-child-position", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WidgetVarp uintptr, AllocationVarp *uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "get-child-position", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "get-child-position", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "accept-position", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "accept-position", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "accept-position", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "accept-position", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cancel-position", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cancel-position", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cancel-position", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cancel-position", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cycle-child-focus", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cycle-child-focus", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ReversedVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cycle-child-focus", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cycle-child-focus", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cycle-handle-focus", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cycle-handle-focus", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ReversedVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cycle-handle-focus", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cycle-handle-focus", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted to move the handle with key bindings.
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;↑&lt;/kbd&gt;, &lt;kbd&gt;↑&lt;/kbd&gt;,
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;↓&lt;/kbd&gt;, &lt;kbd&gt;↓&lt;/kbd&gt;,
 // &lt;kbd&gt;PgUp&lt;/kbd&gt;, &lt;kbd&gt;PgDn&lt;/kbd&gt;, &lt;kbd&gt;Home&lt;/kbd&gt;, &lt;kbd&gt;End&lt;/kbd&gt;.
-func (x *Paned) ConnectMoveHandle(cb *func(Paned, ScrollType) bool) uint32 {
+func (x *Paned) ConnectMoveHandle(cb *func(Paned, ScrollType) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-handle", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-handle", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ScrollTypeVarp ScrollType) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-handle", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-handle", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggle-handle-focus", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-handle-focus", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggle-handle-focus", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-handle-focus", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;Enter&lt;/kbd&gt;.
-func (x *Popover) ConnectActivateDefault(cb *func(Popover)) uint32 {
+func (x *Popover) ConnectActivateDefault(cb *func(Popover)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the popover is closed.
-func (x *Popover) ConnectClosed(cb *func(Popover)) uint32 {
+func (x *Popover) ConnectClosed(cb *func(Popover)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "closed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkprinter.go +7 -3

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "details-acquired", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "details-acquired", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SuccessVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "details-acquired", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "details-acquired", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtkprintjob.go +7 -3

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtkprintoperation.go +77 -33

 // [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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "begin-print", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "begin-print", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "begin-print", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "begin-print", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "create-custom-widget", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "create-custom-widget", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) uintptr {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "create-custom-widget", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "create-custom-widget", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "custom-widget-apply", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "custom-widget-apply", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WidgetVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "custom-widget-apply", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "custom-widget-apply", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ResultVarp PrintOperationResult) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "done", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "draw-page", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "draw-page", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr, PageNrVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "draw-page", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "draw-page", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "end-print", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "end-print", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "end-print", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "end-print", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "paginate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "paginate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "paginate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "paginate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "preview", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "preview", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PreviewVarp uintptr, ContextVarp uintptr, ParentVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "preview", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "preview", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "request-page-setup", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "request-page-setup", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ContextVarp uintptr, PageNrVarp int, SetupVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "request-page-setup", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "request-page-setup", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "status-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "update-custom-widget", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "update-custom-widget", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, WidgetVarp uintptr, SetupVarp uintptr, SettingsVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "update-custom-widget", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "update-custom-widget", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Ends a preview.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "adjust-bounds", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "adjust-bounds", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ValueVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "adjust-bounds", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "adjust-bounds", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ScrollVarp ScrollType, ValueVarp float64) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-slider", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-slider", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp ScrollType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-slider", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-slider", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the range value changes.
-func (x *Range) ConnectValueChanged(cb *func(Range)) uint32 {
+func (x *Range) ConnectValueChanged(cb *func(Range)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtkrecentmanager.go +7 -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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 var xRecentManagerGetDefault func() uintptr

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "popdown", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "popup", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the value field has changed.
-func (x *ScaleButton) ConnectValueChanged(cb *func(ScaleButton, float64)) uint32 {
+func (x *ScaleButton) ConnectValueChanged(cb *func(ScaleButton, float64)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ValueVarp float64) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "edge-overshot", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "edge-overshot", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PosVarp PositionType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "edge-overshot", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "edge-overshot", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "edge-reached", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "edge-reached", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PosVarp PositionType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "edge-reached", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "edge-reached", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when focus is moved away from the scrolled window by a
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; to move forward and
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt;` to move backward.
-func (x *ScrolledWindow) ConnectMoveFocusOut(cb *func(ScrolledWindow, DirectionType)) uint32 {
+func (x *ScrolledWindow) ConnectMoveFocusOut(cb *func(ScrolledWindow, DirectionType)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DirectionTypeVarp DirectionType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "scroll-child", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-child", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ScrollVarp ScrollType, HorizontalVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "scroll-child", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-child", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // Emitted when the entry is activated.
 //
 // The keybindings for this signal are all forms of the &lt;kbd&gt;Enter&lt;/kbd&gt; key.
-func (x *SearchEntry) ConnectActivate(cb *func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectActivate(cb *func(SearchEntry)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the user initiates a move to the next match
 // between matches.
 //
 // The default bindings for this signal is &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;g&lt;/kbd&gt;.
-func (x *SearchEntry) ConnectNextMatch(cb *func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectNextMatch(cb *func(SearchEntry)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "next-match", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "next-match", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "next-match", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "next-match", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the user initiates a move to the previous match
 //
 // The default bindings for this signal is
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;g&lt;/kbd&gt;.
-func (x *SearchEntry) ConnectPreviousMatch(cb *func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectPreviousMatch(cb *func(SearchEntry)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "previous-match", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "previous-match", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "previous-match", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "previous-match", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "search-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "search-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "search-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "search-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "search-started", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "search-started", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "search-started", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "search-started", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the user stops a search via keyboard input.
 // the search entry in this case.
 //
 // The default bindings for this signal is &lt;kbd&gt;Escape&lt;/kbd&gt;.
-func (x *SearchEntry) ConnectStopSearch(cb *func(SearchEntry)) uint32 {
+func (x *SearchEntry) ConnectStopSearch(cb *func(SearchEntry)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "stop-search", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "stop-search", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "stop-search", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "stop-search", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt;, &lt;kbd&gt;PgUp&lt;/kbd&gt;,
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt;, &lt;kbd&gt;PgDn&lt;/kbd&gt;.
-func (x *ShortcutsSection) ConnectChangeCurrentPage(cb *func(ShortcutsSection, int) bool) uint32 {
+func (x *ShortcutsSection) ConnectChangeCurrentPage(cb *func(ShortcutsSection, int) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, OffsetVarp int) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "change-current-page", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is the &lt;kbd&gt;Escape&lt;/kbd&gt; key.
-func (x *ShortcutsWindow) ConnectClose(cb *func(ShortcutsWindow)) uint32 {
+func (x *ShortcutsWindow) ConnectClose(cb *func(ShortcutsWindow)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "close", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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 &lt;kbd&gt;Control&lt;/kbd&gt;+&lt;kbd&gt;F&lt;/kbd&gt;.
-func (x *ShortcutsWindow) ConnectSearch(cb *func(ShortcutsWindow)) uint32 {
+func (x *ShortcutsWindow) ConnectSearch(cb *func(ShortcutsWindow)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "search", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "search", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "search", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "search", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ObjectVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "bind", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when a newly created listitem needs to be prepared 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "setup", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "setup", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ObjectVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "setup", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "setup", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "teardown", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "teardown", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ObjectVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "teardown", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "teardown", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when an object has been unbound from its item.
 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ObjectVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ChangeVarp SorterChange) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtkspinbutton.go +42 -18

 // If the &lt;kbd&gt;Enter&lt;/kbd&gt; key results in the value being committed to the
 // spin button, then activation does not occur until &lt;kbd&gt;Enter&lt;/kbd&gt; is
 // pressed again.
-func (x *SpinButton) ConnectActivate(cb *func(SpinButton)) uint32 {
+func (x *SpinButton) ConnectActivate(cb *func(SpinButton)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the user initiates a value change.
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ScrollVarp ScrollType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "change-value", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, NewValueVarp *float64) int {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "output", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "value-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "wrapped", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "text-popped", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "text-popped", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ContextIdVarp uint, TextVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "text-popped", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "text-popped", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "text-pushed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "text-pushed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ContextIdVarp uint, TextVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "text-pushed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "text-pushed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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


@@ -165,7 +165,7 @@ func (x *StringList) Splice(PositionVar uint, NRemovalsVar uint, AdditionsVar []
165			165
166		}	166		}
167			167
168	-	var xStringListTake func(uintptr, string)	168	+	var xStringListTake func(uintptr, uintptr)
169			169
170		// Adds @string to self at the end, and takes	170		// Adds @string to self at the end, and takes
171		// ownership of it.	171		// ownership of it.

@@ -178,7 +178,7 @@ var xStringListTake func(uintptr, string)
178		// ```	178		// ```
179		func (x *StringList) Take(StringVar string) {	179		func (x *StringList) Take(StringVar string) {
180			180
181	-	xStringListTake(x.GoPointer(), StringVar)	181	+	xStringListTake(x.GoPointer(), core.GStrdup(StringVar))
182			182
183		}	183		}
184			184

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted to change the underlying state.
 // [method@Gtk.Switch.set_state] when the underlying state change is
 // complete. The signal handler should return %TRUE to prevent the
 // default handler from running.
-func (x *Switch) ConnectStateSet(cb *func(Switch, bool) bool) uint32 {
+func (x *Switch) ConnectStateSet(cb *func(Switch, bool) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "state-set", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "state-set", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StateVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "state-set", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "state-set", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TypeVarp DeleteType, CountVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StringVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted to present the Emoji chooser.
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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; and &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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PreeditVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted to toggle the overwrite mode.
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // [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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "apply-tag", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "apply-tag", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr, StartVarp uintptr, EndVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "apply-tag", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "apply-tag", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "begin-user-action", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "begin-user-action", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "begin-user-action", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "begin-user-action", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the content of a `GtkTextBuffer` has changed.
-func (x *TextBuffer) ConnectChanged(cb *func(TextBuffer)) uint32 {
+func (x *TextBuffer) ConnectChanged(cb *func(TextBuffer)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "delete-range", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "delete-range", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StartVarp uintptr, EndVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "delete-range", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "delete-range", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "end-user-action", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "end-user-action", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "end-user-action", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "end-user-action", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "insert-child-anchor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "insert-child-anchor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, LocationVarp uintptr, AnchorVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "insert-child-anchor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "insert-child-anchor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "insert-paintable", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "insert-paintable", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, LocationVarp uintptr, PaintableVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "insert-paintable", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "insert-paintable", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "insert-text", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "insert-text", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, LocationVarp uintptr, TextVarp string, LenVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "insert-text", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "insert-text", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "mark-deleted", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "mark-deleted", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, MarkVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "mark-deleted", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "mark-deleted", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "mark-set", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "mark-set", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, LocationVarp uintptr, MarkVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "mark-set", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "mark-set", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "modified-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "modified-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "modified-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "modified-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "paste-done", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "paste-done", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ClipboardVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "paste-done", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "paste-done", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "redo", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "redo", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "redo", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "redo", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "remove-tag", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "remove-tag", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr, StartVarp uintptr, EndVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "remove-tag", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "remove-tag", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "undo", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "undo", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "undo", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "undo", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtktexttagtable.go +21 -9

 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "tag-added", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "tag-added", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "tag-added", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "tag-added", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "tag-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "tag-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr, SizeChangedVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "tag-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "tag-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "tag-removed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "tag-removed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TagVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "tag-removed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "tag-removed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the ID of the @buildable object.

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

 //
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "backspace", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "copy-clipboard", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cut-clipboard", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, TypeVarp DeleteType, CountVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "delete-from-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "extend-selection", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "extend-selection", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, GranularityVarp TextExtendSelection, LocationVarp uintptr, StartVarp uintptr, EndVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "extend-selection", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "extend-selection", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StringVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "insert-at-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "insert-emoji", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets emitted when the user initiates a cursor movement.
 //   - &lt;kbd&gt;PgUp&lt;/kbd&gt; and &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; and &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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, CountVarp int, ExtendSelectionVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-viewport", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-viewport", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp ScrollStep, CountVarp int) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-viewport", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-viewport", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "paste-clipboard", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PreeditVarp string) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "preedit-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, SelectVarp bool) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "set-anchor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "set-anchor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "set-anchor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "set-anchor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-visible", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-visible", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-visible", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-visible", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-overwrite", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 }
 // Emitted whenever the `GtkToggleButton`'s state is changed.
-func (x *ToggleButton) ConnectToggled(cb *func(ToggleButton)) uint32 {
+func (x *ToggleButton) ConnectToggled(cb *func(ToggleButton)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggled", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 func init() {

M v4/gtk/gtktreeview.go +105 -45

 }
 // The number of columns of the treeview has changed.
-func (x *TreeView) ConnectColumnsChanged(cb *func(TreeView)) uint32 {
+func (x *TreeView) ConnectColumnsChanged(cb *func(TreeView)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "columns-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "columns-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "columns-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "columns-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // The position of the cursor (focused cell) has changed.
-func (x *TreeView) ConnectCursorChanged(cb *func(TreeView)) uint32 {
+func (x *TreeView) ConnectCursorChanged(cb *func(TreeView)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "cursor-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "cursor-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "cursor-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "cursor-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
-func (x *TreeView) ConnectExpandCollapseCursorRow(cb *func(TreeView, bool, bool, bool) bool) uint32 {
+func (x *TreeView) ConnectExpandCollapseCursorRow(cb *func(TreeView, bool, bool, bool) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ObjectVarp bool, P0Varp bool, P1Varp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "expand-collapse-cursor-row", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, StepVarp MovementStep, DirectionVarp int, ExtendVarp bool, ModifyVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-cursor", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PathVarp uintptr, ColumnVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "row-activated", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "row-collapsed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "row-collapsed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "row-collapsed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "row-collapsed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "row-expanded", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "row-expanded", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "row-expanded", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "row-expanded", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
-func (x *TreeView) ConnectSelectAll(cb *func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectSelectAll(cb *func(TreeView) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
-func (x *TreeView) ConnectSelectCursorParent(cb *func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectSelectCursorParent(cb *func(TreeView) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-parent", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
-func (x *TreeView) ConnectSelectCursorRow(cb *func(TreeView, bool) bool) uint32 {
+func (x *TreeView) ConnectSelectCursorRow(cb *func(TreeView, bool) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "select-cursor-row", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-row", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ObjectVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "select-cursor-row", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "select-cursor-row", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
-func (x *TreeView) ConnectStartInteractiveSearch(cb *func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectStartInteractiveSearch(cb *func(TreeView) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "start-interactive-search", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "start-interactive-search", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "start-interactive-search", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "start-interactive-search", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "test-collapse-row", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "test-collapse-row", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "test-collapse-row", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "test-collapse-row", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "test-expand-row", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "test-expand-row", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, IterVarp uintptr, PathVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "test-expand-row", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "test-expand-row", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
-func (x *TreeView) ConnectToggleCursorRow(cb *func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectToggleCursorRow(cb *func(TreeView) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "toggle-cursor-row", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
-func (x *TreeView) ConnectUnselectAll(cb *func(TreeView) bool) uint32 {
+func (x *TreeView) ConnectUnselectAll(cb *func(TreeView) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unselect-all", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

M v4/gtk/gtktreeviewcolumn.go +7 -3

 }
 // Emitted when the column's header has been clicked.
-func (x *TreeViewColumn) ConnectClicked(cb *func(TreeViewColumn)) uint32 {
+func (x *TreeViewColumn) ConnectClicked(cb *func(TreeViewColumn)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "clicked", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Gets the ID of the @buildable object.

M v4/gtk/gtkwidget.go +91 -39

 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "destroy", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "destroy", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "destroy", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "destroy", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "direction-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "direction-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, PreviousDirectionVarp TextDirection) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "direction-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "direction-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when @widget is hidden.
-func (x *Widget) ConnectHide(cb *func(Widget)) uint32 {
+func (x *Widget) ConnectHide(cb *func(Widget)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "hide", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "hide", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "hide", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "hide", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "keynav-failed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "keynav-failed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DirectionVarp DirectionType) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "keynav-failed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "keynav-failed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "map", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "map", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "map", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "map", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "mnemonic-activate", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "mnemonic-activate", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, GroupCyclingVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "mnemonic-activate", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "mnemonic-activate", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the focus is moved.
 //
 // The default bindings for this signal are &lt;kbd&gt;Tab&lt;/kbd&gt; to move forward,
 // and &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; to move backward.
-func (x *Widget) ConnectMoveFocus(cb *func(Widget, DirectionType)) uint32 {
+func (x *Widget) ConnectMoveFocus(cb *func(Widget, DirectionType)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "move-focus", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "move-focus", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, DirectionVarp DirectionType) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "move-focus", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "move-focus", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the widget’s 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "query-tooltip", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "query-tooltip", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, XVarp int, YVarp int, KeyboardModeVarp bool, TooltipVarp uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "query-tooltip", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "query-tooltip", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "realize", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "realize", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "realize", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "realize", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when @widget is shown.
-func (x *Widget) ConnectShow(cb *func(Widget)) uint32 {
+func (x *Widget) ConnectShow(cb *func(Widget)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "show", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "show", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "show", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "show", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "state-flags-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "state-flags-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, FlagsVarp StateFlags) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "state-flags-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "state-flags-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unmap", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unmap", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unmap", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unmap", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "unrealize", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "unrealize", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "unrealize", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "unrealize", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.

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

 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The keybindings for this signal are all forms of the &lt;kbd&gt;Enter&lt;/kbd&gt; key.
-func (x *Window) ConnectActivateDefault(cb *func(Window)) uint32 {
+func (x *Window) ConnectActivateDefault(cb *func(Window)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-default", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the user activates the currently focused
 // This is a [keybinding signal](class.SignalAction.html).
 //
 // The default binding for this signal is &lt;kbd&gt;␣&lt;/kbd&gt;.
-func (x *Window) ConnectActivateFocus(cb *func(Window)) uint32 {
+func (x *Window) ConnectActivateFocus(cb *func(Window)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "activate-focus", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "activate-focus", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "activate-focus", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "activate-focus", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // 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) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "close-request", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "close-request", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "close-request", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "close-request", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the user enables or disables interactive debugging.
 // The default bindings for this signal are
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;I&lt;/kbd&gt; and
 // &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;D&lt;/kbd&gt;.
-func (x *Window) ConnectEnableDebugging(cb *func(Window, bool) bool) uint32 {
+func (x *Window) ConnectEnableDebugging(cb *func(Window, bool) bool) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "enable-debugging", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "enable-debugging", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr, ToggleVarp bool) bool {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "enable-debugging", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "enable-debugging", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Emitted when the set of accelerators or mnemonics that
 // are associated with the window changes.
-func (x *Window) ConnectKeysChanged(cb *func(Window)) uint32 {
+func (x *Window) ConnectKeysChanged(cb *func(Window)) uint {
 	cbPtr := uintptr(unsafe.Pointer(cb))
 	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
-		return gobject.SignalConnect(x.GoPointer(), "keys-changed", cbRefPtr)
+		handlerID := gobject.SignalConnect(x.GoPointer(), "keys-changed", cbRefPtr)
+		glib.SaveHandlerMapping(handlerID, cbPtr)
+		return handlerID
 	}
 	fcb := func(clsPtr uintptr) {
 	}
 	cbRefPtr := purego.NewCallback(fcb)
 	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
-	return gobject.SignalConnect(x.GoPointer(), "keys-changed", cbRefPtr)
+	handlerID := gobject.SignalConnect(x.GoPointer(), "keys-changed", cbRefPtr)
+	glib.SaveHandlerMapping(handlerID, cbPtr)
+	return handlerID
 }
 // Requests the user's screen reader to announce the given message.