libei.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
/*
 * Copyright © 2020 Red Hat, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>



struct ei;

struct ei_device;

struct ei_seat;

struct ei_event;

struct ei_keymap;

struct ei_region;

struct ei_touch;

struct ei_ping;

enum ei_device_type { EI_DEVICE_TYPE_VIRTUAL = 1, EI_DEVICE_TYPE_PHYSICAL };

enum ei_device_capability {
        EI_DEVICE_CAP_POINTER = (1 << 0),
        EI_DEVICE_CAP_POINTER_ABSOLUTE = (1 << 1),
        EI_DEVICE_CAP_KEYBOARD = (1 << 2),
        EI_DEVICE_CAP_TOUCH = (1 << 3),
        EI_DEVICE_CAP_SCROLL = (1 << 4),
        EI_DEVICE_CAP_BUTTON = (1 << 5),
        EI_DEVICE_CAP_TEXT = (1 << 6),
        EI_DEVICE_CAP_GESTURES = (1 << 7),
        EI_DEVICE_CAP_STYLUS = (1 << 8),
};

enum ei_stylus_capability {
        EI_STYLUS_CAP_ERASE = (1 << 0),
        EI_STYLUS_CAP_PRESSURE = (1 << 1),
        EI_STYLUS_CAP_DISTANCE = (1 << 2),
        EI_STYLUS_CAP_TILT = (1 << 3),
        EI_STYLUS_CAP_ROTATION = (1 << 4),
        EI_STYLUS_CAP_AIRBRUSH_FLOW = (1 << 5),
};

enum ei_keymap_type {
        EI_KEYMAP_TYPE_XKB = 1,
};

enum ei_event_type {
        EI_EVENT_CONNECT = 1,

        EI_EVENT_DISCONNECT,

        EI_EVENT_SEAT_ADDED,

        EI_EVENT_SEAT_REMOVED,

        EI_EVENT_DEVICE_ADDED,

        EI_EVENT_DEVICE_REMOVED,

        EI_EVENT_DEVICE_PAUSED,

        EI_EVENT_DEVICE_RESUMED,

        EI_EVENT_KEYBOARD_MODIFIERS,

        EI_EVENT_PONG = 90,

        EI_EVENT_SYNC,

        EI_EVENT_FRAME = 100,

        EI_EVENT_DEVICE_START_EMULATING = 200,
        EI_EVENT_DEVICE_STOP_EMULATING,

        EI_EVENT_POINTER_MOTION = 300,

        EI_EVENT_POINTER_MOTION_ABSOLUTE = 400,

        EI_EVENT_BUTTON_BUTTON = 500,

        EI_EVENT_SCROLL_DELTA = 600,
        EI_EVENT_SCROLL_STOP,
        EI_EVENT_SCROLL_CANCEL,
        EI_EVENT_SCROLL_DISCRETE,

        EI_EVENT_KEYBOARD_KEY = 700,

        EI_EVENT_TOUCH_DOWN = 800,
        EI_EVENT_TOUCH_UP,
        EI_EVENT_TOUCH_MOTION,

        EI_EVENT_TEXT_KEYSYM = 900,

        EI_EVENT_TEXT_UTF8,

        EI_EVENT_SWIPE_BEGIN = 1000,
        EI_EVENT_SWIPE_UPDATE,
        EI_EVENT_SWIPE_END,
        EI_EVENT_SWIPE_ABORTED,

        EI_EVENT_PINCH_BEGIN = 1010,
        EI_EVENT_PINCH_UPDATE,
        EI_EVENT_PINCH_END,
        EI_EVENT_PINCH_ABORTED,

        EI_EVENT_HOLD_BEGIN = 1020,
        EI_EVENT_HOLD_END,
        EI_EVENT_HOLD_ABORTED,

        EI_EVENT_STYLUS_PROXIMITY_IN = 1101,
        EI_EVENT_STYLUS_PROXIMITY_OUT,
        EI_EVENT_STYLUS_ERASE_START,
        EI_EVENT_STYLUS_ERASE_STOP,
        EI_EVENT_STYLUS_TIP_DOWN,
        EI_EVENT_STYLUS_TIP_UP,
        EI_EVENT_STYLUS_AXIS,
};

const char *ei_event_type_to_string(enum ei_event_type);

struct ei *
ei_new(void *user_data);

struct ei *
ei_new_sender(void *user_data);

struct ei *
ei_new_receiver(void *user_data);

struct ei *
ei_ref(struct ei *ei);

struct ei *
ei_unref(struct ei *ei);

void
ei_set_user_data(struct ei *ei, void *user_data);

void *
ei_get_user_data(struct ei *ei);

bool
ei_is_sender(struct ei *ei);

enum ei_log_priority {
        EI_LOG_PRIORITY_DEBUG = 10,
        EI_LOG_PRIORITY_INFO = 20,
        EI_LOG_PRIORITY_WARNING = 30,
        EI_LOG_PRIORITY_ERROR = 40,
};
 
struct ei_log_context;

unsigned int
ei_log_context_get_line(struct ei_log_context *ctx);

const char *
ei_log_context_get_file(struct ei_log_context *ctx);

const char *
ei_log_context_get_func(struct ei_log_context *ctx);

typedef void (*ei_log_handler)(struct ei *ei,
                               enum ei_log_priority priority,
                               const char *message,
                               struct ei_log_context *context);
void
ei_log_set_handler(struct ei *ei, ei_log_handler log_handler);

void
ei_log_set_priority(struct ei *ei, enum ei_log_priority priority);

enum ei_log_priority
ei_log_get_priority(const struct ei *ei);

typedef uint64_t (*ei_clock_now_func)(struct ei *ei);

void
ei_clock_set_now_func(struct ei *, ei_clock_now_func func);

void
ei_configure_name(struct ei *ei, const char *name);

int
ei_setup_backend_fd(struct ei *ei, int fd);

int
ei_setup_backend_socket(struct ei *ei, const char *socketpath);

int
ei_get_fd(struct ei *ei);

struct ei_ping *
ei_new_ping(struct ei *ei);

uint64_t
ei_ping_get_id(struct ei_ping *ping);

struct ei_ping *
ei_ping_ref(struct ei_ping *ei_ping);

struct ei_ping *
ei_ping_unref(struct ei_ping *ei_ping);

void
ei_ping_set_user_data(struct ei_ping *ei_ping, void *user_data);

void *
ei_ping_get_user_data(struct ei_ping *ei_ping);

void
ei_ping(struct ei_ping *ping);

void
ei_dispatch(struct ei *ei);

struct ei_event *
ei_get_event(struct ei *ei);

struct ei_event *
ei_peek_event(struct ei *ei);

uint64_t
ei_now(struct ei *ei);

void
ei_disconnect(struct ei *ei);

void
ei_seat_set_user_data(struct ei_seat *seat, void *user_data);

void *
ei_seat_get_user_data(struct ei_seat *seat);

const char *
ei_seat_get_name(struct ei_seat *seat);

bool
ei_seat_has_capability(struct ei_seat *seat, enum ei_device_capability cap);

void
ei_seat_bind_capabilities(struct ei_seat *seat, ...) __attribute__((sentinel));

void
ei_seat_unbind_capabilities(struct ei_seat *seat, ...) __attribute__((sentinel));

void
ei_seat_request_device_with_capabilities(struct ei_seat *seat, ...) __attribute__((sentinel));

struct ei_seat *
ei_seat_ref(struct ei_seat *seat);

struct ei_seat *
ei_seat_unref(struct ei_seat *seat);

struct ei *
ei_seat_get_context(struct ei_seat *seat);

struct ei_event *
ei_event_ref(struct ei_event *event);

struct ei_event *
ei_event_unref(struct ei_event *event);

enum ei_event_type
ei_event_get_type(struct ei_event *event);

struct ei_device *
ei_event_get_device(struct ei_event *event);

uint64_t
ei_event_get_time(struct ei_event *event);

struct ei_device *
ei_device_ref(struct ei_device *device);

struct ei_device *
ei_device_unref(struct ei_device *device);

struct ei_seat *
ei_device_get_seat(struct ei_device *device);

void
ei_device_set_user_data(struct ei_device *device, void *user_data);

void *
ei_device_get_user_data(struct ei_device *device);

uint32_t
ei_device_get_width(struct ei_device *device);

uint32_t
ei_device_get_height(struct ei_device *device);

size_t
ei_keymap_get_size(struct ei_keymap *keymap);

enum ei_keymap_type
ei_keymap_get_type(struct ei_keymap *keymap);

int
ei_keymap_get_fd(struct ei_keymap *keymap);

struct ei_device *
ei_keymap_get_device(struct ei_keymap *keymap);

struct ei_keymap *
ei_keymap_ref(struct ei_keymap *keymap);

struct ei_keymap *
ei_keymap_unref(struct ei_keymap *keymap);

void
ei_keymap_set_user_data(struct ei_keymap *keymap, void *user_data);

void *
ei_keymap_get_user_data(struct ei_keymap *keymap);

void
ei_device_close(struct ei_device *device);

const char *
ei_device_get_name(struct ei_device *device);

enum ei_device_type
ei_device_get_type(struct ei_device *device);

bool
ei_device_has_capability(struct ei_device *device, enum ei_device_capability cap);

struct ei_region *
ei_device_get_region(struct ei_device *device, size_t index);

struct ei_region *
ei_device_get_region_at(struct ei_device *device, double x, double y);

struct ei_region *
ei_region_ref(struct ei_region *region);

struct ei_region *
ei_region_unref(struct ei_region *region);

void
ei_region_set_user_data(struct ei_region *region, void *user_data);

void *
ei_region_get_user_data(struct ei_region *region);

uint32_t
ei_region_get_x(struct ei_region *region);

uint32_t
ei_region_get_y(struct ei_region *region);

uint32_t
ei_region_get_width(struct ei_region *region);

uint32_t
ei_region_get_height(struct ei_region *region);

const char *
ei_region_get_mapping_id(struct ei_region *region);

bool
ei_region_contains(struct ei_region *region, double x, double y);

bool
ei_region_convert_point(struct ei_region *region, double *x, double *y);

double
ei_region_get_physical_scale(struct ei_region *region);

/* FIXME: the current API makes it impossible to know when the keymap has
 * been consumed so the file stays open forever.
 */
