1	/* GDK - The GIMP Drawing Kit
2	* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3	*
4	* This library is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU Lesser General Public
6	* License as published by the Free Software Foundation; either
7	* version 2 of the License, or (at your option) any later version.
8	*
9	* This library is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	* Lesser General Public License for more details.
13	*
14	* You should have received a copy of the GNU Lesser General Public
15	* License along with this library. If not, see <http://www.gnu.org/licenses/>.
16	*/
17
18	/*
19	* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
20	* file for a list of people on the GTK+ Team. See the ChangeLog
21	* files for a list of changes. These files are distributed with
22	* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
23	*/
24
25	#include "config.h"
26
27	#include "gdkdisplayprivate.h"
28	#include "gdkdragprivate.h"
29	#include "gdkdropprivate.h"
30	#include "gdkeventsprivate.h"
31	#include "gdkintl.h"
32	#include "gdkkeysprivate.h"
33	#include "gdkkeysyms.h"
34	#include "gdk-private.h"
35
36	#include <gobject/gvaluecollector.h>
37
38	#include <string.h>
39	#include <math.h>
40
41	/**
42	* GdkEvent: (ref-func gdk_event_ref) (unref-func gdk_event_unref)
43	*
44	* `GdkEvent`s are immutable data structures, created by GDK to
45	* represent windowing system events.
46	*
47	* In GTK applications the events are handled automatically by toplevel
48	* widgets and passed on to the event controllers of appropriate widgets,
49	* so using `GdkEvent` and its related API is rarely needed.
50	*/
51
52	/**
53	* GdkEventSequence:
54	*
55	* `GdkEventSequence` is an opaque type representing a sequence
56	* of related touch events.
57	*/
58
59	static void
60	value_event_init (GValue *value)
61	{
62	value->data[0].v_pointer = NULL;
63	}
64
65	static void
66	value_event_free_value (GValue *value)
67	{
68	if (value->data[0].v_pointer != NULL)
69	gdk_event_unref (event: value->data[0].v_pointer);
70	}
71
72	static void
73	value_event_copy_value (const GValue *src,
74	GValue *dst)
75	{
76	if (src->data[0].v_pointer != NULL)
77	dst->data[0].v_pointer = gdk_event_ref (event: src->data[0].v_pointer);
78	else
79	dst->data[0].v_pointer = NULL;
80	}
81
82	static gpointer
83	value_event_peek_pointer (const GValue *value)
84	{
85	return value->data[0].v_pointer;
86	}
87
88	static char *
89	value_event_collect_value (GValue *value,
90	guint n_collect_values,
91	GTypeCValue *collect_values,
92	guint collect_flags)
93	{
94	GdkEvent *event = collect_values[0].v_pointer;
95
96	if (event == NULL)
97	{
98	value->data[0].v_pointer = NULL;
99	return NULL;
100	}
101
102	if (event->parent_instance.g_class == NULL)
103	return g_strconcat (string1: "invalid unclassed GdkEvent pointer for "
104	"value type '",
105	G_VALUE_TYPE_NAME (value),
106	"'",
107	NULL);
108
109	value->data[0].v_pointer = gdk_event_ref (event);
110
111	return NULL;
112	}
113
114	static char *
115	value_event_lcopy_value (const GValue *value,
116	guint n_collect_values,
117	GTypeCValue *collect_values,
118	guint collect_flags)
119	{
120	GdkEvent **event_p = collect_values[0].v_pointer;
121
122	if (event_p == NULL)
123	return g_strconcat (string1: "value location for '",
124	G_VALUE_TYPE_NAME (value),
125	"' passed as NULL",
126	NULL);
127
128	if (value->data[0].v_pointer == NULL)
129	*event_p = NULL;
130	else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
131	*event_p = value->data[0].v_pointer;
132	else
133	*event_p = gdk_event_ref (event: value->data[0].v_pointer);
134
135	return NULL;
136	}
137
138	static void
139	gdk_event_finalize (GdkEvent *self)
140	{
141	g_clear_object (&self->surface);
142	g_clear_object (&self->device);
143
144	g_type_free_instance (instance: (GTypeInstance *) self);
145	}
146
147	static GdkModifierType
148	gdk_event_real_get_state (GdkEvent *self)
149	{
150	return 0;
151	}
152
153	static gboolean
154	gdk_event_real_get_position (GdkEvent *self,
155	double *x,
156	double *y)
157	{
158	*x = NAN;
159	*y = NAN;
160
161	return FALSE;
162	}
163
164	static GdkEventSequence *
165	gdk_event_real_get_sequence (GdkEvent *self)
166	{
167	return NULL;
168	}
169
170	static GdkDeviceTool *
171	gdk_event_real_get_tool (GdkEvent *self)
172	{
173	return NULL;
174	}
175
176	static gboolean
177	gdk_event_real_get_axes (GdkEvent *self,
178	double **axes,
179	guint *n_axes)
180	{
181	return FALSE;
182	}
183
184	static void
185	gdk_event_class_init (GdkEventClass *klass)
186	{
187	klass->finalize = gdk_event_finalize;
188	klass->get_state = gdk_event_real_get_state;
189	klass->get_position = gdk_event_real_get_position;
190	klass->get_sequence = gdk_event_real_get_sequence;
191	klass->get_tool = gdk_event_real_get_tool;
192	klass->get_axes = gdk_event_real_get_axes;
193	}
194
195	static void
196	gdk_event_init (GdkEvent *self)
197	{
198	g_ref_count_init (rc: &self->ref_count);
199	}
200
201	GType
202	gdk_event_get_type (void)
203	{
204	static gsize event_type__volatile;
205
206	if (g_once_init_enter (&event_type__volatile))
207	{
208	static const GTypeFundamentalInfo finfo = {
209	(G_TYPE_FLAG_CLASSED |
210	G_TYPE_FLAG_INSTANTIATABLE |
211	G_TYPE_FLAG_DERIVABLE |
212	G_TYPE_FLAG_DEEP_DERIVABLE),
213	};
214
215	static const GTypeValueTable value_table = {
216	value_event_init,
217	value_event_free_value,
218	value_event_copy_value,
219	value_event_peek_pointer,
220	"p",
221	value_event_collect_value,
222	"p",
223	value_event_lcopy_value,
224	};
225
226	const GTypeInfo event_info = {
227	/* Class */
228	sizeof (GdkEventClass),
229	(GBaseInitFunc) NULL,
230	(GBaseFinalizeFunc) NULL,
231	(GClassInitFunc) gdk_event_class_init,
232	(GClassFinalizeFunc) NULL,
233	NULL,
234
235	/* Instance */
236	sizeof (GdkEvent),
237	0,
238	(GInstanceInitFunc) gdk_event_init,
239
240	/* GValue */
241	&value_table,
242	};
243
244	GType event_type =
245	g_type_register_fundamental (type_id: g_type_fundamental_next (),
246	type_name: g_intern_static_string (string: "GdkEvent"),
247	info: &event_info, finfo: &finfo,
248	flags: G_TYPE_FLAG_ABSTRACT);
249
250	g_once_init_leave (&event_type__volatile, event_type);
251	}
252
253	return event_type__volatile;
254	}
255
256	/*< private >
257	* GdkEventTypeInfo:
258	* @instance_size: the size of the instance of a GdkEvent subclass
259	* @instance_init: (nullable): the function to initialize the instance data
260	* @finalize: (nullable): the function to free the instance data
261	* @get_state: (nullable): the function to retrieve the `GdkModifierType`:w
262	* associated to the event
263	* @get_position: (nullable): the function to retrieve the event coordinates
264	* @get_sequence: (nullable): the function to retrieve the event sequence
265	* @get_tool: (nullable): the function to retrieve the event's device tool
266	* @get_axes: (nullable): the function to retrieve the event's axes
267	*
268	* A structure used when registering a new GdkEvent type.
269	*/
270	typedef struct {
271	gsize instance_size;
272
273	void (* instance_init) (GdkEvent *event);
274	void (* finalize) (GdkEvent *event);
275
276	GdkModifierType (* get_state) (GdkEvent *event);
277
278	gboolean (* get_position) (GdkEvent *event,
279	double *x,
280	double *y);
281
282	GdkEventSequence *(* get_sequence) (GdkEvent *event);
283
284	GdkDeviceTool *(* get_tool) (GdkEvent *event);
285
286	gboolean (* get_axes) (GdkEvent *event,
287	double **axes,
288	guint *n_axes);
289	} GdkEventTypeInfo;
290
291	static void
292	gdk_event_generic_class_init (gpointer g_class,
293	gpointer class_data)
294	{
295	GdkEventTypeInfo *info = class_data;
296	GdkEventClass *event_class = g_class;
297
298	/* Optional */
299	if (info->finalize != NULL)
300	event_class->finalize = info->finalize;
301	if (info->get_state != NULL)
302	event_class->get_state = info->get_state;
303	if (info->get_position != NULL)
304	event_class->get_position = info->get_position;
305	if (info->get_sequence != NULL)
306	event_class->get_sequence = info->get_sequence;
307	if (info->get_tool != NULL)
308	event_class->get_tool = info->get_tool;
309	if (info->get_axes != NULL)
310	event_class->get_axes = info->get_axes;
311
312	g_free (mem: info);
313	}
314
315	static GType
316	gdk_event_type_register_static (const char *type_name,
317	const GdkEventTypeInfo *type_info)
318	{
319	GTypeInfo info;
320
321	info.class_size = sizeof (GdkEventClass);
322	info.base_init = NULL;
323	info.base_finalize = NULL;
324	info.class_init = gdk_event_generic_class_init;
325	info.class_finalize = NULL;
326	info.class_data = g_memdup2 (mem: type_info, byte_size: sizeof (GdkEventTypeInfo));
327
328	info.instance_size = type_info->instance_size;
329	info.n_preallocs = 0;
330	info.instance_init = (GInstanceInitFunc) type_info->instance_init;
331	info.value_table = NULL;
332
333	return g_type_register_static (GDK_TYPE_EVENT, type_name, info: &info, flags: 0);
334	}
335
336	/* Map GdkEventType to the appropriate GType */
337	static GType gdk_event_types[GDK_EVENT_LAST];
338
339	/*< private >
340	* GDK_EVENT_TYPE_SLOT:
341	* @ETYPE: a `GdkEvent`Type
342	*
343	* Associates a `GdkEvent` type with the given `GdkEvent`Type enumeration.
344	*
345	* This macro can only be used with %GDK_DEFINE_EVENT_TYPE.
346	*/
347	#define GDK_EVENT_TYPE_SLOT(ETYPE) { gdk_event_types[ETYPE] = gdk_define_event_type_id; }
348
349	/*< private >
350	* GDK_DEFINE_EVENT_TYPE:
351	* @TypeName: the type name, in camel case
352	* @type_name: the type name, in snake case
353	* @type_info: the address of the `GdkEvent`TypeInfo for the event type
354	* @_C_: custom code to call after registering the event type
355	*
356	* Registers a new `GdkEvent` subclass with the given @TypeName and @type_info.
357	*
358	* Similarly to %G_DEFINE_TYPE_WITH_CODE, this macro will generate a `get_type()`
359	* function that registers the event type.
360	*
361	* You can specify code to be run after the type registration; the `GType` of
362	* the event is available in the `gdk_define_event_type_id` variable.
363	*/
364	#define GDK_DEFINE_EVENT_TYPE(TypeName, type_name, type_info, _C_) \
365	GType \
366	type_name ## _get_type (void) \
367	{ \
368	static gsize gdk_define_event_type_id__volatile; \
369	if (g_once_init_enter (&gdk_define_event_type_id__volatile)) \
370	{ \
371	GType gdk_define_event_type_id = \
372	gdk_event_type_register_static (g_intern_static_string (#TypeName), type_info); \
373	{ _C_ } \
374	g_once_init_leave (&gdk_define_event_type_id__volatile, gdk_define_event_type_id); \
375	} \
376	return gdk_define_event_type_id__volatile; \
377	}
378
379	#define GDK_EVENT_SUPER(event) \
380	((GdkEventClass *) g_type_class_peek (g_type_parent (G_TYPE_FROM_INSTANCE (event))))
381
382	/*< private >
383	* gdk_event_alloc:
384	* @event_type: the `GdkEvent`Type to allocate
385	* @surface: (nullable): the `GdkSurface` of the event
386	* @device: (nullable): the `GdkDevice` of the event
387	* @time_: the event serial
388	*
389	* Allocates a `GdkEvent` for the given @event_type, and sets its
390	* common fields with the given parameters.
391	*
392	* Returns: (transfer full): the newly allocated `GdkEvent` instance
393	*/
394	static gpointer
395	gdk_event_alloc (GdkEventType event_type,
396	GdkSurface *surface,
397	GdkDevice *device,
398	guint32 time_)
399	{
400	g_assert (event_type >= GDK_DELETE && event_type < GDK_EVENT_LAST);
401	g_assert (gdk_event_types[event_type] != G_TYPE_INVALID);
402
403	GdkEvent *event = (GdkEvent *) g_type_create_instance (type: gdk_event_types[event_type]);
404
405	GDK_NOTE (EVENTS, {
406	char *str = g_enum_to_string (GDK_TYPE_EVENT_TYPE, event_type);
407	g_message ("Allocating a new %s for event type %s",
408	g_type_name (gdk_event_types[event_type]), str);
409	g_free (str);
410	});
411
412	event->event_type = event_type;
413	event->surface = surface != NULL ? g_object_ref (surface) : NULL;
414	event->device = device != NULL ? g_object_ref (device) : NULL;
415	event->time = time_;
416
417	if (device != NULL && time_ != GDK_CURRENT_TIME)
418	gdk_device_set_timestamp (device, timestamp: time_);
419
420	return event;
421	}
422
423	static void
424	gdk_event_init_types_once (void)
425	{
426	g_type_ensure (GDK_TYPE_BUTTON_EVENT);
427	g_type_ensure (GDK_TYPE_CROSSING_EVENT);
428	g_type_ensure (GDK_TYPE_DELETE_EVENT);
429	g_type_ensure (GDK_TYPE_DND_EVENT);
430	g_type_ensure (GDK_TYPE_FOCUS_EVENT);
431	g_type_ensure (GDK_TYPE_GRAB_BROKEN_EVENT);
432	g_type_ensure (GDK_TYPE_KEY_EVENT);
433	g_type_ensure (GDK_TYPE_MOTION_EVENT);
434	g_type_ensure (GDK_TYPE_PAD_EVENT);
435	g_type_ensure (GDK_TYPE_PROXIMITY_EVENT);
436	g_type_ensure (GDK_TYPE_SCROLL_EVENT);
437	g_type_ensure (GDK_TYPE_TOUCH_EVENT);
438	g_type_ensure (GDK_TYPE_TOUCHPAD_EVENT);
439	}
440
441	/*< private >
442	* gdk_event_init_types:
443	*
444	* Initializes all GdkEvent types.
445	*/
446	void
447	gdk_event_init_types (void)
448	{
449	static gsize event_types__volatile;
450
451	if (g_once_init_enter (&event_types__volatile))
452	{
453	gboolean initialized = FALSE;
454
455	gdk_event_init_types_once ();
456	initialized = TRUE;
457
458	g_once_init_leave (&event_types__volatile, initialized);
459	}
460	}
461
462	#ifdef G_ENABLE_DEBUG
463	static gboolean
464	check_event_sanity (GdkEvent *event)
465	{
466	if (event->device != NULL &&
467	gdk_surface_get_display (surface: event->surface) != gdk_device_get_display (device: event->device))
468	{
469	char *type = g_enum_to_string (g_enum_type: GDK_TYPE_EVENT_TYPE, value: event->event_type);
470	g_warning ("Event of type %s with mismatched device display", type);
471	g_free (mem: type);
472	return FALSE;
473	}
474
475	return TRUE;
476	}
477	#endif
478
479	void
480	_gdk_event_emit (GdkEvent *event)
481	{
482	#ifdef G_ENABLE_DEBUG
483	if (!check_event_sanity (event))
484	return;
485	#endif
486
487	if (gdk_drag_handle_source_event (event))
488	return;
489
490	gdk_surface_handle_event (event);
491	}
492
493	/*********************************************
494	* Functions for maintaining the event queue *
495	*********************************************/
496
497	/**
498	* _gdk_event_queue_find_first:
499	* @display: a `GdkDisplay`
500	*
501	* Find the first event on the queue that is not still
502	* being filled in.
503	*
504	* Returns: (nullable): Pointer to the list node for that event
505	*/
506	GList*
507	_gdk_event_queue_find_first (GdkDisplay *display)
508	{
509	GList *tmp_list;
510	GList *pending_motion = NULL;
511
512	gboolean paused = display->event_pause_count > 0;
513
514	tmp_list = g_queue_peek_head_link (queue: &display->queued_events);
515	while (tmp_list)
516	{
517	GdkEvent *event = tmp_list->data;
518
519	if ((event->flags & GDK_EVENT_PENDING) == 0 &&
520	(!paused || (event->flags & GDK_EVENT_FLUSHED) != 0))
521	{
522	if (pending_motion)
523	return pending_motion;
524
525	if ((event->event_type == GDK_MOTION_NOTIFY ||
526	(event->event_type == GDK_SCROLL && gdk_scroll_event_get_direction (event) == GDK_SCROLL_SMOOTH)) &&
527	(event->flags & GDK_EVENT_FLUSHED) == 0)
528	pending_motion = tmp_list;
529	else
530	return tmp_list;
531	}
532
533	tmp_list = tmp_list->next;
534	}
535
536	return NULL;
537	}
538
539	/**
540	* _gdk_event_queue_append:
541	* @display: a `GdkDisplay`
542	* @event: Event to append
543	*
544	* Appends an event onto the tail of the event queue.
545	*
546	* Returns: the newly appended list node.
547	*/
548	GList *
549	_gdk_event_queue_append (GdkDisplay *display,
550	GdkEvent *event)
551	{
552	g_queue_push_tail (queue: &display->queued_events, data: event);
553
554	return g_queue_peek_tail_link (queue: &display->queued_events);
555	}
556
557	/*
558	* _gdk_event_queue_remove_link:
559	* @display: a `GdkDisplay`
560	* @node: node to remove
561	*
562	* Removes a specified list node from the event queue.
563	*/
564	void
565	_gdk_event_queue_remove_link (GdkDisplay *display,
566	GList *node)
567	{
568	g_queue_unlink (queue: &display->queued_events, link_: node);
569	}
570
571	/*
572	* _gdk_event_unqueue:
573	* @display: a `GdkDisplay`
574	*
575	* Removes and returns the first event from the event
576	* queue that is not still being filled in.
577	*
578	* Returns: (nullable): the event
579	*/
580	GdkEvent*
581	_gdk_event_unqueue (GdkDisplay *display)
582	{
583	GdkEvent *event = NULL;
584	GList *tmp_list;
585
586	tmp_list = _gdk_event_queue_find_first (display);
587
588	if (tmp_list)
589	{
590	event = tmp_list->data;
591	_gdk_event_queue_remove_link (display, node: tmp_list);
592	g_list_free_1 (list: tmp_list);
593	}
594
595	return event;
596	}
597
598	/*
599	* If the last N events in the event queue are smooth scroll events
600	* for the same surface and device, combine them into one.
601	*
602	* We give the remaining event a history with N items, and deltas
603	* that are the sum over the history entries.
604	*/
605	void
606	gdk_event_queue_handle_scroll_compression (GdkDisplay *display)
607	{
608	GList *l;
609	GdkSurface *surface = NULL;
610	GdkDevice *device = NULL;
611	GdkEvent *last_event = NULL;
612	GList *scrolls = NULL;
613	GArray *history = NULL;
614	GdkTimeCoord hist;
615
616	l = g_queue_peek_tail_link (queue: &display->queued_events);
617
618	while (l)
619	{
620	GdkEvent *event = l->data;
621
622	if (event->flags & GDK_EVENT_PENDING)
623	break;
624
625	if (event->event_type != GDK_SCROLL ||
626	gdk_scroll_event_get_direction (event) != GDK_SCROLL_SMOOTH)
627	break;
628
629	if (surface != NULL &&
630	surface != event->surface)
631	break;
632
633	if (device != NULL &&
634	device != event->device)
635	break;
636
637	if (!last_event)
638	last_event = event;
639
640	surface = event->surface;
641	device = event->device;
642	scrolls = l;
643
644	l = l->prev;
645	}
646
647	while (scrolls && scrolls->next != NULL)
648	{
649	GdkEvent *event = scrolls->data;
650	GList *next = scrolls->next;
651	double dx, dy;
652	gboolean inherited = FALSE;
653
654	if (!history && ((GdkScrollEvent *)event)->history)
655	{
656	history = ((GdkScrollEvent *)event)->history;
657	((GdkScrollEvent *)event)->history = NULL;
658	inherited = TRUE;
659	}
660
661	if (!history)
662	history = g_array_new (FALSE, TRUE, element_size: sizeof (GdkTimeCoord));
663
664	if (!inherited)
665	{
666	gdk_scroll_event_get_deltas (event, delta_x: &dx, delta_y: &dy);
667
668	memset (s: &hist, c: 0, n: sizeof (GdkTimeCoord));
669	hist.time = gdk_event_get_time (event);
670	hist.flags = GDK_AXIS_FLAG_DELTA_X | GDK_AXIS_FLAG_DELTA_Y;
671	hist.axes[GDK_AXIS_DELTA_X] = dx;
672	hist.axes[GDK_AXIS_DELTA_Y] = dy;
673
674	g_array_append_val (history, hist);
675	}
676
677	gdk_event_unref (event);
678	g_queue_delete_link (queue: &display->queued_events, link_: scrolls);
679	scrolls = next;
680	}
681
682	if (scrolls && history)
683	{
684	GdkEvent *old_event, *event;
685	double dx, dy;
686
687	old_event = scrolls->data;
688
689	gdk_scroll_event_get_deltas (event: old_event, delta_x: &dx, delta_y: &dy);
690
691	memset (s: &hist, c: 0, n: sizeof (GdkTimeCoord));
692	hist.time = gdk_event_get_time (event: old_event);
693	hist.flags = GDK_AXIS_FLAG_DELTA_X | GDK_AXIS_FLAG_DELTA_Y;
694	hist.axes[GDK_AXIS_DELTA_X] = dx;
695	hist.axes[GDK_AXIS_DELTA_Y] = dy;
696	g_array_append_val (history, hist);
697
698	dx = dy = 0;
699	for (int i = 0; i < history->len; i++)
700	{
701	GdkTimeCoord *val = &g_array_index (history, GdkTimeCoord, i);
702	dx += val->axes[GDK_AXIS_DELTA_X];
703	dy += val->axes[GDK_AXIS_DELTA_Y];
704	}
705
706	event = gdk_scroll_event_new (surface,
707	device,
708	tool: gdk_event_get_device_tool (event: old_event),
709	time: gdk_event_get_time (event: old_event),
710	state: gdk_event_get_modifier_state (event: old_event),
711	delta_x: dx,
712	delta_y: dy,
713	is_stop: gdk_scroll_event_is_stop (event: old_event));
714
715	((GdkScrollEvent *)event)->history = history;
716
717	g_queue_delete_link (queue: &display->queued_events, link_: scrolls);
718	g_queue_push_tail (queue: &display->queued_events, data: event);
719
720	gdk_event_unref (event: old_event);
721	}
722	}
723
724	static void
725	gdk_motion_event_push_history (GdkEvent *event,
726	GdkEvent *history_event)
727	{
728	GdkMotionEvent *self = (GdkMotionEvent *) event;
729	GdkDeviceTool *tool;
730	GdkTimeCoord hist;
731	int i;
732
733	g_assert (GDK_IS_EVENT_TYPE (event, GDK_MOTION_NOTIFY));
734	g_assert (GDK_IS_EVENT_TYPE (history_event, GDK_MOTION_NOTIFY));
735
736	if (G_UNLIKELY (!self->history))
737	self->history = g_array_new (FALSE, TRUE, element_size: sizeof (GdkTimeCoord));
738
739	if (((GdkMotionEvent *)history_event)->history)
740	{
741	GArray *history = ((GdkMotionEvent *)history_event)->history;
742	g_array_append_vals (array: self->history, data: history->data, len: history->len);
743	}
744
745	tool = gdk_event_get_device_tool (event: history_event);
746
747	memset (s: &hist, c: 0, n: sizeof (GdkTimeCoord));
748	hist.time = gdk_event_get_time (event: history_event);
749	if (tool)
750	{
751	hist.flags = gdk_device_tool_get_axes (tool);
752	for (i = GDK_AXIS_X; i < GDK_AXIS_LAST; i++)
753	gdk_event_get_axis (event: history_event, axis_use: i, value: &hist.axes[i]);
754	}
755	else
756	{
757	hist.flags = GDK_AXIS_FLAG_X | GDK_AXIS_FLAG_Y;
758	gdk_event_get_position (event: history_event, x: &hist.axes[GDK_AXIS_X], y: &hist.axes[GDK_AXIS_Y]);
759	}
760
761	g_array_append_val (self->history, hist);
762	}
763
764	/* If the last N events in the event queue are motion notify
765	* events for the same surface, drop all but the last.
766	*
767	* If a button is held down or the device has a tool, then
768	* we give the remaining events a history containing the N-1
769	* dropped events.
770	*/
771	void
772	_gdk_event_queue_handle_motion_compression (GdkDisplay *display)
773	{
774	GList *tmp_list;
775	GList *pending_motions = NULL;
776	GdkSurface *pending_motion_surface = NULL;
777	GdkDevice *pending_motion_device = NULL;
778	GdkEvent *last_motion = NULL;
779
780	tmp_list = g_queue_peek_tail_link (queue: &display->queued_events);
781
782	while (tmp_list)
783	{
784	GdkEvent *event = tmp_list->data;
785
786	if (event->flags & GDK_EVENT_PENDING)
787	break;
788
789	if (event->event_type != GDK_MOTION_NOTIFY)
790	break;
791
792	if (pending_motion_surface != NULL &&
793	pending_motion_surface != event->surface)
794	break;
795
796	if (pending_motion_device != NULL &&
797	pending_motion_device != event->device)
798	break;
799
800	if (!last_motion)
801	last_motion = event;
802
803	pending_motion_surface = event->surface;
804	pending_motion_device = event->device;
805	pending_motions = tmp_list;
806
807	tmp_list = tmp_list->prev;
808	}
809
810	while (pending_motions && pending_motions->next != NULL)
811	{
812	GList *next = pending_motions->next;
813
814	if (last_motion != NULL)
815	{
816	if ((gdk_event_get_modifier_state (event: last_motion) &
817	(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK |
818	GDK_BUTTON4_MASK | GDK_BUTTON5_MASK)) ||
819	gdk_event_get_device_tool (event: last_motion) != NULL)
820	gdk_motion_event_push_history (event: last_motion, history_event: pending_motions->data);
821	}
822
823	gdk_event_unref (event: pending_motions->data);
824	g_queue_delete_link (queue: &display->queued_events, link_: pending_motions);
825	pending_motions = next;
826	}
827	}
828
829	void
830	_gdk_event_queue_flush (GdkDisplay *display)
831	{
832	while (TRUE)
833	{
834	GdkEvent *event;
835
836	event = (GdkEvent *)g_queue_pop_head (queue: &display->queued_events);
837	if (!event)
838	return;
839
840	event->flags |= GDK_EVENT_FLUSHED;
841	_gdk_event_emit (event);
842	gdk_event_unref (event);
843	}
844	}
845
846	/**
847	* gdk_event_ref:
848	* @event: a `GdkEvent`
849	*
850	* Increase the ref count of @event.
851	*
852	* Returns: (transfer full): @event
853	*/
854	GdkEvent *
855	gdk_event_ref (GdkEvent *event)
856	{
857	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
858
859	g_ref_count_inc (rc: &event->ref_count);
860
861	return event;
862	}
863
864	/**
865	* gdk_event_unref:
866	* @event: (transfer full): a `GdkEvent`
867	*
868	* Decrease the ref count of @event.
869	*
870	* If the last reference is dropped, the structure is freed.
871	*/
872	void
873	gdk_event_unref (GdkEvent *event)
874	{
875	g_return_if_fail (GDK_IS_EVENT (event));
876
877	if (g_ref_count_dec (rc: &event->ref_count))
878	GDK_EVENT_GET_CLASS (event)->finalize (event);
879	}
880
881	/**
882	* gdk_event_get_pointer_emulated:
883	* @event: a `GdkEvent`
884	*
885	* Returns whether this event is an 'emulated' pointer event.
886	*
887	* Emulated pointer events typically originate from a touch events.
888	*
889	* Returns: %TRUE if this event is emulated
890	*/
891	gboolean
892	gdk_event_get_pointer_emulated (GdkEvent *event)
893	{
894	switch ((int) event->event_type)
895	{
896	case GDK_TOUCH_BEGIN:
897	case GDK_TOUCH_END:
898	case GDK_TOUCH_UPDATE:
899	case GDK_TOUCH_CANCEL:
900	{
901	GdkTouchEvent *tevent = (GdkTouchEvent *) event;
902
903	return tevent->pointer_emulated;
904	}
905
906	case GDK_SCROLL:
907	case GDK_SCROLL_SMOOTH:
908	{
909	GdkScrollEvent *sevent = (GdkScrollEvent *) event;
910
911	return sevent->pointer_emulated;
912	}
913
914	default:
915	break;
916	}
917
918	return FALSE;
919	}
920
921	/**
922	* gdk_event_get_axis:
923	* @event: a `GdkEvent`
924	* @axis_use: the axis use to look for
925	* @value: (out): location to store the value found
926	*
927	* Extract the axis value for a particular axis use from
928	* an event structure.
929	*
930	* To find out which axes are used, use [method@Gdk.DeviceTool.get_axes]
931	* on the device tool returned by [method@Gdk.Event.get_device_tool].
932	*
933	* Returns: %TRUE if the specified axis was found, otherwise %FALSE
934	*/
935	gboolean
936	gdk_event_get_axis (GdkEvent *event,
937	GdkAxisUse axis_use,
938	double *value)
939	{
940	double *axes;
941	guint n_axes;
942
943	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
944
945	if (axis_use == GDK_AXIS_X || axis_use == GDK_AXIS_Y)
946	{
947	double x, y;
948
949	if (!gdk_event_get_position (event, x: &x, y: &y))
950	return FALSE;
951
952	if (axis_use == GDK_AXIS_X && value != NULL)
953	*value = x;
954	if (axis_use == GDK_AXIS_Y && value != NULL)
955	*value = y;
956
957	return TRUE;
958	}
959
960	if (!gdk_event_get_axes (event, axes: &axes, n_axes: &n_axes))
961	return FALSE;
962
963	*value = axes[axis_use];
964	return TRUE;
965	}
966
967	/**
968	* gdk_event_triggers_context_menu:
969	* @event: a `GdkEvent`, currently only button events are meaningful values
970	*
971	* Returns whether a `GdkEvent` should trigger a context menu,
972	* according to platform conventions.
973	*
974	* The right mouse button typically triggers context menus.
975	*
976	* This function should always be used instead of simply checking for
977	* event->button == %GDK_BUTTON_SECONDARY.
978	*
979	* Returns: %TRUE if the event should trigger a context menu.
980	*/
981	gboolean
982	gdk_event_triggers_context_menu (GdkEvent *event)
983	{
984	g_return_val_if_fail (event != NULL, FALSE);
985
986	if (event->event_type == GDK_BUTTON_PRESS)
987	{
988	GdkButtonEvent *bevent = (GdkButtonEvent *) event;
989
990	g_return_val_if_fail (GDK_IS_SURFACE (event->surface), FALSE);
991
992	if (bevent->button == GDK_BUTTON_SECONDARY &&
993	! (bevent->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK)))
994	return TRUE;
995	}
996
997	return FALSE;
998	}
999
1000	static gboolean
1001	gdk_events_get_axis_distances (GdkEvent *event1,
1002	GdkEvent *event2,
1003	double *x_distance,
1004	double *y_distance,
1005	double *distance)
1006	{
1007	double x1, x2, y1, y2;
1008	double xd, yd;
1009
1010	if (!gdk_event_get_position (event: event1, x: &x1, y: &y1) ||
1011	!gdk_event_get_position (event: event2, x: &x2, y: &y2))
1012	return FALSE;
1013
1014	xd = x2 - x1;
1015	yd = y2 - y1;
1016
1017	if (x_distance)
1018	*x_distance = xd;
1019
1020	if (y_distance)
1021	*y_distance = yd;
1022
1023	if (distance)
1024	*distance = sqrt (x: (xd * xd) + (yd * yd));
1025
1026	return TRUE;
1027	}
1028
1029	/**
1030	* gdk_events_get_distance:
1031	* @event1: first `GdkEvent`
1032	* @event2: second `GdkEvent`
1033	* @distance: (out): return location for the distance
1034	*
1035	* Returns the distance between the event locations.
1036	*
1037	* This assumes that both events have X/Y information.
1038	* If not, this function returns %FALSE.
1039	*
1040	* Returns: %TRUE if the distance could be calculated.
1041	**/
1042	gboolean
1043	gdk_events_get_distance (GdkEvent *event1,
1044	GdkEvent *event2,
1045	double *distance)
1046	{
1047	return gdk_events_get_axis_distances (event1, event2,
1048	NULL, NULL,
1049	distance);
1050	}
1051
1052	/**
1053	* gdk_events_get_angle:
1054	* @event1: first `GdkEvent`
1055	* @event2: second `GdkEvent`
1056	* @angle: (out): return location for the relative angle between both events
1057	*
1058	* Returns the relative angle from @event1 to @event2.
1059	*
1060	* The relative angle is the angle between the X axis and the line
1061	* through both events' positions. The rotation direction for positive
1062	* angles is from the positive X axis towards the positive Y axis.
1063	*
1064	* This assumes that both events have X/Y information.
1065	* If not, this function returns %FALSE.
1066	*
1067	* Returns: %TRUE if the angle could be calculated.
1068	*/
1069	gboolean
1070	gdk_events_get_angle (GdkEvent *event1,
1071	GdkEvent *event2,
1072	double *angle)
1073	{
1074	double x_distance, y_distance, distance;
1075
1076	if (!gdk_events_get_axis_distances (event1, event2,
1077	x_distance: &x_distance, y_distance: &y_distance,
1078	distance: &distance))
1079	return FALSE;
1080
1081	if (angle)
1082	{
1083	*angle = atan2 (y: x_distance, x: y_distance);
1084
1085	/* Invert angle */
1086	*angle = (2 * G_PI) - *angle;
1087
1088	/* Shift it 90° */
1089	*angle += G_PI / 2;
1090
1091	/* And constraint it to 0°-360° */
1092	*angle = fmod (x: *angle, y: 2 * G_PI);
1093	}
1094
1095	return TRUE;
1096	}
1097
1098	/**
1099	* gdk_events_get_center:
1100	* @event1: first `GdkEvent`
1101	* @event2: second `GdkEvent`
1102	* @x: (out): return location for the X coordinate of the center
1103	* @y: (out): return location for the Y coordinate of the center
1104	*
1105	* Returns the point halfway between the events' positions.
1106	*
1107	* This assumes that both events have X/Y information.
1108	* If not, this function returns %FALSE.
1109	*
1110	* Returns: %TRUE if the center could be calculated.
1111	*/
1112	gboolean
1113	gdk_events_get_center (GdkEvent *event1,
1114	GdkEvent *event2,
1115	double *x,
1116	double *y)
1117	{
1118	double x1, x2, y1, y2;
1119
1120	if (!gdk_event_get_position (event: event1, x: &x1, y: &y1) ||
1121	!gdk_event_get_position (event: event2, x: &x2, y: &y2))
1122	return FALSE;
1123
1124	if (x)
1125	*x = (x2 + x1) / 2;
1126
1127	if (y)
1128	*y = (y2 + y1) / 2;
1129
1130	return TRUE;
1131	}
1132
1133	static GdkEventSequence *
1134	gdk_event_sequence_copy (GdkEventSequence *sequence)
1135	{
1136	return sequence;
1137	}
1138
1139	static void
1140	gdk_event_sequence_free (GdkEventSequence *sequence)
1141	{
1142	/* Nothing to free here */
1143	}
1144
1145	G_DEFINE_BOXED_TYPE (GdkEventSequence, gdk_event_sequence,
1146	gdk_event_sequence_copy,
1147	gdk_event_sequence_free)
1148
1149
1150
1151	/**
1152	* gdk_event_get_axes:
1153	* @event: a `GdkEvent`
1154	* @axes: (transfer none) (out) (array length=n_axes): the array of values for all axes
1155	* @n_axes: (out): the length of array
1156	*
1157	* Extracts all axis values from an event.
1158	*
1159	* To find out which axes are used, use [method@Gdk.DeviceTool.get_axes]
1160	* on the device tool returned by [method@Gdk.Event.get_device_tool].
1161	*
1162	* Returns: %TRUE on success, otherwise %FALSE
1163	*/
1164	gboolean
1165	gdk_event_get_axes (GdkEvent *event,
1166	double **axes,
1167	guint *n_axes)
1168	{
1169	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
1170
1171	return GDK_EVENT_GET_CLASS (event)->get_axes (event, axes, n_axes);
1172	}
1173
1174	double *
1175	gdk_event_dup_axes (GdkEvent *event)
1176	{
1177	double *axes;
1178	guint n_axes;
1179
1180	if (gdk_event_get_axes (event, axes: &axes, n_axes: &n_axes))
1181	{
1182	double *axes_copy = g_memdup2 (mem: axes, byte_size: n_axes * sizeof (double));
1183
1184	return axes_copy;
1185	}
1186
1187	return NULL;
1188	}
1189
1190	/**
1191	* gdk_event_get_event_type:
1192	* @event: a `GdkEvent`
1193	*
1194	* Retrieves the type of the event.
1195	*
1196	* Returns: a `GdkEvent`Type
1197	*/
1198	GdkEventType
1199	gdk_event_get_event_type (GdkEvent *event)
1200	{
1201	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1202
1203	return event->event_type;
1204	}
1205
1206	/**
1207	* gdk_event_get_surface:
1208	* @event: a `GdkEvent`
1209	*
1210	* Extracts the surface associated with an event.
1211	*
1212	* Returns: (transfer none) (nullable): The `GdkSurface` associated with the event
1213	*/
1214	GdkSurface *
1215	gdk_event_get_surface (GdkEvent *event)
1216	{
1217	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
1218
1219	return event->surface;
1220	}
1221
1222	/**
1223	* gdk_event_get_seat:
1224	* @event: a `GdkEvent`
1225	*
1226	* Returns the seat that originated the event.
1227	*
1228	* Returns: (nullable) (transfer none): a `GdkSeat`.
1229	*/
1230	GdkSeat *
1231	gdk_event_get_seat (GdkEvent *event)
1232	{
1233	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
1234
1235	return event->device ? gdk_device_get_seat (device: event->device) : NULL;
1236	}
1237
1238	/**
1239	* gdk_event_get_device:
1240	* @event: a `GdkEvent`.
1241	*
1242	* Returns the device of an event.
1243	*
1244	* Returns: (nullable) (transfer none): a `GdkDevice`
1245	*/
1246	GdkDevice *
1247	gdk_event_get_device (GdkEvent *event)
1248	{
1249	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
1250
1251	return event->device;
1252	}
1253
1254	/**
1255	* gdk_event_get_device_tool:
1256	* @event: a `GdkEvent`
1257	*
1258	* Returns a `GdkDeviceTool` representing the tool that
1259	* caused the event.
1260	*
1261	* If the was not generated by a device that supports
1262	* different tools (such as a tablet), this function will
1263	* return %NULL.
1264	*
1265	* Note: the `GdkDeviceTool` will be constant during
1266	* the application lifetime, if settings must be stored
1267	* persistently across runs, see [method@Gdk.DeviceTool.get_serial].
1268	*
1269	* Returns: (transfer none) (nullable): The current device tool
1270	*/
1271	GdkDeviceTool *
1272	gdk_event_get_device_tool (GdkEvent *event)
1273	{
1274	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
1275
1276	return GDK_EVENT_GET_CLASS (event)->get_tool (event);
1277	}
1278
1279	/**
1280	* gdk_event_get_time:
1281	* @event: a `GdkEvent`
1282	*
1283	* Returns the timestamp of @event.
1284	*
1285	* Not all events have timestamps. In that case, this function
1286	* returns %GDK_CURRENT_TIME.
1287	*
1288	* Returns: timestamp field from @event
1289	*/
1290	guint32
1291	gdk_event_get_time (GdkEvent *event)
1292	{
1293	g_return_val_if_fail (GDK_IS_EVENT (event), GDK_CURRENT_TIME);
1294
1295	return event->time;
1296	}
1297
1298	/**
1299	* gdk_event_get_display:
1300	* @event: a `GdkEvent`
1301	*
1302	* Retrieves the display associated to the @event.
1303	*
1304	* Returns: (transfer none) (nullable): a `GdkDisplay`
1305	*/
1306	GdkDisplay *
1307	gdk_event_get_display (GdkEvent *event)
1308	{
1309	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
1310
1311	if (event->surface)
1312	return gdk_surface_get_display (surface: event->surface);
1313
1314	return NULL;
1315	}
1316
1317	/**
1318	* gdk_event_get_event_sequence:
1319	* @event: a `GdkEvent`
1320	*
1321	* Retuns the event sequence to which the event belongs.
1322	*
1323	* Related touch events are connected in a sequence. Other
1324	* events typically don't have event sequence information.
1325	*
1326	* Returns: (transfer none): the event sequence that the event belongs to
1327	*/
1328	GdkEventSequence *
1329	gdk_event_get_event_sequence (GdkEvent *event)
1330	{
1331	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
1332
1333	return GDK_EVENT_GET_CLASS (event)->get_sequence (event);
1334	}
1335
1336	/**
1337	* gdk_event_get_modifier_state:
1338	* @event: a `GdkEvent`
1339	*
1340	* Returns the modifier state field of an event.
1341	*
1342	* Returns: the modifier state of @event
1343	*/
1344	GdkModifierType
1345	gdk_event_get_modifier_state (GdkEvent *event)
1346	{
1347	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1348
1349	return GDK_EVENT_GET_CLASS (event)->get_state (event);
1350	}
1351
1352	/**
1353	* gdk_event_get_position:
1354	* @event: a `GdkEvent`
1355	* @x: (out): location to put event surface x coordinate
1356	* @y: (out): location to put event surface y coordinate
1357	*
1358	* Extract the event surface relative x/y coordinates from an event.
1359	*/
1360	gboolean
1361	gdk_event_get_position (GdkEvent *event,
1362	double *x,
1363	double *y)
1364	{
1365	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
1366
1367	return GDK_EVENT_GET_CLASS (event)->get_position (event, x, y);
1368	}
1369
1370	/* {{{ GdkButtonEvent */
1371
1372	/**
1373	* GdkButtonEvent:
1374	*
1375	* An event related to a button on a pointer device.
1376	*/
1377
1378	static void
1379	gdk_button_event_finalize (GdkEvent *event)
1380	{
1381	GdkButtonEvent *self = (GdkButtonEvent *) event;
1382
1383	g_clear_object (&self->tool);
1384	g_clear_pointer (&self->axes, g_free);
1385
1386	GDK_EVENT_SUPER (event)->finalize (event);
1387	}
1388
1389	static GdkModifierType
1390	gdk_button_event_get_state (GdkEvent *event)
1391	{
1392	GdkButtonEvent *self = (GdkButtonEvent *) event;
1393
1394	return self->state;
1395	}
1396
1397	static gboolean
1398	gdk_button_event_get_position (GdkEvent *event,
1399	double *x,
1400	double *y)
1401	{
1402	GdkButtonEvent *self = (GdkButtonEvent *) event;
1403
1404	*x = self->x;
1405	*y = self->y;
1406
1407	return TRUE;
1408	}
1409
1410	static GdkDeviceTool *
1411	gdk_button_event_get_tool (GdkEvent *event)
1412	{
1413	GdkButtonEvent *self = (GdkButtonEvent *) event;
1414
1415	return self->tool;
1416	}
1417
1418	static gboolean
1419	gdk_button_event_get_axes (GdkEvent *event,
1420	double **axes,
1421	guint *n_axes)
1422	{
1423	GdkButtonEvent *self = (GdkButtonEvent *) event;
1424	GdkDevice *source_device = gdk_event_get_device (event);
1425
1426	if (source_device == NULL)
1427	return FALSE;
1428
1429	*axes = self->axes;
1430	*n_axes = GDK_AXIS_LAST;
1431
1432	return TRUE;
1433	}
1434
1435	static const GdkEventTypeInfo gdk_button_event_info = {
1436	sizeof (GdkButtonEvent),
1437	NULL,
1438	gdk_button_event_finalize,
1439	gdk_button_event_get_state,
1440	gdk_button_event_get_position,
1441	NULL,
1442	gdk_button_event_get_tool,
1443	gdk_button_event_get_axes,
1444	};
1445
1446	GDK_DEFINE_EVENT_TYPE (GdkButtonEvent, gdk_button_event,
1447	&gdk_button_event_info,
1448	GDK_EVENT_TYPE_SLOT (GDK_BUTTON_PRESS)
1449	GDK_EVENT_TYPE_SLOT (GDK_BUTTON_RELEASE))
1450
1451	GdkEvent *
1452	gdk_button_event_new (GdkEventType type,
1453	GdkSurface *surface,
1454	GdkDevice *device,
1455	GdkDeviceTool *tool,
1456	guint32 time,
1457	GdkModifierType state,
1458	guint button,
1459	double x,
1460	double y,
1461	double *axes)
1462	{
1463	g_return_val_if_fail (type == GDK_BUTTON_PRESS ||
1464	type == GDK_BUTTON_RELEASE, NULL);
1465
1466	GdkButtonEvent *self = gdk_event_alloc (event_type: type, surface, device, time_: time);
1467
1468	self->tool = tool != NULL ? g_object_ref (tool) : NULL;
1469	self->axes = axes;
1470	self->state = state;
1471	self->button = button;
1472	self->x = x;
1473	self->y = y;
1474
1475	return (GdkEvent *) self;
1476	}
1477
1478	/**
1479	* gdk_button_event_get_button:
1480	* @event: (type GdkButtonEvent): a button event
1481	*
1482	* Extract the button number from a button event.
1483	*
1484	* Returns: the button of @event
1485	**/
1486	guint
1487	gdk_button_event_get_button (GdkEvent *event)
1488	{
1489	GdkButtonEvent *self = (GdkButtonEvent *) event;
1490
1491	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1492	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_BUTTON_PRESS) ||
1493	GDK_IS_EVENT_TYPE (event, GDK_BUTTON_RELEASE), 0);
1494
1495	return self->button;
1496	}
1497
1498	/* }}} */
1499
1500	/* {{{ GdkKeyEvent */
1501
1502	/**
1503	* GdkKeyEvent:
1504	*
1505	* An event related to a key-based device.
1506	*/
1507
1508	static GdkModifierType
1509	gdk_key_event_get_state (GdkEvent *event)
1510	{
1511	GdkKeyEvent *self = (GdkKeyEvent *) event;
1512
1513	return self->state;
1514	}
1515
1516	static const GdkEventTypeInfo gdk_key_event_info = {
1517	sizeof (GdkKeyEvent),
1518	NULL,
1519	NULL,
1520	gdk_key_event_get_state,
1521	NULL,
1522	NULL,
1523	NULL,
1524	NULL,
1525	};
1526
1527	GDK_DEFINE_EVENT_TYPE (GdkKeyEvent, gdk_key_event,
1528	&gdk_key_event_info,
1529	GDK_EVENT_TYPE_SLOT (GDK_KEY_PRESS)
1530	GDK_EVENT_TYPE_SLOT (GDK_KEY_RELEASE))
1531
1532	/*< private >
1533	* gdk_key_event_new:
1534	* @type: the event type, either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
1535	* @surface: the surface of the event
1536	* @device: the device related to the event
1537	* @time: the event's timestamp
1538	* @keycode: the keycode of the event
1539	* @state: the modifiers state
1540	* @is_modifier: whether the event is a modifiers only event
1541	* @translated: the translated key data for the given @state
1542	* @no_lock: the translated key data without the given @state
1543	*
1544	* Creates a new `GdkKeyEvent`.
1545	*
1546	* Returns: (transfer full) (type GdkKeyEvent): the newly created `GdkEvent`
1547	*/
1548	GdkEvent *
1549	gdk_key_event_new (GdkEventType type,
1550	GdkSurface *surface,
1551	GdkDevice *device,
1552	guint32 time,
1553	guint keycode,
1554	GdkModifierType state,
1555	gboolean is_modifier,
1556	GdkTranslatedKey *translated,
1557	GdkTranslatedKey *no_lock)
1558	{
1559	g_return_val_if_fail (type == GDK_KEY_PRESS ||
1560	type == GDK_KEY_RELEASE, NULL);
1561
1562	GdkKeyEvent *self = gdk_event_alloc (event_type: type, surface, device, time_: time);
1563	GdkEvent *event = (GdkEvent *) self;
1564
1565	self->keycode = keycode;
1566	self->state = state;
1567	self->key_is_modifier = is_modifier;
1568	self->translated[0] = *translated;
1569	self->translated[1] = *no_lock;
1570
1571	return event;
1572	}
1573
1574	/*< private >
1575	* gdk_key_event_get_translated_key:
1576	* @event: (type GdkKeyEvent): a key event
1577	* @no_lock: whether the translated key should take the event
1578	* state into account
1579	*
1580	* Extracts the translated key from a key event.
1581	*
1582	* Returns: (transfer none): the translated key
1583	*/
1584	GdkTranslatedKey *
1585	gdk_key_event_get_translated_key (GdkEvent *event,
1586	gboolean no_lock)
1587	{
1588	GdkKeyEvent *self = (GdkKeyEvent *) event;
1589
1590	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
1591	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1592	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), NULL);
1593
1594	if (no_lock)
1595	return &(self->translated[1]);
1596
1597	return &(self->translated[0]);
1598	}
1599
1600	/**
1601	* gdk_key_event_get_keyval:
1602	* @event: (type GdkKeyEvent): a key event
1603	*
1604	* Extracts the keyval from a key event.
1605	*
1606	* Returns: the keyval of @event
1607	*/
1608	guint
1609	gdk_key_event_get_keyval (GdkEvent *event)
1610	{
1611	GdkKeyEvent *self = (GdkKeyEvent *) event;
1612
1613	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1614	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1615	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), 0);
1616
1617	return self->translated[0].keyval;
1618	}
1619
1620	/**
1621	* gdk_key_event_get_keycode:
1622	* @event: (type GdkKeyEvent): a key event
1623	*
1624	* Extracts the keycode from a key event.
1625	*
1626	* Returns: the keycode of @event
1627	*/
1628	guint
1629	gdk_key_event_get_keycode (GdkEvent *event)
1630	{
1631	GdkKeyEvent *self = (GdkKeyEvent *) event;
1632
1633	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1634	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1635	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), 0);
1636
1637	return self->keycode;
1638	}
1639
1640	/**
1641	* gdk_key_event_get_level:
1642	* @event: (type GdkKeyEvent): a key event
1643	*
1644	* Extracts the shift level from a key event.
1645	*
1646	* Returns: the shift level of @event
1647	*/
1648	guint
1649	gdk_key_event_get_level (GdkEvent *event)
1650	{
1651	GdkKeyEvent *self = (GdkKeyEvent *) event;
1652
1653	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1654	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1655	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), 0);
1656
1657	return self->translated[0].level;
1658	}
1659
1660	/**
1661	* gdk_key_event_get_layout:
1662	* @event: (type GdkKeyEvent): a key event
1663	*
1664	* Extracts the layout from a key event.
1665	*
1666	* Returns: the layout of @event
1667	*/
1668	guint
1669	gdk_key_event_get_layout (GdkEvent *event)
1670	{
1671	GdkKeyEvent *self = (GdkKeyEvent *) event;
1672
1673	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1674	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1675	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), 0);
1676
1677	return self->translated[0].layout;
1678	}
1679
1680	/**
1681	* gdk_key_event_get_consumed_modifiers:
1682	* @event: (type GdkKeyEvent): a key event
1683	*
1684	* Extracts the consumed modifiers from a key event.
1685	*
1686	* Returns: the consumed modifiers or @event
1687	*/
1688	GdkModifierType
1689	gdk_key_event_get_consumed_modifiers (GdkEvent *event)
1690	{
1691	GdkKeyEvent *self = (GdkKeyEvent *) event;
1692
1693	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1694	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1695	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), 0);
1696
1697	return self->translated[0].consumed;
1698	}
1699
1700	/**
1701	* gdk_key_event_is_modifier:
1702	* @event: (type GdkKeyEvent): a key event
1703	*
1704	* Extracts whether the key event is for a modifier key.
1705	*
1706	* Returns: %TRUE if the @event is for a modifier key
1707	*/
1708	gboolean
1709	gdk_key_event_is_modifier (GdkEvent *event)
1710	{
1711	GdkKeyEvent *self = (GdkKeyEvent *) event;
1712
1713	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
1714	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1715	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), FALSE);
1716
1717	return self->key_is_modifier;
1718	}
1719
1720	static gboolean
1721	keyval_in_group (GdkKeymap *keymap,
1722	guint keyval,
1723	int group)
1724	{
1725	GdkKeymapKey *keys;
1726	guint n_keys;
1727
1728	gdk_keymap_get_cached_entries_for_keyval (keymap, keyval, keys: &keys, n_keys: &n_keys);
1729	for (int i = 0; i < n_keys; i++)
1730	{
1731	if (keys[i].group == group)
1732	return TRUE;
1733	}
1734
1735	return FALSE;
1736	}
1737
1738	/**
1739	* gdk_key_event_matches:
1740	* @event: (type GdkKeyEvent): a key `GdkEvent`
1741	* @keyval: the keyval to match
1742	* @modifiers: the modifiers to match
1743	*
1744	* Matches a key event against a keyval and modifiers.
1745	*
1746	* This is typically used to trigger keyboard shortcuts such as Ctrl-C.
1747	*
1748	* Partial matches are possible where the combination matches
1749	* if the currently active group is ignored.
1750	*
1751	* Note that we ignore Caps Lock for matching.
1752	*
1753	* Returns: a `GdkKeyMatch` value describing whether @event matches
1754	*/
1755	GdkKeyMatch
1756	gdk_key_event_matches (GdkEvent *event,
1757	guint keyval,
1758	GdkModifierType modifiers)
1759	{
1760	GdkKeyEvent *self = (GdkKeyEvent *) event;
1761	GdkKeymap *keymap;
1762	guint keycode;
1763	GdkModifierType state;
1764	guint ev_keyval;
1765	int layout;
1766	int level;
1767	GdkModifierType ignored_modifiers;
1768	GdkModifierType shift_group_mask;
1769	gboolean group_mod_is_accel_mod = FALSE;
1770	const GdkModifierType mask = GDK_CONTROL_MASK |
1771	GDK_SHIFT_MASK |
1772	GDK_ALT_MASK |
1773	GDK_SUPER_MASK |
1774	GDK_HYPER_MASK |
1775	GDK_META_MASK;
1776
1777	g_return_val_if_fail (GDK_IS_EVENT (event), GDK_KEY_MATCH_NONE);
1778	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1779	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), GDK_KEY_MATCH_NONE);
1780
1781	keycode = self->keycode;
1782	state = self->state & ~GDK_LOCK_MASK;
1783	ev_keyval = self->translated[1].keyval;
1784	layout = self->translated[1].layout;
1785	level = self->translated[1].level;
1786
1787	/*
1788	* If a modifier is currently active (e.g. Shift is pressed) and was marked
1789	* as consumed, we ignore it for the purposes of matching shortcuts.
1790	* For example, when Ctrl+Shift+[plus/equals key] is translated into
1791	* Ctrl+plus on a keyboard where Shift+equals is the plus sign, we want
1792	* shortcuts for either <Control><Shift>plus or <Control>plus to match.
1793	* (See https://bugzilla.gnome.org/show_bug.cgi?id=100439)
1794	*
1795	* If a modifier is *not* currently active, the X11 backend can sometimes
1796	* mark it as consumed where the Wayland and Windows backends do not.
1797	* In this case, we still want to pay attention to its state.
1798	* For example, when Ctrl+x is translated into Ctrl+x, we only want to
1799	* trigger shortcuts for <Control>x, not for <Control><Shift>x.
1800	* (See https://gitlab.gnome.org/GNOME/gtk/-/issues/5095)
1801	*/
1802	ignored_modifiers = (self->translated[1].consumed & state);
1803
1804	/* if the group-toggling modifier is part of the default accel mod
1805	* mask, and it is active, disable it for matching
1806	*
1807	* FIXME: get shift group mask from backends
1808	*/
1809	shift_group_mask = 0;
1810
1811	if (mask & shift_group_mask)
1812	group_mod_is_accel_mod = TRUE;
1813
1814	if ((modifiers & ~ignored_modifiers & mask) == (state & ~ignored_modifiers & mask))
1815	{
1816	/* modifier match */
1817	GdkKeymapKey *keys;
1818	guint n_keys;
1819	int i;
1820	guint key;
1821
1822	/* Shift gets consumed and applied for the event,
1823	* so apply it to our keyval to match
1824	*/
1825	key = keyval;
1826	if (modifiers & GDK_SHIFT_MASK)
1827	{
1828	if (key == GDK_KEY_Tab)
1829	key = GDK_KEY_ISO_Left_Tab;
1830	else
1831	key = gdk_keyval_to_upper (keyval: key);
1832	}
1833
1834	if (ev_keyval == key && /* exact match */
1835	(!group_mod_is_accel_mod ||
1836	(state & shift_group_mask) == (modifiers & shift_group_mask)))
1837	{
1838	return GDK_KEY_MATCH_EXACT;
1839	}
1840
1841	keymap = gdk_display_get_keymap (display: gdk_event_get_display (event));
1842	gdk_keymap_get_cached_entries_for_keyval (keymap, keyval, keys: &keys, n_keys: &n_keys);
1843
1844	for (i = 0; i < n_keys; i++)
1845	{
1846	if (keys[i].keycode == keycode &&
1847	keys[i].level == level &&
1848	/* Only match for group if it's an accel mod */
1849	(keys[i].group == layout ||
1850	(!group_mod_is_accel_mod && !keyval_in_group (keymap, keyval, group: layout))))
1851	return GDK_KEY_MATCH_PARTIAL;
1852	}
1853	}
1854
1855	return GDK_KEY_MATCH_NONE;
1856	}
1857
1858	/**
1859	* gdk_key_event_get_match:
1860	* @event: (type GdkKeyEvent): a key `GdkEvent`
1861	* @keyval: (out): return location for a keyval
1862	* @modifiers: (out): return location for modifiers
1863	*
1864	* Gets a keyval and modifier combination that will match
1865	* the event.
1866	*
1867	* See [method@Gdk.KeyEvent.matches].
1868	*
1869	* Returns: %TRUE on success
1870	*/
1871	gboolean
1872	gdk_key_event_get_match (GdkEvent *event,
1873	guint *keyval,
1874	GdkModifierType *modifiers)
1875	{
1876	GdkKeyEvent *self = (GdkKeyEvent *) event;
1877	guint key;
1878	guint accel_key;
1879	GdkModifierType accel_mods;
1880	GdkModifierType consumed_modifiers;
1881	const GdkModifierType mask = GDK_CONTROL_MASK |
1882	GDK_SHIFT_MASK |
1883	GDK_ALT_MASK |
1884	GDK_SUPER_MASK |
1885	GDK_HYPER_MASK |
1886	GDK_META_MASK;
1887
1888	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
1889	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_KEY_PRESS) ||
1890	GDK_IS_EVENT_TYPE (event, GDK_KEY_RELEASE), FALSE);
1891
1892	accel_key = self->translated[1].keyval;
1893	accel_mods = self->state;
1894	consumed_modifiers = self->translated[1].consumed;
1895
1896	if (accel_key == GDK_KEY_Sys_Req &&
1897	(accel_mods & GDK_ALT_MASK) != 0)
1898	{
1899	/* HACK: we don't want to use SysRq as a keybinding (but we do
1900	* want Alt+Print), so we avoid translation from Alt+Print to SysRq
1901	*/
1902	*keyval = GDK_KEY_Print;
1903	*modifiers = accel_mods & mask;
1904	return TRUE;
1905	}
1906
1907	key = gdk_keyval_to_lower (keyval: accel_key);
1908
1909	if (key == GDK_KEY_ISO_Left_Tab)
1910	key = GDK_KEY_Tab;
1911
1912	accel_mods &= mask & ~consumed_modifiers;
1913
1914	if (accel_key != key)
1915	accel_mods |= GDK_SHIFT_MASK;
1916
1917	*keyval = key;
1918	*modifiers = accel_mods;
1919
1920	return TRUE;
1921	}
1922
1923	/* }}} */
1924
1925	/* {{{ GdkTouchEvent */
1926
1927	/**
1928	* GdkTouchEvent:
1929	*
1930	* An event related to a touch-based device.
1931	*/
1932
1933	static void
1934	gdk_touch_event_finalize (GdkEvent *event)
1935	{
1936	GdkTouchEvent *self = (GdkTouchEvent *) event;
1937
1938	g_clear_pointer (&self->axes, g_free);
1939
1940	GDK_EVENT_SUPER (event)->finalize (event);
1941	}
1942
1943	static GdkModifierType
1944	gdk_touch_event_get_state (GdkEvent *event)
1945	{
1946	GdkTouchEvent *self = (GdkTouchEvent *) event;
1947
1948	return self->state;
1949	}
1950
1951	static gboolean
1952	gdk_touch_event_get_position (GdkEvent *event,
1953	double *x,
1954	double *y)
1955	{
1956	GdkTouchEvent *self = (GdkTouchEvent *) event;
1957
1958	*x = self->x;
1959	*y = self->y;
1960
1961	return TRUE;
1962	}
1963
1964	static GdkEventSequence *
1965	gdk_touch_event_get_sequence (GdkEvent *event)
1966	{
1967	GdkTouchEvent *self = (GdkTouchEvent *) event;
1968
1969	return self->sequence;
1970	}
1971
1972	static gboolean
1973	gdk_touch_event_get_axes (GdkEvent *event,
1974	double **axes,
1975	guint *n_axes)
1976	{
1977	GdkTouchEvent *self = (GdkTouchEvent *) event;
1978	GdkDevice *source_device = gdk_event_get_device (event);
1979
1980	if (source_device == NULL)
1981	return FALSE;
1982
1983	*axes = self->axes;
1984	*n_axes = GDK_AXIS_LAST;
1985
1986	return TRUE;
1987	}
1988
1989	static const GdkEventTypeInfo gdk_touch_event_info = {
1990	sizeof (GdkTouchEvent),
1991	NULL,
1992	gdk_touch_event_finalize,
1993	gdk_touch_event_get_state,
1994	gdk_touch_event_get_position,
1995	gdk_touch_event_get_sequence,
1996	NULL,
1997	gdk_touch_event_get_axes,
1998	};
1999
2000	GDK_DEFINE_EVENT_TYPE (GdkTouchEvent, gdk_touch_event,
2001	&gdk_touch_event_info,
2002	GDK_EVENT_TYPE_SLOT (GDK_TOUCH_BEGIN)
2003	GDK_EVENT_TYPE_SLOT (GDK_TOUCH_END)
2004	GDK_EVENT_TYPE_SLOT (GDK_TOUCH_UPDATE)
2005	GDK_EVENT_TYPE_SLOT (GDK_TOUCH_CANCEL))
2006
2007	GdkEvent *
2008	gdk_touch_event_new (GdkEventType type,
2009	GdkEventSequence *sequence,
2010	GdkSurface *surface,
2011	GdkDevice *device,
2012	guint32 time,
2013	GdkModifierType state,
2014	double x,
2015	double y,
2016	double *axes,
2017	gboolean emulating)
2018	{
2019	GdkTouchEvent *self;
2020
2021	g_return_val_if_fail (type == GDK_TOUCH_BEGIN ||
2022	type == GDK_TOUCH_END ||
2023	type == GDK_TOUCH_UPDATE ||
2024	type == GDK_TOUCH_CANCEL, NULL);
2025
2026	self = gdk_event_alloc (event_type: type, surface, device, time_: time);
2027	self->sequence = sequence;
2028	self->state = state;
2029	self->x = x;
2030	self->y = y;
2031	self->axes = axes;
2032	self->touch_emulating = emulating;
2033	self->pointer_emulated = emulating;
2034
2035	return (GdkEvent *) self;
2036	}
2037
2038	/**
2039	* gdk_touch_event_get_emulating_pointer:
2040	* @event: (type GdkTouchEvent): a touch event
2041	*
2042	* Extracts whether a touch event is emulating a pointer event.
2043	*
2044	* Returns: %TRUE if @event is emulating
2045	**/
2046	gboolean
2047	gdk_touch_event_get_emulating_pointer (GdkEvent *event)
2048	{
2049	GdkTouchEvent *self = (GdkTouchEvent *) event;
2050
2051	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
2052	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_TOUCH_BEGIN) ||
2053	GDK_IS_EVENT_TYPE (event, GDK_TOUCH_UPDATE) ||
2054	GDK_IS_EVENT_TYPE (event, GDK_TOUCH_END) ||
2055	GDK_IS_EVENT_TYPE (event, GDK_TOUCH_CANCEL), FALSE);
2056
2057	return self->touch_emulating;
2058	}
2059
2060	/* }}} */
2061
2062	/* {{{ GdkCrossingEvent */
2063
2064	/**
2065	* GdkCrossingEvent:
2066	*
2067	* An event caused by a pointing device moving between surfaces.
2068	*/
2069
2070	static void
2071	gdk_crossing_event_finalize (GdkEvent *event)
2072	{
2073	GdkCrossingEvent *self = (GdkCrossingEvent *) event;
2074
2075	g_clear_object (&self->child_surface);
2076
2077	GDK_EVENT_SUPER (self)->finalize (event);
2078	}
2079
2080	static GdkModifierType
2081	gdk_crossing_event_get_state (GdkEvent *event)
2082	{
2083	GdkCrossingEvent *self = (GdkCrossingEvent *) event;
2084
2085	return self->state;
2086	}
2087
2088	static gboolean
2089	gdk_crossing_event_get_position (GdkEvent *event,
2090	double *x,
2091	double *y)
2092	{
2093	GdkCrossingEvent *self = (GdkCrossingEvent *) event;
2094
2095	*x = self->x;
2096	*y = self->y;
2097
2098	return TRUE;
2099	}
2100
2101	static const GdkEventTypeInfo gdk_crossing_event_info = {
2102	sizeof (GdkCrossingEvent),
2103	NULL,
2104	gdk_crossing_event_finalize,
2105	gdk_crossing_event_get_state,
2106	gdk_crossing_event_get_position,
2107	NULL,
2108	NULL,
2109	NULL,
2110	};
2111
2112	GDK_DEFINE_EVENT_TYPE (GdkCrossingEvent, gdk_crossing_event,
2113	&gdk_crossing_event_info,
2114	GDK_EVENT_TYPE_SLOT (GDK_ENTER_NOTIFY)
2115	GDK_EVENT_TYPE_SLOT (GDK_LEAVE_NOTIFY))
2116
2117	GdkEvent *
2118	gdk_crossing_event_new (GdkEventType type,
2119	GdkSurface *surface,
2120	GdkDevice *device,
2121	guint32 time,
2122	GdkModifierType state,
2123	double x,
2124	double y,
2125	GdkCrossingMode mode,
2126	GdkNotifyType detail)
2127	{
2128	GdkCrossingEvent *self;
2129
2130	g_return_val_if_fail (type == GDK_ENTER_NOTIFY ||
2131	type == GDK_LEAVE_NOTIFY, NULL);
2132
2133	self = gdk_event_alloc (event_type: type, surface, device, time_: time);
2134
2135	self->state = state;
2136	self->x = x;
2137	self->y = y;
2138	self->mode = mode;
2139	self->detail = detail;
2140
2141	return (GdkEvent *) self;
2142	}
2143
2144	/**
2145	* gdk_crossing_event_get_mode:
2146	* @event: (type GdkCrossingEvent): a crossing event
2147	*
2148	* Extracts the crossing mode from a crossing event.
2149	*
2150	* Returns: the mode of @event
2151	*/
2152	GdkCrossingMode
2153	gdk_crossing_event_get_mode (GdkEvent *event)
2154	{
2155	GdkCrossingEvent *self = (GdkCrossingEvent *) event;
2156
2157	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
2158	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_ENTER_NOTIFY) ||
2159	GDK_IS_EVENT_TYPE (event, GDK_LEAVE_NOTIFY), 0);
2160
2161	return self->mode;
2162	}
2163
2164	/**
2165	* gdk_crossing_event_get_focus:
2166	* @event: (type GdkCrossingEvent): a crossing event
2167	*
2168	* Checks if the @event surface is the focus surface.
2169	*
2170	* Returns: %TRUE if the surface is the focus surface
2171	*/
2172	gboolean
2173	gdk_crossing_event_get_focus (GdkEvent *event)
2174	{
2175	GdkCrossingEvent *self = (GdkCrossingEvent *) event;
2176
2177	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
2178	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_ENTER_NOTIFY) ||
2179	GDK_IS_EVENT_TYPE (event, GDK_LEAVE_NOTIFY), FALSE);
2180
2181	return self->focus;
2182	}
2183
2184	/**
2185	* gdk_crossing_event_get_detail:
2186	* @event: (type GdkCrossingEvent): a crossing event
2187	*
2188	* Extracts the notify detail from a crossing event.
2189	*
2190	* Returns: the notify detail of @event
2191	*/
2192	GdkNotifyType
2193	gdk_crossing_event_get_detail (GdkEvent *event)
2194	{
2195	GdkCrossingEvent *self = (GdkCrossingEvent *) event;
2196
2197	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
2198	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_ENTER_NOTIFY) ||
2199	GDK_IS_EVENT_TYPE (event, GDK_LEAVE_NOTIFY), 0);
2200
2201	return self->detail;
2202	}
2203
2204	/* }}} */
2205
2206	/* {{{ GdkDeleteEvent */
2207
2208	/**
2209	* GdkDeleteEvent:
2210	*
2211	* An event related to closing a top-level surface.
2212	*/
2213
2214	static const GdkEventTypeInfo gdk_delete_event_info = {
2215	sizeof (GdkDeleteEvent),
2216	NULL,
2217	NULL,
2218	NULL,
2219	NULL,
2220	NULL,
2221	NULL,
2222	NULL,
2223	};
2224
2225	GDK_DEFINE_EVENT_TYPE (GdkDeleteEvent, gdk_delete_event,
2226	&gdk_delete_event_info,
2227	GDK_EVENT_TYPE_SLOT (GDK_DELETE))
2228
2229	GdkEvent *
2230	gdk_delete_event_new (GdkSurface *surface)
2231	{
2232	return gdk_event_alloc (event_type: GDK_DELETE, surface, NULL, GDK_CURRENT_TIME);
2233	}
2234
2235	/* }}} */
2236
2237	/* {{{ GdkFocusEvent */
2238
2239	/**
2240	* GdkFocusEvent:
2241	*
2242	* An event related to a keyboard focus change.
2243	*/
2244
2245	static const GdkEventTypeInfo gdk_focus_event_info = {
2246	sizeof (GdkFocusEvent),
2247	NULL,
2248	NULL,
2249	NULL,
2250	NULL,
2251	NULL,
2252	NULL,
2253	NULL,
2254	};
2255
2256	GDK_DEFINE_EVENT_TYPE (GdkFocusEvent, gdk_focus_event,
2257	&gdk_focus_event_info,
2258	GDK_EVENT_TYPE_SLOT (GDK_FOCUS_CHANGE))
2259
2260	GdkEvent *
2261	gdk_focus_event_new (GdkSurface *surface,
2262	GdkDevice *device,
2263	gboolean focus_in)
2264	{
2265	GdkFocusEvent *self = gdk_event_alloc (event_type: GDK_FOCUS_CHANGE, surface, device, GDK_CURRENT_TIME);
2266
2267	self->focus_in = focus_in;
2268
2269	return (GdkEvent *) self;
2270	}
2271
2272	/**
2273	* gdk_focus_event_get_in:
2274	* @event: (type GdkFocusEvent): a focus change event
2275	*
2276	* Extracts whether this event is about focus entering or
2277	* leaving the surface.
2278	*
2279	* Returns: %TRUE of the focus is entering
2280	*/
2281	gboolean
2282	gdk_focus_event_get_in (GdkEvent *event)
2283	{
2284	GdkFocusEvent *self = (GdkFocusEvent *) event;
2285
2286	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
2287	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_FOCUS_CHANGE), FALSE);
2288
2289	return self->focus_in;
2290	}
2291
2292	/* }}} */
2293
2294	/* {{{ GdkScrollEvent */
2295
2296	/**
2297	* GdkScrollEvent:
2298	*
2299	* An event related to a scrolling motion.
2300	*/
2301
2302	static void
2303	gdk_scroll_event_finalize (GdkEvent *event)
2304	{
2305	GdkScrollEvent *self = (GdkScrollEvent *) event;
2306
2307	g_clear_object (&self->tool);
2308	if (self->history)
2309	g_array_free (array: self->history, TRUE);
2310
2311	GDK_EVENT_SUPER (self)->finalize (event);
2312	}
2313
2314	static GdkModifierType
2315	gdk_scroll_event_get_state (GdkEvent *event)
2316	{
2317	GdkScrollEvent *self = (GdkScrollEvent *) event;
2318
2319	return self->state;
2320	}
2321
2322	static GdkDeviceTool *
2323	gdk_scroll_event_get_tool (GdkEvent *event)
2324	{
2325	GdkScrollEvent *self = (GdkScrollEvent *) event;
2326
2327	return self->tool;
2328	}
2329
2330	static const GdkEventTypeInfo gdk_scroll_event_info = {
2331	sizeof (GdkScrollEvent),
2332	NULL,
2333	gdk_scroll_event_finalize,
2334	gdk_scroll_event_get_state,
2335	NULL,
2336	NULL,
2337	gdk_scroll_event_get_tool,
2338	NULL,
2339	};
2340
2341	GDK_DEFINE_EVENT_TYPE (GdkScrollEvent, gdk_scroll_event,
2342	&gdk_scroll_event_info,
2343	GDK_EVENT_TYPE_SLOT (GDK_SCROLL))
2344
2345	GdkEvent *
2346	gdk_scroll_event_new (GdkSurface *surface,
2347	GdkDevice *device,
2348	GdkDeviceTool *tool,
2349	guint32 time,
2350	GdkModifierType state,
2351	double delta_x,
2352	double delta_y,
2353	gboolean is_stop)
2354	{
2355	GdkScrollEvent *self = gdk_event_alloc (event_type: GDK_SCROLL, surface, device, time_: time);
2356
2357	self->tool = tool != NULL ? g_object_ref (tool) : NULL;
2358	self->state = state;
2359	self->direction = GDK_SCROLL_SMOOTH;
2360	self->delta_x = delta_x;
2361	self->delta_y = delta_y;
2362	self->is_stop = is_stop;
2363
2364	return (GdkEvent *) self;
2365	}
2366
2367	GdkEvent *
2368	gdk_scroll_event_new_discrete (GdkSurface *surface,
2369	GdkDevice *device,
2370	GdkDeviceTool *tool,
2371	guint32 time,
2372	GdkModifierType state,
2373	GdkScrollDirection direction,
2374	gboolean emulated)
2375	{
2376	GdkScrollEvent *self = gdk_event_alloc (event_type: GDK_SCROLL, surface, device, time_: time);
2377
2378	self->tool = tool != NULL ? g_object_ref (tool) : NULL;
2379	self->state = state;
2380	self->direction = direction;
2381	self->pointer_emulated = emulated;
2382
2383	return (GdkEvent *) self;
2384	}
2385
2386	/**
2387	* gdk_scroll_event_get_direction:
2388	* @event: (type GdkScrollEvent): a scroll event
2389	*
2390	* Extracts the direction of a scroll event.
2391	*
2392	* Returns: the scroll direction of @event
2393	*/
2394	GdkScrollDirection
2395	gdk_scroll_event_get_direction (GdkEvent *event)
2396	{
2397	GdkScrollEvent *self = (GdkScrollEvent *) event;
2398
2399	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
2400	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_SCROLL), 0);
2401
2402	return self->direction;
2403	}
2404
2405	/**
2406	* gdk_scroll_event_get_deltas:
2407	* @event: (type GdkScrollEvent): a scroll event
2408	* @delta_x: (out): return location for x scroll delta
2409	* @delta_y: (out): return location for y scroll delta
2410	*
2411	* Extracts the scroll deltas of a scroll event.
2412	*
2413	* The deltas will be zero unless the scroll direction
2414	* is %GDK_SCROLL_SMOOTH.
2415	*/
2416	void
2417	gdk_scroll_event_get_deltas (GdkEvent *event,
2418	double *delta_x,
2419	double *delta_y)
2420	{
2421	GdkScrollEvent *self = (GdkScrollEvent *) event;
2422
2423	g_return_if_fail (GDK_IS_EVENT (event));
2424	g_return_if_fail (GDK_IS_EVENT_TYPE (event, GDK_SCROLL));
2425
2426	*delta_x = self->delta_x;
2427	*delta_y = self->delta_y;
2428	}
2429
2430	/**
2431	* gdk_scroll_event_is_stop:
2432	* @event: (type GdkScrollEvent): a scroll event
2433	*
2434	* Check whether a scroll event is a stop scroll event.
2435	*
2436	* Scroll sequences with smooth scroll information may provide
2437	* a stop scroll event once the interaction with the device finishes,
2438	* e.g. by lifting a finger. This stop scroll event is the signal
2439	* that a widget may trigger kinetic scrolling based on the current
2440	* velocity.
2441	*
2442	* Stop scroll events always have a delta of 0/0.
2443	*
2444	* Returns: %TRUE if the event is a scroll stop event
2445	*/
2446	gboolean
2447	gdk_scroll_event_is_stop (GdkEvent *event)
2448	{
2449	GdkScrollEvent *self = (GdkScrollEvent *) event;
2450
2451	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
2452	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_SCROLL), FALSE);
2453
2454	return self->is_stop;
2455	}
2456
2457	/* }}} */
2458
2459	/* {{{ GdkTouchpadEvent */
2460
2461	/**
2462	* GdkTouchpadEvent:
2463	*
2464	* An event related to a gesture on a touchpad device.
2465	*
2466	* Unlike touchscreens, where the windowing system sends basic
2467	* sequences of begin, update, end events, and leaves gesture
2468	* recognition to the clients, touchpad gestures are typically
2469	* processed by the system, resulting in these events.
2470	*/
2471
2472	static GdkModifierType
2473	gdk_touchpad_event_get_state (GdkEvent *event)
2474	{
2475	GdkTouchpadEvent *self = (GdkTouchpadEvent *) event;
2476
2477	return self->state;
2478	}
2479
2480	static GdkEventSequence *
2481	gdk_touchpad_event_get_sequence (GdkEvent *event)
2482	{
2483	GdkTouchpadEvent *self = (GdkTouchpadEvent *) event;
2484
2485	return self->sequence;
2486	}
2487
2488	static gboolean
2489	gdk_touchpad_event_get_position (GdkEvent *event,
2490	double *x,
2491	double *y)
2492	{
2493	GdkTouchpadEvent *self = (GdkTouchpadEvent *) event;
2494
2495	*x = self->x;
2496	*y = self->y;
2497
2498	return TRUE;
2499	}
2500
2501	static const GdkEventTypeInfo gdk_touchpad_event_info = {
2502	sizeof (GdkTouchpadEvent),
2503	NULL,
2504	NULL,
2505	gdk_touchpad_event_get_state,
2506	gdk_touchpad_event_get_position,
2507	gdk_touchpad_event_get_sequence,
2508	NULL,
2509	NULL,
2510	};
2511
2512	GDK_DEFINE_EVENT_TYPE (GdkTouchpadEvent, gdk_touchpad_event,
2513	&gdk_touchpad_event_info,
2514	GDK_EVENT_TYPE_SLOT (GDK_TOUCHPAD_SWIPE)
2515	GDK_EVENT_TYPE_SLOT (GDK_TOUCHPAD_PINCH)
2516	GDK_EVENT_TYPE_SLOT (GDK_TOUCHPAD_HOLD))
2517
2518	GdkEvent *
2519	gdk_touchpad_event_new_swipe (GdkSurface *surface,
2520	GdkEventSequence *sequence,
2521	GdkDevice *device,
2522	guint32 time,
2523	GdkModifierType state,
2524	GdkTouchpadGesturePhase phase,
2525	double x,
2526	double y,
2527	int n_fingers,
2528	double dx,
2529	double dy)
2530	{
2531	GdkTouchpadEvent *self;
2532
2533	g_return_val_if_fail (phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN ||
2534	phase == GDK_TOUCHPAD_GESTURE_PHASE_END ||
2535	phase == GDK_TOUCHPAD_GESTURE_PHASE_UPDATE ||
2536	phase == GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, NULL);
2537
2538	self = gdk_event_alloc (event_type: GDK_TOUCHPAD_SWIPE, surface, device, time_: time);
2539
2540	self->sequence = sequence;
2541	self->state = state;
2542	self->phase = phase;
2543	self->x = x;
2544	self->y = y;
2545	self->dx = dx;
2546	self->dy = dy;
2547	self->n_fingers = n_fingers;
2548
2549	return (GdkEvent *) self;
2550	}
2551
2552	GdkEvent *
2553	gdk_touchpad_event_new_pinch (GdkSurface *surface,
2554	GdkEventSequence *sequence,
2555	GdkDevice *device,
2556	guint32 time,
2557	GdkModifierType state,
2558	GdkTouchpadGesturePhase phase,
2559	double x,
2560	double y,
2561	int n_fingers,
2562	double dx,
2563	double dy,
2564	double scale,
2565	double angle_delta)
2566	{
2567	GdkTouchpadEvent *self;
2568
2569	g_return_val_if_fail (phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN ||
2570	phase == GDK_TOUCHPAD_GESTURE_PHASE_END ||
2571	phase == GDK_TOUCHPAD_GESTURE_PHASE_UPDATE ||
2572	phase == GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, NULL);
2573
2574	self = gdk_event_alloc (event_type: GDK_TOUCHPAD_PINCH, surface, device, time_: time);
2575
2576	self->sequence = sequence;
2577	self->state = state;
2578	self->phase = phase;
2579	self->x = x;
2580	self->y = y;
2581	self->dx = dx;
2582	self->dy = dy;
2583	self->n_fingers = n_fingers;
2584	self->scale = scale;
2585	self->angle_delta = angle_delta;
2586
2587	return (GdkEvent *) self;
2588	}
2589
2590	GdkEvent *
2591	gdk_touchpad_event_new_hold (GdkSurface *surface,
2592	GdkDevice *device,
2593	guint32 time,
2594	GdkModifierType state,
2595	GdkTouchpadGesturePhase phase,
2596	double x,
2597	double y,
2598	int n_fingers)
2599	{
2600	GdkTouchpadEvent *self = gdk_event_alloc (event_type: GDK_TOUCHPAD_HOLD, surface, device, time_: time);
2601
2602	self->state = state;
2603	self->phase = phase;
2604	self->x = x;
2605	self->y = y;
2606	self->n_fingers = n_fingers;
2607
2608	return (GdkEvent *) self;
2609	}
2610
2611	/**
2612	* gdk_touchpad_event_get_gesture_phase:
2613	* @event: (type GdkTouchpadEvent): a touchpad event
2614	*
2615	* Extracts the touchpad gesture phase from a touchpad event.
2616	*
2617	* Returns: the gesture phase of @event
2618	**/
2619	GdkTouchpadGesturePhase
2620	gdk_touchpad_event_get_gesture_phase (GdkEvent *event)
2621	{
2622	GdkTouchpadEvent *self = (GdkTouchpadEvent *) event;
2623
2624	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
2625	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_PINCH) ||
2626	GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_SWIPE) ||
2627	GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_HOLD), 0);
2628
2629	return self->phase;
2630	}
2631
2632	/**
2633	* gdk_touchpad_event_get_n_fingers:
2634	* @event: (type GdkTouchpadEvent): a touchpad event
2635	*
2636	* Extracts the number of fingers from a touchpad event.
2637	*
2638	* Returns: the number of fingers for @event
2639	**/
2640	guint
2641	gdk_touchpad_event_get_n_fingers (GdkEvent *event)
2642	{
2643	GdkTouchpadEvent *self = (GdkTouchpadEvent *) event;
2644
2645	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
2646	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_PINCH) ||
2647	GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_SWIPE) ||
2648	GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_HOLD), 0);
2649
2650	return self->n_fingers;
2651	}
2652
2653	/**
2654	* gdk_touchpad_event_get_deltas:
2655	* @event: (type GdkTouchpadEvent): a touchpad event
2656	* @dx: (out): return location for x
2657	* @dy: (out): return location for y
2658	*
2659	* Extracts delta information from a touchpad event.
2660	*/
2661	void
2662	gdk_touchpad_event_get_deltas (GdkEvent *event,
2663	double *dx,
2664	double *dy)
2665	{
2666	GdkTouchpadEvent *self = (GdkTouchpadEvent *) event;
2667
2668	g_return_if_fail (GDK_IS_EVENT (event));
2669	g_return_if_fail (GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_PINCH) ||
2670	GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_SWIPE));
2671
2672	*dx = self->dx;
2673	*dy = self->dy;
2674	}
2675
2676	/**
2677	* gdk_touchpad_event_get_pinch_angle_delta:
2678	* @event: (type GdkTouchpadEvent): a touchpad pinch event
2679	*
2680	* Extracts the angle delta from a touchpad pinch event.
2681	*
2682	* Returns: the angle delta of @event
2683	*/
2684	double
2685	gdk_touchpad_event_get_pinch_angle_delta (GdkEvent *event)
2686	{
2687	GdkTouchpadEvent *self = (GdkTouchpadEvent *) event;
2688
2689	g_return_val_if_fail (GDK_IS_EVENT (event), 0.0);
2690	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_PINCH), 0.0);
2691
2692	return self->angle_delta;
2693	}
2694
2695	/**
2696	* gdk_touchpad_event_get_pinch_scale:
2697	* @event: (type GdkTouchpadEvent): a touchpad pinch event
2698	*
2699	* Extracts the scale from a touchpad pinch event.
2700	*
2701	* Returns: the scale of @event
2702	**/
2703	double
2704	gdk_touchpad_event_get_pinch_scale (GdkEvent *event)
2705	{
2706	GdkTouchpadEvent *self = (GdkTouchpadEvent *) event;
2707
2708	g_return_val_if_fail (GDK_IS_EVENT (event), 0.0);
2709	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_TOUCHPAD_PINCH), 0.0);
2710
2711	return self->scale;
2712	}
2713
2714	/* }}} */
2715
2716	/* {{{ GdkPadEvent */
2717
2718	/**
2719	* GdkPadEvent:
2720	*
2721	* An event related to a pad-based device.
2722	*/
2723
2724	static const GdkEventTypeInfo gdk_pad_event_info = {
2725	sizeof (GdkPadEvent),
2726	NULL,
2727	NULL,
2728	NULL,
2729	NULL,
2730	NULL,
2731	NULL,
2732	NULL,
2733	};
2734
2735	GDK_DEFINE_EVENT_TYPE (GdkPadEvent, gdk_pad_event,
2736	&gdk_pad_event_info,
2737	GDK_EVENT_TYPE_SLOT (GDK_PAD_BUTTON_PRESS)
2738	GDK_EVENT_TYPE_SLOT (GDK_PAD_BUTTON_RELEASE)
2739	GDK_EVENT_TYPE_SLOT (GDK_PAD_RING)
2740	GDK_EVENT_TYPE_SLOT (GDK_PAD_STRIP)
2741	GDK_EVENT_TYPE_SLOT (GDK_PAD_GROUP_MODE))
2742
2743	GdkEvent *
2744	gdk_pad_event_new_ring (GdkSurface *surface,
2745	GdkDevice *device,
2746	guint32 time,
2747	guint group,
2748	guint index,
2749	guint mode,
2750	double value)
2751	{
2752	GdkPadEvent *self = gdk_event_alloc (event_type: GDK_PAD_RING, surface, device, time_: time);
2753
2754	self->group = group;
2755	self->index = index;
2756	self->mode = mode;
2757	self->value = value;
2758
2759	return (GdkEvent *) self;
2760	}
2761
2762	GdkEvent *
2763	gdk_pad_event_new_strip (GdkSurface *surface,
2764	GdkDevice *device,
2765	guint32 time,
2766	guint group,
2767	guint index,
2768	guint mode,
2769	double value)
2770	{
2771	GdkPadEvent *self = gdk_event_alloc (event_type: GDK_PAD_STRIP, surface, device, time_: time);
2772
2773	self->group = group;
2774	self->index = index;
2775	self->mode = mode;
2776	self->value = value;
2777
2778	return (GdkEvent *) self;
2779	}
2780
2781	GdkEvent *
2782	gdk_pad_event_new_button (GdkEventType type,
2783	GdkSurface *surface,
2784	GdkDevice *device,
2785	guint32 time,
2786	guint group,
2787	guint button,
2788	guint mode)
2789	{
2790	GdkPadEvent *self;
2791
2792	g_return_val_if_fail (type == GDK_PAD_BUTTON_PRESS ||
2793	type == GDK_PAD_BUTTON_RELEASE, NULL);
2794
2795	self = gdk_event_alloc (event_type: type, surface, device, time_: time);
2796
2797	self->group = group;
2798	self->button = button;
2799	self->mode = mode;
2800
2801	return (GdkEvent *) self;
2802	}
2803
2804	GdkEvent *
2805	gdk_pad_event_new_group_mode (GdkSurface *surface,
2806	GdkDevice *device,
2807	guint32 time,
2808	guint group,
2809	guint mode)
2810	{
2811	GdkPadEvent *self = gdk_event_alloc (event_type: GDK_PAD_GROUP_MODE, surface, device, time_: time);
2812
2813	self->group = group;
2814	self->mode = mode;
2815
2816	return (GdkEvent *) self;
2817	}
2818	/**
2819	* gdk_pad_event_get_button:
2820	* @event: (type GdkPadEvent): a pad button event
2821	*
2822	* Extracts information about the pressed button from
2823	* a pad event.
2824	*
2825	* Returns: the button of @event
2826	*/
2827	guint
2828	gdk_pad_event_get_button (GdkEvent *event)
2829	{
2830	GdkPadEvent *self = (GdkPadEvent *) event;
2831
2832	g_return_val_if_fail (GDK_IS_EVENT (event), 0);
2833	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_PAD_BUTTON_PRESS) ||
2834	GDK_IS_EVENT_TYPE (event, GDK_PAD_BUTTON_RELEASE), 0);
2835
2836	return self->button;
2837	}
2838
2839	/**
2840	* gdk_pad_event_get_axis_value:
2841	* @event: (type GdkPadEvent): a pad strip or ring event
2842	* @index: (out): Return location for the axis index
2843	* @value: (out): Return location for the axis value
2844	*
2845	* Extracts the information from a pad strip or ring event.
2846	*/
2847	void
2848	gdk_pad_event_get_axis_value (GdkEvent *event,
2849	guint *index,
2850	double *value)
2851	{
2852	GdkPadEvent *self = (GdkPadEvent *) event;
2853
2854	g_return_if_fail (GDK_IS_EVENT (event));
2855	g_return_if_fail (GDK_IS_EVENT_TYPE (event, GDK_PAD_RING) ||
2856	GDK_IS_EVENT_TYPE (event, GDK_PAD_STRIP));
2857
2858	*index = self->index;
2859	*value = self->value;
2860	}
2861
2862	/**
2863	* gdk_pad_event_get_group_mode:
2864	* @event: (type GdkPadEvent): a pad event
2865	* @group: (out): return location for the group
2866	* @mode: (out): return location for the mode
2867	*
2868	* Extracts group and mode information from a pad event.
2869	*/
2870	void
2871	gdk_pad_event_get_group_mode (GdkEvent *event,
2872	guint *group,
2873	guint *mode)
2874	{
2875	GdkPadEvent *self = (GdkPadEvent *) event;
2876
2877	g_return_if_fail (GDK_IS_EVENT (event));
2878	g_return_if_fail (GDK_IS_EVENT_TYPE (event, GDK_PAD_GROUP_MODE) ||
2879	GDK_IS_EVENT_TYPE (event, GDK_PAD_BUTTON_PRESS) ||
2880	GDK_IS_EVENT_TYPE (event, GDK_PAD_BUTTON_RELEASE) ||
2881	GDK_IS_EVENT_TYPE (event, GDK_PAD_RING) ||
2882	GDK_IS_EVENT_TYPE (event, GDK_PAD_STRIP));
2883
2884	*group = self->group;
2885	*mode = self->mode;
2886	}
2887
2888	/* }}} */
2889
2890	/* {{{ GdkMotionEvent */
2891
2892	/**
2893	* GdkMotionEvent:
2894	*
2895	* An event related to a pointer or touch device motion.
2896	*/
2897
2898	static void
2899	gdk_motion_event_finalize (GdkEvent *event)
2900	{
2901	GdkMotionEvent *self = (GdkMotionEvent *) event;
2902
2903	g_clear_object (&self->tool);
2904	g_clear_pointer (&self->axes, g_free);
2905	if (self->history)
2906	g_array_free (array: self->history, TRUE);
2907
2908	GDK_EVENT_SUPER (event)->finalize (event);
2909	}
2910
2911	static GdkModifierType
2912	gdk_motion_event_get_state (GdkEvent *event)
2913	{
2914	GdkMotionEvent *self = (GdkMotionEvent *) event;
2915
2916	return self->state;
2917	}
2918
2919	static gboolean
2920	gdk_motion_event_get_position (GdkEvent *event,
2921	double *x,
2922	double *y)
2923	{
2924	GdkMotionEvent *self = (GdkMotionEvent *) event;
2925
2926	*x = self->x;
2927	*y = self->y;
2928
2929	return TRUE;
2930	}
2931
2932	static GdkDeviceTool *
2933	gdk_motion_event_get_tool (GdkEvent *event)
2934	{
2935	GdkMotionEvent *self = (GdkMotionEvent *) event;
2936
2937	return self->tool;
2938	}
2939
2940	static gboolean
2941	gdk_motion_event_get_axes (GdkEvent *event,
2942	double **axes,
2943	guint *n_axes)
2944	{
2945	GdkMotionEvent *self = (GdkMotionEvent *) event;
2946	GdkDevice *source_device = gdk_event_get_device (event);
2947
2948	if (source_device == NULL)
2949	return FALSE;
2950
2951	*axes = self->axes;
2952	*n_axes = GDK_AXIS_LAST;
2953
2954	return TRUE;
2955	}
2956
2957	static const GdkEventTypeInfo gdk_motion_event_info = {
2958	sizeof (GdkMotionEvent),
2959	NULL,
2960	gdk_motion_event_finalize,
2961	gdk_motion_event_get_state,
2962	gdk_motion_event_get_position,
2963	NULL,
2964	gdk_motion_event_get_tool,
2965	gdk_motion_event_get_axes,
2966	};
2967
2968	GDK_DEFINE_EVENT_TYPE (GdkMotionEvent, gdk_motion_event,
2969	&gdk_motion_event_info,
2970	GDK_EVENT_TYPE_SLOT (GDK_MOTION_NOTIFY))
2971
2972	GdkEvent *
2973	gdk_motion_event_new (GdkSurface *surface,
2974	GdkDevice *device,
2975	GdkDeviceTool *tool,
2976	guint32 time,
2977	GdkModifierType state,
2978	double x,
2979	double y,
2980	double *axes)
2981	{
2982	GdkMotionEvent *self = gdk_event_alloc (event_type: GDK_MOTION_NOTIFY, surface, device, time_: time);
2983
2984	self->tool = tool ? g_object_ref (tool) : NULL;
2985	self->state = state;
2986	self->x = x;
2987	self->y = y;
2988	self->axes = axes;
2989	self->state = state;
2990
2991	return (GdkEvent *) self;
2992	}
2993
2994	/**
2995	* gdk_event_get_history:
2996	* @event: a motion or scroll event
2997	* @out_n_coords: (out): Return location for the length of the returned array
2998	*
2999	* Retrieves the history of the device that @event is for, as a list of
3000	* time and coordinates.
3001	*
3002	* The history includes positions that are not delivered as separate events
3003	* to the application because they occurred in the same frame as @event.
3004	*
3005	* Note that only motion and scroll events record history, and motion
3006	* events do it only if one of the mouse buttons is down, or the device
3007	* has a tool.
3008	*
3009	* Returns: (transfer container) (array length=out_n_coords) (nullable): an
3010	* array of time and coordinates
3011	*/
3012	GdkTimeCoord *
3013	gdk_event_get_history (GdkEvent *event,
3014	guint *out_n_coords)
3015	{
3016	GArray *history;
3017
3018	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
3019	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_MOTION_NOTIFY) ||
3020	GDK_IS_EVENT_TYPE (event, GDK_SCROLL), NULL);
3021	g_return_val_if_fail (out_n_coords != NULL, NULL);
3022
3023	if (GDK_IS_EVENT_TYPE (event, GDK_MOTION_NOTIFY))
3024	{
3025	GdkMotionEvent *self = (GdkMotionEvent *) event;
3026	history = self->history;
3027	}
3028	else
3029	{
3030	GdkScrollEvent *self = (GdkScrollEvent *) event;
3031	history = self->history;
3032	}
3033
3034	if (history && history->len > 0)
3035	{
3036	GdkTimeCoord *result;
3037
3038	*out_n_coords = history->len;
3039
3040	result = g_malloc (n_bytes: sizeof (GdkTimeCoord) * history->len);
3041	memcpy (dest: result, src: history->data, n: sizeof (GdkTimeCoord) * history->len);
3042
3043	return result;
3044	}
3045
3046	*out_n_coords = 0;
3047	return NULL;
3048	}
3049
3050	/* }}} */
3051
3052	/* {{{ GdkProximityEvent */
3053
3054	/**
3055	* GdkProximityEvent:
3056	*
3057	* An event related to the proximity of a tool to a device.
3058	*/
3059
3060	static void
3061	gdk_proximity_event_finalize (GdkEvent *event)
3062	{
3063	GdkProximityEvent *self = (GdkProximityEvent *) event;
3064
3065	g_clear_object (&self->tool);
3066
3067	GDK_EVENT_SUPER (event)->finalize (event);
3068	}
3069
3070	static GdkDeviceTool *
3071	gdk_proximity_event_get_tool (GdkEvent *event)
3072	{
3073	GdkProximityEvent *self = (GdkProximityEvent *) event;
3074
3075	return self->tool;
3076	}
3077
3078	static const GdkEventTypeInfo gdk_proximity_event_info = {
3079	sizeof (GdkProximityEvent),
3080	NULL,
3081	gdk_proximity_event_finalize,
3082	NULL,
3083	NULL,
3084	NULL,
3085	gdk_proximity_event_get_tool,
3086	NULL,
3087	};
3088
3089	GDK_DEFINE_EVENT_TYPE (GdkProximityEvent, gdk_proximity_event,
3090	&gdk_proximity_event_info,
3091	GDK_EVENT_TYPE_SLOT (GDK_PROXIMITY_IN)
3092	GDK_EVENT_TYPE_SLOT (GDK_PROXIMITY_OUT))
3093
3094	GdkEvent *
3095	gdk_proximity_event_new (GdkEventType type,
3096	GdkSurface *surface,
3097	GdkDevice *device,
3098	GdkDeviceTool *tool,
3099	guint32 time)
3100	{
3101	GdkProximityEvent *self;
3102
3103	g_return_val_if_fail (type == GDK_PROXIMITY_IN ||
3104	type == GDK_PROXIMITY_OUT, NULL);
3105
3106	self = gdk_event_alloc (event_type: type, surface, device, time_: time);
3107
3108	self->tool = tool ? g_object_ref (tool) : NULL;
3109
3110	return (GdkEvent *) self;
3111	}
3112
3113	/* }}} */
3114
3115	/* {{{ GdkDNDEvent */
3116
3117	/**
3118	* GdkDNDEvent:
3119	*
3120	* An event related to drag and drop operations.
3121	*/
3122
3123	static void
3124	gdk_dnd_event_finalize (GdkEvent *event)
3125	{
3126	GdkDNDEvent *self = (GdkDNDEvent *) event;
3127
3128	g_clear_object (&self->drop);
3129
3130	GDK_EVENT_SUPER (event)->finalize (event);
3131	}
3132
3133	static gboolean
3134	gdk_dnd_event_get_position (GdkEvent *event,
3135	double *x,
3136	double *y)
3137	{
3138	GdkDNDEvent *self = (GdkDNDEvent *) event;
3139
3140	*x = self->x;
3141	*y = self->y;
3142
3143	return TRUE;
3144	}
3145
3146	static GdkEventSequence *
3147	gdk_dnd_event_get_sequence (GdkEvent *event)
3148	{
3149	GdkDNDEvent *self = (GdkDNDEvent *) event;
3150
3151	return (GdkEventSequence *) self->drop;
3152	}
3153
3154	static const GdkEventTypeInfo gdk_dnd_event_info = {
3155	sizeof (GdkDNDEvent),
3156	NULL,
3157	gdk_dnd_event_finalize,
3158	NULL,
3159	gdk_dnd_event_get_position,
3160	gdk_dnd_event_get_sequence,
3161	NULL,
3162	NULL,
3163	};
3164
3165	GDK_DEFINE_EVENT_TYPE (GdkDNDEvent, gdk_dnd_event,
3166	&gdk_dnd_event_info,
3167	GDK_EVENT_TYPE_SLOT (GDK_DRAG_ENTER)
3168	GDK_EVENT_TYPE_SLOT (GDK_DRAG_MOTION)
3169	GDK_EVENT_TYPE_SLOT (GDK_DRAG_LEAVE)
3170	GDK_EVENT_TYPE_SLOT (GDK_DROP_START))
3171
3172	GdkEvent *
3173	gdk_dnd_event_new (GdkEventType type,
3174	GdkSurface *surface,
3175	GdkDevice *device,
3176	GdkDrop *drop,
3177	guint32 time,
3178	double x,
3179	double y)
3180	{
3181	GdkDNDEvent *self;
3182
3183	g_return_val_if_fail (type == GDK_DRAG_ENTER ||
3184	type == GDK_DRAG_MOTION ||
3185	type == GDK_DRAG_LEAVE ||
3186	type == GDK_DROP_START, NULL);
3187
3188	self = gdk_event_alloc (event_type: type, surface, device, time_: time);
3189
3190	self->drop = drop != NULL ? g_object_ref (drop) : NULL;
3191	self->x = x;
3192	self->y = y;
3193
3194	return (GdkEvent *) self;
3195	}
3196
3197	/**
3198	* gdk_dnd_event_get_drop:
3199	* @event: (type GdkDNDEvent): a DND event
3200	*
3201	* Gets the `GdkDrop` object from a DND event.
3202	*
3203	* Returns: (transfer none) (nullable): the drop
3204	**/
3205	GdkDrop *
3206	gdk_dnd_event_get_drop (GdkEvent *event)
3207	{
3208	GdkDNDEvent *self = (GdkDNDEvent *) event;
3209
3210	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
3211	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_DRAG_ENTER) ||
3212	GDK_IS_EVENT_TYPE (event, GDK_DRAG_MOTION) ||
3213	GDK_IS_EVENT_TYPE (event, GDK_DRAG_LEAVE) ||
3214	GDK_IS_EVENT_TYPE (event, GDK_DROP_START), NULL);
3215
3216	return self->drop;
3217	}
3218
3219	/* }}} */
3220
3221	/* {{{ GdkGrabBrokenEvent */
3222
3223	/**
3224	* GdkGrabBrokenEvent:
3225	*
3226	* An event related to a broken windowing system grab.
3227	*/
3228
3229	static const GdkEventTypeInfo gdk_grab_broken_event_info = {
3230	sizeof (GdkGrabBrokenEvent),
3231	NULL,
3232	NULL,
3233	NULL,
3234	NULL,
3235	NULL,
3236	NULL,
3237	NULL,
3238	};
3239
3240	GDK_DEFINE_EVENT_TYPE (GdkGrabBrokenEvent, gdk_grab_broken_event,
3241	&gdk_grab_broken_event_info,
3242	GDK_EVENT_TYPE_SLOT (GDK_GRAB_BROKEN))
3243
3244	GdkEvent *
3245	gdk_grab_broken_event_new (GdkSurface *surface,
3246	GdkDevice *device,
3247	GdkSurface *grab_surface,
3248	gboolean implicit)
3249	{
3250	GdkGrabBrokenEvent *self = gdk_event_alloc (event_type: GDK_GRAB_BROKEN, surface, device, GDK_CURRENT_TIME);
3251
3252	self->grab_surface = grab_surface;
3253	self->implicit = implicit;
3254	self->keyboard = gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD;
3255
3256	return (GdkEvent *) self;
3257	}
3258
3259	/**
3260	* gdk_grab_broken_event_get_grab_surface:
3261	* @event: (type GdkGrabBrokenEvent): a grab broken event
3262	*
3263	* Extracts the grab surface from a grab broken event.
3264	*
3265	* Returns: (transfer none): the grab surface of @event
3266	**/
3267	GdkSurface *
3268	gdk_grab_broken_event_get_grab_surface (GdkEvent *event)
3269	{
3270	GdkGrabBrokenEvent *self = (GdkGrabBrokenEvent *) event;
3271
3272	g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
3273	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_GRAB_BROKEN), NULL);
3274
3275	return self->grab_surface;
3276	}
3277
3278	/**
3279	* gdk_grab_broken_event_get_implicit:
3280	* @event: (type GdkGrabBrokenEvent): a grab broken event
3281	*
3282	* Checks whether the grab broken event is for an implicit grab.
3283	*
3284	* Returns: %TRUE if the an implicit grab was broken
3285	*/
3286	gboolean
3287	gdk_grab_broken_event_get_implicit (GdkEvent *event)
3288	{
3289	GdkGrabBrokenEvent *self = (GdkGrabBrokenEvent *) event;
3290
3291	g_return_val_if_fail (GDK_IS_EVENT (event), FALSE);
3292	g_return_val_if_fail (GDK_IS_EVENT_TYPE (event, GDK_GRAB_BROKEN), FALSE);
3293
3294	return self->implicit;
3295	}
3296
3297	/* }}} */
3298