Window Support

Manage NCurses windows and color settings. More...

Functions
int	bare_box_new (int wlines, int wcols, int wbegy, int wbegx, char *wtitle)
	Create a new window with optional box and title.
int	border_hsplit (WINDOW *box, int y)
	Draw a box with a separator line around the specified window.
int	border_hsplit_text (WINDOW *box, char *text, int separator_line)
	Draw a box with a separator line and text around the specified window.
int	border_title (WINDOW *box, char *title)
	Draw a box with a title around the specified window.
int	box_hsplit_new (int wlines, int split_win_lines, int wcols, int wbegy, int wbegx, char *wtitle)
	Create a new window with optional box and title, and a second window inside it, split horizontally.
int	box_new (int wlines, int wcols, int wbegy, int wbegx, char *wtitle)
	Create a new window with optional box and title.
void	check_panels (int i)
	Check and display the panels for a given window index.
void	destroy_curses ()
	Gracefully shut down NCurses and restore terminal settings.
int	dxwgetch (WINDOW *win_0, WINDOW *win_1, WINDOW *win_2, WINDOW *win_3, WINDOW *win_c, 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.
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.
bool	open_curses (SIO *sio)
	Initialize NCurses and color settings.
void	restore_wins ()
	Restore all windows after a screen resize.
int	vgetch (WINDOW *win, int n)
	Wrapper for wgetch that handles signals and mouse events, and accepts a single character answer.
void	view_boxwin_resize (Init *init)
	Resize the current window and its box.
void	view_full_screen_resize (Init *init)
	Resize the full screen view and its components.
int	win2_box_new (int wlines, int wcols, int wbegy, int wbegx, char *wtitle)
	Create a new window with optional box and title, and a second window inside it.
int	win2_new (int wlines, int wcols, int wbegy, int wbegx)
	Create a new subwindow (win2) with specified dimensions and position.
void	win_del ()
	Delete the current window and its associated box window.
void	win_init_attrs ()
	Initialize window attributes.
int	win_new (int wlines, int wcols)
	Create a new window with specified dimensions and position.
void	win_redraw (WINDOW *win)
	Redraw the specified window.
void	win_resize (int wlines, int wcols, char *title)
	Resize the current window and its box, and update the title.
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

bare_box_new()

int bare_box_new	(	int	wlines,
		int	wcols,
		int	wbegy,
		int	wbegx,
		char *	wtitle )

Create a new window with optional box and title.

box_new

Parameters

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

Returns

0 if successful, 1 if error

Definition at line 981 of file dwin.c.

                                                                            {
    int maxy, maxx;
    if (win_ptr >= MAXWIN) {
        Perror("Maximum number of windows (%d) exceeded");
        exit(EXIT_FAILURE);
    }
#ifdef NCURSES_UI
    getmaxyx(stdscr, maxy, maxx);
#else
    ui_get_screen_size(ui_runtime, &maxy, &maxx);
#endif
    wlines = min(wlines, maxy - 2);
    wcols = min(wcols, maxx - 2);
    win_ptr++;
    // ------------------->    win_box    <-------------------
#ifdef UAL_UI
    ui_rect_set(&ui_rect, wbegy, wbegx, wlines + 2, wcols + 2);
    ui_box[win_ptr] = ui_surface_new(ui_runtime, NULL, ui_rect);
    win_box[win_ptr] = ui_box[win_ptr]->win;
    panel_box[win_ptr] = ui_box[win_ptr]->pan;
 
    UiStyle *ui_style = ui_style_from_cch(&CC_BOX);
    ui_bkgrnd(ui_box[win_ptr], ui_style, " ");     // flood fill_char
    ui_bkgrnd_set(ui_box[win_ptr], ui_style, " "); // like wattron
    wborder_set(win_box[win_ptr], &ls, &rs, &ts, &bs, &tl, &tr, &bl, &br);
    border_title(win_box[win_ptr], wtitle);
 
    ui_rect_set(&ui_rect, 1, 1, wlines, wcols);
    ui_win[win_ptr] = ui_surface_new(ui_runtime, ui_box[win_ptr], ui_rect);
    ui_style = ui_style_from_cch(&CC_NT);
    ui_bkgrnd(ui_win[win_ptr], ui_style, " ");     // flood fill_char
    ui_bkgrnd_set(ui_win[win_ptr], ui_style, " "); // like wattron
    win_win[win_ptr] = ui_win[win_ptr]->win;
    panel_win[win_ptr] = ui_win[win_ptr]->pan;
    mvwaddstr(win_win[win_ptr], 10, 1, "Hello!");
 
#else
    win_box[win_ptr] = newwin(wlines + 2, wcols + 2, wbegy, wbegx);
    if (win_box[win_ptr] == nullptr) {
        Perror("win_box[win_ptr] = newwin() failed");
        exit(EXIT_FAILURE);
    }
    panel_box[win_ptr] = new_panel(win_box[win_ptr]);
    wbkgrnd(win_box[win_ptr], &CC_BOX);
    wbkgrndset(win_box[win_ptr], &CC_BOX);
    border_draw(win_box[win_ptr]);
    border_title(win_box[win_ptr], wtitle);
#endif
    return 0;
}

References border_draw(), border_title(), CC_BOX, panel_box, Perror(), ui_get_screen_size(), ui_runtime, win_box, and win_ptr.

Referenced by box_hsplit_new(), box_new(), and win2_box_new().

Here is the call graph for this function:

Here is the caller graph for this function:

border_hsplit()

int border_hsplit	(	WINDOW *	box,
		int	y )

Draw a box with a separator line around the specified window.

border-hsplit

Parameters

box	Pointer to the window to draw the box around
y	Line number where the separator line should be drawn

This function draws a box around the specified window, similar to border_draw(), but it also includes a horizontal separator line that divides the box into two sections. The separator line is drawn at a fixed position (line 00, page 00) and extends across the width of the box. Use this function when you want to visually separate two sections within a window, such as for a header and content area.

Definition at line 1269 of file dwin.c.

                                      {
    int maxx = getmaxx(box);
    mvwaddnwstr(box, y, 0, &bw_lt, 1);
    for (int x = 1; x < maxx - 1; x++)
        waddnwstr(box, &bw_ho, 1);
    mvwaddnwstr(box, y, maxx - 1, &bw_rt, 1);
    return 0;
}

References bw_ho, bw_lt, and bw_rt.

Referenced by box_hsplit_new().

Here is the caller graph for this function:

border_hsplit_text()

int border_hsplit_text	(	WINDOW *	box,
		char *	text,
		int	separator_line )

Draw a box with a separator line and text around the specified window.

border_hsplit_text

Parameters

box	Pointer to the window to draw the box around
text	Text to display in the middle of the separator line
separator_line	Line number where the separator line should be drawn

This function draws a box around the specified window, similar to border_draw(), but it also includes a horizontal separator line that divides the box into two sections. The separator line is drawn at the specified line number and extends across the width of the box, with the provided text displayed in the middle of the line. Use this function when you want to visually separate two sections within a window and label the separator with descriptive text.

Definition at line 1289 of file dwin.c.

                                                                    {
    int pos = 0;
    int maxx = getmaxx(box);
    int l;
    int y = separator_line;
    int x = 0;
    // Clearly, this is a bit hacky, but it works. We want to draw the
    // horizontal line with text in the middle, so we start by drawing the left
    // edge, then the text, then the right edge, and finally fill in the
    // horizontal line on either side of the text. mvwadd_wchnstr(box, y, x++,
    // &lt, 1);
    mvwadd_wchnstr(box, y, x++, &lt, 1);
    mvwadd_wchnstr(box, y, x++, &ts, 1);
    mvwadd_wchnstr(box, y, x++, &rt, 1);
    mvwadd_wchnstr(box, y, x++, &sp, 1);
    strnz(text, maxx - 7);
    cchar_t text_cc[MAXLEN] = {0};
    l = mb_to_cc(text_cc, text, WA_NORMAL, cp_box, &pos, MAXLEN - 1);
    mvwadd_wchnstr(box, y, x, text_cc, l);
    x += l;
    mvwadd_wchnstr(box, y, x++, &sp, 1);
    mvwadd_wchnstr(box, y, x++, &lt, 1);
 
    while (x < maxx - 1)
        mvwadd_wchnstr(box, y, x++, &ts, 1);
    mvwadd_wchnstr(box, y, x++, &rt, 1);
    return 0;
}

References cp_box, lt, mb_to_cc(), rt, sp, strnz(), and ts.

Referenced by picker().

Here is the call graph for this function:

Here is the caller graph for this function:

border_title()

int border_title	(	WINDOW *	box,
		char *	title )

Draw a box with a title around the specified window.

border_title

Parameters

box	Pointer to the window to draw the box around
title	Title text to display at the top of the box

This function draws a box around the specified window, similar to border_draw(), but it also includes a title at the top of the box. The title is displayed in the center of the top edge of the box, and the horizontal line is drawn on either side of the title. Use this function when you want to visually label a window with a title.

Definition at line 1327 of file dwin.c.

                                           {
    int pos = 0;
    int maxx = getmaxx(box);
    int y = 0;
    int x = 0;
    int l;
    mvwadd_wchnstr(box, y, x++, &tl, 1); // top left
    mvwadd_wchnstr(box, y, x++, &rt, 1); // right tee
    mvwadd_wchnstr(box, y, x++, &sp, 1); // space
    cchar_t title_cc[MAXLEN] = {0};
    l = mb_to_cc(title_cc, title, WA_NORMAL, cp_title, &pos, MAXLEN - 1);
    l = min(l, maxx - 7);
    mvwadd_wchnstr(box, y, x, title_cc, l);
    x += l;
    mvwadd_wchnstr(box, y, x++, &sp, 1); // space
    mvwadd_wchnstr(box, y, x++, &lt, 1); // left tee
    while (x < maxx - 1)
        mvwadd_wchnstr(box, y, x++, &ts, 1); // horizontal line
    return 0;
}

References cp_title, lt, mb_to_cc(), rt, sp, tl, and ts.

Referenced by bare_box_new(), new_view_file(), view_boxwin_resize(), and view_file().

Here is the call graph for this function:

Here is the caller graph for this function:

box_hsplit_new()

int box_hsplit_new	(	int	wlines,
		int	split_win_lines,
		int	wcols,
		int	wbegy,
		int	wbegx,
		char *	wtitle )

Create a new window with optional box and title, and a second window inside it, split horizontally.

box_hsplit_new

Parameters

wlines	Number of lines for the first window
split_win_lines	Number of lines for the second window
wcols	Number of columns for the first window
wbegy	Beginning Y position for the first window
wbegx	Beginning X position for the first window
wtitle	Window title for the first window

Returns

0 if successful, 1 if error

Definition at line 925 of file dwin.c.

                                                                                                   {
    if (win_ptr >= MAXWIN) {
        Perror("Maximum number of windows (%d) exceeded");
        exit(EXIT_FAILURE);
    }
    wlines = min(wlines, LINES - 2);
    wcols = min(wcols, COLS - 2);
    bare_box_new(wlines + split_win_lines + 1, wcols, wbegy, wbegx, wtitle);
    wbkgrnd(win_box[win_ptr], &CC_BOX);
    wbkgrndset(win_box[win_ptr], &CC_BOX);
    border_hsplit(win_box[win_ptr], wlines + 1);
    update_panels();
    doupdate();
    win_new(wlines, wcols);
    win2_new(2, wcols, wlines + 2, 1);
    return 0;
}

References bare_box_new(), border_hsplit(), CC_BOX, Perror(), win2_new(), win_box, win_new(), and win_ptr.

Referenced by open_pick_win().

Here is the call graph for this function:

Here is the caller graph for this function:

box_new()

int box_new	(	int	wlines,
		int	wcols,
		int	wbegy,
		int	wbegx,
		char *	wtitle )

Create a new window with optional box and title.

box_new

Parameters

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

Returns

0 if successful, 1 if error

Definition at line 967 of file dwin.c.

                                                                       {
    bare_box_new(wlines, wcols, wbegy, wbegx, wtitle);
    win_new(wlines, wcols);
    return 0;
}

References bare_box_new(), and win_new().

Referenced by action_disposition(), answer_yn(), display_error(), display_form(), menu_engine(), Perror(), popup_ckeys(), and wait_mk_win().

Here is the call graph for this function:

Here is the caller graph for this function:

check_panels()

void check_panels

(

int

i

)

Check and display the panels for a given window index.

check_panels

Parameters

i	Index of the window to check

This function checks the panels associated with the specified window index. It sets the background color for each panel, displays a label indicating the panel type, and updates the display. The function pauses after displaying each panel to allow the user to view the changes.

Definition at line 1090 of file dwin.c.

                         {
    if (i == -1)
        return;
    char tmp_str[MAXLEN];
    wbkgrnd(win_box[i], &CC_RED);
    ssnprintf(tmp_str, MAXLEN - 1, "box[%d]", i);
    mvwaddstr(win_box[i], 5, 2, tmp_str);
    show_panel(panel_box[i]);
    update_panels();
    doupdate();
    getch();
 
    wbkgrnd(win_win[i], &CC_GREEN);
    ssnprintf(tmp_str, MAXLEN - 1, "win[%d]", i);
    mvwaddstr(win_win[i], 6, 2, tmp_str);
    show_panel(panel_win[i]);
    update_panels();
    doupdate();
    getch();
 
    wbkgrnd(win_win2[i], &CC_BLUE);
    ssnprintf(tmp_str, MAXLEN - 1, "win2[%d]", i);
    mvwaddstr(win_win2[i], 0, 0, tmp_str);
    update_panels();
    doupdate();
    show_panel(panel_win2[i]);
    getch();
}

References CC_BLUE, CC_GREEN, CC_RED, panel_box, panel_win, panel_win2, ssnprintf(), win_box, win_win, and win_win2.

Here is the call graph for this function:

destroy_curses()

void destroy_curses

(

)

Gracefully shut down NCurses and restore terminal settings.

destroy_curses

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, 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 670 of file dwin.c.

                      {
    if (!f_curses_open)
        return;
    for (win_ptr = 0; win_ptr < MAXWIN; win_ptr++) {
        del_panel(panel_box[win_ptr]);
        delwin(win_win2[win_ptr]);
        delwin(win_win[win_ptr]);
        delwin(win_box[win_ptr]);
    }
    win_ptr = -1;
    endwin();
    delscreen(screen);
    fclose(tty_fp);
    f_curses_open = false;
    restore_shell_tioctl();
    sig_dfl_mode();
    return;
}

References f_curses_open, panel_box, restore_shell_tioctl(), screen, sig_dfl_mode(), tty_fp, win_box, win_ptr, win_win, and win_win2.

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

Here is the call graph for this function:

Here is the caller graph for this function:

dxwgetch()

int dxwgetch	(	WINDOW *	win_0,
		WINDOW *	win_1,
		WINDOW *	win_2,
		WINDOW *	win_3,
		WINDOW *	win_c,
		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.

dxwgetch

Parameters

win_0	Pointer to window 0
win_1	Pointer to window 1
win_2	Pointer to window 2
win_3	Pointer to window 3
win_c	Pointer to chyron 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

Get mouse event and check if it's a left click or double click. If the click is outside the windows, 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 2180 of file dwin.c.

                                                                                                               {
    int c;
    MEVENT event;
    mousemask(BUTTON1_CLICKED | BUTTON1_DOUBLE_CLICKED | BUTTON4_PRESSED | BUTTON5_PRESSED,
              nullptr);
    click_y = event.y = -1;
    click_x = event.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);
    do {
        curs_set(1);
        c = wgetch(win_0);
        curs_set(0);
        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) {
                return KEY_UP;
            } else if (event.bstate & BUTTON5_PRESSED) {
                return KEY_DOWN;
            }
            if (event.bstate & BUTTON1_CLICKED || event.bstate & BUTTON1_DOUBLE_CLICKED) {
                // Check if the click is in win_0, win_1, or win_2, and set
                // mouse_win
                // accordingly
                // don't free mouse_win, since it is borrowed
                mouse_win = nullptr;
                if (win_1 != nullptr && wenclose(win_1, event.y, event.x) && wmouse_trafo(win_1, &event.y, &event.x, false))
                    mouse_win = win_1;
                else if (win_2 != nullptr && wenclose(win_2, event.y, event.x) && wmouse_trafo(win_2, &event.y, &event.x, false))
                    mouse_win = win_2;
                else if (win_3 != nullptr && wenclose(win_3, event.y, event.x) && wmouse_trafo(win_3, &event.y, &event.x, false))
                    mouse_win = win_3;
                click_y = event.y;
                click_x = event.x;
                if (mouse_win == nullptr) {
                    c = 0;
                    break;
                }
                if (mouse_win == win_c && chyron && (event.y == getmaxy(mouse_win) - 1))
                    c = get_chyron_key(chyron, event.x);
                break;
            }
        }
    } while (c == ERR);
    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(), mouse_win, restore_curses_tioctl(), and sig_received.

