prog_registry.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "gfx.h"
#include "touch_types.h"
#include "ui_text.h"
#include "ui_workbench.h"
 
#ifdef __cplusplus
extern "C" {
#endif

typedef enum {
    PROG_DEV_SERVO = 0,
    PROG_DEV_MOTOR,
    PROG_DEVICES
} prog_device_t;

#define PROG_REG_NO_PORT 0xFFu
#define PROG_REG_NO_PIN  0xFFu
#define PROG_REG_PORTS   4u
#define PROG_REG_TESTER_PORT 0xFEu
 
/*
 * A function that calls one hook of a page set and nothing else through a
 * pointer: tools/stack_check.py follows the call by the function's name
 * (PROG_CALLS), so the compiler may neither inline it nor clone it under
 * another name.
 */
#if defined(__GNUC__) && !defined(__clang__)
#define PROG_ONE_CALL __attribute__((noinline, noclone))
#else
#define PROG_ONE_CALL __attribute__((noinline))
#endif

#define PROG_FULL_STRIP_X    12  
#define PROG_FULL_STRIP_Y    4   
#define PROG_FULL_STRIP_H    20  
#define PROG_FULL_Y          28  
#define PROG_FULL_STRIP_FONT (&gfx_font_10x20) 
#define PROG_FULL_STRIP_CELLS 100

#define PROG_LIST_SEARCH_OVER   9
#define PROG_LIST_HEADINGS_OVER 8
#define PROG_LIST_MAX           48
#define PROG_LIST_QUERY_MAX     16

typedef struct {
    void       (*init)(gfx_rect_t area);
    void       (*entry)(void);
    void       (*open)(void);
    bool       (*is_open)(void);
    void       (*back)(void);
    bool       (*holds_port)(void);
    void       (*armed)(bool armed);
    void       (*tick)(float dt_s);
    bool       (*has_press)(uint8_t id);
    void       (*event)(const touch_event_t *evt);
    void       (*render)(gfx_canvas_t *c);
    uint32_t   (*revision)(void);
    uint32_t   (*hold_revision)(void);
    gfx_rect_t (*hold_rect)(void);
    void       (*leave)(void);
    void       (*cancel)(void);
    uint8_t    (*pin)(void);
    bool       (*safe_at)(int x, int y);
} prog_page_set_t;
 
typedef struct {
    uint8_t                device;           
    uint8_t                task;             
    ui_text_id_t           name;
    ui_text_id_t           group;
    ui_text_id_t           transport;
    uint8_t                port;             
    uint16_t               needs_capability; 
    const prog_page_set_t *page_set;
    bool                   full_width;
} prog_reg_row_t;

const prog_reg_row_t *prog_registry(size_t *count);

void prog_registry_use(const prog_reg_row_t *rows, size_t count);

void prog_registry_set_ports(uint8_t tester_port, uint8_t held);

uint8_t prog_reg_port(const prog_reg_row_t *r);

bool prog_reg_servo_holds(void);
 
/* ------------------------------------------------------------ the checks */
 
typedef enum {
    PROG_REG_OK = 0,
    PROG_REG_BAD_DEVICE,     
    PROG_REG_BAD_TASK,       
    PROG_REG_NO_NAME,        
    PROG_REG_NO_GROUP,       
    PROG_REG_NO_TRANSPORT,   
    PROG_REG_BAD_PORT,       
    PROG_REG_NO_PAGE_SET,    
    PROG_REG_SAME_NAME,      
    PROG_REG_TOO_MANY,       
    PROG_REG_BAD_WIDTH,
} prog_reg_fault_t;

prog_reg_fault_t prog_reg_check(const prog_reg_row_t *rows, size_t n,
                                size_t *at);
 
/* ------------------------------------------------- a device's sessions */

int prog_reg_sets(uint8_t device, const prog_page_set_t *out[PROG_LIST_MAX]);

bool prog_reg_full_width(const prog_page_set_t *ps);
 
/*
 * A page set's hooks, each called from one function of its own, so
 * tools/stack_check.py follows the call by name (PROG_CALLS there).  The
 * hosts call a session through these and through nothing else.
 */
void prog_ps_init(const prog_page_set_t *ps, gfx_rect_t area);
void prog_ps_entry(const prog_page_set_t *ps);
void prog_ps_open(const prog_page_set_t *ps);
bool prog_ps_is_open(const prog_page_set_t *ps);
void prog_ps_back(const prog_page_set_t *ps);
bool prog_ps_holds(const prog_page_set_t *ps);
void prog_ps_armed(const prog_page_set_t *ps, bool armed);
void prog_ps_tick(const prog_page_set_t *ps, float dt_s);
bool prog_ps_has_press(const prog_page_set_t *ps, uint8_t id);
void prog_ps_event(const prog_page_set_t *ps, const touch_event_t *evt);
void prog_ps_render(const prog_page_set_t *ps, gfx_canvas_t *c);
uint32_t prog_ps_revision(const prog_page_set_t *ps);
uint32_t prog_ps_hold_revision(const prog_page_set_t *ps);
gfx_rect_t prog_ps_hold_rect(const prog_page_set_t *ps);
void prog_ps_leave(const prog_page_set_t *ps);
void prog_ps_cancel(const prog_page_set_t *ps);
uint8_t prog_ps_pin(const prog_page_set_t *ps);
bool prog_ps_safe_at(const prog_page_set_t *ps, int x, int y);
 
/* ------------------------------------------------------- a row's state */
 
typedef enum {
    PROG_ROW_LIVE = 0,       
    PROG_ROW_NO_CAP,         
    PROG_ROW_PORT_BUSY,      
} prog_row_state_t;

prog_row_state_t prog_reg_state(const prog_reg_row_t *rows, size_t n,
                                size_t i, uint16_t caps);

uint16_t prog_reg_missing(const prog_reg_row_t *row, uint16_t caps);

const char *prog_reg_cap_name(uint16_t bit);

bool prog_reg_detail(const prog_reg_row_t *rows, size_t n, size_t i,
                     uint16_t caps, char *out, size_t size);
 
/* -------------------------------------------------------- the list model */

typedef struct {
    uint8_t row;             
    bool    heading;
} prog_list_entry_t;
 
typedef struct {
    uint8_t total;           
    uint8_t rows;            
    uint8_t count;           
    bool    search;          
    bool    headings;        
    prog_list_entry_t e[2 * PROG_LIST_MAX];
} prog_list_t;

void prog_list_build(prog_list_t *l, const prog_reg_row_t *rows, size_t n,
                     uint8_t device, uint8_t task, const char *query);
 
/* --------------------------------------------------------------- the view */

#define PROG_VIEW_PAD      10   
#define PROG_VIEW_BAR_H    48   
#define PROG_VIEW_ROW_H    48   
#define PROG_VIEW_ROW_P    56   
#define PROG_VIEW_HEAD_H   28   
#define PROG_VIEW_HEAD_P   32   
#define PROG_VIEW_SEARCH_W 260  
#define PROG_VIEW_KEY_W    56   
#define PROG_VIEW_FONT     (&gfx_font_10x20) 

enum { PROG_VIEW_P_NONE = -1, PROG_VIEW_P_SEARCH = -2, PROG_VIEW_P_UP = -3,
       PROG_VIEW_P_DOWN = -4 };
 
typedef struct {
    gfx_rect_t area;
    int        top;          
    int        pressed;      
    uint8_t    id;           
    char       query[PROG_LIST_QUERY_MAX + 1];
} prog_view_t;
 
typedef enum {
    PROG_VIEW_NONE = 0,      
    PROG_VIEW_TAKEN,         
    PROG_VIEW_ROW,           
    PROG_VIEW_SEARCH,        
} prog_view_ev_t;
 
void prog_view_init(prog_view_t *v, gfx_rect_t area);

void prog_view_top(prog_view_t *v);

bool prog_view_has_bar(const prog_view_t *v, const prog_list_t *l);

int prog_view_shown(const prog_view_t *v, const prog_list_t *l);

gfx_rect_t prog_view_entry_rect(const prog_view_t *v, const prog_list_t *l,
                                int k);

gfx_rect_t prog_view_search_rect(const prog_view_t *v, const prog_list_t *l);
gfx_rect_t prog_view_up_rect(const prog_view_t *v, const prog_list_t *l);
gfx_rect_t prog_view_down_rect(const prog_view_t *v, const prog_list_t *l);

prog_view_ev_t prog_view_event(prog_view_t *v, const prog_list_t *l,
                               const touch_event_t *evt, uint8_t *row);

void prog_view_cancel(prog_view_t *v);

void prog_view_render(const prog_view_t *v, const prog_list_t *l,
                      const prog_reg_row_t *rows, size_t n, uint16_t caps,
                      const char *query, gfx_canvas_t *c);
 
#ifdef __cplusplus
}
#endif