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
Split
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
423 // as they should only be loaded when there are classes423 // as they should only be loaded when there are classes
424 needsInit := (len(functions[fn]) + methods) > 0424 needsInit := (len(functions[fn]) + methods) > 0
425 425
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+
426 args := types.TemplateArg{463 args := types.TemplateArg{
427- PkgName: pkgName,464+ PkgName: pkgName,
428- PkgEnv: strings.ToUpper(pkgName),465+ PkgEnv: strings.ToUpper(pkgName),
429- PkgConfigName: pkgConfigName,466+ PkgConfigName: pkgConfigName,
430- SharedLibraries: sharedLibraries,467+ SharedLibraries: sharedLibraries,
431- NeedsInit: needsInit,468+ NeedsInit: needsInit,
432- Aliases: aliases[fn],469+ HasReceiverCallbacks: hasReceiverCallbacks,
433- Callbacks: callbacks[fn],470+ HasFunctionCallbacks: hasFunctionCallbacks,
434- Records: records[fn],471+ Aliases: aliases[fn],
435- Enums: enums[fn],472+ Callbacks: callbacks[fn],
436- Constants: constants[fn],473+ Records: records[fn],
437- Functions: functions[fn],474+ Enums: enums[fn],
438- Interfaces: interfaces[fn],475+ Constants: constants[fn],
439- Classes: classes[fn],476+ Functions: functions[fn],
477+ Interfaces: interfaces[fn],
478+ Classes: classes[fn],
440 }479 }
441 480
442 os.MkdirAll(fmt.Sprintf(dir+"/%s", pkgName), 0o755)481 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 {
53 return p.Value.(Interface)53 return p.Value.(Interface)
54 }54 }
55 55
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+
56 type KindPair struct {67 type KindPair struct {
57 K Kind68 K Kind
58 Value interface{}69 Value interface{}
M internal/gir/types/template.go +70 -1
@@ -17,9 +17,27 @@ type argsTemplate struct {
17 // Call are the variables as given in a function call17 // Call are the variables as given in a function call
18 Call []string18 Call []string
19 19
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+
20 Full []string24 Full []string
21 }25 }
22 26
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+
23 type funcArgsTemplate struct {41 type funcArgsTemplate struct {
24 // Pure are the arguments as passed directly to PureGo42 // Pure are the arguments as passed directly to PureGo
25 // The pure Call is a special case that contains the arguments for a callback call43 // The pure Call is a special case that contains the arguments for a callback call
@@ -27,16 +45,20 @@ type funcArgsTemplate struct {
27 45
28 // API are the arguments as suitable for a Go API46 // API are the arguments as suitable for a Go API
29 API argsTemplate47 API argsTemplate
48+
49+ // Callbacks tracks callback parameters for proper closure generation
50+ Callbacks []CallbackParam
30 }51 }
31 52
32 func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullable bool, isOut bool) {53 func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullable bool, isOut bool) {
33 c := n54 c := n
55+ cRef := n // For CallWithRefs, defaults to same as Call
34 stars := strings.Count(t, "*")56 stars := strings.Count(t, "*")
35 gobjectNs := "gobject."57 gobjectNs := "gobject."
58+ glibNs := "glib."
36 if strings.ToLower(ns) == "gobject" {59 if strings.ToLower(ns) == "gobject" {
37 gobjectNs = ""60 gobjectNs = ""
38 }61 }
39- glibNs := "glib."
40 if strings.ToLower(ns) == "glib" {62 if strings.ToLower(ns) == "glib" {
41 glibNs = ""63 glibNs = ""
42 }64 }
@@ -48,14 +70,19 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
48 t = "*" + t70 t = "*" + t
49 }71 }
50 c = n72 c = n
73+ cRef = n
51 } else {74 } else {
52 switch k {75 switch k {
53 case CallbackType:76 case CallbackType:
77+ // Call uses glib.NewCallback for contexts like callback accessor getters
54 if nullable {78 if nullable {
55 c = fmt.Sprintf("%sNewCallbackNullable(%s)", glibNs, n)79 c = fmt.Sprintf("%sNewCallbackNullable(%s)", glibNs, n)
56 } else {80 } else {
57 c = fmt.Sprintf("%sNewCallback(%s)", glibNs, n)81 c = fmt.Sprintf("%sNewCallback(%s)", glibNs, n)
58 }82 }
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
59 t = "*" + t86 t = "*" + t
60 case ClassesType:87 case ClassesType:
61 if stars == 0 {88 if stars == 0 {
@@ -66,6 +93,7 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
66 } else if stars == 1 {93 } else if stars == 1 {
67 c = n + ".GoPointer()"94 c = n + ".GoPointer()"
68 }95 }
96+ cRef = c
69 case InterfacesType:97 case InterfacesType:
70 t = strings.TrimPrefix(t, "*")98 t = strings.TrimPrefix(t, "*")
71 if stars == 0 {99 if stars == 0 {
@@ -76,17 +104,22 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
76 } else if stars == 1 {104 } else if stars == 1 {
77 c = n + ".GoPointer()"105 c = n + ".GoPointer()"
78 }106 }
107+ cRef = c
108+ default:
109+ cRef = c
79 }110 }
80 111
81 // special case for varargs112 // special case for varargs
82 if n == "varArgs" {113 if n == "varArgs" {
83 c = n + "..."114 c = n + "..."
115+ cRef = c
84 }116 }
85 }117 }
86 118
87 f.API.Names = append(f.API.Names, n)119 f.API.Names = append(f.API.Names, n)
88 f.API.Types = append(f.API.Types, t)120 f.API.Types = append(f.API.Types, t)
89 f.API.Call = append(f.API.Call, c)121 f.API.Call = append(f.API.Call, c)
122+ f.API.CallWithRefs = append(f.API.CallWithRefs, cRef)
90 f.API.Full = append(f.API.Full, n+" "+t)123 f.API.Full = append(f.API.Full, n+" "+t)
91 }124 }
92 125
@@ -153,6 +186,9 @@ func (f *funcArgsTemplate) Add(p Parameter, ins string, ns string, kinds KindMap
153 goType := p.Translate(lns, kinds)186 goType := p.Translate(lns, kinds)
154 kind := kinds.Kind(lns, goType)187 kind := kinds.Kind(lns, goType)
155 188
189+ // Save the original type name before normalization for callback lookup
190+ originalType := goType
191+
156 stars := strings.Count(goType, "*")192 stars := strings.Count(goType, "*")
157 goType = util.NormalizeNamespace(ns, goType, true)193 goType = util.NormalizeNamespace(ns, goType, true)
158 194
@@ -170,10 +206,38 @@ func (f *funcArgsTemplate) Add(p Parameter, ins string, ns string, kinds KindMap
170 206
171 f.AddAPI(goType, varName, kind, ns, p.Nullable, isOut)207 f.AddAPI(goType, varName, kind, ns, p.Nullable, isOut)
172 f.AddPure(goType, varName, kind, isOut)208 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+ }
173 }236 }
174 237
175 func (f *funcArgsTemplate) AddThrows(ns string) {238 func (f *funcArgsTemplate) AddThrows(ns string) {
176 f.API.Call = append(f.API.Call, "&cerr")239 f.API.Call = append(f.API.Call, "&cerr")
240+ f.API.CallWithRefs = append(f.API.CallWithRefs, "&cerr")
177 if strings.ToLower(ns) != "glib" {241 if strings.ToLower(ns) != "glib" {
178 f.Pure.Types = append(f.Pure.Types, "**glib.Error")242 f.Pure.Types = append(f.Pure.Types, "**glib.Error")
179 } else {243 } else {
@@ -483,6 +547,11 @@ type TemplateArg struct {
483 SharedLibraries []string547 SharedLibraries []string
484 // NeedsInit declares whether or not this file needs an init code to register functions with purego548 // NeedsInit declares whether or not this file needs an init code to register functions with purego
485 NeedsInit bool549 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
486 // Imports defines the package imports that we need555 // Imports defines the package imports that we need
487 // This does not include purego556 // This does not include purego
488 // As the template already includes that if `NeedsInit` is set to true557 // As the template already includes that if `NeedsInit` is set to true
M templates/go +202 -9
@@ -9,9 +9,10 @@ package {{.PkgName}}
9 {{ $HasSignals = true }}9 {{ $HasSignals = true }}
10 {{end}}10 {{end}}
11 {{end}}11 {{end}}
12-{{ $NeedsUnsafe := or .Records $HasSignals }}12+{{ $HasCallbacks := or .HasReceiverCallbacks .HasFunctionCallbacks }}
13-{{ $NeedsPurego := or .NeedsInit $HasSignals }}13+{{ $NeedsUnsafe := or .Records $HasSignals $HasCallbacks }}
14-{{ $AnyImports := or .NeedsInit .Records $HasSignals }}14+{{ $NeedsPurego := or .NeedsInit $HasSignals $HasCallbacks }}
15+{{ $AnyImports := or .NeedsInit .Records $HasSignals $HasCallbacks }}
15 16
16 {{if $AnyImports}}17 {{if $AnyImports}}
17 import (18 import (
@@ -66,7 +67,39 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
66 {{.Doc}}67 {{.Doc}}
67 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {68 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
68 {{.Ret.Preamble $NotGLib}}69 {{.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}})
70 {{.Ret.Fmt $NotGObject}}103 {{.Ret.Fmt $NotGObject}}
71 }104 }
72 {{end}}105 {{end}}
@@ -78,7 +111,39 @@ var x{{$outer.Name}}{{.Name}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Ra
78 {{.Doc}}111 {{.Doc}}
79 func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {112 func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
80 {{.Ret.Preamble $NotGLib}}113 {{.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}})
82 {{.Ret.Fmt $NotGObject}}147 {{.Ret.Fmt $NotGObject}}
83 }148 }
84 {{end}}149 {{end}}
@@ -239,7 +304,39 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
239 {{.Doc}}304 {{.Doc}}
240 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {305 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
241 {{.Ret.Preamble $NotGLib}}306 {{.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}})
243 {{.Ret.Fmt $NotGObject}}340 {{.Ret.Fmt $NotGObject}}
244 }341 }
245 {{end}}342 {{end}}
@@ -274,7 +371,39 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
274 {{.Doc}}371 {{.Doc}}
275 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {372 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
276 {{.Ret.Preamble $NotGLib}}373 {{.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}})
278 {{.Ret.Fmt $NotGObject}}407 {{.Ret.Fmt $NotGObject}}
279 }408 }
280 {{end}}409 {{end}}
@@ -286,7 +415,39 @@ var x{{$outer.Name}}{{.Name}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Ra
286 {{.Doc}}415 {{.Doc}}
287 func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {416 func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
288 {{.Ret.Preamble $NotGLib}}417 {{.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}})
290 {{.Ret.Fmt $NotGObject}}451 {{.Ret.Fmt $NotGObject}}
291 }452 }
292 {{end}}453 {{end}}
@@ -369,7 +530,39 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
369 {{.Doc}}530 {{.Doc}}
370 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {531 func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
371 {{.Ret.Preamble $NotGLib}}532 {{.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}})
373 {{.Ret.Fmt $NotGObject}}566 {{.Ret.Fmt $NotGObject}}
374 }567 }
375 {{end}}568 {{end}}
M v4/adw/adw-alert-dialog.go +16 -1
@@ -321,7 +321,22 @@ var xAlertDialogChoose func(uintptr, uintptr, uintptr, uintptr, uintptr)
321 // will be shown within it. Otherwise, it will be a separate window.321 // will be shown within it. Otherwise, it will be a separate window.
322 func (x *AlertDialog) Choose(ParentVar *gtk.Widget, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {322 func (x *AlertDialog) Choose(ParentVar *gtk.Widget, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
323 323
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)
325 340
326 }341 }
327 342
M v4/adw/adw-animation-target.go +27 -1
@@ -92,7 +92,33 @@ var xNewCallbackAnimationTarget func(uintptr, uintptr, uintptr) uintptr
92 func NewCallbackAnimationTarget(CallbackVar *AnimationTargetFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) *CallbackAnimationTarget {92 func NewCallbackAnimationTarget(CallbackVar *AnimationTargetFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) *CallbackAnimationTarget {
93 var cls *CallbackAnimationTarget93 var cls *CallbackAnimationTarget
94 94
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)
96 122
97 if cret == 0 {123 if cret == 0 {
98 return nil124 return nil
M v4/adw/adw-message-dialog.go +16 -1
@@ -294,7 +294,22 @@ var xMessageDialogChoose func(uintptr, uintptr, uintptr, uintptr)
294 // This function shows @self to the user.294 // This function shows @self to the user.
295 func (x *MessageDialog) Choose(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {295 func (x *MessageDialog) Choose(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
296 296
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)
298 313
299 }314 }
300 315
M v4/adw/adw-preferences-group.go +29 -1
@@ -113,7 +113,35 @@ var xPreferencesGroupBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
113 // See [method@Gtk.ListBox.bind_model].113 // See [method@Gtk.ListBox.bind_model].
114 func (x *PreferencesGroup) BindModel(ModelVar gio.ListModel, CreateRowFuncVar *gtk.ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {114 func (x *PreferencesGroup) BindModel(ModelVar gio.ListModel, CreateRowFuncVar *gtk.ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
115 115
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)
117 145
118 }146 }
119 147
M v4/gdk/gdkclipboard.go +80 -5
@@ -114,7 +114,22 @@ var xClipboardReadAsync func(uintptr, []string, int, uintptr, uintptr, uintptr)
114 // to fulfill the request, preferring the ones listed first.114 // to fulfill the request, preferring the ones listed first.
115 func (x *Clipboard) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {115 func (x *Clipboard) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
116 116
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)
118 133
119 }134 }
120 135
@@ -150,7 +165,22 @@ var xClipboardReadTextAsync func(uintptr, uintptr, uintptr, uintptr)
150 // need more control over the operation.165 // need more control over the operation.
151 func (x *Clipboard) ReadTextAsync(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {166 func (x *Clipboard) ReadTextAsync(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
152 167
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)
154 184
155 }185 }
156 186
@@ -179,7 +209,22 @@ var xClipboardReadTextureAsync func(uintptr, uintptr, uintptr, uintptr)
179 // need more control over the operation.209 // need more control over the operation.
180 func (x *Clipboard) ReadTextureAsync(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {210 func (x *Clipboard) ReadTextureAsync(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
181 211
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)
183 228
184 }229 }
185 230
@@ -216,7 +261,22 @@ var xClipboardReadValueAsync func(uintptr, types.GType, int, uintptr, uintptr, u
216 // [func@content_deserialize_async] to convert the clipboard's data.261 // [func@content_deserialize_async] to convert the clipboard's data.
217 func (x *Clipboard) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {262 func (x *Clipboard) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
218 263
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)
220 280
221 }281 }
222 282
@@ -327,7 +387,22 @@ var xClipboardStoreAsync func(uintptr, int, uintptr, uintptr, uintptr)
327 // is shut down, so you likely don't need to call it.387 // is shut down, so you likely don't need to call it.
328 func (x *Clipboard) StoreAsync(IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {388 func (x *Clipboard) StoreAsync(IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
329 389
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)
331 406
332 }407 }
333 408
M v4/gdk/gdkcontentdeserializer.go +59 -3
@@ -2,6 +2,8 @@
2 package gdk2 package gdk
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/gio"9 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -25,7 +27,22 @@ var xContentDeserializeAsync func(uintptr, string, types.GType, int, uintptr, ui
25 // indicate a higher priority.27 // indicate a higher priority.
26 func ContentDeserializeAsync(StreamVar *gio.InputStream, MimeTypeVar string, TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {28 func ContentDeserializeAsync(StreamVar *gio.InputStream, MimeTypeVar string, TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
27 29
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)
29 46
30 }47 }
31 48
@@ -52,7 +69,33 @@ var xContentRegisterDeserializer func(string, types.GType, uintptr, uintptr, uin
52 // so applications can override the built-in deserializers.69 // so applications can override the built-in deserializers.
53 func ContentRegisterDeserializer(MimeTypeVar string, TypeVar types.GType, DeserializeVar *ContentDeserializeFunc, DataVar uintptr, NotifyVar *glib.DestroyNotify) {70 func ContentRegisterDeserializer(MimeTypeVar string, TypeVar types.GType, DeserializeVar *ContentDeserializeFunc, DataVar uintptr, NotifyVar *glib.DestroyNotify) {
54 71
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)
56 99
57 }100 }
58 101
@@ -203,7 +246,20 @@ var xContentDeserializerSetTaskData func(uintptr, uintptr, uintptr)
203 // Associate data with the current deserialization operation.246 // Associate data with the current deserialization operation.
204 func (x *ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar *glib.DestroyNotify) {247 func (x *ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar *glib.DestroyNotify) {
205 248
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)
207 263
208 }264 }
209 265
M v4/gdk/gdkcontentprovider.go +16 -1
@@ -402,7 +402,22 @@ var xContentProviderWriteMimeTypeAsync func(uintptr, string, uintptr, int, uintp
402 // The given @stream will not be closed.402 // The given @stream will not be closed.
403 func (x *ContentProvider) WriteMimeTypeAsync(MimeTypeVar string, StreamVar *gio.OutputStream, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {403 func (x *ContentProvider) WriteMimeTypeAsync(MimeTypeVar string, StreamVar *gio.OutputStream, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
404 404
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)
406 421
407 }422 }
408 423
M v4/gdk/gdkcontentserializer.go +59 -3
@@ -2,6 +2,8 @@
2 package gdk2 package gdk
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/gio"9 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -26,7 +28,33 @@ var xContentRegisterSerializer func(types.GType, string, uintptr, uintptr, uintp
26 // so applications can override the built-in serializers.28 // so applications can override the built-in serializers.
27 func ContentRegisterSerializer(TypeVar types.GType, MimeTypeVar string, SerializeVar *ContentSerializeFunc, DataVar uintptr, NotifyVar *glib.DestroyNotify) {29 func ContentRegisterSerializer(TypeVar types.GType, MimeTypeVar string, SerializeVar *ContentSerializeFunc, DataVar uintptr, NotifyVar *glib.DestroyNotify) {
28 30
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)
30 58
31 }59 }
32 60
@@ -38,7 +66,22 @@ var xContentSerializeAsync func(uintptr, string, *gobject.Value, int, uintptr, u
38 // indicate a higher priority.66 // indicate a higher priority.
39 func ContentSerializeAsync(StreamVar *gio.OutputStream, MimeTypeVar string, ValueVar *gobject.Value, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {67 func ContentSerializeAsync(StreamVar *gio.OutputStream, MimeTypeVar string, ValueVar *gobject.Value, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
40 68
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)
42 85
43 }86 }
44 87
@@ -204,7 +247,20 @@ var xContentSerializerSetTaskData func(uintptr, uintptr, uintptr)
204 // Associate data with the current serialization operation.247 // Associate data with the current serialization operation.
205 func (x *ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar *glib.DestroyNotify) {248 func (x *ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar *glib.DestroyNotify) {
206 249
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)
208 264
209 }265 }
210 266
M v4/gdk/gdkcursor.go +29 -1
@@ -2,6 +2,8 @@
2 package gdk2 package gdk
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/glib"9 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -82,7 +84,33 @@ var xNewCursorFromCallback func(uintptr, uintptr, uintptr, uintptr) uintptr
82 func NewCursorFromCallback(CallbackVar *CursorGetTextureCallback, DataVar uintptr, DestroyVar *glib.DestroyNotify, FallbackVar *Cursor) *Cursor {84 func NewCursorFromCallback(CallbackVar *CursorGetTextureCallback, DataVar uintptr, DestroyVar *glib.DestroyNotify, FallbackVar *Cursor) *Cursor {
83 var cls *Cursor85 var cls *Cursor
84 86
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())
86 114
87 if cret == 0 {115 if cret == 0 {
88 return nil116 return nil
M v4/gdk/gdkdmabuftexturebuilder.go +16 -1
@@ -131,7 +131,22 @@ func (x *DmabufTextureBuilder) Build(DestroyVar *glib.DestroyNotify, DataVar uin
131 var cls *Texture131 var cls *Texture
132 var cerr *glib.Error132 var cerr *glib.Error
133 133
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)
135 150
136 if cret == 0 {151 if cret == 0 {
137 return nil, cerr152 return nil, cerr
M v4/gdk/gdkdrop.go +34 -2
@@ -2,6 +2,8 @@
2 package gdk2 package gdk
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/gio"9 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -161,7 +163,22 @@ var xDropReadAsync func(uintptr, []string, int, uintptr, uintptr, uintptr)
161 // in a format that complies with one of the mime types.163 // in a format that complies with one of the mime types.
162 func (x *Drop) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {164 func (x *Drop) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
163 165
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)
165 182
166 }183 }
167 184
@@ -203,7 +220,22 @@ var xDropReadValueAsync func(uintptr, types.GType, int, uintptr, uintptr, uintpt
203 // try to use [func@Gdk.content_deserialize_async] to convert the data.220 // try to use [func@Gdk.content_deserialize_async] to convert the data.
204 func (x *Drop) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {221 func (x *Drop) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
205 222
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)
207 239
208 }240 }
209 241
M v4/gdk/gdkgltexture.go +14 -1
@@ -47,7 +47,20 @@ var xNewGLTexture func(uintptr, uint, int, int, uintptr, uintptr) uintptr
47 func NewGLTexture(ContextVar *GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar *glib.DestroyNotify, DataVar uintptr) *GLTexture {47 func NewGLTexture(ContextVar *GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar *glib.DestroyNotify, DataVar uintptr) *GLTexture {
48 var cls *GLTexture48 var cls *GLTexture
49 49
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)
51 64
52 if cret == 0 {65 if cret == 0 {
53 return nil66 return nil
M v4/gdk/gdkgltexturebuilder.go +16 -1
@@ -81,7 +81,22 @@ var xGLTextureBuilderBuild func(uintptr, uintptr, uintptr) uintptr
81 func (x *GLTextureBuilder) Build(DestroyVar *glib.DestroyNotify, DataVar uintptr) *Texture {81 func (x *GLTextureBuilder) Build(DestroyVar *glib.DestroyNotify, DataVar uintptr) *Texture {
82 var cls *Texture82 var cls *Texture
83 83
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)
85 100
86 if cret == 0 {101 if cret == 0 {
87 return nil102 return nil
M v4/gdkpixbuf/gdk-pixbuf-animation.go +16 -1
@@ -588,7 +588,22 @@ var xPixbufAnimationNewFromStreamAsync func(uintptr, uintptr, uintptr, uintptr)
588 // result of the operation.588 // result of the operation.
589 func PixbufAnimationNewFromStreamAsync(StreamVar *gio.InputStream, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {589 func PixbufAnimationNewFromStreamAsync(StreamVar *gio.InputStream, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
590 590
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)
592 607
593 }608 }
594 609
M v4/gdkpixbuf/gdk-pixbuf.go +126 -8
@@ -2,6 +2,8 @@
2 package gdkpixbuf2 package gdkpixbuf
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/gio"9 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -219,7 +221,22 @@ var xNewPixbufFromData func([]byte, Colorspace, bool, int, int, int, int, uintpt
219 func NewPixbufFromData(DataVar []byte, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar *PixbufDestroyNotify, DestroyFnDataVar uintptr) *Pixbuf {221 func NewPixbufFromData(DataVar []byte, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar *PixbufDestroyNotify, DestroyFnDataVar uintptr) *Pixbuf {
220 var cls *Pixbuf222 var cls *Pixbuf
221 223
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)
223 240
224 if cret == 0 {241 if cret == 0 {
225 return nil242 return nil
@@ -1144,7 +1161,20 @@ var xPixbufSaveToCallback func(uintptr, uintptr, uintptr, string, **glib.Error,
1144 // See [method@GdkPixbuf.Pixbuf.save] for more details.1161 // See [method@GdkPixbuf.Pixbuf.save] for more details.
1145 func (x *Pixbuf) SaveToCallback(SaveFuncVar *PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar **glib.Error, varArgs ...interface{}) bool {1162 func (x *Pixbuf) SaveToCallback(SaveFuncVar *PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar **glib.Error, varArgs ...interface{}) bool {
1146 1163
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...)
1148 return cret1178 return cret
1149 }1179 }
1150 1180
@@ -1161,7 +1191,20 @@ var xPixbufSaveToCallbackv func(uintptr, uintptr, uintptr, string, []string, []s
1161 func (x *Pixbuf) SaveToCallbackv(SaveFuncVar *PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {1191 func (x *Pixbuf) SaveToCallbackv(SaveFuncVar *PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {
1162 var cerr *glib.Error1192 var cerr *glib.Error
1163 1193
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)
1165 if cerr == nil {1208 if cerr == nil {
1166 return cret, nil1209 return cret, nil
1167 }1210 }
@@ -1201,7 +1244,22 @@ var xPixbufSaveToStreamAsync func(uintptr, uintptr, string, uintptr, uintptr, ui
1201 // the operation.1244 // the operation.
1202 func (x *Pixbuf) SaveToStreamAsync(StreamVar *gio.OutputStream, TypeVar string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr, varArgs ...interface{}) {1245 func (x *Pixbuf) SaveToStreamAsync(StreamVar *gio.OutputStream, TypeVar string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr, varArgs ...interface{}) {
1203 1246
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...)
1205 1263
1206 }1264 }
1207 1265
@@ -1237,7 +1295,22 @@ var xPixbufSaveToStreamvAsync func(uintptr, uintptr, string, []string, []string,
1237 // the operation.1295 // the operation.
1238 func (x *Pixbuf) SaveToStreamvAsync(StreamVar *gio.OutputStream, TypeVar string, OptionKeysVar []string, OptionValuesVar []string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {1296 func (x *Pixbuf) SaveToStreamvAsync(StreamVar *gio.OutputStream, TypeVar string, OptionKeysVar []string, OptionValuesVar []string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1239 1297
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)
1241 1314
1242 }1315 }
1243 1316
@@ -1627,7 +1700,22 @@ var xPixbufGetFileInfoAsync func(string, uintptr, uintptr, uintptr)
1627 // get the result of the operation.1700 // get the result of the operation.
1628 func PixbufGetFileInfoAsync(FilenameVar string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {1701 func PixbufGetFileInfoAsync(FilenameVar string, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1629 1702
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)
1631 1719
1632 }1720 }
1633 1721
@@ -1694,7 +1782,22 @@ var xPixbufNewFromStreamAsync func(uintptr, uintptr, uintptr, uintptr)
1694 // the operation.1782 // the operation.
1695 func PixbufNewFromStreamAsync(StreamVar *gio.InputStream, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {1783 func PixbufNewFromStreamAsync(StreamVar *gio.InputStream, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1696 1784
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)
1698 1801
1699 }1802 }
1700 1803
@@ -1709,7 +1812,22 @@ var xPixbufNewFromStreamAtScaleAsync func(uintptr, int, int, bool, uintptr, uint
1709 // You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.1812 // You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
1710 func PixbufNewFromStreamAtScaleAsync(StreamVar *gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {1813 func PixbufNewFromStreamAtScaleAsync(StreamVar *gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1711 1814
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)
1713 1831
1714 }1832 }
1715 1833
M v4/gio/gappinfo.go +48 -3
@@ -1519,7 +1519,22 @@ var xAppInfoGetDefaultForTypeAsync func(string, bool, uintptr, uintptr, uintptr)
1519 // type.1519 // type.
1520 func AppInfoGetDefaultForTypeAsync(ContentTypeVar string, MustSupportUrisVar bool, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1520 func AppInfoGetDefaultForTypeAsync(ContentTypeVar string, MustSupportUrisVar bool, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1521 1521
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)
1523 1538
1524 }1539 }
1525 1540
@@ -1575,7 +1590,22 @@ var xAppInfoGetDefaultForUriSchemeAsync func(string, uintptr, uintptr, uintptr)
1575 // `ftp` or `sip`.1590 // `ftp` or `sip`.
1576 func AppInfoGetDefaultForUriSchemeAsync(UriSchemeVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1591 func AppInfoGetDefaultForUriSchemeAsync(UriSchemeVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1577 1592
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)
1579 1609
1580 }1610 }
1581 1611
@@ -1663,7 +1693,22 @@ var xAppInfoLaunchDefaultForUriAsync func(string, uintptr, uintptr, uintptr, uin
1663 // in receiving error information from their activation.1693 // in receiving error information from their activation.
1664 func AppInfoLaunchDefaultForUriAsync(UriVar string, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1694 func AppInfoLaunchDefaultForUriAsync(UriVar string, ContextVar *AppLaunchContext, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1665 1695
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)
1667 1712
1668 }1713 }
1669 1714
M v4/gio/gasyncinitable.go +16 -1
@@ -306,7 +306,22 @@ var xAsyncInitableNewvAsync func(types.GType, uint, *gobject.Parameter, int, uin
306 // for any errors.306 // for any errors.
307 func AsyncInitableNewvAsync(ObjectTypeVar types.GType, NParametersVar uint, ParametersVar *gobject.Parameter, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {307 func AsyncInitableNewvAsync(ObjectTypeVar types.GType, NParametersVar uint, ParametersVar *gobject.Parameter, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
308 308
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)
310 325
311 }326 }
312 327
M v4/gio/gbufferedinputstream.go +16 -1
@@ -341,7 +341,22 @@ var xBufferedInputStreamFillAsync func(uintptr, int, int, uintptr, uintptr, uint
341 // of bytes that are required to fill the buffer.341 // of bytes that are required to fill the buffer.
342 func (x *BufferedInputStream) FillAsync(CountVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {342 func (x *BufferedInputStream) FillAsync(CountVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
343 343
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)
345 360
346 }361 }
347 362
M v4/gio/gcancellable.go +29 -1
@@ -290,7 +290,35 @@ var xCancellableConnect func(uintptr, uintptr, uintptr, uintptr) uint32
290 // - [method@Gio.Cancellable.release_fd]290 // - [method@Gio.Cancellable.release_fd]
291 func (x *Cancellable) Connect(CallbackVar *gobject.Callback, DataVar uintptr, DataDestroyFuncVar *glib.DestroyNotify) uint32 {291 func (x *Cancellable) Connect(CallbackVar *gobject.Callback, DataVar uintptr, DataDestroyFuncVar *glib.DestroyNotify) uint32 {
292 292
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)
294 return cret322 return cret
295 }323 }
296 324
M v4/gio/gdatainputstream.go +48 -3
@@ -309,7 +309,22 @@ var xDataInputStreamReadLineAsync func(uintptr, int, uintptr, uintptr, uintptr)
309 // the result of the operation.309 // the result of the operation.
310 func (x *DataInputStream) ReadLineAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {310 func (x *DataInputStream) ReadLineAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
311 311
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)
313 328
314 }329 }
315 330
@@ -465,7 +480,22 @@ var xDataInputStreamReadUntilAsync func(uintptr, string, int, uintptr, uintptr,
465 // g_data_input_stream_read_upto_async() instead.480 // g_data_input_stream_read_upto_async() instead.
466 func (x *DataInputStream) ReadUntilAsync(StopCharsVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {481 func (x *DataInputStream) ReadUntilAsync(StopCharsVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
467 482
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)
469 499
470 }500 }
471 501
@@ -527,7 +557,22 @@ var xDataInputStreamReadUptoAsync func(uintptr, string, int, int, uintptr, uintp
527 // the result of the operation.557 // the result of the operation.
528 func (x *DataInputStream) ReadUptoAsync(StopCharsVar string, StopCharsLenVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {558 func (x *DataInputStream) ReadUptoAsync(StopCharsVar string, StopCharsLenVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
529 559
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)
531 576
532 }577 }
533 578
M v4/gio/gdbusaddress.go +18 -1
@@ -2,6 +2,8 @@
2 package gio2 package gio
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/glib"9 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -56,7 +58,22 @@ var xDbusAddressGetStream func(string, uintptr, uintptr, uintptr)
56 // g_dbus_address_get_stream_sync() for the synchronous version.58 // g_dbus_address_get_stream_sync() for the synchronous version.
57 func DbusAddressGetStream(AddressVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {59 func DbusAddressGetStream(AddressVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
58 60
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)
60 77
61 }78 }
62 79
M v4/gio/gdbusconnection.go +212 -12
@@ -225,7 +225,22 @@ var xBusGet func(BusType, uintptr, uintptr, uintptr)
225 // the synchronous version.225 // the synchronous version.
226 func BusGet(BusTypeVar BusType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {226 func BusGet(BusTypeVar BusType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
227 227
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)
229 244
230 }245 }
231 246
@@ -512,7 +527,33 @@ var xDBusConnectionAddFilter func(uintptr, uintptr, uintptr, uintptr) uint
512 // destroyed.)527 // destroyed.)
513 func (x *DBusConnection) AddFilter(FilterFunctionVar *DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {528 func (x *DBusConnection) AddFilter(FilterFunctionVar *DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
514 529
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)
516 return cret557 return cret
517 }558 }
518 559
@@ -567,7 +608,22 @@ var xDBusConnectionCall func(uintptr, string, string, string, string, *glib.Vari
567 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.608 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
568 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) {609 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) {
569 610
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)
571 627
572 }628 }
573 629
@@ -655,7 +711,22 @@ var xDBusConnectionCallWithUnixFdList func(uintptr, string, string, string, stri
655 // This method is only available on UNIX.711 // This method is only available on UNIX.
656 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) {712 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) {
657 713
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)
659 730
660 }731 }
661 732
@@ -730,7 +801,22 @@ var xDBusConnectionClose func(uintptr, uintptr, uintptr, uintptr)
730 // version.801 // version.
731 func (x *DBusConnection) Close(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {802 func (x *DBusConnection) Close(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
732 803
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)
734 820
735 }821 }
736 822
@@ -866,7 +952,22 @@ var xDBusConnectionFlush func(uintptr, uintptr, uintptr, uintptr)
866 // version.952 // version.
867 func (x *DBusConnection) Flush(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {953 func (x *DBusConnection) Flush(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
868 954
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)
870 971
871 }972 }
872 973
@@ -1063,7 +1164,20 @@ var xDBusConnectionRegisterObject func(uintptr, string, *DBusInterfaceInfo, *DBu
1063 func (x *DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar *DBusInterfaceInfo, VtableVar *DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {1164 func (x *DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar *DBusInterfaceInfo, VtableVar *DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
1064 var cerr *glib.Error1165 var cerr *glib.Error
1065 1166
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)
1067 if cerr == nil {1181 if cerr == nil {
1068 return cret, nil1182 return cret, nil
1069 }1183 }
@@ -1155,7 +1269,20 @@ var xDBusConnectionRegisterSubtree func(uintptr, string, *DBusSubtreeVTable, DBu
1155 func (x *DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar *DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {1269 func (x *DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar *DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
1156 var cerr *glib.Error1270 var cerr *glib.Error
1157 1271
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)
1159 if cerr == nil {1286 if cerr == nil {
1160 return cret, nil1287 return cret, nil
1161 }1288 }
@@ -1248,7 +1375,22 @@ var xDBusConnectionSendMessageWithReply func(uintptr, uintptr, DBusSendMessageFl
1248 // UNIX file descriptors.1375 // UNIX file descriptors.
1249 func (x *DBusConnection) SendMessageWithReply(MessageVar *DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar *uint32, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1376 func (x *DBusConnection) SendMessageWithReply(MessageVar *DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar *uint32, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1250 1377
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)
1252 1394
1253 }1395 }
1254 1396
@@ -1405,7 +1547,35 @@ var xDBusConnectionSignalSubscribe func(uintptr, string, string, string, string,
1405 // This function can never fail.1547 // This function can never fail.
1406 func (x *DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar *DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {1548 func (x *DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar *DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
1407 1549
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)
1409 return cret1579 return cret
1410 }1580 }
1411 1581
@@ -1794,7 +1964,22 @@ var xDBusConnectionNew func(uintptr, string, DBusConnectionFlags, uintptr, uintp
1794 // version.1964 // version.
1795 func DBusConnectionNew(StreamVar *IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1965 func DBusConnectionNew(StreamVar *IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1796 1966
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)
1798 1983
1799 }1984 }
1800 1985
@@ -1824,7 +2009,22 @@ var xDBusConnectionNewForAddress func(string, DBusConnectionFlags, uintptr, uint
1824 // version.2009 // version.
1825 func DBusConnectionNewForAddress(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {2010 func DBusConnectionNewForAddress(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar *DBusAuthObserver, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1826 2011
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)
1828 2028
1829 }2029 }
1830 2030
M v4/gio/gdbusnameowning.go +109 -2
@@ -2,6 +2,8 @@
2 package gio2 package gio
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/glib"9 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -71,7 +73,67 @@ var xBusOwnName func(BusType, string, BusNameOwnerFlags, uintptr, uintptr, uintp
71 // unregister the objects (if any) in @name_lost_handler.73 // unregister the objects (if any) in @name_lost_handler.
72 func BusOwnName(BusTypeVar BusType, NameVar string, FlagsVar BusNameOwnerFlags, BusAcquiredHandlerVar *BusAcquiredCallback, NameAcquiredHandlerVar *BusNameAcquiredCallback, NameLostHandlerVar *BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {74 func BusOwnName(BusTypeVar BusType, NameVar string, FlagsVar BusNameOwnerFlags, BusAcquiredHandlerVar *BusAcquiredCallback, NameAcquiredHandlerVar *BusNameAcquiredCallback, NameLostHandlerVar *BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
73 75
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)
75 return cret137 return cret
76 }138 }
77 139
@@ -81,7 +143,52 @@ var xBusOwnNameOnConnection func(uintptr, string, BusNameOwnerFlags, uintptr, ui
81 // of a [enum@Gio.BusType].143 // of a [enum@Gio.BusType].
82 func BusOwnNameOnConnection(ConnectionVar *DBusConnection, NameVar string, FlagsVar BusNameOwnerFlags, NameAcquiredHandlerVar *BusNameAcquiredCallback, NameLostHandlerVar *BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {144 func BusOwnNameOnConnection(ConnectionVar *DBusConnection, NameVar string, FlagsVar BusNameOwnerFlags, NameAcquiredHandlerVar *BusNameAcquiredCallback, NameLostHandlerVar *BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
83 145
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)
85 return cret192 return cret
86 }193 }
87 194
M v4/gio/gdbusnamewatching.go +94 -2
@@ -2,6 +2,8 @@
2 package gio2 package gio
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/glib"9 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -67,7 +69,52 @@ var xBusWatchName func(BusType, string, BusNameWatcherFlags, uintptr, uintptr, u
67 // @name_vanished_handler.69 // @name_vanished_handler.
68 func BusWatchName(BusTypeVar BusType, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar *BusNameAppearedCallback, NameVanishedHandlerVar *BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {70 func BusWatchName(BusTypeVar BusType, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar *BusNameAppearedCallback, NameVanishedHandlerVar *BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
69 71
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)
71 return cret118 return cret
72 }119 }
73 120
@@ -77,7 +124,52 @@ var xBusWatchNameOnConnection func(uintptr, string, BusNameWatcherFlags, uintptr
77 // #GBusType.124 // #GBusType.
78 func BusWatchNameOnConnection(ConnectionVar *DBusConnection, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar *BusNameAppearedCallback, NameVanishedHandlerVar *BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {125 func BusWatchNameOnConnection(ConnectionVar *DBusConnection, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar *BusNameAppearedCallback, NameVanishedHandlerVar *BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
79 126
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)
81 return cret173 return cret
82 }174 }
83 175
M v4/gio/gdbusobjectmanagerclient.go +154 -4
@@ -235,7 +235,37 @@ func NewDBusObjectManagerClientForBusSync(BusTypeVar BusType, FlagsVar DBusObjec
235 var cls *DBusObjectManagerClient235 var cls *DBusObjectManagerClient
236 var cerr *glib.Error236 var cerr *glib.Error
237 237
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)
239 269
240 if cret == 0 {270 if cret == 0 {
241 return nil, cerr271 return nil, cerr
@@ -260,7 +290,37 @@ func NewDBusObjectManagerClientSync(ConnectionVar *DBusConnection, FlagsVar DBus
260 var cls *DBusObjectManagerClient290 var cls *DBusObjectManagerClient
261 var cerr *glib.Error291 var cerr *glib.Error
262 292
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)
264 324
265 if cret == 0 {325 if cret == 0 {
266 return nil, cerr326 return nil, cerr
@@ -666,7 +726,52 @@ var xDBusObjectManagerClientNew func(uintptr, DBusObjectManagerClientFlags, stri
666 // g_dbus_object_manager_client_new_sync() for the synchronous version.726 // g_dbus_object_manager_client_new_sync() for the synchronous version.
667 func DBusObjectManagerClientNew(ConnectionVar *DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {727 func DBusObjectManagerClientNew(ConnectionVar *DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
668 728
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)
670 775
671 }776 }
672 777
@@ -683,7 +788,52 @@ var xDBusObjectManagerClientNewForBus func(BusType, DBusObjectManagerClientFlags
683 // g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.788 // g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
684 func DBusObjectManagerClientNewForBus(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {789 func DBusObjectManagerClientNewForBus(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar *DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar *glib.DestroyNotify, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
685 790
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)
687 837
688 }838 }
689 839
M v4/gio/gdbusproxy.go +64 -4
@@ -305,7 +305,22 @@ var xDBusProxyCall func(uintptr, string, *glib.Variant, DBusCallFlags, int, uint
305 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.305 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
306 func (x *DBusProxy) Call(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {306 func (x *DBusProxy) Call(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
307 307
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)
309 324
310 }325 }
311 326
@@ -379,7 +394,22 @@ var xDBusProxyCallWithUnixFdList func(uintptr, string, *glib.Variant, DBusCallFl
379 // This method is only available on UNIX.394 // This method is only available on UNIX.
380 func (x *DBusProxy) CallWithUnixFdList(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {395 func (x *DBusProxy) CallWithUnixFdList(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
381 396
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)
383 413
384 }414 }
385 415
@@ -1024,7 +1054,22 @@ var xDBusProxyNew func(uintptr, DBusProxyFlags, *DBusInterfaceInfo, string, stri
1024 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].1054 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
1025 func DBusProxyNew(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1055 func DBusProxyNew(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1026 1056
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)
1028 1073
1029 }1074 }
1030 1075
@@ -1035,7 +1080,22 @@ var xDBusProxyNewForBus func(BusType, DBusProxyFlags, *DBusInterfaceInfo, string
1035 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].1080 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
1036 func DBusProxyNewForBus(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1081 func DBusProxyNewForBus(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1037 1082
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)
1039 1099
1040 }1100 }
1041 1101
M v4/gio/gfile.go +32 -2
@@ -6196,7 +6196,22 @@ var xFileNewTmpAsync func(string, int, uintptr, uintptr, uintptr)
6196 // directory components. If it is %NULL, a default template is used.6196 // directory components. If it is %NULL, a default template is used.
6197 func FileNewTmpAsync(TmplVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {6197 func FileNewTmpAsync(TmplVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
6198 6198
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)
6200 6215
6201 }6216 }
6202 6217
@@ -6210,7 +6225,22 @@ var xFileNewTmpDirAsync func(string, int, uintptr, uintptr, uintptr)
6210 // directory components. If it is %NULL, a default template is used.6225 // directory components. If it is %NULL, a default template is used.
6211 func FileNewTmpDirAsync(TmplVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {6226 func FileNewTmpDirAsync(TmplVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
6212 6227
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)
6214 6244
6215 }6245 }
6216 6246
M v4/gio/gfileenumerator.go +32 -2
@@ -436,7 +436,22 @@ var xFileEnumeratorCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
436 // g_file_enumerator_close_finish().436 // g_file_enumerator_close_finish().
437 func (x *FileEnumerator) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {437 func (x *FileEnumerator) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
438 438
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)
440 455
441 }456 }
442 457
@@ -688,7 +703,22 @@ var xFileEnumeratorNextFilesAsync func(uintptr, int, int, uintptr, uintptr, uint
688 // priority is %G_PRIORITY_DEFAULT.703 // priority is %G_PRIORITY_DEFAULT.
689 func (x *FileEnumerator) NextFilesAsync(NumFilesVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {704 func (x *FileEnumerator) NextFilesAsync(NumFilesVar int, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
690 705
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)
692 722
693 }723 }
694 724
M v4/gio/gfileinputstream.go +16 -1
@@ -389,7 +389,22 @@ var xFileInputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr,
389 // was cancelled, the error %G_IO_ERROR_CANCELLED will be set389 // was cancelled, the error %G_IO_ERROR_CANCELLED will be set
390 func (x *FileInputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {390 func (x *FileInputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
391 391
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)
393 408
394 }409 }
395 410
M v4/gio/gfileiostream.go +16 -1
@@ -492,7 +492,22 @@ var xFileIOStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr, uin
492 // g_file_io_stream_query_info().492 // g_file_io_stream_query_info().
493 func (x *FileIOStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {493 func (x *FileIOStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
494 494
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)
496 511
497 }512 }
498 513
M v4/gio/gfileoutputstream.go +16 -1
@@ -487,7 +487,22 @@ var xFileOutputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr,
487 // g_file_output_stream_query_info().487 // g_file_output_stream_query_info().
488 func (x *FileOutputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {488 func (x *FileOutputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
489 489
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)
491 506
492 }507 }
493 508
M v4/gio/ginputstream.go +80 -5
@@ -468,7 +468,22 @@ var xInputStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
468 // override one you must override all.468 // override one you must override all.
469 func (x *InputStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {469 func (x *InputStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
470 470
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)
472 487
473 }488 }
474 489
@@ -584,7 +599,22 @@ var xInputStreamReadAllAsync func(uintptr, *[]byte, uint, int, uintptr, uintptr,
584 // priority. Default priority is %G_PRIORITY_DEFAULT.599 // priority. Default priority is %G_PRIORITY_DEFAULT.
585 func (x *InputStream) ReadAllAsync(BufferVar *[]byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {600 func (x *InputStream) ReadAllAsync(BufferVar *[]byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
586 601
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)
588 618
589 }619 }
590 620
@@ -637,7 +667,22 @@ var xInputStreamReadAsync func(uintptr, *[]byte, uint, int, uintptr, uintptr, ui
637 // override one you must override all.667 // override one you must override all.
638 func (x *InputStream) ReadAsync(BufferVar *[]byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {668 func (x *InputStream) ReadAsync(BufferVar *[]byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
639 669
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)
641 686
642 }687 }
643 688
@@ -701,7 +746,22 @@ var xInputStreamReadBytesAsync func(uintptr, uint, int, uintptr, uintptr, uintpt
701 // priority. Default priority is %G_PRIORITY_DEFAULT.746 // priority. Default priority is %G_PRIORITY_DEFAULT.
702 func (x *InputStream) ReadBytesAsync(CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {747 func (x *InputStream) ReadBytesAsync(CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
703 748
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)
705 765
706 }766 }
707 767
@@ -803,7 +863,22 @@ var xInputStreamSkipAsync func(uintptr, uint, int, uintptr, uintptr, uintptr)
803 // However, if you override one, you must override all.863 // However, if you override one, you must override all.
804 func (x *InputStream) SkipAsync(CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {864 func (x *InputStream) SkipAsync(CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
805 865
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)
807 882
808 }883 }
809 884
M v4/gio/gioscheduler.go +31 -1
@@ -2,6 +2,8 @@
2 package gio2 package gio
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/glib"9 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -31,7 +33,35 @@ var xIoSchedulerPushJob func(uintptr, uintptr, uintptr, int, uintptr)
31 // g_io_scheduler_cancel_all_jobs().33 // g_io_scheduler_cancel_all_jobs().
32 func IoSchedulerPushJob(JobFuncVar *IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {34 func IoSchedulerPushJob(JobFuncVar *IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {
33 35
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())
35 65
36 }66 }
37 67
M v4/gio/giostream.go +32 -2
@@ -558,7 +558,22 @@ var xIOStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
558 // classes. However, if you override one you must override all.558 // classes. However, if you override one you must override all.
559 func (x *IOStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {559 func (x *IOStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
560 560
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)
562 577
563 }578 }
564 579
@@ -657,7 +672,22 @@ var xIOStreamSpliceAsync func(uintptr, uintptr, IOStreamSpliceFlags, int, uintpt
657 // result of the operation.672 // result of the operation.
658 func (x *IOStream) SpliceAsync(Stream2Var *IOStream, FlagsVar IOStreamSpliceFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {673 func (x *IOStream) SpliceAsync(Stream2Var *IOStream, FlagsVar IOStreamSpliceFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
659 674
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)
661 691
662 }692 }
663 693
M v4/gio/giotypes.go +58 -2
@@ -400,7 +400,35 @@ var xIOSchedulerJobSendToMainloop func(uintptr, uintptr, uintptr, uintptr) bool
400 // blocking the I/O job).400 // blocking the I/O job).
401 func (x *IOSchedulerJob) SendToMainloop(FuncVar *glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) bool {401 func (x *IOSchedulerJob) SendToMainloop(FuncVar *glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) bool {
402 402
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)
404 return cret432 return cret
405 }433 }
406 434
@@ -417,7 +445,35 @@ var xIOSchedulerJobSendToMainloopAsync func(uintptr, uintptr, uintptr, uintptr)
417 // g_io_scheduler_push_job() or by using refcounting for @user_data.445 // g_io_scheduler_push_job() or by using refcounting for @user_data.
418 func (x *IOSchedulerJob) SendToMainloopAsync(FuncVar *glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) {446 func (x *IOSchedulerJob) SendToMainloopAsync(FuncVar *glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) {
419 447
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)
421 477
422 }478 }
423 479
M v4/gio/gliststore.go +56 -4
@@ -100,7 +100,20 @@ var xListStoreFindWithEqualFunc func(uintptr, uintptr, uintptr, *uint) bool
100 // Since GLib 2.76 it is possible to pass `NULL` for @item.100 // Since GLib 2.76 it is possible to pass `NULL` for @item.
101 func (x *ListStore) FindWithEqualFunc(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFunc, PositionVar *uint) bool {101 func (x *ListStore) FindWithEqualFunc(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFunc, PositionVar *uint) bool {
102 102
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)
104 return cret117 return cret
105 }118 }
106 119
@@ -114,7 +127,20 @@ var xListStoreFindWithEqualFuncFull func(uintptr, uintptr, uintptr, uintptr, *ui
114 // Since GLib 2.76 it is possible to pass `NULL` for @item.127 // Since GLib 2.76 it is possible to pass `NULL` for @item.
115 func (x *ListStore) FindWithEqualFuncFull(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFuncFull, UserDataVar uintptr, PositionVar *uint) bool {128 func (x *ListStore) FindWithEqualFuncFull(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFuncFull, UserDataVar uintptr, PositionVar *uint) bool {
116 129
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)
118 return cret144 return cret
119 }145 }
120 146
@@ -146,7 +172,20 @@ var xListStoreInsertSorted func(uintptr, uintptr, uintptr, uintptr) uint
146 // This function takes a ref on @item.172 // This function takes a ref on @item.
147 func (x *ListStore) InsertSorted(ItemVar *gobject.Object, CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) uint {173 func (x *ListStore) InsertSorted(ItemVar *gobject.Object, CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) uint {
148 174
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)
150 return cret189 return cret
151 }190 }
152 191
@@ -177,7 +216,20 @@ var xListStoreSort func(uintptr, uintptr, uintptr)
177 // Sort the items in @store according to @compare_func.216 // Sort the items in @store according to @compare_func.
178 func (x *ListStore) Sort(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) {217 func (x *ListStore) Sort(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) {
179 218
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)
181 233
182 }234 }
183 235
M v4/gio/gmemoryinputstream.go +32 -2
@@ -213,7 +213,22 @@ var xNewMemoryInputStreamFromData func([]byte, int, uintptr) uintptr
213 func NewMemoryInputStreamFromData(DataVar []byte, LenVar int, DestroyVar *glib.DestroyNotify) *MemoryInputStream {213 func NewMemoryInputStreamFromData(DataVar []byte, LenVar int, DestroyVar *glib.DestroyNotify) *MemoryInputStream {
214 var cls *MemoryInputStream214 var cls *MemoryInputStream
215 215
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)
217 232
218 if cret == 0 {233 if cret == 0 {
219 return nil234 return nil
@@ -237,7 +252,22 @@ var xMemoryInputStreamAddData func(uintptr, []byte, int, uintptr)
237 // Appends @data to data that can be read from the input stream252 // Appends @data to data that can be read from the input stream
238 func (x *MemoryInputStream) AddData(DataVar []byte, LenVar int, DestroyVar *glib.DestroyNotify) {253 func (x *MemoryInputStream) AddData(DataVar []byte, LenVar int, DestroyVar *glib.DestroyNotify) {
239 254
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)
241 271
242 }272 }
243 273
M v4/gio/gmemoryoutputstream.go +31 -1
@@ -228,7 +228,37 @@ var xNewMemoryOutputStream func(uintptr, uint, uintptr, uintptr) uintptr
228 func NewMemoryOutputStream(DataVar uintptr, SizeVar uint, ReallocFunctionVar *ReallocFunc, DestroyFunctionVar *glib.DestroyNotify) *MemoryOutputStream {228 func NewMemoryOutputStream(DataVar uintptr, SizeVar uint, ReallocFunctionVar *ReallocFunc, DestroyFunctionVar *glib.DestroyNotify) *MemoryOutputStream {
229 var cls *MemoryOutputStream229 var cls *MemoryOutputStream
230 230
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)
232 262
233 if cret == 0 {263 if cret == 0 {
234 return nil264 return nil
M v4/gio/goutputstream.go +128 -8
@@ -628,7 +628,22 @@ var xOutputStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
628 // classes. However, if you override one you must override all.628 // classes. However, if you override one you must override all.
629 func (x *OutputStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {629 func (x *OutputStream) CloseAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
630 630
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)
632 647
633 }648 }
634 649
@@ -679,7 +694,22 @@ var xOutputStreamFlushAsync func(uintptr, int, uintptr, uintptr, uintptr)
679 // result of the operation.694 // result of the operation.
680 func (x *OutputStream) FlushAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {695 func (x *OutputStream) FlushAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
681 696
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)
683 713
684 }714 }
685 715
@@ -788,7 +818,22 @@ var xOutputStreamSpliceAsync func(uintptr, uintptr, OutputStreamSpliceFlags, int
788 // g_output_stream_splice().818 // g_output_stream_splice().
789 func (x *OutputStream) SpliceAsync(SourceVar *InputStream, FlagsVar OutputStreamSpliceFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {819 func (x *OutputStream) SpliceAsync(SourceVar *InputStream, FlagsVar OutputStreamSpliceFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
790 820
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)
792 837
793 }838 }
794 839
@@ -910,7 +955,22 @@ var xOutputStreamWriteAllAsync func(uintptr, []byte, uint, int, uintptr, uintptr
910 // until @callback is called.955 // until @callback is called.
911 func (x *OutputStream) WriteAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {956 func (x *OutputStream) WriteAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
912 957
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)
914 974
915 }975 }
916 976
@@ -976,7 +1036,22 @@ var xOutputStreamWriteAsync func(uintptr, []byte, uint, int, uintptr, uintptr, u
976 // the contents (without copying) for the duration of the call.1036 // the contents (without copying) for the duration of the call.
977 func (x *OutputStream) WriteAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1037 func (x *OutputStream) WriteAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
978 1038
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)
980 1055
981 }1056 }
982 1057
@@ -1021,7 +1096,22 @@ var xOutputStreamWriteBytesAsync func(uintptr, *glib.Bytes, int, uintptr, uintpt
1021 // g_output_stream_write_bytes().1096 // g_output_stream_write_bytes().
1022 func (x *OutputStream) WriteBytesAsync(BytesVar *glib.Bytes, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1097 func (x *OutputStream) WriteBytesAsync(BytesVar *glib.Bytes, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1023 1098
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)
1025 1115
1026 }1116 }
1027 1117
@@ -1144,7 +1234,22 @@ var xOutputStreamWritevAllAsync func(uintptr, []OutputVector, uint, int, uintptr
1144 // of @vectors might be changed by this function.1234 // of @vectors might be changed by this function.
1145 func (x *OutputStream) WritevAllAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1235 func (x *OutputStream) WritevAllAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1146 1236
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)
1148 1253
1149 }1254 }
1150 1255
@@ -1205,7 +1310,22 @@ var xOutputStreamWritevAsync func(uintptr, []OutputVector, uint, int, uintptr, u
1205 // until @callback is called.1310 // until @callback is called.
1206 func (x *OutputStream) WritevAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {1311 func (x *OutputStream) WritevAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1207 1312
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)
1209 1329
1210 }1330 }
1211 1331
M v4/gio/gpermission.go +32 -2
@@ -249,7 +249,22 @@ var xPermissionAcquireAsync func(uintptr, uintptr, uintptr, uintptr)
249 // g_permission_acquire().249 // g_permission_acquire().
250 func (x *Permission) AcquireAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {250 func (x *Permission) AcquireAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
251 251
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)
253 268
254 }269 }
255 270
@@ -353,7 +368,22 @@ var xPermissionReleaseAsync func(uintptr, uintptr, uintptr, uintptr)
353 // g_permission_release().368 // g_permission_release().
354 func (x *Permission) ReleaseAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {369 func (x *Permission) ReleaseAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
355 370
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)
357 387
358 }388 }
359 389
M v4/gio/gresolver.go +80 -5
@@ -531,7 +531,22 @@ var xResolverLookupByAddressAsync func(uintptr, uintptr, uintptr, uintptr, uintp
531 // call g_resolver_lookup_by_address_finish() to get the final result.531 // call g_resolver_lookup_by_address_finish() to get the final result.
532 func (x *Resolver) LookupByAddressAsync(AddressVar *InetAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {532 func (x *Resolver) LookupByAddressAsync(AddressVar *InetAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
533 533
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)
535 550
536 }551 }
537 552
@@ -598,7 +613,22 @@ var xResolverLookupByNameAsync func(uintptr, string, uintptr, uintptr, uintptr)
598 // See g_resolver_lookup_by_name() for more details.613 // See g_resolver_lookup_by_name() for more details.
599 func (x *Resolver) LookupByNameAsync(HostnameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {614 func (x *Resolver) LookupByNameAsync(HostnameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
600 615
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)
602 632
603 }633 }
604 634
@@ -645,7 +675,22 @@ var xResolverLookupByNameWithFlagsAsync func(uintptr, string, ResolverNameLookup
645 // See g_resolver_lookup_by_name() for more details.675 // See g_resolver_lookup_by_name() for more details.
646 func (x *Resolver) LookupByNameWithFlagsAsync(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {676 func (x *Resolver) LookupByNameWithFlagsAsync(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
647 677
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)
649 694
650 }695 }
651 696
@@ -699,7 +744,22 @@ var xResolverLookupRecordsAsync func(uintptr, string, ResolverRecordType, uintpt
699 // g_resolver_lookup_records() for more details.744 // g_resolver_lookup_records() for more details.
700 func (x *Resolver) LookupRecordsAsync(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {745 func (x *Resolver) LookupRecordsAsync(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
701 746
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)
703 763
704 }764 }
705 765
@@ -767,7 +827,22 @@ var xResolverLookupServiceAsync func(uintptr, string, string, string, uintptr, u
767 // details.827 // details.
768 func (x *Resolver) LookupServiceAsync(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {828 func (x *Resolver) LookupServiceAsync(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
769 829
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)
771 846
772 }847 }
773 848
M v4/gio/gsettings.go +58 -2
@@ -793,7 +793,50 @@ var xSettingsBindWithMapping func(uintptr, string, uintptr, string, SettingsBind
793 // binding overrides the first one.793 // binding overrides the first one.
794 func (x *Settings) BindWithMapping(KeyVar string, ObjectVar *gobject.Object, PropertyVar string, FlagsVar SettingsBindFlags, GetMappingVar *SettingsBindGetMapping, SetMappingVar *SettingsBindSetMapping, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {794 func (x *Settings) BindWithMapping(KeyVar string, ObjectVar *gobject.Object, PropertyVar string, FlagsVar SettingsBindFlags, GetMappingVar *SettingsBindGetMapping, SetMappingVar *SettingsBindSetMapping, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
795 795
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)
797 840
798 }841 }
799 842
@@ -1085,7 +1128,20 @@ var xSettingsGetMapped func(uintptr, string, uintptr, uintptr) uintptr
1085 // just as any other value would be.1128 // just as any other value would be.
1086 func (x *Settings) GetMapped(KeyVar string, MappingVar *SettingsGetMapping, UserDataVar uintptr) uintptr {1129 func (x *Settings) GetMapped(KeyVar string, MappingVar *SettingsGetMapping, UserDataVar uintptr) uintptr {
1087 1130
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)
1089 return cret1145 return cret
1090 }1146 }
1091 1147
M v4/gio/gsimpleasyncresult.go +140 -9
@@ -27,7 +27,22 @@ var xSimpleAsyncReportErrorInIdle func(uintptr, uintptr, uintptr, glib.Quark, in
27 // information.27 // information.
28 func SimpleAsyncReportErrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {28 func SimpleAsyncReportErrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {
29 29
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...)
31 46
32 }47 }
33 48
@@ -38,7 +53,22 @@ var xSimpleAsyncReportGerrorInIdle func(uintptr, uintptr, uintptr, *glib.Error)
38 // than building a new one.53 // than building a new one.
39 func SimpleAsyncReportGerrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {54 func SimpleAsyncReportGerrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {
40 55
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)
42 72
43 }73 }
44 74
@@ -49,7 +79,22 @@ var xSimpleAsyncReportTakeGerrorInIdle func(uintptr, uintptr, uintptr, *glib.Err
49 // ownership of @error, so the caller does not have to free it any more.79 // ownership of @error, so the caller does not have to free it any more.
50 func SimpleAsyncReportTakeGerrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {80 func SimpleAsyncReportTakeGerrorInIdle(ObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {
51 81
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)
53 98
54 }99 }
55 100
@@ -257,7 +302,22 @@ var xNewSimpleAsyncResult func(uintptr, uintptr, uintptr, uintptr) uintptr
257 func NewSimpleAsyncResult(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, SourceTagVar uintptr) *SimpleAsyncResult {302 func NewSimpleAsyncResult(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, SourceTagVar uintptr) *SimpleAsyncResult {
258 var cls *SimpleAsyncResult303 var cls *SimpleAsyncResult
259 304
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)
261 321
262 if cret == 0 {322 if cret == 0 {
263 return nil323 return nil
@@ -273,7 +333,22 @@ var xNewSimpleAsyncResultError func(uintptr, uintptr, uintptr, glib.Quark, int,
273 func NewSimpleAsyncResultError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) *SimpleAsyncResult {333 func NewSimpleAsyncResultError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) *SimpleAsyncResult {
274 var cls *SimpleAsyncResult334 var cls *SimpleAsyncResult
275 335
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...)
277 352
278 if cret == 0 {353 if cret == 0 {
279 return nil354 return nil
@@ -289,7 +364,22 @@ var xNewSimpleAsyncResultFromError func(uintptr, uintptr, uintptr, *glib.Error)
289 func NewSimpleAsyncResultFromError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) *SimpleAsyncResult {364 func NewSimpleAsyncResultFromError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) *SimpleAsyncResult {
290 var cls *SimpleAsyncResult365 var cls *SimpleAsyncResult
291 366
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)
293 383
294 if cret == 0 {384 if cret == 0 {
295 return nil385 return nil
@@ -306,7 +396,22 @@ var xNewSimpleAsyncResultTakeError func(uintptr, uintptr, uintptr, *glib.Error)
306 func NewSimpleAsyncResultTakeError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) *SimpleAsyncResult {396 func NewSimpleAsyncResultTakeError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) *SimpleAsyncResult {
307 var cls *SimpleAsyncResult397 var cls *SimpleAsyncResult
308 398
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)
310 415
311 if cret == 0 {416 if cret == 0 {
312 return nil417 return nil
@@ -411,7 +516,20 @@ var xSimpleAsyncResultRunInThread func(uintptr, uintptr, int, uintptr)
411 // is needed to run the job and report its completion.516 // is needed to run the job and report its completion.
412 func (x *SimpleAsyncResult) RunInThread(FuncVar *SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar *Cancellable) {517 func (x *SimpleAsyncResult) RunInThread(FuncVar *SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar *Cancellable) {
413 518
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())
415 533
416 }534 }
417 535
@@ -493,7 +611,20 @@ var xSimpleAsyncResultSetOpResGpointer func(uintptr, uintptr, uintptr)
493 // Sets the operation result within the asynchronous result to a pointer.611 // Sets the operation result within the asynchronous result to a pointer.
494 func (x *SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar *glib.DestroyNotify) {612 func (x *SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar *glib.DestroyNotify) {
495 613
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)
497 628
498 }629 }
499 630
M v4/gio/gsocketaddressenumerator.go +16 -1
@@ -197,7 +197,22 @@ var xSocketAddressEnumeratorNextAsync func(uintptr, uintptr, uintptr, uintptr)
197 // It is an error to call this multiple times before the previous callback has finished.197 // It is an error to call this multiple times before the previous callback has finished.
198 func (x *SocketAddressEnumerator) NextAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {198 func (x *SocketAddressEnumerator) NextAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
199 199
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)
201 216
202 }217 }
203 218
M v4/gio/gsocketclient.go +64 -4
@@ -283,7 +283,22 @@ var xSocketClientConnectAsync func(uintptr, uintptr, uintptr, uintptr, uintptr)
283 // the result of the operation.283 // the result of the operation.
284 func (x *SocketClient) ConnectAsync(ConnectableVar SocketConnectable, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {284 func (x *SocketClient) ConnectAsync(ConnectableVar SocketConnectable, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
285 285
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)
287 302
288 }303 }
289 304
@@ -367,7 +382,22 @@ var xSocketClientConnectToHostAsync func(uintptr, string, uint16, uintptr, uintp
367 // the result of the operation.382 // the result of the operation.
368 func (x *SocketClient) ConnectToHostAsync(HostAndPortVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {383 func (x *SocketClient) ConnectToHostAsync(HostAndPortVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
369 384
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)
371 401
372 }402 }
373 403
@@ -432,7 +462,22 @@ var xSocketClientConnectToServiceAsync func(uintptr, string, string, uintptr, ui
432 // g_socket_client_connect_to_service().462 // g_socket_client_connect_to_service().
433 func (x *SocketClient) ConnectToServiceAsync(DomainVar string, ServiceVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {463 func (x *SocketClient) ConnectToServiceAsync(DomainVar string, ServiceVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
434 464
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)
436 481
437 }482 }
438 483
@@ -507,7 +552,22 @@ var xSocketClientConnectToUriAsync func(uintptr, string, uint16, uintptr, uintpt
507 // the result of the operation.552 // the result of the operation.
508 func (x *SocketClient) ConnectToUriAsync(UriVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {553 func (x *SocketClient) ConnectToUriAsync(UriVar string, DefaultPortVar uint16, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
509 554
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)
511 571
512 }572 }
513 573
M v4/gio/gsocketconnection.go +16 -1
@@ -240,7 +240,22 @@ var xSocketConnectionConnectAsync func(uintptr, uintptr, uintptr, uintptr, uintp
240 // Use g_socket_connection_connect_finish() to retrieve the result.240 // Use g_socket_connection_connect_finish() to retrieve the result.
241 func (x *SocketConnection) ConnectAsync(AddressVar *SocketAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {241 func (x *SocketConnection) ConnectAsync(AddressVar *SocketAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
242 242
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)
244 259
245 }260 }
246 261
M v4/gio/gsocketlistener.go +32 -2
@@ -297,7 +297,22 @@ var xSocketListenerAcceptAsync func(uintptr, uintptr, uintptr, uintptr)
297 // to get the result of the operation.297 // to get the result of the operation.
298 func (x *SocketListener) AcceptAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {298 func (x *SocketListener) AcceptAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
299 299
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)
301 316
302 }317 }
303 318
@@ -365,7 +380,22 @@ var xSocketListenerAcceptSocketAsync func(uintptr, uintptr, uintptr, uintptr)
365 // to get the result of the operation.380 // to get the result of the operation.
366 func (x *SocketListener) AcceptSocketAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {381 func (x *SocketListener) AcceptSocketAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
367 382
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)
369 399
370 }400 }
371 401
M v4/gio/gsubprocess.go +64 -4
@@ -195,7 +195,22 @@ var xSubprocessCommunicateAsync func(uintptr, *glib.Bytes, uintptr, uintptr, uin
195 // invocation with g_subprocess_communicate_finish().195 // invocation with g_subprocess_communicate_finish().
196 func (x *Subprocess) CommunicateAsync(StdinBufVar *glib.Bytes, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {196 func (x *Subprocess) CommunicateAsync(StdinBufVar *glib.Bytes, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
197 197
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)
199 214
200 }215 }
201 216
@@ -237,7 +252,22 @@ var xSubprocessCommunicateUtf8Async func(uintptr, string, uintptr, uintptr, uint
237 // invocation with g_subprocess_communicate_utf8_finish().252 // invocation with g_subprocess_communicate_utf8_finish().
238 func (x *Subprocess) CommunicateUtf8Async(StdinBufVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {253 func (x *Subprocess) CommunicateUtf8Async(StdinBufVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
239 254
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)
241 271
242 }272 }
243 273
@@ -483,7 +513,22 @@ var xSubprocessWaitAsync func(uintptr, uintptr, uintptr, uintptr)
483 // This is the asynchronous version of g_subprocess_wait().513 // This is the asynchronous version of g_subprocess_wait().
484 func (x *Subprocess) WaitAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {514 func (x *Subprocess) WaitAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
485 515
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)
487 532
488 }533 }
489 534
@@ -508,7 +553,22 @@ var xSubprocessWaitCheckAsync func(uintptr, uintptr, uintptr, uintptr)
508 // This is the asynchronous version of g_subprocess_wait_check().553 // This is the asynchronous version of g_subprocess_wait_check().
509 func (x *Subprocess) WaitCheckAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {554 func (x *Subprocess) WaitCheckAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
510 555
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)
512 572
513 }573 }
514 574
M v4/gio/gsubprocesslauncher.go +29 -1
@@ -2,6 +2,8 @@
2 package gio2 package gio
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/glib"9 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -101,7 +103,33 @@ var xSubprocessLauncherSetChildSetup func(uintptr, uintptr, uintptr, uintptr)
101 // Child setup functions are only available on UNIX.103 // Child setup functions are only available on UNIX.
102 func (x *SubprocessLauncher) SetChildSetup(ChildSetupVar *glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {104 func (x *SubprocessLauncher) SetChildSetup(ChildSetupVar *glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
103 105
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)
105 133
106 }134 }
107 135
M v4/gio/gtask.go +122 -8
@@ -633,7 +633,22 @@ var xNewTask func(uintptr, uintptr, uintptr, uintptr) uintptr
633 func NewTask(SourceObjectVar *gobject.Object, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr) *Task {633 func NewTask(SourceObjectVar *gobject.Object, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr) *Task {
634 var cls *Task634 var cls *Task
635 635
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)
637 652
638 if cret == 0 {653 if cret == 0 {
639 return nil654 return nil
@@ -658,7 +673,20 @@ var xTaskAttachSource func(uintptr, *glib.Source, uintptr)
658 // This takes a reference on @task until @source is destroyed.673 // This takes a reference on @task until @source is destroyed.
659 func (x *Task) AttachSource(SourceVar *glib.Source, CallbackVar *glib.SourceFunc) {674 func (x *Task) AttachSource(SourceVar *glib.Source, CallbackVar *glib.SourceFunc) {
660 675
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)
662 690
663 }691 }
664 692
@@ -977,7 +1005,22 @@ var xTaskReturnPointer func(uintptr, uintptr, uintptr)
977 // reference on it.1005 // reference on it.
978 func (x *Task) ReturnPointer(ResultVar uintptr, ResultDestroyVar *glib.DestroyNotify) {1006 func (x *Task) ReturnPointer(ResultVar uintptr, ResultDestroyVar *glib.DestroyNotify) {
979 1007
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)
981 1024
982 }1025 }
983 1026
@@ -1040,7 +1083,20 @@ var xTaskRunInThread func(uintptr, uintptr)
1040 // g_task_run_in_thread().1083 // g_task_run_in_thread().
1041 func (x *Task) RunInThread(TaskFuncVar *TaskThreadFunc) {1084 func (x *Task) RunInThread(TaskFuncVar *TaskThreadFunc) {
1042 1085
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)
1044 1100
1045 }1101 }
1046 1102
@@ -1064,7 +1120,20 @@ var xTaskRunInThreadSync func(uintptr, uintptr)
1064 // limited number of them at a time.1120 // limited number of them at a time.
1065 func (x *Task) RunInThreadSync(TaskFuncVar *TaskThreadFunc) {1121 func (x *Task) RunInThreadSync(TaskFuncVar *TaskThreadFunc) {
1066 1122
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)
1068 1137
1069 }1138 }
1070 1139
@@ -1197,7 +1266,22 @@ var xTaskSetTaskData func(uintptr, uintptr, uintptr)
1197 // Sets @task's task data (freeing the existing task data, if any).1266 // Sets @task's task data (freeing the existing task data, if any).
1198 func (x *Task) SetTaskData(TaskDataVar uintptr, TaskDataDestroyVar *glib.DestroyNotify) {1267 func (x *Task) SetTaskData(TaskDataVar uintptr, TaskDataDestroyVar *glib.DestroyNotify) {
1199 1268
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)
1201 1285
1202 }1286 }
1203 1287
@@ -1296,7 +1380,22 @@ var xTaskReportError func(uintptr, uintptr, uintptr, uintptr, *glib.Error)
1296 // See also g_task_report_new_error().1380 // See also g_task_report_new_error().
1297 func TaskReportError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, ErrorVar *glib.Error) {1381 func TaskReportError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, ErrorVar *glib.Error) {
1298 1382
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)
1300 1399
1301 }1400 }
1302 1401
@@ -1313,7 +1412,22 @@ var xTaskReportNewError func(uintptr, uintptr, uintptr, uintptr, glib.Quark, int
1313 // See also g_task_report_error().1412 // See also g_task_report_error().
1314 func TaskReportNewError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {1413 func TaskReportNewError(SourceObjectVar *gobject.Object, CallbackVar *AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {
1315 1414
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...)
1317 1431
1318 }1432 }
1319 1433
M v4/gio/gtlsconnection.go +16 -1
@@ -483,7 +483,22 @@ var xTlsConnectionHandshakeAsync func(uintptr, int, uintptr, uintptr, uintptr)
483 // g_tls_connection_handshake() for more information.483 // g_tls_connection_handshake() for more information.
484 func (x *TlsConnection) HandshakeAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {484 func (x *TlsConnection) HandshakeAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
485 485
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)
487 502
488 }503 }
489 504
M v4/gio/gtlsdatabase.go +64 -4
@@ -566,7 +566,22 @@ var xTlsDatabaseLookupCertificateForHandleAsync func(uintptr, string, uintptr, T
566 // g_tls_database_lookup_certificate_for_handle() for more information.566 // g_tls_database_lookup_certificate_for_handle() for more information.
567 func (x *TlsDatabase) LookupCertificateForHandleAsync(HandleVar string, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {567 func (x *TlsDatabase) LookupCertificateForHandleAsync(HandleVar string, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
568 568
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)
570 585
571 }586 }
572 587
@@ -641,7 +656,22 @@ var xTlsDatabaseLookupCertificateIssuerAsync func(uintptr, uintptr, uintptr, Tls
641 // g_tls_database_lookup_certificate_issuer() for more information.656 // g_tls_database_lookup_certificate_issuer() for more information.
642 func (x *TlsDatabase) LookupCertificateIssuerAsync(CertificateVar *TlsCertificate, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {657 func (x *TlsDatabase) LookupCertificateIssuerAsync(CertificateVar *TlsCertificate, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
643 658
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)
645 675
646 }676 }
647 677
@@ -694,7 +724,22 @@ var xTlsDatabaseLookupCertificatesIssuedByAsync func(uintptr, []byte, uintptr, T
694 // this time.724 // this time.
695 func (x *TlsDatabase) LookupCertificatesIssuedByAsync(IssuerRawDnVar []byte, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {725 func (x *TlsDatabase) LookupCertificatesIssuedByAsync(IssuerRawDnVar []byte, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
696 726
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)
698 743
699 }744 }
700 745
@@ -793,7 +838,22 @@ var xTlsDatabaseVerifyChainAsync func(uintptr, uintptr, string, uintptr, uintptr
793 // g_tls_database_verify_chain() for more information.838 // g_tls_database_verify_chain() for more information.
794 func (x *TlsDatabase) VerifyChainAsync(ChainVar *TlsCertificate, PurposeVar string, IdentityVar SocketConnectable, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseVerifyFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {839 func (x *TlsDatabase) VerifyChainAsync(ChainVar *TlsCertificate, PurposeVar string, IdentityVar SocketConnectable, InteractionVar *TlsInteraction, FlagsVar TlsDatabaseVerifyFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
795 840
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)
797 857
798 }858 }
799 859
M v4/gio/gtlsinteraction.go +32 -2
@@ -321,7 +321,22 @@ var xTlsInteractionAskPasswordAsync func(uintptr, uintptr, uintptr, uintptr, uin
321 // Certain implementations may not support immediate cancellation.321 // Certain implementations may not support immediate cancellation.
322 func (x *TlsInteraction) AskPasswordAsync(PasswordVar *TlsPassword, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {322 func (x *TlsInteraction) AskPasswordAsync(PasswordVar *TlsPassword, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
323 323
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)
325 340
326 }341 }
327 342
@@ -453,7 +468,22 @@ var xTlsInteractionRequestCertificateAsync func(uintptr, uintptr, TlsCertificate
453 // request, which will usually abort the TLS connection.468 // request, which will usually abort the TLS connection.
454 func (x *TlsInteraction) RequestCertificateAsync(ConnectionVar *TlsConnection, FlagsVar TlsCertificateRequestFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {469 func (x *TlsInteraction) RequestCertificateAsync(ConnectionVar *TlsConnection, FlagsVar TlsCertificateRequestFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
455 470
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)
457 487
458 }488 }
459 489
M v4/gio/gtlspassword.go +16 -1
@@ -240,7 +240,22 @@ var xTlsPasswordSetValueFull func(uintptr, []byte, int, uintptr)
240 // considered part of the password in this case.)240 // considered part of the password in this case.)
241 func (x *TlsPassword) SetValueFull(ValueVar []byte, LengthVar int, DestroyVar *glib.DestroyNotify) {241 func (x *TlsPassword) SetValueFull(ValueVar []byte, LengthVar int, DestroyVar *glib.DestroyNotify) {
242 242
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)
244 259
245 }260 }
246 261
M v4/gio/gunixconnection.go +32 -2
@@ -106,7 +106,22 @@ var xUnixConnectionReceiveCredentialsAsync func(uintptr, uintptr, uintptr, uintp
106 // g_unix_connection_receive_credentials_finish() to get the result of the operation.106 // g_unix_connection_receive_credentials_finish() to get the result of the operation.
107 func (x *UnixConnection) ReceiveCredentialsAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {107 func (x *UnixConnection) ReceiveCredentialsAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
108 108
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)
110 125
111 }126 }
112 127
@@ -195,7 +210,22 @@ var xUnixConnectionSendCredentialsAsync func(uintptr, uintptr, uintptr, uintptr)
195 // g_unix_connection_send_credentials_finish() to get the result of the operation.210 // g_unix_connection_send_credentials_finish() to get the result of the operation.
196 func (x *UnixConnection) SendCredentialsAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {211 func (x *UnixConnection) SendCredentialsAsync(CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
197 212
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)
199 229
200 }230 }
201 231
M v4/gio/gvfs.go +61 -1
@@ -614,7 +614,67 @@ var xVfsRegisterUriScheme func(uintptr, string, uintptr, uintptr, uintptr, uintp
614 // a custom URI scheme, use g_vfs_unregister_uri_scheme().614 // a custom URI scheme, use g_vfs_unregister_uri_scheme().
615 func (x *Vfs) RegisterUriScheme(SchemeVar string, UriFuncVar *VfsFileLookupFunc, UriDataVar uintptr, UriDestroyVar *glib.DestroyNotify, ParseNameFuncVar *VfsFileLookupFunc, ParseNameDataVar uintptr, ParseNameDestroyVar *glib.DestroyNotify) bool {615 func (x *Vfs) RegisterUriScheme(SchemeVar string, UriFuncVar *VfsFileLookupFunc, UriDataVar uintptr, UriDestroyVar *glib.DestroyNotify, ParseNameFuncVar *VfsFileLookupFunc, ParseNameDataVar uintptr, ParseNameDestroyVar *glib.DestroyNotify) bool {
616 616
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)
618 return cret678 return cret
619 }679 }
620 680
M v4/glib/garray.go +152 -8
@@ -147,7 +147,20 @@ var xNewBytesWithFreeFunc func([]byte, uint, uintptr, uintptr) *Bytes
147 // @data may be `NULL` if @size is 0.147 // @data may be `NULL` if @size is 0.
148 func NewBytesWithFreeFunc(DataVar []byte, SizeVar uint, FreeFuncVar *DestroyNotify, UserDataVar uintptr) *Bytes {148 func NewBytesWithFreeFunc(DataVar []byte, SizeVar uint, FreeFuncVar *DestroyNotify, UserDataVar uintptr) *Bytes {
149 149
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)
151 return cret164 return cret
152 }165 }
153 166
@@ -553,7 +566,20 @@ var xByteArraySort func([]byte, uintptr)
553 // their addresses.566 // their addresses.
554 func ByteArraySort(ArrayVar []byte, CompareFuncVar *CompareFunc) {567 func ByteArraySort(ArrayVar []byte, CompareFuncVar *CompareFunc) {
555 568
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)
557 583
558 }584 }
559 585
@@ -563,7 +589,20 @@ var xByteArraySortWithData func([]byte, uintptr, uintptr)
563 // user data argument.589 // user data argument.
564 func ByteArraySortWithData(ArrayVar []byte, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {590 func ByteArraySortWithData(ArrayVar []byte, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
565 591
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)
567 606
568 }607 }
569 608
@@ -619,7 +658,22 @@ var xPtrArrayFindWithEqualFunc func([]uintptr, uintptr, uintptr, *uint) bool
619 // equality is used.658 // equality is used.
620 func PtrArrayFindWithEqualFunc(HaystackVar []uintptr, NeedleVar uintptr, EqualFuncVar *EqualFunc, IndexVar *uint) bool {659 func PtrArrayFindWithEqualFunc(HaystackVar []uintptr, NeedleVar uintptr, EqualFuncVar *EqualFunc, IndexVar *uint) bool {
621 660
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)
623 return cret677 return cret
624 }678 }
625 679
@@ -644,7 +698,37 @@ var xPtrArrayNewFromArray func([]uintptr, uint, uintptr, uintptr, uintptr) uintp
644 // than `gsize`.698 // than `gsize`.
645 func PtrArrayNewFromArray(DataVar []uintptr, LenVar uint, CopyFuncVar *CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {699 func PtrArrayNewFromArray(DataVar []uintptr, LenVar uint, CopyFuncVar *CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {
646 700
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)
648 return cret732 return cret
649 }733 }
650 734
@@ -665,7 +749,37 @@ var xPtrArrayNewFromNullTerminatedArray func([]uintptr, uintptr, uintptr, uintpt
665 // shorter than `gsize`.749 // shorter than `gsize`.
666 func PtrArrayNewFromNullTerminatedArray(DataVar []uintptr, CopyFuncVar *CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {750 func PtrArrayNewFromNullTerminatedArray(DataVar []uintptr, CopyFuncVar *CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {
667 751
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)
669 return cret783 return cret
670 }784 }
671 785
@@ -689,7 +803,22 @@ var xPtrArrayNewTake func([]uintptr, uint, uintptr) uintptr
689 // than `gsize`.803 // than `gsize`.
690 func PtrArrayNewTake(DataVar []uintptr, LenVar uint, ElementFreeFuncVar *DestroyNotify) uintptr {804 func PtrArrayNewTake(DataVar []uintptr, LenVar uint, ElementFreeFuncVar *DestroyNotify) uintptr {
691 805
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)
693 return cret822 return cret
694 }823 }
695 824
@@ -716,7 +845,22 @@ var xPtrArrayNewTakeNullTerminated func([]uintptr, uintptr) uintptr
716 // in `guint`, which may be shorter than `gsize`.845 // in `guint`, which may be shorter than `gsize`.
717 func PtrArrayNewTakeNullTerminated(DataVar []uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {846 func PtrArrayNewTakeNullTerminated(DataVar []uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {
718 847
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)
720 return cret864 return cret
721 }865 }
722 866
M v4/glib/gasyncqueue.go +72 -5
@@ -144,7 +144,20 @@ var xAsyncQueuePushSorted func(uintptr, uintptr, uintptr, uintptr)
144 // For an example of @func see g_async_queue_sort().144 // For an example of @func see g_async_queue_sort().
145 func (x *AsyncQueue) PushSorted(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {145 func (x *AsyncQueue) PushSorted(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
146 146
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)
148 161
149 }162 }
150 163
@@ -167,7 +180,20 @@ var xAsyncQueuePushSortedUnlocked func(uintptr, uintptr, uintptr, uintptr)
167 // For an example of @func see g_async_queue_sort().180 // For an example of @func see g_async_queue_sort().
168 func (x *AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {181 func (x *AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
169 182
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)
171 197
172 }198 }
173 199
@@ -251,7 +277,20 @@ var xAsyncQueueSort func(uintptr, uintptr, uintptr)
251 // ]|277 // ]|
252 func (x *AsyncQueue) Sort(FuncVar *CompareDataFunc, UserDataVar uintptr) {278 func (x *AsyncQueue) Sort(FuncVar *CompareDataFunc, UserDataVar uintptr) {
253 279
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)
255 294
256 }295 }
257 296
@@ -268,7 +307,20 @@ var xAsyncQueueSortUnlocked func(uintptr, uintptr, uintptr)
268 // This function must be called while holding the @queue's lock.307 // This function must be called while holding the @queue's lock.
269 func (x *AsyncQueue) SortUnlocked(FuncVar *CompareDataFunc, UserDataVar uintptr) {308 func (x *AsyncQueue) SortUnlocked(FuncVar *CompareDataFunc, UserDataVar uintptr) {
270 309
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)
272 324
273 }325 }
274 326
@@ -407,7 +459,22 @@ var xAsyncQueueNewFull func(uintptr) *AsyncQueue
407 // the queue is destroyed after the final unref.459 // the queue is destroyed after the final unref.
408 func AsyncQueueNewFull(ItemFreeFuncVar *DestroyNotify) *AsyncQueue {460 func AsyncQueueNewFull(ItemFreeFuncVar *DestroyNotify) *AsyncQueue {
409 461
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)
411 return cret478 return cret
412 }479 }
413 480
M v4/glib/gcache.go +28 -2
@@ -80,7 +80,20 @@ var xCacheKeyForeach func(uintptr, uintptr, uintptr)
80 // pairs to its callback function !80 // pairs to its callback function !
81 func (x *Cache) KeyForeach(FuncVar *HFunc, UserDataVar uintptr) {81 func (x *Cache) KeyForeach(FuncVar *HFunc, UserDataVar uintptr) {
82 82
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)
84 97
85 }98 }
86 99
@@ -100,7 +113,20 @@ var xCacheValueForeach func(uintptr, uintptr, uintptr)
100 // Calls the given function for each of the values in the #GCache.113 // Calls the given function for each of the values in the #GCache.
101 func (x *Cache) ValueForeach(FuncVar *HFunc, UserDataVar uintptr) {114 func (x *Cache) ValueForeach(FuncVar *HFunc, UserDataVar uintptr) {
102 115
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)
104 130
105 }131 }
106 132
M v4/glib/gcompletion.go +14 -1
@@ -131,7 +131,20 @@ var xCompletionSetCompare func(uintptr, uintptr)
131 // comparison function is strncmp().131 // comparison function is strncmp().
132 func (x *Completion) SetCompare(StrncmpFuncVar *CompletionStrncmpFunc) {132 func (x *Completion) SetCompare(StrncmpFuncVar *CompletionStrncmpFunc) {
133 133
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)
135 148
136 }149 }
137 150
M v4/glib/gdataset.go +90 -6
@@ -63,7 +63,20 @@ var xDatalistForeach func(**Data, uintptr, uintptr)
63 // than skipping over elements that are removed.63 // than skipping over elements that are removed.
64 func DatalistForeach(DatalistVar **Data, FuncVar *DataForeachFunc, UserDataVar uintptr) {64 func DatalistForeach(DatalistVar **Data, FuncVar *DataForeachFunc, UserDataVar uintptr) {
65 65
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)
67 80
68 }81 }
69 82
@@ -104,7 +117,22 @@ var xDatalistIdDupData func(**Data, Quark, uintptr, uintptr) uintptr
104 // threads are using the same datalist and the same key.117 // threads are using the same datalist and the same key.
105 func DatalistIdDupData(DatalistVar **Data, KeyIdVar Quark, DupFuncVar *DuplicateFunc, UserDataVar uintptr) uintptr {118 func DatalistIdDupData(DatalistVar **Data, KeyIdVar Quark, DupFuncVar *DuplicateFunc, UserDataVar uintptr) uintptr {
106 119
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)
108 return cret136 return cret
109 }137 }
110 138
@@ -159,7 +187,22 @@ var xDatalistIdReplaceData func(**Data, Quark, uintptr, uintptr, uintptr, *Destr
159 // should not destroy the object in the normal way.187 // should not destroy the object in the normal way.
160 func DatalistIdReplaceData(DatalistVar **Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *DestroyNotify, OldDestroyVar *DestroyNotify) bool {188 func DatalistIdReplaceData(DatalistVar **Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *DestroyNotify, OldDestroyVar *DestroyNotify) bool {
161 189
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)
163 return cret206 return cret
164 }207 }
165 208
@@ -171,7 +214,22 @@ var xDatalistIdSetDataFull func(**Data, Quark, uintptr, uintptr)
171 // function is called.214 // function is called.
172 func DatalistIdSetDataFull(DatalistVar **Data, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {215 func DatalistIdSetDataFull(DatalistVar **Data, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {
173 216
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)
175 233
176 }234 }
177 235
@@ -230,7 +288,20 @@ var xDatasetForeach func(uintptr, uintptr, uintptr)
230 // than skipping over elements that are removed.288 // than skipping over elements that are removed.
231 func DatasetForeach(DatasetLocationVar uintptr, FuncVar *DataForeachFunc, UserDataVar uintptr) {289 func DatasetForeach(DatasetLocationVar uintptr, FuncVar *DataForeachFunc, UserDataVar uintptr) {
232 290
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)
234 305
235 }306 }
236 307
@@ -261,7 +332,20 @@ var xDatasetIdSetDataFull func(uintptr, Quark, uintptr, uintptr)
261 // is called.332 // is called.
262 func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {333 func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {
263 334
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)
265 349
266 }350 }
267 351
M v4/glib/gerror.go +80 -2
@@ -149,7 +149,46 @@ var xErrorDomainRegister func(string, uint, uintptr, uintptr, uintptr) Quark
149 // g_error_domain_register_static().149 // g_error_domain_register_static().
150 func ErrorDomainRegister(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar *ErrorInitFunc, ErrorTypeCopyVar *ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {150 func ErrorDomainRegister(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar *ErrorInitFunc, ErrorTypeCopyVar *ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
151 151
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)
153 return cret192 return cret
154 }193 }
155 194
@@ -174,7 +213,46 @@ var xErrorDomainRegisterStatic func(string, uint, uintptr, uintptr, uintptr) Qua
174 // already takes care of passing valid information to this function.213 // already takes care of passing valid information to this function.
175 func ErrorDomainRegisterStatic(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar *ErrorInitFunc, ErrorTypeCopyVar *ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {214 func ErrorDomainRegisterStatic(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar *ErrorInitFunc, ErrorTypeCopyVar *ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
176 215
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)
178 return cret256 return cret
179 }257 }
180 258
M v4/glib/ghash.go +56 -4
@@ -286,7 +286,20 @@ var xHashTableFind func(*HashTable, uintptr, uintptr) uintptr
286 // values in a hash table ends up needing O(n*n) operations).286 // values in a hash table ends up needing O(n*n) operations).
287 func HashTableFind(HashTableVar *HashTable, PredicateVar *HRFunc, UserDataVar uintptr) uintptr {287 func HashTableFind(HashTableVar *HashTable, PredicateVar *HRFunc, UserDataVar uintptr) uintptr {
288 288
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)
290 return cret303 return cret
291 }304 }
292 305
@@ -306,7 +319,20 @@ var xHashTableForeach func(*HashTable, uintptr, uintptr)
306 // order searches in contrast to g_hash_table_lookup().319 // order searches in contrast to g_hash_table_lookup().
307 func HashTableForeach(HashTableVar *HashTable, FuncVar *HFunc, UserDataVar uintptr) {320 func HashTableForeach(HashTableVar *HashTable, FuncVar *HFunc, UserDataVar uintptr) {
308 321
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)
310 336
311 }337 }
312 338
@@ -322,7 +348,20 @@ var xHashTableForeachRemove func(*HashTable, uintptr, uintptr) uint
322 // key/value pairs in the hash table.348 // key/value pairs in the hash table.
323 func HashTableForeachRemove(HashTableVar *HashTable, FuncVar *HRFunc, UserDataVar uintptr) uint {349 func HashTableForeachRemove(HashTableVar *HashTable, FuncVar *HRFunc, UserDataVar uintptr) uint {
324 350
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)
326 return cret365 return cret
327 }366 }
328 367
@@ -337,7 +376,20 @@ var xHashTableForeachSteal func(*HashTable, uintptr, uintptr) uint
337 // key/value pairs in the hash table.376 // key/value pairs in the hash table.
338 func HashTableForeachSteal(HashTableVar *HashTable, FuncVar *HRFunc, UserDataVar uintptr) uint {377 func HashTableForeachSteal(HashTableVar *HashTable, FuncVar *HRFunc, UserDataVar uintptr) uint {
339 378
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)
341 return cret393 return cret
342 }394 }
343 395
M v4/glib/ghook.go +42 -3
@@ -135,7 +135,20 @@ var xHookListMarshal func(uintptr, bool, uintptr, uintptr)
135 // Calls a function on each valid #GHook.135 // Calls a function on each valid #GHook.
136 func (x *HookList) Marshal(MayRecurseVar bool, MarshallerVar *HookMarshaller, MarshalDataVar uintptr) {136 func (x *HookList) Marshal(MayRecurseVar bool, MarshallerVar *HookMarshaller, MarshalDataVar uintptr) {
137 137
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)
139 152
140 }153 }
141 154
@@ -145,7 +158,20 @@ var xHookListMarshalCheck func(uintptr, bool, uintptr, uintptr)
145 // function returns %FALSE.158 // function returns %FALSE.
146 func (x *HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar *HookCheckMarshaller, MarshalDataVar uintptr) {159 func (x *HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar *HookCheckMarshaller, MarshalDataVar uintptr) {
147 160
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)
149 175
150 }176 }
151 177
@@ -214,7 +240,20 @@ var xHookInsertSorted func(*HookList, *Hook, uintptr)
214 // Inserts a #GHook into a #GHookList, sorted by the given function.240 // Inserts a #GHook into a #GHookList, sorted by the given function.
215 func HookInsertSorted(HookListVar *HookList, HookVar *Hook, FuncVar *HookCompareFunc) {241 func HookInsertSorted(HookListVar *HookList, HookVar *Hook, FuncVar *HookCompareFunc) {
216 242
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)
218 257
219 }258 }
220 259
M v4/glib/giochannel.go +41 -2
@@ -1018,7 +1018,20 @@ var xIoAddWatch func(*IOChannel, IOCondition, uintptr, uintptr) uint
1018 // with the default priority.1018 // with the default priority.
1019 func IoAddWatch(ChannelVar *IOChannel, ConditionVar IOCondition, FuncVar *IOFunc, UserDataVar uintptr) uint {1019 func IoAddWatch(ChannelVar *IOChannel, ConditionVar IOCondition, FuncVar *IOFunc, UserDataVar uintptr) uint {
1020 1020
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)
1022 return cret1035 return cret
1023 }1036 }
1024 1037
@@ -1032,7 +1045,33 @@ var xIoAddWatchFull func(*IOChannel, int, IOCondition, uintptr, uintptr, uintptr
1032 // You can do these steps manually if you need greater control.1045 // You can do these steps manually if you need greater control.
1033 func IoAddWatchFull(ChannelVar *IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar *IOFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {1046 func IoAddWatchFull(ChannelVar *IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar *IOFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
1034 1047
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)
1036 return cret1075 return cret
1037 }1076 }
1038 1077
M v4/glib/glib-unix.go +82 -4
@@ -99,7 +99,20 @@ var xUnixFdAdd func(int, IOCondition, uintptr, uintptr) uint
99 // The source will never close the fd -- you must do it yourself.99 // The source will never close the fd -- you must do it yourself.
100 func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr) uint {100 func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr) uint {
101 101
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)
103 return cret116 return cret
104 }117 }
105 118
@@ -113,7 +126,33 @@ var xUnixFdAddFull func(int, int, IOCondition, uintptr, uintptr, uintptr) uint
113 // @user_data.126 // @user_data.
114 func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {127 func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
115 128
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)
117 return cret156 return cret
118 }157 }
119 158
@@ -211,7 +250,20 @@ var xUnixSignalAdd func(int, uintptr, uintptr) uint
211 // using g_source_remove().250 // using g_source_remove().
212 func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) uint {251 func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) uint {
213 252
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)
215 return cret267 return cret
216 }268 }
217 269
@@ -222,7 +274,33 @@ var xUnixSignalAddFull func(int, int, uintptr, uintptr, uintptr) uint
222 // using g_source_remove().274 // using g_source_remove().
223 func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {275 func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
224 276
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)
226 return cret304 return cret
227 }305 }
228 306
M v4/glib/glist.go +16 -1
@@ -31,7 +31,22 @@ var xClearList func(**List, uintptr)
31 // @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing.31 // @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing.
32 func ClearList(ListPtrVar **List, DestroyVar *DestroyNotify) {32 func ClearList(ListPtrVar **List, DestroyVar *DestroyNotify) {
33 33
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)
35 50
36 }51 }
37 52
M v4/glib/gmain.go +328 -17
@@ -279,7 +279,20 @@ var xMainContextInvoke func(uintptr, uintptr, uintptr)
279 // will be continuously run in a loop (and may prevent this call from returning).279 // will be continuously run in a loop (and may prevent this call from returning).
280 func (x *MainContext) Invoke(FunctionVar *SourceFunc, DataVar uintptr) {280 func (x *MainContext) Invoke(FunctionVar *SourceFunc, DataVar uintptr) {
281 281
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)
283 296
284 }297 }
285 298
@@ -297,7 +310,35 @@ var xMainContextInvokeFull func(uintptr, int, uintptr, uintptr, uintptr)
297 // thread or with any particular context acquired.310 // thread or with any particular context acquired.
298 func (x *MainContext) InvokeFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {311 func (x *MainContext) InvokeFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
299 312
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)
301 342
302 }343 }
303 344
@@ -530,7 +571,20 @@ var xMainContextSetPollFunc func(uintptr, uintptr)
530 // loop with an external event loop.571 // loop with an external event loop.
531 func (x *MainContext) SetPollFunc(FuncVar *PollFunc) {572 func (x *MainContext) SetPollFunc(FuncVar *PollFunc) {
532 573
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)
534 588
535 }589 }
536 590
@@ -1196,7 +1250,35 @@ var xSourceSetCallback func(uintptr, uintptr, uintptr, uintptr)
1196 // of also unsetting the callback.1250 // of also unsetting the callback.
1197 func (x *Source) SetCallback(FuncVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {1251 func (x *Source) SetCallback(FuncVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
1198 1252
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)
1200 1282
1201 }1283 }
1202 1284
@@ -1257,7 +1339,20 @@ var xSourceSetDisposeFunction func(uintptr, uintptr)
1257 // This should only ever be called from [struct@GLib.Source] implementations.1339 // This should only ever be called from [struct@GLib.Source] implementations.
1258 func (x *Source) SetDisposeFunction(DisposeVar *SourceDisposeFunc) {1340 func (x *Source) SetDisposeFunction(DisposeVar *SourceDisposeFunc) {
1259 1341
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)
1261 1356
1262 }1357 }
1263 1358
@@ -1595,7 +1690,20 @@ var xChildWatchAdd func(Pid, uintptr, uintptr) uint
1595 // need greater control.1690 // need greater control.
1596 func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uint {1691 func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uint {
1597 1692
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)
1599 return cret1707 return cret
1600 }1708 }
1601 1709
@@ -1628,7 +1736,35 @@ var xChildWatchAddFull func(int, Pid, uintptr, uintptr, uintptr) uint
1628 // need greater control.1736 // need greater control.
1629 func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {1737 func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
1630 1738
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)
1632 return cret1768 return cret
1633 }1769 }
1634 1770
@@ -1694,7 +1830,20 @@ var xClearHandleId func(uint, uintptr)
1694 // pointer casts.1830 // pointer casts.
1695 func ClearHandleId(TagPtrVar uint, ClearFuncVar *ClearHandleFunc) {1831 func ClearHandleId(TagPtrVar uint, ClearFuncVar *ClearHandleFunc) {
1696 1832
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)
1698 1847
1699 }1848 }
1700 1849
@@ -1767,7 +1916,20 @@ var xIdleAdd func(uintptr, uintptr) uint
1767 // need greater control or to use a custom main context.1916 // need greater control or to use a custom main context.
1768 func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {1917 func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {
1769 1918
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)
1771 return cret1933 return cret
1772 }1934 }
1773 1935
@@ -1789,7 +1951,35 @@ var xIdleAddFull func(int, uintptr, uintptr, uintptr) uint
1789 // need greater control or to use a custom main context.1951 // need greater control or to use a custom main context.
1790 func IdleAddFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {1952 func IdleAddFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
1791 1953
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)
1793 return cret1983 return cret
1794 }1984 }
1795 1985
@@ -1807,7 +1997,20 @@ var xIdleAddOnce func(uintptr, uintptr) uint
1807 // This function otherwise behaves like [func@GLib.idle_add].1997 // This function otherwise behaves like [func@GLib.idle_add].
1808 func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {1998 func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
1809 1999
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)
1811 return cret2014 return cret
1812 }2015 }
1813 2016
@@ -2130,7 +2333,20 @@ var xTimeoutAdd func(uint, uintptr, uintptr) uint
2130 // time. See [func@GLib.get_monotonic_time].2333 // time. See [func@GLib.get_monotonic_time].
2131 func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {2334 func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
2132 2335
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)
2134 return cret2350 return cret
2135 }2351 }
2136 2352
@@ -2166,7 +2382,35 @@ var xTimeoutAddFull func(int, uint, uintptr, uintptr, uintptr) uint
2166 // See [func@GLib.get_monotonic_time].2382 // See [func@GLib.get_monotonic_time].
2167 func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {2383 func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
2168 2384
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)
2170 return cret2414 return cret
2171 }2415 }
2172 2416
@@ -2181,7 +2425,20 @@ var xTimeoutAddOnce func(uint, uintptr, uintptr) uint
2181 // This function otherwise behaves like [func@GLib.timeout_add].2425 // This function otherwise behaves like [func@GLib.timeout_add].
2182 func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {2426 func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2183 2427
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)
2185 return cret2442 return cret
2186 }2443 }
2187 2444
@@ -2212,7 +2469,20 @@ var xTimeoutAddSeconds func(uint, uintptr, uintptr) uint
2212 // time. See [func@GLib.get_monotonic_time].2469 // time. See [func@GLib.get_monotonic_time].
2213 func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {2470 func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
2214 2471
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)
2216 return cret2486 return cret
2217 }2487 }
2218 2488
@@ -2260,7 +2530,35 @@ var xTimeoutAddSecondsFull func(int, uint, uintptr, uintptr, uintptr) uint
2260 // time. See [func@GLib.get_monotonic_time].2530 // time. See [func@GLib.get_monotonic_time].
2261 func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {2531 func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
2262 2532
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)
2264 return cret2562 return cret
2265 }2563 }
2266 2564
@@ -2270,7 +2568,20 @@ var xTimeoutAddSecondsOnce func(uint, uintptr, uintptr) uint
2270 // seconds.2568 // seconds.
2271 func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {2569 func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2272 2570
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)
2274 return cret2585 return cret
2275 }2586 }
2276 2587
M v4/glib/gmarkup.go +14 -1
@@ -38,7 +38,20 @@ var xNewMarkupParseContext func(*MarkupParser, MarkupParseFlags, uintptr, uintpt
38 // free it and create a new parse context).38 // free it and create a new parse context).
39 func NewMarkupParseContext(ParserVar *MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar *DestroyNotify) *MarkupParseContext {39 func NewMarkupParseContext(ParserVar *MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar *DestroyNotify) *MarkupParseContext {
40 40
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)
42 return cret55 return cret
43 }56 }
44 57
M v4/glib/gmem.go +14 -1
@@ -279,7 +279,20 @@ var xClearPointer func(uintptr, uintptr)
279 // ```279 // ```
280 func ClearPointer(PpVar uintptr, DestroyVar *DestroyNotify) {280 func ClearPointer(PpVar uintptr, DestroyVar *DestroyNotify) {
281 281
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)
283 296
284 }297 }
285 298
M v4/glib/gmessages.go +114 -6
@@ -339,7 +339,20 @@ var xLogSetDefaultHandler func(uintptr, uintptr) uintptr
339 // [Using Structured Logging](logging.html#using-structured-logging).339 // [Using Structured Logging](logging.html#using-structured-logging).
340 func LogSetDefaultHandler(LogFuncVar *LogFunc, UserDataVar uintptr) uintptr {340 func LogSetDefaultHandler(LogFuncVar *LogFunc, UserDataVar uintptr) uintptr {
341 341
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)
343 return cret356 return cret
344 }357 }
345 358
@@ -412,7 +425,20 @@ var xLogSetHandler func(string, LogLevelFlags, uintptr, uintptr) uint
412 // ```425 // ```
413 func LogSetHandler(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr) uint {426 func LogSetHandler(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr) uint {
414 427
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)
416 return cret442 return cret
417 }443 }
418 444
@@ -427,7 +453,33 @@ var xLogSetHandlerFull func(string, LogLevelFlags, uintptr, uintptr, uintptr) ui
427 // application domain.453 // application domain.
428 func LogSetHandlerFull(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr, DestroyVar *DestroyNotify) uint {454 func LogSetHandlerFull(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr, DestroyVar *DestroyNotify) uint {
429 455
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)
431 return cret483 return cret
432 }484 }
433 485
@@ -446,7 +498,33 @@ var xLogSetWriterFunc func(uintptr, uintptr, uintptr)
446 // There can only be one writer function. It is an error to set more than one.498 // There can only be one writer function. It is an error to set more than one.
447 func LogSetWriterFunc(FuncVar *LogWriterFunc, UserDataVar uintptr, UserDataFreeVar *DestroyNotify) {499 func LogSetWriterFunc(FuncVar *LogWriterFunc, UserDataVar uintptr, UserDataFreeVar *DestroyNotify) {
448 500
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)
450 528
451 }529 }
452 530
@@ -923,7 +1001,22 @@ var xSetPrintHandler func(uintptr) uintptr
923 // in all platforms. Before GLib 2.76, this was `NULL`.1001 // in all platforms. Before GLib 2.76, this was `NULL`.
924 func SetPrintHandler(FuncVar *PrintFunc) uintptr {1002 func SetPrintHandler(FuncVar *PrintFunc) uintptr {
925 1003
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)
927 return cret1020 return cret
928 }1021 }
929 1022
@@ -946,7 +1039,22 @@ var xSetPrinterrHandler func(uintptr) uintptr
946 // Before GLib 2.76, this was `NULL`.1039 // Before GLib 2.76, this was `NULL`.
947 func SetPrinterrHandler(FuncVar *PrintFunc) uintptr {1040 func SetPrinterrHandler(FuncVar *PrintFunc) uintptr {
948 1041
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)
950 return cret1058 return cret
951 }1059 }
952 1060
M v4/glib/gnode.go +42 -3
@@ -67,7 +67,20 @@ var xNodeChildrenForeach func(uintptr, TraverseFlags, uintptr, uintptr)
67 // that would modify the structure of the tree.67 // that would modify the structure of the tree.
68 func (x *Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar *NodeForeachFunc, DataVar uintptr) {68 func (x *Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar *NodeForeachFunc, DataVar uintptr) {
69 69
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)
71 84
72 }85 }
73 86
@@ -86,7 +99,20 @@ var xNodeCopyDeep func(uintptr, uintptr, uintptr) *Node
86 // Recursively copies a #GNode and its data.99 // Recursively copies a #GNode and its data.
87 func (x *Node) CopyDeep(CopyFuncVar *CopyFunc, DataVar uintptr) *Node {100 func (x *Node) CopyDeep(CopyFuncVar *CopyFunc, DataVar uintptr) *Node {
88 101
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)
90 return cret116 return cret
91 }117 }
92 118
@@ -275,7 +301,20 @@ var xNodeTraverse func(uintptr, TraverseType, TraverseFlags, int, uintptr, uintp
275 // @func must not do anything that would modify the structure of the tree.301 // @func must not do anything that would modify the structure of the tree.
276 func (x *Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar *NodeTraverseFunc, DataVar uintptr) {302 func (x *Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar *NodeTraverseFunc, DataVar uintptr) {
277 303
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)
279 318
280 }319 }
281 320
M v4/glib/goption.go +123 -5
@@ -314,7 +314,37 @@ var xOptionContextSetTranslateFunc func(uintptr, uintptr, uintptr, uintptr)
314 // domain, see g_option_context_set_translation_domain().314 // domain, see g_option_context_set_translation_domain().
315 func (x *OptionContext) SetTranslateFunc(FuncVar *TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {315 func (x *OptionContext) SetTranslateFunc(FuncVar *TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {
316 316
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)
318 348
319 }349 }
320 350
@@ -404,7 +434,22 @@ var xNewOptionGroup func(string, string, string, uintptr, uintptr) *OptionGroup
404 // ‘Application Options:’.434 // ‘Application Options:’.
405 func NewOptionGroup(NameVar string, DescriptionVar string, HelpDescriptionVar string, UserDataVar uintptr, DestroyVar *DestroyNotify) *OptionGroup {435 func NewOptionGroup(NameVar string, DescriptionVar string, HelpDescriptionVar string, UserDataVar uintptr, DestroyVar *DestroyNotify) *OptionGroup {
406 436
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)
408 return cret453 return cret
409 }454 }
410 455
@@ -445,7 +490,20 @@ var xOptionGroupSetErrorHook func(uintptr, uintptr)
445 // specified when constructing the group with g_option_group_new().490 // specified when constructing the group with g_option_group_new().
446 func (x *OptionGroup) SetErrorHook(ErrorFuncVar *OptionErrorFunc) {491 func (x *OptionGroup) SetErrorHook(ErrorFuncVar *OptionErrorFunc) {
447 492
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)
449 507
450 }508 }
451 509
@@ -460,7 +518,37 @@ var xOptionGroupSetParseHooks func(uintptr, uintptr, uintptr)
460 // with g_option_group_new().518 // with g_option_group_new().
461 func (x *OptionGroup) SetParseHooks(PreParseFuncVar *OptionParseFunc, PostParseFuncVar *OptionParseFunc) {519 func (x *OptionGroup) SetParseHooks(PreParseFuncVar *OptionParseFunc, PostParseFuncVar *OptionParseFunc) {
462 520
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)
464 552
465 }553 }
466 554
@@ -474,7 +562,37 @@ var xOptionGroupSetTranslateFunc func(uintptr, uintptr, uintptr, uintptr)
474 // domain, see g_option_group_set_translation_domain().562 // domain, see g_option_group_set_translation_domain().
475 func (x *OptionGroup) SetTranslateFunc(FuncVar *TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {563 func (x *OptionGroup) SetTranslateFunc(FuncVar *TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {
476 564
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)
478 596
479 }597 }
480 598
M v4/glib/gqsort.go +30 -2
@@ -2,6 +2,8 @@
2 package glib2 package glib
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 )9 )
@@ -15,7 +17,20 @@ var xQsortWithData func(uintptr, int, uint, uintptr, uintptr)
15 // Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).17 // Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).
16 func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {18 func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
17 19
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)
19 34
20 }35 }
21 36
@@ -28,7 +43,20 @@ var xSortArray func([]uintptr, uint, uint, uintptr, uintptr)
28 // Unlike `qsort()`, this is guaranteed to be a stable sort.43 // Unlike `qsort()`, this is guaranteed to be a stable sort.
29 func SortArray(ArrayVar []uintptr, NElementsVar uint, ElementSizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {44 func SortArray(ArrayVar []uintptr, NElementsVar uint, ElementSizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
30 45
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)
32 60
33 }61 }
34 62
M v4/glib/gqueue.go +86 -6
@@ -41,7 +41,22 @@ var xQueueClearFull func(uintptr, uintptr)
41 // and calls the provided @free_func on each item in the #GQueue.41 // and calls the provided @free_func on each item in the #GQueue.
42 func (x *Queue) ClearFull(FreeFuncVar *DestroyNotify) {42 func (x *Queue) ClearFull(FreeFuncVar *DestroyNotify) {
43 43
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)
45 60
46 }61 }
47 62
@@ -85,7 +100,20 @@ var xQueueFindCustom func(uintptr, uintptr, uintptr) *List
85 // first argument and the given user data as the second argument.100 // first argument and the given user data as the second argument.
86 func (x *Queue) FindCustom(DataVar uintptr, FuncVar *CompareFunc) *List {101 func (x *Queue) FindCustom(DataVar uintptr, FuncVar *CompareFunc) *List {
87 102
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)
89 return cret117 return cret
90 }118 }
91 119
@@ -98,7 +126,20 @@ var xQueueForeach func(uintptr, uintptr, uintptr)
98 // not modify any part of the queue after that element.126 // not modify any part of the queue after that element.
99 func (x *Queue) Foreach(FuncVar *Func, UserDataVar uintptr) {127 func (x *Queue) Foreach(FuncVar *Func, UserDataVar uintptr) {
100 128
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)
102 143
103 }144 }
104 145
@@ -125,7 +166,20 @@ var xQueueFreeFull func(uintptr, uintptr)
125 // element from it).166 // element from it).
126 func (x *Queue) FreeFull(FreeFuncVar *DestroyNotify) {167 func (x *Queue) FreeFull(FreeFuncVar *DestroyNotify) {
127 168
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)
129 183
130 }184 }
131 185
@@ -210,7 +264,20 @@ var xQueueInsertSorted func(uintptr, uintptr, uintptr, uintptr)
210 // Inserts @data into @queue using @func to determine the new position.264 // Inserts @data into @queue using @func to determine the new position.
211 func (x *Queue) InsertSorted(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {265 func (x *Queue) InsertSorted(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
212 266
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)
214 281
215 }282 }
216 283
@@ -426,7 +493,20 @@ var xQueueSort func(uintptr, uintptr, uintptr)
426 // Sorts @queue using @compare_func.493 // Sorts @queue using @compare_func.
427 func (x *Queue) Sort(CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {494 func (x *Queue) Sort(CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
428 495
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)
430 510
431 }511 }
432 512
M v4/glib/grcbox.go +30 -2
@@ -2,6 +2,8 @@
2 package glib2 package glib
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 )9 )
@@ -95,7 +97,20 @@ var xAtomicRcBoxReleaseFull func(uintptr, uintptr)
95 // when the callback is called and will be freed.97 // when the callback is called and will be freed.
96 func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {98 func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
97 99
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)
99 114
100 }115 }
101 116
@@ -183,7 +198,20 @@ var xRcBoxReleaseFull func(uintptr, uintptr)
183 // resources allocated for @mem_block.198 // resources allocated for @mem_block.
184 func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {199 func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
185 200
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)
187 215
188 }216 }
189 217
M v4/glib/gregex.go +14 -1
@@ -1028,7 +1028,20 @@ var xRegexReplaceEval func(uintptr, []string, int, int, RegexMatchFlags, uintptr
1028 func (x *Regex) ReplaceEval(StringVar []string, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar *RegexEvalCallback, UserDataVar uintptr) (string, error) {1028 func (x *Regex) ReplaceEval(StringVar []string, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar *RegexEvalCallback, UserDataVar uintptr) (string, error) {
1029 var cerr *Error1029 var cerr *Error
1030 1030
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)
1032 if cerr == nil {1045 if cerr == nil {
1033 return cret, nil1046 return cret, nil
1034 }1047 }
M v4/glib/grel.go +27 -1
@@ -104,7 +104,33 @@ var xRelationIndex func(uintptr, int, uintptr, uintptr)
104 // before any records are added to the #GRelation.104 // before any records are added to the #GRelation.
105 func (x *Relation) Index(FieldVar int, HashFuncVar *HashFunc, KeyEqualFuncVar *EqualFunc) {105 func (x *Relation) Index(FieldVar int, HashFuncVar *HashFunc, KeyEqualFuncVar *EqualFunc) {
106 106
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)
108 134
109 }135 }
110 136
M v4/glib/gscanner.go +14 -1
@@ -223,7 +223,20 @@ var xScannerScopeForeachSymbol func(uintptr, uint, uintptr, uintptr)
223 // parameter.223 // parameter.
224 func (x *Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar *HFunc, UserDataVar uintptr) {224 func (x *Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar *HFunc, UserDataVar uintptr) {
225 225
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)
227 240
228 }241 }
229 242
M v4/glib/gsequence.go +168 -12
@@ -39,7 +39,20 @@ var xSequenceForeach func(uintptr, uintptr, uintptr)
39 // to the function. @func must not modify the sequence itself.39 // to the function. @func must not modify the sequence itself.
40 func (x *Sequence) Foreach(FuncVar *Func, UserDataVar uintptr) {40 func (x *Sequence) Foreach(FuncVar *Func, UserDataVar uintptr) {
41 41
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)
43 56
44 }57 }
45 58
@@ -109,7 +122,20 @@ var xSequenceInsertSorted func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
109 // g_sequence_sort() or g_sequence_sort_iter().122 // g_sequence_sort() or g_sequence_sort_iter().
110 func (x *Sequence) InsertSorted(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {123 func (x *Sequence) InsertSorted(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
111 124
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)
113 return cret139 return cret
114 }140 }
115 141
@@ -129,7 +155,20 @@ var xSequenceInsertSortedIter func(uintptr, uintptr, uintptr, uintptr) *Sequence
129 // g_sequence_sort() or g_sequence_sort_iter().155 // g_sequence_sort() or g_sequence_sort_iter().
130 func (x *Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {156 func (x *Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
131 157
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)
133 return cret172 return cret
134 }173 }
135 174
@@ -163,7 +202,20 @@ var xSequenceLookup func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
163 // unsorted.202 // unsorted.
164 func (x *Sequence) Lookup(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {203 func (x *Sequence) Lookup(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
165 204
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)
167 return cret219 return cret
168 }220 }
169 221
@@ -181,7 +233,20 @@ var xSequenceLookupIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
181 // unsorted.233 // unsorted.
182 func (x *Sequence) LookupIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {234 func (x *Sequence) LookupIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
183 235
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)
185 return cret250 return cret
186 }251 }
187 252
@@ -211,7 +276,20 @@ var xSequenceSearch func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
211 // unsorted.276 // unsorted.
212 func (x *Sequence) Search(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {277 func (x *Sequence) Search(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
213 278
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)
215 return cret293 return cret
216 }294 }
217 295
@@ -232,7 +310,20 @@ var xSequenceSearchIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
232 // unsorted.310 // unsorted.
233 func (x *Sequence) SearchIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {311 func (x *Sequence) SearchIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
234 312
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)
236 return cret327 return cret
237 }328 }
238 329
@@ -246,7 +337,20 @@ var xSequenceSort func(uintptr, uintptr, uintptr)
246 // if the second comes before the first.337 // if the second comes before the first.
247 func (x *Sequence) Sort(CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) {338 func (x *Sequence) Sort(CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) {
248 339
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)
250 354
251 }355 }
252 356
@@ -261,7 +365,20 @@ var xSequenceSortIter func(uintptr, uintptr, uintptr)
261 // iterator comes before the first.365 // iterator comes before the first.
262 func (x *Sequence) SortIter(CmpFuncVar *SequenceIterCompareFunc, CmpDataVar uintptr) {366 func (x *Sequence) SortIter(CmpFuncVar *SequenceIterCompareFunc, CmpDataVar uintptr) {
263 367
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)
265 382
266 }383 }
267 384
@@ -362,7 +479,20 @@ var xSequenceForeachRange func(*SequenceIter, *SequenceIter, uintptr, uintptr)
362 // itself.479 // itself.
363 func SequenceForeachRange(BeginVar *SequenceIter, EndVar *SequenceIter, FuncVar *Func, UserDataVar uintptr) {480 func SequenceForeachRange(BeginVar *SequenceIter, EndVar *SequenceIter, FuncVar *Func, UserDataVar uintptr) {
364 481
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)
366 496
367 }497 }
368 498
@@ -476,7 +606,20 @@ var xSequenceSortChanged func(*SequenceIter, uintptr, uintptr)
476 // the second item comes before the first.606 // the second item comes before the first.
477 func SequenceSortChanged(IterVar *SequenceIter, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) {607 func SequenceSortChanged(IterVar *SequenceIter, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) {
478 608
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)
480 623
481 }624 }
482 625
@@ -493,7 +636,20 @@ var xSequenceSortChangedIter func(*SequenceIter, uintptr, uintptr)
493 // iterator comes before the first.636 // iterator comes before the first.
494 func SequenceSortChangedIter(IterVar *SequenceIter, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) {637 func SequenceSortChangedIter(IterVar *SequenceIter, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) {
495 638
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)
497 653
498 }654 }
499 655
M v4/glib/gslist.go +16 -1
@@ -30,7 +30,22 @@ var xClearSlist func(**SList, uintptr)
30 // @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing.30 // @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing.
31 func ClearSlist(SlistPtrVar **SList, DestroyVar *DestroyNotify) {31 func ClearSlist(SlistPtrVar **SList, DestroyVar *DestroyNotify) {
32 32
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)
34 49
35 }50 }
36 51
M v4/glib/gspawn.go +82 -5
@@ -2,6 +2,8 @@
2 package glib2 package glib
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 )9 )
@@ -156,7 +158,22 @@ var xSpawnAsync func(string, []string, []string, SpawnFlags, uintptr, uintptr, *
156 func SpawnAsync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid) (bool, error) {158 func SpawnAsync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid) (bool, error) {
157 var cerr *Error159 var cerr *Error
158 160
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)
160 if cerr == nil {177 if cerr == nil {
161 return cret, nil178 return cret, nil
162 }179 }
@@ -173,7 +190,22 @@ var xSpawnAsyncWithFds func(string, []string, []string, SpawnFlags, uintptr, uin
173 func SpawnAsyncWithFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {190 func SpawnAsyncWithFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {
174 var cerr *Error191 var cerr *Error
175 192
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)
177 if cerr == nil {209 if cerr == nil {
178 return cret, nil210 return cret, nil
179 }211 }
@@ -188,7 +220,22 @@ var xSpawnAsyncWithPipes func(string, []string, []string, SpawnFlags, uintptr, u
188 func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StandardInputVar *int, StandardOutputVar *int, StandardErrorVar *int) (bool, error) {220 func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StandardInputVar *int, StandardOutputVar *int, StandardErrorVar *int) (bool, error) {
189 var cerr *Error221 var cerr *Error
190 222
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)
192 if cerr == nil {239 if cerr == nil {
193 return cret, nil240 return cret, nil
194 }241 }
@@ -395,7 +442,22 @@ var xSpawnAsyncWithPipesAndFds func(string, []string, []string, SpawnFlags, uint
395 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) {442 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) {
396 var cerr *Error443 var cerr *Error
397 444
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)
399 if cerr == nil {461 if cerr == nil {
400 return cret, nil462 return cret, nil
401 }463 }
@@ -581,7 +643,22 @@ var xSpawnSync func(string, []string, []string, SpawnFlags, uintptr, uintptr, *[
581 func SpawnSync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar *[]byte, StandardErrorVar *[]byte, WaitStatusVar *int) (bool, error) {643 func SpawnSync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar *[]byte, StandardErrorVar *[]byte, WaitStatusVar *int) (bool, error) {
582 var cerr *Error644 var cerr *Error
583 645
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)
585 if cerr == nil {662 if cerr == nil {
586 return cret, nil663 return cret, nil
587 }664 }
M v4/glib/gtestutils.go +163 -7
@@ -420,7 +420,20 @@ var xTestAddDataFunc func(string, uintptr, uintptr)
420 // and it is recommended to do so even if it isn’t.420 // and it is recommended to do so even if it isn’t.
421 func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc) {421 func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc) {
422 422
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)
424 437
425 }438 }
426 439
@@ -432,7 +445,33 @@ var xTestAddDataFuncFull func(string, uintptr, uintptr, uintptr)
432 // is freeing @test_data after the test run is complete.445 // is freeing @test_data after the test run is complete.
433 func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc, DataFreeFuncVar *DestroyNotify) {446 func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc, DataFreeFuncVar *DestroyNotify) {
434 447
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)
436 475
437 }476 }
438 477
@@ -454,7 +493,20 @@ var xTestAddFunc func(string, uintptr)
454 // it is recommended to do so even if it isn’t.493 // it is recommended to do so even if it isn’t.
455 func TestAddFunc(TestpathVar string, TestFuncVar *TestFunc) {494 func TestAddFunc(TestpathVar string, TestFuncVar *TestFunc) {
456 495
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)
458 510
459 }511 }
460 512
@@ -462,7 +514,46 @@ var xTestAddVtable func(string, uint, uintptr, uintptr, uintptr, uintptr)
462 514
463 func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar *TestFixtureFunc, DataTestVar *TestFixtureFunc, DataTeardownVar *TestFixtureFunc) {515 func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar *TestFixtureFunc, DataTestVar *TestFixtureFunc, DataTeardownVar *TestFixtureFunc) {
464 516
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)
466 557
467 }558 }
468 559
@@ -566,7 +657,46 @@ var xTestCreateCase func(string, uint, uintptr, uintptr, uintptr, uintptr) *Test
566 // varying @test_name and @data_test arguments.657 // varying @test_name and @data_test arguments.
567 func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar *TestFixtureFunc, DataTestVar *TestFixtureFunc, DataTeardownVar *TestFixtureFunc) *TestCase {658 func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar *TestFixtureFunc, DataTestVar *TestFixtureFunc, DataTeardownVar *TestFixtureFunc) *TestCase {
568 659
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)
570 return cret700 return cret
571 }701 }
572 702
@@ -879,7 +1009,20 @@ var xTestLogSetFatalHandler func(uintptr, uintptr)
879 // [Using Structured Logging](logging.html#using-structured-logging).1009 // [Using Structured Logging](logging.html#using-structured-logging).
880 func TestLogSetFatalHandler(LogFuncVar *TestLogFatalFunc, UserDataVar uintptr) {1010 func TestLogSetFatalHandler(LogFuncVar *TestLogFatalFunc, UserDataVar uintptr) {
881 1011
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)
883 1026
884 }1027 }
885 1028
@@ -939,7 +1082,20 @@ var xTestQueueDestroy func(uintptr, uintptr)
939 // before `A()` during teardown.1082 // before `A()` during teardown.
940 func TestQueueDestroy(DestroyFuncVar *DestroyNotify, DestroyDataVar uintptr) {1083 func TestQueueDestroy(DestroyFuncVar *DestroyNotify, DestroyDataVar uintptr) {
941 1084
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)
943 1099
944 }1100 }
945 1101
M v4/glib/gthread.go +112 -8
@@ -281,7 +281,20 @@ var xOnceImpl func(uintptr, uintptr, uintptr) uintptr
281 281
282 func (x *Once) Impl(FuncVar *ThreadFunc, ArgVar uintptr) uintptr {282 func (x *Once) Impl(FuncVar *ThreadFunc, ArgVar uintptr) uintptr {
283 283
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)
285 return cret298 return cret
286 }299 }
287 300
@@ -859,7 +872,20 @@ var xStaticPrivateSet func(uintptr, uintptr, uintptr)
859 // @notify is used quite differently from @destructor in g_private_new().872 // @notify is used quite differently from @destructor in g_private_new().
860 func (x *StaticPrivate) Set(DataVar uintptr, NotifyVar *DestroyNotify) {873 func (x *StaticPrivate) Set(DataVar uintptr, NotifyVar *DestroyNotify) {
861 874
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)
863 889
864 }890 }
865 891
@@ -1250,7 +1276,20 @@ var xNewThread func(string, uintptr, uintptr) *Thread
1250 // POSIX and all threads inherit their parent thread's priority.1276 // POSIX and all threads inherit their parent thread's priority.
1251 func NewThread(NameVar string, FuncVar *ThreadFunc, DataVar uintptr) *Thread {1277 func NewThread(NameVar string, FuncVar *ThreadFunc, DataVar uintptr) *Thread {
1252 1278
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)
1254 return cret1293 return cret
1255 }1294 }
1256 1295
@@ -1264,7 +1303,20 @@ var xThreadTryNew func(string, uintptr, uintptr, **Error) *Thread
1264 func ThreadTryNew(NameVar string, FuncVar *ThreadFunc, DataVar uintptr) (*Thread, error) {1303 func ThreadTryNew(NameVar string, FuncVar *ThreadFunc, DataVar uintptr) (*Thread, error) {
1265 var cerr *Error1304 var cerr *Error
1266 1305
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)
1268 if cerr == nil {1320 if cerr == nil {
1269 return cret, nil1321 return cret, nil
1270 }1322 }
@@ -2160,7 +2212,20 @@ var xPrivateNew func(uintptr) *Private
2160 // Creates a new #GPrivate.2212 // Creates a new #GPrivate.
2161 func PrivateNew(NotifyVar *DestroyNotify) *Private {2213 func PrivateNew(NotifyVar *DestroyNotify) *Private {
2162 2214
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)
2164 return cret2229 return cret
2165 }2230 }
2166 2231
@@ -2181,7 +2246,20 @@ var xThreadCreate func(uintptr, uintptr, bool, **Error) *Thread
2181 func ThreadCreate(FuncVar *ThreadFunc, DataVar uintptr, JoinableVar bool) (*Thread, error) {2246 func ThreadCreate(FuncVar *ThreadFunc, DataVar uintptr, JoinableVar bool) (*Thread, error) {
2182 var cerr *Error2247 var cerr *Error
2183 2248
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)
2185 if cerr == nil {2263 if cerr == nil {
2186 return cret, nil2264 return cret, nil
2187 }2265 }
@@ -2195,7 +2273,20 @@ var xThreadCreateFull func(uintptr, uintptr, uint32, bool, bool, ThreadPriority,
2195 func ThreadCreateFull(FuncVar *ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (*Thread, error) {2273 func ThreadCreateFull(FuncVar *ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (*Thread, error) {
2196 var cerr *Error2274 var cerr *Error
2197 2275
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)
2199 if cerr == nil {2290 if cerr == nil {
2200 return cret, nil2291 return cret, nil
2201 }2292 }
@@ -2239,7 +2330,20 @@ var xThreadForeach func(uintptr, uintptr)
2239 // which is quadratic in the number of existing threads.2330 // which is quadratic in the number of existing threads.
2240 func ThreadForeach(ThreadFuncVar *Func, UserDataVar uintptr) {2331 func ThreadForeach(ThreadFuncVar *Func, UserDataVar uintptr) {
2241 2332
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)
2243 2347
2244 }2348 }
2245 2349
M v4/glib/gthreadpool.go +14 -1
@@ -172,7 +172,20 @@ var xThreadPoolSetSortFunction func(uintptr, uintptr, uintptr)
172 // created.172 // created.
173 func (x *ThreadPool) SetSortFunction(FuncVar *CompareDataFunc, UserDataVar uintptr) {173 func (x *ThreadPool) SetSortFunction(FuncVar *CompareDataFunc, UserDataVar uintptr) {
174 174
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)
176 189
177 }190 }
178 191
M v4/glib/gtree.go +138 -8
@@ -44,7 +44,20 @@ var xNewTree func(uintptr) *Tree
44 // Creates a new #GTree.44 // Creates a new #GTree.
45 func NewTree(KeyCompareFuncVar *CompareFunc) *Tree {45 func NewTree(KeyCompareFuncVar *CompareFunc) *Tree {
46 46
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)
48 return cret61 return cret
49 }62 }
50 63
@@ -55,7 +68,46 @@ var xNewTreeFull func(uintptr, uintptr, uintptr, uintptr) *Tree
55 // removing the entry from the #GTree.68 // removing the entry from the #GTree.
56 func NewTreeFull(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar *DestroyNotify, ValueDestroyFuncVar *DestroyNotify) *Tree {69 func NewTreeFull(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar *DestroyNotify, ValueDestroyFuncVar *DestroyNotify) *Tree {
57 70
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)
59 return cret111 return cret
60 }112 }
61 113
@@ -65,7 +117,20 @@ var xNewTreeWithData func(uintptr, uintptr) *Tree
65 // See g_tree_new() for more details.117 // See g_tree_new() for more details.
66 func NewTreeWithData(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr) *Tree {118 func NewTreeWithData(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr) *Tree {
67 119
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)
69 return cret134 return cret
70 }135 }
71 136
@@ -95,7 +160,20 @@ var xTreeForeach func(uintptr, uintptr, uintptr)
95 // the tree, then walk the list and remove each item.160 // the tree, then walk the list and remove each item.
96 func (x *Tree) Foreach(FuncVar *TraverseFunc, UserDataVar uintptr) {161 func (x *Tree) Foreach(FuncVar *TraverseFunc, UserDataVar uintptr) {
97 162
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)
99 177
100 }178 }
101 179
@@ -111,7 +189,20 @@ var xTreeForeachNode func(uintptr, uintptr, uintptr)
111 // the tree, then walk the list and remove each item.189 // the tree, then walk the list and remove each item.
112 func (x *Tree) ForeachNode(FuncVar *TraverseNodeFunc, UserDataVar uintptr) {190 func (x *Tree) ForeachNode(FuncVar *TraverseNodeFunc, UserDataVar uintptr) {
113 191
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)
115 206
116 }207 }
117 208
@@ -317,7 +408,20 @@ var xTreeSearch func(uintptr, uintptr, uintptr) uintptr
317 // pairs that have a larger key.408 // pairs that have a larger key.
318 func (x *Tree) Search(SearchFuncVar *CompareFunc, UserDataVar uintptr) uintptr {409 func (x *Tree) Search(SearchFuncVar *CompareFunc, UserDataVar uintptr) uintptr {
319 410
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)
321 return cret425 return cret
322 }426 }
323 427
@@ -334,7 +438,20 @@ var xTreeSearchNode func(uintptr, uintptr, uintptr) *TreeNode
334 // pairs that have a larger key.438 // pairs that have a larger key.
335 func (x *Tree) SearchNode(SearchFuncVar *CompareFunc, UserDataVar uintptr) *TreeNode {439 func (x *Tree) SearchNode(SearchFuncVar *CompareFunc, UserDataVar uintptr) *TreeNode {
336 440
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)
338 return cret455 return cret
339 }456 }
340 457
@@ -355,7 +472,20 @@ var xTreeTraverse func(uintptr, uintptr, TraverseType, uintptr)
355 // Calls the given function for each node in the #GTree.472 // Calls the given function for each node in the #GTree.
356 func (x *Tree) Traverse(TraverseFuncVar *TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {473 func (x *Tree) Traverse(TraverseFuncVar *TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {
357 474
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)
359 489
360 }490 }
361 491
M v4/glib/gutils.go +14 -1
@@ -121,7 +121,20 @@ var xAtexit func(uintptr)
121 // program.121 // program.
122 func Atexit(FuncVar *VoidFunc) {122 func Atexit(FuncVar *VoidFunc) {
123 123
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)
125 138
126 }139 }
127 140
M v4/glib/gvariant.go +14 -1
@@ -466,7 +466,20 @@ var xNewVariantFromData func(*VariantType, []byte, uint, bool, uintptr, uintptr)
466 // process.466 // process.
467 func NewVariantFromData(TypeVar *VariantType, DataVar []byte, SizeVar uint, TrustedVar bool, NotifyVar *DestroyNotify, UserDataVar uintptr) *Variant {467 func NewVariantFromData(TypeVar *VariantType, DataVar []byte, SizeVar uint, TrustedVar bool, NotifyVar *DestroyNotify, UserDataVar uintptr) *Variant {
468 468
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)
470 return cret483 return cret
471 }484 }
472 485
M v4/gobject/gbindinggroup.go +46 -1
@@ -2,6 +2,8 @@
2 package gobject2 package gobject
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/glib"9 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -71,7 +73,50 @@ var xBindingGroupBindFull func(uintptr, string, uintptr, string, BindingFlags, u
71 // See g_object_bind_property_full() for more information.73 // See g_object_bind_property_full() for more information.
72 func (x *BindingGroup) BindFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, UserDataDestroyVar *glib.DestroyNotify) {74 func (x *BindingGroup) BindFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, UserDataDestroyVar *glib.DestroyNotify) {
73 75
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)
75 120
76 }121 }
77 122
M v4/gobject/gboxed.go +29 -1
@@ -2,6 +2,8 @@
2 package gobject2 package gobject
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/glib"9 "github.com/jwijenbergh/puregotk/v4/glib"
@@ -47,7 +49,33 @@ var xBoxedTypeRegisterStatic func(string, uintptr, uintptr) types.GType
47 // will create the appropriate `*_get_type()` function for the boxed type.49 // will create the appropriate `*_get_type()` function for the boxed type.
48 func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar *BoxedCopyFunc, BoxedFreeVar *BoxedFreeFunc) types.GType {50 func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar *BoxedCopyFunc, BoxedFreeVar *BoxedFreeFunc) types.GType {
49 51
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)
51 return cret79 return cret
52 }80 }
53 81
M v4/gobject/gclosure.go +165 -9
@@ -203,7 +203,20 @@ var xClosureAddFinalizeNotifier func(uintptr, uintptr, uintptr)
203 // notifiers will be run before the finalize notifiers.203 // notifiers will be run before the finalize notifiers.
204 func (x *Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {204 func (x *Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
205 205
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)
207 220
208 }221 }
209 222
@@ -216,7 +229,20 @@ var xClosureAddInvalidateNotifier func(uintptr, uintptr, uintptr)
216 // in an unspecified order.229 // in an unspecified order.
217 func (x *Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {230 func (x *Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
218 231
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)
220 246
221 }247 }
222 248
@@ -230,7 +256,33 @@ var xClosureAddMarshalGuards func(uintptr, uintptr, uintptr, uintptr, uintptr)
230 // example of marshal guards.256 // example of marshal guards.
231 func (x *Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar *ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify) {257 func (x *Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar *ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify) {
232 258
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)
234 286
235 }287 }
236 288
@@ -283,7 +335,20 @@ var xClosureRemoveFinalizeNotifier func(uintptr, uintptr, uintptr)
283 // Notice that notifiers are automatically removed after they are run.335 // Notice that notifiers are automatically removed after they are run.
284 func (x *Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {336 func (x *Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
285 337
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)
287 352
288 }353 }
289 354
@@ -294,7 +359,20 @@ var xClosureRemoveInvalidateNotifier func(uintptr, uintptr, uintptr)
294 // Notice that notifiers are automatically removed after they are run.359 // Notice that notifiers are automatically removed after they are run.
295 func (x *Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {360 func (x *Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
296 361
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)
298 376
299 }377 }
300 378
@@ -312,7 +390,20 @@ var xClosureSetMarshal func(uintptr, uintptr)
312 // See also: g_closure_set_meta_marshal()390 // See also: g_closure_set_meta_marshal()
313 func (x *Closure) SetMarshal(MarshalVar *ClosureMarshal) {391 func (x *Closure) SetMarshal(MarshalVar *ClosureMarshal) {
314 392
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)
316 407
317 }408 }
318 409
@@ -337,7 +428,20 @@ var xClosureSetMetaMarshal func(uintptr, uintptr, uintptr)
337 // @marshal_data argument.428 // @marshal_data argument.
338 func (x *Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar *ClosureMarshal) {429 func (x *Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar *ClosureMarshal) {
339 430
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)
341 445
342 }446 }
343 447
@@ -467,7 +571,33 @@ var xCclosureNew func(uintptr, uintptr, uintptr) *Closure
467 // @destroy_data will be called as a finalize notifier on the #GClosure.571 // @destroy_data will be called as a finalize notifier on the #GClosure.
468 func CclosureNew(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {572 func CclosureNew(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {
469 573
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)
471 return cret601 return cret
472 }602 }
473 603
@@ -479,7 +609,33 @@ var xCclosureNewSwap func(uintptr, uintptr, uintptr) *Closure
479 // @destroy_data will be called as a finalize notifier on the #GClosure.609 // @destroy_data will be called as a finalize notifier on the #GClosure.
480 func CclosureNewSwap(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {610 func CclosureNewSwap(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {
481 611
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)
483 return cret639 return cret
484 }640 }
485 641
M v4/gobject/gobject.go +240 -14
@@ -931,7 +931,20 @@ var xCclosureNewObject func(uintptr, uintptr) *Closure
931 // after the object is is freed.931 // after the object is is freed.
932 func CclosureNewObject(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {932 func CclosureNewObject(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {
933 933
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())
935 return cret948 return cret
936 }949 }
937 950
@@ -944,7 +957,20 @@ var xCclosureNewObjectSwap func(uintptr, uintptr) *Closure
944 // after the object is is freed.957 // after the object is is freed.
945 func CclosureNewObjectSwap(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {958 func CclosureNewObjectSwap(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {
946 959
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())
948 return cret974 return cret
949 }975 }
950 976
@@ -986,7 +1012,20 @@ var xSignalConnectObject func(*TypeInstance, string, uintptr, uintptr, ConnectFl
986 // details.1012 // details.
987 func SignalConnectObject(InstanceVar *TypeInstance, DetailedSignalVar string, CHandlerVar *Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {1013 func SignalConnectObject(InstanceVar *TypeInstance, DetailedSignalVar string, CHandlerVar *Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {
988 1014
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)
990 return cret1029 return cret
991 }1030 }
992 1031
@@ -1198,7 +1237,20 @@ var xObjectAddToggleRef func(uintptr, uintptr, uintptr)
1198 // A g_object_add_toggle_ref() must be released with g_object_remove_toggle_ref().1237 // A g_object_add_toggle_ref() must be released with g_object_remove_toggle_ref().
1199 func (x *Object) AddToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {1238 func (x *Object) AddToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {
1200 1239
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)
1202 1254
1203 }1255 }
1204 1256
@@ -1298,7 +1350,52 @@ var xObjectBindPropertyFull func(uintptr, string, uintptr, string, BindingFlags,
1298 func (x *Object) BindPropertyFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) *Binding {1350 func (x *Object) BindPropertyFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) *Binding {
1299 var cls *Binding1351 var cls *Binding
1300 1352
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)
1302 1399
1303 if cret == 0 {1400 if cret == 0 {
1304 return nil1401 return nil
@@ -1407,7 +1504,22 @@ var xObjectDupData func(uintptr, string, uintptr, uintptr) uintptr
1407 // object.1504 // object.
1408 func (x *Object) DupData(KeyVar string, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr {1505 func (x *Object) DupData(KeyVar string, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr {
1409 1506
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)
1411 return cret1523 return cret
1412 }1524 }
1413 1525
@@ -1429,7 +1541,22 @@ var xObjectDupQdata func(uintptr, glib.Quark, uintptr, uintptr) uintptr
1429 // object.1541 // object.
1430 func (x *Object) DupQdata(QuarkVar glib.Quark, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr {1542 func (x *Object) DupQdata(QuarkVar glib.Quark, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr {
1431 1543
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)
1433 return cret1560 return cret
1434 }1561 }
1435 1562
@@ -1703,7 +1830,20 @@ var xObjectRemoveToggleRef func(uintptr, uintptr, uintptr)
1703 // you must take care of that yourself.1830 // you must take care of that yourself.
1704 func (x *Object) RemoveToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {1831 func (x *Object) RemoveToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {
1705 1832
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)
1707 1847
1708 }1848 }
1709 1849
@@ -1738,7 +1878,22 @@ var xObjectReplaceData func(uintptr, string, uintptr, uintptr, uintptr, *glib.De
1738 // for @key.1878 // for @key.
1739 func (x *Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {1879 func (x *Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
1740 1880
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)
1742 return cret1897 return cret
1743 }1898 }
1744 1899
@@ -1759,7 +1914,22 @@ var xObjectReplaceQdata func(uintptr, glib.Quark, uintptr, uintptr, uintptr, *gl
1759 // should not destroy the object in the normal way.1914 // should not destroy the object in the normal way.
1760 func (x *Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {1915 func (x *Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
1761 1916
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)
1763 return cret1933 return cret
1764 }1934 }
1765 1935
@@ -1820,7 +1990,22 @@ var xObjectSetDataFull func(uintptr, string, uintptr, uintptr)
1820 // Note that the @destroy callback is not called if @data is %NULL.1990 // Note that the @destroy callback is not called if @data is %NULL.
1821 func (x *Object) SetDataFull(KeyVar string, DataVar uintptr, DestroyVar *glib.DestroyNotify) {1991 func (x *Object) SetDataFull(KeyVar string, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
1822 1992
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)
1824 2009
1825 }2010 }
1826 2011
@@ -1858,7 +2043,22 @@ var xObjectSetQdataFull func(uintptr, glib.Quark, uintptr, uintptr)
1858 // with the same @quark.2043 // with the same @quark.
1859 func (x *Object) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify) {2044 func (x *Object) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
1860 2045
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)
1862 2062
1863 }2063 }
1864 2064
@@ -2054,7 +2254,20 @@ var xObjectWeakRef func(uintptr, uintptr, uintptr)
2054 // Use #GWeakRef if thread-safety is required.2254 // Use #GWeakRef if thread-safety is required.
2055 func (x *Object) WeakRef(NotifyVar *WeakNotify, DataVar uintptr) {2255 func (x *Object) WeakRef(NotifyVar *WeakNotify, DataVar uintptr) {
2056 2256
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)
2058 2271
2059 }2272 }
2060 2273
@@ -2063,7 +2276,20 @@ var xObjectWeakUnref func(uintptr, uintptr, uintptr)
2063 // Removes a weak reference callback to an object.2276 // Removes a weak reference callback to an object.
2064 func (x *Object) WeakUnref(NotifyVar *WeakNotify, DataVar uintptr) {2277 func (x *Object) WeakUnref(NotifyVar *WeakNotify, DataVar uintptr) {
2065 2278
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)
2067 2293
2068 }2294 }
2069 2295
M v4/gobject/gparam.go +16 -1
@@ -770,7 +770,22 @@ var xParamSpecSetQdataFull func(uintptr, glib.Quark, uintptr, uintptr)
770 // g_param_spec_set_qdata() with the same @quark.770 // g_param_spec_set_qdata() with the same @quark.
771 func (x *ParamSpec) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify) {771 func (x *ParamSpec) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
772 772
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)
774 789
775 }790 }
776 791
M v4/gobject/gsignal.go +151 -7
@@ -228,7 +228,35 @@ var xSignalAddEmissionHook func(uint, glib.Quark, uintptr, uintptr, uintptr) uin
228 // for signals which don't have %G_SIGNAL_NO_HOOKS flag set.228 // for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
229 func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar *SignalEmissionHook, HookDataVar uintptr, DataDestroyVar *glib.DestroyNotify) uint32 {229 func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar *SignalEmissionHook, HookDataVar uintptr, DataDestroyVar *glib.DestroyNotify) uint32 {
230 230
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)
232 return cret260 return cret
233 }261 }
234 262
@@ -313,7 +341,35 @@ var xSignalConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectF
313 // details.341 // details.
314 func SignalConnectData(InstanceVar *Object, DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {342 func SignalConnectData(InstanceVar *Object, DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {
315 343
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)
317 return cret373 return cret
318 }374 }
319 375
@@ -634,7 +690,22 @@ var xSignalNew func(string, types.GType, SignalFlags, uint, uintptr, uintptr, ui
634 // be used.690 // be used.
635 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 {691 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 {
636 692
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...)
638 return cret709 return cret
639 }710 }
640 711
@@ -658,7 +729,37 @@ var xSignalNewClassHandler func(string, types.GType, SignalFlags, uintptr, uintp
658 // the marshaller for this signal.729 // the marshaller for this signal.
659 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 {730 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 {
660 731
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...)
662 return cret763 return cret
663 }764 }
664 765
@@ -672,7 +773,22 @@ var xSignalNewValist func(string, types.GType, SignalFlags, *Closure, uintptr, u
672 // the marshaller for this signal.773 // the marshaller for this signal.
673 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 {774 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 {
674 775
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)
676 return cret792 return cret
677 }793 }
678 794
@@ -686,7 +802,22 @@ var xSignalNewv func(string, types.GType, SignalFlags, *Closure, uintptr, uintpt
686 // the marshaller for this signal.802 // the marshaller for this signal.
687 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 {803 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 {
688 804
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)
690 return cret821 return cret
691 }822 }
692 823
@@ -717,7 +848,20 @@ var xSignalOverrideClassHandler func(string, types.GType, uintptr)
717 // parent class closure from inside the overridden one.848 // parent class closure from inside the overridden one.
718 func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar types.GType, ClassHandlerVar *Callback) {849 func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar types.GType, ClassHandlerVar *Callback) {
719 850
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)
721 865
722 }866 }
723 867
M v4/gobject/gsignalgroup.go +83 -5
@@ -82,7 +82,20 @@ var xSignalGroupConnect func(uintptr, string, uintptr, uintptr)
82 // You cannot connect a signal handler after #GSignalGroup:target has been set.82 // You cannot connect a signal handler after #GSignalGroup:target has been set.
83 func (x *SignalGroup) Connect(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {83 func (x *SignalGroup) Connect(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
84 84
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)
86 99
87 }100 }
88 101
@@ -96,7 +109,20 @@ var xSignalGroupConnectAfter func(uintptr, string, uintptr, uintptr)
96 // You cannot connect a signal handler after #GSignalGroup:target has been set.109 // You cannot connect a signal handler after #GSignalGroup:target has been set.
97 func (x *SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {110 func (x *SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
98 111
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)
100 126
101 }127 }
102 128
@@ -119,7 +145,33 @@ var xSignalGroupConnectData func(uintptr, string, uintptr, uintptr, uintptr, Con
119 // You cannot connect a signal handler after #GSignalGroup:target has been set.145 // You cannot connect a signal handler after #GSignalGroup:target has been set.
120 func (x *SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {146 func (x *SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {
121 147
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)
123 175
124 }176 }
125 177
@@ -134,7 +186,20 @@ var xSignalGroupConnectObject func(uintptr, string, uintptr, uintptr, ConnectFla
134 // You cannot connect a signal handler after #GSignalGroup:target has been set.186 // You cannot connect a signal handler after #GSignalGroup:target has been set.
135 func (x *SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar *Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {187 func (x *SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar *Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {
136 188
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)
138 203
139 }204 }
140 205
@@ -149,7 +214,20 @@ var xSignalGroupConnectSwapped func(uintptr, string, uintptr, uintptr)
149 // You cannot connect a signal handler after #GSignalGroup:target has been set.214 // You cannot connect a signal handler after #GSignalGroup:target has been set.
150 func (x *SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {215 func (x *SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
151 216
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)
153 231
154 }232 }
155 233
M v4/gobject/gtype.go +83 -5
@@ -810,7 +810,20 @@ var xTypeAddClassCacheFunc func(uintptr, uintptr)
810 // chain.810 // chain.
811 func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {811 func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
812 812
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)
814 827
815 }828 }
816 829
@@ -853,7 +866,20 @@ var xTypeAddInterfaceCheck func(uintptr, uintptr)
853 // interfaces.866 // interfaces.
854 func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {867 func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
855 868
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)
857 883
858 }884 }
859 885
@@ -1474,7 +1500,33 @@ var xTypeRegisterStaticSimple func(types.GType, string, uint, uintptr, uint, uin
1474 // struct and calling g_type_register_static().1500 // struct and calling g_type_register_static().
1475 func TypeRegisterStaticSimple(ParentTypeVar types.GType, TypeNameVar string, ClassSizeVar uint, ClassInitVar *ClassInitFunc, InstanceSizeVar uint, InstanceInitVar *InstanceInitFunc, FlagsVar TypeFlags) types.GType {1501 func TypeRegisterStaticSimple(ParentTypeVar types.GType, TypeNameVar string, ClassSizeVar uint, ClassInitVar *ClassInitFunc, InstanceSizeVar uint, InstanceInitVar *InstanceInitFunc, FlagsVar TypeFlags) types.GType {
1476 1502
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)
1478 return cret1530 return cret
1479 }1531 }
1480 1532
@@ -1485,7 +1537,20 @@ var xTypeRemoveClassCacheFunc func(uintptr, uintptr)
1485 // g_type_remove_class_cache_func() to avoid leaks.1537 // g_type_remove_class_cache_func() to avoid leaks.
1486 func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {1538 func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
1487 1539
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)
1489 1554
1490 }1555 }
1491 1556
@@ -1495,7 +1560,20 @@ var xTypeRemoveInterfaceCheck func(uintptr, uintptr)
1495 // g_type_add_interface_check().1560 // g_type_add_interface_check().
1496 func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {1561 func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
1497 1562
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)
1499 1577
1500 }1578 }
1501 1579
M v4/gobject/gvalue.go +14 -1
@@ -848,7 +848,20 @@ var xValueRegisterTransformFunc func(types.GType, types.GType, uintptr)
848 // @dest_type will be replaced.848 // @dest_type will be replaced.
849 func ValueRegisterTransformFunc(SrcTypeVar types.GType, DestTypeVar types.GType, TransformFuncVar *ValueTransform) {849 func ValueRegisterTransformFunc(SrcTypeVar types.GType, DestTypeVar types.GType, TransformFuncVar *ValueTransform) {
850 850
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)
852 865
853 }866 }
854 867
M v4/gobject/gvaluearray.go +28 -2
@@ -145,7 +145,20 @@ var xValueArraySort func(uintptr, uintptr) *ValueArray
145 // C qsort() function.145 // C qsort() function.
146 func (x *ValueArray) Sort(CompareFuncVar *glib.CompareFunc) *ValueArray {146 func (x *ValueArray) Sort(CompareFuncVar *glib.CompareFunc) *ValueArray {
147 147
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)
149 return cret162 return cret
150 }163 }
151 164
@@ -158,7 +171,20 @@ var xValueArraySortWithData func(uintptr, uintptr, uintptr) *ValueArray
158 // C qsort() function.171 // C qsort() function.
159 func (x *ValueArray) SortWithData(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) *ValueArray {172 func (x *ValueArray) SortWithData(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) *ValueArray {
160 173
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)
162 return cret188 return cret
163 }189 }
164 190
M v4/gsk/gskrendernode.go +16 -1
@@ -298,7 +298,22 @@ var xRenderNodeDeserialize func(*glib.Bytes, uintptr, uintptr) uintptr
298 func RenderNodeDeserialize(BytesVar *glib.Bytes, ErrorFuncVar *ParseErrorFunc, UserDataVar uintptr) *RenderNode {298 func RenderNodeDeserialize(BytesVar *glib.Bytes, ErrorFuncVar *ParseErrorFunc, UserDataVar uintptr) *RenderNode {
299 var cls *RenderNode299 var cls *RenderNode
300 300
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)
302 317
303 if cret == 0 {318 if cret == 0 {
304 return nil319 return nil
M v4/gsk/gsktypes.go +28 -2
@@ -247,7 +247,20 @@ var xPathForeach func(uintptr, PathForeachFlags, uintptr, uintptr) bool
247 // an approximation of the path using just the allowed operations.247 // an approximation of the path using just the allowed operations.
248 func (x *Path) Foreach(FlagsVar PathForeachFlags, FuncVar *PathForeachFunc, UserDataVar uintptr) bool {248 func (x *Path) Foreach(FlagsVar PathForeachFlags, FuncVar *PathForeachFunc, UserDataVar uintptr) bool {
249 249
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)
251 return cret264 return cret
252 }265 }
253 266
@@ -270,7 +283,20 @@ var xPathForeachIntersection func(uintptr, *Path, uintptr, uintptr) bool
270 // If @func returns `FALSE`, the iteration is stopped.283 // If @func returns `FALSE`, the iteration is stopped.
271 func (x *Path) ForeachIntersection(Path2Var *Path, FuncVar *PathIntersectionFunc, UserDataVar uintptr) bool {284 func (x *Path) ForeachIntersection(Path2Var *Path, FuncVar *PathIntersectionFunc, UserDataVar uintptr) bool {
272 285
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)
274 return cret300 return cret
275 }301 }
276 302
M v4/gtk/gtkalertdialog.go +16 -1
@@ -74,7 +74,22 @@ var xAlertDialogChoose func(uintptr, uintptr, uintptr, uintptr, uintptr)
74 // this case is [method@Gtk.AlertDialog.show].74 // this case is [method@Gtk.AlertDialog.show].
75 func (x *AlertDialog) Choose(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {75 func (x *AlertDialog) Choose(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
76 76
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)
78 93
79 }94 }
80 95
M v4/gtk/gtkassistant.go +29 -1
@@ -360,7 +360,35 @@ var xAssistantSetForwardPageFunc func(uintptr, uintptr, uintptr, uintptr)
360 // next visible page.360 // next visible page.
361 func (x *Assistant) SetForwardPageFunc(PageFuncVar *AssistantPageFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {361 func (x *Assistant) SetForwardPageFunc(PageFuncVar *AssistantPageFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
362 362
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)
364 392
365 }393 }
366 394
M v4/gtk/gtkbuilderscope.go +28 -2
@@ -274,7 +274,20 @@ var xBuilderCScopeAddCallbackSymbol func(uintptr, string, uintptr)
274 // namespace.274 // namespace.
275 func (x *BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {275 func (x *BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {
276 276
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)
278 291
279 }292 }
280 293
@@ -286,7 +299,20 @@ var xBuilderCScopeAddCallbackSymbols func(uintptr, string, uintptr, ...interface
286 // for each symbol.299 // for each symbol.
287 func (x *BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar *gobject.Callback, varArgs ...interface{}) {300 func (x *BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar *gobject.Callback, varArgs ...interface{}) {
288 301
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...)
290 316
291 }317 }
292 318
M v4/gtk/gtkcellarea.go +28 -2
@@ -1299,7 +1299,20 @@ var xCellAreaForeach func(uintptr, uintptr, uintptr)
1299 // Calls @callback for every `GtkCellRenderer` in @area.1299 // Calls @callback for every `GtkCellRenderer` in @area.
1300 func (x *CellArea) Foreach(CallbackVar *CellCallback, CallbackDataVar uintptr) {1300 func (x *CellArea) Foreach(CallbackVar *CellCallback, CallbackDataVar uintptr) {
1301 1301
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)
1303 1316
1304 }1317 }
1305 1318
@@ -1309,7 +1322,20 @@ var xCellAreaForeachAlloc func(uintptr, uintptr, uintptr, *gdk.Rectangle, *gdk.R
1309 // allocated rectangle inside @cell_area.1322 // allocated rectangle inside @cell_area.
1310 func (x *CellArea) ForeachAlloc(ContextVar *CellAreaContext, WidgetVar *Widget, CellAreaVar *gdk.Rectangle, BackgroundAreaVar *gdk.Rectangle, CallbackVar *CellAllocCallback, CallbackDataVar uintptr) {1323 func (x *CellArea) ForeachAlloc(ContextVar *CellAreaContext, WidgetVar *Widget, CellAreaVar *gdk.Rectangle, BackgroundAreaVar *gdk.Rectangle, CallbackVar *CellAllocCallback, CallbackDataVar uintptr) {
1311 1324
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)
1313 1339
1314 }1340 }
1315 1341
M v4/gtk/gtkcolordialog.go +16 -1
@@ -72,7 +72,22 @@ var xColorDialogChooseRgba func(uintptr, uintptr, *gdk.RGBA, uintptr, uintptr, u
72 // Presents a color chooser dialog to the user.72 // Presents a color chooser dialog to the user.
73 func (x *ColorDialog) ChooseRgba(ParentVar *Window, InitialColorVar *gdk.RGBA, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {73 func (x *ColorDialog) ChooseRgba(ParentVar *Window, InitialColorVar *gdk.RGBA, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
74 74
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)
76 91
77 }92 }
78 93
M v4/gtk/gtkcombobox.go +31 -1
@@ -565,7 +565,37 @@ var xComboBoxSetRowSeparatorFunc func(uintptr, uintptr, uintptr, uintptr)
565 // This is the default value.565 // This is the default value.
566 func (x *ComboBox) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {566 func (x *ComboBox) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
567 567
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)
569 599
570 }600 }
571 601
M v4/gtk/gtkcustomfilter.go +58 -2
@@ -55,7 +55,35 @@ var xNewCustomFilter func(uintptr, uintptr, uintptr) uintptr
55 func NewCustomFilter(MatchFuncVar *CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *CustomFilter {55 func NewCustomFilter(MatchFuncVar *CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *CustomFilter {
56 var cls *CustomFilter56 var cls *CustomFilter
57 57
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)
59 87
60 if cret == 0 {88 if cret == 0 {
61 return nil89 return nil
@@ -78,7 +106,35 @@ var xCustomFilterSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
78 // will be called.106 // will be called.
79 func (x *CustomFilter) SetFilterFunc(MatchFuncVar *CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {107 func (x *CustomFilter) SetFilterFunc(MatchFuncVar *CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
80 108
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)
82 138
83 }139 }
84 140
M v4/gtk/gtkcustomlayout.go +42 -1
@@ -62,7 +62,48 @@ var xNewCustomLayout func(uintptr, uintptr, uintptr) uintptr
62 func NewCustomLayout(RequestModeVar *CustomRequestModeFunc, MeasureVar *CustomMeasureFunc, AllocateVar *CustomAllocateFunc) *CustomLayout {62 func NewCustomLayout(RequestModeVar *CustomRequestModeFunc, MeasureVar *CustomMeasureFunc, AllocateVar *CustomAllocateFunc) *CustomLayout {
63 var cls *CustomLayout63 var cls *CustomLayout
64 64
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)
66 107
67 if cret == 0 {108 if cret == 0 {
68 return nil109 return nil
M v4/gtk/gtkcustomsorter.go +60 -2
@@ -47,7 +47,37 @@ var xNewCustomSorter func(uintptr, uintptr, uintptr) uintptr
47 func NewCustomSorter(SortFuncVar *glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *CustomSorter {47 func NewCustomSorter(SortFuncVar *glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *CustomSorter {
48 var cls *CustomSorter48 var cls *CustomSorter
49 49
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)
51 81
52 if cret == 0 {82 if cret == 0 {
53 return nil83 return nil
@@ -70,7 +100,35 @@ var xCustomSorterSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
70 // called now.100 // called now.
71 func (x *CustomSorter) SetSortFunc(SortFuncVar *glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {101 func (x *CustomSorter) SetSortFunc(SortFuncVar *glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
72 102
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)
74 132
75 }133 }
76 134
M v4/gtk/gtkdrawingarea.go +29 -1
@@ -244,7 +244,35 @@ var xDrawingAreaSetDrawFunc func(uintptr, uintptr, uintptr, uintptr)
244 // on the drawing area. This will cause a redraw and will call @draw_func again.244 // on the drawing area. This will cause a redraw and will call @draw_func again.
245 func (x *DrawingArea) SetDrawFunc(DrawFuncVar *DrawingAreaDrawFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {245 func (x *DrawingArea) SetDrawFunc(DrawFuncVar *DrawingAreaDrawFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
246 246
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)
248 276
249 }277 }
250 278
M v4/gtk/gtkentrycompletion.go +27 -1
@@ -285,7 +285,33 @@ var xEntryCompletionSetMatchFunc func(uintptr, uintptr, uintptr, uintptr)
285 // should not be in the completion list.285 // should not be in the completion list.
286 func (x *EntryCompletion) SetMatchFunc(FuncVar *EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar *glib.DestroyNotify) {286 func (x *EntryCompletion) SetMatchFunc(FuncVar *EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar *glib.DestroyNotify) {
287 287
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)
289 315
290 }316 }
291 317
M v4/gtk/gtkexpression.go +71 -2
@@ -181,7 +181,50 @@ var xNewCClosureExpression func(types.GType, uintptr, uint, uintptr, uintptr, ui
181 func NewCClosureExpression(ValueTypeVar types.GType, MarshalVar *gobject.ClosureMarshal, NParamsVar uint, ParamsVar uintptr, CallbackFuncVar *gobject.Callback, UserDataVar uintptr, UserDestroyVar *gobject.ClosureNotify) *CClosureExpression {181 func NewCClosureExpression(ValueTypeVar types.GType, MarshalVar *gobject.ClosureMarshal, NParamsVar uint, ParamsVar uintptr, CallbackFuncVar *gobject.Callback, UserDataVar uintptr, UserDestroyVar *gobject.ClosureNotify) *CClosureExpression {
182 var cls *CClosureExpression182 var cls *CClosureExpression
183 183
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)
185 228
186 if cret == 0 {229 if cret == 0 {
187 return nil230 return nil
@@ -629,7 +672,33 @@ var xExpressionWatch func(uintptr, uintptr, uintptr, uintptr, uintptr) *Expressi
629 // the @notify will be invoked.672 // the @notify will be invoked.
630 func (x *Expression) Watch(ThisVar *gobject.Object, NotifyVar *ExpressionNotify, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *ExpressionWatch {673 func (x *Expression) Watch(ThisVar *gobject.Object, NotifyVar *ExpressionNotify, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *ExpressionWatch {
631 674
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)
633 return cret702 return cret
634 }703 }
635 704
M v4/gtk/gtkfiledialog.go +128 -8
@@ -181,7 +181,22 @@ var xFileDialogOpen func(uintptr, uintptr, uintptr, uintptr, uintptr)
181 // The @callback will be called when the dialog is closed.181 // The @callback will be called when the dialog is closed.
182 func (x *FileDialog) Open(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {182 func (x *FileDialog) Open(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
183 183
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)
185 200
186 }201 }
187 202
@@ -221,7 +236,22 @@ var xFileDialogOpenMultiple func(uintptr, uintptr, uintptr, uintptr, uintptr)
221 // The @callback will be called when the dialog is closed.236 // The @callback will be called when the dialog is closed.
222 func (x *FileDialog) OpenMultiple(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {237 func (x *FileDialog) OpenMultiple(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
223 238
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)
225 255
226 }256 }
227 257
@@ -264,7 +294,22 @@ var xFileDialogOpenMultipleTextFiles func(uintptr, uintptr, uintptr, uintptr, ui
264 // The @callback will be called when the dialog is closed.294 // The @callback will be called when the dialog is closed.
265 func (x *FileDialog) OpenMultipleTextFiles(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {295 func (x *FileDialog) OpenMultipleTextFiles(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
266 296
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)
268 313
269 }314 }
270 315
@@ -303,7 +348,22 @@ var xFileDialogOpenTextFile func(uintptr, uintptr, uintptr, uintptr, uintptr)
303 // The @callback will be called when the dialog is closed.348 // The @callback will be called when the dialog is closed.
304 func (x *FileDialog) OpenTextFile(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {349 func (x *FileDialog) OpenTextFile(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
305 350
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)
307 367
308 }368 }
309 369
@@ -346,7 +406,22 @@ var xFileDialogSave func(uintptr, uintptr, uintptr, uintptr, uintptr)
346 // The @callback will be called when the dialog is closed.406 // The @callback will be called when the dialog is closed.
347 func (x *FileDialog) Save(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {407 func (x *FileDialog) Save(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
348 408
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)
350 425
351 }426 }
352 427
@@ -386,7 +461,22 @@ var xFileDialogSaveTextFile func(uintptr, uintptr, uintptr, uintptr, uintptr)
386 // The @callback will be called when the dialog is closed.461 // The @callback will be called when the dialog is closed.
387 func (x *FileDialog) SaveTextFile(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {462 func (x *FileDialog) SaveTextFile(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
388 463
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)
390 480
391 }481 }
392 482
@@ -436,7 +526,22 @@ var xFileDialogSelectFolder func(uintptr, uintptr, uintptr, uintptr, uintptr)
436 // The @callback will be called when the dialog is closed.526 // The @callback will be called when the dialog is closed.
437 func (x *FileDialog) SelectFolder(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {527 func (x *FileDialog) SelectFolder(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
438 528
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)
440 545
441 }546 }
442 547
@@ -477,7 +582,22 @@ var xFileDialogSelectMultipleFolders func(uintptr, uintptr, uintptr, uintptr, ui
477 // The @callback will be called when the dialog is closed.582 // The @callback will be called when the dialog is closed.
478 func (x *FileDialog) SelectMultipleFolders(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {583 func (x *FileDialog) SelectMultipleFolders(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
479 584
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)
481 601
482 }602 }
483 603
M v4/gtk/gtkfilelauncher.go +32 -2
@@ -108,7 +108,22 @@ var xFileLauncherLaunch func(uintptr, uintptr, uintptr, uintptr, uintptr)
108 // This may present an app chooser dialog to the user.108 // This may present an app chooser dialog to the user.
109 func (x *FileLauncher) Launch(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {109 func (x *FileLauncher) Launch(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
110 110
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)
112 127
113 }128 }
114 129
@@ -135,7 +150,22 @@ var xFileLauncherOpenContainingFolder func(uintptr, uintptr, uintptr, uintptr, u
135 // is e.g. a http:// uri.150 // is e.g. a http:// uri.
136 func (x *FileLauncher) OpenContainingFolder(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {151 func (x *FileLauncher) OpenContainingFolder(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
137 152
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)
139 169
140 }170 }
141 171
M v4/gtk/gtkflowbox.go +99 -4
@@ -198,7 +198,33 @@ var xFlowBoxBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
198 // should be implemented by the model.198 // should be implemented by the model.
199 func (x *FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {199 func (x *FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
200 200
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)
202 228
203 }229 }
204 230
@@ -414,7 +440,20 @@ var xFlowBoxSelectedForeach func(uintptr, uintptr, uintptr)
414 // this function.440 // this function.
415 func (x *FlowBox) SelectedForeach(FuncVar *FlowBoxForeachFunc, DataVar uintptr) {441 func (x *FlowBox) SelectedForeach(FuncVar *FlowBoxForeachFunc, DataVar uintptr) {
416 442
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)
418 457
419 }458 }
420 459
@@ -454,7 +493,35 @@ var xFlowBoxSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
454 // (see [method@Gtk.FlowBox.bind_model]).493 // (see [method@Gtk.FlowBox.bind_model]).
455 func (x *FlowBox) SetFilterFunc(FilterFuncVar *FlowBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {494 func (x *FlowBox) SetFilterFunc(FilterFuncVar *FlowBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
456 495
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)
458 525
459 }526 }
460 527
@@ -544,7 +611,35 @@ var xFlowBoxSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
544 // (see [method@Gtk.FlowBox.bind_model]).611 // (see [method@Gtk.FlowBox.bind_model]).
545 func (x *FlowBox) SetSortFunc(SortFuncVar *FlowBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {612 func (x *FlowBox) SetSortFunc(SortFuncVar *FlowBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
546 613
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)
548 643
549 }644 }
550 645
M v4/gtk/gtkfontdialog.go +64 -4
@@ -76,7 +76,22 @@ var xFontDialogChooseFace func(uintptr, uintptr, uintptr, uintptr, uintptr, uint
76 // A font face represents a font family and style, but no specific font size.76 // A font face represents a font family and style, but no specific font size.
77 func (x *FontDialog) ChooseFace(ParentVar *Window, InitialValueVar *pango.FontFace, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {77 func (x *FontDialog) ChooseFace(ParentVar *Window, InitialValueVar *pango.FontFace, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
78 78
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)
80 95
81 }96 }
82 97
@@ -111,7 +126,22 @@ var xFontDialogChooseFamily func(uintptr, uintptr, uintptr, uintptr, uintptr, ui
111 // The font chooser dialog will be set up for selecting a font family.126 // The font chooser dialog will be set up for selecting a font family.
112 func (x *FontDialog) ChooseFamily(ParentVar *Window, InitialValueVar *pango.FontFamily, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {127 func (x *FontDialog) ChooseFamily(ParentVar *Window, InitialValueVar *pango.FontFamily, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
113 128
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)
115 145
116 }146 }
117 147
@@ -149,7 +179,22 @@ var xFontDialogChooseFont func(uintptr, uintptr, *pango.FontDescription, uintptr
149 // use [method@Gtk.FontDialog.choose_font_and_features] instead.179 // use [method@Gtk.FontDialog.choose_font_and_features] instead.
150 func (x *FontDialog) ChooseFont(ParentVar *Window, InitialValueVar *pango.FontDescription, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {180 func (x *FontDialog) ChooseFont(ParentVar *Window, InitialValueVar *pango.FontDescription, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
151 181
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)
153 198
154 }199 }
155 200
@@ -164,7 +209,22 @@ var xFontDialogChooseFontAndFeatures func(uintptr, uintptr, *pango.FontDescripti
164 // enabling glyph variants or ligatures.209 // enabling glyph variants or ligatures.
165 func (x *FontDialog) ChooseFontAndFeatures(ParentVar *Window, InitialValueVar *pango.FontDescription, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {210 func (x *FontDialog) ChooseFontAndFeatures(ParentVar *Window, InitialValueVar *pango.FontDescription, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
166 211
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)
168 228
169 }229 }
170 230
M v4/gtk/gtkiconview.go +14 -1
@@ -536,7 +536,20 @@ var xIconViewSelectedForeach func(uintptr, uintptr, uintptr)
536 // selection cannot be modified from within this function.536 // selection cannot be modified from within this function.
537 func (x *IconView) SelectedForeach(FuncVar *IconViewForeachFunc, DataVar uintptr) {537 func (x *IconView) SelectedForeach(FuncVar *IconViewForeachFunc, DataVar uintptr) {
538 538
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)
540 553
541 }554 }
542 555
M v4/gtk/gtklistbox.go +130 -5
@@ -209,7 +209,35 @@ var xListBoxBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
209 // should be implemented by the model.209 // should be implemented by the model.
210 func (x *ListBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {210 func (x *ListBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
211 211
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)
213 241
214 }242 }
215 243
@@ -475,7 +503,20 @@ var xListBoxSelectedForeach func(uintptr, uintptr, uintptr)
475 // Note that the selection cannot be modified from within this function.503 // Note that the selection cannot be modified from within this function.
476 func (x *ListBox) SelectedForeach(FuncVar *ListBoxForeachFunc, DataVar uintptr) {504 func (x *ListBox) SelectedForeach(FuncVar *ListBoxForeachFunc, DataVar uintptr) {
477 505
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)
479 520
480 }521 }
481 522
@@ -524,7 +565,35 @@ var xListBoxSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
524 // (see [method@Gtk.ListBox.bind_model]).565 // (see [method@Gtk.ListBox.bind_model]).
525 func (x *ListBox) SetFilterFunc(FilterFuncVar *ListBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {566 func (x *ListBox) SetFilterFunc(FilterFuncVar *ListBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
526 567
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)
528 597
529 }598 }
530 599
@@ -557,7 +626,35 @@ var xListBoxSetHeaderFunc func(uintptr, uintptr, uintptr, uintptr)
557 // [method@Gtk.ListBox.invalidate_headers] is called.626 // [method@Gtk.ListBox.invalidate_headers] is called.
558 func (x *ListBox) SetHeaderFunc(UpdateHeaderVar *ListBoxUpdateHeaderFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {627 func (x *ListBox) SetHeaderFunc(UpdateHeaderVar *ListBoxUpdateHeaderFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
559 628
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)
561 658
562 }659 }
563 660
@@ -606,7 +703,35 @@ var xListBoxSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
606 // (see [method@Gtk.ListBox.bind_model]).703 // (see [method@Gtk.ListBox.bind_model]).
607 func (x *ListBox) SetSortFunc(SortFuncVar *ListBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {704 func (x *ListBox) SetSortFunc(SortFuncVar *ListBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
608 705
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)
610 735
611 }736 }
612 737
M v4/gtk/gtkmaplistmodel.go +58 -2
@@ -86,7 +86,35 @@ var xNewMapListModel func(uintptr, uintptr, uintptr, uintptr) uintptr
86 func NewMapListModel(ModelVar gio.ListModel, MapFuncVar *MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *MapListModel {86 func NewMapListModel(ModelVar gio.ListModel, MapFuncVar *MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *MapListModel {
87 var cls *MapListModel87 var cls *MapListModel
88 88
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)
90 118
91 if cret == 0 {119 if cret == 0 {
92 return nil120 return nil
@@ -137,7 +165,35 @@ var xMapListModelSetMapFunc func(uintptr, uintptr, uintptr, uintptr)
137 // function returns items of the appropriate type.165 // function returns items of the appropriate type.
138 func (x *MapListModel) SetMapFunc(MapFuncVar *MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {166 func (x *MapListModel) SetMapFunc(MapFuncVar *MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
139 167
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)
141 197
142 }198 }
143 199
M v4/gtk/gtkmenubutton.go +31 -1
@@ -347,7 +347,37 @@ var xMenuButtonSetCreatePopupFunc func(uintptr, uintptr, uintptr, uintptr)
347 // @menu_button. Instead, this can be done manually in @func.347 // @menu_button. Instead, this can be done manually in @func.
348 func (x *MenuButton) SetCreatePopupFunc(FuncVar *MenuButtonCreatePopupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {348 func (x *MenuButton) SetCreatePopupFunc(FuncVar *MenuButtonCreatePopupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
349 349
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)
351 381
352 }382 }
353 383
M v4/gtk/gtkprintdialog.go +48 -3
@@ -226,7 +226,22 @@ var xPrintDialogPrint func(uintptr, uintptr, *PrintSetup, uintptr, uintptr, uint
226 // The @callback will be called when the printing is done.226 // The @callback will be called when the printing is done.
227 func (x *PrintDialog) Print(ParentVar *Window, SetupVar *PrintSetup, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {227 func (x *PrintDialog) Print(ParentVar *Window, SetupVar *PrintSetup, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
228 228
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)
230 245
231 }246 }
232 247
@@ -238,7 +253,22 @@ var xPrintDialogPrintFile func(uintptr, uintptr, *PrintSetup, uintptr, uintptr,
238 // Otherwise, it will attempt to print directly, without user interaction.253 // Otherwise, it will attempt to print directly, without user interaction.
239 func (x *PrintDialog) PrintFile(ParentVar *Window, SetupVar *PrintSetup, FileVar gio.File, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {254 func (x *PrintDialog) PrintFile(ParentVar *Window, SetupVar *PrintSetup, FileVar gio.File, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
240 255
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)
242 272
243 }273 }
244 274
@@ -359,7 +389,22 @@ var xPrintDialogSetup func(uintptr, uintptr, uintptr, uintptr, uintptr)
359 // to do the printing without further user interaction.389 // to do the printing without further user interaction.
360 func (x *PrintDialog) Setup(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {390 func (x *PrintDialog) Setup(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
361 391
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)
363 408
364 }409 }
365 410
M v4/gtk/gtkprinter.go +27 -1
@@ -75,7 +75,33 @@ var xEnumeratePrinters func(uintptr, uintptr, uintptr, bool)
75 // If @func returns true, the enumeration is stopped.75 // If @func returns true, the enumeration is stopped.
76 func EnumeratePrinters(FuncVar *PrinterFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify, WaitVar bool) {76 func EnumeratePrinters(FuncVar *PrinterFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify, WaitVar bool) {
77 77
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)
79 105
80 }106 }
81 107
M v4/gtk/gtkprintjob.go +27 -1
@@ -232,7 +232,33 @@ var xPrintJobSend func(uintptr, uintptr, uintptr, uintptr)
232 // Sends the print job off to the printer.232 // Sends the print job off to the printer.
233 func (x *PrintJob) Send(CallbackVar *PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar *glib.DestroyNotify) {233 func (x *PrintJob) Send(CallbackVar *PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar *glib.DestroyNotify) {
234 234
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)
236 262
237 }263 }
238 264
M v4/gtk/gtkprintoperation.go +14 -1
@@ -528,7 +528,20 @@ var xPrintRunPageSetupDialogAsync func(uintptr, uintptr, uintptr, uintptr, uintp
528 // @done_cb from a signal handler for the ::response signal of the dialog.528 // @done_cb from a signal handler for the ::response signal of the dialog.
529 func PrintRunPageSetupDialogAsync(ParentVar *Window, PageSetupVar *PageSetup, SettingsVar *PrintSettings, DoneCbVar *PageSetupDoneFunc, DataVar uintptr) {529 func PrintRunPageSetupDialogAsync(ParentVar *Window, PageSetupVar *PageSetup, SettingsVar *PrintSettings, DoneCbVar *PageSetupDoneFunc, DataVar uintptr) {
530 530
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)
532 545
533 }546 }
534 547
M v4/gtk/gtkprintsettings.go +14 -1
@@ -253,7 +253,20 @@ var xPrintSettingsForeach func(uintptr, uintptr, uintptr)
253 // Calls @func for each key-value pair of @settings.253 // Calls @func for each key-value pair of @settings.
254 func (x *PrintSettings) Foreach(FuncVar *PrintSettingsFunc, UserDataVar uintptr) {254 func (x *PrintSettings) Foreach(FuncVar *PrintSettingsFunc, UserDataVar uintptr) {
255 255
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)
257 270
258 }271 }
259 272
M v4/gtk/gtkscale.go +31 -1
@@ -352,7 +352,37 @@ var xScaleSetFormatValueFunc func(uintptr, uintptr, uintptr, uintptr)
352 // [property@Gtk.Scale:digits] property.352 // [property@Gtk.Scale:digits] property.
353 func (x *Scale) SetFormatValueFunc(FuncVar *ScaleFormatValueFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {353 func (x *Scale) SetFormatValueFunc(FuncVar *ScaleFormatValueFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
354 354
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)
356 386
357 }387 }
358 388
M v4/gtk/gtkshortcutaction.go +27 -1
@@ -164,7 +164,33 @@ var xNewCallbackAction func(uintptr, uintptr, uintptr) uintptr
164 func NewCallbackAction(CallbackVar *ShortcutFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) *CallbackAction {164 func NewCallbackAction(CallbackVar *ShortcutFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) *CallbackAction {
165 var cls *CallbackAction165 var cls *CallbackAction
166 166
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)
168 194
169 if cret == 0 {195 if cret == 0 {
170 return nil196 return nil
M v4/gtk/gtkshow.go +18 -1
@@ -2,6 +2,8 @@
2 package gtk2 package gtk
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/gio"9 "github.com/jwijenbergh/puregotk/v4/gio"
@@ -29,7 +31,22 @@ var xShowUriFull func(uintptr, string, uint32, uintptr, uintptr, uintptr)
29 // necessary for sandbox helpers to parent their dialogs properly.31 // necessary for sandbox helpers to parent their dialogs properly.
30 func ShowUriFull(ParentVar *Window, UriVar string, TimestampVar uint32, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {32 func ShowUriFull(ParentVar *Window, UriVar string, TimestampVar uint32, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
31 33
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)
33 50
34 }51 }
35 52
M v4/gtk/gtktextbuffer.go +27 -1
@@ -627,7 +627,33 @@ var xTextBufferAddCommitNotify func(uintptr, TextBufferNotifyFlags, uintptr, uin
627 // other signal handlers which may further modify the [type@Gtk.TextBuffer].627 // other signal handlers which may further modify the [type@Gtk.TextBuffer].
628 func (x *TextBuffer) AddCommitNotify(FlagsVar TextBufferNotifyFlags, CommitNotifyVar *TextBufferCommitNotify, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) uint {628 func (x *TextBuffer) AddCommitNotify(FlagsVar TextBufferNotifyFlags, CommitNotifyVar *TextBufferCommitNotify, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) uint {
629 629
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)
631 return cret657 return cret
632 }658 }
633 659
M v4/gtk/gtktextiter.go +28 -2
@@ -136,7 +136,20 @@ var xTextIterBackwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
136 // but goes backward from @iter.136 // but goes backward from @iter.
137 func (x *TextIter) BackwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {137 func (x *TextIter) BackwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
138 138
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)
140 return cret153 return cret
141 }154 }
142 155
@@ -551,7 +564,20 @@ var xTextIterForwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
551 // @limit is non-%NULL, otherwise to the end iterator.564 // @limit is non-%NULL, otherwise to the end iterator.
552 func (x *TextIter) ForwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {565 func (x *TextIter) ForwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
553 566
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)
555 return cret581 return cret
556 }582 }
557 583
M v4/gtk/gtktexttagtable.go +14 -1
@@ -94,7 +94,20 @@ var xTextTagTableForeach func(uintptr, uintptr, uintptr)
94 // over it (you can’t add/remove tags).94 // over it (you can’t add/remove tags).
95 func (x *TextTagTable) Foreach(FuncVar *TextTagTableForeach, DataVar uintptr) {95 func (x *TextTagTable) Foreach(FuncVar *TextTagTableForeach, DataVar uintptr) {
96 96
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)
98 111
99 }112 }
100 113
M v4/gtk/gtktreelistmodel.go +27 -1
@@ -66,7 +66,33 @@ var xNewTreeListModel func(uintptr, bool, bool, uintptr, uintptr, uintptr) uintp
66 func NewTreeListModel(RootVar gio.ListModel, PassthroughVar bool, AutoexpandVar bool, CreateFuncVar *TreeListModelCreateModelFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *TreeListModel {66 func NewTreeListModel(RootVar gio.ListModel, PassthroughVar bool, AutoexpandVar bool, CreateFuncVar *TreeListModelCreateModelFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *TreeListModel {
67 var cls *TreeListModel67 var cls *TreeListModel
68 68
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)
70 96
71 if cret == 0 {97 if cret == 0 {
72 return nil98 return nil
M v4/gtk/gtktreemodelfilter.go +58 -2
@@ -291,7 +291,35 @@ var xTreeModelFilterSetModifyFunc func(uintptr, int, []types.GType, uintptr, uin
291 // can only be called once for a given filter model.291 // can only be called once for a given filter model.
292 func (x *TreeModelFilter) SetModifyFunc(NColumnsVar int, TypesVar []types.GType, FuncVar *TreeModelFilterModifyFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {292 func (x *TreeModelFilter) SetModifyFunc(NColumnsVar int, TypesVar []types.GType, FuncVar *TreeModelFilterModifyFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
293 293
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)
295 323
296 }324 }
297 325
@@ -353,7 +381,35 @@ var xTreeModelFilterSetVisibleFunc func(uintptr, uintptr, uintptr, uintptr)
353 // once for a given filter model.381 // once for a given filter model.
354 func (x *TreeModelFilter) SetVisibleFunc(FuncVar *TreeModelFilterVisibleFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {382 func (x *TreeModelFilter) SetVisibleFunc(FuncVar *TreeModelFilterVisibleFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
355 383
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)
357 413
358 }414 }
359 415
M v4/gtk/gtktreeselection.go +43 -2
@@ -213,7 +213,20 @@ var xTreeSelectionSelectedForeach func(uintptr, uintptr, uintptr)
213 // gtk_tree_selection_get_selected_rows() might be more useful.213 // gtk_tree_selection_get_selected_rows() might be more useful.
214 func (x *TreeSelection) SelectedForeach(FuncVar *TreeSelectionForeachFunc, DataVar uintptr) {214 func (x *TreeSelection) SelectedForeach(FuncVar *TreeSelectionForeachFunc, DataVar uintptr) {
215 215
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)
217 230
218 }231 }
219 232
@@ -238,7 +251,35 @@ var xTreeSelectionSetSelectFunction func(uintptr, uintptr, uintptr, uintptr)
238 // if the state of the node should be left unchanged.251 // if the state of the node should be left unchanged.
239 func (x *TreeSelection) SetSelectFunction(FuncVar *TreeSelectionFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {252 func (x *TreeSelection) SetSelectFunction(FuncVar *TreeSelectionFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
240 253
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)
242 283
243 }284 }
244 285
M v4/gtk/gtktreeview.go +132 -5
@@ -1193,7 +1193,33 @@ var xTreeViewInsertColumnWithDataFunc func(uintptr, int, string, uintptr, uintpt
1193 // “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.1193 // “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
1194 func (x *TreeView) InsertColumnWithDataFunc(PositionVar int, TitleVar string, CellVar *CellRenderer, FuncVar *TreeCellDataFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) int {1194 func (x *TreeView) InsertColumnWithDataFunc(PositionVar int, TitleVar string, CellVar *CellRenderer, FuncVar *TreeCellDataFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) int {
1195 1195
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)
1197 return cret1223 return cret
1198 }1224 }
1199 1225
@@ -1237,7 +1263,20 @@ var xTreeViewMapExpandedRows func(uintptr, uintptr, uintptr)
1237 // Calls @func on all expanded rows.1263 // Calls @func on all expanded rows.
1238 func (x *TreeView) MapExpandedRows(FuncVar *TreeViewMappingFunc, DataVar uintptr) {1264 func (x *TreeView) MapExpandedRows(FuncVar *TreeViewMappingFunc, DataVar uintptr) {
1239 1265
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)
1241 1280
1242 }1281 }
1243 1282
@@ -1340,7 +1379,37 @@ var xTreeViewSetColumnDragFunction func(uintptr, uintptr, uintptr, uintptr)
1340 // dropped everywhere.1379 // dropped everywhere.
1341 func (x *TreeView) SetColumnDragFunction(FuncVar *TreeViewColumnDropFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {1380 func (x *TreeView) SetColumnDragFunction(FuncVar *TreeViewColumnDropFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
1342 1381
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)
1344 1413
1345 }1414 }
1346 1415
@@ -1548,7 +1617,37 @@ var xTreeViewSetRowSeparatorFunc func(uintptr, uintptr, uintptr, uintptr)
1548 // function is %NULL, no separators are drawn. This is the default value.1617 // function is %NULL, no separators are drawn. This is the default value.
1549 func (x *TreeView) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {1618 func (x *TreeView) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
1550 1619
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)
1552 1651
1553 }1652 }
1554 1653
@@ -1600,7 +1699,35 @@ var xTreeViewSetSearchEqualFunc func(uintptr, uintptr, uintptr, uintptr)
1600 // `GtkTreeView`SearchEqualFunc returns %FALSE on matches.1699 // `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
1601 func (x *TreeView) SetSearchEqualFunc(SearchEqualFuncVar *TreeViewSearchEqualFunc, SearchUserDataVar uintptr, SearchDestroyVar *glib.DestroyNotify) {1700 func (x *TreeView) SetSearchEqualFunc(SearchEqualFuncVar *TreeViewSearchEqualFunc, SearchUserDataVar uintptr, SearchDestroyVar *glib.DestroyNotify) {
1602 1701
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)
1604 1731
1605 }1732 }
1606 1733
M v4/gtk/gtktreeviewcolumn.go +29 -1
@@ -523,7 +523,35 @@ var xTreeViewColumnSetCellDataFunc func(uintptr, uintptr, uintptr, uintptr, uint
523 // older one.523 // older one.
524 func (x *TreeViewColumn) SetCellDataFunc(CellRendererVar *CellRenderer, FuncVar *TreeCellDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify) {524 func (x *TreeViewColumn) SetCellDataFunc(CellRendererVar *CellRenderer, FuncVar *TreeCellDataFunc, FuncDataVar uintptr, DestroyVar *glib.DestroyNotify) {
525 525
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)
527 555
528 }556 }
529 557
M v4/gtk/gtkurilauncher.go +16 -1
@@ -95,7 +95,22 @@ var xUriLauncherLaunch func(uintptr, uintptr, uintptr, uintptr, uintptr)
95 // This may present an app chooser dialog to the user.95 // This may present an app chooser dialog to the user.
96 func (x *UriLauncher) Launch(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {96 func (x *UriLauncher) Launch(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
97 97
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)
99 114
100 }115 }
101 116
M v4/gtk/gtkwidget.go +69 -4
@@ -159,7 +159,20 @@ var xWidgetClassAddBinding func(uintptr, uint, gdk.ModifierType, uintptr, string
159 // shortcut.159 // shortcut.
160 func (x *WidgetClass) AddBinding(KeyvalVar uint, ModsVar gdk.ModifierType, CallbackVar *ShortcutFunc, FormatStringVar string, varArgs ...interface{}) {160 func (x *WidgetClass) AddBinding(KeyvalVar uint, ModsVar gdk.ModifierType, CallbackVar *ShortcutFunc, FormatStringVar string, varArgs ...interface{}) {
161 161
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...)
163 176
164 }177 }
165 178
@@ -228,7 +241,20 @@ var xWidgetClassBindTemplateCallbackFull func(uintptr, string, uintptr)
228 // class initializer after calling [method@Gtk.WidgetClass.set_template].241 // class initializer after calling [method@Gtk.WidgetClass.set_template].
229 func (x *WidgetClass) BindTemplateCallbackFull(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {242 func (x *WidgetClass) BindTemplateCallbackFull(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {
230 243
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)
232 258
233 }259 }
234 260
@@ -328,7 +354,20 @@ var xWidgetClassInstallAction func(uintptr, string, string, uintptr)
328 // with [method@Gtk.Widget.action_set_enabled]).354 // with [method@Gtk.Widget.action_set_enabled]).
329 func (x *WidgetClass) InstallAction(ActionNameVar string, ParameterTypeVar string, ActivateVar *WidgetActionActivateFunc) {355 func (x *WidgetClass) InstallAction(ActionNameVar string, ParameterTypeVar string, ActivateVar *WidgetActionActivateFunc) {
330 356
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)
332 371
333 }372 }
334 373
@@ -1832,7 +1871,33 @@ var xWidgetAddTickCallback func(uintptr, uintptr, uintptr, uintptr) uint
1832 // to [method@Gtk.Widget.remove_tick_callback].1871 // to [method@Gtk.Widget.remove_tick_callback].
1833 func (x *Widget) AddTickCallback(CallbackVar *TickCallback, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) uint {1872 func (x *Widget) AddTickCallback(CallbackVar *TickCallback, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) uint {
1834 1873
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)
1836 return cret1901 return cret
1837 }1902 }
1838 1903
M v4/pango/pango-attributes.go +45 -2
@@ -390,7 +390,20 @@ var xAttrListFilter func(uintptr, uintptr, uintptr) *AttrList
390 // inserts them into a new list.390 // inserts them into a new list.
391 func (x *AttrList) Filter(FuncVar *AttrFilterFunc, DataVar uintptr) *AttrList {391 func (x *AttrList) Filter(FuncVar *AttrFilterFunc, DataVar uintptr) *AttrList {
392 392
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)
394 return cret407 return cret
395 }408 }
396 409
@@ -1323,7 +1336,37 @@ var xAttrShapeNewWithData func(*Rectangle, *Rectangle, uintptr, uintptr, uintptr
1323 // rendering the glyph.1336 // rendering the glyph.
1324 func AttrShapeNewWithData(InkRectVar *Rectangle, LogicalRectVar *Rectangle, DataVar uintptr, CopyFuncVar *AttrDataCopyFunc, DestroyFuncVar *glib.DestroyNotify) *Attribute {1337 func AttrShapeNewWithData(InkRectVar *Rectangle, LogicalRectVar *Rectangle, DataVar uintptr, CopyFuncVar *AttrDataCopyFunc, DestroyFuncVar *glib.DestroyNotify) *Attribute {
1325 1338
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)
1327 return cret1370 return cret
1328 }1371 }
1329 1372
M v4/pango/pango-fontset.go +14 -1
@@ -289,7 +289,20 @@ var xFontsetForeach func(uintptr, uintptr, uintptr)
289 // If @func returns %TRUE, that stops the iteration.289 // If @func returns %TRUE, that stops the iteration.
290 func (x *Fontset) Foreach(FuncVar *FontsetForeachFunc, DataVar uintptr) {290 func (x *Fontset) Foreach(FuncVar *FontsetForeachFunc, DataVar uintptr) {
291 291
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)
293 306
294 }307 }
295 308
M v4/pangocairo/pangocairo.go +33 -1
@@ -2,6 +2,8 @@
2 package pangocairo2 package pangocairo
3 3
4 import (4 import (
5+ "unsafe"
6+
5 "github.com/jwijenbergh/purego"7 "github.com/jwijenbergh/purego"
6 "github.com/jwijenbergh/puregotk/pkg/core"8 "github.com/jwijenbergh/puregotk/pkg/core"
7 "github.com/jwijenbergh/puregotk/v4/cairo"9 "github.com/jwijenbergh/puregotk/v4/cairo"
@@ -236,7 +238,37 @@ var xContextSetShapeRenderer func(uintptr, uintptr, uintptr, uintptr)
236 // See `PangoCairoShapeRendererFunc` for details.238 // See `PangoCairoShapeRendererFunc` for details.
237 func ContextSetShapeRenderer(ContextVar *pango.Context, FuncVar *ShapeRendererFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) {239 func ContextSetShapeRenderer(ContextVar *pango.Context, FuncVar *ShapeRendererFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) {
238 240
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)
240 272
241 }273 }
242 274

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