Field Editor

File mapping, user input, command processing, and display logic. More...

Functions
int	field_editor (Form *form)
	Accept input for a field.
int	form_display_field (Form *form)
	Display current field.
int	form_display_field_n (Form *form, uint n)
	Display field n.
int	form_fmt_field (Form *form, char *s)
	Format field according to its format type.
int	form_validate_field (Form *form)
	Validate current field based on flags.
bool	is_valid_date (uint yyyy, uint mm, uint dd)
	Check if a given date is valid, including leap years.
bool	is_valid_time (uint hh, uint mm, uint ss)
	Check if a given time is valid.
void	left_justify (char *s)
	Left justify string by removing leading spaces.
void	numeric (char *d, char *s)
	Extract numeric characters from source string to destination string.
void	right_justify (char *, uint)
	Right justify string by removing trailing spaces and adding leadingspaces.

Detailed Description

File mapping, user input, command processing, and display logic.

Main loop for field editing and entry

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.

Function Documentation

field_editor()

int field_editor

(

Form *

form

)

Accept input for a field.

Parameters

form	Pointer to Form structure

Returns

int Key code of action taken

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).

KEY_F10 is the default key for accepting the field and moving to the next field

KEY_F09 Cancels the current operation

KEY_UP, KEY_BTAB moves to the previous field

KEY_DOWN, TAB moves to the next field

KEY_END moves cursor to end of field

< 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

KEY_IC toggles insert mode

KEY_DC deletes character at cursor

KEY_HOME moves cursor to start of field

KEY_BACKSPACE deletes character before cursor

KEY_LEFT moves cursor left one character

KEY_RIGHT moves cursor right one character

Handles mouse events for field editing

Validates fields based on format

FF_STRING accepts all printable characters and spaces

FF_DECIMAL_INT accepts digits 0 through 9 and decimal point ('.')

FF_HEX_INT accepts digits 0 through 9 and letters A through F (case-insensitive)

FF_FLOAT accepts digits 0 through 9 and decimal point ('.') and negative operator ('-') at the start of the field

FF_DOUBLE accepts digits 0 through 9 and decimal point ('.') and negative operator ('-') at the start of the field

FF_CURRENCY accepts digits 0 through 9 and decimal point ('.') and negative operator ('-') at the start of the field

FF_YYYYMMDD accepts digits 0 through 9

FF_HHMMSS accepts digits 0 through 9

FF_APR accepts digits 0 through 9 and decimal point ('.')

