detached c2d6ab6

fix: wrap callback parameters with closures

commit
c2d6ab62b9645bb0279d968dc2a03c5397d0b83f
author
brice · · 2025-12-10 18:32 UTC
parent
9ff73d6
signature
unsigned
145 files · +7991 -425
Unified
UnifiedSplit
M internal/gir/pass/pass.go +52 -13
@@ -423,20 +423,59 @@ func (p *Pass) writeGo(r types.Repository, gotemp *template.Template, dir string
423423 // as they should only be loaded when there are classes
424424 needsInit := (len(functions[fn]) + methods) > 0
425425
426+ // Check if any receiver method has callback parameters
427+ // This is used to conditionally import unsafe and purego
428+ hasReceiverCallbacks := false
429+ for _, rec := range records[fn] {
430+ for _, r := range rec.Receivers {
431+ if len(r.Args.Callbacks) > 0 {
432+ hasReceiverCallbacks = true
433+ break
434+ }
435+ }
436+ if hasReceiverCallbacks {
437+ break
438+ }
439+ }
440+ if !hasReceiverCallbacks {
441+ for _, cls := range classes[fn] {
442+ for _, r := range cls.Receivers {
443+ if len(r.Args.Callbacks) > 0 {
444+ hasReceiverCallbacks = true
445+ break
446+ }
447+ }
448+ if hasReceiverCallbacks {
449+ break
450+ }
451+ }
452+ }
453+
454+ // Check if any standalone function has callback parameters
455+ hasFunctionCallbacks := false
456+ for _, f := range functions[fn] {
457+ if len(f.Args.Callbacks) > 0 {
458+ hasFunctionCallbacks = true
459+ break
460+ }
461+ }
462+
426463 args := types.TemplateArg{
427- PkgName: pkgName,
428- PkgEnv: strings.ToUpper(pkgName),
429- PkgConfigName: pkgConfigName,
430- SharedLibraries: sharedLibraries,
431- NeedsInit: needsInit,
432- Aliases: aliases[fn],
433- Callbacks: callbacks[fn],
434- Records: records[fn],
435- Enums: enums[fn],
436- Constants: constants[fn],
437- Functions: functions[fn],
438- Interfaces: interfaces[fn],
439- Classes: classes[fn],
464+ PkgName: pkgName,
465+ PkgEnv: strings.ToUpper(pkgName),
466+ PkgConfigName: pkgConfigName,
467+ SharedLibraries: sharedLibraries,
468+ NeedsInit: needsInit,
469+ HasReceiverCallbacks: hasReceiverCallbacks,
470+ HasFunctionCallbacks: hasFunctionCallbacks,
471+ Aliases: aliases[fn],
472+ Callbacks: callbacks[fn],
473+ Records: records[fn],
474+ Enums: enums[fn],
475+ Constants: constants[fn],
476+ Functions: functions[fn],
477+ Interfaces: interfaces[fn],
478+ Classes: classes[fn],
440479 }
441480
442481 os.MkdirAll(fmt.Sprintf(dir+"/%s", pkgName), 0o755)
M internal/gir/types/kind.go +11 -0
@@ -53,6 +53,17 @@ func (km KindMap) MustInterface(ns string, name string) Interface {
5353 return p.Value.(Interface)
5454 }
5555
56+// GetCallback retrieves a callback definition by namespace and name.
57+// Returns the Callback and true if found, otherwise nil and false.
58+func (km KindMap) GetCallback(ns string, name string) (Callback, bool) {
59+ p := km.pair(ns, name)
60+ if p.K != CallbackType {
61+ return Callback{}, false
62+ }
63+ cb, ok := p.Value.(Callback)
64+ return cb, ok
65+}
66+
5667 type KindPair struct {
5768 K Kind
5869 Value interface{}
M internal/gir/types/template.go +70 -1
@@ -17,9 +17,27 @@ type argsTemplate struct {
1717 // Call are the variables as given in a function call
1818 Call []string
1919
20+ // CallWithRefs is like Call but with callback parameters using {name}Ref
21+ // for use in contexts that generate closure wrappers
22+ CallWithRefs []string
23+
2024 Full []string
2125 }
2226
27+// CallbackParam holds metadata for callback parameters to enable proper closure generation
28+type CallbackParam struct {
29+ // Name is the parameter name (e.g., "CallbackVar")
30+ Name string
31+ // TypeName is the callback type name (e.g., "TickCallback")
32+ TypeName string
33+ // PureTypes are the pure argument types for the closure
34+ PureTypes []string
35+ // RetRaw is the return type for the closure (e.g., "bool")
36+ RetRaw string
37+ // Nullable indicates if the callback can be nil
38+ Nullable bool
39+}
40+
2341 type funcArgsTemplate struct {
2442 // Pure are the arguments as passed directly to PureGo
2543 // The pure Call is a special case that contains the arguments for a callback call
@@ -27,16 +45,20 @@ type funcArgsTemplate struct {
2745
2846 // API are the arguments as suitable for a Go API
2947 API argsTemplate
48+
49+ // Callbacks tracks callback parameters for proper closure generation
50+ Callbacks []CallbackParam
3051 }
3152
3253 func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullable bool, isOut bool) {
3354 c := n
55+ cRef := n // For CallWithRefs, defaults to same as Call
3456 stars := strings.Count(t, "*")
3557 gobjectNs := "gobject."
58+ glibNs := "glib."
3659 if strings.ToLower(ns) == "gobject" {
3760 gobjectNs = ""
3861 }
39- glibNs := "glib."
4062 if strings.ToLower(ns) == "glib" {
4163 glibNs = ""
4264 }
@@ -48,14 +70,19 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
4870 t = "*" + t
4971 }
5072 c = n
73+ cRef = n
5174 } else {
5275 switch k {
5376 case CallbackType:
77+ // Call uses glib.NewCallback for contexts like callback accessor getters
5478 if nullable {
5579 c = fmt.Sprintf("%sNewCallbackNullable(%s)", glibNs, n)
5680 } else {
5781 c = fmt.Sprintf("%sNewCallback(%s)", glibNs, n)
5882 }
83+ // For CallWithRefs, start with the same value as Call
84+ // It will be updated to {name}Ref in Add() if the callback lookup succeeds
85+ cRef = c
5986 t = "*" + t
6087 case ClassesType:
6188 if stars == 0 {
@@ -66,6 +93,7 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
6693 } else if stars == 1 {
6794 c = n + ".GoPointer()"
6895 }
96+ cRef = c
6997 case InterfacesType:
7098 t = strings.TrimPrefix(t, "*")
7199 if stars == 0 {
@@ -76,17 +104,22 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
76104 } else if stars == 1 {
77105 c = n + ".GoPointer()"
78106 }
107+ cRef = c
108+ default:
109+ cRef = c
79110 }
80111
81112 // special case for varargs
82113 if n == "varArgs" {
83114 c = n + "..."
115+ cRef = c
84116 }
85117 }
86118
87119 f.API.Names = append(f.API.Names, n)
88120 f.API.Types = append(f.API.Types, t)
89121 f.API.Call = append(f.API.Call, c)
122+ f.API.CallWithRefs = append(f.API.CallWithRefs, cRef)
90123 f.API.Full = append(f.API.Full, n+" "+t)
91124 }
92125
@@ -153,6 +186,9 @@ func (f *funcArgsTemplate) Add(p Parameter, ins string, ns string, kinds KindMap
153186 goType := p.Translate(lns, kinds)
154187 kind := kinds.Kind(lns, goType)
155188
189+ // Save the original type name before normalization for callback lookup
190+ originalType := goType
191+
156192 stars := strings.Count(goType, "*")
157193 goType = util.NormalizeNamespace(ns, goType, true)
158194
@@ -170,10 +206,38 @@ func (f *funcArgsTemplate) Add(p Parameter, ins string, ns string, kinds KindMap
170206
171207 f.AddAPI(goType, varName, kind, ns, p.Nullable, isOut)
172208 f.AddPure(goType, varName, kind, isOut)
209+
210+ // For callback parameters (not out parameters), populate callback metadata
211+ // This enables the template to generate proper closure wrapping
212+ if kind == CallbackType && !isOut {
213+ if cb, ok := kinds.GetCallback(lns, originalType); ok {
214+ // Get the callback's pure argument types and return type
215+ cbArgs := cb.Parameters.Template(lns, "", kinds, cb.Throws)
216+ var retRaw string
217+ if cb.ReturnValue != nil {
218+ cbRet := cb.ReturnValue.Template(lns, "", kinds, cb.Throws)
219+ retRaw = cbRet.Raw
220+ }
221+
222+ f.Callbacks = append(f.Callbacks, CallbackParam{
223+ Name: varName,
224+ TypeName: strings.TrimPrefix(goType, "*"),
225+ PureTypes: cbArgs.Pure.Types,
226+ RetRaw: retRaw,
227+ Nullable: p.Nullable,
228+ })
229+
230+ // Update CallWithRefs to use {name}Ref since we have the callback info
231+ // for generating the closure wrapper
232+ lastIdx := len(f.API.CallWithRefs) - 1
233+ f.API.CallWithRefs[lastIdx] = varName + "Ref"
234+ }
235+ }
173236 }
174237
175238 func (f *funcArgsTemplate) AddThrows(ns string) {
176239 f.API.Call = append(f.API.Call, "&cerr")
240+ f.API.CallWithRefs = append(f.API.CallWithRefs, "&cerr")
177241 if strings.ToLower(ns) != "glib" {
178242 f.Pure.Types = append(f.Pure.Types, "**glib.Error")
179243 } else {
@@ -483,6 +547,11 @@ type TemplateArg struct {
483547 SharedLibraries []string
484548 // NeedsInit declares whether or not this file needs an init code to register functions with purego
485549 NeedsInit bool
550+ // HasReceiverCallbacks indicates if any receiver method has callback parameters
551+ // This is used to conditionally import unsafe and purego
552+ HasReceiverCallbacks bool
553+ // HasFunctionCallbacks indicates if any standalone function has callback parameters
554+ HasFunctionCallbacks bool
486555 // Imports defines the package imports that we need
487556 // This does not include purego
488557 // As the template already includes that if `NeedsInit` is set to true
M templates/go +202 -9
@@ -9,9 +9,10 @@ package {{.PkgName}}
99 {{ $HasSignals = true }}
1010 {{end}}
1111 {{end}}
12-{{ $NeedsUnsafe := or .Records $HasSignals }}
13-{{ $NeedsPurego := or .NeedsInit $HasSignals }}
14-{{ $AnyImports := or .NeedsInit .Records $HasSignals }}
12+{{ $HasCallbacks := or .HasReceiverCallbacks .HasFunctionCallbacks }}
13+{{ $NeedsUnsafe := or .Records $HasSignals $HasCallbacks }}
14+{{ $NeedsPurego := or .NeedsInit $HasSignals $HasCallbacks }}
15+{{ $AnyImports := or .NeedsInit .Records $HasSignals $HasCallbacks }}
1516
1617 {{if $AnyImports}}
1718 import (
@@ -66,7 +67,39 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
6667 {{.Doc}}
6768 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
6869 {{.Ret.Preamble $NotGLib}}
69- {{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.Call}})
70+ {{- /* Generate closure wrappers for callback parameters */}}
71+ {{range .Args.Callbacks}}
72+ {{if .Nullable -}}
73+ var {{.Name}}Ref uintptr
74+ if {{.Name}} != nil {
75+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
76+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
77+ {{.Name}}Ref = cbRefPtr
78+ } else {
79+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
80+ cbFn := *{{.Name}}
81+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
82+ }
83+ {{.Name}}Ref = purego.NewCallback(fcb)
84+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
85+ }
86+ }
87+ {{- else -}}
88+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
89+ var {{.Name}}Ref uintptr
90+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
91+ {{.Name}}Ref = cbRefPtr
92+ } else {
93+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
94+ cbFn := *{{.Name}}
95+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
96+ }
97+ {{.Name}}Ref = purego.NewCallback(fcb)
98+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
99+ }
100+ {{- end}}
101+ {{end}}
102+ {{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
70103 {{.Ret.Fmt $NotGObject}}
71104 }
72105 {{end}}
@@ -78,7 +111,39 @@ var x{{$outer.Name}}{{.Name}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Ra
78111 {{.Doc}}
79112 func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
80113 {{.Ret.Preamble $NotGLib}}
81- {{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.Call}})
114+ {{- /* Generate closure wrappers for callback parameters */}}
115+ {{range .Args.Callbacks}}
116+ {{if .Nullable -}}
117+ var {{.Name}}Ref uintptr
118+ if {{.Name}} != nil {
119+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
120+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
121+ {{.Name}}Ref = cbRefPtr
122+ } else {
123+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
124+ cbFn := *{{.Name}}
125+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
126+ }
127+ {{.Name}}Ref = purego.NewCallback(fcb)
128+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
129+ }
130+ }
131+ {{- else -}}
132+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
133+ var {{.Name}}Ref uintptr
134+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
135+ {{.Name}}Ref = cbRefPtr
136+ } else {
137+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
138+ cbFn := *{{.Name}}
139+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
140+ }
141+ {{.Name}}Ref = purego.NewCallback(fcb)
142+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
143+ }
144+ {{- end}}
145+ {{end}}
146+ {{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.CallWithRefs}})
82147 {{.Ret.Fmt $NotGObject}}
83148 }
84149 {{end}}
@@ -239,7 +304,39 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
239304 {{.Doc}}
240305 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
241306 {{.Ret.Preamble $NotGLib}}
242- {{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.Call}})
307+ {{- /* Generate closure wrappers for callback parameters */}}
308+ {{range .Args.Callbacks}}
309+ {{if .Nullable -}}
310+ var {{.Name}}Ref uintptr
311+ if {{.Name}} != nil {
312+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
313+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
314+ {{.Name}}Ref = cbRefPtr
315+ } else {
316+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
317+ cbFn := *{{.Name}}
318+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
319+ }
320+ {{.Name}}Ref = purego.NewCallback(fcb)
321+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
322+ }
323+ }
324+ {{- else -}}
325+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
326+ var {{.Name}}Ref uintptr
327+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
328+ {{.Name}}Ref = cbRefPtr
329+ } else {
330+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
331+ cbFn := *{{.Name}}
332+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
333+ }
334+ {{.Name}}Ref = purego.NewCallback(fcb)
335+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
336+ }
337+ {{- end}}
338+ {{end}}
339+ {{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
243340 {{.Ret.Fmt $NotGObject}}
244341 }
245342 {{end}}
@@ -274,7 +371,39 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
274371 {{.Doc}}
275372 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
276373 {{.Ret.Preamble $NotGLib}}
277- {{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.Call}})
374+ {{- /* Generate closure wrappers for callback parameters */}}
375+ {{range .Args.Callbacks}}
376+ {{if .Nullable -}}
377+ var {{.Name}}Ref uintptr
378+ if {{.Name}} != nil {
379+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
380+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
381+ {{.Name}}Ref = cbRefPtr
382+ } else {
383+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
384+ cbFn := *{{.Name}}
385+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
386+ }
387+ {{.Name}}Ref = purego.NewCallback(fcb)
388+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
389+ }
390+ }
391+ {{- else -}}
392+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
393+ var {{.Name}}Ref uintptr
394+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
395+ {{.Name}}Ref = cbRefPtr
396+ } else {
397+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
398+ cbFn := *{{.Name}}
399+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
400+ }
401+ {{.Name}}Ref = purego.NewCallback(fcb)
402+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
403+ }
404+ {{- end}}
405+ {{end}}
406+ {{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
278407 {{.Ret.Fmt $NotGObject}}
279408 }
280409 {{end}}
@@ -286,7 +415,39 @@ var x{{$outer.Name}}{{.Name}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Ra
286415 {{.Doc}}
287416 func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
288417 {{.Ret.Preamble $NotGLib}}
289- {{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.Call}})
418+ {{- /* Generate closure wrappers for callback parameters */}}
419+ {{range .Args.Callbacks}}
420+ {{if .Nullable -}}
421+ var {{.Name}}Ref uintptr
422+ if {{.Name}} != nil {
423+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
424+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
425+ {{.Name}}Ref = cbRefPtr
426+ } else {
427+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
428+ cbFn := *{{.Name}}
429+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
430+ }
431+ {{.Name}}Ref = purego.NewCallback(fcb)
432+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
433+ }
434+ }
435+ {{- else -}}
436+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
437+ var {{.Name}}Ref uintptr
438+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
439+ {{.Name}}Ref = cbRefPtr
440+ } else {
441+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
442+ cbFn := *{{.Name}}
443+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
444+ }
445+ {{.Name}}Ref = purego.NewCallback(fcb)
446+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
447+ }
448+ {{- end}}
449+ {{end}}
450+ {{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.CallWithRefs}})
290451 {{.Ret.Fmt $NotGObject}}
291452 }
292453 {{end}}
@@ -369,7 +530,39 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
369530 {{.Doc}}
370531 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
371532 {{.Ret.Preamble $NotGLib}}
372- {{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.Call}})
533+ {{- /* Generate closure wrappers for callback parameters */}}
534+ {{range .Args.Callbacks}}
535+ {{if .Nullable -}}
536+ var {{.Name}}Ref uintptr
537+ if {{.Name}} != nil {
538+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
539+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
540+ {{.Name}}Ref = cbRefPtr
541+ } else {
542+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
543+ cbFn := *{{.Name}}
544+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
545+ }
546+ {{.Name}}Ref = purego.NewCallback(fcb)
547+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
548+ }
549+ }
550+ {{- else -}}
551+ {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
552+ var {{.Name}}Ref uintptr
553+ if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
554+ {{.Name}}Ref = cbRefPtr
555+ } else {
556+ fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
557+ cbFn := *{{.Name}}
558+ {{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
559+ }
560+ {{.Name}}Ref = purego.NewCallback(fcb)
561+ {{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
562+ }
563+ {{- end}}
564+ {{end}}
565+ {{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
373566 {{.Ret.Fmt $NotGObject}}
374567 }
375568 {{end}}
M v4/adw/adw-alert-dialog.go +16 -1
@@ -321,7 +321,22 @@ var xAlertDialogChoose func(uintptr, uintptr, uintptr, uintptr, uintptr)
321321 // will be shown within it. Otherwise, it will be a separate window.
322322 func (x *AlertDialog) Choose(ParentVar *gtk.Widget, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
323323
324- xAlertDialogChoose(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
324+ var CallbackVarRef uintptr
325+ if CallbackVar != nil {
326+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
327+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
328+ CallbackVarRef = cbRefPtr
329+ } else {
330+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
331+ cbFn := *CallbackVar
332+ cbFn(arg0, arg1, arg2)
333+ }
334+ CallbackVarRef = purego.NewCallback(fcb)
335+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
336+ }
337+ }
338+
339+ xAlertDialogChoose(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
325340
326341 }
327342
M v4/adw/adw-animation-target.go +27 -1
@@ -92,7 +92,33 @@ var xNewCallbackAnimationTarget func(uintptr, uintptr, uintptr) uintptr
9292 func NewCallbackAnimationTarget(CallbackVar *AnimationTargetFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) *CallbackAnimationTarget {
9393 var cls *CallbackAnimationTarget
9494
95- cret := xNewCallbackAnimationTarget(glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(DestroyVar))
95+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
96+ 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)
103+ }
104+ CallbackVarRef = purego.NewCallback(fcb)
105+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
106+ }
107+
108+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
109+ 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)
116+ }
117+ DestroyVarRef = purego.NewCallback(fcb)
118+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
119+ }
120+
121+ cret := xNewCallbackAnimationTarget(CallbackVarRef, UserDataVar, DestroyVarRef)
96122
97123 if cret == 0 {
98124 return nil
M v4/adw/adw-message-dialog.go +16 -1
@@ -294,7 +294,22 @@ var xMessageDialogChoose func(uintptr, uintptr, uintptr, uintptr)
294294 // This function shows @self to the user.
295295 func (x *MessageDialog) Choose(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
296296
297- xMessageDialogChoose(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
297+ var CallbackVarRef uintptr
298+ if CallbackVar != nil {
299+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
300+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
301+ CallbackVarRef = cbRefPtr
302+ } else {
303+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
304+ cbFn := *CallbackVar
305+ cbFn(arg0, arg1, arg2)
306+ }
307+ CallbackVarRef = purego.NewCallback(fcb)
308+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
309+ }
310+ }
311+
312+ xMessageDialogChoose(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
298313
299314 }
300315
M v4/adw/adw-preferences-group.go +29 -1
@@ -113,7 +113,35 @@ var xPreferencesGroupBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
113113 // See [method@Gtk.ListBox.bind_model].
114114 func (x *PreferencesGroup) BindModel(ModelVar gio.ListModel, CreateRowFuncVar *gtk.ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
115115
116- xPreferencesGroupBindModel(x.GoPointer(), ModelVar.GoPointer(), glib.NewCallbackNullable(CreateRowFuncVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
116+ var CreateRowFuncVarRef uintptr
117+ if CreateRowFuncVar != nil {
118+ CreateRowFuncVarPtr := uintptr(unsafe.Pointer(CreateRowFuncVar))
119+ if cbRefPtr, ok := glib.GetCallback(CreateRowFuncVarPtr); ok {
120+ CreateRowFuncVarRef = cbRefPtr
121+ } else {
122+ fcb := func(arg0 uintptr, arg1 uintptr) *Widget {
123+ cbFn := *CreateRowFuncVar
124+ return cbFn(arg0, arg1)
125+ }
126+ CreateRowFuncVarRef = purego.NewCallback(fcb)
127+ glib.SaveCallback(CreateRowFuncVarPtr, CreateRowFuncVarRef)
128+ }
129+ }
130+
131+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
132+ 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)
139+ }
140+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
141+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
142+ }
143+
144+ xPreferencesGroupBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateRowFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)
117145
118146 }
119147
M v4/gdk/gdkclipboard.go +80 -5
@@ -114,7 +114,22 @@ var xClipboardReadAsync func(uintptr, []string, int, uintptr, uintptr, uintptr)
114114 // to fulfill the request, preferring the ones listed first.
115115 func (x *Clipboard) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
116116
117- xClipboardReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
117+ var CallbackVarRef uintptr
118+ if CallbackVar != nil {
119+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
120+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
121+ CallbackVarRef = cbRefPtr
122+ } else {
123+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
124+ cbFn := *CallbackVar
125+ cbFn(arg0, arg1, arg2)
126+ }
127+ CallbackVarRef = purego.NewCallback(fcb)
128+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
129+ }
130+ }
131+
132+ xClipboardReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
118133
119134 }
120135
@@ -150,7 +165,22 @@ var xClipboardReadTextAsync func(uintptr, uintptr, uintptr, uintptr)
150165 // need more control over the operation.
151166 func (x *Clipboard) ReadTextAsync(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
152167
153- xClipboardReadTextAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
168+ var CallbackVarRef uintptr
169+ if CallbackVar != nil {
170+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
171+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
172+ CallbackVarRef = cbRefPtr
173+ } else {
174+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
175+ cbFn := *CallbackVar
176+ cbFn(arg0, arg1, arg2)
177+ }
178+ CallbackVarRef = purego.NewCallback(fcb)
179+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
180+ }
181+ }
182+
183+ xClipboardReadTextAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
154184
155185 }
156186
@@ -179,7 +209,22 @@ var xClipboardReadTextureAsync func(uintptr, uintptr, uintptr, uintptr)
179209 // need more control over the operation.
180210 func (x *Clipboard) ReadTextureAsync(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
181211
182- xClipboardReadTextureAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
212+ var CallbackVarRef uintptr
213+ if CallbackVar != nil {
214+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
215+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
216+ CallbackVarRef = cbRefPtr
217+ } else {
218+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
219+ cbFn := *CallbackVar
220+ cbFn(arg0, arg1, arg2)
221+ }
222+ CallbackVarRef = purego.NewCallback(fcb)
223+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
224+ }
225+ }
226+
227+ xClipboardReadTextureAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
183228
184229 }
185230
@@ -216,7 +261,22 @@ var xClipboardReadValueAsync func(uintptr, types.GType, int, uintptr, uintptr, u
216261 // [func@content_deserialize_async] to convert the clipboard's data.
217262 func (x *Clipboard) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
218263
219- xClipboardReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
264+ var CallbackVarRef uintptr
265+ if CallbackVar != nil {
266+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
267+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
268+ CallbackVarRef = cbRefPtr
269+ } else {
270+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
271+ cbFn := *CallbackVar
272+ cbFn(arg0, arg1, arg2)
273+ }
274+ CallbackVarRef = purego.NewCallback(fcb)
275+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
276+ }
277+ }
278+
279+ xClipboardReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
220280
221281 }
222282
@@ -327,7 +387,22 @@ var xClipboardStoreAsync func(uintptr, int, uintptr, uintptr, uintptr)
327387 // is shut down, so you likely don't need to call it.
328388 func (x *Clipboard) StoreAsync(IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
329389
330- xClipboardStoreAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
390+ var CallbackVarRef uintptr
391+ if CallbackVar != nil {
392+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
393+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
394+ CallbackVarRef = cbRefPtr
395+ } else {
396+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
397+ cbFn := *CallbackVar
398+ cbFn(arg0, arg1, arg2)
399+ }
400+ CallbackVarRef = purego.NewCallback(fcb)
401+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
402+ }
403+ }
404+
405+ xClipboardStoreAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
331406
332407 }
333408
M v4/gdk/gdkcontentdeserializer.go +59 -3
@@ -2,6 +2,8 @@
22 package gdk
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -25,7 +27,22 @@ var xContentDeserializeAsync func(uintptr, string, types.GType, int, uintptr, ui
2527 // indicate a higher priority.
2628 func ContentDeserializeAsync(StreamVar *gio.InputStream, MimeTypeVar string, TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
2729
28- xContentDeserializeAsync(StreamVar.GoPointer(), MimeTypeVar, TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
30+ var CallbackVarRef uintptr
31+ if CallbackVar != nil {
32+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
33+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
34+ CallbackVarRef = cbRefPtr
35+ } else {
36+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
37+ cbFn := *CallbackVar
38+ cbFn(arg0, arg1, arg2)
39+ }
40+ CallbackVarRef = purego.NewCallback(fcb)
41+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
42+ }
43+ }
44+
45+ xContentDeserializeAsync(StreamVar.GoPointer(), MimeTypeVar, TypeVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
2946
3047 }
3148
@@ -52,7 +69,33 @@ var xContentRegisterDeserializer func(string, types.GType, uintptr, uintptr, uin
5269 // so applications can override the built-in deserializers.
5370 func ContentRegisterDeserializer(MimeTypeVar string, TypeVar types.GType, DeserializeVar *ContentDeserializeFunc, DataVar uintptr, NotifyVar *glib.DestroyNotify) {
5471
55- xContentRegisterDeserializer(MimeTypeVar, TypeVar, glib.NewCallback(DeserializeVar), DataVar, glib.NewCallback(NotifyVar))
72+ DeserializeVarPtr := uintptr(unsafe.Pointer(DeserializeVar))
73+ 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)
80+ }
81+ DeserializeVarRef = purego.NewCallback(fcb)
82+ glib.SaveCallback(DeserializeVarPtr, DeserializeVarRef)
83+ }
84+
85+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
86+ 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)
93+ }
94+ NotifyVarRef = purego.NewCallback(fcb)
95+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
96+ }
97+
98+ xContentRegisterDeserializer(MimeTypeVar, TypeVar, DeserializeVarRef, DataVar, NotifyVarRef)
5699
57100 }
58101
@@ -203,7 +246,20 @@ var xContentDeserializerSetTaskData func(uintptr, uintptr, uintptr)
203246 // Associate data with the current deserialization operation.
204247 func (x *ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar *glib.DestroyNotify) {
205248
206- xContentDeserializerSetTaskData(x.GoPointer(), DataVar, glib.NewCallback(NotifyVar))
249+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
250+ 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)
257+ }
258+ NotifyVarRef = purego.NewCallback(fcb)
259+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
260+ }
261+
262+ xContentDeserializerSetTaskData(x.GoPointer(), DataVar, NotifyVarRef)
207263
208264 }
209265
M v4/gdk/gdkcontentprovider.go +16 -1
@@ -402,7 +402,22 @@ var xContentProviderWriteMimeTypeAsync func(uintptr, string, uintptr, int, uintp
402402 // The given @stream will not be closed.
403403 func (x *ContentProvider) WriteMimeTypeAsync(MimeTypeVar string, StreamVar *gio.OutputStream, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
404404
405- xContentProviderWriteMimeTypeAsync(x.GoPointer(), MimeTypeVar, StreamVar.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
405+ var CallbackVarRef uintptr
406+ if CallbackVar != nil {
407+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
408+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
409+ CallbackVarRef = cbRefPtr
410+ } else {
411+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
412+ cbFn := *CallbackVar
413+ cbFn(arg0, arg1, arg2)
414+ }
415+ CallbackVarRef = purego.NewCallback(fcb)
416+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
417+ }
418+ }
419+
420+ xContentProviderWriteMimeTypeAsync(x.GoPointer(), MimeTypeVar, StreamVar.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
406421
407422 }
408423
M v4/gdk/gdkcontentserializer.go +59 -3
@@ -2,6 +2,8 @@
22 package gdk
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -26,7 +28,33 @@ var xContentRegisterSerializer func(types.GType, string, uintptr, uintptr, uintp
2628 // so applications can override the built-in serializers.
2729 func ContentRegisterSerializer(TypeVar types.GType, MimeTypeVar string, SerializeVar *ContentSerializeFunc, DataVar uintptr, NotifyVar *glib.DestroyNotify) {
2830
29- xContentRegisterSerializer(TypeVar, MimeTypeVar, glib.NewCallback(SerializeVar), DataVar, glib.NewCallback(NotifyVar))
31+ SerializeVarPtr := uintptr(unsafe.Pointer(SerializeVar))
32+ 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)
39+ }
40+ SerializeVarRef = purego.NewCallback(fcb)
41+ glib.SaveCallback(SerializeVarPtr, SerializeVarRef)
42+ }
43+
44+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
45+ 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)
52+ }
53+ NotifyVarRef = purego.NewCallback(fcb)
54+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
55+ }
56+
57+ xContentRegisterSerializer(TypeVar, MimeTypeVar, SerializeVarRef, DataVar, NotifyVarRef)
3058
3159 }
3260
@@ -38,7 +66,22 @@ var xContentSerializeAsync func(uintptr, string, *gobject.Value, int, uintptr, u
3866 // indicate a higher priority.
3967 func ContentSerializeAsync(StreamVar *gio.OutputStream, MimeTypeVar string, ValueVar *gobject.Value, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
4068
41- xContentSerializeAsync(StreamVar.GoPointer(), MimeTypeVar, ValueVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
69+ var CallbackVarRef uintptr
70+ if CallbackVar != nil {
71+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
72+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
73+ CallbackVarRef = cbRefPtr
74+ } else {
75+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
76+ cbFn := *CallbackVar
77+ cbFn(arg0, arg1, arg2)
78+ }
79+ CallbackVarRef = purego.NewCallback(fcb)
80+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
81+ }
82+ }
83+
84+ xContentSerializeAsync(StreamVar.GoPointer(), MimeTypeVar, ValueVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
4285
4386 }
4487
@@ -204,7 +247,20 @@ var xContentSerializerSetTaskData func(uintptr, uintptr, uintptr)
204247 // Associate data with the current serialization operation.
205248 func (x *ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar *glib.DestroyNotify) {
206249
207- xContentSerializerSetTaskData(x.GoPointer(), DataVar, glib.NewCallback(NotifyVar))
250+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
251+ 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)
258+ }
259+ NotifyVarRef = purego.NewCallback(fcb)
260+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
261+ }
262+
263+ xContentSerializerSetTaskData(x.GoPointer(), DataVar, NotifyVarRef)
208264
209265 }
210266
M v4/gdk/gdkcursor.go +29 -1
@@ -2,6 +2,8 @@
22 package gdk
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -82,7 +84,33 @@ var xNewCursorFromCallback func(uintptr, uintptr, uintptr, uintptr) uintptr
8284 func NewCursorFromCallback(CallbackVar *CursorGetTextureCallback, DataVar uintptr, DestroyVar *glib.DestroyNotify, FallbackVar *Cursor) *Cursor {
8385 var cls *Cursor
8486
85- cret := xNewCursorFromCallback(glib.NewCallback(CallbackVar), DataVar, glib.NewCallback(DestroyVar), FallbackVar.GoPointer())
87+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
88+ 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)
95+ }
96+ CallbackVarRef = purego.NewCallback(fcb)
97+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
98+ }
99+
100+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
101+ 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)
108+ }
109+ DestroyVarRef = purego.NewCallback(fcb)
110+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
111+ }
112+
113+ cret := xNewCursorFromCallback(CallbackVarRef, DataVar, DestroyVarRef, FallbackVar.GoPointer())
86114
87115 if cret == 0 {
88116 return nil
M v4/gdk/gdkdmabuftexturebuilder.go +16 -1
@@ -131,7 +131,22 @@ func (x *DmabufTextureBuilder) Build(DestroyVar *glib.DestroyNotify, DataVar uin
131131 var cls *Texture
132132 var cerr *glib.Error
133133
134- cret := xDmabufTextureBuilderBuild(x.GoPointer(), glib.NewCallbackNullable(DestroyVar), DataVar, &cerr)
134+ var DestroyVarRef uintptr
135+ if DestroyVar != nil {
136+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
137+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
138+ DestroyVarRef = cbRefPtr
139+ } else {
140+ fcb := func(arg0 uintptr) {
141+ cbFn := *DestroyVar
142+ cbFn(arg0)
143+ }
144+ DestroyVarRef = purego.NewCallback(fcb)
145+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
146+ }
147+ }
148+
149+ cret := xDmabufTextureBuilderBuild(x.GoPointer(), DestroyVarRef, DataVar, &cerr)
135150
136151 if cret == 0 {
137152 return nil, cerr
M v4/gdk/gdkdrop.go +34 -2
@@ -2,6 +2,8 @@
22 package gdk
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -161,7 +163,22 @@ var xDropReadAsync func(uintptr, []string, int, uintptr, uintptr, uintptr)
161163 // in a format that complies with one of the mime types.
162164 func (x *Drop) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
163165
164- xDropReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
166+ var CallbackVarRef uintptr
167+ if CallbackVar != nil {
168+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
169+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
170+ CallbackVarRef = cbRefPtr
171+ } else {
172+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
173+ cbFn := *CallbackVar
174+ cbFn(arg0, arg1, arg2)
175+ }
176+ CallbackVarRef = purego.NewCallback(fcb)
177+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
178+ }
179+ }
180+
181+ xDropReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
165182
166183 }
167184
@@ -203,7 +220,22 @@ var xDropReadValueAsync func(uintptr, types.GType, int, uintptr, uintptr, uintpt
203220 // try to use [func@Gdk.content_deserialize_async] to convert the data.
204221 func (x *Drop) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
205222
206- xDropReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
223+ var CallbackVarRef uintptr
224+ if CallbackVar != nil {
225+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
226+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
227+ CallbackVarRef = cbRefPtr
228+ } else {
229+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
230+ cbFn := *CallbackVar
231+ cbFn(arg0, arg1, arg2)
232+ }
233+ CallbackVarRef = purego.NewCallback(fcb)
234+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
235+ }
236+ }
237+
238+ xDropReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
207239
208240 }
209241
M v4/gdk/gdkgltexture.go +14 -1
@@ -47,7 +47,20 @@ var xNewGLTexture func(uintptr, uint, int, int, uintptr, uintptr) uintptr
4747 func NewGLTexture(ContextVar *GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar *glib.DestroyNotify, DataVar uintptr) *GLTexture {
4848 var cls *GLTexture
4949
50- cret := xNewGLTexture(ContextVar.GoPointer(), IdVar, WidthVar, HeightVar, glib.NewCallback(DestroyVar), DataVar)
50+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
51+ 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)
58+ }
59+ DestroyVarRef = purego.NewCallback(fcb)
60+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
61+ }
62+
63+ cret := xNewGLTexture(ContextVar.GoPointer(), IdVar, WidthVar, HeightVar, DestroyVarRef, DataVar)
5164
5265 if cret == 0 {
5366 return nil
M v4/gdk/gdkgltexturebuilder.go +16 -1
@@ -81,7 +81,22 @@ var xGLTextureBuilderBuild func(uintptr, uintptr, uintptr) uintptr
8181 func (x *GLTextureBuilder) Build(DestroyVar *glib.DestroyNotify, DataVar uintptr) *Texture {
8282 var cls *Texture
8383
84- cret := xGLTextureBuilderBuild(x.GoPointer(), glib.NewCallbackNullable(DestroyVar), DataVar)
84+ var DestroyVarRef uintptr
85+ if DestroyVar != nil {
86+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
87+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
88+ DestroyVarRef = cbRefPtr
89+ } else {
90+ fcb := func(arg0 uintptr) {
91+ cbFn := *DestroyVar
92+ cbFn(arg0)
93+ }
94+ DestroyVarRef = purego.NewCallback(fcb)
95+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
96+ }
97+ }
98+
99+ cret := xGLTextureBuilderBuild(x.GoPointer(), DestroyVarRef, DataVar)
85100
86101 if cret == 0 {
87102 return nil
M v4/gdkpixbuf/gdk-pixbuf-animation.go +16 -1
@@ -588,7 +588,22 @@ var xPixbufAnimationNewFromStreamAsync func(uintptr, uintptr, uintptr, uintptr)
588588 // result of the operation.
589589 func PixbufAnimationNewFromStreamAsync(StreamVar *gio.InputStream, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
590590
591- xPixbufAnimationNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
591+ var CallbackVarRef uintptr
592+ if CallbackVar != nil {
593+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
594+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
595+ CallbackVarRef = cbRefPtr
596+ } else {
597+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
598+ cbFn := *CallbackVar
599+ cbFn(arg0, arg1, arg2)
600+ }
601+ CallbackVarRef = purego.NewCallback(fcb)
602+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
603+ }
604+ }
605+
606+ xPixbufAnimationNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
592607
593608 }
594609
M v4/gdkpixbuf/gdk-pixbuf.go +126 -8
@@ -2,6 +2,8 @@
22 package gdkpixbuf
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -219,7 +221,22 @@ var xNewPixbufFromData func([]byte, Colorspace, bool, int, int, int, int, uintpt
219221 func NewPixbufFromData(DataVar []byte, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar *PixbufDestroyNotify, DestroyFnDataVar uintptr) *Pixbuf {
220222 var cls *Pixbuf
221223
222- cret := xNewPixbufFromData(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar, glib.NewCallbackNullable(DestroyFnVar), DestroyFnDataVar)
224+ var DestroyFnVarRef uintptr
225+ if DestroyFnVar != nil {
226+ DestroyFnVarPtr := uintptr(unsafe.Pointer(DestroyFnVar))
227+ if cbRefPtr, ok := glib.GetCallback(DestroyFnVarPtr); ok {
228+ DestroyFnVarRef = cbRefPtr
229+ } else {
230+ fcb := func(arg0 []byte, arg1 uintptr) {
231+ cbFn := *DestroyFnVar
232+ cbFn(arg0, arg1)
233+ }
234+ DestroyFnVarRef = purego.NewCallback(fcb)
235+ glib.SaveCallback(DestroyFnVarPtr, DestroyFnVarRef)
236+ }
237+ }
238+
239+ cret := xNewPixbufFromData(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar, DestroyFnVarRef, DestroyFnDataVar)
223240
224241 if cret == 0 {
225242 return nil
@@ -1144,7 +1161,20 @@ var xPixbufSaveToCallback func(uintptr, uintptr, uintptr, string, **glib.Error,
11441161 // See [method@GdkPixbuf.Pixbuf.save] for more details.
11451162 func (x *Pixbuf) SaveToCallback(SaveFuncVar *PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar **glib.Error, varArgs ...interface{}) bool {
11461163
1147- cret := xPixbufSaveToCallback(x.GoPointer(), glib.NewCallback(SaveFuncVar), UserDataVar, TypeVar, ErrorVar, varArgs...)
1164+ SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
1165+ 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)
1172+ }
1173+ SaveFuncVarRef = purego.NewCallback(fcb)
1174+ glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
1175+ }
1176+
1177+ cret := xPixbufSaveToCallback(x.GoPointer(), SaveFuncVarRef, UserDataVar, TypeVar, ErrorVar, varArgs...)
11481178 return cret
11491179 }
11501180
@@ -1161,7 +1191,20 @@ var xPixbufSaveToCallbackv func(uintptr, uintptr, uintptr, string, []string, []s
11611191 func (x *Pixbuf) SaveToCallbackv(SaveFuncVar *PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {
11621192 var cerr *glib.Error
11631193
1164- cret := xPixbufSaveToCallbackv(x.GoPointer(), glib.NewCallback(SaveFuncVar), UserDataVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)
1194+ SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
1195+ 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)
1202+ }
1203+ SaveFuncVarRef = purego.NewCallback(fcb)
1204+ glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
1205+ }
1206+
1207+ cret := xPixbufSaveToCallbackv(x.GoPointer(), SaveFuncVarRef, UserDataVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)
11651208 if cerr == nil {
11661209 return cret, nil
11671210 }
@@ -1201,7 +1244,22 @@ var xPixbufSaveToStreamAsync func(uintptr, uintptr, string, uintptr, uintptr, ui
12011244 // the operation.
12021245 func (x *Pixbuf) SaveToStreamAsync(StreamVar *gio.OutputStream, TypeVar string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr, varArgs ...interface{}) {
12031246
1204- xPixbufSaveToStreamAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, varArgs...)
1247+ var CallbackVarRef uintptr
1248+ if CallbackVar != nil {
1249+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1250+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1251+ CallbackVarRef = cbRefPtr
1252+ } else {
1253+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
1254+ cbFn := *CallbackVar
1255+ cbFn(arg0, arg1, arg2)
1256+ }
1257+ CallbackVarRef = purego.NewCallback(fcb)
1258+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1259+ }
1260+ }
1261+
1262+ xPixbufSaveToStreamAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar, varArgs...)
12051263
12061264 }
12071265
@@ -1237,7 +1295,22 @@ var xPixbufSaveToStreamvAsync func(uintptr, uintptr, string, []string, []string,
12371295 // the operation.
12381296 func (x *Pixbuf) SaveToStreamvAsync(StreamVar *gio.OutputStream, TypeVar string, OptionKeysVar []string, OptionValuesVar []string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
12391297
1240- xPixbufSaveToStreamvAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, OptionKeysVar, OptionValuesVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1298+ var CallbackVarRef uintptr
1299+ if CallbackVar != nil {
1300+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1301+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1302+ CallbackVarRef = cbRefPtr
1303+ } else {
1304+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
1305+ cbFn := *CallbackVar
1306+ cbFn(arg0, arg1, arg2)
1307+ }
1308+ CallbackVarRef = purego.NewCallback(fcb)
1309+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1310+ }
1311+ }
1312+
1313+ xPixbufSaveToStreamvAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, OptionKeysVar, OptionValuesVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
12411314
12421315 }
12431316
@@ -1627,7 +1700,22 @@ var xPixbufGetFileInfoAsync func(string, uintptr, uintptr, uintptr)
16271700 // get the result of the operation.
16281701 func PixbufGetFileInfoAsync(FilenameVar string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
16291702
1630- xPixbufGetFileInfoAsync(FilenameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1703+ var CallbackVarRef uintptr
1704+ if CallbackVar != nil {
1705+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1706+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1707+ CallbackVarRef = cbRefPtr
1708+ } else {
1709+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
1710+ cbFn := *CallbackVar
1711+ cbFn(arg0, arg1, arg2)
1712+ }
1713+ CallbackVarRef = purego.NewCallback(fcb)
1714+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1715+ }
1716+ }
1717+
1718+ xPixbufGetFileInfoAsync(FilenameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
16311719
16321720 }
16331721
@@ -1694,7 +1782,22 @@ var xPixbufNewFromStreamAsync func(uintptr, uintptr, uintptr, uintptr)
16941782 // the operation.
16951783 func PixbufNewFromStreamAsync(StreamVar *gio.InputStream, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
16961784
1697- xPixbufNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1785+ var CallbackVarRef uintptr
1786+ if CallbackVar != nil {
1787+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1788+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1789+ CallbackVarRef = cbRefPtr
1790+ } else {
1791+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
1792+ cbFn := *CallbackVar
1793+ cbFn(arg0, arg1, arg2)
1794+ }
1795+ CallbackVarRef = purego.NewCallback(fcb)
1796+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1797+ }
1798+ }
1799+
1800+ xPixbufNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
16981801
16991802 }
17001803
@@ -1709,7 +1812,22 @@ var xPixbufNewFromStreamAtScaleAsync func(uintptr, int, int, bool, uintptr, uint
17091812 // You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
17101813 func PixbufNewFromStreamAtScaleAsync(StreamVar *gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
17111814
1712- xPixbufNewFromStreamAtScaleAsync(StreamVar.GoPointer(), WidthVar, HeightVar, PreserveAspectRatioVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1815+ var CallbackVarRef uintptr
1816+ if CallbackVar != nil {
1817+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1818+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1819+ CallbackVarRef = cbRefPtr
1820+ } else {
1821+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
1822+ cbFn := *CallbackVar
1823+ cbFn(arg0, arg1, arg2)
1824+ }
1825+ CallbackVarRef = purego.NewCallback(fcb)
1826+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1827+ }
1828+ }
1829+
1830+ xPixbufNewFromStreamAtScaleAsync(StreamVar.GoPointer(), WidthVar, HeightVar, PreserveAspectRatioVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
17131831
17141832 }
17151833
M v4/gio/gappinfo.go +48 -3
@@ -1519,7 +1519,22 @@ var xAppInfoGetDefaultForTypeAsync func(string, bool, uintptr, uintptr, uintptr)
15191519 // type.
15201520 func AppInfoGetDefaultForTypeAsync(ContentTypeVar string, MustSupportUrisVar bool, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
15211521
1522- xAppInfoGetDefaultForTypeAsync(ContentTypeVar, MustSupportUrisVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1522+ var CallbackVarRef uintptr
1523+ if CallbackVar != nil {
1524+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1525+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1526+ CallbackVarRef = cbRefPtr
1527+ } else {
1528+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1529+ cbFn := *CallbackVar
1530+ cbFn(arg0, arg1, arg2)
1531+ }
1532+ CallbackVarRef = purego.NewCallback(fcb)
1533+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1534+ }
1535+ }
1536+
1537+ xAppInfoGetDefaultForTypeAsync(ContentTypeVar, MustSupportUrisVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
15231538
15241539 }
15251540
@@ -1575,7 +1590,22 @@ var xAppInfoGetDefaultForUriSchemeAsync func(string, uintptr, uintptr, uintptr)
15751590 // `ftp` or `sip`.
15761591 func AppInfoGetDefaultForUriSchemeAsync(UriSchemeVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
15771592
1578- xAppInfoGetDefaultForUriSchemeAsync(UriSchemeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1593+ var CallbackVarRef uintptr
1594+ if CallbackVar != nil {
1595+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1596+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1597+ CallbackVarRef = cbRefPtr
1598+ } else {
1599+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1600+ cbFn := *CallbackVar
1601+ cbFn(arg0, arg1, arg2)
1602+ }
1603+ CallbackVarRef = purego.NewCallback(fcb)
1604+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1605+ }
1606+ }
1607+
1608+ xAppInfoGetDefaultForUriSchemeAsync(UriSchemeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
15791609
15801610 }
15811611
@@ -1663,7 +1693,22 @@ var xAppInfoLaunchDefaultForUriAsync func(string, uintptr, uintptr, uintptr, uin
16631693 // in receiving error information from their activation.
16641694 func AppInfoLaunchDefaultForUriAsync(UriVar string, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
16651695
1666- xAppInfoLaunchDefaultForUriAsync(UriVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1696+ var CallbackVarRef uintptr
1697+ if CallbackVar != nil {
1698+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1699+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1700+ CallbackVarRef = cbRefPtr
1701+ } else {
1702+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1703+ cbFn := *CallbackVar
1704+ cbFn(arg0, arg1, arg2)
1705+ }
1706+ CallbackVarRef = purego.NewCallback(fcb)
1707+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1708+ }
1709+ }
1710+
1711+ xAppInfoLaunchDefaultForUriAsync(UriVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
16671712
16681713 }
16691714
M v4/gio/gasyncinitable.go +16 -1
@@ -306,7 +306,22 @@ var xAsyncInitableNewvAsync func(types.GType, uint, *gobject.Parameter, int, uin
306306 // for any errors.
307307 func AsyncInitableNewvAsync(ObjectTypeVar types.GType, NParametersVar uint, ParametersVar *gobject.Parameter, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
308308
309- xAsyncInitableNewvAsync(ObjectTypeVar, NParametersVar, ParametersVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
309+ var CallbackVarRef uintptr
310+ if CallbackVar != nil {
311+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
312+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
313+ CallbackVarRef = cbRefPtr
314+ } else {
315+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
316+ cbFn := *CallbackVar
317+ cbFn(arg0, arg1, arg2)
318+ }
319+ CallbackVarRef = purego.NewCallback(fcb)
320+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
321+ }
322+ }
323+
324+ xAsyncInitableNewvAsync(ObjectTypeVar, NParametersVar, ParametersVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
310325
311326 }
312327
M v4/gio/gbufferedinputstream.go +16 -1
@@ -341,7 +341,22 @@ var xBufferedInputStreamFillAsync func(uintptr, int, int, uintptr, uintptr, uint
341341 // of bytes that are required to fill the buffer.
342342 func (x *BufferedInputStream) FillAsync(CountVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
343343
344- xBufferedInputStreamFillAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
344+ var CallbackVarRef uintptr
345+ if CallbackVar != nil {
346+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
347+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
348+ CallbackVarRef = cbRefPtr
349+ } else {
350+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
351+ cbFn := *CallbackVar
352+ cbFn(arg0, arg1, arg2)
353+ }
354+ CallbackVarRef = purego.NewCallback(fcb)
355+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
356+ }
357+ }
358+
359+ xBufferedInputStreamFillAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
345360
346361 }
347362
M v4/gio/gcancellable.go +29 -1
@@ -290,7 +290,35 @@ var xCancellableConnect func(uintptr, uintptr, uintptr, uintptr) uint32
290290 // - [method@Gio.Cancellable.release_fd]
291291 func (x *Cancellable) Connect(CallbackVar *gobject.Callback, DataVar uintptr, DataDestroyFuncVar *glib.DestroyNotify) uint32 {
292292
293- cret := xCancellableConnect(x.GoPointer(), glib.NewCallback(CallbackVar), DataVar, glib.NewCallbackNullable(DataDestroyFuncVar))
293+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
294+ var CallbackVarRef uintptr
295+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
296+ CallbackVarRef = cbRefPtr
297+ } else {
298+ fcb := func() {
299+ cbFn := *CallbackVar
300+ cbFn()
301+ }
302+ CallbackVarRef = purego.NewCallback(fcb)
303+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
304+ }
305+
306+ var DataDestroyFuncVarRef uintptr
307+ if DataDestroyFuncVar != nil {
308+ DataDestroyFuncVarPtr := uintptr(unsafe.Pointer(DataDestroyFuncVar))
309+ if cbRefPtr, ok := glib.GetCallback(DataDestroyFuncVarPtr); ok {
310+ DataDestroyFuncVarRef = cbRefPtr
311+ } else {
312+ fcb := func(arg0 uintptr) {
313+ cbFn := *DataDestroyFuncVar
314+ cbFn(arg0)
315+ }
316+ DataDestroyFuncVarRef = purego.NewCallback(fcb)
317+ glib.SaveCallback(DataDestroyFuncVarPtr, DataDestroyFuncVarRef)
318+ }
319+ }
320+
321+ cret := xCancellableConnect(x.GoPointer(), CallbackVarRef, DataVar, DataDestroyFuncVarRef)
294322 return cret
295323 }
296324
M v4/gio/gdatainputstream.go +48 -3
@@ -309,7 +309,22 @@ var xDataInputStreamReadLineAsync func(uintptr, int, uintptr, uintptr, uintptr)
309309 // the result of the operation.
310310 func (x *DataInputStream) ReadLineAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
311311
312- xDataInputStreamReadLineAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
312+ var CallbackVarRef uintptr
313+ if CallbackVar != nil {
314+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
315+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
316+ CallbackVarRef = cbRefPtr
317+ } else {
318+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
319+ cbFn := *CallbackVar
320+ cbFn(arg0, arg1, arg2)
321+ }
322+ CallbackVarRef = purego.NewCallback(fcb)
323+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
324+ }
325+ }
326+
327+ xDataInputStreamReadLineAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
313328
314329 }
315330
@@ -465,7 +480,22 @@ var xDataInputStreamReadUntilAsync func(uintptr, string, int, uintptr, uintptr,
465480 // g_data_input_stream_read_upto_async() instead.
466481 func (x *DataInputStream) ReadUntilAsync(StopCharsVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
467482
468- xDataInputStreamReadUntilAsync(x.GoPointer(), StopCharsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
483+ var CallbackVarRef uintptr
484+ if CallbackVar != nil {
485+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
486+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
487+ CallbackVarRef = cbRefPtr
488+ } else {
489+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
490+ cbFn := *CallbackVar
491+ cbFn(arg0, arg1, arg2)
492+ }
493+ CallbackVarRef = purego.NewCallback(fcb)
494+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
495+ }
496+ }
497+
498+ xDataInputStreamReadUntilAsync(x.GoPointer(), StopCharsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
469499
470500 }
471501
@@ -527,7 +557,22 @@ var xDataInputStreamReadUptoAsync func(uintptr, string, int, int, uintptr, uintp
527557 // the result of the operation.
528558 func (x *DataInputStream) ReadUptoAsync(StopCharsVar string, StopCharsLenVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
529559
530- xDataInputStreamReadUptoAsync(x.GoPointer(), StopCharsVar, StopCharsLenVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
560+ var CallbackVarRef uintptr
561+ if CallbackVar != nil {
562+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
563+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
564+ CallbackVarRef = cbRefPtr
565+ } else {
566+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
567+ cbFn := *CallbackVar
568+ cbFn(arg0, arg1, arg2)
569+ }
570+ CallbackVarRef = purego.NewCallback(fcb)
571+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
572+ }
573+ }
574+
575+ xDataInputStreamReadUptoAsync(x.GoPointer(), StopCharsVar, StopCharsLenVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
531576
532577 }
533578
M v4/gio/gdbusaddress.go +18 -1
@@ -2,6 +2,8 @@
22 package gio
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -56,7 +58,22 @@ var xDbusAddressGetStream func(string, uintptr, uintptr, uintptr)
5658 // g_dbus_address_get_stream_sync() for the synchronous version.
5759 func DbusAddressGetStream(AddressVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
5860
59- xDbusAddressGetStream(AddressVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
61+ var CallbackVarRef uintptr
62+ if CallbackVar != nil {
63+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
64+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
65+ CallbackVarRef = cbRefPtr
66+ } else {
67+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
68+ cbFn := *CallbackVar
69+ cbFn(arg0, arg1, arg2)
70+ }
71+ CallbackVarRef = purego.NewCallback(fcb)
72+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
73+ }
74+ }
75+
76+ xDbusAddressGetStream(AddressVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
6077
6178 }
6279
M v4/gio/gdbusconnection.go +212 -12
@@ -225,7 +225,22 @@ var xBusGet func(BusType, uintptr, uintptr, uintptr)
225225 // the synchronous version.
226226 func BusGet(BusTypeVar BusType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
227227
228- xBusGet(BusTypeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
228+ var CallbackVarRef uintptr
229+ if CallbackVar != nil {
230+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
231+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
232+ CallbackVarRef = cbRefPtr
233+ } else {
234+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
235+ cbFn := *CallbackVar
236+ cbFn(arg0, arg1, arg2)
237+ }
238+ CallbackVarRef = purego.NewCallback(fcb)
239+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
240+ }
241+ }
242+
243+ xBusGet(BusTypeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
229244
230245 }
231246
@@ -512,7 +527,33 @@ var xDBusConnectionAddFilter func(uintptr, uintptr, uintptr, uintptr) uint
512527 // destroyed.)
513528 func (x *DBusConnection) AddFilter(FilterFunctionVar *DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
514529
515- cret := xDBusConnectionAddFilter(x.GoPointer(), glib.NewCallback(FilterFunctionVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
530+ FilterFunctionVarPtr := uintptr(unsafe.Pointer(FilterFunctionVar))
531+ 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)
538+ }
539+ FilterFunctionVarRef = purego.NewCallback(fcb)
540+ glib.SaveCallback(FilterFunctionVarPtr, FilterFunctionVarRef)
541+ }
542+
543+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
544+ 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)
551+ }
552+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
553+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
554+ }
555+
556+ cret := xDBusConnectionAddFilter(x.GoPointer(), FilterFunctionVarRef, UserDataVar, UserDataFreeFuncVarRef)
516557 return cret
517558 }
518559
@@ -567,7 +608,22 @@ var xDBusConnectionCall func(uintptr, string, string, string, string, *glib.Vari
567608 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
568609 func (x *DBusConnection) Call(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar *glib.Variant, ReplyTypeVar *glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
569610
570- xDBusConnectionCall(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
611+ var CallbackVarRef uintptr
612+ if CallbackVar != nil {
613+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
614+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
615+ CallbackVarRef = cbRefPtr
616+ } else {
617+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
618+ cbFn := *CallbackVar
619+ cbFn(arg0, arg1, arg2)
620+ }
621+ CallbackVarRef = purego.NewCallback(fcb)
622+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
623+ }
624+ }
625+
626+ xDBusConnectionCall(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
571627
572628 }
573629
@@ -655,7 +711,22 @@ var xDBusConnectionCallWithUnixFdList func(uintptr, string, string, string, stri
655711 // This method is only available on UNIX.
656712 func (x *DBusConnection) CallWithUnixFdList(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar *glib.Variant, ReplyTypeVar *glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
657713
658- xDBusConnectionCallWithUnixFdList(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
714+ var CallbackVarRef uintptr
715+ if CallbackVar != nil {
716+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
717+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
718+ CallbackVarRef = cbRefPtr
719+ } else {
720+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
721+ cbFn := *CallbackVar
722+ cbFn(arg0, arg1, arg2)
723+ }
724+ CallbackVarRef = purego.NewCallback(fcb)
725+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
726+ }
727+ }
728+
729+ xDBusConnectionCallWithUnixFdList(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
659730
660731 }
661732
@@ -730,7 +801,22 @@ var xDBusConnectionClose func(uintptr, uintptr, uintptr, uintptr)
730801 // version.
731802 func (x *DBusConnection) Close(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
732803
733- xDBusConnectionClose(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
804+ var CallbackVarRef uintptr
805+ if CallbackVar != nil {
806+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
807+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
808+ CallbackVarRef = cbRefPtr
809+ } else {
810+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
811+ cbFn := *CallbackVar
812+ cbFn(arg0, arg1, arg2)
813+ }
814+ CallbackVarRef = purego.NewCallback(fcb)
815+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
816+ }
817+ }
818+
819+ xDBusConnectionClose(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
734820
735821 }
736822
@@ -866,7 +952,22 @@ var xDBusConnectionFlush func(uintptr, uintptr, uintptr, uintptr)
866952 // version.
867953 func (x *DBusConnection) Flush(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
868954
869- xDBusConnectionFlush(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
955+ var CallbackVarRef uintptr
956+ if CallbackVar != nil {
957+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
958+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
959+ CallbackVarRef = cbRefPtr
960+ } else {
961+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
962+ cbFn := *CallbackVar
963+ cbFn(arg0, arg1, arg2)
964+ }
965+ CallbackVarRef = purego.NewCallback(fcb)
966+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
967+ }
968+ }
969+
970+ xDBusConnectionFlush(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
870971
871972 }
872973
@@ -1063,7 +1164,20 @@ var xDBusConnectionRegisterObject func(uintptr, string, *DBusInterfaceInfo, *DBu
10631164 func (x *DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar *DBusInterfaceInfo, VtableVar *DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
10641165 var cerr *glib.Error
10651166
1066- cret := xDBusConnectionRegisterObject(x.GoPointer(), ObjectPathVar, InterfaceInfoVar, VtableVar, UserDataVar, glib.NewCallback(UserDataFreeFuncVar), &cerr)
1167+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
1168+ 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)
1175+ }
1176+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
1177+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
1178+ }
1179+
1180+ cret := xDBusConnectionRegisterObject(x.GoPointer(), ObjectPathVar, InterfaceInfoVar, VtableVar, UserDataVar, UserDataFreeFuncVarRef, &cerr)
10671181 if cerr == nil {
10681182 return cret, nil
10691183 }
@@ -1155,7 +1269,20 @@ var xDBusConnectionRegisterSubtree func(uintptr, string, *DBusSubtreeVTable, DBu
11551269 func (x *DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar *DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
11561270 var cerr *glib.Error
11571271
1158- cret := xDBusConnectionRegisterSubtree(x.GoPointer(), ObjectPathVar, VtableVar, FlagsVar, UserDataVar, glib.NewCallback(UserDataFreeFuncVar), &cerr)
1272+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
1273+ 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)
1280+ }
1281+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
1282+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
1283+ }
1284+
1285+ cret := xDBusConnectionRegisterSubtree(x.GoPointer(), ObjectPathVar, VtableVar, FlagsVar, UserDataVar, UserDataFreeFuncVarRef, &cerr)
11591286 if cerr == nil {
11601287 return cret, nil
11611288 }
@@ -1248,7 +1375,22 @@ var xDBusConnectionSendMessageWithReply func(uintptr, uintptr, DBusSendMessageFl
12481375 // UNIX file descriptors.
12491376 func (x *DBusConnection) SendMessageWithReply(MessageVar *DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar *uint32, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
12501377
1251- xDBusConnectionSendMessageWithReply(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, TimeoutMsecVar, OutSerialVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1378+ var CallbackVarRef uintptr
1379+ if CallbackVar != nil {
1380+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1381+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1382+ CallbackVarRef = cbRefPtr
1383+ } else {
1384+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1385+ cbFn := *CallbackVar
1386+ cbFn(arg0, arg1, arg2)
1387+ }
1388+ CallbackVarRef = purego.NewCallback(fcb)
1389+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1390+ }
1391+ }
1392+
1393+ xDBusConnectionSendMessageWithReply(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, TimeoutMsecVar, OutSerialVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
12521394
12531395 }
12541396
@@ -1405,7 +1547,35 @@ var xDBusConnectionSignalSubscribe func(uintptr, string, string, string, string,
14051547 // This function can never fail.
14061548 func (x *DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar *DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
14071549
1408- cret := xDBusConnectionSignalSubscribe(x.GoPointer(), SenderVar, InterfaceNameVar, MemberVar, ObjectPathVar, Arg0Var, FlagsVar, glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))
1550+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1551+ 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)
1558+ }
1559+ CallbackVarRef = purego.NewCallback(fcb)
1560+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1561+ }
1562+
1563+ var UserDataFreeFuncVarRef uintptr
1564+ if UserDataFreeFuncVar != nil {
1565+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
1566+ if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
1567+ UserDataFreeFuncVarRef = cbRefPtr
1568+ } else {
1569+ fcb := func(arg0 uintptr) {
1570+ cbFn := *UserDataFreeFuncVar
1571+ cbFn(arg0)
1572+ }
1573+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
1574+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
1575+ }
1576+ }
1577+
1578+ cret := xDBusConnectionSignalSubscribe(x.GoPointer(), SenderVar, InterfaceNameVar, MemberVar, ObjectPathVar, Arg0Var, FlagsVar, CallbackVarRef, UserDataVar, UserDataFreeFuncVarRef)
14091579 return cret
14101580 }
14111581
@@ -1794,7 +1964,22 @@ var xDBusConnectionNew func(uintptr, string, DBusConnectionFlags, uintptr, uintp
17941964 // version.
17951965 func DBusConnectionNew(StreamVar *IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
17961966
1797- xDBusConnectionNew(StreamVar.GoPointer(), GuidVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1967+ var CallbackVarRef uintptr
1968+ if CallbackVar != nil {
1969+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1970+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1971+ CallbackVarRef = cbRefPtr
1972+ } else {
1973+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1974+ cbFn := *CallbackVar
1975+ cbFn(arg0, arg1, arg2)
1976+ }
1977+ CallbackVarRef = purego.NewCallback(fcb)
1978+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1979+ }
1980+ }
1981+
1982+ xDBusConnectionNew(StreamVar.GoPointer(), GuidVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
17981983
17991984 }
18001985
@@ -1824,7 +2009,22 @@ var xDBusConnectionNewForAddress func(string, DBusConnectionFlags, uintptr, uint
18242009 // version.
18252010 func DBusConnectionNewForAddress(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
18262011
1827- xDBusConnectionNewForAddress(AddressVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
2012+ var CallbackVarRef uintptr
2013+ if CallbackVar != nil {
2014+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
2015+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
2016+ CallbackVarRef = cbRefPtr
2017+ } else {
2018+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
2019+ cbFn := *CallbackVar
2020+ cbFn(arg0, arg1, arg2)
2021+ }
2022+ CallbackVarRef = purego.NewCallback(fcb)
2023+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
2024+ }
2025+ }
2026+
2027+ xDBusConnectionNewForAddress(AddressVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
18282028
18292029 }
18302030
M v4/gio/gdbusnameowning.go +109 -2
@@ -2,6 +2,8 @@
22 package gio
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -71,7 +73,67 @@ var xBusOwnName func(BusType, string, BusNameOwnerFlags, uintptr, uintptr, uintp
7173 // unregister the objects (if any) in @name_lost_handler.
7274 func BusOwnName(BusTypeVar BusType, NameVar string, FlagsVar BusNameOwnerFlags, BusAcquiredHandlerVar *BusAcquiredCallback, NameAcquiredHandlerVar *BusNameAcquiredCallback, NameLostHandlerVar *BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
7375
74- cret := xBusOwnName(BusTypeVar, NameVar, FlagsVar, glib.NewCallbackNullable(BusAcquiredHandlerVar), glib.NewCallbackNullable(NameAcquiredHandlerVar), glib.NewCallbackNullable(NameLostHandlerVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))
76+ var BusAcquiredHandlerVarRef uintptr
77+ if BusAcquiredHandlerVar != nil {
78+ BusAcquiredHandlerVarPtr := uintptr(unsafe.Pointer(BusAcquiredHandlerVar))
79+ if cbRefPtr, ok := glib.GetCallback(BusAcquiredHandlerVarPtr); ok {
80+ BusAcquiredHandlerVarRef = cbRefPtr
81+ } else {
82+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
83+ cbFn := *BusAcquiredHandlerVar
84+ cbFn(arg0, arg1, arg2)
85+ }
86+ BusAcquiredHandlerVarRef = purego.NewCallback(fcb)
87+ glib.SaveCallback(BusAcquiredHandlerVarPtr, BusAcquiredHandlerVarRef)
88+ }
89+ }
90+
91+ var NameAcquiredHandlerVarRef uintptr
92+ if NameAcquiredHandlerVar != nil {
93+ NameAcquiredHandlerVarPtr := uintptr(unsafe.Pointer(NameAcquiredHandlerVar))
94+ if cbRefPtr, ok := glib.GetCallback(NameAcquiredHandlerVarPtr); ok {
95+ NameAcquiredHandlerVarRef = cbRefPtr
96+ } else {
97+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
98+ cbFn := *NameAcquiredHandlerVar
99+ cbFn(arg0, arg1, arg2)
100+ }
101+ NameAcquiredHandlerVarRef = purego.NewCallback(fcb)
102+ glib.SaveCallback(NameAcquiredHandlerVarPtr, NameAcquiredHandlerVarRef)
103+ }
104+ }
105+
106+ var NameLostHandlerVarRef uintptr
107+ if NameLostHandlerVar != nil {
108+ NameLostHandlerVarPtr := uintptr(unsafe.Pointer(NameLostHandlerVar))
109+ if cbRefPtr, ok := glib.GetCallback(NameLostHandlerVarPtr); ok {
110+ NameLostHandlerVarRef = cbRefPtr
111+ } else {
112+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
113+ cbFn := *NameLostHandlerVar
114+ cbFn(arg0, arg1, arg2)
115+ }
116+ NameLostHandlerVarRef = purego.NewCallback(fcb)
117+ glib.SaveCallback(NameLostHandlerVarPtr, NameLostHandlerVarRef)
118+ }
119+ }
120+
121+ var UserDataFreeFuncVarRef uintptr
122+ if UserDataFreeFuncVar != nil {
123+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
124+ if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
125+ UserDataFreeFuncVarRef = cbRefPtr
126+ } else {
127+ fcb := func(arg0 uintptr) {
128+ cbFn := *UserDataFreeFuncVar
129+ cbFn(arg0)
130+ }
131+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
132+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
133+ }
134+ }
135+
136+ cret := xBusOwnName(BusTypeVar, NameVar, FlagsVar, BusAcquiredHandlerVarRef, NameAcquiredHandlerVarRef, NameLostHandlerVarRef, UserDataVar, UserDataFreeFuncVarRef)
75137 return cret
76138 }
77139
@@ -81,7 +143,52 @@ var xBusOwnNameOnConnection func(uintptr, string, BusNameOwnerFlags, uintptr, ui
81143 // of a [enum@Gio.BusType].
82144 func BusOwnNameOnConnection(ConnectionVar *DBusConnection, NameVar string, FlagsVar BusNameOwnerFlags, NameAcquiredHandlerVar *BusNameAcquiredCallback, NameLostHandlerVar *BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
83145
84- cret := xBusOwnNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, glib.NewCallbackNullable(NameAcquiredHandlerVar), glib.NewCallbackNullable(NameLostHandlerVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))
146+ var NameAcquiredHandlerVarRef uintptr
147+ if NameAcquiredHandlerVar != nil {
148+ NameAcquiredHandlerVarPtr := uintptr(unsafe.Pointer(NameAcquiredHandlerVar))
149+ if cbRefPtr, ok := glib.GetCallback(NameAcquiredHandlerVarPtr); ok {
150+ NameAcquiredHandlerVarRef = cbRefPtr
151+ } else {
152+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
153+ cbFn := *NameAcquiredHandlerVar
154+ cbFn(arg0, arg1, arg2)
155+ }
156+ NameAcquiredHandlerVarRef = purego.NewCallback(fcb)
157+ glib.SaveCallback(NameAcquiredHandlerVarPtr, NameAcquiredHandlerVarRef)
158+ }
159+ }
160+
161+ var NameLostHandlerVarRef uintptr
162+ if NameLostHandlerVar != nil {
163+ NameLostHandlerVarPtr := uintptr(unsafe.Pointer(NameLostHandlerVar))
164+ if cbRefPtr, ok := glib.GetCallback(NameLostHandlerVarPtr); ok {
165+ NameLostHandlerVarRef = cbRefPtr
166+ } else {
167+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
168+ cbFn := *NameLostHandlerVar
169+ cbFn(arg0, arg1, arg2)
170+ }
171+ NameLostHandlerVarRef = purego.NewCallback(fcb)
172+ glib.SaveCallback(NameLostHandlerVarPtr, NameLostHandlerVarRef)
173+ }
174+ }
175+
176+ var UserDataFreeFuncVarRef uintptr
177+ if UserDataFreeFuncVar != nil {
178+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
179+ if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
180+ UserDataFreeFuncVarRef = cbRefPtr
181+ } else {
182+ fcb := func(arg0 uintptr) {
183+ cbFn := *UserDataFreeFuncVar
184+ cbFn(arg0)
185+ }
186+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
187+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
188+ }
189+ }
190+
191+ cret := xBusOwnNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, NameAcquiredHandlerVarRef, NameLostHandlerVarRef, UserDataVar, UserDataFreeFuncVarRef)
85192 return cret
86193 }
87194
M v4/gio/gdbusnamewatching.go +94 -2
@@ -2,6 +2,8 @@
22 package gio
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -67,7 +69,52 @@ var xBusWatchName func(BusType, string, BusNameWatcherFlags, uintptr, uintptr, u
6769 // @name_vanished_handler.
6870 func BusWatchName(BusTypeVar BusType, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar *BusNameAppearedCallback, NameVanishedHandlerVar *BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
6971
70- cret := xBusWatchName(BusTypeVar, NameVar, FlagsVar, glib.NewCallbackNullable(NameAppearedHandlerVar), glib.NewCallbackNullable(NameVanishedHandlerVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))
72+ var NameAppearedHandlerVarRef uintptr
73+ if NameAppearedHandlerVar != nil {
74+ NameAppearedHandlerVarPtr := uintptr(unsafe.Pointer(NameAppearedHandlerVar))
75+ if cbRefPtr, ok := glib.GetCallback(NameAppearedHandlerVarPtr); ok {
76+ NameAppearedHandlerVarRef = cbRefPtr
77+ } else {
78+ fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) {
79+ cbFn := *NameAppearedHandlerVar
80+ cbFn(arg0, arg1, arg2, arg3)
81+ }
82+ NameAppearedHandlerVarRef = purego.NewCallback(fcb)
83+ glib.SaveCallback(NameAppearedHandlerVarPtr, NameAppearedHandlerVarRef)
84+ }
85+ }
86+
87+ var NameVanishedHandlerVarRef uintptr
88+ if NameVanishedHandlerVar != nil {
89+ NameVanishedHandlerVarPtr := uintptr(unsafe.Pointer(NameVanishedHandlerVar))
90+ if cbRefPtr, ok := glib.GetCallback(NameVanishedHandlerVarPtr); ok {
91+ NameVanishedHandlerVarRef = cbRefPtr
92+ } else {
93+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
94+ cbFn := *NameVanishedHandlerVar
95+ cbFn(arg0, arg1, arg2)
96+ }
97+ NameVanishedHandlerVarRef = purego.NewCallback(fcb)
98+ glib.SaveCallback(NameVanishedHandlerVarPtr, NameVanishedHandlerVarRef)
99+ }
100+ }
101+
102+ var UserDataFreeFuncVarRef uintptr
103+ if UserDataFreeFuncVar != nil {
104+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
105+ if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
106+ UserDataFreeFuncVarRef = cbRefPtr
107+ } else {
108+ fcb := func(arg0 uintptr) {
109+ cbFn := *UserDataFreeFuncVar
110+ cbFn(arg0)
111+ }
112+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
113+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
114+ }
115+ }
116+
117+ cret := xBusWatchName(BusTypeVar, NameVar, FlagsVar, NameAppearedHandlerVarRef, NameVanishedHandlerVarRef, UserDataVar, UserDataFreeFuncVarRef)
71118 return cret
72119 }
73120
@@ -77,7 +124,52 @@ var xBusWatchNameOnConnection func(uintptr, string, BusNameWatcherFlags, uintptr
77124 // #GBusType.
78125 func BusWatchNameOnConnection(ConnectionVar *DBusConnection, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar *BusNameAppearedCallback, NameVanishedHandlerVar *BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
79126
80- cret := xBusWatchNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, glib.NewCallbackNullable(NameAppearedHandlerVar), glib.NewCallbackNullable(NameVanishedHandlerVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))
127+ var NameAppearedHandlerVarRef uintptr
128+ if NameAppearedHandlerVar != nil {
129+ NameAppearedHandlerVarPtr := uintptr(unsafe.Pointer(NameAppearedHandlerVar))
130+ if cbRefPtr, ok := glib.GetCallback(NameAppearedHandlerVarPtr); ok {
131+ NameAppearedHandlerVarRef = cbRefPtr
132+ } else {
133+ fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) {
134+ cbFn := *NameAppearedHandlerVar
135+ cbFn(arg0, arg1, arg2, arg3)
136+ }
137+ NameAppearedHandlerVarRef = purego.NewCallback(fcb)
138+ glib.SaveCallback(NameAppearedHandlerVarPtr, NameAppearedHandlerVarRef)
139+ }
140+ }
141+
142+ var NameVanishedHandlerVarRef uintptr
143+ if NameVanishedHandlerVar != nil {
144+ NameVanishedHandlerVarPtr := uintptr(unsafe.Pointer(NameVanishedHandlerVar))
145+ if cbRefPtr, ok := glib.GetCallback(NameVanishedHandlerVarPtr); ok {
146+ NameVanishedHandlerVarRef = cbRefPtr
147+ } else {
148+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
149+ cbFn := *NameVanishedHandlerVar
150+ cbFn(arg0, arg1, arg2)
151+ }
152+ NameVanishedHandlerVarRef = purego.NewCallback(fcb)
153+ glib.SaveCallback(NameVanishedHandlerVarPtr, NameVanishedHandlerVarRef)
154+ }
155+ }
156+
157+ var UserDataFreeFuncVarRef uintptr
158+ if UserDataFreeFuncVar != nil {
159+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
160+ if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
161+ UserDataFreeFuncVarRef = cbRefPtr
162+ } else {
163+ fcb := func(arg0 uintptr) {
164+ cbFn := *UserDataFreeFuncVar
165+ cbFn(arg0)
166+ }
167+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
168+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
169+ }
170+ }
171+
172+ cret := xBusWatchNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, NameAppearedHandlerVarRef, NameVanishedHandlerVarRef, UserDataVar, UserDataFreeFuncVarRef)
81173 return cret
82174 }
83175
M v4/gio/gdbusobjectmanagerclient.go +154 -4
@@ -235,7 +235,37 @@ func NewDBusObjectManagerClientForBusSync(BusTypeVar BusType, FlagsVar DBusObjec
235235 var cls *DBusObjectManagerClient
236236 var cerr *glib.Error
237237
238- cret := xNewDBusObjectManagerClientForBusSync(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, glib.NewCallbackNullable(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallbackNullable(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
238+ var GetProxyTypeFuncVarRef uintptr
239+ if GetProxyTypeFuncVar != nil {
240+ GetProxyTypeFuncVarPtr := uintptr(unsafe.Pointer(GetProxyTypeFuncVar))
241+ if cbRefPtr, ok := glib.GetCallback(GetProxyTypeFuncVarPtr); ok {
242+ GetProxyTypeFuncVarRef = cbRefPtr
243+ } else {
244+ fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) types.GType {
245+ cbFn := *GetProxyTypeFuncVar
246+ return cbFn(arg0, arg1, arg2, arg3)
247+ }
248+ GetProxyTypeFuncVarRef = purego.NewCallback(fcb)
249+ glib.SaveCallback(GetProxyTypeFuncVarPtr, GetProxyTypeFuncVarRef)
250+ }
251+ }
252+
253+ var GetProxyTypeDestroyNotifyVarRef uintptr
254+ if GetProxyTypeDestroyNotifyVar != nil {
255+ GetProxyTypeDestroyNotifyVarPtr := uintptr(unsafe.Pointer(GetProxyTypeDestroyNotifyVar))
256+ if cbRefPtr, ok := glib.GetCallback(GetProxyTypeDestroyNotifyVarPtr); ok {
257+ GetProxyTypeDestroyNotifyVarRef = cbRefPtr
258+ } else {
259+ fcb := func(arg0 uintptr) {
260+ cbFn := *GetProxyTypeDestroyNotifyVar
261+ cbFn(arg0)
262+ }
263+ GetProxyTypeDestroyNotifyVarRef = purego.NewCallback(fcb)
264+ glib.SaveCallback(GetProxyTypeDestroyNotifyVarPtr, GetProxyTypeDestroyNotifyVarRef)
265+ }
266+ }
267+
268+ cret := xNewDBusObjectManagerClientForBusSync(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, GetProxyTypeFuncVarRef, GetProxyTypeUserDataVar, GetProxyTypeDestroyNotifyVarRef, CancellableVar.GoPointer(), &cerr)
239269
240270 if cret == 0 {
241271 return nil, cerr
@@ -260,7 +290,37 @@ func NewDBusObjectManagerClientSync(ConnectionVar *DBusConnection, FlagsVar DBus
260290 var cls *DBusObjectManagerClient
261291 var cerr *glib.Error
262292
263- cret := xNewDBusObjectManagerClientSync(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, glib.NewCallbackNullable(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallbackNullable(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
293+ var GetProxyTypeFuncVarRef uintptr
294+ if GetProxyTypeFuncVar != nil {
295+ GetProxyTypeFuncVarPtr := uintptr(unsafe.Pointer(GetProxyTypeFuncVar))
296+ if cbRefPtr, ok := glib.GetCallback(GetProxyTypeFuncVarPtr); ok {
297+ GetProxyTypeFuncVarRef = cbRefPtr
298+ } else {
299+ fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) types.GType {
300+ cbFn := *GetProxyTypeFuncVar
301+ return cbFn(arg0, arg1, arg2, arg3)
302+ }
303+ GetProxyTypeFuncVarRef = purego.NewCallback(fcb)
304+ glib.SaveCallback(GetProxyTypeFuncVarPtr, GetProxyTypeFuncVarRef)
305+ }
306+ }
307+
308+ var GetProxyTypeDestroyNotifyVarRef uintptr
309+ if GetProxyTypeDestroyNotifyVar != nil {
310+ GetProxyTypeDestroyNotifyVarPtr := uintptr(unsafe.Pointer(GetProxyTypeDestroyNotifyVar))
311+ if cbRefPtr, ok := glib.GetCallback(GetProxyTypeDestroyNotifyVarPtr); ok {
312+ GetProxyTypeDestroyNotifyVarRef = cbRefPtr
313+ } else {
314+ fcb := func(arg0 uintptr) {
315+ cbFn := *GetProxyTypeDestroyNotifyVar
316+ cbFn(arg0)
317+ }
318+ GetProxyTypeDestroyNotifyVarRef = purego.NewCallback(fcb)
319+ glib.SaveCallback(GetProxyTypeDestroyNotifyVarPtr, GetProxyTypeDestroyNotifyVarRef)
320+ }
321+ }
322+
323+ cret := xNewDBusObjectManagerClientSync(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, GetProxyTypeFuncVarRef, GetProxyTypeUserDataVar, GetProxyTypeDestroyNotifyVarRef, CancellableVar.GoPointer(), &cerr)
264324
265325 if cret == 0 {
266326 return nil, cerr
@@ -666,7 +726,52 @@ var xDBusObjectManagerClientNew func(uintptr, DBusObjectManagerClientFlags, stri
666726 // g_dbus_object_manager_client_new_sync() for the synchronous version.
667727 func DBusObjectManagerClientNew(ConnectionVar *DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
668728
669- xDBusObjectManagerClientNew(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, glib.NewCallbackNullable(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallbackNullable(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
729+ var GetProxyTypeFuncVarRef uintptr
730+ if GetProxyTypeFuncVar != nil {
731+ GetProxyTypeFuncVarPtr := uintptr(unsafe.Pointer(GetProxyTypeFuncVar))
732+ if cbRefPtr, ok := glib.GetCallback(GetProxyTypeFuncVarPtr); ok {
733+ GetProxyTypeFuncVarRef = cbRefPtr
734+ } else {
735+ fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) types.GType {
736+ cbFn := *GetProxyTypeFuncVar
737+ return cbFn(arg0, arg1, arg2, arg3)
738+ }
739+ GetProxyTypeFuncVarRef = purego.NewCallback(fcb)
740+ glib.SaveCallback(GetProxyTypeFuncVarPtr, GetProxyTypeFuncVarRef)
741+ }
742+ }
743+
744+ var GetProxyTypeDestroyNotifyVarRef uintptr
745+ if GetProxyTypeDestroyNotifyVar != nil {
746+ GetProxyTypeDestroyNotifyVarPtr := uintptr(unsafe.Pointer(GetProxyTypeDestroyNotifyVar))
747+ if cbRefPtr, ok := glib.GetCallback(GetProxyTypeDestroyNotifyVarPtr); ok {
748+ GetProxyTypeDestroyNotifyVarRef = cbRefPtr
749+ } else {
750+ fcb := func(arg0 uintptr) {
751+ cbFn := *GetProxyTypeDestroyNotifyVar
752+ cbFn(arg0)
753+ }
754+ GetProxyTypeDestroyNotifyVarRef = purego.NewCallback(fcb)
755+ glib.SaveCallback(GetProxyTypeDestroyNotifyVarPtr, GetProxyTypeDestroyNotifyVarRef)
756+ }
757+ }
758+
759+ var CallbackVarRef uintptr
760+ if CallbackVar != nil {
761+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
762+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
763+ CallbackVarRef = cbRefPtr
764+ } else {
765+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
766+ cbFn := *CallbackVar
767+ cbFn(arg0, arg1, arg2)
768+ }
769+ CallbackVarRef = purego.NewCallback(fcb)
770+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
771+ }
772+ }
773+
774+ xDBusObjectManagerClientNew(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, GetProxyTypeFuncVarRef, GetProxyTypeUserDataVar, GetProxyTypeDestroyNotifyVarRef, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
670775
671776 }
672777
@@ -683,7 +788,52 @@ var xDBusObjectManagerClientNewForBus func(BusType, DBusObjectManagerClientFlags
683788 // g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
684789 func DBusObjectManagerClientNewForBus(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
685790
686- xDBusObjectManagerClientNewForBus(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, glib.NewCallbackNullable(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallbackNullable(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
791+ var GetProxyTypeFuncVarRef uintptr
792+ if GetProxyTypeFuncVar != nil {
793+ GetProxyTypeFuncVarPtr := uintptr(unsafe.Pointer(GetProxyTypeFuncVar))
794+ if cbRefPtr, ok := glib.GetCallback(GetProxyTypeFuncVarPtr); ok {
795+ GetProxyTypeFuncVarRef = cbRefPtr
796+ } else {
797+ fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) types.GType {
798+ cbFn := *GetProxyTypeFuncVar
799+ return cbFn(arg0, arg1, arg2, arg3)
800+ }
801+ GetProxyTypeFuncVarRef = purego.NewCallback(fcb)
802+ glib.SaveCallback(GetProxyTypeFuncVarPtr, GetProxyTypeFuncVarRef)
803+ }
804+ }
805+
806+ var GetProxyTypeDestroyNotifyVarRef uintptr
807+ if GetProxyTypeDestroyNotifyVar != nil {
808+ GetProxyTypeDestroyNotifyVarPtr := uintptr(unsafe.Pointer(GetProxyTypeDestroyNotifyVar))
809+ if cbRefPtr, ok := glib.GetCallback(GetProxyTypeDestroyNotifyVarPtr); ok {
810+ GetProxyTypeDestroyNotifyVarRef = cbRefPtr
811+ } else {
812+ fcb := func(arg0 uintptr) {
813+ cbFn := *GetProxyTypeDestroyNotifyVar
814+ cbFn(arg0)
815+ }
816+ GetProxyTypeDestroyNotifyVarRef = purego.NewCallback(fcb)
817+ glib.SaveCallback(GetProxyTypeDestroyNotifyVarPtr, GetProxyTypeDestroyNotifyVarRef)
818+ }
819+ }
820+
821+ var CallbackVarRef uintptr
822+ if CallbackVar != nil {
823+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
824+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
825+ CallbackVarRef = cbRefPtr
826+ } else {
827+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
828+ cbFn := *CallbackVar
829+ cbFn(arg0, arg1, arg2)
830+ }
831+ CallbackVarRef = purego.NewCallback(fcb)
832+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
833+ }
834+ }
835+
836+ xDBusObjectManagerClientNewForBus(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, GetProxyTypeFuncVarRef, GetProxyTypeUserDataVar, GetProxyTypeDestroyNotifyVarRef, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
687837
688838 }
689839
M v4/gio/gdbusproxy.go +64 -4
@@ -305,7 +305,22 @@ var xDBusProxyCall func(uintptr, string, *glib.Variant, DBusCallFlags, int, uint
305305 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
306306 func (x *DBusProxy) Call(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
307307
308- xDBusProxyCall(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
308+ var CallbackVarRef uintptr
309+ if CallbackVar != nil {
310+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
311+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
312+ CallbackVarRef = cbRefPtr
313+ } else {
314+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
315+ cbFn := *CallbackVar
316+ cbFn(arg0, arg1, arg2)
317+ }
318+ CallbackVarRef = purego.NewCallback(fcb)
319+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
320+ }
321+ }
322+
323+ xDBusProxyCall(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
309324
310325 }
311326
@@ -379,7 +394,22 @@ var xDBusProxyCallWithUnixFdList func(uintptr, string, *glib.Variant, DBusCallFl
379394 // This method is only available on UNIX.
380395 func (x *DBusProxy) CallWithUnixFdList(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
381396
382- xDBusProxyCallWithUnixFdList(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
397+ var CallbackVarRef uintptr
398+ if CallbackVar != nil {
399+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
400+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
401+ CallbackVarRef = cbRefPtr
402+ } else {
403+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
404+ cbFn := *CallbackVar
405+ cbFn(arg0, arg1, arg2)
406+ }
407+ CallbackVarRef = purego.NewCallback(fcb)
408+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
409+ }
410+ }
411+
412+ xDBusProxyCallWithUnixFdList(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
383413
384414 }
385415
@@ -1024,7 +1054,22 @@ var xDBusProxyNew func(uintptr, DBusProxyFlags, *DBusInterfaceInfo, string, stri
10241054 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
10251055 func DBusProxyNew(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
10261056
1027- xDBusProxyNew(ConnectionVar.GoPointer(), FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1057+ var CallbackVarRef uintptr
1058+ if CallbackVar != nil {
1059+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1060+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1061+ CallbackVarRef = cbRefPtr
1062+ } else {
1063+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1064+ cbFn := *CallbackVar
1065+ cbFn(arg0, arg1, arg2)
1066+ }
1067+ CallbackVarRef = purego.NewCallback(fcb)
1068+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1069+ }
1070+ }
1071+
1072+ xDBusProxyNew(ConnectionVar.GoPointer(), FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
10281073
10291074 }
10301075
@@ -1035,7 +1080,22 @@ var xDBusProxyNewForBus func(BusType, DBusProxyFlags, *DBusInterfaceInfo, string
10351080 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
10361081 func DBusProxyNewForBus(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
10371082
1038- xDBusProxyNewForBus(BusTypeVar, FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1083+ var CallbackVarRef uintptr
1084+ if CallbackVar != nil {
1085+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1086+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1087+ CallbackVarRef = cbRefPtr
1088+ } else {
1089+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1090+ cbFn := *CallbackVar
1091+ cbFn(arg0, arg1, arg2)
1092+ }
1093+ CallbackVarRef = purego.NewCallback(fcb)
1094+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1095+ }
1096+ }
1097+
1098+ xDBusProxyNewForBus(BusTypeVar, FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
10391099
10401100 }
10411101
M v4/gio/gfile.go +32 -2
@@ -6196,7 +6196,22 @@ var xFileNewTmpAsync func(string, int, uintptr, uintptr, uintptr)
61966196 // directory components. If it is %NULL, a default template is used.
61976197 func FileNewTmpAsync(TmplVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
61986198
6199- xFileNewTmpAsync(TmplVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
6199+ var CallbackVarRef uintptr
6200+ if CallbackVar != nil {
6201+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
6202+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
6203+ CallbackVarRef = cbRefPtr
6204+ } else {
6205+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
6206+ cbFn := *CallbackVar
6207+ cbFn(arg0, arg1, arg2)
6208+ }
6209+ CallbackVarRef = purego.NewCallback(fcb)
6210+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
6211+ }
6212+ }
6213+
6214+ xFileNewTmpAsync(TmplVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
62006215
62016216 }
62026217
@@ -6210,7 +6225,22 @@ var xFileNewTmpDirAsync func(string, int, uintptr, uintptr, uintptr)
62106225 // directory components. If it is %NULL, a default template is used.
62116226 func FileNewTmpDirAsync(TmplVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
62126227
6213- xFileNewTmpDirAsync(TmplVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
6228+ var CallbackVarRef uintptr
6229+ if CallbackVar != nil {
6230+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
6231+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
6232+ CallbackVarRef = cbRefPtr
6233+ } else {
6234+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
6235+ cbFn := *CallbackVar
6236+ cbFn(arg0, arg1, arg2)
6237+ }
6238+ CallbackVarRef = purego.NewCallback(fcb)
6239+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
6240+ }
6241+ }
6242+
6243+ xFileNewTmpDirAsync(TmplVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
62146244
62156245 }
62166246
M v4/gio/gfileenumerator.go +32 -2
@@ -436,7 +436,22 @@ var xFileEnumeratorCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
436436 // g_file_enumerator_close_finish().
437437 func (x *FileEnumerator) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
438438
439- xFileEnumeratorCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
439+ var CallbackVarRef uintptr
440+ if CallbackVar != nil {
441+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
442+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
443+ CallbackVarRef = cbRefPtr
444+ } else {
445+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
446+ cbFn := *CallbackVar
447+ cbFn(arg0, arg1, arg2)
448+ }
449+ CallbackVarRef = purego.NewCallback(fcb)
450+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
451+ }
452+ }
453+
454+ xFileEnumeratorCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
440455
441456 }
442457
@@ -688,7 +703,22 @@ var xFileEnumeratorNextFilesAsync func(uintptr, int, int, uintptr, uintptr, uint
688703 // priority is %G_PRIORITY_DEFAULT.
689704 func (x *FileEnumerator) NextFilesAsync(NumFilesVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
690705
691- xFileEnumeratorNextFilesAsync(x.GoPointer(), NumFilesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
706+ var CallbackVarRef uintptr
707+ if CallbackVar != nil {
708+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
709+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
710+ CallbackVarRef = cbRefPtr
711+ } else {
712+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
713+ cbFn := *CallbackVar
714+ cbFn(arg0, arg1, arg2)
715+ }
716+ CallbackVarRef = purego.NewCallback(fcb)
717+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
718+ }
719+ }
720+
721+ xFileEnumeratorNextFilesAsync(x.GoPointer(), NumFilesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
692722
693723 }
694724
M v4/gio/gfileinputstream.go +16 -1
@@ -389,7 +389,22 @@ var xFileInputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr,
389389 // was cancelled, the error %G_IO_ERROR_CANCELLED will be set
390390 func (x *FileInputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
391391
392- xFileInputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
392+ var CallbackVarRef uintptr
393+ if CallbackVar != nil {
394+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
395+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
396+ CallbackVarRef = cbRefPtr
397+ } else {
398+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
399+ cbFn := *CallbackVar
400+ cbFn(arg0, arg1, arg2)
401+ }
402+ CallbackVarRef = purego.NewCallback(fcb)
403+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
404+ }
405+ }
406+
407+ xFileInputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
393408
394409 }
395410
M v4/gio/gfileiostream.go +16 -1
@@ -492,7 +492,22 @@ var xFileIOStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr, uin
492492 // g_file_io_stream_query_info().
493493 func (x *FileIOStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
494494
495- xFileIOStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
495+ var CallbackVarRef uintptr
496+ if CallbackVar != nil {
497+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
498+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
499+ CallbackVarRef = cbRefPtr
500+ } else {
501+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
502+ cbFn := *CallbackVar
503+ cbFn(arg0, arg1, arg2)
504+ }
505+ CallbackVarRef = purego.NewCallback(fcb)
506+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
507+ }
508+ }
509+
510+ xFileIOStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
496511
497512 }
498513
M v4/gio/gfileoutputstream.go +16 -1
@@ -487,7 +487,22 @@ var xFileOutputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr,
487487 // g_file_output_stream_query_info().
488488 func (x *FileOutputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
489489
490- xFileOutputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
490+ var CallbackVarRef uintptr
491+ if CallbackVar != nil {
492+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
493+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
494+ CallbackVarRef = cbRefPtr
495+ } else {
496+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
497+ cbFn := *CallbackVar
498+ cbFn(arg0, arg1, arg2)
499+ }
500+ CallbackVarRef = purego.NewCallback(fcb)
501+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
502+ }
503+ }
504+
505+ xFileOutputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
491506
492507 }
493508
M v4/gio/ginputstream.go +80 -5
@@ -468,7 +468,22 @@ var xInputStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
468468 // override one you must override all.
469469 func (x *InputStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
470470
471- xInputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
471+ var CallbackVarRef uintptr
472+ if CallbackVar != nil {
473+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
474+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
475+ CallbackVarRef = cbRefPtr
476+ } else {
477+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
478+ cbFn := *CallbackVar
479+ cbFn(arg0, arg1, arg2)
480+ }
481+ CallbackVarRef = purego.NewCallback(fcb)
482+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
483+ }
484+ }
485+
486+ xInputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
472487
473488 }
474489
@@ -584,7 +599,22 @@ var xInputStreamReadAllAsync func(uintptr, *[]byte, uint, int, uintptr, uintptr,
584599 // priority. Default priority is %G_PRIORITY_DEFAULT.
585600 func (x *InputStream) ReadAllAsync(BufferVar *[]byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
586601
587- xInputStreamReadAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
602+ var CallbackVarRef uintptr
603+ if CallbackVar != nil {
604+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
605+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
606+ CallbackVarRef = cbRefPtr
607+ } else {
608+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
609+ cbFn := *CallbackVar
610+ cbFn(arg0, arg1, arg2)
611+ }
612+ CallbackVarRef = purego.NewCallback(fcb)
613+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
614+ }
615+ }
616+
617+ xInputStreamReadAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
588618
589619 }
590620
@@ -637,7 +667,22 @@ var xInputStreamReadAsync func(uintptr, *[]byte, uint, int, uintptr, uintptr, ui
637667 // override one you must override all.
638668 func (x *InputStream) ReadAsync(BufferVar *[]byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
639669
640- xInputStreamReadAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
670+ var CallbackVarRef uintptr
671+ if CallbackVar != nil {
672+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
673+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
674+ CallbackVarRef = cbRefPtr
675+ } else {
676+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
677+ cbFn := *CallbackVar
678+ cbFn(arg0, arg1, arg2)
679+ }
680+ CallbackVarRef = purego.NewCallback(fcb)
681+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
682+ }
683+ }
684+
685+ xInputStreamReadAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
641686
642687 }
643688
@@ -701,7 +746,22 @@ var xInputStreamReadBytesAsync func(uintptr, uint, int, uintptr, uintptr, uintpt
701746 // priority. Default priority is %G_PRIORITY_DEFAULT.
702747 func (x *InputStream) ReadBytesAsync(CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
703748
704- xInputStreamReadBytesAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
749+ var CallbackVarRef uintptr
750+ if CallbackVar != nil {
751+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
752+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
753+ CallbackVarRef = cbRefPtr
754+ } else {
755+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
756+ cbFn := *CallbackVar
757+ cbFn(arg0, arg1, arg2)
758+ }
759+ CallbackVarRef = purego.NewCallback(fcb)
760+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
761+ }
762+ }
763+
764+ xInputStreamReadBytesAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
705765
706766 }
707767
@@ -803,7 +863,22 @@ var xInputStreamSkipAsync func(uintptr, uint, int, uintptr, uintptr, uintptr)
803863 // However, if you override one, you must override all.
804864 func (x *InputStream) SkipAsync(CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
805865
806- xInputStreamSkipAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
866+ var CallbackVarRef uintptr
867+ if CallbackVar != nil {
868+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
869+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
870+ CallbackVarRef = cbRefPtr
871+ } else {
872+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
873+ cbFn := *CallbackVar
874+ cbFn(arg0, arg1, arg2)
875+ }
876+ CallbackVarRef = purego.NewCallback(fcb)
877+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
878+ }
879+ }
880+
881+ xInputStreamSkipAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
807882
808883 }
809884
M v4/gio/gioscheduler.go +31 -1
@@ -2,6 +2,8 @@
22 package gio
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -31,7 +33,35 @@ var xIoSchedulerPushJob func(uintptr, uintptr, uintptr, int, uintptr)
3133 // g_io_scheduler_cancel_all_jobs().
3234 func IoSchedulerPushJob(JobFuncVar *IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {
3335
34- xIoSchedulerPushJob(glib.NewCallback(JobFuncVar), UserDataVar, glib.NewCallbackNullable(NotifyVar), IoPriorityVar, CancellableVar.GoPointer())
36+ JobFuncVarPtr := uintptr(unsafe.Pointer(JobFuncVar))
37+ 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)
44+ }
45+ JobFuncVarRef = purego.NewCallback(fcb)
46+ glib.SaveCallback(JobFuncVarPtr, JobFuncVarRef)
47+ }
48+
49+ var NotifyVarRef uintptr
50+ if NotifyVar != nil {
51+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
52+ if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
53+ NotifyVarRef = cbRefPtr
54+ } else {
55+ fcb := func(arg0 uintptr) {
56+ cbFn := *NotifyVar
57+ cbFn(arg0)
58+ }
59+ NotifyVarRef = purego.NewCallback(fcb)
60+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
61+ }
62+ }
63+
64+ xIoSchedulerPushJob(JobFuncVarRef, UserDataVar, NotifyVarRef, IoPriorityVar, CancellableVar.GoPointer())
3565
3666 }
3767
M v4/gio/giostream.go +32 -2
@@ -558,7 +558,22 @@ var xIOStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
558558 // classes. However, if you override one you must override all.
559559 func (x *IOStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
560560
561- xIOStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
561+ var CallbackVarRef uintptr
562+ if CallbackVar != nil {
563+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
564+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
565+ CallbackVarRef = cbRefPtr
566+ } else {
567+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
568+ cbFn := *CallbackVar
569+ cbFn(arg0, arg1, arg2)
570+ }
571+ CallbackVarRef = purego.NewCallback(fcb)
572+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
573+ }
574+ }
575+
576+ xIOStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
562577
563578 }
564579
@@ -657,7 +672,22 @@ var xIOStreamSpliceAsync func(uintptr, uintptr, IOStreamSpliceFlags, int, uintpt
657672 // result of the operation.
658673 func (x *IOStream) SpliceAsync(Stream2Var *IOStream, FlagsVar IOStreamSpliceFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
659674
660- xIOStreamSpliceAsync(x.GoPointer(), Stream2Var.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
675+ var CallbackVarRef uintptr
676+ if CallbackVar != nil {
677+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
678+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
679+ CallbackVarRef = cbRefPtr
680+ } else {
681+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
682+ cbFn := *CallbackVar
683+ cbFn(arg0, arg1, arg2)
684+ }
685+ CallbackVarRef = purego.NewCallback(fcb)
686+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
687+ }
688+ }
689+
690+ xIOStreamSpliceAsync(x.GoPointer(), Stream2Var.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
661691
662692 }
663693
M v4/gio/giotypes.go +58 -2
@@ -400,7 +400,35 @@ var xIOSchedulerJobSendToMainloop func(uintptr, uintptr, uintptr, uintptr) bool
400400 // blocking the I/O job).
401401 func (x *IOSchedulerJob) SendToMainloop(FuncVar *glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) bool {
402402
403- cret := xIOSchedulerJobSendToMainloop(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallbackNullable(NotifyVar))
403+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
404+ 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)
411+ }
412+ FuncVarRef = purego.NewCallback(fcb)
413+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
414+ }
415+
416+ var NotifyVarRef uintptr
417+ if NotifyVar != nil {
418+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
419+ if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
420+ NotifyVarRef = cbRefPtr
421+ } else {
422+ fcb := func(arg0 uintptr) {
423+ cbFn := *NotifyVar
424+ cbFn(arg0)
425+ }
426+ NotifyVarRef = purego.NewCallback(fcb)
427+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
428+ }
429+ }
430+
431+ cret := xIOSchedulerJobSendToMainloop(x.GoPointer(), FuncVarRef, UserDataVar, NotifyVarRef)
404432 return cret
405433 }
406434
@@ -417,7 +445,35 @@ var xIOSchedulerJobSendToMainloopAsync func(uintptr, uintptr, uintptr, uintptr)
417445 // g_io_scheduler_push_job() or by using refcounting for @user_data.
418446 func (x *IOSchedulerJob) SendToMainloopAsync(FuncVar *glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) {
419447
420- xIOSchedulerJobSendToMainloopAsync(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallbackNullable(NotifyVar))
448+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
449+ 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)
456+ }
457+ FuncVarRef = purego.NewCallback(fcb)
458+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
459+ }
460+
461+ var NotifyVarRef uintptr
462+ if NotifyVar != nil {
463+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
464+ if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
465+ NotifyVarRef = cbRefPtr
466+ } else {
467+ fcb := func(arg0 uintptr) {
468+ cbFn := *NotifyVar
469+ cbFn(arg0)
470+ }
471+ NotifyVarRef = purego.NewCallback(fcb)
472+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
473+ }
474+ }
475+
476+ xIOSchedulerJobSendToMainloopAsync(x.GoPointer(), FuncVarRef, UserDataVar, NotifyVarRef)
421477
422478 }
423479
M v4/gio/gliststore.go +56 -4
@@ -100,7 +100,20 @@ var xListStoreFindWithEqualFunc func(uintptr, uintptr, uintptr, *uint) bool
100100 // Since GLib 2.76 it is possible to pass `NULL` for @item.
101101 func (x *ListStore) FindWithEqualFunc(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFunc, PositionVar *uint) bool {
102102
103- cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(EqualFuncVar), PositionVar)
103+ EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
104+ 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)
111+ }
112+ EqualFuncVarRef = purego.NewCallback(fcb)
113+ glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
114+ }
115+
116+ cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), EqualFuncVarRef, PositionVar)
104117 return cret
105118 }
106119
@@ -114,7 +127,20 @@ var xListStoreFindWithEqualFuncFull func(uintptr, uintptr, uintptr, uintptr, *ui
114127 // Since GLib 2.76 it is possible to pass `NULL` for @item.
115128 func (x *ListStore) FindWithEqualFuncFull(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFuncFull, UserDataVar uintptr, PositionVar *uint) bool {
116129
117- cret := xListStoreFindWithEqualFuncFull(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(EqualFuncVar), UserDataVar, PositionVar)
130+ EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
131+ 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)
138+ }
139+ EqualFuncVarRef = purego.NewCallback(fcb)
140+ glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
141+ }
142+
143+ cret := xListStoreFindWithEqualFuncFull(x.GoPointer(), ItemVar.GoPointer(), EqualFuncVarRef, UserDataVar, PositionVar)
118144 return cret
119145 }
120146
@@ -146,7 +172,20 @@ var xListStoreInsertSorted func(uintptr, uintptr, uintptr, uintptr) uint
146172 // This function takes a ref on @item.
147173 func (x *ListStore) InsertSorted(ItemVar *gobject.Object, CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) uint {
148174
149- cret := xListStoreInsertSorted(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)
175+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
176+ 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)
183+ }
184+ CompareFuncVarRef = purego.NewCallback(fcb)
185+ glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
186+ }
187+
188+ cret := xListStoreInsertSorted(x.GoPointer(), ItemVar.GoPointer(), CompareFuncVarRef, UserDataVar)
150189 return cret
151190 }
152191
@@ -177,7 +216,20 @@ var xListStoreSort func(uintptr, uintptr, uintptr)
177216 // Sort the items in @store according to @compare_func.
178217 func (x *ListStore) Sort(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) {
179218
180- xListStoreSort(x.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)
219+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
220+ 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)
227+ }
228+ CompareFuncVarRef = purego.NewCallback(fcb)
229+ glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
230+ }
231+
232+ xListStoreSort(x.GoPointer(), CompareFuncVarRef, UserDataVar)
181233
182234 }
183235
M v4/gio/gmemoryinputstream.go +32 -2
@@ -213,7 +213,22 @@ var xNewMemoryInputStreamFromData func([]byte, int, uintptr) uintptr
213213 func NewMemoryInputStreamFromData(DataVar []byte, LenVar int, DestroyVar *glib.DestroyNotify) *MemoryInputStream {
214214 var cls *MemoryInputStream
215215
216- cret := xNewMemoryInputStreamFromData(DataVar, LenVar, glib.NewCallbackNullable(DestroyVar))
216+ var DestroyVarRef uintptr
217+ if DestroyVar != nil {
218+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
219+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
220+ DestroyVarRef = cbRefPtr
221+ } else {
222+ fcb := func(arg0 uintptr) {
223+ cbFn := *DestroyVar
224+ cbFn(arg0)
225+ }
226+ DestroyVarRef = purego.NewCallback(fcb)
227+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
228+ }
229+ }
230+
231+ cret := xNewMemoryInputStreamFromData(DataVar, LenVar, DestroyVarRef)
217232
218233 if cret == 0 {
219234 return nil
@@ -237,7 +252,22 @@ var xMemoryInputStreamAddData func(uintptr, []byte, int, uintptr)
237252 // Appends @data to data that can be read from the input stream
238253 func (x *MemoryInputStream) AddData(DataVar []byte, LenVar int, DestroyVar *glib.DestroyNotify) {
239254
240- xMemoryInputStreamAddData(x.GoPointer(), DataVar, LenVar, glib.NewCallbackNullable(DestroyVar))
255+ var DestroyVarRef uintptr
256+ if DestroyVar != nil {
257+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
258+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
259+ DestroyVarRef = cbRefPtr
260+ } else {
261+ fcb := func(arg0 uintptr) {
262+ cbFn := *DestroyVar
263+ cbFn(arg0)
264+ }
265+ DestroyVarRef = purego.NewCallback(fcb)
266+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
267+ }
268+ }
269+
270+ xMemoryInputStreamAddData(x.GoPointer(), DataVar, LenVar, DestroyVarRef)
241271
242272 }
243273
M v4/gio/gmemoryoutputstream.go +31 -1
@@ -228,7 +228,37 @@ var xNewMemoryOutputStream func(uintptr, uint, uintptr, uintptr) uintptr
228228 func NewMemoryOutputStream(DataVar uintptr, SizeVar uint, ReallocFunctionVar *ReallocFunc, DestroyFunctionVar *glib.DestroyNotify) *MemoryOutputStream {
229229 var cls *MemoryOutputStream
230230
231- cret := xNewMemoryOutputStream(DataVar, SizeVar, glib.NewCallbackNullable(ReallocFunctionVar), glib.NewCallbackNullable(DestroyFunctionVar))
231+ var ReallocFunctionVarRef uintptr
232+ if ReallocFunctionVar != nil {
233+ ReallocFunctionVarPtr := uintptr(unsafe.Pointer(ReallocFunctionVar))
234+ if cbRefPtr, ok := glib.GetCallback(ReallocFunctionVarPtr); ok {
235+ ReallocFunctionVarRef = cbRefPtr
236+ } else {
237+ fcb := func(arg0 uintptr, arg1 uint) uintptr {
238+ cbFn := *ReallocFunctionVar
239+ return cbFn(arg0, arg1)
240+ }
241+ ReallocFunctionVarRef = purego.NewCallback(fcb)
242+ glib.SaveCallback(ReallocFunctionVarPtr, ReallocFunctionVarRef)
243+ }
244+ }
245+
246+ var DestroyFunctionVarRef uintptr
247+ if DestroyFunctionVar != nil {
248+ DestroyFunctionVarPtr := uintptr(unsafe.Pointer(DestroyFunctionVar))
249+ if cbRefPtr, ok := glib.GetCallback(DestroyFunctionVarPtr); ok {
250+ DestroyFunctionVarRef = cbRefPtr
251+ } else {
252+ fcb := func(arg0 uintptr) {
253+ cbFn := *DestroyFunctionVar
254+ cbFn(arg0)
255+ }
256+ DestroyFunctionVarRef = purego.NewCallback(fcb)
257+ glib.SaveCallback(DestroyFunctionVarPtr, DestroyFunctionVarRef)
258+ }
259+ }
260+
261+ cret := xNewMemoryOutputStream(DataVar, SizeVar, ReallocFunctionVarRef, DestroyFunctionVarRef)
232262
233263 if cret == 0 {
234264 return nil
M v4/gio/goutputstream.go +128 -8
@@ -628,7 +628,22 @@ var xOutputStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
628628 // classes. However, if you override one you must override all.
629629 func (x *OutputStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
630630
631- xOutputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
631+ var CallbackVarRef uintptr
632+ if CallbackVar != nil {
633+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
634+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
635+ CallbackVarRef = cbRefPtr
636+ } else {
637+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
638+ cbFn := *CallbackVar
639+ cbFn(arg0, arg1, arg2)
640+ }
641+ CallbackVarRef = purego.NewCallback(fcb)
642+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
643+ }
644+ }
645+
646+ xOutputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
632647
633648 }
634649
@@ -679,7 +694,22 @@ var xOutputStreamFlushAsync func(uintptr, int, uintptr, uintptr, uintptr)
679694 // result of the operation.
680695 func (x *OutputStream) FlushAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
681696
682- xOutputStreamFlushAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
697+ var CallbackVarRef uintptr
698+ if CallbackVar != nil {
699+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
700+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
701+ CallbackVarRef = cbRefPtr
702+ } else {
703+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
704+ cbFn := *CallbackVar
705+ cbFn(arg0, arg1, arg2)
706+ }
707+ CallbackVarRef = purego.NewCallback(fcb)
708+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
709+ }
710+ }
711+
712+ xOutputStreamFlushAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
683713
684714 }
685715
@@ -788,7 +818,22 @@ var xOutputStreamSpliceAsync func(uintptr, uintptr, OutputStreamSpliceFlags, int
788818 // g_output_stream_splice().
789819 func (x *OutputStream) SpliceAsync(SourceVar *InputStream, FlagsVar OutputStreamSpliceFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
790820
791- xOutputStreamSpliceAsync(x.GoPointer(), SourceVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
821+ var CallbackVarRef uintptr
822+ if CallbackVar != nil {
823+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
824+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
825+ CallbackVarRef = cbRefPtr
826+ } else {
827+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
828+ cbFn := *CallbackVar
829+ cbFn(arg0, arg1, arg2)
830+ }
831+ CallbackVarRef = purego.NewCallback(fcb)
832+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
833+ }
834+ }
835+
836+ xOutputStreamSpliceAsync(x.GoPointer(), SourceVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
792837
793838 }
794839
@@ -910,7 +955,22 @@ var xOutputStreamWriteAllAsync func(uintptr, []byte, uint, int, uintptr, uintptr
910955 // until @callback is called.
911956 func (x *OutputStream) WriteAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
912957
913- xOutputStreamWriteAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
958+ var CallbackVarRef uintptr
959+ if CallbackVar != nil {
960+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
961+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
962+ CallbackVarRef = cbRefPtr
963+ } else {
964+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
965+ cbFn := *CallbackVar
966+ cbFn(arg0, arg1, arg2)
967+ }
968+ CallbackVarRef = purego.NewCallback(fcb)
969+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
970+ }
971+ }
972+
973+ xOutputStreamWriteAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
914974
915975 }
916976
@@ -976,7 +1036,22 @@ var xOutputStreamWriteAsync func(uintptr, []byte, uint, int, uintptr, uintptr, u
9761036 // the contents (without copying) for the duration of the call.
9771037 func (x *OutputStream) WriteAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
9781038
979- xOutputStreamWriteAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1039+ var CallbackVarRef uintptr
1040+ if CallbackVar != nil {
1041+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1042+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1043+ CallbackVarRef = cbRefPtr
1044+ } else {
1045+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1046+ cbFn := *CallbackVar
1047+ cbFn(arg0, arg1, arg2)
1048+ }
1049+ CallbackVarRef = purego.NewCallback(fcb)
1050+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1051+ }
1052+ }
1053+
1054+ xOutputStreamWriteAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
9801055
9811056 }
9821057
@@ -1021,7 +1096,22 @@ var xOutputStreamWriteBytesAsync func(uintptr, *glib.Bytes, int, uintptr, uintpt
10211096 // g_output_stream_write_bytes().
10221097 func (x *OutputStream) WriteBytesAsync(BytesVar *glib.Bytes, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
10231098
1024- xOutputStreamWriteBytesAsync(x.GoPointer(), BytesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1099+ var CallbackVarRef uintptr
1100+ if CallbackVar != nil {
1101+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1102+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1103+ CallbackVarRef = cbRefPtr
1104+ } else {
1105+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1106+ cbFn := *CallbackVar
1107+ cbFn(arg0, arg1, arg2)
1108+ }
1109+ CallbackVarRef = purego.NewCallback(fcb)
1110+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1111+ }
1112+ }
1113+
1114+ xOutputStreamWriteBytesAsync(x.GoPointer(), BytesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
10251115
10261116 }
10271117
@@ -1144,7 +1234,22 @@ var xOutputStreamWritevAllAsync func(uintptr, []OutputVector, uint, int, uintptr
11441234 // of @vectors might be changed by this function.
11451235 func (x *OutputStream) WritevAllAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
11461236
1147- xOutputStreamWritevAllAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1237+ var CallbackVarRef uintptr
1238+ if CallbackVar != nil {
1239+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1240+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1241+ CallbackVarRef = cbRefPtr
1242+ } else {
1243+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1244+ cbFn := *CallbackVar
1245+ cbFn(arg0, arg1, arg2)
1246+ }
1247+ CallbackVarRef = purego.NewCallback(fcb)
1248+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1249+ }
1250+ }
1251+
1252+ xOutputStreamWritevAllAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
11481253
11491254 }
11501255
@@ -1205,7 +1310,22 @@ var xOutputStreamWritevAsync func(uintptr, []OutputVector, uint, int, uintptr, u
12051310 // until @callback is called.
12061311 func (x *OutputStream) WritevAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
12071312
1208- xOutputStreamWritevAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1313+ var CallbackVarRef uintptr
1314+ if CallbackVar != nil {
1315+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1316+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1317+ CallbackVarRef = cbRefPtr
1318+ } else {
1319+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1320+ cbFn := *CallbackVar
1321+ cbFn(arg0, arg1, arg2)
1322+ }
1323+ CallbackVarRef = purego.NewCallback(fcb)
1324+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1325+ }
1326+ }
1327+
1328+ xOutputStreamWritevAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
12091329
12101330 }
12111331
M v4/gio/gpermission.go +32 -2
@@ -249,7 +249,22 @@ var xPermissionAcquireAsync func(uintptr, uintptr, uintptr, uintptr)
249249 // g_permission_acquire().
250250 func (x *Permission) AcquireAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
251251
252- xPermissionAcquireAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
252+ var CallbackVarRef uintptr
253+ if CallbackVar != nil {
254+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
255+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
256+ CallbackVarRef = cbRefPtr
257+ } else {
258+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
259+ cbFn := *CallbackVar
260+ cbFn(arg0, arg1, arg2)
261+ }
262+ CallbackVarRef = purego.NewCallback(fcb)
263+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
264+ }
265+ }
266+
267+ xPermissionAcquireAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
253268
254269 }
255270
@@ -353,7 +368,22 @@ var xPermissionReleaseAsync func(uintptr, uintptr, uintptr, uintptr)
353368 // g_permission_release().
354369 func (x *Permission) ReleaseAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
355370
356- xPermissionReleaseAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
371+ var CallbackVarRef uintptr
372+ if CallbackVar != nil {
373+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
374+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
375+ CallbackVarRef = cbRefPtr
376+ } else {
377+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
378+ cbFn := *CallbackVar
379+ cbFn(arg0, arg1, arg2)
380+ }
381+ CallbackVarRef = purego.NewCallback(fcb)
382+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
383+ }
384+ }
385+
386+ xPermissionReleaseAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
357387
358388 }
359389
M v4/gio/gresolver.go +80 -5
@@ -531,7 +531,22 @@ var xResolverLookupByAddressAsync func(uintptr, uintptr, uintptr, uintptr, uintp
531531 // call g_resolver_lookup_by_address_finish() to get the final result.
532532 func (x *Resolver) LookupByAddressAsync(AddressVar *InetAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
533533
534- xResolverLookupByAddressAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
534+ var CallbackVarRef uintptr
535+ if CallbackVar != nil {
536+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
537+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
538+ CallbackVarRef = cbRefPtr
539+ } else {
540+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
541+ cbFn := *CallbackVar
542+ cbFn(arg0, arg1, arg2)
543+ }
544+ CallbackVarRef = purego.NewCallback(fcb)
545+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
546+ }
547+ }
548+
549+ xResolverLookupByAddressAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
535550
536551 }
537552
@@ -598,7 +613,22 @@ var xResolverLookupByNameAsync func(uintptr, string, uintptr, uintptr, uintptr)
598613 // See g_resolver_lookup_by_name() for more details.
599614 func (x *Resolver) LookupByNameAsync(HostnameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
600615
601- xResolverLookupByNameAsync(x.GoPointer(), HostnameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
616+ var CallbackVarRef uintptr
617+ if CallbackVar != nil {
618+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
619+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
620+ CallbackVarRef = cbRefPtr
621+ } else {
622+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
623+ cbFn := *CallbackVar
624+ cbFn(arg0, arg1, arg2)
625+ }
626+ CallbackVarRef = purego.NewCallback(fcb)
627+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
628+ }
629+ }
630+
631+ xResolverLookupByNameAsync(x.GoPointer(), HostnameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
602632
603633 }
604634
@@ -645,7 +675,22 @@ var xResolverLookupByNameWithFlagsAsync func(uintptr, string, ResolverNameLookup
645675 // See g_resolver_lookup_by_name() for more details.
646676 func (x *Resolver) LookupByNameWithFlagsAsync(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
647677
648- xResolverLookupByNameWithFlagsAsync(x.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
678+ var CallbackVarRef uintptr
679+ if CallbackVar != nil {
680+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
681+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
682+ CallbackVarRef = cbRefPtr
683+ } else {
684+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
685+ cbFn := *CallbackVar
686+ cbFn(arg0, arg1, arg2)
687+ }
688+ CallbackVarRef = purego.NewCallback(fcb)
689+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
690+ }
691+ }
692+
693+ xResolverLookupByNameWithFlagsAsync(x.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
649694
650695 }
651696
@@ -699,7 +744,22 @@ var xResolverLookupRecordsAsync func(uintptr, string, ResolverRecordType, uintpt
699744 // g_resolver_lookup_records() for more details.
700745 func (x *Resolver) LookupRecordsAsync(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
701746
702- xResolverLookupRecordsAsync(x.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
747+ var CallbackVarRef uintptr
748+ if CallbackVar != nil {
749+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
750+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
751+ CallbackVarRef = cbRefPtr
752+ } else {
753+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
754+ cbFn := *CallbackVar
755+ cbFn(arg0, arg1, arg2)
756+ }
757+ CallbackVarRef = purego.NewCallback(fcb)
758+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
759+ }
760+ }
761+
762+ xResolverLookupRecordsAsync(x.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
703763
704764 }
705765
@@ -767,7 +827,22 @@ var xResolverLookupServiceAsync func(uintptr, string, string, string, uintptr, u
767827 // details.
768828 func (x *Resolver) LookupServiceAsync(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
769829
770- xResolverLookupServiceAsync(x.GoPointer(), ServiceVar, ProtocolVar, DomainVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
830+ var CallbackVarRef uintptr
831+ if CallbackVar != nil {
832+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
833+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
834+ CallbackVarRef = cbRefPtr
835+ } else {
836+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
837+ cbFn := *CallbackVar
838+ cbFn(arg0, arg1, arg2)
839+ }
840+ CallbackVarRef = purego.NewCallback(fcb)
841+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
842+ }
843+ }
844+
845+ xResolverLookupServiceAsync(x.GoPointer(), ServiceVar, ProtocolVar, DomainVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
771846
772847 }
773848
M v4/gio/gsettings.go +58 -2
@@ -793,7 +793,50 @@ var xSettingsBindWithMapping func(uintptr, string, uintptr, string, SettingsBind
793793 // binding overrides the first one.
794794 func (x *Settings) BindWithMapping(KeyVar string, ObjectVar *gobject.Object, PropertyVar string, FlagsVar SettingsBindFlags, GetMappingVar *SettingsBindGetMapping, SetMappingVar *SettingsBindSetMapping, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
795795
796- xSettingsBindWithMapping(x.GoPointer(), KeyVar, ObjectVar.GoPointer(), PropertyVar, FlagsVar, glib.NewCallbackNullable(GetMappingVar), glib.NewCallbackNullable(SetMappingVar), UserDataVar, glib.NewCallback(DestroyVar))
796+ var GetMappingVarRef uintptr
797+ if GetMappingVar != nil {
798+ GetMappingVarPtr := uintptr(unsafe.Pointer(GetMappingVar))
799+ if cbRefPtr, ok := glib.GetCallback(GetMappingVarPtr); ok {
800+ GetMappingVarRef = cbRefPtr
801+ } else {
802+ fcb := func(arg0 *gobject.Value, arg1 *glib.Variant, arg2 uintptr) bool {
803+ cbFn := *GetMappingVar
804+ return cbFn(arg0, arg1, arg2)
805+ }
806+ GetMappingVarRef = purego.NewCallback(fcb)
807+ glib.SaveCallback(GetMappingVarPtr, GetMappingVarRef)
808+ }
809+ }
810+
811+ var SetMappingVarRef uintptr
812+ if SetMappingVar != nil {
813+ SetMappingVarPtr := uintptr(unsafe.Pointer(SetMappingVar))
814+ if cbRefPtr, ok := glib.GetCallback(SetMappingVarPtr); ok {
815+ SetMappingVarRef = cbRefPtr
816+ } else {
817+ fcb := func(arg0 *gobject.Value, arg1 *glib.VariantType, arg2 uintptr) *glib.Variant {
818+ cbFn := *SetMappingVar
819+ return cbFn(arg0, arg1, arg2)
820+ }
821+ SetMappingVarRef = purego.NewCallback(fcb)
822+ glib.SaveCallback(SetMappingVarPtr, SetMappingVarRef)
823+ }
824+ }
825+
826+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
827+ 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)
834+ }
835+ DestroyVarRef = purego.NewCallback(fcb)
836+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
837+ }
838+
839+ xSettingsBindWithMapping(x.GoPointer(), KeyVar, ObjectVar.GoPointer(), PropertyVar, FlagsVar, GetMappingVarRef, SetMappingVarRef, UserDataVar, DestroyVarRef)
797840
798841 }
799842
@@ -1085,7 +1128,20 @@ var xSettingsGetMapped func(uintptr, string, uintptr, uintptr) uintptr
10851128 // just as any other value would be.
10861129 func (x *Settings) GetMapped(KeyVar string, MappingVar *SettingsGetMapping, UserDataVar uintptr) uintptr {
10871130
1088- cret := xSettingsGetMapped(x.GoPointer(), KeyVar, glib.NewCallback(MappingVar), UserDataVar)
1131+ MappingVarPtr := uintptr(unsafe.Pointer(MappingVar))
1132+ 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)
1139+ }
1140+ MappingVarRef = purego.NewCallback(fcb)
1141+ glib.SaveCallback(MappingVarPtr, MappingVarRef)
1142+ }
1143+
1144+ cret := xSettingsGetMapped(x.GoPointer(), KeyVar, MappingVarRef, UserDataVar)
10891145 return cret
10901146 }
10911147
M v4/gio/gsimpleasyncresult.go +140 -9
@@ -27,7 +27,22 @@ var xSimpleAsyncReportErrorInIdle func(uintptr, uintptr, uintptr, glib.Quark, in
2727 // information.
2828 func SimpleAsyncReportErrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {
2929
30- xSimpleAsyncReportErrorInIdle(ObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
30+ var CallbackVarRef uintptr
31+ if CallbackVar != nil {
32+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
33+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
34+ CallbackVarRef = cbRefPtr
35+ } else {
36+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
37+ cbFn := *CallbackVar
38+ cbFn(arg0, arg1, arg2)
39+ }
40+ CallbackVarRef = purego.NewCallback(fcb)
41+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
42+ }
43+ }
44+
45+ xSimpleAsyncReportErrorInIdle(ObjectVar.GoPointer(), CallbackVarRef, UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
3146
3247 }
3348
@@ -38,7 +53,22 @@ var xSimpleAsyncReportGerrorInIdle func(uintptr, uintptr, uintptr, *glib.Error)
3853 // than building a new one.
3954 func SimpleAsyncReportGerrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {
4055
41- xSimpleAsyncReportGerrorInIdle(ObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, ErrorVar)
56+ var CallbackVarRef uintptr
57+ if CallbackVar != nil {
58+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
59+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
60+ CallbackVarRef = cbRefPtr
61+ } else {
62+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
63+ cbFn := *CallbackVar
64+ cbFn(arg0, arg1, arg2)
65+ }
66+ CallbackVarRef = purego.NewCallback(fcb)
67+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
68+ }
69+ }
70+
71+ xSimpleAsyncReportGerrorInIdle(ObjectVar.GoPointer(), CallbackVarRef, UserDataVar, ErrorVar)
4272
4373 }
4474
@@ -49,7 +79,22 @@ var xSimpleAsyncReportTakeGerrorInIdle func(uintptr, uintptr, uintptr, *glib.Err
4979 // ownership of @error, so the caller does not have to free it any more.
5080 func SimpleAsyncReportTakeGerrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {
5181
52- xSimpleAsyncReportTakeGerrorInIdle(ObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, ErrorVar)
82+ var CallbackVarRef uintptr
83+ if CallbackVar != nil {
84+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
85+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
86+ CallbackVarRef = cbRefPtr
87+ } else {
88+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
89+ cbFn := *CallbackVar
90+ cbFn(arg0, arg1, arg2)
91+ }
92+ CallbackVarRef = purego.NewCallback(fcb)
93+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
94+ }
95+ }
96+
97+ xSimpleAsyncReportTakeGerrorInIdle(ObjectVar.GoPointer(), CallbackVarRef, UserDataVar, ErrorVar)
5398
5499 }
55100
@@ -257,7 +302,22 @@ var xNewSimpleAsyncResult func(uintptr, uintptr, uintptr, uintptr) uintptr
257302 func NewSimpleAsyncResult(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, SourceTagVar uintptr) *SimpleAsyncResult {
258303 var cls *SimpleAsyncResult
259304
260- cret := xNewSimpleAsyncResult(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, SourceTagVar)
305+ var CallbackVarRef uintptr
306+ if CallbackVar != nil {
307+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
308+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
309+ CallbackVarRef = cbRefPtr
310+ } else {
311+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
312+ cbFn := *CallbackVar
313+ cbFn(arg0, arg1, arg2)
314+ }
315+ CallbackVarRef = purego.NewCallback(fcb)
316+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
317+ }
318+ }
319+
320+ cret := xNewSimpleAsyncResult(SourceObjectVar.GoPointer(), CallbackVarRef, UserDataVar, SourceTagVar)
261321
262322 if cret == 0 {
263323 return nil
@@ -273,7 +333,22 @@ var xNewSimpleAsyncResultError func(uintptr, uintptr, uintptr, glib.Quark, int,
273333 func NewSimpleAsyncResultError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) *SimpleAsyncResult {
274334 var cls *SimpleAsyncResult
275335
276- cret := xNewSimpleAsyncResultError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
336+ var CallbackVarRef uintptr
337+ if CallbackVar != nil {
338+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
339+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
340+ CallbackVarRef = cbRefPtr
341+ } else {
342+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
343+ cbFn := *CallbackVar
344+ cbFn(arg0, arg1, arg2)
345+ }
346+ CallbackVarRef = purego.NewCallback(fcb)
347+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
348+ }
349+ }
350+
351+ cret := xNewSimpleAsyncResultError(SourceObjectVar.GoPointer(), CallbackVarRef, UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
277352
278353 if cret == 0 {
279354 return nil
@@ -289,7 +364,22 @@ var xNewSimpleAsyncResultFromError func(uintptr, uintptr, uintptr, *glib.Error)
289364 func NewSimpleAsyncResultFromError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) *SimpleAsyncResult {
290365 var cls *SimpleAsyncResult
291366
292- cret := xNewSimpleAsyncResultFromError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, ErrorVar)
367+ var CallbackVarRef uintptr
368+ if CallbackVar != nil {
369+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
370+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
371+ CallbackVarRef = cbRefPtr
372+ } else {
373+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
374+ cbFn := *CallbackVar
375+ cbFn(arg0, arg1, arg2)
376+ }
377+ CallbackVarRef = purego.NewCallback(fcb)
378+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
379+ }
380+ }
381+
382+ cret := xNewSimpleAsyncResultFromError(SourceObjectVar.GoPointer(), CallbackVarRef, UserDataVar, ErrorVar)
293383
294384 if cret == 0 {
295385 return nil
@@ -306,7 +396,22 @@ var xNewSimpleAsyncResultTakeError func(uintptr, uintptr, uintptr, *glib.Error)
306396 func NewSimpleAsyncResultTakeError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) *SimpleAsyncResult {
307397 var cls *SimpleAsyncResult
308398
309- cret := xNewSimpleAsyncResultTakeError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, ErrorVar)
399+ var CallbackVarRef uintptr
400+ if CallbackVar != nil {
401+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
402+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
403+ CallbackVarRef = cbRefPtr
404+ } else {
405+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
406+ cbFn := *CallbackVar
407+ cbFn(arg0, arg1, arg2)
408+ }
409+ CallbackVarRef = purego.NewCallback(fcb)
410+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
411+ }
412+ }
413+
414+ cret := xNewSimpleAsyncResultTakeError(SourceObjectVar.GoPointer(), CallbackVarRef, UserDataVar, ErrorVar)
310415
311416 if cret == 0 {
312417 return nil
@@ -411,7 +516,20 @@ var xSimpleAsyncResultRunInThread func(uintptr, uintptr, int, uintptr)
411516 // is needed to run the job and report its completion.
412517 func (x *SimpleAsyncResult) RunInThread(FuncVar *SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar *Cancellable) {
413518
414- xSimpleAsyncResultRunInThread(x.GoPointer(), glib.NewCallback(FuncVar), IoPriorityVar, CancellableVar.GoPointer())
519+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
520+ 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)
527+ }
528+ FuncVarRef = purego.NewCallback(fcb)
529+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
530+ }
531+
532+ xSimpleAsyncResultRunInThread(x.GoPointer(), FuncVarRef, IoPriorityVar, CancellableVar.GoPointer())
415533
416534 }
417535
@@ -493,7 +611,20 @@ var xSimpleAsyncResultSetOpResGpointer func(uintptr, uintptr, uintptr)
493611 // Sets the operation result within the asynchronous result to a pointer.
494612 func (x *SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar *glib.DestroyNotify) {
495613
496- xSimpleAsyncResultSetOpResGpointer(x.GoPointer(), OpResVar, glib.NewCallback(DestroyOpResVar))
614+ DestroyOpResVarPtr := uintptr(unsafe.Pointer(DestroyOpResVar))
615+ 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)
622+ }
623+ DestroyOpResVarRef = purego.NewCallback(fcb)
624+ glib.SaveCallback(DestroyOpResVarPtr, DestroyOpResVarRef)
625+ }
626+
627+ xSimpleAsyncResultSetOpResGpointer(x.GoPointer(), OpResVar, DestroyOpResVarRef)
497628
498629 }
499630
M v4/gio/gsocketaddressenumerator.go +16 -1
@@ -197,7 +197,22 @@ var xSocketAddressEnumeratorNextAsync func(uintptr, uintptr, uintptr, uintptr)
197197 // It is an error to call this multiple times before the previous callback has finished.
198198 func (x *SocketAddressEnumerator) NextAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
199199
200- xSocketAddressEnumeratorNextAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
200+ var CallbackVarRef uintptr
201+ if CallbackVar != nil {
202+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
203+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
204+ CallbackVarRef = cbRefPtr
205+ } else {
206+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
207+ cbFn := *CallbackVar
208+ cbFn(arg0, arg1, arg2)
209+ }
210+ CallbackVarRef = purego.NewCallback(fcb)
211+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
212+ }
213+ }
214+
215+ xSocketAddressEnumeratorNextAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
201216
202217 }
203218
M v4/gio/gsocketclient.go +64 -4
@@ -283,7 +283,22 @@ var xSocketClientConnectAsync func(uintptr, uintptr, uintptr, uintptr, uintptr)
283283 // the result of the operation.
284284 func (x *SocketClient) ConnectAsync(ConnectableVar SocketConnectable, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
285285
286- xSocketClientConnectAsync(x.GoPointer(), ConnectableVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
286+ var CallbackVarRef uintptr
287+ if CallbackVar != nil {
288+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
289+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
290+ CallbackVarRef = cbRefPtr
291+ } else {
292+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
293+ cbFn := *CallbackVar
294+ cbFn(arg0, arg1, arg2)
295+ }
296+ CallbackVarRef = purego.NewCallback(fcb)
297+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
298+ }
299+ }
300+
301+ xSocketClientConnectAsync(x.GoPointer(), ConnectableVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
287302
288303 }
289304
@@ -367,7 +382,22 @@ var xSocketClientConnectToHostAsync func(uintptr, string, uint16, uintptr, uintp
367382 // the result of the operation.
368383 func (x *SocketClient) ConnectToHostAsync(HostAndPortVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
369384
370- xSocketClientConnectToHostAsync(x.GoPointer(), HostAndPortVar, DefaultPortVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
385+ var CallbackVarRef uintptr
386+ if CallbackVar != nil {
387+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
388+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
389+ CallbackVarRef = cbRefPtr
390+ } else {
391+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
392+ cbFn := *CallbackVar
393+ cbFn(arg0, arg1, arg2)
394+ }
395+ CallbackVarRef = purego.NewCallback(fcb)
396+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
397+ }
398+ }
399+
400+ xSocketClientConnectToHostAsync(x.GoPointer(), HostAndPortVar, DefaultPortVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
371401
372402 }
373403
@@ -432,7 +462,22 @@ var xSocketClientConnectToServiceAsync func(uintptr, string, string, uintptr, ui
432462 // g_socket_client_connect_to_service().
433463 func (x *SocketClient) ConnectToServiceAsync(DomainVar string, ServiceVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
434464
435- xSocketClientConnectToServiceAsync(x.GoPointer(), DomainVar, ServiceVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
465+ var CallbackVarRef uintptr
466+ if CallbackVar != nil {
467+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
468+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
469+ CallbackVarRef = cbRefPtr
470+ } else {
471+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
472+ cbFn := *CallbackVar
473+ cbFn(arg0, arg1, arg2)
474+ }
475+ CallbackVarRef = purego.NewCallback(fcb)
476+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
477+ }
478+ }
479+
480+ xSocketClientConnectToServiceAsync(x.GoPointer(), DomainVar, ServiceVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
436481
437482 }
438483
@@ -507,7 +552,22 @@ var xSocketClientConnectToUriAsync func(uintptr, string, uint16, uintptr, uintpt
507552 // the result of the operation.
508553 func (x *SocketClient) ConnectToUriAsync(UriVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
509554
510- xSocketClientConnectToUriAsync(x.GoPointer(), UriVar, DefaultPortVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
555+ var CallbackVarRef uintptr
556+ if CallbackVar != nil {
557+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
558+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
559+ CallbackVarRef = cbRefPtr
560+ } else {
561+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
562+ cbFn := *CallbackVar
563+ cbFn(arg0, arg1, arg2)
564+ }
565+ CallbackVarRef = purego.NewCallback(fcb)
566+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
567+ }
568+ }
569+
570+ xSocketClientConnectToUriAsync(x.GoPointer(), UriVar, DefaultPortVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
511571
512572 }
513573
M v4/gio/gsocketconnection.go +16 -1
@@ -240,7 +240,22 @@ var xSocketConnectionConnectAsync func(uintptr, uintptr, uintptr, uintptr, uintp
240240 // Use g_socket_connection_connect_finish() to retrieve the result.
241241 func (x *SocketConnection) ConnectAsync(AddressVar *SocketAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
242242
243- xSocketConnectionConnectAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
243+ var CallbackVarRef uintptr
244+ if CallbackVar != nil {
245+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
246+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
247+ CallbackVarRef = cbRefPtr
248+ } else {
249+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
250+ cbFn := *CallbackVar
251+ cbFn(arg0, arg1, arg2)
252+ }
253+ CallbackVarRef = purego.NewCallback(fcb)
254+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
255+ }
256+ }
257+
258+ xSocketConnectionConnectAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
244259
245260 }
246261
M v4/gio/gsocketlistener.go +32 -2
@@ -297,7 +297,22 @@ var xSocketListenerAcceptAsync func(uintptr, uintptr, uintptr, uintptr)
297297 // to get the result of the operation.
298298 func (x *SocketListener) AcceptAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
299299
300- xSocketListenerAcceptAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
300+ var CallbackVarRef uintptr
301+ if CallbackVar != nil {
302+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
303+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
304+ CallbackVarRef = cbRefPtr
305+ } else {
306+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
307+ cbFn := *CallbackVar
308+ cbFn(arg0, arg1, arg2)
309+ }
310+ CallbackVarRef = purego.NewCallback(fcb)
311+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
312+ }
313+ }
314+
315+ xSocketListenerAcceptAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
301316
302317 }
303318
@@ -365,7 +380,22 @@ var xSocketListenerAcceptSocketAsync func(uintptr, uintptr, uintptr, uintptr)
365380 // to get the result of the operation.
366381 func (x *SocketListener) AcceptSocketAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
367382
368- xSocketListenerAcceptSocketAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
383+ var CallbackVarRef uintptr
384+ if CallbackVar != nil {
385+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
386+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
387+ CallbackVarRef = cbRefPtr
388+ } else {
389+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
390+ cbFn := *CallbackVar
391+ cbFn(arg0, arg1, arg2)
392+ }
393+ CallbackVarRef = purego.NewCallback(fcb)
394+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
395+ }
396+ }
397+
398+ xSocketListenerAcceptSocketAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
369399
370400 }
371401
M v4/gio/gsubprocess.go +64 -4
@@ -195,7 +195,22 @@ var xSubprocessCommunicateAsync func(uintptr, *glib.Bytes, uintptr, uintptr, uin
195195 // invocation with g_subprocess_communicate_finish().
196196 func (x *Subprocess) CommunicateAsync(StdinBufVar *glib.Bytes, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
197197
198- xSubprocessCommunicateAsync(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
198+ var CallbackVarRef uintptr
199+ if CallbackVar != nil {
200+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
201+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
202+ CallbackVarRef = cbRefPtr
203+ } else {
204+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
205+ cbFn := *CallbackVar
206+ cbFn(arg0, arg1, arg2)
207+ }
208+ CallbackVarRef = purego.NewCallback(fcb)
209+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
210+ }
211+ }
212+
213+ xSubprocessCommunicateAsync(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
199214
200215 }
201216
@@ -237,7 +252,22 @@ var xSubprocessCommunicateUtf8Async func(uintptr, string, uintptr, uintptr, uint
237252 // invocation with g_subprocess_communicate_utf8_finish().
238253 func (x *Subprocess) CommunicateUtf8Async(StdinBufVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
239254
240- xSubprocessCommunicateUtf8Async(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
255+ var CallbackVarRef uintptr
256+ if CallbackVar != nil {
257+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
258+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
259+ CallbackVarRef = cbRefPtr
260+ } else {
261+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
262+ cbFn := *CallbackVar
263+ cbFn(arg0, arg1, arg2)
264+ }
265+ CallbackVarRef = purego.NewCallback(fcb)
266+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
267+ }
268+ }
269+
270+ xSubprocessCommunicateUtf8Async(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
241271
242272 }
243273
@@ -483,7 +513,22 @@ var xSubprocessWaitAsync func(uintptr, uintptr, uintptr, uintptr)
483513 // This is the asynchronous version of g_subprocess_wait().
484514 func (x *Subprocess) WaitAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
485515
486- xSubprocessWaitAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
516+ var CallbackVarRef uintptr
517+ if CallbackVar != nil {
518+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
519+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
520+ CallbackVarRef = cbRefPtr
521+ } else {
522+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
523+ cbFn := *CallbackVar
524+ cbFn(arg0, arg1, arg2)
525+ }
526+ CallbackVarRef = purego.NewCallback(fcb)
527+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
528+ }
529+ }
530+
531+ xSubprocessWaitAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
487532
488533 }
489534
@@ -508,7 +553,22 @@ var xSubprocessWaitCheckAsync func(uintptr, uintptr, uintptr, uintptr)
508553 // This is the asynchronous version of g_subprocess_wait_check().
509554 func (x *Subprocess) WaitCheckAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
510555
511- xSubprocessWaitCheckAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
556+ var CallbackVarRef uintptr
557+ if CallbackVar != nil {
558+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
559+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
560+ CallbackVarRef = cbRefPtr
561+ } else {
562+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
563+ cbFn := *CallbackVar
564+ cbFn(arg0, arg1, arg2)
565+ }
566+ CallbackVarRef = purego.NewCallback(fcb)
567+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
568+ }
569+ }
570+
571+ xSubprocessWaitCheckAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
512572
513573 }
514574
M v4/gio/gsubprocesslauncher.go +29 -1
@@ -2,6 +2,8 @@
22 package gio
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -101,7 +103,33 @@ var xSubprocessLauncherSetChildSetup func(uintptr, uintptr, uintptr, uintptr)
101103 // Child setup functions are only available on UNIX.
102104 func (x *SubprocessLauncher) SetChildSetup(ChildSetupVar *glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
103105
104- xSubprocessLauncherSetChildSetup(x.GoPointer(), glib.NewCallback(ChildSetupVar), UserDataVar, glib.NewCallback(DestroyNotifyVar))
106+ ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
107+ 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)
114+ }
115+ ChildSetupVarRef = purego.NewCallback(fcb)
116+ glib.SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
117+ }
118+
119+ DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
120+ 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)
127+ }
128+ DestroyNotifyVarRef = purego.NewCallback(fcb)
129+ glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
130+ }
131+
132+ xSubprocessLauncherSetChildSetup(x.GoPointer(), ChildSetupVarRef, UserDataVar, DestroyNotifyVarRef)
105133
106134 }
107135
M v4/gio/gtask.go +122 -8
@@ -633,7 +633,22 @@ var xNewTask func(uintptr, uintptr, uintptr, uintptr) uintptr
633633 func NewTask(SourceObjectVar *gobject.Object, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr) *Task {
634634 var cls *Task
635635
636- cret := xNewTask(SourceObjectVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), CallbackDataVar)
636+ var CallbackVarRef uintptr
637+ if CallbackVar != nil {
638+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
639+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
640+ CallbackVarRef = cbRefPtr
641+ } else {
642+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
643+ cbFn := *CallbackVar
644+ cbFn(arg0, arg1, arg2)
645+ }
646+ CallbackVarRef = purego.NewCallback(fcb)
647+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
648+ }
649+ }
650+
651+ cret := xNewTask(SourceObjectVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, CallbackDataVar)
637652
638653 if cret == 0 {
639654 return nil
@@ -658,7 +673,20 @@ var xTaskAttachSource func(uintptr, *glib.Source, uintptr)
658673 // This takes a reference on @task until @source is destroyed.
659674 func (x *Task) AttachSource(SourceVar *glib.Source, CallbackVar *glib.SourceFunc) {
660675
661- xTaskAttachSource(x.GoPointer(), SourceVar, glib.NewCallback(CallbackVar))
676+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
677+ 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)
684+ }
685+ CallbackVarRef = purego.NewCallback(fcb)
686+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
687+ }
688+
689+ xTaskAttachSource(x.GoPointer(), SourceVar, CallbackVarRef)
662690
663691 }
664692
@@ -977,7 +1005,22 @@ var xTaskReturnPointer func(uintptr, uintptr, uintptr)
9771005 // reference on it.
9781006 func (x *Task) ReturnPointer(ResultVar uintptr, ResultDestroyVar *glib.DestroyNotify) {
9791007
980- xTaskReturnPointer(x.GoPointer(), ResultVar, glib.NewCallbackNullable(ResultDestroyVar))
1008+ var ResultDestroyVarRef uintptr
1009+ if ResultDestroyVar != nil {
1010+ ResultDestroyVarPtr := uintptr(unsafe.Pointer(ResultDestroyVar))
1011+ if cbRefPtr, ok := glib.GetCallback(ResultDestroyVarPtr); ok {
1012+ ResultDestroyVarRef = cbRefPtr
1013+ } else {
1014+ fcb := func(arg0 uintptr) {
1015+ cbFn := *ResultDestroyVar
1016+ cbFn(arg0)
1017+ }
1018+ ResultDestroyVarRef = purego.NewCallback(fcb)
1019+ glib.SaveCallback(ResultDestroyVarPtr, ResultDestroyVarRef)
1020+ }
1021+ }
1022+
1023+ xTaskReturnPointer(x.GoPointer(), ResultVar, ResultDestroyVarRef)
9811024
9821025 }
9831026
@@ -1040,7 +1083,20 @@ var xTaskRunInThread func(uintptr, uintptr)
10401083 // g_task_run_in_thread().
10411084 func (x *Task) RunInThread(TaskFuncVar *TaskThreadFunc) {
10421085
1043- xTaskRunInThread(x.GoPointer(), glib.NewCallback(TaskFuncVar))
1086+ TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
1087+ 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)
1094+ }
1095+ TaskFuncVarRef = purego.NewCallback(fcb)
1096+ glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
1097+ }
1098+
1099+ xTaskRunInThread(x.GoPointer(), TaskFuncVarRef)
10441100
10451101 }
10461102
@@ -1064,7 +1120,20 @@ var xTaskRunInThreadSync func(uintptr, uintptr)
10641120 // limited number of them at a time.
10651121 func (x *Task) RunInThreadSync(TaskFuncVar *TaskThreadFunc) {
10661122
1067- xTaskRunInThreadSync(x.GoPointer(), glib.NewCallback(TaskFuncVar))
1123+ TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
1124+ 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)
1131+ }
1132+ TaskFuncVarRef = purego.NewCallback(fcb)
1133+ glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
1134+ }
1135+
1136+ xTaskRunInThreadSync(x.GoPointer(), TaskFuncVarRef)
10681137
10691138 }
10701139
@@ -1197,7 +1266,22 @@ var xTaskSetTaskData func(uintptr, uintptr, uintptr)
11971266 // Sets @task's task data (freeing the existing task data, if any).
11981267 func (x *Task) SetTaskData(TaskDataVar uintptr, TaskDataDestroyVar *glib.DestroyNotify) {
11991268
1200- xTaskSetTaskData(x.GoPointer(), TaskDataVar, glib.NewCallbackNullable(TaskDataDestroyVar))
1269+ var TaskDataDestroyVarRef uintptr
1270+ if TaskDataDestroyVar != nil {
1271+ TaskDataDestroyVarPtr := uintptr(unsafe.Pointer(TaskDataDestroyVar))
1272+ if cbRefPtr, ok := glib.GetCallback(TaskDataDestroyVarPtr); ok {
1273+ TaskDataDestroyVarRef = cbRefPtr
1274+ } else {
1275+ fcb := func(arg0 uintptr) {
1276+ cbFn := *TaskDataDestroyVar
1277+ cbFn(arg0)
1278+ }
1279+ TaskDataDestroyVarRef = purego.NewCallback(fcb)
1280+ glib.SaveCallback(TaskDataDestroyVarPtr, TaskDataDestroyVarRef)
1281+ }
1282+ }
1283+
1284+ xTaskSetTaskData(x.GoPointer(), TaskDataVar, TaskDataDestroyVarRef)
12011285
12021286 }
12031287
@@ -1296,7 +1380,22 @@ var xTaskReportError func(uintptr, uintptr, uintptr, uintptr, *glib.Error)
12961380 // See also g_task_report_new_error().
12971381 func TaskReportError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, ErrorVar *glib.Error) {
12981382
1299- xTaskReportError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), CallbackDataVar, SourceTagVar, ErrorVar)
1383+ var CallbackVarRef uintptr
1384+ if CallbackVar != nil {
1385+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1386+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1387+ CallbackVarRef = cbRefPtr
1388+ } else {
1389+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1390+ cbFn := *CallbackVar
1391+ cbFn(arg0, arg1, arg2)
1392+ }
1393+ CallbackVarRef = purego.NewCallback(fcb)
1394+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1395+ }
1396+ }
1397+
1398+ xTaskReportError(SourceObjectVar.GoPointer(), CallbackVarRef, CallbackDataVar, SourceTagVar, ErrorVar)
13001399
13011400 }
13021401
@@ -1313,7 +1412,22 @@ var xTaskReportNewError func(uintptr, uintptr, uintptr, uintptr, glib.Quark, int
13131412 // See also g_task_report_error().
13141413 func TaskReportNewError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {
13151414
1316- xTaskReportNewError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), CallbackDataVar, SourceTagVar, DomainVar, CodeVar, FormatVar, varArgs...)
1415+ var CallbackVarRef uintptr
1416+ if CallbackVar != nil {
1417+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1418+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
1419+ CallbackVarRef = cbRefPtr
1420+ } else {
1421+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
1422+ cbFn := *CallbackVar
1423+ cbFn(arg0, arg1, arg2)
1424+ }
1425+ CallbackVarRef = purego.NewCallback(fcb)
1426+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1427+ }
1428+ }
1429+
1430+ xTaskReportNewError(SourceObjectVar.GoPointer(), CallbackVarRef, CallbackDataVar, SourceTagVar, DomainVar, CodeVar, FormatVar, varArgs...)
13171431
13181432 }
13191433
M v4/gio/gtlsconnection.go +16 -1
@@ -483,7 +483,22 @@ var xTlsConnectionHandshakeAsync func(uintptr, int, uintptr, uintptr, uintptr)
483483 // g_tls_connection_handshake() for more information.
484484 func (x *TlsConnection) HandshakeAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
485485
486- xTlsConnectionHandshakeAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
486+ var CallbackVarRef uintptr
487+ if CallbackVar != nil {
488+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
489+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
490+ CallbackVarRef = cbRefPtr
491+ } else {
492+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
493+ cbFn := *CallbackVar
494+ cbFn(arg0, arg1, arg2)
495+ }
496+ CallbackVarRef = purego.NewCallback(fcb)
497+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
498+ }
499+ }
500+
501+ xTlsConnectionHandshakeAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
487502
488503 }
489504
M v4/gio/gtlsdatabase.go +64 -4
@@ -566,7 +566,22 @@ var xTlsDatabaseLookupCertificateForHandleAsync func(uintptr, string, uintptr, T
566566 // g_tls_database_lookup_certificate_for_handle() for more information.
567567 func (x *TlsDatabase) LookupCertificateForHandleAsync(HandleVar string, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
568568
569- xTlsDatabaseLookupCertificateForHandleAsync(x.GoPointer(), HandleVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
569+ var CallbackVarRef uintptr
570+ if CallbackVar != nil {
571+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
572+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
573+ CallbackVarRef = cbRefPtr
574+ } else {
575+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
576+ cbFn := *CallbackVar
577+ cbFn(arg0, arg1, arg2)
578+ }
579+ CallbackVarRef = purego.NewCallback(fcb)
580+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
581+ }
582+ }
583+
584+ xTlsDatabaseLookupCertificateForHandleAsync(x.GoPointer(), HandleVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
570585
571586 }
572587
@@ -641,7 +656,22 @@ var xTlsDatabaseLookupCertificateIssuerAsync func(uintptr, uintptr, uintptr, Tls
641656 // g_tls_database_lookup_certificate_issuer() for more information.
642657 func (x *TlsDatabase) LookupCertificateIssuerAsync(CertificateVar *TlsCertificate, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
643658
644- xTlsDatabaseLookupCertificateIssuerAsync(x.GoPointer(), CertificateVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
659+ var CallbackVarRef uintptr
660+ if CallbackVar != nil {
661+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
662+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
663+ CallbackVarRef = cbRefPtr
664+ } else {
665+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
666+ cbFn := *CallbackVar
667+ cbFn(arg0, arg1, arg2)
668+ }
669+ CallbackVarRef = purego.NewCallback(fcb)
670+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
671+ }
672+ }
673+
674+ xTlsDatabaseLookupCertificateIssuerAsync(x.GoPointer(), CertificateVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
645675
646676 }
647677
@@ -694,7 +724,22 @@ var xTlsDatabaseLookupCertificatesIssuedByAsync func(uintptr, []byte, uintptr, T
694724 // this time.
695725 func (x *TlsDatabase) LookupCertificatesIssuedByAsync(IssuerRawDnVar []byte, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
696726
697- xTlsDatabaseLookupCertificatesIssuedByAsync(x.GoPointer(), IssuerRawDnVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
727+ var CallbackVarRef uintptr
728+ if CallbackVar != nil {
729+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
730+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
731+ CallbackVarRef = cbRefPtr
732+ } else {
733+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
734+ cbFn := *CallbackVar
735+ cbFn(arg0, arg1, arg2)
736+ }
737+ CallbackVarRef = purego.NewCallback(fcb)
738+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
739+ }
740+ }
741+
742+ xTlsDatabaseLookupCertificatesIssuedByAsync(x.GoPointer(), IssuerRawDnVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
698743
699744 }
700745
@@ -793,7 +838,22 @@ var xTlsDatabaseVerifyChainAsync func(uintptr, uintptr, string, uintptr, uintptr
793838 // g_tls_database_verify_chain() for more information.
794839 func (x *TlsDatabase) VerifyChainAsync(ChainVar *TlsCertificate, PurposeVar string, IdentityVar SocketConnectable, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseVerifyFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
795840
796- xTlsDatabaseVerifyChainAsync(x.GoPointer(), ChainVar.GoPointer(), PurposeVar, IdentityVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
841+ var CallbackVarRef uintptr
842+ if CallbackVar != nil {
843+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
844+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
845+ CallbackVarRef = cbRefPtr
846+ } else {
847+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
848+ cbFn := *CallbackVar
849+ cbFn(arg0, arg1, arg2)
850+ }
851+ CallbackVarRef = purego.NewCallback(fcb)
852+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
853+ }
854+ }
855+
856+ xTlsDatabaseVerifyChainAsync(x.GoPointer(), ChainVar.GoPointer(), PurposeVar, IdentityVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
797857
798858 }
799859
M v4/gio/gtlsinteraction.go +32 -2
@@ -321,7 +321,22 @@ var xTlsInteractionAskPasswordAsync func(uintptr, uintptr, uintptr, uintptr, uin
321321 // Certain implementations may not support immediate cancellation.
322322 func (x *TlsInteraction) AskPasswordAsync(PasswordVar *TlsPassword, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
323323
324- xTlsInteractionAskPasswordAsync(x.GoPointer(), PasswordVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
324+ var CallbackVarRef uintptr
325+ if CallbackVar != nil {
326+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
327+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
328+ CallbackVarRef = cbRefPtr
329+ } else {
330+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
331+ cbFn := *CallbackVar
332+ cbFn(arg0, arg1, arg2)
333+ }
334+ CallbackVarRef = purego.NewCallback(fcb)
335+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
336+ }
337+ }
338+
339+ xTlsInteractionAskPasswordAsync(x.GoPointer(), PasswordVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
325340
326341 }
327342
@@ -453,7 +468,22 @@ var xTlsInteractionRequestCertificateAsync func(uintptr, uintptr, TlsCertificate
453468 // request, which will usually abort the TLS connection.
454469 func (x *TlsInteraction) RequestCertificateAsync(ConnectionVar *TlsConnection, FlagsVar TlsCertificateRequestFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
455470
456- xTlsInteractionRequestCertificateAsync(x.GoPointer(), ConnectionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
471+ var CallbackVarRef uintptr
472+ if CallbackVar != nil {
473+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
474+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
475+ CallbackVarRef = cbRefPtr
476+ } else {
477+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
478+ cbFn := *CallbackVar
479+ cbFn(arg0, arg1, arg2)
480+ }
481+ CallbackVarRef = purego.NewCallback(fcb)
482+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
483+ }
484+ }
485+
486+ xTlsInteractionRequestCertificateAsync(x.GoPointer(), ConnectionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
457487
458488 }
459489
M v4/gio/gtlspassword.go +16 -1
@@ -240,7 +240,22 @@ var xTlsPasswordSetValueFull func(uintptr, []byte, int, uintptr)
240240 // considered part of the password in this case.)
241241 func (x *TlsPassword) SetValueFull(ValueVar []byte, LengthVar int, DestroyVar *glib.DestroyNotify) {
242242
243- xTlsPasswordSetValueFull(x.GoPointer(), ValueVar, LengthVar, glib.NewCallbackNullable(DestroyVar))
243+ var DestroyVarRef uintptr
244+ if DestroyVar != nil {
245+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
246+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
247+ DestroyVarRef = cbRefPtr
248+ } else {
249+ fcb := func(arg0 uintptr) {
250+ cbFn := *DestroyVar
251+ cbFn(arg0)
252+ }
253+ DestroyVarRef = purego.NewCallback(fcb)
254+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
255+ }
256+ }
257+
258+ xTlsPasswordSetValueFull(x.GoPointer(), ValueVar, LengthVar, DestroyVarRef)
244259
245260 }
246261
M v4/gio/gunixconnection.go +32 -2
@@ -106,7 +106,22 @@ var xUnixConnectionReceiveCredentialsAsync func(uintptr, uintptr, uintptr, uintp
106106 // g_unix_connection_receive_credentials_finish() to get the result of the operation.
107107 func (x *UnixConnection) ReceiveCredentialsAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
108108
109- xUnixConnectionReceiveCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
109+ var CallbackVarRef uintptr
110+ if CallbackVar != nil {
111+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
112+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
113+ CallbackVarRef = cbRefPtr
114+ } else {
115+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
116+ cbFn := *CallbackVar
117+ cbFn(arg0, arg1, arg2)
118+ }
119+ CallbackVarRef = purego.NewCallback(fcb)
120+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
121+ }
122+ }
123+
124+ xUnixConnectionReceiveCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
110125
111126 }
112127
@@ -195,7 +210,22 @@ var xUnixConnectionSendCredentialsAsync func(uintptr, uintptr, uintptr, uintptr)
195210 // g_unix_connection_send_credentials_finish() to get the result of the operation.
196211 func (x *UnixConnection) SendCredentialsAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
197212
198- xUnixConnectionSendCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
213+ var CallbackVarRef uintptr
214+ if CallbackVar != nil {
215+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
216+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
217+ CallbackVarRef = cbRefPtr
218+ } else {
219+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
220+ cbFn := *CallbackVar
221+ cbFn(arg0, arg1, arg2)
222+ }
223+ CallbackVarRef = purego.NewCallback(fcb)
224+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
225+ }
226+ }
227+
228+ xUnixConnectionSendCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
199229
200230 }
201231
M v4/gio/gvfs.go +61 -1
@@ -614,7 +614,67 @@ var xVfsRegisterUriScheme func(uintptr, string, uintptr, uintptr, uintptr, uintp
614614 // a custom URI scheme, use g_vfs_unregister_uri_scheme().
615615 func (x *Vfs) RegisterUriScheme(SchemeVar string, UriFuncVar *VfsFileLookupFunc, UriDataVar uintptr, UriDestroyVar *glib.DestroyNotify, ParseNameFuncVar *VfsFileLookupFunc, ParseNameDataVar uintptr, ParseNameDestroyVar *glib.DestroyNotify) bool {
616616
617- cret := xVfsRegisterUriScheme(x.GoPointer(), SchemeVar, glib.NewCallbackNullable(UriFuncVar), UriDataVar, glib.NewCallbackNullable(UriDestroyVar), glib.NewCallbackNullable(ParseNameFuncVar), ParseNameDataVar, glib.NewCallbackNullable(ParseNameDestroyVar))
617+ var UriFuncVarRef uintptr
618+ if UriFuncVar != nil {
619+ UriFuncVarPtr := uintptr(unsafe.Pointer(UriFuncVar))
620+ if cbRefPtr, ok := glib.GetCallback(UriFuncVarPtr); ok {
621+ UriFuncVarRef = cbRefPtr
622+ } else {
623+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) uintptr {
624+ cbFn := *UriFuncVar
625+ return cbFn(arg0, arg1, arg2)
626+ }
627+ UriFuncVarRef = purego.NewCallback(fcb)
628+ glib.SaveCallback(UriFuncVarPtr, UriFuncVarRef)
629+ }
630+ }
631+
632+ var UriDestroyVarRef uintptr
633+ if UriDestroyVar != nil {
634+ UriDestroyVarPtr := uintptr(unsafe.Pointer(UriDestroyVar))
635+ if cbRefPtr, ok := glib.GetCallback(UriDestroyVarPtr); ok {
636+ UriDestroyVarRef = cbRefPtr
637+ } else {
638+ fcb := func(arg0 uintptr) {
639+ cbFn := *UriDestroyVar
640+ cbFn(arg0)
641+ }
642+ UriDestroyVarRef = purego.NewCallback(fcb)
643+ glib.SaveCallback(UriDestroyVarPtr, UriDestroyVarRef)
644+ }
645+ }
646+
647+ var ParseNameFuncVarRef uintptr
648+ if ParseNameFuncVar != nil {
649+ ParseNameFuncVarPtr := uintptr(unsafe.Pointer(ParseNameFuncVar))
650+ if cbRefPtr, ok := glib.GetCallback(ParseNameFuncVarPtr); ok {
651+ ParseNameFuncVarRef = cbRefPtr
652+ } else {
653+ fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) uintptr {
654+ cbFn := *ParseNameFuncVar
655+ return cbFn(arg0, arg1, arg2)
656+ }
657+ ParseNameFuncVarRef = purego.NewCallback(fcb)
658+ glib.SaveCallback(ParseNameFuncVarPtr, ParseNameFuncVarRef)
659+ }
660+ }
661+
662+ var ParseNameDestroyVarRef uintptr
663+ if ParseNameDestroyVar != nil {
664+ ParseNameDestroyVarPtr := uintptr(unsafe.Pointer(ParseNameDestroyVar))
665+ if cbRefPtr, ok := glib.GetCallback(ParseNameDestroyVarPtr); ok {
666+ ParseNameDestroyVarRef = cbRefPtr
667+ } else {
668+ fcb := func(arg0 uintptr) {
669+ cbFn := *ParseNameDestroyVar
670+ cbFn(arg0)
671+ }
672+ ParseNameDestroyVarRef = purego.NewCallback(fcb)
673+ glib.SaveCallback(ParseNameDestroyVarPtr, ParseNameDestroyVarRef)
674+ }
675+ }
676+
677+ cret := xVfsRegisterUriScheme(x.GoPointer(), SchemeVar, UriFuncVarRef, UriDataVar, UriDestroyVarRef, ParseNameFuncVarRef, ParseNameDataVar, ParseNameDestroyVarRef)
618678 return cret
619679 }
620680
M v4/glib/garray.go +152 -8
@@ -147,7 +147,20 @@ var xNewBytesWithFreeFunc func([]byte, uint, uintptr, uintptr) *Bytes
147147 // @data may be `NULL` if @size is 0.
148148 func NewBytesWithFreeFunc(DataVar []byte, SizeVar uint, FreeFuncVar *DestroyNotify, UserDataVar uintptr) *Bytes {
149149
150- cret := xNewBytesWithFreeFunc(DataVar, SizeVar, NewCallback(FreeFuncVar), UserDataVar)
150+ FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
151+ 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)
158+ }
159+ FreeFuncVarRef = purego.NewCallback(fcb)
160+ SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
161+ }
162+
163+ cret := xNewBytesWithFreeFunc(DataVar, SizeVar, FreeFuncVarRef, UserDataVar)
151164 return cret
152165 }
153166
@@ -553,7 +566,20 @@ var xByteArraySort func([]byte, uintptr)
553566 // their addresses.
554567 func ByteArraySort(ArrayVar []byte, CompareFuncVar *CompareFunc) {
555568
556- xByteArraySort(ArrayVar, NewCallback(CompareFuncVar))
569+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
570+ 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)
577+ }
578+ CompareFuncVarRef = purego.NewCallback(fcb)
579+ SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
580+ }
581+
582+ xByteArraySort(ArrayVar, CompareFuncVarRef)
557583
558584 }
559585
@@ -563,7 +589,20 @@ var xByteArraySortWithData func([]byte, uintptr, uintptr)
563589 // user data argument.
564590 func ByteArraySortWithData(ArrayVar []byte, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
565591
566- xByteArraySortWithData(ArrayVar, NewCallback(CompareFuncVar), UserDataVar)
592+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
593+ 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)
600+ }
601+ CompareFuncVarRef = purego.NewCallback(fcb)
602+ SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
603+ }
604+
605+ xByteArraySortWithData(ArrayVar, CompareFuncVarRef, UserDataVar)
567606
568607 }
569608
@@ -619,7 +658,22 @@ var xPtrArrayFindWithEqualFunc func([]uintptr, uintptr, uintptr, *uint) bool
619658 // equality is used.
620659 func PtrArrayFindWithEqualFunc(HaystackVar []uintptr, NeedleVar uintptr, EqualFuncVar *EqualFunc, IndexVar *uint) bool {
621660
622- cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, NewCallbackNullable(EqualFuncVar), IndexVar)
661+ var EqualFuncVarRef uintptr
662+ if EqualFuncVar != nil {
663+ EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
664+ if cbRefPtr, ok := GetCallback(EqualFuncVarPtr); ok {
665+ EqualFuncVarRef = cbRefPtr
666+ } else {
667+ fcb := func(arg0 uintptr, arg1 uintptr) bool {
668+ cbFn := *EqualFuncVar
669+ return cbFn(arg0, arg1)
670+ }
671+ EqualFuncVarRef = purego.NewCallback(fcb)
672+ SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
673+ }
674+ }
675+
676+ cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, EqualFuncVarRef, IndexVar)
623677 return cret
624678 }
625679
@@ -644,7 +698,37 @@ var xPtrArrayNewFromArray func([]uintptr, uint, uintptr, uintptr, uintptr) uintp
644698 // than `gsize`.
645699 func PtrArrayNewFromArray(DataVar []uintptr, LenVar uint, CopyFuncVar *CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {
646700
647- cret := xPtrArrayNewFromArray(DataVar, LenVar, NewCallbackNullable(CopyFuncVar), CopyFuncUserDataVar, NewCallbackNullable(ElementFreeFuncVar))
701+ var CopyFuncVarRef uintptr
702+ if CopyFuncVar != nil {
703+ CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
704+ if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
705+ CopyFuncVarRef = cbRefPtr
706+ } else {
707+ fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
708+ cbFn := *CopyFuncVar
709+ return cbFn(arg0, arg1)
710+ }
711+ CopyFuncVarRef = purego.NewCallback(fcb)
712+ SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
713+ }
714+ }
715+
716+ var ElementFreeFuncVarRef uintptr
717+ if ElementFreeFuncVar != nil {
718+ ElementFreeFuncVarPtr := uintptr(unsafe.Pointer(ElementFreeFuncVar))
719+ if cbRefPtr, ok := GetCallback(ElementFreeFuncVarPtr); ok {
720+ ElementFreeFuncVarRef = cbRefPtr
721+ } else {
722+ fcb := func(arg0 uintptr) {
723+ cbFn := *ElementFreeFuncVar
724+ cbFn(arg0)
725+ }
726+ ElementFreeFuncVarRef = purego.NewCallback(fcb)
727+ SaveCallback(ElementFreeFuncVarPtr, ElementFreeFuncVarRef)
728+ }
729+ }
730+
731+ cret := xPtrArrayNewFromArray(DataVar, LenVar, CopyFuncVarRef, CopyFuncUserDataVar, ElementFreeFuncVarRef)
648732 return cret
649733 }
650734
@@ -665,7 +749,37 @@ var xPtrArrayNewFromNullTerminatedArray func([]uintptr, uintptr, uintptr, uintpt
665749 // shorter than `gsize`.
666750 func PtrArrayNewFromNullTerminatedArray(DataVar []uintptr, CopyFuncVar *CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {
667751
668- cret := xPtrArrayNewFromNullTerminatedArray(DataVar, NewCallbackNullable(CopyFuncVar), CopyFuncUserDataVar, NewCallbackNullable(ElementFreeFuncVar))
752+ var CopyFuncVarRef uintptr
753+ if CopyFuncVar != nil {
754+ CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
755+ if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
756+ CopyFuncVarRef = cbRefPtr
757+ } else {
758+ fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
759+ cbFn := *CopyFuncVar
760+ return cbFn(arg0, arg1)
761+ }
762+ CopyFuncVarRef = purego.NewCallback(fcb)
763+ SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
764+ }
765+ }
766+
767+ var ElementFreeFuncVarRef uintptr
768+ if ElementFreeFuncVar != nil {
769+ ElementFreeFuncVarPtr := uintptr(unsafe.Pointer(ElementFreeFuncVar))
770+ if cbRefPtr, ok := GetCallback(ElementFreeFuncVarPtr); ok {
771+ ElementFreeFuncVarRef = cbRefPtr
772+ } else {
773+ fcb := func(arg0 uintptr) {
774+ cbFn := *ElementFreeFuncVar
775+ cbFn(arg0)
776+ }
777+ ElementFreeFuncVarRef = purego.NewCallback(fcb)
778+ SaveCallback(ElementFreeFuncVarPtr, ElementFreeFuncVarRef)
779+ }
780+ }
781+
782+ cret := xPtrArrayNewFromNullTerminatedArray(DataVar, CopyFuncVarRef, CopyFuncUserDataVar, ElementFreeFuncVarRef)
669783 return cret
670784 }
671785
@@ -689,7 +803,22 @@ var xPtrArrayNewTake func([]uintptr, uint, uintptr) uintptr
689803 // than `gsize`.
690804 func PtrArrayNewTake(DataVar []uintptr, LenVar uint, ElementFreeFuncVar *DestroyNotify) uintptr {
691805
692- cret := xPtrArrayNewTake(DataVar, LenVar, NewCallbackNullable(ElementFreeFuncVar))
806+ var ElementFreeFuncVarRef uintptr
807+ if ElementFreeFuncVar != nil {
808+ ElementFreeFuncVarPtr := uintptr(unsafe.Pointer(ElementFreeFuncVar))
809+ if cbRefPtr, ok := GetCallback(ElementFreeFuncVarPtr); ok {
810+ ElementFreeFuncVarRef = cbRefPtr
811+ } else {
812+ fcb := func(arg0 uintptr) {
813+ cbFn := *ElementFreeFuncVar
814+ cbFn(arg0)
815+ }
816+ ElementFreeFuncVarRef = purego.NewCallback(fcb)
817+ SaveCallback(ElementFreeFuncVarPtr, ElementFreeFuncVarRef)
818+ }
819+ }
820+
821+ cret := xPtrArrayNewTake(DataVar, LenVar, ElementFreeFuncVarRef)
693822 return cret
694823 }
695824
@@ -716,7 +845,22 @@ var xPtrArrayNewTakeNullTerminated func([]uintptr, uintptr) uintptr
716845 // in `guint`, which may be shorter than `gsize`.
717846 func PtrArrayNewTakeNullTerminated(DataVar []uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {
718847
719- cret := xPtrArrayNewTakeNullTerminated(DataVar, NewCallbackNullable(ElementFreeFuncVar))
848+ var ElementFreeFuncVarRef uintptr
849+ if ElementFreeFuncVar != nil {
850+ ElementFreeFuncVarPtr := uintptr(unsafe.Pointer(ElementFreeFuncVar))
851+ if cbRefPtr, ok := GetCallback(ElementFreeFuncVarPtr); ok {
852+ ElementFreeFuncVarRef = cbRefPtr
853+ } else {
854+ fcb := func(arg0 uintptr) {
855+ cbFn := *ElementFreeFuncVar
856+ cbFn(arg0)
857+ }
858+ ElementFreeFuncVarRef = purego.NewCallback(fcb)
859+ SaveCallback(ElementFreeFuncVarPtr, ElementFreeFuncVarRef)
860+ }
861+ }
862+
863+ cret := xPtrArrayNewTakeNullTerminated(DataVar, ElementFreeFuncVarRef)
720864 return cret
721865 }
722866
M v4/glib/gasyncqueue.go +72 -5
@@ -144,7 +144,20 @@ var xAsyncQueuePushSorted func(uintptr, uintptr, uintptr, uintptr)
144144 // For an example of @func see g_async_queue_sort().
145145 func (x *AsyncQueue) PushSorted(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
146146
147- xAsyncQueuePushSorted(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)
147+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
148+ 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)
155+ }
156+ FuncVarRef = purego.NewCallback(fcb)
157+ SaveCallback(FuncVarPtr, FuncVarRef)
158+ }
159+
160+ xAsyncQueuePushSorted(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
148161
149162 }
150163
@@ -167,7 +180,20 @@ var xAsyncQueuePushSortedUnlocked func(uintptr, uintptr, uintptr, uintptr)
167180 // For an example of @func see g_async_queue_sort().
168181 func (x *AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
169182
170- xAsyncQueuePushSortedUnlocked(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)
183+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
184+ 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)
191+ }
192+ FuncVarRef = purego.NewCallback(fcb)
193+ SaveCallback(FuncVarPtr, FuncVarRef)
194+ }
195+
196+ xAsyncQueuePushSortedUnlocked(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
171197
172198 }
173199
@@ -251,7 +277,20 @@ var xAsyncQueueSort func(uintptr, uintptr, uintptr)
251277 // ]|
252278 func (x *AsyncQueue) Sort(FuncVar *CompareDataFunc, UserDataVar uintptr) {
253279
254- xAsyncQueueSort(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
280+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
281+ 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)
288+ }
289+ FuncVarRef = purego.NewCallback(fcb)
290+ SaveCallback(FuncVarPtr, FuncVarRef)
291+ }
292+
293+ xAsyncQueueSort(x.GoPointer(), FuncVarRef, UserDataVar)
255294
256295 }
257296
@@ -268,7 +307,20 @@ var xAsyncQueueSortUnlocked func(uintptr, uintptr, uintptr)
268307 // This function must be called while holding the @queue's lock.
269308 func (x *AsyncQueue) SortUnlocked(FuncVar *CompareDataFunc, UserDataVar uintptr) {
270309
271- xAsyncQueueSortUnlocked(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
310+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
311+ 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)
318+ }
319+ FuncVarRef = purego.NewCallback(fcb)
320+ SaveCallback(FuncVarPtr, FuncVarRef)
321+ }
322+
323+ xAsyncQueueSortUnlocked(x.GoPointer(), FuncVarRef, UserDataVar)
272324
273325 }
274326
@@ -407,7 +459,22 @@ var xAsyncQueueNewFull func(uintptr) *AsyncQueue
407459 // the queue is destroyed after the final unref.
408460 func AsyncQueueNewFull(ItemFreeFuncVar *DestroyNotify) *AsyncQueue {
409461
410- cret := xAsyncQueueNewFull(NewCallbackNullable(ItemFreeFuncVar))
462+ var ItemFreeFuncVarRef uintptr
463+ if ItemFreeFuncVar != nil {
464+ ItemFreeFuncVarPtr := uintptr(unsafe.Pointer(ItemFreeFuncVar))
465+ if cbRefPtr, ok := GetCallback(ItemFreeFuncVarPtr); ok {
466+ ItemFreeFuncVarRef = cbRefPtr
467+ } else {
468+ fcb := func(arg0 uintptr) {
469+ cbFn := *ItemFreeFuncVar
470+ cbFn(arg0)
471+ }
472+ ItemFreeFuncVarRef = purego.NewCallback(fcb)
473+ SaveCallback(ItemFreeFuncVarPtr, ItemFreeFuncVarRef)
474+ }
475+ }
476+
477+ cret := xAsyncQueueNewFull(ItemFreeFuncVarRef)
411478 return cret
412479 }
413480
M v4/glib/gcache.go +28 -2
@@ -80,7 +80,20 @@ var xCacheKeyForeach func(uintptr, uintptr, uintptr)
8080 // pairs to its callback function !
8181 func (x *Cache) KeyForeach(FuncVar *HFunc, UserDataVar uintptr) {
8282
83- xCacheKeyForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
83+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
84+ 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)
91+ }
92+ FuncVarRef = purego.NewCallback(fcb)
93+ SaveCallback(FuncVarPtr, FuncVarRef)
94+ }
95+
96+ xCacheKeyForeach(x.GoPointer(), FuncVarRef, UserDataVar)
8497
8598 }
8699
@@ -100,7 +113,20 @@ var xCacheValueForeach func(uintptr, uintptr, uintptr)
100113 // Calls the given function for each of the values in the #GCache.
101114 func (x *Cache) ValueForeach(FuncVar *HFunc, UserDataVar uintptr) {
102115
103- xCacheValueForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
116+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
117+ 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)
124+ }
125+ FuncVarRef = purego.NewCallback(fcb)
126+ SaveCallback(FuncVarPtr, FuncVarRef)
127+ }
128+
129+ xCacheValueForeach(x.GoPointer(), FuncVarRef, UserDataVar)
104130
105131 }
106132
M v4/glib/gcompletion.go +14 -1
@@ -131,7 +131,20 @@ var xCompletionSetCompare func(uintptr, uintptr)
131131 // comparison function is strncmp().
132132 func (x *Completion) SetCompare(StrncmpFuncVar *CompletionStrncmpFunc) {
133133
134- xCompletionSetCompare(x.GoPointer(), NewCallback(StrncmpFuncVar))
134+ StrncmpFuncVarPtr := uintptr(unsafe.Pointer(StrncmpFuncVar))
135+ 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)
142+ }
143+ StrncmpFuncVarRef = purego.NewCallback(fcb)
144+ SaveCallback(StrncmpFuncVarPtr, StrncmpFuncVarRef)
145+ }
146+
147+ xCompletionSetCompare(x.GoPointer(), StrncmpFuncVarRef)
135148
136149 }
137150
M v4/glib/gdataset.go +90 -6
@@ -63,7 +63,20 @@ var xDatalistForeach func(**Data, uintptr, uintptr)
6363 // than skipping over elements that are removed.
6464 func DatalistForeach(DatalistVar **Data, FuncVar *DataForeachFunc, UserDataVar uintptr) {
6565
66- xDatalistForeach(DatalistVar, NewCallback(FuncVar), UserDataVar)
66+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
67+ 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)
74+ }
75+ FuncVarRef = purego.NewCallback(fcb)
76+ SaveCallback(FuncVarPtr, FuncVarRef)
77+ }
78+
79+ xDatalistForeach(DatalistVar, FuncVarRef, UserDataVar)
6780
6881 }
6982
@@ -104,7 +117,22 @@ var xDatalistIdDupData func(**Data, Quark, uintptr, uintptr) uintptr
104117 // threads are using the same datalist and the same key.
105118 func DatalistIdDupData(DatalistVar **Data, KeyIdVar Quark, DupFuncVar *DuplicateFunc, UserDataVar uintptr) uintptr {
106119
107- cret := xDatalistIdDupData(DatalistVar, KeyIdVar, NewCallbackNullable(DupFuncVar), UserDataVar)
120+ var DupFuncVarRef uintptr
121+ if DupFuncVar != nil {
122+ DupFuncVarPtr := uintptr(unsafe.Pointer(DupFuncVar))
123+ if cbRefPtr, ok := GetCallback(DupFuncVarPtr); ok {
124+ DupFuncVarRef = cbRefPtr
125+ } else {
126+ fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
127+ cbFn := *DupFuncVar
128+ return cbFn(arg0, arg1)
129+ }
130+ DupFuncVarRef = purego.NewCallback(fcb)
131+ SaveCallback(DupFuncVarPtr, DupFuncVarRef)
132+ }
133+ }
134+
135+ cret := xDatalistIdDupData(DatalistVar, KeyIdVar, DupFuncVarRef, UserDataVar)
108136 return cret
109137 }
110138
@@ -159,7 +187,22 @@ var xDatalistIdReplaceData func(**Data, Quark, uintptr, uintptr, uintptr, *Destr
159187 // should not destroy the object in the normal way.
160188 func DatalistIdReplaceData(DatalistVar **Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *DestroyNotify, OldDestroyVar *DestroyNotify) bool {
161189
162- cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, NewCallbackNullable(DestroyVar), OldDestroyVar)
190+ var DestroyVarRef uintptr
191+ if DestroyVar != nil {
192+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
193+ if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
194+ DestroyVarRef = cbRefPtr
195+ } else {
196+ fcb := func(arg0 uintptr) {
197+ cbFn := *DestroyVar
198+ cbFn(arg0)
199+ }
200+ DestroyVarRef = purego.NewCallback(fcb)
201+ SaveCallback(DestroyVarPtr, DestroyVarRef)
202+ }
203+ }
204+
205+ cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, DestroyVarRef, OldDestroyVar)
163206 return cret
164207 }
165208
@@ -171,7 +214,22 @@ var xDatalistIdSetDataFull func(**Data, Quark, uintptr, uintptr)
171214 // function is called.
172215 func DatalistIdSetDataFull(DatalistVar **Data, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {
173216
174- xDatalistIdSetDataFull(DatalistVar, KeyIdVar, DataVar, NewCallbackNullable(DestroyFuncVar))
217+ var DestroyFuncVarRef uintptr
218+ if DestroyFuncVar != nil {
219+ DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
220+ if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
221+ DestroyFuncVarRef = cbRefPtr
222+ } else {
223+ fcb := func(arg0 uintptr) {
224+ cbFn := *DestroyFuncVar
225+ cbFn(arg0)
226+ }
227+ DestroyFuncVarRef = purego.NewCallback(fcb)
228+ SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
229+ }
230+ }
231+
232+ xDatalistIdSetDataFull(DatalistVar, KeyIdVar, DataVar, DestroyFuncVarRef)
175233
176234 }
177235
@@ -230,7 +288,20 @@ var xDatasetForeach func(uintptr, uintptr, uintptr)
230288 // than skipping over elements that are removed.
231289 func DatasetForeach(DatasetLocationVar uintptr, FuncVar *DataForeachFunc, UserDataVar uintptr) {
232290
233- xDatasetForeach(DatasetLocationVar, NewCallback(FuncVar), UserDataVar)
291+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
292+ 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)
299+ }
300+ FuncVarRef = purego.NewCallback(fcb)
301+ SaveCallback(FuncVarPtr, FuncVarRef)
302+ }
303+
304+ xDatasetForeach(DatasetLocationVar, FuncVarRef, UserDataVar)
234305
235306 }
236307
@@ -261,7 +332,20 @@ var xDatasetIdSetDataFull func(uintptr, Quark, uintptr, uintptr)
261332 // is called.
262333 func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {
263334
264- xDatasetIdSetDataFull(DatasetLocationVar, KeyIdVar, DataVar, NewCallback(DestroyFuncVar))
335+ DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
336+ 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)
343+ }
344+ DestroyFuncVarRef = purego.NewCallback(fcb)
345+ SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
346+ }
347+
348+ xDatasetIdSetDataFull(DatasetLocationVar, KeyIdVar, DataVar, DestroyFuncVarRef)
265349
266350 }
267351
M v4/glib/gerror.go +80 -2
@@ -149,7 +149,46 @@ var xErrorDomainRegister func(string, uint, uintptr, uintptr, uintptr) Quark
149149 // g_error_domain_register_static().
150150 func ErrorDomainRegister(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar *ErrorInitFunc, ErrorTypeCopyVar *ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
151151
152- cret := xErrorDomainRegister(ErrorTypeNameVar, ErrorTypePrivateSizeVar, NewCallback(ErrorTypeInitVar), NewCallback(ErrorTypeCopyVar), NewCallback(ErrorTypeClearVar))
152+ ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
153+ 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)
160+ }
161+ ErrorTypeInitVarRef = purego.NewCallback(fcb)
162+ SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
163+ }
164+
165+ ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
166+ 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)
173+ }
174+ ErrorTypeCopyVarRef = purego.NewCallback(fcb)
175+ SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
176+ }
177+
178+ ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
179+ 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)
186+ }
187+ ErrorTypeClearVarRef = purego.NewCallback(fcb)
188+ SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
189+ }
190+
191+ cret := xErrorDomainRegister(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)
153192 return cret
154193 }
155194
@@ -174,7 +213,46 @@ var xErrorDomainRegisterStatic func(string, uint, uintptr, uintptr, uintptr) Qua
174213 // already takes care of passing valid information to this function.
175214 func ErrorDomainRegisterStatic(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar *ErrorInitFunc, ErrorTypeCopyVar *ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
176215
177- cret := xErrorDomainRegisterStatic(ErrorTypeNameVar, ErrorTypePrivateSizeVar, NewCallback(ErrorTypeInitVar), NewCallback(ErrorTypeCopyVar), NewCallback(ErrorTypeClearVar))
216+ ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
217+ 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)
224+ }
225+ ErrorTypeInitVarRef = purego.NewCallback(fcb)
226+ SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
227+ }
228+
229+ ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
230+ 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)
237+ }
238+ ErrorTypeCopyVarRef = purego.NewCallback(fcb)
239+ SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
240+ }
241+
242+ ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
243+ 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)
250+ }
251+ ErrorTypeClearVarRef = purego.NewCallback(fcb)
252+ SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
253+ }
254+
255+ cret := xErrorDomainRegisterStatic(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)
178256 return cret
179257 }
180258
M v4/glib/ghash.go +56 -4
@@ -286,7 +286,20 @@ var xHashTableFind func(*HashTable, uintptr, uintptr) uintptr
286286 // values in a hash table ends up needing O(n*n) operations).
287287 func HashTableFind(HashTableVar *HashTable, PredicateVar *HRFunc, UserDataVar uintptr) uintptr {
288288
289- cret := xHashTableFind(HashTableVar, NewCallback(PredicateVar), UserDataVar)
289+ PredicateVarPtr := uintptr(unsafe.Pointer(PredicateVar))
290+ 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)
297+ }
298+ PredicateVarRef = purego.NewCallback(fcb)
299+ SaveCallback(PredicateVarPtr, PredicateVarRef)
300+ }
301+
302+ cret := xHashTableFind(HashTableVar, PredicateVarRef, UserDataVar)
290303 return cret
291304 }
292305
@@ -306,7 +319,20 @@ var xHashTableForeach func(*HashTable, uintptr, uintptr)
306319 // order searches in contrast to g_hash_table_lookup().
307320 func HashTableForeach(HashTableVar *HashTable, FuncVar *HFunc, UserDataVar uintptr) {
308321
309- xHashTableForeach(HashTableVar, NewCallback(FuncVar), UserDataVar)
322+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
323+ 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)
330+ }
331+ FuncVarRef = purego.NewCallback(fcb)
332+ SaveCallback(FuncVarPtr, FuncVarRef)
333+ }
334+
335+ xHashTableForeach(HashTableVar, FuncVarRef, UserDataVar)
310336
311337 }
312338
@@ -322,7 +348,20 @@ var xHashTableForeachRemove func(*HashTable, uintptr, uintptr) uint
322348 // key/value pairs in the hash table.
323349 func HashTableForeachRemove(HashTableVar *HashTable, FuncVar *HRFunc, UserDataVar uintptr) uint {
324350
325- cret := xHashTableForeachRemove(HashTableVar, NewCallback(FuncVar), UserDataVar)
351+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
352+ 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)
359+ }
360+ FuncVarRef = purego.NewCallback(fcb)
361+ SaveCallback(FuncVarPtr, FuncVarRef)
362+ }
363+
364+ cret := xHashTableForeachRemove(HashTableVar, FuncVarRef, UserDataVar)
326365 return cret
327366 }
328367
@@ -337,7 +376,20 @@ var xHashTableForeachSteal func(*HashTable, uintptr, uintptr) uint
337376 // key/value pairs in the hash table.
338377 func HashTableForeachSteal(HashTableVar *HashTable, FuncVar *HRFunc, UserDataVar uintptr) uint {
339378
340- cret := xHashTableForeachSteal(HashTableVar, NewCallback(FuncVar), UserDataVar)
379+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
380+ 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)
387+ }
388+ FuncVarRef = purego.NewCallback(fcb)
389+ SaveCallback(FuncVarPtr, FuncVarRef)
390+ }
391+
392+ cret := xHashTableForeachSteal(HashTableVar, FuncVarRef, UserDataVar)
341393 return cret
342394 }
343395
M v4/glib/ghook.go +42 -3
@@ -135,7 +135,20 @@ var xHookListMarshal func(uintptr, bool, uintptr, uintptr)
135135 // Calls a function on each valid #GHook.
136136 func (x *HookList) Marshal(MayRecurseVar bool, MarshallerVar *HookMarshaller, MarshalDataVar uintptr) {
137137
138- xHookListMarshal(x.GoPointer(), MayRecurseVar, NewCallback(MarshallerVar), MarshalDataVar)
138+ MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
139+ 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)
146+ }
147+ MarshallerVarRef = purego.NewCallback(fcb)
148+ SaveCallback(MarshallerVarPtr, MarshallerVarRef)
149+ }
150+
151+ xHookListMarshal(x.GoPointer(), MayRecurseVar, MarshallerVarRef, MarshalDataVar)
139152
140153 }
141154
@@ -145,7 +158,20 @@ var xHookListMarshalCheck func(uintptr, bool, uintptr, uintptr)
145158 // function returns %FALSE.
146159 func (x *HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar *HookCheckMarshaller, MarshalDataVar uintptr) {
147160
148- xHookListMarshalCheck(x.GoPointer(), MayRecurseVar, NewCallback(MarshallerVar), MarshalDataVar)
161+ MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
162+ 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)
169+ }
170+ MarshallerVarRef = purego.NewCallback(fcb)
171+ SaveCallback(MarshallerVarPtr, MarshallerVarRef)
172+ }
173+
174+ xHookListMarshalCheck(x.GoPointer(), MayRecurseVar, MarshallerVarRef, MarshalDataVar)
149175
150176 }
151177
@@ -214,7 +240,20 @@ var xHookInsertSorted func(*HookList, *Hook, uintptr)
214240 // Inserts a #GHook into a #GHookList, sorted by the given function.
215241 func HookInsertSorted(HookListVar *HookList, HookVar *Hook, FuncVar *HookCompareFunc) {
216242
217- xHookInsertSorted(HookListVar, HookVar, NewCallback(FuncVar))
243+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
244+ 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)
251+ }
252+ FuncVarRef = purego.NewCallback(fcb)
253+ SaveCallback(FuncVarPtr, FuncVarRef)
254+ }
255+
256+ xHookInsertSorted(HookListVar, HookVar, FuncVarRef)
218257
219258 }
220259
M v4/glib/giochannel.go +41 -2
@@ -1018,7 +1018,20 @@ var xIoAddWatch func(*IOChannel, IOCondition, uintptr, uintptr) uint
10181018 // with the default priority.
10191019 func IoAddWatch(ChannelVar *IOChannel, ConditionVar IOCondition, FuncVar *IOFunc, UserDataVar uintptr) uint {
10201020
1021- cret := xIoAddWatch(ChannelVar, ConditionVar, NewCallback(FuncVar), UserDataVar)
1021+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1022+ 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)
1029+ }
1030+ FuncVarRef = purego.NewCallback(fcb)
1031+ SaveCallback(FuncVarPtr, FuncVarRef)
1032+ }
1033+
1034+ cret := xIoAddWatch(ChannelVar, ConditionVar, FuncVarRef, UserDataVar)
10221035 return cret
10231036 }
10241037
@@ -1032,7 +1045,33 @@ var xIoAddWatchFull func(*IOChannel, int, IOCondition, uintptr, uintptr, uintptr
10321045 // You can do these steps manually if you need greater control.
10331046 func IoAddWatchFull(ChannelVar *IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar *IOFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
10341047
1035- cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, NewCallback(FuncVar), UserDataVar, NewCallback(NotifyVar))
1048+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1049+ 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)
1056+ }
1057+ FuncVarRef = purego.NewCallback(fcb)
1058+ SaveCallback(FuncVarPtr, FuncVarRef)
1059+ }
1060+
1061+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1062+ 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)
1069+ }
1070+ NotifyVarRef = purego.NewCallback(fcb)
1071+ SaveCallback(NotifyVarPtr, NotifyVarRef)
1072+ }
1073+
1074+ cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, FuncVarRef, UserDataVar, NotifyVarRef)
10361075 return cret
10371076 }
10381077
M v4/glib/glib-unix.go +82 -4
@@ -99,7 +99,20 @@ var xUnixFdAdd func(int, IOCondition, uintptr, uintptr) uint
9999 // The source will never close the fd -- you must do it yourself.
100100 func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr) uint {
101101
102- cret := xUnixFdAdd(FdVar, ConditionVar, NewCallback(FunctionVar), UserDataVar)
102+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
103+ 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)
110+ }
111+ FunctionVarRef = purego.NewCallback(fcb)
112+ SaveCallback(FunctionVarPtr, FunctionVarRef)
113+ }
114+
115+ cret := xUnixFdAdd(FdVar, ConditionVar, FunctionVarRef, UserDataVar)
103116 return cret
104117 }
105118
@@ -113,7 +126,33 @@ var xUnixFdAddFull func(int, int, IOCondition, uintptr, uintptr, uintptr) uint
113126 // @user_data.
114127 func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
115128
116- cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, NewCallback(FunctionVar), UserDataVar, NewCallback(NotifyVar))
129+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
130+ 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)
137+ }
138+ FunctionVarRef = purego.NewCallback(fcb)
139+ SaveCallback(FunctionVarPtr, FunctionVarRef)
140+ }
141+
142+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
143+ 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)
150+ }
151+ NotifyVarRef = purego.NewCallback(fcb)
152+ SaveCallback(NotifyVarPtr, NotifyVarRef)
153+ }
154+
155+ cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, FunctionVarRef, UserDataVar, NotifyVarRef)
117156 return cret
118157 }
119158
@@ -211,7 +250,20 @@ var xUnixSignalAdd func(int, uintptr, uintptr) uint
211250 // using g_source_remove().
212251 func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) uint {
213252
214- cret := xUnixSignalAdd(SignumVar, NewCallback(HandlerVar), UserDataVar)
253+ HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
254+ 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)
261+ }
262+ HandlerVarRef = purego.NewCallback(fcb)
263+ SaveCallback(HandlerVarPtr, HandlerVarRef)
264+ }
265+
266+ cret := xUnixSignalAdd(SignumVar, HandlerVarRef, UserDataVar)
215267 return cret
216268 }
217269
@@ -222,7 +274,33 @@ var xUnixSignalAddFull func(int, int, uintptr, uintptr, uintptr) uint
222274 // using g_source_remove().
223275 func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
224276
225- cret := xUnixSignalAddFull(PriorityVar, SignumVar, NewCallback(HandlerVar), UserDataVar, NewCallback(NotifyVar))
277+ HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
278+ 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)
285+ }
286+ HandlerVarRef = purego.NewCallback(fcb)
287+ SaveCallback(HandlerVarPtr, HandlerVarRef)
288+ }
289+
290+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
291+ 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)
298+ }
299+ NotifyVarRef = purego.NewCallback(fcb)
300+ SaveCallback(NotifyVarPtr, NotifyVarRef)
301+ }
302+
303+ cret := xUnixSignalAddFull(PriorityVar, SignumVar, HandlerVarRef, UserDataVar, NotifyVarRef)
226304 return cret
227305 }
228306
M v4/glib/glist.go +16 -1
@@ -31,7 +31,22 @@ var xClearList func(**List, uintptr)
3131 // @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing.
3232 func ClearList(ListPtrVar **List, DestroyVar *DestroyNotify) {
3333
34- xClearList(ListPtrVar, NewCallbackNullable(DestroyVar))
34+ var DestroyVarRef uintptr
35+ if DestroyVar != nil {
36+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
37+ if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
38+ DestroyVarRef = cbRefPtr
39+ } else {
40+ fcb := func(arg0 uintptr) {
41+ cbFn := *DestroyVar
42+ cbFn(arg0)
43+ }
44+ DestroyVarRef = purego.NewCallback(fcb)
45+ SaveCallback(DestroyVarPtr, DestroyVarRef)
46+ }
47+ }
48+
49+ xClearList(ListPtrVar, DestroyVarRef)
3550
3651 }
3752
M v4/glib/gmain.go +328 -17
@@ -279,7 +279,20 @@ var xMainContextInvoke func(uintptr, uintptr, uintptr)
279279 // will be continuously run in a loop (and may prevent this call from returning).
280280 func (x *MainContext) Invoke(FunctionVar *SourceFunc, DataVar uintptr) {
281281
282- xMainContextInvoke(x.GoPointer(), NewCallback(FunctionVar), DataVar)
282+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
283+ 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)
290+ }
291+ FunctionVarRef = purego.NewCallback(fcb)
292+ SaveCallback(FunctionVarPtr, FunctionVarRef)
293+ }
294+
295+ xMainContextInvoke(x.GoPointer(), FunctionVarRef, DataVar)
283296
284297 }
285298
@@ -297,7 +310,35 @@ var xMainContextInvokeFull func(uintptr, int, uintptr, uintptr, uintptr)
297310 // thread or with any particular context acquired.
298311 func (x *MainContext) InvokeFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
299312
300- xMainContextInvokeFull(x.GoPointer(), PriorityVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))
313+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
314+ 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)
321+ }
322+ FunctionVarRef = purego.NewCallback(fcb)
323+ SaveCallback(FunctionVarPtr, FunctionVarRef)
324+ }
325+
326+ var NotifyVarRef uintptr
327+ if NotifyVar != nil {
328+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
329+ if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
330+ NotifyVarRef = cbRefPtr
331+ } else {
332+ fcb := func(arg0 uintptr) {
333+ cbFn := *NotifyVar
334+ cbFn(arg0)
335+ }
336+ NotifyVarRef = purego.NewCallback(fcb)
337+ SaveCallback(NotifyVarPtr, NotifyVarRef)
338+ }
339+ }
340+
341+ xMainContextInvokeFull(x.GoPointer(), PriorityVar, FunctionVarRef, DataVar, NotifyVarRef)
301342
302343 }
303344
@@ -530,7 +571,20 @@ var xMainContextSetPollFunc func(uintptr, uintptr)
530571 // loop with an external event loop.
531572 func (x *MainContext) SetPollFunc(FuncVar *PollFunc) {
532573
533- xMainContextSetPollFunc(x.GoPointer(), NewCallback(FuncVar))
574+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
575+ 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)
582+ }
583+ FuncVarRef = purego.NewCallback(fcb)
584+ SaveCallback(FuncVarPtr, FuncVarRef)
585+ }
586+
587+ xMainContextSetPollFunc(x.GoPointer(), FuncVarRef)
534588
535589 }
536590
@@ -1196,7 +1250,35 @@ var xSourceSetCallback func(uintptr, uintptr, uintptr, uintptr)
11961250 // of also unsetting the callback.
11971251 func (x *Source) SetCallback(FuncVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
11981252
1199- xSourceSetCallback(x.GoPointer(), NewCallback(FuncVar), DataVar, NewCallbackNullable(NotifyVar))
1253+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1254+ 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)
1261+ }
1262+ FuncVarRef = purego.NewCallback(fcb)
1263+ SaveCallback(FuncVarPtr, FuncVarRef)
1264+ }
1265+
1266+ var NotifyVarRef uintptr
1267+ if NotifyVar != nil {
1268+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1269+ if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
1270+ NotifyVarRef = cbRefPtr
1271+ } else {
1272+ fcb := func(arg0 uintptr) {
1273+ cbFn := *NotifyVar
1274+ cbFn(arg0)
1275+ }
1276+ NotifyVarRef = purego.NewCallback(fcb)
1277+ SaveCallback(NotifyVarPtr, NotifyVarRef)
1278+ }
1279+ }
1280+
1281+ xSourceSetCallback(x.GoPointer(), FuncVarRef, DataVar, NotifyVarRef)
12001282
12011283 }
12021284
@@ -1257,7 +1339,20 @@ var xSourceSetDisposeFunction func(uintptr, uintptr)
12571339 // This should only ever be called from [struct@GLib.Source] implementations.
12581340 func (x *Source) SetDisposeFunction(DisposeVar *SourceDisposeFunc) {
12591341
1260- xSourceSetDisposeFunction(x.GoPointer(), NewCallback(DisposeVar))
1342+ DisposeVarPtr := uintptr(unsafe.Pointer(DisposeVar))
1343+ 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)
1350+ }
1351+ DisposeVarRef = purego.NewCallback(fcb)
1352+ SaveCallback(DisposeVarPtr, DisposeVarRef)
1353+ }
1354+
1355+ xSourceSetDisposeFunction(x.GoPointer(), DisposeVarRef)
12611356
12621357 }
12631358
@@ -1595,7 +1690,20 @@ var xChildWatchAdd func(Pid, uintptr, uintptr) uint
15951690 // need greater control.
15961691 func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uint {
15971692
1598- cret := xChildWatchAdd(PidVar, NewCallback(FunctionVar), DataVar)
1693+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1694+ 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)
1701+ }
1702+ FunctionVarRef = purego.NewCallback(fcb)
1703+ SaveCallback(FunctionVarPtr, FunctionVarRef)
1704+ }
1705+
1706+ cret := xChildWatchAdd(PidVar, FunctionVarRef, DataVar)
15991707 return cret
16001708 }
16011709
@@ -1628,7 +1736,35 @@ var xChildWatchAddFull func(int, Pid, uintptr, uintptr, uintptr) uint
16281736 // need greater control.
16291737 func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
16301738
1631- cret := xChildWatchAddFull(PriorityVar, PidVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))
1739+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1740+ 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)
1747+ }
1748+ FunctionVarRef = purego.NewCallback(fcb)
1749+ SaveCallback(FunctionVarPtr, FunctionVarRef)
1750+ }
1751+
1752+ var NotifyVarRef uintptr
1753+ if NotifyVar != nil {
1754+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1755+ if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
1756+ NotifyVarRef = cbRefPtr
1757+ } else {
1758+ fcb := func(arg0 uintptr) {
1759+ cbFn := *NotifyVar
1760+ cbFn(arg0)
1761+ }
1762+ NotifyVarRef = purego.NewCallback(fcb)
1763+ SaveCallback(NotifyVarPtr, NotifyVarRef)
1764+ }
1765+ }
1766+
1767+ cret := xChildWatchAddFull(PriorityVar, PidVar, FunctionVarRef, DataVar, NotifyVarRef)
16321768 return cret
16331769 }
16341770
@@ -1694,7 +1830,20 @@ var xClearHandleId func(uint, uintptr)
16941830 // pointer casts.
16951831 func ClearHandleId(TagPtrVar uint, ClearFuncVar *ClearHandleFunc) {
16961832
1697- xClearHandleId(TagPtrVar, NewCallback(ClearFuncVar))
1833+ ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
1834+ 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)
1841+ }
1842+ ClearFuncVarRef = purego.NewCallback(fcb)
1843+ SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
1844+ }
1845+
1846+ xClearHandleId(TagPtrVar, ClearFuncVarRef)
16981847
16991848 }
17001849
@@ -1767,7 +1916,20 @@ var xIdleAdd func(uintptr, uintptr) uint
17671916 // need greater control or to use a custom main context.
17681917 func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {
17691918
1770- cret := xIdleAdd(NewCallback(FunctionVar), DataVar)
1919+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1920+ 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)
1927+ }
1928+ FunctionVarRef = purego.NewCallback(fcb)
1929+ SaveCallback(FunctionVarPtr, FunctionVarRef)
1930+ }
1931+
1932+ cret := xIdleAdd(FunctionVarRef, DataVar)
17711933 return cret
17721934 }
17731935
@@ -1789,7 +1951,35 @@ var xIdleAddFull func(int, uintptr, uintptr, uintptr) uint
17891951 // need greater control or to use a custom main context.
17901952 func IdleAddFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
17911953
1792- cret := xIdleAddFull(PriorityVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))
1954+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1955+ 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)
1962+ }
1963+ FunctionVarRef = purego.NewCallback(fcb)
1964+ SaveCallback(FunctionVarPtr, FunctionVarRef)
1965+ }
1966+
1967+ var NotifyVarRef uintptr
1968+ if NotifyVar != nil {
1969+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1970+ if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
1971+ NotifyVarRef = cbRefPtr
1972+ } else {
1973+ fcb := func(arg0 uintptr) {
1974+ cbFn := *NotifyVar
1975+ cbFn(arg0)
1976+ }
1977+ NotifyVarRef = purego.NewCallback(fcb)
1978+ SaveCallback(NotifyVarPtr, NotifyVarRef)
1979+ }
1980+ }
1981+
1982+ cret := xIdleAddFull(PriorityVar, FunctionVarRef, DataVar, NotifyVarRef)
17931983 return cret
17941984 }
17951985
@@ -1807,7 +1997,20 @@ var xIdleAddOnce func(uintptr, uintptr) uint
18071997 // This function otherwise behaves like [func@GLib.idle_add].
18081998 func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
18091999
1810- cret := xIdleAddOnce(NewCallback(FunctionVar), DataVar)
2000+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2001+ 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)
2008+ }
2009+ FunctionVarRef = purego.NewCallback(fcb)
2010+ SaveCallback(FunctionVarPtr, FunctionVarRef)
2011+ }
2012+
2013+ cret := xIdleAddOnce(FunctionVarRef, DataVar)
18112014 return cret
18122015 }
18132016
@@ -2130,7 +2333,20 @@ var xTimeoutAdd func(uint, uintptr, uintptr) uint
21302333 // time. See [func@GLib.get_monotonic_time].
21312334 func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
21322335
2133- cret := xTimeoutAdd(IntervalVar, NewCallback(FunctionVar), DataVar)
2336+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2337+ 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)
2344+ }
2345+ FunctionVarRef = purego.NewCallback(fcb)
2346+ SaveCallback(FunctionVarPtr, FunctionVarRef)
2347+ }
2348+
2349+ cret := xTimeoutAdd(IntervalVar, FunctionVarRef, DataVar)
21342350 return cret
21352351 }
21362352
@@ -2166,7 +2382,35 @@ var xTimeoutAddFull func(int, uint, uintptr, uintptr, uintptr) uint
21662382 // See [func@GLib.get_monotonic_time].
21672383 func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
21682384
2169- cret := xTimeoutAddFull(PriorityVar, IntervalVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))
2385+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2386+ 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)
2393+ }
2394+ FunctionVarRef = purego.NewCallback(fcb)
2395+ SaveCallback(FunctionVarPtr, FunctionVarRef)
2396+ }
2397+
2398+ var NotifyVarRef uintptr
2399+ if NotifyVar != nil {
2400+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
2401+ if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
2402+ NotifyVarRef = cbRefPtr
2403+ } else {
2404+ fcb := func(arg0 uintptr) {
2405+ cbFn := *NotifyVar
2406+ cbFn(arg0)
2407+ }
2408+ NotifyVarRef = purego.NewCallback(fcb)
2409+ SaveCallback(NotifyVarPtr, NotifyVarRef)
2410+ }
2411+ }
2412+
2413+ cret := xTimeoutAddFull(PriorityVar, IntervalVar, FunctionVarRef, DataVar, NotifyVarRef)
21702414 return cret
21712415 }
21722416
@@ -2181,7 +2425,20 @@ var xTimeoutAddOnce func(uint, uintptr, uintptr) uint
21812425 // This function otherwise behaves like [func@GLib.timeout_add].
21822426 func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
21832427
2184- cret := xTimeoutAddOnce(IntervalVar, NewCallback(FunctionVar), DataVar)
2428+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2429+ 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)
2436+ }
2437+ FunctionVarRef = purego.NewCallback(fcb)
2438+ SaveCallback(FunctionVarPtr, FunctionVarRef)
2439+ }
2440+
2441+ cret := xTimeoutAddOnce(IntervalVar, FunctionVarRef, DataVar)
21852442 return cret
21862443 }
21872444
@@ -2212,7 +2469,20 @@ var xTimeoutAddSeconds func(uint, uintptr, uintptr) uint
22122469 // time. See [func@GLib.get_monotonic_time].
22132470 func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
22142471
2215- cret := xTimeoutAddSeconds(IntervalVar, NewCallback(FunctionVar), DataVar)
2472+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2473+ 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)
2480+ }
2481+ FunctionVarRef = purego.NewCallback(fcb)
2482+ SaveCallback(FunctionVarPtr, FunctionVarRef)
2483+ }
2484+
2485+ cret := xTimeoutAddSeconds(IntervalVar, FunctionVarRef, DataVar)
22162486 return cret
22172487 }
22182488
@@ -2260,7 +2530,35 @@ var xTimeoutAddSecondsFull func(int, uint, uintptr, uintptr, uintptr) uint
22602530 // time. See [func@GLib.get_monotonic_time].
22612531 func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
22622532
2263- cret := xTimeoutAddSecondsFull(PriorityVar, IntervalVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))
2533+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2534+ 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)
2541+ }
2542+ FunctionVarRef = purego.NewCallback(fcb)
2543+ SaveCallback(FunctionVarPtr, FunctionVarRef)
2544+ }
2545+
2546+ var NotifyVarRef uintptr
2547+ if NotifyVar != nil {
2548+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
2549+ if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
2550+ NotifyVarRef = cbRefPtr
2551+ } else {
2552+ fcb := func(arg0 uintptr) {
2553+ cbFn := *NotifyVar
2554+ cbFn(arg0)
2555+ }
2556+ NotifyVarRef = purego.NewCallback(fcb)
2557+ SaveCallback(NotifyVarPtr, NotifyVarRef)
2558+ }
2559+ }
2560+
2561+ cret := xTimeoutAddSecondsFull(PriorityVar, IntervalVar, FunctionVarRef, DataVar, NotifyVarRef)
22642562 return cret
22652563 }
22662564
@@ -2270,7 +2568,20 @@ var xTimeoutAddSecondsOnce func(uint, uintptr, uintptr) uint
22702568 // seconds.
22712569 func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
22722570
2273- cret := xTimeoutAddSecondsOnce(IntervalVar, NewCallback(FunctionVar), DataVar)
2571+ FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2572+ 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)
2579+ }
2580+ FunctionVarRef = purego.NewCallback(fcb)
2581+ SaveCallback(FunctionVarPtr, FunctionVarRef)
2582+ }
2583+
2584+ cret := xTimeoutAddSecondsOnce(IntervalVar, FunctionVarRef, DataVar)
22742585 return cret
22752586 }
22762587
M v4/glib/gmarkup.go +14 -1
@@ -38,7 +38,20 @@ var xNewMarkupParseContext func(*MarkupParser, MarkupParseFlags, uintptr, uintpt
3838 // free it and create a new parse context).
3939 func NewMarkupParseContext(ParserVar *MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar *DestroyNotify) *MarkupParseContext {
4040
41- cret := xNewMarkupParseContext(ParserVar, FlagsVar, UserDataVar, NewCallback(UserDataDnotifyVar))
41+ UserDataDnotifyVarPtr := uintptr(unsafe.Pointer(UserDataDnotifyVar))
42+ 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)
49+ }
50+ UserDataDnotifyVarRef = purego.NewCallback(fcb)
51+ SaveCallback(UserDataDnotifyVarPtr, UserDataDnotifyVarRef)
52+ }
53+
54+ cret := xNewMarkupParseContext(ParserVar, FlagsVar, UserDataVar, UserDataDnotifyVarRef)
4255 return cret
4356 }
4457
M v4/glib/gmem.go +14 -1
@@ -279,7 +279,20 @@ var xClearPointer func(uintptr, uintptr)
279279 // ```
280280 func ClearPointer(PpVar uintptr, DestroyVar *DestroyNotify) {
281281
282- xClearPointer(PpVar, NewCallback(DestroyVar))
282+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
283+ 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)
290+ }
291+ DestroyVarRef = purego.NewCallback(fcb)
292+ SaveCallback(DestroyVarPtr, DestroyVarRef)
293+ }
294+
295+ xClearPointer(PpVar, DestroyVarRef)
283296
284297 }
285298
M v4/glib/gmessages.go +114 -6
@@ -339,7 +339,20 @@ var xLogSetDefaultHandler func(uintptr, uintptr) uintptr
339339 // [Using Structured Logging](logging.html#using-structured-logging).
340340 func LogSetDefaultHandler(LogFuncVar *LogFunc, UserDataVar uintptr) uintptr {
341341
342- cret := xLogSetDefaultHandler(NewCallback(LogFuncVar), UserDataVar)
342+ LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
343+ 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)
350+ }
351+ LogFuncVarRef = purego.NewCallback(fcb)
352+ SaveCallback(LogFuncVarPtr, LogFuncVarRef)
353+ }
354+
355+ cret := xLogSetDefaultHandler(LogFuncVarRef, UserDataVar)
343356 return cret
344357 }
345358
@@ -412,7 +425,20 @@ var xLogSetHandler func(string, LogLevelFlags, uintptr, uintptr) uint
412425 // ```
413426 func LogSetHandler(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr) uint {
414427
415- cret := xLogSetHandler(LogDomainVar, LogLevelsVar, NewCallback(LogFuncVar), UserDataVar)
428+ LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
429+ 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)
436+ }
437+ LogFuncVarRef = purego.NewCallback(fcb)
438+ SaveCallback(LogFuncVarPtr, LogFuncVarRef)
439+ }
440+
441+ cret := xLogSetHandler(LogDomainVar, LogLevelsVar, LogFuncVarRef, UserDataVar)
416442 return cret
417443 }
418444
@@ -427,7 +453,33 @@ var xLogSetHandlerFull func(string, LogLevelFlags, uintptr, uintptr, uintptr) ui
427453 // application domain.
428454 func LogSetHandlerFull(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr, DestroyVar *DestroyNotify) uint {
429455
430- cret := xLogSetHandlerFull(LogDomainVar, LogLevelsVar, NewCallback(LogFuncVar), UserDataVar, NewCallback(DestroyVar))
456+ LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
457+ 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)
464+ }
465+ LogFuncVarRef = purego.NewCallback(fcb)
466+ SaveCallback(LogFuncVarPtr, LogFuncVarRef)
467+ }
468+
469+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
470+ 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)
477+ }
478+ DestroyVarRef = purego.NewCallback(fcb)
479+ SaveCallback(DestroyVarPtr, DestroyVarRef)
480+ }
481+
482+ cret := xLogSetHandlerFull(LogDomainVar, LogLevelsVar, LogFuncVarRef, UserDataVar, DestroyVarRef)
431483 return cret
432484 }
433485
@@ -446,7 +498,33 @@ var xLogSetWriterFunc func(uintptr, uintptr, uintptr)
446498 // There can only be one writer function. It is an error to set more than one.
447499 func LogSetWriterFunc(FuncVar *LogWriterFunc, UserDataVar uintptr, UserDataFreeVar *DestroyNotify) {
448500
449- xLogSetWriterFunc(NewCallback(FuncVar), UserDataVar, NewCallback(UserDataFreeVar))
501+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
502+ 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)
509+ }
510+ FuncVarRef = purego.NewCallback(fcb)
511+ SaveCallback(FuncVarPtr, FuncVarRef)
512+ }
513+
514+ UserDataFreeVarPtr := uintptr(unsafe.Pointer(UserDataFreeVar))
515+ 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)
522+ }
523+ UserDataFreeVarRef = purego.NewCallback(fcb)
524+ SaveCallback(UserDataFreeVarPtr, UserDataFreeVarRef)
525+ }
526+
527+ xLogSetWriterFunc(FuncVarRef, UserDataVar, UserDataFreeVarRef)
450528
451529 }
452530
@@ -923,7 +1001,22 @@ var xSetPrintHandler func(uintptr) uintptr
9231001 // in all platforms. Before GLib 2.76, this was `NULL`.
9241002 func SetPrintHandler(FuncVar *PrintFunc) uintptr {
9251003
926- cret := xSetPrintHandler(NewCallbackNullable(FuncVar))
1004+ var FuncVarRef uintptr
1005+ if FuncVar != nil {
1006+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1007+ if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
1008+ FuncVarRef = cbRefPtr
1009+ } else {
1010+ fcb := func(arg0 string) {
1011+ cbFn := *FuncVar
1012+ cbFn(arg0)
1013+ }
1014+ FuncVarRef = purego.NewCallback(fcb)
1015+ SaveCallback(FuncVarPtr, FuncVarRef)
1016+ }
1017+ }
1018+
1019+ cret := xSetPrintHandler(FuncVarRef)
9271020 return cret
9281021 }
9291022
@@ -946,7 +1039,22 @@ var xSetPrinterrHandler func(uintptr) uintptr
9461039 // Before GLib 2.76, this was `NULL`.
9471040 func SetPrinterrHandler(FuncVar *PrintFunc) uintptr {
9481041
949- cret := xSetPrinterrHandler(NewCallbackNullable(FuncVar))
1042+ var FuncVarRef uintptr
1043+ if FuncVar != nil {
1044+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1045+ if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
1046+ FuncVarRef = cbRefPtr
1047+ } else {
1048+ fcb := func(arg0 string) {
1049+ cbFn := *FuncVar
1050+ cbFn(arg0)
1051+ }
1052+ FuncVarRef = purego.NewCallback(fcb)
1053+ SaveCallback(FuncVarPtr, FuncVarRef)
1054+ }
1055+ }
1056+
1057+ cret := xSetPrinterrHandler(FuncVarRef)
9501058 return cret
9511059 }
9521060
M v4/glib/gnode.go +42 -3
@@ -67,7 +67,20 @@ var xNodeChildrenForeach func(uintptr, TraverseFlags, uintptr, uintptr)
6767 // that would modify the structure of the tree.
6868 func (x *Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar *NodeForeachFunc, DataVar uintptr) {
6969
70- xNodeChildrenForeach(x.GoPointer(), FlagsVar, NewCallback(FuncVar), DataVar)
70+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
71+ 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)
78+ }
79+ FuncVarRef = purego.NewCallback(fcb)
80+ SaveCallback(FuncVarPtr, FuncVarRef)
81+ }
82+
83+ xNodeChildrenForeach(x.GoPointer(), FlagsVar, FuncVarRef, DataVar)
7184
7285 }
7386
@@ -86,7 +99,20 @@ var xNodeCopyDeep func(uintptr, uintptr, uintptr) *Node
8699 // Recursively copies a #GNode and its data.
87100 func (x *Node) CopyDeep(CopyFuncVar *CopyFunc, DataVar uintptr) *Node {
88101
89- cret := xNodeCopyDeep(x.GoPointer(), NewCallback(CopyFuncVar), DataVar)
102+ CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
103+ 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)
110+ }
111+ CopyFuncVarRef = purego.NewCallback(fcb)
112+ SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
113+ }
114+
115+ cret := xNodeCopyDeep(x.GoPointer(), CopyFuncVarRef, DataVar)
90116 return cret
91117 }
92118
@@ -275,7 +301,20 @@ var xNodeTraverse func(uintptr, TraverseType, TraverseFlags, int, uintptr, uintp
275301 // @func must not do anything that would modify the structure of the tree.
276302 func (x *Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar *NodeTraverseFunc, DataVar uintptr) {
277303
278- xNodeTraverse(x.GoPointer(), OrderVar, FlagsVar, MaxDepthVar, NewCallback(FuncVar), DataVar)
304+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
305+ 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)
312+ }
313+ FuncVarRef = purego.NewCallback(fcb)
314+ SaveCallback(FuncVarPtr, FuncVarRef)
315+ }
316+
317+ xNodeTraverse(x.GoPointer(), OrderVar, FlagsVar, MaxDepthVar, FuncVarRef, DataVar)
279318
280319 }
281320
M v4/glib/goption.go +123 -5
@@ -314,7 +314,37 @@ var xOptionContextSetTranslateFunc func(uintptr, uintptr, uintptr, uintptr)
314314 // domain, see g_option_context_set_translation_domain().
315315 func (x *OptionContext) SetTranslateFunc(FuncVar *TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {
316316
317- xOptionContextSetTranslateFunc(x.GoPointer(), NewCallbackNullable(FuncVar), DataVar, NewCallbackNullable(DestroyNotifyVar))
317+ var FuncVarRef uintptr
318+ if FuncVar != nil {
319+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
320+ if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
321+ FuncVarRef = cbRefPtr
322+ } else {
323+ fcb := func(arg0 string, arg1 uintptr) string {
324+ cbFn := *FuncVar
325+ return cbFn(arg0, arg1)
326+ }
327+ FuncVarRef = purego.NewCallback(fcb)
328+ SaveCallback(FuncVarPtr, FuncVarRef)
329+ }
330+ }
331+
332+ var DestroyNotifyVarRef uintptr
333+ if DestroyNotifyVar != nil {
334+ DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
335+ if cbRefPtr, ok := GetCallback(DestroyNotifyVarPtr); ok {
336+ DestroyNotifyVarRef = cbRefPtr
337+ } else {
338+ fcb := func(arg0 uintptr) {
339+ cbFn := *DestroyNotifyVar
340+ cbFn(arg0)
341+ }
342+ DestroyNotifyVarRef = purego.NewCallback(fcb)
343+ SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
344+ }
345+ }
346+
347+ xOptionContextSetTranslateFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyNotifyVarRef)
318348
319349 }
320350
@@ -404,7 +434,22 @@ var xNewOptionGroup func(string, string, string, uintptr, uintptr) *OptionGroup
404434 // ‘Application Options:’.
405435 func NewOptionGroup(NameVar string, DescriptionVar string, HelpDescriptionVar string, UserDataVar uintptr, DestroyVar *DestroyNotify) *OptionGroup {
406436
407- cret := xNewOptionGroup(NameVar, DescriptionVar, HelpDescriptionVar, UserDataVar, NewCallbackNullable(DestroyVar))
437+ var DestroyVarRef uintptr
438+ if DestroyVar != nil {
439+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
440+ if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
441+ DestroyVarRef = cbRefPtr
442+ } else {
443+ fcb := func(arg0 uintptr) {
444+ cbFn := *DestroyVar
445+ cbFn(arg0)
446+ }
447+ DestroyVarRef = purego.NewCallback(fcb)
448+ SaveCallback(DestroyVarPtr, DestroyVarRef)
449+ }
450+ }
451+
452+ cret := xNewOptionGroup(NameVar, DescriptionVar, HelpDescriptionVar, UserDataVar, DestroyVarRef)
408453 return cret
409454 }
410455
@@ -445,7 +490,20 @@ var xOptionGroupSetErrorHook func(uintptr, uintptr)
445490 // specified when constructing the group with g_option_group_new().
446491 func (x *OptionGroup) SetErrorHook(ErrorFuncVar *OptionErrorFunc) {
447492
448- xOptionGroupSetErrorHook(x.GoPointer(), NewCallback(ErrorFuncVar))
493+ ErrorFuncVarPtr := uintptr(unsafe.Pointer(ErrorFuncVar))
494+ 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)
501+ }
502+ ErrorFuncVarRef = purego.NewCallback(fcb)
503+ SaveCallback(ErrorFuncVarPtr, ErrorFuncVarRef)
504+ }
505+
506+ xOptionGroupSetErrorHook(x.GoPointer(), ErrorFuncVarRef)
449507
450508 }
451509
@@ -460,7 +518,37 @@ var xOptionGroupSetParseHooks func(uintptr, uintptr, uintptr)
460518 // with g_option_group_new().
461519 func (x *OptionGroup) SetParseHooks(PreParseFuncVar *OptionParseFunc, PostParseFuncVar *OptionParseFunc) {
462520
463- xOptionGroupSetParseHooks(x.GoPointer(), NewCallbackNullable(PreParseFuncVar), NewCallbackNullable(PostParseFuncVar))
521+ var PreParseFuncVarRef uintptr
522+ if PreParseFuncVar != nil {
523+ PreParseFuncVarPtr := uintptr(unsafe.Pointer(PreParseFuncVar))
524+ if cbRefPtr, ok := GetCallback(PreParseFuncVarPtr); ok {
525+ PreParseFuncVarRef = cbRefPtr
526+ } else {
527+ fcb := func(arg0 *OptionContext, arg1 *OptionGroup, arg2 uintptr, arg3 **Error) bool {
528+ cbFn := *PreParseFuncVar
529+ return cbFn(arg0, arg1, arg2, arg3)
530+ }
531+ PreParseFuncVarRef = purego.NewCallback(fcb)
532+ SaveCallback(PreParseFuncVarPtr, PreParseFuncVarRef)
533+ }
534+ }
535+
536+ var PostParseFuncVarRef uintptr
537+ if PostParseFuncVar != nil {
538+ PostParseFuncVarPtr := uintptr(unsafe.Pointer(PostParseFuncVar))
539+ if cbRefPtr, ok := GetCallback(PostParseFuncVarPtr); ok {
540+ PostParseFuncVarRef = cbRefPtr
541+ } else {
542+ fcb := func(arg0 *OptionContext, arg1 *OptionGroup, arg2 uintptr, arg3 **Error) bool {
543+ cbFn := *PostParseFuncVar
544+ return cbFn(arg0, arg1, arg2, arg3)
545+ }
546+ PostParseFuncVarRef = purego.NewCallback(fcb)
547+ SaveCallback(PostParseFuncVarPtr, PostParseFuncVarRef)
548+ }
549+ }
550+
551+ xOptionGroupSetParseHooks(x.GoPointer(), PreParseFuncVarRef, PostParseFuncVarRef)
464552
465553 }
466554
@@ -474,7 +562,37 @@ var xOptionGroupSetTranslateFunc func(uintptr, uintptr, uintptr, uintptr)
474562 // domain, see g_option_group_set_translation_domain().
475563 func (x *OptionGroup) SetTranslateFunc(FuncVar *TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {
476564
477- xOptionGroupSetTranslateFunc(x.GoPointer(), NewCallbackNullable(FuncVar), DataVar, NewCallbackNullable(DestroyNotifyVar))
565+ var FuncVarRef uintptr
566+ if FuncVar != nil {
567+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
568+ if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
569+ FuncVarRef = cbRefPtr
570+ } else {
571+ fcb := func(arg0 string, arg1 uintptr) string {
572+ cbFn := *FuncVar
573+ return cbFn(arg0, arg1)
574+ }
575+ FuncVarRef = purego.NewCallback(fcb)
576+ SaveCallback(FuncVarPtr, FuncVarRef)
577+ }
578+ }
579+
580+ var DestroyNotifyVarRef uintptr
581+ if DestroyNotifyVar != nil {
582+ DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
583+ if cbRefPtr, ok := GetCallback(DestroyNotifyVarPtr); ok {
584+ DestroyNotifyVarRef = cbRefPtr
585+ } else {
586+ fcb := func(arg0 uintptr) {
587+ cbFn := *DestroyNotifyVar
588+ cbFn(arg0)
589+ }
590+ DestroyNotifyVarRef = purego.NewCallback(fcb)
591+ SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
592+ }
593+ }
594+
595+ xOptionGroupSetTranslateFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyNotifyVarRef)
478596
479597 }
480598
M v4/glib/gqsort.go +30 -2
@@ -2,6 +2,8 @@
22 package glib
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 )
@@ -15,7 +17,20 @@ var xQsortWithData func(uintptr, int, uint, uintptr, uintptr)
1517 // Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).
1618 func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
1719
18- xQsortWithData(PbaseVar, TotalElemsVar, SizeVar, NewCallback(CompareFuncVar), UserDataVar)
20+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
21+ 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)
28+ }
29+ CompareFuncVarRef = purego.NewCallback(fcb)
30+ SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
31+ }
32+
33+ xQsortWithData(PbaseVar, TotalElemsVar, SizeVar, CompareFuncVarRef, UserDataVar)
1934
2035 }
2136
@@ -28,7 +43,20 @@ var xSortArray func([]uintptr, uint, uint, uintptr, uintptr)
2843 // Unlike `qsort()`, this is guaranteed to be a stable sort.
2944 func SortArray(ArrayVar []uintptr, NElementsVar uint, ElementSizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
3045
31- xSortArray(ArrayVar, NElementsVar, ElementSizeVar, NewCallback(CompareFuncVar), UserDataVar)
46+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
47+ 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)
54+ }
55+ CompareFuncVarRef = purego.NewCallback(fcb)
56+ SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
57+ }
58+
59+ xSortArray(ArrayVar, NElementsVar, ElementSizeVar, CompareFuncVarRef, UserDataVar)
3260
3361 }
3462
M v4/glib/gqueue.go +86 -6
@@ -41,7 +41,22 @@ var xQueueClearFull func(uintptr, uintptr)
4141 // and calls the provided @free_func on each item in the #GQueue.
4242 func (x *Queue) ClearFull(FreeFuncVar *DestroyNotify) {
4343
44- xQueueClearFull(x.GoPointer(), NewCallbackNullable(FreeFuncVar))
44+ var FreeFuncVarRef uintptr
45+ if FreeFuncVar != nil {
46+ FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
47+ if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
48+ FreeFuncVarRef = cbRefPtr
49+ } else {
50+ fcb := func(arg0 uintptr) {
51+ cbFn := *FreeFuncVar
52+ cbFn(arg0)
53+ }
54+ FreeFuncVarRef = purego.NewCallback(fcb)
55+ SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
56+ }
57+ }
58+
59+ xQueueClearFull(x.GoPointer(), FreeFuncVarRef)
4560
4661 }
4762
@@ -85,7 +100,20 @@ var xQueueFindCustom func(uintptr, uintptr, uintptr) *List
85100 // first argument and the given user data as the second argument.
86101 func (x *Queue) FindCustom(DataVar uintptr, FuncVar *CompareFunc) *List {
87102
88- cret := xQueueFindCustom(x.GoPointer(), DataVar, NewCallback(FuncVar))
103+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
104+ 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)
111+ }
112+ FuncVarRef = purego.NewCallback(fcb)
113+ SaveCallback(FuncVarPtr, FuncVarRef)
114+ }
115+
116+ cret := xQueueFindCustom(x.GoPointer(), DataVar, FuncVarRef)
89117 return cret
90118 }
91119
@@ -98,7 +126,20 @@ var xQueueForeach func(uintptr, uintptr, uintptr)
98126 // not modify any part of the queue after that element.
99127 func (x *Queue) Foreach(FuncVar *Func, UserDataVar uintptr) {
100128
101- xQueueForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
129+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
130+ 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)
137+ }
138+ FuncVarRef = purego.NewCallback(fcb)
139+ SaveCallback(FuncVarPtr, FuncVarRef)
140+ }
141+
142+ xQueueForeach(x.GoPointer(), FuncVarRef, UserDataVar)
102143
103144 }
104145
@@ -125,7 +166,20 @@ var xQueueFreeFull func(uintptr, uintptr)
125166 // element from it).
126167 func (x *Queue) FreeFull(FreeFuncVar *DestroyNotify) {
127168
128- xQueueFreeFull(x.GoPointer(), NewCallback(FreeFuncVar))
169+ FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
170+ 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)
177+ }
178+ FreeFuncVarRef = purego.NewCallback(fcb)
179+ SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
180+ }
181+
182+ xQueueFreeFull(x.GoPointer(), FreeFuncVarRef)
129183
130184 }
131185
@@ -210,7 +264,20 @@ var xQueueInsertSorted func(uintptr, uintptr, uintptr, uintptr)
210264 // Inserts @data into @queue using @func to determine the new position.
211265 func (x *Queue) InsertSorted(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
212266
213- xQueueInsertSorted(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)
267+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
268+ 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)
275+ }
276+ FuncVarRef = purego.NewCallback(fcb)
277+ SaveCallback(FuncVarPtr, FuncVarRef)
278+ }
279+
280+ xQueueInsertSorted(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
214281
215282 }
216283
@@ -426,7 +493,20 @@ var xQueueSort func(uintptr, uintptr, uintptr)
426493 // Sorts @queue using @compare_func.
427494 func (x *Queue) Sort(CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
428495
429- xQueueSort(x.GoPointer(), NewCallback(CompareFuncVar), UserDataVar)
496+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
497+ 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)
504+ }
505+ CompareFuncVarRef = purego.NewCallback(fcb)
506+ SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
507+ }
508+
509+ xQueueSort(x.GoPointer(), CompareFuncVarRef, UserDataVar)
430510
431511 }
432512
M v4/glib/grcbox.go +30 -2
@@ -2,6 +2,8 @@
22 package glib
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 )
@@ -95,7 +97,20 @@ var xAtomicRcBoxReleaseFull func(uintptr, uintptr)
9597 // when the callback is called and will be freed.
9698 func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
9799
98- xAtomicRcBoxReleaseFull(MemBlockVar, NewCallback(ClearFuncVar))
100+ ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
101+ 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)
108+ }
109+ ClearFuncVarRef = purego.NewCallback(fcb)
110+ SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
111+ }
112+
113+ xAtomicRcBoxReleaseFull(MemBlockVar, ClearFuncVarRef)
99114
100115 }
101116
@@ -183,7 +198,20 @@ var xRcBoxReleaseFull func(uintptr, uintptr)
183198 // resources allocated for @mem_block.
184199 func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
185200
186- xRcBoxReleaseFull(MemBlockVar, NewCallback(ClearFuncVar))
201+ ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
202+ 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)
209+ }
210+ ClearFuncVarRef = purego.NewCallback(fcb)
211+ SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
212+ }
213+
214+ xRcBoxReleaseFull(MemBlockVar, ClearFuncVarRef)
187215
188216 }
189217
M v4/glib/gregex.go +14 -1
@@ -1028,7 +1028,20 @@ var xRegexReplaceEval func(uintptr, []string, int, int, RegexMatchFlags, uintptr
10281028 func (x *Regex) ReplaceEval(StringVar []string, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar *RegexEvalCallback, UserDataVar uintptr) (string, error) {
10291029 var cerr *Error
10301030
1031- cret := xRegexReplaceEval(x.GoPointer(), StringVar, StringLenVar, StartPositionVar, MatchOptionsVar, NewCallback(EvalVar), UserDataVar, &cerr)
1031+ EvalVarPtr := uintptr(unsafe.Pointer(EvalVar))
1032+ 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)
1039+ }
1040+ EvalVarRef = purego.NewCallback(fcb)
1041+ SaveCallback(EvalVarPtr, EvalVarRef)
1042+ }
1043+
1044+ cret := xRegexReplaceEval(x.GoPointer(), StringVar, StringLenVar, StartPositionVar, MatchOptionsVar, EvalVarRef, UserDataVar, &cerr)
10321045 if cerr == nil {
10331046 return cret, nil
10341047 }
M v4/glib/grel.go +27 -1
@@ -104,7 +104,33 @@ var xRelationIndex func(uintptr, int, uintptr, uintptr)
104104 // before any records are added to the #GRelation.
105105 func (x *Relation) Index(FieldVar int, HashFuncVar *HashFunc, KeyEqualFuncVar *EqualFunc) {
106106
107- xRelationIndex(x.GoPointer(), FieldVar, NewCallback(HashFuncVar), NewCallback(KeyEqualFuncVar))
107+ HashFuncVarPtr := uintptr(unsafe.Pointer(HashFuncVar))
108+ 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)
115+ }
116+ HashFuncVarRef = purego.NewCallback(fcb)
117+ SaveCallback(HashFuncVarPtr, HashFuncVarRef)
118+ }
119+
120+ KeyEqualFuncVarPtr := uintptr(unsafe.Pointer(KeyEqualFuncVar))
121+ 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)
128+ }
129+ KeyEqualFuncVarRef = purego.NewCallback(fcb)
130+ SaveCallback(KeyEqualFuncVarPtr, KeyEqualFuncVarRef)
131+ }
132+
133+ xRelationIndex(x.GoPointer(), FieldVar, HashFuncVarRef, KeyEqualFuncVarRef)
108134
109135 }
110136
M v4/glib/gscanner.go +14 -1
@@ -223,7 +223,20 @@ var xScannerScopeForeachSymbol func(uintptr, uint, uintptr, uintptr)
223223 // parameter.
224224 func (x *Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar *HFunc, UserDataVar uintptr) {
225225
226- xScannerScopeForeachSymbol(x.GoPointer(), ScopeIdVar, NewCallback(FuncVar), UserDataVar)
226+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
227+ 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)
234+ }
235+ FuncVarRef = purego.NewCallback(fcb)
236+ SaveCallback(FuncVarPtr, FuncVarRef)
237+ }
238+
239+ xScannerScopeForeachSymbol(x.GoPointer(), ScopeIdVar, FuncVarRef, UserDataVar)
227240
228241 }
229242
M v4/glib/gsequence.go +168 -12
@@ -39,7 +39,20 @@ var xSequenceForeach func(uintptr, uintptr, uintptr)
3939 // to the function. @func must not modify the sequence itself.
4040 func (x *Sequence) Foreach(FuncVar *Func, UserDataVar uintptr) {
4141
42- xSequenceForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
42+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
43+ 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)
50+ }
51+ FuncVarRef = purego.NewCallback(fcb)
52+ SaveCallback(FuncVarPtr, FuncVarRef)
53+ }
54+
55+ xSequenceForeach(x.GoPointer(), FuncVarRef, UserDataVar)
4356
4457 }
4558
@@ -109,7 +122,20 @@ var xSequenceInsertSorted func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
109122 // g_sequence_sort() or g_sequence_sort_iter().
110123 func (x *Sequence) InsertSorted(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
111124
112- cret := xSequenceInsertSorted(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)
125+ CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
126+ 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)
133+ }
134+ CmpFuncVarRef = purego.NewCallback(fcb)
135+ SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
136+ }
137+
138+ cret := xSequenceInsertSorted(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
113139 return cret
114140 }
115141
@@ -129,7 +155,20 @@ var xSequenceInsertSortedIter func(uintptr, uintptr, uintptr, uintptr) *Sequence
129155 // g_sequence_sort() or g_sequence_sort_iter().
130156 func (x *Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
131157
132- cret := xSequenceInsertSortedIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)
158+ IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
159+ 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)
166+ }
167+ IterCmpVarRef = purego.NewCallback(fcb)
168+ SaveCallback(IterCmpVarPtr, IterCmpVarRef)
169+ }
170+
171+ cret := xSequenceInsertSortedIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
133172 return cret
134173 }
135174
@@ -163,7 +202,20 @@ var xSequenceLookup func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
163202 // unsorted.
164203 func (x *Sequence) Lookup(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
165204
166- cret := xSequenceLookup(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)
205+ CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
206+ 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)
213+ }
214+ CmpFuncVarRef = purego.NewCallback(fcb)
215+ SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
216+ }
217+
218+ cret := xSequenceLookup(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
167219 return cret
168220 }
169221
@@ -181,7 +233,20 @@ var xSequenceLookupIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
181233 // unsorted.
182234 func (x *Sequence) LookupIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
183235
184- cret := xSequenceLookupIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)
236+ IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
237+ 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)
244+ }
245+ IterCmpVarRef = purego.NewCallback(fcb)
246+ SaveCallback(IterCmpVarPtr, IterCmpVarRef)
247+ }
248+
249+ cret := xSequenceLookupIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
185250 return cret
186251 }
187252
@@ -211,7 +276,20 @@ var xSequenceSearch func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
211276 // unsorted.
212277 func (x *Sequence) Search(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
213278
214- cret := xSequenceSearch(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)
279+ CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
280+ 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)
287+ }
288+ CmpFuncVarRef = purego.NewCallback(fcb)
289+ SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
290+ }
291+
292+ cret := xSequenceSearch(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
215293 return cret
216294 }
217295
@@ -232,7 +310,20 @@ var xSequenceSearchIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
232310 // unsorted.
233311 func (x *Sequence) SearchIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
234312
235- cret := xSequenceSearchIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)
313+ IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
314+ 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)
321+ }
322+ IterCmpVarRef = purego.NewCallback(fcb)
323+ SaveCallback(IterCmpVarPtr, IterCmpVarRef)
324+ }
325+
326+ cret := xSequenceSearchIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
236327 return cret
237328 }
238329
@@ -246,7 +337,20 @@ var xSequenceSort func(uintptr, uintptr, uintptr)
246337 // if the second comes before the first.
247338 func (x *Sequence) Sort(CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) {
248339
249- xSequenceSort(x.GoPointer(), NewCallback(CmpFuncVar), CmpDataVar)
340+ CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
341+ 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)
348+ }
349+ CmpFuncVarRef = purego.NewCallback(fcb)
350+ SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
351+ }
352+
353+ xSequenceSort(x.GoPointer(), CmpFuncVarRef, CmpDataVar)
250354
251355 }
252356
@@ -261,7 +365,20 @@ var xSequenceSortIter func(uintptr, uintptr, uintptr)
261365 // iterator comes before the first.
262366 func (x *Sequence) SortIter(CmpFuncVar *SequenceIterCompareFunc, CmpDataVar uintptr) {
263367
264- xSequenceSortIter(x.GoPointer(), NewCallback(CmpFuncVar), CmpDataVar)
368+ CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
369+ 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)
376+ }
377+ CmpFuncVarRef = purego.NewCallback(fcb)
378+ SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
379+ }
380+
381+ xSequenceSortIter(x.GoPointer(), CmpFuncVarRef, CmpDataVar)
265382
266383 }
267384
@@ -362,7 +479,20 @@ var xSequenceForeachRange func(*SequenceIter, *SequenceIter, uintptr, uintptr)
362479 // itself.
363480 func SequenceForeachRange(BeginVar *SequenceIter, EndVar *SequenceIter, FuncVar *Func, UserDataVar uintptr) {
364481
365- xSequenceForeachRange(BeginVar, EndVar, NewCallback(FuncVar), UserDataVar)
482+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
483+ 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)
490+ }
491+ FuncVarRef = purego.NewCallback(fcb)
492+ SaveCallback(FuncVarPtr, FuncVarRef)
493+ }
494+
495+ xSequenceForeachRange(BeginVar, EndVar, FuncVarRef, UserDataVar)
366496
367497 }
368498
@@ -476,7 +606,20 @@ var xSequenceSortChanged func(*SequenceIter, uintptr, uintptr)
476606 // the second item comes before the first.
477607 func SequenceSortChanged(IterVar *SequenceIter, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) {
478608
479- xSequenceSortChanged(IterVar, NewCallback(CmpFuncVar), CmpDataVar)
609+ CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
610+ 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)
617+ }
618+ CmpFuncVarRef = purego.NewCallback(fcb)
619+ SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
620+ }
621+
622+ xSequenceSortChanged(IterVar, CmpFuncVarRef, CmpDataVar)
480623
481624 }
482625
@@ -493,7 +636,20 @@ var xSequenceSortChangedIter func(*SequenceIter, uintptr, uintptr)
493636 // iterator comes before the first.
494637 func SequenceSortChangedIter(IterVar *SequenceIter, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) {
495638
496- xSequenceSortChangedIter(IterVar, NewCallback(IterCmpVar), CmpDataVar)
639+ IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
640+ 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)
647+ }
648+ IterCmpVarRef = purego.NewCallback(fcb)
649+ SaveCallback(IterCmpVarPtr, IterCmpVarRef)
650+ }
651+
652+ xSequenceSortChangedIter(IterVar, IterCmpVarRef, CmpDataVar)
497653
498654 }
499655
M v4/glib/gslist.go +16 -1
@@ -30,7 +30,22 @@ var xClearSlist func(**SList, uintptr)
3030 // @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing.
3131 func ClearSlist(SlistPtrVar **SList, DestroyVar *DestroyNotify) {
3232
33- xClearSlist(SlistPtrVar, NewCallbackNullable(DestroyVar))
33+ var DestroyVarRef uintptr
34+ if DestroyVar != nil {
35+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
36+ if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
37+ DestroyVarRef = cbRefPtr
38+ } else {
39+ fcb := func(arg0 uintptr) {
40+ cbFn := *DestroyVar
41+ cbFn(arg0)
42+ }
43+ DestroyVarRef = purego.NewCallback(fcb)
44+ SaveCallback(DestroyVarPtr, DestroyVarRef)
45+ }
46+ }
47+
48+ xClearSlist(SlistPtrVar, DestroyVarRef)
3449
3550 }
3651
M v4/glib/gspawn.go +82 -5
@@ -2,6 +2,8 @@
22 package glib
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 )
@@ -156,7 +158,22 @@ var xSpawnAsync func(string, []string, []string, SpawnFlags, uintptr, uintptr, *
156158 func SpawnAsync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid) (bool, error) {
157159 var cerr *Error
158160
159- cret := xSpawnAsync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, ChildPidVar, &cerr)
161+ var ChildSetupVarRef uintptr
162+ if ChildSetupVar != nil {
163+ ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
164+ if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
165+ ChildSetupVarRef = cbRefPtr
166+ } else {
167+ fcb := func(arg0 uintptr) {
168+ cbFn := *ChildSetupVar
169+ cbFn(arg0)
170+ }
171+ ChildSetupVarRef = purego.NewCallback(fcb)
172+ SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
173+ }
174+ }
175+
176+ cret := xSpawnAsync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, &cerr)
160177 if cerr == nil {
161178 return cret, nil
162179 }
@@ -173,7 +190,22 @@ var xSpawnAsyncWithFds func(string, []string, []string, SpawnFlags, uintptr, uin
173190 func SpawnAsyncWithFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {
174191 var cerr *Error
175192
176- cret := xSpawnAsyncWithFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, ChildPidVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)
193+ var ChildSetupVarRef uintptr
194+ if ChildSetupVar != nil {
195+ ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
196+ if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
197+ ChildSetupVarRef = cbRefPtr
198+ } else {
199+ fcb := func(arg0 uintptr) {
200+ cbFn := *ChildSetupVar
201+ cbFn(arg0)
202+ }
203+ ChildSetupVarRef = purego.NewCallback(fcb)
204+ SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
205+ }
206+ }
207+
208+ cret := xSpawnAsyncWithFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)
177209 if cerr == nil {
178210 return cret, nil
179211 }
@@ -188,7 +220,22 @@ var xSpawnAsyncWithPipes func(string, []string, []string, SpawnFlags, uintptr, u
188220 func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StandardInputVar *int, StandardOutputVar *int, StandardErrorVar *int) (bool, error) {
189221 var cerr *Error
190222
191- cret := xSpawnAsyncWithPipes(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)
223+ var ChildSetupVarRef uintptr
224+ if ChildSetupVar != nil {
225+ ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
226+ if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
227+ ChildSetupVarRef = cbRefPtr
228+ } else {
229+ fcb := func(arg0 uintptr) {
230+ cbFn := *ChildSetupVar
231+ cbFn(arg0)
232+ }
233+ ChildSetupVarRef = purego.NewCallback(fcb)
234+ SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
235+ }
236+ }
237+
238+ cret := xSpawnAsyncWithPipes(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)
192239 if cerr == nil {
193240 return cret, nil
194241 }
@@ -395,7 +442,22 @@ var xSpawnAsyncWithPipesAndFds func(string, []string, []string, SpawnFlags, uint
395442 func SpawnAsyncWithPipesAndFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int, SourceFdsVar []int, TargetFdsVar []int, NFdsVar uint, ChildPidOutVar *Pid, StdinPipeOutVar *int, StdoutPipeOutVar *int, StderrPipeOutVar *int) (bool, error) {
396443 var cerr *Error
397444
398- cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)
445+ var ChildSetupVarRef uintptr
446+ if ChildSetupVar != nil {
447+ ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
448+ if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
449+ ChildSetupVarRef = cbRefPtr
450+ } else {
451+ fcb := func(arg0 uintptr) {
452+ cbFn := *ChildSetupVar
453+ cbFn(arg0)
454+ }
455+ ChildSetupVarRef = purego.NewCallback(fcb)
456+ SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
457+ }
458+ }
459+
460+ cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)
399461 if cerr == nil {
400462 return cret, nil
401463 }
@@ -581,7 +643,22 @@ var xSpawnSync func(string, []string, []string, SpawnFlags, uintptr, uintptr, *[
581643 func SpawnSync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar *[]byte, StandardErrorVar *[]byte, WaitStatusVar *int) (bool, error) {
582644 var cerr *Error
583645
584- cret := xSpawnSync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)
646+ var ChildSetupVarRef uintptr
647+ if ChildSetupVar != nil {
648+ ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
649+ if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
650+ ChildSetupVarRef = cbRefPtr
651+ } else {
652+ fcb := func(arg0 uintptr) {
653+ cbFn := *ChildSetupVar
654+ cbFn(arg0)
655+ }
656+ ChildSetupVarRef = purego.NewCallback(fcb)
657+ SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
658+ }
659+ }
660+
661+ cret := xSpawnSync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)
585662 if cerr == nil {
586663 return cret, nil
587664 }
M v4/glib/gtestutils.go +163 -7
@@ -420,7 +420,20 @@ var xTestAddDataFunc func(string, uintptr, uintptr)
420420 // and it is recommended to do so even if it isn’t.
421421 func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc) {
422422
423- xTestAddDataFunc(TestpathVar, TestDataVar, NewCallback(TestFuncVar))
423+ TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
424+ 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)
431+ }
432+ TestFuncVarRef = purego.NewCallback(fcb)
433+ SaveCallback(TestFuncVarPtr, TestFuncVarRef)
434+ }
435+
436+ xTestAddDataFunc(TestpathVar, TestDataVar, TestFuncVarRef)
424437
425438 }
426439
@@ -432,7 +445,33 @@ var xTestAddDataFuncFull func(string, uintptr, uintptr, uintptr)
432445 // is freeing @test_data after the test run is complete.
433446 func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc, DataFreeFuncVar *DestroyNotify) {
434447
435- xTestAddDataFuncFull(TestpathVar, TestDataVar, NewCallback(TestFuncVar), NewCallback(DataFreeFuncVar))
448+ TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
449+ 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)
456+ }
457+ TestFuncVarRef = purego.NewCallback(fcb)
458+ SaveCallback(TestFuncVarPtr, TestFuncVarRef)
459+ }
460+
461+ DataFreeFuncVarPtr := uintptr(unsafe.Pointer(DataFreeFuncVar))
462+ 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)
469+ }
470+ DataFreeFuncVarRef = purego.NewCallback(fcb)
471+ SaveCallback(DataFreeFuncVarPtr, DataFreeFuncVarRef)
472+ }
473+
474+ xTestAddDataFuncFull(TestpathVar, TestDataVar, TestFuncVarRef, DataFreeFuncVarRef)
436475
437476 }
438477
@@ -454,7 +493,20 @@ var xTestAddFunc func(string, uintptr)
454493 // it is recommended to do so even if it isn’t.
455494 func TestAddFunc(TestpathVar string, TestFuncVar *TestFunc) {
456495
457- xTestAddFunc(TestpathVar, NewCallback(TestFuncVar))
496+ TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
497+ var TestFuncVarRef uintptr
498+ if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
499+ TestFuncVarRef = cbRefPtr
500+ } else {
501+ fcb := func() {
502+ cbFn := *TestFuncVar
503+ cbFn()
504+ }
505+ TestFuncVarRef = purego.NewCallback(fcb)
506+ SaveCallback(TestFuncVarPtr, TestFuncVarRef)
507+ }
508+
509+ xTestAddFunc(TestpathVar, TestFuncVarRef)
458510
459511 }
460512
@@ -462,7 +514,46 @@ var xTestAddVtable func(string, uint, uintptr, uintptr, uintptr, uintptr)
462514
463515 func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar *TestFixtureFunc, DataTestVar *TestFixtureFunc, DataTeardownVar *TestFixtureFunc) {
464516
465- xTestAddVtable(TestpathVar, DataSizeVar, TestDataVar, NewCallback(DataSetupVar), NewCallback(DataTestVar), NewCallback(DataTeardownVar))
517+ DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
518+ 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)
525+ }
526+ DataSetupVarRef = purego.NewCallback(fcb)
527+ SaveCallback(DataSetupVarPtr, DataSetupVarRef)
528+ }
529+
530+ DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
531+ 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)
538+ }
539+ DataTestVarRef = purego.NewCallback(fcb)
540+ SaveCallback(DataTestVarPtr, DataTestVarRef)
541+ }
542+
543+ DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
544+ 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)
551+ }
552+ DataTeardownVarRef = purego.NewCallback(fcb)
553+ SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
554+ }
555+
556+ xTestAddVtable(TestpathVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)
466557
467558 }
468559
@@ -566,7 +657,46 @@ var xTestCreateCase func(string, uint, uintptr, uintptr, uintptr, uintptr) *Test
566657 // varying @test_name and @data_test arguments.
567658 func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar *TestFixtureFunc, DataTestVar *TestFixtureFunc, DataTeardownVar *TestFixtureFunc) *TestCase {
568659
569- cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, NewCallback(DataSetupVar), NewCallback(DataTestVar), NewCallback(DataTeardownVar))
660+ DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
661+ 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)
668+ }
669+ DataSetupVarRef = purego.NewCallback(fcb)
670+ SaveCallback(DataSetupVarPtr, DataSetupVarRef)
671+ }
672+
673+ DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
674+ 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)
681+ }
682+ DataTestVarRef = purego.NewCallback(fcb)
683+ SaveCallback(DataTestVarPtr, DataTestVarRef)
684+ }
685+
686+ DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
687+ 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)
694+ }
695+ DataTeardownVarRef = purego.NewCallback(fcb)
696+ SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
697+ }
698+
699+ cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)
570700 return cret
571701 }
572702
@@ -879,7 +1009,20 @@ var xTestLogSetFatalHandler func(uintptr, uintptr)
8791009 // [Using Structured Logging](logging.html#using-structured-logging).
8801010 func TestLogSetFatalHandler(LogFuncVar *TestLogFatalFunc, UserDataVar uintptr) {
8811011
882- xTestLogSetFatalHandler(NewCallback(LogFuncVar), UserDataVar)
1012+ LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
1013+ 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)
1020+ }
1021+ LogFuncVarRef = purego.NewCallback(fcb)
1022+ SaveCallback(LogFuncVarPtr, LogFuncVarRef)
1023+ }
1024+
1025+ xTestLogSetFatalHandler(LogFuncVarRef, UserDataVar)
8831026
8841027 }
8851028
@@ -939,7 +1082,20 @@ var xTestQueueDestroy func(uintptr, uintptr)
9391082 // before `A()` during teardown.
9401083 func TestQueueDestroy(DestroyFuncVar *DestroyNotify, DestroyDataVar uintptr) {
9411084
942- xTestQueueDestroy(NewCallback(DestroyFuncVar), DestroyDataVar)
1085+ DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
1086+ 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)
1093+ }
1094+ DestroyFuncVarRef = purego.NewCallback(fcb)
1095+ SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
1096+ }
1097+
1098+ xTestQueueDestroy(DestroyFuncVarRef, DestroyDataVar)
9431099
9441100 }
9451101
M v4/glib/gthread.go +112 -8
@@ -281,7 +281,20 @@ var xOnceImpl func(uintptr, uintptr, uintptr) uintptr
281281
282282 func (x *Once) Impl(FuncVar *ThreadFunc, ArgVar uintptr) uintptr {
283283
284- cret := xOnceImpl(x.GoPointer(), NewCallback(FuncVar), ArgVar)
284+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
285+ 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)
292+ }
293+ FuncVarRef = purego.NewCallback(fcb)
294+ SaveCallback(FuncVarPtr, FuncVarRef)
295+ }
296+
297+ cret := xOnceImpl(x.GoPointer(), FuncVarRef, ArgVar)
285298 return cret
286299 }
287300
@@ -859,7 +872,20 @@ var xStaticPrivateSet func(uintptr, uintptr, uintptr)
859872 // @notify is used quite differently from @destructor in g_private_new().
860873 func (x *StaticPrivate) Set(DataVar uintptr, NotifyVar *DestroyNotify) {
861874
862- xStaticPrivateSet(x.GoPointer(), DataVar, NewCallback(NotifyVar))
875+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
876+ 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)
883+ }
884+ NotifyVarRef = purego.NewCallback(fcb)
885+ SaveCallback(NotifyVarPtr, NotifyVarRef)
886+ }
887+
888+ xStaticPrivateSet(x.GoPointer(), DataVar, NotifyVarRef)
863889
864890 }
865891
@@ -1250,7 +1276,20 @@ var xNewThread func(string, uintptr, uintptr) *Thread
12501276 // POSIX and all threads inherit their parent thread's priority.
12511277 func NewThread(NameVar string, FuncVar *ThreadFunc, DataVar uintptr) *Thread {
12521278
1253- cret := xNewThread(NameVar, NewCallback(FuncVar), DataVar)
1279+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1280+ 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)
1287+ }
1288+ FuncVarRef = purego.NewCallback(fcb)
1289+ SaveCallback(FuncVarPtr, FuncVarRef)
1290+ }
1291+
1292+ cret := xNewThread(NameVar, FuncVarRef, DataVar)
12541293 return cret
12551294 }
12561295
@@ -1264,7 +1303,20 @@ var xThreadTryNew func(string, uintptr, uintptr, **Error) *Thread
12641303 func ThreadTryNew(NameVar string, FuncVar *ThreadFunc, DataVar uintptr) (*Thread, error) {
12651304 var cerr *Error
12661305
1267- cret := xThreadTryNew(NameVar, NewCallback(FuncVar), DataVar, &cerr)
1306+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1307+ 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)
1314+ }
1315+ FuncVarRef = purego.NewCallback(fcb)
1316+ SaveCallback(FuncVarPtr, FuncVarRef)
1317+ }
1318+
1319+ cret := xThreadTryNew(NameVar, FuncVarRef, DataVar, &cerr)
12681320 if cerr == nil {
12691321 return cret, nil
12701322 }
@@ -2160,7 +2212,20 @@ var xPrivateNew func(uintptr) *Private
21602212 // Creates a new #GPrivate.
21612213 func PrivateNew(NotifyVar *DestroyNotify) *Private {
21622214
2163- cret := xPrivateNew(NewCallback(NotifyVar))
2215+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
2216+ 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)
2223+ }
2224+ NotifyVarRef = purego.NewCallback(fcb)
2225+ SaveCallback(NotifyVarPtr, NotifyVarRef)
2226+ }
2227+
2228+ cret := xPrivateNew(NotifyVarRef)
21642229 return cret
21652230 }
21662231
@@ -2181,7 +2246,20 @@ var xThreadCreate func(uintptr, uintptr, bool, **Error) *Thread
21812246 func ThreadCreate(FuncVar *ThreadFunc, DataVar uintptr, JoinableVar bool) (*Thread, error) {
21822247 var cerr *Error
21832248
2184- cret := xThreadCreate(NewCallback(FuncVar), DataVar, JoinableVar, &cerr)
2249+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
2250+ 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)
2257+ }
2258+ FuncVarRef = purego.NewCallback(fcb)
2259+ SaveCallback(FuncVarPtr, FuncVarRef)
2260+ }
2261+
2262+ cret := xThreadCreate(FuncVarRef, DataVar, JoinableVar, &cerr)
21852263 if cerr == nil {
21862264 return cret, nil
21872265 }
@@ -2195,7 +2273,20 @@ var xThreadCreateFull func(uintptr, uintptr, uint32, bool, bool, ThreadPriority,
21952273 func ThreadCreateFull(FuncVar *ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (*Thread, error) {
21962274 var cerr *Error
21972275
2198- cret := xThreadCreateFull(NewCallback(FuncVar), DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, &cerr)
2276+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
2277+ 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)
2284+ }
2285+ FuncVarRef = purego.NewCallback(fcb)
2286+ SaveCallback(FuncVarPtr, FuncVarRef)
2287+ }
2288+
2289+ cret := xThreadCreateFull(FuncVarRef, DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, &cerr)
21992290 if cerr == nil {
22002291 return cret, nil
22012292 }
@@ -2239,7 +2330,20 @@ var xThreadForeach func(uintptr, uintptr)
22392330 // which is quadratic in the number of existing threads.
22402331 func ThreadForeach(ThreadFuncVar *Func, UserDataVar uintptr) {
22412332
2242- xThreadForeach(NewCallback(ThreadFuncVar), UserDataVar)
2333+ ThreadFuncVarPtr := uintptr(unsafe.Pointer(ThreadFuncVar))
2334+ 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)
2341+ }
2342+ ThreadFuncVarRef = purego.NewCallback(fcb)
2343+ SaveCallback(ThreadFuncVarPtr, ThreadFuncVarRef)
2344+ }
2345+
2346+ xThreadForeach(ThreadFuncVarRef, UserDataVar)
22432347
22442348 }
22452349
M v4/glib/gthreadpool.go +14 -1
@@ -172,7 +172,20 @@ var xThreadPoolSetSortFunction func(uintptr, uintptr, uintptr)
172172 // created.
173173 func (x *ThreadPool) SetSortFunction(FuncVar *CompareDataFunc, UserDataVar uintptr) {
174174
175- xThreadPoolSetSortFunction(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
175+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
176+ 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)
183+ }
184+ FuncVarRef = purego.NewCallback(fcb)
185+ SaveCallback(FuncVarPtr, FuncVarRef)
186+ }
187+
188+ xThreadPoolSetSortFunction(x.GoPointer(), FuncVarRef, UserDataVar)
176189
177190 }
178191
M v4/glib/gtree.go +138 -8
@@ -44,7 +44,20 @@ var xNewTree func(uintptr) *Tree
4444 // Creates a new #GTree.
4545 func NewTree(KeyCompareFuncVar *CompareFunc) *Tree {
4646
47- cret := xNewTree(NewCallback(KeyCompareFuncVar))
47+ KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
48+ 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)
55+ }
56+ KeyCompareFuncVarRef = purego.NewCallback(fcb)
57+ SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
58+ }
59+
60+ cret := xNewTree(KeyCompareFuncVarRef)
4861 return cret
4962 }
5063
@@ -55,7 +68,46 @@ var xNewTreeFull func(uintptr, uintptr, uintptr, uintptr) *Tree
5568 // removing the entry from the #GTree.
5669 func NewTreeFull(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar *DestroyNotify, ValueDestroyFuncVar *DestroyNotify) *Tree {
5770
58- cret := xNewTreeFull(NewCallback(KeyCompareFuncVar), KeyCompareDataVar, NewCallback(KeyDestroyFuncVar), NewCallback(ValueDestroyFuncVar))
71+ KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
72+ 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)
79+ }
80+ KeyCompareFuncVarRef = purego.NewCallback(fcb)
81+ SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
82+ }
83+
84+ KeyDestroyFuncVarPtr := uintptr(unsafe.Pointer(KeyDestroyFuncVar))
85+ 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)
92+ }
93+ KeyDestroyFuncVarRef = purego.NewCallback(fcb)
94+ SaveCallback(KeyDestroyFuncVarPtr, KeyDestroyFuncVarRef)
95+ }
96+
97+ ValueDestroyFuncVarPtr := uintptr(unsafe.Pointer(ValueDestroyFuncVar))
98+ 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)
105+ }
106+ ValueDestroyFuncVarRef = purego.NewCallback(fcb)
107+ SaveCallback(ValueDestroyFuncVarPtr, ValueDestroyFuncVarRef)
108+ }
109+
110+ cret := xNewTreeFull(KeyCompareFuncVarRef, KeyCompareDataVar, KeyDestroyFuncVarRef, ValueDestroyFuncVarRef)
59111 return cret
60112 }
61113
@@ -65,7 +117,20 @@ var xNewTreeWithData func(uintptr, uintptr) *Tree
65117 // See g_tree_new() for more details.
66118 func NewTreeWithData(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr) *Tree {
67119
68- cret := xNewTreeWithData(NewCallback(KeyCompareFuncVar), KeyCompareDataVar)
120+ KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
121+ 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)
128+ }
129+ KeyCompareFuncVarRef = purego.NewCallback(fcb)
130+ SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
131+ }
132+
133+ cret := xNewTreeWithData(KeyCompareFuncVarRef, KeyCompareDataVar)
69134 return cret
70135 }
71136
@@ -95,7 +160,20 @@ var xTreeForeach func(uintptr, uintptr, uintptr)
95160 // the tree, then walk the list and remove each item.
96161 func (x *Tree) Foreach(FuncVar *TraverseFunc, UserDataVar uintptr) {
97162
98- xTreeForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
163+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
164+ 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)
171+ }
172+ FuncVarRef = purego.NewCallback(fcb)
173+ SaveCallback(FuncVarPtr, FuncVarRef)
174+ }
175+
176+ xTreeForeach(x.GoPointer(), FuncVarRef, UserDataVar)
99177
100178 }
101179
@@ -111,7 +189,20 @@ var xTreeForeachNode func(uintptr, uintptr, uintptr)
111189 // the tree, then walk the list and remove each item.
112190 func (x *Tree) ForeachNode(FuncVar *TraverseNodeFunc, UserDataVar uintptr) {
113191
114- xTreeForeachNode(x.GoPointer(), NewCallback(FuncVar), UserDataVar)
192+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
193+ 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)
200+ }
201+ FuncVarRef = purego.NewCallback(fcb)
202+ SaveCallback(FuncVarPtr, FuncVarRef)
203+ }
204+
205+ xTreeForeachNode(x.GoPointer(), FuncVarRef, UserDataVar)
115206
116207 }
117208
@@ -317,7 +408,20 @@ var xTreeSearch func(uintptr, uintptr, uintptr) uintptr
317408 // pairs that have a larger key.
318409 func (x *Tree) Search(SearchFuncVar *CompareFunc, UserDataVar uintptr) uintptr {
319410
320- cret := xTreeSearch(x.GoPointer(), NewCallback(SearchFuncVar), UserDataVar)
411+ SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
412+ 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)
419+ }
420+ SearchFuncVarRef = purego.NewCallback(fcb)
421+ SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
422+ }
423+
424+ cret := xTreeSearch(x.GoPointer(), SearchFuncVarRef, UserDataVar)
321425 return cret
322426 }
323427
@@ -334,7 +438,20 @@ var xTreeSearchNode func(uintptr, uintptr, uintptr) *TreeNode
334438 // pairs that have a larger key.
335439 func (x *Tree) SearchNode(SearchFuncVar *CompareFunc, UserDataVar uintptr) *TreeNode {
336440
337- cret := xTreeSearchNode(x.GoPointer(), NewCallback(SearchFuncVar), UserDataVar)
441+ SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
442+ 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)
449+ }
450+ SearchFuncVarRef = purego.NewCallback(fcb)
451+ SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
452+ }
453+
454+ cret := xTreeSearchNode(x.GoPointer(), SearchFuncVarRef, UserDataVar)
338455 return cret
339456 }
340457
@@ -355,7 +472,20 @@ var xTreeTraverse func(uintptr, uintptr, TraverseType, uintptr)
355472 // Calls the given function for each node in the #GTree.
356473 func (x *Tree) Traverse(TraverseFuncVar *TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {
357474
358- xTreeTraverse(x.GoPointer(), NewCallback(TraverseFuncVar), TraverseTypeVar, UserDataVar)
475+ TraverseFuncVarPtr := uintptr(unsafe.Pointer(TraverseFuncVar))
476+ 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)
483+ }
484+ TraverseFuncVarRef = purego.NewCallback(fcb)
485+ SaveCallback(TraverseFuncVarPtr, TraverseFuncVarRef)
486+ }
487+
488+ xTreeTraverse(x.GoPointer(), TraverseFuncVarRef, TraverseTypeVar, UserDataVar)
359489
360490 }
361491
M v4/glib/gutils.go +14 -1
@@ -121,7 +121,20 @@ var xAtexit func(uintptr)
121121 // program.
122122 func Atexit(FuncVar *VoidFunc) {
123123
124- xAtexit(NewCallback(FuncVar))
124+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
125+ var FuncVarRef uintptr
126+ if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
127+ FuncVarRef = cbRefPtr
128+ } else {
129+ fcb := func() {
130+ cbFn := *FuncVar
131+ cbFn()
132+ }
133+ FuncVarRef = purego.NewCallback(fcb)
134+ SaveCallback(FuncVarPtr, FuncVarRef)
135+ }
136+
137+ xAtexit(FuncVarRef)
125138
126139 }
127140
M v4/glib/gvariant.go +14 -1
@@ -466,7 +466,20 @@ var xNewVariantFromData func(*VariantType, []byte, uint, bool, uintptr, uintptr)
466466 // process.
467467 func NewVariantFromData(TypeVar *VariantType, DataVar []byte, SizeVar uint, TrustedVar bool, NotifyVar *DestroyNotify, UserDataVar uintptr) *Variant {
468468
469- cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, NewCallback(NotifyVar), UserDataVar)
469+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
470+ 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)
477+ }
478+ NotifyVarRef = purego.NewCallback(fcb)
479+ SaveCallback(NotifyVarPtr, NotifyVarRef)
480+ }
481+
482+ cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, NotifyVarRef, UserDataVar)
470483 return cret
471484 }
472485
M v4/gobject/gbindinggroup.go +46 -1
@@ -2,6 +2,8 @@
22 package gobject
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -71,7 +73,50 @@ var xBindingGroupBindFull func(uintptr, string, uintptr, string, BindingFlags, u
7173 // See g_object_bind_property_full() for more information.
7274 func (x *BindingGroup) BindFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, UserDataDestroyVar *glib.DestroyNotify) {
7375
74- xBindingGroupBindFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, glib.NewCallbackNullable(TransformToVar), glib.NewCallbackNullable(TransformFromVar), UserDataVar, glib.NewCallback(UserDataDestroyVar))
76+ var TransformToVarRef uintptr
77+ if TransformToVar != nil {
78+ TransformToVarPtr := uintptr(unsafe.Pointer(TransformToVar))
79+ if cbRefPtr, ok := glib.GetCallback(TransformToVarPtr); ok {
80+ TransformToVarRef = cbRefPtr
81+ } else {
82+ fcb := func(arg0 uintptr, arg1 *Value, arg2 *Value, arg3 uintptr) bool {
83+ cbFn := *TransformToVar
84+ return cbFn(arg0, arg1, arg2, arg3)
85+ }
86+ TransformToVarRef = purego.NewCallback(fcb)
87+ glib.SaveCallback(TransformToVarPtr, TransformToVarRef)
88+ }
89+ }
90+
91+ var TransformFromVarRef uintptr
92+ if TransformFromVar != nil {
93+ TransformFromVarPtr := uintptr(unsafe.Pointer(TransformFromVar))
94+ if cbRefPtr, ok := glib.GetCallback(TransformFromVarPtr); ok {
95+ TransformFromVarRef = cbRefPtr
96+ } else {
97+ fcb := func(arg0 uintptr, arg1 *Value, arg2 *Value, arg3 uintptr) bool {
98+ cbFn := *TransformFromVar
99+ return cbFn(arg0, arg1, arg2, arg3)
100+ }
101+ TransformFromVarRef = purego.NewCallback(fcb)
102+ glib.SaveCallback(TransformFromVarPtr, TransformFromVarRef)
103+ }
104+ }
105+
106+ UserDataDestroyVarPtr := uintptr(unsafe.Pointer(UserDataDestroyVar))
107+ 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)
114+ }
115+ UserDataDestroyVarRef = purego.NewCallback(fcb)
116+ glib.SaveCallback(UserDataDestroyVarPtr, UserDataDestroyVarRef)
117+ }
118+
119+ xBindingGroupBindFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, TransformToVarRef, TransformFromVarRef, UserDataVar, UserDataDestroyVarRef)
75120
76121 }
77122
M v4/gobject/gboxed.go +29 -1
@@ -2,6 +2,8 @@
22 package gobject
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -47,7 +49,33 @@ var xBoxedTypeRegisterStatic func(string, uintptr, uintptr) types.GType
4749 // will create the appropriate `*_get_type()` function for the boxed type.
4850 func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar *BoxedCopyFunc, BoxedFreeVar *BoxedFreeFunc) types.GType {
4951
50- cret := xBoxedTypeRegisterStatic(NameVar, glib.NewCallback(BoxedCopyVar), glib.NewCallback(BoxedFreeVar))
52+ BoxedCopyVarPtr := uintptr(unsafe.Pointer(BoxedCopyVar))
53+ 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)
60+ }
61+ BoxedCopyVarRef = purego.NewCallback(fcb)
62+ glib.SaveCallback(BoxedCopyVarPtr, BoxedCopyVarRef)
63+ }
64+
65+ BoxedFreeVarPtr := uintptr(unsafe.Pointer(BoxedFreeVar))
66+ 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)
73+ }
74+ BoxedFreeVarRef = purego.NewCallback(fcb)
75+ glib.SaveCallback(BoxedFreeVarPtr, BoxedFreeVarRef)
76+ }
77+
78+ cret := xBoxedTypeRegisterStatic(NameVar, BoxedCopyVarRef, BoxedFreeVarRef)
5179 return cret
5280 }
5381
M v4/gobject/gclosure.go +165 -9
@@ -203,7 +203,20 @@ var xClosureAddFinalizeNotifier func(uintptr, uintptr, uintptr)
203203 // notifiers will be run before the finalize notifiers.
204204 func (x *Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
205205
206- xClosureAddFinalizeNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))
206+ NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
207+ 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)
214+ }
215+ NotifyFuncVarRef = purego.NewCallback(fcb)
216+ glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
217+ }
218+
219+ xClosureAddFinalizeNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
207220
208221 }
209222
@@ -216,7 +229,20 @@ var xClosureAddInvalidateNotifier func(uintptr, uintptr, uintptr)
216229 // in an unspecified order.
217230 func (x *Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
218231
219- xClosureAddInvalidateNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))
232+ NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
233+ 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)
240+ }
241+ NotifyFuncVarRef = purego.NewCallback(fcb)
242+ glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
243+ }
244+
245+ xClosureAddInvalidateNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
220246
221247 }
222248
@@ -230,7 +256,33 @@ var xClosureAddMarshalGuards func(uintptr, uintptr, uintptr, uintptr, uintptr)
230256 // example of marshal guards.
231257 func (x *Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar *ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify) {
232258
233- xClosureAddMarshalGuards(x.GoPointer(), PreMarshalDataVar, glib.NewCallback(PreMarshalNotifyVar), PostMarshalDataVar, glib.NewCallback(PostMarshalNotifyVar))
259+ PreMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PreMarshalNotifyVar))
260+ 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)
267+ }
268+ PreMarshalNotifyVarRef = purego.NewCallback(fcb)
269+ glib.SaveCallback(PreMarshalNotifyVarPtr, PreMarshalNotifyVarRef)
270+ }
271+
272+ PostMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PostMarshalNotifyVar))
273+ 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)
280+ }
281+ PostMarshalNotifyVarRef = purego.NewCallback(fcb)
282+ glib.SaveCallback(PostMarshalNotifyVarPtr, PostMarshalNotifyVarRef)
283+ }
284+
285+ xClosureAddMarshalGuards(x.GoPointer(), PreMarshalDataVar, PreMarshalNotifyVarRef, PostMarshalDataVar, PostMarshalNotifyVarRef)
234286
235287 }
236288
@@ -283,7 +335,20 @@ var xClosureRemoveFinalizeNotifier func(uintptr, uintptr, uintptr)
283335 // Notice that notifiers are automatically removed after they are run.
284336 func (x *Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
285337
286- xClosureRemoveFinalizeNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))
338+ NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
339+ 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)
346+ }
347+ NotifyFuncVarRef = purego.NewCallback(fcb)
348+ glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
349+ }
350+
351+ xClosureRemoveFinalizeNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
287352
288353 }
289354
@@ -294,7 +359,20 @@ var xClosureRemoveInvalidateNotifier func(uintptr, uintptr, uintptr)
294359 // Notice that notifiers are automatically removed after they are run.
295360 func (x *Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
296361
297- xClosureRemoveInvalidateNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))
362+ NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
363+ 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)
370+ }
371+ NotifyFuncVarRef = purego.NewCallback(fcb)
372+ glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
373+ }
374+
375+ xClosureRemoveInvalidateNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
298376
299377 }
300378
@@ -312,7 +390,20 @@ var xClosureSetMarshal func(uintptr, uintptr)
312390 // See also: g_closure_set_meta_marshal()
313391 func (x *Closure) SetMarshal(MarshalVar *ClosureMarshal) {
314392
315- xClosureSetMarshal(x.GoPointer(), glib.NewCallback(MarshalVar))
393+ MarshalVarPtr := uintptr(unsafe.Pointer(MarshalVar))
394+ 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)
401+ }
402+ MarshalVarRef = purego.NewCallback(fcb)
403+ glib.SaveCallback(MarshalVarPtr, MarshalVarRef)
404+ }
405+
406+ xClosureSetMarshal(x.GoPointer(), MarshalVarRef)
316407
317408 }
318409
@@ -337,7 +428,20 @@ var xClosureSetMetaMarshal func(uintptr, uintptr, uintptr)
337428 // @marshal_data argument.
338429 func (x *Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar *ClosureMarshal) {
339430
340- xClosureSetMetaMarshal(x.GoPointer(), MarshalDataVar, glib.NewCallback(MetaMarshalVar))
431+ MetaMarshalVarPtr := uintptr(unsafe.Pointer(MetaMarshalVar))
432+ 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)
439+ }
440+ MetaMarshalVarRef = purego.NewCallback(fcb)
441+ glib.SaveCallback(MetaMarshalVarPtr, MetaMarshalVarRef)
442+ }
443+
444+ xClosureSetMetaMarshal(x.GoPointer(), MarshalDataVar, MetaMarshalVarRef)
341445
342446 }
343447
@@ -467,7 +571,33 @@ var xCclosureNew func(uintptr, uintptr, uintptr) *Closure
467571 // @destroy_data will be called as a finalize notifier on the #GClosure.
468572 func CclosureNew(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {
469573
470- cret := xCclosureNew(glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallback(DestroyDataVar))
574+ CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
575+ var CallbackFuncVarRef uintptr
576+ if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
577+ CallbackFuncVarRef = cbRefPtr
578+ } else {
579+ fcb := func() {
580+ cbFn := *CallbackFuncVar
581+ cbFn()
582+ }
583+ CallbackFuncVarRef = purego.NewCallback(fcb)
584+ glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
585+ }
586+
587+ DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
588+ 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)
595+ }
596+ DestroyDataVarRef = purego.NewCallback(fcb)
597+ glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
598+ }
599+
600+ cret := xCclosureNew(CallbackFuncVarRef, UserDataVar, DestroyDataVarRef)
471601 return cret
472602 }
473603
@@ -479,7 +609,33 @@ var xCclosureNewSwap func(uintptr, uintptr, uintptr) *Closure
479609 // @destroy_data will be called as a finalize notifier on the #GClosure.
480610 func CclosureNewSwap(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {
481611
482- cret := xCclosureNewSwap(glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallback(DestroyDataVar))
612+ CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
613+ var CallbackFuncVarRef uintptr
614+ if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
615+ CallbackFuncVarRef = cbRefPtr
616+ } else {
617+ fcb := func() {
618+ cbFn := *CallbackFuncVar
619+ cbFn()
620+ }
621+ CallbackFuncVarRef = purego.NewCallback(fcb)
622+ glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
623+ }
624+
625+ DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
626+ 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)
633+ }
634+ DestroyDataVarRef = purego.NewCallback(fcb)
635+ glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
636+ }
637+
638+ cret := xCclosureNewSwap(CallbackFuncVarRef, UserDataVar, DestroyDataVarRef)
483639 return cret
484640 }
485641
M v4/gobject/gobject.go +240 -14
@@ -931,7 +931,20 @@ var xCclosureNewObject func(uintptr, uintptr) *Closure
931931 // after the object is is freed.
932932 func CclosureNewObject(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {
933933
934- cret := xCclosureNewObject(glib.NewCallback(CallbackFuncVar), ObjectVar.GoPointer())
934+ CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
935+ var CallbackFuncVarRef uintptr
936+ if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
937+ CallbackFuncVarRef = cbRefPtr
938+ } else {
939+ fcb := func() {
940+ cbFn := *CallbackFuncVar
941+ cbFn()
942+ }
943+ CallbackFuncVarRef = purego.NewCallback(fcb)
944+ glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
945+ }
946+
947+ cret := xCclosureNewObject(CallbackFuncVarRef, ObjectVar.GoPointer())
935948 return cret
936949 }
937950
@@ -944,7 +957,20 @@ var xCclosureNewObjectSwap func(uintptr, uintptr) *Closure
944957 // after the object is is freed.
945958 func CclosureNewObjectSwap(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {
946959
947- cret := xCclosureNewObjectSwap(glib.NewCallback(CallbackFuncVar), ObjectVar.GoPointer())
960+ CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
961+ var CallbackFuncVarRef uintptr
962+ if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
963+ CallbackFuncVarRef = cbRefPtr
964+ } else {
965+ fcb := func() {
966+ cbFn := *CallbackFuncVar
967+ cbFn()
968+ }
969+ CallbackFuncVarRef = purego.NewCallback(fcb)
970+ glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
971+ }
972+
973+ cret := xCclosureNewObjectSwap(CallbackFuncVarRef, ObjectVar.GoPointer())
948974 return cret
949975 }
950976
@@ -986,7 +1012,20 @@ var xSignalConnectObject func(*TypeInstance, string, uintptr, uintptr, ConnectFl
9861012 // details.
9871013 func SignalConnectObject(InstanceVar *TypeInstance, DetailedSignalVar string, CHandlerVar *Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {
9881014
989- cret := xSignalConnectObject(InstanceVar, DetailedSignalVar, glib.NewCallback(CHandlerVar), GobjectVar.GoPointer(), ConnectFlagsVar)
1015+ CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
1016+ var CHandlerVarRef uintptr
1017+ if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
1018+ CHandlerVarRef = cbRefPtr
1019+ } else {
1020+ fcb := func() {
1021+ cbFn := *CHandlerVar
1022+ cbFn()
1023+ }
1024+ CHandlerVarRef = purego.NewCallback(fcb)
1025+ glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
1026+ }
1027+
1028+ cret := xSignalConnectObject(InstanceVar, DetailedSignalVar, CHandlerVarRef, GobjectVar.GoPointer(), ConnectFlagsVar)
9901029 return cret
9911030 }
9921031
@@ -1198,7 +1237,20 @@ var xObjectAddToggleRef func(uintptr, uintptr, uintptr)
11981237 // A g_object_add_toggle_ref() must be released with g_object_remove_toggle_ref().
11991238 func (x *Object) AddToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {
12001239
1201- xObjectAddToggleRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)
1240+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1241+ 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)
1248+ }
1249+ NotifyVarRef = purego.NewCallback(fcb)
1250+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1251+ }
1252+
1253+ xObjectAddToggleRef(x.GoPointer(), NotifyVarRef, DataVar)
12021254
12031255 }
12041256
@@ -1298,7 +1350,52 @@ var xObjectBindPropertyFull func(uintptr, string, uintptr, string, BindingFlags,
12981350 func (x *Object) BindPropertyFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) *Binding {
12991351 var cls *Binding
13001352
1301- cret := xObjectBindPropertyFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, glib.NewCallbackNullable(TransformToVar), glib.NewCallbackNullable(TransformFromVar), UserDataVar, glib.NewCallbackNullable(NotifyVar))
1353+ var TransformToVarRef uintptr
1354+ if TransformToVar != nil {
1355+ TransformToVarPtr := uintptr(unsafe.Pointer(TransformToVar))
1356+ if cbRefPtr, ok := glib.GetCallback(TransformToVarPtr); ok {
1357+ TransformToVarRef = cbRefPtr
1358+ } else {
1359+ fcb := func(arg0 uintptr, arg1 *Value, arg2 *Value, arg3 uintptr) bool {
1360+ cbFn := *TransformToVar
1361+ return cbFn(arg0, arg1, arg2, arg3)
1362+ }
1363+ TransformToVarRef = purego.NewCallback(fcb)
1364+ glib.SaveCallback(TransformToVarPtr, TransformToVarRef)
1365+ }
1366+ }
1367+
1368+ var TransformFromVarRef uintptr
1369+ if TransformFromVar != nil {
1370+ TransformFromVarPtr := uintptr(unsafe.Pointer(TransformFromVar))
1371+ if cbRefPtr, ok := glib.GetCallback(TransformFromVarPtr); ok {
1372+ TransformFromVarRef = cbRefPtr
1373+ } else {
1374+ fcb := func(arg0 uintptr, arg1 *Value, arg2 *Value, arg3 uintptr) bool {
1375+ cbFn := *TransformFromVar
1376+ return cbFn(arg0, arg1, arg2, arg3)
1377+ }
1378+ TransformFromVarRef = purego.NewCallback(fcb)
1379+ glib.SaveCallback(TransformFromVarPtr, TransformFromVarRef)
1380+ }
1381+ }
1382+
1383+ var NotifyVarRef uintptr
1384+ if NotifyVar != nil {
1385+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1386+ if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
1387+ NotifyVarRef = cbRefPtr
1388+ } else {
1389+ fcb := func(arg0 uintptr) {
1390+ cbFn := *NotifyVar
1391+ cbFn(arg0)
1392+ }
1393+ NotifyVarRef = purego.NewCallback(fcb)
1394+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1395+ }
1396+ }
1397+
1398+ cret := xObjectBindPropertyFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, TransformToVarRef, TransformFromVarRef, UserDataVar, NotifyVarRef)
13021399
13031400 if cret == 0 {
13041401 return nil
@@ -1407,7 +1504,22 @@ var xObjectDupData func(uintptr, string, uintptr, uintptr) uintptr
14071504 // object.
14081505 func (x *Object) DupData(KeyVar string, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr {
14091506
1410- cret := xObjectDupData(x.GoPointer(), KeyVar, glib.NewCallbackNullable(DupFuncVar), UserDataVar)
1507+ var DupFuncVarRef uintptr
1508+ if DupFuncVar != nil {
1509+ DupFuncVarPtr := uintptr(unsafe.Pointer(DupFuncVar))
1510+ if cbRefPtr, ok := glib.GetCallback(DupFuncVarPtr); ok {
1511+ DupFuncVarRef = cbRefPtr
1512+ } else {
1513+ fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
1514+ cbFn := *DupFuncVar
1515+ return cbFn(arg0, arg1)
1516+ }
1517+ DupFuncVarRef = purego.NewCallback(fcb)
1518+ glib.SaveCallback(DupFuncVarPtr, DupFuncVarRef)
1519+ }
1520+ }
1521+
1522+ cret := xObjectDupData(x.GoPointer(), KeyVar, DupFuncVarRef, UserDataVar)
14111523 return cret
14121524 }
14131525
@@ -1429,7 +1541,22 @@ var xObjectDupQdata func(uintptr, glib.Quark, uintptr, uintptr) uintptr
14291541 // object.
14301542 func (x *Object) DupQdata(QuarkVar glib.Quark, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr {
14311543
1432- cret := xObjectDupQdata(x.GoPointer(), QuarkVar, glib.NewCallbackNullable(DupFuncVar), UserDataVar)
1544+ var DupFuncVarRef uintptr
1545+ if DupFuncVar != nil {
1546+ DupFuncVarPtr := uintptr(unsafe.Pointer(DupFuncVar))
1547+ if cbRefPtr, ok := glib.GetCallback(DupFuncVarPtr); ok {
1548+ DupFuncVarRef = cbRefPtr
1549+ } else {
1550+ fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
1551+ cbFn := *DupFuncVar
1552+ return cbFn(arg0, arg1)
1553+ }
1554+ DupFuncVarRef = purego.NewCallback(fcb)
1555+ glib.SaveCallback(DupFuncVarPtr, DupFuncVarRef)
1556+ }
1557+ }
1558+
1559+ cret := xObjectDupQdata(x.GoPointer(), QuarkVar, DupFuncVarRef, UserDataVar)
14331560 return cret
14341561 }
14351562
@@ -1703,7 +1830,20 @@ var xObjectRemoveToggleRef func(uintptr, uintptr, uintptr)
17031830 // you must take care of that yourself.
17041831 func (x *Object) RemoveToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {
17051832
1706- xObjectRemoveToggleRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)
1833+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1834+ 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)
1841+ }
1842+ NotifyVarRef = purego.NewCallback(fcb)
1843+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1844+ }
1845+
1846+ xObjectRemoveToggleRef(x.GoPointer(), NotifyVarRef, DataVar)
17071847
17081848 }
17091849
@@ -1738,7 +1878,22 @@ var xObjectReplaceData func(uintptr, string, uintptr, uintptr, uintptr, *glib.De
17381878 // for @key.
17391879 func (x *Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
17401880
1741- cret := xObjectReplaceData(x.GoPointer(), KeyVar, OldvalVar, NewvalVar, glib.NewCallbackNullable(DestroyVar), OldDestroyVar)
1881+ var DestroyVarRef uintptr
1882+ if DestroyVar != nil {
1883+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
1884+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
1885+ DestroyVarRef = cbRefPtr
1886+ } else {
1887+ fcb := func(arg0 uintptr) {
1888+ cbFn := *DestroyVar
1889+ cbFn(arg0)
1890+ }
1891+ DestroyVarRef = purego.NewCallback(fcb)
1892+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
1893+ }
1894+ }
1895+
1896+ cret := xObjectReplaceData(x.GoPointer(), KeyVar, OldvalVar, NewvalVar, DestroyVarRef, OldDestroyVar)
17421897 return cret
17431898 }
17441899
@@ -1759,7 +1914,22 @@ var xObjectReplaceQdata func(uintptr, glib.Quark, uintptr, uintptr, uintptr, *gl
17591914 // should not destroy the object in the normal way.
17601915 func (x *Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
17611916
1762- cret := xObjectReplaceQdata(x.GoPointer(), QuarkVar, OldvalVar, NewvalVar, glib.NewCallbackNullable(DestroyVar), OldDestroyVar)
1917+ var DestroyVarRef uintptr
1918+ if DestroyVar != nil {
1919+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
1920+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
1921+ DestroyVarRef = cbRefPtr
1922+ } else {
1923+ fcb := func(arg0 uintptr) {
1924+ cbFn := *DestroyVar
1925+ cbFn(arg0)
1926+ }
1927+ DestroyVarRef = purego.NewCallback(fcb)
1928+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
1929+ }
1930+ }
1931+
1932+ cret := xObjectReplaceQdata(x.GoPointer(), QuarkVar, OldvalVar, NewvalVar, DestroyVarRef, OldDestroyVar)
17631933 return cret
17641934 }
17651935
@@ -1820,7 +1990,22 @@ var xObjectSetDataFull func(uintptr, string, uintptr, uintptr)
18201990 // Note that the @destroy callback is not called if @data is %NULL.
18211991 func (x *Object) SetDataFull(KeyVar string, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
18221992
1823- xObjectSetDataFull(x.GoPointer(), KeyVar, DataVar, glib.NewCallbackNullable(DestroyVar))
1993+ var DestroyVarRef uintptr
1994+ if DestroyVar != nil {
1995+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
1996+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
1997+ DestroyVarRef = cbRefPtr
1998+ } else {
1999+ fcb := func(arg0 uintptr) {
2000+ cbFn := *DestroyVar
2001+ cbFn(arg0)
2002+ }
2003+ DestroyVarRef = purego.NewCallback(fcb)
2004+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
2005+ }
2006+ }
2007+
2008+ xObjectSetDataFull(x.GoPointer(), KeyVar, DataVar, DestroyVarRef)
18242009
18252010 }
18262011
@@ -1858,7 +2043,22 @@ var xObjectSetQdataFull func(uintptr, glib.Quark, uintptr, uintptr)
18582043 // with the same @quark.
18592044 func (x *Object) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
18602045
1861- xObjectSetQdataFull(x.GoPointer(), QuarkVar, DataVar, glib.NewCallbackNullable(DestroyVar))
2046+ var DestroyVarRef uintptr
2047+ if DestroyVar != nil {
2048+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
2049+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
2050+ DestroyVarRef = cbRefPtr
2051+ } else {
2052+ fcb := func(arg0 uintptr) {
2053+ cbFn := *DestroyVar
2054+ cbFn(arg0)
2055+ }
2056+ DestroyVarRef = purego.NewCallback(fcb)
2057+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
2058+ }
2059+ }
2060+
2061+ xObjectSetQdataFull(x.GoPointer(), QuarkVar, DataVar, DestroyVarRef)
18622062
18632063 }
18642064
@@ -2054,7 +2254,20 @@ var xObjectWeakRef func(uintptr, uintptr, uintptr)
20542254 // Use #GWeakRef if thread-safety is required.
20552255 func (x *Object) WeakRef(NotifyVar *WeakNotify, DataVar uintptr) {
20562256
2057- xObjectWeakRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)
2257+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
2258+ 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)
2265+ }
2266+ NotifyVarRef = purego.NewCallback(fcb)
2267+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
2268+ }
2269+
2270+ xObjectWeakRef(x.GoPointer(), NotifyVarRef, DataVar)
20582271
20592272 }
20602273
@@ -2063,7 +2276,20 @@ var xObjectWeakUnref func(uintptr, uintptr, uintptr)
20632276 // Removes a weak reference callback to an object.
20642277 func (x *Object) WeakUnref(NotifyVar *WeakNotify, DataVar uintptr) {
20652278
2066- xObjectWeakUnref(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)
2279+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
2280+ 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)
2287+ }
2288+ NotifyVarRef = purego.NewCallback(fcb)
2289+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
2290+ }
2291+
2292+ xObjectWeakUnref(x.GoPointer(), NotifyVarRef, DataVar)
20672293
20682294 }
20692295
M v4/gobject/gparam.go +16 -1
@@ -770,7 +770,22 @@ var xParamSpecSetQdataFull func(uintptr, glib.Quark, uintptr, uintptr)
770770 // g_param_spec_set_qdata() with the same @quark.
771771 func (x *ParamSpec) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
772772
773- xParamSpecSetQdataFull(x.GoPointer(), QuarkVar, DataVar, glib.NewCallbackNullable(DestroyVar))
773+ var DestroyVarRef uintptr
774+ if DestroyVar != nil {
775+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
776+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
777+ DestroyVarRef = cbRefPtr
778+ } else {
779+ fcb := func(arg0 uintptr) {
780+ cbFn := *DestroyVar
781+ cbFn(arg0)
782+ }
783+ DestroyVarRef = purego.NewCallback(fcb)
784+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
785+ }
786+ }
787+
788+ xParamSpecSetQdataFull(x.GoPointer(), QuarkVar, DataVar, DestroyVarRef)
774789
775790 }
776791
M v4/gobject/gsignal.go +151 -7
@@ -228,7 +228,35 @@ var xSignalAddEmissionHook func(uint, glib.Quark, uintptr, uintptr, uintptr) uin
228228 // for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
229229 func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar *SignalEmissionHook, HookDataVar uintptr, DataDestroyVar *glib.DestroyNotify) uint32 {
230230
231- cret := xSignalAddEmissionHook(SignalIdVar, DetailVar, glib.NewCallback(HookFuncVar), HookDataVar, glib.NewCallbackNullable(DataDestroyVar))
231+ HookFuncVarPtr := uintptr(unsafe.Pointer(HookFuncVar))
232+ 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)
239+ }
240+ HookFuncVarRef = purego.NewCallback(fcb)
241+ glib.SaveCallback(HookFuncVarPtr, HookFuncVarRef)
242+ }
243+
244+ var DataDestroyVarRef uintptr
245+ if DataDestroyVar != nil {
246+ DataDestroyVarPtr := uintptr(unsafe.Pointer(DataDestroyVar))
247+ if cbRefPtr, ok := glib.GetCallback(DataDestroyVarPtr); ok {
248+ DataDestroyVarRef = cbRefPtr
249+ } else {
250+ fcb := func(arg0 uintptr) {
251+ cbFn := *DataDestroyVar
252+ cbFn(arg0)
253+ }
254+ DataDestroyVarRef = purego.NewCallback(fcb)
255+ glib.SaveCallback(DataDestroyVarPtr, DataDestroyVarRef)
256+ }
257+ }
258+
259+ cret := xSignalAddEmissionHook(SignalIdVar, DetailVar, HookFuncVarRef, HookDataVar, DataDestroyVarRef)
232260 return cret
233261 }
234262
@@ -313,7 +341,35 @@ var xSignalConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectF
313341 // details.
314342 func SignalConnectData(InstanceVar *Object, DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {
315343
316- cret := xSignalConnectData(InstanceVar.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar, glib.NewCallbackNullable(DestroyDataVar), ConnectFlagsVar)
344+ CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
345+ var CHandlerVarRef uintptr
346+ if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
347+ CHandlerVarRef = cbRefPtr
348+ } else {
349+ fcb := func() {
350+ cbFn := *CHandlerVar
351+ cbFn()
352+ }
353+ CHandlerVarRef = purego.NewCallback(fcb)
354+ glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
355+ }
356+
357+ var DestroyDataVarRef uintptr
358+ if DestroyDataVar != nil {
359+ DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
360+ if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
361+ DestroyDataVarRef = cbRefPtr
362+ } else {
363+ fcb := func(arg0 uintptr, arg1 *Closure) {
364+ cbFn := *DestroyDataVar
365+ cbFn(arg0, arg1)
366+ }
367+ DestroyDataVarRef = purego.NewCallback(fcb)
368+ glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
369+ }
370+ }
371+
372+ cret := xSignalConnectData(InstanceVar.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar, DestroyDataVarRef, ConnectFlagsVar)
317373 return cret
318374 }
319375
@@ -634,7 +690,22 @@ var xSignalNew func(string, types.GType, SignalFlags, uint, uintptr, uintptr, ui
634690 // be used.
635691 func SignalNew(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassOffsetVar uint, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, varArgs ...interface{}) uint {
636692
637- cret := xSignalNew(SignalNameVar, ItypeVar, SignalFlagsVar, ClassOffsetVar, glib.NewCallbackNullable(AccumulatorVar), AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, varArgs...)
693+ var AccumulatorVarRef uintptr
694+ if AccumulatorVar != nil {
695+ AccumulatorVarPtr := uintptr(unsafe.Pointer(AccumulatorVar))
696+ if cbRefPtr, ok := glib.GetCallback(AccumulatorVarPtr); ok {
697+ AccumulatorVarRef = cbRefPtr
698+ } else {
699+ fcb := func(arg0 *SignalInvocationHint, arg1 *Value, arg2 *Value, arg3 uintptr) bool {
700+ cbFn := *AccumulatorVar
701+ return cbFn(arg0, arg1, arg2, arg3)
702+ }
703+ AccumulatorVarRef = purego.NewCallback(fcb)
704+ glib.SaveCallback(AccumulatorVarPtr, AccumulatorVarRef)
705+ }
706+ }
707+
708+ cret := xSignalNew(SignalNameVar, ItypeVar, SignalFlagsVar, ClassOffsetVar, AccumulatorVarRef, AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, varArgs...)
638709 return cret
639710 }
640711
@@ -658,7 +729,37 @@ var xSignalNewClassHandler func(string, types.GType, SignalFlags, uintptr, uintp
658729 // the marshaller for this signal.
659730 func SignalNewClassHandler(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassHandlerVar *Callback, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, varArgs ...interface{}) uint {
660731
661- cret := xSignalNewClassHandler(SignalNameVar, ItypeVar, SignalFlagsVar, glib.NewCallbackNullable(ClassHandlerVar), glib.NewCallbackNullable(AccumulatorVar), AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, varArgs...)
732+ var ClassHandlerVarRef uintptr
733+ if ClassHandlerVar != nil {
734+ ClassHandlerVarPtr := uintptr(unsafe.Pointer(ClassHandlerVar))
735+ if cbRefPtr, ok := glib.GetCallback(ClassHandlerVarPtr); ok {
736+ ClassHandlerVarRef = cbRefPtr
737+ } else {
738+ fcb := func() {
739+ cbFn := *ClassHandlerVar
740+ cbFn()
741+ }
742+ ClassHandlerVarRef = purego.NewCallback(fcb)
743+ glib.SaveCallback(ClassHandlerVarPtr, ClassHandlerVarRef)
744+ }
745+ }
746+
747+ var AccumulatorVarRef uintptr
748+ if AccumulatorVar != nil {
749+ AccumulatorVarPtr := uintptr(unsafe.Pointer(AccumulatorVar))
750+ if cbRefPtr, ok := glib.GetCallback(AccumulatorVarPtr); ok {
751+ AccumulatorVarRef = cbRefPtr
752+ } else {
753+ fcb := func(arg0 *SignalInvocationHint, arg1 *Value, arg2 *Value, arg3 uintptr) bool {
754+ cbFn := *AccumulatorVar
755+ return cbFn(arg0, arg1, arg2, arg3)
756+ }
757+ AccumulatorVarRef = purego.NewCallback(fcb)
758+ glib.SaveCallback(AccumulatorVarPtr, AccumulatorVarRef)
759+ }
760+ }
761+
762+ cret := xSignalNewClassHandler(SignalNameVar, ItypeVar, SignalFlagsVar, ClassHandlerVarRef, AccumulatorVarRef, AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, varArgs...)
662763 return cret
663764 }
664765
@@ -672,7 +773,22 @@ var xSignalNewValist func(string, types.GType, SignalFlags, *Closure, uintptr, u
672773 // the marshaller for this signal.
673774 func SignalNewValist(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassClosureVar *Closure, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, ArgsVar []interface{}) uint {
674775
675- cret := xSignalNewValist(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, glib.NewCallbackNullable(AccumulatorVar), AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, ArgsVar)
776+ var AccumulatorVarRef uintptr
777+ if AccumulatorVar != nil {
778+ AccumulatorVarPtr := uintptr(unsafe.Pointer(AccumulatorVar))
779+ if cbRefPtr, ok := glib.GetCallback(AccumulatorVarPtr); ok {
780+ AccumulatorVarRef = cbRefPtr
781+ } else {
782+ fcb := func(arg0 *SignalInvocationHint, arg1 *Value, arg2 *Value, arg3 uintptr) bool {
783+ cbFn := *AccumulatorVar
784+ return cbFn(arg0, arg1, arg2, arg3)
785+ }
786+ AccumulatorVarRef = purego.NewCallback(fcb)
787+ glib.SaveCallback(AccumulatorVarPtr, AccumulatorVarRef)
788+ }
789+ }
790+
791+ cret := xSignalNewValist(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, AccumulatorVarRef, AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, ArgsVar)
676792 return cret
677793 }
678794
@@ -686,7 +802,22 @@ var xSignalNewv func(string, types.GType, SignalFlags, *Closure, uintptr, uintpt
686802 // the marshaller for this signal.
687803 func SignalNewv(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassClosureVar *Closure, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, ParamTypesVar []types.GType) uint {
688804
689- cret := xSignalNewv(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, glib.NewCallbackNullable(AccumulatorVar), AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, ParamTypesVar)
805+ var AccumulatorVarRef uintptr
806+ if AccumulatorVar != nil {
807+ AccumulatorVarPtr := uintptr(unsafe.Pointer(AccumulatorVar))
808+ if cbRefPtr, ok := glib.GetCallback(AccumulatorVarPtr); ok {
809+ AccumulatorVarRef = cbRefPtr
810+ } else {
811+ fcb := func(arg0 *SignalInvocationHint, arg1 *Value, arg2 *Value, arg3 uintptr) bool {
812+ cbFn := *AccumulatorVar
813+ return cbFn(arg0, arg1, arg2, arg3)
814+ }
815+ AccumulatorVarRef = purego.NewCallback(fcb)
816+ glib.SaveCallback(AccumulatorVarPtr, AccumulatorVarRef)
817+ }
818+ }
819+
820+ cret := xSignalNewv(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, AccumulatorVarRef, AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, ParamTypesVar)
690821 return cret
691822 }
692823
@@ -717,7 +848,20 @@ var xSignalOverrideClassHandler func(string, types.GType, uintptr)
717848 // parent class closure from inside the overridden one.
718849 func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar types.GType, ClassHandlerVar *Callback) {
719850
720- xSignalOverrideClassHandler(SignalNameVar, InstanceTypeVar, glib.NewCallback(ClassHandlerVar))
851+ ClassHandlerVarPtr := uintptr(unsafe.Pointer(ClassHandlerVar))
852+ var ClassHandlerVarRef uintptr
853+ if cbRefPtr, ok := glib.GetCallback(ClassHandlerVarPtr); ok {
854+ ClassHandlerVarRef = cbRefPtr
855+ } else {
856+ fcb := func() {
857+ cbFn := *ClassHandlerVar
858+ cbFn()
859+ }
860+ ClassHandlerVarRef = purego.NewCallback(fcb)
861+ glib.SaveCallback(ClassHandlerVarPtr, ClassHandlerVarRef)
862+ }
863+
864+ xSignalOverrideClassHandler(SignalNameVar, InstanceTypeVar, ClassHandlerVarRef)
721865
722866 }
723867
M v4/gobject/gsignalgroup.go +83 -5
@@ -82,7 +82,20 @@ var xSignalGroupConnect func(uintptr, string, uintptr, uintptr)
8282 // You cannot connect a signal handler after #GSignalGroup:target has been set.
8383 func (x *SignalGroup) Connect(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
8484
85- xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)
85+ CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
86+ var CHandlerVarRef uintptr
87+ if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
88+ CHandlerVarRef = cbRefPtr
89+ } else {
90+ fcb := func() {
91+ cbFn := *CHandlerVar
92+ cbFn()
93+ }
94+ CHandlerVarRef = purego.NewCallback(fcb)
95+ glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
96+ }
97+
98+ xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
8699
87100 }
88101
@@ -96,7 +109,20 @@ var xSignalGroupConnectAfter func(uintptr, string, uintptr, uintptr)
96109 // You cannot connect a signal handler after #GSignalGroup:target has been set.
97110 func (x *SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
98111
99- xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)
112+ CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
113+ var CHandlerVarRef uintptr
114+ if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
115+ CHandlerVarRef = cbRefPtr
116+ } else {
117+ fcb := func() {
118+ cbFn := *CHandlerVar
119+ cbFn()
120+ }
121+ CHandlerVarRef = purego.NewCallback(fcb)
122+ glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
123+ }
124+
125+ xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
100126
101127 }
102128
@@ -119,7 +145,33 @@ var xSignalGroupConnectData func(uintptr, string, uintptr, uintptr, uintptr, Con
119145 // You cannot connect a signal handler after #GSignalGroup:target has been set.
120146 func (x *SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {
121147
122- xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar, glib.NewCallback(NotifyVar), FlagsVar)
148+ CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
149+ var CHandlerVarRef uintptr
150+ if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
151+ CHandlerVarRef = cbRefPtr
152+ } else {
153+ fcb := func() {
154+ cbFn := *CHandlerVar
155+ cbFn()
156+ }
157+ CHandlerVarRef = purego.NewCallback(fcb)
158+ glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
159+ }
160+
161+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
162+ 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)
169+ }
170+ NotifyVarRef = purego.NewCallback(fcb)
171+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
172+ }
173+
174+ xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar, NotifyVarRef, FlagsVar)
123175
124176 }
125177
@@ -134,7 +186,20 @@ var xSignalGroupConnectObject func(uintptr, string, uintptr, uintptr, ConnectFla
134186 // You cannot connect a signal handler after #GSignalGroup:target has been set.
135187 func (x *SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar *Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {
136188
137- xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), ObjectVar, FlagsVar)
189+ CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
190+ var CHandlerVarRef uintptr
191+ if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
192+ CHandlerVarRef = cbRefPtr
193+ } else {
194+ fcb := func() {
195+ cbFn := *CHandlerVar
196+ cbFn()
197+ }
198+ CHandlerVarRef = purego.NewCallback(fcb)
199+ glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
200+ }
201+
202+ xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, ObjectVar, FlagsVar)
138203
139204 }
140205
@@ -149,7 +214,20 @@ var xSignalGroupConnectSwapped func(uintptr, string, uintptr, uintptr)
149214 // You cannot connect a signal handler after #GSignalGroup:target has been set.
150215 func (x *SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
151216
152- xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)
217+ CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
218+ var CHandlerVarRef uintptr
219+ if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
220+ CHandlerVarRef = cbRefPtr
221+ } else {
222+ fcb := func() {
223+ cbFn := *CHandlerVar
224+ cbFn()
225+ }
226+ CHandlerVarRef = purego.NewCallback(fcb)
227+ glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
228+ }
229+
230+ xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
153231
154232 }
155233
M v4/gobject/gtype.go +83 -5
@@ -810,7 +810,20 @@ var xTypeAddClassCacheFunc func(uintptr, uintptr)
810810 // chain.
811811 func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
812812
813- xTypeAddClassCacheFunc(CacheDataVar, glib.NewCallback(CacheFuncVar))
813+ CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
814+ 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)
821+ }
822+ CacheFuncVarRef = purego.NewCallback(fcb)
823+ glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
824+ }
825+
826+ xTypeAddClassCacheFunc(CacheDataVar, CacheFuncVarRef)
814827
815828 }
816829
@@ -853,7 +866,20 @@ var xTypeAddInterfaceCheck func(uintptr, uintptr)
853866 // interfaces.
854867 func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
855868
856- xTypeAddInterfaceCheck(CheckDataVar, glib.NewCallback(CheckFuncVar))
869+ CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
870+ 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)
877+ }
878+ CheckFuncVarRef = purego.NewCallback(fcb)
879+ glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
880+ }
881+
882+ xTypeAddInterfaceCheck(CheckDataVar, CheckFuncVarRef)
857883
858884 }
859885
@@ -1474,7 +1500,33 @@ var xTypeRegisterStaticSimple func(types.GType, string, uint, uintptr, uint, uin
14741500 // struct and calling g_type_register_static().
14751501 func TypeRegisterStaticSimple(ParentTypeVar types.GType, TypeNameVar string, ClassSizeVar uint, ClassInitVar *ClassInitFunc, InstanceSizeVar uint, InstanceInitVar *InstanceInitFunc, FlagsVar TypeFlags) types.GType {
14761502
1477- cret := xTypeRegisterStaticSimple(ParentTypeVar, TypeNameVar, ClassSizeVar, glib.NewCallback(ClassInitVar), InstanceSizeVar, glib.NewCallback(InstanceInitVar), FlagsVar)
1503+ ClassInitVarPtr := uintptr(unsafe.Pointer(ClassInitVar))
1504+ 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)
1511+ }
1512+ ClassInitVarRef = purego.NewCallback(fcb)
1513+ glib.SaveCallback(ClassInitVarPtr, ClassInitVarRef)
1514+ }
1515+
1516+ InstanceInitVarPtr := uintptr(unsafe.Pointer(InstanceInitVar))
1517+ 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)
1524+ }
1525+ InstanceInitVarRef = purego.NewCallback(fcb)
1526+ glib.SaveCallback(InstanceInitVarPtr, InstanceInitVarRef)
1527+ }
1528+
1529+ cret := xTypeRegisterStaticSimple(ParentTypeVar, TypeNameVar, ClassSizeVar, ClassInitVarRef, InstanceSizeVar, InstanceInitVarRef, FlagsVar)
14781530 return cret
14791531 }
14801532
@@ -1485,7 +1537,20 @@ var xTypeRemoveClassCacheFunc func(uintptr, uintptr)
14851537 // g_type_remove_class_cache_func() to avoid leaks.
14861538 func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
14871539
1488- xTypeRemoveClassCacheFunc(CacheDataVar, glib.NewCallback(CacheFuncVar))
1540+ CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
1541+ 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)
1548+ }
1549+ CacheFuncVarRef = purego.NewCallback(fcb)
1550+ glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
1551+ }
1552+
1553+ xTypeRemoveClassCacheFunc(CacheDataVar, CacheFuncVarRef)
14891554
14901555 }
14911556
@@ -1495,7 +1560,20 @@ var xTypeRemoveInterfaceCheck func(uintptr, uintptr)
14951560 // g_type_add_interface_check().
14961561 func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
14971562
1498- xTypeRemoveInterfaceCheck(CheckDataVar, glib.NewCallback(CheckFuncVar))
1563+ CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
1564+ 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)
1571+ }
1572+ CheckFuncVarRef = purego.NewCallback(fcb)
1573+ glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
1574+ }
1575+
1576+ xTypeRemoveInterfaceCheck(CheckDataVar, CheckFuncVarRef)
14991577
15001578 }
15011579
M v4/gobject/gvalue.go +14 -1
@@ -848,7 +848,20 @@ var xValueRegisterTransformFunc func(types.GType, types.GType, uintptr)
848848 // @dest_type will be replaced.
849849 func ValueRegisterTransformFunc(SrcTypeVar types.GType, DestTypeVar types.GType, TransformFuncVar *ValueTransform) {
850850
851- xValueRegisterTransformFunc(SrcTypeVar, DestTypeVar, glib.NewCallback(TransformFuncVar))
851+ TransformFuncVarPtr := uintptr(unsafe.Pointer(TransformFuncVar))
852+ 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)
859+ }
860+ TransformFuncVarRef = purego.NewCallback(fcb)
861+ glib.SaveCallback(TransformFuncVarPtr, TransformFuncVarRef)
862+ }
863+
864+ xValueRegisterTransformFunc(SrcTypeVar, DestTypeVar, TransformFuncVarRef)
852865
853866 }
854867
M v4/gobject/gvaluearray.go +28 -2
@@ -145,7 +145,20 @@ var xValueArraySort func(uintptr, uintptr) *ValueArray
145145 // C qsort() function.
146146 func (x *ValueArray) Sort(CompareFuncVar *glib.CompareFunc) *ValueArray {
147147
148- cret := xValueArraySort(x.GoPointer(), glib.NewCallback(CompareFuncVar))
148+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
149+ 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)
156+ }
157+ CompareFuncVarRef = purego.NewCallback(fcb)
158+ glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
159+ }
160+
161+ cret := xValueArraySort(x.GoPointer(), CompareFuncVarRef)
149162 return cret
150163 }
151164
@@ -158,7 +171,20 @@ var xValueArraySortWithData func(uintptr, uintptr, uintptr) *ValueArray
158171 // C qsort() function.
159172 func (x *ValueArray) SortWithData(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) *ValueArray {
160173
161- cret := xValueArraySortWithData(x.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)
174+ CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
175+ 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)
182+ }
183+ CompareFuncVarRef = purego.NewCallback(fcb)
184+ glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
185+ }
186+
187+ cret := xValueArraySortWithData(x.GoPointer(), CompareFuncVarRef, UserDataVar)
162188 return cret
163189 }
164190
M v4/gsk/gskrendernode.go +16 -1
@@ -298,7 +298,22 @@ var xRenderNodeDeserialize func(*glib.Bytes, uintptr, uintptr) uintptr
298298 func RenderNodeDeserialize(BytesVar *glib.Bytes, ErrorFuncVar *ParseErrorFunc, UserDataVar uintptr) *RenderNode {
299299 var cls *RenderNode
300300
301- cret := xRenderNodeDeserialize(BytesVar, glib.NewCallbackNullable(ErrorFuncVar), UserDataVar)
301+ var ErrorFuncVarRef uintptr
302+ if ErrorFuncVar != nil {
303+ ErrorFuncVarPtr := uintptr(unsafe.Pointer(ErrorFuncVar))
304+ if cbRefPtr, ok := glib.GetCallback(ErrorFuncVarPtr); ok {
305+ ErrorFuncVarRef = cbRefPtr
306+ } else {
307+ fcb := func(arg0 *ParseLocation, arg1 *ParseLocation, arg2 *glib.Error, arg3 uintptr) {
308+ cbFn := *ErrorFuncVar
309+ cbFn(arg0, arg1, arg2, arg3)
310+ }
311+ ErrorFuncVarRef = purego.NewCallback(fcb)
312+ glib.SaveCallback(ErrorFuncVarPtr, ErrorFuncVarRef)
313+ }
314+ }
315+
316+ cret := xRenderNodeDeserialize(BytesVar, ErrorFuncVarRef, UserDataVar)
302317
303318 if cret == 0 {
304319 return nil
M v4/gsk/gsktypes.go +28 -2
@@ -247,7 +247,20 @@ var xPathForeach func(uintptr, PathForeachFlags, uintptr, uintptr) bool
247247 // an approximation of the path using just the allowed operations.
248248 func (x *Path) Foreach(FlagsVar PathForeachFlags, FuncVar *PathForeachFunc, UserDataVar uintptr) bool {
249249
250- cret := xPathForeach(x.GoPointer(), FlagsVar, glib.NewCallback(FuncVar), UserDataVar)
250+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
251+ 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)
258+ }
259+ FuncVarRef = purego.NewCallback(fcb)
260+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
261+ }
262+
263+ cret := xPathForeach(x.GoPointer(), FlagsVar, FuncVarRef, UserDataVar)
251264 return cret
252265 }
253266
@@ -270,7 +283,20 @@ var xPathForeachIntersection func(uintptr, *Path, uintptr, uintptr) bool
270283 // If @func returns `FALSE`, the iteration is stopped.
271284 func (x *Path) ForeachIntersection(Path2Var *Path, FuncVar *PathIntersectionFunc, UserDataVar uintptr) bool {
272285
273- cret := xPathForeachIntersection(x.GoPointer(), Path2Var, glib.NewCallback(FuncVar), UserDataVar)
286+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
287+ 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)
294+ }
295+ FuncVarRef = purego.NewCallback(fcb)
296+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
297+ }
298+
299+ cret := xPathForeachIntersection(x.GoPointer(), Path2Var, FuncVarRef, UserDataVar)
274300 return cret
275301 }
276302
M v4/gtk/gtkalertdialog.go +16 -1
@@ -74,7 +74,22 @@ var xAlertDialogChoose func(uintptr, uintptr, uintptr, uintptr, uintptr)
7474 // this case is [method@Gtk.AlertDialog.show].
7575 func (x *AlertDialog) Choose(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
7676
77- xAlertDialogChoose(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
77+ var CallbackVarRef uintptr
78+ if CallbackVar != nil {
79+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
80+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
81+ CallbackVarRef = cbRefPtr
82+ } else {
83+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
84+ cbFn := *CallbackVar
85+ cbFn(arg0, arg1, arg2)
86+ }
87+ CallbackVarRef = purego.NewCallback(fcb)
88+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
89+ }
90+ }
91+
92+ xAlertDialogChoose(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
7893
7994 }
8095
M v4/gtk/gtkassistant.go +29 -1
@@ -360,7 +360,35 @@ var xAssistantSetForwardPageFunc func(uintptr, uintptr, uintptr, uintptr)
360360 // next visible page.
361361 func (x *Assistant) SetForwardPageFunc(PageFuncVar *AssistantPageFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
362362
363- xAssistantSetForwardPageFunc(x.GoPointer(), glib.NewCallbackNullable(PageFuncVar), DataVar, glib.NewCallback(DestroyVar))
363+ var PageFuncVarRef uintptr
364+ if PageFuncVar != nil {
365+ PageFuncVarPtr := uintptr(unsafe.Pointer(PageFuncVar))
366+ if cbRefPtr, ok := glib.GetCallback(PageFuncVarPtr); ok {
367+ PageFuncVarRef = cbRefPtr
368+ } else {
369+ fcb := func(arg0 int, arg1 uintptr) int {
370+ cbFn := *PageFuncVar
371+ return cbFn(arg0, arg1)
372+ }
373+ PageFuncVarRef = purego.NewCallback(fcb)
374+ glib.SaveCallback(PageFuncVarPtr, PageFuncVarRef)
375+ }
376+ }
377+
378+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
379+ 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)
386+ }
387+ DestroyVarRef = purego.NewCallback(fcb)
388+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
389+ }
390+
391+ xAssistantSetForwardPageFunc(x.GoPointer(), PageFuncVarRef, DataVar, DestroyVarRef)
364392
365393 }
366394
M v4/gtk/gtkbuilderscope.go +28 -2
@@ -274,7 +274,20 @@ var xBuilderCScopeAddCallbackSymbol func(uintptr, string, uintptr)
274274 // namespace.
275275 func (x *BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {
276276
277- xBuilderCScopeAddCallbackSymbol(x.GoPointer(), CallbackNameVar, glib.NewCallback(CallbackSymbolVar))
277+ CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
278+ var CallbackSymbolVarRef uintptr
279+ if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
280+ CallbackSymbolVarRef = cbRefPtr
281+ } else {
282+ fcb := func() {
283+ cbFn := *CallbackSymbolVar
284+ cbFn()
285+ }
286+ CallbackSymbolVarRef = purego.NewCallback(fcb)
287+ glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
288+ }
289+
290+ xBuilderCScopeAddCallbackSymbol(x.GoPointer(), CallbackNameVar, CallbackSymbolVarRef)
278291
279292 }
280293
@@ -286,7 +299,20 @@ var xBuilderCScopeAddCallbackSymbols func(uintptr, string, uintptr, ...interface
286299 // for each symbol.
287300 func (x *BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar *gobject.Callback, varArgs ...interface{}) {
288301
289- xBuilderCScopeAddCallbackSymbols(x.GoPointer(), FirstCallbackNameVar, glib.NewCallback(FirstCallbackSymbolVar), varArgs...)
302+ FirstCallbackSymbolVarPtr := uintptr(unsafe.Pointer(FirstCallbackSymbolVar))
303+ var FirstCallbackSymbolVarRef uintptr
304+ if cbRefPtr, ok := glib.GetCallback(FirstCallbackSymbolVarPtr); ok {
305+ FirstCallbackSymbolVarRef = cbRefPtr
306+ } else {
307+ fcb := func() {
308+ cbFn := *FirstCallbackSymbolVar
309+ cbFn()
310+ }
311+ FirstCallbackSymbolVarRef = purego.NewCallback(fcb)
312+ glib.SaveCallback(FirstCallbackSymbolVarPtr, FirstCallbackSymbolVarRef)
313+ }
314+
315+ xBuilderCScopeAddCallbackSymbols(x.GoPointer(), FirstCallbackNameVar, FirstCallbackSymbolVarRef, varArgs...)
290316
291317 }
292318
M v4/gtk/gtkcellarea.go +28 -2
@@ -1299,7 +1299,20 @@ var xCellAreaForeach func(uintptr, uintptr, uintptr)
12991299 // Calls @callback for every `GtkCellRenderer` in @area.
13001300 func (x *CellArea) Foreach(CallbackVar *CellCallback, CallbackDataVar uintptr) {
13011301
1302- xCellAreaForeach(x.GoPointer(), glib.NewCallback(CallbackVar), CallbackDataVar)
1302+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1303+ 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)
1310+ }
1311+ CallbackVarRef = purego.NewCallback(fcb)
1312+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1313+ }
1314+
1315+ xCellAreaForeach(x.GoPointer(), CallbackVarRef, CallbackDataVar)
13031316
13041317 }
13051318
@@ -1309,7 +1322,20 @@ var xCellAreaForeachAlloc func(uintptr, uintptr, uintptr, *gdk.Rectangle, *gdk.R
13091322 // allocated rectangle inside @cell_area.
13101323 func (x *CellArea) ForeachAlloc(ContextVar *CellAreaContext, WidgetVar *Widget, CellAreaVar *gdk.Rectangle, BackgroundAreaVar *gdk.Rectangle, CallbackVar *CellAllocCallback, CallbackDataVar uintptr) {
13111324
1312- xCellAreaForeachAlloc(x.GoPointer(), ContextVar.GoPointer(), WidgetVar.GoPointer(), CellAreaVar, BackgroundAreaVar, glib.NewCallback(CallbackVar), CallbackDataVar)
1325+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1326+ 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)
1333+ }
1334+ CallbackVarRef = purego.NewCallback(fcb)
1335+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1336+ }
1337+
1338+ xCellAreaForeachAlloc(x.GoPointer(), ContextVar.GoPointer(), WidgetVar.GoPointer(), CellAreaVar, BackgroundAreaVar, CallbackVarRef, CallbackDataVar)
13131339
13141340 }
13151341
M v4/gtk/gtkcolordialog.go +16 -1
@@ -72,7 +72,22 @@ var xColorDialogChooseRgba func(uintptr, uintptr, *gdk.RGBA, uintptr, uintptr, u
7272 // Presents a color chooser dialog to the user.
7373 func (x *ColorDialog) ChooseRgba(ParentVar *Window, InitialColorVar *gdk.RGBA, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
7474
75- xColorDialogChooseRgba(x.GoPointer(), ParentVar.GoPointer(), InitialColorVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
75+ var CallbackVarRef uintptr
76+ if CallbackVar != nil {
77+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
78+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
79+ CallbackVarRef = cbRefPtr
80+ } else {
81+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
82+ cbFn := *CallbackVar
83+ cbFn(arg0, arg1, arg2)
84+ }
85+ CallbackVarRef = purego.NewCallback(fcb)
86+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
87+ }
88+ }
89+
90+ xColorDialogChooseRgba(x.GoPointer(), ParentVar.GoPointer(), InitialColorVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
7691
7792 }
7893
M v4/gtk/gtkcombobox.go +31 -1
@@ -565,7 +565,37 @@ var xComboBoxSetRowSeparatorFunc func(uintptr, uintptr, uintptr, uintptr)
565565 // This is the default value.
566566 func (x *ComboBox) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
567567
568- xComboBoxSetRowSeparatorFunc(x.GoPointer(), glib.NewCallbackNullable(FuncVar), DataVar, glib.NewCallbackNullable(DestroyVar))
568+ var FuncVarRef uintptr
569+ if FuncVar != nil {
570+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
571+ if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
572+ FuncVarRef = cbRefPtr
573+ } else {
574+ fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 uintptr) bool {
575+ cbFn := *FuncVar
576+ return cbFn(arg0, arg1, arg2)
577+ }
578+ FuncVarRef = purego.NewCallback(fcb)
579+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
580+ }
581+ }
582+
583+ var DestroyVarRef uintptr
584+ if DestroyVar != nil {
585+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
586+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
587+ DestroyVarRef = cbRefPtr
588+ } else {
589+ fcb := func(arg0 uintptr) {
590+ cbFn := *DestroyVar
591+ cbFn(arg0)
592+ }
593+ DestroyVarRef = purego.NewCallback(fcb)
594+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
595+ }
596+ }
597+
598+ xComboBoxSetRowSeparatorFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyVarRef)
569599
570600 }
571601
M v4/gtk/gtkcustomfilter.go +58 -2
@@ -55,7 +55,35 @@ var xNewCustomFilter func(uintptr, uintptr, uintptr) uintptr
5555 func NewCustomFilter(MatchFuncVar *CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *CustomFilter {
5656 var cls *CustomFilter
5757
58- cret := xNewCustomFilter(glib.NewCallbackNullable(MatchFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
58+ var MatchFuncVarRef uintptr
59+ if MatchFuncVar != nil {
60+ MatchFuncVarPtr := uintptr(unsafe.Pointer(MatchFuncVar))
61+ if cbRefPtr, ok := glib.GetCallback(MatchFuncVarPtr); ok {
62+ MatchFuncVarRef = cbRefPtr
63+ } else {
64+ fcb := func(arg0 uintptr, arg1 uintptr) bool {
65+ cbFn := *MatchFuncVar
66+ return cbFn(arg0, arg1)
67+ }
68+ MatchFuncVarRef = purego.NewCallback(fcb)
69+ glib.SaveCallback(MatchFuncVarPtr, MatchFuncVarRef)
70+ }
71+ }
72+
73+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
74+ 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)
81+ }
82+ UserDestroyVarRef = purego.NewCallback(fcb)
83+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
84+ }
85+
86+ cret := xNewCustomFilter(MatchFuncVarRef, UserDataVar, UserDestroyVarRef)
5987
6088 if cret == 0 {
6189 return nil
@@ -78,7 +106,35 @@ var xCustomFilterSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
78106 // will be called.
79107 func (x *CustomFilter) SetFilterFunc(MatchFuncVar *CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
80108
81- xCustomFilterSetFilterFunc(x.GoPointer(), glib.NewCallbackNullable(MatchFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
109+ var MatchFuncVarRef uintptr
110+ if MatchFuncVar != nil {
111+ MatchFuncVarPtr := uintptr(unsafe.Pointer(MatchFuncVar))
112+ if cbRefPtr, ok := glib.GetCallback(MatchFuncVarPtr); ok {
113+ MatchFuncVarRef = cbRefPtr
114+ } else {
115+ fcb := func(arg0 uintptr, arg1 uintptr) bool {
116+ cbFn := *MatchFuncVar
117+ return cbFn(arg0, arg1)
118+ }
119+ MatchFuncVarRef = purego.NewCallback(fcb)
120+ glib.SaveCallback(MatchFuncVarPtr, MatchFuncVarRef)
121+ }
122+ }
123+
124+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
125+ 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)
132+ }
133+ UserDestroyVarRef = purego.NewCallback(fcb)
134+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
135+ }
136+
137+ xCustomFilterSetFilterFunc(x.GoPointer(), MatchFuncVarRef, UserDataVar, UserDestroyVarRef)
82138
83139 }
84140
M v4/gtk/gtkcustomlayout.go +42 -1
@@ -62,7 +62,48 @@ var xNewCustomLayout func(uintptr, uintptr, uintptr) uintptr
6262 func NewCustomLayout(RequestModeVar *CustomRequestModeFunc, MeasureVar *CustomMeasureFunc, AllocateVar *CustomAllocateFunc) *CustomLayout {
6363 var cls *CustomLayout
6464
65- cret := xNewCustomLayout(glib.NewCallbackNullable(RequestModeVar), glib.NewCallback(MeasureVar), glib.NewCallback(AllocateVar))
65+ var RequestModeVarRef uintptr
66+ if RequestModeVar != nil {
67+ RequestModeVarPtr := uintptr(unsafe.Pointer(RequestModeVar))
68+ if cbRefPtr, ok := glib.GetCallback(RequestModeVarPtr); ok {
69+ RequestModeVarRef = cbRefPtr
70+ } else {
71+ fcb := func(arg0 uintptr) SizeRequestMode {
72+ cbFn := *RequestModeVar
73+ return cbFn(arg0)
74+ }
75+ RequestModeVarRef = purego.NewCallback(fcb)
76+ glib.SaveCallback(RequestModeVarPtr, RequestModeVarRef)
77+ }
78+ }
79+
80+ MeasureVarPtr := uintptr(unsafe.Pointer(MeasureVar))
81+ 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)
88+ }
89+ MeasureVarRef = purego.NewCallback(fcb)
90+ glib.SaveCallback(MeasureVarPtr, MeasureVarRef)
91+ }
92+
93+ AllocateVarPtr := uintptr(unsafe.Pointer(AllocateVar))
94+ 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)
101+ }
102+ AllocateVarRef = purego.NewCallback(fcb)
103+ glib.SaveCallback(AllocateVarPtr, AllocateVarRef)
104+ }
105+
106+ cret := xNewCustomLayout(RequestModeVarRef, MeasureVarRef, AllocateVarRef)
66107
67108 if cret == 0 {
68109 return nil
M v4/gtk/gtkcustomsorter.go +60 -2
@@ -47,7 +47,37 @@ var xNewCustomSorter func(uintptr, uintptr, uintptr) uintptr
4747 func NewCustomSorter(SortFuncVar *glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *CustomSorter {
4848 var cls *CustomSorter
4949
50- cret := xNewCustomSorter(glib.NewCallbackNullable(SortFuncVar), UserDataVar, glib.NewCallbackNullable(UserDestroyVar))
50+ var SortFuncVarRef uintptr
51+ if SortFuncVar != nil {
52+ SortFuncVarPtr := uintptr(unsafe.Pointer(SortFuncVar))
53+ if cbRefPtr, ok := glib.GetCallback(SortFuncVarPtr); ok {
54+ SortFuncVarRef = cbRefPtr
55+ } else {
56+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
57+ cbFn := *SortFuncVar
58+ return cbFn(arg0, arg1, arg2)
59+ }
60+ SortFuncVarRef = purego.NewCallback(fcb)
61+ glib.SaveCallback(SortFuncVarPtr, SortFuncVarRef)
62+ }
63+ }
64+
65+ var UserDestroyVarRef uintptr
66+ if UserDestroyVar != nil {
67+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
68+ if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
69+ UserDestroyVarRef = cbRefPtr
70+ } else {
71+ fcb := func(arg0 uintptr) {
72+ cbFn := *UserDestroyVar
73+ cbFn(arg0)
74+ }
75+ UserDestroyVarRef = purego.NewCallback(fcb)
76+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
77+ }
78+ }
79+
80+ cret := xNewCustomSorter(SortFuncVarRef, UserDataVar, UserDestroyVarRef)
5181
5282 if cret == 0 {
5383 return nil
@@ -70,7 +100,35 @@ var xCustomSorterSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
70100 // called now.
71101 func (x *CustomSorter) SetSortFunc(SortFuncVar *glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
72102
73- xCustomSorterSetSortFunc(x.GoPointer(), glib.NewCallbackNullable(SortFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
103+ var SortFuncVarRef uintptr
104+ if SortFuncVar != nil {
105+ SortFuncVarPtr := uintptr(unsafe.Pointer(SortFuncVar))
106+ if cbRefPtr, ok := glib.GetCallback(SortFuncVarPtr); ok {
107+ SortFuncVarRef = cbRefPtr
108+ } else {
109+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
110+ cbFn := *SortFuncVar
111+ return cbFn(arg0, arg1, arg2)
112+ }
113+ SortFuncVarRef = purego.NewCallback(fcb)
114+ glib.SaveCallback(SortFuncVarPtr, SortFuncVarRef)
115+ }
116+ }
117+
118+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
119+ 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)
126+ }
127+ UserDestroyVarRef = purego.NewCallback(fcb)
128+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
129+ }
130+
131+ xCustomSorterSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, UserDestroyVarRef)
74132
75133 }
76134
M v4/gtk/gtkdrawingarea.go +29 -1
@@ -244,7 +244,35 @@ var xDrawingAreaSetDrawFunc func(uintptr, uintptr, uintptr, uintptr)
244244 // on the drawing area. This will cause a redraw and will call @draw_func again.
245245 func (x *DrawingArea) SetDrawFunc(DrawFuncVar *DrawingAreaDrawFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
246246
247- xDrawingAreaSetDrawFunc(x.GoPointer(), glib.NewCallbackNullable(DrawFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
247+ var DrawFuncVarRef uintptr
248+ if DrawFuncVar != nil {
249+ DrawFuncVarPtr := uintptr(unsafe.Pointer(DrawFuncVar))
250+ if cbRefPtr, ok := glib.GetCallback(DrawFuncVarPtr); ok {
251+ DrawFuncVarRef = cbRefPtr
252+ } else {
253+ fcb := func(arg0 uintptr, arg1 *cairo.Context, arg2 int, arg3 int, arg4 uintptr) {
254+ cbFn := *DrawFuncVar
255+ cbFn(arg0, arg1, arg2, arg3, arg4)
256+ }
257+ DrawFuncVarRef = purego.NewCallback(fcb)
258+ glib.SaveCallback(DrawFuncVarPtr, DrawFuncVarRef)
259+ }
260+ }
261+
262+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
263+ 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)
270+ }
271+ DestroyVarRef = purego.NewCallback(fcb)
272+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
273+ }
274+
275+ xDrawingAreaSetDrawFunc(x.GoPointer(), DrawFuncVarRef, UserDataVar, DestroyVarRef)
248276
249277 }
250278
M v4/gtk/gtkentrycompletion.go +27 -1
@@ -285,7 +285,33 @@ var xEntryCompletionSetMatchFunc func(uintptr, uintptr, uintptr, uintptr)
285285 // should not be in the completion list.
286286 func (x *EntryCompletion) SetMatchFunc(FuncVar *EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar *glib.DestroyNotify) {
287287
288- xEntryCompletionSetMatchFunc(x.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(FuncNotifyVar))
288+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
289+ 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)
296+ }
297+ FuncVarRef = purego.NewCallback(fcb)
298+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
299+ }
300+
301+ FuncNotifyVarPtr := uintptr(unsafe.Pointer(FuncNotifyVar))
302+ 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)
309+ }
310+ FuncNotifyVarRef = purego.NewCallback(fcb)
311+ glib.SaveCallback(FuncNotifyVarPtr, FuncNotifyVarRef)
312+ }
313+
314+ xEntryCompletionSetMatchFunc(x.GoPointer(), FuncVarRef, FuncDataVar, FuncNotifyVarRef)
289315
290316 }
291317
M v4/gtk/gtkexpression.go +71 -2
@@ -181,7 +181,50 @@ var xNewCClosureExpression func(types.GType, uintptr, uint, uintptr, uintptr, ui
181181 func NewCClosureExpression(ValueTypeVar types.GType, MarshalVar *gobject.ClosureMarshal, NParamsVar uint, ParamsVar uintptr, CallbackFuncVar *gobject.Callback, UserDataVar uintptr, UserDestroyVar *gobject.ClosureNotify) *CClosureExpression {
182182 var cls *CClosureExpression
183183
184- cret := xNewCClosureExpression(ValueTypeVar, glib.NewCallbackNullable(MarshalVar), NParamsVar, ParamsVar, glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallbackNullable(UserDestroyVar))
184+ var MarshalVarRef uintptr
185+ if MarshalVar != nil {
186+ MarshalVarPtr := uintptr(unsafe.Pointer(MarshalVar))
187+ if cbRefPtr, ok := glib.GetCallback(MarshalVarPtr); ok {
188+ MarshalVarRef = cbRefPtr
189+ } else {
190+ fcb := func(arg0 *Closure, arg1 *Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
191+ cbFn := *MarshalVar
192+ cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
193+ }
194+ MarshalVarRef = purego.NewCallback(fcb)
195+ glib.SaveCallback(MarshalVarPtr, MarshalVarRef)
196+ }
197+ }
198+
199+ CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
200+ var CallbackFuncVarRef uintptr
201+ if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
202+ CallbackFuncVarRef = cbRefPtr
203+ } else {
204+ fcb := func() {
205+ cbFn := *CallbackFuncVar
206+ cbFn()
207+ }
208+ CallbackFuncVarRef = purego.NewCallback(fcb)
209+ glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
210+ }
211+
212+ var UserDestroyVarRef uintptr
213+ if UserDestroyVar != nil {
214+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
215+ if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
216+ UserDestroyVarRef = cbRefPtr
217+ } else {
218+ fcb := func(arg0 uintptr, arg1 *Closure) {
219+ cbFn := *UserDestroyVar
220+ cbFn(arg0, arg1)
221+ }
222+ UserDestroyVarRef = purego.NewCallback(fcb)
223+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
224+ }
225+ }
226+
227+ cret := xNewCClosureExpression(ValueTypeVar, MarshalVarRef, NParamsVar, ParamsVar, CallbackFuncVarRef, UserDataVar, UserDestroyVarRef)
185228
186229 if cret == 0 {
187230 return nil
@@ -629,7 +672,33 @@ var xExpressionWatch func(uintptr, uintptr, uintptr, uintptr, uintptr) *Expressi
629672 // the @notify will be invoked.
630673 func (x *Expression) Watch(ThisVar *gobject.Object, NotifyVar *ExpressionNotify, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *ExpressionWatch {
631674
632- cret := xExpressionWatch(x.GoPointer(), ThisVar.GoPointer(), glib.NewCallback(NotifyVar), UserDataVar, glib.NewCallback(UserDestroyVar))
675+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
676+ 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)
683+ }
684+ NotifyVarRef = purego.NewCallback(fcb)
685+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
686+ }
687+
688+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
689+ 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)
696+ }
697+ UserDestroyVarRef = purego.NewCallback(fcb)
698+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
699+ }
700+
701+ cret := xExpressionWatch(x.GoPointer(), ThisVar.GoPointer(), NotifyVarRef, UserDataVar, UserDestroyVarRef)
633702 return cret
634703 }
635704
M v4/gtk/gtkfiledialog.go +128 -8
@@ -181,7 +181,22 @@ var xFileDialogOpen func(uintptr, uintptr, uintptr, uintptr, uintptr)
181181 // The @callback will be called when the dialog is closed.
182182 func (x *FileDialog) Open(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
183183
184- xFileDialogOpen(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
184+ var CallbackVarRef uintptr
185+ if CallbackVar != nil {
186+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
187+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
188+ CallbackVarRef = cbRefPtr
189+ } else {
190+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
191+ cbFn := *CallbackVar
192+ cbFn(arg0, arg1, arg2)
193+ }
194+ CallbackVarRef = purego.NewCallback(fcb)
195+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
196+ }
197+ }
198+
199+ xFileDialogOpen(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
185200
186201 }
187202
@@ -221,7 +236,22 @@ var xFileDialogOpenMultiple func(uintptr, uintptr, uintptr, uintptr, uintptr)
221236 // The @callback will be called when the dialog is closed.
222237 func (x *FileDialog) OpenMultiple(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
223238
224- xFileDialogOpenMultiple(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
239+ var CallbackVarRef uintptr
240+ if CallbackVar != nil {
241+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
242+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
243+ CallbackVarRef = cbRefPtr
244+ } else {
245+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
246+ cbFn := *CallbackVar
247+ cbFn(arg0, arg1, arg2)
248+ }
249+ CallbackVarRef = purego.NewCallback(fcb)
250+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
251+ }
252+ }
253+
254+ xFileDialogOpenMultiple(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
225255
226256 }
227257
@@ -264,7 +294,22 @@ var xFileDialogOpenMultipleTextFiles func(uintptr, uintptr, uintptr, uintptr, ui
264294 // The @callback will be called when the dialog is closed.
265295 func (x *FileDialog) OpenMultipleTextFiles(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
266296
267- xFileDialogOpenMultipleTextFiles(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
297+ var CallbackVarRef uintptr
298+ if CallbackVar != nil {
299+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
300+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
301+ CallbackVarRef = cbRefPtr
302+ } else {
303+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
304+ cbFn := *CallbackVar
305+ cbFn(arg0, arg1, arg2)
306+ }
307+ CallbackVarRef = purego.NewCallback(fcb)
308+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
309+ }
310+ }
311+
312+ xFileDialogOpenMultipleTextFiles(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
268313
269314 }
270315
@@ -303,7 +348,22 @@ var xFileDialogOpenTextFile func(uintptr, uintptr, uintptr, uintptr, uintptr)
303348 // The @callback will be called when the dialog is closed.
304349 func (x *FileDialog) OpenTextFile(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
305350
306- xFileDialogOpenTextFile(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
351+ var CallbackVarRef uintptr
352+ if CallbackVar != nil {
353+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
354+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
355+ CallbackVarRef = cbRefPtr
356+ } else {
357+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
358+ cbFn := *CallbackVar
359+ cbFn(arg0, arg1, arg2)
360+ }
361+ CallbackVarRef = purego.NewCallback(fcb)
362+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
363+ }
364+ }
365+
366+ xFileDialogOpenTextFile(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
307367
308368 }
309369
@@ -346,7 +406,22 @@ var xFileDialogSave func(uintptr, uintptr, uintptr, uintptr, uintptr)
346406 // The @callback will be called when the dialog is closed.
347407 func (x *FileDialog) Save(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
348408
349- xFileDialogSave(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
409+ var CallbackVarRef uintptr
410+ if CallbackVar != nil {
411+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
412+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
413+ CallbackVarRef = cbRefPtr
414+ } else {
415+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
416+ cbFn := *CallbackVar
417+ cbFn(arg0, arg1, arg2)
418+ }
419+ CallbackVarRef = purego.NewCallback(fcb)
420+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
421+ }
422+ }
423+
424+ xFileDialogSave(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
350425
351426 }
352427
@@ -386,7 +461,22 @@ var xFileDialogSaveTextFile func(uintptr, uintptr, uintptr, uintptr, uintptr)
386461 // The @callback will be called when the dialog is closed.
387462 func (x *FileDialog) SaveTextFile(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
388463
389- xFileDialogSaveTextFile(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
464+ var CallbackVarRef uintptr
465+ if CallbackVar != nil {
466+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
467+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
468+ CallbackVarRef = cbRefPtr
469+ } else {
470+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
471+ cbFn := *CallbackVar
472+ cbFn(arg0, arg1, arg2)
473+ }
474+ CallbackVarRef = purego.NewCallback(fcb)
475+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
476+ }
477+ }
478+
479+ xFileDialogSaveTextFile(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
390480
391481 }
392482
@@ -436,7 +526,22 @@ var xFileDialogSelectFolder func(uintptr, uintptr, uintptr, uintptr, uintptr)
436526 // The @callback will be called when the dialog is closed.
437527 func (x *FileDialog) SelectFolder(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
438528
439- xFileDialogSelectFolder(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
529+ var CallbackVarRef uintptr
530+ if CallbackVar != nil {
531+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
532+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
533+ CallbackVarRef = cbRefPtr
534+ } else {
535+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
536+ cbFn := *CallbackVar
537+ cbFn(arg0, arg1, arg2)
538+ }
539+ CallbackVarRef = purego.NewCallback(fcb)
540+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
541+ }
542+ }
543+
544+ xFileDialogSelectFolder(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
440545
441546 }
442547
@@ -477,7 +582,22 @@ var xFileDialogSelectMultipleFolders func(uintptr, uintptr, uintptr, uintptr, ui
477582 // The @callback will be called when the dialog is closed.
478583 func (x *FileDialog) SelectMultipleFolders(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
479584
480- xFileDialogSelectMultipleFolders(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
585+ var CallbackVarRef uintptr
586+ if CallbackVar != nil {
587+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
588+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
589+ CallbackVarRef = cbRefPtr
590+ } else {
591+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
592+ cbFn := *CallbackVar
593+ cbFn(arg0, arg1, arg2)
594+ }
595+ CallbackVarRef = purego.NewCallback(fcb)
596+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
597+ }
598+ }
599+
600+ xFileDialogSelectMultipleFolders(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
481601
482602 }
483603
M v4/gtk/gtkfilelauncher.go +32 -2
@@ -108,7 +108,22 @@ var xFileLauncherLaunch func(uintptr, uintptr, uintptr, uintptr, uintptr)
108108 // This may present an app chooser dialog to the user.
109109 func (x *FileLauncher) Launch(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
110110
111- xFileLauncherLaunch(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
111+ var CallbackVarRef uintptr
112+ if CallbackVar != nil {
113+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
114+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
115+ CallbackVarRef = cbRefPtr
116+ } else {
117+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
118+ cbFn := *CallbackVar
119+ cbFn(arg0, arg1, arg2)
120+ }
121+ CallbackVarRef = purego.NewCallback(fcb)
122+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
123+ }
124+ }
125+
126+ xFileLauncherLaunch(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
112127
113128 }
114129
@@ -135,7 +150,22 @@ var xFileLauncherOpenContainingFolder func(uintptr, uintptr, uintptr, uintptr, u
135150 // is e.g. a http:// uri.
136151 func (x *FileLauncher) OpenContainingFolder(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
137152
138- xFileLauncherOpenContainingFolder(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
153+ var CallbackVarRef uintptr
154+ if CallbackVar != nil {
155+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
156+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
157+ CallbackVarRef = cbRefPtr
158+ } else {
159+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
160+ cbFn := *CallbackVar
161+ cbFn(arg0, arg1, arg2)
162+ }
163+ CallbackVarRef = purego.NewCallback(fcb)
164+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
165+ }
166+ }
167+
168+ xFileLauncherOpenContainingFolder(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
139169
140170 }
141171
M v4/gtk/gtkflowbox.go +99 -4
@@ -198,7 +198,33 @@ var xFlowBoxBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
198198 // should be implemented by the model.
199199 func (x *FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
200200
201- xFlowBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), glib.NewCallback(CreateWidgetFuncVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
201+ CreateWidgetFuncVarPtr := uintptr(unsafe.Pointer(CreateWidgetFuncVar))
202+ 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)
209+ }
210+ CreateWidgetFuncVarRef = purego.NewCallback(fcb)
211+ glib.SaveCallback(CreateWidgetFuncVarPtr, CreateWidgetFuncVarRef)
212+ }
213+
214+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
215+ 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)
222+ }
223+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
224+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
225+ }
226+
227+ xFlowBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateWidgetFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)
202228
203229 }
204230
@@ -414,7 +440,20 @@ var xFlowBoxSelectedForeach func(uintptr, uintptr, uintptr)
414440 // this function.
415441 func (x *FlowBox) SelectedForeach(FuncVar *FlowBoxForeachFunc, DataVar uintptr) {
416442
417- xFlowBoxSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
443+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
444+ 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)
451+ }
452+ FuncVarRef = purego.NewCallback(fcb)
453+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
454+ }
455+
456+ xFlowBoxSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
418457
419458 }
420459
@@ -454,7 +493,35 @@ var xFlowBoxSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
454493 // (see [method@Gtk.FlowBox.bind_model]).
455494 func (x *FlowBox) SetFilterFunc(FilterFuncVar *FlowBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
456495
457- xFlowBoxSetFilterFunc(x.GoPointer(), glib.NewCallbackNullable(FilterFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
496+ var FilterFuncVarRef uintptr
497+ if FilterFuncVar != nil {
498+ FilterFuncVarPtr := uintptr(unsafe.Pointer(FilterFuncVar))
499+ if cbRefPtr, ok := glib.GetCallback(FilterFuncVarPtr); ok {
500+ FilterFuncVarRef = cbRefPtr
501+ } else {
502+ fcb := func(arg0 uintptr, arg1 uintptr) bool {
503+ cbFn := *FilterFuncVar
504+ return cbFn(arg0, arg1)
505+ }
506+ FilterFuncVarRef = purego.NewCallback(fcb)
507+ glib.SaveCallback(FilterFuncVarPtr, FilterFuncVarRef)
508+ }
509+ }
510+
511+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
512+ 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)
519+ }
520+ DestroyVarRef = purego.NewCallback(fcb)
521+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
522+ }
523+
524+ xFlowBoxSetFilterFunc(x.GoPointer(), FilterFuncVarRef, UserDataVar, DestroyVarRef)
458525
459526 }
460527
@@ -544,7 +611,35 @@ var xFlowBoxSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
544611 // (see [method@Gtk.FlowBox.bind_model]).
545612 func (x *FlowBox) SetSortFunc(SortFuncVar *FlowBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
546613
547- xFlowBoxSetSortFunc(x.GoPointer(), glib.NewCallbackNullable(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
614+ var SortFuncVarRef uintptr
615+ if SortFuncVar != nil {
616+ SortFuncVarPtr := uintptr(unsafe.Pointer(SortFuncVar))
617+ if cbRefPtr, ok := glib.GetCallback(SortFuncVarPtr); ok {
618+ SortFuncVarRef = cbRefPtr
619+ } else {
620+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
621+ cbFn := *SortFuncVar
622+ return cbFn(arg0, arg1, arg2)
623+ }
624+ SortFuncVarRef = purego.NewCallback(fcb)
625+ glib.SaveCallback(SortFuncVarPtr, SortFuncVarRef)
626+ }
627+ }
628+
629+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
630+ 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)
637+ }
638+ DestroyVarRef = purego.NewCallback(fcb)
639+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
640+ }
641+
642+ xFlowBoxSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, DestroyVarRef)
548643
549644 }
550645
M v4/gtk/gtkfontdialog.go +64 -4
@@ -76,7 +76,22 @@ var xFontDialogChooseFace func(uintptr, uintptr, uintptr, uintptr, uintptr, uint
7676 // A font face represents a font family and style, but no specific font size.
7777 func (x *FontDialog) ChooseFace(ParentVar *Window, InitialValueVar *pango.FontFace, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
7878
79- xFontDialogChooseFace(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
79+ var CallbackVarRef uintptr
80+ if CallbackVar != nil {
81+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
82+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
83+ CallbackVarRef = cbRefPtr
84+ } else {
85+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
86+ cbFn := *CallbackVar
87+ cbFn(arg0, arg1, arg2)
88+ }
89+ CallbackVarRef = purego.NewCallback(fcb)
90+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
91+ }
92+ }
93+
94+ xFontDialogChooseFace(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
8095
8196 }
8297
@@ -111,7 +126,22 @@ var xFontDialogChooseFamily func(uintptr, uintptr, uintptr, uintptr, uintptr, ui
111126 // The font chooser dialog will be set up for selecting a font family.
112127 func (x *FontDialog) ChooseFamily(ParentVar *Window, InitialValueVar *pango.FontFamily, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
113128
114- xFontDialogChooseFamily(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
129+ var CallbackVarRef uintptr
130+ if CallbackVar != nil {
131+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
132+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
133+ CallbackVarRef = cbRefPtr
134+ } else {
135+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
136+ cbFn := *CallbackVar
137+ cbFn(arg0, arg1, arg2)
138+ }
139+ CallbackVarRef = purego.NewCallback(fcb)
140+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
141+ }
142+ }
143+
144+ xFontDialogChooseFamily(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
115145
116146 }
117147
@@ -149,7 +179,22 @@ var xFontDialogChooseFont func(uintptr, uintptr, *pango.FontDescription, uintptr
149179 // use [method@Gtk.FontDialog.choose_font_and_features] instead.
150180 func (x *FontDialog) ChooseFont(ParentVar *Window, InitialValueVar *pango.FontDescription, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
151181
152- xFontDialogChooseFont(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
182+ var CallbackVarRef uintptr
183+ if CallbackVar != nil {
184+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
185+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
186+ CallbackVarRef = cbRefPtr
187+ } else {
188+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
189+ cbFn := *CallbackVar
190+ cbFn(arg0, arg1, arg2)
191+ }
192+ CallbackVarRef = purego.NewCallback(fcb)
193+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
194+ }
195+ }
196+
197+ xFontDialogChooseFont(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
153198
154199 }
155200
@@ -164,7 +209,22 @@ var xFontDialogChooseFontAndFeatures func(uintptr, uintptr, *pango.FontDescripti
164209 // enabling glyph variants or ligatures.
165210 func (x *FontDialog) ChooseFontAndFeatures(ParentVar *Window, InitialValueVar *pango.FontDescription, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
166211
167- xFontDialogChooseFontAndFeatures(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
212+ var CallbackVarRef uintptr
213+ if CallbackVar != nil {
214+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
215+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
216+ CallbackVarRef = cbRefPtr
217+ } else {
218+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
219+ cbFn := *CallbackVar
220+ cbFn(arg0, arg1, arg2)
221+ }
222+ CallbackVarRef = purego.NewCallback(fcb)
223+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
224+ }
225+ }
226+
227+ xFontDialogChooseFontAndFeatures(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
168228
169229 }
170230
M v4/gtk/gtkiconview.go +14 -1
@@ -536,7 +536,20 @@ var xIconViewSelectedForeach func(uintptr, uintptr, uintptr)
536536 // selection cannot be modified from within this function.
537537 func (x *IconView) SelectedForeach(FuncVar *IconViewForeachFunc, DataVar uintptr) {
538538
539- xIconViewSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
539+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
540+ 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)
547+ }
548+ FuncVarRef = purego.NewCallback(fcb)
549+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
550+ }
551+
552+ xIconViewSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
540553
541554 }
542555
M v4/gtk/gtklistbox.go +130 -5
@@ -209,7 +209,35 @@ var xListBoxBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
209209 // should be implemented by the model.
210210 func (x *ListBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
211211
212- xListBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), glib.NewCallbackNullable(CreateWidgetFuncVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
212+ var CreateWidgetFuncVarRef uintptr
213+ if CreateWidgetFuncVar != nil {
214+ CreateWidgetFuncVarPtr := uintptr(unsafe.Pointer(CreateWidgetFuncVar))
215+ if cbRefPtr, ok := glib.GetCallback(CreateWidgetFuncVarPtr); ok {
216+ CreateWidgetFuncVarRef = cbRefPtr
217+ } else {
218+ fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
219+ cbFn := *CreateWidgetFuncVar
220+ return cbFn(arg0, arg1)
221+ }
222+ CreateWidgetFuncVarRef = purego.NewCallback(fcb)
223+ glib.SaveCallback(CreateWidgetFuncVarPtr, CreateWidgetFuncVarRef)
224+ }
225+ }
226+
227+ UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
228+ 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)
235+ }
236+ UserDataFreeFuncVarRef = purego.NewCallback(fcb)
237+ glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
238+ }
239+
240+ xListBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateWidgetFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)
213241
214242 }
215243
@@ -475,7 +503,20 @@ var xListBoxSelectedForeach func(uintptr, uintptr, uintptr)
475503 // Note that the selection cannot be modified from within this function.
476504 func (x *ListBox) SelectedForeach(FuncVar *ListBoxForeachFunc, DataVar uintptr) {
477505
478- xListBoxSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
506+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
507+ 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)
514+ }
515+ FuncVarRef = purego.NewCallback(fcb)
516+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
517+ }
518+
519+ xListBoxSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
479520
480521 }
481522
@@ -524,7 +565,35 @@ var xListBoxSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
524565 // (see [method@Gtk.ListBox.bind_model]).
525566 func (x *ListBox) SetFilterFunc(FilterFuncVar *ListBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
526567
527- xListBoxSetFilterFunc(x.GoPointer(), glib.NewCallbackNullable(FilterFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
568+ var FilterFuncVarRef uintptr
569+ if FilterFuncVar != nil {
570+ FilterFuncVarPtr := uintptr(unsafe.Pointer(FilterFuncVar))
571+ if cbRefPtr, ok := glib.GetCallback(FilterFuncVarPtr); ok {
572+ FilterFuncVarRef = cbRefPtr
573+ } else {
574+ fcb := func(arg0 uintptr, arg1 uintptr) bool {
575+ cbFn := *FilterFuncVar
576+ return cbFn(arg0, arg1)
577+ }
578+ FilterFuncVarRef = purego.NewCallback(fcb)
579+ glib.SaveCallback(FilterFuncVarPtr, FilterFuncVarRef)
580+ }
581+ }
582+
583+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
584+ 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)
591+ }
592+ DestroyVarRef = purego.NewCallback(fcb)
593+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
594+ }
595+
596+ xListBoxSetFilterFunc(x.GoPointer(), FilterFuncVarRef, UserDataVar, DestroyVarRef)
528597
529598 }
530599
@@ -557,7 +626,35 @@ var xListBoxSetHeaderFunc func(uintptr, uintptr, uintptr, uintptr)
557626 // [method@Gtk.ListBox.invalidate_headers] is called.
558627 func (x *ListBox) SetHeaderFunc(UpdateHeaderVar *ListBoxUpdateHeaderFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
559628
560- xListBoxSetHeaderFunc(x.GoPointer(), glib.NewCallbackNullable(UpdateHeaderVar), UserDataVar, glib.NewCallback(DestroyVar))
629+ var UpdateHeaderVarRef uintptr
630+ if UpdateHeaderVar != nil {
631+ UpdateHeaderVarPtr := uintptr(unsafe.Pointer(UpdateHeaderVar))
632+ if cbRefPtr, ok := glib.GetCallback(UpdateHeaderVarPtr); ok {
633+ UpdateHeaderVarRef = cbRefPtr
634+ } else {
635+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
636+ cbFn := *UpdateHeaderVar
637+ cbFn(arg0, arg1, arg2)
638+ }
639+ UpdateHeaderVarRef = purego.NewCallback(fcb)
640+ glib.SaveCallback(UpdateHeaderVarPtr, UpdateHeaderVarRef)
641+ }
642+ }
643+
644+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
645+ 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)
652+ }
653+ DestroyVarRef = purego.NewCallback(fcb)
654+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
655+ }
656+
657+ xListBoxSetHeaderFunc(x.GoPointer(), UpdateHeaderVarRef, UserDataVar, DestroyVarRef)
561658
562659 }
563660
@@ -606,7 +703,35 @@ var xListBoxSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
606703 // (see [method@Gtk.ListBox.bind_model]).
607704 func (x *ListBox) SetSortFunc(SortFuncVar *ListBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
608705
609- xListBoxSetSortFunc(x.GoPointer(), glib.NewCallbackNullable(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))
706+ var SortFuncVarRef uintptr
707+ if SortFuncVar != nil {
708+ SortFuncVarPtr := uintptr(unsafe.Pointer(SortFuncVar))
709+ if cbRefPtr, ok := glib.GetCallback(SortFuncVarPtr); ok {
710+ SortFuncVarRef = cbRefPtr
711+ } else {
712+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
713+ cbFn := *SortFuncVar
714+ return cbFn(arg0, arg1, arg2)
715+ }
716+ SortFuncVarRef = purego.NewCallback(fcb)
717+ glib.SaveCallback(SortFuncVarPtr, SortFuncVarRef)
718+ }
719+ }
720+
721+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
722+ 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)
729+ }
730+ DestroyVarRef = purego.NewCallback(fcb)
731+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
732+ }
733+
734+ xListBoxSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, DestroyVarRef)
610735
611736 }
612737
M v4/gtk/gtkmaplistmodel.go +58 -2
@@ -86,7 +86,35 @@ var xNewMapListModel func(uintptr, uintptr, uintptr, uintptr) uintptr
8686 func NewMapListModel(ModelVar gio.ListModel, MapFuncVar *MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *MapListModel {
8787 var cls *MapListModel
8888
89- cret := xNewMapListModel(ModelVar.GoPointer(), glib.NewCallbackNullable(MapFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
89+ var MapFuncVarRef uintptr
90+ if MapFuncVar != nil {
91+ MapFuncVarPtr := uintptr(unsafe.Pointer(MapFuncVar))
92+ if cbRefPtr, ok := glib.GetCallback(MapFuncVarPtr); ok {
93+ MapFuncVarRef = cbRefPtr
94+ } else {
95+ fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
96+ cbFn := *MapFuncVar
97+ return cbFn(arg0, arg1)
98+ }
99+ MapFuncVarRef = purego.NewCallback(fcb)
100+ glib.SaveCallback(MapFuncVarPtr, MapFuncVarRef)
101+ }
102+ }
103+
104+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
105+ 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)
112+ }
113+ UserDestroyVarRef = purego.NewCallback(fcb)
114+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
115+ }
116+
117+ cret := xNewMapListModel(ModelVar.GoPointer(), MapFuncVarRef, UserDataVar, UserDestroyVarRef)
90118
91119 if cret == 0 {
92120 return nil
@@ -137,7 +165,35 @@ var xMapListModelSetMapFunc func(uintptr, uintptr, uintptr, uintptr)
137165 // function returns items of the appropriate type.
138166 func (x *MapListModel) SetMapFunc(MapFuncVar *MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
139167
140- xMapListModelSetMapFunc(x.GoPointer(), glib.NewCallbackNullable(MapFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
168+ var MapFuncVarRef uintptr
169+ if MapFuncVar != nil {
170+ MapFuncVarPtr := uintptr(unsafe.Pointer(MapFuncVar))
171+ if cbRefPtr, ok := glib.GetCallback(MapFuncVarPtr); ok {
172+ MapFuncVarRef = cbRefPtr
173+ } else {
174+ fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
175+ cbFn := *MapFuncVar
176+ return cbFn(arg0, arg1)
177+ }
178+ MapFuncVarRef = purego.NewCallback(fcb)
179+ glib.SaveCallback(MapFuncVarPtr, MapFuncVarRef)
180+ }
181+ }
182+
183+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
184+ 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)
191+ }
192+ UserDestroyVarRef = purego.NewCallback(fcb)
193+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
194+ }
195+
196+ xMapListModelSetMapFunc(x.GoPointer(), MapFuncVarRef, UserDataVar, UserDestroyVarRef)
141197
142198 }
143199
M v4/gtk/gtkmenubutton.go +31 -1
@@ -347,7 +347,37 @@ var xMenuButtonSetCreatePopupFunc func(uintptr, uintptr, uintptr, uintptr)
347347 // @menu_button. Instead, this can be done manually in @func.
348348 func (x *MenuButton) SetCreatePopupFunc(FuncVar *MenuButtonCreatePopupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
349349
350- xMenuButtonSetCreatePopupFunc(x.GoPointer(), glib.NewCallbackNullable(FuncVar), UserDataVar, glib.NewCallbackNullable(DestroyNotifyVar))
350+ var FuncVarRef uintptr
351+ if FuncVar != nil {
352+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
353+ if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
354+ FuncVarRef = cbRefPtr
355+ } else {
356+ fcb := func(arg0 uintptr, arg1 uintptr) {
357+ cbFn := *FuncVar
358+ cbFn(arg0, arg1)
359+ }
360+ FuncVarRef = purego.NewCallback(fcb)
361+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
362+ }
363+ }
364+
365+ var DestroyNotifyVarRef uintptr
366+ if DestroyNotifyVar != nil {
367+ DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
368+ if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
369+ DestroyNotifyVarRef = cbRefPtr
370+ } else {
371+ fcb := func(arg0 uintptr) {
372+ cbFn := *DestroyNotifyVar
373+ cbFn(arg0)
374+ }
375+ DestroyNotifyVarRef = purego.NewCallback(fcb)
376+ glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
377+ }
378+ }
379+
380+ xMenuButtonSetCreatePopupFunc(x.GoPointer(), FuncVarRef, UserDataVar, DestroyNotifyVarRef)
351381
352382 }
353383
M v4/gtk/gtkprintdialog.go +48 -3
@@ -226,7 +226,22 @@ var xPrintDialogPrint func(uintptr, uintptr, *PrintSetup, uintptr, uintptr, uint
226226 // The @callback will be called when the printing is done.
227227 func (x *PrintDialog) Print(ParentVar *Window, SetupVar *PrintSetup, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
228228
229- xPrintDialogPrint(x.GoPointer(), ParentVar.GoPointer(), SetupVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
229+ var CallbackVarRef uintptr
230+ if CallbackVar != nil {
231+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
232+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
233+ CallbackVarRef = cbRefPtr
234+ } else {
235+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
236+ cbFn := *CallbackVar
237+ cbFn(arg0, arg1, arg2)
238+ }
239+ CallbackVarRef = purego.NewCallback(fcb)
240+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
241+ }
242+ }
243+
244+ xPrintDialogPrint(x.GoPointer(), ParentVar.GoPointer(), SetupVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
230245
231246 }
232247
@@ -238,7 +253,22 @@ var xPrintDialogPrintFile func(uintptr, uintptr, *PrintSetup, uintptr, uintptr,
238253 // Otherwise, it will attempt to print directly, without user interaction.
239254 func (x *PrintDialog) PrintFile(ParentVar *Window, SetupVar *PrintSetup, FileVar gio.File, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
240255
241- xPrintDialogPrintFile(x.GoPointer(), ParentVar.GoPointer(), SetupVar, FileVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
256+ var CallbackVarRef uintptr
257+ if CallbackVar != nil {
258+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
259+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
260+ CallbackVarRef = cbRefPtr
261+ } else {
262+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
263+ cbFn := *CallbackVar
264+ cbFn(arg0, arg1, arg2)
265+ }
266+ CallbackVarRef = purego.NewCallback(fcb)
267+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
268+ }
269+ }
270+
271+ xPrintDialogPrintFile(x.GoPointer(), ParentVar.GoPointer(), SetupVar, FileVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
242272
243273 }
244274
@@ -359,7 +389,22 @@ var xPrintDialogSetup func(uintptr, uintptr, uintptr, uintptr, uintptr)
359389 // to do the printing without further user interaction.
360390 func (x *PrintDialog) Setup(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
361391
362- xPrintDialogSetup(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
392+ var CallbackVarRef uintptr
393+ if CallbackVar != nil {
394+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
395+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
396+ CallbackVarRef = cbRefPtr
397+ } else {
398+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
399+ cbFn := *CallbackVar
400+ cbFn(arg0, arg1, arg2)
401+ }
402+ CallbackVarRef = purego.NewCallback(fcb)
403+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
404+ }
405+ }
406+
407+ xPrintDialogSetup(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
363408
364409 }
365410
M v4/gtk/gtkprinter.go +27 -1
@@ -75,7 +75,33 @@ var xEnumeratePrinters func(uintptr, uintptr, uintptr, bool)
7575 // If @func returns true, the enumeration is stopped.
7676 func EnumeratePrinters(FuncVar *PrinterFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify, WaitVar bool) {
7777
78- xEnumeratePrinters(glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DestroyVar), WaitVar)
78+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
79+ 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)
86+ }
87+ FuncVarRef = purego.NewCallback(fcb)
88+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
89+ }
90+
91+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
92+ 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)
99+ }
100+ DestroyVarRef = purego.NewCallback(fcb)
101+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
102+ }
103+
104+ xEnumeratePrinters(FuncVarRef, DataVar, DestroyVarRef, WaitVar)
79105
80106 }
81107
M v4/gtk/gtkprintjob.go +27 -1
@@ -232,7 +232,33 @@ var xPrintJobSend func(uintptr, uintptr, uintptr, uintptr)
232232 // Sends the print job off to the printer.
233233 func (x *PrintJob) Send(CallbackVar *PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar *glib.DestroyNotify) {
234234
235- xPrintJobSend(x.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(DnotifyVar))
235+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
236+ 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)
243+ }
244+ CallbackVarRef = purego.NewCallback(fcb)
245+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
246+ }
247+
248+ DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
249+ 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)
256+ }
257+ DnotifyVarRef = purego.NewCallback(fcb)
258+ glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
259+ }
260+
261+ xPrintJobSend(x.GoPointer(), CallbackVarRef, UserDataVar, DnotifyVarRef)
236262
237263 }
238264
M v4/gtk/gtkprintoperation.go +14 -1
@@ -528,7 +528,20 @@ var xPrintRunPageSetupDialogAsync func(uintptr, uintptr, uintptr, uintptr, uintp
528528 // @done_cb from a signal handler for the ::response signal of the dialog.
529529 func PrintRunPageSetupDialogAsync(ParentVar *Window, PageSetupVar *PageSetup, SettingsVar *PrintSettings, DoneCbVar *PageSetupDoneFunc, DataVar uintptr) {
530530
531- xPrintRunPageSetupDialogAsync(ParentVar.GoPointer(), PageSetupVar.GoPointer(), SettingsVar.GoPointer(), glib.NewCallback(DoneCbVar), DataVar)
531+ DoneCbVarPtr := uintptr(unsafe.Pointer(DoneCbVar))
532+ 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)
539+ }
540+ DoneCbVarRef = purego.NewCallback(fcb)
541+ glib.SaveCallback(DoneCbVarPtr, DoneCbVarRef)
542+ }
543+
544+ xPrintRunPageSetupDialogAsync(ParentVar.GoPointer(), PageSetupVar.GoPointer(), SettingsVar.GoPointer(), DoneCbVarRef, DataVar)
532545
533546 }
534547
M v4/gtk/gtkprintsettings.go +14 -1
@@ -253,7 +253,20 @@ var xPrintSettingsForeach func(uintptr, uintptr, uintptr)
253253 // Calls @func for each key-value pair of @settings.
254254 func (x *PrintSettings) Foreach(FuncVar *PrintSettingsFunc, UserDataVar uintptr) {
255255
256- xPrintSettingsForeach(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar)
256+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
257+ 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)
264+ }
265+ FuncVarRef = purego.NewCallback(fcb)
266+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
267+ }
268+
269+ xPrintSettingsForeach(x.GoPointer(), FuncVarRef, UserDataVar)
257270
258271 }
259272
M v4/gtk/gtkscale.go +31 -1
@@ -352,7 +352,37 @@ var xScaleSetFormatValueFunc func(uintptr, uintptr, uintptr, uintptr)
352352 // [property@Gtk.Scale:digits] property.
353353 func (x *Scale) SetFormatValueFunc(FuncVar *ScaleFormatValueFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
354354
355- xScaleSetFormatValueFunc(x.GoPointer(), glib.NewCallbackNullable(FuncVar), UserDataVar, glib.NewCallbackNullable(DestroyNotifyVar))
355+ var FuncVarRef uintptr
356+ if FuncVar != nil {
357+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
358+ if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
359+ FuncVarRef = cbRefPtr
360+ } else {
361+ fcb := func(arg0 uintptr, arg1 float64, arg2 uintptr) string {
362+ cbFn := *FuncVar
363+ return cbFn(arg0, arg1, arg2)
364+ }
365+ FuncVarRef = purego.NewCallback(fcb)
366+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
367+ }
368+ }
369+
370+ var DestroyNotifyVarRef uintptr
371+ if DestroyNotifyVar != nil {
372+ DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
373+ if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
374+ DestroyNotifyVarRef = cbRefPtr
375+ } else {
376+ fcb := func(arg0 uintptr) {
377+ cbFn := *DestroyNotifyVar
378+ cbFn(arg0)
379+ }
380+ DestroyNotifyVarRef = purego.NewCallback(fcb)
381+ glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
382+ }
383+ }
384+
385+ xScaleSetFormatValueFunc(x.GoPointer(), FuncVarRef, UserDataVar, DestroyNotifyVarRef)
356386
357387 }
358388
M v4/gtk/gtkshortcutaction.go +27 -1
@@ -164,7 +164,33 @@ var xNewCallbackAction func(uintptr, uintptr, uintptr) uintptr
164164 func NewCallbackAction(CallbackVar *ShortcutFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) *CallbackAction {
165165 var cls *CallbackAction
166166
167- cret := xNewCallbackAction(glib.NewCallback(CallbackVar), DataVar, glib.NewCallback(DestroyVar))
167+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
168+ 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)
175+ }
176+ CallbackVarRef = purego.NewCallback(fcb)
177+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
178+ }
179+
180+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
181+ 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)
188+ }
189+ DestroyVarRef = purego.NewCallback(fcb)
190+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
191+ }
192+
193+ cret := xNewCallbackAction(CallbackVarRef, DataVar, DestroyVarRef)
168194
169195 if cret == 0 {
170196 return nil
M v4/gtk/gtkshow.go +18 -1
@@ -2,6 +2,8 @@
22 package gtk
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -29,7 +31,22 @@ var xShowUriFull func(uintptr, string, uint32, uintptr, uintptr, uintptr)
2931 // necessary for sandbox helpers to parent their dialogs properly.
3032 func ShowUriFull(ParentVar *Window, UriVar string, TimestampVar uint32, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
3133
32- xShowUriFull(ParentVar.GoPointer(), UriVar, TimestampVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
34+ var CallbackVarRef uintptr
35+ if CallbackVar != nil {
36+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
37+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
38+ CallbackVarRef = cbRefPtr
39+ } else {
40+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
41+ cbFn := *CallbackVar
42+ cbFn(arg0, arg1, arg2)
43+ }
44+ CallbackVarRef = purego.NewCallback(fcb)
45+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
46+ }
47+ }
48+
49+ xShowUriFull(ParentVar.GoPointer(), UriVar, TimestampVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
3350
3451 }
3552
M v4/gtk/gtktextbuffer.go +27 -1
@@ -627,7 +627,33 @@ var xTextBufferAddCommitNotify func(uintptr, TextBufferNotifyFlags, uintptr, uin
627627 // other signal handlers which may further modify the [type@Gtk.TextBuffer].
628628 func (x *TextBuffer) AddCommitNotify(FlagsVar TextBufferNotifyFlags, CommitNotifyVar *TextBufferCommitNotify, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) uint {
629629
630- cret := xTextBufferAddCommitNotify(x.GoPointer(), FlagsVar, glib.NewCallback(CommitNotifyVar), UserDataVar, glib.NewCallback(DestroyVar))
630+ CommitNotifyVarPtr := uintptr(unsafe.Pointer(CommitNotifyVar))
631+ 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)
638+ }
639+ CommitNotifyVarRef = purego.NewCallback(fcb)
640+ glib.SaveCallback(CommitNotifyVarPtr, CommitNotifyVarRef)
641+ }
642+
643+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
644+ 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)
651+ }
652+ DestroyVarRef = purego.NewCallback(fcb)
653+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
654+ }
655+
656+ cret := xTextBufferAddCommitNotify(x.GoPointer(), FlagsVar, CommitNotifyVarRef, UserDataVar, DestroyVarRef)
631657 return cret
632658 }
633659
M v4/gtk/gtktextiter.go +28 -2
@@ -136,7 +136,20 @@ var xTextIterBackwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
136136 // but goes backward from @iter.
137137 func (x *TextIter) BackwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
138138
139- cret := xTextIterBackwardFindChar(x.GoPointer(), glib.NewCallback(PredVar), UserDataVar, LimitVar)
139+ PredVarPtr := uintptr(unsafe.Pointer(PredVar))
140+ 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)
147+ }
148+ PredVarRef = purego.NewCallback(fcb)
149+ glib.SaveCallback(PredVarPtr, PredVarRef)
150+ }
151+
152+ cret := xTextIterBackwardFindChar(x.GoPointer(), PredVarRef, UserDataVar, LimitVar)
140153 return cret
141154 }
142155
@@ -551,7 +564,20 @@ var xTextIterForwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
551564 // @limit is non-%NULL, otherwise to the end iterator.
552565 func (x *TextIter) ForwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
553566
554- cret := xTextIterForwardFindChar(x.GoPointer(), glib.NewCallback(PredVar), UserDataVar, LimitVar)
567+ PredVarPtr := uintptr(unsafe.Pointer(PredVar))
568+ 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)
575+ }
576+ PredVarRef = purego.NewCallback(fcb)
577+ glib.SaveCallback(PredVarPtr, PredVarRef)
578+ }
579+
580+ cret := xTextIterForwardFindChar(x.GoPointer(), PredVarRef, UserDataVar, LimitVar)
555581 return cret
556582 }
557583
M v4/gtk/gtktexttagtable.go +14 -1
@@ -94,7 +94,20 @@ var xTextTagTableForeach func(uintptr, uintptr, uintptr)
9494 // over it (you can’t add/remove tags).
9595 func (x *TextTagTable) Foreach(FuncVar *TextTagTableForeach, DataVar uintptr) {
9696
97- xTextTagTableForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
97+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
98+ 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)
105+ }
106+ FuncVarRef = purego.NewCallback(fcb)
107+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
108+ }
109+
110+ xTextTagTableForeach(x.GoPointer(), FuncVarRef, DataVar)
98111
99112 }
100113
M v4/gtk/gtktreelistmodel.go +27 -1
@@ -66,7 +66,33 @@ var xNewTreeListModel func(uintptr, bool, bool, uintptr, uintptr, uintptr) uintp
6666 func NewTreeListModel(RootVar gio.ListModel, PassthroughVar bool, AutoexpandVar bool, CreateFuncVar *TreeListModelCreateModelFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *TreeListModel {
6767 var cls *TreeListModel
6868
69- cret := xNewTreeListModel(RootVar.GoPointer(), PassthroughVar, AutoexpandVar, glib.NewCallback(CreateFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))
69+ CreateFuncVarPtr := uintptr(unsafe.Pointer(CreateFuncVar))
70+ 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)
77+ }
78+ CreateFuncVarRef = purego.NewCallback(fcb)
79+ glib.SaveCallback(CreateFuncVarPtr, CreateFuncVarRef)
80+ }
81+
82+ UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
83+ 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)
90+ }
91+ UserDestroyVarRef = purego.NewCallback(fcb)
92+ glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
93+ }
94+
95+ cret := xNewTreeListModel(RootVar.GoPointer(), PassthroughVar, AutoexpandVar, CreateFuncVarRef, UserDataVar, UserDestroyVarRef)
7096
7197 if cret == 0 {
7298 return nil
M v4/gtk/gtktreemodelfilter.go +58 -2
@@ -291,7 +291,35 @@ var xTreeModelFilterSetModifyFunc func(uintptr, int, []types.GType, uintptr, uin
291291 // can only be called once for a given filter model.
292292 func (x *TreeModelFilter) SetModifyFunc(NColumnsVar int, TypesVar []types.GType, FuncVar *TreeModelFilterModifyFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
293293
294- xTreeModelFilterSetModifyFunc(x.GoPointer(), NColumnsVar, TypesVar, glib.NewCallback(FuncVar), DataVar, glib.NewCallbackNullable(DestroyVar))
294+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
295+ 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)
302+ }
303+ FuncVarRef = purego.NewCallback(fcb)
304+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
305+ }
306+
307+ var DestroyVarRef uintptr
308+ if DestroyVar != nil {
309+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
310+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
311+ DestroyVarRef = cbRefPtr
312+ } else {
313+ fcb := func(arg0 uintptr) {
314+ cbFn := *DestroyVar
315+ cbFn(arg0)
316+ }
317+ DestroyVarRef = purego.NewCallback(fcb)
318+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
319+ }
320+ }
321+
322+ xTreeModelFilterSetModifyFunc(x.GoPointer(), NColumnsVar, TypesVar, FuncVarRef, DataVar, DestroyVarRef)
295323
296324 }
297325
@@ -353,7 +381,35 @@ var xTreeModelFilterSetVisibleFunc func(uintptr, uintptr, uintptr, uintptr)
353381 // once for a given filter model.
354382 func (x *TreeModelFilter) SetVisibleFunc(FuncVar *TreeModelFilterVisibleFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
355383
356- xTreeModelFilterSetVisibleFunc(x.GoPointer(), glib.NewCallback(FuncVar), DataVar, glib.NewCallbackNullable(DestroyVar))
384+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
385+ 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)
392+ }
393+ FuncVarRef = purego.NewCallback(fcb)
394+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
395+ }
396+
397+ var DestroyVarRef uintptr
398+ if DestroyVar != nil {
399+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
400+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
401+ DestroyVarRef = cbRefPtr
402+ } else {
403+ fcb := func(arg0 uintptr) {
404+ cbFn := *DestroyVar
405+ cbFn(arg0)
406+ }
407+ DestroyVarRef = purego.NewCallback(fcb)
408+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
409+ }
410+ }
411+
412+ xTreeModelFilterSetVisibleFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyVarRef)
357413
358414 }
359415
M v4/gtk/gtktreeselection.go +43 -2
@@ -213,7 +213,20 @@ var xTreeSelectionSelectedForeach func(uintptr, uintptr, uintptr)
213213 // gtk_tree_selection_get_selected_rows() might be more useful.
214214 func (x *TreeSelection) SelectedForeach(FuncVar *TreeSelectionForeachFunc, DataVar uintptr) {
215215
216- xTreeSelectionSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
216+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
217+ 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)
224+ }
225+ FuncVarRef = purego.NewCallback(fcb)
226+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
227+ }
228+
229+ xTreeSelectionSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
217230
218231 }
219232
@@ -238,7 +251,35 @@ var xTreeSelectionSetSelectFunction func(uintptr, uintptr, uintptr, uintptr)
238251 // if the state of the node should be left unchanged.
239252 func (x *TreeSelection) SetSelectFunction(FuncVar *TreeSelectionFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
240253
241- xTreeSelectionSetSelectFunction(x.GoPointer(), glib.NewCallbackNullable(FuncVar), DataVar, glib.NewCallback(DestroyVar))
254+ var FuncVarRef uintptr
255+ if FuncVar != nil {
256+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
257+ if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
258+ FuncVarRef = cbRefPtr
259+ } else {
260+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 *TreePath, arg3 bool, arg4 uintptr) bool {
261+ cbFn := *FuncVar
262+ return cbFn(arg0, arg1, arg2, arg3, arg4)
263+ }
264+ FuncVarRef = purego.NewCallback(fcb)
265+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
266+ }
267+ }
268+
269+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
270+ 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)
277+ }
278+ DestroyVarRef = purego.NewCallback(fcb)
279+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
280+ }
281+
282+ xTreeSelectionSetSelectFunction(x.GoPointer(), FuncVarRef, DataVar, DestroyVarRef)
242283
243284 }
244285
M v4/gtk/gtktreeview.go +132 -5
@@ -1193,7 +1193,33 @@ var xTreeViewInsertColumnWithDataFunc func(uintptr, int, string, uintptr, uintpt
11931193 // “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
11941194 func (x *TreeView) InsertColumnWithDataFunc(PositionVar int, TitleVar string, CellVar *CellRenderer, FuncVar *TreeCellDataFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) int {
11951195
1196- cret := xTreeViewInsertColumnWithDataFunc(x.GoPointer(), PositionVar, TitleVar, CellVar.GoPointer(), glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DnotifyVar))
1196+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1197+ 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)
1204+ }
1205+ FuncVarRef = purego.NewCallback(fcb)
1206+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
1207+ }
1208+
1209+ DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
1210+ 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)
1217+ }
1218+ DnotifyVarRef = purego.NewCallback(fcb)
1219+ glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
1220+ }
1221+
1222+ cret := xTreeViewInsertColumnWithDataFunc(x.GoPointer(), PositionVar, TitleVar, CellVar.GoPointer(), FuncVarRef, DataVar, DnotifyVarRef)
11971223 return cret
11981224 }
11991225
@@ -1237,7 +1263,20 @@ var xTreeViewMapExpandedRows func(uintptr, uintptr, uintptr)
12371263 // Calls @func on all expanded rows.
12381264 func (x *TreeView) MapExpandedRows(FuncVar *TreeViewMappingFunc, DataVar uintptr) {
12391265
1240- xTreeViewMapExpandedRows(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
1266+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1267+ 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)
1274+ }
1275+ FuncVarRef = purego.NewCallback(fcb)
1276+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
1277+ }
1278+
1279+ xTreeViewMapExpandedRows(x.GoPointer(), FuncVarRef, DataVar)
12411280
12421281 }
12431282
@@ -1340,7 +1379,37 @@ var xTreeViewSetColumnDragFunction func(uintptr, uintptr, uintptr, uintptr)
13401379 // dropped everywhere.
13411380 func (x *TreeView) SetColumnDragFunction(FuncVar *TreeViewColumnDropFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
13421381
1343- xTreeViewSetColumnDragFunction(x.GoPointer(), glib.NewCallbackNullable(FuncVar), UserDataVar, glib.NewCallbackNullable(DestroyVar))
1382+ var FuncVarRef uintptr
1383+ if FuncVar != nil {
1384+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1385+ if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
1386+ FuncVarRef = cbRefPtr
1387+ } else {
1388+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr, arg4 uintptr) bool {
1389+ cbFn := *FuncVar
1390+ return cbFn(arg0, arg1, arg2, arg3, arg4)
1391+ }
1392+ FuncVarRef = purego.NewCallback(fcb)
1393+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
1394+ }
1395+ }
1396+
1397+ var DestroyVarRef uintptr
1398+ if DestroyVar != nil {
1399+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
1400+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
1401+ DestroyVarRef = cbRefPtr
1402+ } else {
1403+ fcb := func(arg0 uintptr) {
1404+ cbFn := *DestroyVar
1405+ cbFn(arg0)
1406+ }
1407+ DestroyVarRef = purego.NewCallback(fcb)
1408+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
1409+ }
1410+ }
1411+
1412+ xTreeViewSetColumnDragFunction(x.GoPointer(), FuncVarRef, UserDataVar, DestroyVarRef)
13441413
13451414 }
13461415
@@ -1548,7 +1617,37 @@ var xTreeViewSetRowSeparatorFunc func(uintptr, uintptr, uintptr, uintptr)
15481617 // function is %NULL, no separators are drawn. This is the default value.
15491618 func (x *TreeView) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
15501619
1551- xTreeViewSetRowSeparatorFunc(x.GoPointer(), glib.NewCallbackNullable(FuncVar), DataVar, glib.NewCallbackNullable(DestroyVar))
1620+ var FuncVarRef uintptr
1621+ if FuncVar != nil {
1622+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
1623+ if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
1624+ FuncVarRef = cbRefPtr
1625+ } else {
1626+ fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 uintptr) bool {
1627+ cbFn := *FuncVar
1628+ return cbFn(arg0, arg1, arg2)
1629+ }
1630+ FuncVarRef = purego.NewCallback(fcb)
1631+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
1632+ }
1633+ }
1634+
1635+ var DestroyVarRef uintptr
1636+ if DestroyVar != nil {
1637+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
1638+ if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
1639+ DestroyVarRef = cbRefPtr
1640+ } else {
1641+ fcb := func(arg0 uintptr) {
1642+ cbFn := *DestroyVar
1643+ cbFn(arg0)
1644+ }
1645+ DestroyVarRef = purego.NewCallback(fcb)
1646+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
1647+ }
1648+ }
1649+
1650+ xTreeViewSetRowSeparatorFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyVarRef)
15521651
15531652 }
15541653
@@ -1600,7 +1699,35 @@ var xTreeViewSetSearchEqualFunc func(uintptr, uintptr, uintptr, uintptr)
16001699 // `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
16011700 func (x *TreeView) SetSearchEqualFunc(SearchEqualFuncVar *TreeViewSearchEqualFunc, SearchUserDataVar uintptr, SearchDestroyVar *glib.DestroyNotify) {
16021701
1603- xTreeViewSetSearchEqualFunc(x.GoPointer(), glib.NewCallback(SearchEqualFuncVar), SearchUserDataVar, glib.NewCallbackNullable(SearchDestroyVar))
1702+ SearchEqualFuncVarPtr := uintptr(unsafe.Pointer(SearchEqualFuncVar))
1703+ 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)
1710+ }
1711+ SearchEqualFuncVarRef = purego.NewCallback(fcb)
1712+ glib.SaveCallback(SearchEqualFuncVarPtr, SearchEqualFuncVarRef)
1713+ }
1714+
1715+ var SearchDestroyVarRef uintptr
1716+ if SearchDestroyVar != nil {
1717+ SearchDestroyVarPtr := uintptr(unsafe.Pointer(SearchDestroyVar))
1718+ if cbRefPtr, ok := glib.GetCallback(SearchDestroyVarPtr); ok {
1719+ SearchDestroyVarRef = cbRefPtr
1720+ } else {
1721+ fcb := func(arg0 uintptr) {
1722+ cbFn := *SearchDestroyVar
1723+ cbFn(arg0)
1724+ }
1725+ SearchDestroyVarRef = purego.NewCallback(fcb)
1726+ glib.SaveCallback(SearchDestroyVarPtr, SearchDestroyVarRef)
1727+ }
1728+ }
1729+
1730+ xTreeViewSetSearchEqualFunc(x.GoPointer(), SearchEqualFuncVarRef, SearchUserDataVar, SearchDestroyVarRef)
16041731
16051732 }
16061733
M v4/gtk/gtktreeviewcolumn.go +29 -1
@@ -523,7 +523,35 @@ var xTreeViewColumnSetCellDataFunc func(uintptr, uintptr, uintptr, uintptr, uint
523523 // older one.
524524 func (x *TreeViewColumn) SetCellDataFunc(CellRendererVar *CellRenderer, FuncVar *TreeCellDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify) {
525525
526- xTreeViewColumnSetCellDataFunc(x.GoPointer(), CellRendererVar.GoPointer(), glib.NewCallbackNullable(FuncVar), FuncDataVar, glib.NewCallback(DestroyVar))
526+ var FuncVarRef uintptr
527+ if FuncVar != nil {
528+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
529+ if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
530+ FuncVarRef = cbRefPtr
531+ } else {
532+ fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 *TreeIter, arg4 uintptr) {
533+ cbFn := *FuncVar
534+ cbFn(arg0, arg1, arg2, arg3, arg4)
535+ }
536+ FuncVarRef = purego.NewCallback(fcb)
537+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
538+ }
539+ }
540+
541+ DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
542+ 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)
549+ }
550+ DestroyVarRef = purego.NewCallback(fcb)
551+ glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
552+ }
553+
554+ xTreeViewColumnSetCellDataFunc(x.GoPointer(), CellRendererVar.GoPointer(), FuncVarRef, FuncDataVar, DestroyVarRef)
527555
528556 }
529557
M v4/gtk/gtkurilauncher.go +16 -1
@@ -95,7 +95,22 @@ var xUriLauncherLaunch func(uintptr, uintptr, uintptr, uintptr, uintptr)
9595 // This may present an app chooser dialog to the user.
9696 func (x *UriLauncher) Launch(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
9797
98- xUriLauncherLaunch(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
98+ var CallbackVarRef uintptr
99+ if CallbackVar != nil {
100+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
101+ if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
102+ CallbackVarRef = cbRefPtr
103+ } else {
104+ fcb := func(arg0 uintptr, arg1 *AsyncResult, arg2 uintptr) {
105+ cbFn := *CallbackVar
106+ cbFn(arg0, arg1, arg2)
107+ }
108+ CallbackVarRef = purego.NewCallback(fcb)
109+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
110+ }
111+ }
112+
113+ xUriLauncherLaunch(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
99114
100115 }
101116
M v4/gtk/gtkwidget.go +69 -4
@@ -159,7 +159,20 @@ var xWidgetClassAddBinding func(uintptr, uint, gdk.ModifierType, uintptr, string
159159 // shortcut.
160160 func (x *WidgetClass) AddBinding(KeyvalVar uint, ModsVar gdk.ModifierType, CallbackVar *ShortcutFunc, FormatStringVar string, varArgs ...interface{}) {
161161
162- xWidgetClassAddBinding(x.GoPointer(), KeyvalVar, ModsVar, glib.NewCallback(CallbackVar), FormatStringVar, varArgs...)
162+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
163+ 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)
170+ }
171+ CallbackVarRef = purego.NewCallback(fcb)
172+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
173+ }
174+
175+ xWidgetClassAddBinding(x.GoPointer(), KeyvalVar, ModsVar, CallbackVarRef, FormatStringVar, varArgs...)
163176
164177 }
165178
@@ -228,7 +241,20 @@ var xWidgetClassBindTemplateCallbackFull func(uintptr, string, uintptr)
228241 // class initializer after calling [method@Gtk.WidgetClass.set_template].
229242 func (x *WidgetClass) BindTemplateCallbackFull(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {
230243
231- xWidgetClassBindTemplateCallbackFull(x.GoPointer(), CallbackNameVar, glib.NewCallback(CallbackSymbolVar))
244+ CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
245+ var CallbackSymbolVarRef uintptr
246+ if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
247+ CallbackSymbolVarRef = cbRefPtr
248+ } else {
249+ fcb := func() {
250+ cbFn := *CallbackSymbolVar
251+ cbFn()
252+ }
253+ CallbackSymbolVarRef = purego.NewCallback(fcb)
254+ glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
255+ }
256+
257+ xWidgetClassBindTemplateCallbackFull(x.GoPointer(), CallbackNameVar, CallbackSymbolVarRef)
232258
233259 }
234260
@@ -328,7 +354,20 @@ var xWidgetClassInstallAction func(uintptr, string, string, uintptr)
328354 // with [method@Gtk.Widget.action_set_enabled]).
329355 func (x *WidgetClass) InstallAction(ActionNameVar string, ParameterTypeVar string, ActivateVar *WidgetActionActivateFunc) {
330356
331- xWidgetClassInstallAction(x.GoPointer(), ActionNameVar, ParameterTypeVar, glib.NewCallback(ActivateVar))
357+ ActivateVarPtr := uintptr(unsafe.Pointer(ActivateVar))
358+ 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)
365+ }
366+ ActivateVarRef = purego.NewCallback(fcb)
367+ glib.SaveCallback(ActivateVarPtr, ActivateVarRef)
368+ }
369+
370+ xWidgetClassInstallAction(x.GoPointer(), ActionNameVar, ParameterTypeVar, ActivateVarRef)
332371
333372 }
334373
@@ -1832,7 +1871,33 @@ var xWidgetAddTickCallback func(uintptr, uintptr, uintptr, uintptr) uint
18321871 // to [method@Gtk.Widget.remove_tick_callback].
18331872 func (x *Widget) AddTickCallback(CallbackVar *TickCallback, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) uint {
18341873
1835- cret := xWidgetAddTickCallback(x.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(NotifyVar))
1874+ CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
1875+ 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)
1882+ }
1883+ CallbackVarRef = purego.NewCallback(fcb)
1884+ glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
1885+ }
1886+
1887+ NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
1888+ 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)
1895+ }
1896+ NotifyVarRef = purego.NewCallback(fcb)
1897+ glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
1898+ }
1899+
1900+ cret := xWidgetAddTickCallback(x.GoPointer(), CallbackVarRef, UserDataVar, NotifyVarRef)
18361901 return cret
18371902 }
18381903
M v4/pango/pango-attributes.go +45 -2
@@ -390,7 +390,20 @@ var xAttrListFilter func(uintptr, uintptr, uintptr) *AttrList
390390 // inserts them into a new list.
391391 func (x *AttrList) Filter(FuncVar *AttrFilterFunc, DataVar uintptr) *AttrList {
392392
393- cret := xAttrListFilter(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
393+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
394+ 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)
401+ }
402+ FuncVarRef = purego.NewCallback(fcb)
403+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
404+ }
405+
406+ cret := xAttrListFilter(x.GoPointer(), FuncVarRef, DataVar)
394407 return cret
395408 }
396409
@@ -1323,7 +1336,37 @@ var xAttrShapeNewWithData func(*Rectangle, *Rectangle, uintptr, uintptr, uintptr
13231336 // rendering the glyph.
13241337 func AttrShapeNewWithData(InkRectVar *Rectangle, LogicalRectVar *Rectangle, DataVar uintptr, CopyFuncVar *AttrDataCopyFunc, DestroyFuncVar *glib.DestroyNotify) *Attribute {
13251338
1326- cret := xAttrShapeNewWithData(InkRectVar, LogicalRectVar, DataVar, glib.NewCallbackNullable(CopyFuncVar), glib.NewCallbackNullable(DestroyFuncVar))
1339+ var CopyFuncVarRef uintptr
1340+ if CopyFuncVar != nil {
1341+ CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
1342+ if cbRefPtr, ok := glib.GetCallback(CopyFuncVarPtr); ok {
1343+ CopyFuncVarRef = cbRefPtr
1344+ } else {
1345+ fcb := func(arg0 uintptr) uintptr {
1346+ cbFn := *CopyFuncVar
1347+ return cbFn(arg0)
1348+ }
1349+ CopyFuncVarRef = purego.NewCallback(fcb)
1350+ glib.SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
1351+ }
1352+ }
1353+
1354+ var DestroyFuncVarRef uintptr
1355+ if DestroyFuncVar != nil {
1356+ DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
1357+ if cbRefPtr, ok := glib.GetCallback(DestroyFuncVarPtr); ok {
1358+ DestroyFuncVarRef = cbRefPtr
1359+ } else {
1360+ fcb := func(arg0 uintptr) {
1361+ cbFn := *DestroyFuncVar
1362+ cbFn(arg0)
1363+ }
1364+ DestroyFuncVarRef = purego.NewCallback(fcb)
1365+ glib.SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
1366+ }
1367+ }
1368+
1369+ cret := xAttrShapeNewWithData(InkRectVar, LogicalRectVar, DataVar, CopyFuncVarRef, DestroyFuncVarRef)
13271370 return cret
13281371 }
13291372
M v4/pango/pango-fontset.go +14 -1
@@ -289,7 +289,20 @@ var xFontsetForeach func(uintptr, uintptr, uintptr)
289289 // If @func returns %TRUE, that stops the iteration.
290290 func (x *Fontset) Foreach(FuncVar *FontsetForeachFunc, DataVar uintptr) {
291291
292- xFontsetForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)
292+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
293+ 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)
300+ }
301+ FuncVarRef = purego.NewCallback(fcb)
302+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
303+ }
304+
305+ xFontsetForeach(x.GoPointer(), FuncVarRef, DataVar)
293306
294307 }
295308
M v4/pangocairo/pangocairo.go +33 -1
@@ -2,6 +2,8 @@
22 package pangocairo
33
44 import (
5+ "unsafe"
6+
57 "github.com/jwijenbergh/purego"
68 "github.com/jwijenbergh/puregotk/pkg/core"
79 "github.com/jwijenbergh/puregotk/v4/cairo"
@@ -236,7 +238,37 @@ var xContextSetShapeRenderer func(uintptr, uintptr, uintptr, uintptr)
236238 // See `PangoCairoShapeRendererFunc` for details.
237239 func ContextSetShapeRenderer(ContextVar *pango.Context, FuncVar *ShapeRendererFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) {
238240
239- xContextSetShapeRenderer(ContextVar.GoPointer(), glib.NewCallbackNullable(FuncVar), DataVar, glib.NewCallbackNullable(DnotifyVar))
241+ var FuncVarRef uintptr
242+ if FuncVar != nil {
243+ FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
244+ if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
245+ FuncVarRef = cbRefPtr
246+ } else {
247+ fcb := func(arg0 *cairo.Context, arg1 *pango.AttrShape, arg2 bool, arg3 uintptr) {
248+ cbFn := *FuncVar
249+ cbFn(arg0, arg1, arg2, arg3)
250+ }
251+ FuncVarRef = purego.NewCallback(fcb)
252+ glib.SaveCallback(FuncVarPtr, FuncVarRef)
253+ }
254+ }
255+
256+ var DnotifyVarRef uintptr
257+ if DnotifyVar != nil {
258+ DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
259+ if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
260+ DnotifyVarRef = cbRefPtr
261+ } else {
262+ fcb := func(arg0 uintptr) {
263+ cbFn := *DnotifyVar
264+ cbFn(arg0)
265+ }
266+ DnotifyVarRef = purego.NewCallback(fcb)
267+ glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
268+ }
269+ }
270+
271+ xContextSetShapeRenderer(ContextVar.GoPointer(), FuncVarRef, DataVar, DnotifyVarRef)
240272
241273 }
242274

Keyboard shortcuts

Single-key shortcuts are on. ctrl k and esc work whatever this says.

ctrl k :
go to a section, branch, tag, file or repository
?
this list
j k
move the row cursor down / up
enter
open the row under the cursor; on Files, a directory opens or closes in place
↑ ↓ ← → home end
in the file tree (focus on a row): previous / next row, close / open a directory or go to its parent / first entry, first / last row. They never open a file
l h
on Files: open a directory or a file / close a directory or go up to its parent, then to the parent page. Elsewhere: into the side panel (on a merge request, its files) / back to the content; there j k move between its controls
g g G
first / last row
/
filter the list; on Files, find a file anywhere in the repository (esc clears, enter opens the best match)
b
switch branch or tag
g s g f g c g b g m g i g r g a
tabs: summary, files, commits, branches & tags, merge requests, issues, releases, actions (when available)
g h
home
w
wide mode: use the whole width of the screen, or not (remembered)
y
copy a permalink pinned to the commit
d u x
diff: split / unified / collapse or expand all
e E
diff: the whole file in view / every file, with the lines the hunks hide
n
merge request: next note in the diff
esc
close a dialog, leave a field

Branches 1

Tags 102

↑↓ moveenter openesc close