1// Package gobject was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gobject
3
4import (
5 "github.com/ebitengine/purego"
6
7 "github.com/bnema/puregotk/pkg/core"
8 "github.com/bnema/puregotk/v4/glib"
9 "github.com/bnema/puregotk/v4/gobject/types"
10)
11
12var xNewParamSpecBoolean func(string, uintptr, uintptr, bool, ParamFlags) uintptr
13
14// Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
15// property. In many cases, it may be more appropriate to use an enum with
16// g_param_spec_enum(), both to improve code clarity by using explicitly named
17// values, and to allow for more values to be added in future without breaking
18// API.
19//
20// See g_param_spec_internal() for details on property names.
21func NewParamSpecBoolean(NameVar string, NickVar *string, BlurbVar *string, DefaultValueVar bool, FlagsVar ParamFlags) *ParamSpec {
22 var cls *ParamSpec
23
24 NickVarPtr := core.GStrdupNullable(NickVar)
25 defer core.GFreeNullable(NickVarPtr)
26
27 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
28 defer core.GFreeNullable(BlurbVarPtr)
29
30 cret := xNewParamSpecBoolean(NameVar, NickVarPtr, BlurbVarPtr, DefaultValueVar, FlagsVar)
31
32 if cret == 0 {
33 return nil
34 }
35 cls = &ParamSpec{}
36 cls.Ptr = cret
37 return cls
38}
39
40var xNewParamSpecBoxed func(string, uintptr, uintptr, types.GType, ParamFlags) uintptr
41
42// Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
43// derived property.
44//
45// See g_param_spec_internal() for details on property names.
46func NewParamSpecBoxed(NameVar string, NickVar *string, BlurbVar *string, BoxedTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {
47 var cls *ParamSpec
48
49 NickVarPtr := core.GStrdupNullable(NickVar)
50 defer core.GFreeNullable(NickVarPtr)
51
52 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
53 defer core.GFreeNullable(BlurbVarPtr)
54
55 cret := xNewParamSpecBoxed(NameVar, NickVarPtr, BlurbVarPtr, BoxedTypeVar, FlagsVar)
56
57 if cret == 0 {
58 return nil
59 }
60 cls = &ParamSpec{}
61 cls.Ptr = cret
62 return cls
63}
64
65var xNewParamSpecChar func(string, uintptr, uintptr, int8, int8, int8, ParamFlags) uintptr
66
67// Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.
68func NewParamSpecChar(NameVar string, NickVar *string, BlurbVar *string, MinimumVar int8, MaximumVar int8, DefaultValueVar int8, FlagsVar ParamFlags) *ParamSpec {
69 var cls *ParamSpec
70
71 NickVarPtr := core.GStrdupNullable(NickVar)
72 defer core.GFreeNullable(NickVarPtr)
73
74 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
75 defer core.GFreeNullable(BlurbVarPtr)
76
77 cret := xNewParamSpecChar(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
78
79 if cret == 0 {
80 return nil
81 }
82 cls = &ParamSpec{}
83 cls.Ptr = cret
84 return cls
85}
86
87var xNewParamSpecDouble func(string, uintptr, uintptr, float64, float64, float64, ParamFlags) uintptr
88
89// Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
90// property.
91//
92// See g_param_spec_internal() for details on property names.
93func NewParamSpecDouble(NameVar string, NickVar *string, BlurbVar *string, MinimumVar float64, MaximumVar float64, DefaultValueVar float64, FlagsVar ParamFlags) *ParamSpec {
94 var cls *ParamSpec
95
96 NickVarPtr := core.GStrdupNullable(NickVar)
97 defer core.GFreeNullable(NickVarPtr)
98
99 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
100 defer core.GFreeNullable(BlurbVarPtr)
101
102 cret := xNewParamSpecDouble(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
103
104 if cret == 0 {
105 return nil
106 }
107 cls = &ParamSpec{}
108 cls.Ptr = cret
109 return cls
110}
111
112var xNewParamSpecEnum func(string, uintptr, uintptr, types.GType, int, ParamFlags) uintptr
113
114// Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
115// property.
116//
117// See g_param_spec_internal() for details on property names.
118func NewParamSpecEnum(NameVar string, NickVar *string, BlurbVar *string, EnumTypeVar types.GType, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec {
119 var cls *ParamSpec
120
121 NickVarPtr := core.GStrdupNullable(NickVar)
122 defer core.GFreeNullable(NickVarPtr)
123
124 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
125 defer core.GFreeNullable(BlurbVarPtr)
126
127 cret := xNewParamSpecEnum(NameVar, NickVarPtr, BlurbVarPtr, EnumTypeVar, DefaultValueVar, FlagsVar)
128
129 if cret == 0 {
130 return nil
131 }
132 cls = &ParamSpec{}
133 cls.Ptr = cret
134 return cls
135}
136
137var xNewParamSpecFlags func(string, uintptr, uintptr, types.GType, uint, ParamFlags) uintptr
138
139// Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
140// property.
141//
142// See g_param_spec_internal() for details on property names.
143func NewParamSpecFlags(NameVar string, NickVar *string, BlurbVar *string, FlagsTypeVar types.GType, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec {
144 var cls *ParamSpec
145
146 NickVarPtr := core.GStrdupNullable(NickVar)
147 defer core.GFreeNullable(NickVarPtr)
148
149 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
150 defer core.GFreeNullable(BlurbVarPtr)
151
152 cret := xNewParamSpecFlags(NameVar, NickVarPtr, BlurbVarPtr, FlagsTypeVar, DefaultValueVar, FlagsVar)
153
154 if cret == 0 {
155 return nil
156 }
157 cls = &ParamSpec{}
158 cls.Ptr = cret
159 return cls
160}
161
162var xNewParamSpecFloat func(string, uintptr, uintptr, float32, float32, float32, ParamFlags) uintptr
163
164// Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.
165//
166// See g_param_spec_internal() for details on property names.
167func NewParamSpecFloat(NameVar string, NickVar *string, BlurbVar *string, MinimumVar float32, MaximumVar float32, DefaultValueVar float32, FlagsVar ParamFlags) *ParamSpec {
168 var cls *ParamSpec
169
170 NickVarPtr := core.GStrdupNullable(NickVar)
171 defer core.GFreeNullable(NickVarPtr)
172
173 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
174 defer core.GFreeNullable(BlurbVarPtr)
175
176 cret := xNewParamSpecFloat(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
177
178 if cret == 0 {
179 return nil
180 }
181 cls = &ParamSpec{}
182 cls.Ptr = cret
183 return cls
184}
185
186var xParamSpecGtype func(string, uintptr, uintptr, types.GType, ParamFlags) uintptr
187
188// Creates a new #GParamSpecGType instance specifying a
189// %G_TYPE_GTYPE property.
190//
191// See g_param_spec_internal() for details on property names.
192func ParamSpecGtype(NameVar string, NickVar *string, BlurbVar *string, IsATypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {
193 var cls *ParamSpec
194
195 NickVarPtr := core.GStrdupNullable(NickVar)
196 defer core.GFreeNullable(NickVarPtr)
197
198 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
199 defer core.GFreeNullable(BlurbVarPtr)
200
201 cret := xParamSpecGtype(NameVar, NickVarPtr, BlurbVarPtr, IsATypeVar, FlagsVar)
202
203 if cret == 0 {
204 return nil
205 }
206 cls = &ParamSpec{}
207 cls.Ptr = cret
208 return cls
209}
210
211var xNewParamSpecInt func(string, uintptr, uintptr, int, int, int, ParamFlags) uintptr
212
213// Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.
214//
215// See g_param_spec_internal() for details on property names.
216func NewParamSpecInt(NameVar string, NickVar *string, BlurbVar *string, MinimumVar int, MaximumVar int, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec {
217 var cls *ParamSpec
218
219 NickVarPtr := core.GStrdupNullable(NickVar)
220 defer core.GFreeNullable(NickVarPtr)
221
222 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
223 defer core.GFreeNullable(BlurbVarPtr)
224
225 cret := xNewParamSpecInt(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
226
227 if cret == 0 {
228 return nil
229 }
230 cls = &ParamSpec{}
231 cls.Ptr = cret
232 return cls
233}
234
235var xNewParamSpecInt64 func(string, uintptr, uintptr, int64, int64, int64, ParamFlags) uintptr
236
237// Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
238//
239// See g_param_spec_internal() for details on property names.
240func NewParamSpecInt64(NameVar string, NickVar *string, BlurbVar *string, MinimumVar int64, MaximumVar int64, DefaultValueVar int64, FlagsVar ParamFlags) *ParamSpec {
241 var cls *ParamSpec
242
243 NickVarPtr := core.GStrdupNullable(NickVar)
244 defer core.GFreeNullable(NickVarPtr)
245
246 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
247 defer core.GFreeNullable(BlurbVarPtr)
248
249 cret := xNewParamSpecInt64(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
250
251 if cret == 0 {
252 return nil
253 }
254 cls = &ParamSpec{}
255 cls.Ptr = cret
256 return cls
257}
258
259var xNewParamSpecLong func(string, uintptr, uintptr, int, int, int, ParamFlags) uintptr
260
261// Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
262//
263// See g_param_spec_internal() for details on property names.
264func NewParamSpecLong(NameVar string, NickVar *string, BlurbVar *string, MinimumVar int, MaximumVar int, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec {
265 var cls *ParamSpec
266
267 NickVarPtr := core.GStrdupNullable(NickVar)
268 defer core.GFreeNullable(NickVarPtr)
269
270 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
271 defer core.GFreeNullable(BlurbVarPtr)
272
273 cret := xNewParamSpecLong(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
274
275 if cret == 0 {
276 return nil
277 }
278 cls = &ParamSpec{}
279 cls.Ptr = cret
280 return cls
281}
282
283var xNewParamSpecObject func(string, uintptr, uintptr, types.GType, ParamFlags) uintptr
284
285// Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
286// derived property.
287//
288// See g_param_spec_internal() for details on property names.
289func NewParamSpecObject(NameVar string, NickVar *string, BlurbVar *string, ObjectTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {
290 var cls *ParamSpec
291
292 NickVarPtr := core.GStrdupNullable(NickVar)
293 defer core.GFreeNullable(NickVarPtr)
294
295 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
296 defer core.GFreeNullable(BlurbVarPtr)
297
298 cret := xNewParamSpecObject(NameVar, NickVarPtr, BlurbVarPtr, ObjectTypeVar, FlagsVar)
299
300 if cret == 0 {
301 return nil
302 }
303 cls = &ParamSpec{}
304 cls.Ptr = cret
305 return cls
306}
307
308var xNewParamSpecOverride func(string, uintptr) uintptr
309
310// Creates a new property of type #GParamSpecOverride. This is used
311// to direct operations to another paramspec, and will not be directly
312// useful unless you are implementing a new base type similar to GObject.
313func NewParamSpecOverride(NameVar string, OverriddenVar *ParamSpec) *ParamSpec {
314 var cls *ParamSpec
315
316 cret := xNewParamSpecOverride(NameVar, OverriddenVar.GoPointer())
317
318 if cret == 0 {
319 return nil
320 }
321 cls = &ParamSpec{}
322 cls.Ptr = cret
323 return cls
324}
325
326var xNewParamSpecParam func(string, uintptr, uintptr, types.GType, ParamFlags) uintptr
327
328// Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
329// property.
330//
331// See g_param_spec_internal() for details on property names.
332func NewParamSpecParam(NameVar string, NickVar *string, BlurbVar *string, ParamTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {
333 var cls *ParamSpec
334
335 NickVarPtr := core.GStrdupNullable(NickVar)
336 defer core.GFreeNullable(NickVarPtr)
337
338 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
339 defer core.GFreeNullable(BlurbVarPtr)
340
341 cret := xNewParamSpecParam(NameVar, NickVarPtr, BlurbVarPtr, ParamTypeVar, FlagsVar)
342
343 if cret == 0 {
344 return nil
345 }
346 cls = &ParamSpec{}
347 cls.Ptr = cret
348 return cls
349}
350
351var xNewParamSpecPointer func(string, uintptr, uintptr, ParamFlags) uintptr
352
353// Creates a new #GParamSpecPointer instance specifying a pointer property.
354// Where possible, it is better to use g_param_spec_object() or
355// g_param_spec_boxed() to expose memory management information.
356//
357// See g_param_spec_internal() for details on property names.
358func NewParamSpecPointer(NameVar string, NickVar *string, BlurbVar *string, FlagsVar ParamFlags) *ParamSpec {
359 var cls *ParamSpec
360
361 NickVarPtr := core.GStrdupNullable(NickVar)
362 defer core.GFreeNullable(NickVarPtr)
363
364 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
365 defer core.GFreeNullable(BlurbVarPtr)
366
367 cret := xNewParamSpecPointer(NameVar, NickVarPtr, BlurbVarPtr, FlagsVar)
368
369 if cret == 0 {
370 return nil
371 }
372 cls = &ParamSpec{}
373 cls.Ptr = cret
374 return cls
375}
376
377var xNewParamSpecString func(string, uintptr, uintptr, uintptr, ParamFlags) uintptr
378
379// Creates a new #GParamSpecString instance.
380//
381// See g_param_spec_internal() for details on property names.
382func NewParamSpecString(NameVar string, NickVar *string, BlurbVar *string, DefaultValueVar *string, FlagsVar ParamFlags) *ParamSpec {
383 var cls *ParamSpec
384
385 NickVarPtr := core.GStrdupNullable(NickVar)
386 defer core.GFreeNullable(NickVarPtr)
387
388 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
389 defer core.GFreeNullable(BlurbVarPtr)
390
391 DefaultValueVarPtr := core.GStrdupNullable(DefaultValueVar)
392 defer core.GFreeNullable(DefaultValueVarPtr)
393
394 cret := xNewParamSpecString(NameVar, NickVarPtr, BlurbVarPtr, DefaultValueVarPtr, FlagsVar)
395
396 if cret == 0 {
397 return nil
398 }
399 cls = &ParamSpec{}
400 cls.Ptr = cret
401 return cls
402}
403
404var xParamSpecUchar func(string, uintptr, uintptr, byte, byte, byte, ParamFlags) uintptr
405
406// Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.
407func ParamSpecUchar(NameVar string, NickVar *string, BlurbVar *string, MinimumVar byte, MaximumVar byte, DefaultValueVar byte, FlagsVar ParamFlags) *ParamSpec {
408 var cls *ParamSpec
409
410 NickVarPtr := core.GStrdupNullable(NickVar)
411 defer core.GFreeNullable(NickVarPtr)
412
413 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
414 defer core.GFreeNullable(BlurbVarPtr)
415
416 cret := xParamSpecUchar(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
417
418 if cret == 0 {
419 return nil
420 }
421 cls = &ParamSpec{}
422 cls.Ptr = cret
423 return cls
424}
425
426var xParamSpecUint func(string, uintptr, uintptr, uint, uint, uint, ParamFlags) uintptr
427
428// Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.
429//
430// See g_param_spec_internal() for details on property names.
431func ParamSpecUint(NameVar string, NickVar *string, BlurbVar *string, MinimumVar uint, MaximumVar uint, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec {
432 var cls *ParamSpec
433
434 NickVarPtr := core.GStrdupNullable(NickVar)
435 defer core.GFreeNullable(NickVarPtr)
436
437 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
438 defer core.GFreeNullable(BlurbVarPtr)
439
440 cret := xParamSpecUint(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
441
442 if cret == 0 {
443 return nil
444 }
445 cls = &ParamSpec{}
446 cls.Ptr = cret
447 return cls
448}
449
450var xParamSpecUint64 func(string, uintptr, uintptr, uint64, uint64, uint64, ParamFlags) uintptr
451
452// Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
453// property.
454//
455// See g_param_spec_internal() for details on property names.
456func ParamSpecUint64(NameVar string, NickVar *string, BlurbVar *string, MinimumVar uint64, MaximumVar uint64, DefaultValueVar uint64, FlagsVar ParamFlags) *ParamSpec {
457 var cls *ParamSpec
458
459 NickVarPtr := core.GStrdupNullable(NickVar)
460 defer core.GFreeNullable(NickVarPtr)
461
462 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
463 defer core.GFreeNullable(BlurbVarPtr)
464
465 cret := xParamSpecUint64(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
466
467 if cret == 0 {
468 return nil
469 }
470 cls = &ParamSpec{}
471 cls.Ptr = cret
472 return cls
473}
474
475var xParamSpecUlong func(string, uintptr, uintptr, uint, uint, uint, ParamFlags) uintptr
476
477// Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
478// property.
479//
480// See g_param_spec_internal() for details on property names.
481func ParamSpecUlong(NameVar string, NickVar *string, BlurbVar *string, MinimumVar uint, MaximumVar uint, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec {
482 var cls *ParamSpec
483
484 NickVarPtr := core.GStrdupNullable(NickVar)
485 defer core.GFreeNullable(NickVarPtr)
486
487 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
488 defer core.GFreeNullable(BlurbVarPtr)
489
490 cret := xParamSpecUlong(NameVar, NickVarPtr, BlurbVarPtr, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
491
492 if cret == 0 {
493 return nil
494 }
495 cls = &ParamSpec{}
496 cls.Ptr = cret
497 return cls
498}
499
500var xNewParamSpecUnichar func(string, uintptr, uintptr, uint32, ParamFlags) uintptr
501
502// Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
503// property. #GValue structures for this property can be accessed with
504// g_value_set_uint() and g_value_get_uint().
505//
506// See g_param_spec_internal() for details on property names.
507func NewParamSpecUnichar(NameVar string, NickVar *string, BlurbVar *string, DefaultValueVar uint32, FlagsVar ParamFlags) *ParamSpec {
508 var cls *ParamSpec
509
510 NickVarPtr := core.GStrdupNullable(NickVar)
511 defer core.GFreeNullable(NickVarPtr)
512
513 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
514 defer core.GFreeNullable(BlurbVarPtr)
515
516 cret := xNewParamSpecUnichar(NameVar, NickVarPtr, BlurbVarPtr, DefaultValueVar, FlagsVar)
517
518 if cret == 0 {
519 return nil
520 }
521 cls = &ParamSpec{}
522 cls.Ptr = cret
523 return cls
524}
525
526var xNewParamSpecValueArray func(string, uintptr, uintptr, uintptr, ParamFlags) uintptr
527
528// Creates a new #GParamSpecValueArray instance specifying a
529// %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a
530// %G_TYPE_BOXED type, as such, #GValue structures for this property
531// can be accessed with g_value_set_boxed() and g_value_get_boxed().
532//
533// See g_param_spec_internal() for details on property names.
534func NewParamSpecValueArray(NameVar string, NickVar *string, BlurbVar *string, ElementSpecVar *ParamSpec, FlagsVar ParamFlags) *ParamSpec {
535 var cls *ParamSpec
536
537 NickVarPtr := core.GStrdupNullable(NickVar)
538 defer core.GFreeNullable(NickVarPtr)
539
540 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
541 defer core.GFreeNullable(BlurbVarPtr)
542
543 cret := xNewParamSpecValueArray(NameVar, NickVarPtr, BlurbVarPtr, ElementSpecVar.GoPointer(), FlagsVar)
544
545 if cret == 0 {
546 return nil
547 }
548 cls = &ParamSpec{}
549 cls.Ptr = cret
550 return cls
551}
552
553var xNewParamSpecVariant func(string, uintptr, uintptr, *glib.VariantType, *glib.Variant, ParamFlags) uintptr
554
555// Creates a new #GParamSpecVariant instance specifying a #GVariant
556// property.
557//
558// If @default_value is floating, it is consumed.
559//
560// See g_param_spec_internal() for details on property names.
561func NewParamSpecVariant(NameVar string, NickVar *string, BlurbVar *string, TypeVar *glib.VariantType, DefaultValueVar *glib.Variant, FlagsVar ParamFlags) *ParamSpec {
562 var cls *ParamSpec
563
564 NickVarPtr := core.GStrdupNullable(NickVar)
565 defer core.GFreeNullable(NickVarPtr)
566
567 BlurbVarPtr := core.GStrdupNullable(BlurbVar)
568 defer core.GFreeNullable(BlurbVarPtr)
569
570 cret := xNewParamSpecVariant(NameVar, NickVarPtr, BlurbVarPtr, TypeVar, DefaultValueVar, FlagsVar)
571
572 if cret == 0 {
573 return nil
574 }
575 cls = &ParamSpec{}
576 cls.Ptr = cret
577 return cls
578}
579
580// A #GParamSpec derived structure that contains the meta data for boolean properties.
581type ParamSpecBoolean struct {
582 ParamSpec
583}
584
585var xParamSpecBooleanGLibType func() types.GType
586
587func ParamSpecBooleanGLibType() types.GType {
588 return xParamSpecBooleanGLibType()
589}
590
591func ParamSpecBooleanNewFromInternalPtr(ptr uintptr) *ParamSpecBoolean {
592 cls := &ParamSpecBoolean{}
593 cls.Ptr = ptr
594 return cls
595}
596
597func (c *ParamSpecBoolean) GoPointer() uintptr {
598 if c == nil {
599 return 0
600 }
601 return c.Ptr
602}
603
604func (c *ParamSpecBoolean) SetGoPointer(ptr uintptr) {
605 c.Ptr = ptr
606}
607
608// A #GParamSpec derived structure that contains the meta data for boxed properties.
609type ParamSpecBoxed struct {
610 ParamSpec
611}
612
613var xParamSpecBoxedGLibType func() types.GType
614
615func ParamSpecBoxedGLibType() types.GType {
616 return xParamSpecBoxedGLibType()
617}
618
619func ParamSpecBoxedNewFromInternalPtr(ptr uintptr) *ParamSpecBoxed {
620 cls := &ParamSpecBoxed{}
621 cls.Ptr = ptr
622 return cls
623}
624
625func (c *ParamSpecBoxed) GoPointer() uintptr {
626 if c == nil {
627 return 0
628 }
629 return c.Ptr
630}
631
632func (c *ParamSpecBoxed) SetGoPointer(ptr uintptr) {
633 c.Ptr = ptr
634}
635
636// A #GParamSpec derived structure that contains the meta data for character properties.
637type ParamSpecChar struct {
638 ParamSpec
639}
640
641var xParamSpecCharGLibType func() types.GType
642
643func ParamSpecCharGLibType() types.GType {
644 return xParamSpecCharGLibType()
645}
646
647func ParamSpecCharNewFromInternalPtr(ptr uintptr) *ParamSpecChar {
648 cls := &ParamSpecChar{}
649 cls.Ptr = ptr
650 return cls
651}
652
653func (c *ParamSpecChar) GoPointer() uintptr {
654 if c == nil {
655 return 0
656 }
657 return c.Ptr
658}
659
660func (c *ParamSpecChar) SetGoPointer(ptr uintptr) {
661 c.Ptr = ptr
662}
663
664// A #GParamSpec derived structure that contains the meta data for double properties.
665type ParamSpecDouble struct {
666 ParamSpec
667}
668
669var xParamSpecDoubleGLibType func() types.GType
670
671func ParamSpecDoubleGLibType() types.GType {
672 return xParamSpecDoubleGLibType()
673}
674
675func ParamSpecDoubleNewFromInternalPtr(ptr uintptr) *ParamSpecDouble {
676 cls := &ParamSpecDouble{}
677 cls.Ptr = ptr
678 return cls
679}
680
681func (c *ParamSpecDouble) GoPointer() uintptr {
682 if c == nil {
683 return 0
684 }
685 return c.Ptr
686}
687
688func (c *ParamSpecDouble) SetGoPointer(ptr uintptr) {
689 c.Ptr = ptr
690}
691
692// A #GParamSpec derived structure that contains the meta data for enum
693// properties.
694type ParamSpecEnum struct {
695 ParamSpec
696}
697
698var xParamSpecEnumGLibType func() types.GType
699
700func ParamSpecEnumGLibType() types.GType {
701 return xParamSpecEnumGLibType()
702}
703
704func ParamSpecEnumNewFromInternalPtr(ptr uintptr) *ParamSpecEnum {
705 cls := &ParamSpecEnum{}
706 cls.Ptr = ptr
707 return cls
708}
709
710func (c *ParamSpecEnum) GoPointer() uintptr {
711 if c == nil {
712 return 0
713 }
714 return c.Ptr
715}
716
717func (c *ParamSpecEnum) SetGoPointer(ptr uintptr) {
718 c.Ptr = ptr
719}
720
721// A #GParamSpec derived structure that contains the meta data for flags
722// properties.
723type ParamSpecFlags struct {
724 ParamSpec
725}
726
727var xParamSpecFlagsGLibType func() types.GType
728
729func ParamSpecFlagsGLibType() types.GType {
730 return xParamSpecFlagsGLibType()
731}
732
733func ParamSpecFlagsNewFromInternalPtr(ptr uintptr) *ParamSpecFlags {
734 cls := &ParamSpecFlags{}
735 cls.Ptr = ptr
736 return cls
737}
738
739func (c *ParamSpecFlags) GoPointer() uintptr {
740 if c == nil {
741 return 0
742 }
743 return c.Ptr
744}
745
746func (c *ParamSpecFlags) SetGoPointer(ptr uintptr) {
747 c.Ptr = ptr
748}
749
750// A #GParamSpec derived structure that contains the meta data for float properties.
751type ParamSpecFloat struct {
752 ParamSpec
753}
754
755var xParamSpecFloatGLibType func() types.GType
756
757func ParamSpecFloatGLibType() types.GType {
758 return xParamSpecFloatGLibType()
759}
760
761func ParamSpecFloatNewFromInternalPtr(ptr uintptr) *ParamSpecFloat {
762 cls := &ParamSpecFloat{}
763 cls.Ptr = ptr
764 return cls
765}
766
767func (c *ParamSpecFloat) GoPointer() uintptr {
768 if c == nil {
769 return 0
770 }
771 return c.Ptr
772}
773
774func (c *ParamSpecFloat) SetGoPointer(ptr uintptr) {
775 c.Ptr = ptr
776}
777
778// A #GParamSpec derived structure that contains the meta data for #GType properties.
779type ParamSpecGType struct {
780 ParamSpec
781}
782
783var xParamSpecGTypeGLibType func() types.GType
784
785func ParamSpecGTypeGLibType() types.GType {
786 return xParamSpecGTypeGLibType()
787}
788
789func ParamSpecGTypeNewFromInternalPtr(ptr uintptr) *ParamSpecGType {
790 cls := &ParamSpecGType{}
791 cls.Ptr = ptr
792 return cls
793}
794
795func (c *ParamSpecGType) GoPointer() uintptr {
796 if c == nil {
797 return 0
798 }
799 return c.Ptr
800}
801
802func (c *ParamSpecGType) SetGoPointer(ptr uintptr) {
803 c.Ptr = ptr
804}
805
806// A #GParamSpec derived structure that contains the meta data for integer properties.
807type ParamSpecInt struct {
808 ParamSpec
809}
810
811var xParamSpecIntGLibType func() types.GType
812
813func ParamSpecIntGLibType() types.GType {
814 return xParamSpecIntGLibType()
815}
816
817func ParamSpecIntNewFromInternalPtr(ptr uintptr) *ParamSpecInt {
818 cls := &ParamSpecInt{}
819 cls.Ptr = ptr
820 return cls
821}
822
823func (c *ParamSpecInt) GoPointer() uintptr {
824 if c == nil {
825 return 0
826 }
827 return c.Ptr
828}
829
830func (c *ParamSpecInt) SetGoPointer(ptr uintptr) {
831 c.Ptr = ptr
832}
833
834// A #GParamSpec derived structure that contains the meta data for 64bit integer properties.
835type ParamSpecInt64 struct {
836 ParamSpec
837}
838
839var xParamSpecInt64GLibType func() types.GType
840
841func ParamSpecInt64GLibType() types.GType {
842 return xParamSpecInt64GLibType()
843}
844
845func ParamSpecInt64NewFromInternalPtr(ptr uintptr) *ParamSpecInt64 {
846 cls := &ParamSpecInt64{}
847 cls.Ptr = ptr
848 return cls
849}
850
851func (c *ParamSpecInt64) GoPointer() uintptr {
852 if c == nil {
853 return 0
854 }
855 return c.Ptr
856}
857
858func (c *ParamSpecInt64) SetGoPointer(ptr uintptr) {
859 c.Ptr = ptr
860}
861
862// A #GParamSpec derived structure that contains the meta data for long integer properties.
863type ParamSpecLong struct {
864 ParamSpec
865}
866
867var xParamSpecLongGLibType func() types.GType
868
869func ParamSpecLongGLibType() types.GType {
870 return xParamSpecLongGLibType()
871}
872
873func ParamSpecLongNewFromInternalPtr(ptr uintptr) *ParamSpecLong {
874 cls := &ParamSpecLong{}
875 cls.Ptr = ptr
876 return cls
877}
878
879func (c *ParamSpecLong) GoPointer() uintptr {
880 if c == nil {
881 return 0
882 }
883 return c.Ptr
884}
885
886func (c *ParamSpecLong) SetGoPointer(ptr uintptr) {
887 c.Ptr = ptr
888}
889
890// A #GParamSpec derived structure that contains the meta data for object properties.
891type ParamSpecObject struct {
892 ParamSpec
893}
894
895var xParamSpecObjectGLibType func() types.GType
896
897func ParamSpecObjectGLibType() types.GType {
898 return xParamSpecObjectGLibType()
899}
900
901func ParamSpecObjectNewFromInternalPtr(ptr uintptr) *ParamSpecObject {
902 cls := &ParamSpecObject{}
903 cls.Ptr = ptr
904 return cls
905}
906
907func (c *ParamSpecObject) GoPointer() uintptr {
908 if c == nil {
909 return 0
910 }
911 return c.Ptr
912}
913
914func (c *ParamSpecObject) SetGoPointer(ptr uintptr) {
915 c.Ptr = ptr
916}
917
918// A #GParamSpec derived structure that redirects operations to
919// other types of #GParamSpec.
920//
921// All operations other than getting or setting the value are redirected,
922// including accessing the nick and blurb, validating a value, and so
923// forth.
924//
925// See g_param_spec_get_redirect_target() for retrieving the overridden
926// property. #GParamSpecOverride is used in implementing
927// g_object_class_override_property(), and will not be directly useful
928// unless you are implementing a new base type similar to GObject.
929type ParamSpecOverride struct {
930 ParamSpec
931}
932
933var xParamSpecOverrideGLibType func() types.GType
934
935func ParamSpecOverrideGLibType() types.GType {
936 return xParamSpecOverrideGLibType()
937}
938
939func ParamSpecOverrideNewFromInternalPtr(ptr uintptr) *ParamSpecOverride {
940 cls := &ParamSpecOverride{}
941 cls.Ptr = ptr
942 return cls
943}
944
945func (c *ParamSpecOverride) GoPointer() uintptr {
946 if c == nil {
947 return 0
948 }
949 return c.Ptr
950}
951
952func (c *ParamSpecOverride) SetGoPointer(ptr uintptr) {
953 c.Ptr = ptr
954}
955
956// A #GParamSpec derived structure that contains the meta data for %G_TYPE_PARAM
957// properties.
958type ParamSpecParam struct {
959 ParamSpec
960}
961
962var xParamSpecParamGLibType func() types.GType
963
964func ParamSpecParamGLibType() types.GType {
965 return xParamSpecParamGLibType()
966}
967
968func ParamSpecParamNewFromInternalPtr(ptr uintptr) *ParamSpecParam {
969 cls := &ParamSpecParam{}
970 cls.Ptr = ptr
971 return cls
972}
973
974func (c *ParamSpecParam) GoPointer() uintptr {
975 if c == nil {
976 return 0
977 }
978 return c.Ptr
979}
980
981func (c *ParamSpecParam) SetGoPointer(ptr uintptr) {
982 c.Ptr = ptr
983}
984
985// A #GParamSpec derived structure that contains the meta data for pointer properties.
986type ParamSpecPointer struct {
987 ParamSpec
988}
989
990var xParamSpecPointerGLibType func() types.GType
991
992func ParamSpecPointerGLibType() types.GType {
993 return xParamSpecPointerGLibType()
994}
995
996func ParamSpecPointerNewFromInternalPtr(ptr uintptr) *ParamSpecPointer {
997 cls := &ParamSpecPointer{}
998 cls.Ptr = ptr
999 return cls
1000}
1001
1002func (c *ParamSpecPointer) GoPointer() uintptr {
1003 if c == nil {
1004 return 0
1005 }
1006 return c.Ptr
1007}
1008
1009func (c *ParamSpecPointer) SetGoPointer(ptr uintptr) {
1010 c.Ptr = ptr
1011}
1012
1013// A #GParamSpec derived structure that contains the meta data for string
1014// properties.
1015type ParamSpecString struct {
1016 ParamSpec
1017}
1018
1019var xParamSpecStringGLibType func() types.GType
1020
1021func ParamSpecStringGLibType() types.GType {
1022 return xParamSpecStringGLibType()
1023}
1024
1025func ParamSpecStringNewFromInternalPtr(ptr uintptr) *ParamSpecString {
1026 cls := &ParamSpecString{}
1027 cls.Ptr = ptr
1028 return cls
1029}
1030
1031func (c *ParamSpecString) GoPointer() uintptr {
1032 if c == nil {
1033 return 0
1034 }
1035 return c.Ptr
1036}
1037
1038func (c *ParamSpecString) SetGoPointer(ptr uintptr) {
1039 c.Ptr = ptr
1040}
1041
1042// A #GParamSpec derived structure that contains the meta data for unsigned character properties.
1043type ParamSpecUChar struct {
1044 ParamSpec
1045}
1046
1047var xParamSpecUCharGLibType func() types.GType
1048
1049func ParamSpecUCharGLibType() types.GType {
1050 return xParamSpecUCharGLibType()
1051}
1052
1053func ParamSpecUCharNewFromInternalPtr(ptr uintptr) *ParamSpecUChar {
1054 cls := &ParamSpecUChar{}
1055 cls.Ptr = ptr
1056 return cls
1057}
1058
1059func (c *ParamSpecUChar) GoPointer() uintptr {
1060 if c == nil {
1061 return 0
1062 }
1063 return c.Ptr
1064}
1065
1066func (c *ParamSpecUChar) SetGoPointer(ptr uintptr) {
1067 c.Ptr = ptr
1068}
1069
1070// A #GParamSpec derived structure that contains the meta data for unsigned integer properties.
1071type ParamSpecUInt struct {
1072 ParamSpec
1073}
1074
1075var xParamSpecUIntGLibType func() types.GType
1076
1077func ParamSpecUIntGLibType() types.GType {
1078 return xParamSpecUIntGLibType()
1079}
1080
1081func ParamSpecUIntNewFromInternalPtr(ptr uintptr) *ParamSpecUInt {
1082 cls := &ParamSpecUInt{}
1083 cls.Ptr = ptr
1084 return cls
1085}
1086
1087func (c *ParamSpecUInt) GoPointer() uintptr {
1088 if c == nil {
1089 return 0
1090 }
1091 return c.Ptr
1092}
1093
1094func (c *ParamSpecUInt) SetGoPointer(ptr uintptr) {
1095 c.Ptr = ptr
1096}
1097
1098// A #GParamSpec derived structure that contains the meta data for unsigned 64bit integer properties.
1099type ParamSpecUInt64 struct {
1100 ParamSpec
1101}
1102
1103var xParamSpecUInt64GLibType func() types.GType
1104
1105func ParamSpecUInt64GLibType() types.GType {
1106 return xParamSpecUInt64GLibType()
1107}
1108
1109func ParamSpecUInt64NewFromInternalPtr(ptr uintptr) *ParamSpecUInt64 {
1110 cls := &ParamSpecUInt64{}
1111 cls.Ptr = ptr
1112 return cls
1113}
1114
1115func (c *ParamSpecUInt64) GoPointer() uintptr {
1116 if c == nil {
1117 return 0
1118 }
1119 return c.Ptr
1120}
1121
1122func (c *ParamSpecUInt64) SetGoPointer(ptr uintptr) {
1123 c.Ptr = ptr
1124}
1125
1126// A #GParamSpec derived structure that contains the meta data for unsigned long integer properties.
1127type ParamSpecULong struct {
1128 ParamSpec
1129}
1130
1131var xParamSpecULongGLibType func() types.GType
1132
1133func ParamSpecULongGLibType() types.GType {
1134 return xParamSpecULongGLibType()
1135}
1136
1137func ParamSpecULongNewFromInternalPtr(ptr uintptr) *ParamSpecULong {
1138 cls := &ParamSpecULong{}
1139 cls.Ptr = ptr
1140 return cls
1141}
1142
1143func (c *ParamSpecULong) GoPointer() uintptr {
1144 if c == nil {
1145 return 0
1146 }
1147 return c.Ptr
1148}
1149
1150func (c *ParamSpecULong) SetGoPointer(ptr uintptr) {
1151 c.Ptr = ptr
1152}
1153
1154// A #GParamSpec derived structure that contains the meta data for unichar (unsigned integer) properties.
1155type ParamSpecUnichar struct {
1156 ParamSpec
1157}
1158
1159var xParamSpecUnicharGLibType func() types.GType
1160
1161func ParamSpecUnicharGLibType() types.GType {
1162 return xParamSpecUnicharGLibType()
1163}
1164
1165func ParamSpecUnicharNewFromInternalPtr(ptr uintptr) *ParamSpecUnichar {
1166 cls := &ParamSpecUnichar{}
1167 cls.Ptr = ptr
1168 return cls
1169}
1170
1171func (c *ParamSpecUnichar) GoPointer() uintptr {
1172 if c == nil {
1173 return 0
1174 }
1175 return c.Ptr
1176}
1177
1178func (c *ParamSpecUnichar) SetGoPointer(ptr uintptr) {
1179 c.Ptr = ptr
1180}
1181
1182// A #GParamSpec derived structure that contains the meta data for #GValueArray properties.
1183type ParamSpecValueArray struct {
1184 ParamSpec
1185}
1186
1187var xParamSpecValueArrayGLibType func() types.GType
1188
1189func ParamSpecValueArrayGLibType() types.GType {
1190 return xParamSpecValueArrayGLibType()
1191}
1192
1193func ParamSpecValueArrayNewFromInternalPtr(ptr uintptr) *ParamSpecValueArray {
1194 cls := &ParamSpecValueArray{}
1195 cls.Ptr = ptr
1196 return cls
1197}
1198
1199func (c *ParamSpecValueArray) GoPointer() uintptr {
1200 if c == nil {
1201 return 0
1202 }
1203 return c.Ptr
1204}
1205
1206func (c *ParamSpecValueArray) SetGoPointer(ptr uintptr) {
1207 c.Ptr = ptr
1208}
1209
1210// A #GParamSpec derived structure that contains the meta data for #GVariant properties.
1211//
1212// When comparing values with g_param_values_cmp(), scalar values with the same
1213// type will be compared with g_variant_compare(). Other non-%NULL variants will
1214// be checked for equality with g_variant_equal(), and their sort order is
1215// otherwise undefined. %NULL is ordered before non-%NULL variants. Two %NULL
1216// values compare equal.
1217type ParamSpecVariant struct {
1218 ParamSpec
1219}
1220
1221var xParamSpecVariantGLibType func() types.GType
1222
1223func ParamSpecVariantGLibType() types.GType {
1224 return xParamSpecVariantGLibType()
1225}
1226
1227func ParamSpecVariantNewFromInternalPtr(ptr uintptr) *ParamSpecVariant {
1228 cls := &ParamSpecVariant{}
1229 cls.Ptr = ptr
1230 return cls
1231}
1232
1233func (c *ParamSpecVariant) GoPointer() uintptr {
1234 if c == nil {
1235 return 0
1236 }
1237 return c.Ptr
1238}
1239
1240func (c *ParamSpecVariant) SetGoPointer(ptr uintptr) {
1241 c.Ptr = ptr
1242}
1243
1244func init() {
1245 core.SetPackageName("GOBJECT", "gobject-2.0")
1246 core.SetSharedLibraries("GOBJECT", []string{"libgobject-2.0.so.0"})
1247 var libs []uintptr
1248 for _, libPath := range core.GetPaths("GOBJECT") {
1249 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
1250 if err != nil {
1251 panic(err)
1252 }
1253 libs = append(libs, lib)
1254 }
1255
1256 core.PuregoSafeRegister(&xNewParamSpecBoolean, libs, "g_param_spec_boolean")
1257 core.PuregoSafeRegister(&xNewParamSpecBoxed, libs, "g_param_spec_boxed")
1258 core.PuregoSafeRegister(&xNewParamSpecChar, libs, "g_param_spec_char")
1259 core.PuregoSafeRegister(&xNewParamSpecDouble, libs, "g_param_spec_double")
1260 core.PuregoSafeRegister(&xNewParamSpecEnum, libs, "g_param_spec_enum")
1261 core.PuregoSafeRegister(&xNewParamSpecFlags, libs, "g_param_spec_flags")
1262 core.PuregoSafeRegister(&xNewParamSpecFloat, libs, "g_param_spec_float")
1263 core.PuregoSafeRegister(&xParamSpecGtype, libs, "g_param_spec_gtype")
1264 core.PuregoSafeRegister(&xNewParamSpecInt, libs, "g_param_spec_int")
1265 core.PuregoSafeRegister(&xNewParamSpecInt64, libs, "g_param_spec_int64")
1266 core.PuregoSafeRegister(&xNewParamSpecLong, libs, "g_param_spec_long")
1267 core.PuregoSafeRegister(&xNewParamSpecObject, libs, "g_param_spec_object")
1268 core.PuregoSafeRegister(&xNewParamSpecOverride, libs, "g_param_spec_override")
1269 core.PuregoSafeRegister(&xNewParamSpecParam, libs, "g_param_spec_param")
1270 core.PuregoSafeRegister(&xNewParamSpecPointer, libs, "g_param_spec_pointer")
1271 core.PuregoSafeRegister(&xNewParamSpecString, libs, "g_param_spec_string")
1272 core.PuregoSafeRegister(&xParamSpecUchar, libs, "g_param_spec_uchar")
1273 core.PuregoSafeRegister(&xParamSpecUint, libs, "g_param_spec_uint")
1274 core.PuregoSafeRegister(&xParamSpecUint64, libs, "g_param_spec_uint64")
1275 core.PuregoSafeRegister(&xParamSpecUlong, libs, "g_param_spec_ulong")
1276 core.PuregoSafeRegister(&xNewParamSpecUnichar, libs, "g_param_spec_unichar")
1277 core.PuregoSafeRegister(&xNewParamSpecValueArray, libs, "g_param_spec_value_array")
1278 core.PuregoSafeRegister(&xNewParamSpecVariant, libs, "g_param_spec_variant")
1279
1280 core.PuregoSafeRegister(&xParamSpecBooleanGLibType, libs, "intern")
1281
1282 core.PuregoSafeRegister(&xParamSpecBoxedGLibType, libs, "intern")
1283
1284 core.PuregoSafeRegister(&xParamSpecCharGLibType, libs, "intern")
1285
1286 core.PuregoSafeRegister(&xParamSpecDoubleGLibType, libs, "intern")
1287
1288 core.PuregoSafeRegister(&xParamSpecEnumGLibType, libs, "intern")
1289
1290 core.PuregoSafeRegister(&xParamSpecFlagsGLibType, libs, "intern")
1291
1292 core.PuregoSafeRegister(&xParamSpecFloatGLibType, libs, "intern")
1293
1294 core.PuregoSafeRegister(&xParamSpecGTypeGLibType, libs, "intern")
1295
1296 core.PuregoSafeRegister(&xParamSpecIntGLibType, libs, "intern")
1297
1298 core.PuregoSafeRegister(&xParamSpecInt64GLibType, libs, "intern")
1299
1300 core.PuregoSafeRegister(&xParamSpecLongGLibType, libs, "intern")
1301
1302 core.PuregoSafeRegister(&xParamSpecObjectGLibType, libs, "intern")
1303
1304 core.PuregoSafeRegister(&xParamSpecOverrideGLibType, libs, "intern")
1305
1306 core.PuregoSafeRegister(&xParamSpecParamGLibType, libs, "intern")
1307
1308 core.PuregoSafeRegister(&xParamSpecPointerGLibType, libs, "intern")
1309
1310 core.PuregoSafeRegister(&xParamSpecStringGLibType, libs, "intern")
1311
1312 core.PuregoSafeRegister(&xParamSpecUCharGLibType, libs, "intern")
1313
1314 core.PuregoSafeRegister(&xParamSpecUIntGLibType, libs, "intern")
1315
1316 core.PuregoSafeRegister(&xParamSpecUInt64GLibType, libs, "intern")
1317
1318 core.PuregoSafeRegister(&xParamSpecULongGLibType, libs, "intern")
1319
1320 core.PuregoSafeRegister(&xParamSpecUnicharGLibType, libs, "intern")
1321
1322 core.PuregoSafeRegister(&xParamSpecValueArrayGLibType, libs, "intern")
1323
1324 core.PuregoSafeRegister(&xParamSpecVariantGLibType, libs, "intern")
1325
1326}