Window Support

Manage NCurses windows and color settings. More...

Functions
int	box2_new (int wlines, int wcols, int wbegy, int wbegx, char *wtitle, bool win_pair)
	Create a new window with optional box and title.
int	box_new (int wlines, int wcols, int wbegy, int wbegx, char *wtitle, bool win_pair)
	Create a new window with optional box and title.
void	cbox (WINDOW *box)
	Draw a box around the specified window.
void	cbox2 (WINDOW *box)
	Draw a box with a separator line around the specified window.
void	destroy_curses ()
	Gracefully shut down NCurses and restore terminal settings.
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.
void	view_full_screen_resize (Init *init)
	Resize the full screen view and its components.
void	view_win_resize (Init *init, char *title)
	Resize the current window and its box, and update the title.
int	win2_new (int wlines, int wcols, int wbegy, int wbegx)
	Create a new window with specified dimensions and position.
WINDOW *	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, int wbegy, int wbegx)
	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

box2_new()

int box2_new	(	int	wlines,
		int	wcols,
		int	wbegy,
		int	wbegx,
		char *	wtitle,
		bool	win_pair )

Create a new window with optional box and title.

box2_new

Parameters

wlines	Number of lines
wcols	Number of columns
wbegy	Beginning Y position
wbegx	Beginning X position
wtitle	Window title
win_pair	If true, creates a pair of windows (box and inner window)

Returns

0 if successful, 1 if error

Definition at line 697 of file dwin.c.

                            {
    int maxx;
    if (win_ptr >= MAXWIN) {
        ssnprintf(em0, MAXLEN - 1, "Maximum number of windows (%d) exceeded");
        abend(-1, em0);
    }
    win_ptr++;
    wlines = min(wlines, LINES - 2);
    wcols = min(wcols, COLS - 2);
    win_box[win_ptr] = newwin(wlines + 4, wcols + 2, wbegy, wbegx);
    if (win_box[win_ptr] == nullptr) {
        win_ptr--;
        return 1;
    }
#ifdef DEBUG_IMMEDOK
    immedok(win_box[win_ptr], true);
#endif
    wbkgrndset(win_box[win_ptr], &CCC_BOX);
    cbox2(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]);
    win_win[win_ptr] = nullptr;
    win_win2[win_ptr] = nullptr;
    if (win_pair) {
        win_new(wlines - 1, wcols, wbegy, wbegx);
        win2_new(2, wcols, wbegy + wlines, wbegx);
    }
    return 0;
}

References abend(), bw_lt, bw_rt, bw_sp, cbox2(), CCC_BOX, em0, ssnprintf(), win2_new(), win_box, win_new(), win_ptr, win_win, and win_win2.

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,
		bool	win_pair )

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
win_pair	If true, creates a pair of windows (box and inner window)

Returns

0 if successful, 1 if error

Definition at line 745 of file dwin.c.

                           {
    int maxx;
    if (win_ptr >= MAXWIN) {
        ssnprintf(em0, MAXLEN - 1, "Maximum number of windows (%d) exceeded");
        abend(-1, em0);
    }
    win_ptr++;
    wlines = min(wlines, LINES - 2);
    wcols = min(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 DEBUG_IMMEDOK
    immedok(win_box[win_ptr], true);
#endif
    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]);
    win_win[win_ptr] = nullptr;
    if (win_pair)
        win_new(wlines, wcols, wbegy, wbegx);
    return 0;
}

References abend(), bw_lt, bw_rt, bw_sp, cbox(), CCC_BOX, em0, ssnprintf(), win_box, win_new(), win_ptr, and win_win.

Referenced by action_disposition(), answer_yn(), display_error(), display_form(), init_view_boxwin(), 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:

cbox()

void cbox

(

WINDOW *

box

)

Draw a box around the specified window.

cbox

Parameters

box	Pointer to the window to draw the box around

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 957 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 box_new(), view_win_resize(), and win_resize().

Here is the caller graph for this function:

cbox2()

void cbox2

(

WINDOW *

box

)

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

cbox2

Parameters

box	Pointer to the window to draw the box around

This function draws a box around the specified window, similar to cbox(), 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 989 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);
    // Verticals
    for (y = 1; y < maxy - 4; y++) {
        mvwaddnwstr(box, y, 0, &bw_ve, 1);
        mvwaddnwstr(box, y, maxx, &bw_ve, 1);
    }
    // Separator line
    mvwaddnwstr(box, y, 0, &bw_lt, 1);
    // line 00, page 00
    mvwaddnwstr(box, y, 1, &bw_rt, 1);
    mvwaddnwstr(box, y, 24, &bw_lt, 1);
    for (x = 25; x < maxx; x++)
        waddnwstr(box, &bw_ho, 1);
    waddnwstr(box, &bw_rt, 1);
    // Window 2
    y++;
    mvwaddnwstr(box, y, 0, &bw_ve, 1);
    mvwaddnwstr(box, y, maxx, &bw_ve, 1);
    y++;
    mvwaddnwstr(box, y, 0, &bw_ve, 1);
    mvwaddnwstr(box, y, maxx, &bw_ve, 1);
    // Bottom
    y++;
    mvwaddnwstr(box, y, 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_lt, bw_rt, bw_tl, bw_tr, and bw_ve.

Referenced by box2_new().

Here is the caller 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, 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 540 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_win2[win_ptr])
            delwin(win_win2[win_ptr]);
        if (win_box[win_ptr])
            delwin(win_box[win_ptr]);
        win_win[win_ptr] = nullptr;
        win_win2[win_ptr] = nullptr;
        win_box[win_ptr] = nullptr;
        win_ptr--;
    }
    werase(stdscr);
    wrefresh(stdscr);
    endwin();
    delscreen(screen);
    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, win_win, and win_win2.

Referenced by abend(), 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.

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

                                                             {
    char *d, *e;
    char tmp_str[MAXLEN];
 
    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';
    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.

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

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 192 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_ variables are indices for ncurses color pairs, created with get_clr_pair function. These color pairs are used to set the foreground and background colors for different elements of the interface, such as windows, text, and boxes. By defining these color pair indices as global variables, we can easily reference them throughout the code when applying colors to various parts of the interface using NCurses functions that accept color pair indices.
    cp_win = get_clr_pair(CLR_FG, CLR_BG);
    cp_norm = get_clr_pair(CLR_WHITE, CLR_BLACK);
    cp_nt = get_clr_pair(CLR_NT_FG, CLR_NT_BG);
    cp_nt_rev = get_clr_pair(CLR_NT_REV_FG, CLR_NT_REV_BG);
    cp_nt_hl_rev = get_clr_pair(CLR_NT_HL_REV_FG, CLR_NT_HL_REV_BG);
    cp_nt_hl = get_clr_pair(CLR_NT_HL_FG, CLR_NT_HL_BG);
    cp_box = get_clr_pair(CLR_BO, CLR_BG);
    cp_ln = get_clr_pair(CLR_LN, CLR_LN_BG);
    // CCC_ variables are cchar_t versions of the color pairs, created with mkccc function for use in NCurses functions that require cchar_t attributes. These are used to set the background color of windows and other elements in the interface. By creating these cchar_t variables, we can easily apply the desired color pairs to various parts of the interface using NCurses functions that accept cchar_t attributes.
    CCC_NORM = mkccc(cp_norm, WA_NORMAL, " ");
    CCC_WIN = mkccc(cp_win, WA_NORMAL, " ");
    CCC_NT = mkccc(cp_nt, WA_NORMAL, " ");
    CCC_NT_REV = mkccc(cp_nt_rev, WA_NORMAL, " ");
    CCC_NT_HL_REV = mkccc(cp_nt_hl_rev, WA_NORMAL, " ");
    CCC_NT_HL = mkccc(cp_nt_hl, WA_NORMAL, " ");
    CCC_BOX = mkccc(cp_box, WA_NORMAL, " ");
    CCC_LN = mkccc(cp_ln, WA_NORMAL, " ");
    noecho();
    keypad(stdscr, true);
    idlok(stdscr, false);
    idcok(stdscr, false);
    wbkgrndset(stdscr, &CCC_NT);
#ifdef DEBUG_IMMEDOK
    immedok(stdscr, true);
#endif
    win_ptr = -1;
    return sio;
}

References abend(), BLUE_GAMMA, SIO::blue_gamma, CCC_BOX, CCC_LN, CCC_NORM, CCC_NT, CCC_NT_HL, CCC_NT_HL_REV, CCC_NT_REV, CCC_WIN, CLR_BG, CLR_BLACK, CLR_BO, CLR_FG, CLR_LN, CLR_LN_BG, CLR_NT_BG, CLR_NT_FG, CLR_NT_HL_BG, CLR_NT_HL_FG, CLR_NT_HL_REV_BG, CLR_NT_HL_REV_FG, CLR_NT_REV_BG, CLR_NT_REV_FG, CLR_WHITE, cp_box, cp_ln, cp_norm, cp_nt, cp_nt_hl, cp_nt_hl_rev, cp_nt_rev, 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.

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

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

References win_box, win_ptr, and win_win.

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

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 115 of file init_view.c.

                                         {
    erase();
    wnoutrefresh(stdscr);
    wrefresh(stdscr);
    view_calc_full_screen_dimensions(init);
    mvwin(view->cmdln_win, view->lines - 1, 0);
    wresize(view->cmdln_win, 1, view->cols);
    wnoutrefresh(view->cmdln_win);
 
    // wresize(view->ln_win, view->ln_win_lines, view->ln_win_cols);
    wresize(view->ln_win, view->ln_win_lines - 1, view->ln_win_cols);
    wsetscrreg(view->ln_win, 0, view->scroll_lines - 1);
    wnoutrefresh(view->ln_win);
 
    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, View::ln_win_cols, View::ln_win_lines, View::pad, View::scroll_lines, 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:

view_win_resize()

void view_win_resize	(	Init *	init,
		char *	title )

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

Parameters

init	Pointer to the Init structure containing view settings.
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 265 of file init_view.c.

                                              {
    int maxx;
    erase();
    wnoutrefresh(stdscr);
    wrefresh(stdscr);
    view_calc_win_dimensions(init, title);
#ifdef DEBUG_RESIZE
    ssnprintf(em0, MAXLEN - 1, "view->box: begy=%d, begx=%d, lines=%d, cols=%d",
              view->begy, view->begx, view->lines + 2, view->cols + 2);
    write_cmenu_log_nt(em0);
#endif
    mvwin(view->box, view->begy, view->begx);
    wresize(view->box, view->lines + 2, view->cols + 2);
    wbkgrnd(view->box, &CCC_BOX);
    wbkgrndset(view->box, &CCC_BOX);
    cbox(view->box);
    if (title != nullptr && *title != '\0') {
        wmove(view->box, 0, 1);
        waddnstr(view->box, (const char *)&bw_rt, 1);
        wmove(view->box, 0, 2);
        waddnstr(view->box, (const char *)&bw_sp, 1);
        mvwaddnwstr(view->box, 0, 1, &bw_rt, 1);
        mvwaddnwstr(view->box, 0, 2, &bw_sp, 1);
        int len = strlen(title);
        if (len > (view->cols - 4)) {
            len -= (view->cols - 4);
            mvwaddstr(view->box, 0, 3, &title[len]);
        } else
            mvwaddstr(view->box, 0, 3, title);
        maxx = getmaxx(view->box);
        int s = strlen(title);
        if ((s + 3) < maxx)
            mvwaddch(view->box, 0, (s + 3), ' ');
        if ((s + 4) < maxx)
            mvwaddnwstr(view->box, 0, (s + 4), &bw_lt, 1);
    }
    wnoutrefresh(view->box);
#ifdef DEBUG_RESIZE
    ssnprintf(em0, MAXLEN - 1,
              "view->cmdln_win: begy=%d, begx=%d, lines=%d, cols=%d",
              view->begy + view->lines, view->begx + 1, 1, view->cols);
    write_cmenu_log_nt(em0);
#endif
    mvwin(view->cmdln_win, view->begy + view->lines, view->begx + 1);
    wresize(view->cmdln_win, 1, view->cols);
    wnoutrefresh(view->cmdln_win);
#ifdef DEBUG_RESIZE
    ssnprintf(em0, MAXLEN - 1,
              "(285)view->ln_win: begy=%d, begx=%d, lines=%d, cols=%d, "
              "scroll_lines %d",
              view->begy + 1, view->begx + 1, view->ln_win_lines + 2,
              view->ln_win_cols, view->scroll_lines);
    write_cmenu_log_nt(em0);
#endif
    if (view->f_ln) {
        if (view->ln_win == nullptr) {
            view->ln_win = newwin(view->ln_win_lines, view->ln_win_cols,
                                  view->begy + 1, view->begx + 1);
            keypad(view->ln_win, false);
            idlok(view->ln_win, false);
            idcok(view->ln_win, false);
            wbkgrnd(view->ln_win, &CCC_LN);
            wbkgrndset(view->ln_win, &CCC_LN);
            scrollok(view->ln_win, true);
            wsetscrreg(view->ln_win, 0, view->scroll_lines - 1);
#ifdef DEBUG_IMMEDOK
            immedok(view->ln_win, true);
#endif
        } else {
            mvwin(view->ln_win, view->begy + 1, view->begx + 1);
            wresize(view->ln_win, view->ln_win_lines, view->ln_win_cols);
            wsetscrreg(view->ln_win, 0, view->scroll_lines);
            wnoutrefresh(view->ln_win);
        }
    } else if (view->ln_win != nullptr) {
        delwin(view->ln_win);
        view->ln_win = nullptr;
    }
    view->sminrow = view->begy + 1;
    view->smincol = view->begx + 1;
    view->smaxrow = view->begy + view->lines;
    view->smaxcol = view->begx + view->cols;
#ifdef DEBUG_RESIZE
    ssnprintf(em0, MAXLEN - 1,
              "view->pad: sminrow=%d, smincol=%d, smaxrow=%d, smaxcol=%d",
              view->sminrow, view->smincol, view->smaxrow, view->smaxcol);
    write_cmenu_log_nt(em0);
#endif
    wresize(view->pad, view->lines - 1, PAD_COLS);
    wsetscrreg(view->pad, 0, view->scroll_lines);
}

References View::begx, View::begy, View::box, bw_lt, bw_rt, bw_sp, cbox(), CCC_BOX, CCC_LN, View::cmdln_win, View::cols, View::f_ln, View::lines, View::ln_win, View::ln_win_cols, View::ln_win_lines, View::pad, View::scroll_lines, View::smaxcol, View::smaxrow, View::smincol, View::sminrow, view, and view_calc_win_dimensions().

Referenced by view_cmd_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

win2_new()

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

Create a new window with specified dimensions and position.

win2_new

Parameters

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

Returns

0 if successful, 1 if error

Definition at line 814 of file dwin.c.

                                                          {
    wbegy += 1;
    wbegx += 1;
    win_win2[win_ptr] = newwin(wlines, wcols, wbegy, wbegx);
    if (win_win2[win_ptr] == nullptr) {
        delwin(win_box[win_ptr]);
        return 1;
    }
#ifdef DEBUG_IMMEDOK
    immedok(win_win2[win_ptr], true);
#endif
    wbkgrndset(win_win2[win_ptr], &CCC_NT);
    keypad(win_win2[win_ptr], true);
    idlok(win_win2[win_ptr], false);
    idcok(win_win2[win_ptr], false);
    return 0;
}

References CCC_NT, win_box, win_ptr, and win_win2.

Referenced by box2_new().

Here is the caller graph for this function:

win_del()

WINDOW * win_del

(

)

Delete the current window and its associated box window.

win_del

Returns

nullptr

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

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

References CCC_NT, win_box, win_ptr, and win_win.

Referenced by action_disposition(), answer_yn(), display_error(), init_form(), init_pick(), menu_engine(), 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.

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

Definition at line 176 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 )

Create a new window with specified dimensions and position.

win_new

Parameters

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

Returns

0 if successful, 1 if error

Definition at line 788 of file dwin.c.

                                                         {
    wbegy += 1;
    wbegx += 1;
    win_win[win_ptr] = newwin(wlines, wcols, wbegy, wbegx);
    if (win_win[win_ptr] == nullptr) {
        delwin(win_box[win_ptr]);
        return 1;
    }
#ifdef DEBUG_IMMEDOK
    immedok(win_win[win_ptr], true);
#endif
    wbkgrndset(win_win[win_ptr], &CCC_NT);
    keypad(win_win[win_ptr], true);
    idlok(win_win[win_ptr], false);
    idcok(win_win[win_ptr], false);
    scrollok(win_win[win_ptr], true);
    return 0;
}

References CCC_NT, win_box, win_ptr, and win_win.

Referenced by box2_new(), and box_new().

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

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

                                                    {
    int maxx;
    wrefresh(stdscr);
    wresize(win_box[win_ptr], wlines + 2, wcols + 2);
    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);
    wbkgrndset(win_win[win_ptr], &CCC_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);
#ifdef DEBUG_IMMEDOK
    immedok(win_win[win_ptr], true);
#endif
}

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

Here is the call 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.

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 1651 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);
    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)) {
                    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;
                    }
                }
                c = ERR;
                continue;
            }
        }
    } 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(), remove_file(), and wait_continue().

Here is the call graph for this function:

Here is the caller graph for this function: