libeis.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>
#include <sys/types.h>



struct eis;
struct eis_client;
struct eis_device;
struct eis_seat;
struct eis_event;
struct eis_keymap;
struct eis_touch;
struct eis_ping;

struct eis_region;

enum eis_device_type { EIS_DEVICE_TYPE_VIRTUAL = 1, EIS_DEVICE_TYPE_PHYSICAL };

enum eis_device_capability {
        EIS_DEVICE_CAP_POINTER = (1 << 0),
        EIS_DEVICE_CAP_POINTER_ABSOLUTE = (1 << 1),
        EIS_DEVICE_CAP_KEYBOARD = (1 << 2),
        EIS_DEVICE_CAP_TOUCH = (1 << 3),
        EIS_DEVICE_CAP_SCROLL = (1 << 4),
        EIS_DEVICE_CAP_BUTTON = (1 << 5),
        EIS_DEVICE_CAP_TEXT = (1 << 6),
        EIS_DEVICE_CAP_GESTURES = (1 << 7),
        EIS_DEVICE_CAP_STYLUS = (1 << 8),
};

enum eis_stylus_capability {
        EIS_STYLUS_CAP_ERASE = (1 << 0),
        EIS_STYLUS_CAP_PRESSURE = (1 << 1),
        EIS_STYLUS_CAP_DISTANCE = (1 << 2),
        EIS_STYLUS_CAP_TILT = (1 << 3),
        EIS_STYLUS_CAP_ROTATION = (1 << 4),
        EIS_STYLUS_CAP_AIRBRUSH_FLOW = (1 << 5),
};

enum eis_keymap_type {
        EIS_KEYMAP_TYPE_XKB = 1,
};

enum eis_event_type {
        EIS_EVENT_CLIENT_CONNECT = 1,
        EIS_EVENT_CLIENT_DISCONNECT,

        EIS_EVENT_SEAT_BIND,

        EIS_EVENT_DEVICE_CLOSED,

        EIS_EVENT_DEVICE_READY,

        EIS_EVENT_SEAT_DEVICE_REQUESTED,

        EIS_EVENT_PONG = 90,

        EIS_EVENT_SYNC,

        EIS_EVENT_FRAME = 100,

        EIS_EVENT_DEVICE_START_EMULATING = 200,
        EIS_EVENT_DEVICE_STOP_EMULATING,
 
        /* These events are only generated on a receiving EIS context */

        EIS_EVENT_POINTER_MOTION = 300,
        EIS_EVENT_POINTER_MOTION_ABSOLUTE = 400,
        EIS_EVENT_BUTTON_BUTTON = 500,
        EIS_EVENT_SCROLL_DELTA = 600,
        EIS_EVENT_SCROLL_STOP,
        EIS_EVENT_SCROLL_CANCEL,
        EIS_EVENT_SCROLL_DISCRETE,

        EIS_EVENT_KEYBOARD_KEY = 700,

        EIS_EVENT_TOUCH_DOWN = 800,
        EIS_EVENT_TOUCH_UP,
        EIS_EVENT_TOUCH_MOTION,

        EIS_EVENT_TEXT_KEYSYM = 900,

        EIS_EVENT_TEXT_UTF8,

        EIS_EVENT_SWIPE_BEGIN = 1000,
        EIS_EVENT_SWIPE_UPDATE,
        EIS_EVENT_SWIPE_END,

        EIS_EVENT_PINCH_BEGIN = 1010,
        EIS_EVENT_PINCH_UPDATE,
        EIS_EVENT_PINCH_END,

        EIS_EVENT_HOLD_BEGIN = 1020,
        EIS_EVENT_HOLD_END,

        EIS_EVENT_STYLUS_BIND_CAPABILITIES = 1100,
        EIS_EVENT_STYLUS_PROXIMITY_IN,
        EIS_EVENT_STYLUS_PROXIMITY_OUT,
        EIS_EVENT_STYLUS_ERASE_START,
        EIS_EVENT_STYLUS_ERASE_STOP,
        EIS_EVENT_STYLUS_TIP_DOWN,
        EIS_EVENT_STYLUS_TIP_UP,
        EIS_EVENT_STYLUS_AXIS,
};

