home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / snip9707.zip / VMGROS2.C < prev    next >
C/C++ Source or Header  |  1997-07-05  |  8KB  |  329 lines
  1. /* +++Date last modified: 05-Jul-1997 */
  2.  
  3. /*
  4.  *  VMGROS2.C; VidMgr module for OS/2 compilers.  Release 1.2.
  5.  *
  6.  *  This module written in March 1996 by Andrew Clarke and released to the
  7.  *  public domain.  Last modified in May 1996.
  8.  */
  9.  
  10. #define INCL_KBD
  11. #define INCL_VIO
  12. #define INCL_DOSPROCESS
  13.  
  14. #include <string.h>
  15. #include <os2.h>
  16. #include "vidmgr.h"
  17.  
  18. #ifndef KBDTRF_FINAL_CHAR_IN
  19. #define KBDTRF_FINAL_CHAR_IN  FINAL_CHAR_IN
  20. #endif
  21.  
  22. static void vm_setcursorsize(char start, char end);
  23. static void vm_getcursorsize(char *start, char *end);
  24.  
  25. void vm_init(void)
  26. {
  27.     vm_getinfo(&vm_startup);
  28.     vm_setattr(vm_startup.attr);
  29. }
  30.  
  31. void vm_done(void)
  32. {
  33.     vm_setcursorsize(vm_startup.cur_start, vm_startup.cur_end);
  34. }
  35.  
  36. void vm_getinfo(struct vm_info *v)
  37. {
  38.     v->ypos = vm_wherey();
  39.     v->xpos = vm_wherex();
  40.     v->attr = vm_getattrxy(v->xpos, v->ypos);
  41.     v->height = vm_getscreenheight();
  42.     v->width = vm_getscreenwidth();
  43.     vm_getcursorsize(&v->cur_start, &v->cur_end);
  44. }
  45.  
  46. char vm_getscreenwidth(void)
  47. {
  48.     VIOMODEINFO vi;
  49.     vi.cb = sizeof(VIOMODEINFO);
  50.     VioGetMode(&vi, 0);
  51.     return vi.col;
  52. }
  53.  
  54. char vm_getscreenheight(void)
  55. {
  56.     VIOMODEINFO vi;
  57.     vi.cb = sizeof(VIOMODEINFO);
  58.     VioGetMode(&vi, 0);
  59.     return vi.row;
  60. }
  61.  
  62. short vm_getscreensize(void)
  63. {
  64.     return (short)(vm_getscreenwidth() * vm_getscreenheight() * 2);
  65. }
  66.  
  67. char vm_wherex(void)
  68. {
  69.     USHORT row, col;
  70.     VioGetCurPos(&row, &col, 0);
  71.     return (char)(col + 1);
  72. }
  73.  
  74. char vm_wherey(void)
  75. {
  76.     USHORT row, col;
  77.     VioGetCurPos(&row, &col, 0);
  78.     return (char)(row + 1);
  79. }
  80.  
  81. void vm_gotoxy(char x, char y)
  82. {
  83.     VioSetCurPos((USHORT) (y - 1), (USHORT) (x - 1), 0);
  84. }
  85.  
  86. static void vm_setcursorsize(char start, char end)
  87. {
  88.     VIOCURSORINFO vi;
  89.     vi.yStart = start;
  90.     vi.cEnd = end;
  91.     vi.cx = 0;
  92.     vi.attr = 0;
  93.     VioSetCurType(&vi, 0);
  94. }
  95.  
  96. static void vm_getcursorsize(char *start, char *end)
  97. {
  98.     VIOCURSORINFO vi;
  99.     VioGetCurType(&vi, 0);
  100.     *start = vi.yStart;
  101.     *end = vi.cEnd;
  102. }
  103.  
  104. int vm_kbhit(void)
  105. {
  106.     KBDKEYINFO ki;
  107.     ki.fbStatus = 0;
  108.     KbdPeek(&ki, 0);
  109.     return ki.fbStatus & KBDTRF_FINAL_CHAR_IN;
  110. }
  111.  
  112. int vm_getch(void)
  113. {
  114.     KBDKEYINFO ki;
  115.  
  116.     ki.chChar = 0;
  117.     ki.chScan = 0;
  118.     KbdCharIn(&ki, IO_WAIT, 0);
  119.  
  120.     if (ki.chChar == 0xe0)
  121.     {
  122.         if (ki.chScan)
  123.         {
  124.             ki.chChar = 0;      /* force scan return */
  125.         }
  126.         else
  127.         {                       /* get next block */
  128.             ki.chChar = 0;
  129.             KbdCharIn(&ki, IO_WAIT, 0);
  130.             if (!ki.chScan)
  131.             {                   /* still no scan? */
  132.                 ki.chScan = ki.chChar;  /* move new char over */
  133.                 ki.chChar = 0;  /* force its return */
  134.             }
  135.             else
  136.             {
  137.                 ki.chChar = 0;  /* force new scan */
  138.             }
  139.         }
  140.     }
  141.     if (ki.chScan == 0xe0)
  142.     {
  143.         if (!ki.chChar)
  144.         {
  145.             ki.chScan = 0;
  146.             KbdCharIn(&ki, IO_WAIT, 0);
  147.             if (!ki.chScan)
  148.             {                   /* still no scan? */
  149.                 ki.chScan = ki.chChar;  /* move new char over */
  150.                 ki.chChar = 0;  /* force its return */
  151.             }
  152.             else
  153.             {
  154.                 ki.chChar = 0;  /* force new scan */
  155.             }
  156.         }
  157.         else
  158.         {
  159.             ki.chScan = 0;      /* handle 0xe00d case */
  160.         }
  161.     }
  162.     if (ki.chChar)
  163.     {
  164.         ki.chScan = 0;
  165.     }
  166.  
  167.     return (int)((ki.chScan << 8) + (ki.chChar));
  168. }
  169.  
  170. char vm_getchxy(char x, char y)
  171. {
  172.     char ch;
  173.     USHORT len = 1;
  174.     VioReadCharStr(&ch, &len, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  175.     return ch;
  176. }
  177.  
  178. char vm_getattrxy(char x, char y)
  179. {
  180.     char cell[4];
  181.     USHORT len = 4;
  182.     VioReadCellStr(cell, &len, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  183.     return *(cell + 1);
  184. }
  185.  
  186. void vm_xgetchxy(char x, char y, char *attr, char *ch)
  187. {
  188.     char cell[4];
  189.     USHORT len = 4;
  190.     VioReadCellStr(cell, &len, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  191.     *ch = *cell;
  192.     *attr = *(cell + 1);
  193. }
  194.  
  195. void vm_setcursorstyle(int style)
  196. {
  197.     VIOCURSORINFO vi;
  198.  
  199.     switch (style)
  200.     {
  201.     case CURSORHALF:
  202.         vi.yStart = -50;
  203.         vi.cEnd = -100;
  204.         vi.cx = 0;
  205.         vi.attr = 0;
  206.         VioSetCurType(&vi, 0);
  207.         break;
  208.     case CURSORFULL:
  209.         vi.yStart = 0;
  210.         vi.cEnd = -100;
  211.         vi.cx = 0;
  212.         vi.attr = 0;
  213.         VioSetCurType(&vi, 0);
  214.         break;
  215.     case CURSORNORM:
  216.         vi.yStart = -90;
  217.         vi.cEnd = -100;
  218.         vi.cx = 0;
  219.         vi.attr = 0;
  220.         VioSetCurType(&vi, 0);
  221.         break;
  222.     case CURSORHIDE:
  223.         vi.yStart = -90;
  224.         vi.cEnd = -100;
  225.         vi.cx = 0;
  226.         vi.attr = -1;
  227.         VioSetCurType(&vi, 0);
  228.         break;
  229.     default:
  230.         break;
  231.     }
  232. }
  233.  
  234. void vm_putch(char x, char y, char ch)
  235. {
  236.     VioWrtCharStr(&ch, 1, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  237. }
  238.  
  239. void vm_puts(char x, char y, char *str)
  240. {
  241.     VioWrtCharStr(str, (USHORT) strlen(str), (USHORT) (y - 1), (USHORT) (x - 1), 0);
  242. }
  243.  
  244. void vm_xputch(char x, char y, char attr, char ch)
  245. {
  246.     VioWrtCharStrAtt(&ch, 1, (USHORT) (y - 1), (USHORT) (x - 1), (PBYTE) &attr, 0);
  247. }
  248.  
  249. void vm_xputs(char x, char y, char attr, char *str)
  250. {
  251.     VioWrtCharStrAtt(str, (USHORT) strlen(str), (USHORT) (y - 1), (USHORT) (x - 1), (PBYTE) &attr, 0);
  252. }
  253.  
  254. void vm_putattr(char x, char y, char attr)
  255. {
  256.     VioWrtNAttr((PBYTE) &attr, 1, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  257. }
  258.  
  259. void vm_paintclearbox(char x1, char y1, char x2, char y2, char attr)
  260. {
  261.     char y, cell[2];
  262.     cell[0] = ' ';
  263.     cell[1] = attr;
  264.     for (y = y1; y <= y2; y++)
  265.     {
  266.         VioWrtNCell((PBYTE) &cell, (USHORT) (x2 - x1 + 1), (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  267.     }
  268. }
  269.  
  270. void vm_paintbox(char x1, char y1, char x2, char y2, char attr)
  271. {
  272.     char y;
  273.     for (y = y1; y <= y2; y++)
  274.     {
  275.         VioWrtNAttr((PBYTE) &attr, (USHORT) (x2 - x1 + 1), (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  276.     }
  277. }
  278.  
  279. void vm_clearbox(char x1, char y1, char x2, char y2)
  280. {
  281.     char y, ch;
  282.     ch = ' ';
  283.     for (y = y1; y <= y2; y++)
  284.     {
  285.         VioWrtNChar((PBYTE) &ch, (USHORT) (x2 - x1 + 1), (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  286.     }
  287. }
  288.  
  289. void vm_fillbox(char x1, char y1, char x2, char y2, char ch)
  290. {
  291.     char y;
  292.     for (y = y1; y <= y2; y++)
  293.     {
  294.         VioWrtNChar((PBYTE) &ch, (USHORT) (x2 - x1 + 1), (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  295.     }
  296. }
  297.  
  298. void vm_gettext(char x1, char y1, char x2, char y2, char *dest)
  299. {
  300.     USHORT width;
  301.     char y;
  302.     width = (USHORT) ((x2 - x1 + 1) * 2);
  303.     for (y = y1; y <= y2; y++)
  304.     {
  305.         VioReadCellStr((PBYTE) dest, &width, (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  306.         dest += width;
  307.     }
  308. }
  309.  
  310. void vm_puttext(char x1, char y1, char x2, char y2, char *srce)
  311. {
  312.     USHORT width;
  313.     char y;
  314.     width = (USHORT) ((x2 - x1 + 1) * 2);
  315.     for (y = y1; y <= y2; y++)
  316.     {
  317.         VioWrtCellStr((PBYTE) srce, width, (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  318.         srce += width;
  319.     }
  320. }
  321.  
  322. void vm_horizline(char x1, char x2, char row, char attr, char ch)
  323. {
  324.     char cell[2];
  325.     cell[0] = ch;
  326.     cell[1] = attr;
  327.     VioWrtNCell((PBYTE) &cell, (USHORT) (x2 - x1 + 1), (USHORT) (row - 1), (USHORT) (x1 - 1), 0);
  328. }
  329.