fields.c

Go to the documentation of this file.

/** @file fields.c
    @brief Field Edit and Entry for C-Menu Form
    @author Bill Waller
    Copyright (c) 2025
    MIT License
    billxwaller@gmail.com
    @date 2026-02-09
 */
 
#include "common.h"
#include <monetary.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
 
int field_editor(Form *);
int form_display_field(Form *);
int form_display_accept_field(Form *);
int form_display_field_n(Form *, uint);
int form_validate_field(Form *);
 
char ff_tbl[][26] = {_("string"), _("decimal_int"), _("hex_int"), _("float"), _("double"), _("currency"), _("yyyymmdd"), _("hhmmss"), _("apr"), ""};
 
/** @defgroup field_editor Field Editor
   @brief File mapping, user input, command processing, and display logic
    @brief Main loop for field editing and entry
    @details This function handles the main loop for field editing and entry.
   It processes user input, including character input, navigation keys, and
   mouse events, to allow the user to edit the content of a field. The function
   validates input based on the field's specified format and updates the display
   accordingly. It returns the key code of the action taken, such as accepting
   the field, tabbing to the next field, or breaking out of the input loop.
 */
 
/** @brief Accept input for a field
    @ingroup field_editor
     @param form Pointer to Form structure
     @return int Key code of action taken
     @details Handles character input, navigation keys, and mouse events for
   field editing. Validates input based on field format and updates display.
     Returns key code of action taken (e.g., accept field, tab to next field,
     break out of input loop).
 */
