screen.c

multi-tabed terminal based on rxvt

    /* add rows */
    rxvt_scr_reset_realloc(r, page);	/* realloc _first_ */

    i = min(PVTS(r, page)->nscrolled, nrow - prev_nrow);
    for (p = prev_total_rows; p < total_rows; p++)
    {
	PSCR(r, page).tlen[p] = 0;
	PSCR(r, page).text[p] = NULL;
	PSCR(r, page).rend[p] = NULL;
    }

    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;

    rxvt_dbgmsg ((DBG_DEBUG, DBG_SCREEN, "%s( r, page=%d, total_rows=%u ):" "ncol=%d, prev_ncol=%d, nrow=%d\n", __func__, page, total_rows, ncol, prev_ncol, nrow ));


    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], (int16_t)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], (int16_t)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, (int16_t)ncol - 1);
#if NSCREENS
    MIN_IT(PVTS(r, page)->swap.cur.col, (int16_t)ncol - 1);
#endif


    /*
    ** Only reset tabstop if expanding columns, save realloc in
    ** shrinking columns
    */
    if (r->tabstop && ncol > prev_ncol)
    {
	rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "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;


    rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "rxvt_scr_reset %d ()\n", page));

    VSTART = 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;

    rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "rxvt_scr_reset %d () refresh screen\n", page));
    PVTS(r, page)->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;


    rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "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] */
	    rxvt_free(PSCR(r, page).text[i]);
	    PSCR(r, page).text[i] = NULL;
	    assert(PSCR(r, page).rend[i]);
	    rxvt_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]) */
	    rxvt_free(PVTS(r, page)->drawn_text[i]);
	PVTS(r, page)->drawn_text[i] = NULL;
	/* if (PVTS(r, page)->drawn_rend[i]) */
	    rxvt_free(PVTS(r, page)->drawn_rend[i]);
	PVTS(r, page)->drawn_rend[i] = NULL;
#if NSCREENS
	/* if (PVTS(r, page)->swap.text[i]) */
	    rxvt_free(PVTS(r, page)->swap.text[i]);
	PVTS(r, page)->swap.text[i] = NULL;
	/* if (PVTS(r, page)->swap.rend[i])) */
	    rxvt_free(PVTS(r, page)->swap.rend[i]);
	PVTS(r, page)->swap.rend[i] = NULL;
#endif
    }

    rxvt_free(PSCR(r, page).text); PSCR(r, page).text = NULL;
    rxvt_free(PSCR(r, page).tlen); PSCR(r, page).tlen = NULL;
    rxvt_free(PSCR(r, page).rend); PSCR(r, page).rend = NULL;
    rxvt_free(PVTS(r, page)->drawn_text);  PVTS(r, page)->drawn_text = NULL;
    rxvt_free(PVTS(r, page)->drawn_rend);  PVTS(r, page)->drawn_rend = NULL;
#if NSCREENS
    rxvt_free(PVTS(r, page)->swap.text);   PVTS(r, page)->swap.text = NULL;
    rxvt_free(PVTS(r, page)->swap.tlen);   PVTS(r, page)->swap.tlen = NULL;
    rxvt_free(PVTS(r, page)->swap.rend);   PVTS(r, page)->swap.rend = NULL;
#endif
    rxvt_free(PVTS(r, page)->buf_text);	PVTS(r, page)->buf_text = NULL;
    rxvt_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)
{
    rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "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;

    rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "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:
	    PVTS(r, page)->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

    PVTS(r, page)->want_refresh = 1;

    rxvt_dbgmsg ((DBG_VERBOSE, DBG_SCREEN, "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], int16_t);
	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, int16_t);
    SWAP_IT(CURCOL, PVTS(r, page)->swap.cur.col, int16_t);
    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, (int32_t)PVTS(r, page)->prev_nrow - 1);
    MAX_IT(CURCOL, 0);
    MIN_IT(CURCOL, (int32_t)PVTS(r, page)->prev_ncol - 1);

    SWAP_IT(PSCR(r, page).charset, PVTS(r, page)->swap.charset,
	int16_t);
    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 (ISSET_OPTION(r, 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, ret;
    unsigned int    nscrolled;
    size_t 	    size;

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

    PVTS(r, page)->want_refresh = 1;
    rxvt_dbgmsg ((DBG_DEBUG, DBG_SCREEN,
		"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)