Category

Development Platform
Home > SourceCode/Document > Mathimatics-Numerical algorithms > View Code
_vga.c
Package: leda.tar.gz　[view]
Upload User: gzelex
Upload Date: 2007-01-07
Package Size: 707k
Code Size: 36k
Category:

Mathimatics-Numerical algorithms

Development Platform:

MultiPlatform

_vga.c：Code Content
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _vga.c
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  14. #include <LEDA/impl/doswin.h>
  16. /* 
  17.  * basic graphics routines in VGA mode 640x480x16
  18.  * (part of this code is based on "VGAlib" by Tommy Frandsen)
  19.  */
  21. #if defined(__EMX__)
  22. #include <sys/hw.h>
  23. #define port_out(value,port) _outp32(port,value)
  24. #define port_in(port)  _inp32(port)
  25. #else
  26. #if defined(__TURBOC__) || defined(__GNUG__)
  27. #define port_out(value,port) outportb(port,value)
  28. #define port_in(port)  inportb(port)
  29. #else
  30. #define port_out(value,port) outp(port,value)
  31. #define port_in(port)  inp(port)
  32. #endif
  33. #endif
  36. #if defined (__ZTC__) || defined(__TURBOC__)
  37. typedef unsigned char far* VIDEO_PTR;
  38. #else
  39. typedef unsigned char* VIDEO_PTR;
  40. #endif
  44. static VIDEO_PTR  VIDEO=0;
  45. static int LINE_BYTES = 80;
  47. #define FONT_SIZE  0x2000
  49. /* VGA index register ports */
  50. #define CRT_IC  0x3D4   /* CRT Controller Index - color emulation */
  51. #define CRT_IM  0x3B4   /* CRT Controller Index - mono emulation */
  52. #define ATT_IW  0x3C0   /* Attribute Controller Index & Data Write Register */
  53. #define GRA_I   0x3CE   /* Graphics Controller Index */
  54. #define SEQ_I   0x3C4   /* Sequencer Index */
  55. #define PEL_IW  0x3C8   /* PEL Write Index */
  56. #define PEL_IR  0x3C7   /* PEL Read Index */
  58. /* VGA data register ports */
  59. #define CRT_DC  0x3D5   /* CRT Controller Data Register - color emulation */
  60. #define CRT_DM  0x3B5   /* CRT Controller Data Register - mono emulation */
  61. #define ATT_R   0x3C1   /* Attribute Controller Data Read Register */
  62. #define GRA_D   0x3CF   /* Graphics Controller Data Register */
  63. #define SEQ_D   0x3C5   /* Sequencer Data Register */
  64. #define MIS_R   0x3CC   /* Misc Output Read Register */
  65. #define MIS_W   0x3C2   /* Misc Output Write Register */
  66. #define IS1_RC  0x3DA   /* Input Status Register 1 - color emulation */
  67. #define IS1_RM  0x3BA   /* Input Status Register 1 - mono emulation */
  68. #define PEL_D   0x3C9   /* PEL Data Register */
  70. /* VGA indexes max counts */
  71. #define CRT_C   24      /* 24 CRT Controller Registers */
  72. #define ATT_C   21      /* 21 Attribute Controller Registers */
  73. #define GRA_C   9       /* 9  Graphics Controller Registers */
  74. #define SEQ_C   5       /* 5  Sequencer Registers */
  75. #define MIS_C   1       /* 1  Misc Output Register */
  77. /* VGA registers saving indexes */
  78. #define CRT     0               /* CRT Controller Registers start */
  79. #define ATT     CRT+CRT_C       /* Attribute Controller Registers start */
  80. #define GRA     ATT+ATT_C       /* Graphics Controller Registers start */
  81. #define SEQ     GRA+GRA_C       /* Sequencer Registers */
  82. #define MIS     SEQ+SEQ_C       /* General Registers */
  83. #define END     MIS+MIS_C       /* last */
  86. /* variables used to shift between monchrome and color emulation */
  87. static int CRT_I; /* current CRT index register address */
  88. static int CRT_D; /* current CRT data register address */
  89. static int IS1_R; /* current input status register address */
  90. static int color_text; /* true if color text emulation */
  93. /* BIOS mode 12h - 640x480x16 */
  94. static char g640x480x16_regs[60] = {
  95.   0x5F,0x4F,0x50,0x82,0x54,0x80,0x0B,0x3E,0x00,0x40,0x00,0x00,
  96.   0x00,0x00,0x00,0x00,0xEA,0x8C,0xDF,0x28,0x00,0xE7,0x04,0xE3,
  97.   0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,
  98.   0x0C,0x0D,0x0E,0x0F,0x01,0x00,0x0F,0x00,0x00,
  99.   0x00,0x0F,0x00,0x20,0x00,0x00,0x05,0x0F,0xFF,
  100.   0x03,0x01,0x0F,0x00,0x06,
  101.   0xE3
  102. };
  105. static char text_regs[60];   /* VGA registers for saved text mode */
  107. /* saved text mode palette values */
  108. static char text_red[256];
  109. static char text_green[256];
  110. static char text_blue[256];
  113. static int initialized = 0;
  115. static char font_buf1[FONT_SIZE];  /* saved font data - plane 2 */
  116. static char font_buf2[FONT_SIZE];  /* saved font data - plane 3 */
  119. static void set_regs(char regs[])
  120. {
  121.     int i;
  123.     /* disable video */
  124.     port_in(IS1_R);
  125.     port_out(0x00, ATT_IW);
  127.     /* update misc output register */
  128.     port_out(regs[MIS], MIS_W);
  130.     /* synchronous reset on */
  131.     port_out(0x00,SEQ_I);
  132.     port_out(0x01,SEQ_D);
  134.     /* write sequencer registers */
  135.     for (i = 1; i < SEQ_C; i++) {
  136. port_out(i, SEQ_I);
  137. port_out(regs[SEQ+i], SEQ_D);
  138.     }
  140.     /* synchronous reset off */
  141.     port_out(0x00, SEQ_I);
  142.     port_out(0x03, SEQ_D);
  144.     /* deprotect CRT registers 0-7 */
  145.     port_out(0x11, CRT_I);
  146.     port_out(port_in(CRT_D)&0x7F, CRT_D);
  148.     /* write CRT registers */
  149.     for (i = 0; i < CRT_C; i++) {
  150. port_out(i, CRT_I);
  151. port_out(regs[CRT+i], CRT_D);
  152.     }
  154.     /* write graphics controller registers */
  155.     for (i = 0; i < GRA_C; i++) {
  156. port_out(i, GRA_I);
  157. port_out(regs[GRA+i], GRA_D);
  158.     }
  160.     /* write attribute controller registers */
  161.     for (i = 0; i < ATT_C; i++) {
  162. port_in(IS1_R);   /* reset flip-flop */
  163. port_out(i, ATT_IW);
  164. port_out(regs[ATT+i],ATT_IW);
  165.     }
  166. }
  168. static void vga_initialize()
  169. {
  170.     int  i, j;
  171.     int mem_fd = -1;  /* /dev/mem file descriptor      */
  173.     if (initialized) return;
  175.     initialized = 1;
  178. #if defined(__EMX__)
  179.     _portaccess(0x300,0x3FF);
  180.     VIDEO = (VIDEO_PTR)_memaccess(0xa0000,0xaffff,1);
  181. #elif defined(__GNUC__)
  182.     VIDEO = (VIDEO_PTR)0xd0000000;
  183. #elif defined(__ZTC__)
  184.     VIDEO = (VIDEO_PTR)_x386_mk_protected_ptr(0xa0000);
  185. #elif defined(__WATCOMC__)
  186.     VIDEO = (VIDEO_PTR)0xa0000;
  187. #else
  188.     VIDEO = (VIDEO_PTR)MK_FP(0xa000,0);
  189. #endif
  192.     /* color or monochrome text emulation? */
  193.     color_text = port_in(MIS_R)&0x01;
  195.     /* chose registers for color/monochrome emulation */
  196.     if (color_text) {
  197. CRT_I = CRT_IC;
  198. CRT_D = CRT_DC;
  199. IS1_R = IS1_RC;
  200.     } else {
  201. CRT_I = CRT_IM;
  202. CRT_D = CRT_DM;
  203. IS1_R = IS1_RM;
  204.     }
  206.     /* disable video */
  207.     port_in(IS1_R);
  208.     port_out(0x00, ATT_IW);
  210.     /* save text mode palette - first select palette index 0 */
  211.     port_out(0, PEL_IR);
  213.     /* read RGB components - index is autoincremented */
  214.     for(i = 0; i < 256; i++) {
  215. for(j = 0; j < 10; j++) ;   /* delay (minimum 240ns) */
  216. text_red[i] = port_in(PEL_D);
  217. for(j = 0; j < 10; j++) ;   /* delay (minimum 240ns) */
  218. text_green[i] = port_in(PEL_D);
  219. for(j = 0; j < 10; j++) ;   /* delay (minimum 240ns) */
  220. text_blue[i] = port_in(PEL_D);
  221.     }
  223.     /* save text mode VGA registers */
  224.     for (i = 0; i < CRT_C; i++) {
  225.  port_out(i, CRT_I);
  226.  text_regs[CRT+i] = port_in(CRT_D);
  227.     }
  228.     for (i = 0; i < ATT_C; i++) {
  229.         port_in(IS1_R);
  230.          port_out(i, ATT_IW);
  231.          text_regs[ATT+i] = port_in(ATT_R);
  232.     }
  233.     for (i = 0; i < GRA_C; i++) {
  234.          port_out(i, GRA_I);
  235.          text_regs[GRA+i] = port_in(GRA_D);
  236.     }
  237.     for (i = 0; i < SEQ_C; i++) {
  238.          port_out(i, SEQ_I);
  239.          text_regs[SEQ+i] = port_in(SEQ_D);
  240.     }
  241.     text_regs[MIS] = port_in(MIS_R);
  243.     /* shift to color emulation */
  244.     CRT_I = CRT_IC;
  245.     CRT_D = CRT_DC;
  246.     IS1_R = IS1_RC;
  247.     port_out(port_in(MIS_R)|0x01, MIS_W);
  249.     /* save font data - first select a 16 color graphics mode */
  250.     set_regs(g640x480x16_regs);
  252.     /* save font data in plane 2 */
  253.     port_out(0x04, GRA_I);
  254.     port_out(0x02, GRA_D);
  255.     for(i = 0; i < FONT_SIZE; i++) font_buf1[i] = VIDEO[i];
  257.     /* save font data in plane 3 */
  258.     port_out(0x04, GRA_I);
  259.     port_out(0x03, GRA_D);
  260.     for(i = 0; i < FONT_SIZE; i++) font_buf2[i] = VIDEO[i];
  261. }
  264. void set_palette(int index, int red, int green, int blue)
  265. {
  266.     volatile int i;
  268.     if (red < 0)     red = _R_[index]; else _R_[index] = red;
  269.     if (green < 0) green = _G_[index]; else _G_[index] = green;
  270.     if (blue < 0)   blue = _B_[index]; else _B_[index] = blue;
  273.     /* select palette register */
  274.     port_out(index, PEL_IW);
  276.     /* write RGB components */
  277.     for(i = 0; i < 10; i++) ;   /* delay (minimum 240ns) */
  278.     port_out(red, PEL_D);
  279.     for(i = 0; i < 10; i++) ;   /* delay (minimum 240ns) */
  280.     port_out(green, PEL_D);
  281.     for(i = 0; i < 10; i++) ;   /* delay (minimum 240ns) */
  282.     port_out(blue, PEL_D);
  283. }
  286. void get_palette(int index, int *red, int *green, int *blue)
  287. {
  288.     int i;
  290.     /* select palette register */
  291.     port_out(index, PEL_IR);
  293.     /* read RGB components */
  294.     for(i = 0; i < 10; i++) ;   /* delay (minimum 240ns) */
  295.     *red = (int) port_in(PEL_D);
  296.     for(i = 0; i < 10; i++) ;   /* delay (minimum 240ns) */
  297.     *green = (int) port_in(PEL_D);
  298.     for(i = 0; i < 10; i++) ;   /* delay (minimum 240ns) */
  299.     *blue = (int) port_in(PEL_D);
  300. }
  302. static void vga_clear(int c)
  303. {
  304.   register VIDEO_PTR p;
  305.   register VIDEO_PTR last;
  307.   /* set color c */
  308.   port_out(c, GRA_I );
  309.   port_out(0, GRA_D );
  311.   /* set mode 0 */
  312.   port_out(0x03, GRA_I );
  313.   port_out(0, GRA_D );
  315.   /* write to all bits */
  316.   port_out(0x08, GRA_I );
  317.   port_out(0xFF, GRA_D );
  319.   last  = VIDEO + DISP_HEIGHT*LINE_BYTES;
  321.   for(p = VIDEO; p < last; p++)  *p = 0;
  323. }
  326. void init_graphics(int mode, int root_col)  // mode = 0: Text, 1: 640x480x16 
  327. {
  328.     int i;
  330.     vga_initialize();
  331.     
  332.     if (mode == 0)  // TEXT
  333.       { 
  334.         vga_clear(0);
  336.         /* restore font data - first select a 16 color graphics mode */
  337.         set_regs(g640x480x16_regs);
  339. /* disable Set/Reset Register */
  340.      port_out(0x01, GRA_I );
  341.      port_out(0x00, GRA_D );
  343.         /* restore font data in plane 2 - necessary for all VGA's */
  344.      port_out(0x02, SEQ_I );
  345.      port_out(0x04, SEQ_D );
  346.         for(i = 0; i < FONT_SIZE; i++) VIDEO[i] = font_buf1[i];
  348.         /* restore font data in plane 3 - necessary for Trident VGA's */
  349.      port_out(0x02, SEQ_I );
  350.      port_out(0x08, SEQ_D );
  351.         for(i = 0; i < FONT_SIZE; i++) VIDEO[i] = font_buf2[i];
  353.         /* change register adresses if monochrome text mode */
  354.         if (!color_text) {
  355.             CRT_I = CRT_IM;
  356.             CRT_D = CRT_DM;
  357.             IS1_R = IS1_RM;
  358.             port_out(port_in(MIS_R)&0xFE, MIS_W);
  359.         }
  361. /* restore text mode VGA registers */
  362.      set_regs(text_regs);
  364.         /* restore saved palette */
  365.         for(i = 0; i < 256; i++)
  366.             set_palette(i, text_red[i], text_green[i], text_blue[i]);
  368.         DISP_WIDTH = 80;
  369.         DISP_MAX_X = 79;
  370.         DISP_HEIGHT= 25;
  371.         DISP_MAX_Y = 24;
  373.       }
  374.     else // graphics mode
  375.       { 
  376.         /* shift to color emulation */
  377.         CRT_I = CRT_IC;
  378.         CRT_D = CRT_DC;
  379.         IS1_R = IS1_RC;
  380.         port_out(port_in(MIS_R)|0x01, MIS_W);
  381.         set_regs(g640x480x16_regs);
  383.         /* set default palette */
  384.         for(i = 0; i < 16; i++)
  385.           set_palette(i, _R_[i], _G_[i], _B_[i]);
  387.         vga_clear(root_col);
  389.         LINE_BYTES = 80;
  390.         DISP_WIDTH = 640;
  391.         DISP_MAX_X = 639;
  392.         DISP_HEIGHT= 480;
  393.         DISP_MAX_Y = 479;
  394.         DISP_DEPTH = 4;
  395.       }
  397.     /* enable video */
  398.     port_in(IS1_R);
  399.     port_out(0x20, ATT_IW);
  401.     if (mode == 0)  // TEXT
  402.     { union REGISTERS regs;
  403.       regs.h.ah=0x00;
  404.       regs.h.al=0x02;
  405.       int_86(0x10,&regs,&regs);
  406.     }
  408. }
  413. //------------------------------------------------------------------------------
  414. //  basic graphic routines of libWx  declared in <LEDA/impl/x_basic.h>) 
  415. //  iplemented for MSDOS using the VGA 640x480x16 color graphics mode
  416. //------------------------------------------------------------------------------
  419. #if !defined(M_PI)
  420. #define M_PI   3.14159265358979323846
  421. #endif
  423. static VIDEO_PTR video_buf;
  424. static int COLOR = 1;
  425. static int MODE  = 0;
  426. static int LINEWIDTH = 1;
  427. static int LINESTYLE = 0;
  429. void flush_display() {}
  431. int  new_color(const char*) { return 1; }
  433. int  text_height(const char*)  { return FONT_HEIGHT; }
  434. int  text_width(const char* s) { return FONT_WIDTH*strlen(s); }
  436. int load_text_font(const char*) { return 0;}
  437. int load_bold_font(const char*) { return 0;}
  438. int load_message_font(const char*) { return 0;}
  440. int  set_font(const char*) { return 0;}
  441. void set_text_font() {}
  442. void set_bold_font() {}
  443. void set_message_font() {}
  445. int set_line_width(int width)
  446. { int save = LINEWIDTH;
  447.   LINEWIDTH = width;
  448.   return save;
  449. }
  451. int set_line_style(int style)
  452. { int save = LINESTYLE;
  453.   LINESTYLE = style;
  454.   return save;
  455. }
  457. int set_color(int color)
  458. {  int save = COLOR;
  459.    COLOR = color;
  460.    port_out(0x00, GRA_I );
  461.    port_out(color, GRA_D );
  462.    return save;
  463.  }
  465. int set_mode(int mode)
  466. { int save = MODE;
  468.   MODE = mode;
  470.   if (mode==1)         mode = 3; /* xor */
  471.   else if (mode==2)    mode = 2; /* or  */
  472.      else if (mode==3) mode = 1; /* and */
  473.                   else mode = 0; /* src */
  475.   port_out(0x03, GRA_I );
  476.   port_out(mode<<3, GRA_D );
  477.   return save;
  478. }
  480. void set_redraw(Window w, void (*f)())
  481. { win_stack[w]->redraw = f; }
  486. static void put_pixel(DosWindow win, int x, int y)
  487. { VIDEO_PTR p;
  489.   if (x < 0 || x >= win->width || y < 0 || y >= win->height) return;
  491.   x += win->xpos;
  492.   y += win->ypos;
  494.   if (x < 0 || x > DISP_MAX_X || y < 0 || y > DISP_MAX_Y) return;
  496.   if (VIDEO==0)   /* write into (monochrome) buffer */
  497.      video_buf[y*LINE_BYTES+(x>>3)] |= (0x80 >> (x & 7));
  498.   else
  499.   { p = VIDEO + y*LINE_BYTES + (x>>3);
  500.     port_out(8, GRA_I);
  501.     port_out((0x80 >> (x & 7)), GRA_D);
  502.     *p = *p;
  503.    }
  504. }
  506. static void vline(DosWindow win,int x, int y0, int y1)
  507. { register VIDEO_PTR p;
  508.   register VIDEO_PTR last;
  510.   if (y0 > y1)
  511.   { int y = y0;
  512.     y0 = y1;
  513.     y1 = y;
  514.    }
  516.   // clip into window
  517.   if (x < 0 || x >= win->width || y1 < 0 || y0 >= win->height) return;
  518.   if (y0 < 0) y0 = 0;
  519.   if (y1 >= win->height) y1 = win->height-1;
  521.   x  += win->xpos;
  522.   y0 += win->ypos;
  523.   y1 += win->ypos;
  525.   // clip into screen
  526.   if (x < 0 || x > DISP_MAX_X || y1 < 0 || y0 > DISP_MAX_Y) return;
  527.   if (y0 < 0) y0 = 0;
  528.   if (y1 > DISP_MAX_Y) y1 = DISP_MAX_Y;
  530.   port_out(8, GRA_I);
  531.   port_out(128 >> (x&7), GRA_D);
  532.   last  = VIDEO + LINE_BYTES*y1 + (x>>3);
  533.   for(p = VIDEO + LINE_BYTES*y0 + (x>>3); p <= last; p+=LINE_BYTES)  *p = *p;
  535. }
  538. static void hline(DosWindow win, int x0, int x1, int y)
  539. { register VIDEO_PTR p;
  540.   register VIDEO_PTR first;
  541.   register VIDEO_PTR last;
  542.   char byte;
  544.   if (x0 > x1)
  545.   { int x = x0;
  546.     x0 = x1;
  547.     x1 = x;
  548.    }
  550.   // clip into window
  551.   if (y < 0 || y >= win->height || x1 < 0 || x0 >= win->width) return;
  552.   if (x0 < 0) x0 = 0;
  553.   if (x1 >= win->width) x1 = win->width-1;
  555.   x0 += win->xpos;
  556.   x1 += win->xpos;
  557.   y  += win->ypos;
  559.   // clip into screen
  560.   if (y < 0 || y > DISP_MAX_Y || x1 < 0 || x0 > DISP_MAX_X) return;
  561.   if (x0 < 0) x0 = 0;
  562.   if (x1 > DISP_MAX_X) x1 = DISP_MAX_X;
  564.   first = VIDEO + LINE_BYTES*y + (x0>>3);
  565.   last  = VIDEO + LINE_BYTES*y + (x1>>3);
  567.   port_out(8, GRA_I);
  569.   if (first == last)
  570.   { byte  = 0xFF>>(x0&7);
  571.     byte &= 0xFF<<((~x1)&7);
  572.     port_out(byte, GRA_D);
  573.     *first = *first;
  574.     return;
  575.    }
  577.   port_out(0xFF>>(x0&7), GRA_D);
  578.   *first = *first;
  580.   port_out(0xFF<<((~x1)&7), GRA_D);
  581.   *last = *last;
  583.   port_out(0xFF, GRA_D);
  584.   for(p=first+1; p<last; p++) *p = *p;
  586.  }
  589. static void Draw_Line(DosWindow win, int x1, int y1, int x2, int y2)
  590. {
  591.   register int sy = 1;
  592.   register int dx = x2 - x1;
  593.   register int dy = y2 - y1;
  594.   register int c;
  595.   int i;
  597.   if (dx < 0)
  598.   { int i = x1;
  599.     x1 = x2;
  600.     x2 = i;
  601.     dx = -dx;
  602.     i = y1;
  603.     y1 = y2;
  604.     y2 = i;
  605.     dy = -dy;
  606.    }
  607.   if (dy < 0)
  608.   { dy = -dy;
  609.     sy = -1;
  610.    }
  612.   if (dx > dy)
  613.   { c = dx / 2;
  614.     put_pixel(win,x1,y1);
  615.     for (i=1; i<=LINEWIDTH/2; i++)
  616.     { put_pixel(win,x1,y1+i);
  617.       put_pixel(win,x1,y1-i);
  618.      }
  619.     while(x1 != x2)
  620.     { x1++;
  621.       c += dy;
  622.       if (c >= dx)
  623.       { c -= dx;
  624.         y1 += sy;
  625.        }
  626.       put_pixel(win,x1,y1);
  627.       for (i=1; i<=LINEWIDTH/2; i++)
  628.       { put_pixel(win,x1,y1+i);
  629.         put_pixel(win,x1,y1-i);
  630.        }
  631.     }
  632.   }
  633.   else
  634.   { c = dy / 2;
  635.     put_pixel(win,x1,y1);
  636.     for (i=1; i<=LINEWIDTH/2; i++)
  637.     { put_pixel(win,x1+i,y1);
  638.       put_pixel(win,x1-i,y1);
  639.      }
  640.     while(y1 != y2)
  641.     { y1 += sy;
  642.       c += dx;
  643.       if (c >= dy)
  644.       { c -= dy;
  645.         x1++;
  646.        }
  647.       put_pixel(win,x1,y1);
  648.       for (i=1; i<=LINEWIDTH/2; i++)
  649.       { put_pixel(win,x1+i,y1);
  650.         put_pixel(win,x1-i,y1);
  651.        }
  652.     }
  653.   }
  654. }
  656. void line(Window w, int x1, int y1, int x2, int y2)
  657. { int i;
  659.   DosWindow win = win_stack[w];
  661.   if (x1 == x2)
  662.   { vline(win,x1,y1,y2);
  663.     for (i=1; i<=LINEWIDTH/2; i++)
  664.     { vline(win,x1-i,y1,y2);
  665.       vline(win,x1+i,y1,y2);
  666.      }
  667.     return;
  668.    }
  670.   if (y1 == y2)
  671.   { hline(win,x1,x2,y1);
  672.     for (i=1; i<=LINEWIDTH/2; i++)
  673.     { hline(win,x1,x2,y1-i);
  674.       hline(win,x1,x2,y1+i);
  675.      }
  676.     return;
  677.    }
  679.   Draw_Line(win,x1,y1,x2,y2);
  680. }
  684. static int get_pixel(int x, int y)
  685. {
  686.   register int bit = 0x80 >> (x&7);
  687.   register VIDEO_PTR byte = VIDEO + LINE_BYTES*y+(x>>3);
  688.   register int c;
  690.   if (x < 0 || x > DISP_MAX_X || y < 0 || y > DISP_MAX_Y) return 0;
  692.   /* set read mode 1 */
  693.   port_out(5, GRA_I);
  694.   port_out(8, GRA_D);
  696.   for(c=0; c<16; c++)
  697.   { port_out(2, GRA_I);
  698.     port_out(c, GRA_D);
  699.     if (*byte & bit)  break;
  700.    }
  702.   return c;
  703. }
  706. #define FILLPUT(pos,byte)
  707. { p = pos;
  708.   if ((*p & (byte)) == 0)
  709.   { *p |= (byte);
  710.     POS[top] = p; 
  711.     BYTE[top] = byte; 
  712.     top = (top+1) % 512; } else;
  713. }
  715. static  VIDEO_PTR      POS[512];
  716. static  unsigned char  BYTE[512];
  718. static void fill_bits(VIDEO_PTR pos,unsigned char byte)
  719. { register int bot = 0;
  720.   register int top = 0;
  721.   register VIDEO_PTR p;
  723.   FILLPUT(pos,byte)
  725.   while (top != bot)
  726.   { pos  = POS[bot];
  727.     byte = BYTE[bot];
  729.     bot = (bot+1) % 512;
  731.     if (byte == 128)
  732.        FILLPUT(pos-1,1)
  733.     else
  734.        FILLPUT(pos,byte<<1)
  736.     if (byte == 1)
  737.        FILLPUT(pos+1,128)
  738.     else
  739.        FILLPUT(pos,byte>>1)
  741.     FILLPUT(pos-LINE_BYTES,byte)
  742.     FILLPUT(pos+LINE_BYTES,byte)
  743.   }
  744. }
  746. static  VIDEO_PTR  POS1[512];
  747. static  int pos_top = 0;
  749. void fill_bytes(VIDEO_PTR pos, int d)
  750. { VIDEO_PTR p = pos+d;
  752.   unsigned char c = *p;
  753.   unsigned char pat = 0xFF;
  755.   if (c == 0)
  756.   { *p = 0xFF;
  757.     fill_bytes(p,  1);
  758.     fill_bytes(p, -1);
  759.     fill_bytes(p, LINE_BYTES);
  760.     fill_bytes(p,-LINE_BYTES);
  761.     return;
  762.    }
  764.   if (d == -1)
  765.   { while((c&1) == 0)
  766.     { pat <<= 1;
  767.       c >>= 1;
  768.      }
  769.     *p |= ~pat;
  770.    }
  772.   if (d == 1)
  773.   { while((c&128) == 0)
  774.     { pat >>= 1;
  775.       c <<= 1;
  776.      }
  777.     *p |= ~pat;
  778.    }
  780.   if((c&8) == 0 && (d == LINE_BYTES || d == -LINE_BYTES))   POS1[pos_top++] = p;
  782.  }
  785. void fill_polygon(Window w, int n, int* xcoord, int* ycoord)
  786. {
  787.   DosWindow win = win_stack[w];
  789.   register VIDEO_PTR p;
  790.   register VIDEO_PTR q;
  791.   register VIDEO_PTR first;
  792.   register VIDEO_PTR first1;
  793.   register VIDEO_PTR last;
  795.   int i,m1,m2;
  796.   int minxi = 0;
  797.   int maxxi = 0;
  798.   int minyi = 0;
  799.   int maxyi = 0;
  800.   int minx,maxx,miny,maxy,x,y;
  802.   VIDEO_PTR video_save = VIDEO;
  804.   VIDEO = 0;
  806.   video_buf = (VIDEO_PTR)malloc(LINE_BYTES*480);
  809.   for(i=1;i<n;i++)
  810.   { minxi = (xcoord[i] < xcoord[minxi]) ? i : minxi;
  811.     minyi = (ycoord[i] < ycoord[minyi]) ? i : minyi;
  812.     maxxi = (xcoord[i] > xcoord[maxxi]) ? i : maxxi;
  813.     maxyi = (ycoord[i] > ycoord[maxyi]) ? i : maxyi;
  814.    }
  816.   minx = (xcoord[minxi] + win->xpos)/8;
  817.   maxx = (xcoord[maxxi] + win->xpos)/8;
  818.   miny = ycoord[minyi] + win->ypos;
  819.   maxy = ycoord[maxyi] + win->ypos;
  821.   m1 =  (minxi == 0)   ?  n-1 : minxi-1;
  822.   m2 =  (minxi == n-1) ?  0   : minxi+1;
  824.   for(i=miny; i<=maxy; i++)
  825.   { last = video_buf+LINE_BYTES*i + maxx;
  826.     for(p=video_buf+LINE_BYTES*i+minx; p<=last; p++) *p= 0;
  827.    }
  829.   for(i=0; i<n-1; i++)
  830.       Draw_Line(win,xcoord[i],ycoord[i],xcoord[i+1],ycoord[i+1]);
  832.   Draw_Line(win,xcoord[0],ycoord[0],xcoord[n-1],ycoord[n-1]);
  834.   x = (xcoord[m1] + xcoord[m2] + xcoord[minxi])/3 + win->xpos;
  835.   y = (ycoord[m1] + ycoord[m2] + ycoord[minxi])/3 + win->ypos;
  837.   pos_top = 0;
  838.   fill_bytes(video_buf + LINE_BYTES*y + x/8,0);
  840.   while (pos_top--) fill_bits(POS1[pos_top],8);
  842.   fill_bits(video_buf+LINE_BYTES*y+x/8,128>>(x%8));
  844.   VIDEO = video_save;
  846.   first  = video_buf+LINE_BYTES*miny + minx;
  847.   first1 = VIDEO+LINE_BYTES*miny + minx;
  848.   last   = video_buf+LINE_BYTES*miny + maxx;
  850.   port_out(8, GRA_I);
  852.   while(miny <= maxy)
  853.   { for(p=first, q = first1; p<=last; p++, q++)
  854.     { port_out(*p, GRA_D);
  855.       *q = *q;
  856.      }
  857.     first  += LINE_BYTES;
  858.     first1 += LINE_BYTES;
  859.     last   += LINE_BYTES;
  860.     miny++;
  861.    }
  863.   free((char*)video_buf);
  864. }
  867. void box(Window w, int x0, int y0, int x1, int y1)
  868. { DosWindow win = win_stack[w];
  869.   if (y0 > y1)
  870.   { int y = y0;
  871.     y0 = y1;
  872.     y1 = y;
  873.    }
  874.   while(y0<=y1) hline(win,x0,x1,y0++);
  875.  }
  878. void  rectangle(Window w, int x0, int y0, int x1, int y1)
  879. { 
  880.   int left  = x0;
  881.   int right = x1;
  882.   int top   = y0;
  883.   int bottom= y1;
  885.   if (x0 > x1)
  886.   { left  = x1;
  887.     right = x0;
  888.    }
  890.   if (y0 > y1)
  891.   { top  = y1;
  892.     bottom = y0;
  893.    }
  895.   line(w,left, top,     right,top);
  896.   line(w,left, bottom,  right,bottom);
  897.   line(w,left, bottom-1,left, top+1);
  898.   line(w,right,bottom-1,right,top+1);
  899. }
  902. void circle(Window w, int x0,int y0,int r0)
  903. { DosWindow win = win_stack[w];
  904.   int r;
  906.   for (r = r0-LINEWIDTH/2; r <= r0+LINEWIDTH/2; r++)
  907.   { int y = r;
  908.     int x = 0;
  909.     int e = 3-2*y;
  911.     put_pixel(win,x0,y0+r);
  912.     put_pixel(win,x0,y0-r);
  913.     put_pixel(win,x0+r,y0);
  914.     put_pixel(win,x0-r,y0);
  916.     for (x=1;x<y;)
  917.       { put_pixel(win,x0+x,y0+y);
  918.         put_pixel(win,x0+x,y0-y);
  919.         put_pixel(win,x0-x,y0+y);
  920.         put_pixel(win,x0-x,y0-y);
  921.         put_pixel(win,x0+y,y0+x);
  922.         put_pixel(win,x0+y,y0-x);
  923.         put_pixel(win,x0-y,y0+x);
  924.         put_pixel(win,x0-y,y0-x);
  925.         x++;
  926.         if (e>=0) { y--; e = e - 4*y; }
  927.         e = e + 4*x + 2;
  928.        }
  930.     if (x == y)
  931.     { put_pixel(win,x0+x,y0+y);
  932.       put_pixel(win,x0+x,y0-y);
  933.       put_pixel(win,x0-x,y0+y);
  934.       put_pixel(win,x0-x,y0-y);
  935.      }
  936.   }
  937. }
  940. void fill_circle(Window w, int x0, int y0, int r)
  941. { DosWindow win = win_stack[w];
  942.   int y = 1;
  943.   int x = r;
  944.   int e = 3-2*r;
  946.   hline(win,x0-x,x0+x,y0);
  948.   while (y<=x)
  949.   { hline(win,x0-x,x0+x,y0+y);
  950.     hline(win,x0-x,x0+x,y0-y);
  952.     if (y<x && e>=0)
  953.     { hline(win,x0-y,x0+y,y0+x);
  954.       hline(win,x0-y,x0+y,y0-x);
  955.       x--;
  956.       e = e - 4*x;
  957.      }
  958.     y++;
  959.     e = e + 4*y + 2;
  960.    }
  961. }
  965. static void Put_Text(DosWindow win, int x, int y, const char *str, int bg_col)
  966. { /* bgcol = -1 : transparent */
  967.   register unsigned char *fp1;
  968.   register unsigned char *fp2;
  969.   register unsigned char c;
  971.   register VIDEO_PTR start;
  972.   register VIDEO_PTR stop;
  973.   register VIDEO_PTR q;
  975.   char text[128];
  977.   int  len = strlen(str);
  978.   int xmin = win->xpos;
  979.   int ymin = win->ypos;
  980.   int xmax = xmin + win->width  - 1;
  981.   int ymax = ymin + win->height - 1;
  983.   if (xmin < 0) xmin = 0;
  984.   if (ymin < 0) ymin = 0;
  985.   if (xmax > DISP_MAX_X) xmax = DISP_MAX_X;
  986.   if (ymax > DISP_MAX_Y) ymax = DISP_MAX_Y;
  989.   if (bg_col >= 0)  // clear background
  990.   { int save_color = set_color(bg_col);
  991.     int save_mode = set_mode(0);
  992.     box(win->id,x,y,x+text_width(str)-1,y+FONT_HEIGHT-1);
  993.     set_mode(save_mode);
  994.     set_color(save_color);
  995.    }
  997.   x += win->xpos;
  998.   y += win->ypos;
  1000.   if (y < ymin || y > ymax || x > xmax) return;  // string not visible
  1002.   if (x < xmin) 
  1003.   { int pre = (xmin - x)/FONT_WIDTH + 1;
  1004.     if (pre >= len) return;
  1005.     str += pre;
  1006.     len -= pre;
  1007.     x = xmin;
  1008.   }
  1010.   int maxlen = (xmax-x)/FONT_WIDTH;
  1011.   if (len > maxlen) len = maxlen;
  1012.   if (len > 0) strncpy(text,str,len);
  1013.   text[len] = 0;
  1015.   int dy = ymax - y;
  1016.   if (dy > FONT_HEIGHT) dy = FONT_HEIGHT;
  1019.   fp1 = FONT + FONT_HEIGHT * ' ';
  1020.   fp2 = FONT + FONT_HEIGHT * (text[0] & 127);
  1022.   start = VIDEO + LINE_BYTES*y + x/8;
  1023.   stop = start + LINE_BYTES*dy;
  1025.   x &= 7;
  1027.   port_out(8, GRA_I);
  1029.   for(int i=0;i<len; i++)
  1030.   { for (q = start; q < stop; q+=LINE_BYTES, fp1++,fp2++)
  1031.     { c = ((*fp2)>>x) | ((*fp1)<<(8-x));
  1032.       port_out(c, GRA_D);
  1033.       *q = *q;
  1034.      }
  1035.     fp1 = FONT + FONT_HEIGHT * (text[i] & 127);
  1036.     fp2 = FONT + FONT_HEIGHT * (text[i+1] & 127);
  1037.     start++;
  1038.     stop++;
  1039.    }
  1041.   if (x > 0)
  1042.     for (q = start; q < stop; q+=LINE_BYTES, fp1++,fp2++)
  1043.     { c = (*fp1)<<(8-x);
  1044.       port_out(c, GRA_D);
  1045.       *q = *q;
  1046.      }
  1047. }
  1050. void put_text(Window w, int x, int y, const char *text, int opaque)
  1051. { DosWindow win = win_stack[w];
  1052.   Put_Text(win,x,y,text,opaque ? win->bg_col : -1);
  1053. }
  1055. void put_text(Window w, int x, int y, const char *text, int l, int opaque)
  1056. { DosWindow win = win_stack[w];
  1057.   //char* str = new char[l+1];
  1058.   //strncpy(str,text,l);
  1059.   char* str = new char[strlen(text)+1];
  1060.   strcpy(str,text);
  1061.   str[l] = '';
  1062.   Put_Text(win,x,y,str,opaque ? win->bg_col : -1); 
  1063.   delete[] str;
  1064. }
  1066. void put_ctext(Window w, int x, int y, const char* str, int opaque)
  1067. { put_text(w,x-(text_width(str)-1)/2, y-(text_height(str)-1)/2, str, opaque); }
  1070. void show_coordinates(Window w, const char* s)
  1071. { DosWindow win = win_stack[w];
  1072.   int save_mode = set_mode(0);
  1073.   int save_col  = set_color(4);
  1074.   put_text(w,win->width-138,1,s,1); 
  1075.   set_mode(save_mode);
  1076.   set_color(save_col);
  1077. }
  1081. void pixel(Window w, int x, int y) { put_pixel(win_stack[w],x,y);}
  1084. void pixels(Window w, int n, int* x, int* y)
  1085. { while(n--) put_pixel(win_stack[w],x[n],y[n]); }
  1088. void point(Window w, int x, int y) 
  1089. { DosWindow win = win_stack[w];
  1090.   put_pixel(win,x,y);
  1091.   put_pixel(win,x-2,y-2);
  1092.   put_pixel(win,x-1,y-1);
  1093.   put_pixel(win,x+1,y+1);
  1094.   put_pixel(win,x+2,y+2);
  1095.   put_pixel(win,x-2,y+2);
  1096.   put_pixel(win,x-1,y+1);
  1097.   put_pixel(win,x+1,y-1);
  1098.   put_pixel(win,x+2,y-2);
  1099. }
  1103. #define put_arc_pixel(X,Y,x,y,top) { X[top] = x; Y[top] = y; top++; }
  1105. void arc(Window w, int x0, int y0, int r1, int r2, double start, double angle)
  1106. { DosWindow win = win_stack[w];
  1107.   int* X = new int[10*r1];
  1108.   int* Y = new int[10*r2];
  1109.   int r;
  1111.  x0 += win->xpos;
  1112.  y0 += win->ypos;
  1114.  if (angle < 0)
  1115.  { start += angle;
  1116.    angle *= -1;
  1117.   }
  1119.  if (angle > 2*M_PI) angle = 2*M_PI;
  1121.  while (start < 0) start += 2*M_PI;
  1123.  for (r = r1-LINEWIDTH/2; r <= r1+LINEWIDTH/2; r++)
  1124.  { int y = r;
  1125.    int x = 0;
  1126.    int e = 3-2*y;
  1127.    int top = 0;
  1128.    int high;
  1129.    int high1;
  1130.    int s,l;
  1131.    float L;
  1132.    int i;
  1134.    while (x < y)
  1135.    { put_arc_pixel(X,Y,x,y,top);
  1136.      x++;
  1137.      if (e>=0) { y--; e -= 4*y; }
  1138.      e += 4*x + 2;
  1139.     }
  1141.    high = top-1;
  1143.    if (x==y) put_arc_pixel(X,Y,x,y,top);
  1145.    high1 = top;
  1147.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y, Y[i],-X[i],top);
  1148.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y, X[i],-Y[i],top);
  1149.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y,-X[i],-Y[i],top);
  1150.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y,-Y[i],-X[i],top);
  1151.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y,-Y[i], X[i],top);
  1152.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y,-X[i], Y[i],top);
  1153.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y, X[i], Y[i],top);
  1154.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y, Y[i], X[i],top);
  1156.    L = (top - high1)/(2*M_PI);
  1157.    s = high1 - 1 + (int)(start*L);
  1158.    l = s + (int)(angle*L);
  1160.    if (l >= top)
  1161.    { for(i=s; i < top; i++) put_pixel(win,x0+X[i],y0+Y[i]);
  1162.      s = high - 1;
  1163.      l = s + l - top;
  1164.     }
  1165.    for(i=s; i < l; i++) put_pixel(win,x0+X[i],y0+Y[i]);
  1166.   }
  1168.   delete X;
  1169.   delete Y;
  1170. }
  1173. static void ellipse_point(DosWindow win, int x0, int y0, int x, int y)
  1174. { put_pixel(win,x0+x,y0+y);
  1175.   put_pixel(win,x0-x,y0+y);
  1176.   put_pixel(win,x0+x,y0-y);
  1177.   put_pixel(win,x0-x,y0-y);
  1178.  }
  1181. void ellipse(Window w, int x0, int y0, int a, int b)
  1182. { 
  1183.   /* Foley, van Dam, Feiner, Huges: Computer Graphics, page 90 */
  1185.   DosWindow win = win_stack[w];
  1187.   double d1,d2;
  1188.   int x,y;
  1189.   int a_2 = a*a;
  1190.   int b_2 = b*b;
  1192.   put_pixel(win,x0,y0-b);
  1193.   put_pixel(win,x0,y0+b);
  1194.   put_pixel(win,x0-a,y0);
  1195.   put_pixel(win,x0+a,y0);
  1197.   x = 0;
  1198.   y = b;
  1200.   d1 = b*b + a*a*(0.25 - b); 
  1201.    
  1202.   while (a_2*(y - 0.5) > b_2*(x+1))
  1203.   { if (d1 < 0)
  1204.       d1 += b_2*(2*x + 3);
  1205.     else
  1206.     { d1 += b_2*(2*x + 3) + a_2*(2 - 2*y);
  1207.       y--;
  1208.      }
  1209.     x++;
  1210.     ellipse_point(win,x0,y0,x,y);
  1211.   }
  1213.   d2 = b_2*(x+0.5)*(x+0.5) + a_2*(y - 1)*(y - 1) - a_2*b_2;
  1215.   while (y > 1)
  1216.   { if (d2 < 0)
  1217.      { d2 += b_2*(2*x+2)+a_2*(3-2*y);
  1218.        x++;
  1219.       }
  1220.     else
  1221.        d2 += a*a*(3-2*y);
  1223.     y--;
  1225.     ellipse_point(win,x0,y0,x,y);
  1226.    }
  1227. }
  1230. void fill_ellipse(Window w, int x0, int y0, int a, int b)
  1231. { DosWindow win = win_stack[w];
  1232.   double d1,d2;
  1233.   int x,y;
  1234.   int a_2 = a*a;
  1235.   int b_2 = b*b;
  1237.   x = 0;
  1238.   y = b;
  1240.   d1 = b*b + a*a*(0.25 - b); 
  1241.    
  1242.   while (a_2*(y - 0.5) > b_2*(x+1))
  1243.   { if (d1 < 0)
  1244.       d1 += b_2*(2*x + 3);
  1245.     else
  1246.     { d1 += b_2*(2*x + 3) + a_2*(2 - 2*y);
  1247.       hline(win,x0-x,x0+x,y0+y);
  1248.       hline(win,x0-x,x0+x,y0-y);
  1249.       y--;
  1250.      }
  1251.     x++;
  1252.   }
  1253.   hline(win,x0-x,x0+x,y0+y);
  1254.   hline(win,x0-x,x0+x,y0-y);
  1256.   d2 = b_2*(x+0.5)*(x+0.5) + a_2*(y - 1)*(y - 1) - a_2*b_2;
  1258.   while (y > 1)
  1259.   { if (d2 < 0)
  1260.      { d2 += b_2*(2*x+2)+a_2*(3-2*y);
  1261.        x++;
  1262.       }
  1263.     else
  1264.        d2 += a*a*(3-2*y);
  1266.     y--;
  1268.     hline(win,x0-x,x0+x,y0+y);
  1269.     hline(win,x0-x,x0+x,y0-y);
  1270.    }
  1272.   hline(win,x0-x,x0+x,y0);
  1274. }
  1277. void fill_arc(Window,int,int,int,int,double,double)
  1278. { }
  1282. void copy_pixrect(Window w,int left,int top,int right,int bottom,int x,int y)
  1283. { 
  1284.   DosWindow win = win_stack[w];
  1285.   int width = right-left+1;
  1286.   int height = bottom-top+1;
  1288.   left += win->xpos; 
  1289.   top  += win->ypos; 
  1290.   x    += win->xpos; 
  1291.   y    += win->ypos; 
  1292.  
  1293.   register VIDEO_PTR first1;
  1294.   register VIDEO_PTR first;
  1295.   register VIDEO_PTR last1;
  1296.   register VIDEO_PTR last;
  1297.   register VIDEO_PTR p;
  1298.   register VIDEO_PTR q;
  1299.   int i;
  1302.   if(x < 0) 
  1303.   { left += x;
  1304.     width -= x;
  1305.     x = 0;
  1306.    }
  1308.   if(y < 0) 
  1309.   { top += y;
  1310.     height -= y;
  1311.     y = 0;
  1312.    }
  1314.   if(x+width > DISP_MAX_X) width = DISP_MAX_X - x;
  1316.   if(y+height > DISP_MAX_Y) height = DISP_MAX_Y - y;
  1318.   /* set write mode 1 */
  1319.   port_out(5, GRA_I);
  1320.   port_out(1, GRA_D);
  1322.   if (y <= top)
  1323.   { first1 = VIDEO + LINE_BYTES*y + x/8;
  1324.     last1  = VIDEO + LINE_BYTES*y + (x+width-1)/8;
  1325.     first  = VIDEO + LINE_BYTES*top + left/8;
  1326.     last   = VIDEO + LINE_BYTES*top + (left+width-1)/8;
  1327.    }
  1328.   else
  1329.   { first1 = VIDEO + LINE_BYTES*(y+height-1) + x/8;
  1330.     last1  = VIDEO + LINE_BYTES*(y+height-1) + (x+width-1)/8;
  1331.     first  = VIDEO + LINE_BYTES*(top+height-1) + left/8;
  1332.     last   = VIDEO + LINE_BYTES*(top+height-1) + (left+width-1)/8;
  1333.    }
  1335.   for(i=0; i<height; i++)
  1336.   { 
  1337.     if (x <= left)
  1338.       for(q=first, p=first1; q<=last; q++,p++) *p = *q;
  1339.     else
  1340.       for(q=last, p=last1; q>=first; q--,p--) *p = *q;
  1342.     if (y <= top)
  1343.     { first1 += LINE_BYTES;
  1344.       first  += LINE_BYTES;
  1345.       last1  += LINE_BYTES;
  1346.       last   += LINE_BYTES;
  1347.      }
  1348.     else
  1349.     { first1 -= LINE_BYTES;
  1350.       first  -= LINE_BYTES;
  1351.       last1  -= LINE_BYTES;
  1352.       last   -= LINE_BYTES;
  1353.      }
  1354.    }
  1356.   /* set write mode 0 */
  1357.   port_out(5, GRA_I);
  1358.   port_out(0, GRA_D);
  1360.  }
  1363. static char rev_byte(char c)
  1364. { char c1 = 0x00;
  1365.    for(int i=0; i<8; i++)
  1366.    { c1 <<= 1;
  1367.      if (c&1) c1 |= 1;
  1368.      c >>= 1;
  1369.     }
  1370.   return c1;
  1371. }
  1374. void insert_bitmap(Window w, int width, int height, char* data)
  1375. {
  1376.   register VIDEO_PTR first;
  1377.   register VIDEO_PTR last;
  1378.   register VIDEO_PTR q;
  1380.   DosWindow win = win_stack[w];
  1382.   int x = win->x0/8 + 1;
  1383.   int y = win->ypos;
  1385.   int wi = (width > win->width) ? win->width : width;
  1386.   int he = (height > win->height) ? win->height : height;
  1388.   first  = VIDEO + LINE_BYTES*y + x;
  1389.   last   = VIDEO + LINE_BYTES*y + x + wi/8 - 1;
  1391.   if (width % 8)
  1392.      width  = 1+ width/8;
  1393.   else
  1394.      width  = width/8;
  1396.   port_out(8, GRA_I);
  1398.   for(int i=0; i<he; i++)
  1399.   { char* p = data + i*width;
  1400.     for(q=first; q<=last; q++) 
  1401.     { port_out(rev_byte(*p++), GRA_D);
  1402.       *q = *q;
  1403.      }
  1404.     first += LINE_BYTES;
  1405.     last  += LINE_BYTES;
  1406.    }
  1407.  }
  1411. //------------------------------------------------------------------------------
  1412. // pixrects
  1413. //------------------------------------------------------------------------------
  1416. struct pixrect
  1417. { VIDEO_PTR plane[4];
  1418.   int width;
  1419.   int height;
  1420.   int bwidth;  // bytes
  1421. };
  1423. char* create_pixrect(Window w, int left, int top, int right, int bottom)
  1424. { 
  1425.   DosWindow win = win_stack[w];
  1426.   int xmax = win->xpos + win->width - 1;
  1427.   int ymax = win->ypos + win->height - 1;
  1429.   register int y;
  1430.   register VIDEO_PTR p;
  1431.   register VIDEO_PTR q;
  1432.   register VIDEO_PTR first;
  1433.   register VIDEO_PTR last;
  1436.   left   += win->xpos;
  1437.   right  += win->xpos;
  1438.   top    += win->ypos;
  1439.   bottom += win->ypos;
  1442.   if (right  > xmax) right = xmax;
  1443.   if (bottom > ymax) bottom = ymax;
  1445.   if(left < 0) left = 0;
  1446.   if(top  < 0) top = 0;
  1447.   if(right  > DISP_MAX_X) right = DISP_MAX_X;
  1448.   if(bottom > DISP_MAX_Y) bottom = DISP_MAX_Y;
  1451.   pixrect* bp = new pixrect;
  1453.   bp->width    = right-left+1;
  1454.   bp->height   = bottom-top+1;
  1455.   bp->bwidth   = right/8 - left/8 + 1;
  1456.   bp->plane[0] = (VIDEO_PTR)malloc(bp->bwidth * bp->height);
  1457.   bp->plane[1] = (VIDEO_PTR)malloc(bp->bwidth * bp->height);
  1458.   bp->plane[2] = (VIDEO_PTR)malloc(bp->bwidth * bp->height);
  1459.   bp->plane[3] = (VIDEO_PTR)malloc(bp->bwidth * bp->height);
  1462.   /* set read mode 0 */
  1463.   port_out(5, GRA_I);
  1464.   port_out(0, GRA_D);
  1466.   /* read planes 0 to 3 */
  1467.   for(int i=0; i<4; i++)
  1468.   { p = bp->plane[i];
  1470.     port_out(4, GRA_I);
  1471.     port_out(i, GRA_D);
  1473.     first = VIDEO + LINE_BYTES*top + left/8;
  1474.     last  = VIDEO + LINE_BYTES*top + right/8;
  1476.     for(y=top; y<=bottom; y++)
  1477.     { for(q=first; q<=last; q++) *p++ = *q;
  1478.       first  += LINE_BYTES;
  1479.       last   += LINE_BYTES;
  1480.      }
  1481.    }
  1482.   return (char*)bp;
  1483. }
  1486. void insert_pixrect(Window w, int left, int top, char* rect)
  1487. { register int y;
  1488.   register VIDEO_PTR p;
  1489.   register VIDEO_PTR q;
  1490.   register VIDEO_PTR pfirst;
  1491.   register VIDEO_PTR first;
  1492.   register VIDEO_PTR last;
  1494.   pixrect* bp = (pixrect*)rect; 
  1496.   DosWindow win = win_stack[w];
  1497.   int xmax = win->xpos + win->width - 1;
  1498.   int ymax = win->ypos + win->height - 1;
  1500.   left   += win->xpos;
  1501.   top    += win->ypos;
  1503.   if(left < 0) left = 0;
  1504.   if(top  < 0) top = 0;
  1506.   int right  = left + bp->width - 1;
  1507.   int bottom = top + bp->height - 1;
  1509.   if (right  > xmax) right = xmax;
  1510.   if (bottom > xmax) bottom = ymax;
  1512.   int save_mode = set_mode(0);
  1513.   int save_col  = set_color(0);
  1515.   // clean area
  1517.   port_out(8, GRA_I);
  1518.   port_out(0xFF, GRA_D);
  1519.   first  = VIDEO + LINE_BYTES*top + left/8;
  1520.   last   = VIDEO + LINE_BYTES*top + right/8;
  1521.   for(y=top; y<=bottom; y++)
  1522.   { for(q=first; q<=last; q++) *q = *q;
  1523.     first  += LINE_BYTES;
  1524.     last   += LINE_BYTES;
  1525.    }
  1528.   // fill in plane data
  1530.   set_mode(2); /* or */
  1532.   for(int i = 0; i < 4; i++)
  1533.   {
  1534.     set_color(1<<i);
  1536.     pfirst = bp->plane[i];
  1537.     first  = VIDEO + LINE_BYTES*top + left/8;
  1538.     last   = VIDEO + LINE_BYTES*top + right/8;
  1540.     port_out(8, GRA_I);
  1542.     for(y=top; y<=bottom; y++)
  1543.     { for(q=first,p=pfirst; q<=last; q++,p++) 
  1544.       { port_out(*p, GRA_D);
  1545.         *q = *q;
  1546.        }
  1547.       pfirst += bp->bwidth;
  1548.       first  += LINE_BYTES;
  1549.       last   += LINE_BYTES;
  1550.      }
  1551.    }
  1552.   
  1553.   set_mode(save_mode);
  1554.   set_color(save_col);
  1555. }
  1558. void delete_pixrect(char* rect)
  1559. { pixrect* bp =(pixrect*)rect;
  1560.   for(int i=0; i<4; i++) free((char*)(bp->plane[i]));
  1561.   delete bp;
  1562.  }
  1566. //------------------------------------------------------------------------------
  1567. // mouse cursor
  1568. //------------------------------------------------------------------------------
  1570. static unsigned char pointer_mask[2][2][14] = { 
  1571. {{0xc0,0xf0,0x7c,0x7f,0x3f,0x3f,0x1f,0x1f,0x0d,0x0c,0x00,0x00,0x00,0x00},
  1572.  {0x00,0x00,0x00,0x00,0xc0,0xc0,0x00,0x80,0xc0,0xe0,0x70,0x38,0x1c,0x0c}},
  1574. {{0x00,0x00,0x00,0x00,0x03,0x03,0x00,0x01,0x03,0x07,0x0e,0x1c,0x38,0x30},
  1575.  {0x03,0x0f,0x3e,0xfe,0xfc,0xfc,0xf8,0xf8,0xb0,0x30,0x00,0x00,0x00,0x00} }
  1576. };
  1579. static void pointer_pixel(int x, int y)
  1580. { if (x < 0 || x > DISP_MAX_X || y < 0 || y > DISP_MAX_Y) return;
  1581.   VIDEO_PTR p = VIDEO + y*LINE_BYTES + (x>>3);
  1582.   port_out(8, GRA_I);
  1583.   port_out((0x80 >> (x & 7)), GRA_D);
  1584.   *p = *p;
  1585. }
  1587. void draw_pointer(int mouse_x, int mouse_y, int shape)
  1588. {
  1589.   register int x1 = mouse_x % 8;
  1590.   register int x2 = 8-x1;
  1591.   register int x = mouse_x/8;
  1592.   VIDEO_PTR start = VIDEO + LINE_BYTES*mouse_y + x;
  1593.   register VIDEO_PTR q;
  1594.   register unsigned char c;
  1596.   set_color(black);
  1598.   if (shape == 1)
  1599.   { pointer_pixel(mouse_x-3,mouse_y);
  1600.     pointer_pixel(mouse_x-2,mouse_y);
  1601.     pointer_pixel(mouse_x-1,mouse_y);
  1602.     pointer_pixel(mouse_x,mouse_y);
  1603.     pointer_pixel(mouse_x+1,mouse_y);
  1604.     pointer_pixel(mouse_x+2,mouse_y);
  1605.     pointer_pixel(mouse_x+3,mouse_y);
  1606.     pointer_pixel(mouse_x,mouse_y-3);
  1607.     pointer_pixel(mouse_x,mouse_y-2);
  1608.     pointer_pixel(mouse_x,mouse_y-1);
  1609.     pointer_pixel(mouse_x,mouse_y+1);
  1610.     pointer_pixel(mouse_x,mouse_y+2);
  1611.     pointer_pixel(mouse_x,mouse_y+3);
  1612.     // circle(mouse_x,mouse_y,3);
  1613.     return;
  1614.    }
  1617.   int a = 0;
  1618.   int b = 14;
  1619.   int d = 1;
  1620.   int k = 0;
  1622.   if (mouse_y + 15 > DISP_MAX_Y) 
  1623.   { a = 13;
  1624.     b = -1;
  1625.     d = -1;
  1626.     start -= 14*LINE_BYTES;
  1627.    }
  1629.   if (x > 77) 
  1630.   { start -= 2;
  1631.     k = 1;
  1632.    }
  1634.   port_out(8, GRA_I);
  1636.   for(int i=a; i!=b; i+=d)
  1637.   { q = start;
  1638.     c = (pointer_mask[k][0][i]>>x1);
  1639.     port_out(c, GRA_D);
  1640.     *q = *q;
  1641.     ++q; 
  1642.     c = ((pointer_mask[k][1][i]>>x1) | (pointer_mask[k][0][i]<<x2));
  1643.     port_out(c, GRA_D);
  1644.     *q = *q;
  1645.     
  1646.     if (x2)
  1647.     { ++q;
  1648.       c = (pointer_mask[k][1][i]<<x2);
  1649.       port_out(c, GRA_D);
  1650.       *q = *q;
  1651.      }
  1652.     start+=LINE_BYTES;
  1653.    }
  1654. }