Window Support

Manage NCurses windows and color settings. More...

Functions
void	win_init_attrs ()
	Initialize window attributes.
bool	open_curses (SIO *sio)
	Initialize NCurses and color settings.
void	destroy_curses ()
	Gracefully shut down NCurses and restore terminal settings.
int	win_new (int wlines, int wcols, int wbegy, int wbegx, char *wtitle, int flag)
	Create a new window with optional box and title.
void	win_resize (int wlines, int wcols, char *title)
	Resize the current window and its box, and update the title.
void	win_redraw (WINDOW *win)
	Redraw the specified window.
WINDOW *	win_del ()
	Delete the current window and its associated box window.
void	restore_wins ()
	Restore all windows after a screen resize.
void	cbox (WINDOW *box)
	Draw a box around the specified window.
void	mvwaddstr_fill (WINDOW *w, int y, int x, char *s, int l)
	For lines shorter than their display area, fill the rest with spaces.
int	xwgetch (WINDOW *win, Chyron *chyron, int n)
	Wrapper for wgetch that handles signals, mouse events, checks for clicks on the chyron line, and accepts a sinigle character answer.

Detailed Description

Manage NCurses windows and color settings.

Function Documentation

cbox()

void cbox

(

WINDOW *

box

)

Draw a box around the specified window.

Parameters

box	Pointer to the window to draw the box around

Note

This function uses NCurses functions to draw a box around the specified window. It adds the appropriate characters for the corners and edges of the box based on the current character set. Use this function when you want to visually separate a window from the rest of the screen with a border.

Definition at line 960 of file dwin.c.

                       {
    int x, y;
    int maxx;
    int maxy;
 
    maxx = getmaxx(box);
    maxx--;
    mvwaddnwstr(box, 0, 0, &bw_tl, 1);
    for (x = 1; x < maxx; x++)
        waddnwstr(box, &bw_ho, 1);
    waddnwstr(box, &bw_tr, 1);
    maxy = getmaxy(box);
    maxy--;
    for (y = 1; y < maxy; y++) {
        mvwaddnwstr(box, y, 0, &bw_ve, 1);
        mvwaddnwstr(box, y, maxx, &bw_ve, 1);
    }
    mvwaddnwstr(box, maxy, 0, &bw_bl, 1);
    for (x = 1; x < maxx; x++)
        waddnwstr(box, &bw_ho, 1);
    waddnwstr(box, &bw_br, 1);
}

References bw_bl, bw_br, bw_ho, bw_tl, bw_tr, and bw_ve.

Referenced by win_new(), and win_resize().

Here is the caller graph for this function:

destroy_curses()

void destroy_curses

(

)

Gracefully shut down NCurses and restore terminal settings.

Note

This function should be called before exiting the program to ensure that the terminal is left in a usable state. It checks if NCurses was initialized and, if so, it erases the screen, refreshes it, and ends the NCurses session. It also restores the original terminal settings using restore_shell_tioctl and resets signal handlers to their default state with sig_dfl_mode.

Definition at line 738 of file dwin.c.

                      {
    if (!f_curses_open)
        return;
    while (win_ptr > 0) {
        if (win_win[win_ptr])
            delwin(win_win[win_ptr]);
        if (win_box[win_ptr])
            delwin(win_box[win_ptr]);
        win_win[win_ptr] = nullptr;
        win_box[win_ptr] = nullptr;
        win_ptr--;
    }
    werase(stdscr);
    wrefresh(stdscr);
    endwin();
    delscreen(screen);
    // screen = nullptr;
    fclose(ncurses_fp);
    f_curses_open = false;
    restore_shell_tioctl();
    sig_dfl_mode();
    return;
}

References f_curses_open, ncurses_fp, restore_shell_tioctl(), screen, sig_dfl_mode(), win_box, win_ptr, and win_win.

Referenced by abend(), main(), and open_curses().

Here is the call graph for this function:

Here is the caller graph for this function:

mvwaddstr_fill()

void mvwaddstr_fill	(	WINDOW *	w,
		int	y,
		int	x,
		char *	s,
		int	l )

For lines shorter than their display area, fill the rest with spaces.

Parameters

w	Pointer to window
y	Y coordinate
x	X coordinate
s	String to display
l	Length of display area

Definition at line 1262 of file dwin.c.

                                                             {
    char *d, *e;
    char tmp_str[MAXLEN];
 
    d = tmp_str;
    if (l > MAXLEN - 1)
        l = MAXLEN - 1;
    e = tmp_str + l;
    while (d < e)
        if (*s == '\0' || *s == '\n')
            *d++ = ' ';
        else
            *d++ = *s++;
    *d++ = '\0';
    mvwaddstr(w, y, x, tmp_str);
}

