开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
_wcc.c
资源名称：leda.tar.gz　[点击查看]
上传用户：gzelex
上传日期：2007-01-07
资源大小：707k
文件大小：10k
源码类别：

数值算法/人工智能

开发平台：

MultiPlatform

_wcc.c：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _wcc.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. /* basic graphic routines for MSDOS 
  15.  * implemented using watcom's graphics library (graph.lib)
  16.  */
  18. #include <graph.h>
  21. static int MODE;
  22. static int STYLE;
  23. static int WIDTH;
  26. void init_graphics(int mode, int col)
  27. {
  28.   if (mode == 1) // graphics mode
  29.   { _setvideomode(_MAXRESMODE);
  30.     for(int i=0; i<16; i++) 
  31.       set_palette(i,_R_[i],_G_[i],_B_[i]);
  32.     }
  33.   else // text mode
  34.    _setvideomode(_DEFAULTMODE);
  36.   videoconfig vconf;
  37.   _getvideoconfig(&vconf);
  38.   DISP_WIDTH  = vconf.numxpixels;
  39.   DISP_HEIGHT = vconf.numypixels;
  40.   DISP_DEPTH  = vconf.bitsperpixel; 
  41.   DISP_MAX_X  = DISP_WIDTH-1;
  42.   DISP_MAX_Y  = DISP_HEIGHT-1;
  43.   
  44. }
  47. static void set_draw_window(Window w)
  48. { DosWindow win = win_stack[w];
  49.   int x0 = win->xpos;
  50.   int y0 = win->ypos;
  51.   int x1 = x0 + win->width  - 1;
  52.   int y1 = y0 + win->height - 1;
  53.   _setviewport(x0,y0,x1,y1);
  54.  }
  57. void flush_display() {}
  59. int  new_color(const char*) { return 1; }
  61. int  text_height(const char*)  { return FONT_HEIGHT; }
  62. int  text_width(const char* s) { return FONT_WIDTH*strlen(s); }
  64. int  load_text_font(const char*) { return 0;}
  65. int  load_bold_font(const char*) { return 0;}
  66. int  load_message_font(const char*) { return 0;}
  68. int  set_font(const char*) { return 0;}
  69. void set_text_font() {}
  70. void set_bold_font() {}
  71. void set_message_font() {}
  74. int set_line_width(int width) 
  75. { int save = WIDTH;
  76.   WIDTH = width;
  77.   return save; 
  78.  }
  80. int set_line_style(int style) 
  81. { int save = STYLE;
  82.   STYLE = style;
  83.   switch(style) {
  84.   case solid : _setlinestyle(0xFFFF);
  85.                break;
  86.   case dotted: _setlinestyle(0x3333);
  87.                break;
  88.   case dashed: _setlinestyle(0x0F0F);
  89.                break;
  90.   }
  91.   return save;
  92.  }
  95. int set_color(int color) 
  96. { return _setcolor(color); }
  99. int set_mode(int mode)
  100. { int save = MODE;
  101.   MODE = mode;
  102.   switch(mode) {
  103.    case 0: _setplotaction(_GPSET);
  104.            break;
  105.    case 1: _setplotaction(_GXOR);
  106.            break;
  107.    case 2: _setplotaction(_GXOR);
  108.            break;
  109.    case 3: _setplotaction(_GAND);
  110.            break;
  111.   }
  112.   return save;
  113. }
  115. void set_redraw(Window w, void (*f)())
  116. { win_stack[w]->redraw = f; }
  119. void line(Window w, int x1, int y1, int x2, int y2)
  120. { set_draw_window(w);
  122.   _moveto(x1,y1);
  123.   _lineto(x2,y2);
  125.   for(int i = 2; i <= WIDTH; i++)
  126.   { int dx = (x1 > x2) ? x1-x2 : x2-x1;
  127.     int dy = (y1 > y2) ? y1-y2 : y2-y1;
  128.     int d = (i&1) ? i/2 : -i/2;
  129.     if (dx < dy)
  130.       { _moveto(x1+d,y1);
  131.         _lineto(x2+d,y2);
  132.        }
  133.     else
  134.       { _moveto(x1,y1+d);
  135.         _lineto(x2,y2+d);
  136.        }
  137.    }
  138. }
  141. void fill_polygon(Window w, int n, int* xc, int* yc)
  142. { set_draw_window(w);
  143.   xycoord* points = new xycoord[n];
  144.   for(int i=0; i<n; i++)
  145.   { points[i].xcoord = xc[i];
  146.     points[i].ycoord = yc[i];
  147.    }
  148.   _polygon(_GFILLINTERIOR,n,points);
  149.   delete[] points;
  150.  }
  153. void box(Window w, int x0, int y0, int x1, int y1)
  154. { set_draw_window(w);
  155.   _rectangle(_GFILLINTERIOR,x0,y0,x1,y1);
  156.  }
  159. void  rectangle(Window w, int x0, int y0, int x1, int y1)
  160. { set_draw_window(w);
  161.   _rectangle(_GBORDER,x0,y0,x1,y1);
  162.  }
  164. void circle(Window w, int x0,int y0,int r)
  165. { set_draw_window(w);
  166.   _ellipse(_GBORDER,x0-r,y0-r,x0+r,y0+r);
  167.  }
  169. void fill_circle(Window w, int x0, int y0, int r)
  170. { set_draw_window(w);
  171.   _ellipse(_GFILLINTERIOR,x0-r,y0-r,x0+r,y0+r);
  172.  }
  176. void put_text(Window w, int x, int y0, const char *text, int opaque)
  177. { 
  178.   set_draw_window(w);
  180.   int y1 = y0 + FONT_HEIGHT;
  182.   if (opaque)
  183.   { int save_color = _setcolor(win_stack[w]->bg_col);
  184.     int save_mode = _setplotaction(_GPSET);
  185.     _rectangle(_GFILLINTERIOR,x,y0,x+strlen(text)*FONT_WIDTH-1,y0+FONT_HEIGHT);
  186.     _setplotaction(save_mode);
  187.     _setcolor(save_color);
  188.    }
  190.   const char* stop = text + strlen(text);
  192.   for (const char* p = text; p < stop; p++)
  193.   { unsigned char* q =  FONT + (*p & 127) * FONT_HEIGHT;
  194.     for(int y=y0; y<y1; y++)
  195.     { unsigned char pat = *q++;
  196.       if (pat & 128) _setpixel(x  ,y);
  197.       if (pat &  64) _setpixel(x+1,y);
  198.       if (pat &  32) _setpixel(x+2,y);
  199.       if (pat &  16) _setpixel(x+3,y);
  200.       if (pat &   8) _setpixel(x+4,y);
  201.       if (pat &   4) _setpixel(x+5,y);
  202.       if (pat &   2) _setpixel(x+6,y);
  203.       if (pat &   1) _setpixel(x+7,y);
  204.      }
  205.     x += 8;
  206.    }
  207. }
  211. void put_text(Window w, int x, int y, const char *text, int l, int opaque)
  212. { char* str = new char[strlen(text)+1];
  213.   strcpy(str,text);
  214.   str[l] = '';
  215.   put_text(w,x,y,text,l,opaque);
  216.   delete[] str;
  217. }
  219. void put_ctext(Window w, int x, int y, const char* str, int opaque)
  220. { put_text(w,x-(text_width(str)-1)/2, y-(text_height(str)-1)/2, str, opaque); }
  223. void show_coordinates(Window w, const char* s)
  224. { DosWindow win = win_stack[w];
  225.   set_draw_window(w);
  226.   int save_mode = _setplotaction(_GXOR);
  227.   int save_col  = _setcolor(blue);
  228.   put_text(w,win->width-138,1,s,1); 
  229.   _setplotaction(save_mode);
  230.   _setcolor(save_col);
  231. }
  235. void pixel(Window w, int x, int y) 
  236. { set_draw_window(w);
  237.   _setpixel(x,y);
  238. }
  241. void pixels(Window w, int n, int* x, int* y)
  242. { while(n--) pixel(w,x[n],y[n]); }
  245. void point(Window w, int x, int y) 
  246. { set_draw_window(w);
  247.   _setpixel(x,y);
  248.   _setpixel(x-2,y-2);
  249.   _setpixel(x-1,y-1);
  250.   _setpixel(x+1,y+1);
  251.   _setpixel(x+2,y+2);
  252.   _setpixel(x-2,y+2);
  253.   _setpixel(x-1,y+1);
  254.   _setpixel(x+1,y-1);
  255.   _setpixel(x+2,y-2);
  256. }
  260. void ellipse(Window w, int x0, int y0, int a, int b)
  261. { set_draw_window(w);
  262.   _ellipse(_GBORDER,x0-a,y0-b,x0+a,y0+b);
  263. }
  265. void fill_ellipse(Window w, int x0, int y0, int a, int b)
  266. { set_draw_window(w);
  267.   _ellipse(_GFILLINTERIOR,x0-a,y0-b,x0+a,y0+b);
  268. }
  271. void arc(Window w, int x0, int y0, int a, int b, double start, double angle)
  272. { set_draw_window(w);
  273.   int start_x = x0 + int(cos(start)*1000);
  274.   int start_y = y0 - int(sin(start)*1000);
  275.   int end_x   = x0 + int(cos(start+angle)*1000);
  276.   int end_y   = y0 - int(sin(start+angle)*1000);
  277.   _arc(x0-a,y0-b,x0+a,y0+b,start_x,start_y,end_x,end_y);
  278.  }
  281. void fill_arc(Window,int,int,int,int,double,double)
  282. { }
  284. void copy_pixrect(Window w, int x1, int y1, int x2, int y2, int x, int y)
  285. { set_draw_window(w);
  286.   int sz = _imagesize(x1,y1,x2,y2);
  287.   char* image = new char[sz];
  288.   _getimage(x1,y1,x2,y2,image);
  289.   _putimage(x,y,image,_GPSET);
  290.   delete[] image;
  291.  }
  294. void insert_bitmap(Window w, int width, int height, char* data)
  295. { set_draw_window(w);
  296.   char* p = data;
  297.   for(int y=0; y<height; y++)
  298.     for(int x=0; x<width; x+=8)
  299.     { char pat = *p++;
  300.       if (pat & 0x01) _setpixel(x,   y);
  301.       if (pat & 0x02) _setpixel(x+1, y);
  302.       if (pat & 0x04) _setpixel(x+2, y);
  303.       if (pat & 0x08) _setpixel(x+3, y);
  304.       if (pat & 0x10) _setpixel(x+4, y);
  305.       if (pat & 0x20) _setpixel(x+5, y);
  306.       if (pat & 0x40) _setpixel(x+6, y);
  307.       if (pat & 0x80) _setpixel(x+7, y);
  308.      }
  309.  }
  313. void set_palette(int index, int red, int green, int blue)
  314. { if (red < 0)     red = _R_[index]; else _R_[index] = red;
  315.   if (green < 0) green = _G_[index]; else _G_[index] = green;
  316.   if (blue < 0)   blue = _B_[index]; else _B_[index] = blue;
  317.   _remappalette(index, (blue<<16) | (green<<8) | red); 
  318. }
  323. //------------------------------------------------------------------------------
  324. // pixrects
  325. //------------------------------------------------------------------------------
  328. char* create_pixrect(Window w, int left, int top, int right, int bottom)
  329. { set_draw_window(w);
  330.   char* bp = new char[_imagesize(left,top,right,bottom)];
  331.   _getimage(left,top,right,bottom,bp);
  332.   return bp;
  333.  }
  336. void insert_pixrect(Window w, int left, int top, char* rect)
  337. { set_draw_window(w);
  338.   if (left < 0) left = 0;
  339.   if (top < 0) top = 0;
  340.   _putimage(left,top,rect,_GPSET);
  341.  }
  344. void delete_pixrect(char* rect)   { delete rect; }
  348. //------------------------------------------------------------------------------
  349. // mouse cursor
  350. //------------------------------------------------------------------------------
  353. static unsigned short p_mask1[14] = 
  354. {0xc000,0xf000,0x7c00,0x7f00,0x3fc0,0x3fc0,0x1f00,
  355.  0x1f80,0x0dc0,0x0ce0,0x0070,0x0038,0x001c,0x000c};
  357. static unsigned short p_mask2[14] = 
  358. {0x0003,0x000f,0x003e,0x00fe,0x03fc,0x03fc,0x00f8,
  359.  0x01f8,0x03b0,0x0730,0x0e00,0x1c00,0x3800,0x3000};
  362. void draw_pointer(int mouse_x, int mouse_y, int shape)
  363. {
  364.   _setviewport(0,0,DISP_MAX_X,DISP_MAX_Y);
  365.   set_color(black);
  367.   if (shape == 1)
  368.   { _setpixel(mouse_x-2,mouse_y);
  369.     _setpixel(mouse_x-1,mouse_y);
  370.     _setpixel(mouse_x,mouse_y);
  371.     _setpixel(mouse_x+1,mouse_y);
  372.     _setpixel(mouse_x+3,mouse_y);
  373.     _setpixel(mouse_x,mouse_y-2);
  374.     _setpixel(mouse_x,mouse_y-1);
  375.     _setpixel(mouse_x,mouse_y+1);
  376.     _setpixel(mouse_x,mouse_y+2);
  377.     _ellipse(_GBORDER,mouse_x-6,mouse_y-6,mouse_x+6,mouse_y+6);
  378.     return;
  379.    }
  380.   else
  381.   { int x = mouse_x;
  382.     int y = mouse_y;
  383.     unsigned short* p = p_mask1;
  385.     if (x > DISP_MAX_X - 16) 
  386.     { x -= 16;
  387.       p = p_mask2;
  388.      }
  390.     unsigned short* p_stop = p + 14;
  391.     int d  = 1;
  393.     if (y > DISP_MAX_Y - 14) 
  394.     { y -= 14;
  395.       d = -1;
  396.       p_stop = p-1;
  397.       p += 13;
  398.      }
  399.      
  400.     while (p != p_stop)
  401.     { unsigned short pat = *p;
  402.       if (pat & 0x8000) _setpixel(x,   y);
  403.       if (pat & 0x4000) _setpixel(x+1, y);
  404.       if (pat & 0x2000) _setpixel(x+2, y);
  405.       if (pat & 0x1000) _setpixel(x+3, y);
  406.       if (pat & 0x0800) _setpixel(x+4, y);
  407.       if (pat & 0x0400) _setpixel(x+5, y);
  408.       if (pat & 0x0200) _setpixel(x+6, y);
  409.       if (pat & 0x0100) _setpixel(x+7, y);
  410.       if (pat & 0x0080) _setpixel(x+8, y);
  411.       if (pat & 0x0040) _setpixel(x+9, y);
  412.       if (pat & 0x0020) _setpixel(x+10,y);
  413.       if (pat & 0x0010) _setpixel(x+11,y);
  414.       if (pat & 0x0008) _setpixel(x+12,y);
  415.       if (pat & 0x0004) _setpixel(x+13,y);
  416.       if (pat & 0x0002) _setpixel(x+14,y);
  417.       if (pat & 0x0001) _setpixel(x+15,y);
  418.       p+=d;
  419.       y++;
  420.      }
  421.    }
  422. }