gp_backend.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2009-2010 Jiri "BlueBear" Dluhos
 *                         <jiri.bluebear.dluhos@gmail.com>
 *
 * Copyright (C) 2009-2025 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef BACKENDS_GP_BACKEND_H
#define BACKENDS_GP_BACKEND_H
 
#include <core/gp_types.h>
#include <core/gp_compiler.h>
#include <core/gp_pixmap.h>
 
#include <utils/gp_timer.h>
#include <utils/gp_list.h>
#include <utils/gp_poll.h>
 
#include <input/gp_ev_queue.h>
#include <input/gp_task.h>
 
#include <backends/gp_types.h>
 
enum gp_backend_attr {
        GP_BACKEND_ATTR_SIZE,
        GP_BACKEND_ATTR_TITLE,
        GP_BACKEND_ATTR_FULLSCREEN,
        GP_BACKEND_ATTR_CURSOR,
        GP_BACKEND_ATTR_BACKLIGHT,
};
 
enum gp_backend_ret {
        GP_BACKEND_OK = 0,
        GP_BACKEND_OFF = 0,
        GP_BACKEND_ON = 1,
        GP_BACKEND_NOTSUPP = -1,
        GP_BACKEND_EINVAL = -2,
        GP_BACKEND_CONNERR = -3,
};
 
enum gp_backend_fullscreen_req {
        GP_BACKEND_FULLSCREEN_OFF = 0,
        GP_BACKEND_FULLSCREEN_ON = 1,
        GP_BACKEND_FULLSCREEN_TOGGLE = 2,
        GP_BACKEND_FULLSCREEN_QUERY = 3,
};
 
enum gp_backend_cursor_req {
        GP_BACKEND_CURSOR_ARROW,
        GP_BACKEND_CURSOR_TEXT_EDIT,
        GP_BACKEND_CURSOR_CROSSHAIR,
        GP_BACKEND_CURSOR_HAND,
        GP_BACKEND_CURSOR_MAX,
 
        GP_BACKEND_CURSOR_SHOW = 0xc000,
        GP_BACKEND_CURSOR_HIDE = 0x8000,
};
 
enum gp_backend_backlight_req {
        GP_BACKEND_BACKLIGHT_INC,
        GP_BACKEND_BACKLIGHT_DEC,
        GP_BACKEND_BACKLIGHT_GET,
};
 
struct gp_backend {
        gp_pixmap *pixmap;
 
        const char *name;
 
        void (*flip)(gp_backend *self);
 
        void (*update)(gp_backend *self);
 
        void (*update_rect)(gp_backend *self,
                            gp_coord x0, gp_coord y0,
                            gp_coord x1, gp_coord y1);
 
        enum gp_backend_ret (*set_attr)(gp_backend *self,
                                        enum gp_backend_attr attr,
                                        const void *vals);
 
        int (*render_stopped)(gp_backend *self);
 
        void (*exit)(gp_backend *self);
 
        void (*poll)(gp_backend *self);
 
        /*
         * Clipboard handler.
         */
        int (*clipboard)(gp_backend *self, gp_clipboard *op);
 
        void (*wait)(gp_backend *self, int timeout_ms);
 
        gp_poll fds;
 
        gp_ev_queue *event_queue;
 
        gp_timer *timers;
 
        gp_task_queue *task_queue;
 
        gp_dlist input_drivers;
 
        void *clipboard_data;
 
        unsigned int dpi;
 
        /* Backed private data */
        char priv[] GP_ALIGNED;
};
 
#define GP_BACKEND_PRIV(backend) ((void*)(backend)->priv)
 
static inline gp_size gp_backend_w(gp_backend *self)
{
        return gp_pixmap_w(self->pixmap);
}
 
static inline gp_size gp_backend_h(gp_backend *self)
{
        return gp_pixmap_h(self->pixmap);
}
 
static inline gp_pixel_type gp_backend_pixel_type(gp_backend *self)
{
        return self->pixmap->pixel_type;
}
 
void gp_backend_update_rect_xyxy(gp_backend *self,
                                 gp_coord x0, gp_coord y0,
                                 gp_coord x1, gp_coord y1);
 
static inline void gp_backend_update_rect(gp_backend *self,
                                          gp_coord x0, gp_coord y0,
                                          gp_coord x1, gp_coord y1)
{
        return gp_backend_update_rect_xyxy(self, x0, y0, x1, y1);
}
 
static inline void gp_backend_update_rect_xywh(gp_backend *self,
                                               gp_coord x, gp_coord y,
                                               gp_size w, gp_size h)
{
        gp_backend_update_rect_xyxy(self, x, y, x + w - 1, y + h - 1);
}
 
static inline void gp_backend_update(gp_backend *self)
{
        if (self->update)
                self->update(self);
}
 
