ra8_display_pal_policy.c

Go to the documentation of this file.

 
#include "ra8_display_pal_policy.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"

static const char* const s_tag_policy = "disp_policy";

RA8_INTERNAL
static uint16_t internal_clamp_clean_every(uint16_t n)
{
  if (n < (uint16_t)k_display_policy_clean_every_min) {
    return (uint16_t)k_display_policy_clean_every_min;
  }
  if (n > (uint16_t)k_display_policy_clean_every_max) {
    return (uint16_t)k_display_policy_clean_every_max;
  }
  return n;
}

RA8_INTERNAL
static void internal_decide_fast_clean(display_policy_t*          p,
                                       display_turn_event_t       event,
                                       display_policy_decision_t* out)
{
  const uint16_t next  = (uint16_t)(p->turns_since_clean + 1U);
  const bool     clean = (next >= p->clean_every) || (event == k_display_event_chapter);
  if (clean) {
    out->hint            = k_display_refresh_quality;
    out->full_update     = true;
    p->turns_since_clean = 0U;
  } else {
    out->hint            = k_display_refresh_fast;
    out->full_update     = false;
    p->turns_since_clean = next;
  }
}
 
ra8_err_t display_policy_init(display_policy_t* p, display_policy_kind_t kind, uint16_t clean_every)
{
  RA8_CHECK_NULL_PTR(p, s_tag_policy, "init: null policy");
  if (kind > k_display_policy_fast_clean) {
    ra8_log_error(s_tag_policy, "init: kind out of range");
    return k_ra8_err_invalid_arg;
  }
  p->kind              = (uint8_t)kind;
  p->clean_every       = internal_clamp_clean_every(clean_every);
  p->turns_since_clean = 0U;
  return k_ra8_ok;
}
 
ra8_err_t display_policy_decide(display_policy_t*          p,
                                display_turn_event_t       event,
                                display_policy_decision_t* out)
{
  RA8_CHECK_NULL_PTR(p, s_tag_policy, "decide: null policy");
  RA8_CHECK_NULL_PTR(out, s_tag_policy, "decide: null out");
  if (event > k_display_event_chapter) {
    ra8_log_error(s_tag_policy, "decide: event out of range");
    return k_ra8_err_invalid_arg;
  }
 
  /* A fresh open always clears the panel (INIT) regardless of strategy. */
  if (event == k_display_event_open) {
    out->hint            = k_display_refresh_init;
    out->full_update     = true;
    p->turns_since_clean = 0U;
    return k_ra8_ok;
  }
 
  switch (p->kind) {
    case (uint8_t)k_display_policy_fast_only:
      out->hint        = k_display_refresh_fast;
      out->full_update = false;
      break;
    case (uint8_t)k_display_policy_quality:
      out->hint        = k_display_refresh_quality;
      out->full_update = true;
      break;
    case (uint8_t)k_display_policy_fast_clean:
    default:
      internal_decide_fast_clean(p, event, out);
      break;
  }
  return k_ra8_ok;
}
 
ra8_err_t display_policy_full_rect(uint16_t w, uint16_t h, display_rect_t* out)
{
  RA8_CHECK_NULL_PTR(out, s_tag_policy, "full_rect: null out");
  if ((w == 0U) || (h == 0U)) {
    ra8_log_error(s_tag_policy, "full_rect: zero dimension");
    return k_ra8_err_invalid_arg;
  }
  out->x = 0U;
  out->y = 0U;
  out->w = w;
  out->h = h;
  return k_ra8_ok;
}