screen.c

Mrxvt是一个小巧

			  || (j - count < row1 && j >= row1)
			  || (j - count > row2 && j <= row2)
		   )
		{
			CLEAR_ALL_SELECTION(r);
			/* XXX: too aggressive? */
			SEL(r).op = SELECTION_CLEAR;
		}
		else if (j >= row1 && j <= row2)
		{
			/* move selected region too */
			SEL(r).beg.row -= count;
			SEL(r).end.row -= count;
			SEL(r).mark.row -= count;
		}
	}

	/* _after_ PVTS(r, page)->nscrolled update */
	rxvt_selection_check(r, page, 0);

	PVTS(r, page)->num_scr += count;
	j = count;
	if (count < 0)
		count = -count;
	i = row2 - row1 + 1;
	MIN_IT(count, i);

	if (j > 0)
	{
		/* A: scroll up */

		/* A1: Copy lines that will get clobbered by the rotation */
		for (i = 0, j = row1; i < count; i++, j++)
		{
			PVTS(r, page)->buf_text[i] = PSCR(r, page).text[j];
			PVTS(r, page)->buf_rend[i] = PSCR(r, page).rend[j];
		}

		/* A2: Rotate lines */
		for (j = row1, i = j + count; i <= row2; i++, j++)
		{
			PSCR(r, page).tlen[j] = PSCR(r, page).tlen[i];
			PSCR(r, page).text[j] = PSCR(r, page).text[i];
			PSCR(r, page).rend[j] = PSCR(r, page).rend[i];
		}
		j = row2 - count + 1, i = count;
	}
	else /* if (j < 0) */
	{
		/* B: scroll down */

		/* B1: Copy lines that will get clobbered by the rotation */
		for (i = 0, j = row2; i < count; i++, j--)
		{
			PVTS(r, page)->buf_text[i] = PSCR(r, page).text[j];
			PVTS(r, page)->buf_rend[i] = PSCR(r, page).rend[j];
		}

		/* B2: Rotate lines */
		for (j = row2, i = j - count; i >= row1; i--, j--)
		{
			PSCR(r, page).tlen[j] = PSCR(r, page).tlen[i];
			PSCR(r, page).text[j] = PSCR(r, page).text[i];
			PSCR(r, page).rend[j] = PSCR(r, page).rend[i];
		}
		j = row1, i = count;
		count = -count;
	}

	/* C: Resurrect lines */
	for (; i--; j++)
	{
		PSCR(r, page).tlen[j] = 0;
		PSCR(r, page).text[j] = PVTS(r, page)->buf_text[i];
		PSCR(r, page).rend[j] = PVTS(r, page)->buf_rend[i];
		if (!spec)		/* line length may not equal TermWin.ncol */
			rxvt_blank_screen_mem(r, page, PSCR(r, page).text,
					PSCR(r, page).rend, (unsigned int)j,
					PVTS(r, page)->rstyle);
	}

	return count;
}

/* ------------------------------------------------------------------------- */
/*
 * Add text given in <str> of length <len> to screen struct
 */