int field_editor(Form *form) {
    bool f_insert = false;
    int in_key;
    char *s, *d;
    UiSurface *sfc = ui_surface[sfc_ptr];
    UiEvent event;
    uint maxy;
    if (form->fidx >= form->fcnt)
        form->fcnt = 0;
    uint flin = form->field[form->fidx]->line;
    uint fcol = form->field[form->fidx]->col;
    uint flen = form->field[form->fidx]->len;
    uint ff = form->field[form->fidx]->ff;
    char *accept_s = form->field[form->fidx]->accept_s;
    form_fmt_field(form, accept_s);
    click_x = click_y = -1;
    char *fstart = accept_s;
    char *fend = fstart + flen;
    uint x = fcol;
    char *p = fstart = accept_s;
    char *str_end = p + strlen(p);
    in_key = 0;
    if (f_insert)
        ui_set_chyron_key_cb(form->chyron, 18, "INS", UIKEY_IC, cell_nt_hl_rev);
    else
        ui_set_chyron_key_cb(form->chyron, 18, "INS", UIKEY_IC, cell_nt_rev);
    ui_compile_chyron(form->chyron);
    ui_display_chyron(sfc, 1, form->chyron, form->lines - 1, form->chyron->l);
 
    while (1) {
        if (in_key == 0) {
            form_fmt_field(form, accept_s);
            form_display_accept_field(form);
            tcflush(0, TCIFLUSH);
 
            ui_cursor_enable_yx(sfc, WIN, flin, x, true);
            ui_render();
            in_key = ui_get_event(sfc, WIN, form->chyron, &event, -1);
            ui_cursor_enable_yx(sfc, WIN, flin, x, false);
 
            maxy = ui_getmaxy(sfc, WIN);
            if (event.in_win == WIN && event.y == maxy - 1)
                in_key = ui_get_chyron_key(form->chyron, event.x);
        }
        ui_curs_set(0);
        switch (in_key) {
            /** UIKEY_F10 is the default key for accepting the field and moving
                to the next field */
        case UIKEY_F10:
            form_fmt_field(form, accept_s);
            form_display_field(form);
            if (form_validate_field(form) != 0)
                continue;
            return (in_key);
            /** UIKEY_F09 Cancels the current operation */
        case UIKEY_F09:
            form_display_field(form);
            in_key = UIKEY_F09;
            return (in_key);
            /** UIKEY_UP, UIKEY_BTAB moves to the previous field */
        case 'H':
        case UIKEY_F01:
            return (in_key);
        case UIKEY_UP:
            form_fmt_field(form, accept_s);
            form_display_field(form);
            in_key = UIKEY_UP;
            return (in_key);
            /** UIKEY_DOWN, TAB moves to the next field */
        case '\t':
        case UIKEY_DOWN:
            form_fmt_field(form, accept_s);
            form_display_field(form);
            in_key = UIKEY_DOWN;
            return (in_key);
            /** UIKEY_END moves cursor to end of field */
        case UIKEY_END:
        case Ctrl('e'):
            while (*p != '\0')
                p++;
            x = fcol + (p - fstart);
            in_key = 0;
            continue;
            /**< Enter accepts the field and moves to the next field if
             * form->f_erase_remainder is set, it will clear the remaining
             * characters above and after the current cursor location */
        case '\n':
        case UIKEY_ENTER:
            if (form->f_erase_remainder)
                *p = '\0';
            form_fmt_field(form, accept_s);
            form_display_field(form);
            in_key = UIKEY_ENTER;
            return (in_key);
            /** UIKEY_IC toggles insert mode */
        case UIKEY_IC:
            if (f_insert) {
                f_insert = false;
                ui_set_chyron_key_cb(form->chyron, 18, "INS", UIKEY_IC, cell_nt_rev);
            } else {
                f_insert = true;
                ui_set_chyron_key_cb(form->chyron, 18, "INS", UIKEY_IC,
                                     cell_nt_hl_rev);
            }
            ui_compile_chyron(form->chyron);
            ui_display_chyron(sfc, 1, form->chyron, form->lines - 1,
                              form->chyron->l);
            in_key = 0;
            continue;
            /** UIKEY_DC deletes character at cursor */
        case UIKEY_DC:
            s = p + 1;
            d = p;
            while (*s != '\0')
                *d++ = *s++;
            *d = '\0';
            str_end = d;
            f_insert = false;
            in_key = 0;
            continue;
            /** UIKEY_HOME moves cursor to start of field */
        case UIKEY_HOME:
        case Ctrl('a'):
            p = fstart;
            x = fcol;
            in_key = 0;
            continue;
            /** UIKEY_BACKSPACE deletes character before cursor */
        case UIKEY_BACKSPACE:
            if (p > fstart) {
                p--;
                x--;
            }
            s = p + 1;
            d = p;
            while (*s != '\0')
                *d++ = *s++;
            *d = '\0';
            str_end = d;
            in_key = 0;
            continue;
            /** UIKEY_LEFT moves cursor left one character */
        case UIKEY_LEFT:
            if (p > fstart) {
                p--;
                x--;
            }
            in_key = 0;
            continue;
            /** UIKEY_RIGHT moves cursor right one character */
        case UIKEY_RIGHT:
            if (p < fend && p < str_end) {
                p++;
                x++;
            }
            in_key = 0;
            continue;
            /** Handles mouse events for field editing */
        case UIKEY_BUTTON1:
            form->fidx = form_yx_to_fidx(form, click_y, click_x);
            x = click_x;
            flin = click_y;
            flen = form->field[form->fidx]->len;
            ff = form->field[form->fidx]->ff; /* ff - field forat */
            accept_s = form->field[form->fidx]->accept_s;
            // filler_s = form->field[form->fidx]->filler_s;
            form_fmt_field(form, accept_s);
            fstart = accept_s;
            fend = fstart + flen;
            str_end = fstart + strlen(fstart);
            p = fstart + (x - form->field[form->fidx]->col);
            if (p > str_end)
                x -= p - str_end;
            p = min(p, str_end);
            in_key = 0;
            continue;
        default:
            if (p >= fend) {
                in_key = 0;
                continue;
            }
            /** Validates fields based on format */
            switch (ff) {
                /** FF_STRING accepts all printable characters and spaces */
            case FF_STRING:
                break;
                /** FF_DECIMAL_INT accepts digits 0 through 9 and decimal point
                 * ('.') */
            case FF_DECIMAL_INT:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.')
                    break;
                in_key = 0;
                continue;
                /** FF_HEX_INT accepts digits 0 through 9 and letters A through
                 * F (case-insensitive) */
            case FF_HEX_INT:
                if ((in_key >= '0' && in_key <= '9') ||
                    (in_key >= 'A' && in_key <= 'F') ||
                    (in_key >= 'a' && in_key <= 'f'))
                    break;
                in_key = 0;
                continue;
                /** FF_FLOAT accepts digits 0 through 9 and decimal point ('.')
                 * and negative operator ('-') at the start of the field */
            case FF_FLOAT:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                in_key = 0;
                continue;
                /** FF_DOUBLE accepts digits 0 through 9 and decimal point ('.')
                 * and negative operator ('-') at the start of the field */
            case FF_DOUBLE:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                in_key = 0;
                continue;
                /** FF_CURRENCY accepts digits 0 through 9 and decimal point
                 * ('.') and negative operator ('-') at the start of the field
                 */
            case FF_CURRENCY:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                in_key = 0;
                continue;
                /** FF_YYYYMMDD accepts digits 0 through 9 */
            case FF_YYYYMMDD:
                if (in_key >= '0' && in_key <= '9')
                    break;
                in_key = 0;
                continue;
                /** FF_HHMMSS accepts digits 0 through 9 */
            case FF_HHMMSS:
                if (in_key >= '0' && in_key <= '9')
                    break;
                in_key = 0;
                continue;
                /** FF_APR accepts digits 0 through 9 and decimal point ('.') */
            case FF_APR:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.')
                    break;
                in_key = 0;
                continue;
            default:
                ui_perror(_("field_editor() invalid format"));
                break;
            }
            if (in_key < ' ' || in_key > '~') {
                in_key = 0;
                continue;
            }
            if (f_insert) {
                if (str_end < fend) {
                    s = str_end - 1;
                    d = str_end;
                    while (s >= p)
                        *d-- = *s--;
                    *p++ = in_key;
                    str_end++;
                    x++;
                }
            } else {
                if (p < fend) {
                    if (p < str_end) {
                        if (p == accept_s && in_key == ' ') {
                            d = accept_s;
                            s = accept_s + 1;
                            while (*s != '\0')
                                *d++ = *s++;
                            *d = '\0';
                            in_key = 0;
                            continue;
                        }
                        *p++ = in_key;
                        x++;
                    } else if (p == str_end) {
                        *p++ = in_key;
                        *p = '\0';
                        str_end = p;
                        x++;
                    }
                }
            }
            in_key = 0;
            continue;
        }
    }
}
 
