screen.c

Mrxvt是一个小巧

	}

	for (p = prev_total_rows; p < total_rows - i; p++)
		rxvt_blank_screen_mem (r, page, PSCR(r, page).text,
			PSCR(r, page).rend, p, DEFAULT_RSTYLE);

	for (p = prev_nrow; p < nrow; p++)
	{
#if NSCREENS
		PVTS(r, page)->swap.tlen[p] = 0;
		PVTS(r, page)->swap.text[p] = NULL;
		PVTS(r, page)->swap.rend[p] = NULL;
		rxvt_blank_screen_mem (r, page, PVTS(r, page)->swap.text,
			PVTS(r, page)->swap.rend, p, DEFAULT_RSTYLE);
#endif

		PVTS(r, page)->drawn_text[p] = NULL;
		PVTS(r, page)->drawn_rend[p] = NULL;
		rxvt_blank_screen_mem (r, page, PVTS(r, page)->drawn_text,
			PVTS(r, page)->drawn_rend, p, DEFAULT_RSTYLE);
	}

	if (i > 0)
	{
		rxvt_scroll_text(r, page, 0, (int)nrow - 1, -i, 1);
		PSCR(r, page).cur.row += i;
		PSCR(r, page).s_cur.row += i;
		PVTS(r, page)->nscrolled -= i;
	}

	assert(PSCR(r, page).cur.row < r->TermWin.nrow);
	MIN_IT(PSCR(r, page).cur.row, nrow - 1);
#if NSCREENS
	assert(PVTS(r, page)->swap.cur.row < r->TermWin.nrow);
	MIN_IT(PVTS(r, page)->swap.cur.row, nrow - 1);
#endif
}



/* INTPROTO */
void
rxvt_scr_adjust_col (rxvt_t* r, int page, unsigned int total_rows)
{
	unsigned int	nrow, ncol, prev_ncol;
	unsigned int	p;


	nrow = r->TermWin.nrow;
	ncol = r->TermWin.ncol;
	prev_ncol = PVTS(r, page)->prev_ncol;

	DBG_MSG(2, (stderr, "rxvt_scr_adjust_col %d (ncol=%d, prev_ncol = %d, nrow=%d, total_row=%d)\n", page, ncol, prev_ncol, nrow, total_rows));

	for (p = 0; p < total_rows; p++)
	{
		if (PSCR(r, page).text[p])
		{
			PSCR(r, page).text[p] = rxvt_realloc (
				PSCR(r, page).text[p], ncol * sizeof(text_t));
			PSCR(r, page).rend[p] = rxvt_realloc (
				PSCR(r, page).rend[p], ncol * sizeof(rend_t));
			MIN_IT(PSCR(r, page).tlen[p], (RINT16T)ncol);
			if (ncol > prev_ncol)
				rxvt_blank_line (
					&(PSCR(r, page).text[p][prev_ncol]),
					&(PSCR(r, page).rend[p][prev_ncol]),
					ncol - prev_ncol, DEFAULT_RSTYLE);
		}
	}

	for (p = 0; p < nrow; p++)
	{
		PVTS(r, page)->drawn_text[p] = rxvt_realloc (
			PVTS(r, page)->drawn_text[p], ncol * sizeof(text_t));
		PVTS(r, page)->drawn_rend[p] = rxvt_realloc (
			PVTS(r, page)->drawn_rend[p], ncol * sizeof(rend_t));
#if NSCREENS
		if (PVTS(r, page)->swap.text[p])
		{
			PVTS(r, page)->swap.text[p] = rxvt_realloc (
				PVTS(r, page)->swap.text[p], ncol * sizeof(text_t));
			PVTS(r, page)->swap.rend[p] = rxvt_realloc (
				PVTS(r, page)->swap.rend[p], ncol * sizeof(rend_t));
			MIN_IT(PVTS(r, page)->swap.tlen[p], (RINT16T)ncol);
			if (ncol > prev_ncol)
				rxvt_blank_line(
					&(PVTS(r, page)->swap.text[p][prev_ncol]),
					&(PVTS(r, page)->swap.rend[p][prev_ncol]),
					ncol - prev_ncol, DEFAULT_RSTYLE);
		}
#endif
		if (ncol > prev_ncol)
			rxvt_blank_line(
				&(PVTS(r, page)->drawn_text[p][prev_ncol]),
				&(PVTS(r, page)->drawn_rend[p][prev_ncol]),
				ncol - prev_ncol, DEFAULT_RSTYLE);
	}
	MIN_IT(PSCR(r, page).cur.col, (RINT16T)ncol - 1);
#if NSCREENS
	MIN_IT(PVTS(r, page)->swap.cur.col, (RINT16T)ncol - 1);
#endif


	/*
	** Only reset tabstop if expanding columns, save realloc in
	** shrinking columns
	*/
	if (r->tabstop && ncol > prev_ncol)
	{
		DBG_MSG(1, (stderr, "expand r->tabstop to %d\n", ncol));
		r->tabstop = rxvt_realloc(r->tabstop, ncol * sizeof(char));
		for (p = prev_ncol; p < ncol; p++)
			r->tabstop[p] = (p % TABSTOP_SIZE == 0) ? 1 : 0;
	}
}