Definition at line 48 of file fields.c.

                             {
    bool f_insert = false;
    int in_key;
    char *s, *d;
    UiSurface *sfc = ui_surface[sfc_ptr];
    UiEvent event;
    uint maxy, maxx;
    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)
        set_chyron_key_cb(form->chyron, 18, "INS", KEY_IC, cell_nt_hl_rev);
    else
        set_chyron_key_cb(form->chyron, 18, "INS", KEY_IC, cell_nt_rev);
    compile_chyron(form->chyron);
    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_move(sfc, WIN, flin, x);
            in_key = ui_get_event_multi(sfc, WIN, &event, -1);
            ui_getmaxyx(sfc, WIN, &maxy, &maxx);
            if (event.in_win == WIN && event.y == maxy - 1)
                in_key = get_chyron_key(form->chyron, event.x);
        }
        ui_curs_set(0);
        switch (in_key) {
        case KEY_F10:
            form_fmt_field(form, accept_s);
            form_display_field(form);
            if (form_validate_field(form) != 0)
                continue;
            return (in_key);
        case KEY_BREAK:
        case KEY_F09:
            form_display_field(form);
            in_key = KEY_F09;
            return (in_key);
        case 'H':
        case KEY_F01:
            return (in_key);
        case UI_KEY_BTAB:
        case KEY_UP:
            form_fmt_field(form, accept_s);
            form_display_field(form);
            in_key = KEY_UP;
            return (in_key);
        case '\t':
        case KEY_DOWN:
            form_fmt_field(form, accept_s);
            form_display_field(form);
            in_key = KEY_DOWN;
            return (in_key);
        case KEY_END:
        case Ctrl('e'):
            while (*p != '\0')
                p++;
            x = fcol + (p - fstart);
            in_key = 0;
            continue;
        case '\n':
        case KEY_ENTER:
            if (form->f_erase_remainder)
                *p = '\0';
            form_fmt_field(form, accept_s);
            form_display_field(form);
            in_key = KEY_ENTER;
            return (in_key);
        case KEY_IC:
            if (f_insert) {
                f_insert = false;
                set_chyron_key_cb(form->chyron, 18, "INS", KEY_IC, cell_nt_rev);
            } else {
                f_insert = true;
                set_chyron_key_cb(form->chyron, 18, "INS", KEY_IC,
                                  cell_nt_hl_rev);
            }
            compile_chyron(form->chyron);
            display_chyron(sfc, 1, form->chyron, form->lines - 1,
                           form->chyron->l);
            in_key = 0;
            continue;
        case KEY_DC:
            s = p + 1;
            d = p;
            while (*s != '\0')
                *d++ = *s++;
            *d = '\0';
            str_end = d;
            f_insert = false;
            in_key = 0;
            continue;
        case KEY_HOME:
        case Ctrl('a'):
            p = fstart;
            x = fcol;
            in_key = 0;
            continue;
        case KEY_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;
        case KEY_LEFT:
            if (p > fstart) {
                p--;
                x--;
            }
            in_key = 0;
            continue;
        case KEY_RIGHT:
            if (p < fend && p < str_end) {
                p++;
                x++;
            }
            in_key = 0;
            continue;
        case KEY_MOUSE:
            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;
            }
            switch (ff) {
            case FF_STRING:
                break;
            case FF_DECIMAL_INT:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.')
                    break;
                in_key = 0;
                continue;
            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;
            case FF_FLOAT:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                in_key = 0;
                continue;
            case FF_DOUBLE:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                in_key = 0;
                continue;
            case FF_CURRENCY:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                in_key = 0;
                continue;
            case FF_YYYYMMDD:
                if (in_key >= '0' && in_key <= '9')
                    break;
                in_key = 0;
                continue;
            case FF_HHMMSS:
                if (in_key >= '0' && in_key <= '9')
                    break;
                in_key = 0;
                continue;
            case FF_APR:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.')
                    break;
                in_key = 0;
                continue;
            default:
                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;
        }
    }
}

References Field::accept_s, cell_nt_hl_rev, cell_nt_rev, Form::chyron, click_x, click_y, Field::col, compile_chyron(), display_chyron(), Form::f_erase_remainder, Form::fcnt, Field::ff, FF_APR, FF_CURRENCY, FF_DECIMAL_INT, FF_DOUBLE, FF_FLOAT, FF_HEX_INT, FF_HHMMSS, FF_STRING, FF_YYYYMMDD, Form::fidx, Form::field, form_display_accept_field(), form_display_field(), form_fmt_field(), form_validate_field(), form_yx_to_fidx(), get_chyron_key(), UiEvent::in_win, Chyron::l, Field::len, Field::line, Form::lines, Perror(), set_chyron_key_cb(), sfc_ptr, ui_curs_set(), ui_cursor_move(), ui_get_event_multi(), ui_getmaxyx(), UI_KEY_BTAB, ui_surface, WIN, UiEvent::x, and UiEvent::y.

Referenced by field_navigator().

Here is the call graph for this function:

Here is the caller graph for this function:

form_display_field()

int form_display_field

(

Form *

form

)

Display current field.

Parameters

form	Pointer to Form structure

Returns

0 on success, non-zero on error

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.

