1// Package gdk was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gdk
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/gobject"
12 "github.com/bnema/puregotk/v4/gobject/types"
13)
14
15// An opaque type representing a sequence of related events.
16type EventSequence struct {
17 _ structs.HostLayout
18}
19
20var xEventSequenceGLibType func() types.GType
21
22func EventSequenceGLibType() types.GType {
23 return xEventSequenceGLibType()
24}
25
26func (x *EventSequence) GoPointer() uintptr {
27 return uintptr(unsafe.Pointer(x))
28}
29
30const (
31 // The middle button.
32 BUTTON_MIDDLE int = 2
33 // The primary button. This is typically the left mouse button, or the
34 // right button in a left-handed setup.
35 BUTTON_PRIMARY int = 1
36 // The secondary button. This is typically the right mouse button, or the
37 // left button in a left-handed setup.
38 BUTTON_SECONDARY int = 3
39 // Use this macro as the return value for continuing the propagation of
40 // an event handler.
41 EVENT_PROPAGATE bool = false
42 // Use this macro as the return value for stopping the propagation of
43 // an event handler.
44 EVENT_STOP bool = true
45 // This is the priority that the idle handler processing surface updates
46 // is given in the main loop.
47 PRIORITY_REDRAW int = 120
48)
49
50// Specifies the crossing mode for enter and leave events.
51type CrossingMode int
52
53var xCrossingModeGLibType func() types.GType
54
55func CrossingModeGLibType() types.GType {
56 return xCrossingModeGLibType()
57}
58
59const (
60
61 // crossing because of pointer motion.
62 CrossingNormalValue CrossingMode = 0
63 // crossing because a grab is activated.
64 CrossingGrabValue CrossingMode = 1
65 // crossing because a grab is deactivated.
66 CrossingUngrabValue CrossingMode = 2
67 // crossing because a GTK grab is activated.
68 CrossingGtkGrabValue CrossingMode = 3
69 // crossing because a GTK grab is deactivated.
70 CrossingGtkUngrabValue CrossingMode = 4
71 // crossing because a GTK widget changed
72 // state (e.g. sensitivity).
73 CrossingStateChangedValue CrossingMode = 5
74 // crossing because a touch sequence has begun,
75 // this event is synthetic as the pointer might have not left the surface.
76 CrossingTouchBeginValue CrossingMode = 6
77 // crossing because a touch sequence has ended,
78 // this event is synthetic as the pointer might have not left the surface.
79 CrossingTouchEndValue CrossingMode = 7
80 // crossing because of a device switch (i.e.
81 // a mouse taking control of the pointer after a touch device), this event
82 // is synthetic as the pointer didn’t leave the surface.
83 CrossingDeviceSwitchValue CrossingMode = 8
84)
85
86// Specifies the type of the event.
87type EventType int
88
89var xEventTypeGLibType func() types.GType
90
91func EventTypeGLibType() types.GType {
92 return xEventTypeGLibType()
93}
94
95const (
96
97 // the window manager has requested that the toplevel surface be
98 // hidden or destroyed, usually when the user clicks on a special icon in the
99 // title bar.
100 DeleteValue EventType = 0
101 // the pointer (usually a mouse) has moved.
102 MotionNotifyValue EventType = 1
103 // a mouse button has been pressed.
104 ButtonPressValue EventType = 2
105 // a mouse button has been released.
106 ButtonReleaseValue EventType = 3
107 // a key has been pressed.
108 KeyPressValue EventType = 4
109 // a key has been released.
110 KeyReleaseValue EventType = 5
111 // the pointer has entered the surface.
112 EnterNotifyValue EventType = 6
113 // the pointer has left the surface.
114 LeaveNotifyValue EventType = 7
115 // the keyboard focus has entered or left the surface.
116 FocusChangeValue EventType = 8
117 // an input device has moved into contact with a sensing
118 // surface (e.g. a touchscreen or graphics tablet).
119 ProximityInValue EventType = 9
120 // an input device has moved out of contact with a sensing
121 // surface.
122 ProximityOutValue EventType = 10
123 // the mouse has entered the surface while a drag is in progress.
124 DragEnterValue EventType = 11
125 // the mouse has left the surface while a drag is in progress.
126 DragLeaveValue EventType = 12
127 // the mouse has moved in the surface while a drag is in
128 // progress.
129 DragMotionValue EventType = 13
130 // a drop operation onto the surface has started.
131 DropStartValue EventType = 14
132 // the scroll wheel was turned
133 ScrollValue EventType = 15
134 // a pointer or keyboard grab was broken.
135 GrabBrokenValue EventType = 16
136 // A new touch event sequence has just started.
137 TouchBeginValue EventType = 17
138 // A touch event sequence has been updated.
139 TouchUpdateValue EventType = 18
140 // A touch event sequence has finished.
141 TouchEndValue EventType = 19
142 // A touch event sequence has been canceled.
143 TouchCancelValue EventType = 20
144 // A touchpad swipe gesture event, the current state
145 // is determined by its phase field.
146 TouchpadSwipeValue EventType = 21
147 // A touchpad pinch gesture event, the current state
148 // is determined by its phase field.
149 TouchpadPinchValue EventType = 22
150 // A tablet pad button press event.
151 PadButtonPressValue EventType = 23
152 // A tablet pad button release event.
153 PadButtonReleaseValue EventType = 24
154 // A tablet pad axis event from a "ring".
155 PadRingValue EventType = 25
156 // A tablet pad axis event from a "strip".
157 PadStripValue EventType = 26
158 // A tablet pad group mode change.
159 PadGroupModeValue EventType = 27
160 // A touchpad hold gesture event, the current state is determined by its phase
161 // field.
162 TouchpadHoldValue EventType = 28
163 // A tablet pad axis event from a "dial".
164 PadDialValue EventType = 29
165 // marks the end of the GdkEventType enumeration.
166 EventLastValue EventType = 30
167)
168
169// Describes how well an event matches a given keyval and modifiers.
170//
171// `GdkKeyMatch` values are returned by [method@Gdk.KeyEvent.matches].
172type KeyMatch int
173
174var xKeyMatchGLibType func() types.GType
175
176func KeyMatchGLibType() types.GType {
177 return xKeyMatchGLibType()
178}
179
180const (
181
182 // The key event does not match
183 KeyMatchNoneValue KeyMatch = 0
184 // The key event matches if keyboard state
185 // (specifically, the currently active group) is ignored
186 KeyMatchPartialValue KeyMatch = 1
187 // The key event matches
188 KeyMatchExactValue KeyMatch = 2
189)
190
191// Specifies the kind of crossing for enter and leave events.
192//
193// See the X11 protocol specification of LeaveNotify for
194// full details of crossing event generation.
195type NotifyType int
196
197var xNotifyTypeGLibType func() types.GType
198
199func NotifyTypeGLibType() types.GType {
200 return xNotifyTypeGLibType()
201}
202
203const (
204
205 // the surface is entered from an ancestor or
206 // left towards an ancestor.
207 NotifyAncestorValue NotifyType = 0
208 // the pointer moves between an ancestor and an
209 // inferior of the surface.
210 NotifyVirtualValue NotifyType = 1
211 // the surface is entered from an inferior or
212 // left towards an inferior.
213 NotifyInferiorValue NotifyType = 2
214 // the surface is entered from or left towards
215 // a surface which is neither an ancestor nor an inferior.
216 NotifyNonlinearValue NotifyType = 3
217 // the pointer moves between two surfaces
218 // which are not ancestors of each other and the surface is part of
219 // the ancestor chain between one of these surfaces and their least
220 // common ancestor.
221 NotifyNonlinearVirtualValue NotifyType = 4
222 // an unknown type of enter/leave event occurred.
223 NotifyUnknownValue NotifyType = 5
224)
225
226// Specifies the direction for scroll events.
227type ScrollDirection int
228
229var xScrollDirectionGLibType func() types.GType
230
231func ScrollDirectionGLibType() types.GType {
232 return xScrollDirectionGLibType()
233}
234
235const (
236
237 // the surface is scrolled up.
238 ScrollUpValue ScrollDirection = 0
239 // the surface is scrolled down.
240 ScrollDownValue ScrollDirection = 1
241 // the surface is scrolled to the left.
242 ScrollLeftValue ScrollDirection = 2
243 // the surface is scrolled to the right.
244 ScrollRightValue ScrollDirection = 3
245 // the scrolling is determined by the delta values
246 // in scroll events. See gdk_scroll_event_get_deltas()
247 ScrollSmoothValue ScrollDirection = 4
248)
249
250// Specifies the unit of scroll deltas.
251//
252// When you get %GDK_SCROLL_UNIT_WHEEL, a delta of 1.0 means 1 wheel detent
253// click in the south direction, 2.0 means 2 wheel detent clicks in the south
254// direction... This is the same logic for negative values but in the north
255// direction.
256//
257// If you get %GDK_SCROLL_UNIT_SURFACE, are managing a scrollable view and get a
258// value of 123, you have to scroll 123 surface logical pixels right if it's
259// @delta_x or down if it's @delta_y. This is the same logic for negative values
260// but you have to scroll left instead of right if it's @delta_x and up instead
261// of down if it's @delta_y.
262//
263// 1 surface logical pixel is equal to 1 real screen pixel multiplied by the
264// final scale factor of your graphical interface (the product of the desktop
265// scale factor and eventually a custom scale factor in your app).
266type ScrollUnit int
267
268var xScrollUnitGLibType func() types.GType
269
270func ScrollUnitGLibType() types.GType {
271 return xScrollUnitGLibType()
272}
273
274const (
275
276 // The delta is in number of wheel clicks.
277 ScrollUnitWheelValue ScrollUnit = 0
278 // The delta is in surface pixels to scroll directly
279 // on screen.
280 ScrollUnitSurfaceValue ScrollUnit = 1
281)
282
283// Specifies the current state of a touchpad gesture.
284//
285// All gestures are guaranteed to begin with an event with phase
286// %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN, followed by 0 or several events
287// with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.
288//
289// A finished gesture may have 2 possible outcomes, an event with phase
290// %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
291// considered successful, this should be used as the hint to perform any
292// permanent changes.
293//
294// Cancelled gestures may be so for a variety of reasons, due to hardware
295// or the compositor, or due to the gesture recognition layers hinting the
296// gesture did not finish resolutely (eg. a 3rd finger being added during
297// a pinch gesture). In these cases, the last event will report the phase
298// %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
299// to undo any visible/permanent changes that were done throughout the
300// progress of the gesture.
301type TouchpadGesturePhase int
302
303var xTouchpadGesturePhaseGLibType func() types.GType
304
305func TouchpadGesturePhaseGLibType() types.GType {
306 return xTouchpadGesturePhaseGLibType()
307}
308
309const (
310
311 // The gesture has begun.
312 TouchpadGesturePhaseBeginValue TouchpadGesturePhase = 0
313 // The gesture has been updated.
314 TouchpadGesturePhaseUpdateValue TouchpadGesturePhase = 1
315 // The gesture was finished, changes
316 // should be permanently applied.
317 TouchpadGesturePhaseEndValue TouchpadGesturePhase = 2
318 // The gesture was cancelled, all
319 // changes should be undone.
320 TouchpadGesturePhaseCancelValue TouchpadGesturePhase = 3
321)
322
323var xEventsGetAngle func(uintptr, uintptr, *float64) bool
324
325// Returns the relative angle from @event1 to @event2.
326//
327// The relative angle is the angle between the X axis and the line
328// through both events' positions. The rotation direction for positive
329// angles is from the positive X axis towards the positive Y axis.
330//
331// This assumes that both events have X/Y information.
332// If not, this function returns %FALSE.
333func EventsGetAngle(Event1Var *Event, Event2Var *Event, AngleVar *float64) bool {
334
335 cret := xEventsGetAngle(Event1Var.GoPointer(), Event2Var.GoPointer(), AngleVar)
336 return cret
337}
338
339var xEventsGetCenter func(uintptr, uintptr, *float64, *float64) bool
340
341// Returns the point halfway between the events' positions.
342//
343// This assumes that both events have X/Y information.
344// If not, this function returns %FALSE.
345func EventsGetCenter(Event1Var *Event, Event2Var *Event, XVar *float64, YVar *float64) bool {
346
347 cret := xEventsGetCenter(Event1Var.GoPointer(), Event2Var.GoPointer(), XVar, YVar)
348 return cret
349}
350
351var xEventsGetDistance func(uintptr, uintptr, *float64) bool
352
353// Returns the distance between the event locations.
354//
355// This assumes that both events have X/Y information.
356// If not, this function returns %FALSE.
357func EventsGetDistance(Event1Var *Event, Event2Var *Event, DistanceVar *float64) bool {
358
359 cret := xEventsGetDistance(Event1Var.GoPointer(), Event2Var.GoPointer(), DistanceVar)
360 return cret
361}
362
363// An event related to a button on a pointer device.
364type ButtonEvent struct {
365 Event
366}
367
368var xButtonEventGLibType func() types.GType
369
370func ButtonEventGLibType() types.GType {
371 return xButtonEventGLibType()
372}
373
374func ButtonEventNewFromInternalPtr(ptr uintptr) *ButtonEvent {
375 cls := &ButtonEvent{}
376 cls.Ptr = ptr
377 return cls
378}
379
380var xButtonEventGetButton func(uintptr) uint
381
382// Extract the button number from a button event.
383func (x *ButtonEvent) GetButton() uint {
384
385 cret := xButtonEventGetButton(x.GoPointer())
386 return cret
387}
388
389func (c *ButtonEvent) GoPointer() uintptr {
390 if c == nil {
391 return 0
392 }
393 return c.Ptr
394}
395
396func (c *ButtonEvent) SetGoPointer(ptr uintptr) {
397 c.Ptr = ptr
398}
399
400// An event caused by a pointing device moving between surfaces.
401type CrossingEvent struct {
402 Event
403}
404
405var xCrossingEventGLibType func() types.GType
406
407func CrossingEventGLibType() types.GType {
408 return xCrossingEventGLibType()
409}
410
411func CrossingEventNewFromInternalPtr(ptr uintptr) *CrossingEvent {
412 cls := &CrossingEvent{}
413 cls.Ptr = ptr
414 return cls
415}
416
417var xCrossingEventGetDetail func(uintptr) NotifyType
418
419// Extracts the notify detail from a crossing event.
420func (x *CrossingEvent) GetDetail() NotifyType {
421
422 cret := xCrossingEventGetDetail(x.GoPointer())
423 return cret
424}
425
426var xCrossingEventGetFocus func(uintptr) bool
427
428// Checks if the @event surface is the focus surface.
429func (x *CrossingEvent) GetFocus() bool {
430
431 cret := xCrossingEventGetFocus(x.GoPointer())
432 return cret
433}
434
435var xCrossingEventGetMode func(uintptr) CrossingMode
436
437// Extracts the crossing mode from a crossing event.
438func (x *CrossingEvent) GetMode() CrossingMode {
439
440 cret := xCrossingEventGetMode(x.GoPointer())
441 return cret
442}
443
444func (c *CrossingEvent) GoPointer() uintptr {
445 if c == nil {
446 return 0
447 }
448 return c.Ptr
449}
450
451func (c *CrossingEvent) SetGoPointer(ptr uintptr) {
452 c.Ptr = ptr
453}
454
455// An event related to drag and drop operations.
456type DNDEvent struct {
457 Event
458}
459
460var xDNDEventGLibType func() types.GType
461
462func DNDEventGLibType() types.GType {
463 return xDNDEventGLibType()
464}
465
466func DNDEventNewFromInternalPtr(ptr uintptr) *DNDEvent {
467 cls := &DNDEvent{}
468 cls.Ptr = ptr
469 return cls
470}
471
472var xDNDEventGetDrop func(uintptr) uintptr
473
474// Gets the `GdkDrop` object from a DND event.
475func (x *DNDEvent) GetDrop() *Drop {
476 var cls *Drop
477
478 cret := xDNDEventGetDrop(x.GoPointer())
479
480 if cret == 0 {
481 return nil
482 }
483 gobject.IncreaseRef(cret)
484 cls = &Drop{}
485 cls.Ptr = cret
486 return cls
487}
488
489func (c *DNDEvent) GoPointer() uintptr {
490 if c == nil {
491 return 0
492 }
493 return c.Ptr
494}
495
496func (c *DNDEvent) SetGoPointer(ptr uintptr) {
497 c.Ptr = ptr
498}
499
500// An event related to closing a top-level surface.
501type DeleteEvent struct {
502 Event
503}
504
505var xDeleteEventGLibType func() types.GType
506
507func DeleteEventGLibType() types.GType {
508 return xDeleteEventGLibType()
509}
510
511func DeleteEventNewFromInternalPtr(ptr uintptr) *DeleteEvent {
512 cls := &DeleteEvent{}
513 cls.Ptr = ptr
514 return cls
515}
516
517func (c *DeleteEvent) GoPointer() uintptr {
518 if c == nil {
519 return 0
520 }
521 return c.Ptr
522}
523
524func (c *DeleteEvent) SetGoPointer(ptr uintptr) {
525 c.Ptr = ptr
526}
527
528// Represents windowing system events.
529//
530// In GTK applications the events are handled automatically by toplevel
531// widgets and passed on to the event controllers of appropriate widgets,
532// so using `GdkEvent` and its related API is rarely needed.
533//
534// `GdkEvent` structs are immutable.
535type Event struct {
536 Ptr uintptr
537}
538
539var xEventGLibType func() types.GType
540
541func EventGLibType() types.GType {
542 return xEventGLibType()
543}
544
545func EventNewFromInternalPtr(ptr uintptr) *Event {
546 cls := &Event{}
547 cls.Ptr = ptr
548 return cls
549}
550
551var xEventGetAngle func(uintptr, uintptr, *float64) bool
552
553// Returns the relative angle from @event1 to @event2.
554//
555// The relative angle is the angle between the X axis and the line
556// through both events' positions. The rotation direction for positive
557// angles is from the positive X axis towards the positive Y axis.
558//
559// This assumes that both events have X/Y information.
560// If not, this function returns %FALSE.
561func (x *Event) GetAngle(Event2Var *Event, AngleVar *float64) bool {
562
563 cret := xEventGetAngle(x.GoPointer(), Event2Var.GoPointer(), AngleVar)
564 return cret
565}
566
567var xEventGetCenter func(uintptr, uintptr, *float64, *float64) bool
568
569// Returns the point halfway between the events' positions.
570//
571// This assumes that both events have X/Y information.
572// If not, this function returns %FALSE.
573func (x *Event) GetCenter(Event2Var *Event, XVar *float64, YVar *float64) bool {
574
575 cret := xEventGetCenter(x.GoPointer(), Event2Var.GoPointer(), XVar, YVar)
576 return cret
577}
578
579var xEventGetDistance func(uintptr, uintptr, *float64) bool
580
581// Returns the distance between the event locations.
582//
583// This assumes that both events have X/Y information.
584// If not, this function returns %FALSE.
585func (x *Event) GetDistance(Event2Var *Event, DistanceVar *float64) bool {
586
587 cret := xEventGetDistance(x.GoPointer(), Event2Var.GoPointer(), DistanceVar)
588 return cret
589}
590
591var xEventGetAxes func(uintptr, *[]float64, *uint) bool
592
593// Extracts all axis values from an event.
594//
595// To find out which axes are used, use [method@Gdk.DeviceTool.get_axes]
596// on the device tool returned by [method@Gdk.Event.get_device_tool].
597func (x *Event) GetAxes(AxesVar *[]float64, NAxesVar *uint) bool {
598
599 cret := xEventGetAxes(x.GoPointer(), AxesVar, NAxesVar)
600 return cret
601}
602
603var xEventGetAxis func(uintptr, AxisUse, *float64) bool
604
605// Extract the axis value for a particular axis use from
606// an event structure.
607//
608// To find out which axes are used, use [method@Gdk.DeviceTool.get_axes]
609// on the device tool returned by [method@Gdk.Event.get_device_tool].
610func (x *Event) GetAxis(AxisUseVar AxisUse, ValueVar *float64) bool {
611
612 cret := xEventGetAxis(x.GoPointer(), AxisUseVar, ValueVar)
613 return cret
614}
615
616var xEventGetDevice func(uintptr) uintptr
617
618// Returns the device of an event.
619func (x *Event) GetDevice() *Device {
620 var cls *Device
621
622 cret := xEventGetDevice(x.GoPointer())
623
624 if cret == 0 {
625 return nil
626 }
627 gobject.IncreaseRef(cret)
628 cls = &Device{}
629 cls.Ptr = cret
630 return cls
631}
632
633var xEventGetDeviceTool func(uintptr) uintptr
634
635// Returns a `GdkDeviceTool` representing the tool that
636// caused the event.
637//
638// If the was not generated by a device that supports
639// different tools (such as a tablet), this function will
640// return %NULL.
641//
642// Note: the `GdkDeviceTool` will be constant during
643// the application lifetime, if settings must be stored
644// persistently across runs, see [method@Gdk.DeviceTool.get_serial].
645func (x *Event) GetDeviceTool() *DeviceTool {
646 var cls *DeviceTool
647
648 cret := xEventGetDeviceTool(x.GoPointer())
649
650 if cret == 0 {
651 return nil
652 }
653 gobject.IncreaseRef(cret)
654 cls = &DeviceTool{}
655 cls.Ptr = cret
656 return cls
657}
658
659var xEventGetDisplay func(uintptr) uintptr
660
661// Retrieves the display associated to the @event.
662func (x *Event) GetDisplay() *Display {
663 var cls *Display
664
665 cret := xEventGetDisplay(x.GoPointer())
666
667 if cret == 0 {
668 return nil
669 }
670 gobject.IncreaseRef(cret)
671 cls = &Display{}
672 cls.Ptr = cret
673 return cls
674}
675
676var xEventGetEventSequence func(uintptr) *EventSequence
677
678// Returns the event sequence to which the event belongs.
679//
680// Related touch events are connected in a sequence. Other
681// events typically don't have event sequence information.
682func (x *Event) GetEventSequence() *EventSequence {
683
684 cret := xEventGetEventSequence(x.GoPointer())
685 return cret
686}
687
688var xEventGetEventType func(uintptr) EventType
689
690// Retrieves the type of the event.
691func (x *Event) GetEventType() EventType {
692
693 cret := xEventGetEventType(x.GoPointer())
694 return cret
695}
696
697var xEventGetHistory func(uintptr, *uint) uintptr
698
699// Retrieves the history of the device that @event is for, as a list of
700// time and coordinates.
701//
702// The history includes positions that are not delivered as separate events
703// to the application because they occurred in the same frame as @event.
704//
705// Note that only motion and scroll events record history, and motion
706// events do it only if one of the mouse buttons is down, or the device
707// has a tool.
708func (x *Event) GetHistory(OutNCoordsVar *uint) uintptr {
709
710 cret := xEventGetHistory(x.GoPointer(), OutNCoordsVar)
711 return cret
712}
713
714var xEventGetModifierState func(uintptr) ModifierType
715
716// Returns the modifier state field of an event.
717func (x *Event) GetModifierState() ModifierType {
718
719 cret := xEventGetModifierState(x.GoPointer())
720 return cret
721}
722
723var xEventGetPointerEmulated func(uintptr) bool
724
725// Returns whether this event is an 'emulated' pointer event.
726//
727// Emulated pointer events typically originate from a touch events.
728func (x *Event) GetPointerEmulated() bool {
729
730 cret := xEventGetPointerEmulated(x.GoPointer())
731 return cret
732}
733
734var xEventGetPosition func(uintptr, *float64, *float64) bool
735
736// Extract the event surface relative x/y coordinates from an event.
737//
738// This position is in [surface coordinates](coordinates.html).
739func (x *Event) GetPosition(XVar *float64, YVar *float64) bool {
740
741 cret := xEventGetPosition(x.GoPointer(), XVar, YVar)
742 return cret
743}
744
745var xEventGetSeat func(uintptr) uintptr
746
747// Returns the seat that originated the event.
748func (x *Event) GetSeat() *Seat {
749 var cls *Seat
750
751 cret := xEventGetSeat(x.GoPointer())
752
753 if cret == 0 {
754 return nil
755 }
756 gobject.IncreaseRef(cret)
757 cls = &Seat{}
758 cls.Ptr = cret
759 return cls
760}
761
762var xEventGetSurface func(uintptr) uintptr
763
764// Extracts the surface associated with an event.
765func (x *Event) GetSurface() *Surface {
766 var cls *Surface
767
768 cret := xEventGetSurface(x.GoPointer())
769
770 if cret == 0 {
771 return nil
772 }
773 gobject.IncreaseRef(cret)
774 cls = &Surface{}
775 cls.Ptr = cret
776 return cls
777}
778
779var xEventGetTime func(uintptr) uint32
780
781// Returns the timestamp of @event.
782//
783// Not all events have timestamps. In that case, this function
784// returns %GDK_CURRENT_TIME.
785func (x *Event) GetTime() uint32 {
786
787 cret := xEventGetTime(x.GoPointer())
788 return cret
789}
790
791var xEventRef func(uintptr) uintptr
792
793// Increase the ref count of @event.
794func (x *Event) Ref() *Event {
795 var cls *Event
796
797 cret := xEventRef(x.GoPointer())
798
799 if cret == 0 {
800 return nil
801 }
802 cls = &Event{}
803 cls.Ptr = cret
804 return cls
805}
806
807var xEventTriggersContextMenu func(uintptr) bool
808
809// Returns whether a `GdkEvent` should trigger a context menu,
810// according to platform conventions.
811//
812// The right mouse button typically triggers context menus.
813// On macOS, Control+left mouse button also triggers.
814//
815// # This function should always be used instead of simply checking for
816//
817// ```c
818// event->button == GDK_BUTTON_SECONDARY
819// ```
820func (x *Event) TriggersContextMenu() bool {
821
822 cret := xEventTriggersContextMenu(x.GoPointer())
823 return cret
824}
825
826var xEventUnref func(uintptr)
827
828// Decrease the ref count of @event.
829//
830// If the last reference is dropped, the structure is freed.
831func (x *Event) Unref() {
832
833 xEventUnref(x.GoPointer())
834
835}
836
837func (c *Event) GoPointer() uintptr {
838 if c == nil {
839 return 0
840 }
841 return c.Ptr
842}
843
844func (c *Event) SetGoPointer(ptr uintptr) {
845 c.Ptr = ptr
846}
847
848// An event related to a keyboard focus change.
849type FocusEvent struct {
850 Event
851}
852
853var xFocusEventGLibType func() types.GType
854
855func FocusEventGLibType() types.GType {
856 return xFocusEventGLibType()
857}
858
859func FocusEventNewFromInternalPtr(ptr uintptr) *FocusEvent {
860 cls := &FocusEvent{}
861 cls.Ptr = ptr
862 return cls
863}
864
865var xFocusEventGetIn func(uintptr) bool
866
867// Extracts whether this event is about focus entering or
868// leaving the surface.
869func (x *FocusEvent) GetIn() bool {
870
871 cret := xFocusEventGetIn(x.GoPointer())
872 return cret
873}
874
875func (c *FocusEvent) GoPointer() uintptr {
876 if c == nil {
877 return 0
878 }
879 return c.Ptr
880}
881
882func (c *FocusEvent) SetGoPointer(ptr uintptr) {
883 c.Ptr = ptr
884}
885
886// An event related to a broken windowing system grab.
887type GrabBrokenEvent struct {
888 Event
889}
890
891var xGrabBrokenEventGLibType func() types.GType
892
893func GrabBrokenEventGLibType() types.GType {
894 return xGrabBrokenEventGLibType()
895}
896
897func GrabBrokenEventNewFromInternalPtr(ptr uintptr) *GrabBrokenEvent {
898 cls := &GrabBrokenEvent{}
899 cls.Ptr = ptr
900 return cls
901}
902
903var xGrabBrokenEventGetGrabSurface func(uintptr) uintptr
904
905// Extracts the grab surface from a grab broken event.
906func (x *GrabBrokenEvent) GetGrabSurface() *Surface {
907 var cls *Surface
908
909 cret := xGrabBrokenEventGetGrabSurface(x.GoPointer())
910
911 if cret == 0 {
912 return nil
913 }
914 gobject.IncreaseRef(cret)
915 cls = &Surface{}
916 cls.Ptr = cret
917 return cls
918}
919
920var xGrabBrokenEventGetImplicit func(uintptr) bool
921
922// Checks whether the grab broken event is for an implicit grab.
923func (x *GrabBrokenEvent) GetImplicit() bool {
924
925 cret := xGrabBrokenEventGetImplicit(x.GoPointer())
926 return cret
927}
928
929func (c *GrabBrokenEvent) GoPointer() uintptr {
930 if c == nil {
931 return 0
932 }
933 return c.Ptr
934}
935
936func (c *GrabBrokenEvent) SetGoPointer(ptr uintptr) {
937 c.Ptr = ptr
938}
939
940// An event related to a key-based device.
941type KeyEvent struct {
942 Event
943}
944
945var xKeyEventGLibType func() types.GType
946
947func KeyEventGLibType() types.GType {
948 return xKeyEventGLibType()
949}
950
951func KeyEventNewFromInternalPtr(ptr uintptr) *KeyEvent {
952 cls := &KeyEvent{}
953 cls.Ptr = ptr
954 return cls
955}
956
957var xKeyEventGetConsumedModifiers func(uintptr) ModifierType
958
959// Extracts the consumed modifiers from a key event.
960func (x *KeyEvent) GetConsumedModifiers() ModifierType {
961
962 cret := xKeyEventGetConsumedModifiers(x.GoPointer())
963 return cret
964}
965
966var xKeyEventGetKeycode func(uintptr) uint
967
968// Extracts the keycode from a key event.
969func (x *KeyEvent) GetKeycode() uint {
970
971 cret := xKeyEventGetKeycode(x.GoPointer())
972 return cret
973}
974
975var xKeyEventGetKeyval func(uintptr) uint
976
977// Extracts the keyval from a key event.
978func (x *KeyEvent) GetKeyval() uint {
979
980 cret := xKeyEventGetKeyval(x.GoPointer())
981 return cret
982}
983
984var xKeyEventGetLayout func(uintptr) uint
985
986// Extracts the layout from a key event.
987func (x *KeyEvent) GetLayout() uint {
988
989 cret := xKeyEventGetLayout(x.GoPointer())
990 return cret
991}
992
993var xKeyEventGetLevel func(uintptr) uint
994
995// Extracts the shift level from a key event.
996func (x *KeyEvent) GetLevel() uint {
997
998 cret := xKeyEventGetLevel(x.GoPointer())
999 return cret
1000}
1001
1002var xKeyEventGetMatch func(uintptr, *uint, *ModifierType) bool
1003
1004// Gets a keyval and modifier combination that will match
1005// the event.
1006//
1007// See [method@Gdk.KeyEvent.matches].
1008func (x *KeyEvent) GetMatch(KeyvalVar *uint, ModifiersVar *ModifierType) bool {
1009
1010 cret := xKeyEventGetMatch(x.GoPointer(), KeyvalVar, ModifiersVar)
1011 return cret
1012}
1013
1014var xKeyEventIsModifier func(uintptr) bool
1015
1016// Extracts whether the key event is for a modifier key.
1017func (x *KeyEvent) IsModifier() bool {
1018
1019 cret := xKeyEventIsModifier(x.GoPointer())
1020 return cret
1021}
1022
1023var xKeyEventMatches func(uintptr, uint, ModifierType) KeyMatch
1024
1025// Matches a key event against a keyval and modifiers.
1026//
1027// This is typically used to trigger keyboard shortcuts such as Ctrl-C.
1028//
1029// Partial matches are possible where the combination matches
1030// if the currently active group is ignored.
1031//
1032// Note that we ignore Caps Lock for matching.
1033func (x *KeyEvent) Matches(KeyvalVar uint, ModifiersVar ModifierType) KeyMatch {
1034
1035 cret := xKeyEventMatches(x.GoPointer(), KeyvalVar, ModifiersVar)
1036 return cret
1037}
1038
1039func (c *KeyEvent) GoPointer() uintptr {
1040 if c == nil {
1041 return 0
1042 }
1043 return c.Ptr
1044}
1045
1046func (c *KeyEvent) SetGoPointer(ptr uintptr) {
1047 c.Ptr = ptr
1048}
1049
1050// An event related to a pointer or touch device motion.
1051type MotionEvent struct {
1052 Event
1053}
1054
1055var xMotionEventGLibType func() types.GType
1056
1057func MotionEventGLibType() types.GType {
1058 return xMotionEventGLibType()
1059}
1060
1061func MotionEventNewFromInternalPtr(ptr uintptr) *MotionEvent {
1062 cls := &MotionEvent{}
1063 cls.Ptr = ptr
1064 return cls
1065}
1066
1067func (c *MotionEvent) GoPointer() uintptr {
1068 if c == nil {
1069 return 0
1070 }
1071 return c.Ptr
1072}
1073
1074func (c *MotionEvent) SetGoPointer(ptr uintptr) {
1075 c.Ptr = ptr
1076}
1077
1078// An event related to a pad-based device.
1079type PadEvent struct {
1080 Event
1081}
1082
1083var xPadEventGLibType func() types.GType
1084
1085func PadEventGLibType() types.GType {
1086 return xPadEventGLibType()
1087}
1088
1089func PadEventNewFromInternalPtr(ptr uintptr) *PadEvent {
1090 cls := &PadEvent{}
1091 cls.Ptr = ptr
1092 return cls
1093}
1094
1095var xPadEventGetAxisValue func(uintptr, *uint, *float64)
1096
1097// Extracts the information from a pad strip or ring event.
1098func (x *PadEvent) GetAxisValue(IndexVar *uint, ValueVar *float64) {
1099
1100 xPadEventGetAxisValue(x.GoPointer(), IndexVar, ValueVar)
1101
1102}
1103
1104var xPadEventGetButton func(uintptr) uint
1105
1106// Extracts information about the pressed button from
1107// a pad event.
1108func (x *PadEvent) GetButton() uint {
1109
1110 cret := xPadEventGetButton(x.GoPointer())
1111 return cret
1112}
1113
1114var xPadEventGetGroupMode func(uintptr, *uint, *uint)
1115
1116// Extracts group and mode information from a pad event.
1117func (x *PadEvent) GetGroupMode(GroupVar *uint, ModeVar *uint) {
1118
1119 xPadEventGetGroupMode(x.GoPointer(), GroupVar, ModeVar)
1120
1121}
1122
1123func (c *PadEvent) GoPointer() uintptr {
1124 if c == nil {
1125 return 0
1126 }
1127 return c.Ptr
1128}
1129
1130func (c *PadEvent) SetGoPointer(ptr uintptr) {
1131 c.Ptr = ptr
1132}
1133
1134// An event related to the proximity of a tool to a device.
1135type ProximityEvent struct {
1136 Event
1137}
1138
1139var xProximityEventGLibType func() types.GType
1140
1141func ProximityEventGLibType() types.GType {
1142 return xProximityEventGLibType()
1143}
1144
1145func ProximityEventNewFromInternalPtr(ptr uintptr) *ProximityEvent {
1146 cls := &ProximityEvent{}
1147 cls.Ptr = ptr
1148 return cls
1149}
1150
1151func (c *ProximityEvent) GoPointer() uintptr {
1152 if c == nil {
1153 return 0
1154 }
1155 return c.Ptr
1156}
1157
1158func (c *ProximityEvent) SetGoPointer(ptr uintptr) {
1159 c.Ptr = ptr
1160}
1161
1162// An event related to a scrolling motion.
1163type ScrollEvent struct {
1164 Event
1165}
1166
1167var xScrollEventGLibType func() types.GType
1168
1169func ScrollEventGLibType() types.GType {
1170 return xScrollEventGLibType()
1171}
1172
1173func ScrollEventNewFromInternalPtr(ptr uintptr) *ScrollEvent {
1174 cls := &ScrollEvent{}
1175 cls.Ptr = ptr
1176 return cls
1177}
1178
1179var xScrollEventGetDeltas func(uintptr, *float64, *float64)
1180
1181// Extracts the scroll deltas of a scroll event.
1182//
1183// The deltas will be zero unless the scroll direction
1184// is %GDK_SCROLL_SMOOTH.
1185//
1186// For the representation unit of these deltas, see
1187// [method@Gdk.ScrollEvent.get_unit].
1188func (x *ScrollEvent) GetDeltas(DeltaXVar *float64, DeltaYVar *float64) {
1189
1190 xScrollEventGetDeltas(x.GoPointer(), DeltaXVar, DeltaYVar)
1191
1192}
1193
1194var xScrollEventGetDirection func(uintptr) ScrollDirection
1195
1196// Extracts the direction of a scroll event.
1197func (x *ScrollEvent) GetDirection() ScrollDirection {
1198
1199 cret := xScrollEventGetDirection(x.GoPointer())
1200 return cret
1201}
1202
1203var xScrollEventGetUnit func(uintptr) ScrollUnit
1204
1205// Extracts the scroll delta unit of a scroll event.
1206//
1207// The unit will always be %GDK_SCROLL_UNIT_WHEEL if the scroll direction is not
1208// %GDK_SCROLL_SMOOTH.
1209func (x *ScrollEvent) GetUnit() ScrollUnit {
1210
1211 cret := xScrollEventGetUnit(x.GoPointer())
1212 return cret
1213}
1214
1215var xScrollEventIsStop func(uintptr) bool
1216
1217// Check whether a scroll event is a stop scroll event.
1218//
1219// Scroll sequences with smooth scroll information may provide
1220// a stop scroll event once the interaction with the device finishes,
1221// e.g. by lifting a finger. This stop scroll event is the signal
1222// that a widget may trigger kinetic scrolling based on the current
1223// velocity.
1224//
1225// Stop scroll events always have a delta of 0/0.
1226func (x *ScrollEvent) IsStop() bool {
1227
1228 cret := xScrollEventIsStop(x.GoPointer())
1229 return cret
1230}
1231
1232func (c *ScrollEvent) GoPointer() uintptr {
1233 if c == nil {
1234 return 0
1235 }
1236 return c.Ptr
1237}
1238
1239func (c *ScrollEvent) SetGoPointer(ptr uintptr) {
1240 c.Ptr = ptr
1241}
1242
1243var xScrollEventGetRelativeDirection func(uintptr) ScrollRelativeDirection
1244
1245func ScrollEventGetRelativeDirection(EventVar *Event) ScrollRelativeDirection {
1246
1247 cret := xScrollEventGetRelativeDirection(EventVar.GoPointer())
1248 return cret
1249}
1250
1251// An event related to a touch-based device.
1252type TouchEvent struct {
1253 Event
1254}
1255
1256var xTouchEventGLibType func() types.GType
1257
1258func TouchEventGLibType() types.GType {
1259 return xTouchEventGLibType()
1260}
1261
1262func TouchEventNewFromInternalPtr(ptr uintptr) *TouchEvent {
1263 cls := &TouchEvent{}
1264 cls.Ptr = ptr
1265 return cls
1266}
1267
1268var xTouchEventGetEmulatingPointer func(uintptr) bool
1269
1270// Extracts whether a touch event is emulating a pointer event.
1271func (x *TouchEvent) GetEmulatingPointer() bool {
1272
1273 cret := xTouchEventGetEmulatingPointer(x.GoPointer())
1274 return cret
1275}
1276
1277func (c *TouchEvent) GoPointer() uintptr {
1278 if c == nil {
1279 return 0
1280 }
1281 return c.Ptr
1282}
1283
1284func (c *TouchEvent) SetGoPointer(ptr uintptr) {
1285 c.Ptr = ptr
1286}
1287
1288// An event related to a gesture on a touchpad device.
1289//
1290// Unlike touchscreens, where the windowing system sends basic
1291// sequences of begin, update, end events, and leaves gesture
1292// recognition to the clients, touchpad gestures are typically
1293// processed by the system, resulting in these events.
1294type TouchpadEvent struct {
1295 Event
1296}
1297
1298var xTouchpadEventGLibType func() types.GType
1299
1300func TouchpadEventGLibType() types.GType {
1301 return xTouchpadEventGLibType()
1302}
1303
1304func TouchpadEventNewFromInternalPtr(ptr uintptr) *TouchpadEvent {
1305 cls := &TouchpadEvent{}
1306 cls.Ptr = ptr
1307 return cls
1308}
1309
1310var xTouchpadEventGetDeltas func(uintptr, *float64, *float64)
1311
1312// Extracts delta information from a touchpad event.
1313func (x *TouchpadEvent) GetDeltas(DxVar *float64, DyVar *float64) {
1314
1315 xTouchpadEventGetDeltas(x.GoPointer(), DxVar, DyVar)
1316
1317}
1318
1319var xTouchpadEventGetGesturePhase func(uintptr) TouchpadGesturePhase
1320
1321// Extracts the touchpad gesture phase from a touchpad event.
1322func (x *TouchpadEvent) GetGesturePhase() TouchpadGesturePhase {
1323
1324 cret := xTouchpadEventGetGesturePhase(x.GoPointer())
1325 return cret
1326}
1327
1328var xTouchpadEventGetNFingers func(uintptr) uint
1329
1330// Extracts the number of fingers from a touchpad event.
1331func (x *TouchpadEvent) GetNFingers() uint {
1332
1333 cret := xTouchpadEventGetNFingers(x.GoPointer())
1334 return cret
1335}
1336
1337var xTouchpadEventGetPinchAngleDelta func(uintptr) float64
1338
1339// Extracts the angle delta from a touchpad pinch event.
1340func (x *TouchpadEvent) GetPinchAngleDelta() float64 {
1341
1342 cret := xTouchpadEventGetPinchAngleDelta(x.GoPointer())
1343 return cret
1344}
1345
1346var xTouchpadEventGetPinchScale func(uintptr) float64
1347
1348// Extracts the scale from a touchpad pinch event.
1349func (x *TouchpadEvent) GetPinchScale() float64 {
1350
1351 cret := xTouchpadEventGetPinchScale(x.GoPointer())
1352 return cret
1353}
1354
1355func (c *TouchpadEvent) GoPointer() uintptr {
1356 if c == nil {
1357 return 0
1358 }
1359 return c.Ptr
1360}
1361
1362func (c *TouchpadEvent) SetGoPointer(ptr uintptr) {
1363 c.Ptr = ptr
1364}
1365
1366func init() {
1367 core.SetPackageName("GDK", "gtk4")
1368 core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})
1369 var libs []uintptr
1370 for _, libPath := range core.GetPaths("GDK") {
1371 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
1372 if err != nil {
1373 panic(err)
1374 }
1375 libs = append(libs, lib)
1376 }
1377
1378 core.PuregoSafeRegister(&xCrossingModeGLibType, libs, "gdk_crossing_mode_get_type")
1379
1380 core.PuregoSafeRegister(&xEventTypeGLibType, libs, "gdk_event_type_get_type")
1381
1382 core.PuregoSafeRegister(&xKeyMatchGLibType, libs, "gdk_key_match_get_type")
1383
1384 core.PuregoSafeRegister(&xNotifyTypeGLibType, libs, "gdk_notify_type_get_type")
1385
1386 core.PuregoSafeRegister(&xScrollDirectionGLibType, libs, "gdk_scroll_direction_get_type")
1387
1388 core.PuregoSafeRegister(&xScrollUnitGLibType, libs, "gdk_scroll_unit_get_type")
1389
1390 core.PuregoSafeRegister(&xTouchpadGesturePhaseGLibType, libs, "gdk_touchpad_gesture_phase_get_type")
1391
1392 core.PuregoSafeRegister(&xEventsGetAngle, libs, "gdk_events_get_angle")
1393 core.PuregoSafeRegister(&xEventsGetCenter, libs, "gdk_events_get_center")
1394 core.PuregoSafeRegister(&xEventsGetDistance, libs, "gdk_events_get_distance")
1395
1396 core.PuregoSafeRegister(&xEventSequenceGLibType, libs, "gdk_event_sequence_get_type")
1397
1398 core.PuregoSafeRegister(&xButtonEventGLibType, libs, "gdk_button_event_get_type")
1399
1400 core.PuregoSafeRegister(&xButtonEventGetButton, libs, "gdk_button_event_get_button")
1401
1402 core.PuregoSafeRegister(&xCrossingEventGLibType, libs, "gdk_crossing_event_get_type")
1403
1404 core.PuregoSafeRegister(&xCrossingEventGetDetail, libs, "gdk_crossing_event_get_detail")
1405 core.PuregoSafeRegister(&xCrossingEventGetFocus, libs, "gdk_crossing_event_get_focus")
1406 core.PuregoSafeRegister(&xCrossingEventGetMode, libs, "gdk_crossing_event_get_mode")
1407
1408 core.PuregoSafeRegister(&xDNDEventGLibType, libs, "gdk_dnd_event_get_type")
1409
1410 core.PuregoSafeRegister(&xDNDEventGetDrop, libs, "gdk_dnd_event_get_drop")
1411
1412 core.PuregoSafeRegister(&xDeleteEventGLibType, libs, "gdk_delete_event_get_type")
1413
1414 core.PuregoSafeRegister(&xEventGLibType, libs, "gdk_event_get_type")
1415
1416 core.PuregoSafeRegister(&xEventGetAngle, libs, "gdk_events_get_angle")
1417 core.PuregoSafeRegister(&xEventGetCenter, libs, "gdk_events_get_center")
1418 core.PuregoSafeRegister(&xEventGetDistance, libs, "gdk_events_get_distance")
1419 core.PuregoSafeRegister(&xEventGetAxes, libs, "gdk_event_get_axes")
1420 core.PuregoSafeRegister(&xEventGetAxis, libs, "gdk_event_get_axis")
1421 core.PuregoSafeRegister(&xEventGetDevice, libs, "gdk_event_get_device")
1422 core.PuregoSafeRegister(&xEventGetDeviceTool, libs, "gdk_event_get_device_tool")
1423 core.PuregoSafeRegister(&xEventGetDisplay, libs, "gdk_event_get_display")
1424 core.PuregoSafeRegister(&xEventGetEventSequence, libs, "gdk_event_get_event_sequence")
1425 core.PuregoSafeRegister(&xEventGetEventType, libs, "gdk_event_get_event_type")
1426 core.PuregoSafeRegister(&xEventGetHistory, libs, "gdk_event_get_history")
1427 core.PuregoSafeRegister(&xEventGetModifierState, libs, "gdk_event_get_modifier_state")
1428 core.PuregoSafeRegister(&xEventGetPointerEmulated, libs, "gdk_event_get_pointer_emulated")
1429 core.PuregoSafeRegister(&xEventGetPosition, libs, "gdk_event_get_position")
1430 core.PuregoSafeRegister(&xEventGetSeat, libs, "gdk_event_get_seat")
1431 core.PuregoSafeRegister(&xEventGetSurface, libs, "gdk_event_get_surface")
1432 core.PuregoSafeRegister(&xEventGetTime, libs, "gdk_event_get_time")
1433 core.PuregoSafeRegister(&xEventRef, libs, "gdk_event_ref")
1434 core.PuregoSafeRegister(&xEventTriggersContextMenu, libs, "gdk_event_triggers_context_menu")
1435 core.PuregoSafeRegister(&xEventUnref, libs, "gdk_event_unref")
1436
1437 core.PuregoSafeRegister(&xFocusEventGLibType, libs, "gdk_focus_event_get_type")
1438
1439 core.PuregoSafeRegister(&xFocusEventGetIn, libs, "gdk_focus_event_get_in")
1440
1441 core.PuregoSafeRegister(&xGrabBrokenEventGLibType, libs, "gdk_grab_broken_event_get_type")
1442
1443 core.PuregoSafeRegister(&xGrabBrokenEventGetGrabSurface, libs, "gdk_grab_broken_event_get_grab_surface")
1444 core.PuregoSafeRegister(&xGrabBrokenEventGetImplicit, libs, "gdk_grab_broken_event_get_implicit")
1445
1446 core.PuregoSafeRegister(&xKeyEventGLibType, libs, "gdk_key_event_get_type")
1447
1448 core.PuregoSafeRegister(&xKeyEventGetConsumedModifiers, libs, "gdk_key_event_get_consumed_modifiers")
1449 core.PuregoSafeRegister(&xKeyEventGetKeycode, libs, "gdk_key_event_get_keycode")
1450 core.PuregoSafeRegister(&xKeyEventGetKeyval, libs, "gdk_key_event_get_keyval")
1451 core.PuregoSafeRegister(&xKeyEventGetLayout, libs, "gdk_key_event_get_layout")
1452 core.PuregoSafeRegister(&xKeyEventGetLevel, libs, "gdk_key_event_get_level")
1453 core.PuregoSafeRegister(&xKeyEventGetMatch, libs, "gdk_key_event_get_match")
1454 core.PuregoSafeRegister(&xKeyEventIsModifier, libs, "gdk_key_event_is_modifier")
1455 core.PuregoSafeRegister(&xKeyEventMatches, libs, "gdk_key_event_matches")
1456
1457 core.PuregoSafeRegister(&xMotionEventGLibType, libs, "gdk_motion_event_get_type")
1458
1459 core.PuregoSafeRegister(&xPadEventGLibType, libs, "gdk_pad_event_get_type")
1460
1461 core.PuregoSafeRegister(&xPadEventGetAxisValue, libs, "gdk_pad_event_get_axis_value")
1462 core.PuregoSafeRegister(&xPadEventGetButton, libs, "gdk_pad_event_get_button")
1463 core.PuregoSafeRegister(&xPadEventGetGroupMode, libs, "gdk_pad_event_get_group_mode")
1464
1465 core.PuregoSafeRegister(&xProximityEventGLibType, libs, "gdk_proximity_event_get_type")
1466
1467 core.PuregoSafeRegister(&xScrollEventGLibType, libs, "gdk_scroll_event_get_type")
1468
1469 core.PuregoSafeRegister(&xScrollEventGetDeltas, libs, "gdk_scroll_event_get_deltas")
1470 core.PuregoSafeRegister(&xScrollEventGetDirection, libs, "gdk_scroll_event_get_direction")
1471 core.PuregoSafeRegister(&xScrollEventGetUnit, libs, "gdk_scroll_event_get_unit")
1472 core.PuregoSafeRegister(&xScrollEventIsStop, libs, "gdk_scroll_event_is_stop")
1473
1474 core.PuregoSafeRegister(&xScrollEventGetRelativeDirection, libs, "gdk_scroll_event_get_relative_direction")
1475
1476 core.PuregoSafeRegister(&xTouchEventGLibType, libs, "gdk_touch_event_get_type")
1477
1478 core.PuregoSafeRegister(&xTouchEventGetEmulatingPointer, libs, "gdk_touch_event_get_emulating_pointer")
1479
1480 core.PuregoSafeRegister(&xTouchpadEventGLibType, libs, "gdk_touchpad_event_get_type")
1481
1482 core.PuregoSafeRegister(&xTouchpadEventGetDeltas, libs, "gdk_touchpad_event_get_deltas")
1483 core.PuregoSafeRegister(&xTouchpadEventGetGesturePhase, libs, "gdk_touchpad_event_get_gesture_phase")
1484 core.PuregoSafeRegister(&xTouchpadEventGetNFingers, libs, "gdk_touchpad_event_get_n_fingers")
1485 core.PuregoSafeRegister(&xTouchpadEventGetPinchAngleDelta, libs, "gdk_touchpad_event_get_pinch_angle_delta")
1486 core.PuregoSafeRegister(&xTouchpadEventGetPinchScale, libs, "gdk_touchpad_event_get_pinch_scale")
1487
1488}