/** @brief Display field n
    @ingroup field_editor
    @param form Pointer to Form structure
    @param n Field index to display
    @return 0 on success, non-zero on error
    @details This function temporarily sets the form's current field index
   (fidx) to n, calls form_display_field() to display that field, and then
   restores the original fidx value. This allows for displaying a specific field
   without permanently changing the form's current field index.
 */
int form_display_field_n(Form *form, uint n) {
    uint fidx = form->fidx;
    form->fidx = n;
    form_display_field(form);
    form->fidx = fidx;
    return 0;
}
void display_field(UiCell *cmplx_buf, uint y, uint x) {
    UiSurface *sfc = ui_surface[sfc_ptr];
    ui_mvwadd_wchstr(sfc, WIN, y, x, cmplx_buf);
}
/** @brief Display current field
    @ingroup field_editor
    @param form Pointer to Form structure
    @return 0 on success, non-zero on error
    @details This function displays the current field based on the form's
   current field index (fidx). It retrieves the line and column information for
   the current field, displays any brackets if set, and then displays the
   field's content using the display_s string. The function ensures that the
   field is displayed correctly within the form's window and refreshes the
   display to show the updated field content.
 */
int form_display_field(Form *form) {
    UiSurface *sfc = ui_surface[sfc_ptr];
    uint y = form->field[form->fidx]->line;
    uint x = form->field[form->fidx]->col;
 
    uint pos = 0;
    ui_mbstr_to_cellstr(sfc, WIN, form->field[form->fidx]->filler_cc, form->field[form->fidx]->filler_s, &cell_nt, &pos,
                        form->field[form->fidx]->len + 1);
    ui_mvwadd_wchnstr(sfc, WIN, y, x, form->field[form->fidx]->filler_cc, form->field[form->fidx]->len);
    ui_render();
 
    pos = 0;
    ui_mbstr_to_cellstr(sfc, WIN, form->field[form->fidx]->display_cc, form->field[form->fidx]->display_s, &cell_nt, &pos,
                        form->field[form->fidx]->len + 1);
    ui_mvwadd_wchnstr(sfc, WIN, y, x, form->field[form->fidx]->display_cc, form->field[form->fidx]->len);
    ui_render();
    return 0;
}
int form_display_accept_field(Form *form) {
    UiSurface *sfc = ui_surface[sfc_ptr];
    uint y = form->field[form->fidx]->line;
    uint x = form->field[form->fidx]->col;
    uint pos = 0;
    ui_mbstr_to_cellstr(sfc, WIN, form->field[form->fidx]->filler_cc, form->field[form->fidx]->filler_s, &cell_nt, &pos,
                        form->field[form->fidx]->len + 1);
    ui_mvwadd_wchnstr(sfc, WIN, y, x, form->field[form->fidx]->filler_cc, form->field[form->fidx]->len);
    ui_render();
 
    pos = 0;
    ui_mbstr_to_cellstr(sfc, WIN, form->field[form->fidx]->accept_cc, form->field[form->fidx]->accept_s, &cell_nt, &pos,
                        form->field[form->fidx]->len + 1);
    ui_mvwadd_wchnstr(sfc, WIN, y, x, form->field[form->fidx]->accept_cc, form->field[form->fidx]->len);
    ui_render();
    return 0;
}
/** @brief Format field according to its format type
    @ingroup field_editor
    @param form Pointer to Form structure
    @param s Input string to format
    @return 0 on success, non-zero on error
    @details takes the input string for the current field and formats it
   according to the field's specified format type (ff). It updates the
   accept_s and display_s strings for the field based on the formatted
   value.
    Handles various format types, including strings, decimal integers,
   hexadecimal integers, floating-point numbers, currency, dates, and times.
    Uses helper functions for validation and formatting, such as
   is_valid_date(), is_valid_time(), numeric(), right_justify(),
   left_justify(), and strnzcpy(). The function ensures that the formatted
   output fits within the field's length and creates a filler string for the
   field as needed. The function also handles error cases, such as invalid
   formats, and provides feedback through error messages. It is designed to
   be extensible, allowing for additional format types to be added in the
   future as needed.
    Assumes that the input string is well-formed and does not contain
   malicious content. Input validation and sanitization should be performed
   at a higher level in the application to ensure security and robustness.
   The function currently does not handle localization or
   internationalization of number formats, such as different decimal
   separators or currency symbols. Future enhancements may include support
   for locale-specific formatting.
    Error handling is basic; future
   versions may include more detailed error reporting and logging
   mechanisms.
    Performance optimizations may be considered for
   handling large volumes of data or high-frequency updates in real-time
   applications. The following variables and structures are used in
   this function:
    @code
        char field_s[FIELD_MAXLEN];
        int decimal_int_n = 0;
        int hex_int_n = 0;
        float float_n = 0.0;
        double double_n = 0.0;
        double currency_n = 0.0;
        struct Date { int yyyy; int mm; int dd; };
        struct Time { int hh; int mm; int ss; };
    @endcode
  */
int form_fmt_field(Form *form, char *s) {
    strnz__cpy(form->field[form->fidx]->input_s, s, FIELD_MAXLEN - 1);
    char *input_s = form->field[form->fidx]->input_s;
    char *accept_s = form->field[form->fidx]->accept_s;
    char *display_s = form->field[form->fidx]->display_s;
    // char *filler_s = form->field[form->fidx]->filler_s;
    uint ff = form->field[form->fidx]->ff;
    uint fl = form->field[form->fidx]->len;
 
    char field_s[FIELD_MAXLEN];
    uint decimal_int_n = 0;
    uint hex_int_n = 0;
    float float_n = 0.0;
    double double_n = 0.0;
    double currency_n = 0.0;
    Date date;
    date.yyyy = date.mm = date.dd = 0;
    Time time;
    time.hh = time.mm = time.ss = 0;
 
    strnz(accept_s, fl);
    switch (ff) {
    case FF_STRING:
        left_justify(s);
        trim(s);
        strnz__cpy(input_s, s, FIELD_MAXLEN - 1);
        strnz__cpy(accept_s, s, FIELD_MAXLEN - 1);
        strnz__cpy(display_s, s, FIELD_MAXLEN - 1);
        break;
    case FF_DECIMAL_INT:
        sscanf(input_s, "%d", &decimal_int_n);
        sprintf(accept_s, "%d", decimal_int_n);
        sprintf(display_s, "%d", decimal_int_n);
        right_justify(display_s, fl);
        break;
    case FF_HEX_INT:
        sscanf(input_s, "%x", &hex_int_n);
        sprintf(accept_s, "%d", hex_int_n);
        sprintf(display_s, "%x", hex_int_n);
        right_justify(display_s, fl);
        break;
    case FF_FLOAT:
        sscanf(input_s, "%f", &float_n);
        sprintf(accept_s, "%f", float_n);
        sprintf(display_s, "%f", float_n);
        right_justify(display_s, fl);
        break;
    case FF_DOUBLE:
        sscanf(input_s, "%lf", &double_n);
        sprintf(accept_s, "%lf", double_n);
        sprintf(display_s, "%lf", double_n);
        right_justify(display_s, fl);
        break;
    case FF_CURRENCY:
        numeric(field_s, input_s);
        sscanf(field_s, "%lf", &currency_n);
        sprintf(accept_s, "%.2lf", currency_n);
        sprintf(display_s, "%'.2lf", currency_n);
        right_justify(display_s, fl);
        break;
    case FF_YYYYMMDD:
        date.yyyy = date.mm = date.dd = 0;
        strnz__cpy(field_s, input_s, FIELD_MAXLEN - 1);
        sscanf(field_s, "%4d%2d%2d", &date.yyyy, &date.mm, &date.dd);
        sprintf(accept_s, "%04d%02d%02d", date.yyyy, date.mm, date.dd);
        if (is_valid_date(date.yyyy, date.mm, date.dd))
            sprintf(display_s, "%04d-%02d-%02d", date.yyyy, date.mm, date.dd);
        break;
    case FF_HHMMSS:
        time.hh = time.mm = time.ss = 0;
        strnz__cpy(field_s, input_s, FIELD_MAXLEN - 1);
        sscanf(field_s, "%2d%2d%2d", &time.hh, &time.mm, &time.ss);
        sprintf(accept_s, "%02d%02d%02d", time.hh, time.mm, time.ss);
        if (is_valid_time(time.hh, time.mm, time.ss))
            sprintf(display_s, "%02d:%02d:%02d", time.hh, time.mm, time.ss);
        break;
    case FF_APR:
        sscanf(input_s, "%lf", &double_n);
        sprintf(accept_s, "%lf", double_n);
        sprintf(display_s, "%0.3lf", double_n);
        right_justify(display_s, fl);
        break;
    default:
        ui_perror(_("form_fmt_field() invalid format"));
        break;
    }
    strnz(accept_s, fl);
    left_justify(accept_s);
    return 0;
}
/** @brief Validate current field based on flags
    @ingroup field_editor
    @param form Pointer to Form structure
    @return 0 if valid, 1 if invalid
    @details Very underdeveloped - only checks F_NOTBLANK and F_NOMETAS
 */
int form_validate_field(Form *form) {
    uint n = form->fidx;
    char *p = form->field[n]->accept_s;
    if (form->field[n]->ff & F_NOTBLANK) {
        char *s = form->field[n]->accept_s;
        while (*s++ == ' ')
            ;
        if (*s == '\0') {
            ui_perror(_("blank field not allowed"));
            return (1);
        }
    }
    if (form->field[n]->ff & F_NOMETAS) {
        if (strpbrk(p, "*?[]") != 0) {
            ui_perror(_("metacharacters not allowed"));
            return (1);
        }
    }
    return (0);
}
/** @brief Left justify string by removing leading spaces
    @ingroup field_editor
    @param s String to left justify
    @details This function takes a string s and removes any leading spaces,
   effectively left-justifying the text. It does this by finding the first
   non-space character and shifting the string to the left, overwriting the
   leading spaces. The resulting string is null-terminated.
 */
void left_justify(char *s) { trim(s); }
/** @brief Right justify string by removing trailing spaces and adding leading
    @ingroup field_editor
   spaces
    @param s String to right justify
    @param fl Field length
    @details This function takes a string s and right-justifies it within a
   field of length fl. It first removes any trailing spaces from the string,
   then shifts the characters to the right end of the field, filling the left
   side with spaces. The resulting string is null-terminated and fits within the
   specified field length.
 */
void right_justify(char *, uint);
void right_justify(char *s, uint fl) {
    char *p = s;
    char *d = s + fl;
    trim(s);
    *d = '\0';
    while (*s != '\0') {
        s++;
    }
    while (s != p) {
        *(--d) = *(--s);
    }
    while (d != p) {
        *(--d) = ' ';
    }
}
/** @brief Check if a given date is valid, including leap years
    @ingroup field_editor
    @param yyyy Year
    @param mm Month
    @param dd Day
    @return true if the date is valid, false otherwise
    @details This function checks if the provided year, month, and day
   constitute a valid date. It accounts for leap years when determining the
   number of days in February. The function returns true if the date is valid
   and false if it is not.
 */
bool is_valid_date(uint yyyy, uint mm, uint dd) {
    if (yyyy < 1 || mm < 1 || mm > 12 || dd < 1)
        return false;
    uint days_in_month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    if ((yyyy % 4 == 0 && yyyy % 100 != 0) || (yyyy % 400 == 0))
        days_in_month[2] = 29;
    if (dd > days_in_month[mm])
        return false;
    return true;
}
/** @brief Check if a given time is valid
    @ingroup field_editor
    @param hh Hour
    @param mm Minute
    @param ss Second
    @return true if the time is valid, false otherwise
    @details This function checks if the provided hour, minute, and second
   constitute a valid time. It ensures that hours are between 0 and 23, minutes
   and seconds are between 0 and 59. The function returns true if the time is
   valid and false if it is not.
 */
bool is_valid_time(uint hh, uint mm, uint ss) {
    if (hh > 23 || mm > 59 || ss > 59)
        return false;
    return true;
}
/** @brief Extract numeric characters from source string to destination string
    @ingroup field_editor
    @param d Destination string
    @param s Source string
    @details This function takes a source string s and extracts only the numeric
   characters (digits 0-9), as well as dashes ('-') and periods ('.'), copying
   them into the destination string d. The resulting string in d is
   null-terminated. This is useful for processing input that may contain
   non-numeric characters, allowing the application to focus on the numeric
   content for further processing or validation.
 */
void numeric(char *d, char *s) {
    while (*s != '\0') {
        if (*s == '-' || *s == '.' || (*s >= '0' && *s <= '9'))
            *d++ = *s++;
        else
            s++;
    }
    *d = '\0';
}