Category : C Source Code
Archive   : CURSESNT.ZIP
Filename : UPDATE.C

/****************************************************************/
/* Doupdate() routine of the PCcurses package */
/* */
/****************************************************************/
/* This version of curses is based on ncurses, a curses version */
/* originally written by Pavel Curtis at Cornell University. */
/* I have made substantial changes to make it run on IBM PC's, */
/* and therefore consider myself free to make it public domain. */
/* Bjorn Larsson ([email protected]) */
/****************************************************************/
/* 1.4: Use of short wherever possible. Portability */
/* improvements. Superflous parameter in */
/* cursescattr() removed. Clearscreen() changed */
/* so curses is guaranteed to know where the psy- */
/* sical cursor is at all times: 900114 */
/* 1.3: MSC -W3, Turbo'C' -w -w-pro checkes: 881005 */
/* 1.2: Changed call sequence to cursesio.[c,asm], Thanks */
/* to S. Creps. Rcsid[] string for maintenance: 881002 */
/* 1.0: Release: 870515 */
/****************************************************************/

#include
#include

static void clrupdate(); /* fwd declaration */
static bool transformline();
static void clearscreen();
static void gotoxy();
static void Putchar();

char _curses_update_rcsid[] = "@(#)update.c v.1.4 - 900114";

static WINDOW *twin; /* used by many routines */

static char atrtab[64] = /* attribute encoding table. */
{ /* feel free to edit if your */
#ifdef WIN32
(char)7,
#else
(char)7, /* NORMAL (0) */ /* display board supports all */
#endif
(char)0x87, /* BLINK */ /* possible combinations */
(char)0, /* BLANK */
(char)0, /* BLINK & BLANK */
(char)0xf, /* BOLD */
(char)0x8f, /* BOLD & BLINK */
(char)0, /* BOLD & BLANK */
(char)0, /* BOLD & BLINK & BLANK */
(char)0x70, /* REVERSE (8) */
(char)0xf0, /* REVERSE & BLINK */
(char)0, /* REVERSE & BLANK */
(char)0, /* REVERSE & BLINK & BLANK */
(char)0x78, /* REVERSE & BOLD */
(char)0xf8, /* REVERSE & BOLD & BLINK */
(char)0, /* REVERSE & BOLD & BLANK */
(char)0, /* REVERSE & BOLD & BLINK & BLANK */
#ifdef WIN32
(char)0x80 * 3,
#else
(char)0xf, /* STANDOUT (10) */
#endif
(char)0x8f, /* STANDOUT & BLINK */
(char)0, /* STANDOUT & BLANK */
(char)0, /* STANDOUT & BLINK & BLANK */
(char)0xf, /* STANDOUT & BOLD */
(char)0x8f, /* STANDOUT & BOLD & BLINK */
(char)0, /* STANDOUT & BOLD & BLANK */
(char)0, /* STANDOUT & BOLD & BLINK & BLANK */
(char)0x70, /* STANDOUT & REVERSE (18) */
(char)0xf0, /* STANDOUT & REVERSE & BLINK */
(char)0, /* STANDOUT & REVERSE & BLANK */
(char)0, /* STANDOUT & REVERSE & BLINK & BLANK */
(char)0x70, /* STANDOUT & REVERSE & BOLD */
(char)0xf0, /* STANDOUT & REVERSE & BOLD & BLINK */
(char)0, /* STANDOUT & REVERSE & BOLD & BLANK */
(char)0, /* STANDOUT & REVERSE & BOLD & BLINK & BLANK */
(char)1, /* UNDERLINE (20) */
(char)0x81, /* UNDERLINE & BLINK */
(char)0, /* UNDERLINE & BLANK */
(char)0, /* UNDERLINE & BLINK & BLANK */
(char)9, /* UNDERLINE & BOLD */
(char)0x89, /* UNDERLINE & BOLD & BLINK */
(char)0, /* UNDERLINE & BOLD & BLANK */
(char)0, /* UNDERLINE & BOLD & BLINK & BLANK */
(char)0x70, /* UNDERLINE & REVERSE (28) */
(char)0xf0, /* UNDERLINE & REVERSE & BLINK */
(char)0, /* UNDERLINE & REVERSE & BLANK */
(char)0, /* UNDERLINE & REVERSE & BLINK & BLANK */
(char)0x79, /* UNDERLINE & REVERSE & BOLD */
(char)0xf9, /* UNDERLINE & REVERSE & BOLD & BLINK */
(char)0, /* UNDERLINE & REVERSE & BOLD & BLANK */
(char)0, /* UNDERLINE & REVERSE & BOLD & BLINK & BLANK */
(char)9, /* UNDERLINE & STANDOUT (30) */
(char)0x89, /* UNDERLINE & STANDOUT & BLINK */
(char)0, /* UNDERLINE & STANDOUT & BLANK */
(char)0, /* UNDERLINE & STANDOUT & BLINK & BLANK */
(char)9, /* UNDERLINE & STANDOUT & BOLD */
(char)0x89, /* UNDERLINE & STANDOUT & BOLD & BLINK */
(char)0, /* UNDERLINE & STANDOUT & BOLD & BLANK */
(char)0, /* UNDERLINE & STANDOUT & BOLD & BLINK & BLANK */
(char)0x70, /* UNDERLINE & STANDOUT & REVERSE (38) */
(char)0xf0, /* UNDERLINE & STANDOUT & REVERSE & BLINK */
(char)0, /* UNDERLINE & STANDOUT & REVERSE & BLANK */
(char)0, /* UNDERLINE & STANDOUT & REVERSE & BLINK & BLANK */
(char)0x70, /* UNDERLINE & STANDOUT & REVERSE & BOLD */
(char)0xf0, /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLINK */
(char)0, /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLANK */
(char)0, /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLINK & BLANK */
};

