ra8_widget.c

Go to the documentation of this file.

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

static const char* s_tag = "ra8_widget";

RA8_INTERNAL
static bool internal_rect_empty(const ra8_ui_rect_t* r)
{
  return (r->w <= 0) && (r->h <= 0);
}

RA8_INTERNAL
static int32_t internal_min_i32(int32_t a, int32_t b)
{
  return (a < b) ? a : b;
}

RA8_INTERNAL
static int32_t internal_max_i32(int32_t a, int32_t b)
{
  return (a > b) ? a : b;
}

RA8_INTERNAL
static ra8_ui_rect_t internal_rect_union(ra8_ui_rect_t acc, ra8_ui_rect_t r)
{
  if (internal_rect_empty(&acc)) {
    return r;
  }
  if (internal_rect_empty(&r)) {
    return acc;
  }
  const int32_t       x0  = internal_min_i32(acc.x, r.x);
  const int32_t       y0  = internal_min_i32(acc.y, r.y);
  const int32_t       x1  = internal_max_i32(acc.x + acc.w, r.x + r.w);
  const int32_t       y1  = internal_max_i32(acc.y + acc.h, r.y + r.h);
  const ra8_ui_rect_t out = {.x = x0, .y = y0, .w = x1 - x0, .h = y1 - y0};
  return out;
}

RA8_INTERNAL
static uint16_t internal_visible_count(const ra8_widget_t* widgets, uint16_t count)
{
  uint16_t vis = 0U;
  for (uint16_t i = 0U; i < count; ++i) {
    if (widgets[i].visible) {
      ++vis;
    }
  }
  return vis;
}

RA8_INTERNAL
static ra8_err_t internal_build_stack_tree(const ra8_widget_t* widgets,
                                           uint16_t            count,
                                           ra8_widget_axis_t   axis,
                                           int16_t             gap,
                                           int16_t             pad,
                                           ra8_box_t*          scratch,
                                           uint16_t            cap,
                                           ra8_box_tree_t*     out_tree,
                                           int16_t*            out_root)
{
  const uint16_t vis = internal_visible_count(widgets, count);
  if ((uint32_t)cap < ((uint32_t)vis + 1U)) {
    return k_ra8_err_invalid_arg;
  }
  const ra8_err_t ierr = ra8_box_tree_init(out_tree, scratch, cap);
  if (ierr != k_ra8_ok) {
    return ierr;
  }
  ra8_box_t container = {};
  container.kind =
    (axis == k_ra8_widget_axis_row) ? (uint8_t)k_ra8_box_stack_h : (uint8_t)k_ra8_box_stack_v;
  container.pad  = pad;
  container.gap  = gap;
  container.flex = 1U;
  container.tag  = (int16_t)k_ra8_box_none;
  *out_root      = ra8_box_add(out_tree, (int16_t)k_ra8_box_none, &container);
  if (*out_root == (int16_t)k_ra8_box_none) {
    return k_ra8_err_invalid_arg;
  }
  for (uint16_t i = 0U; i < count; ++i) {
    if (!widgets[i].visible) {
      continue;
    }
    ra8_box_t leaf = {};
    leaf.kind      = (uint8_t)k_ra8_box_leaf;
    leaf.fixed     = widgets[i].fixed;
    leaf.flex      = widgets[i].flex;
    leaf.tag       = (int16_t)widgets[i].action_id;
    if (ra8_box_add(out_tree, *out_root, &leaf) == (int16_t)k_ra8_box_none) {
      return k_ra8_err_invalid_arg;
    }
  }
  return k_ra8_ok;
}
 
[[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)
{
  RA8_CHECK_NULL_PTR(widgets, s_tag, "widgets must not be nullptr");
  RA8_CHECK_NULL_PTR(frame, s_tag, "frame must not be nullptr");
  RA8_CHECK_NULL_PTR(box_scratch, s_tag, "box_scratch must not be nullptr");
 
  ra8_box_tree_t  tree = {};
  int16_t         root = (int16_t)k_ra8_box_none;
  const ra8_err_t berr =
    internal_build_stack_tree(widgets, count, axis, gap, pad, box_scratch, box_cap, &tree, &root);
  if (berr != k_ra8_ok) {
    return berr;
  }
  const ra8_err_t lerr = ra8_box_layout(&tree, root, frame);
  if (lerr != k_ra8_ok) {
    return lerr;
  }
 
  /* Box nodes 1..vis are the visible children in add order. */
  uint16_t box_idx = 1U;
  for (uint16_t i = 0U; i < count; ++i) {
    if (!widgets[i].visible) {
      continue;
    }
    widgets[i].rect = box_scratch[box_idx].rect;
    ++box_idx;
  }
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_widget_dispatch(ra8_widget_t*             widgets,
                                            uint16_t                  count,
                                            const ra8_widget_event_t* ev,
                                            bool*                     out_handled)
{
  RA8_CHECK_NULL_PTR(ev, s_tag, "ev must not be nullptr");
  RA8_CHECK_NULL_PTR(out_handled, s_tag, "out_handled must not be nullptr");
  if ((count > 0U) && (widgets == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out_handled = false;
 
  for (uint16_t i = 0U; i < count; ++i) {
    ra8_widget_t* w = &widgets[i];
    if (!w->visible || (w->vt == nullptr) || (w->vt->on_input == nullptr)) {
      continue;
    }
    if (ev->kind == k_ra8_widget_ev_touch) {
      /* Touch: only the widget under the point is offered the event. */
      if (!ra8_ui_rect_contains(&w->rect, ev->x, ev->y)) {
        continue;
      }
      *out_handled = w->vt->on_input(w, ev);
      return k_ra8_ok;
    }
    /* Button: offer to each visible widget until one consumes it. */
    if (w->vt->on_input(w, ev)) {
      *out_handled = true;
      return k_ra8_ok;
    }
  }
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_widget_invalidate(ra8_widget_t* w, ra8_widget_refresh_t refresh)
{
  RA8_CHECK_NULL_PTR(w, s_tag, "w must not be nullptr");
  if (refresh == k_ra8_widget_refresh_none) {
    return k_ra8_err_invalid_arg;
  }
  w->dirty = true;
  if ((uint8_t)refresh > w->refresh) {
    w->refresh = (uint8_t)refresh;
  }
  return k_ra8_ok;
}
 
[[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)
{
  RA8_CHECK_NULL_PTR(out_rect, s_tag, "out_rect must not be nullptr");
  RA8_CHECK_NULL_PTR(out_hint, s_tag, "out_hint must not be nullptr");
  RA8_CHECK_NULL_PTR(out_count, s_tag, "out_count must not be nullptr");
  if ((count > 0U) && (widgets == nullptr)) {
    return k_ra8_err_null_ptr;
  }
 
  ra8_ui_rect_t acc   = {.x = 0, .y = 0, .w = 0, .h = 0};
  uint8_t       hint  = (uint8_t)k_ra8_widget_refresh_none;
  uint16_t      dirty = 0U;
  for (uint16_t i = 0U; i < count; ++i) {
    if (!widgets[i].visible || !widgets[i].dirty) {
      continue;
    }
    acc = internal_rect_union(acc, widgets[i].rect);
    if (widgets[i].refresh > hint) {
      hint = widgets[i].refresh;
    }
    ++dirty;
  }
  *out_rect  = acc;
  *out_hint  = (ra8_widget_refresh_t)hint;
  *out_count = dirty;
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t ra8_widget_render_dirty(ra8_widget_t* widgets, uint16_t count)
{
  if ((count > 0U) && (widgets == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  for (uint16_t i = 0U; i < count; ++i) {
    ra8_widget_t* w = &widgets[i];
    if (!w->visible || !w->dirty) {
      continue;
    }
    if ((w->vt != nullptr) && (w->vt->render != nullptr)) {
      w->vt->render(w);
    }
    w->dirty   = false;
    w->refresh = (uint8_t)k_ra8_widget_refresh_none;
  }
  return k_ra8_ok;
}