## Events Events — Functions for handling events from the window system |

## Synopsis

    #include <gdk/gdk.h>

    enum                GdkEventType;
    enum                GdkEventMask;
    #define             GDK_CURRENT_TIME
    #define             GDK_PRIORITY_EVENTS
    #define             GDK_PRIORITY_REDRAW

    gboolean            gdk_events_pending                  (void);
    GdkEvent*           gdk_event_peek                      (void);
    GdkEvent*           gdk_event_get                       (void);
    GdkEvent*           gdk_event_get_graphics_expose       (GdkWindow *window);
    void                gdk_event_put                       (const GdkEvent *event);
    GdkEvent*           gdk_event_new                       (GdkEventType type);
    GdkEvent*           gdk_event_copy                      (const GdkEvent *event);
    void                gdk_event_free                      (GdkEvent *event);
    guint32             gdk_event_get_time                  (const GdkEvent *event);
    gboolean            gdk_event_get_state                 (const GdkEvent *event,
                                                             GdkModifierType *state);
    gboolean            gdk_event_get_axis                  (const GdkEvent *event,
                                                             GdkAxisUse axis_use,
                                                             gdouble *value);
    gboolean            gdk_event_get_coords                (const GdkEvent *event,
                                                             gdouble *x_win,
                                                             gdouble *y_win);
    gboolean            gdk_event_get_root_coords           (const GdkEvent *event,
                                                             gdouble *x_root,
                                                             gdouble *y_root);
    void                gdk_event_request_motions           (const GdkEventMotion *event);

    void                gdk_event_handler_set               (GdkEventFunc func,
                                                             gpointer data,
                                                             GDestroyNotify notify);
    void                (*GdkEventFunc)                     (GdkEvent *event,
                                                             gpointer data);

    gboolean            gdk_event_send_client_message       (GdkEvent *event,
                                                             GdkNativeWindow winid);
    gboolean            gdk_event_send_client_message_for_display
                                                            (GdkDisplay *display,
                                                             GdkEvent *event,
                                                             GdkNativeWindow winid);
    void                gdk_event_send_clientmessage_toall  (GdkEvent *event);
    void                gdk_add_client_message_filter       (GdkAtom message_type,
                                                             GdkFilterFunc func,
                                                             gpointer data);

    gboolean            gdk_get_show_events                 (void);
    void                gdk_set_show_events                 (gboolean show_events);
    void                gdk_event_set_screen                (GdkEvent *event,
                                                             GdkScreen *screen);
    GdkScreen *         gdk_event_get_screen                (const GdkEvent *event);

    gboolean            gdk_setting_get                     (const gchar *name,
                                                             GValue *value);

## Description

This section describes functions dealing with events from the window system.

In GTK+ applications the events are handled automatically in `gtk_main_do_event()` and passed on to the appropriate widgets, so these functions are rarely needed. Though some of the fields in the Event Structures are useful.

## Details

### enum GdkEventType

    typedef enum
    {
      GDK_NOTHING		= -1,
      GDK_DELETE		= 0,
      GDK_DESTROY		= 1,
      GDK_EXPOSE		= 2,
      GDK_MOTION_NOTIFY	= 3,
      GDK_BUTTON_PRESS	= 4,
      GDK_2BUTTON_PRESS	= 5,
      GDK_3BUTTON_PRESS	= 6,
      GDK_BUTTON_RELEASE	= 7,
      GDK_KEY_PRESS		= 8,
      GDK_KEY_RELEASE	= 9,
      GDK_ENTER_NOTIFY	= 10,
      GDK_LEAVE_NOTIFY	= 11,
      GDK_FOCUS_CHANGE	= 12,
      GDK_CONFIGURE		= 13,
      GDK_MAP		= 14,
      GDK_UNMAP		= 15,
      GDK_PROPERTY_NOTIFY	= 16,
      GDK_SELECTION_CLEAR	= 17,
      GDK_SELECTION_REQUEST = 18,
      GDK_SELECTION_NOTIFY	= 19,
      GDK_PROXIMITY_IN	= 20,
      GDK_PROXIMITY_OUT	= 21,
      GDK_DRAG_ENTER        = 22,
      GDK_DRAG_LEAVE        = 23,
      GDK_DRAG_MOTION       = 24,
      GDK_DRAG_STATUS       = 25,
      GDK_DROP_START        = 26,
      GDK_DROP_FINISHED     = 27,
      GDK_CLIENT_EVENT	= 28,
      GDK_VISIBILITY_NOTIFY = 29,
      GDK_NO_EXPOSE		= 30,
      GDK_SCROLL            = 31,
      GDK_WINDOW_STATE      = 32,
      GDK_SETTING           = 33,
      GDK_OWNER_CHANGE      = 34,
      GDK_GRAB_BROKEN       = 35,
      GDK_DAMAGE            = 36
    } GdkEventType;

