home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c072 / 1.ddi / PRG7_5.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-09-19  |  7.5 KB  |  274 lines
  1. /*Prg7_5 - Open/Close Screen Windows
  2.     by Stephen R. Davis, 1987
  3.  
  4.   Example of using our screen writing skills to open and close
  5.   windows on the screen
  6. */
  7.  
  8. #include <stdio.h>
  9. #include <dos.h>
  10. #include <stdlib.h>
  11. #include <process.h>
  12.  
  13. /*define screen parameters*/
  14. #define height 25
  15. #define width 80
  16. #define cga  (unsigned far *)0xb8000000    /*same for ega*/
  17. #define mono (unsigned far *)0xb0000000
  18.  
  19. /*define screen BIOS functions*/
  20. #define setcursor 0x02
  21. #define getmode 0x0f
  22.  
  23. /*define the colors - 'b'ackground and 'f'oreground*/
  24. #define bred   0x4000
  25. #define bgreen 0x2000
  26. #define bblue  0x1000
  27. #define bwhite bred+bgreen+bblue
  28. #define fred   0x0400
  29. #define fgreen 0x0200
  30. #define fblue  0x0100
  31. #define fwhite fblue+fgreen+fred
  32.  
  33. /*type definitions*/
  34. struct WINDOW {
  35.                unsigned x0, y0;        /*upper, left hand corner*/
  36.                unsigned x1, y1;        /*lower, right hand corner*/
  37.               };
  38.  
  39. /*our prototype definitions*/
  40. void main (void);
  41. char gtcr (struct WINDOW *, char *);
  42. void openwindow  (struct WINDOW *, unsigned *, unsigned);
  43. void closewindow (struct WINDOW *, unsigned *);
  44. void wscroll (struct WINDOW *, unsigned);
  45. void wprintf (struct WINDOW *, char *);
  46. void wpcursor (struct WINDOW *, unsigned, unsigned);
  47. void init (void);
  48.  
  49. /*data definitions*/
  50. union REGS regs;
  51. unsigned far *screen;
  52. typedef unsigned SCREEN [height * width + 5];
  53. unsigned windowwidth, windowheight, color;
  54. unsigned v_pos, h_pos;
  55.  
  56. /*Main - exercise the window routines*/
  57.  
  58. struct WINDOW full = { 0, 0, 79, 24};
  59. struct WINDOW win1 = {10, 5, 60, 20};
  60. struct WINDOW win2 = {20, 0, 40, 24};
  61. SCREEN buff1, buff2;
  62.  
  63. void main (void)
  64. {
  65.      unsigned i;
  66.  
  67.      /*initialize the works*/
  68.      init ();
  69.  
  70.      /*put pattern up before opening first window*/
  71.      for (i = 1; i < height; i++)
  72.           wprintf (&full, "***************************************"
  73.                           "***************************************\n");
  74.      wpcursor (&full, 0, 0);
  75.  
  76.      /*open first window with pattern and then scroll it*/
  77.      gtcr (&full, "This is the main screen\n"
  78.                   "Press Enter key to open first window");
  79.      openwindow (&win1, buff1, bred+fwhite);
  80.      for (i = 1; i < 50; i++)
  81.           wprintf (&win1, "Window #1   ---    scrolling\n\n");
  82.  
  83.      /*now open window #2 and scroll it also*/
  84.      gtcr (&win1, "Press Enter key for #2");
  85.      openwindow (&win2, buff2, bblue+fgreen);
  86.      for (i = 1; i < 50; i++)
  87.           wprintf (&win2, "Window #2 --\n"
  88.                           "          scrolling\n\n");
  89.  
  90.      /*now, prepare to close*/
  91.      gtcr (&win2, "Press Enter key");
  92.      closewindow (&win2, buff2);
  93.      gtcr (&win1, "Press Enter key");
  94.      closewindow (&win1, buff1);
  95. }
  96.  
  97. /*Gtcr - output a prompt and then await a character response*/
  98. char gtcr (window, prompt)
  99.      struct WINDOW *window;
  100.      char *prompt;
  101. {
  102.      char buffer [80];
  103.  
  104.      /*build the message string and write it into current window*/
  105.      sprintf (buffer, "%s :\n", prompt);
  106.      wprintf (window, buffer);
  107.  
  108.      /*now await a response*/
  109.      return (char)getchar ();
  110. }
  111.  
  112. /*Openwindow - save off a specified box from the screen and set
  113.                to a box of the given box*/
  114. void openwindow (window, buffer, fill)
  115.      struct WINDOW *window;
  116.      unsigned *buffer, fill;
  117. {
  118.      unsigned line, column, far *screenptr;
  119.  
  120.      /*first save the cursor and window info*/
  121.      *buffer++ = h_pos;
  122.      *buffer++ = v_pos;
  123.      *buffer++ = windowwidth;
  124.      *buffer++ = windowheight;
  125.      *buffer++ = color;
  126.  
  127.      /*now save off the window and cover it with 'fill'*/
  128.      for (line = window -> y0; line < window -> y1; line++) {
  129.           screenptr = screen + ((line * width) + window -> x0);
  130.           for (column = window -> x0; column < window ->x1;
  131.                          column++, screenptr++, buffer++) {
  132.                *buffer = *screenptr;
  133.                *screenptr = fill;
  134.           }
  135.      }
  136.  
  137.      /*calculate new width and height*/
  138.      h_pos = 0;
  139.      v_pos = 0;
  140.      windowwidth  = window -> x1 - window -> x0;
  141.      windowheight = window -> y1 - window -> y0;
  142.      color = fill & 0xff00;
  143. }
  144.  
  145. /*Closewindow - restore the previously saved window to the screen*/
  146. void closewindow (window, buffer)
  147.      struct WINDOW *window;
  148.      unsigned *buffer;
  149. {
  150.      unsigned line, column, far *screenptr;
  151.  
  152.      /*first restore the cursor position and screen dimensions*/
  153.      h_pos = *buffer++;
  154.      v_pos = *buffer++;
  155.      windowwidth  = *buffer++;
  156.      windowheight = *buffer++;
  157.      color = *buffer++;
  158.  
  159.      /*now restore the window area of the screen*/
  160.      for (line = window -> y0; line < window -> y1; line++) {
  161.           screenptr = screen + ((line * width) + window -> x0);
  162.           for (column = window -> x0; column < window ->x1; column++)
  163.                *screenptr++ = *buffer++;
  164.      }
  165. }
  166.  
  167. /*WScroll - scroll current window up N lines*/
  168.  
  169. #define SCREENLOC(y,x) screen + ((width * (y + window -> y0)) \
  170.                               +  (window -> x0 + x))
  171.  
  172. void wscroll (window, nlines)
  173.     struct WINDOW *window;
  174.     unsigned nlines;
  175. {
  176.     unsigned far *source, far *dest, number, i, j;
  177.  
  178.     if (nlines >= windowheight)
  179.          nlines = windowheight;
  180.  
  181.     h_pos = 0;
  182.     if ((v_pos += nlines) >= windowheight) {
  183.          nlines = (v_pos - windowheight) + 1;
  184.  
  185.          /*scroll the screen up 'nlines' amount*/
  186.          number = windowheight - nlines;
  187.          for (i = 0; i < number; i++) {
  188.               source = SCREENLOC (i + nlines, 0);
  189.               dest   = SCREENLOC (i, 0);
  190.               for (j = 0; j < windowwidth; j++)
  191.                    *dest++ = *source++;
  192.          }
  193.  
  194.      /*now blank the lines abandoned*/
  195.          for (i = number; i < windowheight; i++)
  196.               dest = SCREENLOC (i, 0);
  197.           for (j = 0; j < windowwidth; j++)
  198.                *dest++ = color + 0x20;
  199.  
  200.          v_pos = windowheight - 1;
  201.     }
  202. }
  203.  
  204. /*Wprintf - output a string using the BIOS screen handler.  If
  205.         an attribute is not provided, use the default.*/
  206. void wprintf (window, c)
  207.     struct WINDOW *window;
  208.     char *c;
  209. {
  210.     unsigned far *sp;
  211.  
  212.     sp = SCREENLOC (v_pos, h_pos);
  213.     for (; *c; c++)
  214.          if (*c == '\n') {
  215.               wscroll (window, 1);
  216.               sp = SCREENLOC (v_pos, 0);
  217.          }
  218.          else
  219.               if (h_pos < windowwidth) {
  220.                    h_pos++;
  221.                *sp++ = color + *c;
  222.               }
  223.     wpcursor (window, v_pos, h_pos);
  224. }
  225.  
  226. /*WPCursor - place the cursor at the current x and y location.*/
  227. void wpcursor (window, y, x)
  228.     struct WINDOW *window;
  229.     unsigned x, y;
  230. {
  231.     v_pos = y;
  232.     h_pos = x;
  233.  
  234.     regs.h.ah = setcursor;
  235.     regs.h.bh = 0;
  236.     regs.h.dh = v_pos + window -> y0;
  237.     regs.h.dl = h_pos + window -> x0;
  238.     int86 (0x10, ®s, ®s);
  239. }
  240.  
  241. /*Init - set the screen address and clear the screen*/
  242. void init ()
  243. {
  244.     short mode;
  245.  
  246.     regs.h.ah = getmode;
  247.     int86 (0x10, ®s, ®s);
  248.     mode = regs.h.al;
  249.  
  250.     /*we are only set up for 80 column widths...*/
  251.     if (regs.h.ah != width)
  252.          abort ();
  253.  
  254.     /*...and one of the character modes*/
  255.     if (mode == 7)
  256.          screen = mono;
  257.     else
  258.          if (mode == 3 || mode == 2)
  259.               screen = cga;
  260.          else
  261.               abort ();
  262.  
  263.     /*now initialize the cursor and screen dimensions*/
  264.     windowheight = height;
  265.     windowwidth  = width;
  266.     color = fwhite;
  267.     h_pos = v_pos = 0;
  268.  
  269.     /*and clear the screen*/
  270.     wscroll (&full, height);
  271.     wpcursor (&full, 0, 0);
  272. }
  273.  
  274.