1// Package gtk was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gtk
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/glib"
13 "github.com/bnema/puregotk/v4/gobject"
14 "github.com/bnema/puregotk/v4/gobject/types"
15)
16
17type EventControllerScrollClass struct {
18 _ structs.HostLayout
19}
20
21func (x *EventControllerScrollClass) GoPointer() uintptr {
22 return uintptr(unsafe.Pointer(x))
23}
24
25// Describes the behavior of a `GtkEventControllerScroll`.
26type EventControllerScrollFlags int
27
28var xEventControllerScrollFlagsGLibType func() types.GType
29
30func EventControllerScrollFlagsGLibType() types.GType {
31 return xEventControllerScrollFlagsGLibType()
32}
33
34const (
35
36 // Don't emit scroll.
37 EventControllerScrollNoneValue EventControllerScrollFlags = 0
38 // Emit scroll with vertical deltas.
39 EventControllerScrollVerticalValue EventControllerScrollFlags = 1
40 // Emit scroll with horizontal deltas.
41 EventControllerScrollHorizontalValue EventControllerScrollFlags = 2
42 // Only emit deltas that are multiples of 1.
43 EventControllerScrollDiscreteValue EventControllerScrollFlags = 4
44 // Emit ::decelerate after continuous scroll finishes.
45 EventControllerScrollKineticValue EventControllerScrollFlags = 8
46 // A #GtkEventControllerScrollFlags value to prefer physical direction over
47 // logical direction (i.e. oblivious to natural scroll).
48 EventControllerScrollPhysicalDirectionValue EventControllerScrollFlags = 16
49 // Emit scroll on both axes.
50 EventControllerScrollBothAxesValue EventControllerScrollFlags = 3
51)
52
53// Handles scroll events.
54//
55// It is capable of handling both discrete and continuous scroll
56// events from mice or touchpads, abstracting them both with the
57// [signal@Gtk.EventControllerScroll::scroll] signal. Deltas in
58// the discrete case are multiples of 1.
59//
60// In the case of continuous scroll events, `GtkEventControllerScroll`
61// encloses all [signal@Gtk.EventControllerScroll::scroll] emissions
62// between two [signal@Gtk.EventControllerScroll::scroll-begin] and
63// [signal@Gtk.EventControllerScroll::scroll-end] signals.
64//
65// The behavior of the event controller can be modified by the flags
66// given at creation time, or modified at a later point through
67// [method@Gtk.EventControllerScroll.set_flags] (e.g. because the scrolling
68// conditions of the widget changed).
69//
70// The controller can be set up to emit motion for either/both vertical
71// and horizontal scroll events through %GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
72// %GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and %GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES.
73// If any axis is disabled, the respective [signal@Gtk.EventControllerScroll::scroll]
74// delta will be 0. Vertical scroll events will be translated to horizontal
75// motion for the devices incapable of horizontal scrolling.
76//
77// The event controller can also be forced to emit discrete events on all
78// devices through %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used
79// to implement discrete actions triggered through scroll events (e.g.
80// switching across combobox options).
81//
82// The %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the
83// [signal@Gtk.EventControllerScroll::decelerate] signal, emitted at the end
84// of scrolling with two X/Y velocity arguments that are consistent with the
85// motion that was received.
86type EventControllerScroll struct {
87 EventController
88}
89
90var xEventControllerScrollGLibType func() types.GType
91
92func EventControllerScrollGLibType() types.GType {
93 return xEventControllerScrollGLibType()
94}
95
96func EventControllerScrollNewFromInternalPtr(ptr uintptr) *EventControllerScroll {
97 cls := &EventControllerScroll{}
98 cls.Ptr = ptr
99 return cls
100}
101
102var xNewEventControllerScroll func(EventControllerScrollFlags) uintptr
103
104// Creates a new event controller that will handle scroll events.
105func NewEventControllerScroll(FlagsVar EventControllerScrollFlags) *EventControllerScroll {
106 var cls *EventControllerScroll
107
108 cret := xNewEventControllerScroll(FlagsVar)
109
110 if cret == 0 {
111 return nil
112 }
113 cls = &EventControllerScroll{}
114 cls.Ptr = cret
115 return cls
116}
117
118var xEventControllerScrollGetFlags func(uintptr) EventControllerScrollFlags
119
120// Gets the flags conditioning the scroll controller behavior.
121func (x *EventControllerScroll) GetFlags() EventControllerScrollFlags {
122
123 cret := xEventControllerScrollGetFlags(x.GoPointer())
124 return cret
125}
126
127var xEventControllerScrollGetUnit func(uintptr) gdk.ScrollUnit
128
129// Gets the scroll unit of the last
130// [signal@Gtk.EventControllerScroll::scroll] signal received.
131//
132// Always returns %GDK_SCROLL_UNIT_WHEEL if the
133// %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag is set.
134func (x *EventControllerScroll) GetUnit() gdk.ScrollUnit {
135
136 cret := xEventControllerScrollGetUnit(x.GoPointer())
137 return cret
138}
139
140var xEventControllerScrollSetFlags func(uintptr, EventControllerScrollFlags)
141
142// Sets the flags conditioning scroll controller behavior.
143func (x *EventControllerScroll) SetFlags(FlagsVar EventControllerScrollFlags) {
144
145 xEventControllerScrollSetFlags(x.GoPointer(), FlagsVar)
146
147}
148
149func (c *EventControllerScroll) GoPointer() uintptr {
150 if c == nil {
151 return 0
152 }
153 return c.Ptr
154}
155
156func (c *EventControllerScroll) SetGoPointer(ptr uintptr) {
157 c.Ptr = ptr
158}
159
160// Emitted after scroll is finished if the
161// %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag is set.
162//
163// @vel_x and @vel_y express the initial velocity that was
164// imprinted by the scroll events. @vel_x and @vel_y are expressed in
165// pixels/ms.
166func (x *EventControllerScroll) ConnectDecelerate(cb *func(EventControllerScroll, float64, float64)) uint {
167 cbPtr := uintptr(unsafe.Pointer(cb))
168 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
169 handlerID := gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
170 glib.SaveHandlerMapping(handlerID, cbPtr)
171 return handlerID
172 }
173
174 fcb := func(clsPtr uintptr, VelXVarp float64, VelYVarp float64) {
175 fa := EventControllerScroll{}
176 fa.Ptr = clsPtr
177 cbFn := *cb
178
179 cbFn(fa, VelXVarp, VelYVarp)
180
181 }
182 cbRefPtr := purego.NewCallback(fcb)
183 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
184 handlerID := gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
185 glib.SaveHandlerMapping(handlerID, cbPtr)
186 return handlerID
187}
188
189// Signals that the widget should scroll by the
190// amount specified by @dx and @dy.
191//
192// For the representation unit of the deltas, see
193// [method@Gtk.EventControllerScroll.get_unit].
194func (x *EventControllerScroll) ConnectScroll(cb *func(EventControllerScroll, float64, float64) bool) uint {
195 cbPtr := uintptr(unsafe.Pointer(cb))
196 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
197 handlerID := gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
198 glib.SaveHandlerMapping(handlerID, cbPtr)
199 return handlerID
200 }
201
202 fcb := func(clsPtr uintptr, DxVarp float64, DyVarp float64) bool {
203 fa := EventControllerScroll{}
204 fa.Ptr = clsPtr
205 cbFn := *cb
206
207 return cbFn(fa, DxVarp, DyVarp)
208
209 }
210 cbRefPtr := purego.NewCallback(fcb)
211 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
212 handlerID := gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
213 glib.SaveHandlerMapping(handlerID, cbPtr)
214 return handlerID
215}
216
217// Signals that a new scrolling operation has begun.
218//
219// It will only be emitted on devices capable of it.
220func (x *EventControllerScroll) ConnectScrollBegin(cb *func(EventControllerScroll)) uint {
221 cbPtr := uintptr(unsafe.Pointer(cb))
222 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
223 handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
224 glib.SaveHandlerMapping(handlerID, cbPtr)
225 return handlerID
226 }
227
228 fcb := func(clsPtr uintptr) {
229 fa := EventControllerScroll{}
230 fa.Ptr = clsPtr
231 cbFn := *cb
232
233 cbFn(fa)
234
235 }
236 cbRefPtr := purego.NewCallback(fcb)
237 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
238 handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
239 glib.SaveHandlerMapping(handlerID, cbPtr)
240 return handlerID
241}
242
243// Signals that a scrolling operation has finished.
244//
245// It will only be emitted on devices capable of it.
246func (x *EventControllerScroll) ConnectScrollEnd(cb *func(EventControllerScroll)) uint {
247 cbPtr := uintptr(unsafe.Pointer(cb))
248 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
249 handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
250 glib.SaveHandlerMapping(handlerID, cbPtr)
251 return handlerID
252 }
253
254 fcb := func(clsPtr uintptr) {
255 fa := EventControllerScroll{}
256 fa.Ptr = clsPtr
257 cbFn := *cb
258
259 cbFn(fa)
260
261 }
262 cbRefPtr := purego.NewCallback(fcb)
263 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
264 handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
265 glib.SaveHandlerMapping(handlerID, cbPtr)
266 return handlerID
267}
268
269func init() {
270 core.SetPackageName("GTK", "gtk4")
271 core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})
272 var libs []uintptr
273 for _, libPath := range core.GetPaths("GTK") {
274 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
275 if err != nil {
276 panic(err)
277 }
278 libs = append(libs, lib)
279 }
280
281 core.PuregoSafeRegister(&xEventControllerScrollFlagsGLibType, libs, "gtk_event_controller_scroll_flags_get_type")
282
283 core.PuregoSafeRegister(&xEventControllerScrollGLibType, libs, "gtk_event_controller_scroll_get_type")
284
285 core.PuregoSafeRegister(&xNewEventControllerScroll, libs, "gtk_event_controller_scroll_new")
286
287 core.PuregoSafeRegister(&xEventControllerScrollGetFlags, libs, "gtk_event_controller_scroll_get_flags")
288 core.PuregoSafeRegister(&xEventControllerScrollGetUnit, libs, "gtk_event_controller_scroll_get_unit")
289 core.PuregoSafeRegister(&xEventControllerScrollSetFlags, libs, "gtk_event_controller_scroll_set_flags")
290
291}