gp_event.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2009-2025 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef INPUT_GP_EVENT_H
#define INPUT_GP_EVENT_H
 
#include <stdint.h>
#include <string.h>
 
#include <utils/gp_types.h>
#include <input/gp_types.h>
#include <input/gp_keys.h>
#include <input/gp_event_keys.h>
 
enum gp_ev_type {
        GP_EV_KEY = 1,
        GP_EV_REL = 2,
        GP_EV_ABS = 3,
        GP_EV_SYS = 4,
        GP_EV_TMR = 5,
        GP_EV_FD = 6,
        GP_EV_MAX = 6,
};
 
enum gp_ev_key_code {
        GP_EV_KEY_UP     = 0,
        GP_EV_KEY_DOWN   = 1,
        GP_EV_KEY_REPEAT = 2,
};
 
enum gp_ev_rel_code {
        GP_EV_REL_POS   = 0,
        GP_EV_REL_WHEEL = 8,
};
 
enum gp_ev_abs_code {
        GP_EV_ABS_POS = 0,
};
 
enum gp_ev_sys_code {
        GP_EV_SYS_QUIT = 0,
        GP_EV_SYS_RENDER_RESIZE = 1,
        GP_EV_SYS_CLIPBOARD = 2,
        GP_EV_SYS_BACKLIGHT = 3,
 
        GP_EV_SYS_FOCUS = 4,
 
        GP_EV_SYS_RENDER_STOP = 5,
 
        GP_EV_SYS_RENDER_START = 6,
 
        GP_EV_SYS_RENDER_PIXEL_TYPE = 7,
};
 
enum gp_ev_sys_focus_val {
        GP_EV_SYS_FOCUS_OUT = 0,
        GP_EV_SYS_FOCUS_IN = 1,
};
 
struct gp_ev_pos_rel {
        int32_t rx;
        int32_t ry;
};
 
struct gp_ev_pos_abs {
        uint32_t x, x_max;
        uint32_t y, y_max;
        uint32_t pressure, pressure_max;
};
 
struct gp_ev_key {
        uint32_t key;
        uint32_t utf;
};
 
struct gp_ev_sys_resize {
        uint32_t w;
        uint32_t h;
};
 
#define GP_EVENT_KEY_BITMAP_BYTES 56
 
struct gp_events_state {
        uint8_t keys_pressed[GP_EVENT_KEY_BITMAP_BYTES];
 
        uint32_t cursor_x;
        uint32_t cursor_y;
 
        uint32_t saved_cursor_x;
        uint32_t saved_cursor_y;
};
 
struct gp_event {
        uint16_t type;
        uint16_t code;
        union {
                int32_t val;
                struct gp_ev_key key;
                struct gp_ev_pos_rel rel;
                struct gp_ev_pos_abs abs;
                struct gp_ev_sys_resize resize;
                uint16_t pixel_type;
                gp_timer *tmr;
                gp_fd *fd;
        };
 
        uint64_t time;
 
        struct gp_events_state *st;
};
 
static inline int gp_ev_utf_is_ctrl(const gp_event *ev)
{
        if (!ev->key.utf)
                return 0;
 
        return ev->key.utf < 0x20 && ev->key.utf != 0x7f;
}
 
static inline void gp_events_state_press(gp_events_state *self, uint32_t key)
{
        if (key >= GP_EVENT_KEY_BITMAP_BYTES * 8)
                return;
 
        self->keys_pressed[(key)/8] |= 1<<((key)%8);
}
 
static inline int gp_events_state_pressed(const gp_events_state *self, uint32_t key)
{
        if (key >= GP_EVENT_KEY_BITMAP_BYTES * 8)
                return 0;
 
        return !!(self->keys_pressed[(key)/8] & (1<<((key)%8)));
}
 
static inline void gp_events_state_release(gp_events_state *self, uint32_t key)
{
        if (key >= GP_EVENT_KEY_BITMAP_BYTES * 8)
                return;
 
        self->keys_pressed[(key)/8] &= ~(1<<((key)%8));
}
 
static inline void gp_events_state_release_all(gp_events_state *self)
{
        memset(self->keys_pressed, 0, sizeof(self->keys_pressed));
}
 
static inline int gp_ev_key_pressed(const gp_event *ev, uint32_t key)
{
        if (!ev->st)
                return 0;
 
        return gp_events_state_pressed(ev->st, key);
}
 
#define gp_ev_any_key_pressed(ev, ...) gp_ev_any_key_pressed_(ev, __VA_ARGS__, 0)
int gp_ev_any_key_pressed_(const gp_event *ev, ...);
 
#define gp_ev_all_keys_pressed(ev, ...) gp_ev_all_keys_pressed_(ev, __VA_ARGS__, 0)
int gp_ev_all_keys_pressed_(const gp_event *ev, ...);
 
void gp_ev_dump(const gp_event *ev);
 
#endif /* INPUT_GP_EVENT_H */