1// Package {{.PkgName}} was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package {{.PkgName}}
3
4{{ $NotGObject := ne .PkgName "gobject" }}
5{{ $NotGLib := ne .PkgName "glib" }}
6{{ $HasSignals := false }}
7{{ $HasDetailedSignals := false }}
8{{range .Classes -}}
9 {{if .Signals}}
10 {{ $HasSignals = true }}
11 {{end}}
12 {{range .Signals}}
13 {{if .Detailed}}
14 {{ $HasDetailedSignals = true }}
15 {{end}}
16 {{end}}
17{{end}}
18{{ $HasCallbacks := or .HasReceiverCallbacks .HasFunctionCallbacks }}
19{{ $NeedsUnsafe := or .Records $HasSignals $HasCallbacks }}
20{{ $HasRecordCallbacks := false }}
21{{range .Records}}{{if .CallbackAccessors}}{{ $HasRecordCallbacks = true }}{{end}}{{end}}
22{{ $NeedsPurego := or .NeedsInit $HasSignals $HasCallbacks $HasRecordCallbacks }}
23{{ $NeedsCore := or .NeedsInit .NeedsCore .HasSignalStrings }}
24{{ $NeedsTypes := .HasTypeGetters }}
25{{ $AnyImports := or $NeedsCore $NeedsTypes .Records $HasSignals $HasCallbacks $HasDetailedSignals }}
26
27{{if $AnyImports}}
28import (
29{{- if $NeedsUnsafe}}
30 "unsafe"
31{{- end}}
32{{- if $HasDetailedSignals}}
33 "fmt"
34{{- end}}
35{{- if .Records}}
36 "structs"
37{{- end}}
38{{- if $NeedsPurego}}
39 "github.com/ebitengine/purego"
40{{- end}}
41{{- if $NeedsCore}}
42 "github.com/bnema/puregotk/pkg/core"
43{{- end}}
44{{- if $NeedsTypes}}
45 "github.com/bnema/puregotk/v4/gobject/types"
46{{- end}}
47{{- if and .NeedsGLib $NotGLib}}
48 "github.com/bnema/puregotk/v4/glib"
49{{- end}}
50{{- if and .NeedsGObject $NotGObject}}
51 "github.com/bnema/puregotk/v4/gobject"
52{{- end}}
53{{- range .CrossPkgImports}}
54 "{{.}}"
55{{- end}}
56)
57{{end}}
58
59{{$outer := .}}
60
61{{range .Callbacks -}}
62{{.Doc}}
63type {{.Name}} func({{ conv .Args.Pure.Types }}) {{.Ret.Raw}}
64{{end}}
65
66{{range .Records -}}
67{{.Doc}}
68type {{.Name}} struct {
69 _ structs.HostLayout
70 {{range .Fields}}
71 {{.Name}} {{.Type}}
72 {{end}}
73}
74
75{{if .TypeGetter}}
76var x{{.Name}}GLibType func() types.GType
77func {{.Name}}GLibType() types.GType {
78 return x{{.Name}}GLibType()
79}
80{{end}}
81
82func (x *{{.Name}}) GoPointer() uintptr {
83 return uintptr(unsafe.Pointer(x))
84}
85
86{{$outer := .}}
87
88{{range .Constructors -}}
89var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
90
91
92{{.Doc}}
93func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
94 {{.Ret.Preamble $NotGLib}}
95 {{range .Args.Callbacks}}
96 var {{.Name}}Ref uintptr
97 if {{.Name}} != nil {
98 {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
99 if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
100 {{.Name}}Ref = cbRefPtr
101 } else {
102 fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
103 cbFn := *{{.Name}}
104 {{if .RetRaw}}return {{end}}cbFn({{range $i, $a := .CallArgs}}{{if $i}}, {{end}}{{$a}}{{end}})
105 }
106 {{.Name}}Ref = purego.NewCallback(fcb)
107 {{if $NotGLib}}glib.{{end}}SaveCallbackWithClosure({{.Name}}Ptr, {{.Name}}Ref, {{.Name}})
108 }
109 }
110 {{end}}
111 {{range .Args.NullableStrings}}
112 {{.Name}}Ptr := core.GStrdupNullable({{.Name}})
113 defer core.GFreeNullable({{.Name}}Ptr)
114 {{end}}
115 {{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
116 {{.Ret.Fmt $NotGObject}}
117}
118{{end}}
119
120{{$outer := .}}
121{{range .Receivers -}}
122var x{{$outer.Name}}{{.Name}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Raw}}
123
124{{.Doc}}
125func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
126 {{.Ret.Preamble $NotGLib}}
127 {{range .Args.Callbacks}}
128 var {{.Name}}Ref uintptr
129 if {{.Name}} != nil {
130 {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
131 if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
132 {{.Name}}Ref = cbRefPtr
133 } else {
134 fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
135 cbFn := *{{.Name}}
136 {{if .RetRaw}}return {{end}}cbFn({{range $i, $a := .CallArgs}}{{if $i}}, {{end}}{{$a}}{{end}})
137 }
138 {{.Name}}Ref = purego.NewCallback(fcb)
139 {{if $NotGLib}}glib.{{end}}SaveCallbackWithClosure({{.Name}}Ptr, {{.Name}}Ref, {{.Name}})
140 }
141 }
142 {{end}}
143 {{range .Args.NullableStrings}}
144 {{.Name}}Ptr := core.GStrdupNullable({{.Name}})
145 defer core.GFreeNullable({{.Name}}Ptr)
146 {{end}}
147 {{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.CallWithRefs}})
148 {{.Ret.Fmt $NotGObject}}
149}
150{{end}}
151
152{{range .CallbackAccessors -}}
153// Override{{.Name}} sets the "{{.CName}}" callback function.
154{{if .Doc}}{{.Doc}}
155{{end}}func (x *{{$outer.Name}}) Override{{.Name}}(cb {{.CallbackType}}) {
156 if cb == nil {
157 x.x{{.Name}} = 0
158 } else {
159 x.x{{.Name}} = purego.NewCallback(func({{conv .Args.Pure.Full}}) {{.Ret.Raw}} {
160 {{if .Ret.Value}}{{if .Ret.Class}}ret := cb({{convcb .Args.Pure.Call}})
161 if ret == nil {
162 return 0
163 }
164 return ret.GoPointer(){{else}}return cb({{convcb .Args.Pure.Call}}){{end}}{{else}}cb({{convcb .Args.Pure.Call}}){{end}}
165 })
166 }
167}
168
169// Get{{.Name}} gets the "{{.CName}}" callback function.
170{{if .Doc}}{{.Doc}}
171{{end}}func (x *{{$outer.Name}}) Get{{.Name}}() {{.CallbackType}} {
172 if x.x{{.Name}} == 0 {
173 return nil
174 }
175 var rawCallback func({{conv .Args.Pure.Full}}) {{.Ret.Raw}}
176 purego.RegisterFunc(&rawCallback, x.x{{.Name}})
177 return func({{conv .Args.API.Full}}) {{.Ret.Value}} {
178 {{if .Ret.Value}}{{if .Ret.Class}}rawRet := rawCallback({{convcbne .Args.API.Call}})
179 if rawRet == 0 {
180 return nil
181 }
182 ret := {{.Ret.Instance}}
183 ret.Ptr = rawRet
184 return ret{{else}}return rawCallback({{convcbne .Args.API.Call}}){{end}}{{else}}rawCallback({{convcbne .Args.API.Call}}){{end}}
185 }
186}
187{{end}}
188
189{{end}}
190
191{{range .Interfaces -}}
192{{.Doc}}
193type {{.Name}} interface {
194 GoPointer() uintptr
195 SetGoPointer(uintptr)
196 {{range .Methods -}}
197 {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}}
198 {{end}}
199}
200
201{{if .TypeGetter}}
202var x{{.Name}}GLibType func() types.GType
203func {{.Name}}GLibType() types.GType {
204 return x{{.Name}}GLibType()
205}
206{{end}}
207
208type {{.Name}}Base struct {
209 Ptr uintptr
210}
211
212func (x *{{.Name}}Base) GoPointer() uintptr {
213 if x == nil {
214 return 0
215 }
216 return x.Ptr
217}
218
219func (x *{{.Name}}Base) SetGoPointer(ptr uintptr) {
220 x.Ptr = ptr
221}
222
223{{$outer := .}}
224{{range .Methods -}}
225{{.Doc}}
226func (x *{{$outer.Name}}Base) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
227 {{.Ret.Preamble $NotGLib}}
228 {{range .Args.NullableStrings}}
229 {{.Name}}Ptr := core.GStrdupNullable({{.Name}})
230 defer core.GFreeNullable({{.Name}}Ptr)
231 {{end}}
232 {{if .Ret.Value}}cret := {{end}}{{.Namespace}}X{{.FullName}}(x.GoPointer() {{convcd .Args.API.Call}})
233 {{.Ret.Fmt $NotGObject}}
234}
235{{end}}
236
237{{range .Properties -}}
238{{if .Writable}}
239// SetProperty{{.Name}} sets the "{{.CName}}" property.
240{{if .Doc}}{{.Doc}}
241{{end}}func (x *{{$outer.Name}}Base) SetProperty{{.Name}}(value {{.GoType}}) {
242 obj := {{if $NotGObject}}gobject.{{end}}Object{}
243 obj.Ptr = x.GoPointer()
244 var v {{if $NotGObject}}gobject.{{end}}Value
245 {{if or (eq .GValueType "BoxedStrv") (eq .GValueType "BoxedByteArray") (eq .GValueType "BoxedPtrArray")}}v.Init({{propvset $NotGLib .GoType}}{{else}}v.Init({{propsset $NotGObject .GValueType .SetMethod}}){{end}}
246 obj.SetProperty("{{.CName}}", &v)
247}
248{{end}}
249
250{{if .Readable}}
251// GetProperty{{.Name}} gets the "{{.CName}}" property.
252{{if .Doc}}{{.Doc}}
253{{end}}func (x *{{$outer.Name}}Base) GetProperty{{.Name}}() {{.GoType}} {
254 obj := {{if $NotGObject}}gobject.{{end}}Object{}
255 obj.Ptr = x.GoPointer()
256 var v {{if $NotGObject}}gobject.{{end}}Value
257 obj.GetProperty("{{.CName}}", &v)
258 {{if or (eq .GValueType "BoxedStrv") (eq .GValueType "BoxedByteArray") (eq .GValueType "BoxedPtrArray")}}{{propvget .GoType}}{{else}}return {{propsget .GetMethod}}{{end}}
259}
260{{end}}
261{{end}}
262
263{{range .Methods -}}
264var {{.Namespace}}X{{.FullName}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Raw}}
265{{end}}
266{{end}}
267
268{{range .Aliases -}}
269{{.Doc}}
270type {{.Name}} = {{.Value}}
271{{if .TypeGetter}}
272var x{{.Name}}GLibType func() types.GType
273func {{.Name}}GLibType() types.GType {
274 return x{{.Name}}GLibType()
275}
276{{end}}
277{{end}}
278
279{{if .Constants -}}
280const (
281{{range .Constants -}}
282 {{.Doc}}
283 {{.Name}} {{.Type}} = {{.Value}}
284{{end}}
285)
286{{end}}
287
288{{range .Enums -}}
289{{.Doc}}
290type {{.Name}} int
291{{if .TypeGetter}}
292var x{{.Name}}GLibType func() types.GType
293func {{.Name}}GLibType() types.GType {
294 return x{{.Name}}GLibType()
295}
296{{end}}
297const (
298{{$outer := .}}
299{{range .Values -}}
300 {{.Doc}}
301 {{.Name}} {{$outer.Name}} = {{.Value}}
302{{end}}
303)
304{{end}}
305
306{{- define "glib_source_mapping_post_hook" -}}
307{{- if eq .Name "SourceRemove"}}
308if cret {
309 RemoveCallbackBySource(TagVar)
310 removeSourceTrampolineBySourceID(TagVar)
311}
312{{- end}}
313{{- end}}
314
315{{- /* glib_source_trampoline_body emits the entire function body for IdleAdd/TimeoutAdd
316 family functions. These use a shared purego trampoline callback instead of allocating
317 a new purego callback slot per call. */ -}}
318{{- /* glib_source_trampoline_body emits the entire function body for IdleAdd/TimeoutAdd
319 family functions. These use a shared purego trampoline callback instead of allocating
320 a new purego callback slot per call. */ -}}
321{{- define "glib_source_trampoline_body" -}}
322{{- if or (eq .Name "IdleAdd") (eq .Name "TimeoutAdd") (eq .Name "TimeoutAddSeconds") -}}
323 trampolineCb, userData := registerSourceFunc(FunctionVar, false)
324 cret := x{{.Name}}({{- if or (eq .Name "TimeoutAdd") (eq .Name "TimeoutAddSeconds") -}}IntervalVar, {{end}}trampolineCb, userData)
325 saveSourceTrampolineMapping(cret, userData)
326 return cret
327{{- else if or (eq .Name "IdleAddOnce") (eq .Name "TimeoutAddOnce") (eq .Name "TimeoutAddSecondsOnce") -}}
328 trampolineCb, userData := registerSourceOnceFunc(FunctionVar)
329 cret := x{{.Name}}({{- if or (eq .Name "TimeoutAddOnce") (eq .Name "TimeoutAddSecondsOnce") -}}IntervalVar, {{end}}trampolineCb, userData)
330 saveSourceTrampolineMapping(cret, userData)
331 return cret
332{{- else if or (eq .Name "IdleAddFull") (eq .Name "TimeoutAddFull") (eq .Name "TimeoutAddSecondsFull") -}}
333 trampolineCb, userData := registerSourceFunc(FunctionVar, false)
334 {{range .Args.Callbacks -}}
335 {{- if eq .Name "NotifyVar" -}}
336 var {{.Name}}Ref uintptr
337 if {{.Name}} != nil {
338 {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
339 if cbRefPtr, ok := GetCallback({{.Name}}Ptr); ok {
340 {{.Name}}Ref = cbRefPtr
341 } else {
342 fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
343 cbFn := *{{.Name}}
344 {{if .RetRaw}}return {{end}}cbFn({{range $i, $a := .CallArgs}}{{if $i}}, {{end}}{{$a}}{{end}})
345 }
346 {{.Name}}Ref = purego.NewCallback(fcb)
347 SaveCallbackWithClosure({{.Name}}Ptr, {{.Name}}Ref, {{.Name}})
348 }
349 }
350 {{- end}}
351 {{- end}}
352 cret := x{{.Name}}(PriorityVar, {{- if or (eq .Name "TimeoutAddFull") (eq .Name "TimeoutAddSecondsFull") -}}IntervalVar, {{end}}trampolineCb, userData, NotifyVarRef)
353 saveSourceTrampolineMapping(cret, userData)
354 return cret
355{{- end}}
356{{- end}}
357
358{{range .Functions -}}
359var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
360
361{{.Doc}}
362func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
363 {{- if and (not $NotGLib) (or (eq .Name "IdleAdd") (eq .Name "IdleAddFull") (eq .Name "IdleAddOnce") (eq .Name "TimeoutAdd") (eq .Name "TimeoutAddFull") (eq .Name "TimeoutAddOnce") (eq .Name "TimeoutAddSeconds") (eq .Name "TimeoutAddSecondsFull") (eq .Name "TimeoutAddSecondsOnce"))}}
364 {{template "glib_source_trampoline_body" .}}
365 {{- else}}
366 {{.Ret.Preamble $NotGLib}}
367 {{range .Args.Callbacks}}
368 var {{.Name}}Ref uintptr
369 if {{.Name}} != nil {
370 {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
371 if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
372 {{.Name}}Ref = cbRefPtr
373 } else {
374 fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
375 cbFn := *{{.Name}}
376 {{if .RetRaw}}return {{end}}cbFn({{range $i, $a := .CallArgs}}{{if $i}}, {{end}}{{$a}}{{end}})
377 }
378 {{.Name}}Ref = purego.NewCallback(fcb)
379 {{if $NotGLib}}glib.{{end}}SaveCallbackWithClosure({{.Name}}Ptr, {{.Name}}Ref, {{.Name}})
380 }
381 }
382 {{end}}
383 {{range .Args.NullableStrings}}
384 {{.Name}}Ptr := core.GStrdupNullable({{.Name}})
385 defer core.GFreeNullable({{.Name}}Ptr)
386 {{end}}
387 {{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
388 {{- if eq $.PkgName "glib"}}
389 {{template "glib_source_mapping_post_hook" .}}
390 {{- end}}
391 {{.Ret.Fmt $NotGObject}}
392 {{- end}}
393}
394{{end}}
395
396{{range .Classes -}}
397{{.Doc}}
398type {{.Name}} struct {
399 {{.Parent}}
400 {{if not .Parent}}
401 Ptr uintptr
402 {{end}}
403}
404
405{{if .TypeGetter -}}
406var x{{.Name}}GLibType func() types.GType
407func {{.Name}}GLibType() types.GType {
408 return x{{.Name}}GLibType()
409}
410{{end}}
411
412{{$outer := .}}
413func {{.Name}}NewFromInternalPtr(ptr uintptr) *{{.Name}} {
414 cls := &{{.Name}}{}
415 cls.Ptr = ptr
416 return cls
417}
418
419{{range .Constructors -}}
420var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
421
422
423{{.Doc}}
424func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
425 {{.Ret.Preamble $NotGLib}}
426 {{range .Args.Callbacks}}
427 var {{.Name}}Ref uintptr
428 if {{.Name}} != nil {
429 {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
430 if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
431 {{.Name}}Ref = cbRefPtr
432 } else {
433 fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
434 cbFn := *{{.Name}}
435 {{if .RetRaw}}return {{end}}cbFn({{range $i, $a := .CallArgs}}{{if $i}}, {{end}}{{$a}}{{end}})
436 }
437 {{.Name}}Ref = purego.NewCallback(fcb)
438 {{if $NotGLib}}glib.{{end}}SaveCallbackWithClosure({{.Name}}Ptr, {{.Name}}Ref, {{.Name}})
439 }
440 }
441 {{end}}
442 {{range .Args.NullableStrings}}
443 {{.Name}}Ptr := core.GStrdupNullable({{.Name}})
444 defer core.GFreeNullable({{.Name}}Ptr)
445 {{end}}
446 {{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
447 {{.Ret.Fmt $NotGObject}}
448}
449{{end}}
450
451{{$outer := .}}
452{{range .Receivers -}}
453var x{{$outer.Name}}{{.Name}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Raw}}
454
455{{.Doc}}
456func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
457 {{.Ret.Preamble $NotGLib}}
458 {{range .Args.Callbacks}}
459 var {{.Name}}Ref uintptr
460 if {{.Name}} != nil {
461 {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
462 if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
463 {{.Name}}Ref = cbRefPtr
464 } else {
465 fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
466 cbFn := *{{.Name}}
467 {{if .RetRaw}}return {{end}}cbFn({{range $i, $a := .CallArgs}}{{if $i}}, {{end}}{{$a}}{{end}})
468 }
469 {{.Name}}Ref = purego.NewCallback(fcb)
470 {{if $NotGLib}}glib.{{end}}SaveCallbackWithClosure({{.Name}}Ptr, {{.Name}}Ref, {{.Name}})
471 }
472 }
473 {{end}}
474 {{range .Args.NullableStrings}}
475 {{.Name}}Ptr := core.GStrdupNullable({{.Name}})
476 defer core.GFreeNullable({{.Name}}Ptr)
477 {{end}}
478 {{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.CallWithRefs}})
479 {{.Ret.Fmt $NotGObject}}
480}
481{{end}}
482
483func (c *{{.Name}}) GoPointer() uintptr {
484 if c == nil {
485 return 0
486 }
487 return c.Ptr
488}
489
490func (c *{{.Name}}) SetGoPointer(ptr uintptr) {
491 c.Ptr = ptr
492}
493
494{{range .Properties -}}
495{{if .Writable}}
496// SetProperty{{.Name}} sets the "{{.CName}}" property.
497{{if .Doc}}{{.Doc}}
498{{end}}func (x *{{$outer.Name}}) SetProperty{{.Name}}(value {{.GoType}}) {
499 var v {{if $NotGObject}}gobject.{{end}}Value
500 {{if or (eq .GValueType "BoxedStrv") (eq .GValueType "BoxedByteArray") (eq .GValueType "BoxedPtrArray")}}v.Init({{propvset $NotGLib .GoType}}{{else}}v.Init({{propsset $NotGObject .GValueType .SetMethod}}){{end}}
501 x.SetProperty("{{.CName}}", &v)
502}
503{{end}}
504
505{{if .Readable}}
506// GetProperty{{.Name}} gets the "{{.CName}}" property.
507{{if .Doc}}{{.Doc}}
508{{end}}func (x *{{$outer.Name}}) GetProperty{{.Name}}() {{.GoType}} {
509 var v {{if $NotGObject}}gobject.{{end}}Value
510 x.GetProperty("{{.CName}}", &v)
511 {{if or (eq .GValueType "BoxedStrv") (eq .GValueType "BoxedByteArray") (eq .GValueType "BoxedPtrArray")}}{{propvget .GoType}}{{else}}return {{propsget .GetMethod}}{{end}}
512}
513{{end}}
514{{end}}
515
516{{range .Signals -}}
517
518{{.Doc}}
519func (x *{{$outer.Name}}) Connect{{.Name}}(cb *func({{$outer.Name}} {{convc .Args.API.Types}}) {{.Ret.Value}}) uint {
520 cbPtr := uintptr(unsafe.Pointer(cb))
521 if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback(cbPtr); ok {
522 handlerID := {{if $NotGObject}}gobject.{{end}}SignalConnect(x.GoPointer(), "{{.CName}}", cbRefPtr)
523 {{if $NotGLib}}glib.{{end}}SaveHandlerMapping(handlerID, cbPtr)
524 return handlerID
525 }
526
527 fcb := func(clsPtr uintptr {{convc .Args.PuregoSignalFull}}) {{.Ret.Raw}} {
528 fa := {{$outer.Name}}{}
529 fa.Ptr = clsPtr
530 cbFn := *cb
531 {{if .Ret.Class}}
532 {{.Name}}Cls := cbFn(fa {{convc .Args.PuregoSignalCall}})
533 return {{.Name}}Cls.Ptr
534 {{else if .Ret.Value}}
535 return cbFn(fa {{convc .Args.PuregoSignalCall}})
536 {{else}}
537 cbFn(fa {{convc .Args.PuregoSignalCall}})
538 {{end}}
539 }
540 cbRefPtr := purego.NewCallback(fcb)
541 {{if $NotGLib}}glib.{{end}}SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
542 handlerID := {{if $NotGObject}}gobject.{{end}}SignalConnect(x.GoPointer(), "{{.CName}}", cbRefPtr)
543 {{if $NotGLib}}glib.{{end}}SaveHandlerMapping(handlerID, cbPtr)
544 return handlerID
545}
546{{if .Detailed}}
547// Connect{{.Name}}WithDetail connects to the "{{.CName}}" signal with a detail string.
548// The detail is appended as "{{.CName}}::<detail>".
549func (x *{{$outer.Name}}) Connect{{.Name}}WithDetail(detail string, cb *func({{$outer.Name}} {{convc .Args.API.Types}}) {{.Ret.Value}}) uint {
550 cbPtr := uintptr(unsafe.Pointer(cb))
551 signalName := fmt.Sprintf("{{.CName}}::%s", detail)
552 if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback(cbPtr); ok {
553 handlerID := {{if $NotGObject}}gobject.{{end}}SignalConnect(x.GoPointer(), signalName, cbRefPtr)
554 {{if $NotGLib}}glib.{{end}}SaveHandlerMapping(handlerID, cbPtr)
555 return handlerID
556 }
557
558 fcb := func(clsPtr uintptr {{convc .Args.PuregoSignalFull}}) {{.Ret.Raw}} {
559 fa := {{$outer.Name}}{}
560 fa.Ptr = clsPtr
561 cbFn := *cb
562 {{if .Ret.Class}}
563 {{.Name}}Cls := cbFn(fa {{convc .Args.PuregoSignalCall}})
564 return {{.Name}}Cls.Ptr
565 {{else if .Ret.Value}}
566 return cbFn(fa {{convc .Args.PuregoSignalCall}})
567 {{else}}
568 cbFn(fa {{convc .Args.PuregoSignalCall}})
569 {{end}}
570 }
571 cbRefPtr := purego.NewCallback(fcb)
572 {{if $NotGLib}}glib.{{end}}SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
573 handlerID := {{if $NotGObject}}gobject.{{end}}SignalConnect(x.GoPointer(), signalName, cbRefPtr)
574 {{if $NotGLib}}glib.{{end}}SaveHandlerMapping(handlerID, cbPtr)
575 return handlerID
576}
577{{end}}
578{{end}}
579
580{{range .Interfaces -}}
581{{range .Methods -}}
582{{.Doc}}
583func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
584 {{.Ret.Preamble $NotGLib}}
585 {{range .Args.NullableStrings}}
586 {{.Name}}Ptr := core.GStrdupNullable({{.Name}})
587 defer core.GFreeNullable({{.Name}}Ptr)
588 {{end}}
589 {{if .Ret.Value}}cret := {{end}} {{.Namespace}}X{{.FullName}}(x.GoPointer() {{convcd .Args.API.Call}})
590 {{.Ret.Fmt $NotGObject}}
591}
592{{end}}
593{{end}}
594
595{{range .Functions -}}
596var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
597
598{{.Doc}}
599func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
600 {{.Ret.Preamble $NotGLib}}
601 {{range .Args.Callbacks}}
602 var {{.Name}}Ref uintptr
603 if {{.Name}} != nil {
604 {{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
605 if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
606 {{.Name}}Ref = cbRefPtr
607 } else {
608 fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
609 cbFn := *{{.Name}}
610 {{if .RetRaw}}return {{end}}cbFn({{range $i, $a := .CallArgs}}{{if $i}}, {{end}}{{$a}}{{end}})
611 }
612 {{.Name}}Ref = purego.NewCallback(fcb)
613 {{if $NotGLib}}glib.{{end}}SaveCallbackWithClosure({{.Name}}Ptr, {{.Name}}Ref, {{.Name}})
614 }
615 }
616 {{end}}
617 {{range .Args.NullableStrings}}
618 {{.Name}}Ptr := core.GStrdupNullable({{.Name}})
619 defer core.GFreeNullable({{.Name}}Ptr)
620 {{end}}
621 {{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
622 {{- if eq $.PkgName "glib"}}
623 {{template "glib_source_mapping_post_hook" .}}
624 {{- end}}
625 {{.Ret.Fmt $NotGObject}}
626}
627{{end}}
628
629{{end}}
630
631
632{{if .NeedsInit}}
633
634func init() {
635 {{if .PkgConfigName -}}
636 core.SetPackageName("{{.PkgEnv}}", "{{.PkgConfigName}}")
637 {{end -}}
638 {{if .SharedLibraries -}}
639 core.SetSharedLibraries("{{.PkgEnv}}", []string{ {{range .SharedLibraries}}"{{.}}", {{end}} })
640 {{end -}}
641
642 var libs []uintptr
643 for _, libPath := range core.GetPaths("{{.PkgEnv}}") {
644 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
645 if err != nil {
646 panic(err)
647 }
648 libs = append(libs, lib)
649 }
650
651 {{range .Aliases -}}
652 {{if .TypeGetter -}}
653 core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
654 {{end}}
655 {{end}}
656 {{range .Enums -}}
657 {{if .TypeGetter -}}
658 core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
659 {{end}}
660 {{end}}
661 {{range .Functions -}}
662 core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
663 {{end}}
664
665 {{range .Records -}}
666 {{$rec := .}}
667 {{if .TypeGetter -}}
668 core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
669 {{end}}
670 {{range .Constructors -}}
671 core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
672 {{end}}
673 {{range .Receivers -}}
674 core.PuregoSafeRegister(&x{{$rec.Name}}{{.Name}}, libs, "{{.CName}}")
675 {{end}}
676 {{end}}
677
678 {{range .Classes -}}
679 {{$cls := .}}
680 {{if .TypeGetter -}}
681 core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
682 {{end}}
683 {{range .Constructors -}}
684 core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
685 {{end}}
686 {{range .Receivers -}}
687 core.PuregoSafeRegister(&x{{$cls.Name}}{{.Name}}, libs, "{{.CName}}")
688 {{end}}
689 {{range .Functions -}}
690 core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
691 {{end}}
692 {{end}}
693
694 {{range .Interfaces -}}
695 {{if .TypeGetter -}}
696 core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
697 {{end}}
698 {{range .Methods -}}
699 core.PuregoSafeRegister(&{{.Namespace}}X{{.FullName}}, libs, "{{.CName}}")
700 {{end}}
701 {{end}}
702}
703{{end}}