screen.c

multi-tabed terminal based on rxvt

	    {
		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 0
    if (x != CURCOL)
	rxvt_scr_gotorc(r, page, 0, x, R_RELATIVE);
#else
    /*
     * 2006-09-02 gi1242: Don't call rxvt_scr_gotorc() because that might change
     * CURROW (if it was negative). If we're adding lines to the screen
     * structure, then CURROW is allowed to be negative.
     */
    CURCOL = x;
#endif
}

/* ------------------------------------------------------------------------- */
/*
 * 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)
{
    PVTS(r, page)->want_refresh = 1;
    ZERO_SCROLLBACK(r, page);
    RESET_CHSTAT(r, page);

    rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "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, (int32_t)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;
	}

	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, (int32_t)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;

    PVTS(r, page)->want_refresh = 1;
    dirn = ((direction == UP) ? 1 : -1);
    rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "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, (int32_t)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;

    PVTS(r, page)->want_refresh = 1;
    rxvt_dbgmsg ((DBG_DEBUG, DBG_SCREEN, "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], (int16_t)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;
    int32_t	row, row_offset;
    rend_t	ren;
    XGCValues	gcvalue;

    PVTS(r, page)->want_refresh = 1;
    rxvt_dbgmsg ((DBG_DEBUG, DBG_SCREEN, "rxvt_scr_erase_screen %d (%d) at screen row: %d\n", page, mode, CURROW));
    ZERO_SCROLLBACK(r, page);
    RESET_CHSTAT(r, page);
    row_offset = (int32_t)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 */
		rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "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;

    PVTS(r, page)->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;
    int16_t*	slp;

    PVTS(r, page)->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];