1 /* GDK - The GIMP Drawing Kit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
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.
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.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
28 #include "gdkinternals.h"
30 typedef struct _GdkIOClosure GdkIOClosure;
31 typedef struct _GdkEventPrivate GdkEventPrivate;
35 /* Following flag is set for events on the event queue during
36 * translation and cleared afterwards.
38 GDK_EVENT_PENDING = 1 << 0
43 GdkInputFunction function;
44 GdkInputCondition condition;
45 GdkDestroyNotify notify;
49 struct _GdkEventPrivate
55 /* Private variable declarations
58 static guint32 button_click_time[2] = { 0, 0}; /* The last 2 button click times. Used
59 * to determine if the latest button click
60 * is part of a double or triple click.
62 static GdkWindow *button_window[2] = { NULL, NULL}; /* The last 2 windows to receive button presses.
63 * Also used to determine if the latest button
64 * click is part of a double or triple click.
66 static guint button_number[2] = { -1, -1 }; /* The last 2 buttons to be pressed.
68 GdkEventFunc _gdk_event_func = NULL; /* Callback for events */
69 gpointer _gdk_event_data = NULL;
70 GDestroyNotify _gdk_event_notify = NULL;
72 static guint double_click_time = 250;
73 #define TRIPLE_CLICK_TIME (2*double_click_time)
74 #define DOUBLE_CLICK_DIST 5
75 #define TRIPLE_CLICK_DIST 5
77 /*********************************************
78 * Functions for maintaining the event queue *
79 *********************************************/
81 /*************************************************************
82 * _gdk_event_queue_find_first:
83 * Find the first event on the queue that is not still
88 * Pointer to the list node for that event, or NULL
89 *************************************************************/
92 _gdk_event_queue_find_first (void)
94 GList *tmp_list = _gdk_queued_events;
98 GdkEventPrivate *event = tmp_list->data;
99 if (!(event->flags & GDK_EVENT_PENDING))
102 tmp_list = g_list_next (tmp_list);
108 /*************************************************************
109 * _gdk_event_queue_remove_link:
110 * Remove a specified list node from the event queue.
112 * node: Node to remove.
114 *************************************************************/
117 _gdk_event_queue_remove_link (GList *node)
120 node->prev->next = node->next;
122 _gdk_queued_events = node->next;
125 node->next->prev = node->prev;
127 _gdk_queued_tail = node->prev;
130 /*************************************************************
131 * _gdk_event_queue_append:
132 * Append an event onto the tail of the event queue.
134 * event: Event to append.
136 *************************************************************/
139 _gdk_event_queue_append (GdkEvent *event)
141 _gdk_queued_tail = g_list_append (_gdk_queued_tail, event);
143 if (!_gdk_queued_events)
144 _gdk_queued_events = _gdk_queued_tail;
146 _gdk_queued_tail = _gdk_queued_tail->next;
149 /*************************************************************
150 * gdk_event_handler_set:
153 * func: Callback function to be called for each event.
154 * data: Data supplied to the function
155 * notify: function called when function is no longer needed
158 *************************************************************/
161 gdk_event_handler_set (GdkEventFunc func,
163 GDestroyNotify notify)
165 if (_gdk_event_notify)
166 (*_gdk_event_notify) (_gdk_event_data);
168 _gdk_event_func = func;
169 _gdk_event_data = data;
170 _gdk_event_notify = notify;
174 *--------------------------------------------------------------
177 * Gets the next event.
182 * If an event is waiting that we care about, returns
183 * a pointer to that event, to be freed with gdk_event_free.
184 * Otherwise, returns NULL.
188 *--------------------------------------------------------------
194 _gdk_events_queue ();
196 return _gdk_event_unqueue ();
200 *--------------------------------------------------------------
203 * Gets the next event.
208 * If an event is waiting that we care about, returns
209 * a copy of that event, but does not remove it from
210 * the queue. The pointer is to be freed with gdk_event_free.
211 * Otherwise, returns NULL.
215 *--------------------------------------------------------------
219 gdk_event_peek (void)
223 tmp_list = _gdk_event_queue_find_first ();
226 return gdk_event_copy (tmp_list->data);
232 gdk_event_put (GdkEvent *event)
236 g_return_if_fail (event != NULL);
238 new_event = gdk_event_copy (event);
240 _gdk_event_queue_append (new_event);
244 *--------------------------------------------------------------
247 * Copy a event structure into new storage.
250 * "event" is the event struct to copy.
253 * A new event structure. Free it with gdk_event_free.
256 * The reference count of the window in the event is increased.
258 *--------------------------------------------------------------
261 static GMemChunk *event_chunk = NULL;
264 _gdk_event_new (void)
266 GdkEventPrivate *new_event;
268 if (event_chunk == NULL)
269 event_chunk = g_mem_chunk_new ("events",
270 sizeof (GdkEventPrivate),
274 new_event = g_chunk_new (GdkEventPrivate, event_chunk);
275 new_event->flags = 0;
277 return (GdkEvent*) new_event;
281 gdk_event_copy (GdkEvent *event)
285 g_return_val_if_fail (event != NULL, NULL);
287 new_event = _gdk_event_new ();
290 if (new_event->any.window)
291 gdk_window_ref (new_event->any.window);
293 switch (event->any.type)
296 case GDK_KEY_RELEASE:
297 new_event->key.string = g_strdup (event->key.string);
300 case GDK_ENTER_NOTIFY:
301 case GDK_LEAVE_NOTIFY:
302 if (event->crossing.subwindow != NULL)
303 gdk_window_ref (event->crossing.subwindow);
308 case GDK_DRAG_MOTION:
309 case GDK_DRAG_STATUS:
311 case GDK_DROP_FINISHED:
312 gdk_drag_context_ref (event->dnd.context);
316 if (event->expose.region)
317 new_event->expose.region = gdk_region_copy (event->expose.region);
321 new_event->setting.name = g_strdup (new_event->setting.name);
332 *--------------------------------------------------------------
335 * Free a event structure obtained from gdk_event_copy. Do not use
336 * with other event structures.
339 * "event" is the event struct to free.
344 * The reference count of the window in the event is decreased and
345 * might be freed, too.
347 *-------------------------------------------------------------- */
350 gdk_event_free (GdkEvent *event)
352 g_return_if_fail (event != NULL);
354 g_assert (event_chunk != NULL); /* paranoid */
356 if (event->any.window)
357 gdk_window_unref (event->any.window);
359 switch (event->any.type)
362 case GDK_KEY_RELEASE:
363 g_free (event->key.string);
366 case GDK_ENTER_NOTIFY:
367 case GDK_LEAVE_NOTIFY:
368 if (event->crossing.subwindow != NULL)
369 gdk_window_unref (event->crossing.subwindow);
374 case GDK_DRAG_MOTION:
375 case GDK_DRAG_STATUS:
377 case GDK_DROP_FINISHED:
378 gdk_drag_context_unref (event->dnd.context);
381 case GDK_BUTTON_PRESS:
382 case GDK_BUTTON_RELEASE:
383 if (event->button.axes)
384 g_free (event->button.axes);
388 if (event->expose.region)
389 gdk_region_destroy (event->expose.region);
392 case GDK_MOTION_NOTIFY:
393 if (event->motion.axes)
394 g_free (event->motion.axes);
398 g_free (event->setting.name);
405 g_mem_chunk_free (event_chunk, event);
409 * gdk_event_get_time:
410 * @event: a #GdkEvent
412 * Returns the time stamp from @event, if there is one; otherwise
413 * returns #GDK_CURRENT_TIME. If @event is %NULL, returns #GDK_CURRENT_TIME.
415 * Return value: time stamp field from @event
418 gdk_event_get_time (GdkEvent *event)
423 case GDK_MOTION_NOTIFY:
424 return event->motion.time;
425 case GDK_BUTTON_PRESS:
426 case GDK_2BUTTON_PRESS:
427 case GDK_3BUTTON_PRESS:
428 case GDK_BUTTON_RELEASE:
429 return event->button.time;
431 return event->scroll.time;
433 case GDK_KEY_RELEASE:
434 return event->key.time;
435 case GDK_ENTER_NOTIFY:
436 case GDK_LEAVE_NOTIFY:
437 return event->crossing.time;
438 case GDK_PROPERTY_NOTIFY:
439 return event->property.time;
440 case GDK_SELECTION_CLEAR:
441 case GDK_SELECTION_REQUEST:
442 case GDK_SELECTION_NOTIFY:
443 return event->selection.time;
444 case GDK_PROXIMITY_IN:
445 case GDK_PROXIMITY_OUT:
446 return event->proximity.time;
449 case GDK_DRAG_MOTION:
450 case GDK_DRAG_STATUS:
452 case GDK_DROP_FINISHED:
453 return event->dnd.time;
454 case GDK_CLIENT_EVENT:
455 case GDK_VISIBILITY_NOTIFY:
458 case GDK_FOCUS_CHANGE:
465 case GDK_WINDOW_STATE:
467 /* return current time */
471 return GDK_CURRENT_TIME;
475 * gdk_event_get_state:
476 * @event: a #GdkEvent or NULL
477 * @state: return location for state
479 * If the event contains a "state" field, puts that field in @state. Otherwise
480 * stores an empty state (0). Returns %TRUE if there was a state field
481 * in the event. @event may be %NULL, in which case it's treated
482 * as if the event had no state field.
484 * Return value: %TRUE if there was a state field in the event
487 gdk_event_get_state (GdkEvent *event,
488 GdkModifierType *state)
490 g_return_val_if_fail (state != NULL, FALSE);
495 case GDK_MOTION_NOTIFY:
496 *state = event->motion.state;
498 case GDK_BUTTON_PRESS:
499 case GDK_2BUTTON_PRESS:
500 case GDK_3BUTTON_PRESS:
501 case GDK_BUTTON_RELEASE:
502 *state = event->button.state;
505 *state = event->scroll.state;
508 case GDK_KEY_RELEASE:
509 *state = event->key.state;
511 case GDK_ENTER_NOTIFY:
512 case GDK_LEAVE_NOTIFY:
513 *state = event->crossing.state;
515 case GDK_PROPERTY_NOTIFY:
516 *state = event->property.state;
518 case GDK_VISIBILITY_NOTIFY:
519 *state = event->visibility.state;
521 case GDK_CLIENT_EVENT:
524 case GDK_FOCUS_CHANGE:
525 case GDK_SELECTION_CLEAR:
526 case GDK_SELECTION_REQUEST:
527 case GDK_SELECTION_NOTIFY:
528 case GDK_PROXIMITY_IN:
529 case GDK_PROXIMITY_OUT:
532 case GDK_DRAG_MOTION:
533 case GDK_DRAG_STATUS:
535 case GDK_DROP_FINISHED:
542 case GDK_WINDOW_STATE:
553 * gdk_event_get_coords:
554 * @event: a #GdkEvent
555 * @x_root: location to put event window x coordinate
556 * @y_root: location to put event window y coordinate
558 * Extract the event window relative x/y coordinates from an event.
560 * Return value: %TRUE if the event delivered event window coordinates
563 gdk_event_get_coords (GdkEvent *event,
567 gdouble x = 0, y = 0;
568 gboolean fetched = TRUE;
570 g_return_val_if_fail (event != NULL, FALSE);
575 x = event->configure.x;
576 y = event->configure.y;
578 case GDK_ENTER_NOTIFY:
579 case GDK_LEAVE_NOTIFY:
580 x = event->crossing.x;
581 y = event->crossing.y;
587 case GDK_BUTTON_PRESS:
588 case GDK_2BUTTON_PRESS:
589 case GDK_3BUTTON_PRESS:
590 case GDK_BUTTON_RELEASE:
594 case GDK_MOTION_NOTIFY:
612 * gdk_event_get_root_coords:
613 * @event: a #GdkEvent
614 * @x_root: location to put root window x coordinate
615 * @y_root: location to put root window y coordinate
617 * Extract the root window relative x/y coordinates from an event.
619 * Return value: %TRUE if the event delivered root window coordinates
622 gdk_event_get_root_coords (GdkEvent *event,
626 gdouble x = 0, y = 0;
627 gboolean fetched = TRUE;
629 g_return_val_if_fail (event != NULL, FALSE);
633 case GDK_MOTION_NOTIFY:
634 x = event->motion.x_root;
635 y = event->motion.y_root;
637 case GDK_BUTTON_PRESS:
638 case GDK_2BUTTON_PRESS:
639 case GDK_3BUTTON_PRESS:
640 case GDK_BUTTON_RELEASE:
641 x = event->button.x_root;
642 y = event->button.y_root;
644 case GDK_ENTER_NOTIFY:
645 case GDK_LEAVE_NOTIFY:
646 x = event->crossing.x_root;
647 y = event->crossing.y_root;
651 case GDK_DRAG_MOTION:
652 case GDK_DRAG_STATUS:
654 case GDK_DROP_FINISHED:
655 x = event->dnd.x_root;
656 y = event->dnd.y_root;
672 * gdk_event_get_axis:
673 * @event: a #GdkEvent
674 * @axis_use: the axis use to look for
675 * @value: location to store the value found
677 * Extract the axis value for a particular axis use from
678 * an event structure.
680 * Return value: %TRUE if the specified axis was found, otherwise %FALSE
683 gdk_event_get_axis (GdkEvent *event,
690 g_return_val_if_fail (event != NULL, FALSE);
692 if (axis_use == GDK_AXIS_X || axis_use == GDK_AXIS_Y)
698 case GDK_MOTION_NOTIFY:
706 case GDK_BUTTON_PRESS:
707 case GDK_BUTTON_RELEASE:
711 case GDK_ENTER_NOTIFY:
712 case GDK_LEAVE_NOTIFY:
713 x = event->crossing.x;
714 y = event->crossing.y;
721 if (axis_use == GDK_AXIS_X && value)
723 if (axis_use == GDK_AXIS_Y && value)
728 else if (event->type == GDK_BUTTON_PRESS ||
729 event->type == GDK_BUTTON_RELEASE)
731 device = event->button.device;
732 axes = event->button.axes;
734 else if (event->type == GDK_MOTION_NOTIFY)
736 device = event->motion.device;
737 axes = event->motion.axes;
742 return gdk_device_get_axis (device, axes, axis_use, value);
746 *--------------------------------------------------------------
747 * gdk_set_show_events
749 * Turns on/off the showing of events.
752 * "show_events" is a boolean describing whether or
753 * not to show the events gdk receives.
758 * When "show_events" is TRUE, calls to "gdk_event_get"
759 * will output debugging informatin regarding the event
760 * received to stdout.
762 *--------------------------------------------------------------
766 gdk_set_show_events (gboolean show_events)
769 _gdk_debug_flags |= GDK_DEBUG_EVENTS;
771 _gdk_debug_flags &= ~GDK_DEBUG_EVENTS;
775 gdk_get_show_events (void)
777 return (_gdk_debug_flags & GDK_DEBUG_EVENTS) != 0;
781 gdk_io_destroy (gpointer data)
783 GdkIOClosure *closure = data;
786 closure->notify (closure->data);
791 /* What do we do with G_IO_NVAL?
793 #define READ_CONDITION (G_IO_IN | G_IO_HUP | G_IO_ERR)
794 #define WRITE_CONDITION (G_IO_OUT | G_IO_ERR)
795 #define EXCEPTION_CONDITION (G_IO_PRI)
798 gdk_io_invoke (GIOChannel *source,
799 GIOCondition condition,
802 GdkIOClosure *closure = data;
803 GdkInputCondition gdk_cond = 0;
805 if (condition & READ_CONDITION)
806 gdk_cond |= GDK_INPUT_READ;
807 if (condition & WRITE_CONDITION)
808 gdk_cond |= GDK_INPUT_WRITE;
809 if (condition & EXCEPTION_CONDITION)
810 gdk_cond |= GDK_INPUT_EXCEPTION;
812 if (closure->condition & gdk_cond)
813 closure->function (closure->data, g_io_channel_unix_get_fd (source), gdk_cond);
819 gdk_input_add_full (gint source,
820 GdkInputCondition condition,
821 GdkInputFunction function,
823 GdkDestroyNotify destroy)
826 GdkIOClosure *closure = g_new (GdkIOClosure, 1);
828 GIOCondition cond = 0;
830 closure->function = function;
831 closure->condition = condition;
832 closure->notify = destroy;
833 closure->data = data;
835 if (condition & GDK_INPUT_READ)
836 cond |= READ_CONDITION;
837 if (condition & GDK_INPUT_WRITE)
838 cond |= WRITE_CONDITION;
839 if (condition & GDK_INPUT_EXCEPTION)
840 cond |= EXCEPTION_CONDITION;
842 channel = g_io_channel_unix_new (source);
843 result = g_io_add_watch_full (channel, G_PRIORITY_DEFAULT, cond,
845 closure, gdk_io_destroy);
846 g_io_channel_unref (channel);
852 gdk_input_add (gint source,
853 GdkInputCondition condition,
854 GdkInputFunction function,
857 return gdk_input_add_full (source, condition, function, data, NULL);
861 gdk_input_remove (gint tag)
863 g_source_remove (tag);
867 _gdk_event_unqueue (void)
869 GdkEvent *event = NULL;
872 tmp_list = _gdk_event_queue_find_first ();
876 event = tmp_list->data;
877 _gdk_event_queue_remove_link (tmp_list);
878 g_list_free_1 (tmp_list);
885 gdk_synthesize_click (GdkEvent *event,
890 g_return_if_fail (event != NULL);
893 temp_event.type = (nclicks == 2) ? GDK_2BUTTON_PRESS : GDK_3BUTTON_PRESS;
895 gdk_event_put (&temp_event);
899 _gdk_event_button_generate (GdkEvent *event)
901 if ((event->button.time < (button_click_time[1] + TRIPLE_CLICK_TIME)) &&
902 (event->button.window == button_window[1]) &&
903 (event->button.button == button_number[1]))
905 gdk_synthesize_click (event, 3);
907 button_click_time[1] = 0;
908 button_click_time[0] = 0;
909 button_window[1] = NULL;
910 button_window[0] = 0;
911 button_number[1] = -1;
912 button_number[0] = -1;
914 else if ((event->button.time < (button_click_time[0] + double_click_time)) &&
915 (event->button.window == button_window[0]) &&
916 (event->button.button == button_number[0]))
918 gdk_synthesize_click (event, 2);
920 button_click_time[1] = button_click_time[0];
921 button_click_time[0] = event->button.time;
922 button_window[1] = button_window[0];
923 button_window[0] = event->button.window;
924 button_number[1] = button_number[0];
925 button_number[0] = event->button.button;
929 button_click_time[1] = 0;
930 button_click_time[0] = event->button.time;
931 button_window[1] = NULL;
932 button_window[0] = event->button.window;
933 button_number[1] = -1;
934 button_number[0] = event->button.button;
940 gdk_synthesize_window_state (GdkWindow *window,
941 GdkWindowState unset_flags,
942 GdkWindowState set_flags)
944 GdkEventWindowState temp_event;
947 g_return_if_fail (window != NULL);
949 temp_event.window = window;
950 temp_event.type = GDK_WINDOW_STATE;
951 temp_event.send_event = FALSE;
953 old = ((GdkWindowObject*) temp_event.window)->state;
955 temp_event.changed_mask = (unset_flags | set_flags) ^ old;
956 temp_event.new_window_state = old;
957 temp_event.new_window_state |= set_flags;
958 temp_event.new_window_state &= ~unset_flags;
960 if (temp_event.new_window_state == old)
961 return; /* No actual work to do, nothing changed. */
963 /* Actually update the field in GdkWindow, this is sort of an odd
964 * place to do it, but seems like the safest since it ensures we expose no
965 * inconsistent state to the user.
968 ((GdkWindowObject*) window)->state = temp_event.new_window_state;
970 /* We only really send the event to toplevels, since
971 * all the window states don't apply to non-toplevels.
972 * Non-toplevels do use the GDK_WINDOW_STATE_WITHDRAWN flag
973 * internally so we needed to update window->state.
975 switch (((GdkWindowObject*) window)->window_type)
977 case GDK_WINDOW_TOPLEVEL:
978 case GDK_WINDOW_DIALOG:
979 case GDK_WINDOW_TEMP: /* ? */
980 gdk_event_put ((GdkEvent*) &temp_event);
983 case GDK_WINDOW_FOREIGN:
984 case GDK_WINDOW_ROOT:
985 case GDK_WINDOW_CHILD:
991 gdk_set_double_click_time (guint msec)
993 double_click_time = msec;
997 gdk_event_get_type (void)
999 static GType our_type = 0;
1002 our_type = g_boxed_type_register_static ("GdkEvent",
1004 (GBoxedCopyFunc)gdk_event_copy,
1005 (GBoxedFreeFunc)gdk_event_free,
1011 gdk_device_get_core_pointer (void)
1013 return _gdk_core_pointer;