ra8_keyboard.c

Go to the documentation of this file.

 
#include "ra8_keyboard.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_ui.h"

static const char* s_tag = "KBD";

typedef enum : int32_t {
  k_kbd_hu_div    = 20, 
  k_kbd_key_hu    = 2,  
  k_kbd_wide_hu   = 3,  
  k_kbd_inset_hu  = 1,  
  k_kbd_act_hu    = 4,  
  k_kbd_space_hu  = 12, 
  k_kbd_top_keys  = 10, 
  k_kbd_mid_keys  = 9,  
  k_kbd_r2_lett   = 7,  
  k_kbd_punct_n   = 5,  
  k_kbd_punct_hu0 = 5,  
  k_kbd_sym1_n    = 7,  
  k_kbd_sym1_hu0  = 3,  
  k_kbd_row1      = 1,  
  k_kbd_row2      = 2,  
  k_kbd_row3      = 3,  
} kbd_geom_t;
 
/* Letters layer rows. */
static const char s_l_r0_lo[] = "qwertyuiop";
static const char s_l_r0_hi[] = "QWERTYUIOP";
static const char s_l_r1_lo[] = "asdfghjkl";
static const char s_l_r1_hi[] = "ASDFGHJKL";
static const char s_l_r2_lo[] = "zxcvbnm";
static const char s_l_r2_hi[] = "ZXCVBNM";
/* Numbers layer rows (no shift effect: upper == lower). */
static const char s_n_r0[] = "1234567890";
static const char s_n_r1[] = "-/:;()$&@\"";
/* Symbols layer rows. Goal: every printable 7-bit ASCII symbol is reachable.
 * The 32 ASCII symbols are split across the numbers row 1 (10), the shared
 * punctuation row (5), and these two symbols rows (10 + 7) = 32, no repeats. */
static const char s_s_r0[] = "[]{}#%^*+=";
static const char s_s_r1[] = "<>\\_`|~";
/* Shared third-row punctuation for the numbers + symbols layers. */
static const char s_punct[] = ".,?!'";

RA8_INTERNAL static void internal_add(ra8_kbd_layout_t*  kb,
                                      int32_t            x,
                                      int32_t            w,
                                      int32_t            y,
                                      int32_t            h,
                                      char               lo,
                                      char               hi,
                                      ra8_kbd_key_kind_t kind,
                                      uint8_t            aux)
{
  if (kb->count >= (uint8_t)k_ra8_kbd_max_keys) {
    return;
  }
  ra8_kbd_key_t* k = &kb->keys[kb->count];
  k->rect.x        = x;
  k->rect.y        = y;
  k->rect.w        = w;
  k->rect.h        = h;
  k->ch_lower      = lo;
  k->ch_upper      = hi;
  k->kind          = kind;
  k->aux           = aux;
  kb->count++;
}

RA8_INTERNAL static int32_t internal_hx(const ra8_ui_rect_t* f, int32_t hu)
{
  return f->x + ((f->w * hu) / (int32_t)k_kbd_hu_div);
}

RA8_INTERNAL static void internal_place(ra8_kbd_layout_t*    kb,
                                        const char*          lo,
                                        const char*          hi,
                                        int32_t              n,
                                        int32_t              hu0,
                                        const ra8_ui_rect_t* f,
                                        int32_t              y,
                                        int32_t              rh)
{
  for (int32_t i = 0; i < n; i++) {
    const int32_t x0 = internal_hx(f, hu0 + (i * (int32_t)k_kbd_key_hu));
    const int32_t x1 = internal_hx(f, hu0 + ((i + 1) * (int32_t)k_kbd_key_hu));
    internal_add(kb,
                 x0,
                 x1 - x0,
                 y,
                 rh,
                 (char)lo[i],
                 (char)((hi != nullptr) ? hi[i] : lo[i]),
                 k_ra8_kbd_key_char,
                 0U);
  }
}

RA8_INTERNAL static void internal_span(ra8_kbd_layout_t*    kb,
                                       int32_t              a,
                                       int32_t              b,
                                       const ra8_ui_rect_t* f,
                                       int32_t              y,
                                       int32_t              rh,
                                       ra8_kbd_key_kind_t   kind,
                                       uint8_t              aux)
{
  const int32_t x0 = internal_hx(f, a);
  internal_add(kb, x0, internal_hx(f, b) - x0, y, rh, 0, 0, kind, aux);
}

RA8_INTERNAL static void internal_row_punct(ra8_kbd_layout_t*    kb,
                                            const ra8_ui_rect_t* f,
                                            int32_t              y,
                                            int32_t              rh,
                                            uint8_t              tog_aux)
{
  internal_span(kb, 0, (int32_t)k_kbd_act_hu, f, y, rh, k_ra8_kbd_key_layer, tog_aux);
  internal_place(kb, s_punct, nullptr, (int32_t)k_kbd_punct_n, (int32_t)k_kbd_punct_hu0, f, y, rh);
  internal_span(kb,
                (int32_t)k_kbd_hu_div - (int32_t)k_kbd_act_hu,
                (int32_t)k_kbd_hu_div,
                f,
                y,
                rh,
                k_ra8_kbd_key_backspace,
                0U);
}

RA8_INTERNAL static void internal_row_bottom(ra8_kbd_layout_t*    kb,
                                             const ra8_ui_rect_t* f,
                                             int32_t              y,
                                             int32_t              rh,
                                             uint8_t              left_aux)
{
  internal_span(kb, 0, (int32_t)k_kbd_act_hu, f, y, rh, k_ra8_kbd_key_layer, left_aux);
  internal_span(kb,
                (int32_t)k_kbd_act_hu,
                (int32_t)k_kbd_act_hu + (int32_t)k_kbd_space_hu,
                f,
                y,
                rh,
                k_ra8_kbd_key_space,
                0U);
  internal_span(kb,
                (int32_t)k_kbd_hu_div - (int32_t)k_kbd_act_hu,
                (int32_t)k_kbd_hu_div,
                f,
                y,
                rh,
                k_ra8_kbd_key_enter,
                0U);
}

RA8_INTERNAL static void
internal_build_letters(ra8_kbd_layout_t* kb, const ra8_ui_rect_t* f, int32_t rh)
{
  const int32_t fy = f->y;
  internal_place(kb, s_l_r0_lo, s_l_r0_hi, (int32_t)k_kbd_top_keys, 0, f, fy, rh);
  internal_place(kb,
                 s_l_r1_lo,
                 s_l_r1_hi,
                 (int32_t)k_kbd_mid_keys,
                 (int32_t)k_kbd_inset_hu,
                 f,
                 fy + rh,
                 rh);
  const int32_t y2 = fy + ((int32_t)k_kbd_row2 * rh);
  internal_span(kb, 0, (int32_t)k_kbd_wide_hu, f, y2, rh, k_ra8_kbd_key_shift, 0U);
  internal_place(kb,
                 s_l_r2_lo,
                 s_l_r2_hi,
                 (int32_t)k_kbd_r2_lett,
                 (int32_t)k_kbd_wide_hu,
                 f,
                 y2,
                 rh);
  internal_span(kb,
                (int32_t)k_kbd_hu_div - (int32_t)k_kbd_wide_hu,
                (int32_t)k_kbd_hu_div,
                f,
                y2,
                rh,
                k_ra8_kbd_key_backspace,
                0U);
  internal_row_bottom(kb, f, fy + ((int32_t)k_kbd_row3 * rh), rh, (uint8_t)k_ra8_kbd_layer_numbers);
}

RA8_INTERNAL static void
internal_build_numbers(ra8_kbd_layout_t* kb, const ra8_ui_rect_t* f, int32_t rh)
{
  const int32_t fy = f->y;
  internal_place(kb, s_n_r0, nullptr, (int32_t)k_kbd_top_keys, 0, f, fy, rh);
  internal_place(kb, s_n_r1, nullptr, (int32_t)k_kbd_top_keys, 0, f, fy + rh, rh);
  internal_row_punct(kb, f, fy + ((int32_t)k_kbd_row2 * rh), rh, (uint8_t)k_ra8_kbd_layer_symbols);
  internal_row_bottom(kb, f, fy + ((int32_t)k_kbd_row3 * rh), rh, (uint8_t)k_ra8_kbd_layer_letters);
}

RA8_INTERNAL static void
internal_build_symbols(ra8_kbd_layout_t* kb, const ra8_ui_rect_t* f, int32_t rh)
{
  const int32_t fy = f->y;
  internal_place(kb, s_s_r0, nullptr, (int32_t)k_kbd_top_keys, 0, f, fy, rh);
  internal_place(kb,
                 s_s_r1,
                 nullptr,
                 (int32_t)k_kbd_sym1_n,
                 (int32_t)k_kbd_sym1_hu0,
                 f,
                 fy + rh,
                 rh);
  internal_row_punct(kb, f, fy + ((int32_t)k_kbd_row2 * rh), rh, (uint8_t)k_ra8_kbd_layer_numbers);
  internal_row_bottom(kb, f, fy + ((int32_t)k_kbd_row3 * rh), rh, (uint8_t)k_ra8_kbd_layer_letters);
}

RA8_INTERNAL static void internal_build_layer(ra8_kbd_layout_t* kb)
{
  kb->count        = 0U;
  const int32_t rh = kb->frame.h / (int32_t)k_ra8_kbd_rows;
  if (kb->layer == (uint8_t)k_ra8_kbd_layer_numbers) {
    internal_build_numbers(kb, &kb->frame, rh);
  } else if (kb->layer == (uint8_t)k_ra8_kbd_layer_symbols) {
    internal_build_symbols(kb, &kb->frame, rh);
  } else {
    internal_build_letters(kb, &kb->frame, rh);
  }
}
 
[[nodiscard]] ra8_err_t ra8_kbd_layout_init(ra8_kbd_layout_t* kb, const ra8_ui_rect_t* frame)
{
  RA8_CHECK_NULL_PTR(kb, s_tag, "kb must not be nullptr");
  RA8_CHECK_NULL_PTR(frame, s_tag, "frame must not be nullptr");
  /* Decision (MC/DC): reject a frame with no area. */
  if ((frame->w <= 0) || (frame->h <= 0)) {
    return k_ra8_err_invalid_arg;
  }
  kb->frame = *frame;
  kb->shift = false;
  kb->layer = (uint8_t)k_ra8_kbd_layer_letters;
  internal_build_layer(kb);
  return k_ra8_ok;
}
 
[[nodiscard]] uint8_t ra8_kbd_hit(const ra8_kbd_layout_t* kb, int32_t px, int32_t py)
{
  if (kb == nullptr) {
    return (uint8_t)k_ra8_kbd_no_hit;
  }
  for (uint8_t i = 0U; i < kb->count; i++) {
    if (ra8_ui_rect_contains(&kb->keys[i].rect, px, py)) {
      return i;
    }
  }
  return (uint8_t)k_ra8_kbd_no_hit;
}
 
[[nodiscard]] char ra8_kbd_key_glyph(const ra8_kbd_layout_t* kb, uint8_t key_idx)
{
  if ((kb == nullptr) || (key_idx >= kb->count)) {
    return (char)0;
  }
  const ra8_kbd_key_t* k = &kb->keys[key_idx];
  if (k->kind != k_ra8_kbd_key_char) {
    return (char)0;
  }
  return (char)(kb->shift ? k->ch_upper : k->ch_lower);
}
 
[[nodiscard]] ra8_err_t ra8_kbd_text_init(ra8_kbd_text_t* t)
{
  RA8_CHECK_NULL_PTR(t, s_tag, "t must not be nullptr");
  t->len       = 0U;
  t->buf[0]    = '\0';
  t->committed = false;
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_append(ra8_kbd_text_t* t, char ch)
{
  if (t->len < (uint8_t)((uint8_t)k_ra8_kbd_text_max - 1U)) {
    t->buf[t->len] = ch;
    t->len++;
    t->buf[t->len] = '\0';
  }
}
 
[[nodiscard]] ra8_err_t ra8_kbd_apply(ra8_kbd_text_t* t, ra8_kbd_layout_t* kb, uint8_t key_idx)
{
  RA8_CHECK_NULL_PTR(t, s_tag, "t must not be nullptr");
  RA8_CHECK_NULL_PTR(kb, s_tag, "kb must not be nullptr");
  if (key_idx >= kb->count) {
    return k_ra8_ok; /* no-hit sentinel or out of range -> no-op */
  }
  const ra8_kbd_key_t* k = &kb->keys[key_idx];
  switch (k->kind) {
    case k_ra8_kbd_key_char:
      internal_append(t, (char)(kb->shift ? k->ch_upper : k->ch_lower));
      kb->shift = false; /* one-shot SHIFT clears after a character */
      break;
    case k_ra8_kbd_key_space:
      internal_append(t, ' ');
      kb->shift = false;
      break;
    case k_ra8_kbd_key_backspace:
      if (t->len > 0U) {
        t->len--;
        t->buf[t->len] = '\0';
      }
      break;
    case k_ra8_kbd_key_enter:
      t->committed = true;
      break;
    case k_ra8_kbd_key_shift:
      kb->shift = !kb->shift;
      break;
    case k_ra8_kbd_key_layer:
      kb->layer = k->aux;
      kb->shift = false;
      internal_build_layer(kb); /* re-lay the grid for the new layer */
      break;
    default:
      break;
  }
  return k_ra8_ok;
}