Category

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

Mathimatics-Numerical algorithms

Development Platform:

MultiPlatform

_emx.c：Code Content
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _emx.c
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  15. /* basic graphic routines for MSDOS
  16.  * implemented using the emx graphics library (jmgraph.a)
  17.  */
  19. #include <jmgraph.h>
  20. #include <stdio.h>
  23. static int MODE;
  24. static int STYLE;
  25. static int WIDTH;
  26. static int COLOR;
  28. static int win_xmin;  // coordinates of current window
  29. static int win_ymin;
  30. static int win_xmax; 
  31. static int win_ymax;
  34. void init_graphics(int mode, int col)
  35. {
  36.   if (mode == 1) // graphics mode
  37.   { 
  38.      if (!g_mode(G640x480x16))
  39.      { fprintf (stderr, "Cannot switch to graphics mode 640x480x16n");
  40.        exit(1);
  41.       }
  43.     char pal[48];
  44.     char* p = pal;
  45.     for(int i=0; i<16; i++) 
  46.       { *p++ = _R_[i];
  47.         *p++ = _G_[i];
  48.         *p++ = _B_[i];
  49.        }
  50.       g_vgapal(pal,0,16,1);
  51.     }
  52.   else // text mode
  53.     g_mode(GTEXT);
  56.   DISP_WIDTH  = g_xsize;
  57.   DISP_HEIGHT = g_ysize;
  58.   DISP_DEPTH  = g_colors;
  59.   DISP_MAX_X  = DISP_WIDTH-1;
  60.   DISP_MAX_Y  = DISP_HEIGHT-1;
  62.   MODE  = 0;
  63.   STYLE = 0;
  64.   WIDTH = 1;
  65.   COLOR = 1;
  67.   win_xmin = 0;
  68.   win_ymin = 0;
  69.   win_xmax = DISP_MAX_X;
  70.   win_ymax = DISP_MAX_Y;
  71.   
  72. }
  75. static void set_draw_window(Window w)
  76. { DosWindow win = win_stack[w];
  77.   win_xmin = win->xpos;
  78.   win_ymin = win->ypos;
  79.   win_xmax = win_xmin + win->width  - 1;
  80.   win_ymax = win_ymin + win->height - 1;
  81.   g_clip(win_xmin,win_ymin,win_xmax,win_ymax);
  82.  }
  85. void flush_display() {}
  87. int  new_color(const char*) { return 1; }
  89. int  text_height(const char*)  { return FONT_HEIGHT; }
  90. int  text_width(const char* s) { return FONT_WIDTH*strlen(s); }
  92. int  load_text_font(const char*) { return 0;}
  93. int  load_bold_font(const char*) { return 0;}
  94. int  load_message_font(const char*) { return 0;}
  96. int  set_font(const char*) { return 0;}
  97. void set_text_font() {}
  98. void set_bold_font() {}
  99. void set_message_font() {}
  102. int set_line_width(int width) 
  103. { int save = WIDTH;
  104.   WIDTH = width;
  105.   return save; 
  106.  }
  108. int set_line_style(int style) 
  109. { int save = STYLE;
  110.   STYLE = style;
  111.   switch(style) {
  112.   case solid : //_setlinestyle(0xFFFF);
  113.                break;
  114.   case dotted: //_setlinestyle(0x3333);
  115.                break;
  116.   case dashed: //_setlinestyle(0x0F0F);
  117.                break;
  118.   }
  119.   return save;
  120.  }
  123. int set_color(int col) 
  124. { int c = COLOR;
  125.   COLOR = col;
  126.   return c; 
  127.  }
  130. int set_mode(int mode)
  131. { int save = MODE;
  132.   MODE = mode;
  133.   switch(mode) {
  134.    case 0: g_wmode(G_NORM);
  135.            break;
  136.    case 1: g_wmode(G_XOR);
  137.            break;
  138.    case 2: g_wmode(G_OR);
  139.            break;
  140.    case 3: g_wmode(G_AND);
  141.            break;
  142.   }
  143.   return save;
  144. }
  146. void set_redraw(Window w, void (*f)())
  147. { win_stack[w]->redraw = f; }
  150. void line(Window w, int x1, int y1, int x2, int y2)
  151. { set_draw_window(w);
  153.   x1 += win_xmin;
  154.   x2 += win_xmin;
  155.   y1 += win_ymin;
  156.   y2 += win_ymin;
  158.   g_line(x1,y1,x2,y2,COLOR);
  160.   for(int i = 2; i <= WIDTH; i++)
  161.   { int dx = (x1 > x2) ? x1-x2 : x2-x1;
  162.     int dy = (y1 > y2) ? y1-y2 : y2-y1;
  163.     int d = (i&1) ? i/2 : -i/2;
  164.     if (dx < dy)
  165.        g_line(x1+d,y1,x2+d,y2,COLOR);
  166.     else
  167.        g_line(x1,y1+d,x2,y2+d,COLOR);
  168.    }
  169. }
  172. void fill_polygon(Window w, int n, int* xc, int* yc)
  173. { set_draw_window(w);
  174.   for (int i = 0; i<n; i++)
  175.   { xc[i] += win_xmin;
  176.     yc[i] += win_ymin;
  177.    }
  178.   g_polygon(xc,yc,n,COLOR,G_FILL);
  179.  }
  182. void box(Window w, int x0, int y0, int x1, int y1)
  183. { set_draw_window(w);
  184.   x0 += win_xmin;
  185.   x1 += win_xmin;
  186.   y0 += win_ymin;
  187.   y1 += win_ymin;
  188.   g_box(x0,y0,x1,y1,COLOR,G_FILL);
  189.  }
  192. void  rectangle(Window w, int x0, int y0, int x1, int y1)
  193. { set_draw_window(w);
  194.   x0 += win_xmin;
  195.   x1 += win_xmin;
  196.   y0 += win_ymin;
  197.   y1 += win_ymin;
  198.   g_box(x0,y0,x1,y1,COLOR,G_OUTLINE);
  199.  }
  201. void circle(Window w, int x0,int y0,int r)
  202. { set_draw_window(w);
  203.   x0 += win_xmin;
  204.   y0 += win_ymin;
  205.   g_ellipse(x0,y0,r,r,COLOR,G_OUTLINE);
  206.  }
  208. void fill_circle(Window w, int x0, int y0, int r)
  209. { set_draw_window(w);
  210.   x0 += win_xmin;
  211.   y0 += win_ymin;
  212.   g_ellipse(x0,y0,r,r,COLOR,G_FILL);
  213.  }
  216. void put_text(Window w, int x, int y0, const char *text, int opaque)
  217. { 
  218.   set_draw_window(w);
  219.   x  += win_xmin;
  220.   y0 += win_ymin;
  222.   int y1 = y0 + FONT_HEIGHT;
  225.   if (opaque)
  226.   { int bg_col = win_stack[w]->bg_col;
  227.     int save = set_mode(0);
  228.     g_box(x,y0,x+strlen(text)*FONT_WIDTH-1,y0+FONT_HEIGHT,bg_col,G_FILL);
  229.     set_mode(save);
  230.    }
  232.   const char* stop = text + strlen(text);
  234.   for (const char* p = text; p < stop; p++)
  235.   { unsigned char* q =  FONT + (*p & 127) * FONT_HEIGHT;
  236.     for(int y=y0; y<y1; y++)
  237.     { unsigned char pat = *q++;
  238.       if (pat & 128) g_set(x  ,y,COLOR);
  239.       if (pat &  64) g_set(x+1,y,COLOR);
  240.       if (pat &  32) g_set(x+2,y,COLOR);
  241.       if (pat &  16) g_set(x+3,y,COLOR);
  242.       if (pat &   8) g_set(x+4,y,COLOR);
  243.       if (pat &   4) g_set(x+5,y,COLOR);
  244.       if (pat &   2) g_set(x+6,y,COLOR);
  245.       if (pat &   1) g_set(x+7,y,COLOR);
  246.      }
  247.     x += 8;
  248.    }
  249. }
  253. void put_text(Window w, int x, int y, const char *text, int l, int opaque)
  254. { char* str = new char[strlen(text)+1];
  255.   strcpy(str,text);
  256.   str[l] = '';
  257.   put_text(w,x,y,text,l,opaque);
  258.   delete[] str;
  259. }
  261. void put_ctext(Window w, int x, int y, const char* str, int opaque)
  262. { put_text(w,x-(text_width(str)-1)/2, y-(text_height(str)-1)/2, str, opaque); }
  265. void show_coordinates(Window w, const char* s)
  266. { DosWindow win = win_stack[w];
  267.   set_draw_window(w);
  268.   int save_mode = set_mode(1);
  269.   int save_col = set_color(blue);
  270.   put_text(w,win->width-138,1,s,1); 
  271.   set_color(save_col);
  272.   set_mode(save_mode);
  273. }
  277. void pixel(Window w, int x, int y) 
  278. { set_draw_window(w);
  279.   x += win_xmin;
  280.   y += win_ymin;
  281.   g_set(x,y,COLOR);
  282. }
  284. void point(Window w, int x, int y) 
  285. { set_draw_window(w);
  286.   x += win_xmin;
  287.   y += win_ymin;
  288.   g_set(x,y,COLOR);
  289.   g_set(x-2,y-2,COLOR);
  290.   g_set(x-1,y-1,COLOR);
  291.   g_set(x+1,y+1,COLOR);
  292.   g_set(x+2,y+2,COLOR);
  293.   g_set(x-2,y+2,COLOR);
  294.   g_set(x-1,y+1,COLOR);
  295.   g_set(x+1,y-1,COLOR);
  296.   g_set(x+2,y-2,COLOR);
  297. }
  299. void pixels(Window w, int n, int* x, int* y)
  300. { while(n--) pixel(w,x[n],y[n]); }
  303. void ellipse(Window w, int x0, int y0, int a, int b)
  304. { set_draw_window(w);
  305.   x0 += win_xmin;
  306.   y0 += win_ymin;
  307.   g_ellipse(x0,y0,a,b,COLOR,G_OUTLINE);
  308. }
  310. void fill_ellipse(Window w, int x0, int y0, int a, int b)
  311. { set_draw_window(w);
  312.   x0 += win_xmin;
  313.   y0 += win_ymin;
  314.   g_ellipse(x0,y0,a,b,COLOR,G_FILL);
  315. }
  318. void arc(Window w, int x0, int y0, int a, int b, double start, double angle)
  319. { }
  322. void fill_arc(Window,int,int,int,int,double,double)
  323. { }
  325. void copy_pixrect(Window win, int x1, int y1, int x2, int y2, int x, int y)
  326. { set_draw_window(win);
  327.   x1 += win_xmin;
  328.   x2 += win_xmin;
  329.   x  += win_xmin;
  330.   y1 += win_ymin;
  331.   y2 += win_ymin;
  332.   y  += win_ymin;
  334.   int w = x2 - x1 + 1;
  335.   int h = y2 - y1 + 1;
  336.   int sz = g_imagesize(w,h);
  337.   char* image = new char[sz];
  338.   g_getimage(x1,y1,x2,y2,image);
  339.   g_putimage(x,y,x+w-1,y+h-1,image);
  340.   delete[] image;
  341.  }
  344. void insert_bitmap(Window w, int width, int height, char* data)
  345. { set_draw_window(w);
  346.   char* p = data;
  347.   for(int y=0; y<height; y++)
  348.     for(int x=0; x<width; x+=8)
  349.     { char pat = *p++;
  350.       if (pat & 0x01) g_set(x,   y,black);
  351.       if (pat & 0x02) g_set(x+1, y,black);
  352.       if (pat & 0x04) g_set(x+2, y,black);
  353.       if (pat & 0x08) g_set(x+3, y,black);
  354.       if (pat & 0x10) g_set(x+4, y,black);
  355.       if (pat & 0x20) g_set(x+5, y,black);
  356.       if (pat & 0x40) g_set(x+6, y,black);
  357.       if (pat & 0x80) g_set(x+7, y,black);
  358.      }
  359.  }
  362. void set_palette(int index, int red, int green, int blue)
  363. { if (red < 0)     red = _R_[index]; else _R_[index] = red;
  364.   if (green < 0) green = _G_[index]; else _G_[index] = green;
  365.   if (blue < 0)   blue = _B_[index]; else _B_[index] = blue;
  366.   char pal[3];
  367.   pal[0] = red;
  368.   pal[1] = green;
  369.   pal[2] = blue;
  370.   g_vgapal(pal,index,1,1);
  371. }
  376. //------------------------------------------------------------------------------
  377. // pixrects
  378. //------------------------------------------------------------------------------
  381. char* create_pixrect(Window win, int left, int top, int right, int bottom)
  382. { set_draw_window(win);
  383.   left   += win_xmin;
  384.   right  += win_xmin;
  385.   top    += win_ymin;
  386.   bottom += win_ymin;
  388.   left  &= 0xFFF8;
  389.   right |= 7;
  391.   int w = right-left+1;
  392.   int h = bottom-top+1;
  393.   char* bp = new char[g_imagesize(w,h)+8];
  394.   g_getimage(left,top,right,bottom,bp+8);
  395.   *(int*)bp = w;
  396.   *(int*)(bp+4) = h;
  397.   return bp;
  398.  }
  401. void insert_pixrect(Window win, int left, int top, char* rect)
  402. { set_draw_window(win);
  404.   left   += win_xmin;
  405.   top    += win_ymin;
  407.   left  &= 0xFFF8;
  409.   if (left < 0) left = 0;
  410.   if (top < 0) top = 0;
  411.   int w = *(int*)rect;
  412.   int h = *(int*)(rect+4);
  413.   g_putimage(left,top,left+w-1,top+h-1,rect+8);
  414.  }
  417. void delete_pixrect(char* rect)   { delete rect; }
  421. //------------------------------------------------------------------------------
  422. // mouse cursor
  423. //------------------------------------------------------------------------------
  426. static unsigned short p_mask1[14] = 
  427. {0xc000,0xf000,0x7c00,0x7f00,0x3fc0,0x3fc0,0x1f00,
  428.  0x1f80,0x0dc0,0x0ce0,0x0070,0x0038,0x001c,0x000c};
  430. static unsigned short p_mask2[14] = 
  431. {0x0003,0x000f,0x003e,0x00fe,0x03fc,0x03fc,0x00f8,
  432.  0x01f8,0x03b0,0x0730,0x0e00,0x1c00,0x3800,0x3000};
  435. void draw_pointer(int mouse_x, int mouse_y, int shape)
  436. {
  437.   g_clip(0,0,DISP_MAX_X,DISP_MAX_Y);
  438.   set_color(black);
  440.   if (shape == 1)
  441.   { g_set(mouse_x-2,mouse_y,black);
  442.     g_set(mouse_x-1,mouse_y,black);
  443.     g_set(mouse_x,mouse_y,black);
  444.     g_set(mouse_x+1,mouse_y,black);
  445.     g_set(mouse_x+3,mouse_y,black);
  446.     g_set(mouse_x,mouse_y-2,black);
  447.     g_set(mouse_x,mouse_y-1,black);
  448.     g_set(mouse_x,mouse_y+1,black);
  449.     g_set(mouse_x,mouse_y+2,black);
  450.     g_ellipse(mouse_x,mouse_y,6,6,black,G_OUTLINE);
  451.     return;
  452.    }
  453.   else
  454.   { int x = mouse_x;
  455.     int y = mouse_y;
  456.     unsigned short* p = p_mask1;
  458.     if (x > DISP_MAX_X - 16) 
  459.     { x -= 16;
  460.       p = p_mask2;
  461.      }
  463.     unsigned short* p_stop = p + 14;
  464.     int d  = 1;
  466.     if (y > DISP_MAX_Y - 14) 
  467.     { y -= 14;
  468.       d = -1;
  469.       p_stop = p-1;
  470.       p += 14;
  471.      }
  472.      
  473.     while (p != p_stop)
  474.     { unsigned short pat = *p;
  475.       if (pat & 0x8000) g_set(x,   y,black);
  476.       if (pat & 0x4000) g_set(x+1, y,black);
  477.       if (pat & 0x2000) g_set(x+2, y,black);
  478.       if (pat & 0x1000) g_set(x+3, y,black);
  479.       if (pat & 0x0800) g_set(x+4, y,black);
  480.       if (pat & 0x0400) g_set(x+5, y,black);
  481.       if (pat & 0x0200) g_set(x+6, y,black);
  482.       if (pat & 0x0100) g_set(x+7, y,black);
  483.       if (pat & 0x0080) g_set(x+8, y,black);
  484.       if (pat & 0x0040) g_set(x+9, y,black);
  485.       if (pat & 0x0020) g_set(x+10,y,black);
  486.       if (pat & 0x0010) g_set(x+11,y,black);
  487.       if (pat & 0x0008) g_set(x+12,y,black);
  488.       if (pat & 0x0004) g_set(x+13,y,black);
  489.       if (pat & 0x0002) g_set(x+14,y,black);
  490.       if (pat & 0x0001) g_set(x+15,y,black);
  491.       p+=d;
  492.       y++;
  493.      }
  494.    }
  495. }