## Events

Events — User and window system events

## Synopsis

    #define             CLUTTER_CURRENT_TIME
    #define             CLUTTER_PRIORITY_EVENTS
    #define             CLUTTER_EVENT_PROPAGATE
    #define             CLUTTER_EVENT_STOP
    enum                ClutterModifierType;
    enum                ClutterScrollDirection;
    enum                ClutterStageState;
    enum                ClutterEventType;
    union               ClutterEvent;
    enum                ClutterEventFlags;
    struct              ClutterButtonEvent;
    struct              ClutterKeyEvent;
    struct              ClutterMotionEvent;
    struct              ClutterScrollEvent;
    struct              ClutterStageStateEvent;
    struct              ClutterCrossingEvent;
    struct              ClutterTouchEvent;
                        ClutterEventSequence;
    ClutterEvent *      clutter_event_new                   (ClutterEventType type);
    ClutterEvent *      clutter_event_copy                  (const ClutterEvent *event);
    void                clutter_event_free                  (ClutterEvent *event);
    ClutterEventType    clutter_event_type                  (const ClutterEvent *event);

    void                clutter_event_set_coords            (ClutterEvent *event,
                                                             gfloat x,
                                                             gfloat y);
    void                clutter_event_get_coords            (const ClutterEvent *event,
                                                             gfloat *x,
                                                             gfloat *y);
    void                clutter_event_set_state             (ClutterEvent *event,
                                                             ClutterModifierType state);
    ClutterModifierType clutter_event_get_state             (const ClutterEvent *event);
    void                clutter_event_get_state_full        (const ClutterEvent *event,
                                                             ClutterModifierType *button_state,
                                                             ClutterModifierType *base_state,
                                                             ClutterModifierType *latched_state,
                                                             ClutterModifierType *locked_state,
                                                             ClutterModifierType *effective_state);
    void                clutter_event_set_time              (ClutterEvent *event,
                                                             guint32 time_);
    guint32             clutter_event_get_time              (const ClutterEvent *event);
    void                clutter_event_set_source            (ClutterEvent *event,
                                                             ClutterActor *actor);
    ClutterActor *      clutter_event_get_source            (const ClutterEvent *event);
    void                clutter_event_set_stage             (ClutterEvent *event,
                                                             ClutterStage *stage);
    ClutterStage *      clutter_event_get_stage             (const ClutterEvent *event);
    void                clutter_event_set_flags             (ClutterEvent *event,
                                                             ClutterEventFlags flags);
    ClutterEventFlags   clutter_event_get_flags             (const ClutterEvent *event);
    gdouble *           clutter_event_get_axes              (const ClutterEvent *event,
                                                             guint *n_axes);
    ClutterEventSequence * clutter_event_get_event_sequence (const ClutterEvent *event);
    double              clutter_event_get_angle             (const ClutterEvent *source,
                                                             const ClutterEvent *target);
    float               clutter_event_get_distance          (const ClutterEvent *source,
                                                             const ClutterEvent *target);
    void                clutter_event_get_position          (const ClutterEvent *event,
                                                             ClutterPoint *position);
    gboolean            clutter_event_has_control_modifier  (const ClutterEvent *event);
    gboolean            clutter_event_has_shift_modifier    (const ClutterEvent *event);
    gboolean            clutter_event_is_pointer_emulated   (const ClutterEvent *event);

    ClutterEvent *      clutter_event_get                   (void);
    ClutterEvent *      clutter_event_peek                  (void);
    void                clutter_event_put                   (const ClutterEvent *event);
    gboolean            clutter_events_pending              (void);

    #define             CLUTTER_BUTTON_PRIMARY
    #define             CLUTTER_BUTTON_MIDDLE
    #define             CLUTTER_BUTTON_SECONDARY
    void                clutter_event_set_button            (ClutterEvent *event,
                                                             guint32 button);
    guint32             clutter_event_get_button            (const ClutterEvent *event);
    guint               clutter_event_get_click_count       (const ClutterEvent *event);

    void                clutter_event_set_key_symbol        (ClutterEvent *event,
                                                             guint key_sym);
    guint               clutter_event_get_key_symbol        (const ClutterEvent *event);
    void                clutter_event_set_key_code          (ClutterEvent *event,
                                                             guint16 key_code);
    guint16             clutter_event_get_key_code          (const ClutterEvent *event);
    void                clutter_event_set_key_unicode       (ClutterEvent *event,
                                                             gunichar key_unicode);
    gunichar            clutter_event_get_key_unicode       (const ClutterEvent *event);
    guint32             clutter_keysym_to_unicode           (guint keyval);
    guint               clutter_unicode_to_keysym           (guint32 wc);

    void                clutter_event_set_related           (ClutterEvent *event,
                                                             ClutterActor *actor);
    ClutterActor *      clutter_event_get_related           (const ClutterEvent *event);

    void                clutter_event_set_scroll_direction  (ClutterEvent *event,
                                                             ClutterScrollDirection direction);
    ClutterScrollDirection clutter_event_get_scroll_direction
                                                            (const ClutterEvent *event);
    void                clutter_event_get_scroll_delta      (const ClutterEvent *event,
                                                             gdouble *dx,
                                                             gdouble *dy);
    void                clutter_event_set_scroll_delta      (ClutterEvent *event,
                                                             gdouble dx,
                                                             gdouble dy);

    void                clutter_event_set_device            (ClutterEvent *event,
                                                             ClutterInputDevice *device);
    ClutterInputDevice * clutter_event_get_device           (const ClutterEvent *event);
    void                clutter_event_set_source_device     (ClutterEvent *event,
                                                             ClutterInputDevice *device);
    ClutterInputDevice * clutter_event_get_source_device    (const ClutterEvent *event);
    gint                clutter_event_get_device_id         (const ClutterEvent *event);
    ClutterInputDeviceType clutter_event_get_device_type    (const ClutterEvent *event);

    guint32             clutter_get_current_event_time      (void);
    const ClutterEvent * clutter_get_current_event          (void);