/* EXTPROTO */
void
rxvt_scr_reset(rxvt_t* r, int page)
{
	unsigned int	ncol, nrow, prev_ncol, prev_nrow,
					total_rows, prev_total_rows;


	DBG_MSG(1,(stderr, "rxvt_scr_reset %d ()\n", page));

	PVTS(r, page)->view_start = 0;
	RESET_CHSTAT(r, page);
	PVTS(r, page)->num_scr = 0;	/* number of lines scrolled */

	prev_ncol = PVTS(r, page)->prev_ncol;
	prev_nrow = PVTS(r, page)->prev_nrow;
	if (r->TermWin.ncol == 0)
		r->TermWin.ncol = 80;
	if (r->TermWin.nrow == 0)
		r->TermWin.nrow = 24;
	ncol = r->TermWin.ncol;
	nrow = r->TermWin.nrow;
	if (PVTS(r, page)->init_screen &&
		ncol == prev_ncol && nrow == prev_nrow)
		return;

	DBG_MSG(1,(stderr, "rxvt_scr_reset %d () refresh screen\n", page));
	r->h->want_refresh = 1;

	total_rows = nrow + SVLINES;
	prev_total_rows = prev_nrow + SVLINES;

	PSCR(r, page).tscroll = 0;
	PSCR(r, page).bscroll = nrow - 1;

	if (PVTS(r, page)->init_screen == 0)
	{
		/* Initialize the screen structures */
		rxvt_scr_alloc (r, page);
	}
	else
	{
		/* B1: resize rows */
		if (nrow < prev_nrow)
		{
			rxvt_scr_delete_row (r, page);
		}
		else if (nrow > prev_nrow)
		{
			rxvt_scr_add_row (r, page, total_rows, prev_total_rows);
		}
		/* B2: resize columns */
		if (ncol != prev_ncol)
		{
			rxvt_scr_adjust_col (r, page, total_rows);
		}
	}

	PVTS(r, page)->prev_nrow = nrow;
	PVTS(r, page)->prev_ncol = ncol;

	rxvt_tt_winsize(PVTS(r, page)->cmd_fd, r->TermWin.ncol, r->TermWin.nrow, PVTS(r, page)->cmd_pid);
}




/* ------------------------------------------------------------------------- */
/*
 * Free everything.  That way malloc debugging can find leakage.
 */
/* EXTPROTO */
void
rxvt_scr_release(rxvt_t* r, int page)
{
	unsigned int	total_rows;
	int				i;


	DBG_MSG(1, (stderr, "rxvt_scr_release %d ()\n", page));
	total_rows = r->TermWin.nrow + SVLINES;

	for (i = 0; i < total_rows; i++)
	{
		if (PSCR(r, page).text[i])
		{
			/* then so is PSCR(r, page).rend[i] */
			free(PSCR(r, page).text[i]);
			PSCR(r, page).text[i] = NULL;
			assert(PSCR(r, page).rend[i]);
			free(PSCR(r, page).rend[i]);
			PSCR(r, page).rend[i] = NULL;
		}
	}

	for (i = 0; i < r->TermWin.nrow; i++)
	{
		/* if (PVTS(r, page)->drawn_text[i]) */
			free(PVTS(r, page)->drawn_text[i]);
		PVTS(r, page)->drawn_text[i] = NULL;
		/* if (PVTS(r, page)->drawn_rend[i]) */
			free(PVTS(r, page)->drawn_rend[i]);
		PVTS(r, page)->drawn_rend[i] = NULL;
#if NSCREENS
		/* if (PVTS(r, page)->swap.text[i]) */
			free(PVTS(r, page)->swap.text[i]);
		PVTS(r, page)->swap.text[i] = NULL;
		/* if (PVTS(r, page)->swap.rend[i])) */
			free(PVTS(r, page)->swap.rend[i]);
		PVTS(r, page)->swap.rend[i] = NULL;
#endif
	}

	free(PSCR(r, page).text); PSCR(r, page).text = NULL;
	free(PSCR(r, page).tlen); PSCR(r, page).tlen = NULL;
	free(PSCR(r, page).rend); PSCR(r, page).rend = NULL;
	free(PVTS(r, page)->drawn_text);  PVTS(r, page)->drawn_text = NULL;
	free(PVTS(r, page)->drawn_rend);  PVTS(r, page)->drawn_rend = NULL;
#if NSCREENS
	free(PVTS(r, page)->swap.text);   PVTS(r, page)->swap.text = NULL;
	free(PVTS(r, page)->swap.tlen);   PVTS(r, page)->swap.tlen = NULL;
	free(PVTS(r, page)->swap.rend);   PVTS(r, page)->swap.rend = NULL;
#endif
	free(PVTS(r, page)->buf_text);	PVTS(r, page)->buf_text = NULL;
	free(PVTS(r, page)->buf_rend);	PVTS(r, page)->buf_rend = NULL;

	/* next rxvt_scr_reset will be the first time initialization */
	PVTS(r, page)->init_screen = 0;

	/* clear selection if necessary */
	if (page == r->selection.vt)
	{
		rxvt_process_selectionclear (r, page);
	}
}

/* ------------------------------------------------------------------------- */
/*
 * Hard reset
 */
/* EXTPROTO */
void
rxvt_scr_poweron(rxvt_t* r, int page)
{
	DBG_MSG(1,(stderr, "rxvt_scr_poweron %d ()\n", page));

	rxvt_scr_release(r, page);
	PVTS(r, page)->prev_nrow = PVTS(r, page)->prev_ncol = 0;
	rxvt_scr_reset(r, page);

	rxvt_scr_clear(r, page);
	rxvt_scr_refresh(r, page, SLOW_REFRESH);
}


/* ------------------------------------------------------------------------- *
 *						 PROCESS SCREEN COMMANDS						   *
 * ------------------------------------------------------------------------- */
/*
 * Save and Restore cursor
 * XTERM_SEQ: Save cursor   : ESC 7
 * XTERM_SEQ: Restore cursor: ESC 8
 */
/* EXTPROTO */
void
rxvt_scr_cursor(rxvt_t* r, int page, int mode)
{
	screen_t	   *s;

	DBG_MSG(2,(stderr, "rxvt_scr_cursor %d (%c)\n", page, mode));

#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
	if (PVTS(r, page)->current_screen == SECONDARY)
		s = &(PVTS(r, page)->swap);
	else
#endif
	s = &(PSCR(r, page));
	switch (mode)
	{
		case SAVE:
			s->s_cur.row = s->cur.row;
			s->s_cur.col = s->cur.col;
			s->s_rstyle = PVTS(r, page)->rstyle;
			s->s_charset = s->charset;
			s->s_charset_char = PVTS(r, page)->charsets[s->charset];
			break;
		case RESTORE:
			r->h->want_refresh = 1;
			s->cur.row = s->s_cur.row;
			s->cur.col = s->s_cur.col;
			s->flags &= ~Screen_WrapNext;
			PVTS(r, page)->rstyle = s->s_rstyle;
			s->charset = s->s_charset;
			PVTS(r, page)->charsets[s->charset] = s->s_charset_char;
			rxvt_set_font_style(r, page);
			break;
	}
/* boundary check in case screen size changed between SAVE and RESTORE */
	MIN_IT(s->cur.row, r->TermWin.nrow - 1);
	MIN_IT(s->cur.col, r->TermWin.ncol - 1);
	assert(s->cur.row >= 0);
	assert(s->cur.col >= 0);
	MAX_IT(s->cur.row, 0);
	MAX_IT(s->cur.col, 0);
}

/* ------------------------------------------------------------------------- */
/*
 * Swap between primary and secondary screens
 * XTERM_SEQ: Primary screen  : ESC [ ? 4 7 h
 * XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l
 */
/* EXTPROTO */
int
rxvt_scr_change_screen(rxvt_t* r, int page, int scrn)
{
#if NSCREENS
	unsigned int		i, offset;
#endif

	r->h->want_refresh = 1;

	DBG_MSG(1, (stderr, "rxvt_scr_change_screen %d (%d)\n", page, scrn));

	VSTART = 0;
	RESET_CHSTAT(r, page);

	if (PVTS(r, page)->current_screen == scrn)
		return PVTS(r, page)->current_screen;

	rxvt_selection_check(r, page, 2);	/* check for boundary cross */

	SWAP_IT(PVTS(r, page)->current_screen, scrn, int);

#if NSCREENS
	PVTS(r, page)->num_scr = 0;
	offset = SVLINES;

	for (i = PVTS(r, page)->prev_nrow; i--;)
	{
		SWAP_IT(PSCR(r, page).text[i + offset],
			PVTS(r, page)->swap.text[i], text_t *);
		SWAP_IT(PSCR(r, page).tlen[i + offset],
			PVTS(r, page)->swap.tlen[i], RINT16T);
		SWAP_IT(PSCR(r, page).rend[i + offset],
			PVTS(r, page)->swap.rend[i], rend_t *);
	}
	SWAP_IT(CURROW, PVTS(r, page)->swap.cur.row, RINT16T);
	SWAP_IT(CURCOL, PVTS(r, page)->swap.cur.col, RINT16T);
	assert (CURROW >= 0);
	assert (CURROW < PVTS(r, page)->prev_nrow);
	assert (CURCOL >= 0);
	assert (CURCOL < PVTS(r, page)->prev_ncol);
	MAX_IT(CURROW, 0);
	MIN_IT(CURROW, (RINT32T)PVTS(r, page)->prev_nrow - 1);
	MAX_IT(CURCOL, 0);
	MIN_IT(CURCOL, (RINT32T)PVTS(r, page)->prev_ncol - 1);

	SWAP_IT(PSCR(r, page).charset, PVTS(r, page)->swap.charset,
		RINT16T);
	SWAP_IT(PSCR(r, page).flags, PVTS(r, page)->swap.flags, int);
	PSCR(r, page).flags |= Screen_VisibleCursor;
	PVTS(r, page)->swap.flags |= Screen_VisibleCursor;

#else
# ifdef SCROLL_ON_NO_SECONDARY
	if (PVTS(r, page)->current_screen == PRIMARY)
		rxvt_scroll_text(r, page, 0, (PVTS(r, page)->prev_nrow - 1),
			PVTS(r, page)->prev_nrow, 0);
# endif
#endif

	/* Need to update tabbar buttons */
	if (r->Options2 & Opt2_protectSecondary)
		rxvt_tabbar_draw_buttons (r);

	return scrn;
}

/* ------------------------------------------------------------------------- */
/*
 * Change the colour for following text
 */
/* EXTPROTO */
void
rxvt_scr_color(rxvt_t* r, int page, unsigned int color, int fgbg)
{
	color &= RS_fgMask;
	if (Color_fg == fgbg)
		PVTS(r, page)->rstyle=SET_FGCOLOR(PVTS(r, page)->rstyle, color);
	else 
		PVTS(r, page)->rstyle=SET_BGCOLOR(PVTS(r, page)->rstyle, color);
}


/* ------------------------------------------------------------------------- */
/*
 * Change the rendition style for following text
 */
/* EXTPROTO */
void
rxvt_scr_rendition(rxvt_t* r, int page, int set, int style)
{
	if (set)
		PVTS(r, page)->rstyle |= style;
	else if (style == ~RS_None)
		PVTS(r, page)->rstyle = DEFAULT_RSTYLE | (PVTS(r, page)->rstyle & RS_fontMask);
	else
		PVTS(r, page)->rstyle &= ~style;
}

/* ------------------------------------------------------------------------- */
/*
 * Scroll text between <row1> and <row2> inclusive, by <count> lines
 * count positive ==> scroll up
 * count negative ==> scroll down
 * spec == 0 for normal routines
 */
/* EXTPROTO */
int
rxvt_scroll_text(rxvt_t* r, int page, int row1, int row2, int count, int spec)
{
	int				i, j;
	unsigned int	nscrolled;

	if (count == 0 || (row1 > row2))
		return 0;

	r->h->want_refresh = 1;
	DBG_MSG(2, (stderr, "rxvt_scroll_text %d (%d,%d,%d,%d): %s\n",
				page, row1, row2, count, spec,
				(PVTS(r, page)->current_screen == PRIMARY) ?
						"Primary" : "Secondary"));

	if (
		  (count > 0)
		  && (row1 == 0)
		  && (PVTS(r, page)->current_screen == PRIMARY)
	   )
	{
		nscrolled = (unsigned int) PVTS(r, page)->nscrolled
											+ (unsigned int) count;

		if (nscrolled > (unsigned int)SVLINES)
			PVTS(r, page)->nscrolled = SVLINES;
		else
			PVTS(r, page)->nscrolled = (RUINT16T)nscrolled;
		if ((r->Options & Opt_scrollWithBuffer) &&
			VSTART != 0 &&
			VSTART != SVLINES)
			rxvt_scr_page(r, page, UP, count);
	}
	else if (!spec)
		row1 += SVLINES;
	row2 += SVLINES;

	if (
		  SEL(r).op
		  && SEL(r).vt == page
		  && PVTS(r, page)->current_screen == SEL(r).screen
	   )
	{
		i = SEL(r).beg.row + SVLINES;
		j = SEL(r).end.row + SVLINES;
		if (
			  (i < row1 && j > row1)
			  || (i < row2 && j > row2)
			  || (i - count < row1 && i >= row1)
			  || (i - count > row2 && i <= row2)