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,
        EI_DEVICE_CAP_POINTER_ABSOLUTE,
        EI_DEVICE_CAP_KEYBOARD,
        EI_DEVICE_CAP_TOUCH,
};
 
enum ei_property_permission {
        EI_PROPERTY_PERM_NONE = 0,
        EI_PROPERTY_PERM_READ = (1 << 0),
        EI_PROPERTY_PERM_WRITE = (1 << 1),
        EI_PROPERTY_PERM_DELETE = (1 << 2),
 
        EI_PROPERTY_PERM_ALL = (EI_PROPERTY_PERM_READ|EI_PROPERTY_PERM_WRITE|EI_PROPERTY_PERM_DELETE),
};
 
enum ei_keymap_type {
        EI_KEYMAP_TYPE_XKB = 1,
};
 
enum ei_event_type {
        EI_EVENT_CONNECT = 1,
 
        EI_EVENT_DISCONNECT,
 
        EI_EVENT_PROPERTY,
 
        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,
 
        /* These events are only generated on a receiver ei context. */
        EI_EVENT_POINTER_MOTION = 300,
        EI_EVENT_POINTER_MOTION_ABSOLUTE,
        EI_EVENT_POINTER_BUTTON,
        EI_EVENT_POINTER_SCROLL,
        EI_EVENT_POINTER_SCROLL_STOP,
        EI_EVENT_POINTER_SCROLL_CANCEL,
        EI_EVENT_POINTER_SCROLL_DISCRETE,
 
        EI_EVENT_KEYBOARD_KEY = 400,
 
        EI_EVENT_TOUCH_DOWN = 500,
        EI_EVENT_TOUCH_UP,
        EI_EVENT_TOUCH_MOTION,
};
 
struct ei *
ei_new(void *user_data);
 
struct ei *
ei_new_sender(void *user_data);
 
struct ei *
ei_new_receiver(void *user_data);
 
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,
};
 
typedef void (*ei_log_handler)(struct ei *ei,
                               enum ei_log_priority priority,
                               const char *file, int lineno, const char *func,
                               const char *message,
                               bool is_continuation);
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);
 
void
ei_configure_name(struct ei * ei, const char *name);
 
int
ei_property_set(struct ei *ei, const char *property, const char *value);
 
int
ei_property_set_with_permissions(struct ei *ei, const char *property,
                                 const char *value, uint32_t permission);
 
uint32_t
ei_property_get_permissions(struct ei *ei, const char *property);
 
const char *
ei_property_get(struct ei *ei, const char *property);
 
int
ei_setup_backend_socket(struct ei *ei, const char *socketpath);
 
int
ei_setup_backend_fd(struct ei *ei, int fd);
 
int
ei_setup_backend_portal(struct ei *ei);
 
int
ei_setup_backend_portal_busname(struct ei *ei, const char *busname);
 
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);
 
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);
 
struct ei_event *
ei_event_unref(struct ei_event *event);
 
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_capability(struct ei_seat *seat,
                        enum ei_device_capability cap);
 
__attribute__((sentinel))
void
ei_seat_bind_capabilities(struct ei_seat *seat, ...);
 
void
ei_seat_unbind_capability(struct ei_seat *seat,
                          enum ei_device_capability cap);
 
__attribute__((sentinel))
void
ei_seat_unbind_capabilities(struct ei_seat *seat, ...);
 
 
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);
 
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);
 
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);
 
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_seat_set_user_data(struct ei_seat *seat, void *user_data);
 
void *
ei_seat_get_user_data(struct ei_seat *seat);
 
void
ei_device_set_user_data(struct ei_device *device, void *user_data);
 
void *
ei_device_get_user_data(struct ei_device *device);
 
 
struct ei_keymap *
ei_device_get_keymap(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_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);
 
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);
 
void
ei_device_stop_emulating(struct ei_device *device);
 
void
ei_device_frame(struct ei_device *device);
 
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_pointer_button(struct ei_device *device,
                         uint32_t button, bool is_press);
 
void
ei_device_pointer_scroll(struct ei_device *device, double x, double y);
 
void
ei_device_pointer_scroll_discrete(struct ei_device *device, int32_t x, int32_t y);
 
void
ei_device_pointer_scroll_stop(struct ei_device *device, bool stop_x, bool stop_y);
 
void
ei_device_pointer_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);
 
const char *
ei_event_property_get_name(struct ei_event *event);
 
const char *
ei_event_property_get_value(struct ei_event *event);
 
uint32_t
ei_event_property_get_permissions(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_pointer_get_button(struct ei_event *event);
 
bool
ei_event_pointer_get_button_is_press(struct ei_event *event);
 
double
ei_event_pointer_get_scroll_x(struct ei_event *event);
 
double
ei_event_pointer_get_scroll_y(struct ei_event *event);
 
bool
ei_event_pointer_get_scroll_stop_x(struct ei_event *event);
 
bool
ei_event_pointer_get_scroll_stop_y(struct ei_event *event);
 
int32_t
ei_event_pointer_get_scroll_discrete_x(struct ei_event *event);
 
int32_t
ei_event_pointer_get_scroll_discrete_y(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