gp_widget_ops.h

Go to the documentation of this file.

//SPDX-License-Identifier: LGPL-2.0-or-later
 
/*
 
   Copyright (c) 2014-2020 Cyril Hrubis <metan@ucw.cz>
 
 */
 
#ifndef GP_WIDGET_OPS_H
#define GP_WIDGET_OPS_H
 
#include <input/gp_event.h>
#include <utils/gp_bbox.h>
#include <utils/gp_json.h>
#include <widgets/gp_widget.h>
#include <widgets/gp_widget_render.h>
 
enum gp_widget_focus_flag {
        GP_FOCUS_OUT,
        GP_FOCUS_IN,
        GP_FOCUS_LEFT,
        GP_FOCUS_RIGHT,
        GP_FOCUS_UP,
        GP_FOCUS_DOWN,
        GP_FOCUS_NEXT,
        GP_FOCUS_PREV,
};
 
struct json_object;
 
typedef struct gp_offset {
        gp_coord x;
        gp_coord y;
} gp_offset;
 
enum gp_widget_render_flags {
        GP_WIDGET_REDRAW = 0x01,
        GP_WIDGET_REDRAW_CHILDREN = 0x02,
        GP_WIDGET_COLOR_SCHEME = 0x04,
        GP_WIDGET_RESIZE = 0x08,
        GP_WIDGET_DISABLED = 0x10,
};
 
struct gp_widget_ops {
        void (*free)(gp_widget *self);
 
        int (*event)(gp_widget *self, const gp_widget_render_ctx *ctx, gp_event *ev);
 
        void (*render)(gp_widget *self, const gp_offset *offset,
                       const gp_widget_render_ctx *ctx, int flags);
 
        int (*focus)(gp_widget *self, int focus_dir);
 
        /*
         * Moves focus to widget on x, y coordinates.
         */
        int (*focus_xy)(gp_widget *self, const gp_widget_render_ctx *ctx,
                         unsigned int x, unsigned int y);
 
        int (*focus_child)(gp_widget *self, gp_widget *child);
 
        unsigned int (*min_w)(gp_widget *self, const gp_widget_render_ctx *ctx);
        unsigned int (*min_h)(gp_widget *self, const gp_widget_render_ctx *ctx);
 
        void (*distribute_w)(gp_widget *self,
                             const gp_widget_render_ctx *ctx,
                             int new_wh);
 
        void (*distribute_h)(gp_widget *self,
                             const gp_widget_render_ctx *ctx,
                             int new_wh);
 
        void (*for_each_child)(gp_widget *self, void (*func)(gp_widget *child));
 
        gp_widget *(*from_json)(gp_json_reader *json, gp_json_val *val, gp_widget_json_ctx *ctx);
 
        const char *id;
};
 
const struct gp_widget_ops *gp_widget_ops(gp_widget *self);
 
const struct gp_widget_ops *gp_widget_ops_by_id(const char *id);
 
const char *gp_widget_type_id(gp_widget *self);
 
const char *gp_widget_type_name(enum gp_widget_type type);
 
unsigned int gp_widget_min_w(gp_widget *self, const gp_widget_render_ctx *ctx);
 
unsigned int gp_widget_min_h(gp_widget *self, const gp_widget_render_ctx *ctx);
 
unsigned int gp_widget_align(gp_widget *self);
 
int gp_widget_input_event(gp_widget *self, const gp_widget_render_ctx *ctx, gp_event *ev);
 
void gp_widget_ops_render(gp_widget *self, const gp_offset *offset,
                          const gp_widget_render_ctx *ctx, int flags);
 
int gp_widget_ops_event(gp_widget *self, const gp_widget_render_ctx *ctx, gp_event *ev);
 
/*
 * Send event to a widget with a cursor offset.
 *
 * Same as gp_widget_ops_event() but with offset to the absolute coordinates is
 * applied so that the event is relative to the cursor coordinates.
 *
 * @self A widget to send the event to.
 * @ctx A render context.
 * @ev An input event.
 * @off_x X cursor offset.
 * @off_y Y cursor offset.
 *
 * @return Zero if event wasn't handled, non-zero otherwise.
 */
int gp_widget_ops_event_offset(gp_widget *self, const gp_widget_render_ctx *ctx,
                               gp_event *ev, gp_size off_x, gp_size off_y);
 
int gp_widget_ops_render_focus(gp_widget *self, int focus_dir);
 
int gp_widget_ops_render_focus_xy(gp_widget *self, const gp_widget_render_ctx *ctx,
                                  unsigned int x, unsigned int y);
 
int gp_widget_ops_focus_widget(gp_widget *self);
 
void gp_widget_ops_distribute_w(gp_widget *self, const gp_widget_render_ctx *ctx, unsigned int w, int new_wh);
void gp_widget_ops_distribute_h(gp_widget *self, const gp_widget_render_ctx *ctx, unsigned int h, int new_wh);
 
void gp_widget_ops_for_each_child(gp_widget *self, void (*func)(gp_widget *child));
 
static inline void gp_widget_ops_blit(const gp_widget_render_ctx *ctx,
                                      gp_coord x, gp_coord y,
                                      gp_size w, gp_size h)
{
        if (!ctx->flip)
                return;
 
        if (gp_bbox_empty(*ctx->flip))
                *ctx->flip = gp_bbox_pack(x, y, w, h);
        else
                *ctx->flip = gp_bbox_merge(*ctx->flip, gp_bbox_pack(x, y, w, h));
}
 
static inline int gp_widget_should_redraw(gp_widget *self, int flags)
{
        return self->redraw || (flags & GP_WIDGET_REDRAW);
}
 
static inline int gp_widget_is_disabled(gp_widget *self, int flags)
{
        return self->disabled || (flags & GP_WIDGET_DISABLED);
}
 
void gp_widget_calc_size(gp_widget *layout, const gp_widget_render_ctx *ctx,
                         unsigned int w, unsigned int h, int new_wh);
 
void gp_widget_redraw(gp_widget *self);
 
void gp_widget_resize(gp_widget *self);
 
void gp_widget_redraw_children(gp_widget *self);
 
void gp_widget_render(gp_widget *self, const gp_widget_render_ctx *ctx, int new_wh);
 
#endif /* GP_WIDGET_OPS_H */