static inline int waddch_literal(WINDOW *win, chtype ch) { int x; struct ldat *line; x = win->_curx; CHECK_POSITION(win, x, win->_cury); /* * If we're trying to add a character at the lower-right corner more * than once, fail. (Moving the cursor will clear the flag). */ if (win->_flags & _WRAPPED) { if (x >= win->_maxx) return (ERR); win->_flags &= ~_WRAPPED; } ch = render_char(win, ch); TR(TRACE_VIRTPUT, ("win attr = %s", _traceattr(win->_attrs))); line = win->_line+win->_cury; if (line->firstchar == _NOCHANGE) line->firstchar = line->lastchar = x; else if (x < line->firstchar) line->firstchar = x; else if (x > line->lastchar) line->lastchar = x; line->text[x++] = ch; TR(TRACE_VIRTPUT, ("(%d, %d) = %s", win->_cury, x, _tracechtype(ch))); if (x > win->_maxx) { /* * The _WRAPPED flag is useful only for telling an application * that we've just wrapped the cursor. We don't do anything * with this flag except set it when wrapping, and clear it * whenever we move the cursor. If we try to wrap at the * lower-right corner of a window, we cannot move the cursor * (since that wouldn't be legal). So we return an error * (which is what SVr4 does). Unlike SVr4, we can successfully * add a character to the lower-right corner. */ win->_flags |= _WRAPPED; if (++win->_cury > win->_regbottom) { win->_cury = win->_regbottom; win->_curx = win->_maxx; if (!win->_scroll) return (ERR); scroll(win); } win->_curx = 0; return (OK); } win->_curx = x; return OK; }
static #if !USE_WIDEC_SUPPORT /* cannot be inline if it is recursive */ NCURSES_INLINE #endif int waddch_literal(WINDOW *win, NCURSES_CH_T ch) { int x; int y; struct ldat *line; x = win->_curx; y = win->_cury; CHECK_POSITION(win, x, y); ch = render_char(win, ch); line = win->_line + y; CHANGED_CELL(line, x); /* * Build up multibyte characters until we have a wide-character. */ if_WIDEC({ if (WINDOW_EXT(win, addch_used) != 0 || !Charable(ch)) { int len = _nc_build_wch(win, CHREF(ch)); if (len >= -1) { /* handle EILSEQ */ if (is8bits(CharOf(ch))) { const char *s = unctrl((chtype) CharOf(ch)); if (s[1] != 0) { return waddstr(win, s); } } if (len == -1) return waddch(win, ' '); } else { return OK; } } });
static int wadd_wch_literal(WINDOW *win, cchar_t ch) { int x; int y; struct ldat *line; x = win->_curx; y = win->_cury; CHECK_POSITION(win, x, y); ch = render_char(win, ch); line = win->_line + y; CHANGED_CELL(line, x); /* * Non-spacing characters are added to the current cell. * * Spacing characters that are wider than one column require some display * adjustments. */ { int len = wcwidth(CharOf(ch)); int i; int j; wchar_t *chars; if (len == 0) { /* non-spacing */ if ((x > 0 && y >= 0) || (win->_maxx >= 0 && win->_cury >= 1)) { if (x > 0 && y >= 0) chars = (win->_line[y].text[x - 1].chars); else chars = (win->_line[y - 1].text[win->_maxx].chars); for (i = 0; i < CCHARW_MAX; ++i) { if (chars[i] == 0) { TR(TRACE_VIRTPUT, ("added non-spacing %d: %x", x, (int) CharOf(ch))); chars[i] = CharOf(ch); break; } } } goto testwrapping; } else if (len > 1) { /* multi-column characters */ /* * Check if the character will fit on the current line. If it does * not fit, fill in the remainder of the line with blanks. and * move to the next line. */ if (len > win->_maxx + 1) { TR(TRACE_VIRTPUT, ("character will not fit")); return ERR; } else if (x + len > win->_maxx + 1) { int count = win->_maxx + 1 - x; TR(TRACE_VIRTPUT, ("fill %d remaining cells", count)); fill_cells(win, count); if (wrap_to_next_line(win) == ERR) return ERR; x = win->_curx; y = win->_cury; line = win->_line + y; } /* * Check for cells which are orphaned by adding this character, set * those to blanks. * * FIXME: this actually could fill j-i cells, more complicated to * setup though. */ for (i = 0; i < len; ++i) { if (isWidecBase(win->_line[y].text[x + i])) { break; } else if (isWidecExt(win->_line[y].text[x + i])) { for (j = i; x + j <= win->_maxx; ++j) { if (!isWidecExt(win->_line[y].text[x + j])) { TR(TRACE_VIRTPUT, ("fill %d orphan cells", j)); fill_cells(win, j); break; } } break; } } /* * Finally, add the cells for this character. */ for (i = 0; i < len; ++i) { cchar_t value = ch; SetWidecExt(value, i); TR(TRACE_VIRTPUT, ("multicolumn %d:%d (%d,%d)", i + 1, len, win->_begy + y, win->_begx + x)); line->text[x] = value; CHANGED_CELL(line, x); ++x; } goto testwrapping; } } /* * Single-column characters. */ line->text[x++] = ch; /* * This label is used only for wide-characters. */ testwrapping: TR(TRACE_VIRTPUT, ("cell (%ld, %ld..%d) = %s", (long) win->_cury, (long) win->_curx, x - 1, _tracech_t(CHREF(ch)))); if (x > win->_maxx) { return wrap_to_next_line(win); } win->_curx = (NCURSES_SIZE_T) x; return OK; }
static #if !USE_WIDEC_SUPPORT /* cannot be inline if it is recursive */ NCURSES_INLINE #endif int waddch_literal(WINDOW *win, NCURSES_CH_T ch) { int x; int y; struct ldat *line; x = win->_curx; y = win->_cury; CHECK_POSITION(win, x, y); ch = render_char(win, ch); line = win->_line + y; CHANGED_CELL(line, x); /* * Build up multibyte characters until we have a wide-character. */ #if NCURSES_SP_FUNCS #define DeriveSP() SCREEN *sp = _nc_screen_of(win); #else #define DeriveSP() /*nothing */ #endif if_WIDEC({ DeriveSP(); if (WINDOW_EXT(win, addch_used) != 0 || !Charable(ch)) { int len = _nc_build_wch(win, CHREF(ch)); if (len >= -1) { attr_t attr = AttrOf(ch); /* handle EILSEQ (i.e., when len >= -1) */ if (len == -1 && is8bits(CharOf(ch))) { int rc = OK; const char *s = NCURSES_SP_NAME(unctrl) (NCURSES_SP_ARGx (chtype) CharOf(ch)); if (s[1] != '\0') { while (*s != '\0') { rc = waddch(win, UChar(*s) | attr); if (rc != OK) break; ++s; } return rc; } } if (len == -1) return waddch(win, ' ' | attr); } else { return OK; } } });