mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-11-10 19:00:08 +00:00
5bd8884bf8
This information is rarely useful, and it is one of the last places where we create foreign windows.
811 lines
27 KiB
C
811 lines
27 KiB
C
/* 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. */
|
||
};
|
||
|
||
/**
|
||
* 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 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 or %GDK_BUTTON_RELEASE,
|
||
*/
|
||
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.
|
||
* @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;
|
||
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;
|
||
};
|
||
|
||
/**
|
||
* 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
|
||
* @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
|
||
* @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;
|
||
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;
|
||
GdkEventGrabBroken grab_broken;
|
||
GdkEventTouchpadSwipe touchpad_swipe;
|
||
GdkEventTouchpadPinch touchpad_pinch;
|
||
GdkEventPadButton pad_button;
|
||
GdkEventPadAxis pad_axis;
|
||
GdkEventPadGroupMode pad_group_mode;
|
||
};
|
||
|
||
#endif /* __GDK_EVENTS_PRIVATE_H__ */
|