const char *eis_event_type_to_string(enum eis_event_type);

struct eis *
eis_new(void *user_data);

enum eis_flag {
        EIS_FLAG_DEVICE_READY = 1,
};

int
eis_set_flag(struct eis *eis, enum eis_flag flag);

enum eis_log_priority {
        EIS_LOG_PRIORITY_DEBUG = 10,
        EIS_LOG_PRIORITY_INFO = 20,
        EIS_LOG_PRIORITY_WARNING = 30,
        EIS_LOG_PRIORITY_ERROR = 40,
};

struct eis_log_context;

unsigned int
eis_log_context_get_line(struct eis_log_context *ctx);

const char *
eis_log_context_get_file(struct eis_log_context *ctx);

const char *
eis_log_context_get_func(struct eis_log_context *ctx);

typedef void (*eis_log_handler)(struct eis *eis,
                                enum eis_log_priority priority,
                                const char *message,
                                struct eis_log_context *ctx);
void
eis_log_set_handler(struct eis *eis, eis_log_handler log_handler);

void
eis_log_set_priority(struct eis *eis, enum eis_log_priority priority);

enum eis_log_priority
eis_log_get_priority(const struct eis *eis);

typedef uint64_t (*eis_clock_now_func)(struct eis *eis);

void
eis_clock_set_now_func(struct eis *, eis_clock_now_func func);
 
struct eis *
eis_ref(struct eis *eis);
 
struct eis *
eis_unref(struct eis *eis);
 
void *
eis_get_user_data(struct eis *eis);
 
void
eis_set_user_data(struct eis *eis, void *user_data);

int
eis_setup_backend_fd(struct eis *ctx);

int
eis_backend_fd_add_client(struct eis *ctx);

int
eis_setup_backend_socket(struct eis *ctx, const char *path);

pid_t
eis_backend_socket_get_client_pid(struct eis_client *client);

int
eis_get_fd(struct eis *eis);

void
eis_dispatch(struct eis *eis);

uint64_t
eis_ping_get_id(struct eis_ping *ping);

struct eis_ping *
eis_ping_ref(struct eis_ping *eis_ping);

struct eis_ping *
eis_ping_unref(struct eis_ping *eis_ping);

void
eis_ping_set_user_data(struct eis_ping *eis_ping, void *user_data);

void *
eis_ping_get_user_data(struct eis_ping *eis_ping);

void
eis_ping(struct eis_ping *ping);

struct eis_event *
eis_get_event(struct eis *eis);

struct eis_event *
eis_peek_event(struct eis *eis);

struct eis_event *
eis_event_ref(struct eis_event *event);

struct eis_event *
eis_event_unref(struct eis_event *event);
 
enum eis_event_type
eis_event_get_type(struct eis_event *event);
 
struct eis_client *
eis_event_get_client(struct eis_event *event);
 
struct eis_seat *
eis_event_get_seat(struct eis_event *event);

struct eis_ping *
eis_event_pong_get_ping(struct eis_event *event);

bool
eis_event_seat_has_capability(struct eis_event *event, enum eis_device_capability cap);

struct eis_device *
eis_event_get_device(struct eis_event *event);

uint64_t
eis_event_get_time(struct eis_event *event);

struct eis_ping *
eis_client_new_ping(struct eis_client *client);
 
struct eis_client *
eis_client_ref(struct eis_client *client);
 
struct eis_client *
eis_client_unref(struct eis_client *client);
 
void *
eis_client_get_user_data(struct eis_client *eis_client);
 
void
eis_client_set_user_data(struct eis_client *eis_client, void *user_data);
 
struct eis *
eis_client_get_context(struct eis_client *client);

bool
eis_client_is_sender(struct eis_client *client);

const char *
eis_client_get_name(struct eis_client *client);

void
eis_client_connect(struct eis_client *client);

void
eis_client_disconnect(struct eis_client *client);

struct eis_seat *
eis_client_new_seat(struct eis_client *client, const char *name);

struct eis_seat *
eis_seat_ref(struct eis_seat *seat);

struct eis_seat *
eis_seat_unref(struct eis_seat *seat);

struct eis_client *
eis_seat_get_client(struct eis_seat *eis_seat);

const char *
eis_seat_get_name(struct eis_seat *eis_seat);

void *
eis_seat_get_user_data(struct eis_seat *eis_seat);

void
eis_seat_set_user_data(struct eis_seat *eis_seat, void *user_data);

bool
eis_seat_has_capability(struct eis_seat *seat, enum eis_device_capability cap);

void
eis_seat_configure_capability(struct eis_seat *seat, enum eis_device_capability cap);

void
eis_seat_add(struct eis_seat *seat);

void
eis_seat_remove(struct eis_seat *seat);

struct eis *
eis_seat_get_context(struct eis_seat *seat);

struct eis *
eis_device_get_context(struct eis_device *device);

struct eis_client *
eis_device_get_client(struct eis_device *device);

struct eis_seat *
eis_device_get_seat(struct eis_device *device);

struct eis_device *
eis_device_ref(struct eis_device *device);

struct eis_device *
eis_device_unref(struct eis_device *device);

void *
eis_device_get_user_data(struct eis_device *eis_device);

void
eis_device_set_user_data(struct eis_device *eis_device, void *user_data);

const char *
eis_device_get_name(struct eis_device *device);

bool
eis_device_has_capability(struct eis_device *device, enum eis_device_capability cap);

uint32_t
eis_device_get_width(struct eis_device *device);

uint32_t
eis_device_get_height(struct eis_device *device);

struct eis_device *
eis_seat_new_device(struct eis_seat *seat);

void
eis_device_configure_type(struct eis_device *device, enum eis_device_type type);

enum eis_device_type
eis_device_get_type(struct eis_device *device);

void
eis_device_configure_name(struct eis_device *device, const char *name);

void
eis_device_configure_capability(struct eis_device *device, enum eis_device_capability cap);

void
eis_device_configure_size(struct eis_device *device, uint32_t width, uint32_t height);

struct eis_region *
eis_device_new_region(struct eis_device *device);

void
eis_region_set_size(struct eis_region *region, uint32_t w, uint32_t h);

void
eis_region_set_offset(struct eis_region *region, uint32_t x, uint32_t y);

void
eis_region_set_physical_scale(struct eis_region *region, double scale);

void
eis_region_set_mapping_id(struct eis_region *region, const char *mapping_id);

const char *
eis_region_get_mapping_id(struct eis_region *region);

void
eis_region_add(struct eis_region *region);

struct eis_region *
eis_device_get_region(struct eis_device *device, size_t index);

struct eis_region *
eis_device_get_region_at(struct eis_device *device, double x, double y);

struct eis_region *
eis_region_ref(struct eis_region *region);

struct eis_region *
eis_region_unref(struct eis_region *region);

void *
eis_region_get_user_data(struct eis_region *region);

void
eis_region_set_user_data(struct eis_region *region, void *user_data);

uint32_t
eis_region_get_x(struct eis_region *region);

uint32_t
eis_region_get_y(struct eis_region *region);

uint32_t
eis_region_get_width(struct eis_region *region);

uint32_t
eis_region_get_height(struct eis_region *region);

double
eis_region_get_physical_scale(struct eis_region *region);

bool
eis_region_contains(struct eis_region *region, double x, double y);

void
eis_device_add(struct eis_device *device);

void
eis_device_remove(struct eis_device *device);

void
eis_device_pause(struct eis_device *device);

void
eis_device_resume(struct eis_device *device);

struct eis_keymap *
eis_device_new_keymap(struct eis_device *device, enum eis_keymap_type type, int fd, size_t size);

void
eis_keymap_add(struct eis_keymap *keymap);

size_t
eis_keymap_get_size(struct eis_keymap *keymap);

enum eis_keymap_type
eis_keymap_get_type(struct eis_keymap *keymap);

int
eis_keymap_get_fd(struct eis_keymap *keymap);

struct eis_keymap *
eis_keymap_ref(struct eis_keymap *keymap);

struct eis_keymap *
eis_keymap_unref(struct eis_keymap *keymap);

void *
eis_keymap_get_user_data(struct eis_keymap *eis_keymap);

void
eis_keymap_set_user_data(struct eis_keymap *eis_keymap, void *user_data);

struct eis_device *
eis_keymap_get_device(struct eis_keymap *keymap);

struct eis_keymap *
eis_device_keyboard_get_keymap(struct eis_device *device);

void
eis_device_keyboard_send_xkb_modifiers(struct eis_device *device,
                                       uint32_t depressed,
                                       uint32_t latched,
                                       uint32_t locked,
                                       uint32_t group);

void
eis_device_text_keysym(struct eis_device *device, uint32_t keysym, bool is_press);

void
eis_device_text_utf8(struct eis_device *device, const char *utf8);

void
eis_device_text_utf8_with_length(struct eis_device *device, const char *text, size_t length);

void
eis_device_start_emulating(struct eis_device *device, uint32_t sequence);

void
eis_device_stop_emulating(struct eis_device *device);

void
eis_device_frame(struct eis_device *device, uint64_t time);

void
eis_device_pointer_motion(struct eis_device *device, double x, double y);

void
eis_device_pointer_motion_absolute(struct eis_device *device, double x, double y);

void
eis_device_button_button(struct eis_device *device, uint32_t button, bool is_press);

void
eis_device_scroll_delta(struct eis_device *device, double x, double y);

void
eis_device_scroll_discrete(struct eis_device *device, int32_t x, int32_t y);

void
eis_device_scroll_stop(struct eis_device *device, bool stop_x, bool stop_y);

void
eis_device_scroll_cancel(struct eis_device *device, bool cancel_x, bool cancel_y);

void
eis_device_keyboard_key(struct eis_device *device, uint32_t keycode, bool is_press);

struct eis_touch *
eis_device_touch_new(struct eis_device *device);

void
eis_touch_down(struct eis_touch *touch, double x, double y);

void
eis_touch_motion(struct eis_touch *touch, double x, double y);

void
eis_touch_up(struct eis_touch *touch);

void
eis_touch_cancel(struct eis_touch *touch);

struct eis_touch *
eis_touch_ref(struct eis_touch *touch);

struct eis_touch *
eis_touch_unref(struct eis_touch *touch);

void
eis_touch_set_user_data(struct eis_touch *touch, void *user_data);

void *
eis_touch_get_user_data(struct eis_touch *touch);

struct eis_device *
eis_touch_get_device(struct eis_touch *touch);

void
eis_device_swipe_begin(struct eis_device *device, uint32_t nfingers);

void
eis_device_swipe_update(struct eis_device *device, double dx, double dy);

void
eis_device_swipe_end(struct eis_device *device);

void
eis_device_swipe_cancel(struct eis_device *device);

void
eis_device_swipe_abort(struct eis_device *device);

void
eis_device_pinch_begin(struct eis_device *device, uint32_t nfingers);

void
eis_device_pinch_update(struct eis_device *device,
                        double dx,
                        double dy,
                        double scale,
                        double rotation);

void
eis_device_pinch_end(struct eis_device *device);

void
eis_device_pinch_cancel(struct eis_device *device);

void
eis_device_pinch_abort(struct eis_device *device);

void
eis_device_hold_begin(struct eis_device *device, uint32_t nfingers);

void
eis_device_hold_end(struct eis_device *device);

void
eis_device_hold_cancel(struct eis_device *device);

void
eis_device_configure_stylus_capability(struct eis_device *device, enum eis_stylus_capability cap);

void
eis_device_stylus_proximity_in(struct eis_device *device);

void
eis_device_stylus_proximity_out(struct eis_device *device);

void
eis_device_stylus_erase_start(struct eis_device *device);

void
eis_device_stylus_erase_stop(struct eis_device *device);

void
eis_device_stylus_tip_down(struct eis_device *device);

void
eis_device_stylus_tip_up(struct eis_device *device);

void
eis_device_stylus_motion(struct eis_device *device, double x, double y);

void
eis_device_stylus_pressure(struct eis_device *device, double pressure);

void
eis_device_stylus_distance(struct eis_device *device, double distance);

void
eis_device_stylus_tilt(struct eis_device *device, double tilt_x, double tilt_y);

void
eis_device_stylus_rotation(struct eis_device *device, double rotation);

void
eis_device_stylus_airbrush_flow(struct eis_device *device, double flow);

void
eis_device_hold_abort(struct eis_device *device);

uint32_t
eis_event_emulating_get_sequence(struct eis_event *event);

double
eis_event_pointer_get_dx(struct eis_event *event);

double
eis_event_pointer_get_dy(struct eis_event *event);

double
eis_event_pointer_get_absolute_x(struct eis_event *event);

double
eis_event_pointer_get_absolute_y(struct eis_event *event);

uint32_t
eis_event_button_get_button(struct eis_event *event);

bool
eis_event_button_get_is_press(struct eis_event *event);

double
eis_event_scroll_get_dx(struct eis_event *event);

double
eis_event_scroll_get_dy(struct eis_event *event);

bool
eis_event_scroll_get_stop_x(struct eis_event *event);

bool
eis_event_scroll_get_stop_y(struct eis_event *event);

int32_t
eis_event_scroll_get_discrete_dx(struct eis_event *event);

int32_t
eis_event_scroll_get_discrete_dy(struct eis_event *event);

uint32_t
eis_event_keyboard_get_key(struct eis_event *event);

bool
eis_event_keyboard_get_key_is_press(struct eis_event *event);

uint32_t
eis_event_touch_get_id(struct eis_event *event);

double
eis_event_touch_get_x(struct eis_event *event);

double
eis_event_touch_get_y(struct eis_event *event);

bool
eis_event_touch_get_is_cancel(struct eis_event *event);

uint32_t
eis_event_swipe_get_finger_count(struct eis_event *event);

double
eis_event_swipe_get_dx(struct eis_event *event);

double
eis_event_swipe_get_dy(struct eis_event *event);

bool
eis_event_swipe_get_is_cancelled(struct eis_event *event);

uint32_t
eis_event_pinch_get_finger_count(struct eis_event *event);

double
eis_event_pinch_get_dx(struct eis_event *event);

double
eis_event_pinch_get_dy(struct eis_event *event);

double
eis_event_pinch_get_rotation(struct eis_event *event);

double
eis_event_pinch_get_scale(struct eis_event *event);

bool
eis_event_pinch_get_is_cancelled(struct eis_event *event);

uint32_t
eis_event_hold_get_finger_count(struct eis_event *event);

bool
eis_event_hold_get_is_cancelled(struct eis_event *event);

uint32_t
eis_event_text_get_keysym(struct eis_event *event);

bool
eis_event_text_get_keysym_is_press(struct eis_event *event);

const char *
eis_event_text_get_utf8(struct eis_event *event);

bool
eis_event_stylus_has_capability(struct eis_event *event, enum eis_stylus_capability cap);

double
eis_event_stylus_get_x(struct eis_event *event);

double
eis_event_stylus_get_y(struct eis_event *event);

double
eis_event_stylus_get_pressure(struct eis_event *event);

double
eis_event_stylus_get_distance(struct eis_event *event);

double
eis_event_stylus_get_tilt_x(struct eis_event *event);

double
eis_event_stylus_get_tilt_y(struct eis_event *event);

double
eis_event_stylus_get_rotation(struct eis_event *event);

double
eis_event_stylus_get_airbrush_flow(struct eis_event *event);

uint64_t
eis_now(struct eis *eis);

 
#ifdef __cplusplus
}
#endif