diff options
author | Carlos Garnacho <carlosg@gnome.org> | 2017-08-05 15:34:39 +0200 |
---|---|---|
committer | Carlos Garnacho <carlosg@gnome.org> | 2017-09-19 18:39:02 +0200 |
commit | c7431f46b5dfd795222ae1186b60876026a9278f (patch) | |
tree | 6ca2da803ef37742e39bd80121488915391a50d8 /gdk/gdkeventsprivate.h | |
parent | 63eecd3dfafc87e3f9aedbfba1849f59e9ed1c8f (diff) | |
download | gtk+-c7431f46b5dfd795222ae1186b60876026a9278f.tar.gz |
gdk: Make GdkEvent structs/union opaque
All users are forced to deal with events as opaque pointers, only
using API to access the info.
Diffstat (limited to 'gdk/gdkeventsprivate.h')
-rw-r--r-- | gdk/gdkeventsprivate.h | 891 |
1 files changed, 891 insertions, 0 deletions
diff --git a/gdk/gdkeventsprivate.h b/gdk/gdkeventsprivate.h new file mode 100644 index 0000000000..24c1ea18e1 --- /dev/null +++ b/gdk/gdkeventsprivate.h @@ -0,0 +1,891 @@ +/* GDK - The GIMP Drawing Kit + * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + */ + +/* + * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS + * file for a list of people on the GTK+ Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. + */ + +#ifndef __GDK_EVENTS_PRIVATE_H__ +#define __GDK_EVENTS_PRIVATE_H__ + +#include <gdk/gdktypes.h> +#include <gdk/gdkdnd.h> +#include <gdk/gdkdevice.h> +#include <gdk/gdkdevicetool.h> + +/** + * GdkEventAny: + * @type: the type of the event. + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * + * Contains the fields which are common to all event structs. + * Any event pointer can safely be cast to a pointer to a #GdkEventAny to + * access these fields. + */ +struct _GdkEventAny +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; +}; + +/** + * GdkEventExpose: + * @type: the type of the event (%GDK_EXPOSE or %GDK_DAMAGE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @area: bounding box of @region. + * @region: the region that needs to be redrawn. + * @count: the number of contiguous %GDK_EXPOSE events following this one. + * The only use for this is “exposure compression”, i.e. handling all + * contiguous %GDK_EXPOSE events in one go, though GDK performs some + * exposure compression so this is not normally needed. + * + * Generated when all or part of a window becomes visible and needs to be + * redrawn. + */ +struct _GdkEventExpose +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkRectangle area; + cairo_region_t *region; + gint count; /* If non-zero, how many more events follow. */ +}; + +/** + * GdkEventVisibility: + * @type: the type of the event (%GDK_VISIBILITY_NOTIFY). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @state: the new visibility state (%GDK_VISIBILITY_FULLY_OBSCURED, + * %GDK_VISIBILITY_PARTIAL or %GDK_VISIBILITY_UNOBSCURED). + * + * Generated when the window visibility status has changed. + * + * Deprecated: 3.12: Modern composited windowing systems with pervasive + * transparency make it impossible to track the visibility of a window + * reliably, so this event can not be guaranteed to provide useful + * information. + */ +struct _GdkEventVisibility +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkVisibilityState state; +}; + +/** + * GdkEventMotion: + * @type: the type of the event. + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window. + * @y: the y coordinate of the pointer relative to the window. + * @axes: @x, @y translated to the axes of @device, or %NULL if @device is + * the mouse. + * @state: (type GdkModifierType): a bit-mask representing the state of + * the modifier keys (e.g. Control, Shift and Alt) and the pointer + * buttons. See #GdkModifierType. + * @is_hint: set to 1 if this event is just a hint, see the + * %GDK_POINTER_MOTION_HINT_MASK value of #GdkEventMask. + * @device: the master device that the event originated from. Use + * gdk_event_get_source_device() to get the slave device. + * @x_root: the x coordinate of the pointer relative to the root of the + * screen. + * @y_root: the y coordinate of the pointer relative to the root of the + * screen. + * + * Generated when the pointer moves. + */ +struct _GdkEventMotion +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + gdouble *axes; + guint state; + gint16 is_hint; + GdkDevice *device; + gdouble x_root, y_root; +}; + +/** + * GdkEventButton: + * @type: the type of the event (%GDK_BUTTON_PRESS, %GDK_2BUTTON_PRESS, + * %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window. + * @y: the y coordinate of the pointer relative to the window. + * @axes: @x, @y translated to the axes of @device, or %NULL if @device is + * the mouse. + * @state: (type GdkModifierType): a bit-mask representing the state of + * the modifier keys (e.g. Control, Shift and Alt) and the pointer + * buttons. See #GdkModifierType. + * @button: the button which was pressed or released, numbered from 1 to 5. + * Normally button 1 is the left mouse button, 2 is the middle button, + * and 3 is the right button. On 2-button mice, the middle button can + * often be simulated by pressing both mouse buttons together. + * @device: the master device that the event originated from. Use + * gdk_event_get_source_device() to get the slave device. + * @x_root: the x coordinate of the pointer relative to the root of the + * screen. + * @y_root: the y coordinate of the pointer relative to the root of the + * screen. + * + * Used for button press and button release events. The + * @type field will be one of %GDK_BUTTON_PRESS, + * %GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE, + * + * Double and triple-clicks result in a sequence of events being received. + * For double-clicks the order of events will be: + * + * - %GDK_BUTTON_PRESS + * - %GDK_BUTTON_RELEASE + * - %GDK_BUTTON_PRESS + * - %GDK_2BUTTON_PRESS + * - %GDK_BUTTON_RELEASE + * + * Note that the first click is received just like a normal + * button press, while the second click results in a %GDK_2BUTTON_PRESS + * being received just after the %GDK_BUTTON_PRESS. + * + * Triple-clicks are very similar to double-clicks, except that + * %GDK_3BUTTON_PRESS is inserted after the third click. The order of the + * events is: + * + * - %GDK_BUTTON_PRESS + * - %GDK_BUTTON_RELEASE + * - %GDK_BUTTON_PRESS + * - %GDK_2BUTTON_PRESS + * - %GDK_BUTTON_RELEASE + * - %GDK_BUTTON_PRESS + * - %GDK_3BUTTON_PRESS + * - %GDK_BUTTON_RELEASE + * + * For a double click to occur, the second button press must occur within + * 1/4 of a second of the first. For a triple click to occur, the third + * button press must also occur within 1/2 second of the first button press. + */ +struct _GdkEventButton +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + gdouble *axes; + guint state; + guint button; + GdkDevice *device; + gdouble x_root, y_root; +}; + +/** + * GdkEventTouch: + * @type: the type of the event (%GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE, + * %GDK_TOUCH_END, %GDK_TOUCH_CANCEL) + * @window: the window which received the event + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window + * @y: the y coordinate of the pointer relative to the window + * @axes: @x, @y translated to the axes of @device, or %NULL if @device is + * the mouse + * @state: (type GdkModifierType): a bit-mask representing the state of + * the modifier keys (e.g. Control, Shift and Alt) and the pointer + * buttons. See #GdkModifierType + * @sequence: the event sequence that the event belongs to + * @emulating_pointer: whether the event should be used for emulating + * pointer event + * @device: the master device that the event originated from. Use + * gdk_event_get_source_device() to get the slave device. + * @x_root: the x coordinate of the pointer relative to the root of the + * screen + * @y_root: the y coordinate of the pointer relative to the root of the + * screen + * + * Used for touch events. + * @type field will be one of %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE, + * %GDK_TOUCH_END or %GDK_TOUCH_CANCEL. + * + * Touch events are grouped into sequences by means of the @sequence + * field, which can also be obtained with gdk_event_get_event_sequence(). + * Each sequence begins with a %GDK_TOUCH_BEGIN event, followed by + * any number of %GDK_TOUCH_UPDATE events, and ends with a %GDK_TOUCH_END + * (or %GDK_TOUCH_CANCEL) event. With multitouch devices, there may be + * several active sequences at the same time. + */ +struct _GdkEventTouch +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + gdouble *axes; + guint state; + GdkEventSequence *sequence; + gboolean emulating_pointer; + GdkDevice *device; + gdouble x_root, y_root; +}; + +/** + * GdkEventScroll: + * @type: the type of the event (%GDK_SCROLL). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window. + * @y: the y coordinate of the pointer relative to the window. + * @state: (type GdkModifierType): a bit-mask representing the state of + * the modifier keys (e.g. Control, Shift and Alt) and the pointer + * buttons. See #GdkModifierType. + * @direction: the direction to scroll to (one of %GDK_SCROLL_UP, + * %GDK_SCROLL_DOWN, %GDK_SCROLL_LEFT, %GDK_SCROLL_RIGHT or + * %GDK_SCROLL_SMOOTH). + * @device: the master device that the event originated from. Use + * gdk_event_get_source_device() to get the slave device. + * @x_root: the x coordinate of the pointer relative to the root of the + * screen. + * @y_root: the y coordinate of the pointer relative to the root of the + * screen. + * @delta_x: the x coordinate of the scroll delta + * @delta_y: the y coordinate of the scroll delta + * + * Generated from button presses for the buttons 4 to 7. Wheel mice are + * usually configured to generate button press events for buttons 4 and 5 + * when the wheel is turned. + * + * Some GDK backends can also generate “smooth” scroll events, which + * can be recognized by the %GDK_SCROLL_SMOOTH scroll direction. For + * these, the scroll deltas can be obtained with + * gdk_event_get_scroll_deltas(). + */ +struct _GdkEventScroll +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + guint state; + GdkScrollDirection direction; + GdkDevice *device; + gdouble x_root, y_root; + gdouble delta_x; + gdouble delta_y; + guint is_stop : 1; +}; + +/** + * GdkEventKey: + * @type: the type of the event (%GDK_KEY_PRESS or %GDK_KEY_RELEASE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @state: (type GdkModifierType): a bit-mask representing the state of + * the modifier keys (e.g. Control, Shift and Alt) and the pointer + * buttons. See #GdkModifierType. + * @keyval: the key that was pressed or released. See the + * `gdk/gdkkeysyms.h` header file for a + * complete list of GDK key codes. + * @length: the length of @string. + * @string: a string containing an approximation of the text that + * would result from this keypress. The only correct way to handle text + * input of text is using input methods (see #GtkIMContext), so this + * field is deprecated and should never be used. + * (gdk_unicode_to_keyval() provides a non-deprecated way of getting + * an approximate translation for a key.) The string is encoded in the + * encoding of the current locale (Note: this for backwards compatibility: + * strings in GTK+ and GDK are typically in UTF-8.) and NUL-terminated. + * In some cases, the translation of the key code will be a single + * NUL byte, in which case looking at @length is necessary to distinguish + * it from the an empty translation. + * @hardware_keycode: the raw code of the key that was pressed or released. + * @group: the keyboard group. + * @is_modifier: a flag that indicates if @hardware_keycode is mapped to a + * modifier. Since 2.10 + * + * Describes a key press or key release event. + */ +struct _GdkEventKey +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + guint state; + guint keyval; + gint length; + gchar *string; + guint16 hardware_keycode; + guint8 group; + guint is_modifier : 1; +}; + +/** + * GdkEventCrossing: + * @type: the type of the event (%GDK_ENTER_NOTIFY or %GDK_LEAVE_NOTIFY). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @subwindow: the window that was entered or left. + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window. + * @y: the y coordinate of the pointer relative to the window. + * @x_root: the x coordinate of the pointer relative to the root of the screen. + * @y_root: the y coordinate of the pointer relative to the root of the screen. + * @mode: the crossing mode (%GDK_CROSSING_NORMAL, %GDK_CROSSING_GRAB, + * %GDK_CROSSING_UNGRAB, %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB or + * %GDK_CROSSING_STATE_CHANGED). %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB, + * and %GDK_CROSSING_STATE_CHANGED were added in 2.14 and are always synthesized, + * never native. + * @detail: the kind of crossing that happened (%GDK_NOTIFY_INFERIOR, + * %GDK_NOTIFY_ANCESTOR, %GDK_NOTIFY_VIRTUAL, %GDK_NOTIFY_NONLINEAR or + * %GDK_NOTIFY_NONLINEAR_VIRTUAL). + * @focus: %TRUE if @window is the focus window or an inferior. + * @state: (type GdkModifierType): a bit-mask representing the state of + * the modifier keys (e.g. Control, Shift and Alt) and the pointer + * buttons. See #GdkModifierType. + * + * Generated when the pointer enters or leaves a window. + */ +struct _GdkEventCrossing +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkWindow *subwindow; + guint32 time; + gdouble x; + gdouble y; + gdouble x_root; + gdouble y_root; + GdkCrossingMode mode; + GdkNotifyType detail; + gboolean focus; + guint state; +}; + +/** + * GdkEventFocus: + * @type: the type of the event (%GDK_FOCUS_CHANGE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @in: %TRUE if the window has gained the keyboard focus, %FALSE if + * it has lost the focus. + * + * Describes a change of keyboard focus. + */ +struct _GdkEventFocus +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gint16 in; +}; + +/** + * GdkEventConfigure: + * @type: the type of the event (%GDK_CONFIGURE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @x: the new x coordinate of the window, relative to its parent. + * @y: the new y coordinate of the window, relative to its parent. + * @width: the new width of the window. + * @height: the new height of the window. + * + * Generated when a window size or position has changed. + */ +struct _GdkEventConfigure +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gint x, y; + gint width; + gint height; +}; + +/** + * GdkEventProperty: + * @type: the type of the event (%GDK_PROPERTY_NOTIFY). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @atom: the property that was changed. + * @time: the time of the event in milliseconds. + * @state: (type GdkPropertyState): whether the property was changed + * (%GDK_PROPERTY_NEW_VALUE) or deleted (%GDK_PROPERTY_DELETE). + * + * Describes a property change on a window. + */ +struct _GdkEventProperty +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkAtom atom; + guint32 time; + guint state; +}; + +/** + * GdkEventSelection: + * @type: the type of the event (%GDK_SELECTION_CLEAR, + * %GDK_SELECTION_NOTIFY or %GDK_SELECTION_REQUEST). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @selection: the selection. + * @target: the target to which the selection should be converted. + * @property: the property in which to place the result of the conversion. + * @time: the time of the event in milliseconds. + * @requestor: the window on which to place @property or %NULL if none. + * + * Generated when a selection is requested or ownership of a selection + * is taken over by another client application. + */ +struct _GdkEventSelection +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkAtom selection; + GdkAtom target; + GdkAtom property; + guint32 time; + GdkWindow *requestor; +}; + +/** + * GdkEventOwnerChange: + * @type: the type of the event (%GDK_OWNER_CHANGE). + * @window: the window which received the event + * @send_event: %TRUE if the event was sent explicitly. + * @owner: the new owner of the selection, or %NULL if there is none + * @reason: the reason for the ownership change as a #GdkOwnerChange value + * @selection: the atom identifying the selection + * @time: the timestamp of the event + * @selection_time: the time at which the selection ownership was taken + * over + * + * Generated when the owner of a selection changes. On X11, this + * information is only available if the X server supports the XFIXES + * extension. + * + * Since: 2.6 + */ +struct _GdkEventOwnerChange +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkWindow *owner; + GdkOwnerChange reason; + GdkAtom selection; + guint32 time; + guint32 selection_time; +}; + +/** + * GdkEventProximity: + * @type: the type of the event (%GDK_PROXIMITY_IN or %GDK_PROXIMITY_OUT). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @device: the master device that the event originated from. Use + * gdk_event_get_source_device() to get the slave device. + * + * Proximity events are generated when using GDK’s wrapper for the + * XInput extension. The XInput extension is an add-on for standard X + * that allows you to use nonstandard devices such as graphics tablets. + * A proximity event indicates that the stylus has moved in or out of + * contact with the tablet, or perhaps that the user’s finger has moved + * in or out of contact with a touch screen. + * + * This event type will be used pretty rarely. It only is important for + * XInput aware programs that are drawing their own cursor. + */ +struct _GdkEventProximity +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + GdkDevice *device; +}; + +/** + * GdkEventSetting: + * @type: the type of the event (%GDK_SETTING). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @action: what happened to the setting (%GDK_SETTING_ACTION_NEW, + * %GDK_SETTING_ACTION_CHANGED or %GDK_SETTING_ACTION_DELETED). + * @name: the name of the setting. + * + * Generated when a setting is modified. + */ +struct _GdkEventSetting +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkSettingAction action; + char *name; +}; + +/** + * GdkEventWindowState: + * @type: the type of the event (%GDK_WINDOW_STATE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @changed_mask: mask specifying what flags have changed. + * @new_window_state: the new window state, a combination of + * #GdkWindowState bits. + * + * Generated when the state of a toplevel window changes. + */ +struct _GdkEventWindowState +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkWindowState changed_mask; + GdkWindowState new_window_state; +}; + +/** + * GdkEventGrabBroken: + * @type: the type of the event (%GDK_GRAB_BROKEN) + * @window: the window which received the event, i.e. the window + * that previously owned the grab + * @send_event: %TRUE if the event was sent explicitly. + * @keyboard: %TRUE if a keyboard grab was broken, %FALSE if a pointer + * grab was broken + * @implicit: %TRUE if the broken grab was implicit + * @grab_window: If this event is caused by another grab in the same + * application, @grab_window contains the new grab window. Otherwise + * @grab_window is %NULL. + * + * Generated when a pointer or keyboard grab is broken. On X11, this happens + * when the grab window becomes unviewable (i.e. it or one of its ancestors + * is unmapped), or if the same application grabs the pointer or keyboard + * again. Note that implicit grabs (which are initiated by button presses) + * can also cause #GdkEventGrabBroken events. + * + * Since: 2.8 + */ +struct _GdkEventGrabBroken { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gboolean keyboard; + gboolean implicit; + GdkWindow *grab_window; +}; + +/** + * GdkEventDND: + * @type: the type of the event (%GDK_DRAG_ENTER, %GDK_DRAG_LEAVE, + * %GDK_DRAG_MOTION, %GDK_DRAG_STATUS, %GDK_DROP_START or + * %GDK_DROP_FINISHED). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @context: the #GdkDragContext for the current DND operation. + * @time: the time of the event in milliseconds. + * @x_root: the x coordinate of the pointer relative to the root of the + * screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START. + * @y_root: the y coordinate of the pointer relative to the root of the + * screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START. + * + * Generated during DND operations. + */ +struct _GdkEventDND { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkDragContext *context; + + guint32 time; + gshort x_root, y_root; +}; + +/** + * GdkEventTouchpadSwipe: + * @type: the type of the event (%GDK_TOUCHPAD_SWIPE) + * @window: the window which received the event + * @send_event: %TRUE if the event was sent explicitly + * @phase: (type GdkTouchpadGesturePhase): the current phase of the gesture + * @n_fingers: The number of fingers triggering the swipe + * @time: the time of the event in milliseconds + * @x: The X coordinate of the pointer + * @y: The Y coordinate of the pointer + * @dx: Movement delta in the X axis of the swipe focal point + * @dy: Movement delta in the Y axis of the swipe focal point + * @x_root: The X coordinate of the pointer, relative to the + * root of the screen. + * @y_root: The Y coordinate of the pointer, relative to the + * root of the screen. + * @state: (type GdkModifierType): a bit-mask representing the state of + * the modifier keys (e.g. Control, Shift and Alt) and the pointer + * buttons. See #GdkModifierType. + * + * Generated during touchpad swipe gestures. + */ +struct _GdkEventTouchpadSwipe { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gint8 phase; + gint8 n_fingers; + guint32 time; + gdouble x; + gdouble y; + gdouble dx; + gdouble dy; + gdouble x_root, y_root; + guint state; +}; + +/** + * GdkEventTouchpadPinch: + * @type: the type of the event (%GDK_TOUCHPAD_PINCH) + * @window: the window which received the event + * @send_event: %TRUE if the event was sent explicitly + * @phase: (type GdkTouchpadGesturePhase): the current phase of the gesture + * @n_fingers: The number of fingers triggering the pinch + * @time: the time of the event in milliseconds + * @x: The X coordinate of the pointer + * @y: The Y coordinate of the pointer + * @dx: Movement delta in the X axis of the swipe focal point + * @dy: Movement delta in the Y axis of the swipe focal point + * @angle_delta: The angle change in radians, negative angles + * denote counter-clockwise movements + * @scale: The current scale, relative to that at the time of + * the corresponding %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN event + * @x_root: The X coordinate of the pointer, relative to the + * root of the screen. + * @y_root: The Y coordinate of the pointer, relative to the + * root of the screen. + * @state: (type GdkModifierType): a bit-mask representing the state of + * the modifier keys (e.g. Control, Shift and Alt) and the pointer + * buttons. See #GdkModifierType. + * + * Generated during touchpad swipe gestures. + */ +struct _GdkEventTouchpadPinch { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gint8 phase; + gint8 n_fingers; + guint32 time; + gdouble x; + gdouble y; + gdouble dx; + gdouble dy; + gdouble angle_delta; + gdouble scale; + gdouble x_root, y_root; + guint state; +}; + +/** + * GdkEventPadButton: + * @type: the type of the event (%GDK_PAD_BUTTON_PRESS or %GDK_PAD_BUTTON_RELEASE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @group: the pad group the button belongs to. A %GDK_SOURCE_TABLET_PAD device + * may have one or more groups containing a set of buttons/rings/strips each. + * @button: The pad button that was pressed. + * @mode: The current mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD + * device may have different current modes. + * + * Generated during %GDK_SOURCE_TABLET_PAD button presses and releases. + * + * Since: 3.22 + */ +struct _GdkEventPadButton { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + guint group; + guint button; + guint mode; +}; + +/** + * GdkEventPadAxis: + * @type: the type of the event (%GDK_PAD_RING or %GDK_PAD_STRIP). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @group: the pad group the ring/strip belongs to. A %GDK_SOURCE_TABLET_PAD + * device may have one or more groups containing a set of buttons/rings/strips + * each. + * @index: number of strip/ring that was interacted. This number is 0-indexed. + * @mode: The current mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD + * device may have different current modes. + * @value: The current value for the given axis. + * + * Generated during %GDK_SOURCE_TABLET_PAD interaction with tactile sensors. + * + * Since: 3.22 + */ +struct _GdkEventPadAxis { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + guint group; + guint index; + guint mode; + gdouble value; +}; + +/** + * GdkEventPadGroupMode: + * @type: the type of the event (%GDK_PAD_GROUP_MODE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly. + * @time: the time of the event in milliseconds. + * @group: the pad group that is switching mode. A %GDK_SOURCE_TABLET_PAD + * device may have one or more groups containing a set of buttons/rings/strips + * each. + * @mode: The new mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD + * device may have different current modes. + * + * Generated during %GDK_SOURCE_TABLET_PAD mode switches in a group. + * + * Since: 3.22 + */ +struct _GdkEventPadGroupMode { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + guint group; + guint mode; +}; + +/** + * GdkEvent: + * @type: the #GdkEventType + * @any: a #GdkEventAny + * @expose: a #GdkEventExpose + * @visibility: a #GdkEventVisibility + * @motion: a #GdkEventMotion + * @button: a #GdkEventButton + * @touch: a #GdkEventTouch + * @scroll: a #GdkEventScroll + * @key: a #GdkEventKey + * @crossing: a #GdkEventCrossing + * @focus_change: a #GdkEventFocus + * @configure: a #GdkEventConfigure + * @property: a #GdkEventProperty + * @selection: a #GdkEventSelection + * @owner_change: a #GdkEventOwnerChange + * @proximity: a #GdkEventProximity + * @dnd: a #GdkEventDND + * @window_state: a #GdkEventWindowState + * @setting: a #GdkEventSetting + * @grab_broken: a #GdkEventGrabBroken + * @touchpad_swipe: a #GdkEventTouchpadSwipe + * @touchpad_pinch: a #GdkEventTouchpadPinch + * @pad_button: a #GdkEventPadButton + * @pad_axis: a #GdkEventPadAxis + * @pad_group_mode: a #GdkEventPadGroupMode + * + * A #GdkEvent contains a union of all of the event types, + * and allows access to the data fields in a number of ways. + * + * The event type is always the first field in all of the event types, and + * can always be accessed with the following code, no matter what type of + * event it is: + * |[<!-- language="C" --> + * GdkEvent *event; + * GdkEventType type; + * + * type = event->type; + * ]| + * + * To access other fields of the event, the pointer to the event + * can be cast to the appropriate event type, or the union member + * name can be used. For example if the event type is %GDK_BUTTON_PRESS + * then the x coordinate of the button press can be accessed with: + * |[<!-- language="C" --> + * GdkEvent *event; + * gdouble x; + * + * x = ((GdkEventButton*)event)->x; + * ]| + * or: + * |[<!-- language="C" --> + * GdkEvent *event; + * gdouble x; + * + * x = event->button.x; + * ]| + */ +union _GdkEvent +{ + GdkEventType type; + GdkEventAny any; + GdkEventExpose expose; + GdkEventVisibility visibility; + GdkEventMotion motion; + GdkEventButton button; + GdkEventTouch touch; + GdkEventScroll scroll; + GdkEventKey key; + GdkEventCrossing crossing; + GdkEventFocus focus_change; + GdkEventConfigure configure; + GdkEventProperty property; + GdkEventSelection selection; + GdkEventOwnerChange owner_change; + GdkEventProximity proximity; + GdkEventDND dnd; + GdkEventWindowState window_state; + GdkEventSetting setting; + GdkEventGrabBroken grab_broken; + GdkEventTouchpadSwipe touchpad_swipe; + GdkEventTouchpadPinch touchpad_pinch; + GdkEventPadButton pad_button; + GdkEventPadAxis pad_axis; + GdkEventPadGroupMode pad_group_mode; +}; + +#endif /* __GDK_EVENTS_PRIVATE_H__ */ |