mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-11-16 05:30:28 +00:00
f28aa1ba02
GdkEvent has been a "I-can't-believe-this-is-not-OOP" type for ages, using a union of sub-types. This has always been problematic when it comes to implementing accessor functions: either you get generic API that takes a GdkEvent and uses a massive switch() to determine which event types have the data you're looking for; or you create namespaced accessors, but break language bindings horribly, as boxed types cannot have derived types. The recent conversion of GskRenderNode (which had similar issues) to GTypeInstance, and the fact that GdkEvent is now a completely opaque type, provide us with the chance of moving GdkEvent to GTypeInstance, and have sub-types for GdkEvent. The change from boxed type to GTypeInstance is pretty small, all things considered, but ends up cascading to a larger commit, as we still have backends and code in GTK trying to access GdkEvent structures directly. Additionally, the naming of the public getter functions requires renaming all the data structures to conform to the namespace/type-name pattern.
618 lines
23 KiB
C
618 lines
23 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/gdkdrag.h>
|
||
#include <gdk/gdkdevice.h>
|
||
#include <gdk/gdkdevicetool.h>
|
||
|
||
G_BEGIN_DECLS
|
||
|
||
#define GDK_EVENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_EVENT, GdkEventClass))
|
||
|
||
typedef struct _GdkEventClass GdkEventClass;
|
||
|
||
/*< private >
|
||
* GdkEvent:
|
||
* @ref_count: the reference count of the event
|
||
* @event_type: the specialized event type
|
||
* @surface: the surface of the event
|
||
* @device: the device of the event
|
||
* @source_device: the source device
|
||
* @time: a serial identifier of the event that can be used to order
|
||
* two events
|
||
* @flags: event flags
|
||
*
|
||
* The abstract type for all windowing system events.
|
||
*/
|
||
struct _GdkEvent
|
||
{
|
||
GTypeInstance parent_instance;
|
||
|
||
grefcount ref_count;
|
||
|
||
/* Specialised event type */
|
||
GdkEventType event_type;
|
||
|
||
/* The surface of the event */
|
||
GdkSurface *surface;
|
||
|
||
/* The devices associated to the event */
|
||
GdkDevice *device;
|
||
GdkDevice *source_device;
|
||
|
||
guint32 time;
|
||
guint16 flags;
|
||
};
|
||
|
||
/*< private >
|
||
* GdkEventClass:
|
||
* @finalize: a function called when the last reference held on an event is
|
||
* released; implementations of GdkEvent must chain up to the parent class
|
||
*
|
||
* The base class for events.
|
||
*/
|
||
struct _GdkEventClass
|
||
{
|
||
GTypeClass parent_class;
|
||
|
||
void (* finalize) (GdkEvent *event);
|
||
|
||
GdkModifierType (* get_state) (GdkEvent *event);
|
||
gboolean (* get_position) (GdkEvent *event,
|
||
double *x,
|
||
double *y);
|
||
GdkEventSequence * (* get_sequence) (GdkEvent *event);
|
||
GdkDeviceTool * (* get_tool) (GdkEvent *event);
|
||
gboolean (* get_axes) (GdkEvent *event,
|
||
double **axes,
|
||
guint *n_axes);
|
||
};
|
||
|
||
/*
|
||
* GdkDeleteEvent:
|
||
*
|
||
* Generated when a surface is deleted.
|
||
*/
|
||
struct _GdkDeleteEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
};
|
||
|
||
/*
|
||
* GdkMotionEvent:
|
||
* @state: (type GdkModifierType): a bit-mask representing the state of
|
||
* the modifier keys (e.g. Control, Shift and Alt) set during the motion
|
||
* event. See #GdkModifierType.
|
||
* @x: the x coordinate of the pointer relative to the surface.
|
||
* @y: the y coordinate of the pointer relative to the surface.
|
||
* @axes: @x, @y translated to the axes of @device, or %NULL if @device is
|
||
* the mouse.
|
||
* @history: (element-type GdkTimeCoord): a list of time and coordinates
|
||
* for other motion events that were compressed before delivering the
|
||
* current event
|
||
*
|
||
* Generated when the pointer moves.
|
||
*/
|
||
struct _GdkMotionEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
GdkModifierType state;
|
||
double x;
|
||
double y;
|
||
double *axes;
|
||
GdkDeviceTool *tool;
|
||
GList *history;
|
||
};
|
||
|
||
/*
|
||
* GdkButtonEvent:
|
||
* @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.
|
||
* @x: the x coordinate of the pointer relative to the surface.
|
||
* @y: the y coordinate of the pointer relative to the surface.
|
||
* @axes: @x, @y translated to the axes of @device, or %NULL if @device is
|
||
* the mouse.
|
||
* @tool: a #GdkDeviceTool
|
||
*
|
||
* Used for button press and button release events. The
|
||
* @type field will be one of %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE,
|
||
*/
|
||
struct _GdkButtonEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
GdkModifierType state;
|
||
guint button;
|
||
double x;
|
||
double y;
|
||
double *axes;
|
||
GdkDeviceTool *tool;
|
||
};
|
||
|
||
/*
|
||
* GdkTouchEvent:
|
||
* @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
|
||
* @x: the x coordinate of the pointer relative to the surface
|
||
* @y: the y coordinate of the pointer relative to the surface
|
||
* @axes: @x, @y translated to the axes of the event's device, or %NULL
|
||
* if @device is the mouse
|
||
* @sequence: the event sequence that the event belongs to
|
||
* @emulated: whether the event is the result of a pointer emulation
|
||
*
|
||
* 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 _GdkTouchEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
GdkModifierType state;
|
||
double x;
|
||
double y;
|
||
double *axes;
|
||
GdkEventSequence *sequence;
|
||
gboolean touch_emulating;
|
||
gboolean pointer_emulated;
|
||
};
|
||
|
||
/*
|
||
* GdkScrollEvent:
|
||
* @x: the x coordinate of the pointer relative to the surface.
|
||
* @y: the y coordinate of the pointer relative to the surface.
|
||
* @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).
|
||
* @delta_x: the x coordinate of the scroll delta
|
||
* @delta_y: the y coordinate of the scroll delta
|
||
* @pointer_emulated: whether the scroll event was the result of
|
||
* a pointer emulation
|
||
* @tool: a #GdkDeviceTool
|
||
*
|
||
* 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 _GdkScrollEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
double x;
|
||
double y;
|
||
GdkModifierType state;
|
||
GdkScrollDirection direction;
|
||
double delta_x;
|
||
double delta_y;
|
||
gboolean pointer_emulated;
|
||
gboolean is_stop;
|
||
GdkDeviceTool *tool;
|
||
};
|
||
|
||
/*
|
||
* GdkTranslatedKey:
|
||
* @keyval: the translated key symbol
|
||
* @consumed: the consumed modifiers
|
||
* @layout: the keyboard layout
|
||
* @level: the layout level
|
||
*
|
||
* Describes a translated key code.
|
||
*/
|
||
typedef struct {
|
||
guint keyval;
|
||
GdkModifierType consumed;
|
||
guint layout;
|
||
guint level;
|
||
} GdkTranslatedKey;
|
||
|
||
/*
|
||
* GdkKeyEvent:
|
||
* @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.
|
||
* @keycode: the raw code of the key that was pressed or released.
|
||
* @translated: the result of translating @keycode. First with the full
|
||
* @state, then while ignoring Caps Lock.
|
||
*
|
||
* Describes a key press or key release event.
|
||
*/
|
||
struct _GdkKeyEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
GdkModifierType state;
|
||
guint32 keycode;
|
||
gboolean key_is_modifier;
|
||
GdkTranslatedKey translated[2];
|
||
};
|
||
|
||
/*
|
||
* GdkCrossingEvent:
|
||
* @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.
|
||
* @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.
|
||
* @x: the x coordinate of the pointer relative to the surface.
|
||
* @y: the y coordinate of the pointer relative to the surface.
|
||
* @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 @surface is the focus surface or an inferior.
|
||
* @child_surface: the surface that was entered or left.
|
||
*
|
||
* Generated when the pointer enters or leaves a surface.
|
||
*/
|
||
struct _GdkCrossingEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
GdkModifierType state;
|
||
GdkCrossingMode mode;
|
||
double x;
|
||
double y;
|
||
GdkNotifyType detail;
|
||
gboolean focus;
|
||
GdkSurface *child_surface;
|
||
};
|
||
|
||
/*
|
||
* GdkFocusEvent:
|
||
* @in: %TRUE if the surface has gained the keyboard focus, %FALSE if
|
||
* it has lost the focus.
|
||
* @mode: the crossing mode
|
||
* @detail: the kind of crossing that happened
|
||
*
|
||
* Describes a change of keyboard focus.
|
||
*/
|
||
struct _GdkFocusEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
gboolean focus_in;
|
||
};
|
||
|
||
/*
|
||
* GdkConfigureEvent:
|
||
* @x: the new x coordinate of the surface, relative to its parent.
|
||
* @y: the new y coordinate of the surface, relative to its parent.
|
||
* @width: the new width of the surface.
|
||
* @height: the new height of the surface.
|
||
*
|
||
* Generated when a surface size or position has changed.
|
||
*/
|
||
struct _GdkConfigureEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
int x;
|
||
int y;
|
||
int width;
|
||
int height;
|
||
};
|
||
|
||
/*
|
||
* GdkProximityEvent:
|
||
* @tool: the #GdkDeviceTool associated to the event
|
||
*
|
||
* A proximity event indicates that a tool of a graphic tablet, or similar
|
||
* devices that report proximity, 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.
|
||
*/
|
||
struct _GdkProximityEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
GdkDeviceTool *tool;
|
||
};
|
||
|
||
/*
|
||
* GdkGrabBrokenEvent:
|
||
* @keyboard: %TRUE if a keyboard grab was broken, %FALSE if a pointer
|
||
* grab was broken
|
||
* @implicit: %TRUE if the broken grab was implicit
|
||
* @grab_surface: If this event is caused by another grab in the same
|
||
* application, @grab_surface contains the new grab surface. Otherwise
|
||
* @grab_surface is %NULL.
|
||
*
|
||
* Generated when a pointer or keyboard grab is broken. On X11, this happens
|
||
* when the grab surface 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 #GdkGrabBrokenEvent events.
|
||
*/
|
||
struct _GdkGrabBrokenEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
gboolean keyboard;
|
||
gboolean implicit;
|
||
GdkSurface *grab_surface;
|
||
};
|
||
|
||
/*
|
||
* GdkDNDEvent:
|
||
* @drop: the #GdkDrop for the current DND operation.
|
||
* @x: the X coordinate of the pointer
|
||
* @y: the Y coordinate of the pointer
|
||
*
|
||
* Generated during DND operations.
|
||
*/
|
||
struct _GdkDNDEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
GdkDrop *drop;
|
||
double x;
|
||
double y;
|
||
};
|
||
|
||
/*
|
||
* GdkTouchpadEvent:
|
||
* @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.
|
||
* @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: For pinch events, the angle change in radians, negative angles
|
||
* denote counter-clockwise movements
|
||
* @scale: For pinch events, the current scale, relative to that at the time of
|
||
* the corresponding %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN event
|
||
*
|
||
* Generated during touchpad gestures.
|
||
*/
|
||
struct _GdkTouchpadEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
GdkModifierType state;
|
||
gint8 phase;
|
||
gint8 n_fingers;
|
||
double x;
|
||
double y;
|
||
double dx;
|
||
double dy;
|
||
double angle_delta;
|
||
double scale;
|
||
};
|
||
|
||
struct _GdkPadEvent
|
||
{
|
||
GdkEvent parent_instance;
|
||
|
||
guint group;
|
||
guint mode;
|
||
guint button;
|
||
guint index;
|
||
double value;
|
||
};
|
||
|
||
void gdk_event_init_types (void);
|
||
|
||
GdkEvent * gdk_button_event_new (GdkEventType type,
|
||
GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
GdkDeviceTool *tool,
|
||
guint32 time,
|
||
GdkModifierType state,
|
||
guint button,
|
||
double x,
|
||
double y,
|
||
double *axes);
|
||
|
||
GdkEvent * gdk_motion_event_new (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
GdkDeviceTool *tool,
|
||
guint32 time,
|
||
GdkModifierType state,
|
||
double x,
|
||
double y,
|
||
double *axes);
|
||
|
||
GdkEvent * gdk_crossing_event_new (GdkEventType type,
|
||
GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
GdkModifierType state,
|
||
double x,
|
||
double y,
|
||
GdkCrossingMode mode,
|
||
GdkNotifyType notify);
|
||
|
||
GdkEvent * gdk_proximity_event_new (GdkEventType type,
|
||
GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
GdkDeviceTool *tool,
|
||
guint32 time);
|
||
|
||
GdkEvent * gdk_key_event_new (GdkEventType type,
|
||
GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
guint keycode,
|
||
GdkModifierType modifiers,
|
||
gboolean is_modifier,
|
||
GdkTranslatedKey *translated,
|
||
GdkTranslatedKey *no_lock);
|
||
|
||
GdkEvent * gdk_focus_event_new (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
gboolean focus_in);
|
||
|
||
GdkEvent * gdk_configure_event_new (GdkSurface *surface,
|
||
int width,
|
||
int height);
|
||
|
||
GdkEvent * gdk_delete_event_new (GdkSurface *surface);
|
||
|
||
GdkEvent * gdk_scroll_event_new (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
GdkDeviceTool *tool,
|
||
guint32 time,
|
||
GdkModifierType state,
|
||
double delta_x,
|
||
double delta_y,
|
||
gboolean is_stop);
|
||
|
||
GdkEvent * gdk_scroll_event_new_discrete (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
GdkDeviceTool *tool,
|
||
guint32 time,
|
||
GdkModifierType state,
|
||
GdkScrollDirection direction,
|
||
gboolean emulated);
|
||
|
||
GdkEvent * gdk_touch_event_new (GdkEventType type,
|
||
GdkEventSequence *sequence,
|
||
GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
GdkModifierType state,
|
||
double x,
|
||
double y,
|
||
double *axes,
|
||
gboolean emulating);
|
||
|
||
GdkEvent * gdk_touchpad_event_new_swipe (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
GdkModifierType state,
|
||
GdkTouchpadGesturePhase phase,
|
||
double x,
|
||
double y,
|
||
int n_fingers,
|
||
double dx,
|
||
double dy);
|
||
|
||
GdkEvent * gdk_touchpad_event_new_pinch (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
GdkModifierType state,
|
||
GdkTouchpadGesturePhase phase,
|
||
double x,
|
||
double y,
|
||
int n_fingers,
|
||
double dx,
|
||
double dy,
|
||
double scale,
|
||
double angle_delta);
|
||
|
||
GdkEvent * gdk_pad_event_new_ring (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
guint group,
|
||
guint index,
|
||
guint mode,
|
||
double value);
|
||
|
||
GdkEvent * gdk_pad_event_new_strip (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
guint group,
|
||
guint index,
|
||
guint mode,
|
||
double value);
|
||
|
||
GdkEvent * gdk_pad_event_new_button (GdkEventType type,
|
||
GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
guint group,
|
||
guint button,
|
||
guint mode);
|
||
|
||
GdkEvent * gdk_pad_event_new_group_mode (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
guint32 time,
|
||
guint group,
|
||
guint mode);
|
||
|
||
GdkEvent * gdk_dnd_event_new (GdkEventType type,
|
||
GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDrop *drop,
|
||
guint32 time,
|
||
double x,
|
||
double y);
|
||
|
||
GdkEvent * gdk_grab_broken_event_new (GdkSurface *surface,
|
||
GdkDevice *device,
|
||
GdkDevice *source_device,
|
||
GdkSurface *grab_surface,
|
||
gboolean implicit);
|
||
|
||
G_END_DECLS
|
||
|
||
#endif /* __GDK_EVENTS_PRIVATE_H__ */
|