Definition at line 369 of file fields.c.

                                   {
    UiSurface *sfc = ui_surface[sfc_ptr];
    uint y = form->field[form->fidx]->line;
    uint x = form->field[form->fidx]->col;
 
    uint pos = 0;
    mbstr_to_cellstr(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;
    mbstr_to_cellstr(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;
}

References cell_nt, Field::col, Field::display_cc, Field::display_s, Form::fidx, Form::field, Field::filler_cc, Field::filler_s, Field::len, Field::line, mbstr_to_cellstr(), sfc_ptr, ui_mvwadd_wchnstr(), ui_render(), ui_surface, and WIN.

Referenced by field_editor(), and form_display_field_n().

Here is the call graph for this function:

Here is the caller graph for this function:

form_display_field_n()

int form_display_field_n	(	Form *	form,
		uint	n )

Display field n.

Parameters

form	Pointer to Form structure
n	Field index to display

Returns

0 on success, non-zero on error

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.

Definition at line 347 of file fields.c.

                                             {
    uint fidx = form->fidx;
    form->fidx = n;
    form_display_field(form);
    form->fidx = fidx;
    return 0;
}

References Form::fidx, and form_display_field().

Here is the call graph for this function:

form_fmt_field()

int form_fmt_field	(	Form *	form,
		char *	s )

Format field according to its format type.

Parameters

form	Pointer to Form structure
s	Input string to format

Returns

0 on success, non-zero on error

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:

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; };

Definition at line 448 of file fields.c.

                                        {
    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:
        Perror("form_fmt_field() invalid format");
        break;
    }
    strnz(accept_s, fl);
    left_justify(accept_s);
    return 0;
}

References Field::accept_s, Date::dd, Field::display_s, Field::ff, FF_APR, FF_CURRENCY, FF_DECIMAL_INT, FF_DOUBLE, FF_FLOAT, FF_HEX_INT, FF_HHMMSS, FF_STRING, FF_YYYYMMDD, Form::fidx, Form::field, Time::hh, Field::input_s, is_valid_date(), is_valid_time(), left_justify(), Field::len, Date::mm, Time::mm, numeric(), Perror(), right_justify(), Time::ss, strnz(), strnz__cpy(), trim(), and Date::yyyy.

Referenced by field_editor(), and form_read_data().

Here is the call graph for this function:

Here is the caller graph for this function:

form_validate_field()

int form_validate_field

(

Form *

form

)

Validate current field based on flags.

Parameters

form	Pointer to Form structure

Returns

0 if valid, 1 if invalid

Very underdeveloped - only checks F_NOTBLANK and F_NOMETAS

Definition at line 544 of file fields.c.

                                    {
    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') {
            Perror("blank field not allowed");
            return (1);
        }
    }
    if (form->field[n]->ff & F_NOMETAS) {
        if (strpbrk(p, "*?[]") != 0) {
            Perror("metacharacters not allowed");
            return (1);
        }
    }
    return (0);
}

References Field::accept_s, Field::ff, Form::fidx, Form::field, and Perror().

Referenced by field_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

is_valid_date()

bool is_valid_date	(	uint	yyyy,
		uint	mm,
		uint	dd )

Check if a given date is valid, including leap years.

Parameters

yyyy	Year
mm	Month
dd	Day

Returns

true if the date is valid, false otherwise

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.

Definition at line 611 of file fields.c.

                                                {
    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;
}

is_valid_time()

bool is_valid_time	(	uint	hh,
		uint	mm,
		uint	ss )

Check if a given time is valid.

Parameters

hh	Hour
mm	Minute
ss	Second

Returns

true if the time is valid, false otherwise

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.

Definition at line 632 of file fields.c.

                                              {
    if (hh > 23 || mm > 59 || ss > 59)
        return false;
    return true;
}

left_justify()

void left_justify

(

char *

s

)

Left justify string by removing leading spaces.

Parameters

s	String to left justify

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.

Definition at line 572 of file fields.c.

{ trim(s); }

numeric()

void numeric	(	char *	d,
		char *	s )

Extract numeric characters from source string to destination string.

Parameters

d	Destination string
s	Source string

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.

Definition at line 648 of file fields.c.

                               {
    while (*s != '\0') {
        if (*s == '-' || *s == '.' || (*s >= '0' && *s <= '9'))
            *d++ = *s++;
        else
            s++;
    }
    *d = '\0';
}

right_justify()

void right_justify	(	char *	s,
		uint	fl )

Right justify string by removing trailing spaces and adding leadingspaces.

Parameters

s	String to right justify
fl	Field length

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.

Definition at line 585 of file fields.c.

                                     {
    char *p = s;
    char *d = s + fl;
    trim(s);
    *d = '\0';
    while (*s != '\0') {
        s++;
    }
    while (s != p) {
        *(--d) = *(--s);
    }
    while (d != p) {
        *(--d) = ' ';
    }
}