Referenced by picker().

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.

mvwaddstr_fill

Parameters

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

Definition at line 1941 of file dwin.c.

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

Referenced by display_pick_page(), menu_cmd_processor(), menu_engine(), 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.

open_curses

Parameters

sio	Pointer to SIO struct with terminal and color settings

Returns

true if successful, false if error

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

Definition at line 244 of file dwin.c.

                           {
    char tmp_str[MAXLEN];
    char emsg0[MAXLEN];
 
    // Get the name of the terminal device
    sio->stdin_fd = dup(STDIN_FILENO);
    sio->stdout_fd = dup(STDOUT_FILENO);
    sio->stderr_fd = dup(STDERR_FILENO);
    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);
    }
    // open the terminal device for NCurses input and output
    tty_fp = fopen(sio->tty_name, "r+");
    if (tty_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);
    }
    // newterm() allows us to specify a tty device for NCurses input and
    // output.
    screen = newterm(nullptr, tty_fp, tty_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");
    }
    panel_main = new_panel(stdscr);
    noecho();
    keypad(stdscr, true);
    idlok(stdscr, false);
    idcok(stdscr, false);
    wbkgrnd(stdscr, &CC_NORM);
    for (win_ptr = 0; win_ptr < MAXWIN; win_ptr++) {
        panel_box[win_ptr] = nullptr;
        ui_win[win_ptr] = nullptr;
        ui_win2[win_ptr] = nullptr;
        ui_box[win_ptr] = nullptr;
        win_win[win_ptr] = nullptr;
        win_win2[win_ptr] = nullptr;
        win_box[win_ptr] = nullptr;
    }
    win_ptr = -1;
    return sio;
}

