files_int.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
#include "card_tree.h"
#include "files_screen.h"
#include "fm_req.h"
#include "fm_rules.h"
#include "fm_tree.h"
#include "gfx.h"
#include "touch_types.h"
#include "ui_layout.h"
#include "ui_text.h"
#include "ui_textkey.h"
#include "ui_widgets.h"
 
#define SCREEN_W UI_PANEL_W  
#define SCREEN_H UI_BODY_H
#define MAX_FBS  3           

#define FS_FONT_LABEL (&gfx_font_10x20)
#define FS_FONT_FINE  (&gfx_font_8x16)   
#define FS_FONT_BODY  (&gfx_font_12x24)  

#define FS_L UI_MARGIN
#define FS_R (SCREEN_W - UI_MARGIN)   
#define FS_W (FS_R - FS_L)            
 
/* ---------------------------------------------------------------- panes */

#define FS_PANE_W   500
#define FS_PANE_GAP 8                                
#define FS_PANE_X(i) (FS_L + (i) * (FS_PANE_W + FS_PANE_GAP))
#define FS_HDR_Y    4                                
#define FS_HDR_H    UI_TAP_MIN                       
#define FS_PG_W     88          
#define FS_UP_W     312         
#define FS_UP(i)    gfx_rect_make(FS_PANE_X(i), FS_HDR_Y, FS_UP_W, FS_HDR_H)
#define FS_PREV(i)  gfx_rect_make(FS_PANE_X(i) + FS_PANE_W - 2 * FS_PG_W - 4, \
                                  FS_HDR_Y, FS_PG_W, FS_HDR_H)

#define FS_NEXT(i)  gfx_rect_make(FS_PANE_X(i) + FS_PANE_W - FS_PG_W, \
                                  FS_HDR_Y, FS_PG_W, FS_HDR_H)
#define FS_LIST_Y   60          
#define FS_HEAD_H   30          
#define FS_ROW_H    48          
#define FS_ROWS     6           
#define FS_LIST(i)  gfx_rect_make(FS_PANE_X(i), FS_LIST_Y, FS_PANE_W, \
                                  FS_HEAD_H + FS_ROWS * FS_ROW_H + 4)
#define FS_BAR_W    56          
#define FS_BAR_MIN  32          
#define FS_BAR(i)   gfx_rect_make(FS_PANE_X(i) + FS_PANE_W - 8 - FS_BAR_W, \
                                  FS_LIST_Y + FS_HEAD_H, FS_BAR_W, \
                                  FS_ROWS * FS_ROW_H - 4)
#define FS_ROW_IN   8           
#define FS_ROW_W    (FS_PANE_W - FS_ROW_IN - 8 - FS_BAR_W - 8)
#define FS_ICON     24          
#define FS_SIZE_W   90          

#define FS_MSG_Y    388
#define FS_MSG_LH   24          

#define FOOT_H       52
#define FOOT_Y       (SCREEN_H - UI_ALERT_H - 4 - FOOT_H)  
#define FOOT_W       118        
#define FOOT_W_FIRST 140        
#define FOOT_GAP     6          
#define FOOT_PAD     6          
#define FOOT_N       8          
#define FS_FOOT_X(i) (FS_L + (((i) == 0) ? 0 \
                              : FOOT_W_FIRST + FOOT_GAP \
                                    + ((i) - 1) * (FOOT_W + FOOT_GAP)))

#define FS_FOOT(i)   gfx_rect_make(FS_FOOT_X(i), FOOT_Y, \
                                   ((i) == 0) ? FOOT_W_FIRST : FOOT_W, \
                                   FOOT_H)

typedef enum {
    FS_RESCAN = 0,
    FS_COPY,
    FS_MOVE,
    FS_RENAME,
    FS_DELETE,
    FS_NEW,
    FS_INFO,
    FS_OPEN
} fs_foot_t;
 
_Static_assert(FS_RESCAN == 0, "RESCAN is the first, wide button");
_Static_assert(FS_OPEN == FOOT_N - 1, "OPEN is the last button");
 
/* ---------------------------------------------------------------- boxes */

#define FS_BOX_Y      100       
#define FS_BOX_H      280       
#define FS_BOX        gfx_rect_make(162, FS_BOX_Y, 700, FS_BOX_H)
#define FS_Q_CANCEL   gfx_rect_make(186, 304, 300, 56)  
#define FS_Q_DELETE   gfx_rect_make(538, 304, 300, 56)  
#define FS_JOB_CANCEL gfx_rect_make(362, 304, 300, 56)
#define FS_JOB_BAR    gfx_rect_make(186, 228, 652, 24)

#define FS_INFO_Y     20        
#define FS_INFO_H     420       
#define FS_INFO_BOX   gfx_rect_make(112, FS_INFO_Y, 800, FS_INFO_H)
#define FS_INFO_LH    32        
#define FS_INFO_KEY_W 160       
#define FS_INFO_CLOSE gfx_rect_make(362, 364, 300, 56)  

#define FS_NEW_W      300                             
#define FS_NEW_ROW_H  UI_CHOICE_ROW_H                 
#define FS_NEW_H      (2 * FS_NEW_ROW_H + 8)          
#define FS_NEW_X      (FS_FOOT_X(FS_NEW) + FOOT_W - FS_NEW_W)
#define FS_NEW_Y      (FOOT_Y - 8 - FS_NEW_H)        
#define FS_NEW_LIST   gfx_rect_make(FS_NEW_X, FS_NEW_Y, FS_NEW_W, FS_NEW_H)
#define FS_NEW_ROW(i) gfx_rect_make(FS_NEW_X + 4, \
                                    FS_NEW_Y + 4 + (i) * FS_NEW_ROW_H, \
                                    FS_NEW_W - 8, FS_NEW_ROW_H)

#define FS_TK_AREA gfx_rect_make(FS_L, 4, FS_W, FOOT_Y + FOOT_H - 4)

#define FS_JOB_BOX_S 0.25f

#define DRAG_SLOP 8

typedef enum {
    FS_NAME_FOLDER = 0,   
    FS_NAME_FILE,         
    FS_NAME_RENAME        
} fs_name_for_t;

typedef enum {
    FS_HIT_NONE = -1,
    /* 0 to 7: the footer's buttons, fs_foot_t. */
    FS_HIT_UP = FOOT_N,   
    FS_HIT_PREV = FOOT_N + 2,  
    FS_HIT_NEXT = FOOT_N + 4,  
    FS_HIT_ROW = FOOT_N + 6,   
    FS_HIT_BAR,                
    FS_HIT_Q_CANCEL,           
    FS_HIT_Q_DELETE,           
    FS_HIT_INFO_CLOSE,         
    FS_HIT_NEW_ROW,            
    FS_HIT_JOB_CANCEL = FS_HIT_NEW_ROW + 2  
} fs_hit_t;
 
_Static_assert(FOOT_Y + FOOT_H + 4 <= SCREEN_H - UI_ALERT_H,
               "the footer ends 4px above the alert band");
_Static_assert(FOOT_H >= UI_TAP_MIN, "the footer's buttons are a finger tall");
_Static_assert(FS_FOOT_X(FOOT_N - 1) + FOOT_W == FS_R,
               "the footer's buttons end at the right margin");
_Static_assert(FS_ROW_H >= UI_TAP_MIN, "a row is a finger tall");
_Static_assert(FS_HDR_H >= UI_TAP_MIN && FS_PG_W >= UI_TAP_MIN,
               "UP, PREV and NEXT are a finger tall and wide");
_Static_assert(FS_UP_W + 8 <= FS_PANE_W - 2 * FS_PG_W - 4,
               "UP ends 8px short of PREV");
_Static_assert(FS_PANE_X(1) + FS_PANE_W == FS_R, "the right pane ends at the margin");
_Static_assert(FS_HDR_Y + FS_HDR_H + 8 <= FS_LIST_Y,
               "the header row ends 8px above the list");
_Static_assert(FS_LIST_Y + FS_HEAD_H + FS_ROWS * FS_ROW_H + 4 + 6 <= FS_MSG_Y,
               "the lists end above the message line");
_Static_assert(FS_MSG_Y + 2 * FS_MSG_LH + 4 <= FOOT_Y,
               "the message line's two lines end 4px above the footer");
_Static_assert(FS_ICON + 8 + 28 * 10 + 8 + FS_SIZE_W + 8 <= FS_ROW_W,
               "a row holds its icon, 28 cells of name and the size");
_Static_assert((FS_ROWS * FS_ROW_H - 4) * FS_ROWS / FM_PAGE_MAX >= 32,
               "the scroll bar's thumb is 32px or more on a full page");
_Static_assert(FS_NEW_Y + FS_NEW_H + 8 <= FOOT_Y,
               "NEW's choice ends 8px above the footer");
_Static_assert(FS_NEW_ROW_H >= UI_TAP_MIN, "a choice row is a finger tall");
_Static_assert(FS_INFO_Y + FS_INFO_H <= SCREEN_H - UI_ALERT_H - 4,
               "INFO ends 4px above the alert band");
_Static_assert(FS_BOX_Y + FS_BOX_H <= SCREEN_H - UI_ALERT_H - 4,
               "the question ends 4px above the alert band");

#define FS_MSG_MAX 192

typedef enum {
    FS_MSG_NONE = 0,      
    FS_MSG_TEXT,          
    FS_MSG_ERR            
} fs_msg_kind_t;

typedef struct {
    files_io_t io;            
    bool have_io;             
    files_view_t view;        
 
    fm_tree_t pane[2];        
    int scroll[2];            
    int active;               
    bool read[2];             
    fm_err_t pane_err[2];     
    char enter_name[FM_NAME_BUF]; 
    unsigned mount;           
 
    /* The listings waiting for the card's task, one per pane. */
    bool need[2];             
    fm_go_t need_go[2];       
    bool need_look;           
    bool keep_place[2];
 
    /* The request under way, the card's task's until it is answered. */
    fm_req_t req;             
    bool busy;                
    int req_pane;             
    bool req_keep;            
    float busy_s;             
    uint64_t prog_done;       
    uint64_t prog_total;      
    bool cancel_asked;        

    char select_after[2][FM_NAME_BUF];
 
    /* The DELETE question: the entry it names, copied, and its pane. */
    fm_entry_t doomed;        
    int doomed_pane;          
 
    /* INFO: the entry, its folder, and what the card answered. */
    fm_entry_t info_entry;    
    char info_dir[FM_PATH_SIZE]; 
    fm_info_t info;           
    fm_err_t info_err;        
 
    /* The keyboard for a name, and what it is typed for. */
    ui_textkey_t tk;          
    fs_name_for_t name_for;   
    uint32_t drawn_tk_rev;    
 
    /* The bench as the gate and the rules see it, read each frame. */
    fm_bench_t bench;         
    char user_dir[CARD_DIR_MAX]; 
    char auto_dir[CARD_DIR_MAX]; 
    bool drawn_gate;          
 
    /* The message line, kept as its text's ID and names, not as words,
     * so it is worded in the language showing when it is drawn. */
    fs_msg_kind_t msg_kind;   
    ui_text_id_t msg_id;      
    fm_err_t msg_err;         
    char msg_a[FM_NAME_BUF];  
    char msg_b[FM_NAME_BUF];  
    bool message_ok;          
 
    /* The contact that holds a press, where it came down, and what on. */
    bool tap_have;            
    bool tap_moved;           
    uint8_t tap_id;           
    int16_t tap_x0;           
    int16_t tap_y0;           
    int press;                
    int press_pane;           
    int press_row;            
    int press_scroll0;        
    bool dragged;             
    int bar_grab;             
 
    bool valid[MAX_FBS];      
} fs_state_t;

extern fs_state_t fs_s;
#define s fs_s   
 
/* --- files_screen.c ----------------------------------------------------- */

const fm_entry_t *fs_selected(void);

bool fs_foot_live(fs_foot_t b, fm_err_t *why);

bool fs_paged(int i);

void fs_foot(fs_foot_t b);

void fs_turn(int i, fm_go_t go, bool up);

void fs_row_tap(int i, int row);

void fs_delete_doomed(void);

void fs_new_name(bool folder);

void fs_name_typed(const char *name);

void fs_job_cancel(void);

void fs_say(bool ok, ui_text_id_t id, const char *a, const char *b);

void fs_say_err(fm_err_t err, const char *name);

void fs_quiet(void);

const char *fs_message(char *buf, size_t n);

void fs_err_text(fm_err_t err, const char *name, char *out, size_t n);

void fs_bar_thumb(int i, int *y, int *h);

int fs_bar_scroll_at(int i, int top);

void fs_clamp_scroll(int i);
 
/* --- files_draw.c ------------------------------------------------------- */

void fs_render(gfx_canvas_t *c, int buffer_index);

const char *fs_kind_word(int kind);
 
/* --- files_events.c ----------------------------------------------------- */

void fs_event(const touch_event_t *e);

void fs_cancel_press(void);