home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_src.lha / LEDA-3.1c-source / src / vga.old / _vgadraw.c next >
Encoding:
C/C++ Source or Header  |  1994-11-17  |  18.1 KB  |  928 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _vgadraw.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. /* basic graphic routines of libWx  declared in <LEDA/impl/x_basic.h>) 
  18.  * iplemented for MSDOS using the VGA 640x480x16 color graphics mode
  19.  */
  20.  
  21. #include "vgalib.h"
  22.  
  23. #include "vgafont"
  24.  
  25. static VIDEO_PTR video_buf;
  26. static int COLOR = 1;
  27. static int MODE  = 0;
  28. static int LINEWIDTH = 1;
  29. static int LINESTYLE = 0;
  30.  
  31.  
  32. void flush_display() {}
  33.  
  34. int  new_color(const char*) { return 1; }
  35.  
  36. int  text_height(const char*)  { return FONT_HEIGHT; }
  37. int  text_width(const char* s) { return FONT_WIDTH*strlen(s); }
  38.  
  39. int load_text_font(const char*) { return 0;}
  40. int load_bold_font(const char*) { return 0;}
  41. int load_message_font(const char*) { return 0;}
  42.  
  43. int  set_font(const char*) { return 0;}
  44. void set_text_font() {}
  45. void set_bold_font() {}
  46. void set_message_font() {}
  47.  
  48. int set_line_width(int width)
  49. { int save = LINEWIDTH;
  50.   LINEWIDTH = width;
  51.   return save;
  52. }
  53.  
  54. int set_line_style(int style)
  55. { int save = LINESTYLE;
  56.   LINESTYLE = style;
  57.   return save;
  58. }
  59.  
  60. int set_color(int color)
  61. {  int save = COLOR;
  62.    COLOR = color;
  63.    port_out(0x00, GRA_I );
  64.    port_out(color, GRA_D );
  65.    return save;
  66.  }
  67.  
  68. int set_mode(int mode)
  69. { int save = MODE;
  70.  
  71.   MODE = mode;
  72.  
  73.   if (mode==1)         mode = 3; /* xor */
  74.   else if (mode==2)    mode = 2; /* or  */
  75.      else if (mode==3) mode = 1; /* and */
  76.                   else mode = 0; /* src */
  77.  
  78.   port_out(0x03, GRA_I );
  79.   port_out(mode<<3, GRA_D );
  80.   return save;
  81. }
  82.  
  83.  
  84. static void put_pixel(Window win, int x, int y)
  85. { VIDEO_PTR p;
  86.  
  87.   if (x < 0 || x >= win->width || y < 0 || y >= win->height) return;
  88.  
  89.   x += win->xpos;
  90.   y += win->ypos;
  91.  
  92.   if (VIDEO==0)   /* write into (monochrome) buffer */
  93.      video_buf[y*LINE_BYTES+(x>>3)] |= (0x80 >> (x & 7));
  94.   else
  95.   { p = VIDEO + y*LINE_BYTES + (x>>3);
  96.     port_out(8, GRA_I);
  97.     port_out((0x80 >> (x & 7)), GRA_D);
  98.     *p = *p;
  99.    }
  100. }
  101.  
  102. static void vline(Window win,int x, int y0, int y1)
  103. { register VIDEO_PTR p;
  104.   register VIDEO_PTR last;
  105.  
  106.   if (y0 > y1)
  107.   { int y = y0;
  108.     y0 = y1;
  109.     y1 = y;
  110.    }
  111.  
  112.   if (x < 0 || x >= win->width || y1 < 0 || y0 >= win->height) return;
  113.  
  114.   if (y0 < 0) y0 = 0;
  115.   if (y1 >= win->height) y1 = win->height-1;
  116.  
  117.   x  += win->xpos;
  118.   y0 += win->ypos;
  119.   y1 += win->ypos;
  120.  
  121.   port_out(8, GRA_I);
  122.   port_out(128 >> (x&7), GRA_D);
  123.   last  = VIDEO + LINE_BYTES*y1 + (x>>3);
  124.   for(p = VIDEO + LINE_BYTES*y0 + (x>>3); p <= last; p+=LINE_BYTES)  *p = *p;
  125.  
  126. }
  127.  
  128.  
  129. void hline(Window win, int x0, int x1, int y)
  130. { register VIDEO_PTR p;
  131.   register VIDEO_PTR first;
  132.   register VIDEO_PTR last;
  133.   char byte;
  134.  
  135.   if (x0 > x1)
  136.   { int x = x0;
  137.     x0 = x1;
  138.     x1 = x;
  139.    }
  140.   if (y < 0 || y >= win->height || x1 < 0 || x0 >= win->width) return;
  141.   if (x0 < 0) x0 = 0;
  142.   if (x1 >= win->width) x1 = win->width-1;
  143.  
  144.   x0 += win->xpos;
  145.   x1 += win->xpos;
  146.   y  += win->ypos;
  147.  
  148.  
  149.   if (x0 > DISP_MAX_X  || y > DISP_MAX_Y || y < 0) return;
  150.  
  151.   if (x1 > DISP_MAX_X) x1 = DISP_MAX_X;
  152.   if (x0 < 0) x0 = 0;
  153.  
  154.   first = VIDEO + LINE_BYTES*y + (x0>>3);
  155.   last  = VIDEO + LINE_BYTES*y + (x1>>3);
  156.  
  157.   port_out(8, GRA_I);
  158.  
  159.   if (first == last)
  160.   { byte  = 0xFF>>(x0&7);
  161.     byte &= 0xFF<<((~x1)&7);
  162.     port_out(byte, GRA_D);
  163.     *first = *first;
  164.     return;
  165.    }
  166.  
  167.   port_out(0xFF>>(x0&7), GRA_D);
  168.   *first = *first;
  169.  
  170.   port_out(0xFF<<((~x1)&7), GRA_D);
  171.   *last = *last;
  172.  
  173.   port_out(0xFF, GRA_D);
  174.   for(p=first+1; p<last; p++) *p = *p;
  175.  
  176.  }
  177.  
  178.  
  179. static void Draw_Line(Window win, int x1, int y1, int x2, int y2)
  180. {
  181.   register int sy = 1;
  182.   register int dx = x2 - x1;
  183.   register int dy = y2 - y1;
  184.   register int c;
  185.   int i;
  186.  
  187.   if (dx < 0)
  188.   { int i = x1;
  189.     x1 = x2;
  190.     x2 = i;
  191.     dx = -dx;
  192.     i = y1;
  193.     y1 = y2;
  194.     y2 = i;
  195.     dy = -dy;
  196.    }
  197.   if (dy < 0)
  198.   { dy = -dy;
  199.     sy = -1;
  200.    }
  201.  
  202.   if (dx > dy)
  203.   { c = dx / 2;
  204.     put_pixel(win,x1,y1);
  205.     for (i=1; i<=LINEWIDTH/2; i++)
  206.     { put_pixel(win,x1,y1+i);
  207.       put_pixel(win,x1,y1-i);
  208.      }
  209.     while(x1 != x2)
  210.     { x1++;
  211.       c += dy;
  212.       if (c >= dx)
  213.       { c -= dx;
  214.         y1 += sy;
  215.        }
  216.       put_pixel(win,x1,y1);
  217.       for (i=1; i<=LINEWIDTH/2; i++)
  218.       { put_pixel(win,x1,y1+i);
  219.         put_pixel(win,x1,y1-i);
  220.        }
  221.     }
  222.   }
  223.   else
  224.   { c = dy / 2;
  225.     put_pixel(win,x1,y1);
  226.     for (i=1; i<=LINEWIDTH/2; i++)
  227.     { put_pixel(win,x1+i,y1);
  228.       put_pixel(win,x1-i,y1);
  229.      }
  230.     while(y1 != y2)
  231.     { y1 += sy;
  232.       c += dx;
  233.       if (c >= dy)
  234.       { c -= dy;
  235.         x1++;
  236.        }
  237.       put_pixel(win,x1,y1);
  238.       for (i=1; i<=LINEWIDTH/2; i++)
  239.       { put_pixel(win,x1+i,y1);
  240.         put_pixel(win,x1-i,y1);
  241.        }
  242.     }
  243.   }
  244. }
  245.  
  246. void line(Window win, int x1, int y1, int x2, int y2)
  247. { int i;
  248.  
  249.   if (x1 == x2)
  250.   { vline(win,x1,y1,y2);
  251.     for (i=1; i<=LINEWIDTH/2; i++)
  252.     { vline(win,x1-i,y1,y2);
  253.       vline(win,x1+i,y1,y2);
  254.      }
  255.     return;
  256.    }
  257.  
  258.   if (y1 == y2)
  259.   { hline(win,x1,x2,y1);
  260.     for (i=1; i<=LINEWIDTH/2; i++)
  261.     { hline(win,x1,x2,y1-i);
  262.       hline(win,x1,x2,y1+i);
  263.      }
  264.     return;
  265.    }
  266.  
  267.   Draw_Line(win,x1,y1,x2,y2);
  268. }
  269.  
  270.  
  271.  
  272. #define FILLPUT(pos,byte)\
  273. { p = pos;\
  274.   if ((*p & (byte)) == 0)\
  275.   { *p |= (byte);\
  276.     POS[top] = p; \
  277.     BYTE[top] = byte; \
  278.     top = (top+1) % 512; } else;\
  279. }
  280.  
  281. static  VIDEO_PTR      POS[512];
  282. static  unsigned char  BYTE[512];
  283.  
  284. static void fill_bits(VIDEO_PTR pos,unsigned char byte)
  285. { register int bot = 0;
  286.   register int top = 0;
  287.   register VIDEO_PTR p;
  288.  
  289.   FILLPUT(pos,byte)
  290.  
  291.   while (top != bot)
  292.   { pos  = POS[bot];
  293.     byte = BYTE[bot];
  294.  
  295.     bot = (bot+1) % 512;
  296.  
  297.     if (byte == 128)
  298.        FILLPUT(pos-1,1)
  299.     else
  300.        FILLPUT(pos,byte<<1)
  301.  
  302.     if (byte == 1)
  303.        FILLPUT(pos+1,128)
  304.     else
  305.        FILLPUT(pos,byte>>1)
  306.  
  307.     FILLPUT(pos-LINE_BYTES,byte)
  308.     FILLPUT(pos+LINE_BYTES,byte)
  309.   }
  310. }
  311.  
  312. static  VIDEO_PTR  POS1[512];
  313. static  int pos_top = 0;
  314.  
  315. void fill_bytes(VIDEO_PTR pos, int d)
  316. { VIDEO_PTR p = pos+d;
  317.  
  318.   unsigned char c = *p;
  319.   unsigned char pat = 0xFF;
  320.  
  321.   if (c == 0)
  322.   { *p = 0xFF;
  323.     fill_bytes(p,  1);
  324.     fill_bytes(p, -1);
  325.     fill_bytes(p, LINE_BYTES);
  326.     fill_bytes(p,-LINE_BYTES);
  327.     return;
  328.    }
  329.  
  330.   if (d == -1)
  331.   { while((c&1) == 0)
  332.     { pat <<= 1;
  333.       c >>= 1;
  334.      }
  335.     *p |= ~pat;
  336.    }
  337.  
  338.   if (d == 1)
  339.   { while((c&128) == 0)
  340.     { pat >>= 1;
  341.       c <<= 1;
  342.      }
  343.     *p |= ~pat;
  344.    }
  345.  
  346.   if((c&8) == 0 && (d == LINE_BYTES || d == -LINE_BYTES))   POS1[pos_top++] = p;
  347.  
  348.  }
  349.  
  350.  
  351. void fill_polygon(Window win, int n, int* xcoord, int* ycoord)
  352. {
  353.   register VIDEO_PTR p;
  354.   register VIDEO_PTR q;
  355.   register VIDEO_PTR first;
  356.   register VIDEO_PTR first1;
  357.   register VIDEO_PTR last;
  358.  
  359.   int i,m1,m2;
  360.   int minxi = 0;
  361.   int maxxi = 0;
  362.   int minyi = 0;
  363.   int maxyi = 0;
  364.   int minx,maxx,miny,maxy,x,y;
  365.  
  366.   VIDEO_PTR video_save = VIDEO;
  367.  
  368.   VIDEO = 0;
  369.  
  370.   video_buf = (VIDEO_PTR)malloc(LINE_BYTES*480);
  371.  
  372.  
  373.   for(i=1;i<n;i++)
  374.   { minxi = (xcoord[i] < xcoord[minxi]) ? i : minxi;
  375.     minyi = (ycoord[i] < ycoord[minyi]) ? i : minyi;
  376.     maxxi = (xcoord[i] > xcoord[maxxi]) ? i : maxxi;
  377.     maxyi = (ycoord[i] > ycoord[maxyi]) ? i : maxyi;
  378.    }
  379.  
  380.   minx = (xcoord[minxi] + win->xpos)/8;
  381.   maxx = (xcoord[maxxi] + win->xpos)/8;
  382.   miny = ycoord[minyi] + win->ypos;
  383.   maxy = ycoord[maxyi] + win->ypos;
  384.  
  385.   m1 =  (minxi == 0)   ?  n-1 : minxi-1;
  386.   m2 =  (minxi == n-1) ?  0   : minxi+1;
  387.  
  388.   for(i=miny; i<=maxy; i++)
  389.   { last = video_buf+LINE_BYTES*i + maxx;
  390.     for(p=video_buf+LINE_BYTES*i+minx; p<=last; p++) *p= 0;
  391.    }
  392.  
  393.   for(i=0; i<n-1; i++)
  394.       Draw_Line(win,xcoord[i],ycoord[i],xcoord[i+1],ycoord[i+1]);
  395.  
  396.   Draw_Line(win,xcoord[0],ycoord[0],xcoord[n-1],ycoord[n-1]);
  397.  
  398.   x = (xcoord[m1] + xcoord[m2] + xcoord[minxi])/3 + win->xpos;
  399.   y = (ycoord[m1] + ycoord[m2] + ycoord[minxi])/3 + win->ypos;
  400.  
  401.   pos_top = 0;
  402.   fill_bytes(video_buf + LINE_BYTES*y + x/8,0);
  403.  
  404.   while (pos_top--) fill_bits(POS1[pos_top],8);
  405.  
  406.   fill_bits(video_buf+LINE_BYTES*y+x/8,128>>(x%8));
  407.  
  408.   VIDEO = video_save;
  409.  
  410.   first  = video_buf+LINE_BYTES*miny + minx;
  411.   first1 = VIDEO+LINE_BYTES*miny + minx;
  412.   last   = video_buf+LINE_BYTES*miny + maxx;
  413.  
  414.   port_out(8, GRA_I);
  415.  
  416.   while(miny <= maxy)
  417.   { for(p=first, q = first1; p<=last; p++, q++)
  418.     { port_out(*p, GRA_D);
  419.       *q = *q;
  420.      }
  421.     first  += LINE_BYTES;
  422.     first1 += LINE_BYTES;
  423.     last   += LINE_BYTES;
  424.     miny++;
  425.    }
  426.  
  427.   free((char*)video_buf);
  428. }
  429.  
  430.  
  431. void box(Window win, int x0, int y0, int x1, int y1)
  432. { if (y0 > y1)
  433.   { int y = y0;
  434.     y0 = y1;
  435.     y1 = y;
  436.    }
  437.   while(y0<=y1) hline(win,x0,x1,y0++);
  438.  }
  439.  
  440.  
  441. void  rectangle(Window win, int x0, int y0, int x1, int y1)
  442. { int left  = x0;
  443.   int right = x1;
  444.   int top   = y0;
  445.   int bottom= y1;
  446.  
  447.   if (x0 > x1)
  448.   { left  = x1;
  449.     right = x0;
  450.    }
  451.  
  452.   if (y0 > y1)
  453.   { top  = y1;
  454.     bottom = y0;
  455.    }
  456.  
  457.   line(win,left, top,     right,top);
  458.   line(win,left, bottom,  right,bottom);
  459.   line(win,left, bottom-1,left, top+1);
  460.   line(win,right,bottom-1,right,top+1);
  461. }
  462.  
  463.  
  464. void circle(Window win, int x0,int y0,int r0)
  465. { int r;
  466.  
  467.   for (r = r0-LINEWIDTH/2; r <= r0+LINEWIDTH/2; r++)
  468.   { int y = r;
  469.     int x = 0;
  470.     int e = 3-2*y;
  471.  
  472.     put_pixel(win,x0,y0+r);
  473.     put_pixel(win,x0,y0-r);
  474.     put_pixel(win,x0+r,y0);
  475.     put_pixel(win,x0-r,y0);
  476.  
  477.     for (x=1;x<y;)
  478.       { put_pixel(win,x0+x,y0+y);
  479.         put_pixel(win,x0+x,y0-y);
  480.         put_pixel(win,x0-x,y0+y);
  481.         put_pixel(win,x0-x,y0-y);
  482.         put_pixel(win,x0+y,y0+x);
  483.         put_pixel(win,x0+y,y0-x);
  484.         put_pixel(win,x0-y,y0+x);
  485.         put_pixel(win,x0-y,y0-x);
  486.         x++;
  487.         if (e>=0) { y--; e = e - 4*y; }
  488.         e = e + 4*x + 2;
  489.        }
  490.  
  491.     if (x == y)
  492.     { put_pixel(win,x0+x,y0+y);
  493.       put_pixel(win,x0+x,y0-y);
  494.       put_pixel(win,x0-x,y0+y);
  495.       put_pixel(win,x0-x,y0-y);
  496.      }
  497.   }
  498. }
  499.  
  500.  
  501. void fill_circle(Window win, int x0, int y0, int r)
  502. { int y = 1;
  503.   int x = r;
  504.   int e = 3-2*r;
  505.  
  506.   hline(win,x0-x,x0+x,y0);
  507.  
  508.   while (y<=x)
  509.   { hline(win,x0-x,x0+x,y0+y);
  510.     hline(win,x0-x,x0+x,y0-y);
  511.  
  512.     if (y<x && e>=0)
  513.     { hline(win,x0-y,x0+y,y0+x);
  514.       hline(win,x0-y,x0+y,y0-x);
  515.       x--;
  516.       e = e - 4*x;
  517.      }
  518.     y++;
  519.     e = e + 4*y + 2;
  520.    }
  521. }
  522.  
  523.  
  524.  
  525. static void Put_Text(Window win, int x, int y, const char *str, int bg_col)
  526. { /* bgcol = -1 : transparent */
  527.   register unsigned char *fp1;
  528.   register unsigned char *fp2;
  529.   register unsigned char c;
  530.  
  531.   register VIDEO_PTR start;
  532.   register VIDEO_PTR stop;
  533.   register VIDEO_PTR q;
  534.  
  535.   char text[128];
  536.   int dy,i;
  537.   int len = strlen(str);
  538.   int l = (win->width-x)/text_width("H");
  539.   if (len > l) len = l;
  540.   if (len > 0) strncpy(text,str,len);
  541.   text[len] = 0;
  542.  
  543.  
  544.   if (y < 0 || y >= win->height || x < 0 || x >= win->width) return;
  545.  
  546.   if (bg_col >= 0)
  547.   { int save_color = set_color(bg_col);
  548.     int save_mode = set_mode(0);
  549.     box(win,x,y,x+text_width(text)-1,y+text_height(text)-1);
  550.     set_mode(save_mode);
  551.     set_color(save_color);
  552.    }
  553.  
  554.   dy = win->height - y;
  555.  
  556.   if (dy > FONT_HEIGHT) dy = FONT_HEIGHT;
  557.  
  558.   x += win->xpos;
  559.   y += win->ypos;
  560.  
  561.   fp1 = FONT + FONT_HEIGHT * ' ';
  562.   fp2 = FONT + FONT_HEIGHT * (text[0] & 127);
  563.  
  564.   start = VIDEO + LINE_BYTES*y + x/8;
  565.   stop = start + LINE_BYTES*dy;
  566.  
  567.   x &= 7;
  568.  
  569.   port_out(8, GRA_I);
  570.  
  571.   for(i=0;i<len; i++)
  572.   { for (q = start; q < stop; q+=LINE_BYTES, fp1++,fp2++)
  573.     { c = ((*fp2)>>x) | ((*fp1)<<(8-x));
  574.       port_out(c, GRA_D);
  575.       *q = *q;
  576.      }
  577.     fp1 = FONT + FONT_HEIGHT * (text[i] & 127);
  578.     fp2 = FONT + FONT_HEIGHT * (text[i+1] & 127);
  579.     start++;
  580.     stop++;
  581.    }
  582.  
  583.   if (x > 0)
  584.     for (q = start; q < stop; q+=LINE_BYTES, fp1++,fp2++)
  585.     { c = (*fp1)<<(8-x);
  586.       port_out(c, GRA_D);
  587.       *q = *q;
  588.      }
  589.  
  590. }
  591.  
  592. void put_text(Window win, int x, int y, const char *text, int opaque)
  593. { Put_Text(win,x,y,text,opaque ? win->bg_col : -1); }
  594.  
  595.  
  596. void put_ctext(Window win, int x, int y, const char* str, int opaque)
  597. { put_text(win,x-(text_width(str)-1)/2, y-(text_height(str)-1)/2, str, opaque);
  598.  }
  599.  
  600.  
  601. void show_coordinates(Window win, const char* s)
  602. { int save_mode = set_mode(0);
  603.   int save_col  = set_color(4);
  604.   put_text(win,win->width-138,1,s,1); 
  605.   set_mode(save_mode);
  606.   set_color(save_col);
  607. }
  608.  
  609.  
  610. void clear_window(Window win, int c)
  611. { int save_col  = set_color(win->bg_col);
  612.   int save_mode = set_mode(0);
  613.   box(win,0,0,win->width-1,win->height-1);
  614.   set_color(save_col);
  615.   set_mode(save_mode);
  616.  }
  617.  
  618.  
  619. void pixel(Window win, int x, int y) { put_pixel(win,x,y);}
  620.  
  621. void pixels(Window win, int n, int* x, int* y)
  622. { while(n--) put_pixel(win,x[n],y[n]); }
  623.  
  624.  
  625.  
  626. #define put_arc_pixel(X,Y,x,y,top) { X[top] = x; Y[top] = y; top++; }
  627.  
  628. void arc(Window win, int x0, int y0, int r1, int r2, double start, double angle)
  629. {
  630.  int* X = new int[10*r1];
  631.  int* Y = new int[10*r2];
  632.  int r;
  633.  
  634.  x0 += win->xpos;
  635.  y0 += win->ypos;
  636.  
  637.  if (angle < 0)
  638.  { start += angle;
  639.    angle *= -1;
  640.   }
  641.  
  642.  if (angle > 2*M_PI) angle = 2*M_PI;
  643.  
  644.  while (start < 0) start += 2*M_PI;
  645.  
  646.  for (r = r1-LINEWIDTH/2; r <= r1+LINEWIDTH/2; r++)
  647.  { int y = r;
  648.    int x = 0;
  649.    int e = 3-2*y;
  650.    int top = 0;
  651.    int high;
  652.    int high1;
  653.    int s,l;
  654.    float L;
  655.    int i;
  656.  
  657.    while (x < y)
  658.    { put_arc_pixel(X,Y,x,y,top);
  659.      x++;
  660.      if (e>=0) { y--; e -= 4*y; }
  661.      e += 4*x + 2;
  662.     }
  663.  
  664.    high = top-1;
  665.  
  666.    if (x==y) put_arc_pixel(X,Y,x,y,top);
  667.  
  668.    high1 = top;
  669.  
  670.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y, Y[i],-X[i],top);
  671.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y, X[i],-Y[i],top);
  672.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y,-X[i],-Y[i],top);
  673.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y,-Y[i],-X[i],top);
  674.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y,-Y[i], X[i],top);
  675.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y,-X[i], Y[i],top);
  676.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y, X[i], Y[i],top);
  677.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y, Y[i], X[i],top);
  678.  
  679.    L = (top - high1)/(2*M_PI);
  680.    s = high1 - 1 + (int)(start*L);
  681.    l = s + (int)(angle*L);
  682.  
  683.    if (l >= top)
  684.    { for(i=s; i < top; i++) put_pixel(win,x0+X[i],y0+Y[i]);
  685.      s = high - 1;
  686.      l = s + l - top;
  687.     }
  688.    for(i=s; i < l; i++) put_pixel(win,x0+X[i],y0+Y[i]);
  689.   }
  690.  
  691.   delete X;
  692.   delete Y;
  693. }
  694.  
  695.  
  696. static void ellipse_point(Window win, int x0, int y0, int x, int y)
  697. { put_pixel(win,x0+x,y0+y);
  698.   put_pixel(win,x0-x,y0+y);
  699.   put_pixel(win,x0+x,y0-y);
  700.   put_pixel(win,x0-x,y0-y);
  701.  }
  702.  
  703.  
  704. void ellipse(Window win, int x0, int y0, int a, int b)
  705. { 
  706.   /* Foley, van Dam, Feiner, Huges: Computer Graphics, page 90 */
  707.  
  708.   double d1,d2;
  709.   int x,y;
  710.   int a_2 = a*a;
  711.   int b_2 = b*b;
  712.  
  713.   put_pixel(win,x0,y0-b);
  714.   put_pixel(win,x0,y0+b);
  715.   put_pixel(win,x0-a,y0);
  716.   put_pixel(win,x0+a,y0);
  717.  
  718.   x = 0;
  719.   y = b;
  720.  
  721.   d1 = b*b + a*a*(0.25 - b); 
  722.    
  723.   while (a_2*(y - 0.5) > b_2*(x+1))
  724.   { if (d1 < 0)
  725.       d1 += b_2*(2*x + 3);
  726.     else
  727.     { d1 += b_2*(2*x + 3) + a_2*(2 - 2*y);
  728.       y--;
  729.      }
  730.     x++;
  731.     ellipse_point(win,x0,y0,x,y);
  732.   }
  733.  
  734.   d2 = b_2*(x+0.5)*(x+0.5) + a_2*(y - 1)*(y - 1) - a_2*b_2;
  735.  
  736.   while (y > 1)
  737.   { if (d2 < 0)
  738.      { d2 += b_2*(2*x+2)+a_2*(3-2*y);
  739.        x++;
  740.       }
  741.     else
  742.        d2 += a*a*(3-2*y);
  743.  
  744.     y--;
  745.  
  746.     ellipse_point(win,x0,y0,x,y);
  747.    }
  748. }
  749.  
  750.  
  751. void fill_ellipse(Window win, int x0, int y0, int a, int b)
  752. { 
  753.   double d1,d2;
  754.   int x,y;
  755.   int a_2 = a*a;
  756.   int b_2 = b*b;
  757.  
  758.   x = 0;
  759.   y = b;
  760.  
  761.   d1 = b*b + a*a*(0.25 - b); 
  762.    
  763.   while (a_2*(y - 0.5) > b_2*(x+1))
  764.   { if (d1 < 0)
  765.       d1 += b_2*(2*x + 3);
  766.     else
  767.     { d1 += b_2*(2*x + 3) + a_2*(2 - 2*y);
  768.       hline(win,x0-x,x0+x,y0+y);
  769.       hline(win,x0-x,x0+x,y0-y);
  770.       y--;
  771.      }
  772.     x++;
  773.   }
  774.   hline(win,x0-x,x0+x,y0+y);
  775.   hline(win,x0-x,x0+x,y0-y);
  776.  
  777.   d2 = b_2*(x+0.5)*(x+0.5) + a_2*(y - 1)*(y - 1) - a_2*b_2;
  778.  
  779.   while (y > 1)
  780.   { if (d2 < 0)
  781.      { d2 += b_2*(2*x+2)+a_2*(3-2*y);
  782.        x++;
  783.       }
  784.     else
  785.        d2 += a*a*(3-2*y);
  786.  
  787.     y--;
  788.  
  789.     hline(win,x0-x,x0+x,y0+y);
  790.     hline(win,x0-x,x0+x,y0-y);
  791.    }
  792.  
  793.   hline(win,x0-x,x0+x,y0);
  794.  
  795. }
  796.  
  797.  
  798. void fill_arc(Window,int,int,int,int,double,double)
  799. { }
  800.  
  801.  
  802. static void copy_box(int left, int top, int width, int height, int x, int y)
  803. {
  804.   register VIDEO_PTR first1;
  805.   register VIDEO_PTR first;
  806.   register VIDEO_PTR last1;
  807.   register VIDEO_PTR last;
  808.   register VIDEO_PTR p;
  809.   register VIDEO_PTR q;
  810.  
  811.   int i;
  812.  
  813.   if(x < 0) 
  814.   { left += x;
  815.     width -= x;
  816.     x = 0;
  817.    }
  818.  
  819.   if(y < 0) 
  820.   { top += y;
  821.     height -= y;
  822.     y = 0;
  823.    }
  824.  
  825.   if(x+width > DISP_MAX_X) width = DISP_MAX_X - x;
  826.  
  827.   if(y+height > DISP_MAX_Y) height = DISP_MAX_Y - y;
  828.  
  829.   /* set write mode 1 */
  830.   port_out(5, GRA_I);
  831.   port_out(1, GRA_D);
  832.  
  833.   if (y <= top)
  834.   { first1 = VIDEO + LINE_BYTES*y + x/8;
  835.     last1  = VIDEO + LINE_BYTES*y + (x+width-1)/8;
  836.     first  = VIDEO + LINE_BYTES*top + left/8;
  837.     last   = VIDEO + LINE_BYTES*top + (left+width-1)/8;
  838.    }
  839.   else
  840.   { first1 = VIDEO + LINE_BYTES*(y+height-1) + x/8;
  841.     last1  = VIDEO + LINE_BYTES*(y+height-1) + (x+width-1)/8;
  842.     first  = VIDEO + LINE_BYTES*(top+height-1) + left/8;
  843.     last   = VIDEO + LINE_BYTES*(top+height-1) + (left+width-1)/8;
  844.    }
  845.  
  846.   for(i=0; i<height; i++)
  847.   { 
  848.     if (x <= left)
  849.       for(q=first, p=first1; q<=last; q++,p++) *p = *q;
  850.     else
  851.       for(q=last, p=last1; q>=first; q--,p--) *p = *q;
  852.  
  853.     if (y <= top)
  854.     { first1 += LINE_BYTES;
  855.       first  += LINE_BYTES;
  856.       last1  += LINE_BYTES;
  857.       last   += LINE_BYTES;
  858.      }
  859.     else
  860.     { first1 -= LINE_BYTES;
  861.       first  -= LINE_BYTES;
  862.       last1  -= LINE_BYTES;
  863.       last   -= LINE_BYTES;
  864.      }
  865.    }
  866.  
  867.   /* set write mode 0 */
  868.   port_out(5, GRA_I);
  869.   port_out(0, GRA_D);
  870.  
  871.  }
  872.  
  873. void copy_rect(Window win, int x1, int y1, int x2, int y2, int x, int y)
  874. { int w = x2-x1+1;
  875.   int h = y2-y1+1;
  876.   x1 += win->xpos; 
  877.   y1 += win->ypos; 
  878.   x  += win->xpos; 
  879.   y  += win->ypos; 
  880.   copy_box(x1,y1,w,h,x,y); 
  881.  }
  882.  
  883.  
  884. static char rev_byte(char c)
  885. { char c1 = 0x00;
  886.    for(int i=0; i<8; i++)
  887.    { c1 <<= 1;
  888.      if (c&1) c1 |= 1;
  889.      c >>= 1;
  890.     }
  891.   return c1;
  892. }
  893.  
  894.  
  895. void insert_bitmap(Window win, int width, int height, char* data)
  896. {
  897.   register VIDEO_PTR first;
  898.   register VIDEO_PTR last;
  899.   register VIDEO_PTR q;
  900.  
  901.   int x = win->x0/8 + 1;
  902.   int y = win->ypos;
  903.  
  904.   int w = (width > win->width) ? win->width : width;
  905.   int h = (height > win->height) ? win->height : height;
  906.  
  907.   first  = VIDEO + LINE_BYTES*y + x;
  908.   last   = VIDEO + LINE_BYTES*y + x + w/8 - 1;
  909.  
  910.   if (width % 8)
  911.      width  = 1+ width/8;
  912.   else
  913.      width  = width/8;
  914.  
  915.   port_out(8, GRA_I);
  916.  
  917.   for(int i=0; i<h; i++)
  918.   { char* p = data + i*width;
  919.     for(q=first; q<=last; q++) 
  920.     { port_out(rev_byte(*p++), GRA_D);
  921.       *q = *q;
  922.      }
  923.     first += LINE_BYTES;
  924.     last  += LINE_BYTES;
  925.    }
  926.  }
  927.  
  928.