Field Edit and Entry

Functions for handling field editing and entry. More...

Functions
int	field_editor (Form *form)
	Accept input for a field.
int	form_display_field_n (Form *form, int n)
	Display field n.
int	form_display_field (Form *form)
	Display current field.
int	form_display_field_brackets (Form *form)
	Display brackets around current field if set.
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.
void	mk_filler (char *s, int fl)
	Create filler string for field.
void	left_justify (char *s)
	Left justify string by removing leading spaces.
void	right_justify (char *s, int fl)
	Right justify string by removing trailing spaces and adding leadingspaces.
bool	is_valid_date (int yyyy, int mm, int dd)
	Check if a given date is valid, including leap years.
bool	is_valid_time (int hh, int mm, int ss)
	Check if a given time is valid.
void	numeric (char *d, char *s)
	Extract numeric characters from source string to destination string.

Detailed Description

Functions for handling field editing and entry.

This module provides functions for handling field editing and entry within in the C-Menu Form library. It includes functionality for accepting user input for fields, displaying fields, formatting field content based on specified formats, validating field input, and creating filler strings for fields. The module supports various field formats such as strings, decimal integers, hexadecimal integers, floating-point numbers, currency, dates, and times. It also handles user interactions such as navigation keys and mouse events for editing fields. The functions in this module are designed to be used in conjunction with the overall C-Menu Form library to create interactive forms in a text-based user interface.

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

Note

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_F(10) is the default key for accepting the field and moving to the next field

KEY_F(9) 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 59 of file fields.c.

                             {
    bool f_insert = FALSE;
    int in_key;
    char *s, *d;
    WINDOW *win = form->win;
 
    int flin = form->field[form->fidx]->line;
    int fcol = form->field[form->fidx]->col;
    int flen = form->field[form->fidx]->len;
    int ff = form->field[form->fidx]->ff;
    char *accept_s = form->field[form->fidx]->accept_s;
    char *filler_s = form->field[form->fidx]->filler_s;
    form_fmt_field(form, accept_s);
    click_x = click_y = -1;
    char *fstart = accept_s;
    char *fend = fstart + flen;
    int x = fcol;
    char *p = fstart = accept_s;
    char *str_end = p + strlen(p);
    in_key = 0;
    if (f_insert)
        set_chyron_key_cp(form->chyron, 18, "INS", KEY_IC,
                          cp_reverse_highlight);
    else
        set_chyron_key_cp(form->chyron, 18, "INS", KEY_IC, cp_reverse);
    compile_chyron(form->chyron);
    display_chyron(form->win, form->chyron, form->lines - 1, form->chyron->l);
 
    while (1) {
        if (in_key == 0) {
            mvwaddstr(win, flin, fcol, filler_s);
            mvwaddstr(win, flin, fcol, accept_s);
            wmove(win, flin, x);
            tcflush(0, TCIFLUSH);
            wmove(win, flin, x);
            in_key = xwgetch(win, form->chyron, -1);
        }
        switch (in_key) {
        case KEY_F(10):
            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_F(9):
            form_display_field(form);
            in_key = KEY_F(9);
            return (in_key);
        case 'H':
        case KEY_F(1):
            return (in_key);
        case 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_cp(form->chyron, 18, "INS", KEY_IC, cp_reverse);
            } else {
                f_insert = TRUE;
                set_chyron_key_cp(form->chyron, 18, "INS", KEY_IC,
                                  cp_reverse_highlight);
            }
            compile_chyron(form->chyron);
            display_chyron(form->win, 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;
                beep();
                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;
                beep();
                in_key = 0;
                continue;
            case FF_FLOAT:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                beep();
                in_key = 0;
                continue;
            case FF_DOUBLE:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                beep();
                in_key = 0;
                continue;
            case FF_CURRENCY:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.' ||
                    (in_key == '-' && p == fstart))
                    break;
                beep();
                in_key = 0;
                continue;
            case FF_YYYYMMDD:
                if (in_key >= '0' && in_key <= '9')
                    break;
                beep();
                in_key = 0;
                continue;
            case FF_HHMMSS:
                if (in_key >= '0' && in_key <= '9')
                    break;
                beep();
                in_key = 0;
                continue;
            case FF_APR:
                if ((in_key >= '0' && in_key <= '9') || in_key == '.')
                    break;
                beep();
                in_key = 0;
                continue;
            default:
                Perror("field_editor() invalid format");
                break;
            }
            if (in_key >= ' ') {
                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) {
                            *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, Form::chyron, click_x, click_y, Field::col, compile_chyron(), cp_reverse, cp_reverse_highlight, display_chyron(), Form::f_erase_remainder, 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, Field::filler_s, form_display_field(), form_fmt_field(), form_validate_field(), form_yx_to_fidx(), Chyron::l, Field::len, Field::line, Form::lines, Perror(), set_chyron_key_cp(), Form::win, and xwgetch().

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

Note

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.

                                   {
    WINDOW *win = form->win;
    int flin = form->field[form->fidx]->line;
    int fcol = form->field[form->fidx]->col;
    form_display_field_brackets(form);
    mvwaddstr(win, flin, fcol, form->field[form->fidx]->filler_s);
    mvwaddstr(win, flin, fcol, form->field[form->fidx]->display_s);
    // wrefresh(win);
    return 0;
}

References Field::col, Field::display_s, Form::fidx, Form::field, Field::filler_s, form_display_field_brackets(), Field::line, and Form::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_brackets()

int form_display_field_brackets

(

Form *

form

)

Display brackets around current field if set.

Parameters

form	Pointer to Form structure

Returns

0 on success, non-zero on error

Note

This function checks if the form's brackets array has non-empty values for both the left and right brackets. If so, it retrieves the line and column information for the current field and uses the form's box window to display the left bracket at the start of the field and the right bracket at the end of the field. The display is refreshed to show the brackets around the field.

Definition at line 389 of file fields.c.

                                            {
    int flin, fcol;
    if (form->brackets[0] != '\0' && form->brackets[1] != '\0') {
        WINDOW *box = form->box;
        flin = form->field[form->fidx]->line + 1;
        fcol = form->field[form->fidx]->col;
        wmove(box, flin, fcol);
        waddch(box, form->brackets[0]);
        wmove(box, flin, fcol + form->field[form->fidx]->len + 1);
        waddch(box, form->brackets[1]);
        wrefresh(box);
    }
    return 0;
}

References Form::box, Form::brackets, Field::col, Form::fidx, Form::field, Field::len, and Field::line.

Referenced by form_display_field().

Here is the caller graph for this function:

form_display_field_n()

int form_display_field_n	(	Form *	form,
		int	n )

Display field n.

Parameters

form	Pointer to Form structure
n	Field index to display

Returns

0 on success, non-zero on error

Note

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 351 of file fields.c.

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

References Form::fidx, and form_display_field().

Referenced by form_display_fields().

Here is the call graph for this function:

Here is the caller 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

Note

This function 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. The function handles various format types, including strings, decimal integers, hexadecimal integers, floating-point numbers, currency, dates, and times. It 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.

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

Note

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

supports format types: FF_STRING, FF_DECIMAL_INT, FF_HEX_INT, FF_FLOAT, FF_DOUBLE, FF_CURRENCY, FF_YYYYMMDD, FF_HHMMSS, FF_APR with appropriate formatting and validation for each type.

Handles field length and filler string creation.

As the roadmap indicates, these data types are just a start and more complex types and formats may be added in the future.

These data types are not suitable for financial, scientific, or high-precision applications. They are intended for basic data entry and display in a text-based user interface.

In the future, we will aqdd support for additional data types and formats such as: dates with time zones, timestamps, percentages, scientific notation, and custom user-defined formats.

For high precision applications, we will be integrating support for 128-bit binary coded decimal (BCD) types and arbitrary precision decimal types using libraries such as the GNU MPFR library, IBM's decNumber, Rust Decimal, or the Intel Decimal Floating-Point Math Library.

C-Menu Form converts each field's input string into internal numeric binary based on the field's specified format. The internal numberic binary is then formated and displayed, verifying the user's input and Form's interpretation of the user's input.

Definition at line 421 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;
    int ff = form->field[form->fidx]->ff;
    int fl = form->field[form->fidx]->len;
 
    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 {
        int yyyy;
        int mm;
        int dd;
    } Date;
    Date.yyyy = Date.mm = Date.dd = 0;
    struct {
        int hh;
        int mm;
        int ss;
    } 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);
    mk_filler(filler_s, fl);
    return 0;
}

