adw-leaflet.go RawHistoryFolder

1// Package adw was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package adw
3
4import (
5	"structs"
6	"unsafe"
7
8	"github.com/ebitengine/purego"
9
10	"github.com/bnema/puregotk/pkg/core"
11	"github.com/bnema/puregotk/v4/gdk"
12	"github.com/bnema/puregotk/v4/gobject"
13	"github.com/bnema/puregotk/v4/gobject/types"
14	"github.com/bnema/puregotk/v4/gtk"
15)
16
17type LeafletClass struct {
18	_ structs.HostLayout
19
20	ParentClass gtk.WidgetClass
21}
22
23func (x *LeafletClass) GoPointer() uintptr {
24	return uintptr(unsafe.Pointer(x))
25}
26
27type LeafletPageClass struct {
28	_ structs.HostLayout
29
30	ParentClass gobject.ObjectClass
31}
32
33func (x *LeafletPageClass) GoPointer() uintptr {
34	return uintptr(unsafe.Pointer(x))
35}
36
37// Describes the possible transitions in a [class@Leaflet] widget.
38//
39// New values may be added to this enumeration over time.
40type LeafletTransitionType int
41
42var xLeafletTransitionTypeGLibType func() types.GType
43
44func LeafletTransitionTypeGLibType() types.GType {
45	return xLeafletTransitionTypeGLibType()
46}
47
48const (
49
50	// Cover the old page or uncover the new page, sliding from or towards the end according to orientation, text direction and children order
51	LeafletTransitionTypeOverValue LeafletTransitionType = 0
52	// Uncover the new page or cover the old page, sliding from or towards the start according to orientation, text direction and children order
53	LeafletTransitionTypeUnderValue LeafletTransitionType = 1
54	// Slide from left, right, up or down according to the orientation, text direction and the children order
55	LeafletTransitionTypeSlideValue LeafletTransitionType = 2
56)
57
58// An adaptive container acting like a box or a stack.
59//
60// <picture>
61//
62//	<source srcset="leaflet-wide-dark.png" media="(prefers-color-scheme: dark)">
63//	<img src="leaflet-wide.png" alt="leaflet-wide">
64//
65// </picture>
66// <picture>
67//
68//	<source srcset="leaflet-narrow-dark.png" media="(prefers-color-scheme: dark)">
69//	<img src="leaflet-narrow.png" alt="leaflet-narrow">
70//
71// </picture>
72//
73// The `AdwLeaflet` widget can display its children like a [class@Gtk.Box] does
74// or like a [class@Gtk.Stack] does, adapting to size changes by switching
75// between the two modes.
76//
77// When there is enough space the children are displayed side by side, otherwise
78// only one is displayed and the leaflet is said to be “folded”.
79// The threshold is dictated by the preferred minimum sizes of the children.
80// When a leaflet is folded, the children can be navigated using swipe gestures.
81//
82// The “over” and “under” transition types stack the children one on top of the
83// other, while the “slide” transition puts the children side by side. While
84// navigating to a child on the side or below can be performed by swiping the
85// current child away, navigating to an upper child requires dragging it from
86// the edge where it resides. This doesn't affect non-dragging swipes.
87//
88// ## CSS nodes
89//
90// `AdwLeaflet` has a single CSS node with name `leaflet`. The node will get the
91// style classes `.folded` when it is folded, `.unfolded` when it's not, or none
92// if it hasn't computed its fold yet.
93type Leaflet struct {
94	gtk.Widget
95}
96
97var xLeafletGLibType func() types.GType
98
99func LeafletGLibType() types.GType {
100	return xLeafletGLibType()
101}
102
103func LeafletNewFromInternalPtr(ptr uintptr) *Leaflet {
104	cls := &Leaflet{}
105	cls.Ptr = ptr
106	return cls
107}
108
109var xNewLeaflet func() uintptr
110
111// Creates a new `AdwLeaflet`.
112func NewLeaflet() *Leaflet {
113	var cls *Leaflet
114
115	cret := xNewLeaflet()
116
117	if cret == 0 {
118		return nil
119	}
120	gobject.IncreaseRef(cret)
121	cls = &Leaflet{}
122	cls.Ptr = cret
123	return cls
124}
125
126var xLeafletAppend func(uintptr, uintptr) uintptr
127
128// Adds a child to @self.
129func (x *Leaflet) Append(ChildVar *gtk.Widget) *LeafletPage {
130	var cls *LeafletPage
131
132	cret := xLeafletAppend(x.GoPointer(), ChildVar.GoPointer())
133
134	if cret == 0 {
135		return nil
136	}
137	gobject.IncreaseRef(cret)
138	cls = &LeafletPage{}
139	cls.Ptr = cret
140	return cls
141}
142
143var xLeafletGetAdjacentChild func(uintptr, NavigationDirection) uintptr
144
145// Finds the previous or next navigatable child.
146//
147// This will be the same child [method@Leaflet.navigate] or swipe gestures will
148// navigate to.
149//
150// If there's no child to navigate to, `NULL` will be returned instead.
151//
152// See [property@LeafletPage:navigatable].
153func (x *Leaflet) GetAdjacentChild(DirectionVar NavigationDirection) *gtk.Widget {
154	var cls *gtk.Widget
155
156	cret := xLeafletGetAdjacentChild(x.GoPointer(), DirectionVar)
157
158	if cret == 0 {
159		return nil
160	}
161	gobject.IncreaseRef(cret)
162	cls = &gtk.Widget{}
163	cls.Ptr = cret
164	return cls
165}
166
167var xLeafletGetCanNavigateBack func(uintptr) bool
168
169// Gets whether gestures and shortcuts for navigating backward are enabled.
170func (x *Leaflet) GetCanNavigateBack() bool {
171
172	cret := xLeafletGetCanNavigateBack(x.GoPointer())
173	return cret
174}
175
176var xLeafletGetCanNavigateForward func(uintptr) bool
177
178// Gets whether gestures and shortcuts for navigating forward are enabled.
179func (x *Leaflet) GetCanNavigateForward() bool {
180
181	cret := xLeafletGetCanNavigateForward(x.GoPointer())
182	return cret
183}
184
185var xLeafletGetCanUnfold func(uintptr) bool
186
187// Gets whether @self can unfold.
188func (x *Leaflet) GetCanUnfold() bool {
189
190	cret := xLeafletGetCanUnfold(x.GoPointer())
191	return cret
192}
193
194var xLeafletGetChildByName func(uintptr, string) uintptr
195
196// Finds the child of @self with @name.
197//
198// Returns `NULL` if there is no child with this name.
199//
200// See [property@LeafletPage:name].
201func (x *Leaflet) GetChildByName(NameVar string) *gtk.Widget {
202	var cls *gtk.Widget
203
204	cret := xLeafletGetChildByName(x.GoPointer(), NameVar)
205
206	if cret == 0 {
207		return nil
208	}
209	gobject.IncreaseRef(cret)
210	cls = &gtk.Widget{}
211	cls.Ptr = cret
212	return cls
213}
214
215var xLeafletGetChildTransitionParams func(uintptr) *SpringParams
216
217// Gets the child transition spring parameters for @self.
218func (x *Leaflet) GetChildTransitionParams() *SpringParams {
219
220	cret := xLeafletGetChildTransitionParams(x.GoPointer())
221	return cret
222}
223
224var xLeafletGetChildTransitionRunning func(uintptr) bool
225
226// Gets whether a child transition is currently running for @self.
227func (x *Leaflet) GetChildTransitionRunning() bool {
228
229	cret := xLeafletGetChildTransitionRunning(x.GoPointer())
230	return cret
231}
232
233var xLeafletGetFoldThresholdPolicy func(uintptr) FoldThresholdPolicy
234
235// Gets the fold threshold policy for @self.
236func (x *Leaflet) GetFoldThresholdPolicy() FoldThresholdPolicy {
237
238	cret := xLeafletGetFoldThresholdPolicy(x.GoPointer())
239	return cret
240}
241
242var xLeafletGetFolded func(uintptr) bool
243
244// Gets whether @self is folded.
245//
246// The leaflet will be folded if the size allocated to it is smaller than the
247// sum of the minimum or natural sizes of the children (see
248// [property@Leaflet:fold-threshold-policy]), it will be unfolded otherwise.
249func (x *Leaflet) GetFolded() bool {
250
251	cret := xLeafletGetFolded(x.GoPointer())
252	return cret
253}
254
255var xLeafletGetHomogeneous func(uintptr) bool
256
257// Gets whether @self is homogeneous.
258func (x *Leaflet) GetHomogeneous() bool {
259
260	cret := xLeafletGetHomogeneous(x.GoPointer())
261	return cret
262}
263
264var xLeafletGetModeTransitionDuration func(uintptr) uint
265
266// Gets the mode transition animation duration for @self.
267func (x *Leaflet) GetModeTransitionDuration() uint {
268
269	cret := xLeafletGetModeTransitionDuration(x.GoPointer())
270	return cret
271}
272
273var xLeafletGetPage func(uintptr, uintptr) uintptr
274
275// Returns the [class@LeafletPage] object for @child.
276func (x *Leaflet) GetPage(ChildVar *gtk.Widget) *LeafletPage {
277	var cls *LeafletPage
278
279	cret := xLeafletGetPage(x.GoPointer(), ChildVar.GoPointer())
280
281	if cret == 0 {
282		return nil
283	}
284	gobject.IncreaseRef(cret)
285	cls = &LeafletPage{}
286	cls.Ptr = cret
287	return cls
288}
289
290var xLeafletGetPages func(uintptr) uintptr
291
292// Returns a [iface@Gio.ListModel] that contains the pages of the leaflet.
293//
294// This can be used to keep an up-to-date view. The model also implements
295// [iface@Gtk.SelectionModel] and can be used to track and change the visible
296// page.
297func (x *Leaflet) GetPages() *gtk.SelectionModelBase {
298	var cls *gtk.SelectionModelBase
299
300	cret := xLeafletGetPages(x.GoPointer())
301
302	if cret == 0 {
303		return nil
304	}
305	cls = &gtk.SelectionModelBase{}
306	cls.Ptr = cret
307	return cls
308}
309
310var xLeafletGetTransitionType func(uintptr) LeafletTransitionType
311
312// Gets the type of animation used for transitions between modes and children.
313func (x *Leaflet) GetTransitionType() LeafletTransitionType {
314
315	cret := xLeafletGetTransitionType(x.GoPointer())
316	return cret
317}
318
319var xLeafletGetVisibleChild func(uintptr) uintptr
320
321// Gets the widget currently visible when the leaflet is folded.
322func (x *Leaflet) GetVisibleChild() *gtk.Widget {
323	var cls *gtk.Widget
324
325	cret := xLeafletGetVisibleChild(x.GoPointer())
326
327	if cret == 0 {
328		return nil
329	}
330	gobject.IncreaseRef(cret)
331	cls = &gtk.Widget{}
332	cls.Ptr = cret
333	return cls
334}
335
336var xLeafletGetVisibleChildName func(uintptr) string
337
338// Gets the name of the currently visible child widget.
339func (x *Leaflet) GetVisibleChildName() string {
340
341	cret := xLeafletGetVisibleChildName(x.GoPointer())
342	return cret
343}
344
345var xLeafletInsertChildAfter func(uintptr, uintptr, uintptr) uintptr
346
347// Inserts @child in the position after @sibling in the list of children.
348//
349// If @sibling is `NULL`, inserts @child at the first position.
350func (x *Leaflet) InsertChildAfter(ChildVar *gtk.Widget, SiblingVar *gtk.Widget) *LeafletPage {
351	var cls *LeafletPage
352
353	cret := xLeafletInsertChildAfter(x.GoPointer(), ChildVar.GoPointer(), SiblingVar.GoPointer())
354
355	if cret == 0 {
356		return nil
357	}
358	gobject.IncreaseRef(cret)
359	cls = &LeafletPage{}
360	cls.Ptr = cret
361	return cls
362}
363
364var xLeafletNavigate func(uintptr, NavigationDirection) bool
365
366// Navigates to the previous or next child.
367//
368// The child must have the [property@LeafletPage:navigatable] property set to
369// `TRUE`, otherwise it will be skipped.
370//
371// This will be the same child as returned by
372// [method@Leaflet.get_adjacent_child] or navigated to via swipe gestures.
373func (x *Leaflet) Navigate(DirectionVar NavigationDirection) bool {
374
375	cret := xLeafletNavigate(x.GoPointer(), DirectionVar)
376	return cret
377}
378
379var xLeafletPrepend func(uintptr, uintptr) uintptr
380
381// Inserts @child at the first position in @self.
382func (x *Leaflet) Prepend(ChildVar *gtk.Widget) *LeafletPage {
383	var cls *LeafletPage
384
385	cret := xLeafletPrepend(x.GoPointer(), ChildVar.GoPointer())
386
387	if cret == 0 {
388		return nil
389	}
390	gobject.IncreaseRef(cret)
391	cls = &LeafletPage{}
392	cls.Ptr = cret
393	return cls
394}
395
396var xLeafletRemove func(uintptr, uintptr)
397
398// Removes a child widget from @self.
399func (x *Leaflet) Remove(ChildVar *gtk.Widget) {
400
401	xLeafletRemove(x.GoPointer(), ChildVar.GoPointer())
402
403}
404
405var xLeafletReorderChildAfter func(uintptr, uintptr, uintptr)
406
407// Moves @child to the position after @sibling in the list of children.
408//
409// If @sibling is `NULL`, moves @child to the first position.
410func (x *Leaflet) ReorderChildAfter(ChildVar *gtk.Widget, SiblingVar *gtk.Widget) {
411
412	xLeafletReorderChildAfter(x.GoPointer(), ChildVar.GoPointer(), SiblingVar.GoPointer())
413
414}
415
416var xLeafletSetCanNavigateBack func(uintptr, bool)
417
418// Sets whether gestures and shortcuts for navigating backward are enabled.
419//
420// The supported gestures are:
421//
422// - One-finger swipe on touchscreens
423// - Horizontal scrolling on touchpads (usually two-finger swipe)
424// - Back/forward mouse buttons
425//
426// The keyboard back/forward keys are also supported, as well as the
427// <kbd>Alt</kbd>+<kbd>←</kbd> shortcut for horizontal orientation, or
428// <kbd>Alt</kbd>+<kbd>↑</kbd> for vertical orientation.
429//
430// If the orientation is horizontal, for right-to-left locales, gestures and
431// shortcuts are reversed.
432//
433// Only children that have [property@LeafletPage:navigatable] set to `TRUE` can
434// be navigated to.
435func (x *Leaflet) SetCanNavigateBack(CanNavigateBackVar bool) {
436
437	xLeafletSetCanNavigateBack(x.GoPointer(), CanNavigateBackVar)
438
439}
440
441var xLeafletSetCanNavigateForward func(uintptr, bool)
442
443// Sets whether gestures and shortcuts for navigating forward are enabled.
444//
445// The supported gestures are:
446//
447// - One-finger swipe on touchscreens
448// - Horizontal scrolling on touchpads (usually two-finger swipe)
449// - Back/forward mouse buttons
450//
451// The keyboard back/forward keys are also supported, as well as the
452// <kbd>Alt</kbd>+<kbd>→</kbd> shortcut for horizontal orientation, or
453// <kbd>Alt</kbd>+<kbd>↓</kbd> for vertical orientation.
454//
455// If the orientation is horizontal, for right-to-left locales, gestures and
456// shortcuts are reversed.
457//
458// Only children that have [property@LeafletPage:navigatable] set to `TRUE` can
459// be navigated to.
460func (x *Leaflet) SetCanNavigateForward(CanNavigateForwardVar bool) {
461
462	xLeafletSetCanNavigateForward(x.GoPointer(), CanNavigateForwardVar)
463
464}
465
466var xLeafletSetCanUnfold func(uintptr, bool)
467
468// Sets whether @self can unfold.
469func (x *Leaflet) SetCanUnfold(CanUnfoldVar bool) {
470
471	xLeafletSetCanUnfold(x.GoPointer(), CanUnfoldVar)
472
473}
474
475var xLeafletSetChildTransitionParams func(uintptr, *SpringParams)
476
477// Sets the child transition spring parameters for @self.
478//
479// The default value is equivalent to:
480//
481// ```c
482// adw_spring_params_new (1, 0.5, 500)
483// ```
484func (x *Leaflet) SetChildTransitionParams(ParamsVar *SpringParams) {
485
486	xLeafletSetChildTransitionParams(x.GoPointer(), ParamsVar)
487
488}
489
490var xLeafletSetFoldThresholdPolicy func(uintptr, FoldThresholdPolicy)
491
492// Sets the fold threshold policy for @self.
493//
494// If set to `ADW_FOLD_THRESHOLD_POLICY_MINIMUM`, it will only fold when the
495// children cannot fit anymore. With `ADW_FOLD_THRESHOLD_POLICY_NATURAL`, it
496// will fold as soon as children don't get their natural size.
497//
498// This can be useful if you have a long ellipsizing label and want to let it
499// ellipsize instead of immediately folding.
500func (x *Leaflet) SetFoldThresholdPolicy(PolicyVar FoldThresholdPolicy) {
501
502	xLeafletSetFoldThresholdPolicy(x.GoPointer(), PolicyVar)
503
504}
505
506var xLeafletSetHomogeneous func(uintptr, bool)
507
508// Sets @self to be homogeneous or not.
509//
510// If set to `FALSE`, different children can have different size along the
511// opposite orientation.
512func (x *Leaflet) SetHomogeneous(HomogeneousVar bool) {
513
514	xLeafletSetHomogeneous(x.GoPointer(), HomogeneousVar)
515
516}
517
518var xLeafletSetModeTransitionDuration func(uintptr, uint)
519
520// Sets the mode transition animation duration for @self.
521func (x *Leaflet) SetModeTransitionDuration(DurationVar uint) {
522
523	xLeafletSetModeTransitionDuration(x.GoPointer(), DurationVar)
524
525}
526
527var xLeafletSetTransitionType func(uintptr, LeafletTransitionType)
528
529// Sets the type of animation used for transitions between modes and children.
530//
531// The transition type can be changed without problems at runtime, so it is
532// possible to change the animation based on the mode or child that is about to
533// become current.
534func (x *Leaflet) SetTransitionType(TransitionVar LeafletTransitionType) {
535
536	xLeafletSetTransitionType(x.GoPointer(), TransitionVar)
537
538}
539
540var xLeafletSetVisibleChild func(uintptr, uintptr)
541
542// Sets the widget currently visible when the leaflet is folded.
543//
544// The transition is determined by [property@Leaflet:transition-type] and
545// [property@Leaflet:child-transition-params]. The transition can be cancelled
546// by the user, in which case visible child will change back to the previously
547// visible child.
548func (x *Leaflet) SetVisibleChild(VisibleChildVar *gtk.Widget) {
549
550	xLeafletSetVisibleChild(x.GoPointer(), VisibleChildVar.GoPointer())
551
552}
553
554var xLeafletSetVisibleChildName func(uintptr, string)
555
556// Makes the child with the name @name visible.
557//
558// See [property@Leaflet:visible-child].
559func (x *Leaflet) SetVisibleChildName(NameVar string) {
560
561	xLeafletSetVisibleChildName(x.GoPointer(), NameVar)
562
563}
564
565func (c *Leaflet) GoPointer() uintptr {
566	if c == nil {
567		return 0
568	}
569	return c.Ptr
570}
571
572func (c *Leaflet) SetGoPointer(ptr uintptr) {
573	c.Ptr = ptr
574}
575
576// SetPropertyCanNavigateBack sets the "can-navigate-back" property.
577// Whether gestures and shortcuts for navigating backward are enabled.
578//
579// The supported gestures are:
580//
581// - One-finger swipe on touchscreens
582// - Horizontal scrolling on touchpads (usually two-finger swipe)
583// - Back/forward mouse buttons
584//
585// The keyboard back/forward keys are also supported, as well as the
586// <kbd>Alt</kbd>+<kbd>←</kbd> shortcut for horizontal orientation, or
587// <kbd>Alt</kbd>+<kbd>↑</kbd> for vertical orientation.
588//
589// If the orientation is horizontal, for right-to-left locales, gestures and
590// shortcuts are reversed.
591//
592// Only children that have [property@LeafletPage:navigatable] set to `TRUE`
593// can be navigated to.
594func (x *Leaflet) SetPropertyCanNavigateBack(value bool) {
595	var v gobject.Value
596	v.Init(gobject.TypeBooleanVal)
597	v.SetBoolean(value)
598	x.SetProperty("can-navigate-back", &v)
599}
600
601// GetPropertyCanNavigateBack gets the "can-navigate-back" property.
602// Whether gestures and shortcuts for navigating backward are enabled.
603//
604// The supported gestures are:
605//
606// - One-finger swipe on touchscreens
607// - Horizontal scrolling on touchpads (usually two-finger swipe)
608// - Back/forward mouse buttons
609//
610// The keyboard back/forward keys are also supported, as well as the
611// <kbd>Alt</kbd>+<kbd>←</kbd> shortcut for horizontal orientation, or
612// <kbd>Alt</kbd>+<kbd>↑</kbd> for vertical orientation.
613//
614// If the orientation is horizontal, for right-to-left locales, gestures and
615// shortcuts are reversed.
616//
617// Only children that have [property@LeafletPage:navigatable] set to `TRUE`
618// can be navigated to.
619func (x *Leaflet) GetPropertyCanNavigateBack() bool {
620	var v gobject.Value
621	x.GetProperty("can-navigate-back", &v)
622	return v.GetBoolean()
623}
624
625// SetPropertyCanNavigateForward sets the "can-navigate-forward" property.
626// Whether gestures and shortcuts for navigating forward are enabled.
627//
628// The supported gestures are:
629//
630// - One-finger swipe on touchscreens
631// - Horizontal scrolling on touchpads (usually two-finger swipe)
632// - Back/forward mouse buttons
633//
634// The keyboard back/forward keys are also supported, as well as the
635// <kbd>Alt</kbd>+<kbd>→</kbd> shortcut for horizontal orientation, or
636// <kbd>Alt</kbd>+<kbd>↓</kbd> for vertical orientation.
637//
638// If the orientation is horizontal, for right-to-left locales, gestures and
639// shortcuts are reversed.
640//
641// Only children that have [property@LeafletPage:navigatable] set to `TRUE`
642// can be navigated to.
643func (x *Leaflet) SetPropertyCanNavigateForward(value bool) {
644	var v gobject.Value
645	v.Init(gobject.TypeBooleanVal)
646	v.SetBoolean(value)
647	x.SetProperty("can-navigate-forward", &v)
648}
649
650// GetPropertyCanNavigateForward gets the "can-navigate-forward" property.
651// Whether gestures and shortcuts for navigating forward are enabled.
652//
653// The supported gestures are:
654//
655// - One-finger swipe on touchscreens
656// - Horizontal scrolling on touchpads (usually two-finger swipe)
657// - Back/forward mouse buttons
658//
659// The keyboard back/forward keys are also supported, as well as the
660// <kbd>Alt</kbd>+<kbd>→</kbd> shortcut for horizontal orientation, or
661// <kbd>Alt</kbd>+<kbd>↓</kbd> for vertical orientation.
662//
663// If the orientation is horizontal, for right-to-left locales, gestures and
664// shortcuts are reversed.
665//
666// Only children that have [property@LeafletPage:navigatable] set to `TRUE`
667// can be navigated to.
668func (x *Leaflet) GetPropertyCanNavigateForward() bool {
669	var v gobject.Value
670	x.GetProperty("can-navigate-forward", &v)
671	return v.GetBoolean()
672}
673
674// SetPropertyCanUnfold sets the "can-unfold" property.
675// Whether or not the leaflet can unfold.
676func (x *Leaflet) SetPropertyCanUnfold(value bool) {
677	var v gobject.Value
678	v.Init(gobject.TypeBooleanVal)
679	v.SetBoolean(value)
680	x.SetProperty("can-unfold", &v)
681}
682
683// GetPropertyCanUnfold gets the "can-unfold" property.
684// Whether or not the leaflet can unfold.
685func (x *Leaflet) GetPropertyCanUnfold() bool {
686	var v gobject.Value
687	x.GetProperty("can-unfold", &v)
688	return v.GetBoolean()
689}
690
691// SetPropertyChildTransitionParams sets the "child-transition-params" property.
692// The child transition spring parameters.
693//
694// The default value is equivalent to:
695//
696// ```c
697// adw_spring_params_new (1, 0.5, 500)
698// ```
699func (x *Leaflet) SetPropertyChildTransitionParams(value uintptr) {
700	var v gobject.Value
701	v.Init(gobject.TypePointerVal)
702	v.SetPointer(value)
703	x.SetProperty("child-transition-params", &v)
704}
705
706// GetPropertyChildTransitionParams gets the "child-transition-params" property.
707// The child transition spring parameters.
708//
709// The default value is equivalent to:
710//
711// ```c
712// adw_spring_params_new (1, 0.5, 500)
713// ```
714func (x *Leaflet) GetPropertyChildTransitionParams() uintptr {
715	var v gobject.Value
716	x.GetProperty("child-transition-params", &v)
717	return v.GetPointer()
718}
719
720// GetPropertyChildTransitionRunning gets the "child-transition-running" property.
721// Whether a child transition is currently running.
722func (x *Leaflet) GetPropertyChildTransitionRunning() bool {
723	var v gobject.Value
724	x.GetProperty("child-transition-running", &v)
725	return v.GetBoolean()
726}
727
728// GetPropertyFolded gets the "folded" property.
729// Whether the leaflet is folded.
730//
731// The leaflet will be folded if the size allocated to it is smaller than the
732// sum of the minimum or natural sizes of the children (see
733// [property@Leaflet:fold-threshold-policy]), it will be unfolded otherwise.
734func (x *Leaflet) GetPropertyFolded() bool {
735	var v gobject.Value
736	x.GetProperty("folded", &v)
737	return v.GetBoolean()
738}
739
740// SetPropertyHomogeneous sets the "homogeneous" property.
741// Whether the leaflet allocates the same size for all children when folded.
742//
743// If set to `FALSE`, different children can have different size along the
744// opposite orientation.
745func (x *Leaflet) SetPropertyHomogeneous(value bool) {
746	var v gobject.Value
747	v.Init(gobject.TypeBooleanVal)
748	v.SetBoolean(value)
749	x.SetProperty("homogeneous", &v)
750}
751
752// GetPropertyHomogeneous gets the "homogeneous" property.
753// Whether the leaflet allocates the same size for all children when folded.
754//
755// If set to `FALSE`, different children can have different size along the
756// opposite orientation.
757func (x *Leaflet) GetPropertyHomogeneous() bool {
758	var v gobject.Value
759	x.GetProperty("homogeneous", &v)
760	return v.GetBoolean()
761}
762
763// SetPropertyModeTransitionDuration sets the "mode-transition-duration" property.
764// The mode transition animation duration, in milliseconds.
765func (x *Leaflet) SetPropertyModeTransitionDuration(value uint) {
766	var v gobject.Value
767	v.Init(gobject.TypeUintVal)
768	v.SetUint(value)
769	x.SetProperty("mode-transition-duration", &v)
770}
771
772// GetPropertyModeTransitionDuration gets the "mode-transition-duration" property.
773// The mode transition animation duration, in milliseconds.
774func (x *Leaflet) GetPropertyModeTransitionDuration() uint {
775	var v gobject.Value
776	x.GetProperty("mode-transition-duration", &v)
777	return v.GetUint()
778}
779
780// SetPropertyVisibleChildName sets the "visible-child-name" property.
781// The name of the widget currently visible when the leaflet is folded.
782//
783// See [property@Leaflet:visible-child].
784func (x *Leaflet) SetPropertyVisibleChildName(value string) {
785	var v gobject.Value
786	v.Init(gobject.TypeStringVal)
787	v.SetString(&value)
788	x.SetProperty("visible-child-name", &v)
789}
790
791// GetPropertyVisibleChildName gets the "visible-child-name" property.
792// The name of the widget currently visible when the leaflet is folded.
793//
794// See [property@Leaflet:visible-child].
795func (x *Leaflet) GetPropertyVisibleChildName() string {
796	var v gobject.Value
797	x.GetProperty("visible-child-name", &v)
798	return v.GetString()
799}
800
801// Gets the progress @self will snap back to after the gesture is canceled.
802func (x *Leaflet) GetCancelProgress() float64 {
803
804	cret := XAdwSwipeableGetCancelProgress(x.GoPointer())
805	return cret
806}
807
808// Gets the swipe distance of @self.
809//
810// This corresponds to how many pixels 1 unit represents.
811func (x *Leaflet) GetDistance() float64 {
812
813	cret := XAdwSwipeableGetDistance(x.GoPointer())
814	return cret
815}
816
817// Gets the current progress of @self.
818func (x *Leaflet) GetProgress() float64 {
819
820	cret := XAdwSwipeableGetProgress(x.GoPointer())
821	return cret
822}
823
824// Gets the snap points of @self.
825//
826// Each snap point represents a progress value that is considered acceptable to
827// end the swipe on.
828func (x *Leaflet) GetSnapPoints(NSnapPointsVar *int) uintptr {
829
830	cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)
831	return cret
832}
833
834// Gets the area @self can start a swipe from for the given direction and
835// gesture type.
836//
837// This can be used to restrict swipes to only be possible from a certain area,
838// for example, to only allow edge swipes, or to have a draggable element and
839// ignore swipes elsewhere.
840//
841// If not implemented, the default implementation returns the allocation of
842// @self, allowing swipes from anywhere.
843func (x *Leaflet) GetSwipeArea(NavigationDirectionVar NavigationDirection, IsDragVar bool, RectVar *gdk.Rectangle) {
844
845	XAdwSwipeableGetSwipeArea(x.GoPointer(), NavigationDirectionVar, IsDragVar, RectVar)
846
847}
848
849// Requests the user's screen reader to announce the given message.
850//
851// This kind of notification is useful for messages that
852// either have only a visual representation or that are not
853// exposed visually at all, e.g. a notification about a
854// successful operation.
855//
856// Also, by using this API, you can ensure that the message
857// does not interrupts the user's current screen reader output.
858func (x *Leaflet) Announce(MessageVar string, PriorityVar gtk.AccessibleAnnouncementPriority) {
859
860	gtk.XGtkAccessibleAnnounce(x.GoPointer(), MessageVar, PriorityVar)
861
862}
863
864// Retrieves the accessible parent for an accessible object.
865//
866// This function returns `NULL` for top level widgets.
867func (x *Leaflet) GetAccessibleParent() *gtk.AccessibleBase {
868	var cls *gtk.AccessibleBase
869
870	cret := gtk.XGtkAccessibleGetAccessibleParent(x.GoPointer())
871
872	if cret == 0 {
873		return nil
874	}
875	cls = &gtk.AccessibleBase{}
876	cls.Ptr = cret
877	return cls
878}
879
880// Retrieves the accessible role of an accessible object.
881func (x *Leaflet) GetAccessibleRole() gtk.AccessibleRole {
882
883	cret := gtk.XGtkAccessibleGetAccessibleRole(x.GoPointer())
884	return cret
885}
886
887// Retrieves the implementation for the given accessible object.
888func (x *Leaflet) GetAtContext() *gtk.ATContext {
889	var cls *gtk.ATContext
890
891	cret := gtk.XGtkAccessibleGetAtContext(x.GoPointer())
892
893	if cret == 0 {
894		return nil
895	}
896	cls = &gtk.ATContext{}
897	cls.Ptr = cret
898	return cls
899}
900
901// Queries the coordinates and dimensions of this accessible
902//
903// This functionality can be overridden by `GtkAccessible`
904// implementations, e.g. to get the bounds from an ignored
905// child widget.
906func (x *Leaflet) GetBounds(XVar *int, YVar *int, WidthVar *int, HeightVar *int) bool {
907
908	cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
909	return cret
910}
911
912// Retrieves the first accessible child of an accessible object.
913func (x *Leaflet) GetFirstAccessibleChild() *gtk.AccessibleBase {
914	var cls *gtk.AccessibleBase
915
916	cret := gtk.XGtkAccessibleGetFirstAccessibleChild(x.GoPointer())
917
918	if cret == 0 {
919		return nil
920	}
921	cls = &gtk.AccessibleBase{}
922	cls.Ptr = cret
923	return cls
924}
925
926// Retrieves the next accessible sibling of an accessible object
927func (x *Leaflet) GetNextAccessibleSibling() *gtk.AccessibleBase {
928	var cls *gtk.AccessibleBase
929
930	cret := gtk.XGtkAccessibleGetNextAccessibleSibling(x.GoPointer())
931
932	if cret == 0 {
933		return nil
934	}
935	cls = &gtk.AccessibleBase{}
936	cls.Ptr = cret
937	return cls
938}
939
940// Queries a platform state, such as focus.
941//
942// This functionality can be overridden by `GtkAccessible`
943// implementations, e.g. to get platform state from an ignored
944// child widget, as is the case for `GtkText` wrappers.
945func (x *Leaflet) GetPlatformState(StateVar gtk.AccessiblePlatformState) bool {
946
947	cret := gtk.XGtkAccessibleGetPlatformState(x.GoPointer(), StateVar)
948	return cret
949}
950
951// Resets the accessible property to its default value.
952func (x *Leaflet) ResetProperty(PropertyVar gtk.AccessibleProperty) {
953
954	gtk.XGtkAccessibleResetProperty(x.GoPointer(), PropertyVar)
955
956}
957
958// Resets the accessible relation to its default value.
959func (x *Leaflet) ResetRelation(RelationVar gtk.AccessibleRelation) {
960
961	gtk.XGtkAccessibleResetRelation(x.GoPointer(), RelationVar)
962
963}
964
965// Resets the accessible state to its default value.
966func (x *Leaflet) ResetState(StateVar gtk.AccessibleState) {
967
968	gtk.XGtkAccessibleResetState(x.GoPointer(), StateVar)
969
970}
971
972// Sets the parent and sibling of an accessible object.
973//
974// This function is meant to be used by accessible implementations that are
975// not part of the widget hierarchy, and but act as a logical bridge between
976// widgets. For instance, if a widget creates an object that holds metadata
977// for each child, and you want that object to implement the `GtkAccessible`
978// interface, you will use this function to ensure that the parent of each
979// child widget is the metadata object, and the parent of each metadata
980// object is the container widget.
981func (x *Leaflet) SetAccessibleParent(ParentVar gtk.Accessible, NextSiblingVar gtk.Accessible) {
982
983	gtk.XGtkAccessibleSetAccessibleParent(x.GoPointer(), ParentVar.GoPointer(), NextSiblingVar.GoPointer())
984
985}
986
987// Updates the next accessible sibling.
988//
989// That might be useful when a new child of a custom accessible
990// is created, and it needs to be linked to a previous child.
991func (x *Leaflet) UpdateNextAccessibleSibling(NewSiblingVar gtk.Accessible) {
992
993	gtk.XGtkAccessibleUpdateNextAccessibleSibling(x.GoPointer(), NewSiblingVar.GoPointer())
994
995}
996
997// Informs ATs that the platform state has changed.
998//
999// This function should be used by `GtkAccessible` implementations that
1000// have a platform state but are not widgets. Widgets handle platform
1001// states automatically.
1002func (x *Leaflet) UpdatePlatformState(StateVar gtk.AccessiblePlatformState) {
1003
1004	gtk.XGtkAccessibleUpdatePlatformState(x.GoPointer(), StateVar)
1005
1006}
1007
1008// Updates a list of accessible properties.
1009//
1010// See the [enum@Gtk.AccessibleProperty] documentation for the
1011// value types of accessible properties.
1012//
1013// This function should be called by `GtkWidget` types whenever
1014// an accessible property change must be communicated to assistive
1015// technologies.
1016//
1017// Example:
1018// ```c
1019// value = gtk_adjustment_get_value (adjustment);
1020// gtk_accessible_update_property (GTK_ACCESSIBLE (spin_button),
1021//
1022//	GTK_ACCESSIBLE_PROPERTY_VALUE_NOW, value,
1023//	-1);
1024//
1025// ```
1026func (x *Leaflet) UpdateProperty(FirstPropertyVar gtk.AccessibleProperty, varArgs ...interface{}) {
1027
1028	gtk.XGtkAccessibleUpdateProperty(x.GoPointer(), FirstPropertyVar, varArgs...)
1029
1030}
1031
1032// Updates an array of accessible properties.
1033//
1034// This function should be called by `GtkWidget` types whenever an accessible
1035// property change must be communicated to assistive technologies.
1036//
1037// This function is meant to be used by language bindings.
1038func (x *Leaflet) UpdatePropertyValue(NPropertiesVar int, PropertiesVar []gtk.AccessibleProperty, ValuesVar []gobject.Value) {
1039
1040	gtk.XGtkAccessibleUpdatePropertyValue(x.GoPointer(), NPropertiesVar, PropertiesVar, ValuesVar)
1041
1042}
1043
1044// Updates a list of accessible relations.
1045//
1046// This function should be called by `GtkWidget` types whenever an accessible
1047// relation change must be communicated to assistive technologies.
1048//
1049// If the [enum@Gtk.AccessibleRelation] requires a list of references,
1050// you should pass each reference individually, followed by `NULL`, e.g.
1051//
1052// ```c
1053// gtk_accessible_update_relation (accessible,
1054//
1055//	GTK_ACCESSIBLE_RELATION_CONTROLS,
1056//	  ref1, NULL,
1057//	GTK_ACCESSIBLE_RELATION_LABELLED_BY,
1058//	  ref1, ref2, ref3, NULL,
1059//	-1);
1060//
1061// ```
1062func (x *Leaflet) UpdateRelation(FirstRelationVar gtk.AccessibleRelation, varArgs ...interface{}) {
1063
1064	gtk.XGtkAccessibleUpdateRelation(x.GoPointer(), FirstRelationVar, varArgs...)
1065
1066}
1067
1068// Updates an array of accessible relations.
1069//
1070// This function should be called by `GtkWidget` types whenever an accessible
1071// relation change must be communicated to assistive technologies.
1072//
1073// This function is meant to be used by language bindings.
1074func (x *Leaflet) UpdateRelationValue(NRelationsVar int, RelationsVar []gtk.AccessibleRelation, ValuesVar []gobject.Value) {
1075
1076	gtk.XGtkAccessibleUpdateRelationValue(x.GoPointer(), NRelationsVar, RelationsVar, ValuesVar)
1077
1078}
1079
1080// Updates a list of accessible states.
1081//
1082// See the [enum@Gtk.AccessibleState] documentation for the
1083// value types of accessible states.
1084//
1085// This function should be called by `GtkWidget` types whenever
1086// an accessible state change must be communicated to assistive
1087// technologies.
1088//
1089// Example:
1090//
1091// ```c
1092// value = GTK_ACCESSIBLE_TRISTATE_MIXED;
1093// gtk_accessible_update_state (GTK_ACCESSIBLE (check_button),
1094//
1095//	GTK_ACCESSIBLE_STATE_CHECKED, value,
1096//	-1);
1097//
1098// ```
1099func (x *Leaflet) UpdateState(FirstStateVar gtk.AccessibleState, varArgs ...interface{}) {
1100
1101	gtk.XGtkAccessibleUpdateState(x.GoPointer(), FirstStateVar, varArgs...)
1102
1103}
1104
1105// Updates an array of accessible states.
1106//
1107// This function should be called by `GtkWidget` types whenever an accessible
1108// state change must be communicated to assistive technologies.
1109//
1110// This function is meant to be used by language bindings.
1111func (x *Leaflet) UpdateStateValue(NStatesVar int, StatesVar []gtk.AccessibleState, ValuesVar []gobject.Value) {
1112
1113	gtk.XGtkAccessibleUpdateStateValue(x.GoPointer(), NStatesVar, StatesVar, ValuesVar)
1114
1115}
1116
1117// Gets the ID of the @buildable object.
1118//
1119// `GtkBuilder` sets the name based on the ID attribute
1120// of the `<object>` tag used to construct the @buildable.
1121func (x *Leaflet) GetBuildableId() string {
1122
1123	cret := gtk.XGtkBuildableGetBuildableId(x.GoPointer())
1124	return cret
1125}
1126
1127// Retrieves the orientation of the @orientable.
1128func (x *Leaflet) GetOrientation() gtk.Orientation {
1129
1130	cret := gtk.XGtkOrientableGetOrientation(x.GoPointer())
1131	return cret
1132}
1133
1134// Sets the orientation of the @orientable.
1135func (x *Leaflet) SetOrientation(OrientationVar gtk.Orientation) {
1136
1137	gtk.XGtkOrientableSetOrientation(x.GoPointer(), OrientationVar)
1138
1139}
1140
1141// An auxiliary class used by [class@Leaflet].
1142type LeafletPage struct {
1143	gobject.Object
1144}
1145
1146var xLeafletPageGLibType func() types.GType
1147
1148func LeafletPageGLibType() types.GType {
1149	return xLeafletPageGLibType()
1150}
1151
1152func LeafletPageNewFromInternalPtr(ptr uintptr) *LeafletPage {
1153	cls := &LeafletPage{}
1154	cls.Ptr = ptr
1155	return cls
1156}
1157
1158var xLeafletPageGetChild func(uintptr) uintptr
1159
1160// Gets the leaflet child to which @self belongs.
1161func (x *LeafletPage) GetChild() *gtk.Widget {
1162	var cls *gtk.Widget
1163
1164	cret := xLeafletPageGetChild(x.GoPointer())
1165
1166	if cret == 0 {
1167		return nil
1168	}
1169	gobject.IncreaseRef(cret)
1170	cls = &gtk.Widget{}
1171	cls.Ptr = cret
1172	return cls
1173}
1174
1175var xLeafletPageGetName func(uintptr) string
1176
1177// Gets the name of @self.
1178func (x *LeafletPage) GetName() string {
1179
1180	cret := xLeafletPageGetName(x.GoPointer())
1181	return cret
1182}
1183
1184var xLeafletPageGetNavigatable func(uintptr) bool
1185
1186// Gets whether the child can be navigated to when folded.
1187func (x *LeafletPage) GetNavigatable() bool {
1188
1189	cret := xLeafletPageGetNavigatable(x.GoPointer())
1190	return cret
1191}
1192
1193var xLeafletPageSetName func(uintptr, uintptr)
1194
1195// Sets the name of the @self.
1196func (x *LeafletPage) SetName(NameVar *string) {
1197
1198	NameVarPtr := core.GStrdupNullable(NameVar)
1199	defer core.GFreeNullable(NameVarPtr)
1200
1201	xLeafletPageSetName(x.GoPointer(), NameVarPtr)
1202
1203}
1204
1205var xLeafletPageSetNavigatable func(uintptr, bool)
1206
1207// Sets whether @self can be navigated to when folded.
1208//
1209// If `FALSE`, the child will be ignored by [method@Leaflet.get_adjacent_child],
1210// [method@Leaflet.navigate], and swipe gestures.
1211//
1212// This can be used used to prevent switching to widgets like separators.
1213func (x *LeafletPage) SetNavigatable(NavigatableVar bool) {
1214
1215	xLeafletPageSetNavigatable(x.GoPointer(), NavigatableVar)
1216
1217}
1218
1219func (c *LeafletPage) GoPointer() uintptr {
1220	if c == nil {
1221		return 0
1222	}
1223	return c.Ptr
1224}
1225
1226func (c *LeafletPage) SetGoPointer(ptr uintptr) {
1227	c.Ptr = ptr
1228}
1229
1230// SetPropertyName sets the "name" property.
1231// The name of the child page.
1232func (x *LeafletPage) SetPropertyName(value string) {
1233	var v gobject.Value
1234	v.Init(gobject.TypeStringVal)
1235	v.SetString(&value)
1236	x.SetProperty("name", &v)
1237}
1238
1239// GetPropertyName gets the "name" property.
1240// The name of the child page.
1241func (x *LeafletPage) GetPropertyName() string {
1242	var v gobject.Value
1243	x.GetProperty("name", &v)
1244	return v.GetString()
1245}
1246
1247// SetPropertyNavigatable sets the "navigatable" property.
1248// Whether the child can be navigated to when folded.
1249//
1250// If `FALSE`, the child will be ignored by
1251// [method@Leaflet.get_adjacent_child], [method@Leaflet.navigate], and swipe
1252// gestures.
1253//
1254// This can be used used to prevent switching to widgets like separators.
1255func (x *LeafletPage) SetPropertyNavigatable(value bool) {
1256	var v gobject.Value
1257	v.Init(gobject.TypeBooleanVal)
1258	v.SetBoolean(value)
1259	x.SetProperty("navigatable", &v)
1260}
1261
1262// GetPropertyNavigatable gets the "navigatable" property.
1263// Whether the child can be navigated to when folded.
1264//
1265// If `FALSE`, the child will be ignored by
1266// [method@Leaflet.get_adjacent_child], [method@Leaflet.navigate], and swipe
1267// gestures.
1268//
1269// This can be used used to prevent switching to widgets like separators.
1270func (x *LeafletPage) GetPropertyNavigatable() bool {
1271	var v gobject.Value
1272	x.GetProperty("navigatable", &v)
1273	return v.GetBoolean()
1274}
1275
1276func init() {
1277	core.SetPackageName("ADW", "libadwaita-1")
1278	core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})
1279	var libs []uintptr
1280	for _, libPath := range core.GetPaths("ADW") {
1281		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
1282		if err != nil {
1283			panic(err)
1284		}
1285		libs = append(libs, lib)
1286	}
1287
1288	core.PuregoSafeRegister(&xLeafletTransitionTypeGLibType, libs, "adw_leaflet_transition_type_get_type")
1289
1290	core.PuregoSafeRegister(&xLeafletGLibType, libs, "adw_leaflet_get_type")
1291
1292	core.PuregoSafeRegister(&xNewLeaflet, libs, "adw_leaflet_new")
1293
1294	core.PuregoSafeRegister(&xLeafletAppend, libs, "adw_leaflet_append")
1295	core.PuregoSafeRegister(&xLeafletGetAdjacentChild, libs, "adw_leaflet_get_adjacent_child")
1296	core.PuregoSafeRegister(&xLeafletGetCanNavigateBack, libs, "adw_leaflet_get_can_navigate_back")
1297	core.PuregoSafeRegister(&xLeafletGetCanNavigateForward, libs, "adw_leaflet_get_can_navigate_forward")
1298	core.PuregoSafeRegister(&xLeafletGetCanUnfold, libs, "adw_leaflet_get_can_unfold")
1299	core.PuregoSafeRegister(&xLeafletGetChildByName, libs, "adw_leaflet_get_child_by_name")
1300	core.PuregoSafeRegister(&xLeafletGetChildTransitionParams, libs, "adw_leaflet_get_child_transition_params")
1301	core.PuregoSafeRegister(&xLeafletGetChildTransitionRunning, libs, "adw_leaflet_get_child_transition_running")
1302	core.PuregoSafeRegister(&xLeafletGetFoldThresholdPolicy, libs, "adw_leaflet_get_fold_threshold_policy")
1303	core.PuregoSafeRegister(&xLeafletGetFolded, libs, "adw_leaflet_get_folded")
1304	core.PuregoSafeRegister(&xLeafletGetHomogeneous, libs, "adw_leaflet_get_homogeneous")
1305	core.PuregoSafeRegister(&xLeafletGetModeTransitionDuration, libs, "adw_leaflet_get_mode_transition_duration")
1306	core.PuregoSafeRegister(&xLeafletGetPage, libs, "adw_leaflet_get_page")
1307	core.PuregoSafeRegister(&xLeafletGetPages, libs, "adw_leaflet_get_pages")
1308	core.PuregoSafeRegister(&xLeafletGetTransitionType, libs, "adw_leaflet_get_transition_type")
1309	core.PuregoSafeRegister(&xLeafletGetVisibleChild, libs, "adw_leaflet_get_visible_child")
1310	core.PuregoSafeRegister(&xLeafletGetVisibleChildName, libs, "adw_leaflet_get_visible_child_name")
1311	core.PuregoSafeRegister(&xLeafletInsertChildAfter, libs, "adw_leaflet_insert_child_after")
1312	core.PuregoSafeRegister(&xLeafletNavigate, libs, "adw_leaflet_navigate")
1313	core.PuregoSafeRegister(&xLeafletPrepend, libs, "adw_leaflet_prepend")
1314	core.PuregoSafeRegister(&xLeafletRemove, libs, "adw_leaflet_remove")
1315	core.PuregoSafeRegister(&xLeafletReorderChildAfter, libs, "adw_leaflet_reorder_child_after")
1316	core.PuregoSafeRegister(&xLeafletSetCanNavigateBack, libs, "adw_leaflet_set_can_navigate_back")
1317	core.PuregoSafeRegister(&xLeafletSetCanNavigateForward, libs, "adw_leaflet_set_can_navigate_forward")
1318	core.PuregoSafeRegister(&xLeafletSetCanUnfold, libs, "adw_leaflet_set_can_unfold")
1319	core.PuregoSafeRegister(&xLeafletSetChildTransitionParams, libs, "adw_leaflet_set_child_transition_params")
1320	core.PuregoSafeRegister(&xLeafletSetFoldThresholdPolicy, libs, "adw_leaflet_set_fold_threshold_policy")
1321	core.PuregoSafeRegister(&xLeafletSetHomogeneous, libs, "adw_leaflet_set_homogeneous")
1322	core.PuregoSafeRegister(&xLeafletSetModeTransitionDuration, libs, "adw_leaflet_set_mode_transition_duration")
1323	core.PuregoSafeRegister(&xLeafletSetTransitionType, libs, "adw_leaflet_set_transition_type")
1324	core.PuregoSafeRegister(&xLeafletSetVisibleChild, libs, "adw_leaflet_set_visible_child")
1325	core.PuregoSafeRegister(&xLeafletSetVisibleChildName, libs, "adw_leaflet_set_visible_child_name")
1326
1327	core.PuregoSafeRegister(&xLeafletPageGLibType, libs, "adw_leaflet_page_get_type")
1328
1329	core.PuregoSafeRegister(&xLeafletPageGetChild, libs, "adw_leaflet_page_get_child")
1330	core.PuregoSafeRegister(&xLeafletPageGetName, libs, "adw_leaflet_page_get_name")
1331	core.PuregoSafeRegister(&xLeafletPageGetNavigatable, libs, "adw_leaflet_page_get_navigatable")
1332	core.PuregoSafeRegister(&xLeafletPageSetName, libs, "adw_leaflet_page_set_name")
1333	core.PuregoSafeRegister(&xLeafletPageSetNavigatable, libs, "adw_leaflet_page_set_navigatable")
1334
1335}