ui_widgets.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
 
#include "gfx.h"
#include "ui_icons.h"
#include "ui_theme.h"
 
#ifdef __cplusplus
extern "C" {
#endif

void ui_panel(gfx_canvas_t *c, gfx_rect_t r, const char *title,
              gfx_color_t accent);

void ui_panel_header(gfx_canvas_t *c, gfx_rect_t r, const char *title,
                     gfx_color_t accent);

void ui_button(gfx_canvas_t *c, gfx_rect_t r, const char *label,
               gfx_color_t fill, bool pressed, bool enabled);

gfx_color_t ui_button_off_fill(void);

void ui_button_font(gfx_canvas_t *c, gfx_rect_t r, const char *label,
                    gfx_color_t fill, bool pressed, bool enabled,
                    const gfx_font_t *f);

bool ui_is_light(gfx_color_t c);

bool ui_text_fits(const gfx_font_t *f, const char *s, int w, int h, int pad);

const gfx_font_t *ui_button_face(const char *label, int w, int h, int pad,
                                 const gfx_font_t *big,
                                 const gfx_font_t *small);

#define UI_KEYS_FOOT (UI_ALERT_Y - UI_BAND_H - 4)

void ui_card(gfx_canvas_t *c, gfx_rect_t r, gfx_color_t fill);

int ui_text_wrap(gfx_canvas_t *c, gfx_rect_t first, int pitch, const char *t,
                 const gfx_font_t *f, gfx_color_t col);

typedef struct {
    int16_t icon_dy;          
    int16_t icon;             
    int16_t name_dy;          
    int16_t line_dy;          
    int16_t line_pitch;       
    const gfx_font_t *name_f; 
    const gfx_font_t *line_f; 
} ui_tile_look_t;

#define UI_TILE_PAD 8

void ui_tile(gfx_canvas_t *c, gfx_rect_t r, const ui_tile_look_t *look,
             ui_icon_fn icon, const char *name, const char *line,
             bool pressed);

#define UI_PILL_INSET 24
void ui_pill(gfx_canvas_t *c, gfx_rect_t r, const char *label,
             gfx_color_t dot, gfx_color_t fill);

void ui_pill_font(gfx_canvas_t *c, gfx_rect_t r, const char *label,
                  gfx_color_t dot, gfx_color_t fill, int inset,
                  const gfx_font_t *f);

void ui_pill_ink(gfx_canvas_t *c, gfx_rect_t r, const char *label,
                 gfx_color_t dot, gfx_color_t fill, gfx_color_t ink,
                 int inset, const gfx_font_t *f);

void ui_bar(gfx_canvas_t *c, gfx_rect_t r, float frac, float peak_frac,
            gfx_color_t color);

void ui_value(gfx_canvas_t *c, gfx_rect_t box, const char *number,
              const char *unit, gfx_color_t color);

void ui_fmt(char *out, size_t n, float value, int decimals);

void ui_clock(char *out, size_t n, uint32_t seconds);
 
/*
 * The home tag, at the same place at the top left of every screen that has
 * one: 44px tall (6.6mm), 8px from the band's top and left edges, the
 * title in UI_FONT_TAG (20 x 36).  The router hit-tests it before the
 * screen sees the event.
 */
#define UI_TAG_X 8
#define UI_TAG_Y 8
#define UI_TAG_H 44

gfx_rect_t ui_home_tag_rect(const char *title);

void ui_home_tag(gfx_canvas_t *c, const char *title, bool pressed);

void ui_wordmark(gfx_canvas_t *c, const char *text, gfx_color_t fill);

void ui_chevron_left(gfx_canvas_t *c, int x, int cy, int size, gfx_color_t color);

void ui_rule(gfx_canvas_t *c, int x, int y, int w, gfx_color_t color);
 
/* ----------------------------------------------------------- choice list */
 
/*
 * A list that opens over the screen: a face that names the choice, and the
 * rows it opens into.  The chevron on the face says it opens rather than
 * steps, which is the difference between this and a settings row.  The
 * outputs screen's protocol list and the pin picker's are this one.
 *
 * A face or a row UI_CHOICE_ROW_H (56px, 8.4mm) tall or taller draws its
 * text in the type scale's head face, 20 x 36 (UI_FONT_TAG), when the text
 * fits; a shorter one, and a text that does not fit, in the 16 x 28 face
 * (UI_FONT_HEAD).  A screen takes the larger face with the row height its
 * own layout gives.  The text is centred in the face's and each row's
 * height.  A face takes 10px before its text and 33px after it for a
 * 7px chevron, 12px and 43px for an 11px one when tall; a row 12px
 * before and after its text.  Each face and row picks its own face: the
 * rows of one list can differ where one name does not fit.
 */
#define UI_CHOICE_ROW_H 56

const gfx_font_t *ui_choice_font(int h);

const gfx_font_t *ui_choice_text_font(int h, int w, const char *text);
 
void ui_choice_face(gfx_canvas_t *c, gfx_rect_t r, const char *text,
                    bool pressed, bool open);

void ui_choice_face_locked(gfx_canvas_t *c, gfx_rect_t r, const char *text);

void ui_choice_list(gfx_canvas_t *c, gfx_rect_t r);

void ui_choice_row(gfx_canvas_t *c, gfx_rect_t r, const char *text,
                   bool chosen, bool pressed);
 
/* ------------------------------------------------------- hold-to-confirm */
 
/*
 * A button that is held rather than pressed, and what it looks like while it
 * is held.
 *
 * Two seconds of contact, the fill fading from where it starts to where it
 * ends across them, and the whole button flashing twice as the command goes.
 * ARM uses it because a bench should not spin a propeller on a touch that
 * could have been an elbow; the bus-fault screen uses it because an
 * acknowledgement that can be given by brushing the panel is not one.
 *
 * The timing, the colours and the rules are all here: two screens can arm
 * the bench, and a safety control that behaves differently on one of them is
 * a control the operator has to learn twice.
 */
#define UI_HOLD_S 2.0f
 
/*
 * The most one frame can add to a hold.  A frame's duration is measured at
 * its top and applied at its end, so without a cap a single late frame
 * completes a hold that began inside that same frame.  0.25s puts at least
 * eight frames with the press standing between a press and an arm.
 */
#define UI_HOLD_MAX_CREDIT_S 0.25f

#define UI_HOLD_FLASH_PHASE_MS 25
#define UI_HOLD_FLASH_CYCLE    3
#define UI_HOLD_FLASH_TIMES    2
#define UI_HOLD_FLASH_MS \
    (UI_HOLD_FLASH_PHASE_MS * UI_HOLD_FLASH_CYCLE * UI_HOLD_FLASH_TIMES)

gfx_color_t ui_hold_fill(gfx_color_t base, gfx_color_t target, float held_s);

gfx_color_t ui_hold_flash(gfx_color_t settled, int ms_left);

typedef struct {
    float held_s;      
    bool  down;        
    bool  fired;       
    int   flash_ms;    
    bool  flash_new;   
} ui_hold_t;

void ui_hold_reset(ui_hold_t *h);

void ui_hold_begin(ui_hold_t *h);

bool ui_hold_leave(ui_hold_t *h);

bool ui_hold_end(ui_hold_t *h);

float ui_hold_credit(float dt_s);

bool ui_hold_tick(ui_hold_t *h, float dt_s);

void ui_hold_reached(ui_hold_t *h);

bool ui_hold_left(ui_hold_t *h);

void ui_hold_flash_step(ui_hold_t *h, float dt_s);

int ui_hold_flash_left(int ms_left, float dt_s);
 
#ifdef __cplusplus
}
#endif