## Description

Windowing events handled by Clutter.

The events usually come from the windowing backend, but can also be synthesized by Clutter itself or by the application code.

## Details

### CLUTTER_CURRENT_TIME

    #define CLUTTER_CURRENT_TIME            (0L)

Default value for "now".

Since 0.4

### CLUTTER_PRIORITY_EVENTS

    #define CLUTTER_PRIORITY_EVENTS         (G_PRIORITY_DEFAULT)

Priority for event handling.

Since 0.4

### CLUTTER_EVENT_PROPAGATE

    #define CLUTTER_EVENT_PROPAGATE         (FALSE)

Continues the propagation of an event; this macro should be used in event-related signals.

Since 1.10

### CLUTTER_EVENT_STOP

    #define CLUTTER_EVENT_STOP              (TRUE)

Stops the propagation of an event; this macro should be used in event-related signals.

Since 1.10

### enum ClutterModifierType

    typedef enum {
      CLUTTER_SHIFT_MASK    = 1 << 0,
      CLUTTER_LOCK_MASK     = 1 << 1,
      CLUTTER_CONTROL_MASK  = 1 << 2,
      CLUTTER_MOD1_MASK     = 1 << 3,
      CLUTTER_MOD2_MASK     = 1 << 4,
      CLUTTER_MOD3_MASK     = 1 << 5,
      CLUTTER_MOD4_MASK     = 1 << 6,
      CLUTTER_MOD5_MASK     = 1 << 7,
      CLUTTER_BUTTON1_MASK  = 1 << 8,
      CLUTTER_BUTTON2_MASK  = 1 << 9,
      CLUTTER_BUTTON3_MASK  = 1 << 10,
      CLUTTER_BUTTON4_MASK  = 1 << 11,
      CLUTTER_BUTTON5_MASK  = 1 << 12,

    #endif

      CLUTTER_SUPER_MASK    = 1 << 26,
      CLUTTER_HYPER_MASK    = 1 << 27,
      CLUTTER_META_MASK     = 1 << 28,

    #endif

      CLUTTER_RELEASE_MASK  = 1 << 30,

      /* Combination of CLUTTER_SHIFT_MASK..CLUTTER_BUTTON5_MASK + CLUTTER_SUPER_MASK
         + CLUTTER_HYPER_MASK + CLUTTER_META_MASK + CLUTTER_RELEASE_MASK */
      CLUTTER_MODIFIER_MASK = 0x5c001fff
    } ClutterModifierType;

Masks applied to a ClutterEvent by modifiers.

Note that Clutter may add internal values to events which include reserved values such as `CLUTTER_MODIFIER_RESERVED_13_MASK`. Your code should preserve and ignore them. You can use `CLUTTER_MODIFIER_MASK` to remove all reserved values.

`CLUTTER_SHIFT_MASK` | Mask applied by the Shift key
`CLUTTER_LOCK_MASK` | Mask applied by the Caps Lock key
`CLUTTER_CONTROL_MASK` | Mask applied by the Control key
`CLUTTER_MOD1_MASK` | Mask applied by the first Mod key
`CLUTTER_MOD2_MASK` | Mask applied by the second Mod key
`CLUTTER_MOD3_MASK` | Mask applied by the third Mod key
`CLUTTER_MOD4_MASK` | Mask applied by the fourth Mod key
`CLUTTER_MOD5_MASK` | Mask applied by the fifth Mod key
`CLUTTER_BUTTON1_MASK` | Mask applied by the first pointer button
`CLUTTER_BUTTON2_MASK` | Mask applied by the second pointer button
`CLUTTER_BUTTON3_MASK` | Mask applied by the third pointer button
`CLUTTER_BUTTON4_MASK` | Mask applied by the fourth pointer button
`CLUTTER_BUTTON5_MASK` | Mask applied by the fifth pointer button
`CLUTTER_SUPER_MASK` | Mask applied by the Super key
`CLUTTER_HYPER_MASK` | Mask applied by the Hyper key
`CLUTTER_META_MASK` | Mask applied by the Meta key
`CLUTTER_RELEASE_MASK` | Mask applied during release
`CLUTTER_MODIFIER_MASK` | A mask covering all modifier types

Since 0.4