Referenced by display_page(), menu_cmd_processor(), picker(), reverse_object(), and unreverse_object().

Here is the caller graph for this function:

open_curses()

bool open_curses

(

SIO *

sio

)

Initialize NCurses and color settings.

Parameters

sio	Pointer to SIO struct with terminal and color settings

Returns

true if successful, false if error note This function initializes NCurses and sets up color pairs based on the settings in the SIO struct. It also applies gamma correction to colors. Use this function to initialize NCurses if you don't want NCurses to receive data from the stdin pipe

1. saves stdin and stdout file descriptors in SIO
2. opens a terminal device for NCurses screen IO
3. replaces STDERR_FILENO with terminal file descriptor

open the terminal device for reading and writing

We use SCREEN and newterm because this allows us to

specify the terminal FILE

Set gamma correction values

These are read from ~/.minitrc

We need these values when initializing colors

Definition at line 423 of file dwin.c.

                           {
    char tmp_str[MAXLEN];
    char emsg0[MAXLEN];
 
    if (ttyname_r(STDERR_FILENO, sio->tty_name, sizeof(sio->tty_name)) != 0) {
        strerror_r(errno, tmp_str, MAXLEN - 1);
        strnz__cpy(emsg0, "ttyname_r failed ", MAXLEN - 1);
        strnz__cat(emsg0, tmp_str, MAXLEN - 1);
        fprintf(stderr, "%s\n", tmp_str);
        exit(0);
    }
    ncurses_fp = fopen(sio->tty_name, "r+");
    if (ncurses_fp == nullptr) {
        strerror_r(errno, tmp_str, MAXLEN - 1);
        strnz__cpy(emsg0, "fopen(sio->tty_name) failed ", MAXLEN - 1);
        strnz__cat(emsg0, tmp_str, MAXLEN - 1);
        fprintf(stderr, "%s\n", tmp_str);
        exit(0);
    }
    screen = newterm(nullptr, ncurses_fp, ncurses_fp);
    if (screen == nullptr) {
        strerror_r(errno, tmp_str, MAXLEN - 1);
        strnz__cpy(emsg0, "newterm failed ", MAXLEN - 1);
        strnz__cat(emsg0, tmp_str, MAXLEN - 1);
        fprintf(stderr, "%s\n", tmp_str);
        exit(0);
    }
    set_term(screen);
    f_curses_open = true;
    if (!has_colors()) {
        destroy_curses();
        abend(-1, "Terminal color support required");
    }
    start_color();
    if (!can_change_color()) {
        destroy_curses();
        fprintf(stderr, "Terminal cannot change colors\n");
        fprintf(stderr, "Check TERM environment variable\n");
        fprintf(stderr, "Check terminfo for missing \"ccc\"\n");
        abend(-1, "fatal error");
    }
    init_clr_palette(sio);
    RED_GAMMA = sio->red_gamma;
    GREEN_GAMMA = sio->green_gamma;
    BLUE_GAMMA = sio->blue_gamma;
    GRAY_GAMMA = sio->gray_gamma;
 
    cp_win = get_clr_pair(CLR_FG, CLR_BG);
    cp_norm = get_clr_pair(CLR_WHITE, CLR_BLACK);
    cp_reverse = get_clr_pair(CLR_BLACK, CLR_WHITE);
    cp_reverse_highlight = get_clr_pair(CLR_BLACK, CLR_YELLOW);
    cp_box = get_clr_pair(CLR_BO, CLR_BG);
    cp_ln = get_clr_pair(CLR_LN, CLR_LN_BG);
 
    CCC_NORM = mkccc(cp_norm);
    CCC_WIN = mkccc(cp_win);
    CCC_REVERSE = mkccc(cp_reverse);
    CCC_REVERSE_HIGHLIGHT = mkccc(cp_reverse_highlight);
    CCC_BOX = mkccc(cp_box);
    CCC_LN = mkccc(cp_ln);
    noecho();
    keypad(stdscr, true);
    idlok(stdscr, false);
    idcok(stdscr, false);
    wbkgrnd(stdscr, &CCC_NORM);
    wbkgrndset(stdscr, &CCC_NORM);
#ifdef NCDEBUG
    immedok(stdscr, true);
#endif
    win_ptr = -1;
    return sio;
}