/* EXTPROTO */
void
rxvt_scr_add_lines(rxvt_t* r, int page, const unsigned char *str, int nlines, int len)
{
	unsigned char   checksel, clearsel;
	char			c;
	int			 i, row, last_col;
	text_t		 *stp;
	rend_t		 *srp;
	struct rxvt_hidden *h = r->h;

	if (len <= 0)		/* sanity */
	return;

	h->want_refresh = 1;
	last_col = r->TermWin.ncol;

	DBG_MSG(2,(stderr, "rxvt_scr_add_lines %d (%d,%d)\n", page, nlines, len));
	ZERO_SCROLLBACK(r, page);
	if (nlines > 0)
	{
		nlines += (CURROW - PSCR(r, page).bscroll);
		if (
			  (nlines > 0)
			  && (PSCR(r, page).tscroll == 0)
			  && (PSCR(r, page).bscroll == (r->TermWin.nrow - 1))
		   )
		{
			/* _at least_ this many lines need to be scrolled */
			rxvt_scroll_text(r, page, PSCR(r, page).tscroll,
				PSCR(r, page).bscroll, nlines, 0);
			CURROW -= nlines;
		}
	}

	assert(CURCOL < last_col);
	assert((CURROW < r->TermWin.nrow) &&
		(CURROW >= -(RINT32T)PVTS(r, page)->nscrolled));
	MIN_IT(CURCOL, last_col - 1);
	MIN_IT(CURROW, (RINT32T)r->TermWin.nrow - 1);
	MAX_IT(CURROW, -(RINT32T)PVTS(r, page)->nscrolled);

	row = CURROW + SVLINES;

	checksel = (SEL(r).op && SEL(r).vt == page &&
		PVTS(r, page)->current_screen == SEL(r).screen) ? 1 : 0;
	clearsel = 0;

	stp = PSCR(r, page).text[row];
	srp = PSCR(r, page).rend[row];

#ifdef MULTICHAR_SET
	if (PVTS(r, page)->lost_multi &&
		CURCOL > 0 &&
		IS_MULTI1(srp[CURCOL - 1]) &&
		*str != '\n' && *str != '\r' && *str != '\t')
		PVTS(r, page)->chstat = WBYTE;
#endif

	for (i = 0; i < len;)
	{
		c = str[i++];
		switch (c)
		{
			case '\t':
				rxvt_scr_tab(r, page, 1);
				continue;

			case '\n':
				/* XXX: think about this */
				if (PSCR(r, page).tlen[row] != -1)
					MAX_IT(PSCR(r, page).tlen[row], CURCOL);
					PSCR(r, page).flags &= ~Screen_WrapNext;
					if (CURROW == PSCR(r, page).bscroll)
						rxvt_scroll_text(r, page, PSCR(r, page).tscroll,
							PSCR(r, page).bscroll, 1, 0);
					else if (CURROW < (r->TermWin.nrow - 1))
						row = (++CURROW) + SVLINES;
					stp = PSCR(r, page).text[row];	/* _must_ refresh */
					srp = PSCR(r, page).rend[row];	/* _must_ refresh */
					RESET_CHSTAT(r, page);
					continue;

			case '\r':
				/* XXX: think about this */
				if (PSCR(r, page).tlen[row] != -1)
					MAX_IT(PSCR(r, page).tlen[row], CURCOL);
				PSCR(r, page).flags &= ~Screen_WrapNext;
				CURCOL = 0;
				RESET_CHSTAT(r, page);
				continue;

			default:
#ifdef MULTICHAR_SET
				if (r->encoding_method == ENC_NOENC)
				{
					if (c == 127)
						continue;
					break;
				}
				PVTS(r, page)->rstyle &= ~RS_multiMask;

				/* multibyte 2nd byte */
				if (PVTS(r, page)->chstat == WBYTE)
				{
					/* set flag of second byte in style */
					PVTS(r, page)->rstyle |= RS_multi2;
					/* switch back to single byte for next char */
					PVTS(r, page)->chstat = SBYTE;
					if (
						  (r->encoding_method == ENC_EUCJ)
						  && ((char) stp[CURCOL-1] == (char) 0x8e)
					   )
					{
						PVTS(r, page)->rstyle &= ~RS_multiMask;
						CURCOL --;
					}
					else
					/* maybe overkill, but makes it selectable */
					if ((r->encoding_method == ENC_EUCJ) ||
						(r->encoding_method == ENC_GBK) ||
						(r->encoding_method == ENC_GB))
						c |= 0x80;
				}
				/* multibyte 1st byte */
				else if (PVTS(r, page)->chstat == SBYTE)
				{
					if (r->encoding_method == ENC_SJIS)
					{
						if (
							  PVTS(r, page)->multi_byte
							  || (
								  (
								   (unsigned char) c >= (unsigned char) 0x81
								   && (unsigned char) c <= (unsigned char) 0x9f
								  )
								  ||
								  (
								   (unsigned char) c >= (unsigned char) 0xe0
								   && (unsigned char) c <= (unsigned char) 0xfc
								  )
								 )
						   )
						{
							PVTS(r, page)->rstyle |= RS_multi1;
							PVTS(r, page)->chstat = WBYTE;
						}
					}
					else if (PVTS(r, page)->multi_byte || (c & 0x80))
					{
						/* set flag of first byte in style */
						PVTS(r, page)->rstyle |= RS_multi1;
						/* switch to multiple byte for next char */
						PVTS(r, page)->chstat = WBYTE;
						/* maybe overkill, but makes selectable */
						if (
							  (r->encoding_method == ENC_EUCJ)
							  || (r->encoding_method == ENC_GBK)
							  || (r->encoding_method == ENC_GB)
						   )
							c |= 0x80;
					}
				}
				else
#endif
				if (c == 127)
					continue;	/* yummmm..... */
				break;
		}	/* switch */

		if (
			  checksel		/* see if we're writing within selection */
			  && !RC_BEFORE(PSCR(r, page).cur, SEL(r).beg)
			  && RC_BEFORE(PSCR(r, page).cur, SEL(r).end)
		   )
		{
			checksel = 0;
			clearsel = 1;
		}

		if (PSCR(r, page).flags & Screen_WrapNext)
		{
			PSCR(r, page).tlen[row] = -1;
			if (CURROW == PSCR(r, page).bscroll)
				rxvt_scroll_text(r, page, PSCR(r, page).tscroll,
						PSCR(r, page).bscroll, 1, 0);
			else if (CURROW < (r->TermWin.nrow - 1))
				row = (++CURROW) + SVLINES;
			stp = PSCR(r, page).text[row];	/* _must_ refresh */
			srp = PSCR(r, page).rend[row];	/* _must_ refresh */
			CURCOL = 0;
			PSCR(r, page).flags &= ~Screen_WrapNext;
		}

		if (PSCR(r, page).flags & Screen_Insert)
			rxvt_scr_insdel_chars(r, page, 1, INSERT);

#ifdef MULTICHAR_SET
		if (
			  IS_MULTI1(PVTS(r, page)->rstyle)
			  && CURCOL > 0
			  && IS_MULTI1(srp[CURCOL - 1])
		   )
		{
			stp[CURCOL - 1] = ' ';
			srp[CURCOL - 1] &= ~RS_multiMask;
		}
		else if (
				  IS_MULTI2(PVTS(r, page)->rstyle)
				  && CURCOL < (last_col - 1)
				  && IS_MULTI2(srp[CURCOL + 1])
				)
		{
			stp[CURCOL + 1] = ' ';
			srp[CURCOL + 1] &= ~RS_multiMask;
		}
#endif

		stp[CURCOL] = c;
		srp[CURCOL] = PVTS(r, page)->rstyle;
		if (CURCOL < (last_col - 1))
			CURCOL++;
		else
		{
			PSCR(r, page).tlen[row] = last_col;
			if (PSCR(r, page).flags & Screen_Autowrap)
				PSCR(r, page).flags |= Screen_WrapNext;
		}
	}	/* for */

	if (PSCR(r, page).tlen[row] != -1)	/* XXX: think about this */
		MAX_IT(PSCR(r, page).tlen[row], CURCOL);

	/*
	** If we wrote anywhere in the selected area, kill the selection
	** XXX: should we kill the mark too?  Possibly, but maybe that
	**	  should be a similar check.
	*/
	if (clearsel)
		CLEAR_SELECTION(r);

	assert(CURROW >= 0);
	MAX_IT(CURROW, 0);
}

