home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / CURSES.LZH / UPDATE.C < prev    next >
C/C++ Source or Header  |  1980-01-01  |  9KB  |  248 lines
  1. /****************************************************************/
  2. /* Doupdate() routine of the PCcurses package            */
  3. /*                                */
  4. /****************************************************************/
  5. /* This version of curses is based on ncurses, a curses version    */
  6. /* originally written by Pavel Curtis at Cornell University.    */
  7. /* I have made substantial changes to make it run on IBM PC's,    */
  8. /* and therefore consider myself free to make it public domain.    */
  9. /*        Bjorn Larsson (...mcvax!enea!infovax!bl)    */
  10. /****************************************************************/
  11. /* 1.0:    Release:                    870515    */
  12. /* 1.2:    Changed call sequence to cursesio.[c,asm], Thanks    */
  13. /*    to S. Creps. Rcsid[] string for maintenance:    881002    */
  14. /* 1.3:    MSC -W3, Turbo'C' -w -w-pro checkes:        881005    */
  15. /****************************************************************/
  16.  
  17. #include <curses.h>
  18. #include <curspriv.h>
  19.  
  20. static void clrupdate();        /* fwd declaration */
  21. static bool transformline();
  22. static void clearscreen();
  23. static void gotoxy();
  24. static void Putchar();
  25.  
  26. char _curses_update_rcsid[] = "@(#)update.c v1.3 - 881005";
  27.  
  28. static WINDOW    *twin;            /* used by many routines */
  29.  
  30. static    char     atrtab[64] =        /* attribute encoding table. */
  31.   {                    /* feel free to edit if your */
  32.   (char)7,    /* NORMAL (0) */    /* display board supports all */
  33.   (char)0x87,    /* BLINK */        /* possible combinations */
  34.   (char)0,    /* BLANK */
  35.   (char)0,    /* BLINK & BLANK */
  36.   (char)0xf,    /* BOLD */
  37.   (char)0x8f,    /* BOLD & BLINK */
  38.   (char)0,    /* BOLD & BLANK */
  39.   (char)0,    /* BOLD & BLINK & BLANK */
  40.   (char)0x70,    /* REVERSE (8) */
  41.   (char)0xf0,    /* REVERSE & BLINK */
  42.   (char)0,    /* REVERSE & BLANK */
  43.   (char)0,    /* REVERSE & BLINK & BLANK */
  44.   (char)0x78,    /* REVERSE & BOLD */
  45.   (char)0xf8,    /* REVERSE & BOLD & BLINK */
  46.   (char)0,    /* REVERSE & BOLD & BLANK */
  47.   (char)0,    /* REVERSE & BOLD & BLINK & BLANK */
  48.   (char)0xf,    /* STANDOUT (10) */
  49.   (char)0x8f,    /* STANDOUT & BLINK */
  50.   (char)0,    /* STANDOUT & BLANK */
  51.   (char)0,    /* STANDOUT & BLINK & BLANK */
  52.   (char)0xf,    /* STANDOUT & BOLD */
  53.   (char)0x8f,    /* STANDOUT & BOLD & BLINK */
  54.   (char)0,    /* STANDOUT & BOLD & BLANK */
  55.   (char)0,    /* STANDOUT & BOLD & BLINK & BLANK */
  56.   (char)0x70,    /* STANDOUT & REVERSE (18) */
  57.   (char)0xf0,    /* STANDOUT & REVERSE & BLINK */
  58.   (char)0,    /* STANDOUT & REVERSE & BLANK */
  59.   (char)0,    /* STANDOUT & REVERSE & BLINK & BLANK */
  60.   (char)0x70,    /* STANDOUT & REVERSE & BOLD */
  61.   (char)0xf0,    /* STANDOUT & REVERSE & BOLD & BLINK */
  62.   (char)0,    /* STANDOUT & REVERSE & BOLD & BLANK */
  63.   (char)0,    /* STANDOUT & REVERSE & BOLD & BLINK & BLANK */
  64.   (char)1,    /* UNDERLINE (20) */
  65.   (char)0x81,    /* UNDERLINE & BLINK */
  66.   (char)0,    /* UNDERLINE & BLANK */
  67.   (char)0,    /* UNDERLINE & BLINK & BLANK */
  68.   (char)9,    /* UNDERLINE & BOLD */
  69.   (char)0x89,    /* UNDERLINE & BOLD & BLINK */
  70.   (char)0,    /* UNDERLINE & BOLD & BLANK */
  71.   (char)0,    /* UNDERLINE & BOLD & BLINK & BLANK */
  72.   (char)0x70,    /* UNDERLINE & REVERSE (28) */
  73.   (char)0xf0,    /* UNDERLINE & REVERSE & BLINK */
  74.   (char)0,    /* UNDERLINE & REVERSE & BLANK */
  75.   (char)0,    /* UNDERLINE & REVERSE & BLINK & BLANK */
  76.   (char)0x79,    /* UNDERLINE & REVERSE & BOLD */
  77.   (char)0xf9,    /* UNDERLINE & REVERSE & BOLD & BLINK */
  78.   (char)0,    /* UNDERLINE & REVERSE & BOLD & BLANK */
  79.   (char)0,    /* UNDERLINE & REVERSE & BOLD & BLINK & BLANK */
  80.   (char)9,    /* UNDERLINE & STANDOUT (30) */
  81.   (char)0x89,    /* UNDERLINE & STANDOUT & BLINK */
  82.   (char)0,    /* UNDERLINE & STANDOUT & BLANK */
  83.   (char)0,    /* UNDERLINE & STANDOUT & BLINK & BLANK */
  84.   (char)9,    /* UNDERLINE & STANDOUT & BOLD */
  85.   (char)0x89,    /* UNDERLINE & STANDOUT & BOLD & BLINK */
  86.   (char)0,    /* UNDERLINE & STANDOUT & BOLD & BLANK */
  87.   (char)0,    /* UNDERLINE & STANDOUT & BOLD & BLINK & BLANK */
  88.   (char)0x70,    /* UNDERLINE & STANDOUT & REVERSE (38) */
  89.   (char)0xf0,    /* UNDERLINE & STANDOUT & REVERSE & BLINK */
  90.   (char)0,    /* UNDERLINE & STANDOUT & REVERSE & BLANK */
  91.   (char)0,    /* UNDERLINE & STANDOUT & REVERSE & BLINK & BLANK */
  92.   (char)0x70,    /* UNDERLINE & STANDOUT & REVERSE & BOLD */
  93.   (char)0xf0,    /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLINK */
  94.   (char)0,    /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLANK */
  95.   (char)0,    /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLINK & BLANK */
  96.   };
  97.  
  98. /****************************************************************/
  99. /* Doupdate() updates the physical screen to look like _curs-   */
  100. /* var.tmpwin if curscr is not 'Clear-marked'. Otherwise it    */
  101. /* updates the screen to look like curscr.            */
  102. /****************************************************************/
  103.  
  104. void doupdate()
  105.   {
  106.   register int         i;
  107.  
  108.   twin   = _cursvar.tmpwin;
  109.   if (curscr->_clear)
  110.     clrupdate(curscr);
  111.   else
  112.     {
  113.     if (twin->_clear)
  114.       clrupdate(twin);
  115.     else
  116.       {
  117.       for (i=0; i < LINES; i++)
  118.     if (twin->_minchng[i] != _NO_CHANGE)
  119.       if (transformline(i))
  120.         break;
  121.       } /* else */
  122.     } /* else */
  123.   curscr->_curx = twin->_curx;
  124.   curscr->_cury = twin->_cury;
  125.   gotoxy(curscr->_cury, curscr->_curx);
  126.   } /* doupdate */
  127.  
  128. /****************************************************************/
  129. /* Clrupdate(scr) updates the screen by clearing it and then    */
  130. /* redraw it in its entirety. If _cursvar.refrbrk is TRUE, and    */
  131. /* there is pending input characters, the update will be pre-    */
  132. /* maturely terminated.                        */
  133. /****************************************************************/
  134.  
  135. static void clrupdate(scr)
  136.   WINDOW    *scr;
  137.   {
  138.   register int        *src;
  139.   register int        *dst;
  140.   register int         i;
  141.   register int         j;
  142.   static   WINDOW    *w;
  143.  
  144.   w = curscr;
  145.   
  146.   if (scr != w)                /* copy scr to curscr */
  147.     {
  148.     for (i=0; i < LINES; i++)
  149.       {
  150.       src = scr->_line[i];
  151.       dst = w->_line[i];
  152.       for (j=0; j < COLS; j++)
  153.     *dst++ = *src++;
  154.       } /* for */
  155.     } /* if */
  156.   clearscreen();            /* clear physical screen */
  157.   scr->_clear = FALSE;
  158.   for (i=0; i < LINES; i++)        /* update physical screen */
  159.     {
  160.     src = w->_line[i];
  161.     for(j=0; j < COLS; j++)
  162.       {
  163.       if (*src != (' ' | ATR_NRM))
  164.     {
  165.     gotoxy(i,j);
  166.     Putchar(*src);
  167.     } /* if */
  168.       src++;
  169.       } /* for */
  170.     if(_cursvar.refrbrk && _cursespendch())
  171.       return;
  172.     } /* for */
  173.   } /* clrupdate */
  174.  
  175. /****************************************************************/
  176. /* Transformline() updates the given physical line to look    */
  177. /* like the corresponding line in _cursvar.tmpwin. Transform-    */
  178. /* returns 1 if premature refresh end is allowed, and there is    */
  179. /* an input character pending.                    */
  180. /****************************************************************/
  181.  
  182. static bool transformline(lineno)
  183.   register int    lineno;
  184.   {
  185.   register int        *dstp;
  186.   register int        *srcp;
  187.   static   int         x;
  188.   static   int         endx;
  189.  
  190.   x    = twin->_minchng[lineno];
  191.   endx = twin->_maxchng[lineno];
  192.   dstp = curscr->_line[lineno] + x;
  193.   srcp = twin->_line[lineno] + x;
  194.   
  195.   for( ; x <= endx; x++)
  196.     {
  197.     if(*dstp != *srcp)
  198.       {
  199.       gotoxy(lineno,x);
  200.       Putchar(*srcp);
  201.       } /* if */
  202.     *dstp++ = *srcp++;
  203.     } /* for */
  204.   twin->_minchng[lineno] = _NO_CHANGE;
  205.   twin->_maxchng[lineno] = _NO_CHANGE;
  206.   return ((bool)(_cursvar.refrbrk && _cursespendch()));
  207.   } /* transformline */
  208.  
  209. /****************************************************************/
  210. /* Clearscreen() clears the physical screen and puts the cursor    */
  211. /* in the home position.                    */
  212. /****************************************************************/
  213.  
  214. static void clearscreen()
  215.   {
  216.   _cursesscroll(0,0,LINES-1,COLS-1,0,atrtab[0]);
  217.   gotoxy(0,0);
  218.   } /* clearscreen */
  219.  
  220. /****************************************************************/
  221. /* Gotoxy() moves the physical cursor to the desired address on    */
  222. /* the screen. We don't optimize here - on a PC, it takes more    */
  223. /* time to optimize than to do things directly.            */
  224. /****************************************************************/
  225.  
  226. static void gotoxy(row,col)
  227.   int row, col;
  228.   {
  229.   if((_cursvar.cursrow == row) && (_cursvar.curscol == col))
  230.     return;
  231.   _cursescursor(row,col);
  232.   _cursvar.cursrow = row;
  233.   _cursvar.curscol = col;
  234.   } /* gotoxy */
  235.  
  236. /****************************************************************/
  237. /* Putchar() writes a character, with attributes, to the physi-    */
  238. /* cal screen, but avoids writing to the lower right screen    */
  239. /* position.                            */
  240. /****************************************************************/
  241.  
  242. static void Putchar(ch)
  243.   int ch;
  244.   {
  245.   if ((_cursvar.cursrow < LINES) || (_cursvar.curscol < COLS))
  246.     _cursescattr(ch,atrtab[(ch >> 8) & 0x3f],1);
  247.   } /* Putchar */
  248.