References Field::accept_s, 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, Field::filler_s, Field::input_s, is_valid_date(), is_valid_time(), left_justify(), Field::len, mk_filler(), numeric(), Perror(), right_justify(), strnz(), strnz__cpy(), and trim().

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

Note

Very underdeveloped - only checks F_NOTBLANK and F_NOMETAS

Definition at line 588 of file fields.c.

                                    {
    int 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	(	int	yyyy,
		int	mm,
		int	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

Note

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 672 of file fields.c.

                                             {
    if (yyyy < 1 || mm < 1 || mm > 12 || dd < 1)
        return false;
    int 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;
}

Referenced by form_fmt_field().

Here is the caller graph for this function:

is_valid_time()

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

Check if a given time is valid.

Parameters

hh	Hour
mm	Minute
ss	Second

Returns

true if the time is valid, false otherwise

Note

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 693 of file fields.c.

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

Referenced by form_fmt_field().

Here is the caller graph for this function:

left_justify()

void left_justify

(

char *

s

)

Left justify string by removing leading spaces.

Parameters

s	String to left justify

Note

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 634 of file fields.c.

{ trim(s); }

References trim().

Referenced by form_fmt_field().

Here is the call graph for this function:

Here is the caller graph for this function:

mk_filler()

void mk_filler	(	char *	s,
		int	fl )

Create filler string for field.

Parameters

s	Filler string to create
fl	Field length

Note

Fills the string s with the fill character specified in the form's fill_char array, repeated for the length of the field (fl). The resulting string is null-terminated. This filler string can be used to display empty fields or to clear the field area before displaying new content.

Definition at line 617 of file fields.c.

                                {
    char *e = s + fl;
    unsigned char c;
 
    c = form->fill_char[0];
    while (s != e)
        *s++ = c;
    *s = '\0';
}

References Form::fill_char, and form.

Referenced by form_fmt_field().

Here is the caller graph for this function:

numeric()

void numeric	(	char *	d,
		char *	s )

Extract numeric characters from source string to destination string.

Parameters

d	Destination string
s	Source string

Note

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 709 of file fields.c.

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

Referenced by form_fmt_field().

Here is the caller graph for this function:

right_justify()

void right_justify	(	char *	s,
		int	fl )

Right justify string by removing trailing spaces and adding leadingspaces.

Parameters

s	String to right justify
fl	Field length

Note

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 646 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) = ' ';
    }
}

References trim().

Referenced by form_fmt_field().

Here is the call graph for this function:

Here is the caller graph for this function: