ui_ncurses_draw.c File Reference

NCurses UI backend — drawing functions. More...

#include "cm.h"
#include "ui_backend.h"
#include "ui_ncurses_internal.h"
#include <stdlib.h>
#include <string.h>
#include <wchar.h>

Include dependency graph for ui_ncurses_draw.c:

Go to the source code of this file.

Macros
#define	_XOPEN_SOURCE_EXTENDED   1

Functions
int	mbstr_to_cc (char *in_str, UiCell *cmplx_buf_s)
	Convert a multibyte string to a complex character array.
void	parse_ansi (char *ansi_str, attr_t *attr, uint *cpx)
	Parse an ANSI SGR sequence and update attributes and color pair index.
int	ui_draw_ch_yx (UiSurface *s, uint w, uint y, uint x, const char c)
int	ui_draw_text (UiSurface *s, uint w, uint y, uint x, const char *text)
int	ui_draw_text_fill (UiSurface *s, uint w, uint y, uint x, const char *text, int n)
int	ui_draw_text_n (UiSurface *s, uint w, uint y, uint x, const char *text, int n)
int	ui_mvaddstr (UiSurface *s, uint w, uint y, uint x, const char *text)
int	ui_mvwadd_wch (UiSurface *s, uint w, uint y, uint x, const UiCell *cell)
int	ui_mvwadd_wchnstr (UiSurface *s, uint w, uint y, uint x, const UiCell *cmplx_buf, uint n)
int	ui_mvwadd_wchstr (UiSurface *s, uint w, uint y, uint x, const UiCell *cmplx_buf)
int	ui_mvwaddch (UiSurface *s, uint w, uint y, uint x, const char c)
int	ui_mvwaddnstr (UiSurface *s, uint w, uint y, uint x, const char *text, int m)
int	ui_mvwaddnwstr (UiSurface *s, uint w, uint y, uint x, const wchar_t *wstr, int m)
int	ui_mvwaddstr (UiSurface *s, uint w, uint y, uint x, const char *text)
int	ui_mvwaddstr_fill (UiSurface *s, uint w, uint y, uint x, const char *str, int m)
int	ui_mvwaddwstr (UiSurface *s, uint w, uint y, uint x, const wchar_t *wstr)
void	ui_restore_wins ()
int	ui_wadd_wch (UiSurface *s, uint w, const UiCell *cell)
int	ui_wadd_wchnstr (UiSurface *s, uint w, const UiCell *cmplx_buf, uint n)
int	ui_wadd_wchstr (UiSurface *s, uint w, const UiCell *cmplx_buf)
int	ui_waddnwstr (UiSurface *s, uint w, const wchar_t *wstr, int m)
int	ui_waddstr (UiSurface *s, uint w, const char *text)
int	ui_waddwstr (UiSurface *s, uint w, const wchar_t *wstr)
int	ui_wclrtobot (UiSurface *s, uint w)
int	ui_wclrtoeol (UiSurface *s, uint w)

Detailed Description

NCurses UI backend — drawing functions.

Implements the drawing operations declared in ui_backend.h using the NCurses wide-character API.

Definition in file ui_ncurses_draw.c.

Macro Definition Documentation

_XOPEN_SOURCE_EXTENDED

#define _XOPEN_SOURCE_EXTENDED   1

Definition at line 9 of file ui_ncurses_draw.c.

Function Documentation

mbstr_to_cc()

int mbstr_to_cc	(	char *	in_str,
		UiCell *	cmplx_buf_s )

Convert a multibyte string to a complex character array.

Definition at line 224 of file ui_ncurses_draw.c.

                                                   {
    char ansi_tok[MAXLEN];
    uint i = 0, j = 0, x = 0;
    uint len = 0;
    uint tab_stop = 4;
    uint tab_spaces = 0;
    uint char_width;
    attr_t attr = WA_NORMAL;
    uint cpx = cp_nt;
    UiCell cc = {0};
    wchar_t wstr[2] = {L'\0', L'\0'};
    UiCell *cmplx_buf = cmplx_buf_s;
    mbstate_t mbstate;
    memset(&mbstate, 0, sizeof(mbstate));
    while (in_str[i] != '\0') {        // line
        while (1) {                    // ANSI SGR, Character, and Word
            if (in_str[i] == '\033') { // ANSI SGR
                if (in_str[i + 1] == '[') {
                    len = strcspn(&in_str[i], "mK ") + 1;
                    memcpy(ansi_tok, &in_str[i], len + 1);
                    ansi_tok[len] = '\0';
                    if (ansi_tok[0] == '\0') {
                        if (i + 2 < MAXLEN)
                            i += 2;
                        continue;
                    }
                    if (len == 0 || in_str[i + len - 1] == ' ') {
                        i += 2;
                        continue;
                    } else if (in_str[i + len - 1] == 'K') {
                        i += len;
                        continue;
                    }
                    parse_ansi(ansi_tok, &attr, &cpx);
                    i += len;
                } else {
                    i++;
                    continue;
                }
            } else { // Characters
                if (in_str[i] == ' ') {
                    wstr[0] = L' ';
                    wstr[1] = L'\0';
                    setcchar(&cc, wstr, attr, cpx, nullptr);
                    cmplx_buf[j++] = cc;
                    x++;
                    i++;
                    continue;
                }
                if (in_str[i] == '\0') {
                    break;
                }
                if (in_str[i] == '\t') {
                    tab_spaces = tab_stop - j % tab_stop;
                    wstr[0] = L' ';
                    wstr[1] = L'\0';
                    setcchar(&cc, wstr, attr, cpx, nullptr);
                    for (uint z = 0; z < tab_spaces; z++) {
                        cmplx_buf[j++] = cc;
                        x++;
                    }
                    i++;
                    continue;
                }
                wstr[1] = L'\0';
                len = mbrtowc(wstr, &in_str[i], MB_CUR_MAX, &mbstate);
                if (len <= 0) {
                    wstr[0] = L'?';
                    wstr[1] = L'\0';
                    len = 1;
                }
                char_width = wcwidth(wstr[0]);
                x += char_width;
                setcchar(&cc, wstr, attr, cpx, nullptr);
                cmplx_buf[j++] = cc;
                i += len;
                continue;
            } // END Character and Word
        } // END WHILE - ANSI SGR, Character, and Word
    } // END WHILE - line
    wstr[0] = '\0';
    wstr[1] = '\0';
    setcchar(&cc, wstr, WA_NORMAL, cpx, nullptr);
    cmplx_buf[j] = cc;
    return x;
}

References cp_nt, and parse_ansi().

Here is the call graph for this function:

parse_ansi()

void parse_ansi	(	char *	ansi_str,
		attr_t *	attr,
		uint *	cpx )

Parse an ANSI SGR sequence and update attributes and color pair index.

Definition at line 311 of file ui_ncurses_draw.c.

                                                         {
    char *tok;
    char t0, t1;
    char tstr[3];
    uint len, x_idx;
    uint fg, bg;
    int _fg_clr, _bg_clr;
    uint fg_clr, bg_clr;
    char *ansi_p = ansi_str + 2;
    extended_pair_content(*cpx, &_fg_clr, &_bg_clr);
    fg = fg_clr = (uint)_fg_clr;
    bg = fg_clr = (uint)_bg_clr;
    RGB rgb;
    tok = strtok((char *)ansi_p, ";m");
    bool a_toi_error = false;
    while (1) {
        if (tok == nullptr || *tok == '\0')
            break;
        len = strlen(tok);
        if (len == 2) {
            t0 = tok[0];
            t1 = tok[1];
            if (t0 == '3' || t0 == '4') {
                if (t1 == '8') {
                    tok = strtok(nullptr, ";m");
                    if (tok != nullptr) {
                        if (*tok == '5') {
                            tok = strtok(nullptr, ";m");
                            if (tok != nullptr) {
                                x_idx = a_toi(tok, &a_toi_error);
                                rgb = xterm256_idx_to_rgb(x_idx);
                            }
                        } else if (*tok == '2') {
                            tok = strtok(nullptr, ";m");
                            rgb.r = a_toi(tok, &a_toi_error);
                            tok = strtok(nullptr, ";m");
                            rgb.g = a_toi(tok, &a_toi_error);
                            tok = strtok(nullptr, ";m");
                            rgb.b = a_toi(tok, &a_toi_error);
                        }
                    }
                    if (t0 == '3')
                        fg_clr = ui_add_color_rgb(&rgb);
                    else if (t0 == '4')
                        bg_clr = ui_add_color_rgb(&rgb);
                } else if (t1 == '9') {
                    if (t0 == '3')
                        fg_clr = CLR_NT_FG;
                    else if (t0 == '4')
                        bg_clr = CLR_NT_BG;
                } else if (t1 >= '0' && t1 <= '7') {
                    if (t0 == '3') {
                        tstr[0] = t1;
                        tstr[1] = '\0';
                        x_idx = a_toi(tstr, &a_toi_error);
                        rgb = xterm256_idx_to_rgb(x_idx);
                        fg_clr = ui_add_color_rgb(&rgb);
                    } else if (t0 == '4') {
                        tstr[0] = t1;
                        tstr[1] = '\0';
                        x_idx = a_toi(tstr, &a_toi_error);
                        rgb = xterm256_idx_to_rgb(x_idx);
                        bg_clr = ui_add_color_rgb(&rgb);
                    }
                }
            } else if (t0 == '0') {
                *tok = t1;
                len = 1;
            }
        }
        if (len == 1) {
            if (*tok == '0') {
                *attr = WA_NORMAL;
                fg_clr = CLR_NT_FG;
                bg_clr = CLR_NT_BG;
            } else {
                switch (a_toi(tok, &a_toi_error)) {
                case 1:
                    *attr |= WA_BOLD;
                    break;
                case 2:
                    *attr |= WA_DIM;
                    break;
                case 3:
                    *attr |= WA_ITALIC;
                    break;
                case 4:
                    *attr |= WA_UNDERLINE;
                    break;
                case 5:
                    *attr |= WA_BLINK;
                    break;
                case 7:
                    *attr |= WA_REVERSE;
                    break;
                case 8:
                    *attr |= WA_INVIS;
                    break;
                default:
                    break;
                }
            }
        } else if (len == 0) {
            *attr = WA_NORMAL;
            fg_clr = CLR_NT_FG;
            bg_clr = CLR_NT_BG;
        }
        tok = strtok(nullptr, ";m");
    }
    if (!a_toi_error && (fg_clr != fg || bg_clr != bg))
        *cpx = ui_add_pair(fg_clr, bg_clr);
    return;
}

References a_toi(), CLR_NT_BG, CLR_NT_FG, ui_add_color_rgb(), ui_add_pair(), and xterm256_idx_to_rgb().

Referenced by mbstr_to_cc().

Here is the call graph for this function:

Here is the caller graph for this function:

ui_draw_ch_yx()

int ui_draw_ch_yx	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char	c )

Definition at line 40 of file ui_ncurses_draw.c.

                                                                      {
    if (!s)
        return -1;
    mvwaddch(s->mwin[w], y, x, c);
    return 0;
}

ui_draw_text()

int ui_draw_text	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char *	text )

Definition at line 47 of file ui_ncurses_draw.c.

                                                                         {
    if (!s || !text)
        return -1;
    mvwaddstr(s->mwin[w], y, x, text);
    return 0;
}

ui_draw_text_fill()

int ui_draw_text_fill	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char *	text,
		int	n )

Definition at line 61 of file ui_ncurses_draw.c.

                                                                                     {
    if (!s || !text)
        return -1;
    uint l = strlen(text);
    if (l < (uint)n) {
        char *tmp_str = (char *)malloc(n + 1);
        if (!tmp_str)
            return -1;
        strcpy(tmp_str, text);
        for (int i = l; i < (int)n; i++) {
            tmp_str[i] = ' ';
        }
        tmp_str[n] = '\0';
        mvwaddstr(s->mwin[w], y, x, tmp_str);
        free(tmp_str);
    } else {
        mvwaddnstr(s->mwin[w], y, x, text, (int)n);
    }
    return 0;
}

ui_draw_text_n()

int ui_draw_text_n	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char *	text,
		int	n )

Definition at line 54 of file ui_ncurses_draw.c.

                                                                                  {
    if (!s || !text)
        return -1;
    mvwaddnstr(s->mwin[w], y, x, text, (int)n);
    return 0;
}

ui_mvaddstr()

int ui_mvaddstr	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char *	text )

Definition at line 118 of file ui_ncurses_draw.c.

                                                                        {
    if (!s || !text)
        return -1;
    mvwaddstr(s->mwin[w], y, x, text);
    return 0;
}

ui_mvwadd_wch()

int ui_mvwadd_wch	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const UiCell *	cell )

Definition at line 175 of file ui_ncurses_draw.c.

                                                                            {
    if (!s)
        return -1;
    mvwadd_wch(s->mwin[w], y, x, cell);
    return 0;
}

ui_mvwadd_wchnstr()

int ui_mvwadd_wchnstr	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const UiCell *	cmplx_buf,
		uint	n )

Definition at line 201 of file ui_ncurses_draw.c.

                                                                                             {
    if (!s || !cmplx_buf)
        return -1;
    mvwadd_wchnstr(s->mwin[w], y, x, cmplx_buf, n);
    return 0;
}

ui_mvwadd_wchstr()

int ui_mvwadd_wchstr	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const UiCell *	cmplx_buf )

Definition at line 188 of file ui_ncurses_draw.c.

                                                                                    {
    if (!s || !cmplx_buf)
        return -1;
    mvwadd_wchstr(s->mwin[w], y, x, cmplx_buf);
    return 0;
}

ui_mvwaddch()

int ui_mvwaddch	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char	c )

Definition at line 125 of file ui_ncurses_draw.c.

                                                                    {
    if (!s || !c)
        return -1;
    mvwaddch(s->mwin[w], y, x, c);
    return 0;
}

ui_mvwaddnstr()

int ui_mvwaddnstr	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char *	text,
		int	m )

Definition at line 138 of file ui_ncurses_draw.c.

                                                                                 {
    if (!s || !text)
        return -1;
    mvwaddnstr(s->mwin[w], y, x, text, m);
    return 0;
}

ui_mvwaddnwstr()

int ui_mvwaddnwstr	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const wchar_t *	wstr,
		int	m )

Definition at line 102 of file ui_ncurses_draw.c.

                                                                                     {
    if (!s || !wstr)
        return -1;
    mvwaddnwstr(s->mwin[w], y, x, wstr, m);
    return 0;
}

ui_mvwaddstr()

int ui_mvwaddstr	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char *	text )

Definition at line 132 of file ui_ncurses_draw.c.

                                                                         {
    if (!s || !text)
        return -1;
    mvwaddstr(s->mwin[w], y, x, text);
    return 0;
}

ui_mvwaddstr_fill()

int ui_mvwaddstr_fill	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const char *	str,
		int	m )

Definition at line 145 of file ui_ncurses_draw.c.

                                                                                    {
    char *d, *e;
    uint maxy, maxx;
    char tmp_str[MAXLEN];
    getmaxyx(s->mwin[w], maxy, maxx);
    y = min(y, maxy);
    m = min(m, maxx);
    m = min(m, (uint)MAXLEN - 1);
    e = d = tmp_str;
    e += m;
    while (d < e) {
        if (*str == '\0' || *str == '\n')
            *d++ = ' ';
        else
            *d++ = *str++;
    }
    *d = '\0';
    m = strlen(tmp_str);
    mvwaddnstr(s->mwin[w], y, x, tmp_str, m);
    return 0;
}

ui_mvwaddwstr()

int ui_mvwaddwstr	(	UiSurface *	s,
		uint	w,
		uint	y,
		uint	x,
		const wchar_t *	wstr )

Definition at line 90 of file ui_ncurses_draw.c.

                                                                             {
    if (!s || !wstr)
        return -1;
    mvwaddwstr(s->mwin[w], y, x, wstr);
    return 0;
}

ui_restore_wins()

void ui_restore_wins

(

)

Definition at line 210 of file ui_ncurses_draw.c.

                       {
    touchwin(stdscr);
    for (int s = 0; s <= sfc_ptr; s++) {
        for (uint w = 0; w < SUB_SFC_MAX; w++)
            if (ui_surface[s]->mwin[w] != nullptr)
                touchwin(ui_surface[s]->mwin[w]);
    }
    ui_render();
}

ui_wadd_wch()

int ui_wadd_wch	(	UiSurface *	s,
		uint	w,
		const UiCell *	cell )

Definition at line 169 of file ui_ncurses_draw.c.

                                                          {
    if (!s)
        return -1;
    wadd_wchnstr(s->mwin[w], cell, 1);
    return 0;
}

ui_wadd_wchnstr()

int ui_wadd_wchnstr	(	UiSurface *	s,
		uint	w,
		const UiCell *	cmplx_buf,
		uint	n )

Definition at line 195 of file ui_ncurses_draw.c.

                                                                           {
    if (!s || !cmplx_buf)
        return -1;
    wadd_wchnstr(s->mwin[w], cmplx_buf, n);
    return 0;
}

ui_wadd_wchstr()

int ui_wadd_wchstr	(	UiSurface *	s,
		uint	w,
		const UiCell *	cmplx_buf )

Definition at line 181 of file ui_ncurses_draw.c.

                                                                  {
    if (!s || !cmplx_buf)
        return -1;
    wadd_wchstr(s->mwin[w], cmplx_buf);
    return 0;
}

ui_waddnwstr()

int ui_waddnwstr	(	UiSurface *	s,
		uint	w,
		const wchar_t *	wstr,
		int	m )

Definition at line 96 of file ui_ncurses_draw.c.

                                                                   {
    if (!s || !wstr)
        return -1;
    waddnwstr(s->mwin[w], wstr, m);
    return 0;
}

ui_waddstr()

int ui_waddstr	(	UiSurface *	s,
		uint	w,
		const char *	text )

Definition at line 111 of file ui_ncurses_draw.c.

                                                       {
    if (!s || !text)
        return -1;
    waddstr(s->mwin[w], text);
    return 0;
}

ui_waddwstr()

int ui_waddwstr	(	UiSurface *	s,
		uint	w,
		const wchar_t *	wstr )

Definition at line 84 of file ui_ncurses_draw.c.

                                                           {
    if (!s || !wstr)
        return -1;
    waddwstr(s->mwin[w], wstr);
    return 0;
}

ui_wclrtobot()

int ui_wclrtobot	(	UiSurface *	s,
		uint	w )

Definition at line 25 of file ui_ncurses_draw.c.

                                       {
    if (!s)
        return -1;
    wclrtobot(s->mwin[w]);
    return 0;
}

ui_wclrtoeol()

int ui_wclrtoeol	(	UiSurface *	s,
		uint	w )

Definition at line 31 of file ui_ncurses_draw.c.

                                       {
    if (!s)
        return -1;
    wclrtoeol(s->mwin[w]);
    return 0;
}