1// Package gtk was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gtk
3
4import (
5 "unsafe"
6
7 "github.com/ebitengine/purego"
8
9 "github.com/bnema/puregotk/pkg/core"
10 "github.com/bnema/puregotk/v4/glib"
11 "github.com/bnema/puregotk/v4/gobject"
12 "github.com/bnema/puregotk/v4/gobject/types"
13)
14
15// Specifies which corner a child widget should be placed in when packed into
16// a `GtkScrolledWindow.`
17//
18// This is effectively the opposite of where the scroll bars are placed.
19type CornerType int
20
21var xCornerTypeGLibType func() types.GType
22
23func CornerTypeGLibType() types.GType {
24 return xCornerTypeGLibType()
25}
26
27const (
28
29 // Place the scrollbars on the right and bottom of the
30 // widget (default behaviour).
31 CornerTopLeftValue CornerType = 0
32 // Place the scrollbars on the top and right of the
33 // widget.
34 CornerBottomLeftValue CornerType = 1
35 // Place the scrollbars on the left and bottom of the
36 // widget.
37 CornerTopRightValue CornerType = 2
38 // Place the scrollbars on the top and left of the
39 // widget.
40 CornerBottomRightValue CornerType = 3
41)
42
43// Determines how the size should be computed to achieve the one of the
44// visibility mode for the scrollbars.
45type PolicyType int
46
47var xPolicyTypeGLibType func() types.GType
48
49func PolicyTypeGLibType() types.GType {
50 return xPolicyTypeGLibType()
51}
52
53const (
54
55 // The scrollbar is always visible. The view size is
56 // independent of the content.
57 PolicyAlwaysValue PolicyType = 0
58 // The scrollbar will appear and disappear as necessary.
59 // For example, when all of a `GtkTreeView` can not be seen.
60 PolicyAutomaticValue PolicyType = 1
61 // The scrollbar should never appear. In this mode the
62 // content determines the size.
63 PolicyNeverValue PolicyType = 2
64 // Don't show a scrollbar, but don't force the
65 // size to follow the content. This can be used e.g. to make multiple
66 // scrolled windows share a scrollbar.
67 PolicyExternalValue PolicyType = 3
68)
69
70// Makes its child scrollable.
71//
72// <picture>
73//
74// <source srcset="scrolledwindow-dark.png" media="(prefers-color-scheme: dark)">
75// <img alt="An example GtkScrolledWindow" src="scrolledwindow.png">
76//
77// </picture>
78//
79// It does so using either internally added scrollbars or externally
80// associated adjustments, and optionally draws a frame around the child.
81//
82// Widgets with native scrolling support, i.e. those whose classes implement
83// the [iface@Gtk.Scrollable] interface, are added directly. For other types
84// of widget, the class [class@Gtk.Viewport] acts as an adaptor, giving
85// scrollability to other widgets. [method@Gtk.ScrolledWindow.set_child]
86// intelligently accounts for whether or not the added child is a `GtkScrollable`.
87// If it isn’t, then it wraps the child in a `GtkViewport`. Therefore, you can
88// just add any child widget and not worry about the details.
89//
90// If [method@Gtk.ScrolledWindow.set_child] has added a `GtkViewport` for you,
91// it will be automatically removed when you unset the child.
92// Unless [property@Gtk.ScrolledWindow:hscrollbar-policy] and
93// [property@Gtk.ScrolledWindow:vscrollbar-policy] are %GTK_POLICY_NEVER or
94// %GTK_POLICY_EXTERNAL, `GtkScrolledWindow` adds internal `GtkScrollbar` widgets
95// around its child. The scroll position of the child, and if applicable the
96// scrollbars, is controlled by the [property@Gtk.ScrolledWindow:hadjustment]
97// and [property@Gtk.ScrolledWindow:vadjustment] that are associated with the
98// `GtkScrolledWindow`. See the docs on [class@Gtk.Scrollbar] for the details,
99// but note that the “step_increment” and “page_increment” fields are only
100// effective if the policy causes scrollbars to be present.
101//
102// If a `GtkScrolledWindow` doesn’t behave quite as you would like, or
103// doesn’t have exactly the right layout, it’s very possible to set up
104// your own scrolling with `GtkScrollbar` and for example a `GtkGrid`.
105//
106// # Touch support
107//
108// `GtkScrolledWindow` has built-in support for touch devices. When a
109// touchscreen is used, swiping will move the scrolled window, and will
110// expose 'kinetic' behavior. This can be turned off with the
111// [property@Gtk.ScrolledWindow:kinetic-scrolling] property if it is undesired.
112//
113// `GtkScrolledWindow` also displays visual 'overshoot' indication when
114// the content is pulled beyond the end, and this situation can be
115// captured with the [signal@Gtk.ScrolledWindow::edge-overshot] signal.
116//
117// If no mouse device is present, the scrollbars will overlaid as
118// narrow, auto-hiding indicators over the content. If traditional
119// scrollbars are desired although no mouse is present, this behaviour
120// can be turned off with the [property@Gtk.ScrolledWindow:overlay-scrolling]
121// property.
122//
123// # Shortcuts and Gestures
124//
125// The following signals have default keybindings:
126//
127// - [signal@Gtk.ScrolledWindow::scroll-child]
128//
129// # CSS nodes
130//
131// `GtkScrolledWindow` has a main CSS node with name scrolledwindow.
132// It gets a .frame style class added when [property@Gtk.ScrolledWindow:has-frame]
133// is %TRUE.
134//
135// It uses subnodes with names overshoot and undershoot to draw the overflow
136// and underflow indications. These nodes get the .left, .right, .top or .bottom
137// style class added depending on where the indication is drawn.
138//
139// `GtkScrolledWindow` also sets the positional style classes (.left, .right,
140// .top, .bottom) and style classes related to overlay scrolling
141// (.overlay-indicator, .dragging, .hovering) on its scrollbars.
142//
143// If both scrollbars are visible, the area where they meet is drawn
144// with a subnode named junction.
145//
146// # Accessibility
147//
148// Until GTK 4.10, `GtkScrolledWindow` used the [enum@Gtk.AccessibleRole.group] role.
149//
150// Starting from GTK 4.12, `GtkScrolledWindow` uses the [enum@Gtk.AccessibleRole.generic]
151// role.
152type ScrolledWindow struct {
153 Widget
154}
155
156var xScrolledWindowGLibType func() types.GType
157
158func ScrolledWindowGLibType() types.GType {
159 return xScrolledWindowGLibType()
160}
161
162func ScrolledWindowNewFromInternalPtr(ptr uintptr) *ScrolledWindow {
163 cls := &ScrolledWindow{}
164 cls.Ptr = ptr
165 return cls
166}
167
168var xNewScrolledWindow func() uintptr
169
170// Creates a new scrolled window.
171func NewScrolledWindow() *ScrolledWindow {
172 var cls *ScrolledWindow
173
174 cret := xNewScrolledWindow()
175
176 if cret == 0 {
177 return nil
178 }
179 gobject.IncreaseRef(cret)
180 cls = &ScrolledWindow{}
181 cls.Ptr = cret
182 return cls
183}
184
185var xScrolledWindowGetChild func(uintptr) uintptr
186
187// Gets the child widget of @scrolled_window.
188//
189// If the scrolled window automatically added a [class@Gtk.Viewport], this
190// function will return the viewport widget, and you can retrieve its child
191// using [method@Gtk.Viewport.get_child].
192func (x *ScrolledWindow) GetChild() *Widget {
193 var cls *Widget
194
195 cret := xScrolledWindowGetChild(x.GoPointer())
196
197 if cret == 0 {
198 return nil
199 }
200 gobject.IncreaseRef(cret)
201 cls = &Widget{}
202 cls.Ptr = cret
203 return cls
204}
205
206var xScrolledWindowGetHadjustment func(uintptr) uintptr
207
208// Returns the horizontal scrollbar’s adjustment.
209//
210// This is the adjustment used to connect the horizontal scrollbar
211// to the child widget’s horizontal scroll functionality.
212func (x *ScrolledWindow) GetHadjustment() *Adjustment {
213 var cls *Adjustment
214
215 cret := xScrolledWindowGetHadjustment(x.GoPointer())
216
217 if cret == 0 {
218 return nil
219 }
220 gobject.IncreaseRef(cret)
221 cls = &Adjustment{}
222 cls.Ptr = cret
223 return cls
224}
225
226var xScrolledWindowGetHasFrame func(uintptr) bool
227
228// Gets whether the scrolled window draws a frame.
229func (x *ScrolledWindow) GetHasFrame() bool {
230
231 cret := xScrolledWindowGetHasFrame(x.GoPointer())
232 return cret
233}
234
235var xScrolledWindowGetHscrollbar func(uintptr) uintptr
236
237// Returns the horizontal scrollbar of @scrolled_window.
238func (x *ScrolledWindow) GetHscrollbar() *Widget {
239 var cls *Widget
240
241 cret := xScrolledWindowGetHscrollbar(x.GoPointer())
242
243 if cret == 0 {
244 return nil
245 }
246 gobject.IncreaseRef(cret)
247 cls = &Widget{}
248 cls.Ptr = cret
249 return cls
250}
251
252var xScrolledWindowGetKineticScrolling func(uintptr) bool
253
254// Returns the specified kinetic scrolling behavior.
255func (x *ScrolledWindow) GetKineticScrolling() bool {
256
257 cret := xScrolledWindowGetKineticScrolling(x.GoPointer())
258 return cret
259}
260
261var xScrolledWindowGetMaxContentHeight func(uintptr) int
262
263// Returns the maximum content height set.
264func (x *ScrolledWindow) GetMaxContentHeight() int {
265
266 cret := xScrolledWindowGetMaxContentHeight(x.GoPointer())
267 return cret
268}
269
270var xScrolledWindowGetMaxContentWidth func(uintptr) int
271
272// Returns the maximum content width set.
273func (x *ScrolledWindow) GetMaxContentWidth() int {
274
275 cret := xScrolledWindowGetMaxContentWidth(x.GoPointer())
276 return cret
277}
278
279var xScrolledWindowGetMinContentHeight func(uintptr) int
280
281// Gets the minimal content height of @scrolled_window.
282func (x *ScrolledWindow) GetMinContentHeight() int {
283
284 cret := xScrolledWindowGetMinContentHeight(x.GoPointer())
285 return cret
286}
287
288var xScrolledWindowGetMinContentWidth func(uintptr) int
289
290// Gets the minimum content width of @scrolled_window.
291func (x *ScrolledWindow) GetMinContentWidth() int {
292
293 cret := xScrolledWindowGetMinContentWidth(x.GoPointer())
294 return cret
295}
296
297var xScrolledWindowGetOverlayScrolling func(uintptr) bool
298
299// Returns whether overlay scrolling is enabled for this scrolled window.
300func (x *ScrolledWindow) GetOverlayScrolling() bool {
301
302 cret := xScrolledWindowGetOverlayScrolling(x.GoPointer())
303 return cret
304}
305
306var xScrolledWindowGetPlacement func(uintptr) CornerType
307
308// Gets the placement of the contents with respect to the scrollbars.
309func (x *ScrolledWindow) GetPlacement() CornerType {
310
311 cret := xScrolledWindowGetPlacement(x.GoPointer())
312 return cret
313}
314
315var xScrolledWindowGetPolicy func(uintptr, *PolicyType, *PolicyType)
316
317// Retrieves the current policy values for the horizontal and vertical
318// scrollbars.
319//
320// See [method@Gtk.ScrolledWindow.set_policy].
321func (x *ScrolledWindow) GetPolicy(HscrollbarPolicyVar *PolicyType, VscrollbarPolicyVar *PolicyType) {
322
323 xScrolledWindowGetPolicy(x.GoPointer(), HscrollbarPolicyVar, VscrollbarPolicyVar)
324
325}
326
327var xScrolledWindowGetPropagateNaturalHeight func(uintptr) bool
328
329// Reports whether the natural height of the child will be calculated
330// and propagated through the scrolled window’s requested natural height.
331func (x *ScrolledWindow) GetPropagateNaturalHeight() bool {
332
333 cret := xScrolledWindowGetPropagateNaturalHeight(x.GoPointer())
334 return cret
335}
336
337var xScrolledWindowGetPropagateNaturalWidth func(uintptr) bool
338
339// Reports whether the natural width of the child will be calculated
340// and propagated through the scrolled window’s requested natural width.
341func (x *ScrolledWindow) GetPropagateNaturalWidth() bool {
342
343 cret := xScrolledWindowGetPropagateNaturalWidth(x.GoPointer())
344 return cret
345}
346
347var xScrolledWindowGetVadjustment func(uintptr) uintptr
348
349// Returns the vertical scrollbar’s adjustment.
350//
351// This is the adjustment used to connect the vertical
352// scrollbar to the child widget’s vertical scroll functionality.
353func (x *ScrolledWindow) GetVadjustment() *Adjustment {
354 var cls *Adjustment
355
356 cret := xScrolledWindowGetVadjustment(x.GoPointer())
357
358 if cret == 0 {
359 return nil
360 }
361 gobject.IncreaseRef(cret)
362 cls = &Adjustment{}
363 cls.Ptr = cret
364 return cls
365}
366
367var xScrolledWindowGetVscrollbar func(uintptr) uintptr
368
369// Returns the vertical scrollbar of @scrolled_window.
370func (x *ScrolledWindow) GetVscrollbar() *Widget {
371 var cls *Widget
372
373 cret := xScrolledWindowGetVscrollbar(x.GoPointer())
374
375 if cret == 0 {
376 return nil
377 }
378 gobject.IncreaseRef(cret)
379 cls = &Widget{}
380 cls.Ptr = cret
381 return cls
382}
383
384var xScrolledWindowSetChild func(uintptr, uintptr)
385
386// Sets the child widget of @scrolled_window.
387//
388// If @child does not implement the [iface@Gtk.Scrollable] interface,
389// the scrolled window will add @child to a [class@Gtk.Viewport] instance
390// and then add the viewport as its child widget.
391func (x *ScrolledWindow) SetChild(ChildVar *Widget) {
392
393 xScrolledWindowSetChild(x.GoPointer(), ChildVar.GoPointer())
394
395}
396
397var xScrolledWindowSetHadjustment func(uintptr, uintptr)
398
399// Sets the `GtkAdjustment` for the horizontal scrollbar.
400func (x *ScrolledWindow) SetHadjustment(HadjustmentVar *Adjustment) {
401
402 xScrolledWindowSetHadjustment(x.GoPointer(), HadjustmentVar.GoPointer())
403
404}
405
406var xScrolledWindowSetHasFrame func(uintptr, bool)
407
408// Changes the frame drawn around the contents of @scrolled_window.
409func (x *ScrolledWindow) SetHasFrame(HasFrameVar bool) {
410
411 xScrolledWindowSetHasFrame(x.GoPointer(), HasFrameVar)
412
413}
414
415var xScrolledWindowSetKineticScrolling func(uintptr, bool)
416
417// Turns kinetic scrolling on or off.
418//
419// Kinetic scrolling only applies to devices with source
420// %GDK_SOURCE_TOUCHSCREEN.
421func (x *ScrolledWindow) SetKineticScrolling(KineticScrollingVar bool) {
422
423 xScrolledWindowSetKineticScrolling(x.GoPointer(), KineticScrollingVar)
424
425}
426
427var xScrolledWindowSetMaxContentHeight func(uintptr, int)
428
429// Sets the maximum height that @scrolled_window should keep visible.
430//
431// The @scrolled_window will grow up to this height before it starts
432// scrolling the content.
433//
434// It is a programming error to set the maximum content height to a value
435// smaller than [property@Gtk.ScrolledWindow:min-content-height].
436func (x *ScrolledWindow) SetMaxContentHeight(HeightVar int) {
437
438 xScrolledWindowSetMaxContentHeight(x.GoPointer(), HeightVar)
439
440}
441
442var xScrolledWindowSetMaxContentWidth func(uintptr, int)
443
444// Sets the maximum width that @scrolled_window should keep visible.
445//
446// The @scrolled_window will grow up to this width before it starts
447// scrolling the content.
448//
449// It is a programming error to set the maximum content width to a
450// value smaller than [property@Gtk.ScrolledWindow:min-content-width].
451func (x *ScrolledWindow) SetMaxContentWidth(WidthVar int) {
452
453 xScrolledWindowSetMaxContentWidth(x.GoPointer(), WidthVar)
454
455}
456
457var xScrolledWindowSetMinContentHeight func(uintptr, int)
458
459// Sets the minimum height that @scrolled_window should keep visible.
460//
461// Note that this can and (usually will) be smaller than the minimum
462// size of the content.
463//
464// It is a programming error to set the minimum content height to a
465// value greater than [property@Gtk.ScrolledWindow:max-content-height].
466func (x *ScrolledWindow) SetMinContentHeight(HeightVar int) {
467
468 xScrolledWindowSetMinContentHeight(x.GoPointer(), HeightVar)
469
470}
471
472var xScrolledWindowSetMinContentWidth func(uintptr, int)
473
474// Sets the minimum width that @scrolled_window should keep visible.
475//
476// Note that this can and (usually will) be smaller than the minimum
477// size of the content.
478//
479// It is a programming error to set the minimum content width to a
480// value greater than [property@Gtk.ScrolledWindow:max-content-width].
481func (x *ScrolledWindow) SetMinContentWidth(WidthVar int) {
482
483 xScrolledWindowSetMinContentWidth(x.GoPointer(), WidthVar)
484
485}
486
487var xScrolledWindowSetOverlayScrolling func(uintptr, bool)
488
489// Enables or disables overlay scrolling for this scrolled window.
490func (x *ScrolledWindow) SetOverlayScrolling(OverlayScrollingVar bool) {
491
492 xScrolledWindowSetOverlayScrolling(x.GoPointer(), OverlayScrollingVar)
493
494}
495
496var xScrolledWindowSetPlacement func(uintptr, CornerType)
497
498// Sets the placement of the contents with respect to the scrollbars
499// for the scrolled window.
500//
501// The default is %GTK_CORNER_TOP_LEFT, meaning the child is
502// in the top left, with the scrollbars underneath and to the right.
503// Other values in [enum@Gtk.CornerType] are %GTK_CORNER_TOP_RIGHT,
504// %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
505//
506// See also [method@Gtk.ScrolledWindow.get_placement] and
507// [method@Gtk.ScrolledWindow.unset_placement].
508func (x *ScrolledWindow) SetPlacement(WindowPlacementVar CornerType) {
509
510 xScrolledWindowSetPlacement(x.GoPointer(), WindowPlacementVar)
511
512}
513
514var xScrolledWindowSetPolicy func(uintptr, PolicyType, PolicyType)
515
516// Sets the scrollbar policy for the horizontal and vertical scrollbars.
517//
518// The policy determines when the scrollbar should appear; it is a value
519// from the [enum@Gtk.PolicyType] enumeration. If %GTK_POLICY_ALWAYS, the
520// scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
521// never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
522// if needed (that is, if the slider part of the bar would be smaller
523// than the trough — the display is larger than the page size).
524func (x *ScrolledWindow) SetPolicy(HscrollbarPolicyVar PolicyType, VscrollbarPolicyVar PolicyType) {
525
526 xScrolledWindowSetPolicy(x.GoPointer(), HscrollbarPolicyVar, VscrollbarPolicyVar)
527
528}
529
530var xScrolledWindowSetPropagateNaturalHeight func(uintptr, bool)
531
532// Sets whether the natural height of the child should be calculated
533// and propagated through the scrolled window’s requested natural height.
534func (x *ScrolledWindow) SetPropagateNaturalHeight(PropagateVar bool) {
535
536 xScrolledWindowSetPropagateNaturalHeight(x.GoPointer(), PropagateVar)
537
538}
539
540var xScrolledWindowSetPropagateNaturalWidth func(uintptr, bool)
541
542// Sets whether the natural width of the child should be calculated
543// and propagated through the scrolled window’s requested natural width.
544func (x *ScrolledWindow) SetPropagateNaturalWidth(PropagateVar bool) {
545
546 xScrolledWindowSetPropagateNaturalWidth(x.GoPointer(), PropagateVar)
547
548}
549
550var xScrolledWindowSetVadjustment func(uintptr, uintptr)
551
552// Sets the `GtkAdjustment` for the vertical scrollbar.
553func (x *ScrolledWindow) SetVadjustment(VadjustmentVar *Adjustment) {
554
555 xScrolledWindowSetVadjustment(x.GoPointer(), VadjustmentVar.GoPointer())
556
557}
558
559var xScrolledWindowUnsetPlacement func(uintptr)
560
561// Unsets the placement of the contents with respect to the scrollbars.
562//
563// If no window placement is set for a scrolled window,
564// it defaults to %GTK_CORNER_TOP_LEFT.
565func (x *ScrolledWindow) UnsetPlacement() {
566
567 xScrolledWindowUnsetPlacement(x.GoPointer())
568
569}
570
571func (c *ScrolledWindow) GoPointer() uintptr {
572 if c == nil {
573 return 0
574 }
575 return c.Ptr
576}
577
578func (c *ScrolledWindow) SetGoPointer(ptr uintptr) {
579 c.Ptr = ptr
580}
581
582// SetPropertyHasFrame sets the "has-frame" property.
583// Whether to draw a frame around the contents.
584func (x *ScrolledWindow) SetPropertyHasFrame(value bool) {
585 var v gobject.Value
586 v.Init(gobject.TypeBooleanVal)
587 v.SetBoolean(value)
588 x.SetProperty("has-frame", &v)
589}
590
591// GetPropertyHasFrame gets the "has-frame" property.
592// Whether to draw a frame around the contents.
593func (x *ScrolledWindow) GetPropertyHasFrame() bool {
594 var v gobject.Value
595 x.GetProperty("has-frame", &v)
596 return v.GetBoolean()
597}
598
599// SetPropertyKineticScrolling sets the "kinetic-scrolling" property.
600// Whether kinetic scrolling is enabled or not.
601//
602// Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
603func (x *ScrolledWindow) SetPropertyKineticScrolling(value bool) {
604 var v gobject.Value
605 v.Init(gobject.TypeBooleanVal)
606 v.SetBoolean(value)
607 x.SetProperty("kinetic-scrolling", &v)
608}
609
610// GetPropertyKineticScrolling gets the "kinetic-scrolling" property.
611// Whether kinetic scrolling is enabled or not.
612//
613// Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
614func (x *ScrolledWindow) GetPropertyKineticScrolling() bool {
615 var v gobject.Value
616 x.GetProperty("kinetic-scrolling", &v)
617 return v.GetBoolean()
618}
619
620// SetPropertyMaxContentHeight sets the "max-content-height" property.
621// The maximum content height of @scrolled_window.
622func (x *ScrolledWindow) SetPropertyMaxContentHeight(value int) {
623 var v gobject.Value
624 v.Init(gobject.TypeIntVal)
625 v.SetInt(value)
626 x.SetProperty("max-content-height", &v)
627}
628
629// GetPropertyMaxContentHeight gets the "max-content-height" property.
630// The maximum content height of @scrolled_window.
631func (x *ScrolledWindow) GetPropertyMaxContentHeight() int {
632 var v gobject.Value
633 x.GetProperty("max-content-height", &v)
634 return v.GetInt()
635}
636
637// SetPropertyMaxContentWidth sets the "max-content-width" property.
638// The maximum content width of @scrolled_window.
639func (x *ScrolledWindow) SetPropertyMaxContentWidth(value int) {
640 var v gobject.Value
641 v.Init(gobject.TypeIntVal)
642 v.SetInt(value)
643 x.SetProperty("max-content-width", &v)
644}
645
646// GetPropertyMaxContentWidth gets the "max-content-width" property.
647// The maximum content width of @scrolled_window.
648func (x *ScrolledWindow) GetPropertyMaxContentWidth() int {
649 var v gobject.Value
650 x.GetProperty("max-content-width", &v)
651 return v.GetInt()
652}
653
654// SetPropertyMinContentHeight sets the "min-content-height" property.
655// The minimum content height of @scrolled_window.
656func (x *ScrolledWindow) SetPropertyMinContentHeight(value int) {
657 var v gobject.Value
658 v.Init(gobject.TypeIntVal)
659 v.SetInt(value)
660 x.SetProperty("min-content-height", &v)
661}
662
663// GetPropertyMinContentHeight gets the "min-content-height" property.
664// The minimum content height of @scrolled_window.
665func (x *ScrolledWindow) GetPropertyMinContentHeight() int {
666 var v gobject.Value
667 x.GetProperty("min-content-height", &v)
668 return v.GetInt()
669}
670
671// SetPropertyMinContentWidth sets the "min-content-width" property.
672// The minimum content width of @scrolled_window.
673func (x *ScrolledWindow) SetPropertyMinContentWidth(value int) {
674 var v gobject.Value
675 v.Init(gobject.TypeIntVal)
676 v.SetInt(value)
677 x.SetProperty("min-content-width", &v)
678}
679
680// GetPropertyMinContentWidth gets the "min-content-width" property.
681// The minimum content width of @scrolled_window.
682func (x *ScrolledWindow) GetPropertyMinContentWidth() int {
683 var v gobject.Value
684 x.GetProperty("min-content-width", &v)
685 return v.GetInt()
686}
687
688// SetPropertyOverlayScrolling sets the "overlay-scrolling" property.
689// Whether overlay scrolling is enabled or not.
690//
691// If it is, the scrollbars are only added as traditional widgets
692// when a mouse is present. Otherwise, they are overlaid on top of
693// the content, as narrow indicators.
694//
695// Note that overlay scrolling can also be globally disabled, with
696// the [property@Gtk.Settings:gtk-overlay-scrolling] setting.
697func (x *ScrolledWindow) SetPropertyOverlayScrolling(value bool) {
698 var v gobject.Value
699 v.Init(gobject.TypeBooleanVal)
700 v.SetBoolean(value)
701 x.SetProperty("overlay-scrolling", &v)
702}
703
704// GetPropertyOverlayScrolling gets the "overlay-scrolling" property.
705// Whether overlay scrolling is enabled or not.
706//
707// If it is, the scrollbars are only added as traditional widgets
708// when a mouse is present. Otherwise, they are overlaid on top of
709// the content, as narrow indicators.
710//
711// Note that overlay scrolling can also be globally disabled, with
712// the [property@Gtk.Settings:gtk-overlay-scrolling] setting.
713func (x *ScrolledWindow) GetPropertyOverlayScrolling() bool {
714 var v gobject.Value
715 x.GetProperty("overlay-scrolling", &v)
716 return v.GetBoolean()
717}
718
719// SetPropertyPropagateNaturalHeight sets the "propagate-natural-height" property.
720// Whether the natural height of the child should be calculated and propagated
721// through the scrolled window’s requested natural height.
722//
723// This is useful in cases where an attempt should be made to allocate exactly
724// enough space for the natural size of the child.
725func (x *ScrolledWindow) SetPropertyPropagateNaturalHeight(value bool) {
726 var v gobject.Value
727 v.Init(gobject.TypeBooleanVal)
728 v.SetBoolean(value)
729 x.SetProperty("propagate-natural-height", &v)
730}
731
732// GetPropertyPropagateNaturalHeight gets the "propagate-natural-height" property.
733// Whether the natural height of the child should be calculated and propagated
734// through the scrolled window’s requested natural height.
735//
736// This is useful in cases where an attempt should be made to allocate exactly
737// enough space for the natural size of the child.
738func (x *ScrolledWindow) GetPropertyPropagateNaturalHeight() bool {
739 var v gobject.Value
740 x.GetProperty("propagate-natural-height", &v)
741 return v.GetBoolean()
742}
743
744// SetPropertyPropagateNaturalWidth sets the "propagate-natural-width" property.
745// Whether the natural width of the child should be calculated and propagated
746// through the scrolled window’s requested natural width.
747//
748// This is useful in cases where an attempt should be made to allocate exactly
749// enough space for the natural size of the child.
750func (x *ScrolledWindow) SetPropertyPropagateNaturalWidth(value bool) {
751 var v gobject.Value
752 v.Init(gobject.TypeBooleanVal)
753 v.SetBoolean(value)
754 x.SetProperty("propagate-natural-width", &v)
755}
756
757// GetPropertyPropagateNaturalWidth gets the "propagate-natural-width" property.
758// Whether the natural width of the child should be calculated and propagated
759// through the scrolled window’s requested natural width.
760//
761// This is useful in cases where an attempt should be made to allocate exactly
762// enough space for the natural size of the child.
763func (x *ScrolledWindow) GetPropertyPropagateNaturalWidth() bool {
764 var v gobject.Value
765 x.GetProperty("propagate-natural-width", &v)
766 return v.GetBoolean()
767}
768
769// Emitted whenever user initiated scrolling makes the scrolled
770// window firmly surpass the limits defined by the adjustment
771// in that orientation.
772//
773// A similar behavior without edge resistance is provided by the
774// [signal@Gtk.ScrolledWindow::edge-reached] signal.
775//
776// Note: The @pos argument is LTR/RTL aware, so callers should be
777// aware too if intending to provide behavior on horizontal edges.
778func (x *ScrolledWindow) ConnectEdgeOvershot(cb *func(ScrolledWindow, PositionType)) uint {
779 cbPtr := uintptr(unsafe.Pointer(cb))
780 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
781 handlerID := gobject.SignalConnect(x.GoPointer(), "edge-overshot", cbRefPtr)
782 glib.SaveHandlerMapping(handlerID, cbPtr)
783 return handlerID
784 }
785
786 fcb := func(clsPtr uintptr, PosVarp PositionType) {
787 fa := ScrolledWindow{}
788 fa.Ptr = clsPtr
789 cbFn := *cb
790
791 cbFn(fa, PosVarp)
792
793 }
794 cbRefPtr := purego.NewCallback(fcb)
795 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
796 handlerID := gobject.SignalConnect(x.GoPointer(), "edge-overshot", cbRefPtr)
797 glib.SaveHandlerMapping(handlerID, cbPtr)
798 return handlerID
799}
800
801// Emitted whenever user-initiated scrolling makes the scrolled
802// window exactly reach the lower or upper limits defined by the
803// adjustment in that orientation.
804//
805// A similar behavior with edge resistance is provided by the
806// [signal@Gtk.ScrolledWindow::edge-overshot] signal.
807//
808// Note: The @pos argument is LTR/RTL aware, so callers should be
809// aware too if intending to provide behavior on horizontal edges.
810func (x *ScrolledWindow) ConnectEdgeReached(cb *func(ScrolledWindow, PositionType)) uint {
811 cbPtr := uintptr(unsafe.Pointer(cb))
812 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
813 handlerID := gobject.SignalConnect(x.GoPointer(), "edge-reached", cbRefPtr)
814 glib.SaveHandlerMapping(handlerID, cbPtr)
815 return handlerID
816 }
817
818 fcb := func(clsPtr uintptr, PosVarp PositionType) {
819 fa := ScrolledWindow{}
820 fa.Ptr = clsPtr
821 cbFn := *cb
822
823 cbFn(fa, PosVarp)
824
825 }
826 cbRefPtr := purego.NewCallback(fcb)
827 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
828 handlerID := gobject.SignalConnect(x.GoPointer(), "edge-reached", cbRefPtr)
829 glib.SaveHandlerMapping(handlerID, cbPtr)
830 return handlerID
831}
832
833// Emitted when focus is moved away from the scrolled window by a
834// keybinding.
835//
836// This is a [keybinding signal](class.SignalAction.html).
837//
838// The default bindings for this signal are
839// <kbd>Ctrl</kbd>+<kbd>Tab</kbd> to move forward and
840// <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Tab</kbd>` to move backward.
841func (x *ScrolledWindow) ConnectMoveFocusOut(cb *func(ScrolledWindow, DirectionType)) uint {
842 cbPtr := uintptr(unsafe.Pointer(cb))
843 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
844 handlerID := gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
845 glib.SaveHandlerMapping(handlerID, cbPtr)
846 return handlerID
847 }
848
849 fcb := func(clsPtr uintptr, DirectionTypeVarp DirectionType) {
850 fa := ScrolledWindow{}
851 fa.Ptr = clsPtr
852 cbFn := *cb
853
854 cbFn(fa, DirectionTypeVarp)
855
856 }
857 cbRefPtr := purego.NewCallback(fcb)
858 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
859 handlerID := gobject.SignalConnect(x.GoPointer(), "move-focus-out", cbRefPtr)
860 glib.SaveHandlerMapping(handlerID, cbPtr)
861 return handlerID
862}
863
864// Emitted when a keybinding that scrolls is pressed.
865//
866// This is a [keybinding signal](class.SignalAction.html).
867//
868// The horizontal or vertical adjustment is updated which triggers a
869// signal that the scrolled window’s child may listen to and scroll itself.
870func (x *ScrolledWindow) ConnectScrollChild(cb *func(ScrolledWindow, ScrollType, bool) bool) uint {
871 cbPtr := uintptr(unsafe.Pointer(cb))
872 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
873 handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-child", cbRefPtr)
874 glib.SaveHandlerMapping(handlerID, cbPtr)
875 return handlerID
876 }
877
878 fcb := func(clsPtr uintptr, ScrollVarp ScrollType, HorizontalVarp bool) bool {
879 fa := ScrolledWindow{}
880 fa.Ptr = clsPtr
881 cbFn := *cb
882
883 return cbFn(fa, ScrollVarp, HorizontalVarp)
884
885 }
886 cbRefPtr := purego.NewCallback(fcb)
887 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
888 handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-child", cbRefPtr)
889 glib.SaveHandlerMapping(handlerID, cbPtr)
890 return handlerID
891}
892
893// Requests the user's screen reader to announce the given message.
894//
895// This kind of notification is useful for messages that
896// either have only a visual representation or that are not
897// exposed visually at all, e.g. a notification about a
898// successful operation.
899//
900// Also, by using this API, you can ensure that the message
901// does not interrupts the user's current screen reader output.
902func (x *ScrolledWindow) Announce(MessageVar string, PriorityVar AccessibleAnnouncementPriority) {
903
904 XGtkAccessibleAnnounce(x.GoPointer(), MessageVar, PriorityVar)
905
906}
907
908// Retrieves the accessible parent for an accessible object.
909//
910// This function returns `NULL` for top level widgets.
911func (x *ScrolledWindow) GetAccessibleParent() *AccessibleBase {
912 var cls *AccessibleBase
913
914 cret := XGtkAccessibleGetAccessibleParent(x.GoPointer())
915
916 if cret == 0 {
917 return nil
918 }
919 cls = &AccessibleBase{}
920 cls.Ptr = cret
921 return cls
922}
923
924// Retrieves the accessible role of an accessible object.
925func (x *ScrolledWindow) GetAccessibleRole() AccessibleRole {
926
927 cret := XGtkAccessibleGetAccessibleRole(x.GoPointer())
928 return cret
929}
930
931// Retrieves the implementation for the given accessible object.
932func (x *ScrolledWindow) GetAtContext() *ATContext {
933 var cls *ATContext
934
935 cret := XGtkAccessibleGetAtContext(x.GoPointer())
936
937 if cret == 0 {
938 return nil
939 }
940 cls = &ATContext{}
941 cls.Ptr = cret
942 return cls
943}
944
945// Queries the coordinates and dimensions of this accessible
946//
947// This functionality can be overridden by `GtkAccessible`
948// implementations, e.g. to get the bounds from an ignored
949// child widget.
950func (x *ScrolledWindow) GetBounds(XVar *int, YVar *int, WidthVar *int, HeightVar *int) bool {
951
952 cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
953 return cret
954}
955
956// Retrieves the first accessible child of an accessible object.
957func (x *ScrolledWindow) GetFirstAccessibleChild() *AccessibleBase {
958 var cls *AccessibleBase
959
960 cret := XGtkAccessibleGetFirstAccessibleChild(x.GoPointer())
961
962 if cret == 0 {
963 return nil
964 }
965 cls = &AccessibleBase{}
966 cls.Ptr = cret
967 return cls
968}
969
970// Retrieves the next accessible sibling of an accessible object
971func (x *ScrolledWindow) GetNextAccessibleSibling() *AccessibleBase {
972 var cls *AccessibleBase
973
974 cret := XGtkAccessibleGetNextAccessibleSibling(x.GoPointer())
975
976 if cret == 0 {
977 return nil
978 }
979 cls = &AccessibleBase{}
980 cls.Ptr = cret
981 return cls
982}
983
984// Queries a platform state, such as focus.
985//
986// This functionality can be overridden by `GtkAccessible`
987// implementations, e.g. to get platform state from an ignored
988// child widget, as is the case for `GtkText` wrappers.
989func (x *ScrolledWindow) GetPlatformState(StateVar AccessiblePlatformState) bool {
990
991 cret := XGtkAccessibleGetPlatformState(x.GoPointer(), StateVar)
992 return cret
993}
994
995// Resets the accessible property to its default value.
996func (x *ScrolledWindow) ResetProperty(PropertyVar AccessibleProperty) {
997
998 XGtkAccessibleResetProperty(x.GoPointer(), PropertyVar)
999
1000}
1001
1002// Resets the accessible relation to its default value.
1003func (x *ScrolledWindow) ResetRelation(RelationVar AccessibleRelation) {
1004
1005 XGtkAccessibleResetRelation(x.GoPointer(), RelationVar)
1006
1007}
1008
1009// Resets the accessible state to its default value.
1010func (x *ScrolledWindow) ResetState(StateVar AccessibleState) {
1011
1012 XGtkAccessibleResetState(x.GoPointer(), StateVar)
1013
1014}
1015
1016// Sets the parent and sibling of an accessible object.
1017//
1018// This function is meant to be used by accessible implementations that are
1019// not part of the widget hierarchy, and but act as a logical bridge between
1020// widgets. For instance, if a widget creates an object that holds metadata
1021// for each child, and you want that object to implement the `GtkAccessible`
1022// interface, you will use this function to ensure that the parent of each
1023// child widget is the metadata object, and the parent of each metadata
1024// object is the container widget.
1025func (x *ScrolledWindow) SetAccessibleParent(ParentVar Accessible, NextSiblingVar Accessible) {
1026
1027 XGtkAccessibleSetAccessibleParent(x.GoPointer(), ParentVar.GoPointer(), NextSiblingVar.GoPointer())
1028
1029}
1030
1031// Updates the next accessible sibling.
1032//
1033// That might be useful when a new child of a custom accessible
1034// is created, and it needs to be linked to a previous child.
1035func (x *ScrolledWindow) UpdateNextAccessibleSibling(NewSiblingVar Accessible) {
1036
1037 XGtkAccessibleUpdateNextAccessibleSibling(x.GoPointer(), NewSiblingVar.GoPointer())
1038
1039}
1040
1041// Informs ATs that the platform state has changed.
1042//
1043// This function should be used by `GtkAccessible` implementations that
1044// have a platform state but are not widgets. Widgets handle platform
1045// states automatically.
1046func (x *ScrolledWindow) UpdatePlatformState(StateVar AccessiblePlatformState) {
1047
1048 XGtkAccessibleUpdatePlatformState(x.GoPointer(), StateVar)
1049
1050}
1051
1052// Updates a list of accessible properties.
1053//
1054// See the [enum@Gtk.AccessibleProperty] documentation for the
1055// value types of accessible properties.
1056//
1057// This function should be called by `GtkWidget` types whenever
1058// an accessible property change must be communicated to assistive
1059// technologies.
1060//
1061// Example:
1062// ```c
1063// value = gtk_adjustment_get_value (adjustment);
1064// gtk_accessible_update_property (GTK_ACCESSIBLE (spin_button),
1065//
1066// GTK_ACCESSIBLE_PROPERTY_VALUE_NOW, value,
1067// -1);
1068//
1069// ```
1070func (x *ScrolledWindow) UpdateProperty(FirstPropertyVar AccessibleProperty, varArgs ...interface{}) {
1071
1072 XGtkAccessibleUpdateProperty(x.GoPointer(), FirstPropertyVar, varArgs...)
1073
1074}
1075
1076// Updates an array of accessible properties.
1077//
1078// This function should be called by `GtkWidget` types whenever an accessible
1079// property change must be communicated to assistive technologies.
1080//
1081// This function is meant to be used by language bindings.
1082func (x *ScrolledWindow) UpdatePropertyValue(NPropertiesVar int, PropertiesVar []AccessibleProperty, ValuesVar []gobject.Value) {
1083
1084 XGtkAccessibleUpdatePropertyValue(x.GoPointer(), NPropertiesVar, PropertiesVar, ValuesVar)
1085
1086}
1087
1088// Updates a list of accessible relations.
1089//
1090// This function should be called by `GtkWidget` types whenever an accessible
1091// relation change must be communicated to assistive technologies.
1092//
1093// If the [enum@Gtk.AccessibleRelation] requires a list of references,
1094// you should pass each reference individually, followed by `NULL`, e.g.
1095//
1096// ```c
1097// gtk_accessible_update_relation (accessible,
1098//
1099// GTK_ACCESSIBLE_RELATION_CONTROLS,
1100// ref1, NULL,
1101// GTK_ACCESSIBLE_RELATION_LABELLED_BY,
1102// ref1, ref2, ref3, NULL,
1103// -1);
1104//
1105// ```
1106func (x *ScrolledWindow) UpdateRelation(FirstRelationVar AccessibleRelation, varArgs ...interface{}) {
1107
1108 XGtkAccessibleUpdateRelation(x.GoPointer(), FirstRelationVar, varArgs...)
1109
1110}
1111
1112// Updates an array of accessible relations.
1113//
1114// This function should be called by `GtkWidget` types whenever an accessible
1115// relation change must be communicated to assistive technologies.
1116//
1117// This function is meant to be used by language bindings.
1118func (x *ScrolledWindow) UpdateRelationValue(NRelationsVar int, RelationsVar []AccessibleRelation, ValuesVar []gobject.Value) {
1119
1120 XGtkAccessibleUpdateRelationValue(x.GoPointer(), NRelationsVar, RelationsVar, ValuesVar)
1121
1122}
1123
1124// Updates a list of accessible states.
1125//
1126// See the [enum@Gtk.AccessibleState] documentation for the
1127// value types of accessible states.
1128//
1129// This function should be called by `GtkWidget` types whenever
1130// an accessible state change must be communicated to assistive
1131// technologies.
1132//
1133// Example:
1134//
1135// ```c
1136// value = GTK_ACCESSIBLE_TRISTATE_MIXED;
1137// gtk_accessible_update_state (GTK_ACCESSIBLE (check_button),
1138//
1139// GTK_ACCESSIBLE_STATE_CHECKED, value,
1140// -1);
1141//
1142// ```
1143func (x *ScrolledWindow) UpdateState(FirstStateVar AccessibleState, varArgs ...interface{}) {
1144
1145 XGtkAccessibleUpdateState(x.GoPointer(), FirstStateVar, varArgs...)
1146
1147}
1148
1149// Updates an array of accessible states.
1150//
1151// This function should be called by `GtkWidget` types whenever an accessible
1152// state change must be communicated to assistive technologies.
1153//
1154// This function is meant to be used by language bindings.
1155func (x *ScrolledWindow) UpdateStateValue(NStatesVar int, StatesVar []AccessibleState, ValuesVar []gobject.Value) {
1156
1157 XGtkAccessibleUpdateStateValue(x.GoPointer(), NStatesVar, StatesVar, ValuesVar)
1158
1159}
1160
1161// Gets the ID of the @buildable object.
1162//
1163// `GtkBuilder` sets the name based on the ID attribute
1164// of the `<object>` tag used to construct the @buildable.
1165func (x *ScrolledWindow) GetBuildableId() string {
1166
1167 cret := XGtkBuildableGetBuildableId(x.GoPointer())
1168 return cret
1169}
1170
1171func init() {
1172 core.SetPackageName("GTK", "gtk4")
1173 core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})
1174 var libs []uintptr
1175 for _, libPath := range core.GetPaths("GTK") {
1176 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
1177 if err != nil {
1178 panic(err)
1179 }
1180 libs = append(libs, lib)
1181 }
1182
1183 core.PuregoSafeRegister(&xCornerTypeGLibType, libs, "gtk_corner_type_get_type")
1184
1185 core.PuregoSafeRegister(&xPolicyTypeGLibType, libs, "gtk_policy_type_get_type")
1186
1187 core.PuregoSafeRegister(&xScrolledWindowGLibType, libs, "gtk_scrolled_window_get_type")
1188
1189 core.PuregoSafeRegister(&xNewScrolledWindow, libs, "gtk_scrolled_window_new")
1190
1191 core.PuregoSafeRegister(&xScrolledWindowGetChild, libs, "gtk_scrolled_window_get_child")
1192 core.PuregoSafeRegister(&xScrolledWindowGetHadjustment, libs, "gtk_scrolled_window_get_hadjustment")
1193 core.PuregoSafeRegister(&xScrolledWindowGetHasFrame, libs, "gtk_scrolled_window_get_has_frame")
1194 core.PuregoSafeRegister(&xScrolledWindowGetHscrollbar, libs, "gtk_scrolled_window_get_hscrollbar")
1195 core.PuregoSafeRegister(&xScrolledWindowGetKineticScrolling, libs, "gtk_scrolled_window_get_kinetic_scrolling")
1196 core.PuregoSafeRegister(&xScrolledWindowGetMaxContentHeight, libs, "gtk_scrolled_window_get_max_content_height")
1197 core.PuregoSafeRegister(&xScrolledWindowGetMaxContentWidth, libs, "gtk_scrolled_window_get_max_content_width")
1198 core.PuregoSafeRegister(&xScrolledWindowGetMinContentHeight, libs, "gtk_scrolled_window_get_min_content_height")
1199 core.PuregoSafeRegister(&xScrolledWindowGetMinContentWidth, libs, "gtk_scrolled_window_get_min_content_width")
1200 core.PuregoSafeRegister(&xScrolledWindowGetOverlayScrolling, libs, "gtk_scrolled_window_get_overlay_scrolling")
1201 core.PuregoSafeRegister(&xScrolledWindowGetPlacement, libs, "gtk_scrolled_window_get_placement")
1202 core.PuregoSafeRegister(&xScrolledWindowGetPolicy, libs, "gtk_scrolled_window_get_policy")
1203 core.PuregoSafeRegister(&xScrolledWindowGetPropagateNaturalHeight, libs, "gtk_scrolled_window_get_propagate_natural_height")
1204 core.PuregoSafeRegister(&xScrolledWindowGetPropagateNaturalWidth, libs, "gtk_scrolled_window_get_propagate_natural_width")
1205 core.PuregoSafeRegister(&xScrolledWindowGetVadjustment, libs, "gtk_scrolled_window_get_vadjustment")
1206 core.PuregoSafeRegister(&xScrolledWindowGetVscrollbar, libs, "gtk_scrolled_window_get_vscrollbar")
1207 core.PuregoSafeRegister(&xScrolledWindowSetChild, libs, "gtk_scrolled_window_set_child")
1208 core.PuregoSafeRegister(&xScrolledWindowSetHadjustment, libs, "gtk_scrolled_window_set_hadjustment")
1209 core.PuregoSafeRegister(&xScrolledWindowSetHasFrame, libs, "gtk_scrolled_window_set_has_frame")
1210 core.PuregoSafeRegister(&xScrolledWindowSetKineticScrolling, libs, "gtk_scrolled_window_set_kinetic_scrolling")
1211 core.PuregoSafeRegister(&xScrolledWindowSetMaxContentHeight, libs, "gtk_scrolled_window_set_max_content_height")
1212 core.PuregoSafeRegister(&xScrolledWindowSetMaxContentWidth, libs, "gtk_scrolled_window_set_max_content_width")
1213 core.PuregoSafeRegister(&xScrolledWindowSetMinContentHeight, libs, "gtk_scrolled_window_set_min_content_height")
1214 core.PuregoSafeRegister(&xScrolledWindowSetMinContentWidth, libs, "gtk_scrolled_window_set_min_content_width")
1215 core.PuregoSafeRegister(&xScrolledWindowSetOverlayScrolling, libs, "gtk_scrolled_window_set_overlay_scrolling")
1216 core.PuregoSafeRegister(&xScrolledWindowSetPlacement, libs, "gtk_scrolled_window_set_placement")
1217 core.PuregoSafeRegister(&xScrolledWindowSetPolicy, libs, "gtk_scrolled_window_set_policy")
1218 core.PuregoSafeRegister(&xScrolledWindowSetPropagateNaturalHeight, libs, "gtk_scrolled_window_set_propagate_natural_height")
1219 core.PuregoSafeRegister(&xScrolledWindowSetPropagateNaturalWidth, libs, "gtk_scrolled_window_set_propagate_natural_width")
1220 core.PuregoSafeRegister(&xScrolledWindowSetVadjustment, libs, "gtk_scrolled_window_set_vadjustment")
1221 core.PuregoSafeRegister(&xScrolledWindowUnsetPlacement, libs, "gtk_scrolled_window_unset_placement")
1222
1223}