home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / cpm / cpm68k / kmince.lbr / TERM.CQ / TERM.C
Text File  |  1986-08-29  |  7KB  |  316 lines
  1. /* term.c    This is the low level terminal support package.
  2.  
  3.     Copyright 1980 by Jason T. Linhart
  4.     Updated to version two 5/15/80 JTL
  5.  
  6.     This is the generalized terminal support package. It deals
  7. with things like where the cursor is and how to get it to somewhere
  8. new as well as fancy things like clear to end of line and clear to end
  9. of screen. */
  10.  
  11. #include "mince.gbl"
  12.  
  13. TInit()                /* set up the keyboard input queue */
  14. {
  15.     int trow;
  16.  
  17.     QInit(&kbdq,KBBUFMAX);
  18.     put_string(&terminal.init);
  19.     for (trow=0; trow<terminal.nrows; ++trow) clrcol[trow]=terminal.ncols;
  20.     srow=scol=255;            /* init to impossible values */
  21.     TClrWind();
  22.     }
  23.  
  24. TFini()                /* set terminal back to defaults */
  25. {
  26.     TForce();
  27.     put_string(&terminal.deinit);
  28.     }
  29.  
  30. TForce()                /* Position the cursor to the point */
  31. {
  32.     if (pcol>=terminal.ncols) {
  33.         pcol=0;
  34.         Error("Off Screen");
  35.         }
  36.     if (srow==prow && scol==pcol) return;
  37.     put_string(&terminal.cpos1);
  38.     put_coord(FIRST);
  39.     put_string(&terminal.cpos2);
  40.     put_coord(SECOND);
  41.     put_string(&terminal.cpos3);
  42.     put_pad(terminal.ncpospad);
  43.     srow=prow;
  44.     scol=pcol;
  45.     }
  46.  
  47. TSetPoint(irow,icol)    /* Set the position of the active point */
  48.     int irow, icol;
  49. {
  50.     prow=irow;
  51.     pcol=icol;
  52.     }
  53.  
  54. TGetRow()                /* Return the row the terminal is on */
  55. {
  56.     return(prow);
  57.     }
  58.  
  59. TGetCol()                /* Return the column the terminal is on */
  60. {
  61.     return(pcol);
  62.     }
  63.  
  64. TMaxRow()                /* Return the max # of rows on the terminal */
  65. {
  66.     return(terminal.nrows);
  67.     }
  68.  
  69. TMaxCol()                /* Return the max # of columns on the terminal */
  70. {
  71.     return(terminal.ncols);
  72.     }
  73.  
  74. TBell()                /* Ring the terminal bell */
  75. {
  76.     put_string(&terminal.bell);
  77.     }
  78.  
  79. TPrntChar(ichar)        /* Print a character */
  80.     char ichar;
  81. {
  82.     int tcol;
  83.  
  84.     if (ichar>=' ' && ichar<='~') {
  85.         TForce();
  86.         TPutChar(ichar);
  87.         ++scol;
  88.         ++pcol;
  89.         if (clrcol[prow]<pcol) clrcol[prow]=pcol;
  90.         }
  91.     else switch(((int) ichar) & 255) {
  92.         case '\t':
  93.             tcol=tabincr-(pcol%tabincr);
  94.             while (tcol) {
  95.                 TPrntChar(' ');
  96.                 --tcol;
  97.                 }
  98.             break;
  99.         case NL:
  100.             pcol=0;
  101.             if (prow<terminal.nrows-1) ++prow;
  102.             else prow=0;
  103.             TCLEOL();
  104.             break;
  105.         default:
  106.             if (ichar&128) {
  107.                 TPrntChar('~');
  108.                 TPrntChar(ichar & ~128);
  109.                 }
  110.             else {
  111.                 TPrntChar('^');
  112.                 TPrntChar(ichar^'@');
  113.                 }
  114.             break;
  115.         }
  116.     }
  117.  
  118. TWidth(colcnt,tchar)    /* determine width of tchar */
  119.     int colcnt;
  120.     char tchar;
  121. {
  122.     int wid, delta;
  123.  
  124.     if (tchar>=' ' && tchar<='~') return(1);
  125.     switch(((int) tchar) & 255) {
  126.  
  127.     case NL:
  128.         return(-colcnt);
  129.     case TAB:
  130.         colcnt %= terminal.ncols;
  131.         wid=tabincr-(colcnt%tabincr);
  132.         delta=terminal.ncols-colcnt;
  133.         if (delta<wid) wid=delta+tabincr;
  134.         break;
  135.     default:
  136.         if (tchar&128) wid = TWidth(colcnt+1,tchar & ~128)+1;
  137.         else wid=2;
  138.         delta=terminal.ncols-(colcnt%terminal.ncols);
  139.         if (delta<wid) wid+=delta;
  140.         break;
  141.         }
  142.     return(wid);
  143.     }
  144.  
  145. TCLEOL()                /* Clear to end of line */
  146. {
  147.     int tcol;
  148.  
  149.     if (pcol>=clrcol[prow]) return;
  150.     TForce();
  151.     if (terminal.cleol.len) {
  152.         put_string(&terminal.cleol);
  153.         put_pad(terminal.ncleolpad);
  154.         }
  155.     else for (tcol=pcol; tcol<clrcol[prow]; ++tcol) {
  156.         TPutChar(' ');
  157.         ++scol;
  158.         TKbChk();
  159.         }
  160.     clrcol[prow]=pcol;
  161.     }
  162.  
  163. TClrLine()            /* Goto the beginning of the line and clear it */
  164. {
  165.     pcol=0;
  166.     TCLEOL();
  167.     }
  168.  
  169. TCLEOW()                /* Clear to end of window */
  170. {
  171.     int trow, tcol;
  172.  
  173.     if (terminal.cleow.len) {
  174.         TForce();
  175.         put_string(&terminal.cleow);
  176.         put_pad(terminal.ncleowpad);
  177.         }
  178.     else {
  179.         trow=prow;
  180.         tcol=pcol;
  181.         while (prow<terminal.nrows) {
  182.             TCLEOL();
  183.             ++prow;
  184.             pcol=0;
  185.             }
  186.         prow=trow;
  187.         pcol=tcol;
  188.         }
  189.     }
  190.  
  191. TClrWind()            /* Home and clear window */
  192. {
  193.     int trow;
  194.  
  195.     prow=pcol=0;
  196.     if (terminal.hcl.len) {
  197.         put_string(&terminal.hcl);
  198.         put_pad(terminal.nhclpad);
  199.         for (trow=0; trow<terminal.nrows; ++trow) clrcol[trow]=0;
  200.         srow=scol=0;
  201.         }
  202.     else TCLEOW();
  203.     }
  204.  
  205. TPrntStr(string)        /* Print a string */
  206.     char *string;
  207. {
  208.     while (*string) TPrntChar(*string++);
  209.     }
  210.  
  211. TDisStr(row,col,string)    /* Display a string at row,col */
  212.     int row, col;
  213.     char *string;
  214. {
  215.     TSetPoint(row,col);
  216.     while (*string) TPrntChar(*string++);
  217.     }
  218.  
  219. TKbRdy()                /* Returns TRUE if input available */
  220. {
  221. #ifdef KBMACRO
  222.     if (KBexecuting) return(!QEmpty(&kbmacro));
  223. #endif
  224.     TKbChk();
  225.     return (!QEmpty(&kbdq));
  226.     }
  227.  
  228. TGetKb()                /* Returns an input character */
  229. {
  230.     char temp;
  231.  
  232. #ifdef KBMACRO
  233.     if (KBexecuting) return(QGrab(&kbmacro));
  234. #endif
  235.     while (QEmpty(&kbdq)) TKbChk();    /* Wait for input */
  236.     temp = QGrab(&kbdq);
  237. #ifdef KBMACRO
  238.     if (remember) {
  239.         if (QFull(&kbmacro)) { TBell(); 
  240.         QInit(&kbmacro,MAXKBMACL); remember = FALSE; }
  241.         else QShove(temp,&kbmacro);
  242.         }
  243. #endif
  244.     return(temp);        /* Pass back the character */
  245.     }
  246.  
  247. TKbChk()                /* Check for keyboard input and queue it */
  248. {
  249. #ifdef STRIDE
  250.     uread(132,0L,0L,0L,2);
  251. #endif
  252.     if (terminal.inport.biosp ? bios(2) : 
  253.         ((inp(terminal.inport.statport)&terminal.inport.readymask) == terminal.inport.polarity))
  254.         if (!QFull(&kbdq)) QShove(terminal.inport.biosp ? bios(3) :
  255.             (inp(terminal.inport.dataport)&terminal.inport.datamask), &kbdq);
  256.         else TBell();
  257.     }
  258.  
  259. TPutChar(ochar)        /* print a character on the terminal */
  260.     char ochar;
  261. {
  262.     if (terminal.outport.biosp) bios(4,ochar);
  263.     else {
  264.         while ((inp(terminal.outport.statport)&terminal.outport.readymask) !=
  265.             terminal.outport.polarity);
  266.         outp(terminal.outport.dataport,ochar);
  267.         }
  268.     }
  269.  
  270. /* the following are internal routines */
  271.  
  272. put_string(sdef)        /* output a command string */
  273.     struct str *sdef;
  274. {
  275.     int tlen;
  276.     char *tptr;
  277.  
  278.     tptr = &terminal.strspc[sdef->idx];
  279.     for (tlen=sdef->len; tlen; --tlen) TPutChar(*tptr++);
  280.     }
  281.  
  282. put_coord(firstp)        /* output a cursor-positioning coordinate */
  283.     int firstp;
  284. {
  285.     char location;
  286.     char shortarg;        /* cause we can't compare int with char */
  287.  
  288.     shortarg=firstp;
  289.     if (shortarg == terminal.rowfirstp) location=prow+terminal.rowbias;
  290.     else location=pcol+terminal.colbias;
  291.  
  292.     if (terminal.binaryp) TPutChar(location^terminal.compp);
  293.     else put_num(location);
  294.     }
  295.  
  296.  
  297. put_num(num)            /* output a number to the terminal */
  298.     unsigned num;
  299. {
  300.     if (num>=10) put_num(num/10);
  301.     TPutChar(num%10+'0');
  302.     }
  303.  
  304. put_pad(npads)            /* do padding */
  305.     int npads;
  306. {
  307.     int count;
  308.  
  309.     if (terminal.padp == CHARPAD) while (npads--) TPutChar(terminal.padchar);
  310.     if (terminal.padp == DELAYPAD)
  311.         while (npads--) for (count=terminal.mhz*8; count; --count);
  312.     }
  313.  
  314. /* END OF TERM.C - terminal support code */
  315. = DELAYPAD)
  316.         while (npad