<< Back to man.ChinaUnix.net

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                   (GdkEvent *event);
GdkEvent*   gdk_event_new                   (GdkEventType type);
GdkEvent*   gdk_event_copy                  (GdkEvent *event);
void        gdk_event_free                  (GdkEvent *event);
guint32     gdk_event_get_time              (GdkEvent *event);
gboolean    gdk_event_get_state             (GdkEvent *event,
                                             GdkModifierType *state);
gboolean    gdk_event_get_axis              (GdkEvent *event,
                                             GdkAxisUse axis_use,
                                             gdouble *value);
gboolean    gdk_event_get_coords            (GdkEvent *event,
                                             gdouble *x_win,
                                             gdouble *y_win);
gboolean    gdk_event_get_root_coords       (GdkEvent *event,
                                             gdouble *x_root,
                                             gdouble *y_root);

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            (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
} 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_NOTHINGa special code to indicate a null event.
GDK_DELETEthe 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_DESTROYthe window has been destroyed.
GDK_EXPOSEall or part of the window has become visible and needs to be redrawn.
GDK_MOTION_NOTIFYthe pointer (usually a mouse) has moved.
GDK_BUTTON_PRESSa mouse button has been pressed.
GDK_2BUTTON_PRESSa 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_PRESSa 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_RELEASEa mouse button has been released.
GDK_KEY_PRESSa key has been pressed.
GDK_KEY_RELEASEa key has been released.
GDK_ENTER_NOTIFYthe pointer has entered the window.
GDK_LEAVE_NOTIFYthe pointer has left the window.
GDK_FOCUS_CHANGEthe keyboard focus has entered or left the window.
GDK_CONFIGUREthe size, position or stacking order of the window has changed. Note that GTK+ discards these events for GDK_WINDOW_CHILD windows.
GDK_MAPthe window has been mapped.
GDK_UNMAPthe window has been unmapped.
GDK_PROPERTY_NOTIFYa property on the window has been changed or deleted.
GDK_SELECTION_CLEARthe application has lost ownership of a selection.
GDK_SELECTION_REQUESTanother application has requested a selection.
GDK_SELECTION_NOTIFYa selection has been received.
GDK_PROXIMITY_INan input device has moved into contact with a sensing surface (e.g. a touchscreen or graphics tablet).
GDK_PROXIMITY_OUTan input device has moved out of contact with a sensing surface.
GDK_DRAG_ENTERthe mouse has entered the window while a drag is in progress.
GDK_DRAG_LEAVEthe mouse has left the window while a drag is in progress.
GDK_DRAG_MOTIONthe mouse has moved in the window while a drag is in progress.
GDK_DRAG_STATUSthe status of the drag operation initiated by the window has changed.
GDK_DROP_STARTa drop operation onto the window has started.
GDK_DROP_FINISHEDthe drop operation initiated by the window has completed.
GDK_CLIENT_EVENTa message has been received from another application.
GDK_VISIBILITY_NOTIFYthe window visibility status has changed.
GDK_NO_EXPOSEindicates that the source region was completely available when parts of a drawable were copied. This is not very useful.
GDK_SCROLL
GDK_WINDOW_STATE
GDK_SETTING
GDK_OWNER_CHANGEthe owner of a selection has changed. This event type was added in 2.6

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 easily lag behind the position of the mouse. When using the GDK_POINTER_MOTION_HINT_MASK the server will only send a single GDK_MOTION_NOTIFY event (which is marked as a hint) until the application asks for more, by calling gdk_window_get_pointer().

GDK_EXPOSURE_MASK
GDK_POINTER_MOTION_MASK
GDK_POINTER_MOTION_HINT_MASK
GDK_BUTTON_MOTION_MASK
GDK_BUTTON1_MOTION_MASK
GDK_BUTTON2_MOTION_MASK
GDK_BUTTON3_MOTION_MASK
GDK_BUTTON_PRESS_MASK
GDK_BUTTON_RELEASE_MASK
GDK_KEY_PRESS_MASK
GDK_KEY_RELEASE_MASK
GDK_ENTER_NOTIFY_MASK
GDK_LEAVE_NOTIFY_MASK
GDK_FOCUS_CHANGE_MASK
GDK_STRUCTURE_MASK
GDK_PROPERTY_CHANGE_MASK
GDK_VISIBILITY_NOTIFY_MASK
GDK_PROXIMITY_IN_MASK
GDK_PROXIMITY_OUT_MASK
GDK_SUBSTRUCTURE_MASK
GDK_SCROLL_MASK
GDK_ALL_EVENTS_MASKthe 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                   (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                  (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              (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             (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              (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            (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       (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_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            (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.