gp_ev_queue.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2009-2024 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef INPUT_GP_EV_QUEUE_H
#define INPUT_GP_EV_QUEUE_H
 
#include <input/gp_ev_feedback.h>
#include <input/gp_event.h>
 
#define GP_EVENT_QUEUE_SIZE 32
 
struct gp_ev_queue {
        unsigned int screen_w;
        unsigned int screen_h;
 
        uint32_t cursor_x;
        uint32_t cursor_y;
        void (*cursor_move)(void *priv, uint32_t x, uint32_t y);
        void *cursor_priv;
 
        /* event queue */
        unsigned int queue_first;
        unsigned int queue_last;
        unsigned int queue_size;
 
        gp_keymap *keymap;
 
        gp_ev_feedback *feedbacks_list;
 
        gp_events_state state;
 
        gp_event events[GP_EVENT_QUEUE_SIZE];
};
 
enum gp_ev_queue_flags {
        GP_EVENT_QUEUE_LOAD_KEYMAP = 0x01,
};
 
void gp_ev_queue_init(gp_ev_queue *self,
                      unsigned int screen_w, unsigned int screen_h,
                      unsigned int queue_size,
                      void (*cursor_move)(void *cursor_priv, uint32_t x, uint32_t y),
                      void *cursor_priv,
                      enum gp_ev_queue_flags flags);
 
void gp_ev_queue_flush(gp_ev_queue *self);
 
void gp_ev_queue_set_screen_size(gp_ev_queue *self,
                                 unsigned int w, unsigned int h);
 
static inline void gp_ev_queue_feedback_register(gp_ev_queue *self, gp_ev_feedback *feedback)
{
        gp_ev_feedback_register(&self->feedbacks_list, feedback);
}
 
static inline void gp_ev_queue_feedback_unregister(gp_ev_queue *self, gp_ev_feedback *feedback)
{
        gp_ev_feedback_unregister(&self->feedbacks_list, feedback);
}
 
static inline void gp_ev_queue_feedback_set_all(gp_ev_queue *self, gp_ev_feedback_op *op)
{
        gp_ev_feedback_set_all(self->feedbacks_list, op);
}
 
void gp_ev_queue_set_cursor_pos(gp_ev_queue *self,
                                unsigned int x, unsigned int y);
 
unsigned int gp_ev_queue_events(gp_ev_queue *self);
 
static inline int gp_ev_queue_full(gp_ev_queue *self)
{
        unsigned int next = (self->queue_last + 1) % self->queue_size;
 
        return next == self->queue_first;
}
 
gp_event *gp_ev_queue_get(gp_ev_queue *self);
 
gp_event *gp_ev_queue_peek(gp_ev_queue *self);
 
void gp_ev_queue_put(gp_ev_queue *self, gp_event *ev);
 
void gp_ev_queue_put_back(gp_ev_queue *self, gp_event *ev);
 
void gp_ev_queue_push_rel(gp_ev_queue *self,
                          int32_t rx, int32_t ry, uint64_t time);
 
void gp_ev_queue_push_rel_to(gp_ev_queue *self,
                             uint32_t x, uint32_t y, uint64_t time);
 
void gp_ev_queue_push_abs(gp_ev_queue *self,
                          uint32_t x, uint32_t y, uint32_t pressure,
                          uint32_t x_max, uint32_t y_max, uint32_t pressure_max,
                          uint64_t time);
 
void gp_ev_queue_push_key(gp_ev_queue *self,
                          uint32_t key, uint8_t code,
                          uint64_t time);
 
void gp_ev_queue_push_utf(gp_ev_queue *self, uint32_t utf_ch,
                          uint64_t time);
 
void gp_ev_queue_push_resize(gp_ev_queue *self,
                             uint32_t new_w, uint32_t new_h, uint64_t time);
 
void gp_ev_queue_push(gp_ev_queue *self,
                      uint16_t type, uint32_t code, int32_t value,
                      uint64_t time);
 
static inline void gp_ev_queue_push_wheel(gp_ev_queue *self,
                                          int32_t val, uint64_t time)
{
        gp_ev_queue_push(self, GP_EV_REL, GP_EV_REL_WHEEL, val, time);
}
 
#endif /* INPUT_GP_EV_QUEUE_H */