home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 13 / 13.iso / s / s001 / 1.ddi / PFC / SRC / _VDSPC.C next >
Encoding:
C/C++ Source or Header  |  1990-04-04  |  7.7 KB  |  268 lines
  1. /* (c) 1985, Phoenix Computer Products Corp. and Novum Organum, Inc. */
  2. #include "pdefs.h"
  3. #include "psys.h"
  4.  
  5. #define    VS_ATRCHR    '^'
  6. #define    TABSIZ        8
  7.  
  8. static    int    _row, _col;    /* screen position */
  9. static    int    _nchars;    /* max # of chars to use from string */
  10. static    int    _smode, _cmode;    /* _dsp mode constants */
  11. static    int    _oldstate;    /* place to save the attribute state */
  12. static    int    _attr = 0x07;    /* IBM-PC attribute */
  13. static    int    _srchchr;    /* CRET if VA_TTY is on, EOS otherwise */
  14.                 /*    to control scanning for TTY chars  */
  15.  
  16.         int _vdsp();
  17. static  PFI _dsp = _vdsp;  /* video display function */
  18.  
  19.  
  20. /* These two little routines just save and return the IBM-PC attribute */
  21.  
  22. _vdspsattr( ibmattr )
  23. { 
  24.     _attr = ibmattr; 
  25. }
  26.  
  27. int    _vdspattr()
  28. { 
  29.     return( _attr ); 
  30. }
  31.  
  32. /* This internal routine handles the attribute control sequences within    *
  33. *  strings.  Other pieces of the string are passed through to _vdspstty    *
  34. *  later in this file.                            */
  35.  
  36.  
  37.  
  38. _vdsps( int row, int col, int nchars, int astate, char *str, void **pargs )
  39. {
  40.     int    chr, offset;
  41.     char    *strnfmtp();
  42.     char    _fmtbuf[256];
  43.  
  44.     _setargs( row, col, nchars, astate );    /* set static variables */
  45.  
  46.     if    ((!(vstattr() & VA_PCT)) && (stridxc('%',str) != NOTFND))
  47.     {
  48. //          str = strnfmtp(_fmtbuf,sizeof(_fmtbuf),str,(int *)pargs);
  49.           vsprintf(_fmtbuf, str, pargs);
  50.           str = _fmtbuf;
  51.     }
  52.     if    (!(vstattr() & VA_CARET)) /* if the attribute stuff is on */
  53.         {            /* look for attribute control stuff */
  54.         while    ( (offset = stridxc(VS_ATRCHR,str)) != NOTFND )
  55.             {
  56.             _vdspstty(offset,str);    /* do display up to stuff */
  57.             str += offset + 1;
  58.  
  59.             chr = *str++;
  60.             switch    ( TOUPPER(chr) )/* check out the control char*/
  61.                 {
  62.             case EOS: goto end;    /* EndOfString -- all done */
  63.             case 'B': vsttogattr(VA_BLINK); break;
  64.             case 'H': vsttogattr(VA_HIINTY); break;
  65.             case 'R': vsttogattr(VA_REVVID); break;
  66.             case 'U': vsttogattr(VA_ULN); break;
  67.             default : str--; break;
  68.             case VS_ATRCHR:
  69.                   _vdspctty(1,VS_ATRCHR); /* display '^' */
  70.                   break;
  71.                 }
  72.  
  73.             }
  74.         }
  75.     _vdspstty( _nchars, str );    /* do the part of the string after  */
  76.                     /* the last control sequence or the */
  77.                     /* whole string if the control      */
  78.                     /* sequence jazz is turned off      */
  79. end:    
  80.     if    ((nchars < VD_ALLOFIT) && (_nchars > 0))
  81.         {
  82.         chr = BLNK;
  83.         (*_dsp) ( _cmode, _row, _col, _nchars, &chr, _attr );
  84.         }
  85.  
  86.     if    ( _oldstate != VD_CURSTAT ) /* if the state was changed */
  87.         vstsetcur( _oldstate );        /* change it back */
  88. }
  89.  
  90. /* This internal routine handles the pieces of a string which have already  *
  91. *  been scanned for attribute control sequences.  It handles TTY characters *
  92. *  by calling _vdspctty, which appears later in this file, and the normal   *
  93. *  parts of the string with _dsp, which is a separate assembler routine.    */
  94.  
  95. static    _vdspstty( nchars, str )
  96.     int    nchars;
  97.     char    *str;
  98. {
  99.     int    offset;
  100.  
  101.     while    ( _nchars > 0  )
  102.         {
  103.         offset = stridxle( _srchchr, str );    /* look for TTY char */
  104.  
  105.         if    ( offset > 0 )        /* do STR up to the TTY char */
  106.             {
  107.             /* limit the number of characters to write */
  108.             if    ( offset > nchars )
  109.                 offset = nchars;
  110.             if    ( offset > _nchars )
  111.                 offset = _nchars;
  112.  
  113.         /* the normal part of a string gets displayed right here */
  114.             (*_dsp) (_smode, _row, _col, offset, str, _attr);
  115.             str += offset;
  116.             nchars -= offset;
  117.             _nchars -= offset;
  118.             _col += offset;
  119.             }
  120.         /* EOS comes up as a TTY char since it's less than CRET */
  121.         /* if we've reached the EOS, just quit */
  122.         if    ( *str == EOS || nchars <= 0 ) 
  123.             break;
  124.  
  125.         _vdspctty( 1, *str++ );        /* do the TTY char */
  126.         nchars--;
  127.         }
  128. }
  129.  
  130. /* A little internal routine to handle the attribute changing functions. *
  131. *  Packages the call for handling by _dsp, an assembly language routine. */
  132.  
  133. _vdspa ( row, col, nchars, astate )
  134.     int    row, col, nchars, astate;
  135. {
  136.     _setargs( row, col, nchars, astate );    /* set up statics */
  137.  
  138.     (*_dsp) ( VD_0C1A, _row, _col, _nchars, NULLPTR, _attr ); /* do it */
  139.  
  140.     if    ( _oldstate != VD_CURSTAT )    /* if state was changed */
  141.         vstsetcur( _oldstate );        /* restore it */
  142. }
  143.  
  144.  
  145.  
  146. /* This routine packages up the character display functions for either    *
  147. *  _vdspctty, which is later in this file, or _dsp, a separate assembly *
  148. *  language function elsewhere.                      */
  149.  
  150. _vdspc ( row, col, nchars, astate, chr )
  151.     int    row, col, nchars, chr, astate;
  152. {
  153.     _setargs( row, col, nchars, astate );    /* set up static variables */
  154.  
  155.     if    ( chr <= _srchchr )        /* if a possible TTY-char */
  156.         {
  157.         if    (chr == TAB)
  158.             _nchars = TABSIZ;
  159.         _vdspctty( _nchars, chr );    /* display TTY char */
  160.         }
  161.     else
  162.                         /* normal character display */
  163.         (*_dsp) ( _cmode, _row, _col, _nchars, &chr, _attr );
  164.  
  165.     if    ( _oldstate != VD_CURSTAT )    /* if attribute state altered*/
  166.         vstsetcur( _oldstate );        /* change it back */
  167. }
  168.  
  169.  
  170. /* Internal routine to handle TTY characters for the string and character *
  171. *  display functions.  BKSP, TAB, LNFEED, and CRET characters cause cursor*
  172. *  control, BELL calls sybeep().                      */
  173.  
  174. static    _vdspctty( nchars, chr )
  175.     int    nchars, chr;
  176. {
  177.     int    nrows;
  178.  
  179.     if    ( _nchars <= 0 ) return;
  180.  
  181.     switch    ( chr )
  182.         {
  183.     case BELL:            /* ASCII 7 or CTRL-G */
  184.         while    ( nchars-- )
  185.             sybeep();        /* make noise */
  186.         break;
  187.     case BKSP:            /* ASCII 8 or CTRL-H */
  188.         _col -= nchars;            /* back up cursor */
  189.         if    ( _col < 0 )        /* but not too far */
  190.             _col = 0;
  191.         vidsetloc( _row, _col );        /* move cursor */
  192.         break;
  193.     case TAB:            /* ASCII 9 or CTRL-I  */
  194.         nchars = TABSIZ - (_col % TABSIZ);/* Tabs are every 8 characters */
  195.         if    (nchars > _nchars)
  196.             nchars = _nchars;
  197.         chr = BLNK;
  198.         (*_dsp) ( _cmode, _row, _col, nchars, &chr, _attr );
  199.         _col += nchars;
  200.         _nchars -= nchars;
  201.         break;
  202.     case LNFEED:            /* ASCII 10 or CTRL-J */
  203.         _row += nchars;            /* move down NCHARS rows */
  204.         nrows = vidnrows() - 1;
  205.         if    ( _row > nrows )    /* if off screen */
  206.             {
  207.             vidscroll( _row-nrows );/* scroll screen */
  208.             _row = nrows;        /* and leave on bottom line */
  209.             }
  210.         vidsetloc( _row, _col );        /* move cursor */
  211.         break;
  212.     case CRET:            /* ASCII 13 or CTRL-M */
  213.         vidsetloc( _row, _col = 0 );    /* move to beginning of row */
  214.         break;
  215.     default:            /* graphics chars 0-6,11, and 12 */
  216.         (*_dsp) ( _cmode, _row, _col, nchars, &chr, _attr );
  217.         _col += nchars;
  218.         _nchars -= nchars;
  219.         break;
  220.         }
  221. }
  222.  
  223.  
  224. /* This internal routine sets up the static variables declared at the very *
  225. *  beginning of this file for _vdspc, _vdsps, and _vdspa above.           */
  226.  
  227. static    _setargs( row, col, nchars, astate )
  228.     int    row, col, nchars, astate;
  229. {
  230.     /* if position is referenced to current cursor position */
  231.     if    ( row == VD_CURPOS || col == VD_CURPOS )
  232.         vidgetloc( &_row, &_col );    /* find out cursor position */
  233.                         /* set default _row and _col*/
  234.     if    ( row != VD_CURPOS )
  235.         _row = row;        /* set explicit ROW */
  236.     if    ( col != VD_CURPOS )
  237.         _col = col;        /* set explicit COL */
  238.  
  239.     _nchars = nchars;
  240.  
  241.     _smode = VD_NC1A;        /* normal string mode */
  242.     _cmode = VD_1C1A;        /* normal character mode */
  243.     /* if request is for no attribute, i.e., on-screen attribute is   */
  244.     /* retained when new chars are written.                  */
  245.     if    ( astate == VD_NOATTR )
  246.         {
  247.         _smode = VD_NC0A;    /* set no-attribute modes */
  248.         _cmode = VD_1C0A;
  249.         }
  250.  
  251.     _oldstate = ( astate >= 0 )        /* if not using current state */
  252.             ? vstsetcur ( astate )    /* set new and save old state*/
  253.             : VD_CURSTAT;        /* indicate cur state was used*/
  254.  
  255.                 /* if the TTY enabling attribute is on */
  256.     _srchchr = ( vstattr() & VA_GRAPHICS ) 
  257.             ? EOS    /* defeat searches for TTY chars */
  258.             : CRET;    /* enable searches for TTY chars */
  259. }
  260.  
  261.  
  262. /* the window system installs its own display function for speed's sake */
  263. _vdspsetdsp( pfi )
  264.     PFI pfi;
  265. {
  266.     _dsp = pfi;
  267. }
  268.