### enum ClutterScrollDirection

    typedef enum {
     /*< prefix=CLUTTER_SCROLL >*/
      CLUTTER_SCROLL_UP,
      CLUTTER_SCROLL_DOWN,
      CLUTTER_SCROLL_LEFT,
      CLUTTER_SCROLL_RIGHT,
      CLUTTER_SCROLL_SMOOTH
    } ClutterScrollDirection;

Direction of a pointer scroll event.

The `CLUTTER_SCROLL_SMOOTH` value implies that the ClutterScrollEvent has precise scrolling delta information.

`CLUTTER_SCROLL_UP` | Scroll up
`CLUTTER_SCROLL_DOWN` | Scroll down
`CLUTTER_SCROLL_LEFT` | Scroll left
`CLUTTER_SCROLL_RIGHT` | Scroll right
`CLUTTER_SCROLL_SMOOTH` | Precise scrolling delta (available in 1.10)

Since 0.4

### enum ClutterStageState

    typedef enum {
      CLUTTER_STAGE_STATE_FULLSCREEN       = (1 << 1),
      CLUTTER_STAGE_STATE_OFFSCREEN        = (1 << 2),
      CLUTTER_STAGE_STATE_ACTIVATED        = (1 << 3)
    } ClutterStageState;

Stage state masks, used by the ClutterEvent of type `CLUTTER_STAGE_STATE`.

`CLUTTER_STAGE_STATE_FULLSCREEN` | Fullscreen mask
`CLUTTER_STAGE_STATE_OFFSCREEN` | Offscreen mask (deprecated)
`CLUTTER_STAGE_STATE_ACTIVATED` | Activated mask

Since 0.4

### enum ClutterEventType

    typedef enum {
     /*< prefix=CLUTTER >*/
      CLUTTER_NOTHING = 0,
      CLUTTER_KEY_PRESS,
      CLUTTER_KEY_RELEASE,
      CLUTTER_MOTION,
      CLUTTER_ENTER,
      CLUTTER_LEAVE,
      CLUTTER_BUTTON_PRESS,
      CLUTTER_BUTTON_RELEASE,
      CLUTTER_SCROLL,
      CLUTTER_STAGE_STATE,
      CLUTTER_DESTROY_NOTIFY,
      CLUTTER_CLIENT_MESSAGE,
      CLUTTER_DELETE,
      CLUTTER_TOUCH_BEGIN,
      CLUTTER_TOUCH_UPDATE,
      CLUTTER_TOUCH_END,
      CLUTTER_TOUCH_CANCEL,

      CLUTTER_EVENT_LAST            /* helper */
    } ClutterEventType;

Types of events.

`CLUTTER_NOTHING` | Empty event
`CLUTTER_KEY_PRESS` | Key press event
`CLUTTER_KEY_RELEASE` | Key release event
`CLUTTER_MOTION` | Pointer motion event
`CLUTTER_ENTER` | Actor enter event
`CLUTTER_LEAVE` | Actor leave event
`CLUTTER_BUTTON_PRESS` | Pointer button press event
`CLUTTER_BUTTON_RELEASE` | Pointer button release event
`CLUTTER_SCROLL` | Pointer scroll event
`CLUTTER_STAGE_STATE` | Stage state change event
`CLUTTER_DESTROY_NOTIFY` | Destroy notification event
`CLUTTER_CLIENT_MESSAGE` | Client message event
`CLUTTER_DELETE` | Stage delete event
`CLUTTER_TOUCH_BEGIN` | A new touch event sequence has started; event added in 1.10
`CLUTTER_TOUCH_UPDATE` | A touch event sequence has been updated; event added in 1.10
`CLUTTER_TOUCH_END` | A touch event sequence has finished; event added in 1.10
`CLUTTER_TOUCH_CANCEL` | A touch event sequence has been canceled; event added in 1.10
`CLUTTER_EVENT_LAST` | Marks the end of the ClutterEventType enumeration; added in 1.10

Since 0.4

### union ClutterEvent

Generic event wrapper.

Since 0.2

### enum ClutterEventFlags

    typedef enum {
     /*< flags prefix=CLUTTER_EVENT >*/
      CLUTTER_EVENT_NONE           = 0,
      CLUTTER_EVENT_FLAG_SYNTHETIC = 1 << 0
    } ClutterEventFlags;

Flags for the ClutterEvent

`CLUTTER_EVENT_NONE` | No flag set
`CLUTTER_EVENT_FLAG_SYNTHETIC` | Synthetic event

Since 0.6

### struct ClutterButtonEvent

    struct ClutterButtonEvent {
      ClutterEventType type;
      guint32 time;
      ClutterEventFlags flags;
      ClutterStage *stage;
      ClutterActor *source;

      gfloat x;
      gfloat y;
      ClutterModifierType modifier_state;
      guint32 button;
      guint click_count;
      gdouble *axes; /* Future use */
      ClutterInputDevice *device;
    };

Button event.

The event coordinates are relative to the stage that received the event, and can be transformed into actor-relative coordinates by using `clutter_actor_transform_stage_point()`.

