screen.c

Mrxvt是一个小巧

		}

		else if (row < 0)
		{
			if (CURROW >= PSCR(r, page).tscroll &&
				(CURROW + row) < PSCR(r, page).tscroll)
				CURROW = PSCR(r, page).tscroll;
			else
				CURROW += row;
		}
	}
	else
	{
		if (PSCR(r, page).flags & Screen_Relative)
		{
			/* relative origin mode */
			CURROW = row + PSCR(r, page).tscroll;
			MIN_IT(CURROW, PSCR(r, page).bscroll);
		}
		else
			CURROW = row;
	}
	MAX_IT(CURROW, 0);
	MIN_IT(CURROW, (RINT32T)r->TermWin.nrow - 1);
}

/* ------------------------------------------------------------------------- */
/*
 * direction  should be UP or DN
 */
/* EXTPROTO */
void
rxvt_scr_index(rxvt_t* r, int page, enum page_dirn direction)
{
	int			 dirn;

	r->h->want_refresh = 1;
	dirn = ((direction == UP) ? 1 : -1);
	DBG_MSG(1,(stderr, "rxvt_scr_index %d (%d)\n", page, dirn));

	ZERO_SCROLLBACK(r, page);
	RESET_CHSTAT(r, page);

	PSCR(r, page).flags &= ~Screen_WrapNext;
	if ((CURROW == PSCR(r, page).bscroll && direction == UP) ||
		(CURROW == PSCR(r, page).tscroll && direction == DN))
		rxvt_scroll_text(r, page, PSCR(r, page).tscroll, PSCR(r, page).bscroll, dirn, 0);
	else
		CURROW += dirn;
	MAX_IT(CURROW, 0);
	MIN_IT(CURROW, (RINT32T)r->TermWin.nrow - 1);
	rxvt_selection_check(r, page, 0);
}

/* ------------------------------------------------------------------------- */
/*
 * Erase part or whole of a line
 * XTERM_SEQ: Clear line to right: ESC [ 0 K
 * XTERM_SEQ: Clear line to left : ESC [ 1 K
 * XTERM_SEQ: Clear whole line   : ESC [ 2 K
 */
/* EXTPROTO */
void
rxvt_scr_erase_line(rxvt_t* r, int page, int mode)
{
	unsigned int	row, col, num;

	r->h->want_refresh = 1;
	DBG_MSG(2,(stderr, "rxvt_scr_erase_line %d (%d) at screen row: %d\n",
				page, mode, CURROW));
	ZERO_SCROLLBACK(r, page);
	RESET_CHSTAT(r, page);
	rxvt_selection_check(r, page, 1);

	PSCR(r, page).flags &= ~Screen_WrapNext;

	row = SVLINES + CURROW;
	switch (mode)
	{
		case 0:			/* erase to end of line */
			col = CURCOL;
			num = r->TermWin.ncol - col;
			MIN_IT(PSCR(r, page).tlen[row], (RINT16T)col);
			if (
				  RC_ROW_ATAFTER(SEL(r).beg, PSCR(r, page).cur)
				  || RC_ROW_ATAFTER(SEL(r).end, PSCR(r, page).cur)
			   )
				CLEAR_SELECTION(r);
			break;
		case 1:			/* erase to beginning of line */
			col = 0;
			num = CURCOL + 1;
			if (
				  RC_ROW_ATBEFORE(SEL(r).beg, PSCR(r, page).cur)
				  || RC_ROW_ATBEFORE(SEL(r).end, PSCR(r, page).cur)
			   )
				CLEAR_SELECTION(r);
			break;
		case 2:			/* erase whole line */
			col = 0;
			num = r->TermWin.ncol;
			PSCR(r, page).tlen[row] = 0;
			if (SEL(r).beg.row <= CURROW && SEL(r).end.row >= CURROW)
				CLEAR_SELECTION(r);
			break;
		default:
			return;
	}

	if (PSCR(r, page).text[row])
		rxvt_blank_line(&(PSCR(r, page).text[row][col]),
			&(PSCR(r, page).rend[row][col]), num, PVTS(r, page)->rstyle);
	else
		rxvt_blank_screen_mem(r, page, PSCR(r, page).text,
			PSCR(r, page).rend, row, PVTS(r, page)->rstyle);
}