References abend(), BLUE_GAMMA, SIO::blue_gamma, CCC_BOX, CCC_LN, CCC_NORM, CCC_REVERSE, CCC_REVERSE_HIGHLIGHT, CCC_WIN, CLR_BG, CLR_BLACK, CLR_BO, CLR_FG, CLR_LN, CLR_LN_BG, CLR_WHITE, CLR_YELLOW, cp_box, cp_ln, cp_norm, cp_reverse, cp_reverse_highlight, cp_win, destroy_curses(), f_curses_open, get_clr_pair(), GRAY_GAMMA, SIO::gray_gamma, GREEN_GAMMA, SIO::green_gamma, init_clr_palette(), mkccc(), ncurses_fp, RED_GAMMA, SIO::red_gamma, screen, strnz__cat(), strnz__cpy(), SIO::tty_name, and win_ptr.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

restore_wins()

void restore_wins

(

)

Restore all windows after a screen resize.

Note

This function is used to restore the display of all windows after a screen resize event. It clears the standard screen and then iterates through all existing windows, touching and refreshing them to ensure they are redrawn correctly on the resized screen. Use this function in response to a SIGWINCH signal to handle terminal resizing gracefully.

Definition at line 938 of file dwin.c.

                    {
    int i;
    touchwin(stdscr);
    wnoutrefresh(stdscr);
    wrefresh(stdscr);
    for (i = 0; i <= win_ptr; i++) {
        touchwin(win_box[i]);
        wnoutrefresh(win_box[i]);
        wrefresh(win_box[i]);
        touchwin(win_win[i]);
        wnoutrefresh(win_win[i]);
        wrefresh(win_win[i]);
    }
}

References win_box, win_ptr, and win_win.

Referenced by enter_file_spec(), exec_objects(), fork_exec(), full_screen_shell(), menu_cmd_processor(), menu_engine(), resize_page(), view_cmd_processor(), and write_view_buffer().

Here is the caller graph for this function:

win_del()

WINDOW * win_del

(

)

Delete the current window and its associated box window.

Returns

nullptr

Note

This function deletes the current window and its associated box window, if they exist. It also refreshes the remaining windows to ensure the display is updated correctly. After calling this function, the global win_ptr variable is decremented to point to the previous window in the stack.

Definition at line 902 of file dwin.c.

                  {
    int i;
    curs_set(0);
    if (win_ptr >= 0) {
        touchwin(win_win[win_ptr]);
        wbkgrnd(win_win[win_ptr], &CCC_NORM);
        wbkgrndset(win_win[win_ptr], &CCC_NORM);
        werase(win_win[win_ptr]);
        wnoutrefresh(win_win[win_ptr]);
        delwin(win_win[win_ptr]);
 
        touchwin(win_box[win_ptr]);
        wbkgrnd(win_box[win_ptr], &CCC_NORM);
        wbkgrndset(win_box[win_ptr], &CCC_NORM);
        werase(win_box[win_ptr]);
        wnoutrefresh(win_box[win_ptr]);
        delwin(win_box[win_ptr]);
 
        for (i = 0; i < win_ptr; i++) {
            touchwin(win_box[i]);
            wnoutrefresh(win_box[i]);
            touchwin(win_win[i]);
            wnoutrefresh(win_win[i]);
        }
        win_ptr--;
    }
    curs_set(1);
    return (0);
}

References CCC_NORM, win_box, win_ptr, and win_win.

Referenced by action_disposition(), answer_yn(), display_error(), init_form(), init_pick(), main(), menu_engine(), mview(), Perror(), popup_ckeys(), popup_view(), and wait_destroy().

Here is the caller graph for this function:

win_init_attrs()

void win_init_attrs

(

)

Initialize window attributes.

Note

This function initializes color pairs for the window

cp_norm, cp_win, and cp_box are global variables

See also

get_clr_pair

Definition at line 162 of file dwin.c.

{ return; }

Referenced by main().

Here is the caller graph for this function:

win_new()

int win_new	(	int	wlines,
		int	wcols,
		int	wbegy,
		int	wbegx,
		char *	wtitle,
		int	flag )

Create a new window with optional box and title.

Parameters

wlines	Number of lines
wcols	Number of columns
wbegy	Beginning Y position
wbegx	Beginning X position
wtitle	Window title
flag	Window flags

Note

if flag set to W_BOX, Only create win_box. This is for View which uses the box window for display and doesn't need a separate win_win

Returns

0 if successful, 1 if error

