diff options
Diffstat (limited to 'core.c')
| -rw-r--r-- | core.c | 755 |
1 files changed, 755 insertions, 0 deletions
@@ -0,0 +1,755 @@ +/* core.c - the interaction state machine, independent of any backend. */ +#include "core.h" +#include "draw.h" +#include "font.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#define MAX_LABEL 24 + +struct rect { int x, y, w, h; }; + +struct cell { + struct rect r; /* global coordinates */ + int screen; + char label[MAX_LABEL]; +}; + +enum action { ACT_NONE, ACT_LEFT, ACT_MIDDLE, ACT_RIGHT, ACT_DOUBLE, ACT_DRAG }; + +/* ---- labels ---------------------------------------------------------- */ + +static int label_len(int base, int n) +{ + int len = 1; + long cap = base; + while (cap < n) { + cap *= base; + len++; + } + return len; +} + +static void make_label(char *out, const char *alpha, int base, int len, int idx) +{ + out[len] = 0; + for (int i = len - 1; i >= 0; i--) { + out[i] = alpha[idx % base]; + idx /= base; + } +} + +/* ---- geometry -------------------------------------------------------- */ + +static int fit_scale(int cw, int ch, int len) +{ + int wunit = len * FONT_W + (len - 1); /* label width at scale 1 */ + int sw = (cw * 8 / 10) / wunit; /* fit 80% of cell width */ + int sh = (ch * 6 / 10) / FONT_H; /* fit 60% of cell height */ + int s = sw < sh ? sw : sh; + if (s < 1) + s = 1; + if (s > 8) + s = 8; + return s; +} + +static int screen_at(struct platform *p, int x, int y) +{ + for (int s = 0; s < p->n_screens; s++) { + struct mb_screen c = p->screens[s]; + if (x >= c.x && x < c.x + c.w && y >= c.y && y < c.y + c.h) + return s; + } + return -1; +} + +static int build_cells(const struct config *cfg, struct platform *p, + struct cell **out, int *out_len) +{ + int base = (int)strlen(cfg->alphabet); + int total = 0; + int cols[MB_MAX_SCREENS], rows[MB_MAX_SCREENS]; + + for (int s = 0; s < p->n_screens; s++) { + struct mb_screen sc = p->screens[s]; + int c, r; + if (cfg->cols > 0 && cfg->rows > 0) { + c = cfg->cols; + r = cfg->rows; + } else { + int cs = cfg->cell_size > 0 ? cfg->cell_size : 100; + c = (sc.w + cs / 2) / cs; + r = (sc.h + cs / 2) / cs; + } + if (c < 1) + c = 1; + if (r < 1) + r = 1; + if (c > MB_MAX_GRID_DIM) + c = MB_MAX_GRID_DIM; + if (r > MB_MAX_GRID_DIM) + r = MB_MAX_GRID_DIM; + cols[s] = c; + rows[s] = r; + total += c * r; + } + if (total <= 0) + return 0; + + int len = label_len(base, total); + if (len >= MAX_LABEL) + len = MAX_LABEL - 1; + + struct cell *cells = calloc((size_t)total, sizeof *cells); + if (!cells) + return 0; + + int idx = 0; + for (int s = 0; s < p->n_screens; s++) { + struct mb_screen sc = p->screens[s]; + for (int cy = 0; cy < rows[s]; cy++) { + for (int cx = 0; cx < cols[s]; cx++) { + int x0 = sc.x + cx * sc.w / cols[s]; + int x1 = sc.x + (cx + 1) * sc.w / cols[s]; + int y0 = sc.y + cy * sc.h / rows[s]; + int y1 = sc.y + (cy + 1) * sc.h / rows[s]; + struct cell *cl = &cells[idx]; + cl->r = (struct rect){ x0, y0, x1 - x0, + y1 - y0 }; + cl->screen = s; + make_label(cl->label, cfg->alphabet, base, len, + idx); + idx++; + } + } + } + + *out = cells; + *out_len = len; + return total; +} + +/* ---- rendering ------------------------------------------------------- */ + +/* Begin every screen's overlay and paint the dim backdrop, filling bufs[]. */ +static int frame_begin_dim(struct platform *p, const struct config *cfg, + struct mb_buffer **bufs) +{ + for (int s = 0; s < p->n_screens; s++) { + bufs[s] = p->frame_begin(p, s); + if (!bufs[s]) + return -1; + draw_fill(bufs[s], 0, 0, bufs[s]->w, bufs[s]->h, cfg->color_bg); + } + return 0; +} + +static int render_grid(struct platform *p, const struct config *cfg, + struct cell *cells, int ncells, int len, + const char *typed) +{ + struct mb_buffer *bufs[MB_MAX_SCREENS]; + if (frame_begin_dim(p, cfg, bufs)) + return -1; + + int tlen = (int)strlen(typed); + for (int i = 0; i < ncells; i++) { + struct cell *cl = &cells[i]; + struct mb_buffer *b = bufs[cl->screen]; + struct mb_screen sc = p->screens[cl->screen]; + int lx = cl->r.x - sc.x, ly = cl->r.y - sc.y; + + draw_rect(b, lx, ly, cl->r.w, cl->r.h, 1, cfg->color_grid); + if (tlen && strncmp(cl->label, typed, (size_t)tlen) != 0) + continue; + + int scale = cfg->font_scale > 0 ? cfg->font_scale + : fit_scale(cl->r.w, cl->r.h, len); + const char *lab = cl->label; + int tx = lx + (cl->r.w - text_width(lab, scale)) / 2; + int ty = ly + (cl->r.h - text_height(scale)) / 2; + + if (tlen) { + char pre[MAX_LABEL]; + memcpy(pre, lab, (size_t)tlen); + pre[tlen] = 0; + draw_text(b, tx, ty, pre, scale, cfg->color_typed); + int off = text_width(pre, scale) + scale; + draw_text(b, tx + off, ty, lab + tlen, scale, + cfg->color_label); + } else { + draw_text(b, tx, ty, lab, scale, cfg->color_label); + } + } + return p->frame_commit(p); +} + +/* Draw a refine key centred in its quadrant, while the quadrant is large enough + * for the glyph to be legible; it shrinks away as the region is bisected. */ +static void draw_quad_key(struct mb_buffer *b, int qx, int qy, int qw, int qh, + char key, uint32_t fg) +{ + int smin = qw < qh ? qw : qh; + int scale = (smin / 2) / FONT_W; + if (scale < 1) + return; + if (scale > 6) + scale = 6; + char s[2] = { key, 0 }; + int tx = qx + (qw - text_width(s, scale)) / 2; + int ty = qy + (qh - text_height(scale)) / 2; + draw_text(b, tx, ty, s, scale, fg); +} + +static int render_refine(struct platform *p, const struct config *cfg, + struct rect cur) +{ + struct mb_buffer *bufs[MB_MAX_SCREENS]; + if (frame_begin_dim(p, cfg, bufs)) + return -1; + + int cx = cur.x + cur.w / 2, cy = cur.y + cur.h / 2; + int s = screen_at(p, cx, cy); + if (s < 0) + s = 0; + struct mb_buffer *b = bufs[s]; + struct mb_screen sc = p->screens[s]; + int lx = cur.x - sc.x, ly = cur.y - sc.y; + uint32_t ac = cfg->color_active; + /* Guide lines at ~38% of the active alpha, so they track opacity. */ + uint32_t guide = (ac & 0x00ffffff) | (((ac >> 24) * 0x60 / 0xff) << 24); + + draw_rect(b, lx, ly, cur.w, cur.h, 2, ac); + draw_vline(b, lx + cur.w / 2, ly, cur.h, 1, guide); + draw_hline(b, lx, ly + cur.h / 2, cur.w, 1, guide); + + int hw = cur.w / 2, hh = cur.h / 2; + int rw = cur.w - hw, rh = cur.h - hh; + draw_quad_key(b, lx, ly, hw, hh, cfg->k_tl, cfg->color_label); + draw_quad_key(b, lx + hw, ly, rw, hh, cfg->k_tr, cfg->color_label); + draw_quad_key(b, lx, ly + hh, hw, rh, cfg->k_bl, cfg->color_label); + draw_quad_key(b, lx + hw, ly + hh, rw, rh, cfg->k_br, cfg->color_label); + + int gx = lx + cur.w / 2, gy = ly + cur.h / 2; + draw_hline(b, gx - 12, gy - 1, 25, 2, ac); + draw_vline(b, gx - 1, gy - 12, 25, 2, ac); + return p->frame_commit(p); +} + +/* ---- actions --------------------------------------------------------- */ + +static enum action action_for(const struct config *cfg, uint32_t k) +{ + if (k == MB_KEY_ENTER) + return ACT_LEFT; + if (k > 0x7e) + return ACT_NONE; + char c = (char)k; + if (c == cfg->k_left) + return ACT_LEFT; + if (c == cfg->k_middle) + return ACT_MIDDLE; + if (c == cfg->k_right) + return ACT_RIGHT; + if (c == cfg->k_double) + return ACT_DOUBLE; + if (c == cfg->k_drag) + return ACT_DRAG; + return ACT_NONE; +} + +#define CLICK_MS 12 /* down->up and inter-click gap; 0ms clicks get missed */ + +static int do_click(struct platform *p, enum mb_button b, int times) +{ + for (int i = 0; i < times; i++) { + if (i) + platform_sleep_ms(CLICK_MS); + if (p->pointer_button(p, b, 1)) { + p->pointer_button(p, b, 0); + return -1; + } + platform_sleep_ms(CLICK_MS); + if (p->pointer_button(p, b, 0)) + return -1; + } + return 0; +} + +static int emit(struct platform *p, int dry, int x, int y, enum action a) +{ + static const char *name[] = { "none", "left", "middle", + "right", "double", "drag" }; + if (dry) { + printf("%d %d %s\n", x, y, name[a]); + return 0; + } + if (p->pointer_move(p, x, y)) + return -1; + switch (a) { + case ACT_LEFT: + return do_click(p, MB_LEFT, 1); + case ACT_MIDDLE: + return do_click(p, MB_MIDDLE, 1); + case ACT_RIGHT: + return do_click(p, MB_RIGHT, 1); + case ACT_DOUBLE: + return do_click(p, MB_LEFT, 2); + default: + return 0; + } +} + +/* ---- main flow ------------------------------------------------------- */ + +int core_run(struct platform *p, const struct config *cfg, int dry) +{ + if (cfg->cols > 0 && cfg->rows > 0) { + for (int s = 0; s < p->n_screens; s++) { + if (cfg->cols > p->screens[s].w || + cfg->rows > p->screens[s].h) { + fprintf(stderr, + "mouseboard: grid exceeds screen dimensions\n"); + return 2; + } + } + } + struct cell *cells; + int len; + int ncells = build_cells(cfg, p, &cells, &len); + if (ncells <= 0) { + fprintf(stderr, "mouseboard: no screen cells\n"); + return 2; + } + + enum { GRID, REFINE } state = GRID; + char typed[MAX_LABEL] = ""; + int tn = 0; + struct rect stack[64]; + int sp = 0; + int drag = 0; + int rc = 2; + + if (render_grid(p, cfg, cells, ncells, len, typed)) + goto out; + + for (;;) { + uint32_t k = p->next_key(p); + if (k >= 'A' && k <= 'Z') + k += 'a' - 'A'; /* labels and bindings are lowercase; + makes Caps Lock harmless */ + if (k == MB_KEY_NONE) { + rc = 2; + break; + } + if (k == MB_KEY_ESC) { + rc = 1; + break; + } + + if (state == GRID) { + if (k == MB_KEY_BACKSPACE) { + if (tn) { + typed[--tn] = 0; + if (render_grid(p, cfg, cells, ncells, len, + typed)) + break; + } + continue; + } + if (k < 0x20 || k > 0x7e || tn >= MAX_LABEL - 1) + continue; + + typed[tn] = (char)k; + typed[tn + 1] = 0; + int matches = 0, exact = -1; + for (int i = 0; i < ncells; i++) { + if (strncmp(cells[i].label, typed, + (size_t)(tn + 1))) + continue; + matches++; + if ((int)strlen(cells[i].label) == tn + 1) + exact = i; + } + if (matches == 0) { + typed[tn] = 0; /* reject, keep prompt */ + continue; + } + tn++; + if (exact >= 0 && tn == len) { + stack[0] = cells[exact].r; + sp = 1; + state = REFINE; + struct rect c = stack[0]; + if (!dry) { + if (p->pointer_move(p, c.x + c.w / 2, + c.y + c.h / 2)) + break; + } + if (render_refine(p, cfg, c)) + break; + } else { + if (render_grid(p, cfg, cells, ncells, len, typed)) + break; + } + continue; + } + + /* REFINE */ + struct rect cur = stack[sp - 1]; + if (k == MB_KEY_BACKSPACE) { + if (sp > 1) { + sp--; + cur = stack[sp - 1]; + if (!dry) { + if (p->pointer_move(p, cur.x + cur.w / 2, + cur.y + cur.h / 2)) + break; + } + if (render_refine(p, cfg, cur)) + break; + } else { + state = GRID; + tn = 0; + typed[0] = 0; + if (render_grid(p, cfg, cells, ncells, len, typed)) + break; + } + continue; + } + + char c = (k <= 0x7e) ? (char)k : 0; + int hw = cur.w / 2, hh = cur.h / 2; + int rw = cur.w - hw, rh = cur.h - hh; + struct rect nr; + int split = 1; + if (c && c == cfg->k_tl) + nr = (struct rect){ cur.x, cur.y, hw, hh }; + else if (c && c == cfg->k_tr) + nr = (struct rect){ cur.x + hw, cur.y, rw, hh }; + else if (c && c == cfg->k_bl) + nr = (struct rect){ cur.x, cur.y + hh, hw, rh }; + else if (c && c == cfg->k_br) + nr = (struct rect){ cur.x + hw, cur.y + hh, rw, rh }; + else + split = 0; + + if (split) { + if (sp >= (int)(sizeof stack / sizeof stack[0])) + continue; /* depth limit; the region has been + 1x1 for dozens of splits by now */ + if (nr.w < 1) + nr.w = 1; + if (nr.h < 1) + nr.h = 1; + stack[sp++] = nr; + cur = nr; + if (!dry) { + if (p->pointer_move(p, cur.x + cur.w / 2, + cur.y + cur.h / 2)) + break; + } + if (render_refine(p, cfg, cur)) + break; + continue; + } + + enum action a = action_for(cfg, k); + if (a == ACT_NONE) + continue; + + int tx = cur.x + cur.w / 2, ty = cur.y + cur.h / 2; + if (a == ACT_DRAG && !drag) { + if (dry) + printf("%d %d drag-start\n", tx, ty); + else { + if (p->pointer_move(p, tx, ty)) + break; + if (p->pointer_button(p, MB_LEFT, 1)) { + p->pointer_button(p, MB_LEFT, 0); + break; + } + } + drag = 1; + state = GRID; + tn = 0; + typed[0] = 0; + if (render_grid(p, cfg, cells, ncells, len, typed)) + break; + continue; + } + if (drag) { + if (dry) + printf("%d %d drag-end\n", tx, ty); + else { + if (p->pointer_move(p, tx, ty) || + p->pointer_button(p, MB_LEFT, 0)) + break; + } + drag = 0; + rc = 0; + break; + } + if (emit(p, dry, tx, ty, a)) + break; + rc = 0; + break; + } + +out: + if (drag && !dry && p->pointer_button(p, MB_LEFT, 0)) + rc = 2; + free(cells); + return rc; +} + +/* ---- offline self-test ---------------------------------------------- */ + +static int st_fail; + +static void check(int cond, const char *what) +{ + if (!cond) { + st_fail++; + printf("FAIL: %s\n", what); + } else { + printf("ok: %s\n", what); + } +} + +struct test_platform { + uint32_t keys[8]; + int key_count; + int key_pos; + int commits; + int moves; + int buttons; + int last_x, last_y; + int fail_commit; + int fail_move; + int fail_button_down; + struct mb_buffer buffer; + uint32_t pixels[100 * 80]; +}; + +static struct mb_buffer *test_frame_begin(struct platform *p, int screen) +{ + (void)screen; + return &((struct test_platform *)p->priv)->buffer; +} + +static int test_frame_commit(struct platform *p) +{ + struct test_platform *t = p->priv; + t->commits++; + return t->fail_commit ? -1 : 0; +} + +static uint32_t test_next_key(struct platform *p) +{ + struct test_platform *t = p->priv; + if (t->key_pos >= t->key_count) + return MB_KEY_NONE; + return t->keys[t->key_pos++]; +} + +static int test_pointer_move(struct platform *p, int x, int y) +{ + struct test_platform *t = p->priv; + t->moves++; + t->last_x = x; + t->last_y = y; + return t->fail_move ? -1 : 0; +} + +static int test_pointer_button(struct platform *p, enum mb_button b, int press) +{ + (void)b; + struct test_platform *t = p->priv; + t->buttons++; + if (press && t->fail_button_down) + return -1; + return 0; +} + +static void test_platform_init(struct platform *p, struct test_platform *t) +{ + memset(t, 0, sizeof *t); + *p = (struct platform){ 0 }; + p->n_screens = 1; + p->screens[0] = (struct mb_screen){ 0, 0, 100, 80 }; + p->frame_begin = test_frame_begin; + p->frame_commit = test_frame_commit; + p->next_key = test_next_key; + p->pointer_move = test_pointer_move; + p->pointer_button = test_pointer_button; + p->priv = t; + t->buffer = (struct mb_buffer){ t->pixels, 100, 80, 100, 1 }; +} + +int core_selftest(void) +{ + st_fail = 0; + + /* label length and base conversion */ + check(label_len(2, 4) == 2, "label_len(2,4)==2"); + check(label_len(26, 26) == 1, "label_len(26,26)==1"); + check(label_len(26, 27) == 2, "label_len(26,27)==2"); + + const char *alpha = "abcdef"; + int base = 6, len = label_len(base, 36); + check(len == 2, "len for 36 over base 6 == 2"); + char l0[8], l1[8], l35[8]; + make_label(l0, alpha, base, len, 0); + make_label(l1, alpha, base, len, 1); + make_label(l35, alpha, base, len, 35); + check(!strcmp(l0, "aa"), "label 0 == aa"); + check(!strcmp(l1, "ab"), "label 1 == ab"); + check(!strcmp(l35, "ff"), "label 35 == ff"); + + /* labels are unique across a range */ + int dup = 0; + char seen[36][8]; + for (int i = 0; i < 36; i++) + make_label(seen[i], alpha, base, len, i); + for (int i = 0; i < 36 && !dup; i++) + for (int j = i + 1; j < 36; j++) + if (!strcmp(seen[i], seen[j])) + dup = 1; + check(!dup, "labels unique over full range"); + + /* bisection converges and stays inside the cell */ + struct rect r = { 0, 0, 1000, 800 }; + struct rect cur = r; + for (int i = 0; i < 12; i++) { + int hw = cur.w / 2, hh = cur.h / 2; + cur = (struct rect){ cur.x, cur.y, hw, hh }; /* keep TL */ + } + check(cur.w <= 1 && cur.h <= 1, "bisection shrinks to a point"); + check(cur.x >= r.x && cur.y >= r.y, "bisection stays inside cell"); + + /* config parsing */ + struct config cfg; + config_defaults(&cfg); + check(config_set(&cfg, "color_active", "#112233") == 0, + "parse #RRGGBB"); + check(cfg.color_active == 0xff112233, "color #RRGGBB -> 0xAARRGGBB"); + check(config_set(&cfg, "color_bg", "#11223344") == 0, + "parse #RRGGBBAA"); + check(cfg.color_bg == 0x44112233, "color #RRGGBBAA -> 0xAARRGGBB"); + check(config_set(&cfg, "click_left", "z") == 0, "parse binding"); + check(cfg.k_left == 'z', "binding applied"); + check(config_set(&cfg, "bogus", "x") == -1, "unknown key rejected"); + check(config_set(&cfg, "cell_size", "abc") == -2, "bad int rejected"); + check(config_set(&cfg, "click_left", "Z") == -2, + "uppercase binding rejected"); + check(config_set(&cfg, "alphabet", "abC") == -2, + "uppercase alphabet rejected"); + check(config_set(&cfg, "opacity_bg", "50") == 0, "parse opacity_bg"); + check(config_set(&cfg, "opacity_fg", "150") == -2, + "opacity >100 rejected"); + check(config_validate(&cfg) == NULL, "default config is valid"); + struct config bad = cfg; + bad.rows = 2; + check(config_validate(&bad) != NULL, "incomplete grid rejected"); + bad = cfg; + bad.k_drag = bad.k_tl; + check(config_validate(&bad) != NULL, "binding collision rejected"); + bad = cfg; + bad.font_scale = MB_MAX_FONT_SCALE + 1; + check(config_validate(&bad) != NULL, "excessive font scale rejected"); + + /* opacity_bg drives the backdrop, opacity_fg everything else; the + full-alpha default colours make 100 mean solid */ + struct config oc; + config_defaults(&oc); + config_apply_opacity(&oc); + check((oc.color_bg >> 24) == 0xff * 33 / 100, + "opacity_bg scales backdrop alpha"); + check((oc.color_label >> 24) == 0xff * 65 / 100, + "opacity_fg scales label alpha"); + struct config os; + config_defaults(&os); + os.opacity_bg = 100; + config_apply_opacity(&os); + check((os.color_bg >> 24) == 0xff, "opacity_bg 100 is solid"); + + /* build_cells tiles every screen with uniquely labelled cells */ + struct platform pl = { 0 }; + pl.n_screens = 2; + pl.screens[0] = (struct mb_screen){ 0, 0, 1000, 800 }; + pl.screens[1] = (struct mb_screen){ 1000, 0, 1920, 1080 }; + struct config c2; + config_defaults(&c2); + struct cell *cells; + int clen; + int n = build_cells(&c2, &pl, &cells, &clen); + check(n > 0, "build_cells returns cells"); + long area[2] = { 0, 0 }; + int inside = 1, unique = 1; + for (int i = 0; i < n; i++) { + struct mb_screen sc = pl.screens[cells[i].screen]; + struct rect cr = cells[i].r; + if (cr.x < sc.x || cr.y < sc.y || cr.x + cr.w > sc.x + sc.w || + cr.y + cr.h > sc.y + sc.h) + inside = 0; + area[cells[i].screen] += (long)cr.w * cr.h; + for (int j = i + 1; j < n && unique; j++) + if (!strcmp(cells[i].label, cells[j].label)) + unique = 0; + } + check(inside, "cells stay inside their screen"); + check(area[0] == 1000L * 800 && area[1] == 1920L * 1080, + "cells tile each screen exactly"); + check(unique, "cell labels unique across screens"); + check(n > 0 && (int)strlen(cells[0].label) == clen, + "label length matches build_cells"); + free(cells); + + /* Complete state-machine flows through a fake dependency-free backend. */ + struct platform tp; + struct test_platform ts; + struct config tc; + config_defaults(&tc); + tc.cols = tc.rows = 1; + test_platform_init(&tp, &ts); + ts.keys[0] = (uint32_t)tc.alphabet[0]; + ts.keys[1] = MB_KEY_ENTER; + ts.key_count = 2; + check(core_run(&tp, &tc, 0) == 0, "core click flow succeeds"); + check(ts.moves == 2 && ts.buttons == 2, "click emits move, down and up"); + check(ts.last_x == 50 && ts.last_y == 40, "click targets cell centre"); + + test_platform_init(&tp, &ts); + ts.keys[0] = (uint32_t)tc.alphabet[0]; + ts.keys[1] = (uint32_t)tc.k_drag; + ts.keys[2] = MB_KEY_ESC; + ts.key_count = 3; + check(core_run(&tp, &tc, 0) == 1, "drag cancellation reports cancel"); + check(ts.buttons == 2, "drag cancellation releases held button"); + + test_platform_init(&tp, &ts); + ts.keys[0] = (uint32_t)tc.alphabet[0]; + ts.key_count = 1; + ts.fail_move = 1; + check(core_run(&tp, &tc, 0) == 2, "pointer failure reaches caller"); + check(ts.buttons == 0, "pointer failure emits no click"); + + test_platform_init(&tp, &ts); + ts.fail_commit = 1; + check(core_run(&tp, &tc, 0) == 2, "presentation failure reaches caller"); + + test_platform_init(&tp, &ts); + ts.keys[0] = (uint32_t)tc.alphabet[0]; + ts.keys[1] = MB_KEY_ENTER; + ts.key_count = 2; + ts.fail_button_down = 1; + check(core_run(&tp, &tc, 0) == 2, "button failure reaches caller"); + check(ts.buttons == 2, "failed button press gets release attempt"); + + printf(st_fail ? "\n%d FAILED\n" : "\nall passed\n", st_fail); + return st_fail ? 1 : 0; +} |