AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-28 22:41:43 +00:00
Code Issues Projects Releases Wiki Activity
1bf94b045c
gtk/gdk/gdkeventsprivate.h

637 lines
24 KiB
C
Raw Normal View History

gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
/* 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/.
*/
Convert headers to #pragma once The conversion was done by guard2one.
2023-03-31 19:11:10 +00:00
#pragma once
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
#include <gdk/gdktypes.h>
dnd: Rename headers Rename gdkdnd.h to gdkdrag.h, to go along with gdkdrop.h This commit includes the necessary updates to the X11, Wayland and Broadway backends. Other backends have to be updated separately.
2018-07-02 11:39:09 +00:00
#include <gdk/gdkdrag.h>
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
#include <gdk/gdkdevice.h>
#include <gdk/gdkdevicetool.h>
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
G_BEGIN_DECLS
gdk: Drop event structs from the headers All events are GdkEvents now.
2020-02-21 02:22:16 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
#define GDK_EVENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_EVENT, GdkEventClass))
gdk: Drop event structs from the headers All events are GdkEvents now.
2020-02-21 02:22:16 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
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
* @time: a serial identifier of the event that can be used to order
* two events
* @flags: event flags
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* The abstract type for all windowing system events.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GTypeInstance parent_instance;
grefcount ref_count;
/* Specialised event type */
GdkEventType event_type;
/* The surface of the event */
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
GdkSurface *surface;
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
/* The devices associated to the event */
gdk: Fold GdkEventPrivate fields into event structs Now all events structs are private, it doesn't make as much sense having GdkEventPrivate wrapping allocating events. This is a first step towards removing it.
2017-10-11 06:42:41 +00:00
GdkDevice *device;
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
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;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkMotionEvent:
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) set during the motion
docs: Tag Gdk.ModifierType as flags
2021-11-07 17:14:15 +00:00
* event. See [flags@Gdk.ModifierType]
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
* @x: the x coordinate of the pointer relative to the surface.
* @y: the y coordinate of the pointer relative to the surface.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @axes: @x, @y translated to the axes of @device, or %NULL if @device is
* the mouse.
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @history: (element-type GdkTimeCoord): a list of time and coordinates
* for other motion events that were compressed before delivering the
* current event
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
* Generated when the pointer moves.
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkMotionEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent parent_instance;
Some event struct packing improvements Rearrange a few things, and move some booleans into the Any struct, by using a bitfield there. Some more cleanup could be done - the flags field with its PENDING and FLUSHED members appears entirely unused. Nobody is setting those flags.
2020-02-18 04:08:44 +00:00
GdkModifierType state;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
double x;
double y;
double *axes;
gdk: Fold GdkEventPrivate fields into event structs Now all events structs are private, it doesn't make as much sense having GdkEventPrivate wrapping allocating events. This is a first step towards removing it.
2017-10-11 06:42:41 +00:00
GdkDeviceTool *tool;
GdkEvent: Save history in a GArray Instead of a less efficient GList.
2020-04-25 15:50:11 +00:00
GArray *history; /* <GdkTimeCoord> */
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkButtonEvent:
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
docs: Tag Gdk.ModifierType as flags
2021-11-07 17:14:15 +00:00
* buttons. See [flags@Gdk.ModifierType]
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @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.
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @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.
gdk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:39:18 +00:00
* @tool: a `GdkDeviceTool`
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
* Used for button press and button release events. The
gtk: Remove 2BUTTON and 3BUTTON events and event types Those should be interpreted by widget-local gestures, not guessed at a high level with no notions of the specific context. Users will want GtkGestureMultiPress to replace these events.
2017-09-15 15:34:06 +00:00
* @type field will be one of %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE,
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkButtonEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent parent_instance;
Some event struct packing improvements Rearrange a few things, and move some booleans into the Any struct, by using a bitfield there. Some more cleanup could be done - the flags field with its PENDING and FLUSHED members appears entirely unused. Nobody is setting those flags.
2020-02-18 04:08:44 +00:00
GdkModifierType state;
guint button;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
double x;
double y;
double *axes;
gdk: Fold GdkEventPrivate fields into event structs Now all events structs are private, it doesn't make as much sense having GdkEventPrivate wrapping allocating events. This is a first step towards removing it.
2017-10-11 06:42:41 +00:00
GdkDeviceTool *tool;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkTouchEvent:
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
docs: Tag Gdk.ModifierType as flags
2021-11-07 17:14:15 +00:00
* buttons. See [flags@Gdk.ModifierType]
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @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
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @sequence: the event sequence that the event belongs to
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @emulated: whether the event is the result of a pointer emulation
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
* 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.
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkTouchEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent parent_instance;
Some event struct packing improvements Rearrange a few things, and move some booleans into the Any struct, by using a bitfield there. Some more cleanup could be done - the flags field with its PENDING and FLUSHED members appears entirely unused. Nobody is setting those flags.
2020-02-18 04:08:44 +00:00
GdkModifierType state;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
double x;
double y;
double *axes;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
GdkEventSequence *sequence;
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
gboolean touch_emulating;
gboolean pointer_emulated;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkScrollEvent:
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
* @x: the x coordinate of the pointer relative to the surface.
* @y: the y coordinate of the pointer relative to the surface.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
docs: Tag Gdk.ModifierType as flags
2021-11-07 17:14:15 +00:00
* buttons. See [flags@Gdk.ModifierType]
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @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
gdk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:39:18 +00:00
* @tool: a `GdkDeviceTool`
Cosmetrics: Remove mention of a nonexisting type No such thing as GdkScrollHistory.
2021-12-15 04:42:14 +00:00
* @history: (element-type GdkTimeCoord): array of times and deltas
Keep scroll history Similar to how we keep motion history for compressed events, keep scroll history for compressed scroll events.
2020-06-09 00:29:38 +00:00
* for other scroll events that were compressed before delivering the
* current event
gdk: Add enum to indicate the unit of scroll deltas Add a new GdkScrollUnit enum that represent the unit of scroll deltas provided by GdkScrollEvent. The unit is accessible through gdk_scroll_event_get_unit().
2022-02-21 15:22:57 +00:00
* @unit: The scroll unit in which delta_x and delta_y are represented.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
* 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().
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkScrollEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent parent_instance;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
GdkModifierType state;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
GdkScrollDirection direction;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
double delta_x;
double delta_y;
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
gboolean is_stop;
events: Make proximity and scroll events have tools The Wayland backend tries to set device tools on these events, and it was just an oversight that they don't carry them.
2020-02-14 21:46:43 +00:00
GdkDeviceTool *tool;
Cosmetrics: Remove mention of a nonexisting type No such thing as GdkScrollHistory.
2021-12-15 04:42:14 +00:00
GArray *history; /* <GdkTimeCoord> */
gdk: Add enum to indicate the unit of scroll deltas Add a new GdkScrollUnit enum that represent the unit of scroll deltas provided by GdkScrollEvent. The unit is accessible through gdk_scroll_event_get_unit().
2022-02-21 15:22:57 +00:00
GdkScrollUnit unit;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
/*
* GdkTranslatedKey:
* @keyval: the translated key symbol
* @consumed: the consumed modifiers
* @layout: the keyboard layout
* @level: the layout level
*
* Describes a translated key code.
*/
gdk: Redo key events Add all of the keyboard translation results in the key event, so we can translate the keyboard state at the time the event is created, and avoid doing state translation at match time. We actually need to carry two sets of translation results, since we ignore CapsLock when matching accelerators, in gdk_event_matches(). At the same time, drop the scancode field - it is only ever set on win32, and is basically unused in GTK. Update all callers.
2020-04-05 18:40:55 +00:00
typedef struct {
guint keyval;
GdkModifierType consumed;
guint layout;
guint level;
} GdkTranslatedKey;
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkKeyEvent:
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
docs: Tag Gdk.ModifierType as flags
2021-11-07 17:14:15 +00:00
* buttons. See [flags@Gdk.ModifierType]
gdk: Redo key events Add all of the keyboard translation results in the key event, so we can translate the keyboard state at the time the event is created, and avoid doing state translation at match time. We actually need to carry two sets of translation results, since we ignore CapsLock when matching accelerators, in gdk_event_matches(). At the same time, drop the scancode field - it is only ever set on win32, and is basically unused in GTK. Update all callers.
2020-04-05 18:40:55 +00:00
* @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.
Use native Windows API for converting keystrokes to characters
2022-08-24 11:21:10 +00:00
* @compose_sequence: optional string for use by selected IM modules.
* Contains either partial compose sequences or the final composed
* string of the keystroke sequence.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
* Describes a key press or key release event.
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkKeyEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent parent_instance;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
GdkModifierType state;
gdk: Redo key events Add all of the keyboard translation results in the key event, so we can translate the keyboard state at the time the event is created, and avoid doing state translation at match time. We actually need to carry two sets of translation results, since we ignore CapsLock when matching accelerators, in gdk_event_matches(). At the same time, drop the scancode field - it is only ever set on win32, and is basically unused in GTK. Update all callers.
2020-04-05 18:40:55 +00:00
guint32 keycode;
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
gboolean key_is_modifier;
gdk: Redo key events Add all of the keyboard translation results in the key event, so we can translate the keyboard state at the time the event is created, and avoid doing state translation at match time. We actually need to carry two sets of translation results, since we ignore CapsLock when matching accelerators, in gdk_event_matches(). At the same time, drop the scancode field - it is only ever set on win32, and is basically unused in GTK. Update all callers.
2020-04-05 18:40:55 +00:00
GdkTranslatedKey translated[2];
Use native Windows API for converting keystrokes to characters
2022-08-24 11:21:10 +00:00
char *compose_sequence;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkCrossingEvent:
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
docs: Tag Gdk.ModifierType as flags
2021-11-07 17:14:15 +00:00
* buttons. See [flags@Gdk.ModifierType]
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @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.
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @x: the x coordinate of the pointer relative to the surface.
* @y: the y coordinate of the pointer relative to the surface.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @detail: the kind of crossing that happened (%GDK_NOTIFY_INFERIOR,
* %GDK_NOTIFY_ANCESTOR, %GDK_NOTIFY_VIRTUAL, %GDK_NOTIFY_NONLINEAR or
* %GDK_NOTIFY_NONLINEAR_VIRTUAL).
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
* @focus: %TRUE if @surface is the focus surface or an inferior.
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @child_surface: the surface that was entered or left.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
* Generated when the pointer enters or leaves a surface.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkCrossingEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent parent_instance;
Some event struct packing improvements Rearrange a few things, and move some booleans into the Any struct, by using a bitfield there. Some more cleanup could be done - the flags field with its PENDING and FLUSHED members appears entirely unused. Nobody is setting those flags.
2020-02-18 04:08:44 +00:00
GdkModifierType state;
GdkCrossingMode mode;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
double x;
double y;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
GdkNotifyType detail;
gboolean focus;
Some event struct packing improvements Rearrange a few things, and move some booleans into the Any struct, by using a bitfield there. Some more cleanup could be done - the flags field with its PENDING and FLUSHED members appears entirely unused. Nobody is setting those flags.
2020-02-18 04:08:44 +00:00
GdkSurface *child_surface;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkFocusEvent:
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
* @in: %TRUE if the surface has gained the keyboard focus, %FALSE if
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* it has lost the focus.
gdk: Add crossing mode and detail to focus events We want focus events more similar to crossing events.
2019-03-06 21:55:27 +00:00
* @mode: the crossing mode
* @detail: the kind of crossing that happened
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
* Describes a change of keyboard focus.
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkFocusEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent parent_instance;
gboolean focus_in;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkProximityEvent:
gdk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:39:18 +00:00
* @tool: the `GdkDeviceTool` associated to the event
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* 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.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkProximityEvent
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
{
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent parent_instance;
events: Make proximity and scroll events have tools The Wayland backend tries to set device tools on these events, and it was just an oversight that they don't carry them.
2020-02-14 21:46:43 +00:00
GdkDeviceTool *tool;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkGrabBrokenEvent:
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @keyboard: %TRUE if a keyboard grab was broken, %FALSE if a pointer
* grab was broken
* @implicit: %TRUE if the broken grab was implicit
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
* @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.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
* Generated when a pointer or keyboard grab is broken. On X11, this happens
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
* when the grab surface becomes unviewable (i.e. it or one of its ancestors
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* is unmapped), or if the same application grabs the pointer or keyboard
* again. Note that implicit grabs (which are initiated by button presses)
gdk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:39:18 +00:00
* can also cause `GdkGrabBrokenEvent` events.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkGrabBrokenEvent
{
GdkEvent parent_instance;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
gboolean keyboard;
gboolean implicit;
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
GdkSurface *grab_surface;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkDNDEvent:
gdk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:39:18 +00:00
* @drop: the `GdkDrop` for the current DND operation.
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @x: the X coordinate of the pointer
* @y: the Y coordinate of the pointer
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*
* Generated during DND operations.
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkDNDEvent
{
GdkEvent parent_instance;
events: Make GdkEventDND have a GdkDrop member ... instead of a GdkDragContext.
2018-05-29 18:49:41 +00:00
GdkDrop *drop;
gdk: Fix coordinates in dnd events Don't store coordinates as shorts. Use doubles, as everywhere else. Also add x, y in addition to x_root, y_root, and actually return those in gdk_event_get_coords.
2019-12-30 16:56:49 +00:00
double x;
double y;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Try to make the docs build more quiet Not sure if this really makes a difference.
2017-12-26 15:30:50 +00:00
/*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* GdkTouchpadEvent:
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
docs: Tag Gdk.ModifierType as flags
2021-11-07 17:14:15 +00:00
* buttons. See [flags@Gdk.ModifierType]
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* @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
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @angle_delta: For pinch events, the angle change in radians, negative angles
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* denote counter-clockwise movements
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* @scale: For pinch events, the current scale, relative to that at the time of
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
* the corresponding %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN event
*
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
* Generated during touchpad gestures.
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
*/
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkTouchpadEvent
{
GdkEvent parent_instance;
gdk: Prepare touchpad events for sequences It makes sense to connect the begin/update/end events for touchpad swipes and pinches in a sequence. This commit adds the plumbing for it, but not backends are setting sequences yet.
2021-12-16 01:11:51 +00:00
GdkEventSequence *sequence;
Some event struct packing improvements Rearrange a few things, and move some booleans into the Any struct, by using a bitfield there. Some more cleanup could be done - the flags field with its PENDING and FLUSHED members appears entirely unused. Nobody is setting those flags.
2020-02-18 04:08:44 +00:00
GdkModifierType state;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
gint8 phase;
gint8 n_fingers;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
double x;
double y;
double dx;
double dy;
double angle_delta;
double scale;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
struct _GdkPadEvent
{
GdkEvent parent_instance;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
guint group;
guint mode;
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
guint button;
guint index;
Streamline event structs Use proper types (GdkModifierType, double), and drop some unused fields (send_event, display).
2020-02-18 03:20:01 +00:00
double value;
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
};
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
void gdk_event_init_types (void);
gdk: Make GdkEvent structs/union opaque All users are forced to deal with events as opaque pointers, only using API to access the info.
2017-08-05 13:34:39 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_button_event_new (GdkEventType type,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkSurface *surface,
GdkDevice *device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
guint button,
double x,
double y,
double *axes);
GdkEvent: Save history in a GArray Instead of a less efficient GList.
2020-04-25 15:50:11 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_motion_event_new (GdkSurface *surface,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
double x,
double y,
double *axes);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_crossing_event_new (GdkEventType type,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkSurface *surface,
GdkDevice *device,
guint32 time,
GdkModifierType state,
double x,
double y,
GdkCrossingMode mode,
GdkNotifyType notify);
GdkEvent: Save history in a GArray Instead of a less efficient GList.
2020-04-25 15:50:11 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_proximity_event_new (GdkEventType type,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkSurface *surface,
GdkDevice *device,
GdkDeviceTool *tool,
guint32 time);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_key_event_new (GdkEventType type,
gdk: Redo key events Add all of the keyboard translation results in the key event, so we can translate the keyboard state at the time the event is created, and avoid doing state translation at match time. We actually need to carry two sets of translation results, since we ignore CapsLock when matching accelerators, in gdk_event_matches(). At the same time, drop the scancode field - it is only ever set on win32, and is basically unused in GTK. Update all callers.
2020-04-05 18:40:55 +00:00
GdkSurface *surface,
GdkDevice *device,
guint32 time,
guint keycode,
GdkModifierType modifiers,
gboolean is_modifier,
GdkTranslatedKey *translated,
Use native Windows API for converting keystrokes to characters
2022-08-24 11:21:10 +00:00
GdkTranslatedKey *no_lock,
char *compose_sequence);
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_focus_event_new (GdkSurface *surface,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
gboolean focus_in);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_delete_event_new (GdkSurface *surface);
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_scroll_event_new (GdkSurface *surface,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
double delta_x,
double delta_y,
gdk: Add enum to indicate the unit of scroll deltas Add a new GdkScrollUnit enum that represent the unit of scroll deltas provided by GdkScrollEvent. The unit is accessible through gdk_scroll_event_get_unit().
2022-02-21 15:22:57 +00:00
gboolean is_stop,
GdkScrollUnit unit);
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_scroll_event_new_discrete (GdkSurface *surface,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
Drop pointer_emulated discrete scroll events GTK4 has had smooth scroll events since the beginning, so we prefer not to emit emulated discrete scroll events at all
2022-05-06 11:50:23 +00:00
GdkScrollDirection direction);
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
gdk/events: Add constructor for high-resolution scroll events Starting with Linux Kernel v5.0 two new axes are available for mice that support high-resolution wheel scrolling: REL_WHEEL_HI_RES and REL_HWHEEL_HI_RES. Both axes send data in fractions of 120 where each multiple of 120 amounts to one logical scroll event. Fractions of 120 indicate a wheel movement less than one detent. The 120 magic number is a copy of the Windows API, so this new constructor can be used both in Linux >= 5.0 and Windows >= Vista.
2021-09-20 17:59:35 +00:00
GdkEvent * gdk_scroll_event_new_value120 (GdkSurface *surface,
GdkDevice *device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
GdkScrollDirection direction,
double delta_x,
double delta_y);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_touch_event_new (GdkEventType type,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkEventSequence *sequence,
GdkSurface *surface,
GdkDevice *device,
guint32 time,
GdkModifierType state,
double x,
double y,
double *axes,
gboolean emulating);
GdkEvent: Save history in a GArray Instead of a less efficient GList.
2020-04-25 15:50:11 +00:00
gdk: Prepare touchpad events for sequences It makes sense to connect the begin/update/end events for touchpad swipes and pinches in a sequence. This commit adds the plumbing for it, but not backends are setting sequences yet.
2021-12-16 01:11:51 +00:00
GdkEvent * gdk_touchpad_event_new_swipe (GdkSurface *surface,
GdkEventSequence *sequence,
GdkDevice *device,
guint32 time,
GdkModifierType state,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkTouchpadGesturePhase phase,
gdk: Prepare touchpad events for sequences It makes sense to connect the begin/update/end events for touchpad swipes and pinches in a sequence. This commit adds the plumbing for it, but not backends are setting sequences yet.
2021-12-16 01:11:51 +00:00
double x,
double y,
int n_fingers,
double dx,
double dy);
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_touchpad_event_new_pinch (GdkSurface *surface,
gdk: Prepare touchpad events for sequences It makes sense to connect the begin/update/end events for touchpad swipes and pinches in a sequence. This commit adds the plumbing for it, but not backends are setting sequences yet.
2021-12-16 01:11:51 +00:00
GdkEventSequence *sequence,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
guint32 time,
GdkModifierType state,
GdkTouchpadGesturePhase phase,
double x,
double y,
int n_fingers,
double dx,
double dy,
double scale,
double angle_delta);
gdk/events: Add hold GdkEvent Allow to create hold events as well as the required functions to get information about the event: gesture phase, finger count, etc Part-of: <!3454>
2021-06-27 09:49:24 +00:00
GdkEvent * gdk_touchpad_event_new_hold (GdkSurface *surface,
gdkevent: Give touchpad hold events a sequence Following what was done for pinch/swipe events, give hold gestures their own distinct sequence as well. Without this it was NULL, which was already distinct to other touchpad gestures.
2022-08-05 09:35:28 +00:00
GdkEventSequence *sequence,
gdk/events: Add hold GdkEvent Allow to create hold events as well as the required functions to get information about the event: gesture phase, finger count, etc Part-of: <!3454>
2021-06-27 09:49:24 +00:00
GdkDevice *device,
guint32 time,
GdkModifierType state,
GdkTouchpadGesturePhase phase,
double x,
double y,
int n_fingers);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_pad_event_new_ring (GdkSurface *surface,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
guint32 time,
guint group,
guint index,
guint mode,
double value);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_pad_event_new_strip (GdkSurface *surface,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
guint32 time,
guint group,
guint index,
guint mode,
double value);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_pad_event_new_button (GdkEventType type,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkSurface *surface,
GdkDevice *device,
guint32 time,
guint group,
guint button,
guint mode);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_pad_event_new_group_mode (GdkSurface *surface,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
guint32 time,
guint group,
guint mode);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_dnd_event_new (GdkEventType type,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkSurface *surface,
GdkDevice *device,
GdkDrop *drop,
guint32 time,
double x,
double y);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
GdkEvent * gdk_grab_broken_event_new (GdkSurface *surface,
gdk: Add event constructors Add private API to construct events. This is a step towards making events readonly, and not objects anymore. The constructors here are sufficient to convert the Wayland backend over. More may be added for other backends as needed. Open issues: - history
2020-02-14 13:09:59 +00:00
GdkDevice *device,
GdkSurface *grab_surface,
gboolean implicit);
Add private accessor for GdkKeyEvent.translated Avoid accessing the event structure directly, even from within GTK.
2020-05-22 11:35:58 +00:00
GdkTranslatedKey * gdk_key_event_get_translated_key (GdkEvent *event,
gboolean no_lock);
Use native Windows API for converting keystrokes to characters
2022-08-24 11:21:10 +00:00
char * gdk_key_event_get_compose_sequence (GdkEvent *event);
gdk: Slim down gdkinternals.h more Move things to the private headers they belong in.
2020-08-14 01:47:54 +00:00
typedef enum
{
/* Following flag is set for events on the event queue during
* translation and cleared afterwards.
*/
GDK_EVENT_PENDING = 1 << 0,
/* When we are ready to draw a frame, we pause event delivery,
* mark all events in the queue with this flag, and deliver
* only those events until we finish the frame.
*/
GDK_EVENT_FLUSHED = 1 << 2
} GdkEventFlags;
GdkEvent* _gdk_event_unqueue (GdkDisplay *display);
void _gdk_event_emit (GdkEvent *event);
GList* _gdk_event_queue_find_first (GdkDisplay *display);
void _gdk_event_queue_remove_link (GdkDisplay *display,
GList *node);
GList* _gdk_event_queue_append (GdkDisplay *display,
GdkEvent *event);
void _gdk_event_queue_handle_motion_compression (GdkDisplay *display);
void gdk_event_queue_handle_scroll_compression (GdkDisplay *display);
void _gdk_event_queue_flush (GdkDisplay *display);
main: Add & use gdk_event_dup_axes() The way this code is written trips up scan-build. Add gdk_event_dup_axes() and use it in gtkmain.c.
2020-12-17 15:32:31 +00:00
double * gdk_event_dup_axes (GdkEvent *event);
Restructure the GdkEvent type hierarchy 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.
2020-04-16 16:23:36 +00:00
G_END_DECLS
GdkEvent: Make gdk_event_set_user_data private
2019-01-17 16:02:49 +00:00
Reference in New Issue Copy Permalink