home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 26 / CD_ASCQ_26_1295.iso / vrac / user_int.zip / WINDOW.CPP < prev   
C/C++ Source or Header  |  1995-07-30  |  7KB  |  378 lines
  1. #include <conio.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <bios.h>
  6.  
  7. int video_mode(void);
  8. void goto_xy(int x, int y);
  9. void set_v_ptr();
  10. void write_char(int x, int y, char ch, int attrib);
  11. void write_string(int x, int y, char *p, int attrib);
  12.  
  13. const enum clr { black, blue, green, cyan, red, magenta,
  14.          brown, lightgray, darkgray, lightblue,
  15.          lightgreen, lightcyan, lightred,
  16.          lightmagenta, yellow, white, blink=128 };
  17.  
  18. int vmode;
  19. char far *vid_mem;
  20.  
  21. class wintype {
  22. int leftx;
  23. int upy;
  24. int rightx;
  25. int downy;
  26. int border;
  27. int active;
  28. char *title;
  29.  
  30. int curx, cury;
  31.  
  32. char *buf;
  33.  
  34. char color;
  35.  
  36. void save_screen();
  37. void restore_screen();
  38. void draw_border();
  39. void display_title();
  40. public:
  41.   wintype(int lx, int uy,
  42.       int rx, int ly,
  43.       int b = 1,
  44.       char *mess = ""
  45.   );
  46.   ~wintype() {winremove(); delete buf;};
  47.  
  48.   void winput();
  49.   void winremove();
  50.   int winputs(char *s);
  51.   int winxy(int x, int y);
  52.   void wincls();
  53.   void wincleol();
  54.   void line_border();
  55.   int getx();
  56.   int gety();
  57.   void movex();
  58.   void resetxy();
  59.   void wcout(int x, int y, char *string);
  60.   void setcolor(char c) {color = c;}
  61.   char getcolor() {return color;}
  62.   void setbkcolor(char c) {color = color | (c<<4);}
  63.   char getbkcolor() {return (color>>4) & 127;}
  64.  
  65.   friend wintype &operator<<(wintype &o, char *s);
  66. };
  67. wintype::wintype(int lx, int uy,
  68.          int rx, int ly,
  69.          int b,
  70.          char *mess
  71.   )
  72. {
  73.   if(lx<0) lx = 0;
  74.   if(rx>79) rx = 79;
  75.   if(uy<0) uy = 0;
  76.   if(ly>24) ly = 24;
  77.   leftx = lx; upy = uy;
  78.   rightx = rx; downy = ly;
  79.   border = b;
  80.   title = mess;
  81.   active = 0;
  82.   curx = cury = 0;
  83.  
  84.   buf = new char[2*(rightx-leftx+1)*(downy-upy+1)];
  85.   if(!buf) {
  86.     clrscr();
  87.     _setcursortype(_NORMALCURSOR);
  88.     printf("Memory Allocation error\n");
  89.     exit(1);
  90.   }
  91.   color = white;
  92.  }
  93. void wintype::winput()
  94. {
  95.   if(!active) {
  96.   save_screen();
  97.   active = 1;
  98.  }
  99.   else return;
  100.  
  101.   if(border) draw_border();
  102.   display_title();
  103.  
  104.   goto_xy(leftx + curx + 1, upy + cury + 1);
  105.  }
  106. void wintype::winremove()
  107. {
  108.   if(!active) return;
  109.  
  110.   restore_screen();
  111.   active = 0;
  112.  }
  113. void wintype::draw_border()
  114. {
  115.   register int i;
  116.   char far *v, far *t;
  117.  
  118.   v = vid_mem;
  119.   t = v;
  120.   for(i=leftx+1; i<rightx; i++) {
  121.       v += (upy*160) + i*2;
  122.       *v++ = 255;
  123.       *v = color;
  124.       v = t;
  125.       v += (downy*160) + i*2;
  126.       *v++ = 255;
  127.       *v = color;
  128.       v = t;
  129.  }
  130.  for(i=upy+1; i<downy; i++) {
  131.      v += (i*160) + leftx*2;
  132.      *v++ = 255;
  133.      *v = color;
  134.      v = t;
  135.      v += (i*160) + rightx*2;
  136.      *v++ = 255;
  137.      *v = color;
  138.      v = t;
  139.  }
  140. write_char(leftx, upy, 255, color);
  141. write_char(leftx, downy, 255, color);
  142. write_char(rightx, upy, 255, color);
  143. write_char(rightx, downy, 255, color);
  144. write_char(rightx, upy+1, 255, color);
  145. write_char(rightx, downy-1, 255, color);
  146. }
  147. void wintype::display_title()
  148. {
  149.   register int x, len;
  150.  
  151.   x = leftx;
  152.   len = strlen(title);
  153.   len = (rightx - x - len) / 2;
  154.   if(len<0) return;
  155.   x = x + len + 1;
  156.  
  157.   write_string(x, upy, title, color);
  158.  }
  159. void wintype::save_screen()
  160. {
  161.   register int i, j;
  162.   char *buf_ptr;
  163.   char far *v, far *t;
  164.  
  165.   buf_ptr = buf;
  166.   v = vid_mem;
  167.   for(i=upy; i<downy+1; i++)
  168.     for(j=leftx; j<rightx+1; j++) {
  169.        t = (v + (i*160) + j*2);
  170.        *buf_ptr++ = *t++;
  171.        *buf_ptr++ = *t;
  172.        *(t-1) = ' ';
  173.      }
  174.  }
  175. void wintype::restore_screen()
  176. {
  177.   register int i, j;
  178.   char far *v, far *t;
  179.   char *buf_ptr;
  180.  
  181.   buf_ptr = buf;
  182.   v = vid_mem;
  183.   t = v;
  184.   for(i=upy; i<downy+1; i++)
  185.     for(j=leftx; j<rightx+1; j++) {
  186.        v = t;
  187.        v += (i*160) + j*2;
  188.        *v++ = *buf_ptr++;
  189.        *v = *buf_ptr++;
  190.      }
  191.  }
  192. int wintype::winputs(char *s)
  193. {
  194.   register int x, y;
  195.   char far *v;
  196.  
  197.   if(!active) return 0;
  198.    x = curx + leftx + 1;
  199.    y = cury + upy + 1;
  200.  
  201.    v = vid_mem;
  202.    v += (y*160) + x*2;
  203.  
  204.    for( ; *s; s++) {
  205.      if(y >= downy) {
  206.        return 1;
  207.      }
  208.      if(x >= rightx) {
  209.       return 1;
  210.      }
  211.      if(*s=='\n') {
  212.        y++;
  213.        x = leftx+1;
  214.        v = vid_mem;
  215.        v += (y*160) + x*2;
  216.        cury++;
  217.        curx = 0;
  218.       }
  219.      else {
  220.        curx++;
  221.        x++;
  222.        *v++ = *s;
  223.        *v++ = color;
  224.       }
  225.      winxy(curx, cury);
  226.    }
  227.    return 1;
  228.  }
  229. void wintype::line_border()
  230. {
  231.   register int i;
  232.   char far *v, far *t;
  233.  
  234.   v = vid_mem;
  235.   t = v;
  236.   for(i=leftx+1; i<rightx; i++) {
  237.       v += (upy*160) + i*2;
  238.       *v++ = 196;
  239.       *v = color;
  240.       v = t;
  241.       v += (downy*160) + i*2;
  242.       *v++ = 196;
  243.       *v = color;
  244.       v = t;
  245.  }
  246.  for(i=upy+1; i<downy; i++) {
  247.      v += (i*160) + leftx*2;
  248.      *v++ = 179;
  249.      *v = color;
  250.      v = t;
  251.      v += (i*160) + rightx*2;
  252.      *v++ = 179;
  253.      *v = color;
  254.      v = t;
  255.  }
  256. write_char(leftx, upy, 218, color);
  257. write_char(leftx, downy, 192, color);
  258. write_char(rightx, upy, 191, color);
  259. write_char(rightx, downy, 217, color);
  260. }
  261. int wintype::winxy(int x, int y)
  262. {
  263.   if(x<0 || x+leftx >= rightx-1)
  264.     return 0;
  265.   if(y<0 || y+upy >= downy-1)
  266.     return 0;
  267.   curx = x;
  268.   cury = y;
  269.   goto_xy(leftx+x+1, upy+y+1);
  270.   return 1;
  271.  }
  272. int wintype::getx()
  273. {
  274.   return curx;
  275.  }
  276. int wintype::gety()
  277. {
  278.   return cury;
  279.  }
  280. void wintype::movex()
  281. {
  282.   curx++;
  283.  }
  284. void wintype::resetxy()
  285. {
  286.   winxy(curx=leftx, cury+1);
  287.  }
  288. void wintype::wcout(int x, int y, char *string)
  289. {
  290.   write_string(leftx-1+x,upy-1+y,string,color);
  291.  }
  292. void wintype::wincls()
  293. {
  294.   register int i, j;
  295.   char far *v, far *t;
  296.  
  297.   v = vid_mem;
  298.   t = v;
  299.   for(i=upy+1; i<downy; i++)
  300.     for(j=leftx+1; j<rightx; j++) {
  301.       v = t;
  302.       v += (i*160) + j*2;
  303.       *v++ = ' ';
  304.       *v = color;
  305.     }
  306.   curx = 0;
  307.   cury = 0;
  308.  }
  309. void wintype:: wincleol()
  310. {
  311.   register int i, x, y;
  312.  
  313.   x = curx;
  314.   y = cury;
  315.   winxy(curx, cury);
  316.  
  317.   for(i=curx; i<rightx-1; i++)
  318.     winputs(" ");
  319.   winxy(x, y);
  320.  }
  321. wintype &operator<<(wintype &o, char *s)
  322. {
  323.   o.winputs(s);
  324.   return o;
  325.  }
  326. void set_v_ptr()
  327. {
  328.   vmode = video_mode();
  329.   if((vmode!=2) && (vmode!=3) && (vmode!=7)) {
  330.     printf("video must be in 80 column text mode");
  331.     exit(1);
  332.    }
  333.   if(vmode==7)
  334.   { vid_mem = (char far *) 0xB0000000;
  335.    }
  336.   else
  337.   { vid_mem = (char far *) 0xB8000000;
  338.    }
  339.  }
  340. video_mode(void)
  341. {
  342.   union REGS r;
  343.  
  344.   r.h.ah = 15;
  345.   return int86(0x10, &r, &r) & 255;
  346.  }
  347. void write_char(int x, int y, char ch, int attrib)
  348. {
  349.   char far *v;
  350.  
  351.   v = vid_mem;
  352.   v += (y*160) + x*2;
  353.   *v++ = ch;
  354.   *v = attrib;
  355.  }
  356. void goto_xy(int x, int y)
  357. {
  358.   union REGS r;
  359.  
  360.   r.h.ah = 2;
  361.   r.h.dl = x;
  362.   r.h.dh = y;
  363.   r.h.bh = 0;
  364.   int86(0x10, &r, &r);
  365.  }
  366. void write_string(int x, int y, char *p, int attrib)
  367. {
  368.   register int i;
  369.   char far *v;
  370.  
  371.   v = vid_mem;
  372.   v += (y*160) + x*2;
  373.   for(i=y; *p; i++) {
  374.     *v++ = *p++;
  375.     *v++ = attrib;
  376.    }
  377.  }
  378.