ra8_widget.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "ra8_box.h"
#include "ra8_err.h"
#include "ra8_ui.h"
 
/* ===========================================================================
 * Events + refresh hints
 * ===========================================================================
 */

typedef enum : uint8_t {
  k_ra8_widget_ev_touch  = 0U, 
  k_ra8_widget_ev_button = 1U, 
} ra8_widget_ev_kind_t;

typedef struct {
  ra8_widget_ev_kind_t kind;      
  uint8_t              reserved;  
  uint16_t             button_id; 
  int32_t              x;         
  int32_t              y;         
} ra8_widget_event_t;

typedef enum : uint8_t {
  k_ra8_widget_refresh_none    = 0U, 
  k_ra8_widget_refresh_fast    = 1U, 
  k_ra8_widget_refresh_quality = 2U, 
} ra8_widget_refresh_t;
 
/* ===========================================================================
 * Widget + vtable
 * ===========================================================================
 */
 
struct ra8_widget; /* fwd */

typedef struct {
  void (*measure)(struct ra8_widget* w,
                  int32_t            avail_w,
                  int32_t            avail_h,
                  int32_t*           out_w,
                  int32_t*           out_h);
  void (*render)(struct ra8_widget* w);
  bool (*on_input)(struct ra8_widget* w, const ra8_widget_event_t* ev);
} ra8_widget_vtable_t;

typedef struct ra8_widget {
  const ra8_widget_vtable_t* vt;        
  void*                      ctx;       
  ra8_ui_rect_t              rect;      
  int16_t                    fixed;     
  uint16_t                   flex;      
  uint16_t                   action_id; 
  uint8_t                    refresh;   
  bool                       visible;   
  bool                       dirty;     
} ra8_widget_t;

typedef enum : uint8_t {
  k_ra8_widget_axis_col = 0U, 
  k_ra8_widget_axis_row = 1U, 
} ra8_widget_axis_t;
 
/* ===========================================================================
 * Container operations (all pure except the render dispatch)
 * ===========================================================================
 */

[[nodiscard]] ra8_err_t ra8_widget_layout_stack(ra8_widget_t*        widgets,
                                                uint16_t             count,
                                                const ra8_ui_rect_t* frame,
                                                ra8_widget_axis_t    axis,
                                                int16_t              gap,
                                                int16_t              pad,
                                                ra8_box_t*           box_scratch,
                                                uint16_t             box_cap);

[[nodiscard]] ra8_err_t ra8_widget_dispatch(ra8_widget_t*             widgets,
                                            uint16_t                  count,
                                            const ra8_widget_event_t* ev,
                                            bool*                     out_handled);

[[nodiscard]] ra8_err_t ra8_widget_invalidate(ra8_widget_t* w, ra8_widget_refresh_t refresh);

[[nodiscard]] ra8_err_t ra8_widget_damage(const ra8_widget_t*   widgets,
                                          uint16_t              count,
                                          ra8_ui_rect_t*        out_rect,
                                          ra8_widget_refresh_t* out_hint,
                                          uint16_t*             out_count);

[[nodiscard]] ra8_err_t ra8_widget_render_dirty(ra8_widget_t* widgets, uint16_t count);
 
/* ===========================================================================
 * Container panel: a composite widget that nests a child widget array
 * ===========================================================================
 */

typedef struct ra8_widget_panel {
  ra8_widget_t*     children;    
  ra8_box_t*        box_scratch; 
  uint16_t          count;       
  uint16_t          box_cap;     
  int16_t           gap;         
  int16_t           pad;         
  ra8_widget_axis_t axis;        
  uint8_t           reserved;    
} ra8_widget_panel_t;

const ra8_widget_vtable_t* ra8_widget_panel_vtable(void);

[[nodiscard]] ra8_err_t ra8_widget_panel_init(ra8_widget_t* w, ra8_widget_panel_t* panel);

[[nodiscard]] ra8_err_t ra8_widget_panel_compose(ra8_widget_t*         panel_w,
                                                 const ra8_ui_rect_t*  frame,
                                                 ra8_ui_rect_t*        out_damage,
                                                 ra8_widget_refresh_t* out_hint,
                                                 uint16_t*             out_dirty);
 
/* ===========================================================================
 * Concrete leaf widgets: text label + push button (DI paint backend)
 * ===========================================================================
 */

typedef struct ra8_widget_paint {
  void* user;
  void (*fill_rect)(void* user, int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
  void (*draw_text)(void* user, int32_t x, int32_t y, const char* str, uint32_t fg, uint32_t bg);
  void (*text_size)(void* user, const char* str, int32_t* out_w, int32_t* out_h);
} ra8_widget_paint_t;

typedef enum : uint8_t {
  k_ra8_widget_align_left   = 0U, 
  k_ra8_widget_align_center = 1U, 
  k_ra8_widget_align_right  = 2U, 
} ra8_widget_align_t;

typedef struct ra8_widget_label {
  const ra8_widget_paint_t* paint;    
  const char*               text;     
  uint32_t                  fg;       
  uint32_t                  bg;       
  int16_t                   pad;      
  ra8_widget_align_t        align;    
  uint8_t                   reserved; 
} ra8_widget_label_t;

typedef struct ra8_widget_button {
  const ra8_widget_paint_t* paint;        
  const char*               text;         
  void (*on_press)(struct ra8_widget* w); 
  uint32_t           fg;                  
  uint32_t           face;                
  uint32_t           face_pressed;        
  uint32_t           border;              
  uint32_t           presses;             
  int16_t            pad;                 
  int16_t            border_w;            
  ra8_widget_align_t align;               
  bool               pressed;             
  uint8_t            reserved;            
} ra8_widget_button_t;

const ra8_widget_vtable_t* ra8_widget_label_vtable(void);

[[nodiscard]] ra8_err_t ra8_widget_label_init(ra8_widget_t* w, ra8_widget_label_t* label);

const ra8_widget_vtable_t* ra8_widget_button_vtable(void);

[[nodiscard]] ra8_err_t ra8_widget_button_init(ra8_widget_t* w, ra8_widget_button_t* button);
 
#ifdef __cplusplus
}
#endif