Specifies the type of the event.

Do not confuse these events with the signals that GTK+ widgets emit. Although many of these events result in corresponding signals being emitted, the events are often transformed or filtered along the way.

`GDK_NOTHING` | a special code to indicate a null event.
`GDK_DELETE` | the window manager has requested that the toplevel window be hidden or destroyed, usually when the user clicks on a special icon in the title bar.
`GDK_DESTROY` | the window has been destroyed.
`GDK_EXPOSE` | all or part of the window has become visible and needs to be redrawn.
`GDK_MOTION_NOTIFY` | the pointer (usually a mouse) has moved.
`GDK_BUTTON_PRESS` | a mouse button has been pressed.
`GDK_2BUTTON_PRESS` | a mouse button has been double-clicked (clicked twice within a short period of time). Note that each click also generates a `GDK_BUTTON_PRESS` event.
`GDK_3BUTTON_PRESS` | a mouse button has been clicked 3 times in a short period of time. Note that each click also generates a `GDK_BUTTON_PRESS` event.
`GDK_BUTTON_RELEASE` | a mouse button has been released.
`GDK_KEY_PRESS` | a key has been pressed.
`GDK_KEY_RELEASE` | a key has been released.
`GDK_ENTER_NOTIFY` | the pointer has entered the window.
`GDK_LEAVE_NOTIFY` | the pointer has left the window.
`GDK_FOCUS_CHANGE` | the keyboard focus has entered or left the window.
`GDK_CONFIGURE` | the size, position or stacking order of the window has changed. Note that GTK+ discards these events for `GDK_WINDOW_CHILD` windows.
`GDK_MAP` | the window has been mapped.
`GDK_UNMAP` | the window has been unmapped.
`GDK_PROPERTY_NOTIFY` | a property on the window has been changed or deleted.
`GDK_SELECTION_CLEAR` | the application has lost ownership of a selection.
`GDK_SELECTION_REQUEST` | another application has requested a selection.
`GDK_SELECTION_NOTIFY` | a selection has been received.
`GDK_PROXIMITY_IN` | an input device has moved into contact with a sensing surface (e.g. a touchscreen or graphics tablet).
`GDK_PROXIMITY_OUT` | an input device has moved out of contact with a sensing surface.
`GDK_DRAG_ENTER` | the mouse has entered the window while a drag is in progress.
`GDK_DRAG_LEAVE` | the mouse has left the window while a drag is in progress.
`GDK_DRAG_MOTION` | the mouse has moved in the window while a drag is in progress.
`GDK_DRAG_STATUS` | the status of the drag operation initiated by the window has changed.
`GDK_DROP_START` | a drop operation onto the window has started.
`GDK_DROP_FINISHED` | the drop operation initiated by the window has completed.
`GDK_CLIENT_EVENT` | a message has been received from another application.
`GDK_VISIBILITY_NOTIFY` | the window visibility status has changed.
`GDK_NO_EXPOSE` | indicates that the source region was completely available when parts of a drawable were copied. This is not very useful.
`GDK_SCROLL` | the scroll wheel was turned
`GDK_WINDOW_STATE` | the state of a window has changed. See GdkWindowState for the possible window states
`GDK_SETTING` | a setting has been modified.
`GDK_OWNER_CHANGE` | the owner of a selection has changed. This event type was added in 2.6
`GDK_GRAB_BROKEN` | a pointer or keyboard grab was broken. This event type was added in 2.8.
`GDK_DAMAGE` | the content of the window has been changed. This event type was added in 2.14.

### enum GdkEventMask

    typedef enum
    {
      GDK_EXPOSURE_MASK		= 1 << 1,
      GDK_POINTER_MOTION_MASK	= 1 << 2,
      GDK_POINTER_MOTION_HINT_MASK	= 1 << 3,
      GDK_BUTTON_MOTION_MASK	= 1 << 4,
      GDK_BUTTON1_MOTION_MASK	= 1 << 5,
      GDK_BUTTON2_MOTION_MASK	= 1 << 6,
      GDK_BUTTON3_MOTION_MASK	= 1 << 7,
      GDK_BUTTON_PRESS_MASK		= 1 << 8,
      GDK_BUTTON_RELEASE_MASK	= 1 << 9,
      GDK_KEY_PRESS_MASK		= 1 << 10,
      GDK_KEY_RELEASE_MASK		= 1 << 11,
      GDK_ENTER_NOTIFY_MASK		= 1 << 12,
      GDK_LEAVE_NOTIFY_MASK		= 1 << 13,
      GDK_FOCUS_CHANGE_MASK		= 1 << 14,
      GDK_STRUCTURE_MASK		= 1 << 15,
      GDK_PROPERTY_CHANGE_MASK	= 1 << 16,
      GDK_VISIBILITY_NOTIFY_MASK	= 1 << 17,
      GDK_PROXIMITY_IN_MASK		= 1 << 18,
      GDK_PROXIMITY_OUT_MASK	= 1 << 19,
      GDK_SUBSTRUCTURE_MASK		= 1 << 20,
      GDK_SCROLL_MASK               = 1 << 21,
      GDK_ALL_EVENTS_MASK		= 0x3FFFFE
    } GdkEventMask;

A set of bit-flags to indicate which events a window is to receive. Most of these masks map onto one or more of the GdkEventType event types above.

`GDK_POINTER_MOTION_HINT_MASK` is a special mask which is used to reduce the number of `GDK_MOTION_NOTIFY` events received. Normally a `GDK_MOTION_NOTIFY` event is received each time the mouse moves. However, if the application spends a lot of time processing the event (updating the display, for example), it can lag behind the position of the mouse. When using `GDK_POINTER_MOTION_HINT_MASK`, fewer `GDK_MOTION_NOTIFY` events will be sent, some of which are marked as a hint (the is_hint member is `TRUE`). To receive more motion events after a motion hint event, the application needs to asks for more, by calling `gdk_event_request_motions()`.

`GDK_EXPOSURE_MASK` | receive expose events
`GDK_POINTER_MOTION_MASK` | receive all pointer motion events
`GDK_POINTER_MOTION_HINT_MASK` | see the explanation above
`GDK_BUTTON_MOTION_MASK` | receive pointer motion events while any button is pressed
`GDK_BUTTON1_MOTION_MASK` | receive pointer motion events while 1 button is pressed
`GDK_BUTTON2_MOTION_MASK` | receive pointer motion events while 2 button is pressed
`GDK_BUTTON3_MOTION_MASK` | receive pointer motion events while 3 button is pressed
`GDK_BUTTON_PRESS_MASK` | receive button press events
`GDK_BUTTON_RELEASE_MASK` | receive button release events
`GDK_KEY_PRESS_MASK` | receive key press events
`GDK_KEY_RELEASE_MASK` | receive key release events
`GDK_ENTER_NOTIFY_MASK` | receive window enter events
`GDK_LEAVE_NOTIFY_MASK` | receive window leave events
`GDK_FOCUS_CHANGE_MASK` | receive focus change events
`GDK_STRUCTURE_MASK` | receive events about window configuration change
`GDK_PROPERTY_CHANGE_MASK` | receive property change events
`GDK_VISIBILITY_NOTIFY_MASK` | receive visibility change events
`GDK_PROXIMITY_IN_MASK` | receive proximity in events
`GDK_PROXIMITY_OUT_MASK` | receive proximity out events
`GDK_SUBSTRUCTURE_MASK` | receive events about window configuration changes of child windows
`GDK_SCROLL_MASK` | receive scroll events
`GDK_ALL_EVENTS_MASK` | the combination of all the above event masks.

### GDK_CURRENT_TIME

    #define GDK_CURRENT_TIME     0L

Represents the current time, and can be used anywhere a time is expected.

### GDK_PRIORITY_EVENTS

    #define             GDK_PRIORITY_EVENTS

This is the priority that events from the X server are given in the GLib Main Loop.

### GDK_PRIORITY_REDRAW

    #define GDK_PRIORITY_REDRAW     (G_PRIORITY_HIGH_IDLE + 20)

This is the priority that the idle handler processing window updates is given in the GLib Main Loop.

### gdk_events_pending ()

    gboolean            gdk_events_pending                  (void);

Checks if any events are ready to be processed for any display.

Returns : | `TRUE` if any events are pending.

### gdk_event_peek ()

    GdkEvent*           gdk_event_peek                      (void);

If there is an event waiting in the event queue of some open display, returns a copy of it. See `gdk_display_peek_event()`.

Returns : | a copy of the first GdkEvent on some event queue, or `NULL` if no events are in any queues. The returned GdkEvent should be freed with `gdk_event_free()`.

### gdk_event_get ()

    GdkEvent*           gdk_event_get                       (void);

Checks all open displays for a GdkEvent to process,to be processed on, fetching events from the windowing system if necessary. See `gdk_display_get_event()`.

Returns : | the next GdkEvent to be processed, or `NULL` if no events are pending. The returned GdkEvent should be freed with `gdk_event_free()`.

### gdk_event_get_graphics_expose ()

    GdkEvent*           gdk_event_get_graphics_expose       (GdkWindow *window);

Waits for a GraphicsExpose or NoExpose event from the X server. This is used in the GtkText and GtkCList widgets in GTK+ to make sure any GraphicsExpose events are handled before the widget is scrolled.

`window` : | the GdkWindow to wait for the events for.
Returns : | a GdkEventExpose if a GraphicsExpose was received, or `NULL` if a NoExpose event was received.

### gdk_event_put ()

    void                gdk_event_put                       (const GdkEvent *event);

Appends a copy of the given event onto the front of the event queue for event->any.window's display, or the default event queue if event->any.window is `NULL`. See `gdk_display_put_event()`.

`event` : | a GdkEvent.

### gdk_event_new ()

    GdkEvent*           gdk_event_new                       (GdkEventType type);

Creates a new event of the given type. All fields are set to 0.

`type` : | a GdkEventType
Returns : | a newly-allocated GdkEvent. The returned GdkEvent should be freed with `gdk_event_free()`.

Since 2.2

### gdk_event_copy ()

    GdkEvent*           gdk_event_copy                      (const GdkEvent *event);

Copies a GdkEvent, copying or incrementing the reference count of the resources associated with it (e.g. GdkWindow's and strings).

`event` : | a GdkEvent
Returns : | a copy of `event`. The returned GdkEvent should be freed with `gdk_event_free()`.

### gdk_event_free ()

    void                gdk_event_free                      (GdkEvent *event);

Frees a GdkEvent, freeing or decrementing any resources associated with it. Note that this function should only be called with events returned from functions such as `gdk_event_peek()`, `gdk_event_get()`, `gdk_event_get_graphics_expose()` and `gdk_event_copy()`.

`event` : | a GdkEvent.

### gdk_event_get_time ()

    guint32             gdk_event_get_time                  (const GdkEvent *event);

Returns the time stamp from `event`, if there is one; otherwise returns GDK_CURRENT_TIME. If `event` is `NULL`, returns GDK_CURRENT_TIME.

`event` : | a GdkEvent
Returns : | time stamp field from `event`

### gdk_event_get_state ()

    gboolean            gdk_event_get_state                 (const GdkEvent *event,
                                                             GdkModifierType *state);

If the event contains a "state" field, puts that field in `state`. Otherwise stores an empty state (0). Returns `TRUE` if there was a state field in the event. `event` may be `NULL`, in which case it's treated as if the event had no state field.

`event` : | a GdkEvent or NULL
`state` : | return location for state
Returns : | `TRUE` if there was a state field in the event

### gdk_event_get_axis ()

    gboolean            gdk_event_get_axis                  (const GdkEvent *event,
                                                             GdkAxisUse axis_use,
                                                             gdouble *value);

Extract the axis value for a particular axis use from an event structure.

`event` : | a GdkEvent
`axis_use` : | the axis use to look for
`value` : | location to store the value found
Returns : | `TRUE` if the specified axis was found, otherwise `FALSE`

### gdk_event_get_coords ()

    gboolean            gdk_event_get_coords                (const GdkEvent *event,
                                                             gdouble *x_win,
                                                             gdouble *y_win);

Extract the event window relative x/y coordinates from an event.

`event` : | a GdkEvent
`x_win` : | location to put event window x coordinate
`y_win` : | location to put event window y coordinate
Returns : | `TRUE` if the event delivered event window coordinates

### gdk_event_get_root_coords ()

    gboolean            gdk_event_get_root_coords           (const GdkEvent *event,
                                                             gdouble *x_root,
                                                             gdouble *y_root);

Extract the root window relative x/y coordinates from an event.

`event` : | a GdkEvent
`x_root` : | location to put root window x coordinate
`y_root` : | location to put root window y coordinate
Returns : | `TRUE` if the event delivered root window coordinates

### gdk_event_request_motions ()

    void                gdk_event_request_motions           (const GdkEventMotion *event);

Request more motion notifies if `event` is a motion notify hint event. This function should be used instead of `gdk_window_get_pointer()` to request further motion notifies, because it also works for extension events where motion notifies are provided for devices other than the core pointer. Coordinate extraction, processing and requesting more motion events from a `GDK_MOTION_NOTIFY` event usually works like this:

    {
      /* motion_event handler */
      x = motion_event->x;
      y = motion_event->y;
      /* handle (x,y) motion */
      gdk_event_request_motions (motion_event); /* handles is_hint events */
    }

`event` : | a valid GdkEvent

Since 2.12

### gdk_event_handler_set ()

    void                gdk_event_handler_set               (GdkEventFunc func,
                                                             gpointer data,
                                                             GDestroyNotify notify);

Sets the function to call to handle all events from GDK.

Note that GTK+ uses this to install its own event handler, so it is usually not useful for GTK+ applications. (Although an application can call this function then call `gtk_main_do_event()` to pass events to GTK+.)

`func` : | the function to call to handle events from GDK.
`data` : | user data to pass to the function.
`notify` : | the function to call when the handler function is removed, i.e. when `gdk_event_handler_set()` is called with another event handler.

### GdkEventFunc ()

    void                (*GdkEventFunc)                     (GdkEvent *event,
                                                             gpointer data);

Specifies the type of function passed to `gdk_event_handler_set()` to handle all GDK events.

`event` : | the GdkEvent to process.
`data` : | user data set when the event handler was installed with `gdk_event_handler_set()`.

### gdk_event_send_client_message ()

    gboolean            gdk_event_send_client_message       (GdkEvent *event,
                                                             GdkNativeWindow winid);

Sends an X ClientMessage event to a given window (which must be on the default GdkDisplay.) This could be used for communicating between different applications, though the amount of data is limited to 20 bytes.

`event` : | the GdkEvent to send, which should be a GdkEventClient.
`winid` : | the window to send the X ClientMessage event to.
Returns : | non-zero on success.

### gdk_event_send_client_message_for_display ()

    gboolean            gdk_event_send_client_message_for_display
                                                            (GdkDisplay *display,
                                                             GdkEvent *event,
                                                             GdkNativeWindow winid);

On X11, sends an X ClientMessage event to a given window. On Windows, sends a message registered with the name GDK_WIN32_CLIENT_MESSAGE.

This could be used for communicating between different applications, though the amount of data is limited to 20 bytes on X11, and to just four bytes on Windows.

`display` : | the GdkDisplay for the window where the message is to be sent.
`event` : | the GdkEvent to send, which should be a GdkEventClient.
`winid` : | the window to send the client message to.
Returns : | non-zero on success.

Since 2.2

### gdk_event_send_clientmessage_toall ()

    void                gdk_event_send_clientmessage_toall  (GdkEvent *event);

Sends an X ClientMessage event to all toplevel windows on the default GdkScreen.

Toplevel windows are determined by checking for the WM_STATE property, as described in the Inter-Client Communication Conventions Manual (ICCCM). If no windows are found with the WM_STATE property set, the message is sent to all children of the root window.

`event` : | the GdkEvent to send, which should be a GdkEventClient.

### gdk_add_client_message_filter ()

    void                gdk_add_client_message_filter       (GdkAtom message_type,
                                                             GdkFilterFunc func,
                                                             gpointer data);

Adds a filter to the default display to be called when X ClientMessage events are received. See `gdk_display_add_client_message_filter()`.

`message_type` : | the type of ClientMessage events to receive. This will be checked against the `message_type` field of the XClientMessage event struct.
`func` : | the function to call to process the event.
`data` : | user data to pass to `func`.

### gdk_get_show_events ()

    gboolean            gdk_get_show_events                 (void);

Gets whether event debugging output is enabled.

Returns : | `TRUE` if event debugging output is enabled.

### gdk_set_show_events ()

    void                gdk_set_show_events                 (gboolean show_events);

Sets whether a trace of received events is output. Note that GTK+ must be compiled with debugging (that is, configured using the `--enable-debug` option) to use this option.

`show_events` : | `TRUE` to output event debugging information.

### gdk_event_set_screen ()

    void                gdk_event_set_screen                (GdkEvent *event,
                                                             GdkScreen *screen);

Sets the screen for `event` to `screen`. The event must have been allocated by GTK+, for instance, by `gdk_event_copy()`.

`event` : | a GdkEvent
`screen` : | a GdkScreen

Since 2.2

### gdk_event_get_screen ()

    GdkScreen *         gdk_event_get_screen                (const GdkEvent *event);

Returns the screen for the event. The screen is typically the screen for `event->any.window`, but for events such as mouse events, it is the screen where the pointer was when the event occurs - that is, the screen which has the root window to which `event->motion.x_root` and `event->motion.y_root` are relative.

`event` : | a GdkEvent
Returns : | the screen for the event

Since 2.2

### gdk_setting_get ()

    gboolean            gdk_setting_get                     (const gchar *name,
                                                             GValue *value);

Obtains a desktop-wide setting, such as the double-click time, for the default screen. See `gdk_screen_get_setting()`.

`name` : | the name of the setting.
`value` : | location to store the value of the setting.
Returns : | `TRUE` if the setting existed and a value was stored in `value`, `FALSE` otherwise.

## See Also

Event Structures | The structs used for each type of event.