home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / snip9707.zip / VMGRWNT.C < prev    next >
C/C++ Source or Header  |  1997-07-05  |  14KB  |  570 lines
  1. /* +++Date last modified: 05-Jul-1997 */
  2.  
  3. /*
  4.  *  VMGRWNT.C; VidMgr module for Windows 95/NT compilers.  Release 1.3.
  5.  *
  6.  *  This module written in May 1996 by Andrew Clarke and released to the
  7.  *  public domain.  Last modified in October 1996.
  8.  */
  9.  
  10. #include <stdlib.h>
  11. #include <string.h>
  12.  
  13. #define WIN32_LEAN_AND_MEAN
  14.  
  15. #include <windows.h>
  16. #include "vidmgr.h"
  17.  
  18. #ifdef __CYGWIN32__
  19. typedef WORD far *LPWORD;
  20. #endif
  21.  
  22. static HANDLE HInput = INVALID_HANDLE_VALUE;
  23. static HANDLE HOutput = INVALID_HANDLE_VALUE;
  24. static unsigned long key_hit = 0xFFFFFFFFUL;
  25.  
  26. static int video_init = 0;
  27.  
  28. #define vi_init()  if (!video_init) vm_vi_init()
  29. #define vi_done()  if (video_init) vm_vi_done()
  30.  
  31. void vm_vi_init(void)
  32. {
  33.     HInput = GetStdHandle(STD_INPUT_HANDLE);
  34.     HOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  35.     video_init = 1;
  36. }
  37.  
  38. void vm_vi_done(void)
  39. {
  40.     CloseHandle(HInput);
  41.     HInput = INVALID_HANDLE_VALUE;
  42.     CloseHandle(HOutput);
  43.     HOutput = INVALID_HANDLE_VALUE;
  44.     video_init = 0;
  45. }
  46.  
  47. void vm_init(void)
  48. {
  49.     vi_init();
  50.     vm_getinfo(&vm_startup);
  51.     vm_setattr(vm_startup.attr);
  52. }
  53.  
  54. void vm_done(void)
  55. {
  56.     CONSOLE_CURSOR_INFO cci;
  57.     SetConsoleCursorInfo(HOutput, &cci);
  58.     vm_startup.dwSize = (unsigned short)cci.dwSize;
  59.     vm_startup.bVisible = (int)cci.bVisible;
  60.     vi_done();
  61. }
  62.  
  63. void vm_getinfo(struct vm_info *v)
  64. {
  65.     CONSOLE_CURSOR_INFO cci;
  66.     v->ypos = vm_wherey();
  67.     v->xpos = vm_wherex();
  68.     v->attr = vm_getattrxy(v->xpos, v->ypos);
  69.     v->height = vm_getscreenheight();
  70.     v->width = vm_getscreenwidth();
  71.     cci.dwSize = (DWORD) vm_startup.dwSize;
  72.     cci.bVisible = (BOOL) vm_startup.bVisible;
  73.     GetConsoleCursorInfo(HOutput, &cci);
  74. }
  75.  
  76. char vm_getscreenwidth(void)
  77. {
  78.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  79.     GetConsoleScreenBufferInfo(HOutput, &csbi);
  80.     return (char)csbi.dwSize.X;
  81. }
  82.  
  83. char vm_getscreenheight(void)
  84. {
  85.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  86.     GetConsoleScreenBufferInfo(HOutput, &csbi);
  87.     return (char)csbi.dwSize.Y;
  88. }
  89.  
  90. short vm_getscreensize(void)
  91. {
  92.     return (short)(vm_getscreenwidth() * vm_getscreenheight() * 2);
  93. }
  94.  
  95. char vm_wherex(void)
  96. {
  97.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  98.     GetConsoleScreenBufferInfo(HOutput, &csbi);
  99.     return (char)(csbi.dwCursorPosition.X + 1);
  100. }
  101.  
  102. char vm_wherey(void)
  103. {
  104.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  105.     GetConsoleScreenBufferInfo(HOutput, &csbi);
  106.     return (char)(csbi.dwCursorPosition.Y + 1);
  107. }
  108.  
  109. void vm_gotoxy(char x, char y)
  110. {
  111.     COORD dwCursorPosition;
  112.     dwCursorPosition.X = (SHORT) (x - 1);
  113.     dwCursorPosition.Y = (SHORT) (y - 1);
  114.     SetConsoleCursorPosition(HOutput, dwCursorPosition);
  115. }
  116.  
  117. int vm_kbhit(void)
  118. {
  119.     int iKey = 0;
  120.     INPUT_RECORD irBuffer;
  121.     DWORD pcRead;
  122.  
  123.     if (key_hit != 0xFFFFFFFFUL)
  124.     {
  125.         return (int)key_hit;
  126.     }
  127.  
  128.     memset(&irBuffer, 0, sizeof irBuffer);
  129.  
  130.     if (WaitForSingleObject(HInput, 0L) == 0)
  131.     {
  132.         ReadConsoleInput(HInput, &irBuffer, 1, &pcRead);
  133.         if (irBuffer.EventType == KEY_EVENT &&
  134.           irBuffer.Event.KeyEvent.bKeyDown != 0 &&
  135.           irBuffer.Event.KeyEvent.wRepeatCount <= 1)
  136.         {
  137.             WORD vk, vs, uc;
  138.             BOOL fShift, fAlt, fCtrl;
  139.  
  140.             vk = irBuffer.Event.KeyEvent.wVirtualKeyCode;
  141.             vs = irBuffer.Event.KeyEvent.wVirtualScanCode;
  142. #ifdef __CYGWIN32__
  143.             uc = irBuffer.Event.KeyEvent.AsciiChar;
  144. #else
  145.             uc = irBuffer.Event.KeyEvent.uChar.AsciiChar;
  146. #endif
  147.  
  148.             fShift = (irBuffer.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED);
  149.             fAlt = (irBuffer.Event.KeyEvent.dwControlKeyState & (RIGHT_ALT_PRESSED + LEFT_ALT_PRESSED));
  150.             fCtrl = (irBuffer.Event.KeyEvent.dwControlKeyState & (RIGHT_CTRL_PRESSED + LEFT_CTRL_PRESSED));
  151.  
  152.             if (uc == 0)
  153.             {                   /* function keys */
  154.                 switch (vk)
  155.                 {
  156.                 case 0x21:     /* PgUp */
  157.                     if (fCtrl)
  158.                     {
  159.                         vs = 0x84;  /* Ctrl+PgUp */
  160.                     }
  161.                     break;
  162.  
  163.                 case 0x22:     /* PgDn */
  164.                     if (fCtrl)
  165.                     {
  166.                         vs = 0x76;  /* Ctrl+PgDn */
  167.                     }
  168.                     break;
  169.  
  170.                 case 0x23:     /* End */
  171.                     if (fCtrl)
  172.                     {
  173.                         vs = 0x75;  /* Ctrl+End */
  174.                     }
  175.                     break;
  176.  
  177.                 case 0x24:     /* Home */
  178.                     if (fCtrl)
  179.                     {
  180.                         vs = 0x77;  /* Ctrl+Home */
  181.                     }
  182.                     break;
  183.  
  184.                 case 0x25:     /* Left Arrow */
  185.                     if (fCtrl)
  186.                     {
  187.                         vs = 0x73;  /* Ctrl+Left Arrow */
  188.                     }
  189.                     break;
  190.  
  191.                 case 0x26:     /* Up Arrow */
  192.                     if (fCtrl)
  193.                     {
  194.                         vs = 0x8d;  /* Ctrl+Up Arrow */
  195.                     }
  196.                     break;
  197.  
  198.                 case 0x27:     /* Right Arrow */
  199.                     if (fCtrl)
  200.                     {
  201.                         vs = 0x74;  /* Ctrl+Right Arrow */
  202.                     }
  203.                     break;
  204.  
  205.                 case 0x28:     /* Down Arrow */
  206.                     if (fCtrl)
  207.                     {
  208.                         vs = 0x91;  /* Ctrl+Down Arrow */
  209.                     }
  210.                     break;
  211.  
  212.                 case 0x70:     /* F-Keys */
  213.                 case 0x71:
  214.                 case 0x72:
  215.                 case 0x73:
  216.                 case 0x74:
  217.                 case 0x75:
  218.                 case 0x76:
  219.                 case 0x77:
  220.                 case 0x78:
  221.                 case 0x79:
  222.                     if (fAlt)
  223.                     {
  224.                         vs += 0x2d;  /* Alt+F-Key */
  225.                     }
  226.                     else if (fShift)
  227.                     {
  228.                         vs += 0x19;  /* Shift+F-Key */
  229.                     }
  230.                     break;
  231.                 }
  232.  
  233.                 if (vk > 0x20 && vk < 0x92)  /* If it's OK use scan code */
  234.                 {
  235.                     iKey = vs << 8;
  236.                 }
  237.             }
  238.             else
  239.             {
  240.                 if (fAlt)       /* Alt+Key */
  241.                 {
  242.                     iKey = vs << 8;
  243.                 }
  244.                 else if (fCtrl) /* Ctrl+Key */
  245.                 {
  246.                     iKey = vk & 0xbf;
  247.                 }
  248.                 else
  249.                 {
  250.                     iKey = uc;
  251.                 }
  252.             }
  253.         }
  254.     }
  255.  
  256.     if (iKey != 0)
  257.     {
  258.         key_hit = iKey;
  259.     }
  260.  
  261.     return (int)iKey;
  262. }
  263.  
  264. int vm_getch(void)
  265. {
  266.     int iKey;
  267.     while (key_hit == 0xFFFFFFFFUL)
  268.     {
  269.         vm_kbhit();
  270.     }
  271.     iKey = key_hit;
  272.     key_hit = 0xFFFFFFFFUL;
  273.     return (int)iKey;
  274. }
  275.  
  276. char vm_getchxy(char x, char y)
  277. {
  278.     char ch;
  279.     DWORD len;
  280.     COORD coord;
  281.     coord.X = (DWORD) (x - 1);
  282.     coord.Y = (DWORD) (y - 1);
  283.     ReadConsoleOutputCharacterA(HOutput, &ch, 1, coord, &len);
  284.     return ch;
  285. }
  286.  
  287. char vm_getattrxy(char x, char y)
  288. {
  289.     DWORD len;
  290.     COORD coord;
  291.     WORD wattr;
  292.     coord.X = (DWORD) (x - 1);
  293.     coord.Y = (DWORD) (y - 1);
  294.     ReadConsoleOutputAttribute(HOutput, &wattr, 1, coord, &len);
  295.     return (char)wattr;
  296. }
  297.  
  298. void vm_xgetchxy(char x, char y, char *attr, char *ch)
  299. {
  300.     DWORD len;
  301.     COORD coord;
  302.     WORD wattr;
  303.     coord.X = (DWORD) (x - 1);
  304.     coord.Y = (DWORD) (y - 1);
  305.     ReadConsoleOutputCharacterA(HOutput, ch, 1, coord, &len);
  306.     ReadConsoleOutputAttribute(HOutput, &wattr, 1, coord, &len);
  307.     *attr = (char)wattr;
  308. }
  309.  
  310. void vm_setcursorstyle(int style)
  311. {
  312.     CONSOLE_CURSOR_INFO cci;
  313.     GetConsoleCursorInfo(HOutput, &cci);
  314.     switch (style)
  315.     {
  316.     case CURSORHALF:
  317.         cci.bVisible = 1;
  318.         cci.dwSize = 49;
  319.         SetConsoleCursorInfo(HOutput, &cci);
  320.         break;
  321.     case CURSORFULL:
  322.         cci.bVisible = 1;
  323.         cci.dwSize = 99;
  324.         SetConsoleCursorInfo(HOutput, &cci);
  325.         break;
  326.     case CURSORNORM:
  327.         cci.bVisible = 1;
  328.         cci.dwSize = 12;
  329.         SetConsoleCursorInfo(HOutput, &cci);
  330.         break;
  331.     case CURSORHIDE:
  332.         cci.bVisible = 0;
  333.         SetConsoleCursorInfo(HOutput, &cci);
  334.         break;
  335.     default:
  336.         break;
  337.     }
  338. }
  339.  
  340. void vm_putch(char x, char y, char ch)
  341. {
  342.     DWORD len;
  343.     COORD coord;
  344.     coord.X = (DWORD) (x - 1);
  345.     coord.Y = (DWORD) (y - 1);
  346.     WriteConsoleOutputCharacterA(HOutput, &ch, 1, coord, &len);
  347. }
  348.  
  349. void vm_puts(char x, char y, char *str)
  350. {
  351.     DWORD len;
  352.     COORD coord;
  353.     coord.X = (DWORD) (x - 1);
  354.     coord.Y = (DWORD) (y - 1);
  355.     WriteConsoleOutputCharacterA(HOutput, str, (DWORD) strlen(str), coord, &len);
  356. }
  357.  
  358. void vm_xputch(char x, char y, char attr, char ch)
  359. {
  360.     DWORD len;
  361.     COORD coord;
  362.     WORD wattr;
  363.     coord.X = (DWORD) (x - 1);
  364.     coord.Y = (DWORD) (y - 1);
  365.     wattr = attr;
  366.     WriteConsoleOutputCharacterA(HOutput, &ch, 1, coord, &len);
  367.     WriteConsoleOutputAttribute(HOutput, &wattr, 1, coord, &len);
  368. }
  369.  
  370. void vm_xputs(char x, char y, char attr, char *str)
  371. {
  372.     DWORD i, len;
  373.     COORD coord;
  374.     LPWORD pwattr;
  375.     pwattr = malloc(strlen(str) * sizeof(*pwattr));
  376.     if (!pwattr)
  377.     {
  378.         return;
  379.     }
  380.     coord.X = (DWORD) (x - 1);
  381.     coord.Y = (DWORD) (y - 1);
  382.     for (i = 0; i < strlen(str); i++)
  383.     {
  384.         *(pwattr + i) = attr;
  385.     }
  386.     WriteConsoleOutputCharacterA(HOutput, str, (DWORD) strlen(str), coord, &len);
  387.     WriteConsoleOutputAttribute(HOutput, pwattr, (DWORD) strlen(str), coord, &len);
  388.     free(pwattr);
  389. }
  390.  
  391. void vm_putattr(char x, char y, char attr)
  392. {
  393.     DWORD len;
  394.     COORD coord;
  395.     WORD wattr;
  396.     coord.X = (DWORD) (x - 1);
  397.     coord.Y = (DWORD) (y - 1);
  398.     wattr = attr;
  399.     WriteConsoleOutputAttribute(HOutput, &wattr, 1, coord, &len);
  400. }
  401.  
  402. void vm_paintclearbox(char x1, char y1, char x2, char y2, char attr)
  403. {
  404.     COORD coord;
  405.     LPWORD pwattr;
  406.     char y, *pstr;
  407.     DWORD i, len, width;
  408.     width = (x2 - x1 + 1);
  409.     pwattr = malloc(width * sizeof(*pwattr));
  410.     if (!pwattr)
  411.     {
  412.         return;
  413.     }
  414.     pstr = malloc(width);
  415.     if (!pstr)
  416.     {
  417.         free(pwattr);
  418.         return;
  419.     }
  420.     for (i = 0; i < width; i++)
  421.     {
  422.         *(pwattr + i) = attr;
  423.         *(pstr + i) = ' ';
  424.     }
  425.     for (y = y1; y <= y2; y++)
  426.     {
  427.         coord.X = (DWORD) (x1 - 1);
  428.         coord.Y = (DWORD) (y - 1);
  429.         WriteConsoleOutputCharacterA(HOutput, pstr, width, coord, &len);
  430.         WriteConsoleOutputAttribute(HOutput, pwattr, width, coord, &len);
  431.     }
  432.     free(pwattr);
  433.     free(pstr);
  434. }
  435.  
  436. void vm_paintbox(char x1, char y1, char x2, char y2, char attr)
  437. {
  438.     DWORD i, len, width;
  439.     COORD coord;
  440.     LPWORD pwattr;
  441.     char y;
  442.     width = (x2 - x1 + 1);
  443.     pwattr = malloc(width * sizeof(*pwattr));
  444.     if (!pwattr)
  445.     {
  446.         return;
  447.     }
  448.     for (i = 0; i < width; i++)
  449.     {
  450.         *(pwattr + i) = attr;
  451.     }
  452.     for (y = y1; y <= y2; y++)
  453.     {
  454.         coord.X = (DWORD) (x1 - 1);
  455.         coord.Y = (DWORD) (y - 1);
  456.         WriteConsoleOutputAttribute(HOutput, pwattr, width, coord, &len);
  457.     }
  458.     free(pwattr);
  459. }
  460.  
  461. void vm_clearbox(char x1, char y1, char x2, char y2)
  462. {
  463.     vm_fillbox(x1, y1, x2, y2, ' ');
  464. }
  465.  
  466. void vm_fillbox(char x1, char y1, char x2, char y2, char ch)
  467. {
  468.     DWORD i, len, width;
  469.     COORD coord;
  470.     char y, *pstr;
  471.     width = (x2 - x1 + 1);
  472.     pstr = malloc(width);
  473.     if (!pstr)
  474.     {
  475.         return;
  476.     }
  477.     for (i = 0; i < width; i++)
  478.     {
  479.         *(pstr + i) = ch;
  480.     }
  481.     for (y = y1; y <= y2; y++)
  482.     {
  483.         coord.X = (DWORD) (x1 - 1);
  484.         coord.Y = (DWORD) (y - 1);
  485.         WriteConsoleOutputCharacterA(HOutput, pstr, width, coord, &len);
  486.     }
  487.     free(pstr);
  488. }
  489.  
  490. void vm_gettext(char x1, char y1, char x2, char y2, char *dest)
  491. {
  492.     DWORD i, len, width;
  493.     COORD coord;
  494.     LPWORD pwattr;
  495.     char y, *pstr;
  496.     width = (x2 - x1 + 1);
  497.     pwattr = malloc(width * sizeof(*pwattr));
  498.     if (!pwattr)
  499.     {
  500.         return;
  501.     }
  502.     pstr = malloc(width);
  503.     if (!pstr)
  504.     {
  505.         free(pwattr);
  506.         return;
  507.     }
  508.     for (y = y1; y <= y2; y++)
  509.     {
  510.         coord.X = (DWORD) (x1 - 1);
  511.         coord.Y = (DWORD) (y - 1);
  512.         ReadConsoleOutputCharacterA(HOutput, pstr, width, coord, &len);
  513.         ReadConsoleOutputAttribute(HOutput, pwattr, width, coord, &len);
  514.         for (i = 0; i < width; i++)
  515.         {
  516.             *dest = *(pstr + i);
  517.             dest++;
  518.             *dest = (char)*(pwattr + i);
  519.             dest++;
  520.         }
  521.     }
  522.     free(pwattr);
  523.     free(pstr);
  524. }
  525.  
  526. void vm_puttext(char x1, char y1, char x2, char y2, char *srce)
  527. {
  528.     DWORD i, len, width;
  529.     COORD coord;
  530.     LPWORD pwattr;
  531.     char y, *pstr;
  532.     width = (x2 - x1 + 1);
  533.     pwattr = malloc(width * sizeof(*pwattr));
  534.     if (!pwattr)
  535.     {
  536.         return;
  537.     }
  538.     pstr = malloc(width);
  539.     if (!pstr)
  540.     {
  541.         free(pwattr);
  542.         return;
  543.     }
  544.     for (y = y1; y <= y2; y++)
  545.     {
  546.         for (i = 0; i < width; i++)
  547.         {
  548.             *(pstr + i) = *srce;
  549.             srce++;
  550.             *(pwattr + i) = *srce;
  551.             srce++;
  552.         }
  553.         coord.X = (DWORD) (x1 - 1);
  554.         coord.Y = (DWORD) (y - 1);
  555.         WriteConsoleOutputCharacterA(HOutput, pstr, width, coord, &len);
  556.         WriteConsoleOutputAttribute(HOutput, pwattr, width, coord, &len);
  557.     }
  558.     free(pwattr);
  559.     free(pstr);
  560. }
  561.  
  562. void vm_horizline(char x1, char x2, char row, char attr, char ch)
  563. {
  564.     char x;
  565.     for (x = x1; x <= x2; x++)
  566.     {
  567.         vm_xputch(x, row, attr, ch);
  568.     }
  569. }
  570.