ra8_widget_panel.c

Go to the documentation of this file.

 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_widget.h"

static const char* s_tag = "ra8_widget_panel";

RA8_INTERNAL
static ra8_err_t internal_panel_layout(const ra8_widget_panel_t* p, const ra8_ui_rect_t* rect)
{
  return ra8_widget_layout_stack(p->children,
                                 p->count,
                                 rect,
                                 p->axis,
                                 p->gap,
                                 p->pad,
                                 p->box_scratch,
                                 p->box_cap);
}

RA8_INTERNAL
static ra8_err_t internal_compose_check(ra8_widget_t*               panel_w,
                                        const ra8_ui_rect_t*        frame,
                                        const ra8_ui_rect_t*        out_damage,
                                        const ra8_widget_refresh_t* out_hint,
                                        const uint16_t*             out_dirty,
                                        ra8_widget_panel_t**        out_panel)
{
  RA8_CHECK_NULL_PTR(panel_w, s_tag, "panel_w must not be nullptr");
  RA8_CHECK_NULL_PTR(frame, s_tag, "frame must not be nullptr");
  RA8_CHECK_NULL_PTR(out_damage, s_tag, "out_damage must not be nullptr");
  RA8_CHECK_NULL_PTR(out_hint, s_tag, "out_hint must not be nullptr");
  RA8_CHECK_NULL_PTR(out_dirty, s_tag, "out_dirty must not be nullptr");
  ra8_widget_panel_t* p = (ra8_widget_panel_t*)panel_w->ctx;
  if ((p == nullptr) || (p->children == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  *out_panel = p;
  return k_ra8_ok;
}

RA8_INTERNAL
static void internal_panel_render(ra8_widget_t* w)
{
  ra8_widget_panel_t* p = (ra8_widget_panel_t*)w->ctx;
  if ((p == nullptr) || (p->children == nullptr)) {
    return;
  }
  if (internal_panel_layout(p, &w->rect) != k_ra8_ok) {
    return;
  }
  const ra8_widget_refresh_t hint = (w->refresh == (uint8_t)k_ra8_widget_refresh_none)
                                      ? k_ra8_widget_refresh_quality
                                      : (ra8_widget_refresh_t)w->refresh;
  for (uint16_t i = 0U; i < p->count; ++i) {
    if (p->children[i].visible) {
      (void)ra8_widget_invalidate(&p->children[i], hint);
    }
  }
  (void)ra8_widget_render_dirty(p->children, p->count);
}

RA8_INTERNAL
static bool internal_panel_on_input(ra8_widget_t* w, const ra8_widget_event_t* ev)
{
  ra8_widget_panel_t* p = (ra8_widget_panel_t*)w->ctx;
  if ((p == nullptr) || (p->children == nullptr)) {
    return false;
  }
  bool handled = false;
  (void)ra8_widget_dispatch(p->children, p->count, ev, &handled);
  return handled;
}

static const ra8_widget_vtable_t s_panel_vt = {
  .measure  = nullptr,
  .render   = internal_panel_render,
  .on_input = internal_panel_on_input,
};
 
const ra8_widget_vtable_t* ra8_widget_panel_vtable(void)
{
  return &s_panel_vt;
}
 
[[nodiscard]] ra8_err_t ra8_widget_panel_init(ra8_widget_t* w, ra8_widget_panel_t* panel)
{
  RA8_CHECK_NULL_PTR(w, s_tag, "w must not be nullptr");
  RA8_CHECK_NULL_PTR(panel, s_tag, "panel must not be nullptr");
  if (panel->count > 0U) {
    if (panel->children == nullptr) {
      return k_ra8_err_invalid_arg;
    }
    if ((uint32_t)panel->box_cap < ((uint32_t)panel->count + 1U)) {
      return k_ra8_err_invalid_arg;
    }
  }
  w->vt      = ra8_widget_panel_vtable();
  w->ctx     = panel;
  w->visible = true;
  return k_ra8_ok;
}
 
[[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)
{
  ra8_widget_panel_t* p = nullptr;
  const ra8_err_t     cerr =
    internal_compose_check(panel_w, frame, out_damage, out_hint, out_dirty, &p);
  if (cerr != k_ra8_ok) {
    return cerr;
  }
  panel_w->rect        = *frame;
  const ra8_err_t lerr = internal_panel_layout(p, &panel_w->rect);
  if (lerr != k_ra8_ok) {
    return lerr;
  }
  const ra8_err_t derr = ra8_widget_damage(p->children, p->count, out_damage, out_hint, out_dirty);
  if (derr != k_ra8_ok) {
    return derr;
  }
  const ra8_err_t rerr = ra8_widget_render_dirty(p->children, p->count);
  if (rerr != k_ra8_ok) {
    return rerr;
  }
  panel_w->dirty   = false;
  panel_w->refresh = (uint8_t)k_ra8_widget_refresh_none;
  return k_ra8_ok;
}