ClutterEventType `type`; | event type
guint32 `time`; | event time
ClutterEventFlags `flags`; | event flags
ClutterStage *`stage`; | event source stage
ClutterActor *`source`; | event source actor
gfloat `x`; | event X coordinate, relative to the stage
gfloat `y`; | event Y coordinate, relative to the stage
ClutterModifierType `modifier_state`; | button modifiers
guint32 `button`; | event button
guint `click_count`; | number of button presses within the default time and radius
gdouble *`axes`; | reserved for future use
ClutterInputDevice *`device`; | the device that originated the event. If you want the physical device the event originated from, use `clutter_event_get_source_device()`

Since 0.2

### struct ClutterKeyEvent

    struct ClutterKeyEvent {
      ClutterEventType type;
      guint32 time;
      ClutterEventFlags flags;
      ClutterStage *stage;
      ClutterActor *source;

      ClutterModifierType modifier_state;
      guint keyval;
      guint16 hardware_keycode;
      gunichar unicode_value;
      ClutterInputDevice *device;
    };

Key event

ClutterEventType `type`; | event type
guint32 `time`; | event time
ClutterEventFlags `flags`; | event flags
ClutterStage *`stage`; | event source stage
ClutterActor *`source`; | event source actor
ClutterModifierType `modifier_state`; | key modifiers
guint `keyval`; | raw key value
guint16 `hardware_keycode`; | raw hardware key value
gunichar `unicode_value`; | Unicode representation
ClutterInputDevice *`device`; | the device that originated the event. If you want the physical device the event originated from, use `clutter_event_get_source_device()`

Since 0.2

### struct ClutterMotionEvent

    struct ClutterMotionEvent {
      ClutterEventType type;
      guint32 time;
      ClutterEventFlags flags;
      ClutterStage *stage;
      ClutterActor *source;

      gfloat x;
      gfloat y;
      ClutterModifierType modifier_state;
      gdouble *axes; /* Future use */
      ClutterInputDevice *device;
    };

Event for the pointer motion

ClutterEventType `type`; | event type
guint32 `time`; | event time
ClutterEventFlags `flags`; | event flags
ClutterStage *`stage`; | event source stage
ClutterActor *`source`; | event source actor
gfloat `x`; | event X coordinate
gfloat `y`; | event Y coordinate
ClutterModifierType `modifier_state`; | button modifiers
gdouble *`axes`; | reserved for future use
ClutterInputDevice *`device`; | the device that originated the event. If you want the physical device the event originated from, use `clutter_event_get_source_device()`

Since 0.2

### struct ClutterScrollEvent

    struct ClutterScrollEvent {
      ClutterEventType type;
      guint32 time;
      ClutterEventFlags flags;
      ClutterStage *stage;
      ClutterActor *source;

      gfloat x;
      gfloat y;
      ClutterScrollDirection direction;
      ClutterModifierType modifier_state;
      gdouble *axes; /* future use */
      ClutterInputDevice *device;
    };

Scroll wheel (or similar device) event

ClutterEventType `type`; | event type
guint32 `time`; | event time
ClutterEventFlags `flags`; | event flags
ClutterStage *`stage`; | event source stage
ClutterActor *`source`; | event source actor
gfloat `x`; | event X coordinate
gfloat `y`; | event Y coordinate
ClutterScrollDirection `direction`; | direction of the scrolling
ClutterModifierType `modifier_state`; | button modifiers
gdouble *`axes`; | reserved for future use
ClutterInputDevice *`device`; | the device that originated the event. If you want the physical device the event originated from, use `clutter_event_get_source_device()`

Since 0.2

### struct ClutterStageStateEvent

    struct ClutterStageStateEvent {
      ClutterEventType type;
      guint32 time;
      ClutterEventFlags flags;
      ClutterStage *stage;
      ClutterActor *source; /* XXX: should probably be the stage itself */

      ClutterStageState changed_mask;
      ClutterStageState new_state;
    };

Event signalling a change in the ClutterStage state.

ClutterEventType `type`; | event type
guint32 `time`; | event time
ClutterEventFlags `flags`; | event flags
ClutterStage *`stage`; | event source stage
ClutterActor *`source`; | event source actor (unused)
ClutterStageState `changed_mask`; | bitwise OR of the changed flags
ClutterStageState `new_state`; | bitwise OR of the current state flags

Since 0.2

### struct ClutterCrossingEvent

    struct ClutterCrossingEvent {
      ClutterEventType type;
      guint32 time;
      ClutterEventFlags flags;
      ClutterStage *stage;
      ClutterActor *source;

      gfloat x;
      gfloat y;
      ClutterInputDevice *device;
      ClutterActor *related;
    };

Event for the movement of the pointer across different actors

ClutterEventType `type`; | event type
guint32 `time`; | event time
ClutterEventFlags `flags`; | event flags
ClutterStage *`stage`; | event source stage
ClutterActor *`source`; | event source actor
gfloat `x`; | event X coordinate
gfloat `y`; | event Y coordinate
ClutterInputDevice *`device`; | the device that originated the event. If you want the physical device the event originated from, use `clutter_event_get_source_device()`
ClutterActor *`related`; | actor related to the crossing

Since 0.2

### struct ClutterTouchEvent

    struct ClutterTouchEvent {
      ClutterEventType type;
      guint32 time;
      ClutterEventFlags flags;
      ClutterStage *stage;
      ClutterActor *source;

      gfloat x;
      gfloat y;
      ClutterEventSequence *sequence;
      ClutterModifierType modifier_state;
      gdouble *axes; /* reserved */
      ClutterInputDevice *device;
    };

Used for touch events.

The `type` field will be one of `CLUTTER_TOUCH_BEGIN`, `CLUTTER_TOUCH_END`, `CLUTTER_TOUCH_UPDATE`, or `CLUTTER_TOUCH_CANCEL`.

Touch events are grouped into sequences; each touch sequence will begin with a `CLUTTER_TOUCH_BEGIN` event, progress with `CLUTTER_TOUCH_UPDATE` events, and end either with a `CLUTTER_TOUCH_END` event or with a `CLUTTER_TOUCH_CANCEL` event.

With multi-touch capable devices there can be multiple event sequence running at the same time.

ClutterEventType `type`; | event type
guint32 `time`; | event time
ClutterEventFlags `flags`; | event flags
ClutterStage *`stage`; | event source stage
ClutterActor *`source`; | event source actor (unused)
gfloat `x`; | the X coordinate of the pointer, relative to the stage
gfloat `y`; | the Y coordinate of the pointer, relative to the stage
ClutterEventSequence *`sequence`; | the event sequence that this event belongs to
ClutterModifierType `modifier_state`; | a bit-mask representing the state of modifier keys (e.g. Control, Shift, and Alt) and the pointer buttons. See ClutterModifierType. [type ClutterModifierType]
gdouble *`axes`; | reserved
ClutterInputDevice *`device`; | the device that originated the event. If you want the physical device the event originated from, use `clutter_event_get_source_device()`

Since 1.10

### ClutterEventSequence

    typedef struct _ClutterEventSequence ClutterEventSequence;

The ClutterEventSequence structure is an opaque type used to denote the event sequence of a touch event.

Since 1.12

### clutter_event_new ()

    ClutterEvent *      clutter_event_new                   (ClutterEventType type);

Creates a new ClutterEvent of the specified type.

`type` : | The type of event.
Returns : | A newly allocated ClutterEvent. [transfer full]

### clutter_event_copy ()

    ClutterEvent *      clutter_event_copy                  (const ClutterEvent *event);

Copies `event`.

`event` : | A ClutterEvent.
Returns : | A newly allocated ClutterEvent. [transfer full]

### clutter_event_free ()

    void                clutter_event_free                  (ClutterEvent *event);

Frees all resources used by `event`.

`event` : | A ClutterEvent.

### clutter_event_type ()

    ClutterEventType    clutter_event_type                  (const ClutterEvent *event);

Retrieves the type of the event.

`event` : | a ClutterEvent
Returns : | a ClutterEventType

### clutter_event_set_coords ()

    void                clutter_event_set_coords            (ClutterEvent *event,
                                                             gfloat x,
                                                             gfloat y);

Sets the coordinates of the `event`.

`event` : | a ClutterEvent
`x` : | the X coordinate of the event
`y` : | the Y coordinate of the event

Since 1.8

### clutter_event_get_coords ()

    void                clutter_event_get_coords            (const ClutterEvent *event,
                                                             gfloat *x,
                                                             gfloat *y);

Retrieves the coordinates of `event` and puts them into `x` and `y`.

`event` : | a ClutterEvent
`x` : | return location for the X coordinate, or `NULL`. [out]
`y` : | return location for the Y coordinate, or `NULL`. [out]

Since 0.4

### clutter_event_set_state ()

    void                clutter_event_set_state             (ClutterEvent *event,
                                                             ClutterModifierType state);

Sets the modifier state of the event.

`event` : | a ClutterEvent
`state` : | the modifier state to set

Since 1.8

### clutter_event_get_state ()

    ClutterModifierType clutter_event_get_state             (const ClutterEvent *event);

Retrieves the modifier state of the event. In case the window system supports reporting latched and locked modifiers, this function returns the effective state.

`event` : | a ClutterEvent
Returns : | the modifier state parameter, or 0

Since 0.4

### clutter_event_get_state_full ()

    void                clutter_event_get_state_full        (const ClutterEvent *event,
                                                             ClutterModifierType *button_state,
                                                             ClutterModifierType *base_state,
                                                             ClutterModifierType *latched_state,
                                                             ClutterModifierType *locked_state,
                                                             ClutterModifierType *effective_state);

Retrieves the decomposition of the keyboard state into button, base, latched, locked and effective. This can be used to transmit to other applications, for example when implementing a wayland compositor.

`event` : | a ClutterEvent
`button_state` : | the pressed buttons as a mask. [out][allow-none]
`base_state` : | the regular pressed modifier keys. [out][allow-none]
`latched_state` : | the latched modifier keys (currently released but still valid for one key press/release). [out][allow-none]
`locked_state` : | the locked modifier keys (valid until the lock key is pressed and released again). [out][allow-none]
`effective_state` : | the logical OR of all the state bits above. [out][allow-none]

Since 1.16

### clutter_event_set_time ()

    void                clutter_event_set_time              (ClutterEvent *event,
                                                             guint32 time_);

Sets the time of the event.

`event` : | a ClutterEvent
`time_` : | the time of the event

Since 1.8

### clutter_event_get_time ()

    guint32             clutter_event_get_time              (const ClutterEvent *event);

Retrieves the time of the event.

`event` : | a ClutterEvent
Returns : | the time of the event, or `CLUTTER_CURRENT_TIME`

Since 0.4

### clutter_event_set_source ()

    void                clutter_event_set_source            (ClutterEvent *event,
                                                             ClutterActor *actor);

Sets the source ClutterActor of `event`.

`event` : | a ClutterEvent
`actor` : | a ClutterActor, or `NULL`. [allow-none]

Since 1.8

### clutter_event_get_source ()

    ClutterActor *      clutter_event_get_source            (const ClutterEvent *event);

Retrieves the source ClutterActor the event originated from, or NULL if the event has no source.

`event` : | a ClutterEvent
Returns : | a ClutterActor. [transfer none]

Since 0.6

### clutter_event_set_stage ()

    void                clutter_event_set_stage             (ClutterEvent *event,
                                                             ClutterStage *stage);

Sets the source ClutterStage of the event.

`event` : | a ClutterEvent
`stage` : | a ClutterStage, or `NULL`. [allow-none]

Since 1.8

### clutter_event_get_stage ()

    ClutterStage *      clutter_event_get_stage             (const ClutterEvent *event);

Retrieves the source ClutterStage the event originated for, or `NULL` if the event has no stage.

`event` : | a ClutterEvent
Returns : | a ClutterStage. [transfer none]

Since 0.8

### clutter_event_set_flags ()

    void                clutter_event_set_flags             (ClutterEvent *event,
                                                             ClutterEventFlags flags);

Sets the ClutterEventFlags of `event`

`event` : | a ClutterEvent
`flags` : | a binary OR of ClutterEventFlags values

Since 1.8

### clutter_event_get_flags ()

    ClutterEventFlags   clutter_event_get_flags             (const ClutterEvent *event);

Retrieves the ClutterEventFlags of `event`

`event` : | a ClutterEvent
Returns : | the event flags

Since 1.0

### clutter_event_get_axes ()

    gdouble *           clutter_event_get_axes              (const ClutterEvent *event,
                                                             guint *n_axes);

Retrieves the array of axes values attached to the event.

`event` : | a ClutterEvent
`n_axes` : | return location for the number of axes returned. [out]
Returns : | an array of axis values. [transfer none]

Since 1.6

### clutter_event_get_event_sequence ()

    ClutterEventSequence * clutter_event_get_event_sequence (const ClutterEvent *event);

Retrieves the ClutterEventSequence of `event`.

`event` : | a ClutterEvent of type `CLUTTER_TOUCH_BEGIN`, `CLUTTER_TOUCH_UPDATE`, `CLUTTER_TOUCH_END`, or `CLUTTER_TOUCH_CANCEL`
Returns : | the event sequence, or `NULL`. [transfer none]

Since 1.10

### clutter_event_get_angle ()

    double              clutter_event_get_angle             (const ClutterEvent *source,
                                                             const ClutterEvent *target);

Retrieves the angle relative from `source` to `target`.

The direction of the angle is from the position X axis towards the positive Y axis.

`source` : | a ClutterEvent
`target` : | a ClutterEvent
Returns : | the angle between two ClutterEvent

Since 1.12

### clutter_event_get_distance ()

    float               clutter_event_get_distance          (const ClutterEvent *source,
                                                             const ClutterEvent *target);

Retrieves the distance between two events, a `source` and a `target`.

`source` : | a ClutterEvent
`target` : | a ClutterEvent
Returns : | the distance between two ClutterEvent

Since 1.12

### clutter_event_get_position ()

    void                clutter_event_get_position          (const ClutterEvent *event,
                                                             ClutterPoint *position);

Retrieves the event coordinates as a ClutterPoint.

`event` : | a ClutterEvent
`position` : | a ClutterPoint

Since 1.12

### clutter_event_has_control_modifier ()

    gboolean            clutter_event_has_control_modifier  (const ClutterEvent *event);

Checks whether `event` has the Control modifier mask set.

`event` : | a ClutterEvent
Returns : | `TRUE` if the event has the Control modifier mask set

Since 1.12

### clutter_event_has_shift_modifier ()

    gboolean            clutter_event_has_shift_modifier    (const ClutterEvent *event);

Checks whether `event` has the Shift modifier mask set.

`event` : | a ClutterEvent
Returns : | `TRUE` if the event has the Shift modifier mask set

Since 1.12

### clutter_event_is_pointer_emulated ()

    gboolean            clutter_event_is_pointer_emulated   (const ClutterEvent *event);

Checks whether a pointer `event` has been generated by the windowing system. The returned value can be used to distinguish between events synthesized by the windowing system itself (as opposed by Clutter).

`event` : | a ClutterEvent
Returns : | `TRUE` if the event is pointer emulated

Since 1.12

### clutter_event_get ()

    ClutterEvent *      clutter_event_get                   (void);

Pops an event off the event queue. Applications should not need to call this.

Returns : | A ClutterEvent or NULL if queue empty

Since 0.4

### clutter_event_peek ()

    ClutterEvent *      clutter_event_peek                  (void);

Returns a pointer to the first event from the event queue but does not remove it.

Returns : | A ClutterEvent or NULL if queue empty. [transfer none]

Since 0.4

### clutter_event_put ()

    void                clutter_event_put                   (const ClutterEvent *event);

Puts a copy of the event on the back of the event queue. The event will have the `CLUTTER_EVENT_FLAG_SYNTHETIC` flag set. If the source is set event signals will be emitted for this source and capture/bubbling for its ancestors. If the source is not set it will be generated by picking or use the actor that currently has keyboard focus

`event` : | a ClutterEvent

Since 0.6

### clutter_events_pending ()

    gboolean            clutter_events_pending              (void);

Checks if events are pending in the event queue.

Returns : | TRUE if there are pending events, FALSE otherwise.

Since 0.4

### CLUTTER_BUTTON_PRIMARY

    #define CLUTTER_BUTTON_PRIMARY          (1)

The primary button of a pointer device.

This is typically the left mouse button in a right-handed mouse configuration.

Since 1.10

### CLUTTER_BUTTON_MIDDLE

    #define CLUTTER_BUTTON_MIDDLE           (2)

The middle button of a pointer device.

Since 1.10

### CLUTTER_BUTTON_SECONDARY

    #define CLUTTER_BUTTON_SECONDARY        (3)

The secondary button of a pointer device.

This is typically the right mouse button in a right-handed mouse configuration.

Since 1.10

### clutter_event_set_button ()

    void                clutter_event_set_button            (ClutterEvent *event,
                                                             guint32 button);

Sets the button number of `event`

`event` : | a ClutterEvent or type `CLUTTER_BUTTON_PRESS` or of type `CLUTTER_BUTTON_RELEASE`
`button` : | the button number

Since 1.8

### clutter_event_get_button ()

    guint32             clutter_event_get_button            (const ClutterEvent *event);

Retrieves the button number of `event`

`event` : | a ClutterEvent of type `CLUTTER_BUTTON_PRESS` or of type `CLUTTER_BUTTON_RELEASE`
Returns : | the button number

Since 1.0

### clutter_event_get_click_count ()

    guint               clutter_event_get_click_count       (const ClutterEvent *event);

Retrieves the number of clicks of `event`

`event` : | a ClutterEvent of type `CLUTTER_BUTTON_PRESS` or of type `CLUTTER_BUTTON_RELEASE`
Returns : | the click count

Since 1.0

### clutter_event_set_key_symbol ()

    void                clutter_event_set_key_symbol        (ClutterEvent *event,
                                                             guint key_sym);

Sets the key symbol of `event`.

`event` : | a ClutterEvent of type `CLUTTER_KEY_PRESS` or `CLUTTER_KEY_RELEASE`
`key_sym` : | the key symbol representing the key

Since 1.8

### clutter_event_get_key_symbol ()

    guint               clutter_event_get_key_symbol        (const ClutterEvent *event);

Retrieves the key symbol of `event`

`event` : | a ClutterEvent of type `CLUTTER_KEY_PRESS` or of type `CLUTTER_KEY_RELEASE`
Returns : | the key symbol representing the key

Since 1.0

### clutter_event_set_key_code ()

    void                clutter_event_set_key_code          (ClutterEvent *event,
                                                             guint16 key_code);

Sets the keycode of the `event`.

`event` : | a ClutterEvent of type `CLUTTER_KEY_PRESS` or `CLUTTER_KEY_RELEASE`
`key_code` : | the keycode representing the key

Since 1.8

### clutter_event_get_key_code ()

    guint16             clutter_event_get_key_code          (const ClutterEvent *event);

Retrieves the keycode of the key that caused `event`

`event` : | a ClutterEvent of type `CLUTTER_KEY_PRESS` or of type `CLUTTER_KEY_RELEASE`
Returns : | The keycode representing the key

Since 1.0

### clutter_event_set_key_unicode ()

    void                clutter_event_set_key_unicode       (ClutterEvent *event,
                                                             gunichar key_unicode);

Sets the Unicode value of `event`.

`event` : | a ClutterEvent of type `CLUTTER_KEY_PRESS` or `CLUTTER_KEY_RELEASE`
`key_unicode` : | the Unicode value representing the key

Since 1.8

### clutter_event_get_key_unicode ()

    gunichar            clutter_event_get_key_unicode       (const ClutterEvent *event);

Retrieves the unicode value for the key that caused `keyev`.

`event` : | a ClutterEvent of type `CLUTTER_KEY_PRESS` or `CLUTTER_KEY_RELEASE`
Returns : | The unicode value representing the key

### clutter_keysym_to_unicode ()

    guint32             clutter_keysym_to_unicode           (guint keyval);

Converts `keyval` from a Clutter key symbol to the corresponding ISO10646 (Unicode) character.

`keyval` : | a key symbol
Returns : | a Unicode character, or 0 if there is no corresponding character.

### clutter_unicode_to_keysym ()

    guint               clutter_unicode_to_keysym           (guint32 wc);

Convert from a ISO10646 character to a key symbol.

`wc` : | a ISO10646 encoded character
Returns : | the corresponding Clutter key symbol, if one exists. or, if there is no corresponding symbol, wc | 0x01000000

Since 1.10

### clutter_event_set_related ()

    void                clutter_event_set_related           (ClutterEvent *event,
                                                             ClutterActor *actor);

Sets the related actor of a crossing event

`event` : | a ClutterEvent of type `CLUTTER_ENTER` or `CLUTTER_LEAVE`
`actor` : | a ClutterActor or `NULL`. [allow-none]

Since 1.8

### clutter_event_get_related ()

    ClutterActor *      clutter_event_get_related           (const ClutterEvent *event);

Retrieves the related actor of a crossing event.

`event` : | a ClutterEvent of type `CLUTTER_ENTER` or of type `CLUTTER_LEAVE`
Returns : | the related ClutterActor, or `NULL`. [transfer none]

Since 1.0

### clutter_event_set_scroll_direction ()

    void                clutter_event_set_scroll_direction  (ClutterEvent *event,
                                                             ClutterScrollDirection direction);

Sets the direction of the scrolling of `event`

`event` : | a ClutterEvent
`direction` : | the scrolling direction

Since 1.8

### clutter_event_get_scroll_direction ()

    ClutterScrollDirection clutter_event_get_scroll_direction
                                                            (const ClutterEvent *event);

Retrieves the direction of the scrolling of `event`

`event` : | a ClutterEvent of type `CLUTTER_SCROLL`
Returns : | the scrolling direction

Since 1.0

### clutter_event_get_scroll_delta ()

    void                clutter_event_get_scroll_delta      (const ClutterEvent *event,
                                                             gdouble *dx,
                                                             gdouble *dy);

Retrieves the precise scrolling information of `event`.

The `event` has to have a ClutterScrollEvent.direction value of `CLUTTER_SCROLL_SMOOTH`.

`event` : | a ClutterEvent of type `CLUTTER_SCROLL`
`dx` : | return location for the delta on the horizontal axis. [out]
`dy` : | return location for the delta on the vertical axis. [out]

Since 1.10

### clutter_event_set_scroll_delta ()

    void                clutter_event_set_scroll_delta      (ClutterEvent *event,
                                                             gdouble dx,
                                                             gdouble dy);

Sets the precise scrolling information of `event`.

`event` : | a ClutterEvent of type `CLUTTER_SCROLL`
`dx` : | delta on the horizontal axis
`dy` : | delta on the vertical axis

Since 1.10

### clutter_event_set_device ()

    void                clutter_event_set_device            (ClutterEvent *event,
                                                             ClutterInputDevice *device);

Sets the device for `event`.

`event` : | a ClutterEvent
`device` : | a ClutterInputDevice, or `NULL`. [allow-none]

Since 1.6

### clutter_event_get_device ()

    ClutterInputDevice * clutter_event_get_device           (const ClutterEvent *event);

Retrieves the ClutterInputDevice for the event. If you want the physical device the event originated from, use `clutter_event_get_source_device()`.

The ClutterInputDevice structure is completely opaque and should be cast to the platform-specific implementation.

`event` : | a ClutterEvent
Returns : | the ClutterInputDevice or `NULL`. The returned device is owned by the ClutterEvent and it should not be unreferenced. [transfer none]

Since 1.0

### clutter_event_set_source_device ()

    void                clutter_event_set_source_device     (ClutterEvent *event,
                                                             ClutterInputDevice *device);

Sets the source ClutterInputDevice for `event`.

The ClutterEvent must have been created using `clutter_event_new()`.

`event` : | a ClutterEvent
`device` : | a ClutterInputDevice. [allow-none]

Since 1.8

### clutter_event_get_source_device ()

    ClutterInputDevice * clutter_event_get_source_device    (const ClutterEvent *event);

Retrieves the hardware device that originated the event.

If you need the virtual device, use `clutter_event_get_device()`.

If no hardware device originated this event, this function will return the same device as `clutter_event_get_device()`.

`event` : | a ClutterEvent
Returns : | a pointer to a ClutterInputDevice or `NULL`. [transfer none]

Since 1.6

### clutter_event_get_device_id ()

    gint                clutter_event_get_device_id         (const ClutterEvent *event);

Retrieves the events device id if set.

`event` : | a clutter event
Returns : | A unique identifier for the device or -1 if the event has no specific device set.

### clutter_event_get_device_type ()

    ClutterInputDeviceType clutter_event_get_device_type    (const ClutterEvent *event);

Retrieves the type of the device for `event`

`event` : | a ClutterEvent
Returns : | the ClutterInputDeviceType for the device, if any is set

Since 1.0

### clutter_get_current_event_time ()

    guint32             clutter_get_current_event_time      (void);

Retrieves the timestamp of the last event, if there is an event or if the event has a timestamp.

Returns : | the event timestamp, or `CLUTTER_CURRENT_TIME`

Since 1.0

### clutter_get_current_event ()

    const ClutterEvent * clutter_get_current_event          (void);

If an event is currently being processed, return that event. This function is intended to be used to access event state that might not be exposed by higher-level widgets. For example, to get the key modifier state from a Button 'clicked' event.

Returns : | The current ClutterEvent, or `NULL` if none. [transfer none]

Since 1.2