cdk_events_pending ()

gboolean
cdk_events_pending (void);

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

cdk_event_peek ()

CdkEvent *
cdk_event_peek (void);

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

cdk_event_get ()

CdkEvent *
cdk_event_get (void);

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

cdk_event_put ()

void
cdk_event_put (const CdkEvent *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 cdk_display_put_event().

cdk_event_new ()

CdkEvent *
cdk_event_new (CdkEventType type);

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

Since: 2.2

cdk_event_copy ()

CdkEvent *
cdk_event_copy (const CdkEvent *event);

Copies a CdkEvent, copying or incrementing the reference count of the resources associated with it (e.g. CdkWindow’s and strings).

cdk_event_free ()

void
cdk_event_free (CdkEvent *event);

Frees a CdkEvent, freeing or decrementing any resources associated with it. Note that this function should only be called with events returned from functions such as cdk_event_peek(), cdk_event_get(), cdk_event_copy() and cdk_event_new().

cdk_event_get_axis ()

gboolean
cdk_event_get_axis (const CdkEvent *event,
                    CdkAxisUse axis_use,
                    gdouble *value);

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

cdk_event_get_button ()

gboolean
cdk_event_get_button (const CdkEvent *event,
                      guint *button);

Extract the button number from an event.

Since: 3.2

cdk_event_get_click_count ()

gboolean
cdk_event_get_click_count (const CdkEvent *event,
                           guint *click_count);

Extracts the click count from an event.

Since: 3.2

cdk_event_get_coords ()

gboolean
cdk_event_get_coords (const CdkEvent *event,
                      gdouble *x_win,
                      gdouble *y_win);

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

cdk_event_get_keycode ()

gboolean
cdk_event_get_keycode (const CdkEvent *event,
                       guint16 *keycode);

Extracts the hardware keycode from an event.

Also see cdk_event_get_scancode().

Since: 3.2

cdk_event_get_keyval ()

gboolean
cdk_event_get_keyval (const CdkEvent *event,
                      guint *keyval);

Extracts the keyval from an event.

Since: 3.2

cdk_event_get_root_coords ()

gboolean
cdk_event_get_root_coords (const CdkEvent *event,
                           gdouble *x_root,
                           gdouble *y_root);

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

cdk_event_get_scroll_direction ()

gboolean
cdk_event_get_scroll_direction (const CdkEvent *event,
                                CdkScrollDirection *direction);

Extracts the scroll direction from an event.

If event is not of type CDK_SCROLL, the contents of direction are undefined.

If you wish to handle both discrete and smooth scrolling, you should check the return value of this function, or of cdk_event_get_scroll_deltas(); for instance:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

CdkScrollDirection direction;
double vscroll_factor = 0.0;
double x_scroll, y_scroll;

if (cdk_event_get_scroll_direction (event, &direction))
  {
    // Handle discrete scrolling with a known constant delta;
    const double delta = 12.0;

    switch (direction)
      {
      case CDK_SCROLL_UP:
        vscroll_factor = -delta;
        break;
      case CDK_SCROLL_DOWN:
        vscroll_factor = delta;
        break;
      default:
        // no scrolling
        break;
      }
  }
else if (cdk_event_get_scroll_deltas (event, &x_scroll, &y_scroll))
  {
    // Handle smooth scrolling directly
    vscroll_factor = y_scroll;
  }

Since: 3.2

cdk_event_get_scroll_deltas ()

gboolean
cdk_event_get_scroll_deltas (const CdkEvent *event,
                             gdouble *delta_x,
                             gdouble *delta_y);

Retrieves the scroll deltas from a CdkEvent

See also: cdk_event_get_scroll_direction()

Since: 3.4

cdk_event_is_scroll_stop_event ()

gboolean
cdk_event_is_scroll_stop_event (const CdkEvent *event);

Check whether a scroll event is a stop scroll event. Scroll sequences with smooth scroll information may provide a stop scroll event once the interaction with the device finishes, e.g. by lifting a finger. This stop scroll event is the signal that a widget may trigger kinetic scrolling based on the current velocity.

Stop scroll events always have a a delta of 0/0.

Since: 3.20

cdk_event_get_state ()

gboolean
cdk_event_get_state (const CdkEvent *event,
                     CdkModifierType *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.

cdk_event_get_time ()

guint32
cdk_event_get_time (const CdkEvent *event);

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

cdk_event_get_window ()

CdkWindow *
cdk_event_get_window (const CdkEvent *event);

Extracts the CdkWindow associated with an event.

Since: 3.10

cdk_event_get_event_type ()

CdkEventType
cdk_event_get_event_type (const CdkEvent *event);

Retrieves the type of the event.

Since: 3.10

cdk_event_get_event_sequence ()

CdkEventSequence *
cdk_event_get_event_sequence (const CdkEvent *event);

If event if of type CDK_TOUCH_BEGIN, CDK_TOUCH_UPDATE, CDK_TOUCH_END or CDK_TOUCH_CANCEL, returns the CdkEventSequence to which the event belongs. Otherwise, return NULL.

Since: 3.4

cdk_event_request_motions ()

void
cdk_event_request_motions (const CdkEventMotion *event);

Request more motion notifies if event is a motion notify hint event.

This function should be used instead of cdk_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 CDK_MOTION_NOTIFY event usually works like this:

1
2
3
4
5
6
7

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

Since: 2.12

cdk_events_get_angle ()

gboolean
cdk_events_get_angle (CdkEvent *event1,
                      CdkEvent *event2,
                      gdouble *angle);

If both events contain X/Y information, this function will return TRUE and return in angle the relative angle from event1 to event2 . The rotation direction for positive angles is from the positive X axis towards the positive Y axis.

Since: 3.0

cdk_events_get_center ()

gboolean
cdk_events_get_center (CdkEvent *event1,
                       CdkEvent *event2,
                       gdouble *x,
                       gdouble *y);

If both events contain X/Y information, the center of both coordinates will be returned in x and y .

Since: 3.0

cdk_events_get_distance ()

gboolean
cdk_events_get_distance (CdkEvent *event1,
                         CdkEvent *event2,
                         gdouble *distance);

If both events have X/Y information, the distance between both coordinates (as in a straight line going from event1 to event2 ) will be returned.

Since: 3.0

cdk_event_triggers_context_menu ()

gboolean
cdk_event_triggers_context_menu (const CdkEvent *event);

This function returns whether a CdkEventButton should trigger a context menu, according to platform conventions. The right mouse button always triggers context menus. Additionally, if cdk_keymap_get_modifier_mask() returns a non-0 mask for CDK_MODIFIER_INTENT_CONTEXT_MENU, then the left mouse button will also trigger a context menu if this modifier is pressed.

This function should always be used instead of simply checking for event->button == CDK_BUTTON_SECONDARY.

Since: 3.4

cdk_event_get_seat ()

CdkSeat *
cdk_event_get_seat (const CdkEvent *event);

Returns the CdkSeat this event was generated for.

Since: 3.20

cdk_event_get_scancode ()

int
cdk_event_get_scancode (CdkEvent *event);

Gets the keyboard low-level scancode of a key event.

This is usually hardware_keycode. On Windows this is the high word of WM_KEY{DOWN,UP} lParam which contains the scancode and some extended flags.

Since: 3.22

cdk_event_get_pointer_emulated ()

gboolean
cdk_event_get_pointer_emulated (CdkEvent *event);

Returns whether this event is an 'emulated' pointer event (typically from a touch event), as opposed to a real one.

Since: 3.22

cdk_event_handler_set ()

void
cdk_event_handler_set (CdkEventFunc func,
                       gpointer data,
                       GDestroyNotify notify);

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

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

CdkEventFunc ()

void
(*CdkEventFunc) (CdkEvent *event,
                 gpointer data);

Specifies the type of function passed to cdk_event_handler_set() to handle all CDK events.

cdk_get_show_events ()

gboolean
cdk_get_show_events (void);

Gets whether event debugging output is enabled.

cdk_set_show_events ()

void
cdk_set_show_events (gboolean show_events);

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

cdk_event_set_screen ()

void
cdk_event_set_screen (CdkEvent *event,
                      CdkScreen *screen);

Sets the screen for event to screen . The event must have been allocated by CTK+, for instance, by cdk_event_copy().

Since: 2.2

cdk_event_get_screen ()

CdkScreen *
cdk_event_get_screen (const CdkEvent *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.

Since: 2.2

cdk_event_get_device ()

CdkDevice *
cdk_event_get_device (const CdkEvent *event);

If the event contains a “device” field, this function will return it, else it will return NULL.

Since: 3.0

cdk_event_set_device ()

void
cdk_event_set_device (CdkEvent *event,
                      CdkDevice *device);

Sets the device for event to device . The event must have been allocated by CTK+, for instance, by cdk_event_copy().

Since: 3.0

cdk_event_get_source_device ()

CdkDevice *
cdk_event_get_source_device (const CdkEvent *event);

This function returns the hardware (slave) CdkDevice that has triggered the event, falling back to the virtual (master) device (as in cdk_event_get_device()) if the event wasn’t caused by interaction with a hardware device. This may happen for example in synthesized crossing events after a CdkWindow updates its geometry or a grab is acquired/released.

If the event does not contain a device field, this function will return NULL.

Since: 3.0

cdk_event_set_source_device ()

void
cdk_event_set_source_device (CdkEvent *event,
                             CdkDevice *device);

Sets the slave device for event to device .

The event must have been allocated by CTK+, for instance by cdk_event_copy().

Since: 3.0

cdk_event_get_device_tool ()

CdkDeviceTool *
cdk_event_get_device_tool (const CdkEvent *event);

If the event was generated by a device that supports different tools (eg. a tablet), this function will return a CdkDeviceTool representing the tool that caused the event. Otherwise, NULL will be returned.

Note: the CdkDeviceTool<!-- -->s will be constant during the application lifetime, if settings must be stored persistently across runs, see cdk_device_tool_get_serial()

Since: 3.22

cdk_event_set_device_tool ()

void
cdk_event_set_device_tool (CdkEvent *event,
                           CdkDeviceTool *tool);

Sets the device tool for this event, should be rarely used.

Since: 3.22

cdk_setting_get ()

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

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

enum CdkEventType

Specifies the type of the event.

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

In some language bindings, the values CDK_2BUTTON_PRESS and CDK_3BUTTON_PRESS would translate into something syntactically invalid (eg Cdk.EventType.2ButtonPress, where a symbol is not allowed to start with a number). In that case, the aliases CDK_DOUBLE_BUTTON_PRESS and CDK_TRIPLE_BUTTON_PRESS can be used instead.

enum CdkEventMask

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 CdkEventType event types above.

See the input handling overview for details of event masks and event propagation.

CDK_POINTER_MOTION_HINT_MASK is deprecated. It is a special mask to reduce the number of CDK_MOTION_NOTIFY events received. When using CDK_POINTER_MOTION_HINT_MASK, fewer CDK_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 cdk_event_request_motions().

Since CTK 3.8, motion events are already compressed by default, independent of this mechanism. This compression can be disabled with cdk_window_set_event_compression(). See the documentation of that function for details.

If CDK_TOUCH_MASK is enabled, the window will receive touch events from touch-enabled devices. Those will come as sequences of CdkEventTouch with type CDK_TOUCH_UPDATE, enclosed by two events with type CDK_TOUCH_BEGIN and CDK_TOUCH_END (or CDK_TOUCH_CANCEL). cdk_event_get_event_sequence() returns the event sequence for these events, so different sequences may be distinguished.

CDK_CURRENT_TIME

#define CDK_CURRENT_TIME     0L

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

CDK_PRIORITY_EVENTS

#define             CDK_PRIORITY_EVENTS

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

CDK_PRIORITY_REDRAW

#define CDK_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.

CDK_EVENT_PROPAGATE

#define CDK_EVENT_PROPAGATE     (FALSE)

Use this macro as the return value for continuing the propagation of an event handler.

Since: 3.4

CDK_EVENT_STOP

#define CDK_EVENT_STOP          (TRUE)

Use this macro as the return value for stopping the propagation of an event handler.

Since: 3.4

CDK_BUTTON_PRIMARY

#define CDK_BUTTON_PRIMARY      (1)

The primary button. This is typically the left mouse button, or the right button in a left-handed setup.

Since: 3.4

CDK_BUTTON_MIDDLE

#define CDK_BUTTON_MIDDLE       (2)

The middle button.

Since: 3.4

CDK_BUTTON_SECONDARY

#define CDK_BUTTON_SECONDARY    (3)

The secondary button. This is typically the right mouse button, or the left button in a left-handed setup.

Since: 3.4

CdkEventSequence

typedef struct _CdkEventSequence CdkEventSequence;