/* ------------------------------------------------------------------------- */
/*
 * Erase part of whole of the screen
 * XTERM_SEQ: Clear screen after cursor : ESC [ 0 J
 * XTERM_SEQ: Clear screen before cursor: ESC [ 1 J
 * XTERM_SEQ: Clear whole screen		: ESC [ 2 J
 */
/* EXTPROTO */
void
rxvt_scr_erase_screen(rxvt_t* r, int page, int mode)
{
	int			num;
	RINT32T		row, row_offset;
	rend_t		ren;
	XGCValues	gcvalue;

	r->h->want_refresh = 1;
	DBG_MSG(2,(stderr, "rxvt_scr_erase_screen %d (%d) at screen row: %d\n",
				page, mode, CURROW));
	ZERO_SCROLLBACK(r, page);
	RESET_CHSTAT(r, page);
	row_offset = (RINT32T)SVLINES;

	switch (mode)
	{
		case 0:			/* erase to end of screen */
			rxvt_selection_check(r, page, 1);
			rxvt_scr_erase_line(r, page, 0);
			row = CURROW + 1;	/* possible OOB */
			num = r->TermWin.nrow - row;
			break;
		case 1:			/* erase to beginning of screen */
			rxvt_selection_check(r, page, 3);
			rxvt_scr_erase_line(r, page, 1);
			row = 0;
			num = CURROW;
			break;
		case 2:			/* erase whole screen */
			/*
			 * 2006-02-15 gi1242: As pointed out by Sabit Sayeed, Gnome terminal
			 * scrolls the text off screen, instead of wiping it out completely.
			 * That's seems much better so let's do it here.
			 */
			if( PVTS(r, page)->current_screen == PRIMARY )
			{
				/*
				 * Only scroll if the primary screen is bieng cleared.
				 */
				int sr;

				/*
				 * Find the last non-empty line to save.
				 */
				for( sr = SVLINES + r->TermWin.nrow - 1; sr >= SVLINES; sr--)
				{
					int non_empty = 0, sc;

					for( sc = 0; sc < PSCR( r, page).tlen[sr]; sc++)
						if (
							  PSCR( r, page).text[sr][sc] != '\0'
							  && PSCR( r, page).text[sr][sc] != ' '
						   )
						{
							non_empty = 1;
							break;
						}
					;
					if( non_empty ) break;
				}

				sr -=  SVLINES /* - 1 */;	/* Dump last non-empty line */
				DBG_MSG( 3, ( stderr, "Saving %d lines\n", sr));

				if( sr > 0)
					rxvt_scroll_text(r, page,
							PSCR(r, page).tscroll, PSCR(r, page).bscroll,
							sr, 0);
			}
			else rxvt_selection_check(r, page, 3);

			row = 0;
			num = r->TermWin.nrow;
			break;
		default:
			return;
	}

	r->h->refresh_type |= REFRESH_BOUNDS;
	if (SEL(r).op &&
		SEL(r).vt == page &&
		PVTS(r, page)->current_screen == SEL(r).screen &&
		((SEL(r).beg.row >= row && SEL(r).beg.row <= row + num) ||
		 (SEL(r).end.row >= row && SEL(r).end.row <= row + num)))
		CLEAR_SELECTION(r);
	if (row >= r->TermWin.nrow)	/* Out Of Bounds */
		return;
	MIN_IT(num, (r->TermWin.nrow - row));
	if (PVTS(r, page)->rstyle & (RS_RVid | RS_Uline))
		ren = (rend_t) ~RS_None;
	else if (GET_BASEBG(PVTS(r, page)->rstyle) == Color_bg)
	{
		ren = DEFAULT_RSTYLE;
		CLEAR_ROWS(row, num);
	}
	else
	{
		ren = (PVTS(r, page)->rstyle & (RS_fgMask | RS_bgMask));
		gcvalue.foreground = r->PixColors[GET_BGCOLOR(PVTS(r, page)->rstyle)];
		XChangeGC(r->Xdisplay, r->TermWin.gc, GCForeground, &gcvalue);
		ERASE_ROWS(row, num);
		gcvalue.foreground = r->PixColors[Color_fg];
		XChangeGC(r->Xdisplay, r->TermWin.gc, GCForeground, &gcvalue);
	}
	for (; num--; row++)
	{
		rxvt_blank_screen_mem(r, page, PSCR(r, page).text,
				PSCR(r, page).rend,
				(unsigned int)(row + row_offset), PVTS(r, page)->rstyle);
		PSCR(r, page).tlen[row + row_offset] = 0;
		rxvt_blank_line(PVTS(r, page)->drawn_text[row],
				PVTS(r, page)->drawn_rend[row],
				(unsigned int) r->TermWin.ncol, ren);
	}
}

