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 <stdint.h>
#include <stddef.h>
 
struct ei;
 
struct ei_device;
 
struct ei_seat;
 
struct ei_event;
 
struct ei_keymap;
 
struct ei_region;
 
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),
};
 
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_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,
};
 
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);
 
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_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));
 
 
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_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);
 
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);
 
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);
 
struct ei_seat *
ei_event_get_seat(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);
 
#ifdef __cplusplus
}
#endif