X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gdk%2Fgdkevents.h;h=b7e5ed37a24a7e06e180c9367f273f315995fead;hb=af7afbbe06690281d9703aaab7d1b9522cede3cb;hp=a1eeb02ed24677854639f82c95d6979bd5bd636a;hpb=b52b326d5f34b09af70e9f277a43b48c5bf3be2d;p=~andy%2Fgtk diff --git a/gdk/gdkevents.h b/gdk/gdkevents.h index a1eeb02ed..b7e5ed37a 100644 --- a/gdk/gdkevents.h +++ b/gdk/gdkevents.h @@ -1,24 +1,82 @@ +/* GDK - The GIMP Drawing Kit + * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/* + * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS + * file for a list of people on the GTK+ Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. + */ + +#if !defined (__GDK_H_INSIDE__) && !defined (GDK_COMPILATION) +#error "Only can be included directly." +#endif + #ifndef __GDK_EVENTS_H__ #define __GDK_EVENTS_H__ #include #include #include -#include +#include + +G_BEGIN_DECLS + + +/** + * SECTION:event_structs + * @Short_description: Data structures specific to each type of event + * @Title: Event Structures + * + * The event structs contain data specific to each type of event in GDK. + * + * + * + * 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(). + * + * + */ -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ #define GDK_TYPE_EVENT (gdk_event_get_type ()) +/** + * GDK_PRIORITY_EVENTS: + * + * This is the priority that events from the X server are given in the + * GLib Main Loop. + */ #define GDK_PRIORITY_EVENTS (G_PRIORITY_DEFAULT) + +/** + * GDK_PRIORITY_REDRAW: + * + * This is the priority that the idle handler processing window updates + * is given in the + * GLib Main Loop. + */ #define GDK_PRIORITY_REDRAW (G_PRIORITY_HIGH_IDLE + 20) typedef struct _GdkEventAny GdkEventAny; typedef struct _GdkEventExpose GdkEventExpose; -typedef struct _GdkEventNoExpose GdkEventNoExpose; typedef struct _GdkEventVisibility GdkEventVisibility; typedef struct _GdkEventMotion GdkEventMotion; typedef struct _GdkEventButton GdkEventButton; @@ -29,56 +87,140 @@ typedef struct _GdkEventCrossing GdkEventCrossing; typedef struct _GdkEventConfigure GdkEventConfigure; typedef struct _GdkEventProperty GdkEventProperty; typedef struct _GdkEventSelection GdkEventSelection; +typedef struct _GdkEventOwnerChange GdkEventOwnerChange; typedef struct _GdkEventProximity GdkEventProximity; typedef struct _GdkEventClient GdkEventClient; typedef struct _GdkEventDND GdkEventDND; typedef struct _GdkEventWindowState GdkEventWindowState; typedef struct _GdkEventSetting GdkEventSetting; +typedef struct _GdkEventGrabBroken GdkEventGrabBroken; typedef union _GdkEvent GdkEvent; +/** + * GdkEventFunc: + * @event: the #GdkEvent to process. + * @data: user data set when the event handler was installed with + * gdk_event_handler_set(). + * + * Specifies the type of function passed to gdk_event_handler_set() to + * handle all GDK events. + */ typedef void (*GdkEventFunc) (GdkEvent *event, gpointer data); /* Event filtering */ +/** + * GdkXEvent: + * + * Used to represent native events (XEvents for the X11 + * backend, MSGs for Win32). + */ typedef void GdkXEvent; /* Can be cast to window system specific * even type, XEvent on X11, MSG on Win32. */ +/** + * GdkFilterReturn: + * @GDK_FILTER_CONTINUE: event not handled, continue processing. + * @GDK_FILTER_TRANSLATE: native event translated into a GDK event and stored + * in the event structure that was passed in. + * @GDK_FILTER_REMOVE: event handled, terminate processing. + * + * Specifies the result of applying a #GdkFilterFunc to a native event. + */ typedef enum { GDK_FILTER_CONTINUE, /* Event not handled, continue processesing */ - GDK_FILTER_TRANSLATE, /* Translated event stored */ + GDK_FILTER_TRANSLATE, /* Native event translated into a GDK event and + stored in the "event" structure that was + passed in */ GDK_FILTER_REMOVE /* Terminate processing, removing event */ } GdkFilterReturn; +/** + * GdkFilterFunc: + * @xevent: the native event to filter. + * @event: the GDK event to which the X event will be translated. + * @data: user data set when the filter was installed. + * + * Specifies the type of function used to filter native events before they are + * converted to GDK events. + * + * When a filter is called, @event is unpopulated, except for + * event->window. The filter may translate the native + * event to a GDK event and store the result in @event, or handle it without + * translation. If the filter translates the event and processing should + * continue, it should return %GDK_FILTER_TRANSLATE. + * + * Returns: a #GdkFilterReturn value. + */ typedef GdkFilterReturn (*GdkFilterFunc) (GdkXEvent *xevent, GdkEvent *event, gpointer data); -/* Event types. - * Nothing: No event occurred. - * Delete: A window delete event was sent by the window manager. - * The specified window should be deleted. - * Destroy: A window has been destroyed. - * Expose: Part of a window has been uncovered. - * NoExpose: Same as expose, but no expose event was generated. - * VisibilityNotify: A window has become fully/partially/not obscured. - * MotionNotify: The mouse has moved. - * ButtonPress: A mouse button was pressed. - * ButtonRelease: A mouse button was release. - * KeyPress: A key was pressed. - * KeyRelease: A key was released. - * EnterNotify: A window was entered. - * LeaveNotify: A window was exited. - * FocusChange: The focus window has changed. (The focus window gets - * keyboard events). - * Resize: A window has been resized. - * Map: A window has been mapped. (It is now visible on the screen). - * Unmap: A window has been unmapped. (It is no longer visible on - * the screen). - * Scroll: A mouse wheel was scrolled either up or down. +/** + * GdkEventType: + * @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_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. + * @GDK_EVENT_LAST: marks the end of the GdkEventType enumeration. Added in 2.18 + * + * 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. */ typedef enum { @@ -113,41 +255,23 @@ typedef enum 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_SETTING = 33, + GDK_OWNER_CHANGE = 34, + GDK_GRAB_BROKEN = 35, + GDK_DAMAGE = 36, + GDK_EVENT_LAST /* helper variable for decls */ } GdkEventType; -/* Event masks. (Used to select what types of events a window - * will receive). +/** + * GdkVisibilityState: + * @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. + * + * Specifies the visiblity status of a window for a #GdkEventVisibility. */ -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; - typedef enum { GDK_VISIBILITY_UNOBSCURED, @@ -155,6 +279,15 @@ typedef enum GDK_VISIBILITY_FULLY_OBSCURED } GdkVisibilityState; +/** + * GdkScrollDirection: + * @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. + * + * Specifies the direction for #GdkEventScroll. + */ typedef enum { GDK_SCROLL_UP, @@ -163,13 +296,26 @@ typedef enum GDK_SCROLL_RIGHT } GdkScrollDirection; -/* Types of enter/leave notifications. - * Ancestor: - * Virtual: - * Inferior: - * Nonlinear: - * NonlinearVirtual: - * Unknown: An unknown type of enter/leave event occurred. +/** + * GdkNotifyType: + * @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: an unknown type of enter/leave event occurred. + * + * Specifies the kind of crossing for #GdkEventCrossing. + * + * See the X11 protocol specification of LeaveNotify for + * full details of crossing event generation. */ typedef enum { @@ -181,32 +327,74 @@ typedef enum GDK_NOTIFY_UNKNOWN = 5 } GdkNotifyType; -/* Enter/leave event modes. - * NotifyNormal - * NotifyGrab - * NotifyUngrab +/** + * GdkCrossingMode: + * @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. + * @GDK_CROSSING_GTK_GRAB: crossing because a GTK+ grab is activated. + * @GDK_CROSSING_GTK_UNGRAB: crossing because a GTK+ grab is deactivated. + * @GDK_CROSSING_STATE_CHANGED: crossing because a GTK+ widget changed + * state (e.g. sensitivity). + * + * Specifies the crossing mode for #GdkEventCrossing. */ typedef enum { GDK_CROSSING_NORMAL, GDK_CROSSING_GRAB, - GDK_CROSSING_UNGRAB + GDK_CROSSING_UNGRAB, + GDK_CROSSING_GTK_GRAB, + GDK_CROSSING_GTK_UNGRAB, + GDK_CROSSING_STATE_CHANGED } GdkCrossingMode; +/** + * GdkPropertyState: + * @GDK_PROPERTY_NEW_VALUE: the property value was changed. + * @GDK_PROPERTY_DELETE: the property was deleted. + * + * Specifies the type of a property change for a #GdkEventProperty. + */ typedef enum { GDK_PROPERTY_NEW_VALUE, GDK_PROPERTY_DELETE } GdkPropertyState; +/** + * GdkWindowState: + * @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: the window is maximized without + * decorations. + * @GDK_WINDOW_STATE_ABOVE: the window is kept above other windows. + * @GDK_WINDOW_STATE_BELOW: the window is kept below other windows. + * + * Specifies the state of a toplevel window. + */ 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_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, + GDK_WINDOW_STATE_ABOVE = 1 << 5, + GDK_WINDOW_STATE_BELOW = 1 << 6 } GdkWindowState; +/** + * GdkSettingAction: + * @GDK_SETTING_ACTION_NEW: a setting was added. + * @GDK_SETTING_ACTION_CHANGED: a setting was changed. + * @GDK_SETTING_ACTION_DELETED: a setting was deleted. + * + * Specifies the kind of modification applied to a setting in a + * #GdkEventSetting. + */ typedef enum { GDK_SETTING_ACTION_NEW, @@ -214,6 +402,32 @@ typedef enum GDK_SETTING_ACTION_DELETED } GdkSettingAction; +/** + * GdkOwnerChange: + * @GDK_OWNER_CHANGE_NEW_OWNER: some other app claimed the ownership + * @GDK_OWNER_CHANGE_DESTROY: the window was destroyed + * @GDK_OWNER_CHANGE_CLOSE: the client was closed + * + * Specifies why a selection ownership was changed. + */ +typedef enum +{ + GDK_OWNER_CHANGE_NEW_OWNER, + GDK_OWNER_CHANGE_DESTROY, + GDK_OWNER_CHANGE_CLOSE +} GdkOwnerChange; + +/** + * GdkEventAny: + * @type: the type of the event. + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * + * 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. + */ struct _GdkEventAny { GdkEventType type; @@ -221,24 +435,43 @@ struct _GdkEventAny gint8 send_event; }; +/** + * GdkEventExpose: + * @type: the type of the event (%GDK_EXPOSE or %GDK_DAMAGE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @area: bounding box of @region. + * @region: the region that needs to be redrawn. + * @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. + * + * Generated when all or part of a window becomes visible and needs to be + * redrawn. + */ struct _GdkEventExpose { GdkEventType type; GdkWindow *window; gint8 send_event; GdkRectangle area; - GdkRegion *region; + cairo_region_t *region; gint count; /* If non-zero, how many more events follow. */ }; -struct _GdkEventNoExpose -{ - GdkEventType type; - GdkWindow *window; - gint8 send_event; - /* XXX: does anyone need the X major_code or minor_code fields? */ -}; - +/** + * GdkEventVisibility: + * @type: the type of the event (%GDK_VISIBILITY_NOTIFY). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @state: the new visibility state (%GDK_VISIBILITY_FULLY_OBSCURED, + * %GDK_VISIBILITY_PARTIAL or %GDK_VISIBILITY_UNOBSCURED). + * + * Generated when the window visibility status has changed. + */ struct _GdkEventVisibility { GdkEventType type; @@ -247,6 +480,29 @@ struct _GdkEventVisibility GdkVisibilityState state; }; +/** + * GdkEventMotion: + * @type: the type of the event. + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window. + * @y: the y coordinate of the pointer relative to the window. + * @axes: @x, @y translated to the axes of @device, or %NULL if @device is + * the mouse. + * @state: a bit-mask representing the state of the modifier keys (e.g. + * Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. + * @is_hint: set to 1 if this event is just a hint, see the + * %GDK_POINTER_MOTION_HINT_MASK value of #GdkEventMask. + * @device: the device where the event originated. + * @x_root: the x coordinate of the pointer relative to the root of the + * screen. + * @y_root: the y coordinate of the pointer relative to the root of the + * screen. + * + * Generated when the pointer moves. + */ struct _GdkEventMotion { GdkEventType type; @@ -262,6 +518,65 @@ struct _GdkEventMotion gdouble x_root, y_root; }; +/** + * GdkEventButton: + * @type: the type of the event (%GDK_BUTTON_PRESS, %GDK_2BUTTON_PRESS, + * %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window. + * @y: the y coordinate of the pointer relative to the window. + * @axes: @x, @y translated to the axes of @device, or %NULL if @device is + * the mouse. + * @state: a bit-mask representing the state of the modifier keys (e.g. + * Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. + * @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. + * @device: the device where the event originated. + * @x_root: the x coordinate of the pointer relative to the root of the + * screen. + * @y_root: the y coordinate of the pointer relative to the root of the + * screen. + * + * 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: + * + * %GDK_BUTTON_PRESS + * %GDK_BUTTON_RELEASE + * %GDK_BUTTON_PRESS + * %GDK_2BUTTON_PRESS + * %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: + * + * %GDK_BUTTON_PRESS + * %GDK_BUTTON_RELEASE + * %GDK_BUTTON_PRESS + * %GDK_2BUTTON_PRESS + * %GDK_BUTTON_RELEASE + * %GDK_BUTTON_PRESS + * %GDK_3BUTTON_PRESS + * %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. + */ struct _GdkEventButton { GdkEventType type; @@ -277,6 +592,29 @@ struct _GdkEventButton gdouble x_root, y_root; }; +/** + * GdkEventScroll: + * @type: the type of the event (%GDK_SCROLL). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window. + * @y: the y coordinate of the pointer relative to the window. + * @state: a bit-mask representing the state of the modifier keys (e.g. + * Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. + * @direction: the direction to scroll to (one of %GDK_SCROLL_UP, + * %GDK_SCROLL_DOWN, %GDK_SCROLL_LEFT and %GDK_SCROLL_RIGHT). + * @device: the device where the event originated. + * @x_root: the x coordinate of the pointer relative to the root of the + * screen. + * @y_root: the y coordinate of the pointer relative to the root of the + * screen. + * + * 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. + */ struct _GdkEventScroll { GdkEventType type; @@ -291,6 +629,37 @@ struct _GdkEventScroll gdouble x_root, y_root; }; +/** + * GdkEventKey: + * @type: the type of the event (%GDK_KEY_PRESS or %GDK_KEY_RELEASE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @time: the time of the event in milliseconds. + * @state: a bit-mask representing the state of the modifier keys (e.g. + * Control, Shift and Alt) and the pointer buttons. See #GdkModifierType. + * @keyval: the key that was pressed or released. See the + * <gdk/gdkkeysyms.h> header file for a + * complete list of GDK key codes. + * @length: the length of @string. + * @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. + * @hardware_keycode: the raw code of the key that was pressed or released. + * @group: the keyboard group. + * @is_modifier: a flag that indicates if @hardware_keycode is mapped to a + * modifier. Since 2.10 + * + * Describes a key press or key release event. + */ struct _GdkEventKey { GdkEventType type; @@ -303,8 +672,35 @@ struct _GdkEventKey gchar *string; guint16 hardware_keycode; guint8 group; + guint is_modifier : 1; }; +/** + * GdkEventCrossing: + * @type: the type of the event (%GDK_ENTER_NOTIFY or %GDK_LEAVE_NOTIFY). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @subwindow: the window that was entered or left. + * @time: the time of the event in milliseconds. + * @x: the x coordinate of the pointer relative to the window. + * @y: the y coordinate of the pointer relative to the window. + * @x_root: the x coordinate of the pointer relative to the root of the screen. + * @y_root: the y coordinate of the pointer relative to the root of the screen. + * @mode: the crossing mode (%GDK_CROSSING_NORMAL, %GDK_CROSSING_GRAB, + * %GDK_CROSSING_UNGRAB, %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB or + * %GDK_CROSSING_STATE_CHANGED). %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB, + * and %GDK_CROSSING_STATE_CHANGED were added in 2.14 and are always synthesized, + * never native. + * @detail: the kind of crossing that happened (%GDK_NOTIFY_INFERIOR, + * %GDK_NOTIFY_ANCESTOR, %GDK_NOTIFY_VIRTUAL, %GDK_NOTIFY_NONLINEAR or + * %GDK_NOTIFY_NONLINEAR_VIRTUAL). + * @focus: %TRUE if @window is the focus window or an inferior. + * @state: a bit-mask representing the state of the modifier keys (e.g. Control, + * Shift and Alt) and the pointer buttons. See #GdkModifierType. + * + * Generated when the pointer enters or leaves a window. + */ struct _GdkEventCrossing { GdkEventType type; @@ -322,6 +718,17 @@ struct _GdkEventCrossing guint state; }; +/** + * GdkEventFocus: + * @type: the type of the event (%GDK_FOCUS_CHANGE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @in: %TRUE if the window has gained the keyboard focus, %FALSE if + * it has lost the focus. + * + * Describes a change of keyboard focus. + */ struct _GdkEventFocus { GdkEventType type; @@ -330,6 +737,19 @@ struct _GdkEventFocus gint16 in; }; +/** + * GdkEventConfigure: + * @type: the type of the event (%GDK_CONFIGURE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @x: the new x coordinate of the window, relative to its parent. + * @y: the new y coordinate of the window, relative to its parent. + * @width: the new width of the window. + * @height: the new height of the window. + * + * Generated when a window size or position has changed. + */ struct _GdkEventConfigure { GdkEventType type; @@ -340,6 +760,19 @@ struct _GdkEventConfigure gint height; }; +/** + * GdkEventProperty: + * @type: the type of the event (%GDK_PROPERTY_NOTIFY). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @atom: the property that was changed. + * @time: the time of the event in milliseconds. + * @state: whether the property was changed (%GDK_PROPERTY_NEW_VALUE) or + * deleted (%GDK_PROPERTY_DELETE). + * + * Describes a property change on a window. + */ struct _GdkEventProperty { GdkEventType type; @@ -350,6 +783,22 @@ struct _GdkEventProperty guint state; }; +/** + * GdkEventSelection: + * @type: the type of the event (%GDK_SELECTION_CLEAR, + * %GDK_SELECTION_NOTIFY or %GDK_SELECTION_REQUEST). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @selection: the selection. + * @target: the target to which the selection should be converted. + * @property: the property in which to place the result of the conversion. + * @time: the time of the event in milliseconds. + * @requestor: the native window on which to place @property. + * + * Generated when a selection is requested or ownership of a selection + * is taken over by another client application. + */ struct _GdkEventSelection { GdkEventType type; @@ -362,9 +811,55 @@ struct _GdkEventSelection GdkNativeWindow requestor; }; -/* This event type will be used pretty rarely. It only is important - for XInput aware programs that are drawing their own cursor */ +/** + * GdkEventOwnerChange: + * @type: the type of the event (%GDK_OWNER_CHANGE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @owner: the new owner of the selection. + * @reason: the reason for the ownership change as a #GdkOwnerChange value. + * @selection: the atom identifying the selection. + * @time: the timestamp of the event. + * @selection_time: the time at which the selection ownership was taken + * over. + * + * Generated when the owner of a selection changes. On X11, this + * information is only available if the X server supports the XFIXES + * extension. + * + * Since: 2.6 + */ +struct _GdkEventOwnerChange +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkNativeWindow owner; + GdkOwnerChange reason; + GdkAtom selection; + guint32 time; + guint32 selection_time; +}; +/** + * GdkEventProximity: + * @type: the type of the event (%GDK_PROXIMITY_IN or %GDK_PROXIMITY_OUT). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using XSendEvent). + * @time: the time of the event in milliseconds. + * @device: the device where the event originated. + * + * 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. + * + * This event type will be used pretty rarely. It only is important for + * XInput aware programs that are drawing their own cursor. + */ struct _GdkEventProximity { GdkEventType type; @@ -374,6 +869,21 @@ struct _GdkEventProximity GdkDevice *device; }; +/** + * GdkEventClient: + * @type: the type of the event (%GDK_CLIENT_EVENT). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @message_type: the type of the message, which can be defined by the + * application. + * @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. + * + * An event sent by another client application. + */ struct _GdkEventClient { GdkEventType type; @@ -388,6 +898,18 @@ struct _GdkEventClient } data; }; +/** + * GdkEventSetting: + * @type: the type of the event (%GDK_SETTING). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @action: what happened to the setting (%GDK_SETTING_ACTION_NEW, + * %GDK_SETTING_ACTION_CHANGED or %GDK_SETTING_ACTION_DELETED). + * @name: the name of the setting. + * + * Generated when a setting is modified. + */ struct _GdkEventSetting { GdkEventType type; @@ -397,6 +919,18 @@ struct _GdkEventSetting char *name; }; +/** + * GdkEventWindowState: + * @type: the type of the event (%GDK_WINDOW_STATE). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @changed_mask: mask specifying what flags have changed. + * @new_window_state: the new window state, a combination of + * #GdkWindowState bits. + * + * Generated when the state of a toplevel window changes. + */ struct _GdkEventWindowState { GdkEventType type; @@ -406,8 +940,54 @@ struct _GdkEventWindowState GdkWindowState new_window_state; }; -/* Event types for DND */ +/** + * GdkEventGrabBroken: + * @type: the type of the event (%GDK_GRAB_BROKEN) + * @window: the window which received the event, i.e. the window + * that previously owned the grab + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @keyboard: %TRUE if a keyboard grab was broken, %FALSE if a pointer + * grab was broken + * @implicit: %TRUE if the broken grab was implicit + * @grab_window: If this event is caused by another grab in the same + * application, @grab_window contains the new grab window. Otherwise + * @grab_window is %NULL. + * + * Generated when a pointer or keyboard grab is broken. On X11, this happens + * when the grab window becomes unviewable (i.e. it or one of its ancestors + * is unmapped), or if the same application grabs the pointer or keyboard + * again. Note that implicit grabs (which are initiated by button presses) + * can also cause #GdkEventGrabBroken events. + * + * Since: 2.8 + */ +struct _GdkEventGrabBroken { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gboolean keyboard; + gboolean implicit; + GdkWindow *grab_window; +}; +/** + * GdkEventDND: + * @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). + * @window: the window which received the event. + * @send_event: %TRUE if the event was sent explicitly (e.g. using + * XSendEvent). + * @context: the #GdkDragContext for the current DND operation. + * @time: the time of the event in milliseconds. + * @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. + * @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. + * + * Generated during DND operations. + */ struct _GdkEventDND { GdkEventType type; GdkWindow *window; @@ -418,12 +998,51 @@ struct _GdkEventDND { gshort x_root, y_root; }; +/** + * GdkEvent: + * + * 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; + * + * + */ union _GdkEvent { GdkEventType type; GdkEventAny any; GdkEventExpose expose; - GdkEventNoExpose no_expose; GdkEventVisibility visibility; GdkEventMotion motion; GdkEventButton button; @@ -434,52 +1053,86 @@ union _GdkEvent GdkEventConfigure configure; GdkEventProperty property; GdkEventSelection selection; + GdkEventOwnerChange owner_change; GdkEventProximity proximity; GdkEventClient client; GdkEventDND dnd; GdkEventWindowState window_state; GdkEventSetting setting; + GdkEventGrabBroken grab_broken; }; -GType gdk_event_get_type (void); +GType gdk_event_get_type (void) G_GNUC_CONST; gboolean gdk_events_pending (void); GdkEvent* gdk_event_get (void); GdkEvent* gdk_event_peek (void); -GdkEvent* gdk_event_get_graphics_expose (GdkWindow *window); -void gdk_event_put (GdkEvent *event); +void gdk_event_put (const GdkEvent *event); -GdkEvent* gdk_event_copy (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 (GdkEvent *event); -gboolean gdk_event_get_state (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 (GdkEvent *event, +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); +gboolean gdk_event_get_axis (const GdkEvent *event, GdkAxisUse axis_use, gdouble *value); +void gdk_event_set_device (GdkEvent *event, + GdkDevice *device); +GdkDevice* gdk_event_get_device (const GdkEvent *event); +void gdk_event_set_source_device (GdkEvent *event, + GdkDevice *device); +GdkDevice* gdk_event_get_source_device (const GdkEvent *event); +void gdk_event_request_motions (const GdkEventMotion *event); + +gboolean gdk_events_get_distance (GdkEvent *event1, + GdkEvent *event2, + gdouble *distance); +gboolean gdk_events_get_angle (GdkEvent *event1, + GdkEvent *event2, + gdouble *angle); +gboolean gdk_events_get_center (GdkEvent *event1, + GdkEvent *event2, + gdouble *x, + gdouble *y); void gdk_event_handler_set (GdkEventFunc func, gpointer data, GDestroyNotify notify); +void gdk_event_set_screen (GdkEvent *event, + GdkScreen *screen); +GdkScreen *gdk_event_get_screen (const GdkEvent *event); + void gdk_set_show_events (gboolean show_events); gboolean gdk_get_show_events (void); -/* - * The following function adds a global filter for all client - * messages of type message_type - */ -void gdk_add_client_message_filter (GdkAtom message_type, - GdkFilterFunc func, - gpointer data); +#ifndef GDK_MULTIHEAD_SAFE + +gboolean gdk_setting_get (const gchar *name, + GValue *value); +void gdk_add_client_message_filter (GdkAtom message_type, + GdkFilterFunc func, + gpointer data); +gboolean gdk_event_send_client_message (GdkEvent *event, + GdkNativeWindow winid); +void gdk_event_send_clientmessage_toall (GdkEvent *event); + +#endif /* GDK_MULTIHEAD_SAFE */ -gboolean gdk_setting_get (const gchar *name, - GValue *value); +gboolean gdk_event_send_client_message_for_display (GdkDisplay *display, + GdkEvent *event, + GdkNativeWindow winid); -#ifdef __cplusplus -} -#endif /* __cplusplus */ +G_END_DECLS #endif /* __GDK_EVENTS_H__ */