home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / snip9707.zip / VIDMGR.C < prev    next >
C/C++ Source or Header  |  1997-07-05  |  6KB  |  219 lines
  1. /* +++Date last modified: 05-Jul-1997 */
  2.  
  3. /*
  4.  *  VIDMGR.C; Screen drawing, cursor and keyboard routines for text mode
  5.  *            16-bit and 32-bit MS-DOS, 16-bit and 32-bit OS/2, and 32-bit
  6.  *            Windows 95/NT applications.  Release 1.3.
  7.  *
  8.  *  This module written in March 1996 by Andrew Clarke and released to the
  9.  *  public domain.  Last modified in October 1996.
  10.  *
  11.  *  VidMgr has been compiled and tested with the following C compilers:
  12.  *
  13.  *    - Borland C++ (16-bit) for DOS 3.1
  14.  *    - Borland C++ (16-bit) for DOS 4.5
  15.  *    - Borland C++ (32-bit) for OS/2 1.0
  16.  *    - Cygnus GNU C (32-bit) for Windows 95/NT b14.0
  17.  *    - DJGPP GNU C (32-bit) for DOS 2.0
  18.  *    - EMX GNU C (32-bit) for OS/2 & DOS 0.9b
  19.  *    - IBM VisualAge C/C++ 3.0 (32-bit) for OS/2
  20.  *    - Microsoft C/C++ (16-bit) for OS/2 6.00a
  21.  *    - Microsoft C/C++ (16-bit) for DOS 8.00c
  22.  *    - Microsoft Quick C (16-bit) for DOS 2.50
  23.  *    - Microsoft Visual C/C++ (16-bit) for DOS 1.52
  24.  *    - WATCOM C/C++ (16-bit & 32-bit) for DOS 9.5
  25.  *    - WATCOM C/C++ (16-bit & 32-bit) for DOS 10.0
  26.  *    - WATCOM C/C++ (32-bit) for OS/2 10.0
  27.  *    - WATCOM C/C++ (32-bit) for Windows 95/NT 10.0
  28.  *    - HI-TECH Pacific C (16-bit) for DOS 7.51
  29.  *    - Symantec C/C++ (16-bit) for DOS 7.0
  30.  *    - Zortech C/C++ (16-bit) for DOS 3.0r4
  31.  */
  32.  
  33. #include <stdio.h>
  34. #include <stdarg.h>
  35. #include <string.h>
  36. #include "vidmgr.h"
  37.  
  38. struct vm_info vm_startup;
  39. char vm_curattr;
  40.  
  41. char vm_frame_blank[] = "      ";
  42. char vm_frame_single[] = "┌─┐│└┘";
  43. char vm_frame_double[] = "╔═╗║╚╝";
  44.  
  45. void vm_setattr(char attr)
  46. {
  47.     vm_curattr = attr;
  48. }
  49.  
  50. void vm_printf(char x, char y, const char *format,...)
  51. {
  52.     va_list args;
  53.     char buffer[512];
  54.     va_start(args, format);
  55.     vsprintf(buffer, format, args);
  56.     va_end(args);
  57.     vm_puts(x, y, buffer);
  58. }
  59.  
  60. void vm_printfcenter(char row, const char *format,...)
  61. {
  62.     va_list args;
  63.     char buffer[512];
  64.     va_start(args, format);
  65.     vsprintf(buffer, format, args);
  66.     va_end(args);
  67.     vm_puts((char)((vm_getscreenwidth() / 2) - (strlen(buffer) / 2)), row, buffer);
  68. }
  69.  
  70. void vm_printfbetween(char x1, char x2, char row, const char *format,...)
  71. {
  72.     char x;
  73.     va_list args;
  74.     char buffer[512];
  75.     va_start(args, format);
  76.     vsprintf(buffer, format, args);
  77.     va_end(args);
  78.     if ((char)strlen(buffer) >= (char)(x2 - x1 + 1))
  79.     {
  80.         vm_puts(x1, row, buffer);
  81.     }
  82.     else
  83.     {
  84.         x = (char)(x1 + (x2 - x1 + 1 - strlen(buffer)) / 2);
  85.         vm_puts(x, row, buffer);
  86.     }
  87. }
  88.  
  89. void vm_xprintf(char x, char y, char attr, const char *format,...)
  90. {
  91.     va_list args;
  92.     char buffer[512];
  93.     va_start(args, format);
  94.     vsprintf(buffer, format, args);
  95.     va_end(args);
  96.     vm_xputs(x, y, attr, buffer);
  97. }
  98.  
  99. void vm_xprintfcenter(char row, char attr, const char *format,...)
  100. {
  101.     va_list args;
  102.     char buffer[512];
  103.     va_start(args, format);
  104.     vsprintf(buffer, format, args);
  105.     va_end(args);
  106.     vm_xputs((char)((vm_getscreenwidth() / 2) - (strlen(buffer) / 2)), row, attr, buffer);
  107. }
  108.  
  109. void vm_xprintfbetween(char x1, char x2, char row, char attr, const char *format,...)
  110. {
  111.     char x;
  112.     va_list args;
  113.     char buffer[512];
  114.     va_start(args, format);
  115.     vsprintf(buffer, format, args);
  116.     va_end(args);
  117.     if ((char)strlen(buffer) >= (char)(x2 - x1 + 1))
  118.     {
  119.         vm_xputs(x1, row, attr, buffer);
  120.     }
  121.     else
  122.     {
  123.         x = (char)(x1 + (x2 - x1 + 1 - strlen(buffer)) / 2);
  124.         vm_xputs(x, row, attr, buffer);
  125.     }
  126. }
  127.  
  128. void vm_paintclearscreen(char attr)
  129. {
  130.     vm_paintclearbox(1, 1, vm_getscreenwidth(), vm_getscreenheight(), attr);
  131. }
  132.  
  133. void vm_paintclearline(char row, char attr)
  134. {
  135.     vm_paintclearbox(1, row, vm_getscreenwidth(), row, attr);
  136. }
  137.  
  138. void vm_paintcleareol(char row, char attr)
  139. {
  140.     vm_paintclearbox(vm_wherex(), row, (char)(vm_getscreenwidth() - vm_wherex() + 1), row, attr);
  141. }
  142.  
  143. void vm_paintscreen(char attr)
  144. {
  145.     vm_paintbox(1, 1, vm_getscreenwidth(), vm_getscreenheight(), attr);
  146. }
  147.  
  148. void vm_paintline(char row, char attr)
  149. {
  150.     vm_paintbox(1, row, vm_getscreenwidth(), row, attr);
  151. }
  152.  
  153. void vm_painteol(char row, char attr)
  154. {
  155.     vm_paintbox(vm_wherex(), row, (char)(vm_getscreenwidth() - vm_wherex() + 1), row, attr);
  156. }
  157.  
  158. void vm_clearscreen(void)
  159. {
  160.     vm_clearbox(1, 1, vm_getscreenwidth(), vm_getscreenheight());
  161. }
  162.  
  163. void vm_clearline(char row)
  164. {
  165.     vm_clearbox(1, row, vm_getscreenwidth(), row);
  166. }
  167.  
  168. void vm_cleareol(char row)
  169. {
  170.     vm_clearbox(vm_wherex(), row, (char)(vm_getscreenwidth() - vm_wherex() + 1), row);
  171. }
  172.  
  173. void vm_fillscreen(char ch)
  174. {
  175.     vm_fillbox(1, 1, vm_getscreenwidth(), vm_getscreenheight(), ch);
  176. }
  177.  
  178. void vm_fillline(char row, char ch)
  179. {
  180.     vm_fillbox(1, row, vm_getscreenwidth(), row, ch);
  181. }
  182.  
  183. void vm_filleol(char row, char ch)
  184. {
  185.     vm_fillbox(vm_wherex(), row, (char)(vm_getscreenwidth() - vm_wherex() + 1), row, ch);
  186. }
  187.  
  188. void vm_clrscr(void)
  189. {
  190.     vm_paintclearscreen(vm_curattr);
  191.     vm_gotoxy(1, 1);
  192. }
  193.  
  194. void vm_clreol(void)
  195. {
  196.     vm_paintcleareol(vm_wherey(), vm_curattr);
  197. }
  198.  
  199. void vm_vertline(char y1, char y2, char col, char attr, char ch)
  200. {
  201.     char y;
  202.     for (y = y1; y <= y2; y++)
  203.     {
  204.         vm_xputch(col, y, attr, ch);
  205.     }
  206. }
  207.  
  208. void vm_frame(char x1, char y1, char x2, char y2, char attr, char *frame)
  209. {
  210.     vm_xputch(x1, y1, attr, frame[0]);
  211.     vm_horizline((char)(x1 + 1), (char)(x2 - 1), y1, attr, frame[1]);
  212.     vm_xputch(x2, y1, attr, frame[2]);
  213.     vm_vertline((char)(y1 + 1), (char)(y2 - 1), x1, attr, frame[3]);
  214.     vm_vertline((char)(y1 + 1), (char)(y2 - 1), x2, attr, frame[3]);
  215.     vm_xputch(x1, y2, attr, frame[4]);
  216.     vm_horizline((char)(x1 + 1), (char)(x2 - 1), y2, attr, frame[1]);
  217.     vm_xputch(x2, y2, attr, frame[5]);
  218. }
  219.