/* ------------------------------------------------------------------------- */
/*
 * Fill the screen with `E's
 * XTERM_SEQ: Screen Alignment Test: ESC # 8
 */
/* EXTPROTO */
void
rxvt_scr_E(rxvt_t* r, int page)
{
	int			 i, j, k;
	rend_t		 *r1, fs;

	r->h->want_refresh = 1;
	r->h->num_scr_allow = 0;
	ZERO_SCROLLBACK(r, page);
	RESET_CHSTAT(r, page);
	rxvt_selection_check(r, page, 3);

	fs = PVTS(r, page)->rstyle;
	for (k = SVLINES, i = r->TermWin.nrow; i--; k++)
	{
		/* make the `E's selectable */
		PSCR(r, page).tlen[k] = r->TermWin.ncol;
		MEMSET(PSCR(r, page).text[k], 'E', r->TermWin.ncol);
		for (r1 = PSCR(r, page).rend[k], j = r->TermWin.ncol; j--; )
			*r1++ = fs;
	}
}

/* ------------------------------------------------------------------------- */
/*
 * Insert/Delete <count> lines
 */
/* EXTPROTO */
void
rxvt_scr_insdel_lines(rxvt_t* r, int page, int count, int insdel)
{
	int			 end;

	ZERO_SCROLLBACK(r, page);
	RESET_CHSTAT(r, page);
	rxvt_selection_check(r, page, 1);

	if (CURROW > PSCR(r, page).bscroll)
		return;

	end = PSCR(r, page).bscroll - CURROW + 1;
	if (count > end)
	{
		if (insdel == DELETE)
			return;
		else if (insdel == INSERT)
			count = end;
	}
	PSCR(r, page).flags &= ~Screen_WrapNext;

	rxvt_scroll_text(r, page, CURROW,
		PSCR(r, page).bscroll, insdel * count, 0);
}

/* ------------------------------------------------------------------------- */
/*
 * Insert/Delete <count> characters from the current position
 */
/* EXTPROTO */
void
rxvt_scr_insdel_chars(rxvt_t* r, int page, int count, int insdel)
{
	int			col, row;
	rend_t		tr;
	text_t*		stp;
	rend_t*		srp;
	RINT16T*	slp;

	r->h->want_refresh = 1;
	ZERO_SCROLLBACK(r, page);
#if 0
	RESET_CHSTAT(r, page);
#endif
	if (count <= 0)
		return;

	rxvt_selection_check(r, page, 1);
	MIN_IT(count, (r->TermWin.ncol - CURCOL));

	row = CURROW + SVLINES;
	PSCR(r, page).flags &= ~Screen_WrapNext;

	stp = PSCR(r, page).text[row];
	srp = PSCR(r, page).rend[row];
	slp = &(PSCR(r, page).tlen[row]);
	switch (insdel)
	{
		case INSERT:
			for (col = r->TermWin.ncol - 1; (col - count) >= CURCOL; col--)
			{
				stp[col] = stp[col - count];
				srp[col] = srp[col - count];
			}
			if (*slp != -1)
			{
				*slp += count;
				MIN_IT(*slp, r->TermWin.ncol);
			}
			if (
				  SEL(r).op && SEL(r).vt == page
				  && PVTS(r, page)->current_screen == SEL(r).screen
				  && RC_ROW_ATAFTER(SEL(r).beg, PSCR(r, page).cur)
			   )
			{
				if (
					  SEL(r).end.row != CURROW
					  || (SEL(r).end.col + count >= r->TermWin.ncol)
				   )
					CLEAR_SELECTION(r);
				else		/* shift selection */
				{
					SEL(r).beg.col += count;
					SEL(r).mark.col += count;	/* XXX: yes? */
					SEL(r).end.col += count;
				}
			}
			rxvt_blank_line(&(stp[CURCOL]),
				&(srp[CURCOL]),
				(unsigned int)count, PVTS(r, page)->rstyle);
			break;

		case ERASE:
			CURCOL += count;	/* don't worry if > r->TermWin.ncol */
			rxvt_selection_check(r, page, 1);
			CURCOL -= count;
			rxvt_blank_line(&(stp[CURCOL]),
				&(srp[CURCOL]),
				(unsigned int)count, PVTS(r, page)->rstyle);
			break;

		case DELETE:
			tr = srp[r->TermWin.ncol - 1]
				 & (RS_fgMask | RS_bgMask | RS_baseattrMask);
			for (col = CURCOL; (col + count) < r->TermWin.ncol; col++)
			{
				stp[col] = stp[col + count];
				srp[col] = srp[col + count];
			}
			rxvt_blank_line(&(stp[r->TermWin.ncol - count]),
				&(srp[r->TermWin.ncol - count]),
				(unsigned int)count, tr);
			if (*slp == -1)	/* break line continuation */
				*slp = r->TermWin.ncol;
			*slp -= count;
			MAX_IT(*slp, 0);
			if (
				  SEL(r).op && SEL(r).vt == page
				  && PVTS(r, page)->current_screen == SEL(r).screen
				  && RC_ROW_ATAFTER(SEL(r).beg, PSCR(r, page).cur)
			   )
			{
				if (
					  SEL(r).end.row != CURROW
					  || (CURCOL >= SEL(r).beg.col - count)
					  || SEL(r).end.col >= r->TermWin.ncol
				   )
					CLEAR_SELECTION(r);
				else
				{
					/* shift selection */
					SEL(r).beg.col -= count;
					SEL(r).mark.col -= count;	/* XXX: yes? */
					SEL(r).end.col -= count;
				}
			}
			break;
	}
#if 0
	if (IS_MULTI2(srp[0]))
	{
		srp[0] &= ~RS_multiMask;
		stp[0] = ' ';
	}
	if (IS_MULTI1(srp[r->TermWin.ncol - 1]))
	{
		srp[r->TermWin.ncol - 1] &= ~RS_multiMask;
		stp[r->TermWin.ncol - 1] = ' ';
	}
#endif
}

/* ------------------------------------------------------------------------- */
/*
 * Set the scrolling region
 * XTERM_SEQ: Set region <top> - <bot> inclusive: ESC [ <top> ; <bot> r
 */
/* EXTPROTO */
void
rxvt_scr_scroll_region(rxvt_t* r, int page, int top, int bot)
{
	DBG_MSG( 2, ( stderr, "rxvt_scr_scroll_region( %d, %d, %d)\n",
				page, top, bot));

	MAX_IT(top, 0);
	MIN_IT(bot, (int)r->TermWin.nrow - 1);
	if (top > bot)
		return;
	PSCR(r, page).tscroll = top;
	PSCR(r, page).bscroll = bot;
	rxvt_scr_gotorc(r, page, 0, 0, 0);
}

/* ------------------------------------------------------------------------- */
/*
 * Make the cursor visible/invisible
 * XTERM_SEQ: Make cursor visible  : ESC [ ? 25 h
 * XTERM_SEQ: Make cursor invisible: ESC [ ? 25 l
 */
/* EXTPROTO */
void
rxvt_scr_cursor_visible(rxvt_t* r, int page, int mode)
{
	r->h->want_refresh = 1;
	if (mode)
		PSCR(r, page).flags |= Screen_VisibleCursor;
	else
		PSCR(r, page).flags &= ~Screen_VisibleCursor;
}

/* ------------------------------------------------------------------------- */
/*
 * Set/unset automatic wrapping
 * XTERM_SEQ: Set Wraparound  : ESC [ ? 7 h
 * XTERM_SEQ: Unset Wraparound: ESC [ ? 7 l
 */
/* EXTPROTO */
void
rxvt_scr_autowrap(rxvt_t* r, int page, int mode)
{
	if (mode)
		PSCR(r, page).flags |= Screen_Autowrap;
	else
		PSCR(r, page).flags &= ~(Screen_Autowrap | Screen_WrapNext);
}

/* ------------------------------------------------------------------------- */
/*
 * Set/unset margin origin mode
 * Absolute mode: line numbers are counted relative to top margin of screen
 *	  and the cursor can be moved outside the scrolling region.