static inline void gp_backend_flip(gp_backend *self)
{
        if (self->flip)
                self->flip(self);
        else
                gp_backend_update(self);
}
 
void gp_backend_poll_add(gp_backend *self, gp_fd *fd);
 
static inline void gp_backend_poll_rem(gp_backend *self, gp_fd *fd)
{
        gp_poll_rem(&self->fds, fd);
}
 
static inline gp_fd *gp_backend_poll_rem_by_fd(gp_backend *self, int fd)
{
        return gp_poll_rem_by_fd(&self->fds, fd);
}
 
static inline enum gp_backend_ret gp_backend_cursor_set(gp_backend *self,
                                                        enum gp_backend_cursor_req cursor)
{
        if (self->set_attr)
                return self->set_attr(self, GP_BACKEND_ATTR_CURSOR, &cursor);
 
        return GP_BACKEND_NOTSUPP;
}
 
static inline int gp_backend_backlight_inc(gp_backend *self)
{
        enum gp_backend_backlight_req req = GP_BACKEND_BACKLIGHT_INC;
 
        if (self->set_attr)
                return self->set_attr(self, GP_BACKEND_ATTR_BACKLIGHT, &req);
 
        return GP_BACKEND_NOTSUPP;
}
 
static inline int gp_backend_backlight_dec(gp_backend *self)
{
        enum gp_backend_backlight_req req = GP_BACKEND_BACKLIGHT_DEC;
 
        if (self->set_attr)
                return self->set_attr(self, GP_BACKEND_ATTR_BACKLIGHT, &req);
 
        return GP_BACKEND_NOTSUPP;
}
 
static inline int gp_backend_backlight_get(gp_backend *self)
{
        enum gp_backend_backlight_req req = GP_BACKEND_BACKLIGHT_GET;
 
        if (self->set_attr)
                return self->set_attr(self, GP_BACKEND_ATTR_BACKLIGHT, &req);
 
        return GP_BACKEND_NOTSUPP;
}
 
void gp_backend_exit(gp_backend *self);
 
void gp_backend_poll(gp_backend *self);
 
gp_event *gp_backend_ev_poll(gp_backend *self);
 
void gp_backend_wait_timeout(gp_backend *self, int timeout_ms);
 
static inline void gp_backend_wait(gp_backend *self)
{
        gp_backend_wait_timeout(self, -1);
}
 
gp_event *gp_backend_ev_wait_timeout(gp_backend *self, int timeout_ms);
 
static inline gp_event *gp_backend_ev_wait(gp_backend *self)
{
        return gp_backend_ev_wait_timeout(self, -1);
}
 
void gp_backend_timer_start(gp_backend *self, gp_timer *timer);
 
void gp_backend_timer_reschedule(gp_backend *self, gp_timer *timer, uint32_t expires_ms);
 
void gp_backend_timer_stop(gp_backend *self, gp_timer *timer);
 
static inline unsigned int gp_backend_timers_queued(gp_backend *self)
{
        return gp_timer_queue_size(self->timers);
}
 
int gp_backend_timer_timeout(gp_backend *self);
 
static inline enum gp_backend_ret gp_backend_set_caption(gp_backend *backend,
                                                         const char *caption)
{
        if (!backend->set_attr)
                return GP_BACKEND_NOTSUPP;
 
        return backend->set_attr(backend, GP_BACKEND_ATTR_TITLE, caption);
}
 
int gp_backend_resize(gp_backend *backend, uint32_t w, uint32_t h);
 
static inline enum gp_backend_ret gp_backend_fullscreen(gp_backend *backend,
                                                        enum gp_backend_fullscreen_req req)
{
        if (!backend->set_attr)
                return GP_BACKEND_NOTSUPP;
 
        return backend->set_attr(backend, GP_BACKEND_ATTR_FULLSCREEN, &req);
}
 
int gp_backend_render_stopped(gp_backend *self);
 
void gp_backend_task_ins(gp_backend *self, gp_task *task);
 
void gp_backend_task_rem(gp_backend *self, gp_task *task);
 
void gp_backend_task_queue_set(gp_backend *self, gp_task_queue *task_queue);
 
static inline void gp_backend_ev_flush(gp_backend *self)
{
        return gp_ev_queue_flush(self->event_queue);
}
 
static inline unsigned int gp_backend_ev_queued(gp_backend *self)
{
        return gp_ev_queue_events(self->event_queue);
}
 
gp_event *gp_backend_ev_get(gp_backend *self);
 
static inline gp_event *gp_backend_ev_peek(gp_backend *self)
{
        return gp_ev_queue_peek(self->event_queue);
}
 
static inline void gp_backend_ev_put_back(gp_backend *self, gp_event *ev)
{
        gp_ev_queue_put_back(self->event_queue, ev);
}
 
#endif /* BACKENDS_GP_BACKEND_H */