gp_event.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2009-2021 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_RESIZE = 1,
        GP_EV_SYS_CLIPBOARD = 2,
        GP_EV_SYS_BACKLIGHT = 3,

        GP_EV_SYS_FOCUS = 4,

        GP_EV_SYS_VISIBILITY = 5,
};

enum gp_ev_sys_focus_val {
        GP_EV_SYS_FOCUS_OUT = 0,
        GP_EV_SYS_FOCUS_IN = 1,
};

enum gp_ev_sys_visibility_val {
        GP_EV_SYS_VISIBILITY_HIDE = 0,
        GP_EV_SYS_VISIBILITY_SHOW = 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 {
        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 sys;
                gp_timer *tmr;
                gp_fd *fd;
        };

        uint64_t time;

        struct gp_events_state *st;
};

static inline int gp_ev_utf_is_ctrl(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(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(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_(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_(gp_event *ev, ...);

void gp_ev_dump(gp_event *ev);
 
#endif /* INPUT_GP_EVENT_H */