Gen: Re-run script

commit: eb0e2e412155fee7cbb42007bd2383e6c8339c86
author: brice · 10mo ago · 2025-12-12 06:19 UTC
parent: 98b19e9
signature: unsigned

84 files · +2860 -2340

M v4/adw/adw-animation-target.go +22 -18


@@ -92,30 +92,34 @@ var xNewCallbackAnimationTarget func(uintptr, uintptr, uintptr) uintptr
92	92		func NewCallbackAnimationTarget(CallbackVar AnimationTargetFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAnimationTarget {
93	93		var cls *CallbackAnimationTarget
94	94
95		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
96	95		var CallbackVarRef uintptr
97		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
98		-	CallbackVarRef = cbRefPtr
99		-	} else {
100		-	fcb := func(arg0 float64, arg1 uintptr) {
101		-	cbFn := *CallbackVar
102		-	cbFn(arg0, arg1)
	96	+	if CallbackVar != nil {
	97	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	98	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	99	+	CallbackVarRef = cbRefPtr
	100	+	} else {
	101	+	fcb := func(arg0 float64, arg1 uintptr) {
	102	+	cbFn := *CallbackVar
	103	+	cbFn(arg0, arg1)
	104	+	}
	105	+	CallbackVarRef = purego.NewCallback(fcb)
	106	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
103	107		}
104		-	CallbackVarRef = purego.NewCallback(fcb)
105		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
106	108		}
107	109
108		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
109	110		var DestroyVarRef uintptr
110		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
111		-	DestroyVarRef = cbRefPtr
112		-	} else {
113		-	fcb := func(arg0 uintptr) {
114		-	cbFn := *DestroyVar
115		-	cbFn(arg0)
	111	+	if DestroyVar != nil {
	112	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	113	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	114	+	DestroyVarRef = cbRefPtr
	115	+	} else {
	116	+	fcb := func(arg0 uintptr) {
	117	+	cbFn := *DestroyVar
	118	+	cbFn(arg0)
	119	+	}
	120	+	DestroyVarRef = purego.NewCallback(fcb)
	121	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
116	122		}
117		-	DestroyVarRef = purego.NewCallback(fcb)
118		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
119	123		}
120	124
121	125		cret := xNewCallbackAnimationTarget(CallbackVarRef, UserDataVar, DestroyVarRef)

M v4/adw/adw-preferences-group.go +11 -9


@@ -128,17 +128,19 @@ func (x PreferencesGroup) BindModel(ModelVar gio.ListModel, CreateRowFuncVar g
128	128		}
129	129		}
130	130
131		-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
132	131		var UserDataFreeFuncVarRef uintptr
133		-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
134		-	UserDataFreeFuncVarRef = cbRefPtr
135		-	} else {
136		-	fcb := func(arg0 uintptr) {
137		-	cbFn := *UserDataFreeFuncVar
138		-	cbFn(arg0)
	132	+	if UserDataFreeFuncVar != nil {
	133	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
	134	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
	135	+	UserDataFreeFuncVarRef = cbRefPtr
	136	+	} else {
	137	+	fcb := func(arg0 uintptr) {
	138	+	cbFn := *UserDataFreeFuncVar
	139	+	cbFn(arg0)
	140	+	}
	141	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
	142	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
139	143		}
140		-	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
141		-	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
142	144		}
143	145
144	146		xPreferencesGroupBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateRowFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)

M v4/gdk/gdkcontentdeserializer.go +33 -27


@@ -69,30 +69,34 @@ var xContentRegisterDeserializer func(string, types.GType, uintptr, uintptr, uin
69	69		// so applications can override the built-in deserializers.
70	70		func ContentRegisterDeserializer(MimeTypeVar string, TypeVar types.GType, DeserializeVar ContentDeserializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {
71	71
72		-	DeserializeVarPtr := uintptr(unsafe.Pointer(DeserializeVar))
73	72		var DeserializeVarRef uintptr
74		-	if cbRefPtr, ok := glib.GetCallback(DeserializeVarPtr); ok {
75		-	DeserializeVarRef = cbRefPtr
76		-	} else {
77		-	fcb := func(arg0 uintptr) {
78		-	cbFn := *DeserializeVar
79		-	cbFn(arg0)
	73	+	if DeserializeVar != nil {
	74	+	DeserializeVarPtr := uintptr(unsafe.Pointer(DeserializeVar))
	75	+	if cbRefPtr, ok := glib.GetCallback(DeserializeVarPtr); ok {
	76	+	DeserializeVarRef = cbRefPtr
	77	+	} else {
	78	+	fcb := func(arg0 uintptr) {
	79	+	cbFn := *DeserializeVar
	80	+	cbFn(arg0)
	81	+	}
	82	+	DeserializeVarRef = purego.NewCallback(fcb)
	83	+	glib.SaveCallback(DeserializeVarPtr, DeserializeVarRef)
80	84		}
81		-	DeserializeVarRef = purego.NewCallback(fcb)
82		-	glib.SaveCallback(DeserializeVarPtr, DeserializeVarRef)
83	85		}
84	86
85		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
86	87		var NotifyVarRef uintptr
87		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
88		-	NotifyVarRef = cbRefPtr
89		-	} else {
90		-	fcb := func(arg0 uintptr) {
91		-	cbFn := *NotifyVar
92		-	cbFn(arg0)
	88	+	if NotifyVar != nil {
	89	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	90	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	91	+	NotifyVarRef = cbRefPtr
	92	+	} else {
	93	+	fcb := func(arg0 uintptr) {
	94	+	cbFn := *NotifyVar
	95	+	cbFn(arg0)
	96	+	}
	97	+	NotifyVarRef = purego.NewCallback(fcb)
	98	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
93	99		}
94		-	NotifyVarRef = purego.NewCallback(fcb)
95		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
96	100		}
97	101
98	102		xContentRegisterDeserializer(MimeTypeVar, TypeVar, DeserializeVarRef, DataVar, NotifyVarRef)

@@ -246,17 +250,19 @@ var xContentDeserializerSetTaskData func(uintptr, uintptr, uintptr)
246	250		// Associate data with the current deserialization operation.
247	251		func (x ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {
248	252
249		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
250	253		var NotifyVarRef uintptr
251		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
252		-	NotifyVarRef = cbRefPtr
253		-	} else {
254		-	fcb := func(arg0 uintptr) {
255		-	cbFn := *NotifyVar
256		-	cbFn(arg0)
	254	+	if NotifyVar != nil {
	255	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	256	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	257	+	NotifyVarRef = cbRefPtr
	258	+	} else {
	259	+	fcb := func(arg0 uintptr) {
	260	+	cbFn := *NotifyVar
	261	+	cbFn(arg0)
	262	+	}
	263	+	NotifyVarRef = purego.NewCallback(fcb)
	264	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
257	265		}
258		-	NotifyVarRef = purego.NewCallback(fcb)
259		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
260	266		}
261	267
262	268		xContentDeserializerSetTaskData(x.GoPointer(), DataVar, NotifyVarRef)

M v4/gdk/gdkcontentserializer.go +33 -27


@@ -28,30 +28,34 @@ var xContentRegisterSerializer func(types.GType, string, uintptr, uintptr, uintp
28	28		// so applications can override the built-in serializers.
29	29		func ContentRegisterSerializer(TypeVar types.GType, MimeTypeVar string, SerializeVar ContentSerializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {
30	30
31		-	SerializeVarPtr := uintptr(unsafe.Pointer(SerializeVar))
32	31		var SerializeVarRef uintptr
33		-	if cbRefPtr, ok := glib.GetCallback(SerializeVarPtr); ok {
34		-	SerializeVarRef = cbRefPtr
35		-	} else {
36		-	fcb := func(arg0 uintptr) {
37		-	cbFn := *SerializeVar
38		-	cbFn(arg0)
	32	+	if SerializeVar != nil {
	33	+	SerializeVarPtr := uintptr(unsafe.Pointer(SerializeVar))
	34	+	if cbRefPtr, ok := glib.GetCallback(SerializeVarPtr); ok {
	35	+	SerializeVarRef = cbRefPtr
	36	+	} else {
	37	+	fcb := func(arg0 uintptr) {
	38	+	cbFn := *SerializeVar
	39	+	cbFn(arg0)
	40	+	}
	41	+	SerializeVarRef = purego.NewCallback(fcb)
	42	+	glib.SaveCallback(SerializeVarPtr, SerializeVarRef)
39	43		}
40		-	SerializeVarRef = purego.NewCallback(fcb)
41		-	glib.SaveCallback(SerializeVarPtr, SerializeVarRef)
42	44		}
43	45
44		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
45	46		var NotifyVarRef uintptr
46		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
47		-	NotifyVarRef = cbRefPtr
48		-	} else {
49		-	fcb := func(arg0 uintptr) {
50		-	cbFn := *NotifyVar
51		-	cbFn(arg0)
	47	+	if NotifyVar != nil {
	48	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	49	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	50	+	NotifyVarRef = cbRefPtr
	51	+	} else {
	52	+	fcb := func(arg0 uintptr) {
	53	+	cbFn := *NotifyVar
	54	+	cbFn(arg0)
	55	+	}
	56	+	NotifyVarRef = purego.NewCallback(fcb)
	57	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
52	58		}
53		-	NotifyVarRef = purego.NewCallback(fcb)
54		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
55	59		}
56	60
57	61		xContentRegisterSerializer(TypeVar, MimeTypeVar, SerializeVarRef, DataVar, NotifyVarRef)

@@ -247,17 +251,19 @@ var xContentSerializerSetTaskData func(uintptr, uintptr, uintptr)
247	251		// Associate data with the current serialization operation.
248	252		func (x ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {
249	253
250		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
251	254		var NotifyVarRef uintptr
252		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
253		-	NotifyVarRef = cbRefPtr
254		-	} else {
255		-	fcb := func(arg0 uintptr) {
256		-	cbFn := *NotifyVar
257		-	cbFn(arg0)
	255	+	if NotifyVar != nil {
	256	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	257	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	258	+	NotifyVarRef = cbRefPtr
	259	+	} else {
	260	+	fcb := func(arg0 uintptr) {
	261	+	cbFn := *NotifyVar
	262	+	cbFn(arg0)
	263	+	}
	264	+	NotifyVarRef = purego.NewCallback(fcb)
	265	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
258	266		}
259		-	NotifyVarRef = purego.NewCallback(fcb)
260		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
261	267		}
262	268
263	269		xContentSerializerSetTaskData(x.GoPointer(), DataVar, NotifyVarRef)

M v4/gdk/gdkcursor.go +22 -18


@@ -84,30 +84,34 @@ var xNewCursorFromCallback func(uintptr, uintptr, uintptr, uintptr) uintptr
84	84		func NewCursorFromCallback(CallbackVar CursorGetTextureCallback, DataVar uintptr, DestroyVar glib.DestroyNotify, FallbackVar Cursor) Cursor {
85	85		var cls *Cursor
86	86
87		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
88	87		var CallbackVarRef uintptr
89		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
90		-	CallbackVarRef = cbRefPtr
91		-	} else {
92		-	fcb := func(arg0 uintptr, arg1 int, arg2 float64, arg3 int, arg4 int, arg5 int, arg6 int, arg7 uintptr) uintptr {
93		-	cbFn := *CallbackVar
94		-	return cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
	88	+	if CallbackVar != nil {
	89	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	90	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	91	+	CallbackVarRef = cbRefPtr
	92	+	} else {
	93	+	fcb := func(arg0 uintptr, arg1 int, arg2 float64, arg3 int, arg4 int, arg5 int, arg6 int, arg7 uintptr) uintptr {
	94	+	cbFn := *CallbackVar
	95	+	return cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
	96	+	}
	97	+	CallbackVarRef = purego.NewCallback(fcb)
	98	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
95	99		}
96		-	CallbackVarRef = purego.NewCallback(fcb)
97		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
98	100		}
99	101
100		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
101	102		var DestroyVarRef uintptr
102		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
103		-	DestroyVarRef = cbRefPtr
104		-	} else {
105		-	fcb := func(arg0 uintptr) {
106		-	cbFn := *DestroyVar
107		-	cbFn(arg0)
	103	+	if DestroyVar != nil {
	104	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	105	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	106	+	DestroyVarRef = cbRefPtr
	107	+	} else {
	108	+	fcb := func(arg0 uintptr) {
	109	+	cbFn := *DestroyVar
	110	+	cbFn(arg0)
	111	+	}
	112	+	DestroyVarRef = purego.NewCallback(fcb)
	113	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
108	114		}
109		-	DestroyVarRef = purego.NewCallback(fcb)
110		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
111	115		}
112	116
113	117		cret := xNewCursorFromCallback(CallbackVarRef, DataVar, DestroyVarRef, FallbackVar.GoPointer())

M v4/gdk/gdkgltexture.go +11 -9


@@ -47,17 +47,19 @@ var xNewGLTexture func(uintptr, uint, int, int, uintptr, uintptr) uintptr
47	47		func NewGLTexture(ContextVar GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar glib.DestroyNotify, DataVar uintptr) *GLTexture {
48	48		var cls *GLTexture
49	49
50		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
51	50		var DestroyVarRef uintptr
52		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
53		-	DestroyVarRef = cbRefPtr
54		-	} else {
55		-	fcb := func(arg0 uintptr) {
56		-	cbFn := *DestroyVar
57		-	cbFn(arg0)
	51	+	if DestroyVar != nil {
	52	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	53	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	54	+	DestroyVarRef = cbRefPtr
	55	+	} else {
	56	+	fcb := func(arg0 uintptr) {
	57	+	cbFn := *DestroyVar
	58	+	cbFn(arg0)
	59	+	}
	60	+	DestroyVarRef = purego.NewCallback(fcb)
	61	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
58	62		}
59		-	DestroyVarRef = purego.NewCallback(fcb)
60		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
61	63		}
62	64
63	65		cret := xNewGLTexture(ContextVar.GoPointer(), IdVar, WidthVar, HeightVar, DestroyVarRef, DataVar)

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


@@ -1161,17 +1161,19 @@ var xPixbufSaveToCallback func(uintptr, uintptr, uintptr, string, **glib.Error,
1161	1161		// See [method@GdkPixbuf.Pixbuf.save] for more details.
1162	1162		func (x Pixbuf) SaveToCallback(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar **glib.Error, varArgs ...interface{}) bool {
1163	1163
1164		-	SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
1165	1164		var SaveFuncVarRef uintptr
1166		-	if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
1167		-	SaveFuncVarRef = cbRefPtr
1168		-	} else {
1169		-	fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
1170		-	cbFn := *SaveFuncVar
1171		-	return cbFn(arg0, arg1, arg2, arg3)
	1165	+	if SaveFuncVar != nil {
	1166	+	SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
	1167	+	if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
	1168	+	SaveFuncVarRef = cbRefPtr
	1169	+	} else {
	1170	+	fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
	1171	+	cbFn := *SaveFuncVar
	1172	+	return cbFn(arg0, arg1, arg2, arg3)
	1173	+	}
	1174	+	SaveFuncVarRef = purego.NewCallback(fcb)
	1175	+	glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
1172	1176		}
1173		-	SaveFuncVarRef = purego.NewCallback(fcb)
1174		-	glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
1175	1177		}
1176	1178
1177	1179		cret := xPixbufSaveToCallback(x.GoPointer(), SaveFuncVarRef, UserDataVar, TypeVar, ErrorVar, varArgs...)

@@ -1191,17 +1193,19 @@ var xPixbufSaveToCallbackv func(uintptr, uintptr, uintptr, string, []string, []s
1191	1193		func (x Pixbuf) SaveToCallbackv(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {
1192	1194		var cerr *glib.Error
1193	1195
1194		-	SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
1195	1196		var SaveFuncVarRef uintptr
1196		-	if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
1197		-	SaveFuncVarRef = cbRefPtr
1198		-	} else {
1199		-	fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
1200		-	cbFn := *SaveFuncVar
1201		-	return cbFn(arg0, arg1, arg2, arg3)
	1197	+	if SaveFuncVar != nil {
	1198	+	SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
	1199	+	if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
	1200	+	SaveFuncVarRef = cbRefPtr
	1201	+	} else {
	1202	+	fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
	1203	+	cbFn := *SaveFuncVar
	1204	+	return cbFn(arg0, arg1, arg2, arg3)
	1205	+	}
	1206	+	SaveFuncVarRef = purego.NewCallback(fcb)
	1207	+	glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
1202	1208		}
1203		-	SaveFuncVarRef = purego.NewCallback(fcb)
1204		-	glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
1205	1209		}
1206	1210
1207	1211		cret := xPixbufSaveToCallbackv(x.GoPointer(), SaveFuncVarRef, UserDataVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)

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


@@ -290,17 +290,19 @@ var xCancellableConnect func(uintptr, uintptr, uintptr, uintptr) uint32
290	290		// - [method@Gio.Cancellable.release_fd]
291	291		func (x Cancellable) Connect(CallbackVar gobject.Callback, DataVar uintptr, DataDestroyFuncVar *glib.DestroyNotify) uint32 {
292	292
293		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
294	293		var CallbackVarRef uintptr
295		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
296		-	CallbackVarRef = cbRefPtr
297		-	} else {
298		-	fcb := func() {
299		-	cbFn := *CallbackVar
300		-	cbFn()
	294	+	if CallbackVar != nil {
	295	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	296	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	297	+	CallbackVarRef = cbRefPtr
	298	+	} else {
	299	+	fcb := func() {
	300	+	cbFn := *CallbackVar
	301	+	cbFn()
	302	+	}
	303	+	CallbackVarRef = purego.NewCallback(fcb)
	304	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
301	305		}
302		-	CallbackVarRef = purego.NewCallback(fcb)
303		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
304	306		}
305	307
306	308		var DataDestroyFuncVarRef uintptr

M v4/gio/gdbusconnection.go +55 -45


@@ -527,30 +527,34 @@ var xDBusConnectionAddFilter func(uintptr, uintptr, uintptr, uintptr) uint
527	527		// destroyed.)
528	528		func (x DBusConnection) AddFilter(FilterFunctionVar DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
529	529
530		-	FilterFunctionVarPtr := uintptr(unsafe.Pointer(FilterFunctionVar))
531	530		var FilterFunctionVarRef uintptr
532		-	if cbRefPtr, ok := glib.GetCallback(FilterFunctionVarPtr); ok {
533		-	FilterFunctionVarRef = cbRefPtr
534		-	} else {
535		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool, arg3 uintptr) uintptr {
536		-	cbFn := *FilterFunctionVar
537		-	return cbFn(arg0, arg1, arg2, arg3)
	531	+	if FilterFunctionVar != nil {
	532	+	FilterFunctionVarPtr := uintptr(unsafe.Pointer(FilterFunctionVar))
	533	+	if cbRefPtr, ok := glib.GetCallback(FilterFunctionVarPtr); ok {
	534	+	FilterFunctionVarRef = cbRefPtr
	535	+	} else {
	536	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool, arg3 uintptr) uintptr {
	537	+	cbFn := *FilterFunctionVar
	538	+	return cbFn(arg0, arg1, arg2, arg3)
	539	+	}
	540	+	FilterFunctionVarRef = purego.NewCallback(fcb)
	541	+	glib.SaveCallback(FilterFunctionVarPtr, FilterFunctionVarRef)
538	542		}
539		-	FilterFunctionVarRef = purego.NewCallback(fcb)
540		-	glib.SaveCallback(FilterFunctionVarPtr, FilterFunctionVarRef)
541	543		}
542	544
543		-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
544	545		var UserDataFreeFuncVarRef uintptr
545		-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
546		-	UserDataFreeFuncVarRef = cbRefPtr
547		-	} else {
548		-	fcb := func(arg0 uintptr) {
549		-	cbFn := *UserDataFreeFuncVar
550		-	cbFn(arg0)
	546	+	if UserDataFreeFuncVar != nil {
	547	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
	548	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
	549	+	UserDataFreeFuncVarRef = cbRefPtr
	550	+	} else {
	551	+	fcb := func(arg0 uintptr) {
	552	+	cbFn := *UserDataFreeFuncVar
	553	+	cbFn(arg0)
	554	+	}
	555	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
	556	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
551	557		}
552		-	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
553		-	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
554	558		}
555	559
556	560		cret := xDBusConnectionAddFilter(x.GoPointer(), FilterFunctionVarRef, UserDataVar, UserDataFreeFuncVarRef)

@@ -1164,17 +1168,19 @@ var xDBusConnectionRegisterObject func(uintptr, string, DBusInterfaceInfo, DBu
1164	1168		func (x DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar DBusInterfaceInfo, VtableVar DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) (uint, error) {
1165	1169		var cerr *glib.Error
1166	1170
1167		-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
1168	1171		var UserDataFreeFuncVarRef uintptr
1169		-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
1170		-	UserDataFreeFuncVarRef = cbRefPtr
1171		-	} else {
1172		-	fcb := func(arg0 uintptr) {
1173		-	cbFn := *UserDataFreeFuncVar
1174		-	cbFn(arg0)
	1172	+	if UserDataFreeFuncVar != nil {
	1173	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
	1174	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
	1175	+	UserDataFreeFuncVarRef = cbRefPtr
	1176	+	} else {
	1177	+	fcb := func(arg0 uintptr) {
	1178	+	cbFn := *UserDataFreeFuncVar
	1179	+	cbFn(arg0)
	1180	+	}
	1181	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
	1182	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
1175	1183		}
1176		-	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
1177		-	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
1178	1184		}
1179	1185
1180	1186		cret := xDBusConnectionRegisterObject(x.GoPointer(), ObjectPathVar, InterfaceInfoVar, VtableVar, UserDataVar, UserDataFreeFuncVarRef, &cerr)

@@ -1269,17 +1275,19 @@ var xDBusConnectionRegisterSubtree func(uintptr, string, *DBusSubtreeVTable, DBu
1269	1275		func (x DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
1270	1276		var cerr *glib.Error
1271	1277
1272		-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
1273	1278		var UserDataFreeFuncVarRef uintptr
1274		-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
1275		-	UserDataFreeFuncVarRef = cbRefPtr
1276		-	} else {
1277		-	fcb := func(arg0 uintptr) {
1278		-	cbFn := *UserDataFreeFuncVar
1279		-	cbFn(arg0)
	1279	+	if UserDataFreeFuncVar != nil {
	1280	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
	1281	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
	1282	+	UserDataFreeFuncVarRef = cbRefPtr
	1283	+	} else {
	1284	+	fcb := func(arg0 uintptr) {
	1285	+	cbFn := *UserDataFreeFuncVar
	1286	+	cbFn(arg0)
	1287	+	}
	1288	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
	1289	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
1280	1290		}
1281		-	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
1282		-	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
1283	1291		}
1284	1292
1285	1293		cret := xDBusConnectionRegisterSubtree(x.GoPointer(), ObjectPathVar, VtableVar, FlagsVar, UserDataVar, UserDataFreeFuncVarRef, &cerr)

@@ -1547,17 +1555,19 @@ var xDBusConnectionSignalSubscribe func(uintptr, string, string, string, string,
1547	1555		// This function can never fail.
1548	1556		func (x DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
1549	1557
1550		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1551	1558		var CallbackVarRef uintptr
1552		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1553		-	CallbackVarRef = cbRefPtr
1554		-	} else {
1555		-	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 string, arg4 string, arg5 *glib.Variant, arg6 uintptr) {
1556		-	cbFn := *CallbackVar
1557		-	cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	1559	+	if CallbackVar != nil {
	1560	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	1561	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	1562	+	CallbackVarRef = cbRefPtr
	1563	+	} else {
	1564	+	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 string, arg4 string, arg5 *glib.Variant, arg6 uintptr) {
	1565	+	cbFn := *CallbackVar
	1566	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	1567	+	}
	1568	+	CallbackVarRef = purego.NewCallback(fcb)
	1569	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1558	1570		}
1559		-	CallbackVarRef = purego.NewCallback(fcb)
1560		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1561	1571		}
1562	1572
1563	1573		var UserDataFreeFuncVarRef uintptr

M v4/gio/gioscheduler.go +11 -9


@@ -33,17 +33,19 @@ var xIoSchedulerPushJob func(uintptr, uintptr, uintptr, int, uintptr)
33	33		// g_io_scheduler_cancel_all_jobs().
34	34		func IoSchedulerPushJob(JobFuncVar IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {
35	35
36		-	JobFuncVarPtr := uintptr(unsafe.Pointer(JobFuncVar))
37	36		var JobFuncVarRef uintptr
38		-	if cbRefPtr, ok := glib.GetCallback(JobFuncVarPtr); ok {
39		-	JobFuncVarRef = cbRefPtr
40		-	} else {
41		-	fcb := func(arg0 *IOSchedulerJob, arg1 uintptr, arg2 uintptr) bool {
42		-	cbFn := *JobFuncVar
43		-	return cbFn(arg0, arg1, arg2)
	37	+	if JobFuncVar != nil {
	38	+	JobFuncVarPtr := uintptr(unsafe.Pointer(JobFuncVar))
	39	+	if cbRefPtr, ok := glib.GetCallback(JobFuncVarPtr); ok {
	40	+	JobFuncVarRef = cbRefPtr
	41	+	} else {
	42	+	fcb := func(arg0 *IOSchedulerJob, arg1 uintptr, arg2 uintptr) bool {
	43	+	cbFn := *JobFuncVar
	44	+	return cbFn(arg0, arg1, arg2)
	45	+	}
	46	+	JobFuncVarRef = purego.NewCallback(fcb)
	47	+	glib.SaveCallback(JobFuncVarPtr, JobFuncVarRef)
44	48		}
45		-	JobFuncVarRef = purego.NewCallback(fcb)
46		-	glib.SaveCallback(JobFuncVarPtr, JobFuncVarRef)
47	49		}
48	50
49	51		var NotifyVarRef uintptr

M v4/gio/giotypes.go +22 -18


@@ -400,17 +400,19 @@ var xIOSchedulerJobSendToMainloop func(uintptr, uintptr, uintptr, uintptr) bool
400	400		// blocking the I/O job).
401	401		func (x IOSchedulerJob) SendToMainloop(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) bool {
402	402
403		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
404	403		var FuncVarRef uintptr
405		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
406		-	FuncVarRef = cbRefPtr
407		-	} else {
408		-	fcb := func(arg0 uintptr) bool {
409		-	cbFn := *FuncVar
410		-	return cbFn(arg0)
	404	+	if FuncVar != nil {
	405	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	406	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	407	+	FuncVarRef = cbRefPtr
	408	+	} else {
	409	+	fcb := func(arg0 uintptr) bool {
	410	+	cbFn := *FuncVar
	411	+	return cbFn(arg0)
	412	+	}
	413	+	FuncVarRef = purego.NewCallback(fcb)
	414	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
411	415		}
412		-	FuncVarRef = purego.NewCallback(fcb)
413		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
414	416		}
415	417
416	418		var NotifyVarRef uintptr

@@ -445,17 +447,19 @@ var xIOSchedulerJobSendToMainloopAsync func(uintptr, uintptr, uintptr, uintptr)
445	447		// g_io_scheduler_push_job() or by using refcounting for @user_data.
446	448		func (x IOSchedulerJob) SendToMainloopAsync(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) {
447	449
448		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
449	450		var FuncVarRef uintptr
450		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
451		-	FuncVarRef = cbRefPtr
452		-	} else {
453		-	fcb := func(arg0 uintptr) bool {
454		-	cbFn := *FuncVar
455		-	return cbFn(arg0)
	451	+	if FuncVar != nil {
	452	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	453	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	454	+	FuncVarRef = cbRefPtr
	455	+	} else {
	456	+	fcb := func(arg0 uintptr) bool {
	457	+	cbFn := *FuncVar
	458	+	return cbFn(arg0)
	459	+	}
	460	+	FuncVarRef = purego.NewCallback(fcb)
	461	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
456	462		}
457		-	FuncVarRef = purego.NewCallback(fcb)
458		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
459	463		}
460	464
461	465		var NotifyVarRef uintptr

M v4/gio/gliststore.go +44 -36


@@ -100,17 +100,19 @@ var xListStoreFindWithEqualFunc func(uintptr, uintptr, uintptr, *uint) bool
100	100		// Since GLib 2.76 it is possible to pass `NULL` for @item.
101	101		func (x ListStore) FindWithEqualFunc(ItemVar gobject.Object, EqualFuncVar glib.EqualFunc, PositionVar uint) bool {
102	102
103		-	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
104	103		var EqualFuncVarRef uintptr
105		-	if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
106		-	EqualFuncVarRef = cbRefPtr
107		-	} else {
108		-	fcb := func(arg0 uintptr, arg1 uintptr) bool {
109		-	cbFn := *EqualFuncVar
110		-	return cbFn(arg0, arg1)
	104	+	if EqualFuncVar != nil {
	105	+	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
	106	+	if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
	107	+	EqualFuncVarRef = cbRefPtr
	108	+	} else {
	109	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
	110	+	cbFn := *EqualFuncVar
	111	+	return cbFn(arg0, arg1)
	112	+	}
	113	+	EqualFuncVarRef = purego.NewCallback(fcb)
	114	+	glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
111	115		}
112		-	EqualFuncVarRef = purego.NewCallback(fcb)
113		-	glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
114	116		}
115	117
116	118		cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), EqualFuncVarRef, PositionVar)

@@ -127,17 +129,19 @@ var xListStoreFindWithEqualFuncFull func(uintptr, uintptr, uintptr, uintptr, *ui
127	129		// Since GLib 2.76 it is possible to pass `NULL` for @item.
128	130		func (x ListStore) FindWithEqualFuncFull(ItemVar gobject.Object, EqualFuncVar glib.EqualFuncFull, UserDataVar uintptr, PositionVar uint) bool {
129	131
130		-	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
131	132		var EqualFuncVarRef uintptr
132		-	if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
133		-	EqualFuncVarRef = cbRefPtr
134		-	} else {
135		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
136		-	cbFn := *EqualFuncVar
137		-	return cbFn(arg0, arg1, arg2)
	133	+	if EqualFuncVar != nil {
	134	+	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
	135	+	if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
	136	+	EqualFuncVarRef = cbRefPtr
	137	+	} else {
	138	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
	139	+	cbFn := *EqualFuncVar
	140	+	return cbFn(arg0, arg1, arg2)
	141	+	}
	142	+	EqualFuncVarRef = purego.NewCallback(fcb)
	143	+	glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
138	144		}
139		-	EqualFuncVarRef = purego.NewCallback(fcb)
140		-	glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
141	145		}
142	146
143	147		cret := xListStoreFindWithEqualFuncFull(x.GoPointer(), ItemVar.GoPointer(), EqualFuncVarRef, UserDataVar, PositionVar)

@@ -172,17 +176,19 @@ var xListStoreInsertSorted func(uintptr, uintptr, uintptr, uintptr) uint
172	176		// This function takes a ref on @item.
173	177		func (x ListStore) InsertSorted(ItemVar gobject.Object, CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) uint {
174	178
175		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
176	179		var CompareFuncVarRef uintptr
177		-	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
178		-	CompareFuncVarRef = cbRefPtr
179		-	} else {
180		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
181		-	cbFn := *CompareFuncVar
182		-	return cbFn(arg0, arg1, arg2)
	180	+	if CompareFuncVar != nil {
	181	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	182	+	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
	183	+	CompareFuncVarRef = cbRefPtr
	184	+	} else {
	185	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	186	+	cbFn := *CompareFuncVar
	187	+	return cbFn(arg0, arg1, arg2)
	188	+	}
	189	+	CompareFuncVarRef = purego.NewCallback(fcb)
	190	+	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
183	191		}
184		-	CompareFuncVarRef = purego.NewCallback(fcb)
185		-	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
186	192		}
187	193
188	194		cret := xListStoreInsertSorted(x.GoPointer(), ItemVar.GoPointer(), CompareFuncVarRef, UserDataVar)

@@ -216,17 +222,19 @@ var xListStoreSort func(uintptr, uintptr, uintptr)
216	222		// Sort the items in @store according to @compare_func.
217	223		func (x ListStore) Sort(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) {
218	224
219		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
220	225		var CompareFuncVarRef uintptr
221		-	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
222		-	CompareFuncVarRef = cbRefPtr
223		-	} else {
224		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
225		-	cbFn := *CompareFuncVar
226		-	return cbFn(arg0, arg1, arg2)
	226	+	if CompareFuncVar != nil {
	227	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	228	+	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
	229	+	CompareFuncVarRef = cbRefPtr
	230	+	} else {
	231	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	232	+	cbFn := *CompareFuncVar
	233	+	return cbFn(arg0, arg1, arg2)
	234	+	}
	235	+	CompareFuncVarRef = purego.NewCallback(fcb)
	236	+	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
227	237		}
228		-	CompareFuncVarRef = purego.NewCallback(fcb)
229		-	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
230	238		}
231	239
232	240		xListStoreSort(x.GoPointer(), CompareFuncVarRef, UserDataVar)

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


@@ -823,17 +823,19 @@ func (x Settings) BindWithMapping(KeyVar string, ObjectVar gobject.Object, Pro
823	823		}
824	824		}
825	825
826		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
827	826		var DestroyVarRef uintptr
828		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
829		-	DestroyVarRef = cbRefPtr
830		-	} else {
831		-	fcb := func(arg0 uintptr) {
832		-	cbFn := *DestroyVar
833		-	cbFn(arg0)
	827	+	if DestroyVar != nil {
	828	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	829	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	830	+	DestroyVarRef = cbRefPtr
	831	+	} else {
	832	+	fcb := func(arg0 uintptr) {
	833	+	cbFn := *DestroyVar
	834	+	cbFn(arg0)
	835	+	}
	836	+	DestroyVarRef = purego.NewCallback(fcb)
	837	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
834	838		}
835		-	DestroyVarRef = purego.NewCallback(fcb)
836		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
837	839		}
838	840
839	841		xSettingsBindWithMapping(x.GoPointer(), KeyVar, ObjectVar.GoPointer(), PropertyVar, FlagsVar, GetMappingVarRef, SetMappingVarRef, UserDataVar, DestroyVarRef)

@@ -1128,17 +1130,19 @@ var xSettingsGetMapped func(uintptr, string, uintptr, uintptr) uintptr
1128	1130		// just as any other value would be.
1129	1131		func (x Settings) GetMapped(KeyVar string, MappingVar SettingsGetMapping, UserDataVar uintptr) uintptr {
1130	1132
1131		-	MappingVarPtr := uintptr(unsafe.Pointer(MappingVar))
1132	1133		var MappingVarRef uintptr
1133		-	if cbRefPtr, ok := glib.GetCallback(MappingVarPtr); ok {
1134		-	MappingVarRef = cbRefPtr
1135		-	} else {
1136		-	fcb := func(arg0 glib.Variant, arg1 uintptr, arg2 uintptr) bool {
1137		-	cbFn := *MappingVar
1138		-	return cbFn(arg0, arg1, arg2)
	1134	+	if MappingVar != nil {
	1135	+	MappingVarPtr := uintptr(unsafe.Pointer(MappingVar))
	1136	+	if cbRefPtr, ok := glib.GetCallback(MappingVarPtr); ok {
	1137	+	MappingVarRef = cbRefPtr
	1138	+	} else {
	1139	+	fcb := func(arg0 glib.Variant, arg1 uintptr, arg2 uintptr) bool {
	1140	+	cbFn := *MappingVar
	1141	+	return cbFn(arg0, arg1, arg2)
	1142	+	}
	1143	+	MappingVarRef = purego.NewCallback(fcb)
	1144	+	glib.SaveCallback(MappingVarPtr, MappingVarRef)
1139	1145		}
1140		-	MappingVarRef = purego.NewCallback(fcb)
1141		-	glib.SaveCallback(MappingVarPtr, MappingVarRef)
1142	1146		}
1143	1147
1144	1148		cret := xSettingsGetMapped(x.GoPointer(), KeyVar, MappingVarRef, UserDataVar)

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


@@ -516,17 +516,19 @@ var xSimpleAsyncResultRunInThread func(uintptr, uintptr, int, uintptr)
516	516		// is needed to run the job and report its completion.
517	517		func (x SimpleAsyncResult) RunInThread(FuncVar SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar *Cancellable) {
518	518
519		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
520	519		var FuncVarRef uintptr
521		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
522		-	FuncVarRef = cbRefPtr
523		-	} else {
524		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
525		-	cbFn := *FuncVar
526		-	cbFn(arg0, arg1, arg2)
	520	+	if FuncVar != nil {
	521	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	522	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	523	+	FuncVarRef = cbRefPtr
	524	+	} else {
	525	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
	526	+	cbFn := *FuncVar
	527	+	cbFn(arg0, arg1, arg2)
	528	+	}
	529	+	FuncVarRef = purego.NewCallback(fcb)
	530	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
527	531		}
528		-	FuncVarRef = purego.NewCallback(fcb)
529		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
530	532		}
531	533
532	534		xSimpleAsyncResultRunInThread(x.GoPointer(), FuncVarRef, IoPriorityVar, CancellableVar.GoPointer())

@@ -611,17 +613,19 @@ var xSimpleAsyncResultSetOpResGpointer func(uintptr, uintptr, uintptr)
611	613		// Sets the operation result within the asynchronous result to a pointer.
612	614		func (x SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar glib.DestroyNotify) {
613	615
614		-	DestroyOpResVarPtr := uintptr(unsafe.Pointer(DestroyOpResVar))
615	616		var DestroyOpResVarRef uintptr
616		-	if cbRefPtr, ok := glib.GetCallback(DestroyOpResVarPtr); ok {
617		-	DestroyOpResVarRef = cbRefPtr
618		-	} else {
619		-	fcb := func(arg0 uintptr) {
620		-	cbFn := *DestroyOpResVar
621		-	cbFn(arg0)
	617	+	if DestroyOpResVar != nil {
	618	+	DestroyOpResVarPtr := uintptr(unsafe.Pointer(DestroyOpResVar))
	619	+	if cbRefPtr, ok := glib.GetCallback(DestroyOpResVarPtr); ok {
	620	+	DestroyOpResVarRef = cbRefPtr
	621	+	} else {
	622	+	fcb := func(arg0 uintptr) {
	623	+	cbFn := *DestroyOpResVar
	624	+	cbFn(arg0)
	625	+	}
	626	+	DestroyOpResVarRef = purego.NewCallback(fcb)
	627	+	glib.SaveCallback(DestroyOpResVarPtr, DestroyOpResVarRef)
622	628		}
623		-	DestroyOpResVarRef = purego.NewCallback(fcb)
624		-	glib.SaveCallback(DestroyOpResVarPtr, DestroyOpResVarRef)
625	629		}
626	630
627	631		xSimpleAsyncResultSetOpResGpointer(x.GoPointer(), OpResVar, DestroyOpResVarRef)

M v4/gio/gsubprocesslauncher.go +22 -18


@@ -103,30 +103,34 @@ var xSubprocessLauncherSetChildSetup func(uintptr, uintptr, uintptr, uintptr)
103	103		// Child setup functions are only available on UNIX.
104	104		func (x SubprocessLauncher) SetChildSetup(ChildSetupVar glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
105	105
106		-	ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
107	106		var ChildSetupVarRef uintptr
108		-	if cbRefPtr, ok := glib.GetCallback(ChildSetupVarPtr); ok {
109		-	ChildSetupVarRef = cbRefPtr
110		-	} else {
111		-	fcb := func(arg0 uintptr) {
112		-	cbFn := *ChildSetupVar
113		-	cbFn(arg0)
	107	+	if ChildSetupVar != nil {
	108	+	ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
	109	+	if cbRefPtr, ok := glib.GetCallback(ChildSetupVarPtr); ok {
	110	+	ChildSetupVarRef = cbRefPtr
	111	+	} else {
	112	+	fcb := func(arg0 uintptr) {
	113	+	cbFn := *ChildSetupVar
	114	+	cbFn(arg0)
	115	+	}
	116	+	ChildSetupVarRef = purego.NewCallback(fcb)
	117	+	glib.SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
114	118		}
115		-	ChildSetupVarRef = purego.NewCallback(fcb)
116		-	glib.SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
117	119		}
118	120
119		-	DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
120	121		var DestroyNotifyVarRef uintptr
121		-	if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
122		-	DestroyNotifyVarRef = cbRefPtr
123		-	} else {
124		-	fcb := func(arg0 uintptr) {
125		-	cbFn := *DestroyNotifyVar
126		-	cbFn(arg0)
	122	+	if DestroyNotifyVar != nil {
	123	+	DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
	124	+	if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
	125	+	DestroyNotifyVarRef = cbRefPtr
	126	+	} else {
	127	+	fcb := func(arg0 uintptr) {
	128	+	cbFn := *DestroyNotifyVar
	129	+	cbFn(arg0)
	130	+	}
	131	+	DestroyNotifyVarRef = purego.NewCallback(fcb)
	132	+	glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
127	133		}
128		-	DestroyNotifyVarRef = purego.NewCallback(fcb)
129		-	glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
130	134		}
131	135
132	136		xSubprocessLauncherSetChildSetup(x.GoPointer(), ChildSetupVarRef, UserDataVar, DestroyNotifyVarRef)

M v4/gio/gtask.go +33 -27


@@ -673,17 +673,19 @@ var xTaskAttachSource func(uintptr, *glib.Source, uintptr)
673	673		// This takes a reference on @task until @source is destroyed.
674	674		func (x Task) AttachSource(SourceVar glib.Source, CallbackVar *glib.SourceFunc) {
675	675
676		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
677	676		var CallbackVarRef uintptr
678		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
679		-	CallbackVarRef = cbRefPtr
680		-	} else {
681		-	fcb := func(arg0 uintptr) bool {
682		-	cbFn := *CallbackVar
683		-	return cbFn(arg0)
	677	+	if CallbackVar != nil {
	678	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	679	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	680	+	CallbackVarRef = cbRefPtr
	681	+	} else {
	682	+	fcb := func(arg0 uintptr) bool {
	683	+	cbFn := *CallbackVar
	684	+	return cbFn(arg0)
	685	+	}
	686	+	CallbackVarRef = purego.NewCallback(fcb)
	687	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
684	688		}
685		-	CallbackVarRef = purego.NewCallback(fcb)
686		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
687	689		}
688	690
689	691		xTaskAttachSource(x.GoPointer(), SourceVar, CallbackVarRef)

@@ -1083,17 +1085,19 @@ var xTaskRunInThread func(uintptr, uintptr)
1083	1085		// g_task_run_in_thread().
1084	1086		func (x Task) RunInThread(TaskFuncVar TaskThreadFunc) {
1085	1087
1086		-	TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
1087	1088		var TaskFuncVarRef uintptr
1088		-	if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
1089		-	TaskFuncVarRef = cbRefPtr
1090		-	} else {
1091		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
1092		-	cbFn := *TaskFuncVar
1093		-	cbFn(arg0, arg1, arg2, arg3)
	1089	+	if TaskFuncVar != nil {
	1090	+	TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
	1091	+	if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
	1092	+	TaskFuncVarRef = cbRefPtr
	1093	+	} else {
	1094	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
	1095	+	cbFn := *TaskFuncVar
	1096	+	cbFn(arg0, arg1, arg2, arg3)
	1097	+	}
	1098	+	TaskFuncVarRef = purego.NewCallback(fcb)
	1099	+	glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
1094	1100		}
1095		-	TaskFuncVarRef = purego.NewCallback(fcb)
1096		-	glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
1097	1101		}
1098	1102
1099	1103		xTaskRunInThread(x.GoPointer(), TaskFuncVarRef)

@@ -1120,17 +1124,19 @@ var xTaskRunInThreadSync func(uintptr, uintptr)
1120	1124		// limited number of them at a time.
1121	1125		func (x Task) RunInThreadSync(TaskFuncVar TaskThreadFunc) {
1122	1126
1123		-	TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
1124	1127		var TaskFuncVarRef uintptr
1125		-	if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
1126		-	TaskFuncVarRef = cbRefPtr
1127		-	} else {
1128		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
1129		-	cbFn := *TaskFuncVar
1130		-	cbFn(arg0, arg1, arg2, arg3)
	1128	+	if TaskFuncVar != nil {
	1129	+	TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
	1130	+	if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
	1131	+	TaskFuncVarRef = cbRefPtr
	1132	+	} else {
	1133	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
	1134	+	cbFn := *TaskFuncVar
	1135	+	cbFn(arg0, arg1, arg2, arg3)
	1136	+	}
	1137	+	TaskFuncVarRef = purego.NewCallback(fcb)
	1138	+	glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
1131	1139		}
1132		-	TaskFuncVarRef = purego.NewCallback(fcb)
1133		-	glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
1134	1140		}
1135	1141
1136	1142		xTaskRunInThreadSync(x.GoPointer(), TaskFuncVarRef)

M v4/glib/garray.go +33 -27


@@ -147,17 +147,19 @@ var xNewBytesWithFreeFunc func([]byte, uint, uintptr, uintptr) *Bytes
147	147		// @data may be `NULL` if @size is 0.
148	148		func NewBytesWithFreeFunc(DataVar []byte, SizeVar uint, FreeFuncVar DestroyNotify, UserDataVar uintptr) Bytes {
149	149
150		-	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
151	150		var FreeFuncVarRef uintptr
152		-	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
153		-	FreeFuncVarRef = cbRefPtr
154		-	} else {
155		-	fcb := func(arg0 uintptr) {
156		-	cbFn := *FreeFuncVar
157		-	cbFn(arg0)
	151	+	if FreeFuncVar != nil {
	152	+	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
	153	+	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
	154	+	FreeFuncVarRef = cbRefPtr
	155	+	} else {
	156	+	fcb := func(arg0 uintptr) {
	157	+	cbFn := *FreeFuncVar
	158	+	cbFn(arg0)
	159	+	}
	160	+	FreeFuncVarRef = purego.NewCallback(fcb)
	161	+	SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
158	162		}
159		-	FreeFuncVarRef = purego.NewCallback(fcb)
160		-	SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
161	163		}
162	164
163	165		cret := xNewBytesWithFreeFunc(DataVar, SizeVar, FreeFuncVarRef, UserDataVar)

@@ -566,17 +568,19 @@ var xByteArraySort func([]byte, uintptr)
566	568		// their addresses.
567	569		func ByteArraySort(ArrayVar []byte, CompareFuncVar *CompareFunc) {
568	570
569		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
570	571		var CompareFuncVarRef uintptr
571		-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
572		-	CompareFuncVarRef = cbRefPtr
573		-	} else {
574		-	fcb := func(arg0 uintptr, arg1 uintptr) int {
575		-	cbFn := *CompareFuncVar
576		-	return cbFn(arg0, arg1)
	572	+	if CompareFuncVar != nil {
	573	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	574	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
	575	+	CompareFuncVarRef = cbRefPtr
	576	+	} else {
	577	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
	578	+	cbFn := *CompareFuncVar
	579	+	return cbFn(arg0, arg1)
	580	+	}
	581	+	CompareFuncVarRef = purego.NewCallback(fcb)
	582	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
577	583		}
578		-	CompareFuncVarRef = purego.NewCallback(fcb)
579		-	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
580	584		}
581	585
582	586		xByteArraySort(ArrayVar, CompareFuncVarRef)

@@ -589,17 +593,19 @@ var xByteArraySortWithData func([]byte, uintptr, uintptr)
589	593		// user data argument.
590	594		func ByteArraySortWithData(ArrayVar []byte, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
591	595
592		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
593	596		var CompareFuncVarRef uintptr
594		-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
595		-	CompareFuncVarRef = cbRefPtr
596		-	} else {
597		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
598		-	cbFn := *CompareFuncVar
599		-	return cbFn(arg0, arg1, arg2)
	597	+	if CompareFuncVar != nil {
	598	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	599	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
	600	+	CompareFuncVarRef = cbRefPtr
	601	+	} else {
	602	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	603	+	cbFn := *CompareFuncVar
	604	+	return cbFn(arg0, arg1, arg2)
	605	+	}
	606	+	CompareFuncVarRef = purego.NewCallback(fcb)
	607	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
600	608		}
601		-	CompareFuncVarRef = purego.NewCallback(fcb)
602		-	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
603	609		}
604	610
605	611		xByteArraySortWithData(ArrayVar, CompareFuncVarRef, UserDataVar)

M v4/glib/gasyncqueue.go +44 -36


@@ -144,17 +144,19 @@ var xAsyncQueuePushSorted func(uintptr, uintptr, uintptr, uintptr)
144	144		// For an example of @func see g_async_queue_sort().
145	145		func (x AsyncQueue) PushSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
146	146
147		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
148	147		var FuncVarRef uintptr
149		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
150		-	FuncVarRef = cbRefPtr
151		-	} else {
152		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
153		-	cbFn := *FuncVar
154		-	return cbFn(arg0, arg1, arg2)
	148	+	if FuncVar != nil {
	149	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	150	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	151	+	FuncVarRef = cbRefPtr
	152	+	} else {
	153	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	154	+	cbFn := *FuncVar
	155	+	return cbFn(arg0, arg1, arg2)
	156	+	}
	157	+	FuncVarRef = purego.NewCallback(fcb)
	158	+	SaveCallback(FuncVarPtr, FuncVarRef)
155	159		}
156		-	FuncVarRef = purego.NewCallback(fcb)
157		-	SaveCallback(FuncVarPtr, FuncVarRef)
158	160		}
159	161
160	162		xAsyncQueuePushSorted(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)

@@ -180,17 +182,19 @@ var xAsyncQueuePushSortedUnlocked func(uintptr, uintptr, uintptr, uintptr)
180	182		// For an example of @func see g_async_queue_sort().
181	183		func (x AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
182	184
183		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
184	185		var FuncVarRef uintptr
185		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
186		-	FuncVarRef = cbRefPtr
187		-	} else {
188		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
189		-	cbFn := *FuncVar
190		-	return cbFn(arg0, arg1, arg2)
	186	+	if FuncVar != nil {
	187	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	188	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	189	+	FuncVarRef = cbRefPtr
	190	+	} else {
	191	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	192	+	cbFn := *FuncVar
	193	+	return cbFn(arg0, arg1, arg2)
	194	+	}
	195	+	FuncVarRef = purego.NewCallback(fcb)
	196	+	SaveCallback(FuncVarPtr, FuncVarRef)
191	197		}
192		-	FuncVarRef = purego.NewCallback(fcb)
193		-	SaveCallback(FuncVarPtr, FuncVarRef)
194	198		}
195	199
196	200		xAsyncQueuePushSortedUnlocked(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)

@@ -277,17 +281,19 @@ var xAsyncQueueSort func(uintptr, uintptr, uintptr)
277	281		// ]\|
278	282		func (x AsyncQueue) Sort(FuncVar CompareDataFunc, UserDataVar uintptr) {
279	283
280		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
281	284		var FuncVarRef uintptr
282		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
283		-	FuncVarRef = cbRefPtr
284		-	} else {
285		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
286		-	cbFn := *FuncVar
287		-	return cbFn(arg0, arg1, arg2)
	285	+	if FuncVar != nil {
	286	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	287	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	288	+	FuncVarRef = cbRefPtr
	289	+	} else {
	290	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	291	+	cbFn := *FuncVar
	292	+	return cbFn(arg0, arg1, arg2)
	293	+	}
	294	+	FuncVarRef = purego.NewCallback(fcb)
	295	+	SaveCallback(FuncVarPtr, FuncVarRef)
288	296		}
289		-	FuncVarRef = purego.NewCallback(fcb)
290		-	SaveCallback(FuncVarPtr, FuncVarRef)
291	297		}
292	298
293	299		xAsyncQueueSort(x.GoPointer(), FuncVarRef, UserDataVar)

@@ -307,17 +313,19 @@ var xAsyncQueueSortUnlocked func(uintptr, uintptr, uintptr)
307	313		// This function must be called while holding the @queue's lock.
308	314		func (x AsyncQueue) SortUnlocked(FuncVar CompareDataFunc, UserDataVar uintptr) {
309	315
310		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
311	316		var FuncVarRef uintptr
312		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
313		-	FuncVarRef = cbRefPtr
314		-	} else {
315		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
316		-	cbFn := *FuncVar
317		-	return cbFn(arg0, arg1, arg2)
	317	+	if FuncVar != nil {
	318	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	319	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	320	+	FuncVarRef = cbRefPtr
	321	+	} else {
	322	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	323	+	cbFn := *FuncVar
	324	+	return cbFn(arg0, arg1, arg2)
	325	+	}
	326	+	FuncVarRef = purego.NewCallback(fcb)
	327	+	SaveCallback(FuncVarPtr, FuncVarRef)
318	328		}
319		-	FuncVarRef = purego.NewCallback(fcb)
320		-	SaveCallback(FuncVarPtr, FuncVarRef)
321	329		}
322	330
323	331		xAsyncQueueSortUnlocked(x.GoPointer(), FuncVarRef, UserDataVar)

M v4/glib/gcache.go +22 -18


@@ -80,17 +80,19 @@ var xCacheKeyForeach func(uintptr, uintptr, uintptr)
80	80		// pairs to its callback function !
81	81		func (x Cache) KeyForeach(FuncVar HFunc, UserDataVar uintptr) {
82	82
83		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
84	83		var FuncVarRef uintptr
85		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
86		-	FuncVarRef = cbRefPtr
87		-	} else {
88		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
89		-	cbFn := *FuncVar
90		-	cbFn(arg0, arg1, arg2)
	84	+	if FuncVar != nil {
	85	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	86	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	87	+	FuncVarRef = cbRefPtr
	88	+	} else {
	89	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
	90	+	cbFn := *FuncVar
	91	+	cbFn(arg0, arg1, arg2)
	92	+	}
	93	+	FuncVarRef = purego.NewCallback(fcb)
	94	+	SaveCallback(FuncVarPtr, FuncVarRef)
91	95		}
92		-	FuncVarRef = purego.NewCallback(fcb)
93		-	SaveCallback(FuncVarPtr, FuncVarRef)
94	96		}
95	97
96	98		xCacheKeyForeach(x.GoPointer(), FuncVarRef, UserDataVar)

@@ -113,17 +115,19 @@ var xCacheValueForeach func(uintptr, uintptr, uintptr)
113	115		// Calls the given function for each of the values in the #GCache.
114	116		func (x Cache) ValueForeach(FuncVar HFunc, UserDataVar uintptr) {
115	117
116		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
117	118		var FuncVarRef uintptr
118		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
119		-	FuncVarRef = cbRefPtr
120		-	} else {
121		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
122		-	cbFn := *FuncVar
123		-	cbFn(arg0, arg1, arg2)
	119	+	if FuncVar != nil {
	120	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	121	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	122	+	FuncVarRef = cbRefPtr
	123	+	} else {
	124	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
	125	+	cbFn := *FuncVar
	126	+	cbFn(arg0, arg1, arg2)
	127	+	}
	128	+	FuncVarRef = purego.NewCallback(fcb)
	129	+	SaveCallback(FuncVarPtr, FuncVarRef)
124	130		}
125		-	FuncVarRef = purego.NewCallback(fcb)
126		-	SaveCallback(FuncVarPtr, FuncVarRef)
127	131		}
128	132
129	133		xCacheValueForeach(x.GoPointer(), FuncVarRef, UserDataVar)

M v4/glib/gcompletion.go +11 -9


@@ -131,17 +131,19 @@ var xCompletionSetCompare func(uintptr, uintptr)
131	131		// comparison function is strncmp().
132	132		func (x Completion) SetCompare(StrncmpFuncVar CompletionStrncmpFunc) {
133	133
134		-	StrncmpFuncVarPtr := uintptr(unsafe.Pointer(StrncmpFuncVar))
135	134		var StrncmpFuncVarRef uintptr
136		-	if cbRefPtr, ok := GetCallback(StrncmpFuncVarPtr); ok {
137		-	StrncmpFuncVarRef = cbRefPtr
138		-	} else {
139		-	fcb := func(arg0 string, arg1 string, arg2 uint) int {
140		-	cbFn := *StrncmpFuncVar
141		-	return cbFn(arg0, arg1, arg2)
	135	+	if StrncmpFuncVar != nil {
	136	+	StrncmpFuncVarPtr := uintptr(unsafe.Pointer(StrncmpFuncVar))
	137	+	if cbRefPtr, ok := GetCallback(StrncmpFuncVarPtr); ok {
	138	+	StrncmpFuncVarRef = cbRefPtr
	139	+	} else {
	140	+	fcb := func(arg0 string, arg1 string, arg2 uint) int {
	141	+	cbFn := *StrncmpFuncVar
	142	+	return cbFn(arg0, arg1, arg2)
	143	+	}
	144	+	StrncmpFuncVarRef = purego.NewCallback(fcb)
	145	+	SaveCallback(StrncmpFuncVarPtr, StrncmpFuncVarRef)
142	146		}
143		-	StrncmpFuncVarRef = purego.NewCallback(fcb)
144		-	SaveCallback(StrncmpFuncVarPtr, StrncmpFuncVarRef)
145	147		}
146	148
147	149		xCompletionSetCompare(x.GoPointer(), StrncmpFuncVarRef)

M v4/glib/gdataset.go +33 -27


@@ -63,17 +63,19 @@ var xDatalistForeach func(**Data, uintptr, uintptr)
63	63		// than skipping over elements that are removed.
64	64		func DatalistForeach(DatalistVar *Data, FuncVar DataForeachFunc, UserDataVar uintptr) {
65	65
66		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
67	66		var FuncVarRef uintptr
68		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
69		-	FuncVarRef = cbRefPtr
70		-	} else {
71		-	fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
72		-	cbFn := *FuncVar
73		-	cbFn(arg0, arg1, arg2)
	67	+	if FuncVar != nil {
	68	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	69	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	70	+	FuncVarRef = cbRefPtr
	71	+	} else {
	72	+	fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
	73	+	cbFn := *FuncVar
	74	+	cbFn(arg0, arg1, arg2)
	75	+	}
	76	+	FuncVarRef = purego.NewCallback(fcb)
	77	+	SaveCallback(FuncVarPtr, FuncVarRef)
74	78		}
75		-	FuncVarRef = purego.NewCallback(fcb)
76		-	SaveCallback(FuncVarPtr, FuncVarRef)
77	79		}
78	80
79	81		xDatalistForeach(DatalistVar, FuncVarRef, UserDataVar)

@@ -288,17 +290,19 @@ var xDatasetForeach func(uintptr, uintptr, uintptr)
288	290		// than skipping over elements that are removed.
289	291		func DatasetForeach(DatasetLocationVar uintptr, FuncVar *DataForeachFunc, UserDataVar uintptr) {
290	292
291		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
292	293		var FuncVarRef uintptr
293		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
294		-	FuncVarRef = cbRefPtr
295		-	} else {
296		-	fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
297		-	cbFn := *FuncVar
298		-	cbFn(arg0, arg1, arg2)
	294	+	if FuncVar != nil {
	295	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	296	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	297	+	FuncVarRef = cbRefPtr
	298	+	} else {
	299	+	fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
	300	+	cbFn := *FuncVar
	301	+	cbFn(arg0, arg1, arg2)
	302	+	}
	303	+	FuncVarRef = purego.NewCallback(fcb)
	304	+	SaveCallback(FuncVarPtr, FuncVarRef)
299	305		}
300		-	FuncVarRef = purego.NewCallback(fcb)
301		-	SaveCallback(FuncVarPtr, FuncVarRef)
302	306		}
303	307
304	308		xDatasetForeach(DatasetLocationVar, FuncVarRef, UserDataVar)

@@ -332,17 +336,19 @@ var xDatasetIdSetDataFull func(uintptr, Quark, uintptr, uintptr)
332	336		// is called.
333	337		func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {
334	338
335		-	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
336	339		var DestroyFuncVarRef uintptr
337		-	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
338		-	DestroyFuncVarRef = cbRefPtr
339		-	} else {
340		-	fcb := func(arg0 uintptr) {
341		-	cbFn := *DestroyFuncVar
342		-	cbFn(arg0)
	340	+	if DestroyFuncVar != nil {
	341	+	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
	342	+	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
	343	+	DestroyFuncVarRef = cbRefPtr
	344	+	} else {
	345	+	fcb := func(arg0 uintptr) {
	346	+	cbFn := *DestroyFuncVar
	347	+	cbFn(arg0)
	348	+	}
	349	+	DestroyFuncVarRef = purego.NewCallback(fcb)
	350	+	SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
343	351		}
344		-	DestroyFuncVarRef = purego.NewCallback(fcb)
345		-	SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
346	352		}
347	353
348	354		xDatasetIdSetDataFull(DatasetLocationVar, KeyIdVar, DataVar, DestroyFuncVarRef)

M v4/glib/gerror.go +66 -54


@@ -149,43 +149,49 @@ var xErrorDomainRegister func(string, uint, uintptr, uintptr, uintptr) Quark
149	149		// g_error_domain_register_static().
150	150		func ErrorDomainRegister(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar ErrorInitFunc, ErrorTypeCopyVar ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
151	151
152		-	ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
153	152		var ErrorTypeInitVarRef uintptr
154		-	if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
155		-	ErrorTypeInitVarRef = cbRefPtr
156		-	} else {
157		-	fcb := func(arg0 *Error) {
158		-	cbFn := *ErrorTypeInitVar
159		-	cbFn(arg0)
	153	+	if ErrorTypeInitVar != nil {
	154	+	ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
	155	+	if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
	156	+	ErrorTypeInitVarRef = cbRefPtr
	157	+	} else {
	158	+	fcb := func(arg0 *Error) {
	159	+	cbFn := *ErrorTypeInitVar
	160	+	cbFn(arg0)
	161	+	}
	162	+	ErrorTypeInitVarRef = purego.NewCallback(fcb)
	163	+	SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
160	164		}
161		-	ErrorTypeInitVarRef = purego.NewCallback(fcb)
162		-	SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
163	165		}
164	166
165		-	ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
166	167		var ErrorTypeCopyVarRef uintptr
167		-	if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
168		-	ErrorTypeCopyVarRef = cbRefPtr
169		-	} else {
170		-	fcb := func(arg0 Error, arg1 Error) {
171		-	cbFn := *ErrorTypeCopyVar
172		-	cbFn(arg0, arg1)
	168	+	if ErrorTypeCopyVar != nil {
	169	+	ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
	170	+	if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
	171	+	ErrorTypeCopyVarRef = cbRefPtr
	172	+	} else {
	173	+	fcb := func(arg0 Error, arg1 Error) {
	174	+	cbFn := *ErrorTypeCopyVar
	175	+	cbFn(arg0, arg1)
	176	+	}
	177	+	ErrorTypeCopyVarRef = purego.NewCallback(fcb)
	178	+	SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
173	179		}
174		-	ErrorTypeCopyVarRef = purego.NewCallback(fcb)
175		-	SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
176	180		}
177	181
178		-	ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
179	182		var ErrorTypeClearVarRef uintptr
180		-	if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
181		-	ErrorTypeClearVarRef = cbRefPtr
182		-	} else {
183		-	fcb := func(arg0 *Error) {
184		-	cbFn := *ErrorTypeClearVar
185		-	cbFn(arg0)
	183	+	if ErrorTypeClearVar != nil {
	184	+	ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
	185	+	if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
	186	+	ErrorTypeClearVarRef = cbRefPtr
	187	+	} else {
	188	+	fcb := func(arg0 *Error) {
	189	+	cbFn := *ErrorTypeClearVar
	190	+	cbFn(arg0)
	191	+	}
	192	+	ErrorTypeClearVarRef = purego.NewCallback(fcb)
	193	+	SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
186	194		}
187		-	ErrorTypeClearVarRef = purego.NewCallback(fcb)
188		-	SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
189	195		}
190	196
191	197		cret := xErrorDomainRegister(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)

@@ -213,43 +219,49 @@ var xErrorDomainRegisterStatic func(string, uint, uintptr, uintptr, uintptr) Qua
213	219		// already takes care of passing valid information to this function.
214	220		func ErrorDomainRegisterStatic(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar ErrorInitFunc, ErrorTypeCopyVar ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
215	221
216		-	ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
217	222		var ErrorTypeInitVarRef uintptr
218		-	if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
219		-	ErrorTypeInitVarRef = cbRefPtr
220		-	} else {
221		-	fcb := func(arg0 *Error) {
222		-	cbFn := *ErrorTypeInitVar
223		-	cbFn(arg0)
	223	+	if ErrorTypeInitVar != nil {
	224	+	ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
	225	+	if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
	226	+	ErrorTypeInitVarRef = cbRefPtr
	227	+	} else {
	228	+	fcb := func(arg0 *Error) {
	229	+	cbFn := *ErrorTypeInitVar
	230	+	cbFn(arg0)
	231	+	}
	232	+	ErrorTypeInitVarRef = purego.NewCallback(fcb)
	233	+	SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
224	234		}
225		-	ErrorTypeInitVarRef = purego.NewCallback(fcb)
226		-	SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
227	235		}
228	236
229		-	ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
230	237		var ErrorTypeCopyVarRef uintptr
231		-	if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
232		-	ErrorTypeCopyVarRef = cbRefPtr
233		-	} else {
234		-	fcb := func(arg0 Error, arg1 Error) {
235		-	cbFn := *ErrorTypeCopyVar
236		-	cbFn(arg0, arg1)
	238	+	if ErrorTypeCopyVar != nil {
	239	+	ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
	240	+	if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
	241	+	ErrorTypeCopyVarRef = cbRefPtr
	242	+	} else {
	243	+	fcb := func(arg0 Error, arg1 Error) {
	244	+	cbFn := *ErrorTypeCopyVar
	245	+	cbFn(arg0, arg1)
	246	+	}
	247	+	ErrorTypeCopyVarRef = purego.NewCallback(fcb)
	248	+	SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
237	249		}
238		-	ErrorTypeCopyVarRef = purego.NewCallback(fcb)
239		-	SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
240	250		}
241	251
242		-	ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
243	252		var ErrorTypeClearVarRef uintptr
244		-	if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
245		-	ErrorTypeClearVarRef = cbRefPtr
246		-	} else {
247		-	fcb := func(arg0 *Error) {
248		-	cbFn := *ErrorTypeClearVar
249		-	cbFn(arg0)
	253	+	if ErrorTypeClearVar != nil {
	254	+	ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
	255	+	if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
	256	+	ErrorTypeClearVarRef = cbRefPtr
	257	+	} else {
	258	+	fcb := func(arg0 *Error) {
	259	+	cbFn := *ErrorTypeClearVar
	260	+	cbFn(arg0)
	261	+	}
	262	+	ErrorTypeClearVarRef = purego.NewCallback(fcb)
	263	+	SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
250	264		}
251		-	ErrorTypeClearVarRef = purego.NewCallback(fcb)
252		-	SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
253	265		}
254	266
255	267		cret := xErrorDomainRegisterStatic(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)

M v4/glib/ghash.go +44 -36


@@ -286,17 +286,19 @@ var xHashTableFind func(*HashTable, uintptr, uintptr) uintptr
286	286		// values in a hash table ends up needing O(n*n) operations).
287	287		func HashTableFind(HashTableVar HashTable, PredicateVar HRFunc, UserDataVar uintptr) uintptr {
288	288
289		-	PredicateVarPtr := uintptr(unsafe.Pointer(PredicateVar))
290	289		var PredicateVarRef uintptr
291		-	if cbRefPtr, ok := GetCallback(PredicateVarPtr); ok {
292		-	PredicateVarRef = cbRefPtr
293		-	} else {
294		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
295		-	cbFn := *PredicateVar
296		-	return cbFn(arg0, arg1, arg2)
	290	+	if PredicateVar != nil {
	291	+	PredicateVarPtr := uintptr(unsafe.Pointer(PredicateVar))
	292	+	if cbRefPtr, ok := GetCallback(PredicateVarPtr); ok {
	293	+	PredicateVarRef = cbRefPtr
	294	+	} else {
	295	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
	296	+	cbFn := *PredicateVar
	297	+	return cbFn(arg0, arg1, arg2)
	298	+	}
	299	+	PredicateVarRef = purego.NewCallback(fcb)
	300	+	SaveCallback(PredicateVarPtr, PredicateVarRef)
297	301		}
298		-	PredicateVarRef = purego.NewCallback(fcb)
299		-	SaveCallback(PredicateVarPtr, PredicateVarRef)
300	302		}
301	303
302	304		cret := xHashTableFind(HashTableVar, PredicateVarRef, UserDataVar)

@@ -319,17 +321,19 @@ var xHashTableForeach func(*HashTable, uintptr, uintptr)
319	321		// order searches in contrast to g_hash_table_lookup().
320	322		func HashTableForeach(HashTableVar HashTable, FuncVar HFunc, UserDataVar uintptr) {
321	323
322		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
323	324		var FuncVarRef uintptr
324		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
325		-	FuncVarRef = cbRefPtr
326		-	} else {
327		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
328		-	cbFn := *FuncVar
329		-	cbFn(arg0, arg1, arg2)
	325	+	if FuncVar != nil {
	326	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	327	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	328	+	FuncVarRef = cbRefPtr
	329	+	} else {
	330	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
	331	+	cbFn := *FuncVar
	332	+	cbFn(arg0, arg1, arg2)
	333	+	}
	334	+	FuncVarRef = purego.NewCallback(fcb)
	335	+	SaveCallback(FuncVarPtr, FuncVarRef)
330	336		}
331		-	FuncVarRef = purego.NewCallback(fcb)
332		-	SaveCallback(FuncVarPtr, FuncVarRef)
333	337		}
334	338
335	339		xHashTableForeach(HashTableVar, FuncVarRef, UserDataVar)

@@ -348,17 +352,19 @@ var xHashTableForeachRemove func(*HashTable, uintptr, uintptr) uint
348	352		// key/value pairs in the hash table.
349	353		func HashTableForeachRemove(HashTableVar HashTable, FuncVar HRFunc, UserDataVar uintptr) uint {
350	354
351		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
352	355		var FuncVarRef uintptr
353		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
354		-	FuncVarRef = cbRefPtr
355		-	} else {
356		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
357		-	cbFn := *FuncVar
358		-	return cbFn(arg0, arg1, arg2)
	356	+	if FuncVar != nil {
	357	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	358	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	359	+	FuncVarRef = cbRefPtr
	360	+	} else {
	361	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
	362	+	cbFn := *FuncVar
	363	+	return cbFn(arg0, arg1, arg2)
	364	+	}
	365	+	FuncVarRef = purego.NewCallback(fcb)
	366	+	SaveCallback(FuncVarPtr, FuncVarRef)
359	367		}
360		-	FuncVarRef = purego.NewCallback(fcb)
361		-	SaveCallback(FuncVarPtr, FuncVarRef)
362	368		}
363	369
364	370		cret := xHashTableForeachRemove(HashTableVar, FuncVarRef, UserDataVar)

@@ -376,17 +382,19 @@ var xHashTableForeachSteal func(*HashTable, uintptr, uintptr) uint
376	382		// key/value pairs in the hash table.
377	383		func HashTableForeachSteal(HashTableVar HashTable, FuncVar HRFunc, UserDataVar uintptr) uint {
378	384
379		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
380	385		var FuncVarRef uintptr
381		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
382		-	FuncVarRef = cbRefPtr
383		-	} else {
384		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
385		-	cbFn := *FuncVar
386		-	return cbFn(arg0, arg1, arg2)
	386	+	if FuncVar != nil {
	387	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	388	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	389	+	FuncVarRef = cbRefPtr
	390	+	} else {
	391	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
	392	+	cbFn := *FuncVar
	393	+	return cbFn(arg0, arg1, arg2)
	394	+	}
	395	+	FuncVarRef = purego.NewCallback(fcb)
	396	+	SaveCallback(FuncVarPtr, FuncVarRef)
387	397		}
388		-	FuncVarRef = purego.NewCallback(fcb)
389		-	SaveCallback(FuncVarPtr, FuncVarRef)
390	398		}
391	399
392	400		cret := xHashTableForeachSteal(HashTableVar, FuncVarRef, UserDataVar)

M v4/glib/ghook.go +33 -27


@@ -135,17 +135,19 @@ var xHookListMarshal func(uintptr, bool, uintptr, uintptr)
135	135		// Calls a function on each valid #GHook.
136	136		func (x HookList) Marshal(MayRecurseVar bool, MarshallerVar HookMarshaller, MarshalDataVar uintptr) {
137	137
138		-	MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
139	138		var MarshallerVarRef uintptr
140		-	if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
141		-	MarshallerVarRef = cbRefPtr
142		-	} else {
143		-	fcb := func(arg0 *Hook, arg1 uintptr) {
144		-	cbFn := *MarshallerVar
145		-	cbFn(arg0, arg1)
	139	+	if MarshallerVar != nil {
	140	+	MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
	141	+	if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
	142	+	MarshallerVarRef = cbRefPtr
	143	+	} else {
	144	+	fcb := func(arg0 *Hook, arg1 uintptr) {
	145	+	cbFn := *MarshallerVar
	146	+	cbFn(arg0, arg1)
	147	+	}
	148	+	MarshallerVarRef = purego.NewCallback(fcb)
	149	+	SaveCallback(MarshallerVarPtr, MarshallerVarRef)
146	150		}
147		-	MarshallerVarRef = purego.NewCallback(fcb)
148		-	SaveCallback(MarshallerVarPtr, MarshallerVarRef)
149	151		}
150	152
151	153		xHookListMarshal(x.GoPointer(), MayRecurseVar, MarshallerVarRef, MarshalDataVar)

@@ -158,17 +160,19 @@ var xHookListMarshalCheck func(uintptr, bool, uintptr, uintptr)
158	160		// function returns %FALSE.
159	161		func (x HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar HookCheckMarshaller, MarshalDataVar uintptr) {
160	162
161		-	MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
162	163		var MarshallerVarRef uintptr
163		-	if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
164		-	MarshallerVarRef = cbRefPtr
165		-	} else {
166		-	fcb := func(arg0 *Hook, arg1 uintptr) bool {
167		-	cbFn := *MarshallerVar
168		-	return cbFn(arg0, arg1)
	164	+	if MarshallerVar != nil {
	165	+	MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
	166	+	if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
	167	+	MarshallerVarRef = cbRefPtr
	168	+	} else {
	169	+	fcb := func(arg0 *Hook, arg1 uintptr) bool {
	170	+	cbFn := *MarshallerVar
	171	+	return cbFn(arg0, arg1)
	172	+	}
	173	+	MarshallerVarRef = purego.NewCallback(fcb)
	174	+	SaveCallback(MarshallerVarPtr, MarshallerVarRef)
169	175		}
170		-	MarshallerVarRef = purego.NewCallback(fcb)
171		-	SaveCallback(MarshallerVarPtr, MarshallerVarRef)
172	176		}
173	177
174	178		xHookListMarshalCheck(x.GoPointer(), MayRecurseVar, MarshallerVarRef, MarshalDataVar)

@@ -240,17 +244,19 @@ var xHookInsertSorted func(HookList, Hook, uintptr)
240	244		// Inserts a #GHook into a #GHookList, sorted by the given function.
241	245		func HookInsertSorted(HookListVar HookList, HookVar Hook, FuncVar *HookCompareFunc) {
242	246
243		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
244	247		var FuncVarRef uintptr
245		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
246		-	FuncVarRef = cbRefPtr
247		-	} else {
248		-	fcb := func(arg0 Hook, arg1 Hook) int {
249		-	cbFn := *FuncVar
250		-	return cbFn(arg0, arg1)
	248	+	if FuncVar != nil {
	249	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	250	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	251	+	FuncVarRef = cbRefPtr
	252	+	} else {
	253	+	fcb := func(arg0 Hook, arg1 Hook) int {
	254	+	cbFn := *FuncVar
	255	+	return cbFn(arg0, arg1)
	256	+	}
	257	+	FuncVarRef = purego.NewCallback(fcb)
	258	+	SaveCallback(FuncVarPtr, FuncVarRef)
251	259		}
252		-	FuncVarRef = purego.NewCallback(fcb)
253		-	SaveCallback(FuncVarPtr, FuncVarRef)
254	260		}
255	261
256	262		xHookInsertSorted(HookListVar, HookVar, FuncVarRef)

M v4/glib/giochannel.go +33 -27


@@ -1018,17 +1018,19 @@ var xIoAddWatch func(*IOChannel, IOCondition, uintptr, uintptr) uint
1018	1018		// with the default priority.
1019	1019		func IoAddWatch(ChannelVar IOChannel, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr) uint {
1020	1020
1021		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1022	1021		var FuncVarRef uintptr
1023		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
1024		-	FuncVarRef = cbRefPtr
1025		-	} else {
1026		-	fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
1027		-	cbFn := *FuncVar
1028		-	return cbFn(arg0, arg1, arg2)
	1022	+	if FuncVar != nil {
	1023	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	1024	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	1025	+	FuncVarRef = cbRefPtr
	1026	+	} else {
	1027	+	fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
	1028	+	cbFn := *FuncVar
	1029	+	return cbFn(arg0, arg1, arg2)
	1030	+	}
	1031	+	FuncVarRef = purego.NewCallback(fcb)
	1032	+	SaveCallback(FuncVarPtr, FuncVarRef)
1029	1033		}
1030		-	FuncVarRef = purego.NewCallback(fcb)
1031		-	SaveCallback(FuncVarPtr, FuncVarRef)
1032	1034		}
1033	1035
1034	1036		cret := xIoAddWatch(ChannelVar, ConditionVar, FuncVarRef, UserDataVar)

@@ -1045,30 +1047,34 @@ var xIoAddWatchFull func(*IOChannel, int, IOCondition, uintptr, uintptr, uintptr
1045	1047		// You can do these steps manually if you need greater control.
1046	1048		func IoAddWatchFull(ChannelVar IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
1047	1049
1048		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1049	1050		var FuncVarRef uintptr
1050		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
1051		-	FuncVarRef = cbRefPtr
1052		-	} else {
1053		-	fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
1054		-	cbFn := *FuncVar
1055		-	return cbFn(arg0, arg1, arg2)
	1051	+	if FuncVar != nil {
	1052	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	1053	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	1054	+	FuncVarRef = cbRefPtr
	1055	+	} else {
	1056	+	fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
	1057	+	cbFn := *FuncVar
	1058	+	return cbFn(arg0, arg1, arg2)
	1059	+	}
	1060	+	FuncVarRef = purego.NewCallback(fcb)
	1061	+	SaveCallback(FuncVarPtr, FuncVarRef)
1056	1062		}
1057		-	FuncVarRef = purego.NewCallback(fcb)
1058		-	SaveCallback(FuncVarPtr, FuncVarRef)
1059	1063		}
1060	1064
1061		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1062	1065		var NotifyVarRef uintptr
1063		-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
1064		-	NotifyVarRef = cbRefPtr
1065		-	} else {
1066		-	fcb := func(arg0 uintptr) {
1067		-	cbFn := *NotifyVar
1068		-	cbFn(arg0)
	1066	+	if NotifyVar != nil {
	1067	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	1068	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
	1069	+	NotifyVarRef = cbRefPtr
	1070	+	} else {
	1071	+	fcb := func(arg0 uintptr) {
	1072	+	cbFn := *NotifyVar
	1073	+	cbFn(arg0)
	1074	+	}
	1075	+	NotifyVarRef = purego.NewCallback(fcb)
	1076	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
1069	1077		}
1070		-	NotifyVarRef = purego.NewCallback(fcb)
1071		-	SaveCallback(NotifyVarPtr, NotifyVarRef)
1072	1078		}
1073	1079
1074	1080		cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, FuncVarRef, UserDataVar, NotifyVarRef)

M v4/glib/glib-unix.go +66 -54


@@ -99,17 +99,19 @@ var xUnixFdAdd func(int, IOCondition, uintptr, uintptr) uint
99	99		// The source will never close the fd -- you must do it yourself.
100	100		func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr) uint {
101	101
102		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
103	102		var FunctionVarRef uintptr
104		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
105		-	FunctionVarRef = cbRefPtr
106		-	} else {
107		-	fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
108		-	cbFn := *FunctionVar
109		-	return cbFn(arg0, arg1, arg2)
	103	+	if FunctionVar != nil {
	104	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	105	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	106	+	FunctionVarRef = cbRefPtr
	107	+	} else {
	108	+	fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
	109	+	cbFn := *FunctionVar
	110	+	return cbFn(arg0, arg1, arg2)
	111	+	}
	112	+	FunctionVarRef = purego.NewCallback(fcb)
	113	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
110	114		}
111		-	FunctionVarRef = purego.NewCallback(fcb)
112		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
113	115		}
114	116
115	117		cret := xUnixFdAdd(FdVar, ConditionVar, FunctionVarRef, UserDataVar)

@@ -126,30 +128,34 @@ var xUnixFdAddFull func(int, int, IOCondition, uintptr, uintptr, uintptr) uint
126	128		// @user_data.
127	129		func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar UnixFDSourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {
128	130
129		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
130	131		var FunctionVarRef uintptr
131		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
132		-	FunctionVarRef = cbRefPtr
133		-	} else {
134		-	fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
135		-	cbFn := *FunctionVar
136		-	return cbFn(arg0, arg1, arg2)
	132	+	if FunctionVar != nil {
	133	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	134	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	135	+	FunctionVarRef = cbRefPtr
	136	+	} else {
	137	+	fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
	138	+	cbFn := *FunctionVar
	139	+	return cbFn(arg0, arg1, arg2)
	140	+	}
	141	+	FunctionVarRef = purego.NewCallback(fcb)
	142	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
137	143		}
138		-	FunctionVarRef = purego.NewCallback(fcb)
139		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
140	144		}
141	145
142		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
143	146		var NotifyVarRef uintptr
144		-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
145		-	NotifyVarRef = cbRefPtr
146		-	} else {
147		-	fcb := func(arg0 uintptr) {
148		-	cbFn := *NotifyVar
149		-	cbFn(arg0)
	147	+	if NotifyVar != nil {
	148	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	149	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
	150	+	NotifyVarRef = cbRefPtr
	151	+	} else {
	152	+	fcb := func(arg0 uintptr) {
	153	+	cbFn := *NotifyVar
	154	+	cbFn(arg0)
	155	+	}
	156	+	NotifyVarRef = purego.NewCallback(fcb)
	157	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
150	158		}
151		-	NotifyVarRef = purego.NewCallback(fcb)
152		-	SaveCallback(NotifyVarPtr, NotifyVarRef)
153	159		}
154	160
155	161		cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, FunctionVarRef, UserDataVar, NotifyVarRef)

@@ -250,17 +256,19 @@ var xUnixSignalAdd func(int, uintptr, uintptr) uint
250	256		// using g_source_remove().
251	257		func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) uint {
252	258
253		-	HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
254	259		var HandlerVarRef uintptr
255		-	if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
256		-	HandlerVarRef = cbRefPtr
257		-	} else {
258		-	fcb := func(arg0 uintptr) bool {
259		-	cbFn := *HandlerVar
260		-	return cbFn(arg0)
	260	+	if HandlerVar != nil {
	261	+	HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
	262	+	if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
	263	+	HandlerVarRef = cbRefPtr
	264	+	} else {
	265	+	fcb := func(arg0 uintptr) bool {
	266	+	cbFn := *HandlerVar
	267	+	return cbFn(arg0)
	268	+	}
	269	+	HandlerVarRef = purego.NewCallback(fcb)
	270	+	SaveCallback(HandlerVarPtr, HandlerVarRef)
261	271		}
262		-	HandlerVarRef = purego.NewCallback(fcb)
263		-	SaveCallback(HandlerVarPtr, HandlerVarRef)
264	272		}
265	273
266	274		cret := xUnixSignalAdd(SignumVar, HandlerVarRef, UserDataVar)

@@ -274,30 +282,34 @@ var xUnixSignalAddFull func(int, int, uintptr, uintptr, uintptr) uint
274	282		// using g_source_remove().
275	283		func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar SourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {
276	284
277		-	HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
278	285		var HandlerVarRef uintptr
279		-	if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
280		-	HandlerVarRef = cbRefPtr
281		-	} else {
282		-	fcb := func(arg0 uintptr) bool {
283		-	cbFn := *HandlerVar
284		-	return cbFn(arg0)
	286	+	if HandlerVar != nil {
	287	+	HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
	288	+	if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
	289	+	HandlerVarRef = cbRefPtr
	290	+	} else {
	291	+	fcb := func(arg0 uintptr) bool {
	292	+	cbFn := *HandlerVar
	293	+	return cbFn(arg0)
	294	+	}
	295	+	HandlerVarRef = purego.NewCallback(fcb)
	296	+	SaveCallback(HandlerVarPtr, HandlerVarRef)
285	297		}
286		-	HandlerVarRef = purego.NewCallback(fcb)
287		-	SaveCallback(HandlerVarPtr, HandlerVarRef)
288	298		}
289	299
290		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
291	300		var NotifyVarRef uintptr
292		-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
293		-	NotifyVarRef = cbRefPtr
294		-	} else {
295		-	fcb := func(arg0 uintptr) {
296		-	cbFn := *NotifyVar
297		-	cbFn(arg0)
	301	+	if NotifyVar != nil {
	302	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	303	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
	304	+	NotifyVarRef = cbRefPtr
	305	+	} else {
	306	+	fcb := func(arg0 uintptr) {
	307	+	cbFn := *NotifyVar
	308	+	cbFn(arg0)
	309	+	}
	310	+	NotifyVarRef = purego.NewCallback(fcb)
	311	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
298	312		}
299		-	NotifyVarRef = purego.NewCallback(fcb)
300		-	SaveCallback(NotifyVarPtr, NotifyVarRef)
301	313		}
302	314
303	315		cret := xUnixSignalAddFull(PriorityVar, SignumVar, HandlerVarRef, UserDataVar, NotifyVarRef)

M v4/glib/gmain.go +187 -153


@@ -279,17 +279,19 @@ var xMainContextInvoke func(uintptr, uintptr, uintptr)
279	279		// will be continuously run in a loop (and may prevent this call from returning).
280	280		func (x MainContext) Invoke(FunctionVar SourceFunc, DataVar uintptr) {
281	281
282		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
283	282		var FunctionVarRef uintptr
284		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
285		-	FunctionVarRef = cbRefPtr
286		-	} else {
287		-	fcb := func(arg0 uintptr) bool {
288		-	cbFn := *FunctionVar
289		-	return cbFn(arg0)
	283	+	if FunctionVar != nil {
	284	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	285	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	286	+	FunctionVarRef = cbRefPtr
	287	+	} else {
	288	+	fcb := func(arg0 uintptr) bool {
	289	+	cbFn := *FunctionVar
	290	+	return cbFn(arg0)
	291	+	}
	292	+	FunctionVarRef = purego.NewCallback(fcb)
	293	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
290	294		}
291		-	FunctionVarRef = purego.NewCallback(fcb)
292		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
293	295		}
294	296
295	297		xMainContextInvoke(x.GoPointer(), FunctionVarRef, DataVar)

@@ -310,17 +312,19 @@ var xMainContextInvokeFull func(uintptr, int, uintptr, uintptr, uintptr)
310	312		// thread or with any particular context acquired.
311	313		func (x MainContext) InvokeFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
312	314
313		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
314	315		var FunctionVarRef uintptr
315		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
316		-	FunctionVarRef = cbRefPtr
317		-	} else {
318		-	fcb := func(arg0 uintptr) bool {
319		-	cbFn := *FunctionVar
320		-	return cbFn(arg0)
	316	+	if FunctionVar != nil {
	317	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	318	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	319	+	FunctionVarRef = cbRefPtr
	320	+	} else {
	321	+	fcb := func(arg0 uintptr) bool {
	322	+	cbFn := *FunctionVar
	323	+	return cbFn(arg0)
	324	+	}
	325	+	FunctionVarRef = purego.NewCallback(fcb)
	326	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
321	327		}
322		-	FunctionVarRef = purego.NewCallback(fcb)
323		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
324	328		}
325	329
326	330		var NotifyVarRef uintptr

@@ -571,17 +575,19 @@ var xMainContextSetPollFunc func(uintptr, uintptr)
571	575		// loop with an external event loop.
572	576		func (x MainContext) SetPollFunc(FuncVar PollFunc) {
573	577
574		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
575	578		var FuncVarRef uintptr
576		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
577		-	FuncVarRef = cbRefPtr
578		-	} else {
579		-	fcb := func(arg0 *PollFD, arg1 uint, arg2 int) int {
580		-	cbFn := *FuncVar
581		-	return cbFn(arg0, arg1, arg2)
	579	+	if FuncVar != nil {
	580	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	581	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	582	+	FuncVarRef = cbRefPtr
	583	+	} else {
	584	+	fcb := func(arg0 *PollFD, arg1 uint, arg2 int) int {
	585	+	cbFn := *FuncVar
	586	+	return cbFn(arg0, arg1, arg2)
	587	+	}
	588	+	FuncVarRef = purego.NewCallback(fcb)
	589	+	SaveCallback(FuncVarPtr, FuncVarRef)
582	590		}
583		-	FuncVarRef = purego.NewCallback(fcb)
584		-	SaveCallback(FuncVarPtr, FuncVarRef)
585	591		}
586	592
587	593		xMainContextSetPollFunc(x.GoPointer(), FuncVarRef)

@@ -1250,17 +1256,19 @@ var xSourceSetCallback func(uintptr, uintptr, uintptr, uintptr)
1250	1256		// of also unsetting the callback.
1251	1257		func (x Source) SetCallback(FuncVar SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
1252	1258
1253		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1254	1259		var FuncVarRef uintptr
1255		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
1256		-	FuncVarRef = cbRefPtr
1257		-	} else {
1258		-	fcb := func(arg0 uintptr) bool {
1259		-	cbFn := *FuncVar
1260		-	return cbFn(arg0)
	1260	+	if FuncVar != nil {
	1261	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	1262	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	1263	+	FuncVarRef = cbRefPtr
	1264	+	} else {
	1265	+	fcb := func(arg0 uintptr) bool {
	1266	+	cbFn := *FuncVar
	1267	+	return cbFn(arg0)
	1268	+	}
	1269	+	FuncVarRef = purego.NewCallback(fcb)
	1270	+	SaveCallback(FuncVarPtr, FuncVarRef)
1261	1271		}
1262		-	FuncVarRef = purego.NewCallback(fcb)
1263		-	SaveCallback(FuncVarPtr, FuncVarRef)
1264	1272		}
1265	1273
1266	1274		var NotifyVarRef uintptr

@@ -1339,17 +1347,19 @@ var xSourceSetDisposeFunction func(uintptr, uintptr)
1339	1347		// This should only ever be called from [struct@GLib.Source] implementations.
1340	1348		func (x Source) SetDisposeFunction(DisposeVar SourceDisposeFunc) {
1341	1349
1342		-	DisposeVarPtr := uintptr(unsafe.Pointer(DisposeVar))
1343	1350		var DisposeVarRef uintptr
1344		-	if cbRefPtr, ok := GetCallback(DisposeVarPtr); ok {
1345		-	DisposeVarRef = cbRefPtr
1346		-	} else {
1347		-	fcb := func(arg0 *Source) {
1348		-	cbFn := *DisposeVar
1349		-	cbFn(arg0)
	1351	+	if DisposeVar != nil {
	1352	+	DisposeVarPtr := uintptr(unsafe.Pointer(DisposeVar))
	1353	+	if cbRefPtr, ok := GetCallback(DisposeVarPtr); ok {
	1354	+	DisposeVarRef = cbRefPtr
	1355	+	} else {
	1356	+	fcb := func(arg0 *Source) {
	1357	+	cbFn := *DisposeVar
	1358	+	cbFn(arg0)
	1359	+	}
	1360	+	DisposeVarRef = purego.NewCallback(fcb)
	1361	+	SaveCallback(DisposeVarPtr, DisposeVarRef)
1350	1362		}
1351		-	DisposeVarRef = purego.NewCallback(fcb)
1352		-	SaveCallback(DisposeVarPtr, DisposeVarRef)
1353	1363		}
1354	1364
1355	1365		xSourceSetDisposeFunction(x.GoPointer(), DisposeVarRef)

@@ -1690,17 +1700,19 @@ var xChildWatchAdd func(Pid, uintptr, uintptr) uint
1690	1700		// need greater control.
1691	1701		func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uint {
1692	1702
1693		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1694	1703		var FunctionVarRef uintptr
1695		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
1696		-	FunctionVarRef = cbRefPtr
1697		-	} else {
1698		-	fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
1699		-	cbFn := *FunctionVar
1700		-	cbFn(arg0, arg1, arg2)
	1704	+	if FunctionVar != nil {
	1705	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	1706	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	1707	+	FunctionVarRef = cbRefPtr
	1708	+	} else {
	1709	+	fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
	1710	+	cbFn := *FunctionVar
	1711	+	cbFn(arg0, arg1, arg2)
	1712	+	}
	1713	+	FunctionVarRef = purego.NewCallback(fcb)
	1714	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
1701	1715		}
1702		-	FunctionVarRef = purego.NewCallback(fcb)
1703		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
1704	1716		}
1705	1717
1706	1718		cret := xChildWatchAdd(PidVar, FunctionVarRef, DataVar)

@@ -1736,17 +1748,19 @@ var xChildWatchAddFull func(int, Pid, uintptr, uintptr, uintptr) uint
1736	1748		// need greater control.
1737	1749		func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar ChildWatchFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1738	1750
1739		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1740	1751		var FunctionVarRef uintptr
1741		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
1742		-	FunctionVarRef = cbRefPtr
1743		-	} else {
1744		-	fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
1745		-	cbFn := *FunctionVar
1746		-	cbFn(arg0, arg1, arg2)
	1752	+	if FunctionVar != nil {
	1753	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	1754	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	1755	+	FunctionVarRef = cbRefPtr
	1756	+	} else {
	1757	+	fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
	1758	+	cbFn := *FunctionVar
	1759	+	cbFn(arg0, arg1, arg2)
	1760	+	}
	1761	+	FunctionVarRef = purego.NewCallback(fcb)
	1762	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
1747	1763		}
1748		-	FunctionVarRef = purego.NewCallback(fcb)
1749		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
1750	1764		}
1751	1765
1752	1766		var NotifyVarRef uintptr

@@ -1830,17 +1844,19 @@ var xClearHandleId func(uint, uintptr)
1830	1844		// pointer casts.
1831	1845		func ClearHandleId(TagPtrVar uint, ClearFuncVar *ClearHandleFunc) {
1832	1846
1833		-	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
1834	1847		var ClearFuncVarRef uintptr
1835		-	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
1836		-	ClearFuncVarRef = cbRefPtr
1837		-	} else {
1838		-	fcb := func(arg0 uint) {
1839		-	cbFn := *ClearFuncVar
1840		-	cbFn(arg0)
	1848	+	if ClearFuncVar != nil {
	1849	+	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
	1850	+	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
	1851	+	ClearFuncVarRef = cbRefPtr
	1852	+	} else {
	1853	+	fcb := func(arg0 uint) {
	1854	+	cbFn := *ClearFuncVar
	1855	+	cbFn(arg0)
	1856	+	}
	1857	+	ClearFuncVarRef = purego.NewCallback(fcb)
	1858	+	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
1841	1859		}
1842		-	ClearFuncVarRef = purego.NewCallback(fcb)
1843		-	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
1844	1860		}
1845	1861
1846	1862		xClearHandleId(TagPtrVar, ClearFuncVarRef)

@@ -1916,17 +1932,19 @@ var xIdleAdd func(uintptr, uintptr) uint
1916	1932		// need greater control or to use a custom main context.
1917	1933		func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {
1918	1934
1919		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1920	1935		var FunctionVarRef uintptr
1921		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
1922		-	FunctionVarRef = cbRefPtr
1923		-	} else {
1924		-	fcb := func(arg0 uintptr) bool {
1925		-	cbFn := *FunctionVar
1926		-	return cbFn(arg0)
	1936	+	if FunctionVar != nil {
	1937	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	1938	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	1939	+	FunctionVarRef = cbRefPtr
	1940	+	} else {
	1941	+	fcb := func(arg0 uintptr) bool {
	1942	+	cbFn := *FunctionVar
	1943	+	return cbFn(arg0)
	1944	+	}
	1945	+	FunctionVarRef = purego.NewCallback(fcb)
	1946	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
1927	1947		}
1928		-	FunctionVarRef = purego.NewCallback(fcb)
1929		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
1930	1948		}
1931	1949
1932	1950		cret := xIdleAdd(FunctionVarRef, DataVar)

@@ -1951,17 +1969,19 @@ var xIdleAddFull func(int, uintptr, uintptr, uintptr) uint
1951	1969		// need greater control or to use a custom main context.
1952	1970		func IdleAddFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1953	1971
1954		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1955	1972		var FunctionVarRef uintptr
1956		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
1957		-	FunctionVarRef = cbRefPtr
1958		-	} else {
1959		-	fcb := func(arg0 uintptr) bool {
1960		-	cbFn := *FunctionVar
1961		-	return cbFn(arg0)
	1973	+	if FunctionVar != nil {
	1974	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	1975	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	1976	+	FunctionVarRef = cbRefPtr
	1977	+	} else {
	1978	+	fcb := func(arg0 uintptr) bool {
	1979	+	cbFn := *FunctionVar
	1980	+	return cbFn(arg0)
	1981	+	}
	1982	+	FunctionVarRef = purego.NewCallback(fcb)
	1983	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
1962	1984		}
1963		-	FunctionVarRef = purego.NewCallback(fcb)
1964		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
1965	1985		}
1966	1986
1967	1987		var NotifyVarRef uintptr

@@ -1997,17 +2017,19 @@ var xIdleAddOnce func(uintptr, uintptr) uint
1997	2017		// This function otherwise behaves like [func@GLib.idle_add].
1998	2018		func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
1999	2019
2000		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2001	2020		var FunctionVarRef uintptr
2002		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2003		-	FunctionVarRef = cbRefPtr
2004		-	} else {
2005		-	fcb := func(arg0 uintptr) {
2006		-	cbFn := *FunctionVar
2007		-	cbFn(arg0)
	2021	+	if FunctionVar != nil {
	2022	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	2023	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	2024	+	FunctionVarRef = cbRefPtr
	2025	+	} else {
	2026	+	fcb := func(arg0 uintptr) {
	2027	+	cbFn := *FunctionVar
	2028	+	cbFn(arg0)
	2029	+	}
	2030	+	FunctionVarRef = purego.NewCallback(fcb)
	2031	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
2008	2032		}
2009		-	FunctionVarRef = purego.NewCallback(fcb)
2010		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
2011	2033		}
2012	2034
2013	2035		cret := xIdleAddOnce(FunctionVarRef, DataVar)

@@ -2333,17 +2355,19 @@ var xTimeoutAdd func(uint, uintptr, uintptr) uint
2333	2355		// time. See [func@GLib.get_monotonic_time].
2334	2356		func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
2335	2357
2336		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2337	2358		var FunctionVarRef uintptr
2338		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2339		-	FunctionVarRef = cbRefPtr
2340		-	} else {
2341		-	fcb := func(arg0 uintptr) bool {
2342		-	cbFn := *FunctionVar
2343		-	return cbFn(arg0)
	2359	+	if FunctionVar != nil {
	2360	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	2361	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	2362	+	FunctionVarRef = cbRefPtr
	2363	+	} else {
	2364	+	fcb := func(arg0 uintptr) bool {
	2365	+	cbFn := *FunctionVar
	2366	+	return cbFn(arg0)
	2367	+	}
	2368	+	FunctionVarRef = purego.NewCallback(fcb)
	2369	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
2344	2370		}
2345		-	FunctionVarRef = purego.NewCallback(fcb)
2346		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
2347	2371		}
2348	2372
2349	2373		cret := xTimeoutAdd(IntervalVar, FunctionVarRef, DataVar)

@@ -2382,17 +2406,19 @@ var xTimeoutAddFull func(int, uint, uintptr, uintptr, uintptr) uint
2382	2406		// See [func@GLib.get_monotonic_time].
2383	2407		func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
2384	2408
2385		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2386	2409		var FunctionVarRef uintptr
2387		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2388		-	FunctionVarRef = cbRefPtr
2389		-	} else {
2390		-	fcb := func(arg0 uintptr) bool {
2391		-	cbFn := *FunctionVar
2392		-	return cbFn(arg0)
	2410	+	if FunctionVar != nil {
	2411	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	2412	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	2413	+	FunctionVarRef = cbRefPtr
	2414	+	} else {
	2415	+	fcb := func(arg0 uintptr) bool {
	2416	+	cbFn := *FunctionVar
	2417	+	return cbFn(arg0)
	2418	+	}
	2419	+	FunctionVarRef = purego.NewCallback(fcb)
	2420	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
2393	2421		}
2394		-	FunctionVarRef = purego.NewCallback(fcb)
2395		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
2396	2422		}
2397	2423
2398	2424		var NotifyVarRef uintptr

@@ -2425,17 +2451,19 @@ var xTimeoutAddOnce func(uint, uintptr, uintptr) uint
2425	2451		// This function otherwise behaves like [func@GLib.timeout_add].
2426	2452		func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2427	2453
2428		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2429	2454		var FunctionVarRef uintptr
2430		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2431		-	FunctionVarRef = cbRefPtr
2432		-	} else {
2433		-	fcb := func(arg0 uintptr) {
2434		-	cbFn := *FunctionVar
2435		-	cbFn(arg0)
	2455	+	if FunctionVar != nil {
	2456	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	2457	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	2458	+	FunctionVarRef = cbRefPtr
	2459	+	} else {
	2460	+	fcb := func(arg0 uintptr) {
	2461	+	cbFn := *FunctionVar
	2462	+	cbFn(arg0)
	2463	+	}
	2464	+	FunctionVarRef = purego.NewCallback(fcb)
	2465	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
2436	2466		}
2437		-	FunctionVarRef = purego.NewCallback(fcb)
2438		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
2439	2467		}
2440	2468
2441	2469		cret := xTimeoutAddOnce(IntervalVar, FunctionVarRef, DataVar)

@@ -2469,17 +2497,19 @@ var xTimeoutAddSeconds func(uint, uintptr, uintptr) uint
2469	2497		// time. See [func@GLib.get_monotonic_time].
2470	2498		func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
2471	2499
2472		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2473	2500		var FunctionVarRef uintptr
2474		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2475		-	FunctionVarRef = cbRefPtr
2476		-	} else {
2477		-	fcb := func(arg0 uintptr) bool {
2478		-	cbFn := *FunctionVar
2479		-	return cbFn(arg0)
	2501	+	if FunctionVar != nil {
	2502	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	2503	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	2504	+	FunctionVarRef = cbRefPtr
	2505	+	} else {
	2506	+	fcb := func(arg0 uintptr) bool {
	2507	+	cbFn := *FunctionVar
	2508	+	return cbFn(arg0)
	2509	+	}
	2510	+	FunctionVarRef = purego.NewCallback(fcb)
	2511	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
2480	2512		}
2481		-	FunctionVarRef = purego.NewCallback(fcb)
2482		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
2483	2513		}
2484	2514
2485	2515		cret := xTimeoutAddSeconds(IntervalVar, FunctionVarRef, DataVar)

@@ -2530,17 +2560,19 @@ var xTimeoutAddSecondsFull func(int, uint, uintptr, uintptr, uintptr) uint
2530	2560		// time. See [func@GLib.get_monotonic_time].
2531	2561		func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
2532	2562
2533		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2534	2563		var FunctionVarRef uintptr
2535		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2536		-	FunctionVarRef = cbRefPtr
2537		-	} else {
2538		-	fcb := func(arg0 uintptr) bool {
2539		-	cbFn := *FunctionVar
2540		-	return cbFn(arg0)
	2564	+	if FunctionVar != nil {
	2565	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	2566	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	2567	+	FunctionVarRef = cbRefPtr
	2568	+	} else {
	2569	+	fcb := func(arg0 uintptr) bool {
	2570	+	cbFn := *FunctionVar
	2571	+	return cbFn(arg0)
	2572	+	}
	2573	+	FunctionVarRef = purego.NewCallback(fcb)
	2574	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
2541	2575		}
2542		-	FunctionVarRef = purego.NewCallback(fcb)
2543		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
2544	2576		}
2545	2577
2546	2578		var NotifyVarRef uintptr

@@ -2568,17 +2600,19 @@ var xTimeoutAddSecondsOnce func(uint, uintptr, uintptr) uint
2568	2600		// seconds.
2569	2601		func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2570	2602
2571		-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2572	2603		var FunctionVarRef uintptr
2573		-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2574		-	FunctionVarRef = cbRefPtr
2575		-	} else {
2576		-	fcb := func(arg0 uintptr) {
2577		-	cbFn := *FunctionVar
2578		-	cbFn(arg0)
	2604	+	if FunctionVar != nil {
	2605	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
	2606	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
	2607	+	FunctionVarRef = cbRefPtr
	2608	+	} else {
	2609	+	fcb := func(arg0 uintptr) {
	2610	+	cbFn := *FunctionVar
	2611	+	cbFn(arg0)
	2612	+	}
	2613	+	FunctionVarRef = purego.NewCallback(fcb)
	2614	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
2579	2615		}
2580		-	FunctionVarRef = purego.NewCallback(fcb)
2581		-	SaveCallback(FunctionVarPtr, FunctionVarRef)
2582	2616		}
2583	2617
2584	2618		cret := xTimeoutAddSecondsOnce(IntervalVar, FunctionVarRef, DataVar)

M v4/glib/gmarkup.go +11 -9


@@ -38,17 +38,19 @@ var xNewMarkupParseContext func(*MarkupParser, MarkupParseFlags, uintptr, uintpt
38	38		// free it and create a new parse context).
39	39		func NewMarkupParseContext(ParserVar MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar DestroyNotify) *MarkupParseContext {
40	40
41		-	UserDataDnotifyVarPtr := uintptr(unsafe.Pointer(UserDataDnotifyVar))
42	41		var UserDataDnotifyVarRef uintptr
43		-	if cbRefPtr, ok := GetCallback(UserDataDnotifyVarPtr); ok {
44		-	UserDataDnotifyVarRef = cbRefPtr
45		-	} else {
46		-	fcb := func(arg0 uintptr) {
47		-	cbFn := *UserDataDnotifyVar
48		-	cbFn(arg0)
	42	+	if UserDataDnotifyVar != nil {
	43	+	UserDataDnotifyVarPtr := uintptr(unsafe.Pointer(UserDataDnotifyVar))
	44	+	if cbRefPtr, ok := GetCallback(UserDataDnotifyVarPtr); ok {
	45	+	UserDataDnotifyVarRef = cbRefPtr
	46	+	} else {
	47	+	fcb := func(arg0 uintptr) {
	48	+	cbFn := *UserDataDnotifyVar
	49	+	cbFn(arg0)
	50	+	}
	51	+	UserDataDnotifyVarRef = purego.NewCallback(fcb)
	52	+	SaveCallback(UserDataDnotifyVarPtr, UserDataDnotifyVarRef)
49	53		}
50		-	UserDataDnotifyVarRef = purego.NewCallback(fcb)
51		-	SaveCallback(UserDataDnotifyVarPtr, UserDataDnotifyVarRef)
52	54		}
53	55
54	56		cret := xNewMarkupParseContext(ParserVar, FlagsVar, UserDataVar, UserDataDnotifyVarRef)

M v4/glib/gmem.go +11 -9


@@ -279,17 +279,19 @@ var xClearPointer func(uintptr, uintptr)
279	279		// ```
280	280		func ClearPointer(PpVar uintptr, DestroyVar *DestroyNotify) {
281	281
282		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
283	282		var DestroyVarRef uintptr
284		-	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
285		-	DestroyVarRef = cbRefPtr
286		-	} else {
287		-	fcb := func(arg0 uintptr) {
288		-	cbFn := *DestroyVar
289		-	cbFn(arg0)
	283	+	if DestroyVar != nil {
	284	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	285	+	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
	286	+	DestroyVarRef = cbRefPtr
	287	+	} else {
	288	+	fcb := func(arg0 uintptr) {
	289	+	cbFn := *DestroyVar
	290	+	cbFn(arg0)
	291	+	}
	292	+	DestroyVarRef = purego.NewCallback(fcb)
	293	+	SaveCallback(DestroyVarPtr, DestroyVarRef)
290	294		}
291		-	DestroyVarRef = purego.NewCallback(fcb)
292		-	SaveCallback(DestroyVarPtr, DestroyVarRef)
293	295		}
294	296
295	297		xClearPointer(PpVar, DestroyVarRef)

M v4/glib/gmessages.go +66 -54


@@ -339,17 +339,19 @@ var xLogSetDefaultHandler func(uintptr, uintptr) uintptr
339	339		// [Using Structured Logging](logging.html#using-structured-logging).
340	340		func LogSetDefaultHandler(LogFuncVar *LogFunc, UserDataVar uintptr) uintptr {
341	341
342		-	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
343	342		var LogFuncVarRef uintptr
344		-	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
345		-	LogFuncVarRef = cbRefPtr
346		-	} else {
347		-	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
348		-	cbFn := *LogFuncVar
349		-	cbFn(arg0, arg1, arg2, arg3)
	343	+	if LogFuncVar != nil {
	344	+	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
	345	+	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
	346	+	LogFuncVarRef = cbRefPtr
	347	+	} else {
	348	+	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
	349	+	cbFn := *LogFuncVar
	350	+	cbFn(arg0, arg1, arg2, arg3)
	351	+	}
	352	+	LogFuncVarRef = purego.NewCallback(fcb)
	353	+	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
350	354		}
351		-	LogFuncVarRef = purego.NewCallback(fcb)
352		-	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
353	355		}
354	356
355	357		cret := xLogSetDefaultHandler(LogFuncVarRef, UserDataVar)

@@ -425,17 +427,19 @@ var xLogSetHandler func(string, LogLevelFlags, uintptr, uintptr) uint
425	427		// ```
426	428		func LogSetHandler(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr) uint {
427	429
428		-	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
429	430		var LogFuncVarRef uintptr
430		-	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
431		-	LogFuncVarRef = cbRefPtr
432		-	} else {
433		-	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
434		-	cbFn := *LogFuncVar
435		-	cbFn(arg0, arg1, arg2, arg3)
	431	+	if LogFuncVar != nil {
	432	+	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
	433	+	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
	434	+	LogFuncVarRef = cbRefPtr
	435	+	} else {
	436	+	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
	437	+	cbFn := *LogFuncVar
	438	+	cbFn(arg0, arg1, arg2, arg3)
	439	+	}
	440	+	LogFuncVarRef = purego.NewCallback(fcb)
	441	+	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
436	442		}
437		-	LogFuncVarRef = purego.NewCallback(fcb)
438		-	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
439	443		}
440	444
441	445		cret := xLogSetHandler(LogDomainVar, LogLevelsVar, LogFuncVarRef, UserDataVar)

@@ -453,30 +457,34 @@ var xLogSetHandlerFull func(string, LogLevelFlags, uintptr, uintptr, uintptr) ui
453	457		// application domain.
454	458		func LogSetHandlerFull(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar LogFunc, UserDataVar uintptr, DestroyVar DestroyNotify) uint {
455	459
456		-	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
457	460		var LogFuncVarRef uintptr
458		-	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
459		-	LogFuncVarRef = cbRefPtr
460		-	} else {
461		-	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
462		-	cbFn := *LogFuncVar
463		-	cbFn(arg0, arg1, arg2, arg3)
	461	+	if LogFuncVar != nil {
	462	+	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
	463	+	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
	464	+	LogFuncVarRef = cbRefPtr
	465	+	} else {
	466	+	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
	467	+	cbFn := *LogFuncVar
	468	+	cbFn(arg0, arg1, arg2, arg3)
	469	+	}
	470	+	LogFuncVarRef = purego.NewCallback(fcb)
	471	+	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
464	472		}
465		-	LogFuncVarRef = purego.NewCallback(fcb)
466		-	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
467	473		}
468	474
469		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
470	475		var DestroyVarRef uintptr
471		-	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
472		-	DestroyVarRef = cbRefPtr
473		-	} else {
474		-	fcb := func(arg0 uintptr) {
475		-	cbFn := *DestroyVar
476		-	cbFn(arg0)
	476	+	if DestroyVar != nil {
	477	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	478	+	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
	479	+	DestroyVarRef = cbRefPtr
	480	+	} else {
	481	+	fcb := func(arg0 uintptr) {
	482	+	cbFn := *DestroyVar
	483	+	cbFn(arg0)
	484	+	}
	485	+	DestroyVarRef = purego.NewCallback(fcb)
	486	+	SaveCallback(DestroyVarPtr, DestroyVarRef)
477	487		}
478		-	DestroyVarRef = purego.NewCallback(fcb)
479		-	SaveCallback(DestroyVarPtr, DestroyVarRef)
480	488		}
481	489
482	490		cret := xLogSetHandlerFull(LogDomainVar, LogLevelsVar, LogFuncVarRef, UserDataVar, DestroyVarRef)

@@ -498,30 +506,34 @@ var xLogSetWriterFunc func(uintptr, uintptr, uintptr)
498	506		// There can only be one writer function. It is an error to set more than one.
499	507		func LogSetWriterFunc(FuncVar LogWriterFunc, UserDataVar uintptr, UserDataFreeVar DestroyNotify) {
500	508
501		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
502	509		var FuncVarRef uintptr
503		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
504		-	FuncVarRef = cbRefPtr
505		-	} else {
506		-	fcb := func(arg0 LogLevelFlags, arg1 []LogField, arg2 uint, arg3 uintptr) LogWriterOutput {
507		-	cbFn := *FuncVar
508		-	return cbFn(arg0, arg1, arg2, arg3)
	510	+	if FuncVar != nil {
	511	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	512	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	513	+	FuncVarRef = cbRefPtr
	514	+	} else {
	515	+	fcb := func(arg0 LogLevelFlags, arg1 []LogField, arg2 uint, arg3 uintptr) LogWriterOutput {
	516	+	cbFn := *FuncVar
	517	+	return cbFn(arg0, arg1, arg2, arg3)
	518	+	}
	519	+	FuncVarRef = purego.NewCallback(fcb)
	520	+	SaveCallback(FuncVarPtr, FuncVarRef)
509	521		}
510		-	FuncVarRef = purego.NewCallback(fcb)
511		-	SaveCallback(FuncVarPtr, FuncVarRef)
512	522		}
513	523
514		-	UserDataFreeVarPtr := uintptr(unsafe.Pointer(UserDataFreeVar))
515	524		var UserDataFreeVarRef uintptr
516		-	if cbRefPtr, ok := GetCallback(UserDataFreeVarPtr); ok {
517		-	UserDataFreeVarRef = cbRefPtr
518		-	} else {
519		-	fcb := func(arg0 uintptr) {
520		-	cbFn := *UserDataFreeVar
521		-	cbFn(arg0)
	525	+	if UserDataFreeVar != nil {
	526	+	UserDataFreeVarPtr := uintptr(unsafe.Pointer(UserDataFreeVar))
	527	+	if cbRefPtr, ok := GetCallback(UserDataFreeVarPtr); ok {
	528	+	UserDataFreeVarRef = cbRefPtr
	529	+	} else {
	530	+	fcb := func(arg0 uintptr) {
	531	+	cbFn := *UserDataFreeVar
	532	+	cbFn(arg0)
	533	+	}
	534	+	UserDataFreeVarRef = purego.NewCallback(fcb)
	535	+	SaveCallback(UserDataFreeVarPtr, UserDataFreeVarRef)
522	536		}
523		-	UserDataFreeVarRef = purego.NewCallback(fcb)
524		-	SaveCallback(UserDataFreeVarPtr, UserDataFreeVarRef)
525	537		}
526	538
527	539		xLogSetWriterFunc(FuncVarRef, UserDataVar, UserDataFreeVarRef)

M v4/glib/gnode.go +33 -27


@@ -67,17 +67,19 @@ var xNodeChildrenForeach func(uintptr, TraverseFlags, uintptr, uintptr)
67	67		// that would modify the structure of the tree.
68	68		func (x Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar NodeForeachFunc, DataVar uintptr) {
69	69
70		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
71	70		var FuncVarRef uintptr
72		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
73		-	FuncVarRef = cbRefPtr
74		-	} else {
75		-	fcb := func(arg0 *Node, arg1 uintptr) {
76		-	cbFn := *FuncVar
77		-	cbFn(arg0, arg1)
	71	+	if FuncVar != nil {
	72	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	73	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	74	+	FuncVarRef = cbRefPtr
	75	+	} else {
	76	+	fcb := func(arg0 *Node, arg1 uintptr) {
	77	+	cbFn := *FuncVar
	78	+	cbFn(arg0, arg1)
	79	+	}
	80	+	FuncVarRef = purego.NewCallback(fcb)
	81	+	SaveCallback(FuncVarPtr, FuncVarRef)
78	82		}
79		-	FuncVarRef = purego.NewCallback(fcb)
80		-	SaveCallback(FuncVarPtr, FuncVarRef)
81	83		}
82	84
83	85		xNodeChildrenForeach(x.GoPointer(), FlagsVar, FuncVarRef, DataVar)

@@ -99,17 +101,19 @@ var xNodeCopyDeep func(uintptr, uintptr, uintptr) *Node
99	101		// Recursively copies a #GNode and its data.
100	102		func (x Node) CopyDeep(CopyFuncVar CopyFunc, DataVar uintptr) *Node {
101	103
102		-	CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
103	104		var CopyFuncVarRef uintptr
104		-	if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
105		-	CopyFuncVarRef = cbRefPtr
106		-	} else {
107		-	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
108		-	cbFn := *CopyFuncVar
109		-	return cbFn(arg0, arg1)
	105	+	if CopyFuncVar != nil {
	106	+	CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
	107	+	if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
	108	+	CopyFuncVarRef = cbRefPtr
	109	+	} else {
	110	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
	111	+	cbFn := *CopyFuncVar
	112	+	return cbFn(arg0, arg1)
	113	+	}
	114	+	CopyFuncVarRef = purego.NewCallback(fcb)
	115	+	SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
110	116		}
111		-	CopyFuncVarRef = purego.NewCallback(fcb)
112		-	SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
113	117		}
114	118
115	119		cret := xNodeCopyDeep(x.GoPointer(), CopyFuncVarRef, DataVar)

@@ -301,17 +305,19 @@ var xNodeTraverse func(uintptr, TraverseType, TraverseFlags, int, uintptr, uintp
301	305		// @func must not do anything that would modify the structure of the tree.
302	306		func (x Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar NodeTraverseFunc, DataVar uintptr) {
303	307
304		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
305	308		var FuncVarRef uintptr
306		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
307		-	FuncVarRef = cbRefPtr
308		-	} else {
309		-	fcb := func(arg0 *Node, arg1 uintptr) bool {
310		-	cbFn := *FuncVar
311		-	return cbFn(arg0, arg1)
	309	+	if FuncVar != nil {
	310	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	311	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	312	+	FuncVarRef = cbRefPtr
	313	+	} else {
	314	+	fcb := func(arg0 *Node, arg1 uintptr) bool {
	315	+	cbFn := *FuncVar
	316	+	return cbFn(arg0, arg1)
	317	+	}
	318	+	FuncVarRef = purego.NewCallback(fcb)
	319	+	SaveCallback(FuncVarPtr, FuncVarRef)
312	320		}
313		-	FuncVarRef = purego.NewCallback(fcb)
314		-	SaveCallback(FuncVarPtr, FuncVarRef)
315	321		}
316	322
317	323		xNodeTraverse(x.GoPointer(), OrderVar, FlagsVar, MaxDepthVar, FuncVarRef, DataVar)

M v4/glib/goption.go +11 -9


@@ -490,17 +490,19 @@ var xOptionGroupSetErrorHook func(uintptr, uintptr)
490	490		// specified when constructing the group with g_option_group_new().
491	491		func (x OptionGroup) SetErrorHook(ErrorFuncVar OptionErrorFunc) {
492	492
493		-	ErrorFuncVarPtr := uintptr(unsafe.Pointer(ErrorFuncVar))
494	493		var ErrorFuncVarRef uintptr
495		-	if cbRefPtr, ok := GetCallback(ErrorFuncVarPtr); ok {
496		-	ErrorFuncVarRef = cbRefPtr
497		-	} else {
498		-	fcb := func(arg0 OptionContext, arg1 OptionGroup, arg2 uintptr, arg3 **Error) {
499		-	cbFn := *ErrorFuncVar
500		-	cbFn(arg0, arg1, arg2, arg3)
	494	+	if ErrorFuncVar != nil {
	495	+	ErrorFuncVarPtr := uintptr(unsafe.Pointer(ErrorFuncVar))
	496	+	if cbRefPtr, ok := GetCallback(ErrorFuncVarPtr); ok {
	497	+	ErrorFuncVarRef = cbRefPtr
	498	+	} else {
	499	+	fcb := func(arg0 OptionContext, arg1 OptionGroup, arg2 uintptr, arg3 **Error) {
	500	+	cbFn := *ErrorFuncVar
	501	+	cbFn(arg0, arg1, arg2, arg3)
	502	+	}
	503	+	ErrorFuncVarRef = purego.NewCallback(fcb)
	504	+	SaveCallback(ErrorFuncVarPtr, ErrorFuncVarRef)
501	505		}
502		-	ErrorFuncVarRef = purego.NewCallback(fcb)
503		-	SaveCallback(ErrorFuncVarPtr, ErrorFuncVarRef)
504	506		}
505	507
506	508		xOptionGroupSetErrorHook(x.GoPointer(), ErrorFuncVarRef)

M v4/glib/gqsort.go +22 -18


@@ -17,17 +17,19 @@ var xQsortWithData func(uintptr, int, uint, uintptr, uintptr)
17	17		// Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).
18	18		func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
19	19
20		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
21	20		var CompareFuncVarRef uintptr
22		-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
23		-	CompareFuncVarRef = cbRefPtr
24		-	} else {
25		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
26		-	cbFn := *CompareFuncVar
27		-	return cbFn(arg0, arg1, arg2)
	21	+	if CompareFuncVar != nil {
	22	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	23	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
	24	+	CompareFuncVarRef = cbRefPtr
	25	+	} else {
	26	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	27	+	cbFn := *CompareFuncVar
	28	+	return cbFn(arg0, arg1, arg2)
	29	+	}
	30	+	CompareFuncVarRef = purego.NewCallback(fcb)
	31	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
28	32		}
29		-	CompareFuncVarRef = purego.NewCallback(fcb)
30		-	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
31	33		}
32	34
33	35		xQsortWithData(PbaseVar, TotalElemsVar, SizeVar, CompareFuncVarRef, UserDataVar)

@@ -43,17 +45,19 @@ var xSortArray func([]uintptr, uint, uint, uintptr, uintptr)
43	45		// Unlike `qsort()`, this is guaranteed to be a stable sort.
44	46		func SortArray(ArrayVar []uintptr, NElementsVar uint, ElementSizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
45	47
46		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
47	48		var CompareFuncVarRef uintptr
48		-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
49		-	CompareFuncVarRef = cbRefPtr
50		-	} else {
51		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
52		-	cbFn := *CompareFuncVar
53		-	return cbFn(arg0, arg1, arg2)
	49	+	if CompareFuncVar != nil {
	50	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	51	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
	52	+	CompareFuncVarRef = cbRefPtr
	53	+	} else {
	54	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	55	+	cbFn := *CompareFuncVar
	56	+	return cbFn(arg0, arg1, arg2)
	57	+	}
	58	+	CompareFuncVarRef = purego.NewCallback(fcb)
	59	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
54	60		}
55		-	CompareFuncVarRef = purego.NewCallback(fcb)
56		-	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
57	61		}
58	62
59	63		xSortArray(ArrayVar, NElementsVar, ElementSizeVar, CompareFuncVarRef, UserDataVar)

M v4/glib/gqueue.go +55 -45


@@ -100,17 +100,19 @@ var xQueueFindCustom func(uintptr, uintptr, uintptr) *List
100	100		// first argument and the given user data as the second argument.
101	101		func (x Queue) FindCustom(DataVar uintptr, FuncVar CompareFunc) *List {
102	102
103		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
104	103		var FuncVarRef uintptr
105		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
106		-	FuncVarRef = cbRefPtr
107		-	} else {
108		-	fcb := func(arg0 uintptr, arg1 uintptr) int {
109		-	cbFn := *FuncVar
110		-	return cbFn(arg0, arg1)
	104	+	if FuncVar != nil {
	105	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	106	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	107	+	FuncVarRef = cbRefPtr
	108	+	} else {
	109	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
	110	+	cbFn := *FuncVar
	111	+	return cbFn(arg0, arg1)
	112	+	}
	113	+	FuncVarRef = purego.NewCallback(fcb)
	114	+	SaveCallback(FuncVarPtr, FuncVarRef)
111	115		}
112		-	FuncVarRef = purego.NewCallback(fcb)
113		-	SaveCallback(FuncVarPtr, FuncVarRef)
114	116		}
115	117
116	118		cret := xQueueFindCustom(x.GoPointer(), DataVar, FuncVarRef)

@@ -126,17 +128,19 @@ var xQueueForeach func(uintptr, uintptr, uintptr)
126	128		// not modify any part of the queue after that element.
127	129		func (x Queue) Foreach(FuncVar Func, UserDataVar uintptr) {
128	130
129		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
130	131		var FuncVarRef uintptr
131		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
132		-	FuncVarRef = cbRefPtr
133		-	} else {
134		-	fcb := func(arg0 uintptr, arg1 uintptr) {
135		-	cbFn := *FuncVar
136		-	cbFn(arg0, arg1)
	132	+	if FuncVar != nil {
	133	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	134	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	135	+	FuncVarRef = cbRefPtr
	136	+	} else {
	137	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	138	+	cbFn := *FuncVar
	139	+	cbFn(arg0, arg1)
	140	+	}
	141	+	FuncVarRef = purego.NewCallback(fcb)
	142	+	SaveCallback(FuncVarPtr, FuncVarRef)
137	143		}
138		-	FuncVarRef = purego.NewCallback(fcb)
139		-	SaveCallback(FuncVarPtr, FuncVarRef)
140	144		}
141	145
142	146		xQueueForeach(x.GoPointer(), FuncVarRef, UserDataVar)

@@ -166,17 +170,19 @@ var xQueueFreeFull func(uintptr, uintptr)
166	170		// element from it).
167	171		func (x Queue) FreeFull(FreeFuncVar DestroyNotify) {
168	172
169		-	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
170	173		var FreeFuncVarRef uintptr
171		-	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
172		-	FreeFuncVarRef = cbRefPtr
173		-	} else {
174		-	fcb := func(arg0 uintptr) {
175		-	cbFn := *FreeFuncVar
176		-	cbFn(arg0)
	174	+	if FreeFuncVar != nil {
	175	+	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
	176	+	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
	177	+	FreeFuncVarRef = cbRefPtr
	178	+	} else {
	179	+	fcb := func(arg0 uintptr) {
	180	+	cbFn := *FreeFuncVar
	181	+	cbFn(arg0)
	182	+	}
	183	+	FreeFuncVarRef = purego.NewCallback(fcb)
	184	+	SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
177	185		}
178		-	FreeFuncVarRef = purego.NewCallback(fcb)
179		-	SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
180	186		}
181	187
182	188		xQueueFreeFull(x.GoPointer(), FreeFuncVarRef)

@@ -264,17 +270,19 @@ var xQueueInsertSorted func(uintptr, uintptr, uintptr, uintptr)
264	270		// Inserts @data into @queue using @func to determine the new position.
265	271		func (x Queue) InsertSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
266	272
267		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
268	273		var FuncVarRef uintptr
269		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
270		-	FuncVarRef = cbRefPtr
271		-	} else {
272		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
273		-	cbFn := *FuncVar
274		-	return cbFn(arg0, arg1, arg2)
	274	+	if FuncVar != nil {
	275	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	276	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	277	+	FuncVarRef = cbRefPtr
	278	+	} else {
	279	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	280	+	cbFn := *FuncVar
	281	+	return cbFn(arg0, arg1, arg2)
	282	+	}
	283	+	FuncVarRef = purego.NewCallback(fcb)
	284	+	SaveCallback(FuncVarPtr, FuncVarRef)
275	285		}
276		-	FuncVarRef = purego.NewCallback(fcb)
277		-	SaveCallback(FuncVarPtr, FuncVarRef)
278	286		}
279	287
280	288		xQueueInsertSorted(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)

@@ -493,17 +501,19 @@ var xQueueSort func(uintptr, uintptr, uintptr)
493	501		// Sorts @queue using @compare_func.
494	502		func (x Queue) Sort(CompareFuncVar CompareDataFunc, UserDataVar uintptr) {
495	503
496		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
497	504		var CompareFuncVarRef uintptr
498		-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
499		-	CompareFuncVarRef = cbRefPtr
500		-	} else {
501		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
502		-	cbFn := *CompareFuncVar
503		-	return cbFn(arg0, arg1, arg2)
	505	+	if CompareFuncVar != nil {
	506	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	507	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
	508	+	CompareFuncVarRef = cbRefPtr
	509	+	} else {
	510	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	511	+	cbFn := *CompareFuncVar
	512	+	return cbFn(arg0, arg1, arg2)
	513	+	}
	514	+	CompareFuncVarRef = purego.NewCallback(fcb)
	515	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
504	516		}
505		-	CompareFuncVarRef = purego.NewCallback(fcb)
506		-	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
507	517		}
508	518
509	519		xQueueSort(x.GoPointer(), CompareFuncVarRef, UserDataVar)

M v4/glib/grcbox.go +22 -18


@@ -97,17 +97,19 @@ var xAtomicRcBoxReleaseFull func(uintptr, uintptr)
97	97		// when the callback is called and will be freed.
98	98		func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
99	99
100		-	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
101	100		var ClearFuncVarRef uintptr
102		-	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
103		-	ClearFuncVarRef = cbRefPtr
104		-	} else {
105		-	fcb := func(arg0 uintptr) {
106		-	cbFn := *ClearFuncVar
107		-	cbFn(arg0)
	101	+	if ClearFuncVar != nil {
	102	+	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
	103	+	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
	104	+	ClearFuncVarRef = cbRefPtr
	105	+	} else {
	106	+	fcb := func(arg0 uintptr) {
	107	+	cbFn := *ClearFuncVar
	108	+	cbFn(arg0)
	109	+	}
	110	+	ClearFuncVarRef = purego.NewCallback(fcb)
	111	+	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
108	112		}
109		-	ClearFuncVarRef = purego.NewCallback(fcb)
110		-	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
111	113		}
112	114
113	115		xAtomicRcBoxReleaseFull(MemBlockVar, ClearFuncVarRef)

@@ -198,17 +200,19 @@ var xRcBoxReleaseFull func(uintptr, uintptr)
198	200		// resources allocated for @mem_block.
199	201		func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
200	202
201		-	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
202	203		var ClearFuncVarRef uintptr
203		-	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
204		-	ClearFuncVarRef = cbRefPtr
205		-	} else {
206		-	fcb := func(arg0 uintptr) {
207		-	cbFn := *ClearFuncVar
208		-	cbFn(arg0)
	204	+	if ClearFuncVar != nil {
	205	+	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
	206	+	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
	207	+	ClearFuncVarRef = cbRefPtr
	208	+	} else {
	209	+	fcb := func(arg0 uintptr) {
	210	+	cbFn := *ClearFuncVar
	211	+	cbFn(arg0)
	212	+	}
	213	+	ClearFuncVarRef = purego.NewCallback(fcb)
	214	+	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
209	215		}
210		-	ClearFuncVarRef = purego.NewCallback(fcb)
211		-	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
212	216		}
213	217
214	218		xRcBoxReleaseFull(MemBlockVar, ClearFuncVarRef)

M v4/glib/gregex.go +11 -9


@@ -1028,17 +1028,19 @@ var xRegexReplaceEval func(uintptr, []string, int, int, RegexMatchFlags, uintptr
1028	1028		func (x Regex) ReplaceEval(StringVar []string, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar RegexEvalCallback, UserDataVar uintptr) (string, error) {
1029	1029		var cerr *Error
1030	1030
1031		-	EvalVarPtr := uintptr(unsafe.Pointer(EvalVar))
1032	1031		var EvalVarRef uintptr
1033		-	if cbRefPtr, ok := GetCallback(EvalVarPtr); ok {
1034		-	EvalVarRef = cbRefPtr
1035		-	} else {
1036		-	fcb := func(arg0 MatchInfo, arg1 String, arg2 uintptr) bool {
1037		-	cbFn := *EvalVar
1038		-	return cbFn(arg0, arg1, arg2)
	1032	+	if EvalVar != nil {
	1033	+	EvalVarPtr := uintptr(unsafe.Pointer(EvalVar))
	1034	+	if cbRefPtr, ok := GetCallback(EvalVarPtr); ok {
	1035	+	EvalVarRef = cbRefPtr
	1036	+	} else {
	1037	+	fcb := func(arg0 MatchInfo, arg1 String, arg2 uintptr) bool {
	1038	+	cbFn := *EvalVar
	1039	+	return cbFn(arg0, arg1, arg2)
	1040	+	}
	1041	+	EvalVarRef = purego.NewCallback(fcb)
	1042	+	SaveCallback(EvalVarPtr, EvalVarRef)
1039	1043		}
1040		-	EvalVarRef = purego.NewCallback(fcb)
1041		-	SaveCallback(EvalVarPtr, EvalVarRef)
1042	1044		}
1043	1045
1044	1046		cret := xRegexReplaceEval(x.GoPointer(), StringVar, StringLenVar, StartPositionVar, MatchOptionsVar, EvalVarRef, UserDataVar, &cerr)

M v4/glib/grel.go +22 -18


@@ -104,30 +104,34 @@ var xRelationIndex func(uintptr, int, uintptr, uintptr)
104	104		// before any records are added to the #GRelation.
105	105		func (x Relation) Index(FieldVar int, HashFuncVar HashFunc, KeyEqualFuncVar *EqualFunc) {
106	106
107		-	HashFuncVarPtr := uintptr(unsafe.Pointer(HashFuncVar))
108	107		var HashFuncVarRef uintptr
109		-	if cbRefPtr, ok := GetCallback(HashFuncVarPtr); ok {
110		-	HashFuncVarRef = cbRefPtr
111		-	} else {
112		-	fcb := func(arg0 uintptr) uint {
113		-	cbFn := *HashFuncVar
114		-	return cbFn(arg0)
	108	+	if HashFuncVar != nil {
	109	+	HashFuncVarPtr := uintptr(unsafe.Pointer(HashFuncVar))
	110	+	if cbRefPtr, ok := GetCallback(HashFuncVarPtr); ok {
	111	+	HashFuncVarRef = cbRefPtr
	112	+	} else {
	113	+	fcb := func(arg0 uintptr) uint {
	114	+	cbFn := *HashFuncVar
	115	+	return cbFn(arg0)
	116	+	}
	117	+	HashFuncVarRef = purego.NewCallback(fcb)
	118	+	SaveCallback(HashFuncVarPtr, HashFuncVarRef)
115	119		}
116		-	HashFuncVarRef = purego.NewCallback(fcb)
117		-	SaveCallback(HashFuncVarPtr, HashFuncVarRef)
118	120		}
119	121
120		-	KeyEqualFuncVarPtr := uintptr(unsafe.Pointer(KeyEqualFuncVar))
121	122		var KeyEqualFuncVarRef uintptr
122		-	if cbRefPtr, ok := GetCallback(KeyEqualFuncVarPtr); ok {
123		-	KeyEqualFuncVarRef = cbRefPtr
124		-	} else {
125		-	fcb := func(arg0 uintptr, arg1 uintptr) bool {
126		-	cbFn := *KeyEqualFuncVar
127		-	return cbFn(arg0, arg1)
	123	+	if KeyEqualFuncVar != nil {
	124	+	KeyEqualFuncVarPtr := uintptr(unsafe.Pointer(KeyEqualFuncVar))
	125	+	if cbRefPtr, ok := GetCallback(KeyEqualFuncVarPtr); ok {
	126	+	KeyEqualFuncVarRef = cbRefPtr
	127	+	} else {
	128	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
	129	+	cbFn := *KeyEqualFuncVar
	130	+	return cbFn(arg0, arg1)
	131	+	}
	132	+	KeyEqualFuncVarRef = purego.NewCallback(fcb)
	133	+	SaveCallback(KeyEqualFuncVarPtr, KeyEqualFuncVarRef)
128	134		}
129		-	KeyEqualFuncVarRef = purego.NewCallback(fcb)
130		-	SaveCallback(KeyEqualFuncVarPtr, KeyEqualFuncVarRef)
131	135		}
132	136
133	137		xRelationIndex(x.GoPointer(), FieldVar, HashFuncVarRef, KeyEqualFuncVarRef)

M v4/glib/gscanner.go +11 -9


@@ -223,17 +223,19 @@ var xScannerScopeForeachSymbol func(uintptr, uint, uintptr, uintptr)
223	223		// parameter.
224	224		func (x Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar HFunc, UserDataVar uintptr) {
225	225
226		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
227	226		var FuncVarRef uintptr
228		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
229		-	FuncVarRef = cbRefPtr
230		-	} else {
231		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
232		-	cbFn := *FuncVar
233		-	cbFn(arg0, arg1, arg2)
	227	+	if FuncVar != nil {
	228	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	229	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	230	+	FuncVarRef = cbRefPtr
	231	+	} else {
	232	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
	233	+	cbFn := *FuncVar
	234	+	cbFn(arg0, arg1, arg2)
	235	+	}
	236	+	FuncVarRef = purego.NewCallback(fcb)
	237	+	SaveCallback(FuncVarPtr, FuncVarRef)
234	238		}
235		-	FuncVarRef = purego.NewCallback(fcb)
236		-	SaveCallback(FuncVarPtr, FuncVarRef)
237	239		}
238	240
239	241		xScannerScopeForeachSymbol(x.GoPointer(), ScopeIdVar, FuncVarRef, UserDataVar)

M v4/glib/gsequence.go +132 -108


@@ -39,17 +39,19 @@ var xSequenceForeach func(uintptr, uintptr, uintptr)
39	39		// to the function. @func must not modify the sequence itself.
40	40		func (x Sequence) Foreach(FuncVar Func, UserDataVar uintptr) {
41	41
42		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
43	42		var FuncVarRef uintptr
44		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
45		-	FuncVarRef = cbRefPtr
46		-	} else {
47		-	fcb := func(arg0 uintptr, arg1 uintptr) {
48		-	cbFn := *FuncVar
49		-	cbFn(arg0, arg1)
	43	+	if FuncVar != nil {
	44	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	45	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	46	+	FuncVarRef = cbRefPtr
	47	+	} else {
	48	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	49	+	cbFn := *FuncVar
	50	+	cbFn(arg0, arg1)
	51	+	}
	52	+	FuncVarRef = purego.NewCallback(fcb)
	53	+	SaveCallback(FuncVarPtr, FuncVarRef)
50	54		}
51		-	FuncVarRef = purego.NewCallback(fcb)
52		-	SaveCallback(FuncVarPtr, FuncVarRef)
53	55		}
54	56
55	57		xSequenceForeach(x.GoPointer(), FuncVarRef, UserDataVar)

@@ -122,17 +124,19 @@ var xSequenceInsertSorted func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
122	124		// g_sequence_sort() or g_sequence_sort_iter().
123	125		func (x Sequence) InsertSorted(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
124	126
125		-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
126	127		var CmpFuncVarRef uintptr
127		-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
128		-	CmpFuncVarRef = cbRefPtr
129		-	} else {
130		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
131		-	cbFn := *CmpFuncVar
132		-	return cbFn(arg0, arg1, arg2)
	128	+	if CmpFuncVar != nil {
	129	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
	130	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
	131	+	CmpFuncVarRef = cbRefPtr
	132	+	} else {
	133	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	134	+	cbFn := *CmpFuncVar
	135	+	return cbFn(arg0, arg1, arg2)
	136	+	}
	137	+	CmpFuncVarRef = purego.NewCallback(fcb)
	138	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
133	139		}
134		-	CmpFuncVarRef = purego.NewCallback(fcb)
135		-	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
136	140		}
137	141
138	142		cret := xSequenceInsertSorted(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)

@@ -155,17 +159,19 @@ var xSequenceInsertSortedIter func(uintptr, uintptr, uintptr, uintptr) *Sequence
155	159		// g_sequence_sort() or g_sequence_sort_iter().
156	160		func (x Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
157	161
158		-	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
159	162		var IterCmpVarRef uintptr
160		-	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
161		-	IterCmpVarRef = cbRefPtr
162		-	} else {
163		-	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
164		-	cbFn := *IterCmpVar
165		-	return cbFn(arg0, arg1, arg2)
	163	+	if IterCmpVar != nil {
	164	+	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
	165	+	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
	166	+	IterCmpVarRef = cbRefPtr
	167	+	} else {
	168	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
	169	+	cbFn := *IterCmpVar
	170	+	return cbFn(arg0, arg1, arg2)
	171	+	}
	172	+	IterCmpVarRef = purego.NewCallback(fcb)
	173	+	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
166	174		}
167		-	IterCmpVarRef = purego.NewCallback(fcb)
168		-	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
169	175		}
170	176
171	177		cret := xSequenceInsertSortedIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)

@@ -202,17 +208,19 @@ var xSequenceLookup func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
202	208		// unsorted.
203	209		func (x Sequence) Lookup(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
204	210
205		-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
206	211		var CmpFuncVarRef uintptr
207		-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
208		-	CmpFuncVarRef = cbRefPtr
209		-	} else {
210		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
211		-	cbFn := *CmpFuncVar
212		-	return cbFn(arg0, arg1, arg2)
	212	+	if CmpFuncVar != nil {
	213	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
	214	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
	215	+	CmpFuncVarRef = cbRefPtr
	216	+	} else {
	217	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	218	+	cbFn := *CmpFuncVar
	219	+	return cbFn(arg0, arg1, arg2)
	220	+	}
	221	+	CmpFuncVarRef = purego.NewCallback(fcb)
	222	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
213	223		}
214		-	CmpFuncVarRef = purego.NewCallback(fcb)
215		-	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
216	224		}
217	225
218	226		cret := xSequenceLookup(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)

@@ -233,17 +241,19 @@ var xSequenceLookupIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
233	241		// unsorted.
234	242		func (x Sequence) LookupIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
235	243
236		-	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
237	244		var IterCmpVarRef uintptr
238		-	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
239		-	IterCmpVarRef = cbRefPtr
240		-	} else {
241		-	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
242		-	cbFn := *IterCmpVar
243		-	return cbFn(arg0, arg1, arg2)
	245	+	if IterCmpVar != nil {
	246	+	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
	247	+	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
	248	+	IterCmpVarRef = cbRefPtr
	249	+	} else {
	250	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
	251	+	cbFn := *IterCmpVar
	252	+	return cbFn(arg0, arg1, arg2)
	253	+	}
	254	+	IterCmpVarRef = purego.NewCallback(fcb)
	255	+	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
244	256		}
245		-	IterCmpVarRef = purego.NewCallback(fcb)
246		-	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
247	257		}
248	258
249	259		cret := xSequenceLookupIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)

@@ -276,17 +286,19 @@ var xSequenceSearch func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
276	286		// unsorted.
277	287		func (x Sequence) Search(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
278	288
279		-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
280	289		var CmpFuncVarRef uintptr
281		-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
282		-	CmpFuncVarRef = cbRefPtr
283		-	} else {
284		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
285		-	cbFn := *CmpFuncVar
286		-	return cbFn(arg0, arg1, arg2)
	290	+	if CmpFuncVar != nil {
	291	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
	292	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
	293	+	CmpFuncVarRef = cbRefPtr
	294	+	} else {
	295	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	296	+	cbFn := *CmpFuncVar
	297	+	return cbFn(arg0, arg1, arg2)
	298	+	}
	299	+	CmpFuncVarRef = purego.NewCallback(fcb)
	300	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
287	301		}
288		-	CmpFuncVarRef = purego.NewCallback(fcb)
289		-	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
290	302		}
291	303
292	304		cret := xSequenceSearch(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)

@@ -310,17 +322,19 @@ var xSequenceSearchIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
310	322		// unsorted.
311	323		func (x Sequence) SearchIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
312	324
313		-	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
314	325		var IterCmpVarRef uintptr
315		-	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
316		-	IterCmpVarRef = cbRefPtr
317		-	} else {
318		-	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
319		-	cbFn := *IterCmpVar
320		-	return cbFn(arg0, arg1, arg2)
	326	+	if IterCmpVar != nil {
	327	+	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
	328	+	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
	329	+	IterCmpVarRef = cbRefPtr
	330	+	} else {
	331	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
	332	+	cbFn := *IterCmpVar
	333	+	return cbFn(arg0, arg1, arg2)
	334	+	}
	335	+	IterCmpVarRef = purego.NewCallback(fcb)
	336	+	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
321	337		}
322		-	IterCmpVarRef = purego.NewCallback(fcb)
323		-	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
324	338		}
325	339
326	340		cret := xSequenceSearchIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)

@@ -337,17 +351,19 @@ var xSequenceSort func(uintptr, uintptr, uintptr)
337	351		// if the second comes before the first.
338	352		func (x Sequence) Sort(CmpFuncVar CompareDataFunc, CmpDataVar uintptr) {
339	353
340		-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
341	354		var CmpFuncVarRef uintptr
342		-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
343		-	CmpFuncVarRef = cbRefPtr
344		-	} else {
345		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
346		-	cbFn := *CmpFuncVar
347		-	return cbFn(arg0, arg1, arg2)
	355	+	if CmpFuncVar != nil {
	356	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
	357	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
	358	+	CmpFuncVarRef = cbRefPtr
	359	+	} else {
	360	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	361	+	cbFn := *CmpFuncVar
	362	+	return cbFn(arg0, arg1, arg2)
	363	+	}
	364	+	CmpFuncVarRef = purego.NewCallback(fcb)
	365	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
348	366		}
349		-	CmpFuncVarRef = purego.NewCallback(fcb)
350		-	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
351	367		}
352	368
353	369		xSequenceSort(x.GoPointer(), CmpFuncVarRef, CmpDataVar)

@@ -365,17 +381,19 @@ var xSequenceSortIter func(uintptr, uintptr, uintptr)
365	381		// iterator comes before the first.
366	382		func (x Sequence) SortIter(CmpFuncVar SequenceIterCompareFunc, CmpDataVar uintptr) {
367	383
368		-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
369	384		var CmpFuncVarRef uintptr
370		-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
371		-	CmpFuncVarRef = cbRefPtr
372		-	} else {
373		-	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
374		-	cbFn := *CmpFuncVar
375		-	return cbFn(arg0, arg1, arg2)
	385	+	if CmpFuncVar != nil {
	386	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
	387	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
	388	+	CmpFuncVarRef = cbRefPtr
	389	+	} else {
	390	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
	391	+	cbFn := *CmpFuncVar
	392	+	return cbFn(arg0, arg1, arg2)
	393	+	}
	394	+	CmpFuncVarRef = purego.NewCallback(fcb)
	395	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
376	396		}
377		-	CmpFuncVarRef = purego.NewCallback(fcb)
378		-	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
379	397		}
380	398
381	399		xSequenceSortIter(x.GoPointer(), CmpFuncVarRef, CmpDataVar)

@@ -479,17 +497,19 @@ var xSequenceForeachRange func(SequenceIter, SequenceIter, uintptr, uintptr)
479	497		// itself.
480	498		func SequenceForeachRange(BeginVar SequenceIter, EndVar SequenceIter, FuncVar *Func, UserDataVar uintptr) {
481	499
482		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
483	500		var FuncVarRef uintptr
484		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
485		-	FuncVarRef = cbRefPtr
486		-	} else {
487		-	fcb := func(arg0 uintptr, arg1 uintptr) {
488		-	cbFn := *FuncVar
489		-	cbFn(arg0, arg1)
	501	+	if FuncVar != nil {
	502	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	503	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	504	+	FuncVarRef = cbRefPtr
	505	+	} else {
	506	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	507	+	cbFn := *FuncVar
	508	+	cbFn(arg0, arg1)
	509	+	}
	510	+	FuncVarRef = purego.NewCallback(fcb)
	511	+	SaveCallback(FuncVarPtr, FuncVarRef)
490	512		}
491		-	FuncVarRef = purego.NewCallback(fcb)
492		-	SaveCallback(FuncVarPtr, FuncVarRef)
493	513		}
494	514
495	515		xSequenceForeachRange(BeginVar, EndVar, FuncVarRef, UserDataVar)

@@ -606,17 +626,19 @@ var xSequenceSortChanged func(*SequenceIter, uintptr, uintptr)
606	626		// the second item comes before the first.
607	627		func SequenceSortChanged(IterVar SequenceIter, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) {
608	628
609		-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
610	629		var CmpFuncVarRef uintptr
611		-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
612		-	CmpFuncVarRef = cbRefPtr
613		-	} else {
614		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
615		-	cbFn := *CmpFuncVar
616		-	return cbFn(arg0, arg1, arg2)
	630	+	if CmpFuncVar != nil {
	631	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
	632	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
	633	+	CmpFuncVarRef = cbRefPtr
	634	+	} else {
	635	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	636	+	cbFn := *CmpFuncVar
	637	+	return cbFn(arg0, arg1, arg2)
	638	+	}
	639	+	CmpFuncVarRef = purego.NewCallback(fcb)
	640	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
617	641		}
618		-	CmpFuncVarRef = purego.NewCallback(fcb)
619		-	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
620	642		}
621	643
622	644		xSequenceSortChanged(IterVar, CmpFuncVarRef, CmpDataVar)

@@ -636,17 +658,19 @@ var xSequenceSortChangedIter func(*SequenceIter, uintptr, uintptr)
636	658		// iterator comes before the first.
637	659		func SequenceSortChangedIter(IterVar SequenceIter, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) {
638	660
639		-	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
640	661		var IterCmpVarRef uintptr
641		-	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
642		-	IterCmpVarRef = cbRefPtr
643		-	} else {
644		-	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
645		-	cbFn := *IterCmpVar
646		-	return cbFn(arg0, arg1, arg2)
	662	+	if IterCmpVar != nil {
	663	+	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
	664	+	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
	665	+	IterCmpVarRef = cbRefPtr
	666	+	} else {
	667	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
	668	+	cbFn := *IterCmpVar
	669	+	return cbFn(arg0, arg1, arg2)
	670	+	}
	671	+	IterCmpVarRef = purego.NewCallback(fcb)
	672	+	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
647	673		}
648		-	IterCmpVarRef = purego.NewCallback(fcb)
649		-	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
650	674		}
651	675
652	676		xSequenceSortChangedIter(IterVar, IterCmpVarRef, CmpDataVar)

M v4/glib/gtestutils.go +132 -108


@@ -420,17 +420,19 @@ var xTestAddDataFunc func(string, uintptr, uintptr)
420	420		// and it is recommended to do so even if it isn’t.
421	421		func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc) {
422	422
423		-	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
424	423		var TestFuncVarRef uintptr
425		-	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
426		-	TestFuncVarRef = cbRefPtr
427		-	} else {
428		-	fcb := func(arg0 uintptr) {
429		-	cbFn := *TestFuncVar
430		-	cbFn(arg0)
	424	+	if TestFuncVar != nil {
	425	+	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
	426	+	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
	427	+	TestFuncVarRef = cbRefPtr
	428	+	} else {
	429	+	fcb := func(arg0 uintptr) {
	430	+	cbFn := *TestFuncVar
	431	+	cbFn(arg0)
	432	+	}
	433	+	TestFuncVarRef = purego.NewCallback(fcb)
	434	+	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
431	435		}
432		-	TestFuncVarRef = purego.NewCallback(fcb)
433		-	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
434	436		}
435	437
436	438		xTestAddDataFunc(TestpathVar, TestDataVar, TestFuncVarRef)

@@ -445,30 +447,34 @@ var xTestAddDataFuncFull func(string, uintptr, uintptr, uintptr)
445	447		// is freeing @test_data after the test run is complete.
446	448		func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar TestDataFunc, DataFreeFuncVar DestroyNotify) {
447	449
448		-	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
449	450		var TestFuncVarRef uintptr
450		-	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
451		-	TestFuncVarRef = cbRefPtr
452		-	} else {
453		-	fcb := func(arg0 uintptr) {
454		-	cbFn := *TestFuncVar
455		-	cbFn(arg0)
	451	+	if TestFuncVar != nil {
	452	+	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
	453	+	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
	454	+	TestFuncVarRef = cbRefPtr
	455	+	} else {
	456	+	fcb := func(arg0 uintptr) {
	457	+	cbFn := *TestFuncVar
	458	+	cbFn(arg0)
	459	+	}
	460	+	TestFuncVarRef = purego.NewCallback(fcb)
	461	+	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
456	462		}
457		-	TestFuncVarRef = purego.NewCallback(fcb)
458		-	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
459	463		}
460	464
461		-	DataFreeFuncVarPtr := uintptr(unsafe.Pointer(DataFreeFuncVar))
462	465		var DataFreeFuncVarRef uintptr
463		-	if cbRefPtr, ok := GetCallback(DataFreeFuncVarPtr); ok {
464		-	DataFreeFuncVarRef = cbRefPtr
465		-	} else {
466		-	fcb := func(arg0 uintptr) {
467		-	cbFn := *DataFreeFuncVar
468		-	cbFn(arg0)
	466	+	if DataFreeFuncVar != nil {
	467	+	DataFreeFuncVarPtr := uintptr(unsafe.Pointer(DataFreeFuncVar))
	468	+	if cbRefPtr, ok := GetCallback(DataFreeFuncVarPtr); ok {
	469	+	DataFreeFuncVarRef = cbRefPtr
	470	+	} else {
	471	+	fcb := func(arg0 uintptr) {
	472	+	cbFn := *DataFreeFuncVar
	473	+	cbFn(arg0)
	474	+	}
	475	+	DataFreeFuncVarRef = purego.NewCallback(fcb)
	476	+	SaveCallback(DataFreeFuncVarPtr, DataFreeFuncVarRef)
469	477		}
470		-	DataFreeFuncVarRef = purego.NewCallback(fcb)
471		-	SaveCallback(DataFreeFuncVarPtr, DataFreeFuncVarRef)
472	478		}
473	479
474	480		xTestAddDataFuncFull(TestpathVar, TestDataVar, TestFuncVarRef, DataFreeFuncVarRef)

@@ -493,17 +499,19 @@ var xTestAddFunc func(string, uintptr)
493	499		// it is recommended to do so even if it isn’t.
494	500		func TestAddFunc(TestpathVar string, TestFuncVar *TestFunc) {
495	501
496		-	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
497	502		var TestFuncVarRef uintptr
498		-	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
499		-	TestFuncVarRef = cbRefPtr
500		-	} else {
501		-	fcb := func() {
502		-	cbFn := *TestFuncVar
503		-	cbFn()
	503	+	if TestFuncVar != nil {
	504	+	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
	505	+	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
	506	+	TestFuncVarRef = cbRefPtr
	507	+	} else {
	508	+	fcb := func() {
	509	+	cbFn := *TestFuncVar
	510	+	cbFn()
	511	+	}
	512	+	TestFuncVarRef = purego.NewCallback(fcb)
	513	+	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
504	514		}
505		-	TestFuncVarRef = purego.NewCallback(fcb)
506		-	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
507	515		}
508	516
509	517		xTestAddFunc(TestpathVar, TestFuncVarRef)

@@ -514,43 +522,49 @@ var xTestAddVtable func(string, uint, uintptr, uintptr, uintptr, uintptr)
514	522
515	523		func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar *TestFixtureFunc) {
516	524
517		-	DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
518	525		var DataSetupVarRef uintptr
519		-	if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
520		-	DataSetupVarRef = cbRefPtr
521		-	} else {
522		-	fcb := func(arg0 uintptr, arg1 uintptr) {
523		-	cbFn := *DataSetupVar
524		-	cbFn(arg0, arg1)
	526	+	if DataSetupVar != nil {
	527	+	DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
	528	+	if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
	529	+	DataSetupVarRef = cbRefPtr
	530	+	} else {
	531	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	532	+	cbFn := *DataSetupVar
	533	+	cbFn(arg0, arg1)
	534	+	}
	535	+	DataSetupVarRef = purego.NewCallback(fcb)
	536	+	SaveCallback(DataSetupVarPtr, DataSetupVarRef)
525	537		}
526		-	DataSetupVarRef = purego.NewCallback(fcb)
527		-	SaveCallback(DataSetupVarPtr, DataSetupVarRef)
528	538		}
529	539
530		-	DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
531	540		var DataTestVarRef uintptr
532		-	if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
533		-	DataTestVarRef = cbRefPtr
534		-	} else {
535		-	fcb := func(arg0 uintptr, arg1 uintptr) {
536		-	cbFn := *DataTestVar
537		-	cbFn(arg0, arg1)
	541	+	if DataTestVar != nil {
	542	+	DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
	543	+	if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
	544	+	DataTestVarRef = cbRefPtr
	545	+	} else {
	546	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	547	+	cbFn := *DataTestVar
	548	+	cbFn(arg0, arg1)
	549	+	}
	550	+	DataTestVarRef = purego.NewCallback(fcb)
	551	+	SaveCallback(DataTestVarPtr, DataTestVarRef)
538	552		}
539		-	DataTestVarRef = purego.NewCallback(fcb)
540		-	SaveCallback(DataTestVarPtr, DataTestVarRef)
541	553		}
542	554
543		-	DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
544	555		var DataTeardownVarRef uintptr
545		-	if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
546		-	DataTeardownVarRef = cbRefPtr
547		-	} else {
548		-	fcb := func(arg0 uintptr, arg1 uintptr) {
549		-	cbFn := *DataTeardownVar
550		-	cbFn(arg0, arg1)
	556	+	if DataTeardownVar != nil {
	557	+	DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
	558	+	if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
	559	+	DataTeardownVarRef = cbRefPtr
	560	+	} else {
	561	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	562	+	cbFn := *DataTeardownVar
	563	+	cbFn(arg0, arg1)
	564	+	}
	565	+	DataTeardownVarRef = purego.NewCallback(fcb)
	566	+	SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
551	567		}
552		-	DataTeardownVarRef = purego.NewCallback(fcb)
553		-	SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
554	568		}
555	569
556	570		xTestAddVtable(TestpathVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)

@@ -657,43 +671,49 @@ var xTestCreateCase func(string, uint, uintptr, uintptr, uintptr, uintptr) *Test
657	671		// varying @test_name and @data_test arguments.
658	672		func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar TestFixtureFunc) TestCase {
659	673
660		-	DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
661	674		var DataSetupVarRef uintptr
662		-	if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
663		-	DataSetupVarRef = cbRefPtr
664		-	} else {
665		-	fcb := func(arg0 uintptr, arg1 uintptr) {
666		-	cbFn := *DataSetupVar
667		-	cbFn(arg0, arg1)
	675	+	if DataSetupVar != nil {
	676	+	DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
	677	+	if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
	678	+	DataSetupVarRef = cbRefPtr
	679	+	} else {
	680	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	681	+	cbFn := *DataSetupVar
	682	+	cbFn(arg0, arg1)
	683	+	}
	684	+	DataSetupVarRef = purego.NewCallback(fcb)
	685	+	SaveCallback(DataSetupVarPtr, DataSetupVarRef)
668	686		}
669		-	DataSetupVarRef = purego.NewCallback(fcb)
670		-	SaveCallback(DataSetupVarPtr, DataSetupVarRef)
671	687		}
672	688
673		-	DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
674	689		var DataTestVarRef uintptr
675		-	if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
676		-	DataTestVarRef = cbRefPtr
677		-	} else {
678		-	fcb := func(arg0 uintptr, arg1 uintptr) {
679		-	cbFn := *DataTestVar
680		-	cbFn(arg0, arg1)
	690	+	if DataTestVar != nil {
	691	+	DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
	692	+	if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
	693	+	DataTestVarRef = cbRefPtr
	694	+	} else {
	695	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	696	+	cbFn := *DataTestVar
	697	+	cbFn(arg0, arg1)
	698	+	}
	699	+	DataTestVarRef = purego.NewCallback(fcb)
	700	+	SaveCallback(DataTestVarPtr, DataTestVarRef)
681	701		}
682		-	DataTestVarRef = purego.NewCallback(fcb)
683		-	SaveCallback(DataTestVarPtr, DataTestVarRef)
684	702		}
685	703
686		-	DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
687	704		var DataTeardownVarRef uintptr
688		-	if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
689		-	DataTeardownVarRef = cbRefPtr
690		-	} else {
691		-	fcb := func(arg0 uintptr, arg1 uintptr) {
692		-	cbFn := *DataTeardownVar
693		-	cbFn(arg0, arg1)
	705	+	if DataTeardownVar != nil {
	706	+	DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
	707	+	if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
	708	+	DataTeardownVarRef = cbRefPtr
	709	+	} else {
	710	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	711	+	cbFn := *DataTeardownVar
	712	+	cbFn(arg0, arg1)
	713	+	}
	714	+	DataTeardownVarRef = purego.NewCallback(fcb)
	715	+	SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
694	716		}
695		-	DataTeardownVarRef = purego.NewCallback(fcb)
696		-	SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
697	717		}
698	718
699	719		cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)

@@ -1009,17 +1029,19 @@ var xTestLogSetFatalHandler func(uintptr, uintptr)
1009	1029		// [Using Structured Logging](logging.html#using-structured-logging).
1010	1030		func TestLogSetFatalHandler(LogFuncVar *TestLogFatalFunc, UserDataVar uintptr) {
1011	1031
1012		-	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
1013	1032		var LogFuncVarRef uintptr
1014		-	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
1015		-	LogFuncVarRef = cbRefPtr
1016		-	} else {
1017		-	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) bool {
1018		-	cbFn := *LogFuncVar
1019		-	return cbFn(arg0, arg1, arg2, arg3)
	1033	+	if LogFuncVar != nil {
	1034	+	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
	1035	+	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
	1036	+	LogFuncVarRef = cbRefPtr
	1037	+	} else {
	1038	+	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) bool {
	1039	+	cbFn := *LogFuncVar
	1040	+	return cbFn(arg0, arg1, arg2, arg3)
	1041	+	}
	1042	+	LogFuncVarRef = purego.NewCallback(fcb)
	1043	+	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
1020	1044		}
1021		-	LogFuncVarRef = purego.NewCallback(fcb)
1022		-	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
1023	1045		}
1024	1046
1025	1047		xTestLogSetFatalHandler(LogFuncVarRef, UserDataVar)

@@ -1082,17 +1104,19 @@ var xTestQueueDestroy func(uintptr, uintptr)
1082	1104		// before `A()` during teardown.
1083	1105		func TestQueueDestroy(DestroyFuncVar *DestroyNotify, DestroyDataVar uintptr) {
1084	1106
1085		-	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
1086	1107		var DestroyFuncVarRef uintptr
1087		-	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
1088		-	DestroyFuncVarRef = cbRefPtr
1089		-	} else {
1090		-	fcb := func(arg0 uintptr) {
1091		-	cbFn := *DestroyFuncVar
1092		-	cbFn(arg0)
	1108	+	if DestroyFuncVar != nil {
	1109	+	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
	1110	+	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
	1111	+	DestroyFuncVarRef = cbRefPtr
	1112	+	} else {
	1113	+	fcb := func(arg0 uintptr) {
	1114	+	cbFn := *DestroyFuncVar
	1115	+	cbFn(arg0)
	1116	+	}
	1117	+	DestroyFuncVarRef = purego.NewCallback(fcb)
	1118	+	SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
1093	1119		}
1094		-	DestroyFuncVarRef = purego.NewCallback(fcb)
1095		-	SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
1096	1120		}
1097	1121
1098	1122		xTestQueueDestroy(DestroyFuncVarRef, DestroyDataVar)

M v4/glib/gthread.go +88 -72


@@ -281,17 +281,19 @@ var xOnceImpl func(uintptr, uintptr, uintptr) uintptr
281	281
282	282		func (x Once) Impl(FuncVar ThreadFunc, ArgVar uintptr) uintptr {
283	283
284		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
285	284		var FuncVarRef uintptr
286		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
287		-	FuncVarRef = cbRefPtr
288		-	} else {
289		-	fcb := func(arg0 uintptr) uintptr {
290		-	cbFn := *FuncVar
291		-	return cbFn(arg0)
	285	+	if FuncVar != nil {
	286	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	287	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	288	+	FuncVarRef = cbRefPtr
	289	+	} else {
	290	+	fcb := func(arg0 uintptr) uintptr {
	291	+	cbFn := *FuncVar
	292	+	return cbFn(arg0)
	293	+	}
	294	+	FuncVarRef = purego.NewCallback(fcb)
	295	+	SaveCallback(FuncVarPtr, FuncVarRef)
292	296		}
293		-	FuncVarRef = purego.NewCallback(fcb)
294		-	SaveCallback(FuncVarPtr, FuncVarRef)
295	297		}
296	298
297	299		cret := xOnceImpl(x.GoPointer(), FuncVarRef, ArgVar)

@@ -872,17 +874,19 @@ var xStaticPrivateSet func(uintptr, uintptr, uintptr)
872	874		// @notify is used quite differently from @destructor in g_private_new().
873	875		func (x StaticPrivate) Set(DataVar uintptr, NotifyVar DestroyNotify) {
874	876
875		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
876	877		var NotifyVarRef uintptr
877		-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
878		-	NotifyVarRef = cbRefPtr
879		-	} else {
880		-	fcb := func(arg0 uintptr) {
881		-	cbFn := *NotifyVar
882		-	cbFn(arg0)
	878	+	if NotifyVar != nil {
	879	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	880	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
	881	+	NotifyVarRef = cbRefPtr
	882	+	} else {
	883	+	fcb := func(arg0 uintptr) {
	884	+	cbFn := *NotifyVar
	885	+	cbFn(arg0)
	886	+	}
	887	+	NotifyVarRef = purego.NewCallback(fcb)
	888	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
883	889		}
884		-	NotifyVarRef = purego.NewCallback(fcb)
885		-	SaveCallback(NotifyVarPtr, NotifyVarRef)
886	890		}
887	891
888	892		xStaticPrivateSet(x.GoPointer(), DataVar, NotifyVarRef)

@@ -1276,17 +1280,19 @@ var xNewThread func(string, uintptr, uintptr) *Thread
1276	1280		// POSIX and all threads inherit their parent thread's priority.
1277	1281		func NewThread(NameVar string, FuncVar ThreadFunc, DataVar uintptr) Thread {
1278	1282
1279		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1280	1283		var FuncVarRef uintptr
1281		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
1282		-	FuncVarRef = cbRefPtr
1283		-	} else {
1284		-	fcb := func(arg0 uintptr) uintptr {
1285		-	cbFn := *FuncVar
1286		-	return cbFn(arg0)
	1284	+	if FuncVar != nil {
	1285	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	1286	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	1287	+	FuncVarRef = cbRefPtr
	1288	+	} else {
	1289	+	fcb := func(arg0 uintptr) uintptr {
	1290	+	cbFn := *FuncVar
	1291	+	return cbFn(arg0)
	1292	+	}
	1293	+	FuncVarRef = purego.NewCallback(fcb)
	1294	+	SaveCallback(FuncVarPtr, FuncVarRef)
1287	1295		}
1288		-	FuncVarRef = purego.NewCallback(fcb)
1289		-	SaveCallback(FuncVarPtr, FuncVarRef)
1290	1296		}
1291	1297
1292	1298		cret := xNewThread(NameVar, FuncVarRef, DataVar)

@@ -1303,17 +1309,19 @@ var xThreadTryNew func(string, uintptr, uintptr, *Error) Thread
1303	1309		func ThreadTryNew(NameVar string, FuncVar ThreadFunc, DataVar uintptr) (Thread, error) {
1304	1310		var cerr *Error
1305	1311
1306		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1307	1312		var FuncVarRef uintptr
1308		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
1309		-	FuncVarRef = cbRefPtr
1310		-	} else {
1311		-	fcb := func(arg0 uintptr) uintptr {
1312		-	cbFn := *FuncVar
1313		-	return cbFn(arg0)
	1313	+	if FuncVar != nil {
	1314	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	1315	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	1316	+	FuncVarRef = cbRefPtr
	1317	+	} else {
	1318	+	fcb := func(arg0 uintptr) uintptr {
	1319	+	cbFn := *FuncVar
	1320	+	return cbFn(arg0)
	1321	+	}
	1322	+	FuncVarRef = purego.NewCallback(fcb)
	1323	+	SaveCallback(FuncVarPtr, FuncVarRef)
1314	1324		}
1315		-	FuncVarRef = purego.NewCallback(fcb)
1316		-	SaveCallback(FuncVarPtr, FuncVarRef)
1317	1325		}
1318	1326
1319	1327		cret := xThreadTryNew(NameVar, FuncVarRef, DataVar, &cerr)

@@ -2212,17 +2220,19 @@ var xPrivateNew func(uintptr) *Private
2212	2220		// Creates a new #GPrivate.
2213	2221		func PrivateNew(NotifyVar DestroyNotify) Private {
2214	2222
2215		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
2216	2223		var NotifyVarRef uintptr
2217		-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
2218		-	NotifyVarRef = cbRefPtr
2219		-	} else {
2220		-	fcb := func(arg0 uintptr) {
2221		-	cbFn := *NotifyVar
2222		-	cbFn(arg0)
	2224	+	if NotifyVar != nil {
	2225	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	2226	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
	2227	+	NotifyVarRef = cbRefPtr
	2228	+	} else {
	2229	+	fcb := func(arg0 uintptr) {
	2230	+	cbFn := *NotifyVar
	2231	+	cbFn(arg0)
	2232	+	}
	2233	+	NotifyVarRef = purego.NewCallback(fcb)
	2234	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
2223	2235		}
2224		-	NotifyVarRef = purego.NewCallback(fcb)
2225		-	SaveCallback(NotifyVarPtr, NotifyVarRef)
2226	2236		}
2227	2237
2228	2238		cret := xPrivateNew(NotifyVarRef)

@@ -2246,17 +2256,19 @@ var xThreadCreate func(uintptr, uintptr, bool, *Error) Thread
2246	2256		func ThreadCreate(FuncVar ThreadFunc, DataVar uintptr, JoinableVar bool) (Thread, error) {
2247	2257		var cerr *Error
2248	2258
2249		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
2250	2259		var FuncVarRef uintptr
2251		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
2252		-	FuncVarRef = cbRefPtr
2253		-	} else {
2254		-	fcb := func(arg0 uintptr) uintptr {
2255		-	cbFn := *FuncVar
2256		-	return cbFn(arg0)
	2260	+	if FuncVar != nil {
	2261	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	2262	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	2263	+	FuncVarRef = cbRefPtr
	2264	+	} else {
	2265	+	fcb := func(arg0 uintptr) uintptr {
	2266	+	cbFn := *FuncVar
	2267	+	return cbFn(arg0)
	2268	+	}
	2269	+	FuncVarRef = purego.NewCallback(fcb)
	2270	+	SaveCallback(FuncVarPtr, FuncVarRef)
2257	2271		}
2258		-	FuncVarRef = purego.NewCallback(fcb)
2259		-	SaveCallback(FuncVarPtr, FuncVarRef)
2260	2272		}
2261	2273
2262	2274		cret := xThreadCreate(FuncVarRef, DataVar, JoinableVar, &cerr)

@@ -2273,17 +2285,19 @@ var xThreadCreateFull func(uintptr, uintptr, uint32, bool, bool, ThreadPriority,
2273	2285		func ThreadCreateFull(FuncVar ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (Thread, error) {
2274	2286		var cerr *Error
2275	2287
2276		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
2277	2288		var FuncVarRef uintptr
2278		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
2279		-	FuncVarRef = cbRefPtr
2280		-	} else {
2281		-	fcb := func(arg0 uintptr) uintptr {
2282		-	cbFn := *FuncVar
2283		-	return cbFn(arg0)
	2289	+	if FuncVar != nil {
	2290	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	2291	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	2292	+	FuncVarRef = cbRefPtr
	2293	+	} else {
	2294	+	fcb := func(arg0 uintptr) uintptr {
	2295	+	cbFn := *FuncVar
	2296	+	return cbFn(arg0)
	2297	+	}
	2298	+	FuncVarRef = purego.NewCallback(fcb)
	2299	+	SaveCallback(FuncVarPtr, FuncVarRef)
2284	2300		}
2285		-	FuncVarRef = purego.NewCallback(fcb)
2286		-	SaveCallback(FuncVarPtr, FuncVarRef)
2287	2301		}
2288	2302
2289	2303		cret := xThreadCreateFull(FuncVarRef, DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, &cerr)

@@ -2330,17 +2344,19 @@ var xThreadForeach func(uintptr, uintptr)
2330	2344		// which is quadratic in the number of existing threads.
2331	2345		func ThreadForeach(ThreadFuncVar *Func, UserDataVar uintptr) {
2332	2346
2333		-	ThreadFuncVarPtr := uintptr(unsafe.Pointer(ThreadFuncVar))
2334	2347		var ThreadFuncVarRef uintptr
2335		-	if cbRefPtr, ok := GetCallback(ThreadFuncVarPtr); ok {
2336		-	ThreadFuncVarRef = cbRefPtr
2337		-	} else {
2338		-	fcb := func(arg0 uintptr, arg1 uintptr) {
2339		-	cbFn := *ThreadFuncVar
2340		-	cbFn(arg0, arg1)
	2348	+	if ThreadFuncVar != nil {
	2349	+	ThreadFuncVarPtr := uintptr(unsafe.Pointer(ThreadFuncVar))
	2350	+	if cbRefPtr, ok := GetCallback(ThreadFuncVarPtr); ok {
	2351	+	ThreadFuncVarRef = cbRefPtr
	2352	+	} else {
	2353	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	2354	+	cbFn := *ThreadFuncVar
	2355	+	cbFn(arg0, arg1)
	2356	+	}
	2357	+	ThreadFuncVarRef = purego.NewCallback(fcb)
	2358	+	SaveCallback(ThreadFuncVarPtr, ThreadFuncVarRef)
2341	2359		}
2342		-	ThreadFuncVarRef = purego.NewCallback(fcb)
2343		-	SaveCallback(ThreadFuncVarPtr, ThreadFuncVarRef)
2344	2360		}
2345	2361
2346	2362		xThreadForeach(ThreadFuncVarRef, UserDataVar)

M v4/glib/gthreadpool.go +11 -9


@@ -172,17 +172,19 @@ var xThreadPoolSetSortFunction func(uintptr, uintptr, uintptr)
172	172		// created.
173	173		func (x ThreadPool) SetSortFunction(FuncVar CompareDataFunc, UserDataVar uintptr) {
174	174
175		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
176	175		var FuncVarRef uintptr
177		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
178		-	FuncVarRef = cbRefPtr
179		-	} else {
180		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
181		-	cbFn := *FuncVar
182		-	return cbFn(arg0, arg1, arg2)
	176	+	if FuncVar != nil {
	177	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	178	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	179	+	FuncVarRef = cbRefPtr
	180	+	} else {
	181	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	182	+	cbFn := *FuncVar
	183	+	return cbFn(arg0, arg1, arg2)
	184	+	}
	185	+	FuncVarRef = purego.NewCallback(fcb)
	186	+	SaveCallback(FuncVarPtr, FuncVarRef)
183	187		}
184		-	FuncVarRef = purego.NewCallback(fcb)
185		-	SaveCallback(FuncVarPtr, FuncVarRef)
186	188		}
187	189
188	190		xThreadPoolSetSortFunction(x.GoPointer(), FuncVarRef, UserDataVar)

M v4/glib/gtree.go +110 -90


@@ -44,17 +44,19 @@ var xNewTree func(uintptr) *Tree
44	44		// Creates a new #GTree.
45	45		func NewTree(KeyCompareFuncVar CompareFunc) Tree {
46	46
47		-	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
48	47		var KeyCompareFuncVarRef uintptr
49		-	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
50		-	KeyCompareFuncVarRef = cbRefPtr
51		-	} else {
52		-	fcb := func(arg0 uintptr, arg1 uintptr) int {
53		-	cbFn := *KeyCompareFuncVar
54		-	return cbFn(arg0, arg1)
	48	+	if KeyCompareFuncVar != nil {
	49	+	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
	50	+	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
	51	+	KeyCompareFuncVarRef = cbRefPtr
	52	+	} else {
	53	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
	54	+	cbFn := *KeyCompareFuncVar
	55	+	return cbFn(arg0, arg1)
	56	+	}
	57	+	KeyCompareFuncVarRef = purego.NewCallback(fcb)
	58	+	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
55	59		}
56		-	KeyCompareFuncVarRef = purego.NewCallback(fcb)
57		-	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
58	60		}
59	61
60	62		cret := xNewTree(KeyCompareFuncVarRef)

@@ -68,43 +70,49 @@ var xNewTreeFull func(uintptr, uintptr, uintptr, uintptr) *Tree
68	70		// removing the entry from the #GTree.
69	71		func NewTreeFull(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar DestroyNotify, ValueDestroyFuncVar DestroyNotify) Tree {
70	72
71		-	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
72	73		var KeyCompareFuncVarRef uintptr
73		-	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
74		-	KeyCompareFuncVarRef = cbRefPtr
75		-	} else {
76		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
77		-	cbFn := *KeyCompareFuncVar
78		-	return cbFn(arg0, arg1, arg2)
	74	+	if KeyCompareFuncVar != nil {
	75	+	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
	76	+	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
	77	+	KeyCompareFuncVarRef = cbRefPtr
	78	+	} else {
	79	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	80	+	cbFn := *KeyCompareFuncVar
	81	+	return cbFn(arg0, arg1, arg2)
	82	+	}
	83	+	KeyCompareFuncVarRef = purego.NewCallback(fcb)
	84	+	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
79	85		}
80		-	KeyCompareFuncVarRef = purego.NewCallback(fcb)
81		-	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
82	86		}
83	87
84		-	KeyDestroyFuncVarPtr := uintptr(unsafe.Pointer(KeyDestroyFuncVar))
85	88		var KeyDestroyFuncVarRef uintptr
86		-	if cbRefPtr, ok := GetCallback(KeyDestroyFuncVarPtr); ok {
87		-	KeyDestroyFuncVarRef = cbRefPtr
88		-	} else {
89		-	fcb := func(arg0 uintptr) {
90		-	cbFn := *KeyDestroyFuncVar
91		-	cbFn(arg0)
	89	+	if KeyDestroyFuncVar != nil {
	90	+	KeyDestroyFuncVarPtr := uintptr(unsafe.Pointer(KeyDestroyFuncVar))
	91	+	if cbRefPtr, ok := GetCallback(KeyDestroyFuncVarPtr); ok {
	92	+	KeyDestroyFuncVarRef = cbRefPtr
	93	+	} else {
	94	+	fcb := func(arg0 uintptr) {
	95	+	cbFn := *KeyDestroyFuncVar
	96	+	cbFn(arg0)
	97	+	}
	98	+	KeyDestroyFuncVarRef = purego.NewCallback(fcb)
	99	+	SaveCallback(KeyDestroyFuncVarPtr, KeyDestroyFuncVarRef)
92	100		}
93		-	KeyDestroyFuncVarRef = purego.NewCallback(fcb)
94		-	SaveCallback(KeyDestroyFuncVarPtr, KeyDestroyFuncVarRef)
95	101		}
96	102
97		-	ValueDestroyFuncVarPtr := uintptr(unsafe.Pointer(ValueDestroyFuncVar))
98	103		var ValueDestroyFuncVarRef uintptr
99		-	if cbRefPtr, ok := GetCallback(ValueDestroyFuncVarPtr); ok {
100		-	ValueDestroyFuncVarRef = cbRefPtr
101		-	} else {
102		-	fcb := func(arg0 uintptr) {
103		-	cbFn := *ValueDestroyFuncVar
104		-	cbFn(arg0)
	104	+	if ValueDestroyFuncVar != nil {
	105	+	ValueDestroyFuncVarPtr := uintptr(unsafe.Pointer(ValueDestroyFuncVar))
	106	+	if cbRefPtr, ok := GetCallback(ValueDestroyFuncVarPtr); ok {
	107	+	ValueDestroyFuncVarRef = cbRefPtr
	108	+	} else {
	109	+	fcb := func(arg0 uintptr) {
	110	+	cbFn := *ValueDestroyFuncVar
	111	+	cbFn(arg0)
	112	+	}
	113	+	ValueDestroyFuncVarRef = purego.NewCallback(fcb)
	114	+	SaveCallback(ValueDestroyFuncVarPtr, ValueDestroyFuncVarRef)
105	115		}
106		-	ValueDestroyFuncVarRef = purego.NewCallback(fcb)
107		-	SaveCallback(ValueDestroyFuncVarPtr, ValueDestroyFuncVarRef)
108	116		}
109	117
110	118		cret := xNewTreeFull(KeyCompareFuncVarRef, KeyCompareDataVar, KeyDestroyFuncVarRef, ValueDestroyFuncVarRef)

@@ -117,17 +125,19 @@ var xNewTreeWithData func(uintptr, uintptr) *Tree
117	125		// See g_tree_new() for more details.
118	126		func NewTreeWithData(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr) Tree {
119	127
120		-	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
121	128		var KeyCompareFuncVarRef uintptr
122		-	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
123		-	KeyCompareFuncVarRef = cbRefPtr
124		-	} else {
125		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
126		-	cbFn := *KeyCompareFuncVar
127		-	return cbFn(arg0, arg1, arg2)
	129	+	if KeyCompareFuncVar != nil {
	130	+	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
	131	+	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
	132	+	KeyCompareFuncVarRef = cbRefPtr
	133	+	} else {
	134	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	135	+	cbFn := *KeyCompareFuncVar
	136	+	return cbFn(arg0, arg1, arg2)
	137	+	}
	138	+	KeyCompareFuncVarRef = purego.NewCallback(fcb)
	139	+	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
128	140		}
129		-	KeyCompareFuncVarRef = purego.NewCallback(fcb)
130		-	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
131	141		}
132	142
133	143		cret := xNewTreeWithData(KeyCompareFuncVarRef, KeyCompareDataVar)

@@ -160,17 +170,19 @@ var xTreeForeach func(uintptr, uintptr, uintptr)
160	170		// the tree, then walk the list and remove each item.
161	171		func (x Tree) Foreach(FuncVar TraverseFunc, UserDataVar uintptr) {
162	172
163		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
164	173		var FuncVarRef uintptr
165		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
166		-	FuncVarRef = cbRefPtr
167		-	} else {
168		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
169		-	cbFn := *FuncVar
170		-	return cbFn(arg0, arg1, arg2)
	174	+	if FuncVar != nil {
	175	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	176	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	177	+	FuncVarRef = cbRefPtr
	178	+	} else {
	179	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
	180	+	cbFn := *FuncVar
	181	+	return cbFn(arg0, arg1, arg2)
	182	+	}
	183	+	FuncVarRef = purego.NewCallback(fcb)
	184	+	SaveCallback(FuncVarPtr, FuncVarRef)
171	185		}
172		-	FuncVarRef = purego.NewCallback(fcb)
173		-	SaveCallback(FuncVarPtr, FuncVarRef)
174	186		}
175	187
176	188		xTreeForeach(x.GoPointer(), FuncVarRef, UserDataVar)

@@ -189,17 +201,19 @@ var xTreeForeachNode func(uintptr, uintptr, uintptr)
189	201		// the tree, then walk the list and remove each item.
190	202		func (x Tree) ForeachNode(FuncVar TraverseNodeFunc, UserDataVar uintptr) {
191	203
192		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
193	204		var FuncVarRef uintptr
194		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
195		-	FuncVarRef = cbRefPtr
196		-	} else {
197		-	fcb := func(arg0 *TreeNode, arg1 uintptr) bool {
198		-	cbFn := *FuncVar
199		-	return cbFn(arg0, arg1)
	205	+	if FuncVar != nil {
	206	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	207	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	208	+	FuncVarRef = cbRefPtr
	209	+	} else {
	210	+	fcb := func(arg0 *TreeNode, arg1 uintptr) bool {
	211	+	cbFn := *FuncVar
	212	+	return cbFn(arg0, arg1)
	213	+	}
	214	+	FuncVarRef = purego.NewCallback(fcb)
	215	+	SaveCallback(FuncVarPtr, FuncVarRef)
200	216		}
201		-	FuncVarRef = purego.NewCallback(fcb)
202		-	SaveCallback(FuncVarPtr, FuncVarRef)
203	217		}
204	218
205	219		xTreeForeachNode(x.GoPointer(), FuncVarRef, UserDataVar)

@@ -408,17 +422,19 @@ var xTreeSearch func(uintptr, uintptr, uintptr) uintptr
408	422		// pairs that have a larger key.
409	423		func (x Tree) Search(SearchFuncVar CompareFunc, UserDataVar uintptr) uintptr {
410	424
411		-	SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
412	425		var SearchFuncVarRef uintptr
413		-	if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
414		-	SearchFuncVarRef = cbRefPtr
415		-	} else {
416		-	fcb := func(arg0 uintptr, arg1 uintptr) int {
417		-	cbFn := *SearchFuncVar
418		-	return cbFn(arg0, arg1)
	426	+	if SearchFuncVar != nil {
	427	+	SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
	428	+	if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
	429	+	SearchFuncVarRef = cbRefPtr
	430	+	} else {
	431	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
	432	+	cbFn := *SearchFuncVar
	433	+	return cbFn(arg0, arg1)
	434	+	}
	435	+	SearchFuncVarRef = purego.NewCallback(fcb)
	436	+	SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
419	437		}
420		-	SearchFuncVarRef = purego.NewCallback(fcb)
421		-	SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
422	438		}
423	439
424	440		cret := xTreeSearch(x.GoPointer(), SearchFuncVarRef, UserDataVar)

@@ -438,17 +454,19 @@ var xTreeSearchNode func(uintptr, uintptr, uintptr) *TreeNode
438	454		// pairs that have a larger key.
439	455		func (x Tree) SearchNode(SearchFuncVar CompareFunc, UserDataVar uintptr) *TreeNode {
440	456
441		-	SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
442	457		var SearchFuncVarRef uintptr
443		-	if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
444		-	SearchFuncVarRef = cbRefPtr
445		-	} else {
446		-	fcb := func(arg0 uintptr, arg1 uintptr) int {
447		-	cbFn := *SearchFuncVar
448		-	return cbFn(arg0, arg1)
	458	+	if SearchFuncVar != nil {
	459	+	SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
	460	+	if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
	461	+	SearchFuncVarRef = cbRefPtr
	462	+	} else {
	463	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
	464	+	cbFn := *SearchFuncVar
	465	+	return cbFn(arg0, arg1)
	466	+	}
	467	+	SearchFuncVarRef = purego.NewCallback(fcb)
	468	+	SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
449	469		}
450		-	SearchFuncVarRef = purego.NewCallback(fcb)
451		-	SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
452	470		}
453	471
454	472		cret := xTreeSearchNode(x.GoPointer(), SearchFuncVarRef, UserDataVar)

@@ -472,17 +490,19 @@ var xTreeTraverse func(uintptr, uintptr, TraverseType, uintptr)
472	490		// Calls the given function for each node in the #GTree.
473	491		func (x Tree) Traverse(TraverseFuncVar TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {
474	492
475		-	TraverseFuncVarPtr := uintptr(unsafe.Pointer(TraverseFuncVar))
476	493		var TraverseFuncVarRef uintptr
477		-	if cbRefPtr, ok := GetCallback(TraverseFuncVarPtr); ok {
478		-	TraverseFuncVarRef = cbRefPtr
479		-	} else {
480		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
481		-	cbFn := *TraverseFuncVar
482		-	return cbFn(arg0, arg1, arg2)
	494	+	if TraverseFuncVar != nil {
	495	+	TraverseFuncVarPtr := uintptr(unsafe.Pointer(TraverseFuncVar))
	496	+	if cbRefPtr, ok := GetCallback(TraverseFuncVarPtr); ok {
	497	+	TraverseFuncVarRef = cbRefPtr
	498	+	} else {
	499	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
	500	+	cbFn := *TraverseFuncVar
	501	+	return cbFn(arg0, arg1, arg2)
	502	+	}
	503	+	TraverseFuncVarRef = purego.NewCallback(fcb)
	504	+	SaveCallback(TraverseFuncVarPtr, TraverseFuncVarRef)
483	505		}
484		-	TraverseFuncVarRef = purego.NewCallback(fcb)
485		-	SaveCallback(TraverseFuncVarPtr, TraverseFuncVarRef)
486	506		}
487	507
488	508		xTreeTraverse(x.GoPointer(), TraverseFuncVarRef, TraverseTypeVar, UserDataVar)

M v4/glib/gutils.go +11 -9


@@ -121,17 +121,19 @@ var xAtexit func(uintptr)
121	121		// program.
122	122		func Atexit(FuncVar *VoidFunc) {
123	123
124		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
125	124		var FuncVarRef uintptr
126		-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
127		-	FuncVarRef = cbRefPtr
128		-	} else {
129		-	fcb := func() {
130		-	cbFn := *FuncVar
131		-	cbFn()
	125	+	if FuncVar != nil {
	126	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	127	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
	128	+	FuncVarRef = cbRefPtr
	129	+	} else {
	130	+	fcb := func() {
	131	+	cbFn := *FuncVar
	132	+	cbFn()
	133	+	}
	134	+	FuncVarRef = purego.NewCallback(fcb)
	135	+	SaveCallback(FuncVarPtr, FuncVarRef)
132	136		}
133		-	FuncVarRef = purego.NewCallback(fcb)
134		-	SaveCallback(FuncVarPtr, FuncVarRef)
135	137		}
136	138
137	139		xAtexit(FuncVarRef)

M v4/glib/gvariant.go +11 -9


@@ -466,17 +466,19 @@ var xNewVariantFromData func(*VariantType, []byte, uint, bool, uintptr, uintptr)
466	466		// process.
467	467		func NewVariantFromData(TypeVar VariantType, DataVar []byte, SizeVar uint, TrustedVar bool, NotifyVar DestroyNotify, UserDataVar uintptr) *Variant {
468	468
469		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
470	469		var NotifyVarRef uintptr
471		-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
472		-	NotifyVarRef = cbRefPtr
473		-	} else {
474		-	fcb := func(arg0 uintptr) {
475		-	cbFn := *NotifyVar
476		-	cbFn(arg0)
	470	+	if NotifyVar != nil {
	471	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	472	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
	473	+	NotifyVarRef = cbRefPtr
	474	+	} else {
	475	+	fcb := func(arg0 uintptr) {
	476	+	cbFn := *NotifyVar
	477	+	cbFn(arg0)
	478	+	}
	479	+	NotifyVarRef = purego.NewCallback(fcb)
	480	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
477	481		}
478		-	NotifyVarRef = purego.NewCallback(fcb)
479		-	SaveCallback(NotifyVarPtr, NotifyVarRef)
480	482		}
481	483
482	484		cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, NotifyVarRef, UserDataVar)

M v4/gobject/gbindinggroup.go +11 -9


@@ -103,17 +103,19 @@ func (x BindingGroup) BindFull(SourcePropertyVar string, TargetVar Object, Tar
103	103		}
104	104		}
105	105
106		-	UserDataDestroyVarPtr := uintptr(unsafe.Pointer(UserDataDestroyVar))
107	106		var UserDataDestroyVarRef uintptr
108		-	if cbRefPtr, ok := glib.GetCallback(UserDataDestroyVarPtr); ok {
109		-	UserDataDestroyVarRef = cbRefPtr
110		-	} else {
111		-	fcb := func(arg0 uintptr) {
112		-	cbFn := *UserDataDestroyVar
113		-	cbFn(arg0)
	107	+	if UserDataDestroyVar != nil {
	108	+	UserDataDestroyVarPtr := uintptr(unsafe.Pointer(UserDataDestroyVar))
	109	+	if cbRefPtr, ok := glib.GetCallback(UserDataDestroyVarPtr); ok {
	110	+	UserDataDestroyVarRef = cbRefPtr
	111	+	} else {
	112	+	fcb := func(arg0 uintptr) {
	113	+	cbFn := *UserDataDestroyVar
	114	+	cbFn(arg0)
	115	+	}
	116	+	UserDataDestroyVarRef = purego.NewCallback(fcb)
	117	+	glib.SaveCallback(UserDataDestroyVarPtr, UserDataDestroyVarRef)
114	118		}
115		-	UserDataDestroyVarRef = purego.NewCallback(fcb)
116		-	glib.SaveCallback(UserDataDestroyVarPtr, UserDataDestroyVarRef)
117	119		}
118	120
119	121		xBindingGroupBindFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, TransformToVarRef, TransformFromVarRef, UserDataVar, UserDataDestroyVarRef)

M v4/gobject/gboxed.go +22 -18


@@ -49,30 +49,34 @@ var xBoxedTypeRegisterStatic func(string, uintptr, uintptr) types.GType
49	49		// will create the appropriate `*_get_type()` function for the boxed type.
50	50		func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar BoxedCopyFunc, BoxedFreeVar BoxedFreeFunc) types.GType {
51	51
52		-	BoxedCopyVarPtr := uintptr(unsafe.Pointer(BoxedCopyVar))
53	52		var BoxedCopyVarRef uintptr
54		-	if cbRefPtr, ok := glib.GetCallback(BoxedCopyVarPtr); ok {
55		-	BoxedCopyVarRef = cbRefPtr
56		-	} else {
57		-	fcb := func(arg0 uintptr) uintptr {
58		-	cbFn := *BoxedCopyVar
59		-	return cbFn(arg0)
	53	+	if BoxedCopyVar != nil {
	54	+	BoxedCopyVarPtr := uintptr(unsafe.Pointer(BoxedCopyVar))
	55	+	if cbRefPtr, ok := glib.GetCallback(BoxedCopyVarPtr); ok {
	56	+	BoxedCopyVarRef = cbRefPtr
	57	+	} else {
	58	+	fcb := func(arg0 uintptr) uintptr {
	59	+	cbFn := *BoxedCopyVar
	60	+	return cbFn(arg0)
	61	+	}
	62	+	BoxedCopyVarRef = purego.NewCallback(fcb)
	63	+	glib.SaveCallback(BoxedCopyVarPtr, BoxedCopyVarRef)
60	64		}
61		-	BoxedCopyVarRef = purego.NewCallback(fcb)
62		-	glib.SaveCallback(BoxedCopyVarPtr, BoxedCopyVarRef)
63	65		}
64	66
65		-	BoxedFreeVarPtr := uintptr(unsafe.Pointer(BoxedFreeVar))
66	67		var BoxedFreeVarRef uintptr
67		-	if cbRefPtr, ok := glib.GetCallback(BoxedFreeVarPtr); ok {
68		-	BoxedFreeVarRef = cbRefPtr
69		-	} else {
70		-	fcb := func(arg0 uintptr) {
71		-	cbFn := *BoxedFreeVar
72		-	cbFn(arg0)
	68	+	if BoxedFreeVar != nil {
	69	+	BoxedFreeVarPtr := uintptr(unsafe.Pointer(BoxedFreeVar))
	70	+	if cbRefPtr, ok := glib.GetCallback(BoxedFreeVarPtr); ok {
	71	+	BoxedFreeVarRef = cbRefPtr
	72	+	} else {
	73	+	fcb := func(arg0 uintptr) {
	74	+	cbFn := *BoxedFreeVar
	75	+	cbFn(arg0)
	76	+	}
	77	+	BoxedFreeVarRef = purego.NewCallback(fcb)
	78	+	glib.SaveCallback(BoxedFreeVarPtr, BoxedFreeVarRef)
73	79		}
74		-	BoxedFreeVarRef = purego.NewCallback(fcb)
75		-	glib.SaveCallback(BoxedFreeVarPtr, BoxedFreeVarRef)
76	80		}
77	81
78	82		cret := xBoxedTypeRegisterStatic(NameVar, BoxedCopyVarRef, BoxedFreeVarRef)

M v4/gobject/gclosure.go +132 -108


@@ -203,17 +203,19 @@ var xClosureAddFinalizeNotifier func(uintptr, uintptr, uintptr)
203	203		// notifiers will be run before the finalize notifiers.
204	204		func (x Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
205	205
206		-	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
207	206		var NotifyFuncVarRef uintptr
208		-	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
209		-	NotifyFuncVarRef = cbRefPtr
210		-	} else {
211		-	fcb := func(arg0 uintptr, arg1 *Closure) {
212		-	cbFn := *NotifyFuncVar
213		-	cbFn(arg0, arg1)
	207	+	if NotifyFuncVar != nil {
	208	+	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
	209	+	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
	210	+	NotifyFuncVarRef = cbRefPtr
	211	+	} else {
	212	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	213	+	cbFn := *NotifyFuncVar
	214	+	cbFn(arg0, arg1)
	215	+	}
	216	+	NotifyFuncVarRef = purego.NewCallback(fcb)
	217	+	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
214	218		}
215		-	NotifyFuncVarRef = purego.NewCallback(fcb)
216		-	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
217	219		}
218	220
219	221		xClosureAddFinalizeNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)

@@ -229,17 +231,19 @@ var xClosureAddInvalidateNotifier func(uintptr, uintptr, uintptr)
229	231		// in an unspecified order.
230	232		func (x Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
231	233
232		-	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
233	234		var NotifyFuncVarRef uintptr
234		-	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
235		-	NotifyFuncVarRef = cbRefPtr
236		-	} else {
237		-	fcb := func(arg0 uintptr, arg1 *Closure) {
238		-	cbFn := *NotifyFuncVar
239		-	cbFn(arg0, arg1)
	235	+	if NotifyFuncVar != nil {
	236	+	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
	237	+	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
	238	+	NotifyFuncVarRef = cbRefPtr
	239	+	} else {
	240	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	241	+	cbFn := *NotifyFuncVar
	242	+	cbFn(arg0, arg1)
	243	+	}
	244	+	NotifyFuncVarRef = purego.NewCallback(fcb)
	245	+	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
240	246		}
241		-	NotifyFuncVarRef = purego.NewCallback(fcb)
242		-	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
243	247		}
244	248
245	249		xClosureAddInvalidateNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)

@@ -256,30 +260,34 @@ var xClosureAddMarshalGuards func(uintptr, uintptr, uintptr, uintptr, uintptr)
256	260		// example of marshal guards.
257	261		func (x Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify) {
258	262
259		-	PreMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PreMarshalNotifyVar))
260	263		var PreMarshalNotifyVarRef uintptr
261		-	if cbRefPtr, ok := glib.GetCallback(PreMarshalNotifyVarPtr); ok {
262		-	PreMarshalNotifyVarRef = cbRefPtr
263		-	} else {
264		-	fcb := func(arg0 uintptr, arg1 *Closure) {
265		-	cbFn := *PreMarshalNotifyVar
266		-	cbFn(arg0, arg1)
	264	+	if PreMarshalNotifyVar != nil {
	265	+	PreMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PreMarshalNotifyVar))
	266	+	if cbRefPtr, ok := glib.GetCallback(PreMarshalNotifyVarPtr); ok {
	267	+	PreMarshalNotifyVarRef = cbRefPtr
	268	+	} else {
	269	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	270	+	cbFn := *PreMarshalNotifyVar
	271	+	cbFn(arg0, arg1)
	272	+	}
	273	+	PreMarshalNotifyVarRef = purego.NewCallback(fcb)
	274	+	glib.SaveCallback(PreMarshalNotifyVarPtr, PreMarshalNotifyVarRef)
267	275		}
268		-	PreMarshalNotifyVarRef = purego.NewCallback(fcb)
269		-	glib.SaveCallback(PreMarshalNotifyVarPtr, PreMarshalNotifyVarRef)
270	276		}
271	277
272		-	PostMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PostMarshalNotifyVar))
273	278		var PostMarshalNotifyVarRef uintptr
274		-	if cbRefPtr, ok := glib.GetCallback(PostMarshalNotifyVarPtr); ok {
275		-	PostMarshalNotifyVarRef = cbRefPtr
276		-	} else {
277		-	fcb := func(arg0 uintptr, arg1 *Closure) {
278		-	cbFn := *PostMarshalNotifyVar
279		-	cbFn(arg0, arg1)
	279	+	if PostMarshalNotifyVar != nil {
	280	+	PostMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PostMarshalNotifyVar))
	281	+	if cbRefPtr, ok := glib.GetCallback(PostMarshalNotifyVarPtr); ok {
	282	+	PostMarshalNotifyVarRef = cbRefPtr
	283	+	} else {
	284	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	285	+	cbFn := *PostMarshalNotifyVar
	286	+	cbFn(arg0, arg1)
	287	+	}
	288	+	PostMarshalNotifyVarRef = purego.NewCallback(fcb)
	289	+	glib.SaveCallback(PostMarshalNotifyVarPtr, PostMarshalNotifyVarRef)
280	290		}
281		-	PostMarshalNotifyVarRef = purego.NewCallback(fcb)
282		-	glib.SaveCallback(PostMarshalNotifyVarPtr, PostMarshalNotifyVarRef)
283	291		}
284	292
285	293		xClosureAddMarshalGuards(x.GoPointer(), PreMarshalDataVar, PreMarshalNotifyVarRef, PostMarshalDataVar, PostMarshalNotifyVarRef)

@@ -335,17 +343,19 @@ var xClosureRemoveFinalizeNotifier func(uintptr, uintptr, uintptr)
335	343		// Notice that notifiers are automatically removed after they are run.
336	344		func (x Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
337	345
338		-	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
339	346		var NotifyFuncVarRef uintptr
340		-	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
341		-	NotifyFuncVarRef = cbRefPtr
342		-	} else {
343		-	fcb := func(arg0 uintptr, arg1 *Closure) {
344		-	cbFn := *NotifyFuncVar
345		-	cbFn(arg0, arg1)
	347	+	if NotifyFuncVar != nil {
	348	+	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
	349	+	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
	350	+	NotifyFuncVarRef = cbRefPtr
	351	+	} else {
	352	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	353	+	cbFn := *NotifyFuncVar
	354	+	cbFn(arg0, arg1)
	355	+	}
	356	+	NotifyFuncVarRef = purego.NewCallback(fcb)
	357	+	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
346	358		}
347		-	NotifyFuncVarRef = purego.NewCallback(fcb)
348		-	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
349	359		}
350	360
351	361		xClosureRemoveFinalizeNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)

@@ -359,17 +369,19 @@ var xClosureRemoveInvalidateNotifier func(uintptr, uintptr, uintptr)
359	369		// Notice that notifiers are automatically removed after they are run.
360	370		func (x Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
361	371
362		-	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
363	372		var NotifyFuncVarRef uintptr
364		-	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
365		-	NotifyFuncVarRef = cbRefPtr
366		-	} else {
367		-	fcb := func(arg0 uintptr, arg1 *Closure) {
368		-	cbFn := *NotifyFuncVar
369		-	cbFn(arg0, arg1)
	373	+	if NotifyFuncVar != nil {
	374	+	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
	375	+	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
	376	+	NotifyFuncVarRef = cbRefPtr
	377	+	} else {
	378	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	379	+	cbFn := *NotifyFuncVar
	380	+	cbFn(arg0, arg1)
	381	+	}
	382	+	NotifyFuncVarRef = purego.NewCallback(fcb)
	383	+	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
370	384		}
371		-	NotifyFuncVarRef = purego.NewCallback(fcb)
372		-	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
373	385		}
374	386
375	387		xClosureRemoveInvalidateNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)

@@ -390,17 +402,19 @@ var xClosureSetMarshal func(uintptr, uintptr)
390	402		// See also: g_closure_set_meta_marshal()
391	403		func (x Closure) SetMarshal(MarshalVar ClosureMarshal) {
392	404
393		-	MarshalVarPtr := uintptr(unsafe.Pointer(MarshalVar))
394	405		var MarshalVarRef uintptr
395		-	if cbRefPtr, ok := glib.GetCallback(MarshalVarPtr); ok {
396		-	MarshalVarRef = cbRefPtr
397		-	} else {
398		-	fcb := func(arg0 Closure, arg1 Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
399		-	cbFn := *MarshalVar
400		-	cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
	406	+	if MarshalVar != nil {
	407	+	MarshalVarPtr := uintptr(unsafe.Pointer(MarshalVar))
	408	+	if cbRefPtr, ok := glib.GetCallback(MarshalVarPtr); ok {
	409	+	MarshalVarRef = cbRefPtr
	410	+	} else {
	411	+	fcb := func(arg0 Closure, arg1 Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
	412	+	cbFn := *MarshalVar
	413	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
	414	+	}
	415	+	MarshalVarRef = purego.NewCallback(fcb)
	416	+	glib.SaveCallback(MarshalVarPtr, MarshalVarRef)
401	417		}
402		-	MarshalVarRef = purego.NewCallback(fcb)
403		-	glib.SaveCallback(MarshalVarPtr, MarshalVarRef)
404	418		}
405	419
406	420		xClosureSetMarshal(x.GoPointer(), MarshalVarRef)

@@ -428,17 +442,19 @@ var xClosureSetMetaMarshal func(uintptr, uintptr, uintptr)
428	442		// @marshal_data argument.
429	443		func (x Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar ClosureMarshal) {
430	444
431		-	MetaMarshalVarPtr := uintptr(unsafe.Pointer(MetaMarshalVar))
432	445		var MetaMarshalVarRef uintptr
433		-	if cbRefPtr, ok := glib.GetCallback(MetaMarshalVarPtr); ok {
434		-	MetaMarshalVarRef = cbRefPtr
435		-	} else {
436		-	fcb := func(arg0 Closure, arg1 Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
437		-	cbFn := *MetaMarshalVar
438		-	cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
	446	+	if MetaMarshalVar != nil {
	447	+	MetaMarshalVarPtr := uintptr(unsafe.Pointer(MetaMarshalVar))
	448	+	if cbRefPtr, ok := glib.GetCallback(MetaMarshalVarPtr); ok {
	449	+	MetaMarshalVarRef = cbRefPtr
	450	+	} else {
	451	+	fcb := func(arg0 Closure, arg1 Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
	452	+	cbFn := *MetaMarshalVar
	453	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
	454	+	}
	455	+	MetaMarshalVarRef = purego.NewCallback(fcb)
	456	+	glib.SaveCallback(MetaMarshalVarPtr, MetaMarshalVarRef)
439	457		}
440		-	MetaMarshalVarRef = purego.NewCallback(fcb)
441		-	glib.SaveCallback(MetaMarshalVarPtr, MetaMarshalVarRef)
442	458		}
443	459
444	460		xClosureSetMetaMarshal(x.GoPointer(), MarshalDataVar, MetaMarshalVarRef)

@@ -571,30 +587,34 @@ var xCclosureNew func(uintptr, uintptr, uintptr) *Closure
571	587		// @destroy_data will be called as a finalize notifier on the #GClosure.
572	588		func CclosureNew(CallbackFuncVar Callback, UserDataVar uintptr, DestroyDataVar ClosureNotify) *Closure {
573	589
574		-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
575	590		var CallbackFuncVarRef uintptr
576		-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
577		-	CallbackFuncVarRef = cbRefPtr
578		-	} else {
579		-	fcb := func() {
580		-	cbFn := *CallbackFuncVar
581		-	cbFn()
	591	+	if CallbackFuncVar != nil {
	592	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
	593	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
	594	+	CallbackFuncVarRef = cbRefPtr
	595	+	} else {
	596	+	fcb := func() {
	597	+	cbFn := *CallbackFuncVar
	598	+	cbFn()
	599	+	}
	600	+	CallbackFuncVarRef = purego.NewCallback(fcb)
	601	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
582	602		}
583		-	CallbackFuncVarRef = purego.NewCallback(fcb)
584		-	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
585	603		}
586	604
587		-	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
588	605		var DestroyDataVarRef uintptr
589		-	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
590		-	DestroyDataVarRef = cbRefPtr
591		-	} else {
592		-	fcb := func(arg0 uintptr, arg1 *Closure) {
593		-	cbFn := *DestroyDataVar
594		-	cbFn(arg0, arg1)
	606	+	if DestroyDataVar != nil {
	607	+	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
	608	+	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
	609	+	DestroyDataVarRef = cbRefPtr
	610	+	} else {
	611	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	612	+	cbFn := *DestroyDataVar
	613	+	cbFn(arg0, arg1)
	614	+	}
	615	+	DestroyDataVarRef = purego.NewCallback(fcb)
	616	+	glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
595	617		}
596		-	DestroyDataVarRef = purego.NewCallback(fcb)
597		-	glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
598	618		}
599	619
600	620		cret := xCclosureNew(CallbackFuncVarRef, UserDataVar, DestroyDataVarRef)

@@ -609,30 +629,34 @@ var xCclosureNewSwap func(uintptr, uintptr, uintptr) *Closure
609	629		// @destroy_data will be called as a finalize notifier on the #GClosure.
610	630		func CclosureNewSwap(CallbackFuncVar Callback, UserDataVar uintptr, DestroyDataVar ClosureNotify) *Closure {
611	631
612		-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
613	632		var CallbackFuncVarRef uintptr
614		-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
615		-	CallbackFuncVarRef = cbRefPtr
616		-	} else {
617		-	fcb := func() {
618		-	cbFn := *CallbackFuncVar
619		-	cbFn()
	633	+	if CallbackFuncVar != nil {
	634	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
	635	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
	636	+	CallbackFuncVarRef = cbRefPtr
	637	+	} else {
	638	+	fcb := func() {
	639	+	cbFn := *CallbackFuncVar
	640	+	cbFn()
	641	+	}
	642	+	CallbackFuncVarRef = purego.NewCallback(fcb)
	643	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
620	644		}
621		-	CallbackFuncVarRef = purego.NewCallback(fcb)
622		-	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
623	645		}
624	646
625		-	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
626	647		var DestroyDataVarRef uintptr
627		-	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
628		-	DestroyDataVarRef = cbRefPtr
629		-	} else {
630		-	fcb := func(arg0 uintptr, arg1 *Closure) {
631		-	cbFn := *DestroyDataVar
632		-	cbFn(arg0, arg1)
	648	+	if DestroyDataVar != nil {
	649	+	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
	650	+	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
	651	+	DestroyDataVarRef = cbRefPtr
	652	+	} else {
	653	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	654	+	cbFn := *DestroyDataVar
	655	+	cbFn(arg0, arg1)
	656	+	}
	657	+	DestroyDataVarRef = purego.NewCallback(fcb)
	658	+	glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
633	659		}
634		-	DestroyDataVarRef = purego.NewCallback(fcb)
635		-	glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
636	660		}
637	661
638	662		cret := xCclosureNewSwap(CallbackFuncVarRef, UserDataVar, DestroyDataVarRef)

M v4/gobject/gobject.go +77 -63


@@ -931,17 +931,19 @@ var xCclosureNewObject func(uintptr, uintptr) *Closure
931	931		// after the object is is freed.
932	932		func CclosureNewObject(CallbackFuncVar Callback, ObjectVar Object) *Closure {
933	933
934		-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
935	934		var CallbackFuncVarRef uintptr
936		-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
937		-	CallbackFuncVarRef = cbRefPtr
938		-	} else {
939		-	fcb := func() {
940		-	cbFn := *CallbackFuncVar
941		-	cbFn()
	935	+	if CallbackFuncVar != nil {
	936	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
	937	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
	938	+	CallbackFuncVarRef = cbRefPtr
	939	+	} else {
	940	+	fcb := func() {
	941	+	cbFn := *CallbackFuncVar
	942	+	cbFn()
	943	+	}
	944	+	CallbackFuncVarRef = purego.NewCallback(fcb)
	945	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
942	946		}
943		-	CallbackFuncVarRef = purego.NewCallback(fcb)
944		-	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
945	947		}
946	948
947	949		cret := xCclosureNewObject(CallbackFuncVarRef, ObjectVar.GoPointer())

@@ -957,17 +959,19 @@ var xCclosureNewObjectSwap func(uintptr, uintptr) *Closure
957	959		// after the object is is freed.
958	960		func CclosureNewObjectSwap(CallbackFuncVar Callback, ObjectVar Object) *Closure {
959	961
960		-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
961	962		var CallbackFuncVarRef uintptr
962		-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
963		-	CallbackFuncVarRef = cbRefPtr
964		-	} else {
965		-	fcb := func() {
966		-	cbFn := *CallbackFuncVar
967		-	cbFn()
	963	+	if CallbackFuncVar != nil {
	964	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
	965	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
	966	+	CallbackFuncVarRef = cbRefPtr
	967	+	} else {
	968	+	fcb := func() {
	969	+	cbFn := *CallbackFuncVar
	970	+	cbFn()
	971	+	}
	972	+	CallbackFuncVarRef = purego.NewCallback(fcb)
	973	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
968	974		}
969		-	CallbackFuncVarRef = purego.NewCallback(fcb)
970		-	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
971	975		}
972	976
973	977		cret := xCclosureNewObjectSwap(CallbackFuncVarRef, ObjectVar.GoPointer())

@@ -1012,17 +1016,19 @@ var xSignalConnectObject func(*TypeInstance, string, uintptr, uintptr, ConnectFl
1012	1016		// details.
1013	1017		func SignalConnectObject(InstanceVar TypeInstance, DetailedSignalVar string, CHandlerVar Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {
1014	1018
1015		-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
1016	1019		var CHandlerVarRef uintptr
1017		-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
1018		-	CHandlerVarRef = cbRefPtr
1019		-	} else {
1020		-	fcb := func() {
1021		-	cbFn := *CHandlerVar
1022		-	cbFn()
	1020	+	if CHandlerVar != nil {
	1021	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
	1022	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
	1023	+	CHandlerVarRef = cbRefPtr
	1024	+	} else {
	1025	+	fcb := func() {
	1026	+	cbFn := *CHandlerVar
	1027	+	cbFn()
	1028	+	}
	1029	+	CHandlerVarRef = purego.NewCallback(fcb)
	1030	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
1023	1031		}
1024		-	CHandlerVarRef = purego.NewCallback(fcb)
1025		-	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
1026	1032		}
1027	1033
1028	1034		cret := xSignalConnectObject(InstanceVar, DetailedSignalVar, CHandlerVarRef, GobjectVar.GoPointer(), ConnectFlagsVar)

@@ -1237,17 +1243,19 @@ var xObjectAddToggleRef func(uintptr, uintptr, uintptr)
1237	1243		// A g_object_add_toggle_ref() must be released with g_object_remove_toggle_ref().
1238	1244		func (x Object) AddToggleRef(NotifyVar ToggleNotify, DataVar uintptr) {
1239	1245
1240		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1241	1246		var NotifyVarRef uintptr
1242		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
1243		-	NotifyVarRef = cbRefPtr
1244		-	} else {
1245		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
1246		-	cbFn := *NotifyVar
1247		-	cbFn(arg0, arg1, arg2)
	1247	+	if NotifyVar != nil {
	1248	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	1249	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	1250	+	NotifyVarRef = cbRefPtr
	1251	+	} else {
	1252	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
	1253	+	cbFn := *NotifyVar
	1254	+	cbFn(arg0, arg1, arg2)
	1255	+	}
	1256	+	NotifyVarRef = purego.NewCallback(fcb)
	1257	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1248	1258		}
1249		-	NotifyVarRef = purego.NewCallback(fcb)
1250		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1251	1259		}
1252	1260
1253	1261		xObjectAddToggleRef(x.GoPointer(), NotifyVarRef, DataVar)

@@ -1830,17 +1838,19 @@ var xObjectRemoveToggleRef func(uintptr, uintptr, uintptr)
1830	1838		// you must take care of that yourself.
1831	1839		func (x Object) RemoveToggleRef(NotifyVar ToggleNotify, DataVar uintptr) {
1832	1840
1833		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1834	1841		var NotifyVarRef uintptr
1835		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
1836		-	NotifyVarRef = cbRefPtr
1837		-	} else {
1838		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
1839		-	cbFn := *NotifyVar
1840		-	cbFn(arg0, arg1, arg2)
	1842	+	if NotifyVar != nil {
	1843	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	1844	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	1845	+	NotifyVarRef = cbRefPtr
	1846	+	} else {
	1847	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
	1848	+	cbFn := *NotifyVar
	1849	+	cbFn(arg0, arg1, arg2)
	1850	+	}
	1851	+	NotifyVarRef = purego.NewCallback(fcb)
	1852	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1841	1853		}
1842		-	NotifyVarRef = purego.NewCallback(fcb)
1843		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1844	1854		}
1845	1855
1846	1856		xObjectRemoveToggleRef(x.GoPointer(), NotifyVarRef, DataVar)

@@ -2254,17 +2264,19 @@ var xObjectWeakRef func(uintptr, uintptr, uintptr)
2254	2264		// Use #GWeakRef if thread-safety is required.
2255	2265		func (x Object) WeakRef(NotifyVar WeakNotify, DataVar uintptr) {
2256	2266
2257		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
2258	2267		var NotifyVarRef uintptr
2259		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
2260		-	NotifyVarRef = cbRefPtr
2261		-	} else {
2262		-	fcb := func(arg0 uintptr, arg1 uintptr) {
2263		-	cbFn := *NotifyVar
2264		-	cbFn(arg0, arg1)
	2268	+	if NotifyVar != nil {
	2269	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	2270	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	2271	+	NotifyVarRef = cbRefPtr
	2272	+	} else {
	2273	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	2274	+	cbFn := *NotifyVar
	2275	+	cbFn(arg0, arg1)
	2276	+	}
	2277	+	NotifyVarRef = purego.NewCallback(fcb)
	2278	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
2265	2279		}
2266		-	NotifyVarRef = purego.NewCallback(fcb)
2267		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
2268	2280		}
2269	2281
2270	2282		xObjectWeakRef(x.GoPointer(), NotifyVarRef, DataVar)

@@ -2276,17 +2288,19 @@ var xObjectWeakUnref func(uintptr, uintptr, uintptr)
2276	2288		// Removes a weak reference callback to an object.
2277	2289		func (x Object) WeakUnref(NotifyVar WeakNotify, DataVar uintptr) {
2278	2290
2279		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
2280	2291		var NotifyVarRef uintptr
2281		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
2282		-	NotifyVarRef = cbRefPtr
2283		-	} else {
2284		-	fcb := func(arg0 uintptr, arg1 uintptr) {
2285		-	cbFn := *NotifyVar
2286		-	cbFn(arg0, arg1)
	2292	+	if NotifyVar != nil {
	2293	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	2294	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	2295	+	NotifyVarRef = cbRefPtr
	2296	+	} else {
	2297	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	2298	+	cbFn := *NotifyVar
	2299	+	cbFn(arg0, arg1)
	2300	+	}
	2301	+	NotifyVarRef = purego.NewCallback(fcb)
	2302	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
2287	2303		}
2288		-	NotifyVarRef = purego.NewCallback(fcb)
2289		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
2290	2304		}
2291	2305
2292	2306		xObjectWeakUnref(x.GoPointer(), NotifyVarRef, DataVar)

M v4/gobject/gsignal.go +33 -27


@@ -228,17 +228,19 @@ var xSignalAddEmissionHook func(uint, glib.Quark, uintptr, uintptr, uintptr) uin
228	228		// for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
229	229		func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar SignalEmissionHook, HookDataVar uintptr, DataDestroyVar glib.DestroyNotify) uint32 {
230	230
231		-	HookFuncVarPtr := uintptr(unsafe.Pointer(HookFuncVar))
232	231		var HookFuncVarRef uintptr
233		-	if cbRefPtr, ok := glib.GetCallback(HookFuncVarPtr); ok {
234		-	HookFuncVarRef = cbRefPtr
235		-	} else {
236		-	fcb := func(arg0 *SignalInvocationHint, arg1 uint, arg2 []Value, arg3 uintptr) bool {
237		-	cbFn := *HookFuncVar
238		-	return cbFn(arg0, arg1, arg2, arg3)
	232	+	if HookFuncVar != nil {
	233	+	HookFuncVarPtr := uintptr(unsafe.Pointer(HookFuncVar))
	234	+	if cbRefPtr, ok := glib.GetCallback(HookFuncVarPtr); ok {
	235	+	HookFuncVarRef = cbRefPtr
	236	+	} else {
	237	+	fcb := func(arg0 *SignalInvocationHint, arg1 uint, arg2 []Value, arg3 uintptr) bool {
	238	+	cbFn := *HookFuncVar
	239	+	return cbFn(arg0, arg1, arg2, arg3)
	240	+	}
	241	+	HookFuncVarRef = purego.NewCallback(fcb)
	242	+	glib.SaveCallback(HookFuncVarPtr, HookFuncVarRef)
239	243		}
240		-	HookFuncVarRef = purego.NewCallback(fcb)
241		-	glib.SaveCallback(HookFuncVarPtr, HookFuncVarRef)
242	244		}
243	245
244	246		var DataDestroyVarRef uintptr

@@ -341,17 +343,19 @@ var xSignalConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectF
341	343		// details.
342	344		func SignalConnectData(InstanceVar Object, DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {
343	345
344		-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
345	346		var CHandlerVarRef uintptr
346		-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
347		-	CHandlerVarRef = cbRefPtr
348		-	} else {
349		-	fcb := func() {
350		-	cbFn := *CHandlerVar
351		-	cbFn()
	347	+	if CHandlerVar != nil {
	348	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
	349	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
	350	+	CHandlerVarRef = cbRefPtr
	351	+	} else {
	352	+	fcb := func() {
	353	+	cbFn := *CHandlerVar
	354	+	cbFn()
	355	+	}
	356	+	CHandlerVarRef = purego.NewCallback(fcb)
	357	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
352	358		}
353		-	CHandlerVarRef = purego.NewCallback(fcb)
354		-	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
355	359		}
356	360
357	361		var DestroyDataVarRef uintptr

@@ -848,17 +852,19 @@ var xSignalOverrideClassHandler func(string, types.GType, uintptr)
848	852		// parent class closure from inside the overridden one.
849	853		func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar types.GType, ClassHandlerVar *Callback) {
850	854
851		-	ClassHandlerVarPtr := uintptr(unsafe.Pointer(ClassHandlerVar))
852	855		var ClassHandlerVarRef uintptr
853		-	if cbRefPtr, ok := glib.GetCallback(ClassHandlerVarPtr); ok {
854		-	ClassHandlerVarRef = cbRefPtr
855		-	} else {
856		-	fcb := func() {
857		-	cbFn := *ClassHandlerVar
858		-	cbFn()
	856	+	if ClassHandlerVar != nil {
	857	+	ClassHandlerVarPtr := uintptr(unsafe.Pointer(ClassHandlerVar))
	858	+	if cbRefPtr, ok := glib.GetCallback(ClassHandlerVarPtr); ok {
	859	+	ClassHandlerVarRef = cbRefPtr
	860	+	} else {
	861	+	fcb := func() {
	862	+	cbFn := *ClassHandlerVar
	863	+	cbFn()
	864	+	}
	865	+	ClassHandlerVarRef = purego.NewCallback(fcb)
	866	+	glib.SaveCallback(ClassHandlerVarPtr, ClassHandlerVarRef)
859	867		}
860		-	ClassHandlerVarRef = purego.NewCallback(fcb)
861		-	glib.SaveCallback(ClassHandlerVarPtr, ClassHandlerVarRef)
862	868		}
863	869
864	870		xSignalOverrideClassHandler(SignalNameVar, InstanceTypeVar, ClassHandlerVarRef)

M v4/gobject/gsignalgroup.go +66 -54


@@ -82,17 +82,19 @@ var xSignalGroupConnect func(uintptr, string, uintptr, uintptr)
82	82		// You cannot connect a signal handler after #GSignalGroup:target has been set.
83	83		func (x SignalGroup) Connect(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
84	84
85		-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
86	85		var CHandlerVarRef uintptr
87		-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
88		-	CHandlerVarRef = cbRefPtr
89		-	} else {
90		-	fcb := func() {
91		-	cbFn := *CHandlerVar
92		-	cbFn()
	86	+	if CHandlerVar != nil {
	87	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
	88	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
	89	+	CHandlerVarRef = cbRefPtr
	90	+	} else {
	91	+	fcb := func() {
	92	+	cbFn := *CHandlerVar
	93	+	cbFn()
	94	+	}
	95	+	CHandlerVarRef = purego.NewCallback(fcb)
	96	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
93	97		}
94		-	CHandlerVarRef = purego.NewCallback(fcb)
95		-	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
96	98		}
97	99
98	100		xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)

@@ -109,17 +111,19 @@ var xSignalGroupConnectAfter func(uintptr, string, uintptr, uintptr)
109	111		// You cannot connect a signal handler after #GSignalGroup:target has been set.
110	112		func (x SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
111	113
112		-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
113	114		var CHandlerVarRef uintptr
114		-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
115		-	CHandlerVarRef = cbRefPtr
116		-	} else {
117		-	fcb := func() {
118		-	cbFn := *CHandlerVar
119		-	cbFn()
	115	+	if CHandlerVar != nil {
	116	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
	117	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
	118	+	CHandlerVarRef = cbRefPtr
	119	+	} else {
	120	+	fcb := func() {
	121	+	cbFn := *CHandlerVar
	122	+	cbFn()
	123	+	}
	124	+	CHandlerVarRef = purego.NewCallback(fcb)
	125	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
120	126		}
121		-	CHandlerVarRef = purego.NewCallback(fcb)
122		-	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
123	127		}
124	128
125	129		xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)

@@ -145,30 +149,34 @@ var xSignalGroupConnectData func(uintptr, string, uintptr, uintptr, uintptr, Con
145	149		// You cannot connect a signal handler after #GSignalGroup:target has been set.
146	150		func (x SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {
147	151
148		-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
149	152		var CHandlerVarRef uintptr
150		-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
151		-	CHandlerVarRef = cbRefPtr
152		-	} else {
153		-	fcb := func() {
154		-	cbFn := *CHandlerVar
155		-	cbFn()
	153	+	if CHandlerVar != nil {
	154	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
	155	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
	156	+	CHandlerVarRef = cbRefPtr
	157	+	} else {
	158	+	fcb := func() {
	159	+	cbFn := *CHandlerVar
	160	+	cbFn()
	161	+	}
	162	+	CHandlerVarRef = purego.NewCallback(fcb)
	163	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
156	164		}
157		-	CHandlerVarRef = purego.NewCallback(fcb)
158		-	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
159	165		}
160	166
161		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
162	167		var NotifyVarRef uintptr
163		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
164		-	NotifyVarRef = cbRefPtr
165		-	} else {
166		-	fcb := func(arg0 uintptr, arg1 *Closure) {
167		-	cbFn := *NotifyVar
168		-	cbFn(arg0, arg1)
	168	+	if NotifyVar != nil {
	169	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	170	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	171	+	NotifyVarRef = cbRefPtr
	172	+	} else {
	173	+	fcb := func(arg0 uintptr, arg1 *Closure) {
	174	+	cbFn := *NotifyVar
	175	+	cbFn(arg0, arg1)
	176	+	}
	177	+	NotifyVarRef = purego.NewCallback(fcb)
	178	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
169	179		}
170		-	NotifyVarRef = purego.NewCallback(fcb)
171		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
172	180		}
173	181
174	182		xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar, NotifyVarRef, FlagsVar)

@@ -186,17 +194,19 @@ var xSignalGroupConnectObject func(uintptr, string, uintptr, uintptr, ConnectFla
186	194		// You cannot connect a signal handler after #GSignalGroup:target has been set.
187	195		func (x SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {
188	196
189		-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
190	197		var CHandlerVarRef uintptr
191		-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
192		-	CHandlerVarRef = cbRefPtr
193		-	} else {
194		-	fcb := func() {
195		-	cbFn := *CHandlerVar
196		-	cbFn()
	198	+	if CHandlerVar != nil {
	199	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
	200	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
	201	+	CHandlerVarRef = cbRefPtr
	202	+	} else {
	203	+	fcb := func() {
	204	+	cbFn := *CHandlerVar
	205	+	cbFn()
	206	+	}
	207	+	CHandlerVarRef = purego.NewCallback(fcb)
	208	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
197	209		}
198		-	CHandlerVarRef = purego.NewCallback(fcb)
199		-	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
200	210		}
201	211
202	212		xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, ObjectVar, FlagsVar)

@@ -214,17 +224,19 @@ var xSignalGroupConnectSwapped func(uintptr, string, uintptr, uintptr)
214	224		// You cannot connect a signal handler after #GSignalGroup:target has been set.
215	225		func (x SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
216	226
217		-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
218	227		var CHandlerVarRef uintptr
219		-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
220		-	CHandlerVarRef = cbRefPtr
221		-	} else {
222		-	fcb := func() {
223		-	cbFn := *CHandlerVar
224		-	cbFn()
	228	+	if CHandlerVar != nil {
	229	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
	230	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
	231	+	CHandlerVarRef = cbRefPtr
	232	+	} else {
	233	+	fcb := func() {
	234	+	cbFn := *CHandlerVar
	235	+	cbFn()
	236	+	}
	237	+	CHandlerVarRef = purego.NewCallback(fcb)
	238	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
225	239		}
226		-	CHandlerVarRef = purego.NewCallback(fcb)
227		-	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
228	240		}
229	241
230	242		xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)

M v4/gobject/gtype.go +66 -54


@@ -810,17 +810,19 @@ var xTypeAddClassCacheFunc func(uintptr, uintptr)
810	810		// chain.
811	811		func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
812	812
813		-	CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
814	813		var CacheFuncVarRef uintptr
815		-	if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
816		-	CacheFuncVarRef = cbRefPtr
817		-	} else {
818		-	fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
819		-	cbFn := *CacheFuncVar
820		-	return cbFn(arg0, arg1)
	814	+	if CacheFuncVar != nil {
	815	+	CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
	816	+	if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
	817	+	CacheFuncVarRef = cbRefPtr
	818	+	} else {
	819	+	fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
	820	+	cbFn := *CacheFuncVar
	821	+	return cbFn(arg0, arg1)
	822	+	}
	823	+	CacheFuncVarRef = purego.NewCallback(fcb)
	824	+	glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
821	825		}
822		-	CacheFuncVarRef = purego.NewCallback(fcb)
823		-	glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
824	826		}
825	827
826	828		xTypeAddClassCacheFunc(CacheDataVar, CacheFuncVarRef)

@@ -866,17 +868,19 @@ var xTypeAddInterfaceCheck func(uintptr, uintptr)
866	868		// interfaces.
867	869		func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
868	870
869		-	CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
870	871		var CheckFuncVarRef uintptr
871		-	if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
872		-	CheckFuncVarRef = cbRefPtr
873		-	} else {
874		-	fcb := func(arg0 uintptr, arg1 *TypeInterface) {
875		-	cbFn := *CheckFuncVar
876		-	cbFn(arg0, arg1)
	872	+	if CheckFuncVar != nil {
	873	+	CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
	874	+	if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
	875	+	CheckFuncVarRef = cbRefPtr
	876	+	} else {
	877	+	fcb := func(arg0 uintptr, arg1 *TypeInterface) {
	878	+	cbFn := *CheckFuncVar
	879	+	cbFn(arg0, arg1)
	880	+	}
	881	+	CheckFuncVarRef = purego.NewCallback(fcb)
	882	+	glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
877	883		}
878		-	CheckFuncVarRef = purego.NewCallback(fcb)
879		-	glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
880	884		}
881	885
882	886		xTypeAddInterfaceCheck(CheckDataVar, CheckFuncVarRef)

@@ -1500,30 +1504,34 @@ var xTypeRegisterStaticSimple func(types.GType, string, uint, uintptr, uint, uin
1500	1504		// struct and calling g_type_register_static().
1501	1505		func TypeRegisterStaticSimple(ParentTypeVar types.GType, TypeNameVar string, ClassSizeVar uint, ClassInitVar ClassInitFunc, InstanceSizeVar uint, InstanceInitVar InstanceInitFunc, FlagsVar TypeFlags) types.GType {
1502	1506
1503		-	ClassInitVarPtr := uintptr(unsafe.Pointer(ClassInitVar))
1504	1507		var ClassInitVarRef uintptr
1505		-	if cbRefPtr, ok := glib.GetCallback(ClassInitVarPtr); ok {
1506		-	ClassInitVarRef = cbRefPtr
1507		-	} else {
1508		-	fcb := func(arg0 *TypeClass, arg1 uintptr) {
1509		-	cbFn := *ClassInitVar
1510		-	cbFn(arg0, arg1)
	1508	+	if ClassInitVar != nil {
	1509	+	ClassInitVarPtr := uintptr(unsafe.Pointer(ClassInitVar))
	1510	+	if cbRefPtr, ok := glib.GetCallback(ClassInitVarPtr); ok {
	1511	+	ClassInitVarRef = cbRefPtr
	1512	+	} else {
	1513	+	fcb := func(arg0 *TypeClass, arg1 uintptr) {
	1514	+	cbFn := *ClassInitVar
	1515	+	cbFn(arg0, arg1)
	1516	+	}
	1517	+	ClassInitVarRef = purego.NewCallback(fcb)
	1518	+	glib.SaveCallback(ClassInitVarPtr, ClassInitVarRef)
1511	1519		}
1512		-	ClassInitVarRef = purego.NewCallback(fcb)
1513		-	glib.SaveCallback(ClassInitVarPtr, ClassInitVarRef)
1514	1520		}
1515	1521
1516		-	InstanceInitVarPtr := uintptr(unsafe.Pointer(InstanceInitVar))
1517	1522		var InstanceInitVarRef uintptr
1518		-	if cbRefPtr, ok := glib.GetCallback(InstanceInitVarPtr); ok {
1519		-	InstanceInitVarRef = cbRefPtr
1520		-	} else {
1521		-	fcb := func(arg0 TypeInstance, arg1 TypeClass) {
1522		-	cbFn := *InstanceInitVar
1523		-	cbFn(arg0, arg1)
	1523	+	if InstanceInitVar != nil {
	1524	+	InstanceInitVarPtr := uintptr(unsafe.Pointer(InstanceInitVar))
	1525	+	if cbRefPtr, ok := glib.GetCallback(InstanceInitVarPtr); ok {
	1526	+	InstanceInitVarRef = cbRefPtr
	1527	+	} else {
	1528	+	fcb := func(arg0 TypeInstance, arg1 TypeClass) {
	1529	+	cbFn := *InstanceInitVar
	1530	+	cbFn(arg0, arg1)
	1531	+	}
	1532	+	InstanceInitVarRef = purego.NewCallback(fcb)
	1533	+	glib.SaveCallback(InstanceInitVarPtr, InstanceInitVarRef)
1524	1534		}
1525		-	InstanceInitVarRef = purego.NewCallback(fcb)
1526		-	glib.SaveCallback(InstanceInitVarPtr, InstanceInitVarRef)
1527	1535		}
1528	1536
1529	1537		cret := xTypeRegisterStaticSimple(ParentTypeVar, TypeNameVar, ClassSizeVar, ClassInitVarRef, InstanceSizeVar, InstanceInitVarRef, FlagsVar)

@@ -1537,17 +1545,19 @@ var xTypeRemoveClassCacheFunc func(uintptr, uintptr)
1537	1545		// g_type_remove_class_cache_func() to avoid leaks.
1538	1546		func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
1539	1547
1540		-	CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
1541	1548		var CacheFuncVarRef uintptr
1542		-	if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
1543		-	CacheFuncVarRef = cbRefPtr
1544		-	} else {
1545		-	fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
1546		-	cbFn := *CacheFuncVar
1547		-	return cbFn(arg0, arg1)
	1549	+	if CacheFuncVar != nil {
	1550	+	CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
	1551	+	if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
	1552	+	CacheFuncVarRef = cbRefPtr
	1553	+	} else {
	1554	+	fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
	1555	+	cbFn := *CacheFuncVar
	1556	+	return cbFn(arg0, arg1)
	1557	+	}
	1558	+	CacheFuncVarRef = purego.NewCallback(fcb)
	1559	+	glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
1548	1560		}
1549		-	CacheFuncVarRef = purego.NewCallback(fcb)
1550		-	glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
1551	1561		}
1552	1562
1553	1563		xTypeRemoveClassCacheFunc(CacheDataVar, CacheFuncVarRef)

@@ -1560,17 +1570,19 @@ var xTypeRemoveInterfaceCheck func(uintptr, uintptr)
1560	1570		// g_type_add_interface_check().
1561	1571		func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
1562	1572
1563		-	CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
1564	1573		var CheckFuncVarRef uintptr
1565		-	if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
1566		-	CheckFuncVarRef = cbRefPtr
1567		-	} else {
1568		-	fcb := func(arg0 uintptr, arg1 *TypeInterface) {
1569		-	cbFn := *CheckFuncVar
1570		-	cbFn(arg0, arg1)
	1574	+	if CheckFuncVar != nil {
	1575	+	CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
	1576	+	if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
	1577	+	CheckFuncVarRef = cbRefPtr
	1578	+	} else {
	1579	+	fcb := func(arg0 uintptr, arg1 *TypeInterface) {
	1580	+	cbFn := *CheckFuncVar
	1581	+	cbFn(arg0, arg1)
	1582	+	}
	1583	+	CheckFuncVarRef = purego.NewCallback(fcb)
	1584	+	glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
1571	1585		}
1572		-	CheckFuncVarRef = purego.NewCallback(fcb)
1573		-	glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
1574	1586		}
1575	1587
1576	1588		xTypeRemoveInterfaceCheck(CheckDataVar, CheckFuncVarRef)

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


@@ -848,17 +848,19 @@ var xValueRegisterTransformFunc func(types.GType, types.GType, uintptr)
848	848		// @dest_type will be replaced.
849	849		func ValueRegisterTransformFunc(SrcTypeVar types.GType, DestTypeVar types.GType, TransformFuncVar *ValueTransform) {
850	850
851		-	TransformFuncVarPtr := uintptr(unsafe.Pointer(TransformFuncVar))
852	851		var TransformFuncVarRef uintptr
853		-	if cbRefPtr, ok := glib.GetCallback(TransformFuncVarPtr); ok {
854		-	TransformFuncVarRef = cbRefPtr
855		-	} else {
856		-	fcb := func(arg0 Value, arg1 Value) {
857		-	cbFn := *TransformFuncVar
858		-	cbFn(arg0, arg1)
	852	+	if TransformFuncVar != nil {
	853	+	TransformFuncVarPtr := uintptr(unsafe.Pointer(TransformFuncVar))
	854	+	if cbRefPtr, ok := glib.GetCallback(TransformFuncVarPtr); ok {
	855	+	TransformFuncVarRef = cbRefPtr
	856	+	} else {
	857	+	fcb := func(arg0 Value, arg1 Value) {
	858	+	cbFn := *TransformFuncVar
	859	+	cbFn(arg0, arg1)
	860	+	}
	861	+	TransformFuncVarRef = purego.NewCallback(fcb)
	862	+	glib.SaveCallback(TransformFuncVarPtr, TransformFuncVarRef)
859	863		}
860		-	TransformFuncVarRef = purego.NewCallback(fcb)
861		-	glib.SaveCallback(TransformFuncVarPtr, TransformFuncVarRef)
862	864		}
863	865
864	866		xValueRegisterTransformFunc(SrcTypeVar, DestTypeVar, TransformFuncVarRef)

M v4/gobject/gvaluearray.go +22 -18


@@ -145,17 +145,19 @@ var xValueArraySort func(uintptr, uintptr) *ValueArray
145	145		// C qsort() function.
146	146		func (x ValueArray) Sort(CompareFuncVar glib.CompareFunc) *ValueArray {
147	147
148		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
149	148		var CompareFuncVarRef uintptr
150		-	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
151		-	CompareFuncVarRef = cbRefPtr
152		-	} else {
153		-	fcb := func(arg0 uintptr, arg1 uintptr) int {
154		-	cbFn := *CompareFuncVar
155		-	return cbFn(arg0, arg1)
	149	+	if CompareFuncVar != nil {
	150	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	151	+	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
	152	+	CompareFuncVarRef = cbRefPtr
	153	+	} else {
	154	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
	155	+	cbFn := *CompareFuncVar
	156	+	return cbFn(arg0, arg1)
	157	+	}
	158	+	CompareFuncVarRef = purego.NewCallback(fcb)
	159	+	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
156	160		}
157		-	CompareFuncVarRef = purego.NewCallback(fcb)
158		-	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
159	161		}
160	162
161	163		cret := xValueArraySort(x.GoPointer(), CompareFuncVarRef)

@@ -171,17 +173,19 @@ var xValueArraySortWithData func(uintptr, uintptr, uintptr) *ValueArray
171	173		// C qsort() function.
172	174		func (x ValueArray) SortWithData(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) *ValueArray {
173	175
174		-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
175	176		var CompareFuncVarRef uintptr
176		-	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
177		-	CompareFuncVarRef = cbRefPtr
178		-	} else {
179		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
180		-	cbFn := *CompareFuncVar
181		-	return cbFn(arg0, arg1, arg2)
	177	+	if CompareFuncVar != nil {
	178	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
	179	+	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
	180	+	CompareFuncVarRef = cbRefPtr
	181	+	} else {
	182	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
	183	+	cbFn := *CompareFuncVar
	184	+	return cbFn(arg0, arg1, arg2)
	185	+	}
	186	+	CompareFuncVarRef = purego.NewCallback(fcb)
	187	+	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
182	188		}
183		-	CompareFuncVarRef = purego.NewCallback(fcb)
184		-	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
185	189		}
186	190
187	191		cret := xValueArraySortWithData(x.GoPointer(), CompareFuncVarRef, UserDataVar)

M v4/gsk/gsktypes.go +22 -18


@@ -247,17 +247,19 @@ var xPathForeach func(uintptr, PathForeachFlags, uintptr, uintptr) bool
247	247		// an approximation of the path using just the allowed operations.
248	248		func (x Path) Foreach(FlagsVar PathForeachFlags, FuncVar PathForeachFunc, UserDataVar uintptr) bool {
249	249
250		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
251	250		var FuncVarRef uintptr
252		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
253		-	FuncVarRef = cbRefPtr
254		-	} else {
255		-	fcb := func(arg0 PathOperation, arg1 []graphene.Point, arg2 uint, arg3 float32, arg4 uintptr) bool {
256		-	cbFn := *FuncVar
257		-	return cbFn(arg0, arg1, arg2, arg3, arg4)
	251	+	if FuncVar != nil {
	252	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	253	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	254	+	FuncVarRef = cbRefPtr
	255	+	} else {
	256	+	fcb := func(arg0 PathOperation, arg1 []graphene.Point, arg2 uint, arg3 float32, arg4 uintptr) bool {
	257	+	cbFn := *FuncVar
	258	+	return cbFn(arg0, arg1, arg2, arg3, arg4)
	259	+	}
	260	+	FuncVarRef = purego.NewCallback(fcb)
	261	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
258	262		}
259		-	FuncVarRef = purego.NewCallback(fcb)
260		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
261	263		}
262	264
263	265		cret := xPathForeach(x.GoPointer(), FlagsVar, FuncVarRef, UserDataVar)

@@ -283,17 +285,19 @@ var xPathForeachIntersection func(uintptr, *Path, uintptr, uintptr) bool
283	285		// If @func returns `FALSE`, the iteration is stopped.
284	286		func (x Path) ForeachIntersection(Path2Var Path, FuncVar *PathIntersectionFunc, UserDataVar uintptr) bool {
285	287
286		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
287	288		var FuncVarRef uintptr
288		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
289		-	FuncVarRef = cbRefPtr
290		-	} else {
291		-	fcb := func(arg0 Path, arg1 PathPoint, arg2 Path, arg3 PathPoint, arg4 PathIntersection, arg5 uintptr) bool {
292		-	cbFn := *FuncVar
293		-	return cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
	289	+	if FuncVar != nil {
	290	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	291	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	292	+	FuncVarRef = cbRefPtr
	293	+	} else {
	294	+	fcb := func(arg0 Path, arg1 PathPoint, arg2 Path, arg3 PathPoint, arg4 PathIntersection, arg5 uintptr) bool {
	295	+	cbFn := *FuncVar
	296	+	return cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
	297	+	}
	298	+	FuncVarRef = purego.NewCallback(fcb)
	299	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
294	300		}
295		-	FuncVarRef = purego.NewCallback(fcb)
296		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
297	301		}
298	302
299	303		cret := xPathForeachIntersection(x.GoPointer(), Path2Var, FuncVarRef, UserDataVar)

M v4/gtk/gtkassistant.go +11 -9


@@ -375,17 +375,19 @@ func (x Assistant) SetForwardPageFunc(PageFuncVar AssistantPageFunc, DataVar u
375	375		}
376	376		}
377	377
378		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
379	378		var DestroyVarRef uintptr
380		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
381		-	DestroyVarRef = cbRefPtr
382		-	} else {
383		-	fcb := func(arg0 uintptr) {
384		-	cbFn := *DestroyVar
385		-	cbFn(arg0)
	379	+	if DestroyVar != nil {
	380	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	381	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	382	+	DestroyVarRef = cbRefPtr
	383	+	} else {
	384	+	fcb := func(arg0 uintptr) {
	385	+	cbFn := *DestroyVar
	386	+	cbFn(arg0)
	387	+	}
	388	+	DestroyVarRef = purego.NewCallback(fcb)
	389	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
386	390		}
387		-	DestroyVarRef = purego.NewCallback(fcb)
388		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
389	391		}
390	392
391	393		xAssistantSetForwardPageFunc(x.GoPointer(), PageFuncVarRef, DataVar, DestroyVarRef)

M v4/gtk/gtkbuilderscope.go +22 -18


@@ -274,17 +274,19 @@ var xBuilderCScopeAddCallbackSymbol func(uintptr, string, uintptr)
274	274		// namespace.
275	275		func (x BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar gobject.Callback) {
276	276
277		-	CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
278	277		var CallbackSymbolVarRef uintptr
279		-	if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
280		-	CallbackSymbolVarRef = cbRefPtr
281		-	} else {
282		-	fcb := func() {
283		-	cbFn := *CallbackSymbolVar
284		-	cbFn()
	278	+	if CallbackSymbolVar != nil {
	279	+	CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
	280	+	if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
	281	+	CallbackSymbolVarRef = cbRefPtr
	282	+	} else {
	283	+	fcb := func() {
	284	+	cbFn := *CallbackSymbolVar
	285	+	cbFn()
	286	+	}
	287	+	CallbackSymbolVarRef = purego.NewCallback(fcb)
	288	+	glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
285	289		}
286		-	CallbackSymbolVarRef = purego.NewCallback(fcb)
287		-	glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
288	290		}
289	291
290	292		xBuilderCScopeAddCallbackSymbol(x.GoPointer(), CallbackNameVar, CallbackSymbolVarRef)

@@ -299,17 +301,19 @@ var xBuilderCScopeAddCallbackSymbols func(uintptr, string, uintptr, ...interface
299	301		// for each symbol.
300	302		func (x BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar gobject.Callback, varArgs ...interface{}) {
301	303
302		-	FirstCallbackSymbolVarPtr := uintptr(unsafe.Pointer(FirstCallbackSymbolVar))
303	304		var FirstCallbackSymbolVarRef uintptr
304		-	if cbRefPtr, ok := glib.GetCallback(FirstCallbackSymbolVarPtr); ok {
305		-	FirstCallbackSymbolVarRef = cbRefPtr
306		-	} else {
307		-	fcb := func() {
308		-	cbFn := *FirstCallbackSymbolVar
309		-	cbFn()
	305	+	if FirstCallbackSymbolVar != nil {
	306	+	FirstCallbackSymbolVarPtr := uintptr(unsafe.Pointer(FirstCallbackSymbolVar))
	307	+	if cbRefPtr, ok := glib.GetCallback(FirstCallbackSymbolVarPtr); ok {
	308	+	FirstCallbackSymbolVarRef = cbRefPtr
	309	+	} else {
	310	+	fcb := func() {
	311	+	cbFn := *FirstCallbackSymbolVar
	312	+	cbFn()
	313	+	}
	314	+	FirstCallbackSymbolVarRef = purego.NewCallback(fcb)
	315	+	glib.SaveCallback(FirstCallbackSymbolVarPtr, FirstCallbackSymbolVarRef)
310	316		}
311		-	FirstCallbackSymbolVarRef = purego.NewCallback(fcb)
312		-	glib.SaveCallback(FirstCallbackSymbolVarPtr, FirstCallbackSymbolVarRef)
313	317		}
314	318
315	319		xBuilderCScopeAddCallbackSymbols(x.GoPointer(), FirstCallbackNameVar, FirstCallbackSymbolVarRef, varArgs...)

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


@@ -1299,17 +1299,19 @@ var xCellAreaForeach func(uintptr, uintptr, uintptr)
1299	1299		// Calls @callback for every `GtkCellRenderer` in @area.
1300	1300		func (x CellArea) Foreach(CallbackVar CellCallback, CallbackDataVar uintptr) {
1301	1301
1302		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1303	1302		var CallbackVarRef uintptr
1304		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1305		-	CallbackVarRef = cbRefPtr
1306		-	} else {
1307		-	fcb := func(arg0 uintptr, arg1 uintptr) bool {
1308		-	cbFn := *CallbackVar
1309		-	return cbFn(arg0, arg1)
	1303	+	if CallbackVar != nil {
	1304	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	1305	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	1306	+	CallbackVarRef = cbRefPtr
	1307	+	} else {
	1308	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
	1309	+	cbFn := *CallbackVar
	1310	+	return cbFn(arg0, arg1)
	1311	+	}
	1312	+	CallbackVarRef = purego.NewCallback(fcb)
	1313	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1310	1314		}
1311		-	CallbackVarRef = purego.NewCallback(fcb)
1312		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1313	1315		}
1314	1316
1315	1317		xCellAreaForeach(x.GoPointer(), CallbackVarRef, CallbackDataVar)

@@ -1322,17 +1324,19 @@ var xCellAreaForeachAlloc func(uintptr, uintptr, uintptr, gdk.Rectangle, gdk.R
1322	1324		// allocated rectangle inside @cell_area.
1323	1325		func (x CellArea) ForeachAlloc(ContextVar CellAreaContext, WidgetVar Widget, CellAreaVar gdk.Rectangle, BackgroundAreaVar gdk.Rectangle, CallbackVar CellAllocCallback, CallbackDataVar uintptr) {
1324	1326
1325		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1326	1327		var CallbackVarRef uintptr
1327		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1328		-	CallbackVarRef = cbRefPtr
1329		-	} else {
1330		-	fcb := func(arg0 uintptr, arg1 gdk.Rectangle, arg2 gdk.Rectangle, arg3 uintptr) bool {
1331		-	cbFn := *CallbackVar
1332		-	return cbFn(arg0, arg1, arg2, arg3)
	1328	+	if CallbackVar != nil {
	1329	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	1330	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	1331	+	CallbackVarRef = cbRefPtr
	1332	+	} else {
	1333	+	fcb := func(arg0 uintptr, arg1 gdk.Rectangle, arg2 gdk.Rectangle, arg3 uintptr) bool {
	1334	+	cbFn := *CallbackVar
	1335	+	return cbFn(arg0, arg1, arg2, arg3)
	1336	+	}
	1337	+	CallbackVarRef = purego.NewCallback(fcb)
	1338	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1333	1339		}
1334		-	CallbackVarRef = purego.NewCallback(fcb)
1335		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1336	1340		}
1337	1341
1338	1342		xCellAreaForeachAlloc(x.GoPointer(), ContextVar.GoPointer(), WidgetVar.GoPointer(), CellAreaVar, BackgroundAreaVar, CallbackVarRef, CallbackDataVar)

M v4/gtk/gtkcustomfilter.go +22 -18


@@ -70,17 +70,19 @@ func NewCustomFilter(MatchFuncVar *CustomFilterFunc, UserDataVar uintptr, UserDe
70	70		}
71	71		}
72	72
73		-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
74	73		var UserDestroyVarRef uintptr
75		-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
76		-	UserDestroyVarRef = cbRefPtr
77		-	} else {
78		-	fcb := func(arg0 uintptr) {
79		-	cbFn := *UserDestroyVar
80		-	cbFn(arg0)
	74	+	if UserDestroyVar != nil {
	75	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
	76	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
	77	+	UserDestroyVarRef = cbRefPtr
	78	+	} else {
	79	+	fcb := func(arg0 uintptr) {
	80	+	cbFn := *UserDestroyVar
	81	+	cbFn(arg0)
	82	+	}
	83	+	UserDestroyVarRef = purego.NewCallback(fcb)
	84	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
81	85		}
82		-	UserDestroyVarRef = purego.NewCallback(fcb)
83		-	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
84	86		}
85	87
86	88		cret := xNewCustomFilter(MatchFuncVarRef, UserDataVar, UserDestroyVarRef)

@@ -121,17 +123,19 @@ func (x CustomFilter) SetFilterFunc(MatchFuncVar CustomFilterFunc, UserDataVar
121	123		}
122	124		}
123	125
124		-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
125	126		var UserDestroyVarRef uintptr
126		-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
127		-	UserDestroyVarRef = cbRefPtr
128		-	} else {
129		-	fcb := func(arg0 uintptr) {
130		-	cbFn := *UserDestroyVar
131		-	cbFn(arg0)
	127	+	if UserDestroyVar != nil {
	128	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
	129	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
	130	+	UserDestroyVarRef = cbRefPtr
	131	+	} else {
	132	+	fcb := func(arg0 uintptr) {
	133	+	cbFn := *UserDestroyVar
	134	+	cbFn(arg0)
	135	+	}
	136	+	UserDestroyVarRef = purego.NewCallback(fcb)
	137	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
132	138		}
133		-	UserDestroyVarRef = purego.NewCallback(fcb)
134		-	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
135	139		}
136	140
137	141		xCustomFilterSetFilterFunc(x.GoPointer(), MatchFuncVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtkcustomlayout.go +22 -18


@@ -77,30 +77,34 @@ func NewCustomLayout(RequestModeVar CustomRequestModeFunc, MeasureVar CustomMe
77	77		}
78	78		}
79	79
80		-	MeasureVarPtr := uintptr(unsafe.Pointer(MeasureVar))
81	80		var MeasureVarRef uintptr
82		-	if cbRefPtr, ok := glib.GetCallback(MeasureVarPtr); ok {
83		-	MeasureVarRef = cbRefPtr
84		-	} else {
85		-	fcb := func(arg0 uintptr, arg1 Orientation, arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) {
86		-	cbFn := *MeasureVar
87		-	cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	81	+	if MeasureVar != nil {
	82	+	MeasureVarPtr := uintptr(unsafe.Pointer(MeasureVar))
	83	+	if cbRefPtr, ok := glib.GetCallback(MeasureVarPtr); ok {
	84	+	MeasureVarRef = cbRefPtr
	85	+	} else {
	86	+	fcb := func(arg0 uintptr, arg1 Orientation, arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) {
	87	+	cbFn := *MeasureVar
	88	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	89	+	}
	90	+	MeasureVarRef = purego.NewCallback(fcb)
	91	+	glib.SaveCallback(MeasureVarPtr, MeasureVarRef)
88	92		}
89		-	MeasureVarRef = purego.NewCallback(fcb)
90		-	glib.SaveCallback(MeasureVarPtr, MeasureVarRef)
91	93		}
92	94
93		-	AllocateVarPtr := uintptr(unsafe.Pointer(AllocateVar))
94	95		var AllocateVarRef uintptr
95		-	if cbRefPtr, ok := glib.GetCallback(AllocateVarPtr); ok {
96		-	AllocateVarRef = cbRefPtr
97		-	} else {
98		-	fcb := func(arg0 uintptr, arg1 int, arg2 int, arg3 int) {
99		-	cbFn := *AllocateVar
100		-	cbFn(arg0, arg1, arg2, arg3)
	96	+	if AllocateVar != nil {
	97	+	AllocateVarPtr := uintptr(unsafe.Pointer(AllocateVar))
	98	+	if cbRefPtr, ok := glib.GetCallback(AllocateVarPtr); ok {
	99	+	AllocateVarRef = cbRefPtr
	100	+	} else {
	101	+	fcb := func(arg0 uintptr, arg1 int, arg2 int, arg3 int) {
	102	+	cbFn := *AllocateVar
	103	+	cbFn(arg0, arg1, arg2, arg3)
	104	+	}
	105	+	AllocateVarRef = purego.NewCallback(fcb)
	106	+	glib.SaveCallback(AllocateVarPtr, AllocateVarRef)
101	107		}
102		-	AllocateVarRef = purego.NewCallback(fcb)
103		-	glib.SaveCallback(AllocateVarPtr, AllocateVarRef)
104	108		}
105	109
106	110		cret := xNewCustomLayout(RequestModeVarRef, MeasureVarRef, AllocateVarRef)

M v4/gtk/gtkcustomsorter.go +11 -9


@@ -115,17 +115,19 @@ func (x CustomSorter) SetSortFunc(SortFuncVar glib.CompareDataFunc, UserDataVa
115	115		}
116	116		}
117	117
118		-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
119	118		var UserDestroyVarRef uintptr
120		-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
121		-	UserDestroyVarRef = cbRefPtr
122		-	} else {
123		-	fcb := func(arg0 uintptr) {
124		-	cbFn := *UserDestroyVar
125		-	cbFn(arg0)
	119	+	if UserDestroyVar != nil {
	120	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
	121	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
	122	+	UserDestroyVarRef = cbRefPtr
	123	+	} else {
	124	+	fcb := func(arg0 uintptr) {
	125	+	cbFn := *UserDestroyVar
	126	+	cbFn(arg0)
	127	+	}
	128	+	UserDestroyVarRef = purego.NewCallback(fcb)
	129	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
126	130		}
127		-	UserDestroyVarRef = purego.NewCallback(fcb)
128		-	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
129	131		}
130	132
131	133		xCustomSorterSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtkdrawingarea.go +11 -9


@@ -259,17 +259,19 @@ func (x DrawingArea) SetDrawFunc(DrawFuncVar DrawingAreaDrawFunc, UserDataVar
259	259		}
260	260		}
261	261
262		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
263	262		var DestroyVarRef uintptr
264		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
265		-	DestroyVarRef = cbRefPtr
266		-	} else {
267		-	fcb := func(arg0 uintptr) {
268		-	cbFn := *DestroyVar
269		-	cbFn(arg0)
	263	+	if DestroyVar != nil {
	264	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	265	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	266	+	DestroyVarRef = cbRefPtr
	267	+	} else {
	268	+	fcb := func(arg0 uintptr) {
	269	+	cbFn := *DestroyVar
	270	+	cbFn(arg0)
	271	+	}
	272	+	DestroyVarRef = purego.NewCallback(fcb)
	273	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
270	274		}
271		-	DestroyVarRef = purego.NewCallback(fcb)
272		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
273	275		}
274	276
275	277		xDrawingAreaSetDrawFunc(x.GoPointer(), DrawFuncVarRef, UserDataVar, DestroyVarRef)

M v4/gtk/gtkentrycompletion.go +22 -18


@@ -285,30 +285,34 @@ var xEntryCompletionSetMatchFunc func(uintptr, uintptr, uintptr, uintptr)
285	285		// should not be in the completion list.
286	286		func (x EntryCompletion) SetMatchFunc(FuncVar EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar *glib.DestroyNotify) {
287	287
288		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
289	288		var FuncVarRef uintptr
290		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
291		-	FuncVarRef = cbRefPtr
292		-	} else {
293		-	fcb := func(arg0 uintptr, arg1 string, arg2 *TreeIter, arg3 uintptr) bool {
294		-	cbFn := *FuncVar
295		-	return cbFn(arg0, arg1, arg2, arg3)
	289	+	if FuncVar != nil {
	290	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	291	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	292	+	FuncVarRef = cbRefPtr
	293	+	} else {
	294	+	fcb := func(arg0 uintptr, arg1 string, arg2 *TreeIter, arg3 uintptr) bool {
	295	+	cbFn := *FuncVar
	296	+	return cbFn(arg0, arg1, arg2, arg3)
	297	+	}
	298	+	FuncVarRef = purego.NewCallback(fcb)
	299	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
296	300		}
297		-	FuncVarRef = purego.NewCallback(fcb)
298		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
299	301		}
300	302
301		-	FuncNotifyVarPtr := uintptr(unsafe.Pointer(FuncNotifyVar))
302	303		var FuncNotifyVarRef uintptr
303		-	if cbRefPtr, ok := glib.GetCallback(FuncNotifyVarPtr); ok {
304		-	FuncNotifyVarRef = cbRefPtr
305		-	} else {
306		-	fcb := func(arg0 uintptr) {
307		-	cbFn := *FuncNotifyVar
308		-	cbFn(arg0)
	304	+	if FuncNotifyVar != nil {
	305	+	FuncNotifyVarPtr := uintptr(unsafe.Pointer(FuncNotifyVar))
	306	+	if cbRefPtr, ok := glib.GetCallback(FuncNotifyVarPtr); ok {
	307	+	FuncNotifyVarRef = cbRefPtr
	308	+	} else {
	309	+	fcb := func(arg0 uintptr) {
	310	+	cbFn := *FuncNotifyVar
	311	+	cbFn(arg0)
	312	+	}
	313	+	FuncNotifyVarRef = purego.NewCallback(fcb)
	314	+	glib.SaveCallback(FuncNotifyVarPtr, FuncNotifyVarRef)
309	315		}
310		-	FuncNotifyVarRef = purego.NewCallback(fcb)
311		-	glib.SaveCallback(FuncNotifyVarPtr, FuncNotifyVarRef)
312	316		}
313	317
314	318		xEntryCompletionSetMatchFunc(x.GoPointer(), FuncVarRef, FuncDataVar, FuncNotifyVarRef)

M v4/gtk/gtkexpression.go +33 -27


@@ -196,17 +196,19 @@ func NewCClosureExpression(ValueTypeVar types.GType, MarshalVar *gobject.Closure
196	196		}
197	197		}
198	198
199		-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
200	199		var CallbackFuncVarRef uintptr
201		-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
202		-	CallbackFuncVarRef = cbRefPtr
203		-	} else {
204		-	fcb := func() {
205		-	cbFn := *CallbackFuncVar
206		-	cbFn()
	200	+	if CallbackFuncVar != nil {
	201	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
	202	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
	203	+	CallbackFuncVarRef = cbRefPtr
	204	+	} else {
	205	+	fcb := func() {
	206	+	cbFn := *CallbackFuncVar
	207	+	cbFn()
	208	+	}
	209	+	CallbackFuncVarRef = purego.NewCallback(fcb)
	210	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
207	211		}
208		-	CallbackFuncVarRef = purego.NewCallback(fcb)
209		-	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
210	212		}
211	213
212	214		var UserDestroyVarRef uintptr

@@ -672,30 +674,34 @@ var xExpressionWatch func(uintptr, uintptr, uintptr, uintptr, uintptr) *Expressi
672	674		// the @notify will be invoked.
673	675		func (x Expression) Watch(ThisVar gobject.Object, NotifyVar ExpressionNotify, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *ExpressionWatch {
674	676
675		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
676	677		var NotifyVarRef uintptr
677		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
678		-	NotifyVarRef = cbRefPtr
679		-	} else {
680		-	fcb := func(arg0 uintptr) {
681		-	cbFn := *NotifyVar
682		-	cbFn(arg0)
	678	+	if NotifyVar != nil {
	679	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	680	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	681	+	NotifyVarRef = cbRefPtr
	682	+	} else {
	683	+	fcb := func(arg0 uintptr) {
	684	+	cbFn := *NotifyVar
	685	+	cbFn(arg0)
	686	+	}
	687	+	NotifyVarRef = purego.NewCallback(fcb)
	688	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
683	689		}
684		-	NotifyVarRef = purego.NewCallback(fcb)
685		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
686	690		}
687	691
688		-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
689	692		var UserDestroyVarRef uintptr
690		-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
691		-	UserDestroyVarRef = cbRefPtr
692		-	} else {
693		-	fcb := func(arg0 uintptr) {
694		-	cbFn := *UserDestroyVar
695		-	cbFn(arg0)
	693	+	if UserDestroyVar != nil {
	694	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
	695	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
	696	+	UserDestroyVarRef = cbRefPtr
	697	+	} else {
	698	+	fcb := func(arg0 uintptr) {
	699	+	cbFn := *UserDestroyVar
	700	+	cbFn(arg0)
	701	+	}
	702	+	UserDestroyVarRef = purego.NewCallback(fcb)
	703	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
696	704		}
697		-	UserDestroyVarRef = purego.NewCallback(fcb)
698		-	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
699	705		}
700	706
701	707		cret := xExpressionWatch(x.GoPointer(), ThisVar.GoPointer(), NotifyVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtkflowbox.go +55 -45


@@ -198,30 +198,34 @@ var xFlowBoxBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
198	198		// should be implemented by the model.
199	199		func (x FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
200	200
201		-	CreateWidgetFuncVarPtr := uintptr(unsafe.Pointer(CreateWidgetFuncVar))
202	201		var CreateWidgetFuncVarRef uintptr
203		-	if cbRefPtr, ok := glib.GetCallback(CreateWidgetFuncVarPtr); ok {
204		-	CreateWidgetFuncVarRef = cbRefPtr
205		-	} else {
206		-	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
207		-	cbFn := *CreateWidgetFuncVar
208		-	return cbFn(arg0, arg1)
	202	+	if CreateWidgetFuncVar != nil {
	203	+	CreateWidgetFuncVarPtr := uintptr(unsafe.Pointer(CreateWidgetFuncVar))
	204	+	if cbRefPtr, ok := glib.GetCallback(CreateWidgetFuncVarPtr); ok {
	205	+	CreateWidgetFuncVarRef = cbRefPtr
	206	+	} else {
	207	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
	208	+	cbFn := *CreateWidgetFuncVar
	209	+	return cbFn(arg0, arg1)
	210	+	}
	211	+	CreateWidgetFuncVarRef = purego.NewCallback(fcb)
	212	+	glib.SaveCallback(CreateWidgetFuncVarPtr, CreateWidgetFuncVarRef)
209	213		}
210		-	CreateWidgetFuncVarRef = purego.NewCallback(fcb)
211		-	glib.SaveCallback(CreateWidgetFuncVarPtr, CreateWidgetFuncVarRef)
212	214		}
213	215
214		-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
215	216		var UserDataFreeFuncVarRef uintptr
216		-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
217		-	UserDataFreeFuncVarRef = cbRefPtr
218		-	} else {
219		-	fcb := func(arg0 uintptr) {
220		-	cbFn := *UserDataFreeFuncVar
221		-	cbFn(arg0)
	217	+	if UserDataFreeFuncVar != nil {
	218	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
	219	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
	220	+	UserDataFreeFuncVarRef = cbRefPtr
	221	+	} else {
	222	+	fcb := func(arg0 uintptr) {
	223	+	cbFn := *UserDataFreeFuncVar
	224	+	cbFn(arg0)
	225	+	}
	226	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
	227	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
222	228		}
223		-	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
224		-	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
225	229		}
226	230
227	231		xFlowBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateWidgetFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)

@@ -440,17 +444,19 @@ var xFlowBoxSelectedForeach func(uintptr, uintptr, uintptr)
440	444		// this function.
441	445		func (x FlowBox) SelectedForeach(FuncVar FlowBoxForeachFunc, DataVar uintptr) {
442	446
443		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
444	447		var FuncVarRef uintptr
445		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
446		-	FuncVarRef = cbRefPtr
447		-	} else {
448		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
449		-	cbFn := *FuncVar
450		-	cbFn(arg0, arg1, arg2)
	448	+	if FuncVar != nil {
	449	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	450	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	451	+	FuncVarRef = cbRefPtr
	452	+	} else {
	453	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
	454	+	cbFn := *FuncVar
	455	+	cbFn(arg0, arg1, arg2)
	456	+	}
	457	+	FuncVarRef = purego.NewCallback(fcb)
	458	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
451	459		}
452		-	FuncVarRef = purego.NewCallback(fcb)
453		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
454	460		}
455	461
456	462		xFlowBoxSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)

@@ -508,17 +514,19 @@ func (x FlowBox) SetFilterFunc(FilterFuncVar FlowBoxFilterFunc, UserDataVar ui
508	514		}
509	515		}
510	516
511		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
512	517		var DestroyVarRef uintptr
513		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
514		-	DestroyVarRef = cbRefPtr
515		-	} else {
516		-	fcb := func(arg0 uintptr) {
517		-	cbFn := *DestroyVar
518		-	cbFn(arg0)
	518	+	if DestroyVar != nil {
	519	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	520	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	521	+	DestroyVarRef = cbRefPtr
	522	+	} else {
	523	+	fcb := func(arg0 uintptr) {
	524	+	cbFn := *DestroyVar
	525	+	cbFn(arg0)
	526	+	}
	527	+	DestroyVarRef = purego.NewCallback(fcb)
	528	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
519	529		}
520		-	DestroyVarRef = purego.NewCallback(fcb)
521		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
522	530		}
523	531
524	532		xFlowBoxSetFilterFunc(x.GoPointer(), FilterFuncVarRef, UserDataVar, DestroyVarRef)

@@ -626,17 +634,19 @@ func (x FlowBox) SetSortFunc(SortFuncVar FlowBoxSortFunc, UserDataVar uintptr,
626	634		}
627	635		}
628	636
629		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
630	637		var DestroyVarRef uintptr
631		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
632		-	DestroyVarRef = cbRefPtr
633		-	} else {
634		-	fcb := func(arg0 uintptr) {
635		-	cbFn := *DestroyVar
636		-	cbFn(arg0)
	638	+	if DestroyVar != nil {
	639	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	640	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	641	+	DestroyVarRef = cbRefPtr
	642	+	} else {
	643	+	fcb := func(arg0 uintptr) {
	644	+	cbFn := *DestroyVar
	645	+	cbFn(arg0)
	646	+	}
	647	+	DestroyVarRef = purego.NewCallback(fcb)
	648	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
637	649		}
638		-	DestroyVarRef = purego.NewCallback(fcb)
639		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
640	650		}
641	651
642	652		xFlowBoxSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, DestroyVarRef)

M v4/gtk/gtkiconview.go +11 -9


@@ -536,17 +536,19 @@ var xIconViewSelectedForeach func(uintptr, uintptr, uintptr)
536	536		// selection cannot be modified from within this function.
537	537		func (x IconView) SelectedForeach(FuncVar IconViewForeachFunc, DataVar uintptr) {
538	538
539		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
540	539		var FuncVarRef uintptr
541		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
542		-	FuncVarRef = cbRefPtr
543		-	} else {
544		-	fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
545		-	cbFn := *FuncVar
546		-	cbFn(arg0, arg1, arg2)
	540	+	if FuncVar != nil {
	541	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	542	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	543	+	FuncVarRef = cbRefPtr
	544	+	} else {
	545	+	fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
	546	+	cbFn := *FuncVar
	547	+	cbFn(arg0, arg1, arg2)
	548	+	}
	549	+	FuncVarRef = purego.NewCallback(fcb)
	550	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
547	551		}
548		-	FuncVarRef = purego.NewCallback(fcb)
549		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
550	552		}
551	553
552	554		xIconViewSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)

M v4/gtk/gtklistbox.go +55 -45


@@ -224,17 +224,19 @@ func (x ListBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar ListBox
224	224		}
225	225		}
226	226
227		-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
228	227		var UserDataFreeFuncVarRef uintptr
229		-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
230		-	UserDataFreeFuncVarRef = cbRefPtr
231		-	} else {
232		-	fcb := func(arg0 uintptr) {
233		-	cbFn := *UserDataFreeFuncVar
234		-	cbFn(arg0)
	228	+	if UserDataFreeFuncVar != nil {
	229	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
	230	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
	231	+	UserDataFreeFuncVarRef = cbRefPtr
	232	+	} else {
	233	+	fcb := func(arg0 uintptr) {
	234	+	cbFn := *UserDataFreeFuncVar
	235	+	cbFn(arg0)
	236	+	}
	237	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
	238	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
235	239		}
236		-	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
237		-	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
238	240		}
239	241
240	242		xListBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateWidgetFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)

@@ -503,17 +505,19 @@ var xListBoxSelectedForeach func(uintptr, uintptr, uintptr)
503	505		// Note that the selection cannot be modified from within this function.
504	506		func (x ListBox) SelectedForeach(FuncVar ListBoxForeachFunc, DataVar uintptr) {
505	507
506		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
507	508		var FuncVarRef uintptr
508		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
509		-	FuncVarRef = cbRefPtr
510		-	} else {
511		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
512		-	cbFn := *FuncVar
513		-	cbFn(arg0, arg1, arg2)
	509	+	if FuncVar != nil {
	510	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	511	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	512	+	FuncVarRef = cbRefPtr
	513	+	} else {
	514	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
	515	+	cbFn := *FuncVar
	516	+	cbFn(arg0, arg1, arg2)
	517	+	}
	518	+	FuncVarRef = purego.NewCallback(fcb)
	519	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
514	520		}
515		-	FuncVarRef = purego.NewCallback(fcb)
516		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
517	521		}
518	522
519	523		xListBoxSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)

@@ -580,17 +584,19 @@ func (x ListBox) SetFilterFunc(FilterFuncVar ListBoxFilterFunc, UserDataVar ui
580	584		}
581	585		}
582	586
583		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
584	587		var DestroyVarRef uintptr
585		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
586		-	DestroyVarRef = cbRefPtr
587		-	} else {
588		-	fcb := func(arg0 uintptr) {
589		-	cbFn := *DestroyVar
590		-	cbFn(arg0)
	588	+	if DestroyVar != nil {
	589	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	590	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	591	+	DestroyVarRef = cbRefPtr
	592	+	} else {
	593	+	fcb := func(arg0 uintptr) {
	594	+	cbFn := *DestroyVar
	595	+	cbFn(arg0)
	596	+	}
	597	+	DestroyVarRef = purego.NewCallback(fcb)
	598	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
591	599		}
592		-	DestroyVarRef = purego.NewCallback(fcb)
593		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
594	600		}
595	601
596	602		xListBoxSetFilterFunc(x.GoPointer(), FilterFuncVarRef, UserDataVar, DestroyVarRef)

@@ -641,17 +647,19 @@ func (x ListBox) SetHeaderFunc(UpdateHeaderVar ListBoxUpdateHeaderFunc, UserDa
641	647		}
642	648		}
643	649
644		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
645	650		var DestroyVarRef uintptr
646		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
647		-	DestroyVarRef = cbRefPtr
648		-	} else {
649		-	fcb := func(arg0 uintptr) {
650		-	cbFn := *DestroyVar
651		-	cbFn(arg0)
	651	+	if DestroyVar != nil {
	652	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	653	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	654	+	DestroyVarRef = cbRefPtr
	655	+	} else {
	656	+	fcb := func(arg0 uintptr) {
	657	+	cbFn := *DestroyVar
	658	+	cbFn(arg0)
	659	+	}
	660	+	DestroyVarRef = purego.NewCallback(fcb)
	661	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
652	662		}
653		-	DestroyVarRef = purego.NewCallback(fcb)
654		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
655	663		}
656	664
657	665		xListBoxSetHeaderFunc(x.GoPointer(), UpdateHeaderVarRef, UserDataVar, DestroyVarRef)

@@ -718,17 +726,19 @@ func (x ListBox) SetSortFunc(SortFuncVar ListBoxSortFunc, UserDataVar uintptr,
718	726		}
719	727		}
720	728
721		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
722	729		var DestroyVarRef uintptr
723		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
724		-	DestroyVarRef = cbRefPtr
725		-	} else {
726		-	fcb := func(arg0 uintptr) {
727		-	cbFn := *DestroyVar
728		-	cbFn(arg0)
	730	+	if DestroyVar != nil {
	731	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	732	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	733	+	DestroyVarRef = cbRefPtr
	734	+	} else {
	735	+	fcb := func(arg0 uintptr) {
	736	+	cbFn := *DestroyVar
	737	+	cbFn(arg0)
	738	+	}
	739	+	DestroyVarRef = purego.NewCallback(fcb)
	740	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
729	741		}
730		-	DestroyVarRef = purego.NewCallback(fcb)
731		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
732	742		}
733	743
734	744		xListBoxSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, DestroyVarRef)

M v4/gtk/gtkmaplistmodel.go +22 -18


@@ -101,17 +101,19 @@ func NewMapListModel(ModelVar gio.ListModel, MapFuncVar *MapListModelMapFunc, Us
101	101		}
102	102		}
103	103
104		-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
105	104		var UserDestroyVarRef uintptr
106		-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
107		-	UserDestroyVarRef = cbRefPtr
108		-	} else {
109		-	fcb := func(arg0 uintptr) {
110		-	cbFn := *UserDestroyVar
111		-	cbFn(arg0)
	105	+	if UserDestroyVar != nil {
	106	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
	107	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
	108	+	UserDestroyVarRef = cbRefPtr
	109	+	} else {
	110	+	fcb := func(arg0 uintptr) {
	111	+	cbFn := *UserDestroyVar
	112	+	cbFn(arg0)
	113	+	}
	114	+	UserDestroyVarRef = purego.NewCallback(fcb)
	115	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
112	116		}
113		-	UserDestroyVarRef = purego.NewCallback(fcb)
114		-	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
115	117		}
116	118
117	119		cret := xNewMapListModel(ModelVar.GoPointer(), MapFuncVarRef, UserDataVar, UserDestroyVarRef)

@@ -180,17 +182,19 @@ func (x MapListModel) SetMapFunc(MapFuncVar MapListModelMapFunc, UserDataVar u
180	182		}
181	183		}
182	184
183		-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
184	185		var UserDestroyVarRef uintptr
185		-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
186		-	UserDestroyVarRef = cbRefPtr
187		-	} else {
188		-	fcb := func(arg0 uintptr) {
189		-	cbFn := *UserDestroyVar
190		-	cbFn(arg0)
	186	+	if UserDestroyVar != nil {
	187	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
	188	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
	189	+	UserDestroyVarRef = cbRefPtr
	190	+	} else {
	191	+	fcb := func(arg0 uintptr) {
	192	+	cbFn := *UserDestroyVar
	193	+	cbFn(arg0)
	194	+	}
	195	+	UserDestroyVarRef = purego.NewCallback(fcb)
	196	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
191	197		}
192		-	UserDestroyVarRef = purego.NewCallback(fcb)
193		-	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
194	198		}
195	199
196	200		xMapListModelSetMapFunc(x.GoPointer(), MapFuncVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtkprinter.go +22 -18


@@ -75,30 +75,34 @@ var xEnumeratePrinters func(uintptr, uintptr, uintptr, bool)
75	75		// If @func returns true, the enumeration is stopped.
76	76		func EnumeratePrinters(FuncVar PrinterFunc, DataVar uintptr, DestroyVar glib.DestroyNotify, WaitVar bool) {
77	77
78		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
79	78		var FuncVarRef uintptr
80		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
81		-	FuncVarRef = cbRefPtr
82		-	} else {
83		-	fcb := func(arg0 uintptr, arg1 uintptr) bool {
84		-	cbFn := *FuncVar
85		-	return cbFn(arg0, arg1)
	79	+	if FuncVar != nil {
	80	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	81	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	82	+	FuncVarRef = cbRefPtr
	83	+	} else {
	84	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
	85	+	cbFn := *FuncVar
	86	+	return cbFn(arg0, arg1)
	87	+	}
	88	+	FuncVarRef = purego.NewCallback(fcb)
	89	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
86	90		}
87		-	FuncVarRef = purego.NewCallback(fcb)
88		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
89	91		}
90	92
91		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
92	93		var DestroyVarRef uintptr
93		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
94		-	DestroyVarRef = cbRefPtr
95		-	} else {
96		-	fcb := func(arg0 uintptr) {
97		-	cbFn := *DestroyVar
98		-	cbFn(arg0)
	94	+	if DestroyVar != nil {
	95	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	96	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	97	+	DestroyVarRef = cbRefPtr
	98	+	} else {
	99	+	fcb := func(arg0 uintptr) {
	100	+	cbFn := *DestroyVar
	101	+	cbFn(arg0)
	102	+	}
	103	+	DestroyVarRef = purego.NewCallback(fcb)
	104	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
99	105		}
100		-	DestroyVarRef = purego.NewCallback(fcb)
101		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
102	106		}
103	107
104	108		xEnumeratePrinters(FuncVarRef, DataVar, DestroyVarRef, WaitVar)

M v4/gtk/gtkprintjob.go +22 -18


@@ -232,30 +232,34 @@ var xPrintJobSend func(uintptr, uintptr, uintptr, uintptr)
232	232		// Sends the print job off to the printer.
233	233		func (x PrintJob) Send(CallbackVar PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar *glib.DestroyNotify) {
234	234
235		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
236	235		var CallbackVarRef uintptr
237		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
238		-	CallbackVarRef = cbRefPtr
239		-	} else {
240		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 *glib.Error) {
241		-	cbFn := *CallbackVar
242		-	cbFn(arg0, arg1, arg2)
	236	+	if CallbackVar != nil {
	237	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	238	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	239	+	CallbackVarRef = cbRefPtr
	240	+	} else {
	241	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 *glib.Error) {
	242	+	cbFn := *CallbackVar
	243	+	cbFn(arg0, arg1, arg2)
	244	+	}
	245	+	CallbackVarRef = purego.NewCallback(fcb)
	246	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
243	247		}
244		-	CallbackVarRef = purego.NewCallback(fcb)
245		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
246	248		}
247	249
248		-	DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
249	250		var DnotifyVarRef uintptr
250		-	if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
251		-	DnotifyVarRef = cbRefPtr
252		-	} else {
253		-	fcb := func(arg0 uintptr) {
254		-	cbFn := *DnotifyVar
255		-	cbFn(arg0)
	251	+	if DnotifyVar != nil {
	252	+	DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
	253	+	if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
	254	+	DnotifyVarRef = cbRefPtr
	255	+	} else {
	256	+	fcb := func(arg0 uintptr) {
	257	+	cbFn := *DnotifyVar
	258	+	cbFn(arg0)
	259	+	}
	260	+	DnotifyVarRef = purego.NewCallback(fcb)
	261	+	glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
256	262		}
257		-	DnotifyVarRef = purego.NewCallback(fcb)
258		-	glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
259	263		}
260	264
261	265		xPrintJobSend(x.GoPointer(), CallbackVarRef, UserDataVar, DnotifyVarRef)

M v4/gtk/gtkprintoperation.go +11 -9


@@ -528,17 +528,19 @@ var xPrintRunPageSetupDialogAsync func(uintptr, uintptr, uintptr, uintptr, uintp
528	528		// @done_cb from a signal handler for the ::response signal of the dialog.
529	529		func PrintRunPageSetupDialogAsync(ParentVar Window, PageSetupVar PageSetup, SettingsVar PrintSettings, DoneCbVar PageSetupDoneFunc, DataVar uintptr) {
530	530
531		-	DoneCbVarPtr := uintptr(unsafe.Pointer(DoneCbVar))
532	531		var DoneCbVarRef uintptr
533		-	if cbRefPtr, ok := glib.GetCallback(DoneCbVarPtr); ok {
534		-	DoneCbVarRef = cbRefPtr
535		-	} else {
536		-	fcb := func(arg0 uintptr, arg1 uintptr) {
537		-	cbFn := *DoneCbVar
538		-	cbFn(arg0, arg1)
	532	+	if DoneCbVar != nil {
	533	+	DoneCbVarPtr := uintptr(unsafe.Pointer(DoneCbVar))
	534	+	if cbRefPtr, ok := glib.GetCallback(DoneCbVarPtr); ok {
	535	+	DoneCbVarRef = cbRefPtr
	536	+	} else {
	537	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	538	+	cbFn := *DoneCbVar
	539	+	cbFn(arg0, arg1)
	540	+	}
	541	+	DoneCbVarRef = purego.NewCallback(fcb)
	542	+	glib.SaveCallback(DoneCbVarPtr, DoneCbVarRef)
539	543		}
540		-	DoneCbVarRef = purego.NewCallback(fcb)
541		-	glib.SaveCallback(DoneCbVarPtr, DoneCbVarRef)
542	544		}
543	545
544	546		xPrintRunPageSetupDialogAsync(ParentVar.GoPointer(), PageSetupVar.GoPointer(), SettingsVar.GoPointer(), DoneCbVarRef, DataVar)

M v4/gtk/gtkprintsettings.go +11 -9


@@ -253,17 +253,19 @@ var xPrintSettingsForeach func(uintptr, uintptr, uintptr)
253	253		// Calls @func for each key-value pair of @settings.
254	254		func (x PrintSettings) Foreach(FuncVar PrintSettingsFunc, UserDataVar uintptr) {
255	255
256		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
257	256		var FuncVarRef uintptr
258		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
259		-	FuncVarRef = cbRefPtr
260		-	} else {
261		-	fcb := func(arg0 string, arg1 string, arg2 uintptr) {
262		-	cbFn := *FuncVar
263		-	cbFn(arg0, arg1, arg2)
	257	+	if FuncVar != nil {
	258	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	259	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	260	+	FuncVarRef = cbRefPtr
	261	+	} else {
	262	+	fcb := func(arg0 string, arg1 string, arg2 uintptr) {
	263	+	cbFn := *FuncVar
	264	+	cbFn(arg0, arg1, arg2)
	265	+	}
	266	+	FuncVarRef = purego.NewCallback(fcb)
	267	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
264	268		}
265		-	FuncVarRef = purego.NewCallback(fcb)
266		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
267	269		}
268	270
269	271		xPrintSettingsForeach(x.GoPointer(), FuncVarRef, UserDataVar)

M v4/gtk/gtkshortcutaction.go +22 -18


@@ -164,30 +164,34 @@ var xNewCallbackAction func(uintptr, uintptr, uintptr) uintptr
164	164		func NewCallbackAction(CallbackVar ShortcutFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAction {
165	165		var cls *CallbackAction
166	166
167		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
168	167		var CallbackVarRef uintptr
169		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
170		-	CallbackVarRef = cbRefPtr
171		-	} else {
172		-	fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
173		-	cbFn := *CallbackVar
174		-	return cbFn(arg0, arg1, arg2)
	168	+	if CallbackVar != nil {
	169	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	170	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	171	+	CallbackVarRef = cbRefPtr
	172	+	} else {
	173	+	fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
	174	+	cbFn := *CallbackVar
	175	+	return cbFn(arg0, arg1, arg2)
	176	+	}
	177	+	CallbackVarRef = purego.NewCallback(fcb)
	178	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
175	179		}
176		-	CallbackVarRef = purego.NewCallback(fcb)
177		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
178	180		}
179	181
180		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
181	182		var DestroyVarRef uintptr
182		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
183		-	DestroyVarRef = cbRefPtr
184		-	} else {
185		-	fcb := func(arg0 uintptr) {
186		-	cbFn := *DestroyVar
187		-	cbFn(arg0)
	183	+	if DestroyVar != nil {
	184	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	185	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	186	+	DestroyVarRef = cbRefPtr
	187	+	} else {
	188	+	fcb := func(arg0 uintptr) {
	189	+	cbFn := *DestroyVar
	190	+	cbFn(arg0)
	191	+	}
	192	+	DestroyVarRef = purego.NewCallback(fcb)
	193	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
188	194		}
189		-	DestroyVarRef = purego.NewCallback(fcb)
190		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
191	195		}
192	196
193	197		cret := xNewCallbackAction(CallbackVarRef, DataVar, DestroyVarRef)

M v4/gtk/gtktextbuffer.go +22 -18


@@ -627,30 +627,34 @@ var xTextBufferAddCommitNotify func(uintptr, TextBufferNotifyFlags, uintptr, uin
627	627		// other signal handlers which may further modify the [type@Gtk.TextBuffer].
628	628		func (x TextBuffer) AddCommitNotify(FlagsVar TextBufferNotifyFlags, CommitNotifyVar TextBufferCommitNotify, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) uint {
629	629
630		-	CommitNotifyVarPtr := uintptr(unsafe.Pointer(CommitNotifyVar))
631	630		var CommitNotifyVarRef uintptr
632		-	if cbRefPtr, ok := glib.GetCallback(CommitNotifyVarPtr); ok {
633		-	CommitNotifyVarRef = cbRefPtr
634		-	} else {
635		-	fcb := func(arg0 uintptr, arg1 TextBufferNotifyFlags, arg2 uint, arg3 uint, arg4 uintptr) {
636		-	cbFn := *CommitNotifyVar
637		-	cbFn(arg0, arg1, arg2, arg3, arg4)
	631	+	if CommitNotifyVar != nil {
	632	+	CommitNotifyVarPtr := uintptr(unsafe.Pointer(CommitNotifyVar))
	633	+	if cbRefPtr, ok := glib.GetCallback(CommitNotifyVarPtr); ok {
	634	+	CommitNotifyVarRef = cbRefPtr
	635	+	} else {
	636	+	fcb := func(arg0 uintptr, arg1 TextBufferNotifyFlags, arg2 uint, arg3 uint, arg4 uintptr) {
	637	+	cbFn := *CommitNotifyVar
	638	+	cbFn(arg0, arg1, arg2, arg3, arg4)
	639	+	}
	640	+	CommitNotifyVarRef = purego.NewCallback(fcb)
	641	+	glib.SaveCallback(CommitNotifyVarPtr, CommitNotifyVarRef)
638	642		}
639		-	CommitNotifyVarRef = purego.NewCallback(fcb)
640		-	glib.SaveCallback(CommitNotifyVarPtr, CommitNotifyVarRef)
641	643		}
642	644
643		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
644	645		var DestroyVarRef uintptr
645		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
646		-	DestroyVarRef = cbRefPtr
647		-	} else {
648		-	fcb := func(arg0 uintptr) {
649		-	cbFn := *DestroyVar
650		-	cbFn(arg0)
	646	+	if DestroyVar != nil {
	647	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	648	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	649	+	DestroyVarRef = cbRefPtr
	650	+	} else {
	651	+	fcb := func(arg0 uintptr) {
	652	+	cbFn := *DestroyVar
	653	+	cbFn(arg0)
	654	+	}
	655	+	DestroyVarRef = purego.NewCallback(fcb)
	656	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
651	657		}
652		-	DestroyVarRef = purego.NewCallback(fcb)
653		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
654	658		}
655	659
656	660		cret := xTextBufferAddCommitNotify(x.GoPointer(), FlagsVar, CommitNotifyVarRef, UserDataVar, DestroyVarRef)

M v4/gtk/gtktextiter.go +22 -18


@@ -136,17 +136,19 @@ var xTextIterBackwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
136	136		// but goes backward from @iter.
137	137		func (x TextIter) BackwardFindChar(PredVar TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
138	138
139		-	PredVarPtr := uintptr(unsafe.Pointer(PredVar))
140	139		var PredVarRef uintptr
141		-	if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
142		-	PredVarRef = cbRefPtr
143		-	} else {
144		-	fcb := func(arg0 uint32, arg1 uintptr) bool {
145		-	cbFn := *PredVar
146		-	return cbFn(arg0, arg1)
	140	+	if PredVar != nil {
	141	+	PredVarPtr := uintptr(unsafe.Pointer(PredVar))
	142	+	if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
	143	+	PredVarRef = cbRefPtr
	144	+	} else {
	145	+	fcb := func(arg0 uint32, arg1 uintptr) bool {
	146	+	cbFn := *PredVar
	147	+	return cbFn(arg0, arg1)
	148	+	}
	149	+	PredVarRef = purego.NewCallback(fcb)
	150	+	glib.SaveCallback(PredVarPtr, PredVarRef)
147	151		}
148		-	PredVarRef = purego.NewCallback(fcb)
149		-	glib.SaveCallback(PredVarPtr, PredVarRef)
150	152		}
151	153
152	154		cret := xTextIterBackwardFindChar(x.GoPointer(), PredVarRef, UserDataVar, LimitVar)

@@ -564,17 +566,19 @@ var xTextIterForwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
564	566		// @limit is non-%NULL, otherwise to the end iterator.
565	567		func (x TextIter) ForwardFindChar(PredVar TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
566	568
567		-	PredVarPtr := uintptr(unsafe.Pointer(PredVar))
568	569		var PredVarRef uintptr
569		-	if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
570		-	PredVarRef = cbRefPtr
571		-	} else {
572		-	fcb := func(arg0 uint32, arg1 uintptr) bool {
573		-	cbFn := *PredVar
574		-	return cbFn(arg0, arg1)
	570	+	if PredVar != nil {
	571	+	PredVarPtr := uintptr(unsafe.Pointer(PredVar))
	572	+	if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
	573	+	PredVarRef = cbRefPtr
	574	+	} else {
	575	+	fcb := func(arg0 uint32, arg1 uintptr) bool {
	576	+	cbFn := *PredVar
	577	+	return cbFn(arg0, arg1)
	578	+	}
	579	+	PredVarRef = purego.NewCallback(fcb)
	580	+	glib.SaveCallback(PredVarPtr, PredVarRef)
575	581		}
576		-	PredVarRef = purego.NewCallback(fcb)
577		-	glib.SaveCallback(PredVarPtr, PredVarRef)
578	582		}
579	583
580	584		cret := xTextIterForwardFindChar(x.GoPointer(), PredVarRef, UserDataVar, LimitVar)

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


@@ -94,17 +94,19 @@ var xTextTagTableForeach func(uintptr, uintptr, uintptr)
94	94		// over it (you can’t add/remove tags).
95	95		func (x TextTagTable) Foreach(FuncVar TextTagTableForeach, DataVar uintptr) {
96	96
97		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
98	97		var FuncVarRef uintptr
99		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
100		-	FuncVarRef = cbRefPtr
101		-	} else {
102		-	fcb := func(arg0 uintptr, arg1 uintptr) {
103		-	cbFn := *FuncVar
104		-	cbFn(arg0, arg1)
	98	+	if FuncVar != nil {
	99	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	100	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	101	+	FuncVarRef = cbRefPtr
	102	+	} else {
	103	+	fcb := func(arg0 uintptr, arg1 uintptr) {
	104	+	cbFn := *FuncVar
	105	+	cbFn(arg0, arg1)
	106	+	}
	107	+	FuncVarRef = purego.NewCallback(fcb)
	108	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
105	109		}
106		-	FuncVarRef = purego.NewCallback(fcb)
107		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
108	110		}
109	111
110	112		xTextTagTableForeach(x.GoPointer(), FuncVarRef, DataVar)

M v4/gtk/gtktreelistmodel.go +22 -18


@@ -66,30 +66,34 @@ var xNewTreeListModel func(uintptr, bool, bool, uintptr, uintptr, uintptr) uintp
66	66		func NewTreeListModel(RootVar gio.ListModel, PassthroughVar bool, AutoexpandVar bool, CreateFuncVar TreeListModelCreateModelFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *TreeListModel {
67	67		var cls *TreeListModel
68	68
69		-	CreateFuncVarPtr := uintptr(unsafe.Pointer(CreateFuncVar))
70	69		var CreateFuncVarRef uintptr
71		-	if cbRefPtr, ok := glib.GetCallback(CreateFuncVarPtr); ok {
72		-	CreateFuncVarRef = cbRefPtr
73		-	} else {
74		-	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
75		-	cbFn := *CreateFuncVar
76		-	return cbFn(arg0, arg1)
	70	+	if CreateFuncVar != nil {
	71	+	CreateFuncVarPtr := uintptr(unsafe.Pointer(CreateFuncVar))
	72	+	if cbRefPtr, ok := glib.GetCallback(CreateFuncVarPtr); ok {
	73	+	CreateFuncVarRef = cbRefPtr
	74	+	} else {
	75	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
	76	+	cbFn := *CreateFuncVar
	77	+	return cbFn(arg0, arg1)
	78	+	}
	79	+	CreateFuncVarRef = purego.NewCallback(fcb)
	80	+	glib.SaveCallback(CreateFuncVarPtr, CreateFuncVarRef)
77	81		}
78		-	CreateFuncVarRef = purego.NewCallback(fcb)
79		-	glib.SaveCallback(CreateFuncVarPtr, CreateFuncVarRef)
80	82		}
81	83
82		-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
83	84		var UserDestroyVarRef uintptr
84		-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
85		-	UserDestroyVarRef = cbRefPtr
86		-	} else {
87		-	fcb := func(arg0 uintptr) {
88		-	cbFn := *UserDestroyVar
89		-	cbFn(arg0)
	85	+	if UserDestroyVar != nil {
	86	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
	87	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
	88	+	UserDestroyVarRef = cbRefPtr
	89	+	} else {
	90	+	fcb := func(arg0 uintptr) {
	91	+	cbFn := *UserDestroyVar
	92	+	cbFn(arg0)
	93	+	}
	94	+	UserDestroyVarRef = purego.NewCallback(fcb)
	95	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
90	96		}
91		-	UserDestroyVarRef = purego.NewCallback(fcb)
92		-	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
93	97		}
94	98
95	99		cret := xNewTreeListModel(RootVar.GoPointer(), PassthroughVar, AutoexpandVar, CreateFuncVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtktreemodelfilter.go +22 -18


@@ -291,17 +291,19 @@ var xTreeModelFilterSetModifyFunc func(uintptr, int, []types.GType, uintptr, uin
291	291		// can only be called once for a given filter model.
292	292		func (x TreeModelFilter) SetModifyFunc(NColumnsVar int, TypesVar []types.GType, FuncVar TreeModelFilterModifyFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
293	293
294		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
295	294		var FuncVarRef uintptr
296		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
297		-	FuncVarRef = cbRefPtr
298		-	} else {
299		-	fcb := func(arg0 uintptr, arg1 TreeIter, arg2 gobject.Value, arg3 int, arg4 uintptr) {
300		-	cbFn := *FuncVar
301		-	cbFn(arg0, arg1, arg2, arg3, arg4)
	295	+	if FuncVar != nil {
	296	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	297	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	298	+	FuncVarRef = cbRefPtr
	299	+	} else {
	300	+	fcb := func(arg0 uintptr, arg1 TreeIter, arg2 gobject.Value, arg3 int, arg4 uintptr) {
	301	+	cbFn := *FuncVar
	302	+	cbFn(arg0, arg1, arg2, arg3, arg4)
	303	+	}
	304	+	FuncVarRef = purego.NewCallback(fcb)
	305	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
302	306		}
303		-	FuncVarRef = purego.NewCallback(fcb)
304		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
305	307		}
306	308
307	309		var DestroyVarRef uintptr

@@ -381,17 +383,19 @@ var xTreeModelFilterSetVisibleFunc func(uintptr, uintptr, uintptr, uintptr)
381	383		// once for a given filter model.
382	384		func (x TreeModelFilter) SetVisibleFunc(FuncVar TreeModelFilterVisibleFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
383	385
384		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
385	386		var FuncVarRef uintptr
386		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
387		-	FuncVarRef = cbRefPtr
388		-	} else {
389		-	fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 uintptr) bool {
390		-	cbFn := *FuncVar
391		-	return cbFn(arg0, arg1, arg2)
	387	+	if FuncVar != nil {
	388	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	389	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	390	+	FuncVarRef = cbRefPtr
	391	+	} else {
	392	+	fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 uintptr) bool {
	393	+	cbFn := *FuncVar
	394	+	return cbFn(arg0, arg1, arg2)
	395	+	}
	396	+	FuncVarRef = purego.NewCallback(fcb)
	397	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
392	398		}
393		-	FuncVarRef = purego.NewCallback(fcb)
394		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
395	399		}
396	400
397	401		var DestroyVarRef uintptr

M v4/gtk/gtktreeselection.go +22 -18


@@ -213,17 +213,19 @@ var xTreeSelectionSelectedForeach func(uintptr, uintptr, uintptr)
213	213		// gtk_tree_selection_get_selected_rows() might be more useful.
214	214		func (x TreeSelection) SelectedForeach(FuncVar TreeSelectionForeachFunc, DataVar uintptr) {
215	215
216		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
217	216		var FuncVarRef uintptr
218		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
219		-	FuncVarRef = cbRefPtr
220		-	} else {
221		-	fcb := func(arg0 uintptr, arg1 TreePath, arg2 TreeIter, arg3 uintptr) {
222		-	cbFn := *FuncVar
223		-	cbFn(arg0, arg1, arg2, arg3)
	217	+	if FuncVar != nil {
	218	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	219	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	220	+	FuncVarRef = cbRefPtr
	221	+	} else {
	222	+	fcb := func(arg0 uintptr, arg1 TreePath, arg2 TreeIter, arg3 uintptr) {
	223	+	cbFn := *FuncVar
	224	+	cbFn(arg0, arg1, arg2, arg3)
	225	+	}
	226	+	FuncVarRef = purego.NewCallback(fcb)
	227	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
224	228		}
225		-	FuncVarRef = purego.NewCallback(fcb)
226		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
227	229		}
228	230
229	231		xTreeSelectionSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)

@@ -266,17 +268,19 @@ func (x TreeSelection) SetSelectFunction(FuncVar TreeSelectionFunc, DataVar ui
266	268		}
267	269		}
268	270
269		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
270	271		var DestroyVarRef uintptr
271		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
272		-	DestroyVarRef = cbRefPtr
273		-	} else {
274		-	fcb := func(arg0 uintptr) {
275		-	cbFn := *DestroyVar
276		-	cbFn(arg0)
	272	+	if DestroyVar != nil {
	273	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	274	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	275	+	DestroyVarRef = cbRefPtr
	276	+	} else {
	277	+	fcb := func(arg0 uintptr) {
	278	+	cbFn := *DestroyVar
	279	+	cbFn(arg0)
	280	+	}
	281	+	DestroyVarRef = purego.NewCallback(fcb)
	282	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
277	283		}
278		-	DestroyVarRef = purego.NewCallback(fcb)
279		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
280	284		}
281	285
282	286		xTreeSelectionSetSelectFunction(x.GoPointer(), FuncVarRef, DataVar, DestroyVarRef)

M v4/gtk/gtktreeview.go +44 -36


@@ -1193,30 +1193,34 @@ var xTreeViewInsertColumnWithDataFunc func(uintptr, int, string, uintptr, uintpt
1193	1193		// “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
1194	1194		func (x TreeView) InsertColumnWithDataFunc(PositionVar int, TitleVar string, CellVar CellRenderer, FuncVar TreeCellDataFunc, DataVar uintptr, DnotifyVar glib.DestroyNotify) int {
1195	1195
1196		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1197	1196		var FuncVarRef uintptr
1198		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
1199		-	FuncVarRef = cbRefPtr
1200		-	} else {
1201		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 *TreeIter, arg4 uintptr) {
1202		-	cbFn := *FuncVar
1203		-	cbFn(arg0, arg1, arg2, arg3, arg4)
	1197	+	if FuncVar != nil {
	1198	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	1199	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	1200	+	FuncVarRef = cbRefPtr
	1201	+	} else {
	1202	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 *TreeIter, arg4 uintptr) {
	1203	+	cbFn := *FuncVar
	1204	+	cbFn(arg0, arg1, arg2, arg3, arg4)
	1205	+	}
	1206	+	FuncVarRef = purego.NewCallback(fcb)
	1207	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
1204	1208		}
1205		-	FuncVarRef = purego.NewCallback(fcb)
1206		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
1207	1209		}
1208	1210
1209		-	DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
1210	1211		var DnotifyVarRef uintptr
1211		-	if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
1212		-	DnotifyVarRef = cbRefPtr
1213		-	} else {
1214		-	fcb := func(arg0 uintptr) {
1215		-	cbFn := *DnotifyVar
1216		-	cbFn(arg0)
	1212	+	if DnotifyVar != nil {
	1213	+	DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
	1214	+	if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
	1215	+	DnotifyVarRef = cbRefPtr
	1216	+	} else {
	1217	+	fcb := func(arg0 uintptr) {
	1218	+	cbFn := *DnotifyVar
	1219	+	cbFn(arg0)
	1220	+	}
	1221	+	DnotifyVarRef = purego.NewCallback(fcb)
	1222	+	glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
1217	1223		}
1218		-	DnotifyVarRef = purego.NewCallback(fcb)
1219		-	glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
1220	1224		}
1221	1225
1222	1226		cret := xTreeViewInsertColumnWithDataFunc(x.GoPointer(), PositionVar, TitleVar, CellVar.GoPointer(), FuncVarRef, DataVar, DnotifyVarRef)

@@ -1263,17 +1267,19 @@ var xTreeViewMapExpandedRows func(uintptr, uintptr, uintptr)
1263	1267		// Calls @func on all expanded rows.
1264	1268		func (x TreeView) MapExpandedRows(FuncVar TreeViewMappingFunc, DataVar uintptr) {
1265	1269
1266		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1267	1270		var FuncVarRef uintptr
1268		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
1269		-	FuncVarRef = cbRefPtr
1270		-	} else {
1271		-	fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
1272		-	cbFn := *FuncVar
1273		-	cbFn(arg0, arg1, arg2)
	1271	+	if FuncVar != nil {
	1272	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	1273	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	1274	+	FuncVarRef = cbRefPtr
	1275	+	} else {
	1276	+	fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
	1277	+	cbFn := *FuncVar
	1278	+	cbFn(arg0, arg1, arg2)
	1279	+	}
	1280	+	FuncVarRef = purego.NewCallback(fcb)
	1281	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
1274	1282		}
1275		-	FuncVarRef = purego.NewCallback(fcb)
1276		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
1277	1283		}
1278	1284
1279	1285		xTreeViewMapExpandedRows(x.GoPointer(), FuncVarRef, DataVar)

@@ -1699,17 +1705,19 @@ var xTreeViewSetSearchEqualFunc func(uintptr, uintptr, uintptr, uintptr)
1699	1705		// `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
1700	1706		func (x TreeView) SetSearchEqualFunc(SearchEqualFuncVar TreeViewSearchEqualFunc, SearchUserDataVar uintptr, SearchDestroyVar *glib.DestroyNotify) {
1701	1707
1702		-	SearchEqualFuncVarPtr := uintptr(unsafe.Pointer(SearchEqualFuncVar))
1703	1708		var SearchEqualFuncVarRef uintptr
1704		-	if cbRefPtr, ok := glib.GetCallback(SearchEqualFuncVarPtr); ok {
1705		-	SearchEqualFuncVarRef = cbRefPtr
1706		-	} else {
1707		-	fcb := func(arg0 uintptr, arg1 int, arg2 string, arg3 *TreeIter, arg4 uintptr) bool {
1708		-	cbFn := *SearchEqualFuncVar
1709		-	return cbFn(arg0, arg1, arg2, arg3, arg4)
	1709	+	if SearchEqualFuncVar != nil {
	1710	+	SearchEqualFuncVarPtr := uintptr(unsafe.Pointer(SearchEqualFuncVar))
	1711	+	if cbRefPtr, ok := glib.GetCallback(SearchEqualFuncVarPtr); ok {
	1712	+	SearchEqualFuncVarRef = cbRefPtr
	1713	+	} else {
	1714	+	fcb := func(arg0 uintptr, arg1 int, arg2 string, arg3 *TreeIter, arg4 uintptr) bool {
	1715	+	cbFn := *SearchEqualFuncVar
	1716	+	return cbFn(arg0, arg1, arg2, arg3, arg4)
	1717	+	}
	1718	+	SearchEqualFuncVarRef = purego.NewCallback(fcb)
	1719	+	glib.SaveCallback(SearchEqualFuncVarPtr, SearchEqualFuncVarRef)
1710	1720		}
1711		-	SearchEqualFuncVarRef = purego.NewCallback(fcb)
1712		-	glib.SaveCallback(SearchEqualFuncVarPtr, SearchEqualFuncVarRef)
1713	1721		}
1714	1722
1715	1723		var SearchDestroyVarRef uintptr

M v4/gtk/gtktreeviewcolumn.go +11 -9


@@ -538,17 +538,19 @@ func (x TreeViewColumn) SetCellDataFunc(CellRendererVar CellRenderer, FuncVar
538	538		}
539	539		}
540	540
541		-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
542	541		var DestroyVarRef uintptr
543		-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
544		-	DestroyVarRef = cbRefPtr
545		-	} else {
546		-	fcb := func(arg0 uintptr) {
547		-	cbFn := *DestroyVar
548		-	cbFn(arg0)
	542	+	if DestroyVar != nil {
	543	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
	544	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
	545	+	DestroyVarRef = cbRefPtr
	546	+	} else {
	547	+	fcb := func(arg0 uintptr) {
	548	+	cbFn := *DestroyVar
	549	+	cbFn(arg0)
	550	+	}
	551	+	DestroyVarRef = purego.NewCallback(fcb)
	552	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
549	553		}
550		-	DestroyVarRef = purego.NewCallback(fcb)
551		-	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
552	554		}
553	555
554	556		xTreeViewColumnSetCellDataFunc(x.GoPointer(), CellRendererVar.GoPointer(), FuncVarRef, FuncDataVar, DestroyVarRef)

M v4/gtk/gtkwidget.go +55 -45


@@ -159,17 +159,19 @@ var xWidgetClassAddBinding func(uintptr, uint, gdk.ModifierType, uintptr, string
159	159		// shortcut.
160	160		func (x WidgetClass) AddBinding(KeyvalVar uint, ModsVar gdk.ModifierType, CallbackVar ShortcutFunc, FormatStringVar string, varArgs ...interface{}) {
161	161
162		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
163	162		var CallbackVarRef uintptr
164		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
165		-	CallbackVarRef = cbRefPtr
166		-	} else {
167		-	fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
168		-	cbFn := *CallbackVar
169		-	return cbFn(arg0, arg1, arg2)
	163	+	if CallbackVar != nil {
	164	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	165	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	166	+	CallbackVarRef = cbRefPtr
	167	+	} else {
	168	+	fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
	169	+	cbFn := *CallbackVar
	170	+	return cbFn(arg0, arg1, arg2)
	171	+	}
	172	+	CallbackVarRef = purego.NewCallback(fcb)
	173	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
170	174		}
171		-	CallbackVarRef = purego.NewCallback(fcb)
172		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
173	175		}
174	176
175	177		xWidgetClassAddBinding(x.GoPointer(), KeyvalVar, ModsVar, CallbackVarRef, FormatStringVar, varArgs...)

@@ -241,17 +243,19 @@ var xWidgetClassBindTemplateCallbackFull func(uintptr, string, uintptr)
241	243		// class initializer after calling [method@Gtk.WidgetClass.set_template].
242	244		func (x WidgetClass) BindTemplateCallbackFull(CallbackNameVar string, CallbackSymbolVar gobject.Callback) {
243	245
244		-	CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
245	246		var CallbackSymbolVarRef uintptr
246		-	if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
247		-	CallbackSymbolVarRef = cbRefPtr
248		-	} else {
249		-	fcb := func() {
250		-	cbFn := *CallbackSymbolVar
251		-	cbFn()
	247	+	if CallbackSymbolVar != nil {
	248	+	CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
	249	+	if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
	250	+	CallbackSymbolVarRef = cbRefPtr
	251	+	} else {
	252	+	fcb := func() {
	253	+	cbFn := *CallbackSymbolVar
	254	+	cbFn()
	255	+	}
	256	+	CallbackSymbolVarRef = purego.NewCallback(fcb)
	257	+	glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
252	258		}
253		-	CallbackSymbolVarRef = purego.NewCallback(fcb)
254		-	glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
255	259		}
256	260
257	261		xWidgetClassBindTemplateCallbackFull(x.GoPointer(), CallbackNameVar, CallbackSymbolVarRef)

@@ -354,17 +358,19 @@ var xWidgetClassInstallAction func(uintptr, string, string, uintptr)
354	358		// with [method@Gtk.Widget.action_set_enabled]).
355	359		func (x WidgetClass) InstallAction(ActionNameVar string, ParameterTypeVar string, ActivateVar WidgetActionActivateFunc) {
356	360
357		-	ActivateVarPtr := uintptr(unsafe.Pointer(ActivateVar))
358	361		var ActivateVarRef uintptr
359		-	if cbRefPtr, ok := glib.GetCallback(ActivateVarPtr); ok {
360		-	ActivateVarRef = cbRefPtr
361		-	} else {
362		-	fcb := func(arg0 uintptr, arg1 string, arg2 *glib.Variant) {
363		-	cbFn := *ActivateVar
364		-	cbFn(arg0, arg1, arg2)
	362	+	if ActivateVar != nil {
	363	+	ActivateVarPtr := uintptr(unsafe.Pointer(ActivateVar))
	364	+	if cbRefPtr, ok := glib.GetCallback(ActivateVarPtr); ok {
	365	+	ActivateVarRef = cbRefPtr
	366	+	} else {
	367	+	fcb := func(arg0 uintptr, arg1 string, arg2 *glib.Variant) {
	368	+	cbFn := *ActivateVar
	369	+	cbFn(arg0, arg1, arg2)
	370	+	}
	371	+	ActivateVarRef = purego.NewCallback(fcb)
	372	+	glib.SaveCallback(ActivateVarPtr, ActivateVarRef)
365	373		}
366		-	ActivateVarRef = purego.NewCallback(fcb)
367		-	glib.SaveCallback(ActivateVarPtr, ActivateVarRef)
368	374		}
369	375
370	376		xWidgetClassInstallAction(x.GoPointer(), ActionNameVar, ParameterTypeVar, ActivateVarRef)

@@ -1871,30 +1877,34 @@ var xWidgetAddTickCallback func(uintptr, uintptr, uintptr, uintptr) uint
1871	1877		// to [method@Gtk.Widget.remove_tick_callback].
1872	1878		func (x Widget) AddTickCallback(CallbackVar TickCallback, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) uint {
1873	1879
1874		-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1875	1880		var CallbackVarRef uintptr
1876		-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1877		-	CallbackVarRef = cbRefPtr
1878		-	} else {
1879		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
1880		-	cbFn := *CallbackVar
1881		-	return cbFn(arg0, arg1, arg2)
	1881	+	if CallbackVar != nil {
	1882	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
	1883	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
	1884	+	CallbackVarRef = cbRefPtr
	1885	+	} else {
	1886	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
	1887	+	cbFn := *CallbackVar
	1888	+	return cbFn(arg0, arg1, arg2)
	1889	+	}
	1890	+	CallbackVarRef = purego.NewCallback(fcb)
	1891	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1882	1892		}
1883		-	CallbackVarRef = purego.NewCallback(fcb)
1884		-	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1885	1893		}
1886	1894
1887		-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1888	1895		var NotifyVarRef uintptr
1889		-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
1890		-	NotifyVarRef = cbRefPtr
1891		-	} else {
1892		-	fcb := func(arg0 uintptr) {
1893		-	cbFn := *NotifyVar
1894		-	cbFn(arg0)
	1896	+	if NotifyVar != nil {
	1897	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
	1898	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
	1899	+	NotifyVarRef = cbRefPtr
	1900	+	} else {
	1901	+	fcb := func(arg0 uintptr) {
	1902	+	cbFn := *NotifyVar
	1903	+	cbFn(arg0)
	1904	+	}
	1905	+	NotifyVarRef = purego.NewCallback(fcb)
	1906	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1895	1907		}
1896		-	NotifyVarRef = purego.NewCallback(fcb)
1897		-	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1898	1908		}
1899	1909
1900	1910		cret := xWidgetAddTickCallback(x.GoPointer(), CallbackVarRef, UserDataVar, NotifyVarRef)

M v4/pango/pango-attributes.go +11 -9


@@ -390,17 +390,19 @@ var xAttrListFilter func(uintptr, uintptr, uintptr) *AttrList
390	390		// inserts them into a new list.
391	391		func (x AttrList) Filter(FuncVar AttrFilterFunc, DataVar uintptr) *AttrList {
392	392
393		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
394	393		var FuncVarRef uintptr
395		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
396		-	FuncVarRef = cbRefPtr
397		-	} else {
398		-	fcb := func(arg0 *Attribute, arg1 uintptr) bool {
399		-	cbFn := *FuncVar
400		-	return cbFn(arg0, arg1)
	394	+	if FuncVar != nil {
	395	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	396	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	397	+	FuncVarRef = cbRefPtr
	398	+	} else {
	399	+	fcb := func(arg0 *Attribute, arg1 uintptr) bool {
	400	+	cbFn := *FuncVar
	401	+	return cbFn(arg0, arg1)
	402	+	}
	403	+	FuncVarRef = purego.NewCallback(fcb)
	404	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
401	405		}
402		-	FuncVarRef = purego.NewCallback(fcb)
403		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
404	406		}
405	407
406	408		cret := xAttrListFilter(x.GoPointer(), FuncVarRef, DataVar)

M v4/pango/pango-fontset.go +11 -9


@@ -289,17 +289,19 @@ var xFontsetForeach func(uintptr, uintptr, uintptr)
289	289		// If @func returns %TRUE, that stops the iteration.
290	290		func (x Fontset) Foreach(FuncVar FontsetForeachFunc, DataVar uintptr) {
291	291
292		-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
293	292		var FuncVarRef uintptr
294		-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
295		-	FuncVarRef = cbRefPtr
296		-	} else {
297		-	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
298		-	cbFn := *FuncVar
299		-	return cbFn(arg0, arg1, arg2)
	293	+	if FuncVar != nil {
	294	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
	295	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
	296	+	FuncVarRef = cbRefPtr
	297	+	} else {
	298	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
	299	+	cbFn := *FuncVar
	300	+	return cbFn(arg0, arg1, arg2)
	301	+	}
	302	+	FuncVarRef = purego.NewCallback(fcb)
	303	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
300	304		}
301		-	FuncVarRef = purego.NewCallback(fcb)
302		-	glib.SaveCallback(FuncVarPtr, FuncVarRef)
303	305		}
304	306
305	307		xFontsetForeach(x.GoPointer(), FuncVarRef, DataVar)