screen.c

STEVIE文本文件编缉器的C 语言源程序

		need_redraw = TRUE;
		return;
	}

	endline = np + (Cline_size * Columns);

	row = Cline_row;
	col = 0;

	outcstr(T_CI);		/* disable cursor */

	for ( ; np < endline ; np++,rp++ ) {
		/* If desired screen (contents of Nextscreen) does not */
		/* match what's really there, put it there. */
		if ( *np != *rp ) {
			/* if we are positioned at the right place, */
			/* we don't have to use windgoto(). */
			if (gocol != col || gorow != row) {
				/*
				 * If we're just off by one, don't send
				 * an entire esc. seq. (this happens a lot!)
				 */
				if (gorow == row && gocol+1 == col) {
					outchar(*(np-1));
					gocol++;
				} else
					windgoto(gorow=row,gocol=col);
			}
			outchar(*rp = *np);
			gocol++;
		}
		if ( ++col >= Columns ) {
			col = 0;
			row++;
		}
	}
	outcstr(T_CV);		/* enable cursor again */
}

static char *
mkline(n)
register int	n;
{
	static	char	lbuf[9];
	register int	i = 2;

	strcpy(lbuf, "        ");

	lbuf[i++] = (n % 10) + '0';
	n /= 10;
	if (n != 0) {
		lbuf[i++] = (n % 10) + '0';
		n /= 10;
	}
	if (n != 0) {
		lbuf[i++] = (n % 10) + '0';
		n /= 10;
	}
	if (n != 0) {
		lbuf[i++] = (n % 10) + '0';
		n /= 10;
	}
	if (n != 0) {
		lbuf[i++] = (n % 10) + '0';
		n /= 10;
	}
	return lbuf;
}

/*
 * updateline() - update the line the cursor is on
 *
 * Updateline() is called after changes that only affect the line that
 * the cursor is on. This improves performance tremendously for normal
 * insert mode operation. The only thing we have to watch for is when
 * the cursor line grows or shrinks around a row boundary. This means
 * we have to repaint other parts of the screen appropriately. If
 * lfiletonext() returns FALSE, the size of the cursor line (in rows)
 * has changed and we have to call updatescreen() to do a complete job.
 */
void
updateline()
{
	if (!lfiletonext())
		updatescreen();	/* bag it, do the whole screen */
	else
		lnexttoscreen();
}

void
updatescreen()
{
	extern	bool_t	interactive;

	if (interactive) {
		filetonext();
		nexttoscreen();
	}
}

/*
 * prt_line() - print the given line
 */
void
prt_line(s)
char	*s;
{
	register int	si = 0;
	register int	c;
	register int	col = 0;

	char	extra[16];
	int	nextra = 0;
	int	n;

	for (;;) {

		if ( nextra > 0 )
			c = extra[--nextra];
		else {
			c = s[si++];
			if ( c == TAB && !P(P_LS) ) {
				strcpy(extra, "        ");
				/* tab amount depends on current column */
				nextra = (P(P_TS) - 1) - col%P(P_TS);
				c = ' ';
			} else if ( c == NUL && P(P_LS) ) {
				extra[0] = NUL;
				nextra = 1;
				c = '$';
			} else if ( c != NUL && (n=chars[c].ch_size) > 1 ) {
				char	*p;

				nextra = 0;
				p = chars[c].ch_str;
				/* copy 'ch-str'ing into 'extra' in reverse */
				while ( n > 1 )
					extra[nextra++] = p[--n];
				c = p[0];
			}
		}

		if ( c == NUL )
			break;

		outchar(c);
		col++;
	}
}

void
screenclear()
{
	register char	*rp, *np;
	register char	*end;

	outcstr(T_ED);		/* clear the display */

	rp  = Realscreen;
	end = Realscreen + Rows * Columns;
	np  = Nextscreen;

	/* blank out the stored screens */
	while (rp != end)
		*rp++ = *np++ = ' ';
}

void
cursupdate()
{
	register LPTR	*p;
	register int	icnt, c, nlines;
	register int	i;
	int	didinc;

	if (bufempty()) {		/* special case - file is empty */
		*Topchar  = *Filemem;
		*Curschar = *Filemem;
	} else if ( LINEOF(Curschar) < LINEOF(Topchar) ) {
		nlines = cntllines(Curschar,Topchar);
		/* if the cursor is above the top of */
		/* the screen, put it at the top of the screen.. */
		*Topchar = *Curschar;
		Topchar->index = 0;
		/* ... and, if we weren't very close to begin with, */
		/* we scroll so that the line is close to the middle. */
		if ( nlines > Rows/3 ) {
			for (i=0, p = Topchar; i < Rows/3 ;i++, *Topchar = *p)
				if ((p = prevline(p)) == NULL)
					break;
		} else
			s_ins(0, nlines-1);
		updatescreen();
	}
	else if (LINEOF(Curschar) >= LINEOF(Botchar)) {
		nlines = cntllines(Botchar,Curschar);
		/* If the cursor is off the bottom of the screen, */
		/* put it at the top of the screen.. */
		/* ... and back up */
		if ( nlines > Rows/3 ) {
			p = Curschar;
			for (i=0; i < (2*Rows)/3 ;i++)
				if ((p = prevline(p)) == NULL)
					break;
			*Topchar = *p;
		} else {
			scrollup(nlines);
		}
		updatescreen();
	}

	Cursrow = Curscol = Cursvcol = 0;
	for ( p=Topchar; p->linep != Curschar->linep ;p = nextline(p) )
		Cursrow += plines(p);

	Cline_row = Cursrow;
	Cline_size = plines(p);

	if (P(P_NU))
		Curscol = 8;

	for (i=0; i <= Curschar->index ;i++) {
		c = Curschar->linep->s[i];
		/* A tab gets expanded, depending on the current column */
		if ( c == TAB && !P(P_LS) )
			icnt = P(P_TS) - (Cursvcol % P(P_TS));
		else
			icnt = chars[(unsigned)(c & 0xff)].ch_size;
		Curscol += icnt;
		Cursvcol += icnt;
		if ( Curscol >= Columns ) {
			Curscol -= Columns;
			Cursrow++;
			didinc = TRUE;
		}
		else
			didinc = FALSE;
	}
	if (didinc)
		Cursrow--;

	if (c == TAB && State == NORMAL && !P(P_LS)) {
		Curscol--;
		Cursvcol--;
	} else {
		Curscol -= icnt;
		Cursvcol -= icnt;
	}
	if (Curscol < 0)
		Curscol += Columns;

	if (set_want_col) {
		Curswant = Cursvcol;
		set_want_col = FALSE;
	}
}

/*
 * The rest of the routines in this file perform screen manipulations.
 * The given operation is performed physically on the screen. The
 * corresponding change is also made to the internal screen image.
 * In this way, the editor anticipates the effect of editing changes
 * on the appearance of the screen. That way, when we call screenupdate
 * a complete redraw isn't usually necessary. Another advantage is that
 * we can keep adding code to anticipate screen changes, and in the
 * meantime, everything still works.
 */

/*
 * s_ins(row, nlines) - insert 'nlines' lines at 'row'
 */
void
s_ins(row, nlines)
int	row;
int	nlines;
{
	register char	*s, *d;		/* src & dest for block copy */
	register char	*e;		/* end point for copy */
	register int	i;

	if (T_IL[0] == NUL)		/* can't do it */
		return;

	/*
	 * It "looks" better if we do all the inserts at once
	 */
	outcstr(T_SC);			/* save position */
	windgoto(row, 0);

	for (i=0; i < nlines ;i++)
		outcstr(T_IL);

	windgoto(Rows-1, 0);	/* delete any garbage that may have */
	outcstr(T_EL);		/* been shifted to the bottom line */
	outcstr(T_RC);		/* restore the cursor position */

	/*
	 * Now do a block move to update the internal screen image
	 */
	d = Realscreen + (Columns * (Rows - 1)) - 1;
	s = d - (Columns * nlines);
	e = Realscreen + (Columns * row);

	while (s >= e)
		*d-- = *s--;

	/*
	 * Clear the inserted lines
	 */
	s = Realscreen + (row * Columns);
	e = s + (nlines * Columns);
	while (s < e)
		*s++ = ' ';
}

/*
 * s_del(row, nlines) - delete 'nlines' lines at 'row'
 */
void
s_del(row, nlines)
int	row;
int	nlines;
{
	register char	*s, *d, *e;
	register int	i;

	if (T_DL[0] == NUL)			/* can't do it */
		return;

	/* delete the lines */
	outcstr(T_SC);				/* save position */
	windgoto(row, 0);

	for (i=0; i < nlines ;i++) {
		outcstr(T_DL);			/* delete a line */
		if (i == 0) {
			windgoto(Rows-2, 0);	/* delete any garbage that */
			outcstr(T_EL);		/* was on the status line */
			windgoto(row, 0);
		}
	}
	outcstr(T_RC);				/* restore position */

	/*
	 * do a block move to update the internal image
	 */
	d = Realscreen + (row * Columns);
	s = d + (nlines * Columns);
	e = Realscreen + ((Rows - 1) * Columns);

	while (s < e)
		*d++ = *s++;

	while (d < e)		/* clear the lines at the bottom */
		*d++ = ' ';
}