/* ------------------------------------------------------------------------- */
/*
 * Process Backspace.  Move back the cursor back a position, wrap if have to
 * XTERM_SEQ: CTRL-H
 */
/* EXTPROTO */
void
rxvt_scr_backspace(rxvt_t* r, int page)
{
	RESET_CHSTAT(r, page);
	r->h->want_refresh = 1;
	if (CURCOL == 0)
	{
		if (CURROW > 0)
		{
#ifdef TERMCAP_HAS_BW
			CURCOL = r->TermWin.ncol - 1;
			CURROW--;
			return;
#endif
		}
	} else if ((PSCR(r, page).flags & Screen_WrapNext) == 0)
		rxvt_scr_gotorc(r, page, 0, -1, RELATIVE);
	PSCR(r, page).flags &= ~Screen_WrapNext;
}

/* ------------------------------------------------------------------------- */
/*
 * Process Horizontal Tab
 * count: +ve = forward; -ve = backwards
 * XTERM_SEQ: CTRL-I
 */
/* EXTPROTO */
void
rxvt_scr_tab(rxvt_t* r, int page, int count)
{
	int			 i, x;

	DBG_MSG(3,(stderr, "rxvt_scr_tab %d (%d)\n", page, count));
	r->h->want_refresh = 1;
	RESET_CHSTAT(r, page);
	i = x = CURCOL;
	if (count == 0)
		return;
	else if (count > 0)
	{
		for (; ++i < r->TermWin.ncol; )
			if (r->tabstop[i])
			{
				x = i;
				if (!--count)
					break;
			}
		;
		if (count)
			x = r->TermWin.ncol - 1;
	}
	else /* if (count < 0) */
	{
		for (; --i >= 0; )
			if (r->tabstop[i])
			{
				x = i;
				if (!++count)
					break;
			}
		;
		if (count)
			x = 0;
	}
	if (x != CURCOL)
		rxvt_scr_gotorc(r, page, 0, x, R_RELATIVE);
}

/* ------------------------------------------------------------------------- */
/*
 * Process DEC Back Index
 * XTERM_SEQ: ESC 6
 * Move cursor left in row.  If we're at the left boundary, shift everything
 * in that row right.  Clear left column.
 */
#ifndef NO_FRILLS
/* EXTPROTO */
void
rxvt_scr_backindex(rxvt_t* r, int page)
{
	if (CURCOL > 0)
		rxvt_scr_gotorc(r, page, 0, -1, R_RELATIVE | C_RELATIVE);
	else
	{
		if (PSCR(r, page).tlen[CURROW + SVLINES] == 0)
			return;		/* um, yeah? */
		rxvt_scr_insdel_chars(r, page, 1, INSERT);
	}
}
#endif
/* ------------------------------------------------------------------------- */
/*
 * Process DEC Forward Index
 * XTERM_SEQ: ESC 9
 * Move cursor right in row.  If we're at the right boundary, shift everything
 * in that row left.  Clear right column.
 */
#ifndef NO_FRILLS
/* EXTPROTO */
void
rxvt_scr_forwardindex(rxvt_t* r, int page)
{
	int			 row;

	if (CURCOL < r->TermWin.ncol - 1)
		rxvt_scr_gotorc(r, page, 0, 1, R_RELATIVE | C_RELATIVE);
	else
	{
		row = CURROW + SVLINES;
		if (PSCR(r, page).tlen[row] == 0)
			return;		/* um, yeah? */
		else if (PSCR(r, page).tlen[row] == -1)
			PSCR(r, page).tlen[row] = r->TermWin.ncol;
		rxvt_scr_gotorc(r, page, 0, 0, R_RELATIVE);
		rxvt_scr_insdel_chars(r, page, 1, DELETE);
		rxvt_scr_gotorc(r, 0, page, r->TermWin.ncol - 1, R_RELATIVE);
	}
}
#endif

/* ------------------------------------------------------------------------- */
/*
 * Goto Row/Column
 */
/* EXTPROTO */
void
rxvt_scr_gotorc(rxvt_t* r, int page, int row, int col, int relative)
{
	r->h->want_refresh = 1;
	ZERO_SCROLLBACK(r, page);
	RESET_CHSTAT(r, page);

	DBG_MSG(2,(stderr, "rxvt_scr_gotorc %d (r:%s%d,c:%s%d): from (r:%d,c:%d)\n", page, (relative & R_RELATIVE ? "+" : ""), row, (relative & C_RELATIVE ? "+" : ""), col, CURROW, CURCOL));

	CURCOL = ((relative & C_RELATIVE) ? (CURCOL + col)
						 : col);
	MAX_IT(CURCOL, 0);
	MIN_IT(CURCOL, (RINT32T)r->TermWin.ncol - 1);

	PSCR(r, page).flags &= ~Screen_WrapNext;
	if (relative & R_RELATIVE)
	{
		if (row > 0)
		{
			if (CURROW <= PSCR(r, page).bscroll &&
				(CURROW + row) > PSCR(r, page).bscroll)
				CURROW = PSCR(r, page).bscroll;
			else
				CURROW += row;