/****************************************************************/
/* Doupdate() updates the physical screen to look like _curs- */
/* var.tmpwin if curscr is not 'Clear-marked'. Otherwise it */
/* updates the screen to look like curscr. */
/****************************************************************/

void doupdate()
{
short i;

twin = _cursvar.tmpwin;
if (curscr->_clear)
clrupdate(curscr);
else
{
if (twin->_clear)

clrupdate(twin);
else
{
for (i=0; i < LINES; i++)
if (twin->_minchng[i] != _NO_CHANGE)
if (transformline(i))
break;
} /* else */
} /* else */
curscr->_curx = twin->_curx;
curscr->_cury = twin->_cury;
gotoxy(curscr->_cury, curscr->_curx);
} /* doupdate */

/****************************************************************/
/* Clrupdate(scr) updates the screen by clearing it and then */
/* redraw it in it's entirety. If _cursvar.refrbrk is TRUE, and */
/* there is pending input characters, the update will be pre- */
/* maturely terminated. */
/****************************************************************/

static void clrupdate(scr)
WINDOW *scr;
{
short *src;
short *dst;
short i;
short j;
static WINDOW *w;

w = curscr;

if (scr != w) /* copy scr to curscr */
{
for (i=0; i < LINES; i++)
{
src = scr->_line[i];
dst = w->_line[i];
for (j=0; j < COLS; j++)
*dst++ = *src++;
} /* for */
} /* if */
clearscreen(); /* clear physical screen */
scr->_clear = FALSE;
for (i=0; i < LINES; i++) /* update physical screen */
{
src = w->_line[i];
for(j=0; j < COLS; j++)
{
if (*src != (' ' | ATR_NRM))
{
gotoxy(i,j);
Putchar(*src);
} /* if */
src++;
} /* for */
if(_cursvar.refrbrk && _cursespendch())
return;
} /* for */
} /* clrupdate */

/****************************************************************/
/* Transformline() updates the given physical line to look */
/* like the corresponding line in _cursvar.tmpwin. Transform- */
/* line returns 1 if premature refresh end is allowed, and */
/* there is an input character pending. */
/****************************************************************/

static bool transformline(lineno)
register int lineno;
{
short *dstp;
short *srcp;
short x;
short endx;

x = twin->_minchng[lineno];
endx = twin->_maxchng[lineno];
dstp = curscr->_line[lineno] + x;
srcp = twin->_line[lineno] + x;

for( ; x <= endx; x++)
{
if(*dstp != *srcp)
{
gotoxy(lineno,x);
Putchar(*srcp);
} /* if */
*dstp++ = *srcp++;
} /* for */
twin->_minchng[lineno] = _NO_CHANGE;
twin->_maxchng[lineno] = _NO_CHANGE;
return ((bool)(_cursvar.refrbrk && _cursespendch()));
} /* transformline */

/****************************************************************/
/* Clearscreen() clears the physical screen and puts the cursor */
/* in the home position. */
/****************************************************************/

static void clearscreen()
{
_cursesscroll(0,0,LINES-1,COLS-1,0,atrtab[0]);
_cursescursor(0,0);
_cursvar.cursrow = 0;
_cursvar.curscol = 0;
} /* clearscreen */

/****************************************************************/
/* Gotoxy() moves the physical cursor to the desired address on */
/* the screen. We don't optimize here - on a PC, it takes more */
/* time to optimize than to do things directly. */
/****************************************************************/

static void gotoxy(row,col)
int row, col;
{
if((_cursvar.cursrow == row) && (_cursvar.curscol == col))
return;
_cursescursor(row,col);
_cursvar.cursrow = row;
_cursvar.curscol = col;
} /* gotoxy */

/****************************************************************/
/* Putchar() writes a character, with attributes, to the physi- */
/* cal screen, but avoids writing to the lower right screen */
/* position. */
/****************************************************************/

static void Putchar(ch)
int ch;
{
if ((_cursvar.cursrow < LINES) || (_cursvar.curscol < COLS))
_cursescattr(ch,atrtab[(ch >> 8) & 0x3f]);
} /* Putchar */