struct ei_keymap *
ei_device_keyboard_get_keymap(struct ei_device *device);

struct ei_device *
ei_keymap_get_context(struct ei_keymap *keymap);

struct ei *
ei_device_get_context(struct ei_device *device);

void
ei_device_start_emulating(struct ei_device *device, uint32_t sequence);

void
ei_device_stop_emulating(struct ei_device *device);

void
ei_device_frame(struct ei_device *device, uint64_t time);

void
ei_device_pointer_motion(struct ei_device *device, double x, double y);

void
ei_device_pointer_motion_absolute(struct ei_device *device, double x, double y);

void
ei_device_button_button(struct ei_device *device, uint32_t button, bool is_press);

void
ei_device_scroll_delta(struct ei_device *device, double x, double y);

void
ei_device_scroll_discrete(struct ei_device *device, int32_t x, int32_t y);

void
ei_device_scroll_stop(struct ei_device *device, bool stop_x, bool stop_y);

void
ei_device_scroll_cancel(struct ei_device *device, bool cancel_x, bool cancel_y);

void
ei_device_keyboard_key(struct ei_device *device, uint32_t keycode, bool is_press);

void
ei_device_text_keysym(struct ei_device *device, uint32_t keysym, bool is_press);

void
ei_device_text_utf8(struct ei_device *device, const char *utf8);

void
ei_device_text_utf8_with_length(struct ei_device *device, const char *text, size_t length);

struct ei_touch *
ei_device_touch_new(struct ei_device *device);

void
ei_touch_down(struct ei_touch *touch, double x, double y);

void
ei_touch_motion(struct ei_touch *touch, double x, double y);

void
ei_touch_up(struct ei_touch *touch);

void
ei_touch_cancel(struct ei_touch *touch);

struct ei_touch *
ei_touch_ref(struct ei_touch *touch);

struct ei_touch *
ei_touch_unref(struct ei_touch *touch);

void
ei_touch_set_user_data(struct ei_touch *touch, void *user_data);

void *
ei_touch_get_user_data(struct ei_touch *touch);

struct ei_device *
ei_touch_get_device(struct ei_touch *touch);

void
ei_device_swipe_begin(struct ei_device *device, uint32_t nfingers);

void
ei_device_swipe_update(struct ei_device *device, double dx, double dy);

void
ei_device_swipe_end(struct ei_device *device);

void
ei_device_swipe_cancel(struct ei_device *device);

void
ei_device_pinch_begin(struct ei_device *device, uint32_t nfingers);

void
ei_device_pinch_update(struct ei_device *device,
                       double dx,
                       double dy,
                       double scale,
                       double rotation);

void
ei_device_pinch_end(struct ei_device *device);

void
ei_device_pinch_cancel(struct ei_device *device);

void
ei_device_hold_begin(struct ei_device *device, uint32_t nfingers);

void
ei_device_hold_end(struct ei_device *device);

void
ei_device_hold_cancel(struct ei_device *device);

void
ei_event_device_bind_stylus_capability(struct ei_event *event,
                                       enum ei_stylus_capability capability);

void
ei_device_stylus_proximity_in(struct ei_device *device);

void
ei_device_stylus_proximity_out(struct ei_device *device);

void
ei_device_stylus_erase_start(struct ei_device *device);

void
ei_device_stylus_erase_stop(struct ei_device *device);

void
ei_device_stylus_tip_down(struct ei_device *device);

void
ei_device_stylus_tip_up(struct ei_device *device);

void
ei_device_stylus_motion(struct ei_device *device, double x, double y);

void
ei_device_stylus_pressure(struct ei_device *device, double pressure);

void
ei_device_stylus_distance(struct ei_device *device, double distance);

void
ei_device_stylus_tilt(struct ei_device *device, double tilt_x, double tilt_y);

void
ei_device_stylus_rotation(struct ei_device *device, double rotation);

void
ei_device_stylus_airbrush_flow(struct ei_device *device, double flow);

struct ei_seat *
ei_event_get_seat(struct ei_event *event);

struct ei_ping *
ei_event_pong_get_ping(struct ei_event *event);

uint32_t
ei_event_emulating_get_sequence(struct ei_event *event);

uint32_t
ei_event_keyboard_get_xkb_mods_depressed(struct ei_event *event);

uint32_t
ei_event_keyboard_get_xkb_mods_latched(struct ei_event *event);

uint32_t
ei_event_keyboard_get_xkb_mods_locked(struct ei_event *event);

uint32_t
ei_event_keyboard_get_xkb_group(struct ei_event *event);

double
ei_event_pointer_get_dx(struct ei_event *event);

double
ei_event_pointer_get_dy(struct ei_event *event);

double
ei_event_pointer_get_absolute_x(struct ei_event *event);

double
ei_event_pointer_get_absolute_y(struct ei_event *event);

uint32_t
ei_event_button_get_button(struct ei_event *event);

bool
ei_event_button_get_is_press(struct ei_event *event);

double
ei_event_scroll_get_dx(struct ei_event *event);

double
ei_event_scroll_get_dy(struct ei_event *event);

bool
ei_event_scroll_get_stop_x(struct ei_event *event);

bool
ei_event_scroll_get_stop_y(struct ei_event *event);

int32_t
ei_event_scroll_get_discrete_dx(struct ei_event *event);

int32_t
ei_event_scroll_get_discrete_dy(struct ei_event *event);

uint32_t
ei_event_keyboard_get_key(struct ei_event *event);

bool
ei_event_keyboard_get_key_is_press(struct ei_event *event);

uint32_t
ei_event_touch_get_id(struct ei_event *event);

double
ei_event_touch_get_x(struct ei_event *event);

double
ei_event_touch_get_y(struct ei_event *event);

bool
ei_event_touch_get_is_cancel(struct ei_event *event);

uint32_t
ei_event_swipe_get_finger_count(struct ei_event *event);

double
ei_event_swipe_get_dx(struct ei_event *event);

double
ei_event_swipe_get_dy(struct ei_event *event);

bool
ei_event_swipe_get_is_cancelled(struct ei_event *event);

uint32_t
ei_event_pinch_get_finger_count(struct ei_event *event);

double
ei_event_pinch_get_dx(struct ei_event *event);

double
ei_event_pinch_get_dy(struct ei_event *event);

double
ei_event_pinch_get_rotation(struct ei_event *event);

double
ei_event_pinch_get_scale(struct ei_event *event);

bool
ei_event_pinch_get_is_cancelled(struct ei_event *event);

uint32_t
ei_event_hold_get_finger_count(struct ei_event *event);

bool
ei_event_hold_get_is_cancelled(struct ei_event *event);

uint32_t
ei_event_text_get_keysym(struct ei_event *event);

bool
ei_event_text_get_keysym_is_press(struct ei_event *event);

const char *
ei_event_text_get_utf8(struct ei_event *event);

bool
ei_event_device_has_stylus_capability(struct ei_event *event, enum ei_stylus_capability capability);

double
ei_event_stylus_get_x(struct ei_event *event);

double
ei_event_stylus_get_y(struct ei_event *event);

double
ei_event_stylus_get_pressure(struct ei_event *event);

double
ei_event_stylus_get_distance(struct ei_event *event);

double
ei_event_stylus_get_tilt_x(struct ei_event *event);

double
ei_event_stylus_get_tilt_y(struct ei_event *event);

double
ei_event_stylus_get_rotation(struct ei_event *event);

double
ei_event_stylus_get_airbrush_flow(struct ei_event *event);

 
#ifdef __cplusplus
}
#endif