home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d197 / stevie.lha / Stevie / os2.c < prev    next >
C/C++ Source or Header  |  1989-03-28  |  4KB  |  256 lines
  1. /*
  2.  * OS/2 System-dependent routines.
  3.  *
  4.  * $Log:    os2.c,v $
  5.  * Revision 1.2  88/04/25  16:50:19  tony
  6.  * Minor changes for OS/2 version 1.1; also fixed up the RCS header.
  7.  * 
  8.  * Revision 1.1  88/03/21  12:04:23  tony
  9.  * Initial revision
  10.  * 
  11.  *
  12.  */
  13.  
  14. #define    INCL_BASE
  15. #include <os2.h>
  16. #include "stevie.h"
  17.  
  18. /*
  19.  * inchar() - get a character from the keyboard
  20.  */
  21. int
  22. inchar()
  23. {
  24.     int             c;
  25.  
  26.     for (;; beep()) {        /* loop until we get a valid character */
  27.  
  28.     flushbuf();        /* flush any pending output */
  29.  
  30.     switch (c = getch()) {
  31.       case 0x1e:
  32.         return K_CGRAVE;
  33.       case 0:        /* special key */
  34.       case 0xe0:        /* special key */
  35.         if (State != NORMAL) {
  36.         c = getch();    /* throw away next char */
  37.         continue;    /* and loop for another char */
  38.         }
  39.         switch (c = getch()) {
  40.           case 0x50:
  41.         return K_DARROW;
  42.           case 0x48:
  43.         return K_UARROW;
  44.           case 0x4b:
  45.         return K_LARROW;
  46.           case 0x4d:
  47.         return K_RARROW;
  48.           case 0x52:
  49.         return K_INSERT;
  50.           case 0x47:
  51.         stuffReadbuff("1G");
  52.         return -1;
  53.           case 0x4f:
  54.         stuffReadbuff("G");
  55.         return -1;
  56.           case 0x51:
  57.         stuffReadbuff(mkstr(CTRL('F')));
  58.         return -1;
  59.           case 0x49:
  60.         stuffReadbuff(mkstr(CTRL('B')));
  61.         return -1;
  62.         /*
  63.          * Hard-code some useful function key macros. 
  64.          */
  65.           case 0x3b:    /* F1 */
  66.         stuffReadbuff(":p\n");
  67.         return -1;
  68.           case 0x54:    /* SF1 */
  69.         stuffReadbuff(":p!\n");
  70.         return -1;
  71.           case 0x3c:    /* F2 */
  72.         stuffReadbuff(":n\n");
  73.         return -1;
  74.           case 0x55:    /* SF2 */
  75.         stuffReadbuff(":n!\n");
  76.         return -1;
  77.           case 0x3d:    /* F3 */
  78.         stuffReadbuff(":e #\n");
  79.         return -1;
  80.           case 0x3e:    /* F4 */
  81.         stuffReadbuff(":rew\n");
  82.         return -1;
  83.           case 0x57:    /* SF4 */
  84.         stuffReadbuff(":rew!\n");
  85.         return -1;
  86.           case 0x3f:    /* F5 */
  87.         stuffReadbuff("[[");
  88.         return -1;
  89.           case 0x40:    /* F6 */
  90.         stuffReadbuff("]]");
  91.         return -1;
  92.           case 0x41:    /* F7 */
  93.         stuffReadbuff("<<");
  94.         return -1;
  95.           case 0x42:    /* F8 */
  96.         stuffReadbuff(">>");
  97.         return -1;
  98.           case 0x43:    /* F9 */
  99.         stuffReadbuff(":x\n");
  100.         return -1;
  101.           case 0x44:    /* F10 */
  102.         stuffReadbuff(":help\n");
  103.         return -1;
  104.           default:
  105.         break;
  106.         }
  107.         break;
  108.  
  109.       default:
  110.         return c;
  111.     }
  112.     }
  113. }
  114.  
  115. #define    BSIZE    2048
  116. static char     outbuf[BSIZE];
  117. static int      bpos = 0;
  118.  
  119. flushbuf()
  120. {
  121.     if (bpos != 0)
  122.     write(1, outbuf, bpos);
  123.     bpos = 0;
  124. }
  125.  
  126. /*
  127.  * Macro to output a character. Used within this file for speed.
  128.  */
  129. #define    outone(c)    outbuf[bpos++] = c; if (bpos >= BSIZE) flushbuf()
  130.  
  131. /*
  132.  * Function version for use outside this file.
  133.  */
  134.  
  135. void
  136. outchar(c)
  137.     register char   c;
  138. {
  139.     outbuf[bpos++] = c;
  140.     if (bpos >= BSIZE)
  141.     flushbuf();
  142. }
  143.  
  144. static char     cell[2] = {0, 7};
  145.  
  146. /*
  147.  * outstr(s) - write a string to the console
  148.  *
  149.  * We implement insert/delete line escape sequences here. This is kind
  150.  * of a kludge, but at least it's localized to a single point.
  151.  */
  152. void
  153. outstr(s)
  154.     register char  *s;
  155. {
  156.     if (strcmp(s, T_DL) == 0) {    /* delete line */
  157.     int             r, c;
  158.  
  159.     flushbuf();
  160.     VioGetCurPos(&r, &c, 0);
  161.     VioScrollUp(r, 0, 100, 100, 1, cell, 0);
  162.     return;
  163.     }
  164.     if (strcmp(s, T_IL) == 0) {    /* insert line */
  165.     int             r, c;
  166.  
  167.     flushbuf();
  168.     VioGetCurPos(&r, &c, 0);
  169.     VioScrollDn(r, 0, 100, 100, 1, cell, 0);
  170.     return;
  171.     }
  172.     while (*s) {
  173.     outone(*s++);
  174.     }
  175. }
  176.  
  177. void
  178. beep()
  179. {
  180.     if (RedrawingDisabled)
  181.     return;
  182.  
  183.     outone('\007');
  184. }
  185.  
  186. void
  187. sleep(n)
  188.     int             n;
  189. {
  190.     DosSleep(1000L * n);
  191. }
  192.  
  193. void
  194. delay()
  195. {
  196.     flushbuf();
  197.     DosSleep(300L);
  198. }
  199.  
  200. void
  201. windinit()
  202. {
  203.     Columns = 80;
  204.     P(P_LI) = Rows = 25;
  205. }
  206.  
  207. void
  208. windexit(r)
  209.     int             r;
  210. {
  211.     flushbuf();
  212.     exit(r);
  213. }
  214.  
  215. void
  216. windgoto(r, c)
  217.     register int    r, c;
  218. {
  219.     r += 1;
  220.     c += 1;
  221.  
  222. /* I would recommend the following: 
  223.     flushbuf();
  224.     VioSetCurPos(r, c, 0);
  225. Alex */
  226.  
  227.     /*
  228.      * Check for overflow once, to save time. 
  229.      */
  230.     if (bpos + 8 >= BSIZE)
  231.     flushbuf();
  232.  
  233.     outbuf[bpos++] = '\033';
  234.     outbuf[bpos++] = '[';
  235.     if (r >= 10)
  236.     outbuf[bpos++] = r / 10 + '0';
  237.     outbuf[bpos++] = r % 10 + '0';
  238.     outbuf[bpos++] = ';';
  239.     if (c >= 10)
  240.     outbuf[bpos++] = c / 10 + '0';
  241.     outbuf[bpos++] = c % 10 + '0';
  242.     outbuf[bpos++] = 'H';
  243. }
  244.  
  245. FILE           *
  246. fopenb(fname, mode)
  247.     char           *fname;
  248.     char           *mode;
  249. {
  250.     FILE           *fopen();
  251.     char            modestr[16];
  252.  
  253.     sprintf(modestr, "%sb", mode);
  254.     return fopen(fname, modestr);
  255. }
  256.