home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 1 / CDPD_Vol1.bin / pd / 176-200 / 197 / stevie / amiga.c < prev    next >
C/C++ Source or Header  |  1992-06-23  |  5KB  |  290 lines
  1. /*
  2.  * Amiga system-dependent routines. 
  3.  */
  4.  
  5. #include <proto/dos.h>
  6. #include "stevie.h"
  7.  
  8. long            raw_in = 0;
  9. long            raw_out = 0;
  10.  
  11. #define    BSIZE    2048
  12. static char     outbuf[BSIZE];
  13. static int      bpos = 0;
  14.  
  15. void
  16. flushbuf()
  17. {
  18.     if (bpos != 0)
  19.     Write(raw_out, outbuf, bpos);
  20.     bpos = 0;
  21. }
  22.  
  23. /*
  24.  * Macro to output a character. Used within this file for speed. 
  25.  */
  26. #define    outone(c)    outbuf[bpos++] = c; if (bpos >= BSIZE) flushbuf()
  27.  
  28. int
  29. GetCharacter()
  30. {
  31.     char            c;
  32.  
  33.     Read(raw_in, &c, sizeof(c));
  34.     return ((int) c);
  35. }
  36.  
  37. /*
  38.  * getCSIsequence - get a CSI sequence
  39.  *                - either cursor keys, help, functionkeys, or some
  40.  *                  other sequence (if other, check window size)
  41.  */
  42. int
  43. getCSIsequence()
  44. {
  45.     int             c;
  46.     int             param1;
  47.     int             param2;
  48.  
  49.     c = GetCharacter();
  50.     if (isdigit(c)) {
  51.     param1 = 0;
  52.     while (isdigit(c)) {
  53.         param1 = param1 * 10 + c - '0';
  54.         c = GetCharacter();
  55.     }
  56.     if (c == '~')        /* function key */
  57.         return ((char) (K_F1 + param1));
  58.  
  59.     /* must be an event of some sort or a window bound report */
  60.     if (c == ';') {
  61.         param2 = 0;
  62.         c = GetCharacter();
  63.         while (isdigit(c)) {
  64.         param2 = param2 * 10 + c - '0';
  65.         c = GetCharacter();
  66.         }
  67.         if (c == ';') {
  68.         param1 = 0;
  69.         c = GetCharacter();
  70.         while (isdigit(c)) {
  71.             param1 = param1 * 10 + c - '0';
  72.             c = GetCharacter();
  73.         }
  74.         if (c == ';') {
  75.             param2 = 0;
  76.             c = GetCharacter();
  77.             while (isdigit(c)) {
  78.             param2 = param2 * 10 + c - '0';
  79.             c = GetCharacter();
  80.             }
  81.             if (c == ' ') {
  82.             c = GetCharacter();
  83.             if (c == 'r') {
  84.                 if (param1 < 2)
  85.                 param1 = 2;
  86.                 if (param2 < 5)
  87.                 param2 = 5;
  88.                 if (Columns != param2 || Rows != param1) {
  89.                 Columns = param2;
  90.                 Rows = param1;
  91.                 P(P_LI) = Rows;
  92.                 return (-1);
  93.                 } else
  94.                 return 0;
  95.             }
  96.             }
  97.         }
  98.         }
  99.     }
  100.     while ((c != '|') && (c != '~'))
  101.         c = GetCharacter();
  102.  
  103.     outstr("\033[0 q");
  104.     flushbuf();
  105.     }
  106.     switch (c) {
  107.       case 'A':        /* cursor up */
  108.     return K_UARROW;
  109.       case 'B':        /* cursor down */
  110.     return K_DARROW;
  111.       case 'C':        /* cursor right */
  112.     return K_RARROW;
  113.       case 'D':        /* cursor left */
  114.     return K_LARROW;
  115.       case 'T':        /* shift cursor up */
  116.     return K_SUARROW;
  117.       case 'S':        /* shift cursor down */
  118.     return K_SDARROW;
  119.       case ' ':        /* shift cursor left or right */
  120.     c = GetCharacter();
  121.     if (c == 'A')        /* shift cursor left */
  122.         return K_SLARROW;
  123.     if (c == '@')        /* shift cursor right */
  124.         return K_SRARROW;
  125.     break;
  126.       case '?':        /* help */
  127.     c = GetCharacter();
  128.     if (c == '~')
  129.         return K_HELP;
  130.     break;
  131.     }
  132.     return 0;            /* some other control code */
  133. }
  134.  
  135. /*
  136.  * inchar() - get a character from the keyboard 
  137.  */
  138. int
  139. inchar()
  140. {
  141.     int             c;
  142.  
  143.     flushbuf();
  144.  
  145.     for (;;) {
  146.     c = GetCharacter();
  147.     if (c != 0x9b)
  148.         break;
  149.     c = getCSIsequence();
  150.     if (c > 0)
  151.         break;
  152.     if (c == -1) {
  153.         screenalloc();
  154.         screenclear();
  155.         msg("");
  156.         updateNextscreen(NOT_VALID);
  157.         cursupdate();
  158.         updateNextscreen(NOT_VALID);
  159.         cursupdate();
  160.         updateRealscreen();
  161.         windgoto(Cursrow, Curscol);
  162.         flushbuf();
  163.     }
  164.     }
  165.     return c;
  166. }
  167.  
  168. void
  169. outchar(c)
  170.     char            c;
  171. {
  172.     outbuf[bpos++] = c;
  173.     if (bpos >= BSIZE)
  174.     flushbuf();
  175. }
  176.  
  177. void
  178. outstr(s)
  179.     char           *s;
  180. {
  181.     while (*s)
  182.     outone(*s++);
  183. }
  184.  
  185. void
  186. beep()
  187. {
  188.     if (RedrawingDisabled)
  189.     return;
  190.  
  191.     outone('\007');
  192. }
  193.  
  194. void
  195. sleep(n)
  196.     int             n;
  197. {
  198.     void            Delay();
  199.  
  200.     if (n > 0)
  201.     Delay(50L * n);
  202. }
  203.  
  204. void
  205. delay()
  206. {
  207.     void            Delay();
  208.  
  209.     Delay(25L);
  210. }
  211.  
  212. void
  213. windinit()
  214. {
  215.     Columns = 80;
  216.     P(P_LI) = Rows = 24;
  217.  
  218.     raw_in = Input();
  219.     if (!IsInteractive(raw_in)) {
  220.     raw_in = Open("RAW:0/0/480/200/STEVIE", MODE_NEWFILE);
  221.     if (raw_in == NULL) {
  222.         fprintf(stderr, "Can't open window ?!?!?!?\n");
  223.         exit(2);
  224.     }
  225.     raw_out = raw_in;
  226.     } else {
  227.     raw_out = Output();
  228.     if (raw(stdin) != 0)
  229.         perror("Can't change to raw mode ?!?!?!?");
  230.     }
  231.  
  232.     outstr("\033[12{");        /* window resize events activated */
  233.     flushbuf();
  234.  
  235.     for (;;) {
  236.     outstr("\033[0 q");    /* get window size */
  237.     flushbuf();
  238.     if (GetCharacter() == 0x9b)
  239.         if (getCSIsequence() == -1)
  240.         break;
  241.     }
  242. }
  243.  
  244. void
  245. windexit(r)
  246.     int             r;
  247. {
  248.     outstr("\033[12}");        /* window resize events de-activated */
  249.     flushbuf();
  250.  
  251.     if (raw_in != raw_out) {
  252.     if (cooked(stdin) != 0)
  253.         perror("Can't change to cooked mode ?!?!?!?");
  254.     } else {
  255.     Close(raw_in);
  256.     }
  257.     exit(r);
  258. }
  259.  
  260. void
  261. windgoto(r, c)
  262.     int             c;
  263.     int             r;
  264. {
  265.     r++;
  266.     c++;
  267.  
  268.     outstr("\033[");
  269.     if (r >= 10)
  270.     outchar((char) (r / 10 + '0'));
  271.     outchar((char) (r % 10 + '0'));
  272.     outchar(';');
  273.     if (c >= 10)
  274.     outchar((char) (c / 10 + '0'));
  275.     outchar((char) (c % 10 + '0'));
  276.     outchar('H');
  277. }
  278.  
  279. FILE           *
  280. fopenb(fname, mode)
  281.     char           *fname;
  282.     char           *mode;
  283. {
  284.     FILE           *fopen();
  285.     char            modestr[16];
  286.  
  287.     sprintf(modestr, "%sb", mode);
  288.     return fopen(fname, modestr);
  289. }
  290.