screen.c

multi-tabed terminal based on rxvt

	  && (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 = (uint16_t)nscrolled;
    }
    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)
	      || (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 = count - 1, j = row1; i >= 0; 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 */
	size = sizeof(*PSCR(r, page).tlen);
	MEMMOVE(&(PSCR(r, page).tlen[row1]), &(PSCR(r, page).tlen[row1+count]),
			(row2 - row1 - count + 1) * size);
	size = sizeof(*PSCR(r, page).text);
	MEMMOVE(&(PSCR(r, page).text[row1]), &(PSCR(r, page).text[row1+count]),
			(row2 - row1 - count + 1) * size);
	size = sizeof(*PSCR(r, page).rend);
	MEMMOVE(&(PSCR(r, page).rend[row1]), &(PSCR(r, page).rend[row1+count]),
			(row2 - row1 - count + 1) * size);

	j = row2 - count + 1;
	ret = i = count;
    }
    else /* if (j < 0) */
    {
	/* B: scroll down */

	/* B1: Copy lines that will get clobbered by the rotation */
	size = sizeof(*PSCR(r, page).text);
	MEMCPY(PVTS(r, page)->buf_text, &PSCR(r, page).text[row2 - count + 1], count * size);
	size = sizeof(*PSCR(r, page).rend);
	MEMCPY(PVTS(r, page)->buf_rend, &PSCR(r, page).rend[row2 - count + 1], count * size);

	/* B2: Rotate lines */
	size = sizeof(*PSCR(r, page).tlen);
	MEMMOVE(&(PSCR(r, page).tlen[row1 + count]), &(PSCR(r, page).tlen[row1]),
			(row2 - row1 - count + 1) * size);
	size = sizeof(*PSCR(r, page).text);
	MEMMOVE(&(PSCR(r, page).text[row1 + count]), &(PSCR(r, page).text[row1]),
			(row2 - row1 - count + 1) * size);
	size = sizeof(*PSCR(r, page).rend);
	MEMMOVE(&(PSCR(r, page).rend[row1 + count]), &(PSCR(r, page).rend[row1]),
			(row2 - row1 - count + 1) * size);

	j = row1, i = count;
	ret = -count;
    }

    /* C: Resurrect lines */
    size = sizeof(*PSCR(r, page).tlen);
    MEMSET(&PSCR(r, page).tlen[j], 0, count * size);
    size = sizeof(*PSCR(r, page).text);
    MEMCPY(&PSCR(r, page).text[j], PVTS(r, page)->buf_text, count * size);
    size = sizeof(*PSCR(r, page).rend);
    MEMCPY(&PSCR(r, page).rend[j], PVTS(r, page)->buf_rend, count * size);

    for (; i--; j++)
    {
	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 ret;
}

/* ------------------------------------------------------------------------- */
/*
 * Adjust the PVTS(r, page)->view_start so that the if nlines of text are added,
 * the view will not change.
 */
void static inline
adjust_view_start( rxvt_t *r, int page, int nlines)
{
    if(
	 ISSET_OPTION( r, Opt_scrollTtyOutputInhibit) &&
	 VSTART != 0 && VSTART + nlines <= PVTS( r, page)->nscrolled
      )
	VSTART += nlines;
}

/*
 * 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;

    rxvt_dbgmsg ((DBG_DEBUG, DBG_SCREEN, "rxvt_scr_add_lines( r, %d, %.*s, %d, %d)\n", page, min(len, 36), str, nlines, len ));

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

    PVTS(r, page)->want_refresh = 1;
    last_col = r->TermWin.ncol;

    ZERO_SCROLLBACK(r, page);
    if (nlines > 0)
    {
	/*
	 * 2006-09-02 gi1242 TODO: The code below is *horrible*. When we call
	 * rxvt_scroll_text(), we might end up with a negative CURROW. We try
	 * and be clever using this information, but rxvt_scr_gotorc() will
	 * reset this information!
	 */
	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);
	    adjust_view_start(r, page, nlines );

	    CURROW -= nlines;

	    rxvt_dbgmsg ((DBG_DEBUG, DBG_SCREEN, "\e[32mScrolling %d lines. CURROW=%d\e[0m\n", nlines, CURROW ));
	}
    }

    assert(CURCOL < last_col);
    assert(CURROW < r->TermWin.nrow);

#if 0 /*{{{ Possibly incorrection assertion */
    /*
     * XXX 2006-09-12 gi1242: I think this assertion is wrong! Note that a few
     * lines later we set CURROW to be the max of CURROW and -PVTS()->nscrolled
     */
    assert(CURROW >= -(int32_t)PVTS(r, page)->nscrolled);
#endif /*}}}*/

    MIN_IT(CURCOL, last_col - 1);
    MIN_IT(CURROW, (int32_t)r->TermWin.nrow - 1);
    MAX_IT(CURROW, -(int32_t)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_dbgmsg ((DBG_DEBUG, DBG_SCREEN, "%s:%d ",
				__FILE__, __LINE__ ));
		    rxvt_scroll_text(r, page, PSCR(r, page).tscroll,
			    PSCR(r, page).bscroll, 1, 0);
		    adjust_view_start( r, page, 1 );
		}
		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);
		adjust_view_start( r, page, 1 );
	    }
	    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);
    PVTS(r, page)->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;

    rxvt_dbgmsg ((DBG_DEBUG, DBG_SCREEN, "rxvt_scr_tab %d (%d)\n", page, count));
    PVTS(r, page)->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])