References abend(), CC_NORM, destroy_curses(), f_curses_open, panel_box, panel_main, screen, SIO::stderr_fd, SIO::stdin_fd, SIO::stdout_fd, strnz__cat(), strnz__cpy(), tty_fp, SIO::tty_name, ui_box, ui_win, ui_win2, win_box, win_ptr, win_win, and win_win2.

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.

restore_wins

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 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 1225 of file dwin.c.

                    {
    touchwin(stdscr);
    for (int i = 0; i <= win_ptr; i++) {
        if (win_box[i] != nullptr)
            touchwin(win_box[i]);
        if (win_win[i] != nullptr)
            touchwin(win_win[i]);
        if (win_win2[i] == nullptr)
            touchwin(win_win2[i]);
    }
}

References win_box, win_ptr, win_win, and win_win2.

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

Here is the caller graph for this function:

vgetch()

int vgetch	(	WINDOW *	win,
		int	n )

Wrapper for wgetch that handles signals and mouse events, and accepts a single character answer.

vgetch

Parameters

win	Pointer to window
n	Number of seconds to wait before timing out

Returns

Key code or ERR if interrupted by signal

This function is similar to xwgetch, but it does not handle chyron clicks. It sets the terminal to raw mode if n is -1, or halfdelay mode if n is 0 or greater. It waits for user input and returns the key code. If a signal is received, it handles the signal and may display an error message. If the user presses 'q', 'Q', or F9, the program exits.

Definition at line 2258 of file dwin.c.

                               {
    int c;
    mousemask(0, nullptr);
 
    curs_set(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)));
    do {
        c = wgetch(win);
        if (n > 0 && c == ERR) {
            c = 0;
            break;
        }
    } while (c == ERR);
    curs_set(0);
    // restore_curses_tioctl();
    return c;
}

References curses_tioctl, and mk_raw_tioctl().

Referenced by cf_accept(), get_cmd_char(), and remove_file().

Here is the call graph for this function:

Here is the caller graph for this function:

view_boxwin_resize()

void view_boxwin_resize

(

Init *

init

)

Resize the current window and its box.

Parameters

init	Pointer to the Init structure containing view settings.

This function resizes the current window and its associated box window to the specified number of lines and columns.

Definition at line 346 of file init_view.c.

                                    {
    destroy_view_win(init);
    init_view_boxwin(init);
    border_title(init->view->box_win, init->view->title);
    // initialize_line_table(init->view);
}

References border_title(), View::box_win, destroy_view_win(), init_view_boxwin(), View::title, and Init::view.

Referenced by view_cmd_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

view_full_screen_resize()

void view_full_screen_resize

(

Init *

init

)

Resize the full screen view and its components.

Parameters

init	Pointer to the Init structure containing view settings.

This function resizes the full screen view and its components, including the command line window, line number window, and main content pad. It also recalculates the dimensions for the full screen mode and updates the scroll regions accordingly.

Definition at line 140 of file init_view.c.

                                         {
    erase();
    View *view = init->view;
    view_calc_full_screen_dimensions(init);
    mvwin(view->cmdln_win, view->lines - 1, 0);
    wresize(view->cmdln_win, 1, view->cols);
    wresize(view->lnno_win, view->ln_win_lines - 1, view->ln_win_cols);
    wsetscrreg(view->lnno_win, 0, view->scroll_lines - 1);
    wresize(view->pad, view->lines - 1, PAD_COLS);
    wsetscrreg(view->pad, 0, view->lines - 1);
}

References View::cmdln_win, View::cols, View::lines, View::ln_win_cols, View::ln_win_lines, View::lnno_win, View::pad, View::scroll_lines, Init::view, and view_calc_full_screen_dimensions().

Referenced by view_cmd_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

win2_box_new()

int win2_box_new	(	int	wlines,
		int	wcols,
		int	wbegy,
		int	wbegx,
		char *	wtitle )

Create a new window with optional box and title, and a second window inside it.

win2_box_new

Parameters

wlines	Number of lines for the first window
wcols	Number of columns for the first window
wbegy	Beginning Y position for the first window
wbegx	Beginning X position for the first window
wtitle	Window title for the first window

Returns

0 if successful, 1 if error

Definition at line 952 of file dwin.c.

                                                                            {
    bare_box_new(wlines, wcols, wbegy, wbegx, wtitle);
    win_new(wlines, wcols);
    win2_new(wlines, wcols, 1, 1);
    return 0;
}

References bare_box_new(), win2_new(), and win_new().

Here is the call graph for this function:

win2_new()

int win2_new	(	int	wlines,
		int	wcols,
		int	wbegy,
		int	wbegx )

Create a new subwindow (win2) with specified dimensions and position.

win2_new

Parameters

wlines	Number of lines
wcols	Number of columns
wbegy	Beginning Y position relative to the parent window
wbegx	Beginning X position relative to the parent window

Returns

0 if successful, 1 if error

Definition at line 1066 of file dwin.c.

                                                          {
 
    // ------------------->   win2_win   <-------------------
    win_win2[win_ptr] = derwin(win_box[win_ptr], wlines, wcols, wbegy, wbegx);
    if (win_win2[win_ptr] == nullptr) {
        Perror("win_win2[win_ptr] = derwin() failed");
        exit(EXIT_FAILURE);
    }
    panel_win2[win_ptr] = new_panel(win_win2[win_ptr]);
    wbkgrnd(win_win2[win_ptr], &CC_NT);
    keypad(win_win2[win_ptr], true);
    idlok(win_win2[win_ptr], false);
    idcok(win_win2[win_ptr], false);
    return 0;
}

References CC_NT, panel_win2, Perror(), win_box, win_ptr, and win_win2.

Referenced by box_hsplit_new(), and win2_box_new().

Here is the call graph for this function:

Here is the caller graph for this function:

win_del()

void win_del

(

)

Delete the current window and its associated box window.

win_del

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 1179 of file dwin.c.

               {
    if (win_ptr >= MAXWIN) {
        Perror("win_ptr >= MAXWIN");
        exit(EXIT_FAILURE);
    }
    if (win_ptr >= 0) {
 
        if (panel_win[win_ptr] != nullptr) {
            del_panel(panel_win[win_ptr]);
            panel_win[win_ptr] = nullptr;
        }
        if (win_win[win_ptr] != nullptr) {
            delwin(win_win[win_ptr]);
            win_win[win_ptr] = nullptr;
        }
 
        if (panel_win2[win_ptr] != nullptr) {
            del_panel(panel_win2[win_ptr]);
            panel_win2[win_ptr] = nullptr;
        }
        if (win_win2[win_ptr] != nullptr) {
            delwin(win_win2[win_ptr]);
            win_win2[win_ptr] = nullptr;
        }
 
        if (panel_box[win_ptr] != nullptr) {
            del_panel(panel_box[win_ptr]);
            panel_box[win_ptr] = nullptr;
        }
 
        if (win_box[win_ptr] != nullptr) {
            delwin(win_box[win_ptr]);
            win_box[win_ptr] = nullptr;
        }
        win_ptr--;
    }
}

References panel_box, panel_win, panel_win2, Perror(), win_box, win_ptr, win_win, and win_win2.

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

Here is the call graph for this function:

Here is the caller graph for this function:

win_init_attrs()

void win_init_attrs

(

)

Initialize window attributes.

This function initializes color pairs for the window cp_nt, and cp_box are global variables

Definition at line 226 of file dwin.c.

                      {
    return;
}

win_new()

int win_new	(	int	wlines,
		int	wcols )

Create a new window with specified dimensions and position.

win_new

Parameters

wlines	Number of lines
wcols	Number of columns

Returns

0 if successful, 1 if error

Definition at line 1037 of file dwin.c.

                                   {
    // ------------------->    win_win    <-------------------
    win_win[win_ptr] = derwin(win_box[win_ptr], wlines, wcols, 1, 1);
    if (win_win[win_ptr] == nullptr) {
        Perror("win_win[win_ptr] = derwin() failed");
        exit(EXIT_FAILURE);
    }
    panel_win[win_ptr] = new_panel(win_win[win_ptr]);
    wbkgrnd(win_win[win_ptr], &CC_NT);
    wbkgrndset(win_win[win_ptr], &CC_NT);
    keypad(win_win[win_ptr], true);
    idlok(win_win[win_ptr], false);
    idcok(win_win[win_ptr], false);
    wsetscrreg(win_win[win_ptr], 0, wlines - 1);
    scrollok(win_win[win_ptr], true);
    return 0;
}

References CC_NT, panel_win, Perror(), win_box, win_ptr, and win_win.

Referenced by box_hsplit_new(), box_new(), and win2_box_new().

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.

win_redraw

Parameters

win	Pointer to the window to redraw

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 1168 of file dwin.c.

                             {
    werase(win);
    update_panels();
}

win_resize()

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

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

win_resize

Parameters

wlines	Number of lines
wcols	Number of columns
title	Window title

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 1128 of file dwin.c.

                                                    {
    int maxx;
    update_panels();
    doupdate();
    wresize(win_box[win_ptr], wlines + 2, wcols + 2);
    wbkgrndset(win_box[win_ptr], &CC_BOX);
    wborder_set(win_box[win_ptr], &ls, &rs, &ts, &bs, &tl, &tr, &bl, &br);
    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);
    }
    update_panels();
    wresize(win_win[win_ptr], wlines, wcols);
    wbkgrndset(win_win[win_ptr], &CC_NT);
    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);
    scrollok(win_win[win_ptr], true);
    update_panels();
    doupdate();
}

References bl, br, bs, bw_lt, bw_rt, bw_sp, CC_BOX, CC_NT, ls, rs, tl, tr, ts, win_box, win_ptr, and win_win.

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.

xwgetch

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

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 2094 of file dwin.c.

                                                {
    int c;
    MEVENT event;
    mousemask(BUTTON1_CLICKED | BUTTON1_DOUBLE_CLICKED | BUTTON4_PRESSED | BUTTON5_PRESSED,
              nullptr);
    click_y = event.y = -1;
    click_x = event.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);
    do {
        curs_set(1);
        c = wgetch(win);
        curs_set(0);
        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) {
                return KEY_UP;
            } else if (event.bstate & BUTTON5_PRESSED) {
                return KEY_DOWN;
            }
            if (event.bstate & BUTTON1_CLICKED || event.bstate & BUTTON1_DOUBLE_CLICKED) {
                if (wenclose(win, event.y, event.x)) {
                    wmouse_trafo(win, &event.y, &event.x, false);
                    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;
                }
                c = ERR;
                continue;
            }
        }
    } while (c == ERR);
    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(), menu_cmd_processor(), Perror(), and wait_continue().

Here is the call graph for this function:

Here is the caller graph for this function: