Пример #1
0
/*
 * Delete the character under the cursor; all characters to the right of
 * the cursor on the same line are moved to the left by one position and
 * the last character on the line is filled with a blank. The cursor
 * position does not change.
 */
int
wdelch(WINDOW *w)
{
	int	next, width, y, x;

	y = w->_cury;
	x = w->_curx;

	next = __m_cc_next(w, y, x);
	x = __m_cc_first(w, y, x);

	/* Determine the character width to delete. */
	width = __m_cc_width(&w->_line[y][x]);

	/* Shift line left to erase the character under the cursor. */
	(void) memcpy(&w->_line[y][x], &w->_line[y][next],
		(w->_maxx - next) * sizeof (**w->_line));

	/*
	 * Add blank(s) to the end of line based on the width
	 * of the character that was deleted.
	 */
	(void) __m_cc_erase(w, y, w->_maxx - width, y, w->_maxx - 1);

	/* Set dity region markers. */
	if (x < w->_first[y])
		w->_first[y] = (short) x;
	w->_last[y] = w->_maxx;

	WSYNC(w);

	return (WFLUSH(w));
}
Пример #2
0
int
winsnstr(WINDOW *w, const char *mbs, int n)
{
	cchar_t	cc;
	int	i, y, x;
	short	oflags;

	y = w->_cury;
	x = w->_curx;

	if (n < 0)
		n = INT_MAX;

	/*
	 * Disable window flushing until the entire string has
	 * been written into the window.
	 */
	oflags = w->_flags & (W_FLUSH | W_SYNC_UP);
	w->_flags &= ~(W_FLUSH | W_SYNC_UP);

	for (; *mbs != '\0' && 0 < n; n -= i, mbs += i) {
		if ((i = __m_mbs_cc(mbs, w->_bg._at, w->_fg._co, &cc))
			< 0	|| __m_wins_wch(w, y, x, &cc, &y, &x) == ERR)
			break;
	}

	w->_flags |= oflags;

	WSYNC(w);

	return (WFLUSH(w));
}
Пример #3
0
/*
 * Erase from the current cursor position in the window to the right
 * margin.
 */
int
wclrtoeol(WINDOW *w)
{
	int	x;

	x = __m_cc_first(w, w->_cury, w->_curx);
	if (__m_cc_erase(w, w->_cury, x, w->_cury, w->_maxx-1) != 0)
		return (ERR);

	WSYNC(w);

	return (WFLUSH(w));
}
Пример #4
0
int
waddchnstr(WINDOW *w, const chtype *chs, int n)
{
	cchar_t	cc;
	int	x, y, xnew, ynew;

	if (n < 0 || w->_maxx < (n += w->_curx))
		n = w->_maxx;

	for (x = w->_curx, y = w->_cury; x < n && *chs != 0;
		x = xnew, y = ynew, ++chs) {
		(void) __m_chtype_cc(*chs, &cc);
		if (__m_cc_add_k(w, y, x, &cc, 0, &ynew, &xnew) == ERR)
			break;
	}

	WSYNC(w);

	return (WFLUSH(w));
}
Пример #5
0
int
waddchnstr(WINDOW *w, const chtype *chs, int n)
{
	cchar_t cc;
	int x, width;

#ifdef M_CURSES_TRACE
	__m_trace("waddchnstr(%p, %p, %d)", w, chs, n);
#endif

	if (n < 0 || w->_maxx < (n += w->_curx))
		n = w->_maxx;

	for (x = w->_curx; x < n && *chs != 0; x += width, ++chs) {
                (void) __m_chtype_cc(*chs, &cc);
		width = __m_cc_replace(w, w->_cury, x, &cc, 0);
        }

	WSYNC(w);

	return __m_return_code("waddchnstr", WFLUSH(w));
}
Пример #6
0
/*
 * For positive n scroll the window up n lines (line i+n becomes i);
 * otherwise scroll the window down n lines.
 */
int
wscrl(WINDOW *w, int n)
{
	int	start, finish, to;

	if (!(w->_flags & W_CAN_SCROLL))
		return (ERR);

	if (n == 0)
		return (OK);

	if (w->_parent) {
		/* Sub-window should not shuffle pointers (parent owns them) */
		int	row;
		cchar_t	save;
		int	first;

		if (n > 0) {
			for (row = w->_top; row < w->_bottom; row++) {
				if (row < w->_bottom - n) {
					if (!w->_line[row+n][0]._f)	{
						/*
						 * Tail end of
						 * a multi-col-char
						 */
						(void) __m_cc_erase(w, row + n,
							0, row + n, 0);
					}
					/*
					 * Erase trailing multi-col-chars
					 * where they hang into parent window
					 */
					first = __m_cc_first(w, row + n,
						w->_maxx - 1);
					save = w->_line[row + n][first];
					(void) __m_cc_erase(w, row + n,
						first, row + n, first);
					w->_line[row + n][first] = save;
					(void) memcpy(w->_line[row],
						w->_line[row + n],
						sizeof (cchar_t) * w->_maxx);
				} else {
					(void) __m_cc_erase(w, row, 0,
						w->_bottom -1, w->_maxx - 1);
					break;
				}
			}
		} else {
			abort();
		}
	} else {
		/*
		 * Shuffle pointers in order to scroll.  The region
		 * from start to finish inclusive will be moved to
		 * either the top or bottom of _line[].
		 */
		if (0 < n) {
			start = w->_top;
			finish = w->_top + n - 1;
			to = w->_bottom;
		} else {
			start = w->_bottom + n;
			finish = w->_bottom - 1;
			to = w->_top;
		}

		/* Blank out new lines. */
		(void) __m_cc_erase(w, start, 0, finish, w->_maxx - 1);

		/* Scroll lines by shuffling pointers. */
		(void) __m_ptr_move((void **) w->_line, w->_maxy,
			start, finish, to);
	}

	if ((w->_flags & W_FULL_WINDOW) &&
		w->_top == 0 && w->_bottom == w->_maxy)
		w->_scroll += (short) n;
	else
		w->_scroll = 0;

	(void) wtouchln(w, 0, w->_maxy, 1);
	wtouchln_hard(w, 0, w->_maxy);

#ifdef	BREAKS_fimmedok_fimmedok1_2
	w->_flags |= W_FLUSH;
#endif	/* BREAKS_fimmedok_fimmedok1_2 */

	WSYNC(w);

	return (WFLUSH(w));
}