## Event Structures

Event Structures — Data structures specific to each type of event

## Synopsis

    #include <gdk/gdk.h>

    union       GdkEvent;

    struct      GdkEventAny;
    struct      GdkEventKey;
    struct      GdkEventButton;
    struct      GdkEventScroll;
    struct      GdkEventMotion;
    struct      GdkEventExpose;
    struct      GdkEventVisibility;
    struct      GdkEventCrossing;
    struct      GdkEventFocus;
    struct      GdkEventConfigure;
    struct      GdkEventProperty;
    struct      GdkEventSelection;
    typedef     GdkNativeWindow;
    struct      GdkEventDND;
    struct      GdkEventProximity;
    struct      GdkEventClient;
    struct      GdkEventNoExpose;
    struct      GdkEventWindowState;
    struct      GdkEventSetting;

    enum        GdkScrollDirection;
    enum        GdkVisibilityState;
    enum        GdkCrossingMode;
    enum        GdkNotifyType;
    enum        GdkPropertyState;
    enum        GdkWindowState;
    enum        GdkSettingAction;

## Description

The event structs contain data specific to each type of event in GDK.

### Note

A common mistake is to forget to set the event mask of a widget so that the required events are received. See gtk_widget_set_events().

## Details

### union GdkEvent

    union GdkEvent
    {
      GdkEventType		    type;
      GdkEventAny		    any;
      GdkEventExpose	    expose;
      GdkEventNoExpose	    no_expose;
      GdkEventVisibility	    visibility;
      GdkEventMotion	    motion;
      GdkEventButton	    button;
      GdkEventScroll            scroll;
      GdkEventKey		    key;
      GdkEventCrossing	    crossing;
      GdkEventFocus		    focus_change;
      GdkEventConfigure	    configure;
      GdkEventProperty	    property;
      GdkEventSelection	    selection;
      GdkEventProximity	    proximity;
      GdkEventClient	    client;
      GdkEventDND               dnd;
      GdkEventWindowState       window_state;
      GdkEventSetting           setting;
    };

The GdkEvent struct contains a union of all of the event structs, and allows access to the data fields in a number of ways.

The event type is always the first field in all of the event structs, and can always be accessed with the following code, no matter what type of event it is:

      GdkEvent *event;
      GdkEventType type;

      type = event->type;

To access other fields of the event structs, the pointer to the event can be cast to the appropriate event struct pointer, or the union member name can be used. For example if the event type is `GDK_BUTTON_PRESS` then the x coordinate of the button press can be accessed with:

      GdkEvent *event;
      gdouble x;

      x = ((GdkEventButton*)event)->x;

or:

      GdkEvent *event;
      gdouble x;

      x = event->button.x;

### struct GdkEventAny

    struct GdkEventAny {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
    };

Contains the fields which are common to all event structs. Any event pointer can safely be cast to a pointer to a GdkEventAny to access these fields.

GdkEventType `type` | the type of the event.
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).

### struct GdkEventKey

    struct GdkEventKey {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      guint32 time;
      guint state;
      guint keyval;
      gint length;
      gchar *string;
      guint16 hardware_keycode;
      guint8 group;
    };

Describes a key press or key release event.

GdkEventType `type` | the type of the event (`GDK_KEY_PRESS` or `GDK_KEY_RELEASE`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
guint32 `time` | the time of the event in milliseconds.
guint `state` | a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See GdkModifierType.
guint `keyval` | the key that was pressed or released. See the `<gdk/gdkkeysym.h>` header file for a complete list of GDK key codes.
gint `length` | the length of `string`.
gchar *`string` | a string containing the an approximation of the text that would result from this keypress. The only correct way to handle text input of text is using input methods (see GtkIMContext), so this field is deprecated and should never be used. (gdk_unicode_to_keyval() provides a non-deprecated way of getting an approximate translation for a key.) The string is encoded in the encoding of the current locale (Note: this for backwards compatibility: strings in GTK+ and GDK are typically in UTF-8.) and NUL-terminated. In some cases, the translation of the key code will be a single NUL byte, in which case looking at `length` is necessary to distinguish it from the an empty translation.
guint16 `hardware_keycode` | the raw code of the key that was pressed or released.
guint8 `group` | the keyboard group.

### struct GdkEventButton

    struct GdkEventButton {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      guint32 time;
      gdouble x;
      gdouble y;
      gdouble *axes;
      guint state;
      guint button;
      GdkDevice *device;
      gdouble x_root, y_root;
    };

Used for button press and button release events. The `type` field will be one of `GDK_BUTTON_PRESS`, `GDK_2BUTTON_PRESS`, `GDK_3BUTTON_PRESS`, and `GDK_BUTTON_RELEASE`.

Double and triple-clicks result in a sequence of events being received. For double-clicks the order of events will be:

1. `GDK_BUTTON_PRESS`

2. `GDK_BUTTON_RELEASE`

3. `GDK_BUTTON_PRESS`

4. `GDK_2BUTTON_PRESS`

5. `GDK_BUTTON_RELEASE`

Note that the first click is received just like a normal button press, while the second click results in a `GDK_2BUTTON_PRESS` being received just after the `GDK_BUTTON_PRESS`.

Triple-clicks are very similar to double-clicks, except that `GDK_3BUTTON_PRESS` is inserted after the third click. The order of the events is:

1. `GDK_BUTTON_PRESS`

2. `GDK_BUTTON_RELEASE`

3. `GDK_BUTTON_PRESS`

4. `GDK_2BUTTON_PRESS`

5. `GDK_BUTTON_RELEASE`

6. `GDK_BUTTON_PRESS`

7. `GDK_3BUTTON_PRESS`

8. `GDK_BUTTON_RELEASE`

For a double click to occur, the second button press must occur within 1/4 of a second of the first. For a triple click to occur, the third button press must also occur within 1/2 second of the first button press.

GdkEventType `type` | the type of the event (`GDK_BUTTON_PRESS`, `GDK_2BUTTON_PRESS`, `GDK_3BUTTON_PRESS` or `GDK_BUTTON_RELEASE`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
guint32 `time` | the time of the event in milliseconds.
gdouble `x` | the x coordinate of the pointer relative to the window.
gdouble `y` | the y coordinate of the pointer relative to the window.
gdouble *`axes` | `x`, `y` translated to the axes of `device`, or `NULL` if `device` is the mouse.
guint `state` | a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See GdkModifierType.
guint `button` | the button which was pressed or released, numbered from 1 to 5. Normally button 1 is the left mouse button, 2 is the middle button, and 3 is the right button. On 2-button mice, the middle button can often be simulated by pressing both mouse buttons together.
GdkDevice *`device` | the device where the event originated.
gdouble `x_root` | the x coordinate of the pointer relative to the root of the screen.
gdouble `y_root` | the y coordinate of the pointer relative to the root of the screen.

### struct GdkEventScroll

    struct GdkEventScroll {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      guint32 time;
      gdouble x;
      gdouble y;
      guint state;
      GdkScrollDirection direction;
      GdkDevice *device;
      gdouble x_root, y_root;
    };

Generated from button presses for the buttons 4 to 7. Wheel mice are usually configured to generate button press events for buttons 4 and 5 when the wheel is turned.

GdkEventType `type` | the type of the event (`GDK_SCROLL`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
guint32 `time` | the time of the event in milliseconds.
gdouble `x` | the x coordinate of the pointer relative to the window.
gdouble `y` | the y coordinate of the pointer relative to the window.
guint `state` | a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See GdkModifierType.
GdkScrollDirection `direction` | the direction to scroll to (one of `GDK_SCROLL_UP`, `GDK_SCROLL_DOWN`, `GDK_SCROLL_LEFT` and `GDK_SCROLL_RIGHT`).
GdkDevice *`device` | the device where the event originated.
gdouble `x_root` | the x coordinate of the pointer relative to the root of the screen.
gdouble `y_root` | the y coordinate of the pointer relative to the root of the screen.

### struct GdkEventMotion

    struct GdkEventMotion {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      guint32 time;
      gdouble x;
      gdouble y;
      gdouble *axes;
      guint state;
      gint16 is_hint;
      GdkDevice *device;
      gdouble x_root, y_root;
    };

Generated when the pointer moves.

GdkEventType `type` | the type of the event.
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
guint32 `time` | the time of the event in milliseconds.
gdouble `x` | the x coordinate of the pointer relative to the window.
gdouble `y` | the y coordinate of the pointer relative to the window.
gdouble *`axes` | `x`, `y` translated to the axes of `device`, or `NULL` if `device` is the mouse.
guint `state` | a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See GdkModifierType.
gint16 `is_hint` |
GdkDevice *`device` | the device where the event originated.
gdouble `x_root` | the x coordinate of the pointer relative to the root of the screen.
gdouble `y_root` | the y coordinate of the pointer relative to the root of the screen.

### struct GdkEventExpose

    struct GdkEventExpose {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkRectangle area;
      GdkRegion *region;
      gint count; /* If non-zero, how many more events follow. */
    };

Generated when all or part of a window becomes visible and needs to be redrawn.

GdkEventType `type` | the type of the event (`GDK_EXPOSE`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkRectangle `area` | bounding box of `region`.
GdkRegion *`region` | the region that needs to be redrawn.
gint `count` | the number of contiguous `GDK_EXPOSE` events following this one. The only use for this is "exposure compression", i.e. handling all contiguous `GDK_EXPOSE` events in one go, though GDK performs some exposure compression so this is not normally needed.

### struct GdkEventVisibility

    struct GdkEventVisibility {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkVisibilityState state;
    };

Generated when the window visibility status has changed.

GdkEventType `type` | the type of the event (`GDK_VISIBILITY_NOTIFY`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkVisibilityState `state` | the new visibility state (`GDK_VISIBILITY_FULLY_OBSCURED`, `GDK_VISIBILITY_PARTIAL` or `GDK_VISIBILITY_UNOBSCURED`).

### struct GdkEventCrossing

    struct GdkEventCrossing {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkWindow *subwindow;
      guint32 time;
      gdouble x;
      gdouble y;
      gdouble x_root;
      gdouble y_root;
      GdkCrossingMode mode;
      GdkNotifyType detail;
      gboolean focus;
      guint state;
    };

Generated when the pointer enters or leaves a window.

GdkEventType `type` | the type of the event (`GDK_ENTER_NOTIFY` or `GDK_LEAVE_NOTIFY`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkWindow *`subwindow` | the window that was entered or left.
guint32 `time` | the time of the event in milliseconds.
gdouble `x` | the x coordinate of the pointer relative to the window.
gdouble `y` | the y coordinate of the pointer relative to the window.
gdouble `x_root` | the x coordinate of the pointer relative to the root of the screen.
gdouble `y_root` | the y coordinate of the pointer relative to the root of the screen.
GdkCrossingMode `mode` | the crossing mode (`GDK_CROSSING_NORMAL`, `GDK_CROSSING_GRAB` or `GDK_CROSSING_UNGRAB`).
GdkNotifyType `detail` | the kind of crossing that happened (`GDK_NOTIFY_INFERIOR`, `GDK_NOTIFY_ANCESTOR`, `GDK_NOTIFY_VIRTUAL`, `GDK_NOTIFY_NONLINEAR` or `GDK_NOTIFY_NONLINEAR_VIRTUAL`).
gboolean `focus` | `TRUE` if `window` is the focus window or an inferior.
guint `state` | a bit-mask representing the state of the modifier keys (e.g. Control, Shift and Alt) and the pointer buttons. See GdkModifierType.

### struct GdkEventFocus

    struct GdkEventFocus {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      gint16 in;
    };

Describes a change of keyboard focus.

GdkEventType `type` | the type of the event (`GDK_FOCUS_CHANGE`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
gint16 `in` | `TRUE` if the window has gained the keyboard focus, `FALSE` if it has lost the focus.

### struct GdkEventConfigure

    struct GdkEventConfigure {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      gint x, y;
      gint width;
      gint height;
    };

Generated when a window size or position has changed.

GdkEventType `type` | the type of the event (`GDK_CONFIGURE`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
gint `x` | the new x coordinate of the window, relative to its parent.
gint `y` | the new y coordinate of the window, relative to its parent.
gint `width` | the new width of the window.
gint `height` | the new height of the window.

### struct GdkEventProperty

    struct GdkEventProperty {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkAtom atom;
      guint32 time;
      guint state;
    };

Describes a property change on a window.

GdkEventType `type` | the type of the event (`GDK_PROPERTY_NOTIFY`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkAtom `atom` | the property that was changed.
guint32 `time` | the time of the event in milliseconds.
guint `state` | whether the property was changed (`GDK_PROPERTY_NEW_VALUE`) or deleted (`GDK_PROPERTY_DELETE`).

### struct GdkEventSelection

    struct GdkEventSelection {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkAtom selection;
      GdkAtom target;
      GdkAtom property;
      guint32 time;
      GdkNativeWindow requestor;
    };

Generated when a selection is requested or ownership of a selection is taken over by another client application.

GdkEventType `type` | the type of the event (`GDK_SELECTION_CLEAR`, `GDK_SELECTION_NOTIFY` or `GDK_SELECTION_REQUEST`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkAtom `selection` | the selection.
GdkAtom `target` | the target to which the selection should be converted.
GdkAtom `property` | the property in which to place the result of the conversion.
guint32 `time` | the time of the event in milliseconds.
GdkNativeWindow `requestor` | the native window on which to place `property`.

### GdkNativeWindow

Used to represent native windows (Windows for the X11 backend, HWNDs for Win32).

### struct GdkEventDND

    struct GdkEventDND {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkDragContext *context;

      guint32 time;
      gshort x_root, y_root;
    };

Generated during DND operations.

GdkEventType `type` | the type of the event (`GDK_DRAG_ENTER`, `GDK_DRAG_LEAVE`, `GDK_DRAG_MOTION`, `GDK_DRAG_STATUS`, `GDK_DROP_START` or `GDK_DROP_FINISHED`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkDragContext *`context` | the GdkDragContext for the current DND operation.
guint32 `time` | the time of the event in milliseconds.
gshort `x_root` | the x coordinate of the pointer relative to the root of the screen, only set for `GDK_DRAG_MOTION` and `GDK_DROP_START`.
gshort `y_root` | the y coordinate of the pointer relative to the root of the screen, only set for `GDK_DRAG_MOTION` and `GDK_DROP_START`.

### struct GdkEventProximity

    struct GdkEventProximity {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      guint32 time;
      GdkDevice *device;
    };

Proximity events are generated when using GDK's wrapper for the XInput extension. The XInput extension is an add-on for standard X that allows you to use nonstandard devices such as graphics tablets. A proximity event indicates that the stylus has moved in or out of contact with the tablet, or perhaps that the user's finger has moved in or out of contact with a touch screen.

GdkEventType `type` | the type of the event (`GDK_PROXIMITY_IN` or `GDK_PROXIMITY_OUT`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
guint32 `time` | the time of the event in milliseconds.
GdkDevice *`device` | the device where the event originated.

### struct GdkEventClient

    struct GdkEventClient {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkAtom message_type;
      gushort data_format;
      union {
        char b[20];
        short s[10];
        long l[5];
      } data;
    };

An event sent by another client application.

GdkEventType `type` | the type of the event (`GDK_CLIENT_EVENT`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkAtom `message_type` | the type of the message, which can be defined by the application.
gushort `data_format` | the format of the data, given as the number of bits in each data element, i.e. 8, 16, or 32. 8-bit data uses the b array of the data union, 16-bit data uses the s array, and 32-bit data uses the l array.

### struct GdkEventNoExpose

    struct GdkEventNoExpose {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
    };

Generated when the area of a GdkDrawable being copied, with gdk_draw_drawable() or gdk_window_copy_area(), was completely available.

FIXME: add more here.

GdkEventType `type` | the type of the event (`GDK_NO_EXPOSE`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).

### struct GdkEventWindowState

    struct GdkEventWindowState {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkWindowState changed_mask;
      GdkWindowState new_window_state;
    };

Generated when the state of a toplevel window changes.

GdkEventType `type` | the type of the event (`GDK_WINDOW_STATE`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkWindowState `changed_mask` | mask specifying what flags have changed.
GdkWindowState `new_window_state` | the new window state, a combination of GdkWindowState bits.

### struct GdkEventSetting

    struct GdkEventSetting {

      GdkEventType type;
      GdkWindow *window;
      gint8 send_event;
      GdkSettingAction action;
      char *name;
    };

Generated when a setting is modified.

GdkEventType `type` | the type of the event (`GDK_SETTING`).
GdkWindow *`window` | the window which received the event.
gint8 `send_event` | `TRUE` if the event was sent explicitly (e.g. using `XSendEvent`).
GdkSettingAction `action` | what happened to the setting (`GDK_SETTING_ACTION_NEW`, `GDK_SETTING_ACTION_CHANGED` or `GDK_SETTING_ACTION_DELETED`).
char *`name` | the name of the setting.

### enum GdkScrollDirection

    typedef enum
    {
      GDK_SCROLL_UP,
      GDK_SCROLL_DOWN,
      GDK_SCROLL_LEFT,
      GDK_SCROLL_RIGHT
    } GdkScrollDirection;

Specifies the direction for GdkEventScroll.

`GDK_SCROLL_UP` | the window is scrolled up.
`GDK_SCROLL_DOWN` | the window is scrolled down.
`GDK_SCROLL_LEFT` | the window is scrolled to the left.
`GDK_SCROLL_RIGHT` | the window is scrolled to the right.

### enum GdkVisibilityState

    typedef enum
    {
      GDK_VISIBILITY_UNOBSCURED,
      GDK_VISIBILITY_PARTIAL,
      GDK_VISIBILITY_FULLY_OBSCURED
    } GdkVisibilityState;

Specifies the visiblity status of a window for a GdkEventVisibility.

`GDK_VISIBILITY_UNOBSCURED` | the window is completely visible.
`GDK_VISIBILITY_PARTIAL` | the window is partially visible.
`GDK_VISIBILITY_FULLY_OBSCURED` | the window is not visible at all.

### enum GdkCrossingMode

    typedef enum
    {
      GDK_CROSSING_NORMAL,
      GDK_CROSSING_GRAB,
      GDK_CROSSING_UNGRAB
    } GdkCrossingMode;

Specifies the crossing mode for GdkEventCrossing.

`GDK_CROSSING_NORMAL` | crossing because of pointer motion.
`GDK_CROSSING_GRAB` | crossing because a grab is activated.
`GDK_CROSSING_UNGRAB` | crossing because a grab is deactivated.

### enum GdkNotifyType

    typedef enum
    {
      GDK_NOTIFY_ANCESTOR		= 0,
      GDK_NOTIFY_VIRTUAL		= 1,
      GDK_NOTIFY_INFERIOR		= 2,
      GDK_NOTIFY_NONLINEAR		= 3,
      GDK_NOTIFY_NONLINEAR_VIRTUAL	= 4,
      GDK_NOTIFY_UNKNOWN		= 5
    } GdkNotifyType;

Specifies the kind of crossing for GdkEventCrossing.

See the X11 protocol specification of LeaveNotify for full details of crossing event generation.

`GDK_NOTIFY_ANCESTOR` | the window is entered from an ancestor or left towards an ancestor.
`GDK_NOTIFY_VIRTUAL` | the pointer moves between an ancestor and an inferior of the window.
`GDK_NOTIFY_INFERIOR` | the window is entered from an inferior or left towards an inferior.
`GDK_NOTIFY_NONLINEAR` | the window is entered from or left towards a window which is neither an ancestor nor an inferior.
`GDK_NOTIFY_NONLINEAR_VIRTUAL` | the pointer moves between two windows which are not ancestors of each other and the window is part of the ancestor chain between one of these windows and their least common ancestor.
`GDK_NOTIFY_UNKNOWN` |

### enum GdkPropertyState

    typedef enum
    {
      GDK_PROPERTY_NEW_VALUE,
      GDK_PROPERTY_DELETE
    } GdkPropertyState;

Specifies the type of a property change for a GdkEventProperty.

`GDK_PROPERTY_NEW_VALUE` | the property value was changed.
`GDK_PROPERTY_DELETE` | the property was deleted.

### enum GdkWindowState

    typedef enum
    {
      GDK_WINDOW_STATE_WITHDRAWN  = 1 << 0,
      GDK_WINDOW_STATE_ICONIFIED  = 1 << 1,
      GDK_WINDOW_STATE_MAXIMIZED  = 1 << 2,
      GDK_WINDOW_STATE_STICKY     = 1 << 3,
      GDK_WINDOW_STATE_FULLSCREEN = 1 << 4
    } GdkWindowState;

Specifies the state of a toplevel window.

`GDK_WINDOW_STATE_WITHDRAWN` | the window is not shown.
`GDK_WINDOW_STATE_ICONIFIED` | the window is minimized.
`GDK_WINDOW_STATE_MAXIMIZED` | the window is maximized.
`GDK_WINDOW_STATE_STICKY` | the window is sticky.
`GDK_WINDOW_STATE_FULLSCREEN` |

### enum GdkSettingAction

    typedef enum
    {
      GDK_SETTING_ACTION_NEW,
      GDK_SETTING_ACTION_CHANGED,
      GDK_SETTING_ACTION_DELETED
    } GdkSettingAction;

Specifies the kind of modification applied to a setting in a GdkEventSetting.

`GDK_SETTING_ACTION_NEW` | a setting was added.
`GDK_SETTING_ACTION_CHANGED` | a setting was changed.
`GDK_SETTING_ACTION_DELETED` | a setting was deleted.