kst_panel_int.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "gfx.h"
#include "kst_panel.h"
#include "kst_prog.h"
#include "touch_types.h"
#include "ui_card_text.h"
#include "ui_keypad.h"
#include "ui_layout.h"
#include "ui_tabs.h"
#include "ui_text.h"
#include "ui_textkey.h"
#include "ui_widgets.h"
 
/* ------------------------------------------------------------------ geometry */

#define TAB_Y    8            
#define TAB_H    UI_TAP_MIN   
#define CLOSE_W  120          
#define ROW0     64           
#define PITCH    56           
#define ROW_H    UI_TAP_MIN   
#define VAL_W    150          
#define WIDE_W   260          
#define STEP_W   56           

#define KP_FONT       (&gfx_font_10x20) 
#define KP_TITLE_FONT (&gfx_font_20x36) 
#define KP_CELL       10                
#define LINE_H        20                

#define FOOT_GAP 4
 
/* The plus and minus keys repeat as SETUP's do. */
#define REPEAT_DELAY_S 0.45f            
#define REPEAT_SLOW_HZ 8.0f             
#define REPEAT_FAST_S  1.8f             
#define REPEAT_FAST_HZ 30.0f            
 
enum { PG_SERVO = 0, PG_TUNE, PG_PULSE, PG_FAILSAFE, PG_LOCKED, PG_COUNT };
 
enum { K_FIELD = 0, K_STEP, K_LOCKED, K_ACT };
 
enum {
    A_PORT = 0, A_READ, A_FILES, A_RESTORE, A_MORE, A_ENABLE,
    A_WRITE
};

typedef struct {
    uint8_t page,                           
            row,                            
            col,                            
            wide,                           
            kind,                           
            what;                           
    int16_t label;                      
    const char *name;                   
} row_t;

#define ROW_COUNT 33
extern const row_t kpn_rows[ROW_COUNT];

extern const int16_t kpn_rule[KST_RULE_COUNT];
 
/* -------------------------------------------------------------------- state */
 
enum {
    P_NONE = 0, P_TAB, P_CLOSE, P_ROW, P_MINUS, P_PLUS, P_KEYPAD, P_CHOICE,
    P_CHOICE_CANCEL, P_APPLY, P_CANCEL, P_TEXTKEY, P_NOTES
};
 
enum { C_STRETCH = 0, C_RESTORE, C_MORE, C_FILES };
#define FILES_SAVE (-1)                 
#define FILES_NEXT (-2)
enum { MORE_VERIFY = 0, MORE_DISCARD, MORE_RELEASE, MORE_VOLTAGE,
       MORE_CURRENT, MORE_WAIT };
#define RESTORE_FORGET ((int)KST_PROG_FROM_COUNT)
 
enum { W_SOFT = 0, W_ENABLE, W_WRITE, W_RESTORE, W_RELEASE, W_LEAVE,
       W_CHECK, W_HV };
 
/* The keypad edits what an ENTER asks of the supply, not a row. */
#define KP_VOLTAGE (-1)                 
#define KP_CURRENT (-2)
#define KP_WAIT    (-3)                 
#define CHOICE_MAX 7
#define WARN_LINES 12
#define WARN_ROWS 16
/* The lines a page gives to the warnings of soft limits. */
#define WARN_RULES 7
/* The lines the page of a file gives to its values. */
#define FILE_VALUES 4
#define WARN_TOP 64

typedef struct {
    kst_prog_t prog;                    
    gfx_rect_t area;                    
    bool       open;                    
    uint8_t    note_page;               
    uint32_t   note_sig;
    ui_tabs_t  tabs;                    
    bool       hv;                      
    bool       loaded;                  
    bool       card_look;               
 
    ui_keypad_t kp;                     
    int        kp_row;
 
    ui_textkey_t tk;                    
    char       name[KST_PROG_NAME_MAX];  
    bool       name_wait;               
    bool       files_wait;              
    uint32_t   files_seq;               
 
    struct {
        bool open;                      
        int  kind;                      
        int  count;                     
        char title[64];                 
        char labels[CHOICE_MAX][KST_PANEL_LINE];  
        int  values[CHOICE_MAX];        
    } ch;                               
 
    struct {
        bool      open;                 
        int       kind;                 
        bool      danger;               
        bool      down;                 
        ui_hold_t hold;                 
        int       count;                
        char      title[64];            
        char      apply[64];            
        char      lines[WARN_LINES][KST_PANEL_LINE];  
        uint8_t   level[WARN_LINES];    
        bool      no_file;              
        uint16_t  mv;                   
        kst_prog_restore_t plan;        
    } warn;                             
 
    bool    have;                       
    uint8_t id;                         
    int     pressed;                    
    int     row;                        
    float   held_s;                     
 
    kst_prog_state_t state_seen;        
    uint32_t sig;                       
    uint32_t rev;
    uint32_t hold_rev;                  
 
    /* A limit run's step of the programmer (kst_panel_run_connect()). */
    struct {
        uint8_t  op;                    
        bool     kept;                  
        uint16_t keep_mv,                   
                 keep_ma;                   
        kst_field_id_t want_id[2];      
        uint16_t want[2];               
        unsigned writes;                
        uint32_t said;          
    } run;                              
} kst_panel_state_t;

extern kst_panel_state_t kst_panel_k;
#define k kst_panel_k
 
/* --- the functions one file calls of another ---------------------------- */
 
/* kst_panel.c */

ui_text_id_t kpn_card_text_id(ui_card_at_t at);
const char *kpn_card_tr(ui_card_at_t at);
unsigned kpn_ones(uint64_t v);
uint8_t kpn_port_no(void);
bool kpn_on_port(void);
bool kpn_flag(uint16_t f);
bool kpn_programming(void);
unsigned kpn_servo_type(void);
const char *kpn_row_label(const row_t *r);
const char *kpn_field_name(unsigned id);
bool kpn_in_set(kst_field_set_t set, unsigned id);
const char *kpn_unit_of(kst_field_id_t id);
int kpn_decimals_of(kst_field_id_t id);
void kpn_fmt_value(kst_field_id_t id, uint16_t raw, char *out, size_t n,
                   bool unit);
void kpn_fmt_field(kst_field_id_t id, uint16_t raw, char *out, size_t n);
bool kpn_changed(kst_field_id_t id);
int kpn_text_rows(gfx_canvas_t *c, int x, int y, const char *s,
                  gfx_color_t color);
gfx_rect_t kpn_tabs_rect(void);
int kpn_foot(void);
int kpn_notes_foot(void);
gfx_rect_t kpn_row_rect(const row_t *r);
gfx_rect_t kpn_value_rect(const row_t *r);
gfx_rect_t kpn_step_rect(const row_t *r, bool up);
const row_t *kpn_row_at(int page, int row, int col);
const char *kpn_shown(const char *name);
 
/* kst_panel_text.c */

void kpn_stay_line(char *out, unsigned n);
void kpn_journal_line(char *out, int text, unsigned arg);
void kpn_kind_line(char *out, int text);
void kpn_write_n(char *out, size_t size, unsigned n);
 
/* kst_panel_warn.c */

int kpn_warn_rows(void);
int kpn_warn_room(void);
void kpn_warn_soft(const row_t *r);
void kpn_warn_enable(void);
void kpn_warn_file(void);
void kpn_warn_write(void);
ui_text_id_t kpn_from_text(unsigned from);
void kpn_warn_restore(const kst_prog_restore_t *plan);
void kpn_warn_check(const kst_prog_restore_t *plan);
void kpn_warn_release(void);
void kpn_warn_leave(void);
void kpn_warn_hv(uint16_t mv);
void kpn_warn_apply(void);
 
/* kst_panel_edit.c */

void kpn_close_editors(void);
void kpn_name_done(const char *name);
void kpn_card_moved(void);
void kpn_edit_field(const row_t *r);
void kpn_options_keep(void);
void kpn_options_load(void);
void kpn_keypad_done(float v);
void kpn_step(const row_t *r, bool up);
bool kpn_leave_waits(const kst_prog_t *p);
void kpn_act(const row_t *r);
void kpn_choice_done(int value);
bool kpn_row_live(const row_t *r);
 
/* kst_panel_touch.c */

void kpn_supply_sync(void);
 
/* kst_panel_draw.c */

bool kpn_notes_paged_at(int x, int y);