home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / snip9707.zip / VMGRDOS.C < prev    next >
C/C++ Source or Header  |  1997-07-05  |  11KB  |  547 lines
  1. /* +++Date last modified: 05-Jul-1997 */
  2.  
  3. /*
  4.  *  VMGRDOS.C  VidMgr module for MS-DOS compilers.  Release 1.3.
  5.  *
  6.  *  This module written in March 1996 by Andrew Clarke and released to the
  7.  *  public domain.  Last modified in October 1996.
  8.  */
  9.  
  10. #include <string.h>
  11. #include <dos.h>
  12. #include "vidmgr.h"
  13. #include "opsys.h"
  14.  
  15. #if defined(__POWERC) || (defined(__TURBOC__) && !defined(__BORLANDC__)) || \
  16.   (defined(__ZTC__) && !defined(__SC__))
  17. #define FAR far
  18. #else
  19. #if defined(__MSDOS__) || defined(MSDOS) || defined(DOS)
  20. #define FAR _far
  21. #else
  22. #define FAR
  23. #endif
  24. #endif
  25.  
  26. #ifndef MK_FP
  27. #define MK_FP(seg,off) \
  28.   ((void FAR *)(((unsigned long)(seg) << 16)|(unsigned)(off)))
  29. #endif
  30.  
  31. static int vm_iscolorcard(void);
  32. static char vm_getscreenmode(void);
  33. static void vm_setscreenmode(char mode);
  34. static void vm_setcursorsize(char start, char end);
  35. static void vm_getcursorsize(char *start, char *end);
  36. static void vm_getkey(unsigned char *chScan, unsigned char *chChar);
  37.  
  38. void vm_init(void)
  39. {
  40.     vm_getinfo(&vm_startup);
  41.     vm_setattr(vm_startup.attr);
  42.     opsysDetect();
  43. }
  44.  
  45. void vm_done(void)
  46. {
  47.     if (vm_getscreenmode() != vm_startup.mode)
  48.     {
  49.         vm_setscreenmode(vm_startup.mode);
  50.     }
  51.     vm_setcursorsize(vm_startup.cur_start, vm_startup.cur_end);
  52. }
  53.  
  54. void vm_getinfo(struct vm_info *v)
  55. {
  56.     v->ypos = vm_wherey();
  57.     v->xpos = vm_wherex();
  58.     v->attr = vm_getattrxy(v->xpos, v->ypos);
  59.     v->mode = vm_getscreenmode();
  60.     v->height = vm_getscreenheight();
  61.     v->width = vm_getscreenwidth();
  62.     vm_getcursorsize(&v->cur_start, &v->cur_end);
  63. }
  64.  
  65. static int vm_iscolorcard(void)
  66. {
  67.     return vm_getscreenmode() != 7;
  68. }
  69.  
  70. #if defined(__WATCOMC__) && defined(__386__)
  71.  
  72. char *vm_screenptr(char x, char y)
  73. {
  74.     char *ptr;
  75.     if (vm_iscolorcard())
  76.     {
  77.         ptr = (char *)(opsysGetVideoSeg(0xB800) << 4);
  78.     }
  79.     else
  80.     {
  81.         ptr = (char *)(opsysGetVideoSeg(0xB000) << 4);
  82.     }
  83.     return ptr + (y * vm_getscreenwidth() * 2) + (x * 2);
  84. }
  85.  
  86. #else
  87.  
  88. char FAR *vm_screenptr(char x, char y)
  89. {
  90.     char FAR *ptr;
  91.     if (vm_iscolorcard())
  92.     {
  93.         ptr = (char FAR *)MK_FP(opsysGetVideoSeg(0xB800), 0x0000);
  94.     }
  95.     else
  96.     {
  97.         ptr = (char FAR *)MK_FP(opsysGetVideoSeg(0xB000), 0x0000);
  98.     }
  99.     return ptr + (y * vm_getscreenwidth() * 2) + (x * 2);
  100. }
  101.  
  102. #endif
  103.  
  104. static char vm_getscreenmode(void)
  105. {
  106. #if defined(__WATCOMC__) && defined(__386__)
  107.     return *((char *)0x0449);
  108. #else
  109.     return *((char FAR *)MK_FP(0x0040, 0x0049));
  110. #endif
  111. }
  112.  
  113. static void vm_setscreenmode(char mode)
  114. {
  115. #if defined(__TURBOC__)
  116.     _AH = 0x00;
  117.     _AL = mode;
  118.     geninterrupt(0x10);
  119. #else
  120.     union REGS regs;
  121.     regs.h.ah = 0x00;
  122.     regs.h.al = mode;
  123. #if defined(__WATCOMC__) && defined(__386__)
  124.     int386(0x10, ®s, ®s);
  125. #else
  126.     int86(0x10, ®s, ®s);
  127. #endif
  128. #endif
  129. }
  130.  
  131. char vm_getscreenwidth(void)
  132. {
  133. #if defined(__WATCOMC__) && defined(__386__)
  134.     return *((char *)0x044a);
  135. #else
  136.     return *((char FAR *)MK_FP(0x0040, 0x004a));
  137. #endif
  138. }
  139.  
  140. char vm_getscreenheight(void)
  141. {
  142. #if defined(__WATCOMC__) && defined(__386__)
  143.     return (char)(*((char *)0x0484) + 1);
  144. #else
  145.     return (char)(*((char FAR *)MK_FP(0x0040, 0x0084)) + 1);
  146. #endif
  147. }
  148.  
  149. short vm_getscreensize(void)
  150. {
  151. #if defined(__WATCOMC__) && defined(__386__)
  152.     return *((short *)0x044c);
  153. #else
  154.     return *((short FAR *)MK_FP(0x0040, 0x004c));
  155. #endif
  156. }
  157.  
  158. void vm_gotoxy(char x, char y)
  159. {
  160. #if defined(__TURBOC__)
  161.     _AH = 0x02;
  162.     _BH = 0;
  163.     _DH = y - 1;
  164.     _DL = x - 1;
  165.     geninterrupt(0x10);
  166. #else
  167.     union REGS regs;
  168.     regs.h.ah = 0x02;
  169.     regs.h.bh = 0;
  170.     regs.h.dh = (unsigned char)(y - 1);
  171.     regs.h.dl = (unsigned char)(x - 1);
  172. #if defined(__WATCOMC__) && defined(__386__)
  173.     int386(0x10, ®s, ®s);
  174. #else
  175.     int86(0x10, ®s, ®s);
  176. #endif
  177. #endif
  178. }
  179.  
  180. char vm_wherex(void)
  181. {
  182. #if defined(__WATCOMC__) && defined(__386__)
  183.     return (char)(*((char *)0x0450) + 1);
  184. #else
  185.     return (char)(*((char FAR *)MK_FP(0x0040, 0x0050)) + 1);
  186. #endif
  187. }
  188.  
  189. char vm_wherey(void)
  190. {
  191. #if defined(__WATCOMC__) && defined(__386__)
  192.     return (char)(*((char *)0x0451) + 1);
  193. #else
  194.     return (char)(*((char FAR *)MK_FP(0x0040, 0x0051)) + 1);
  195. #endif
  196. }
  197.  
  198. static void vm_setcursorsize(char start, char end)
  199. {
  200. #if defined(__TURBOC__)
  201.     _AH = 0x01;
  202.     _CH = start;
  203.     _CL = end;
  204.     geninterrupt(0x10);
  205. #else
  206.     union REGS regs;
  207.     regs.h.ah = 0x01;
  208.     regs.h.ch = start;
  209.     regs.h.cl = end;
  210. #if defined(__WATCOMC__) && defined(__386__)
  211.     int386(0x10, ®s, ®s);
  212. #else
  213.     int86(0x10, ®s, ®s);
  214. #endif
  215. #endif
  216. }
  217.  
  218. static void vm_getcursorsize(char *start, char *end)
  219. {
  220. #if defined(__TURBOC__)
  221.     _AH = 0x03;
  222.     _BH = 0;
  223.     geninterrupt(0x10);
  224.     *start = _CH;
  225.     *end = _CL;
  226. #else
  227.     union REGS regs;
  228.     regs.h.ah = 0x03;
  229.     regs.h.bh = 0;
  230. #if defined(__WATCOMC__) && defined(__386__)
  231.     int386(0x10, ®s, ®s);
  232. #else
  233.     int86(0x10, ®s, ®s);
  234. #endif
  235.     *start = regs.h.ch;
  236.     *end = regs.h.cl;
  237. #endif
  238. }
  239.  
  240. int vm_kbhit(void)
  241. {
  242.     static unsigned short counter = 0;
  243.     if (counter % 10 == 0)
  244.     {
  245.         opsysTimeSlice();
  246.     }
  247.     counter++;
  248. #if defined(_MSC_VER) || defined(_QC) || defined(__SC__)
  249.     _asm
  250.     {
  251.         mov    ah,0x01
  252.         int    16h
  253.         jz     nokey
  254.     }
  255.     return 1;
  256. nokey:
  257.     return 0;
  258. #elif defined(__TURBOC__)
  259.     _AH = 0x01;
  260.     geninterrupt(0x16);
  261.     return !(_FLAGS & 0x40);
  262. #else
  263.     {
  264.         union REGPACK regpack;
  265.         memset(®pack, 0, sizeof regpack);
  266.         regpack.h.ah = 0x01;
  267.         intr(0x16, ®pack);
  268.         return !(regpack.x.flags & 0x40);
  269.     }
  270. #endif
  271. }
  272.  
  273. static void vm_getkey(unsigned char *chScan, unsigned char *chChar)
  274. {
  275. #if defined(__TURBOC__)
  276.     _AH = 0x00;
  277.     geninterrupt(0x16);
  278.     *chScan = _AH;
  279.     *chChar = _AL;
  280. #else
  281.     union REGS regs;
  282.     regs.h.ah = 0x00;
  283. #if defined(__WATCOMC__) && defined(__386__)
  284.     int386(0x16, ®s, ®s);
  285. #else
  286.     int86(0x16, ®s, ®s);
  287. #endif
  288.     *chScan = regs.h.ah;
  289.     *chChar = regs.h.al;
  290. #endif
  291. }
  292.  
  293. int vm_getch(void)
  294. {
  295.     unsigned char chChar, chScan;
  296.  
  297.     while (!vm_kbhit())
  298.     {
  299.         /* nada */
  300.     }
  301.  
  302.     vm_getkey(&chScan, &chChar);
  303.     if (chChar == 0xe0)
  304.     {
  305.         if (chScan)
  306.         {
  307.             chChar = 0;         /* force scan return */
  308.         }
  309.         else
  310.         {                       /* get next block */
  311.             chChar = 0;
  312.  
  313.             vm_getkey(&chScan, &chChar);
  314.             if (!chScan)
  315.             {                   /* still no scan? */
  316.                 chScan = chChar;  /* move new char over */
  317.                 chChar = 0;     /* force its return */
  318.             }
  319.             else
  320.             {
  321.                 chChar = 0;     /* force new scan */
  322.             }
  323.         }
  324.     }
  325.     if (chScan == 0xe0)
  326.     {
  327.         if (!chChar)
  328.         {
  329.             chScan = 0;
  330.  
  331.             vm_getkey(&chScan, &chChar);
  332.             if (!chScan)
  333.             {                   /* still no scan? */
  334.                 chScan = chChar;  /* move new char over */
  335.                 chChar = 0;     /* force its return */
  336.             }
  337.             else
  338.             {
  339.                 chChar = 0;     /* force new scan */
  340.             }
  341.         }
  342.         else
  343.         {
  344.             chScan = 0;         /* handle 0xe00d case */
  345.         }
  346.     }
  347.     if (chChar)
  348.     {
  349.         chScan = 0;
  350.     }
  351.  
  352.     return (int)((chScan << 8) + (chChar));
  353. }
  354.  
  355. void vm_setcursorstyle(int style)
  356. {
  357.     if (vm_iscolorcard())
  358.     {
  359.         switch (style)
  360.         {
  361.         case CURSORHALF:
  362.             vm_setcursorsize(4, 7);
  363.             break;
  364.         case CURSORFULL:
  365.             vm_setcursorsize(0, 7);
  366.             break;
  367.         case CURSORNORM:
  368.             vm_setcursorsize(7, 8);
  369.             break;
  370.         case CURSORHIDE:
  371.             vm_setcursorsize(32, 32);
  372.             break;
  373.         default:
  374.             break;
  375.         }
  376.     }
  377.     else
  378.     {
  379.         switch (style)
  380.         {
  381.         case CURSORHALF:
  382.             vm_setcursorsize(8, 13);
  383.             break;
  384.         case CURSORFULL:
  385.             vm_setcursorsize(0, 13);
  386.             break;
  387.         case CURSORNORM:
  388.             vm_setcursorsize(11, 13);
  389.             break;
  390.         case CURSORHIDE:
  391.             vm_setcursorsize(32, 32);
  392.             break;
  393.         default:
  394.             break;
  395.         }
  396.     }
  397. }
  398.  
  399. char vm_getchxy(char x, char y)
  400. {
  401.     char FAR *p;
  402.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  403.     return *p;
  404. }
  405.  
  406. char vm_getattrxy(char x, char y)
  407. {
  408.     char FAR *p;
  409.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  410.     return *(p + 1);
  411. }
  412.  
  413. void vm_xgetchxy(char x, char y, char *attr, char *ch)
  414. {
  415.     char FAR *p;
  416.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  417.     *ch = *p;
  418.     *attr = *(p + 1);
  419. }
  420.  
  421. void vm_putch(char x, char y, char ch)
  422. {
  423.     char FAR *p;
  424.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  425.     *p = ch;
  426. }
  427.  
  428. void vm_puts(char x, char y, char *str)
  429. {
  430.     char FAR *p;
  431.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  432.     while (*str)
  433.     {
  434.         *p++ = *str++;
  435.         p++;
  436.     }
  437. }
  438.  
  439. void vm_xputch(char x, char y, char attr, char ch)
  440. {
  441.     char FAR *p;
  442.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  443.     *p = ch;
  444.     *(p + 1) = attr;
  445. }
  446.  
  447. void vm_xputs(char x, char y, char attr, char *str)
  448. {
  449.     char FAR *p;
  450.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  451.     while (*str)
  452.     {
  453.         *p++ = *str++;
  454.         *p++ = attr;
  455.     }
  456. }
  457.  
  458. void vm_putattr(char x, char y, char attr)
  459. {
  460.     char FAR *p;
  461.     p = vm_screenptr((char)(x - 1), (char)(y - 1));
  462.     *(p + 1) = attr;
  463. }
  464.  
  465. void vm_paintclearbox(char x1, char y1, char x2, char y2, char attr)
  466. {
  467.     char x, y;
  468.     for (y = y1; y <= y2; y++)
  469.     {
  470.         for (x = x1; x <= x2; x++)
  471.         {
  472.             vm_xputch(x, y, attr, ' ');
  473.         }
  474.     }
  475. }
  476.  
  477. void vm_paintbox(char x1, char y1, char x2, char y2, char attr)
  478. {
  479.     char x, y;
  480.     for (y = y1; y <= y2; y++)
  481.     {
  482.         for (x = x1; x <= x2; x++)
  483.         {
  484.             vm_putattr(x, y, attr);
  485.         }
  486.     }
  487. }
  488.  
  489. void vm_clearbox(char x1, char y1, char x2, char y2)
  490. {
  491.     char x, y;
  492.     for (y = y1; y <= y2; y++)
  493.     {
  494.         for (x = x1; x <= x2; x++)
  495.         {
  496.             vm_putch(x, y, ' ');
  497.         }
  498.     }
  499. }
  500.  
  501. void vm_fillbox(char x1, char y1, char x2, char y2, char ch)
  502. {
  503.     char x, y;
  504.     for (y = y1; y <= y2; y++)
  505.     {
  506.         for (x = x1; x <= x2; x++)
  507.         {
  508.             vm_putch(x, y, ch);
  509.         }
  510.     }
  511. }
  512.  
  513. void vm_gettext(char x1, char y1, char x2, char y2, char *dest)
  514. {
  515.     char x, y;
  516.     for (y = y1; y <= y2; y++)
  517.     {
  518.         for (x = x1; x <= x2; x++)
  519.         {
  520.             vm_xgetchxy(x, y, dest + 1, dest);
  521.             dest += 2;
  522.         }
  523.     }
  524. }
  525.  
  526. void vm_puttext(char x1, char y1, char x2, char y2, char *srce)
  527. {
  528.     char x, y;
  529.     for (y = y1; y <= y2; y++)
  530.     {
  531.         for (x = x1; x <= x2; x++)
  532.         {
  533.             vm_xputch(x, y, *(srce + 1), *srce);
  534.             srce += 2;
  535.         }
  536.     }
  537. }
  538.  
  539. void vm_horizline(char x1, char x2, char row, char attr, char ch)
  540. {
  541.     char x;
  542.     for (x = x1; x <= x2; x++)
  543.     {
  544.         vm_xputch(x, row, attr, ch);
  545.     }
  546. }
  547.