Definition at line 783 of file dwin.c.

                      {
    int maxx;
    if (win_ptr < MAXWIN) {
        win_ptr++;
        if (wbegy != 0 || wbegx != 0 || wlines < LINES - 2 ||
            wcols < COLS - 2) {
            win_box[win_ptr] = newwin(wlines + 2, wcols + 2, wbegy, wbegx);
            if (win_box[win_ptr] == nullptr) {
                win_ptr--;
                return (1);
            }
#ifdef NCDEBUG
            immedok(win_box[win_ptr], true);
#endif
            wbkgrnd(win_box[win_ptr], &CCC_BOX);
            wbkgrndset(win_box[win_ptr], &CCC_BOX);
            cbox(win_box[win_ptr]);
            mvwaddnwstr(win_box[win_ptr], 0, 1, &bw_rt, 1);
            mvwaddnwstr(win_box[win_ptr], 0, 2, &bw_sp, 1);
            mvwaddstr(win_box[win_ptr], 0, 3, wtitle);
            maxx = getmaxx(win_box[win_ptr]);
            int s = strlen(wtitle);
            if ((s + 3) < maxx)
                mvwaddch(win_box[win_ptr], 0, (s + 3), ' ');
            if ((s + 4) < maxx)
                mvwaddnwstr(win_box[win_ptr], 0, (s + 4), &bw_lt, 1);
            wnoutrefresh(win_box[win_ptr]);
            wbegy += 1;
            wbegx += 1;
        } else {
            win_box[win_ptr] = newwin(wlines, wcols, wbegy, wbegx);
            if (win_box[win_ptr] == nullptr)
                win_ptr--;
            return (1);
#ifdef NCDEBUG
            immedok(win_box[win_ptr], true);
#endif
            wbkgrnd(win_box[win_ptr], &CCC_BOX);
            wbkgrndset(win_box[win_ptr], &CCC_BOX);
        }
        if (!(flag & W_BOX)) {
            win_win[win_ptr] = newwin(wlines, wcols, wbegy, wbegx);
            if (win_win[win_ptr] == nullptr) {
                delwin(win_box[win_ptr]);
                return (1);
            }
#ifdef NCDEBUG
            immedok(win_win[win_ptr], true);
#endif
            wbkgrnd(win_win[win_ptr], &CCC_WIN);
            wbkgrndset(win_win[win_ptr], &CCC_WIN);
            keypad(win_win[win_ptr], true);
            idlok(win_win[win_ptr], false);
            idcok(win_win[win_ptr], false);
        }
    }
    return (0);
}

References bw_lt, bw_rt, bw_sp, cbox(), CCC_BOX, CCC_WIN, win_box, win_ptr, and win_win.

Referenced by action_disposition(), answer_yn(), display_error(), form_display_screen(), init_view_boxwin(), menu_engine(), open_pick_win(), Perror(), popup_ckeys(), and wait_mk_win().

Here is the call graph for this function:

Here is the caller graph for this function:

win_redraw()

void win_redraw

(

WINDOW *

win

)

Redraw the specified window.

Parameters

win	Pointer to the window to redraw

Note

This function erases the contents of the specified window and then refreshes it to update the display. Use this function when you need to clear and redraw a window, such as after resizing or when updating its contents.

Definition at line 891 of file dwin.c.

                             {
    werase(win);
    wnoutrefresh(win);
}

win_resize()

void win_resize	(	int	wlines,
		int	wcols,
		char *	title )

Resize the current window and its box, and update the title.

Parameters

wlines	Number of lines
wcols	Number of columns
title	Window title

Note

This function resizes the current window and its associated box window to the specified number of lines and columns. It also updates the title of the box window if a title is provided. After resizing, it refreshes the windows to apply the changes.

Definition at line 851 of file dwin.c.

                                                    {
    int maxx;
    wrefresh(stdscr);
    wresize(win_box[win_ptr], wlines + 2, wcols + 2);
    wbkgrnd(win_box[win_ptr], &CCC_BOX);
    wbkgrndset(win_box[win_ptr], &CCC_BOX);
    cbox(win_box[win_ptr]);
    if (title != nullptr && *title != '\0') {
        wmove(win_box[win_ptr], 0, 1);
        waddnstr(win_box[win_ptr], (const char *)&bw_rt, 1);
        wmove(win_box[win_ptr], 0, 2);
        waddnstr(win_box[win_ptr], (const char *)&bw_sp, 1);
        mvwaddnwstr(win_box[win_ptr], 0, 1, &bw_rt, 1);
        mvwaddnwstr(win_box[win_ptr], 0, 2, &bw_sp, 1);
        mvwaddstr(win_box[win_ptr], 0, 3, title);
        maxx = getmaxx(win_box[win_ptr]);
        int s = strlen(title);
        if ((s + 3) < maxx)
            mvwaddch(win_box[win_ptr], 0, (s + 3), ' ');
        if ((s + 4) < maxx)
            mvwaddnwstr(win_box[win_ptr], 0, (s + 4), &bw_lt, 1);
    }
    wnoutrefresh(win_box[win_ptr]);
    wresize(win_win[win_ptr], wlines, wcols);
    wbkgrnd(win_win[win_ptr], &CCC_WIN);
    wbkgrndset(win_win[win_ptr], &CCC_WIN);
    wsetscrreg(win_win[win_ptr], 0, wlines - 1);
    keypad(win_win[win_ptr], TRUE);
    idlok(win_win[win_ptr], false);
    idcok(win_win[win_ptr], false);
#ifdef NCDEBUG
    immedok(win_win[win_ptr], true);
#endif
}

References bw_lt, bw_rt, bw_sp, cbox(), CCC_BOX, CCC_WIN, win_box, win_ptr, and win_win.

Referenced by resize_page().

Here is the call graph for this function:

Here is the caller graph for this function:

xwgetch()

int xwgetch	(	WINDOW *	win,
		Chyron *	chyron,
		int	n )

Wrapper for wgetch that handles signals, mouse events, checks for clicks on the chyron line, and accepts a sinigle character answer.

Parameters

win	Pointer to window
chyron	Pointer to chyron struct
n	Number of seconds to wait before timing out 0: Wait indefinitely for user input (raw mode) accept a single character answer, and don't wait for Enter key 1: Wait for 1 decisecond n > 1: Wait for n/10 seconds

Returns

Key code or ERR if interrupted by signal

Note

This, of course, will be expanded into an event loop for message queuing

Get mouse event and check if it's a left click or double click. If the click is outside the window, ignore it. If it's on the chyron line, get the corresponding key command. Otherwise, store the click coordinates as click_y and click_x for later use.

Definition at line 1359 of file dwin.c.

                                                {
    int c;
    MEVENT event;
    mousemask(BUTTON1_CLICKED | BUTTON1_DOUBLE_CLICKED | BUTTON4_PRESSED |
                  BUTTON5_PRESSED,
              nullptr);
    event.y = event.x = -1;
    click_y = click_x = -1;
 
    if (n == -1) {
        struct termios raw_tioctl;
        raw_tioctl = curses_tioctl;
        mk_raw_tioctl(&raw_tioctl);
    } else if (n == 0)
        halfdelay(1);
    else
        halfdelay(min(255, max(0, n * 10)));
    tcflush(2, TCIFLUSH);
    curs_set(1);
    do {
        c = wgetch(win);
        if (sig_received != 0) {
            if (handle_signal(sig_received))
                c = display_error(em0, em1, em2, nullptr);
            if (c == 'q' || c == 'Q' || c == KEY_F(9))
                exit(EXIT_FAILURE);
        }
        if (n > 0 && c == ERR) {
            c = 0;
            break;
        }
        if (c == ERR)
            continue;
        if (c == KEY_MOUSE) {
            if (getmouse(&event) != OK) {
                c = 0;
                continue;
            }
            if (event.bstate & BUTTON4_PRESSED) {
                curs_set(0);
                return KEY_UP;
            } else if (event.bstate & BUTTON5_PRESSED) {
                curs_set(0);
                return KEY_DOWN;
            }
            if (event.bstate & BUTTON1_CLICKED ||
                event.bstate & BUTTON1_DOUBLE_CLICKED) {
                if (!wenclose(win, event.y, event.x)) {
                    c = 0;
                    continue;
                }
                wmouse_trafo(win, &event.y, &event.x, false);
                if (event.y < 0 || event.x < 0 || event.x >= getmaxx(win) ||
                    event.y >= getmaxy(win)) {
                    c = 0;
                    continue;
                }
                click_y = event.y;
                click_x = event.x;
                if (chyron && event.y == getmaxy(win) - 1) {
                    c = get_chyron_key(chyron, event.x);
                    break;
                } else
                    break;
            }
        }
    } while (c == ERR);
    curs_set(0);
    restore_curses_tioctl();
    return c;
}

References click_x, click_y, curses_tioctl, display_error(), em0, em1, em2, get_chyron_key(), handle_signal(), mk_raw_tioctl(), restore_curses_tioctl(), and sig_received.

Referenced by action_disposition(), answer_yn(), display_error(), field_editor(), form_post(), form_process(), get_cmd_arg(), get_cmd_char(), menu_cmd_processor(), Perror(), picker(), remove_file(), and wait_continue().

Here is the call graph for this function:

Here is the caller graph for this function: