home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / src / graphics / _turbo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  21.3 KB  |  1,128 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  _turbo.c
  7. +
  8. +
  9. +  Copyright (c) 1991  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17.  
  18. /* TC graphic  routines */
  19.  
  20. #include <graphics.h>
  21. #include <dos.h>
  22. #include <conio.h>
  23.  
  24. #include <math.h>
  25. #include <string.h>
  26. #include <stdio.h>
  27. #include <values.h>
  28.  
  29. #define KEY_UP 72
  30. #define KEY_DO 80
  31. #define KEY_LE 75
  32. #define KEY_RI 77
  33.  
  34.  
  35. #define XPIX(coord) (int)(xorigin + (coord)*x_draw_scale)
  36. #define YPIX(coord) (int)(yorigin - (coord)*y_draw_scale)
  37.  
  38. #define XREAL(pix)  ((double)(pix-xorigin)/x_draw_scale)
  39. #define YREAL(pix)  ((double)(yorigin-pix)/y_draw_scale)
  40.  
  41.  
  42. static char default_frame_label[128];
  43.  
  44. static char frame_label[80];
  45.  
  46. static char read_frame_format[] = "%8.2f %8.2f      %s";
  47.  
  48. typedef void (*PRD)();
  49. typedef void (*PMA)();
  50.  
  51. static void x_draw_mouse_default_action(x,y) 
  52. double x,y;
  53. { /* do nothing */}
  54.  
  55. PRD x_draw_redraw = 0;
  56. PMA x_draw_mouse_action = x_draw_mouse_default_action;
  57.  
  58. static int x_draw_have_mouse;
  59.  
  60. static int xpix_mode_op;
  61.  
  62. static int xdots,ydots, xorigin,yorigin;  /* pixels          */
  63.  
  64. static int mouse_key,mouse_xpix, mouse_ypix; 
  65. static int mouse_last_xpix, mouse_last_ypix;
  66. static int mouse_start_xpix, mouse_start_ypix;  /* start for segments  ... */
  67. static int mouse_read_kind;
  68.  
  69.  
  70. static double mouse_xreal,mouse_yreal;
  71. static double mouse_last_xreal,mouse_last_yreal;
  72. static double mouse_start_xreal,mouse_start_yreal;
  73.  
  74. static double x_draw_aspect_ratio;
  75. static double y_draw_scale;   
  76.  
  77. /* external variables */
  78.  
  79. int SCREEN_WIDTH  = 740;
  80. int SCREEN_HEIGHT = 360;
  81.    
  82. double x_draw_xmax,x_draw_xmin,x_draw_ymax,x_draw_ymin, x_draw_scale;
  83.  
  84. int    x_draw_grid_mode;
  85. int    x_draw_depth;
  86.  
  87. int    x_draw_line_width, x_draw_node_width, x_draw_line_style, x_draw_color,
  88.        x_draw_text_mode, x_draw_drawing_mode, x_draw_screen_flush;
  89.  
  90.  
  91.  
  92. /* some forward declarations */
  93.  
  94. void x_draw_circle();
  95. void x_draw_rectangle();
  96. void x_draw_clear();
  97. void x_draw_ctext();
  98. void x_draw_text();
  99. void x_draw_cursor();
  100.  
  101.  
  102. void x_draw_flush() { }
  103.  
  104. void x_draw_set_redraw(f)
  105. PRD f;
  106. { x_draw_redraw = f; 
  107.  }
  108.  
  109. void x_draw_set_frame_label(message)
  110. char* message;
  111. { strcpy(frame_label,message);
  112.   }
  113.  
  114. void x_draw_reset_frame_label()
  115. { x_draw_set_frame_label(default_frame_label);
  116.  }
  117.  
  118.  
  119. void x_draw_mouse_segment_action(x,y)
  120. double x,y;
  121. { setcolor(WHITE);
  122.   line(mouse_start_xpix,mouse_start_ypix,XPIX(x),YPIX(y));
  123.  }
  124.  
  125. void x_draw_mouse_rect_action(x,y)
  126. double x,y;
  127. { 
  128.    x_draw_rectangle(mouse_start_xreal,mouse_start_yreal,x,y,WHITE);
  129.  } 
  130.  
  131.  
  132. void x_draw_mouse_circle_action(x,y)
  133. double x,y;
  134. { double r = hypot(x - mouse_start_xreal, y - mouse_start_yreal);
  135.   setcolor(WHITE);
  136.   line(mouse_start_xpix,mouse_start_ypix-(int)(r*y_draw_scale),
  137.        mouse_start_xpix,mouse_start_ypix+(int)(r*y_draw_scale));
  138.   line(mouse_start_xpix+(int)(r*x_draw_scale),mouse_start_ypix,
  139.        mouse_start_xpix-(int)(r*x_draw_scale),mouse_start_ypix);
  140.  }
  141.  
  142.  
  143. void x_draw_set_font(fname)
  144. char* fname;
  145. { }
  146.  
  147.  
  148.  
  149.  
  150. static void x_draw_set_color(col)
  151. int col;
  152. { switch(col) 
  153.   { case 1 : col = WHITE;
  154.              break;
  155.     case 0 : col = BLACK;
  156.              break;
  157.     case 2 : col = LIGHTRED;
  158.              break;
  159.     case 3 : col = LIGHTGREEN;
  160.              break;
  161.     case 4 : col = LIGHTBLUE;
  162.              break;
  163.     case 5 : col = YELLOW;
  164.              break;
  165.     case 6 : col = LIGHTCYAN;
  166.              break;
  167.     case 7 : col = BROWN;
  168.              break;
  169.    }
  170.   setcolor(col);
  171.   setfillstyle(SOLID_FILL,col);
  172. }
  173.  
  174. int x_draw_set_line_width(w)
  175. int w;
  176. { int save = x_draw_line_width;
  177.   x_draw_line_width = w;
  178.   setlinestyle(x_draw_line_style,0,w);
  179.   return save;
  180. }
  181.  
  182.  
  183. int x_draw_set_line_style(s)
  184. int s;
  185. { int old = x_draw_line_style;
  186.   x_draw_line_style = s;
  187.   setlinestyle(s,0,x_draw_line_width);
  188.   return old;
  189. }
  190.  
  191.  
  192. int x_draw_set_mode(m)
  193. int m;
  194. { int old=x_draw_drawing_mode;
  195.   x_draw_drawing_mode=m;
  196.   setwritemode(m);
  197.   return old;
  198. }
  199.  
  200.  
  201. int x_draw_set_node_width(w)
  202. int w;
  203. { int save = x_draw_node_width;
  204.   x_draw_node_width = w;
  205.   return save;
  206.  }
  207.  
  208. int x_draw_set_text_mode(m)
  209. int m;
  210. { int save = x_draw_text_mode;
  211.   x_draw_text_mode = m;
  212.   return save;
  213.  }
  214.  
  215. static void draw_cursor(x,y)
  216. int x,y;
  217. { int save = getcolor();
  218.   int dx = 8;
  219.   int dy = 8*x_draw_aspect_ratio;
  220.   setcolor(WHITE);
  221.   setlinestyle(SOLID_LINE,0,THICK_WIDTH);
  222.   line(x-dx,y,x+dx,y);
  223.   line(x,y-dy,x,y+dy);
  224.   setlinestyle(x_draw_line_style,0,x_draw_line_width);
  225.   setcolor(save);
  226.  }
  227.  
  228.  
  229. int x_read_mouse_action(action, xstart,ystart,x,y)
  230. PMA   action;
  231. double xstart;
  232. double ystart;
  233. double *x;
  234. double *y;
  235. { 
  236.   int taste=0;
  237.   
  238.   union REGS regs;
  239.  
  240.   if (action==0)
  241.     action = x_draw_mouse_default_action; 
  242.  
  243.   setwritemode(XOR_PUT);
  244.  
  245.   mouse_start_xreal = xstart;
  246.   mouse_start_yreal = ystart;
  247.   mouse_start_xpix = XPIX(xstart);
  248.   mouse_start_ypix = YPIX(ystart);
  249.  
  250.   if (x_draw_grid_mode) x_draw_cursor();
  251.  
  252.   action(mouse_last_xreal,mouse_last_yreal);
  253.  
  254.   draw_cursor(mouse_last_xpix, mouse_last_ypix);
  255.  
  256.  
  257.   while (taste == 0)
  258.   { 
  259.     if (x_draw_have_mouse)
  260.     { regs.x.ax=03;
  261.       int86(0x33,®s,®s);
  262.       taste=regs.x.bx;
  263.       mouse_xpix=regs.x.cx;
  264.       mouse_ypix=regs.x.dx;
  265.      }
  266.     else
  267.     { char c;
  268.       c = getch();
  269.       switch(c) {
  270.         case KEY_LE: mouse_xpix -= 8; break;
  271.         case KEY_RI: mouse_xpix += 8; break;
  272.         case KEY_UP: mouse_ypix -= 8*x_draw_aspect_ratio; break;
  273.         case KEY_DO: mouse_ypix += 8*x_draw_aspect_ratio; break;
  274.         case    'j': mouse_ypix +=1; break;
  275.         case    'k': mouse_ypix -=1; break;
  276.         case    'l': mouse_xpix +=1; break;
  277.         case    'h': mouse_xpix -=1; break;
  278.         case    '1': taste = 1; break;
  279.         case    '2': taste = 4; break;
  280.         case    '3': taste = 2; break;
  281.         case     3 : closegraph(); exit(0); break;     /* ctrl-C */
  282.         case    13 : taste = 1; break;                 /* return */
  283.        }
  284.       }
  285.   
  286.     if (x_draw_grid_mode)  x_draw_cursor();
  287.    
  288.     mouse_xreal =  XREAL(mouse_xpix);
  289.     mouse_yreal =  YREAL(mouse_ypix);
  290.    
  291.     if (x_draw_grid_mode) 
  292.     { mouse_xreal = x_draw_grid_mode * (int)(mouse_xreal/x_draw_grid_mode + ((mouse_xreal > 0) ? 0.5 : -0.5));
  293.    
  294.       mouse_yreal = x_draw_grid_mode * (int)(mouse_yreal/x_draw_grid_mode + ((mouse_yreal > 0) ? 0.5 : -0.5));
  295.    
  296.       mouse_xpix  = XPIX(mouse_xreal);
  297.       mouse_ypix  = YPIX(mouse_yreal);
  298.       x_draw_cursor();
  299.     }
  300.           
  301.     if (mouse_last_xpix != mouse_xpix || mouse_last_ypix != mouse_ypix)
  302.     { action(mouse_last_xreal,mouse_last_yreal);
  303.       action(mouse_xreal,mouse_yreal);
  304.       draw_cursor(mouse_last_xpix,mouse_last_ypix);
  305.       draw_cursor(mouse_xpix,mouse_ypix);
  306.      }
  307. /*
  308.     if (x_draw_mouse_action)
  309.     { x_draw_mouse_action(mouse_last_xreal,mouse_last_yreal);
  310.       x_draw_mouse_action(mouse_xreal,mouse_yreal);
  311.      }
  312. */
  313.  
  314.     mouse_last_xpix = mouse_xpix;
  315.     mouse_last_ypix = mouse_ypix;
  316.           
  317.     mouse_last_xreal = mouse_xreal;
  318.     mouse_last_yreal = mouse_yreal;
  319.  
  320.    }
  321.  
  322.   if (x_draw_have_mouse)
  323.    while (regs.x.bx != 0)
  324.     { regs.x.ax=03;
  325.       int86(0x33,®s,®s);
  326.      }
  327.    
  328.    /* if (!x_draw_have_mouse)  */
  329.  
  330.    draw_cursor(mouse_xpix,mouse_ypix);
  331.    action(mouse_xreal,mouse_yreal);
  332.  
  333. /*
  334.     if (x_draw_mouse_action)  
  335.        x_draw_mouse_action(mouse_xreal,mouse_yreal);
  336. */
  337.    
  338.     if (x_draw_grid_mode) x_draw_cursor();
  339.    
  340.    
  341.   *x = mouse_xreal;
  342.   *y = mouse_yreal;
  343.  
  344.  setwritemode(COPY_PUT);
  345.  
  346.  switch (taste) {
  347.  case 1:  return 1;
  348.  case 4:  return 2;
  349.  case 2:  return 3;
  350.  default: return taste;
  351.  }
  352.  
  353. }
  354.  
  355.  
  356. int x_read_mouse(kind, xstart,ystart,x,y)
  357. int    kind;   /* 0: point, 1: segment, 2:rectangle, 3: circle */
  358. double xstart;
  359. double ystart;
  360. double *x;
  361. double *y;
  362. { 
  363.   PMA f;
  364.   int key;
  365.  
  366.   switch(kind) {
  367.  
  368.   case 0 : f = 0; /* x_draw_mouse_default_action; */
  369.           break;
  370.  
  371.   case 1:  f = x_draw_mouse_segment_action;
  372.            break;
  373.  
  374.   case 2:  f = x_draw_mouse_rect_action;
  375.            break;
  376.  
  377.   case 3:  f = x_draw_mouse_circle_action;
  378.            break;
  379.  
  380.   default: f = x_draw_mouse_default_action;
  381.            break;
  382.  
  383.   }
  384.  
  385.   key = x_read_mouse_action(f,xstart,ystart,x,y);
  386.  
  387.   return key;
  388.  
  389. }
  390.  
  391.  
  392. void x_draw_init_window(w_width,w_height,w_xpos,w_ypos,frame_label)
  393. int w_width;
  394. int w_height;
  395. int w_xpos;
  396. int w_ypos;
  397. char* frame_label;
  398. { 
  399.   int  i;
  400.   union REGS regs;
  401.   int fehler;
  402.   int xasp, yasp;
  403.  
  404.  
  405.  // ***** Initialisierung des Grafikfensters
  406.  
  407.    int gdriver=DETECT, gmode, errorcode;
  408.    //initgraph(&gdriver,&gmode,"\\TC\\BGI\\");
  409.  
  410.    initgraph(&gdriver,&gmode,"\\BORLANDC\\BGI\\");
  411.    errorcode=graphresult();
  412.  
  413.    if(errorcode != grOk)
  414.    {  printf(grapherrormsg(errorcode));
  415.       exit(1);
  416.    }
  417.  
  418.  // ***** Initialisierung des Mousetreibers
  419.    regs.x.ax=0;
  420.    int86(0x33,®s,®s);
  421.    fehler=regs.x.ax;
  422.    if (fehler != 0x0ffff)
  423.       x_draw_have_mouse = 0;
  424.     else
  425.       x_draw_have_mouse = 1;
  426.  
  427.  
  428.   strcpy(default_frame_label,frame_label);
  429.  
  430.   x_draw_depth = 1;
  431.  
  432.   x_draw_set_line_style(0);
  433.   x_draw_set_line_width(1);
  434.   x_draw_set_mode(0);
  435.   x_draw_set_node_width(12);
  436.   x_draw_set_text_mode(0); 
  437.  
  438.   x_draw_color = WHITE;
  439.  
  440.   x_draw_xmin = 0;
  441.   x_draw_ymin = 0;
  442.   x_draw_xmax = 0;
  443.   x_draw_ymax = 0;
  444.   x_draw_scale = 1;
  445.   y_draw_scale = 1;
  446.  
  447.   mouse_xpix = 0;
  448.   mouse_ypix = 0;
  449.   mouse_last_xpix = 0;
  450.   mouse_last_ypix = 0;
  451.  
  452.   getaspectratio(&xasp,&yasp);
  453.   x_draw_aspect_ratio = (float)xasp/(float)yasp;
  454.  
  455.   setfillstyle(SOLID_FILL,WHITE);
  456.  
  457.   if (! x_draw_have_mouse)
  458.      x_draw_acknowledge("NO MOUSE ! (use cursor keys)");
  459. }
  460.  
  461. void x_draw_init(x0,x1,y0,g_mode)
  462. double x0,x1,y0;
  463. int g_mode;
  464. {
  465.   if (x0>=x1) 
  466.   {fprintf(stderr,"Illegal arguments in draw_init: x0 (%f) >= x1 (%f)\n",x0,x1);
  467.    abort();
  468.    }
  469.  
  470.   x_draw_grid_mode = g_mode; 
  471.  
  472.   x_draw_reset_frame_label();
  473.  
  474.   xdots = getmaxx();
  475.   ydots = getmaxy();
  476.  
  477.  
  478.   x_draw_scale = ((double)xdots)/(x1-x0);
  479.   y_draw_scale = x_draw_scale * x_draw_aspect_ratio;
  480.  
  481.   /* at least grid distance of 2 pixels */
  482.   if ((x_draw_grid_mode) && (x_draw_grid_mode*x_draw_scale < 2)) 
  483.     x_draw_grid_mode=0;  
  484.  
  485.   if (x_draw_grid_mode) 
  486.   { if (x_draw_scale < 1) x_draw_scale = 1;
  487.     else x_draw_scale = (int)x_draw_scale;
  488.    }
  489.  
  490.   x_draw_xmin = x0;
  491.   x_draw_ymin = y0;
  492.   x_draw_xmax = x0+xdots/x_draw_scale;
  493.   x_draw_ymax = y0+ydots/y_draw_scale;
  494.  
  495.   xorigin = -x0*x_draw_scale;
  496.   yorigin = ydots+y0*y_draw_scale;
  497.  
  498.   mouse_xpix = mouse_last_xpix = getmaxx()/2;
  499.   mouse_ypix = mouse_last_ypix = getmaxy()/2;
  500.  
  501.   mouse_xreal = XREAL(mouse_xpix);
  502.   mouse_yreal = YREAL(mouse_ypix);
  503.  
  504.   x_draw_clear(0);   
  505.  
  506.   if (x_draw_grid_mode)  x_draw_cursor();
  507.  
  508.   if (x_draw_redraw) (*x_draw_redraw)();
  509.  
  510. }
  511.  
  512.  
  513. void x_show_window() 
  514. { }
  515.  
  516. void x_draw_end() { closegraph(); }
  517.  
  518. void x_draw_line(x1, y1, x2, y2, col)
  519. double x1,y1,x2,y2;
  520. int col;
  521. { x_draw_set_color(col);
  522.   line(XPIX(x1), YPIX(y1), XPIX(x2), YPIX(y2));
  523.  }
  524.  
  525.  
  526. void x_draw_point(x,y,col)
  527. double x,y;
  528. int col;
  529. { int X = XPIX(x);
  530.   int Y = YPIX(y);
  531.   x_draw_set_color(col);
  532.   setlinestyle(x_draw_line_style,0,1);
  533.   line(X-2,Y-2,X+2,Y+2);
  534.   line(X-2,Y+2,X+2,Y-2);
  535.   setlinestyle(x_draw_line_style,0,x_draw_line_width);
  536.  }
  537.  
  538. void x_draw_arc(x0,y0,a,b,col)
  539. double x0,y0;
  540. int a,b,col;
  541. { x_draw_set_color(col);
  542.   ellipse(XPIX(x0)-a,YPIX(y0)-b,0,360,2*a,2*b);
  543. }
  544.  
  545. void x_draw_filled_arc(x0,y0,a,b,col)
  546. double x0,y0;
  547. int a,b,col;
  548. { x_draw_set_color(col);
  549.   fillellipse(XPIX(x0)-a,YPIX(y0)-b,2*a,2*b);
  550. }
  551.  
  552. void x_draw_node(x0,y0,col)
  553. double x0,y0;
  554. int col;
  555. { int save = x_draw_set_line_width(1); 
  556.   x_draw_set_color(col);
  557.   circle(XPIX(x0),YPIX(y0),2*x_draw_node_width); 
  558.   x_draw_set_line_width(save); 
  559.  }
  560.  
  561. void x_draw_filled_node(x0,y0,col)
  562. double x0,y0;
  563. int col;
  564. { x_draw_set_color(col);
  565.   fillellipse(XPIX(x0),YPIX(y0),2*x_draw_node_width,
  566.                                 2*x_draw_node_width*x_draw_aspect_ratio); 
  567.  }
  568.  
  569.  
  570. void x_draw_text_node(x0,y0,s,col)
  571. double x0,y0;
  572. int col;
  573. char* s;
  574. { 
  575.   int save = x_draw_text_mode;
  576.   x_draw_text_mode = 0;  /* transparent */
  577.  
  578.   if (x_draw_depth==1 || col == 1)
  579.      x_draw_node(x0,y0,1);
  580.   else
  581.      x_draw_filled_node(x0,y0,col);
  582.  
  583.   x_draw_ctext(x0,y0,s,1);
  584.   x_draw_text_mode = save;
  585.  
  586.  }
  587.  
  588. void x_draw_int_node(x0,y0,i,col)
  589. double x0,y0;
  590. int i,col;
  591. { char buf[16];
  592.   sprintf(buf,"%d",i);
  593.   x_draw_text_node(x0,y0,buf,col);
  594.  }
  595.  
  596. void x_draw_ellipse(x0,y0,a,b,col)
  597. double x0,y0,a,b; 
  598. int col;
  599. { int A = (int)(a*x_draw_scale);
  600.   int B = (int)(b*y_draw_scale);
  601.   x_draw_arc(x0,y0,A,B,col); }
  602.  
  603. void x_draw_filled_ellipse(x0,y0,a,b,col)
  604. double x0,y0,a,b; 
  605. int col;
  606. { int A = (int)(a*x_draw_scale);
  607.   int B = (int)(b*y_draw_scale);
  608.   x_draw_filled_arc(x0,y0,A,B,col); }
  609.  
  610.  
  611. void x_draw_circle(x0,y0,r,col)
  612. double x0,y0,r; 
  613. int col;
  614. { int R = (int)(r*x_draw_scale);
  615.   x_draw_set_color(col);
  616.   circle(XPIX(x0),YPIX(y0),R); 
  617.  }
  618.  
  619.  
  620. void x_draw_filled_circle(x0,y0,r,col)
  621. double x0,y0,r; 
  622. int col;
  623. { int A = (int)(r*x_draw_scale);
  624.   int B = (int)(r*y_draw_scale);
  625.   x_draw_set_color(col);
  626.   fillellipse(XPIX(x0),YPIX(y0),A,B); 
  627.  }
  628.  
  629.  
  630. int x_draw_xpix(x)
  631. double x;
  632. { return XPIX(x); }
  633.  
  634. int x_draw_ypix(x)
  635. double x;
  636. { return YPIX(x); }
  637.  
  638. void x_draw_pix(x,y,col)
  639. double x,y;
  640. int col;
  641. { 
  642.   putpixel(XPIX(x),YPIX(y),col);
  643.  }
  644.  
  645.  
  646. void x_draw_plot_xy(x0,x1,f,col)
  647. double x0,x1;
  648. double (*f)();
  649. int col;
  650. { } 
  651.  
  652. void x_draw_plot_yx(y0,y1,f,col)
  653. double y0,y1;
  654. double (*f)();
  655. int col;
  656. { }
  657.  
  658.  
  659. void x_draw_filled_polygon(n,xcoord,ycoord,col)
  660. int col, n;
  661. double *xcoord, *ycoord;
  662. {
  663.  int* points;
  664.  int  i;
  665.  
  666.  points = (int *) malloc(2*n*sizeof(int));
  667.  
  668.  for (i=0; i<n; i++)
  669.  { points[2*i]   = XPIX(xcoord[i]);
  670.    points[2*i+1] = YPIX(ycoord[i]);
  671.   }
  672.  
  673.  x_draw_set_color(col);
  674.  
  675.  fillpoly(n,points);
  676.  
  677.  free((char*)points);
  678.  
  679.  }
  680.  
  681. void x_draw_polygon(n,xcoord,ycoord,col)
  682. int col, n;
  683. double *xcoord, *ycoord;
  684. {
  685.  int* points;
  686.  int  i;
  687.  
  688.  points = (int *) malloc(2*(n+1)*sizeof(int));
  689.  
  690.  for (i=0; i<n; i++)
  691.  { points[2*i]   = XPIX(xcoord[i]);
  692.    points[2*i+1] = YPIX(ycoord[i]);
  693.   }
  694.  
  695.  points[2*n]   = points[0];
  696.  points[2*n+1] = points[1];
  697.  
  698.  x_draw_set_color(col);
  699.  
  700.  drawpoly(n+1,points);
  701.  
  702.  free((char*)points);
  703.  
  704.  }
  705.  
  706. void x_draw_rectangle(x1,y1,x2,y2,col)
  707. double x1,y1,x2,y2;
  708. int col;
  709. {
  710.  x_draw_line(x1,y1,x1,y2,col);
  711.  x_draw_line(x1,y2,x2,y2,col);
  712.  x_draw_line(x2,y2,x2,y1,col);
  713.  x_draw_line(x2,y1,x1,y1,col);
  714.  
  715.  }
  716.  
  717.  
  718. void x_draw_filled_rectangle(x1,y1,x2,y2,col)
  719. double x1,y1,x2,y2; 
  720. int col;
  721. { double xcoord[4], ycoord[4];
  722.  
  723.  xcoord[0] = x1;   
  724.  ycoord[0] = y1;   
  725.  xcoord[1] = x1;  
  726.  ycoord[1] = y2;   
  727.  xcoord[2] = x2; 
  728.  ycoord[2] = y2;   
  729.  xcoord[3] = x2;
  730.  ycoord[3] = y1;
  731.  
  732.  x_draw_filled_polygon(4,xcoord,ycoord,col);
  733.  
  734.  }
  735.  
  736.  
  737. void x_draw_copy_rect(x1,y1,x2,y2,x,y)
  738. double x1,y1,x2,y2,x,y;
  739. { int X1 = XPIX(x1);
  740.   int Y1 = XPIX(y1);
  741.   int X2 = XPIX(x2);
  742.   int Y2 = XPIX(y2);
  743.   int p[16000];
  744.   if (X1 > X2 || Y1 > Y2) return;
  745.   if ((X2-X1+1)*(Y2-Y1+1)/8 > 16000) return;
  746.   getimage(X1,Y1,X2,Y2,p);
  747.   putimage(XPIX(x),YPIX(y),p,COPY_PUT);
  748. }
  749.  
  750.  
  751. /*
  752. void x_draw_move_rect(x1,y1,x2,y2,x,y)
  753. double x1,y1,x2,y2,x,y;
  754. {}
  755. */
  756.  
  757.  
  758.  
  759. void x_draw_clear(col)
  760. int col;
  761. { clearviewport(); 
  762.   setcolor(WHITE);
  763.   outtextxy(30,1,frame_label);
  764.  } 
  765.  
  766.  
  767. /* TEXT  */
  768.  
  769. static void x_draw_clear_text(x,y,s,center)
  770. int x,y;
  771. char * s;
  772. int center;
  773. { int width = textwidth(s);
  774.   int height = textheight(s);
  775.   int frame[10];
  776.   if (center != 0)
  777.   { frame[0] = x-width/2;
  778.     frame[1] = y-height/2;
  779.    }
  780.   else
  781.   { frame[0]=x; 
  782.     frame[1]=y;
  783.    }
  784.   frame[2]=frame[0]+width; 
  785.   frame[3]=frame[1];
  786.   frame[4]=frame[0]+width; 
  787.   frame[5]=frame[1]+height;
  788.   frame[6]=frame[0]; 
  789.   frame[7]=frame[1]+height;
  790.   frame[8]=frame[0]; 
  791.   frame[9]=frame[1];
  792.  
  793.  setcolor(BLACK);
  794.  setfillstyle(SOLID_FILL,BLACK);
  795.  fillpoly(5,frame);
  796. }
  797.   
  798.  
  799. void x_draw_message(line,s,col)
  800. int line;
  801. char * s;
  802. int col;
  803. { int x = 5*textwidth("H");
  804.   int y = (int)(1.25*textheight("H")*(line+1));
  805.   settextstyle(DEFAULT_FONT,HORIZ_DIR,1);
  806.   settextjustify(LEFT_TEXT,TOP_TEXT);
  807.   setcolor(WHITE);
  808.   outtextxy(x,y,s);
  809.  }
  810.  
  811. void x_draw_ctext(x,y,s,col)
  812. double x,y;
  813. char * s;
  814. int col;
  815. { if (x_draw_text_mode != 0) x_draw_clear_text(x,y,s,1);
  816.   settextstyle(DEFAULT_FONT,HORIZ_DIR,1);
  817.   settextjustify(CENTER_TEXT,CENTER_TEXT);
  818.   x_draw_set_color(col);
  819.   outtextxy(x,y,s);
  820. }
  821.  
  822. void x_draw_text(x,y,s,col)
  823. double x,y;
  824. char * s;
  825. int col;
  826. { if (x_draw_text_mode != 0) x_draw_clear_text(x,y,s,0);
  827.   settextstyle(DEFAULT_FONT,HORIZ_DIR,1);
  828.   settextjustify(LEFT_TEXT,TOP_TEXT);
  829.   x_draw_set_color(col);
  830.   outtextxy(XPIX(x),YPIX(y),s);
  831. }
  832.  
  833. void x_draw_int(x0,y0,i,col)
  834. double x0,y0;
  835. int i,col;
  836. { char buf[16];
  837.   sprintf(buf,"%d",i);
  838.   x_draw_ctext(x0,y0,buf,col);
  839.  }
  840.  
  841.  
  842. void x_draw_cursor()
  843. { 
  844.   int X,Y;
  845.  
  846.   X = XPIX(mouse_xreal);
  847.   Y = YPIX(mouse_yreal);
  848.  
  849.   line(X,Y,X+10,Y);
  850.   line(X,Y,X-10,Y);
  851.   line(X,Y,X,Y+10);
  852.   line(X,Y,X,Y-10);
  853.  
  854. }
  855.  
  856.  
  857.  
  858. int x_draw_confirm(header)
  859. char *header;
  860. { /* ask for yes or no */
  861.   char* s[2];
  862.   s[0] = "NO";
  863.   s[1] = "YES";
  864.   return x_draw_read_panel(header,2,s,0);
  865. }
  866.  
  867. int x_draw_acknowledge(header)
  868. char *header;
  869. { /* ask for ok */
  870.   char* s[1];
  871.   s[0] = "OK";
  872.  
  873.   mouse_last_xpix = mouse_xpix = getmaxx()/2;
  874.   mouse_last_ypix = mouse_ypix = getmaxy()/2 + 10;
  875.  
  876.   return x_draw_read_panel(header,1,s,0);
  877. }
  878.  
  879. int x_draw_screen_width() { return(getmaxx()); }
  880.  
  881.  
  882. int x_draw_screen_height() { return(getmaxx()); }
  883.  
  884. static void x_draw_putch(x,y,ch,col)
  885. int x;
  886. int y;
  887. char ch;
  888. int col;
  889. { char out[2];
  890.   out[0] = ch;
  891.   out[1] = 0;
  892.   setcolor(col);
  893.   outtextxy(x,y,out);
  894. }
  895.  
  896. char* x_draw_read_text_panel(message,menu_label,n,items)
  897. char    *message;
  898. char    *menu_label;
  899. int      n;
  900. char   **items;
  901. { union REGS regs;
  902.  
  903.   int i;
  904.   int tw,mw;
  905.   int x1,x2,y1,y2;
  906.   int p[5000];
  907.   char c;
  908.  
  909.   int cw = textwidth("H");
  910.  
  911.   int loop=0;
  912.   char* result = (char*)malloc(32);
  913.   int maxx=getmaxx();
  914.   int maxy=getmaxy();
  915.   int save_color=getcolor();
  916.   int poly[10];
  917.  
  918.   n = 0;
  919.   menu_label = "";
  920.   items = 0;
  921.  
  922.   if (strlen(message) == 0) message = "STRING INPUT";
  923.   if (strlen(message) > 31) message[31] = 0;
  924.  
  925.   mw = textwidth(message);
  926.   tw = 24*cw;
  927.  
  928.   setcolor(BLACK);
  929.  
  930.   settextstyle(DEFAULT_FONT,HORIZ_DIR,1);
  931.   settextjustify(LEFT_TEXT,TOP_TEXT);
  932.   setwritemode(COPY_PUT);
  933.  
  934.   x1 = (maxx-tw-mw-30)/2;
  935.   x2 = x1+tw+mw+30;
  936.   y1 = maxy/2-15;
  937.   y2 = maxy/2+15;
  938.  
  939.   getimage(x1,y1,x2,y2,p);
  940.   poly[0]=x1; poly[1]=y1;
  941.   poly[2]=x2; poly[3]=y1;
  942.   poly[4]=x2; poly[5]=y2;
  943.   poly[6]=x1; poly[7]=y2;
  944.   poly[8]=x1; poly[9]=y1;
  945.   setfillstyle(SOLID_FILL,LIGHTBLUE);
  946.   fillpoly(5,poly);
  947.   outtextxy(x1+10,y1+12,message);
  948.  
  949.   line(x1+10,y1+20,x2-10,y1+20);
  950.  
  951.   x2 = x1 + mw + 20;
  952.   y2 = y1+12;
  953.  
  954.  
  955.   x_draw_putch(x2,y2,'|',BLACK);
  956.  
  957.   c=getch();
  958.  
  959.   while(c != 13)
  960.   { int x = x2+loop*cw;
  961.     if (loop < 23 && isprint(c))
  962.     { result[loop]=c;
  963.       x_draw_putch(x,y2,'|',LIGHTBLUE);
  964.       x_draw_putch(x,y2,c,BLACK);
  965.       loop++;
  966.       x_draw_putch(x+cw,y2,'|',BLACK);
  967.     }
  968.     if(c==8 && loop>0)
  969.     { loop--;
  970.       x_draw_putch(x,y2,'|',LIGHTBLUE);
  971.       x_draw_putch(x-cw,y2,result[loop],LIGHTBLUE);
  972.       x_draw_putch(x-cw,y2,'|',BLACK);
  973.     }
  974.     c=getch();
  975.   }
  976.  
  977.   result[loop]='\0';
  978.  
  979.   putimage(x1,y1,p,COPY_PUT);
  980.  
  981.   setcolor(save_color);
  982.  
  983.   return result;
  984. }
  985.  
  986. int x_draw_read_panel(message,n,labels,vertical)
  987. char    *message;
  988. int n;
  989. char    **labels;
  990. int    vertical;
  991. { 
  992.   union REGS regs;
  993.   unsigned int size;
  994.   int answer= -1;
  995.   int save_color;
  996.   int i;
  997.   int panel_width;
  998.   int frame[10],but[10];
  999.   int buffer[6000];
  1000.  
  1001.   int L[16]; 
  1002.   int R[16]; 
  1003.  
  1004.   int panel_height = 54;
  1005.   int mes_y = 10;
  1006.   int y0 = 30;
  1007.   int xskip  = 30;
  1008.   int xspace = 5;
  1009.   int yspace = 3;
  1010.   int panel_y = (getmaxy()-panel_height)/2;
  1011.   int panel_x;
  1012.   int mes_x;
  1013.   int mes_width = textwidth(message);
  1014.  
  1015.   int y1 = y0 + textheight("H") + 2*yspace;
  1016.  
  1017.   if (vertical !=0 ) vertical = 0;
  1018.  
  1019.   panel_width = xskip;
  1020.  
  1021.   for(i=0;i<n;i++)
  1022.   { L[i] = panel_width;
  1023.     panel_width += 2*xspace+textwidth(labels[i]);
  1024.     R[i] = panel_width;
  1025.     panel_width += xskip;
  1026.    }
  1027.  
  1028.  
  1029.   mes_x = (panel_width-mes_width)/2;
  1030.  
  1031.   if (mes_x < xskip)
  1032.   { int d = xskip - mes_x;
  1033.     for(i=0;i<n;i++)
  1034.     { L[i] += d;
  1035.       R[i] += d;
  1036.      }
  1037.     panel_width += 2*d;
  1038.     mes_x = xskip;
  1039.   }
  1040.  
  1041.   panel_x = (getmaxx()-panel_width)/2;
  1042.  
  1043.   frame[0]=panel_x; 
  1044.   frame[1]=panel_y;
  1045.   frame[2]=panel_x+panel_width; 
  1046.   frame[3]=panel_y;
  1047.   frame[4]=panel_x+panel_width; 
  1048.   frame[5]=panel_y+panel_height;
  1049.   frame[6]=panel_x; 
  1050.   frame[7]=panel_y+panel_height;
  1051.   frame[8]=panel_x; 
  1052.   frame[9]=panel_y;
  1053.  
  1054.   /* save picture */
  1055.  
  1056.   getimage(frame[0],frame[1],frame[4],frame[5],buffer);
  1057.  
  1058.  
  1059.   settextstyle(DEFAULT_FONT,HORIZ_DIR,1);
  1060.   settextjustify(LEFT_TEXT,TOP_TEXT);
  1061.   setwritemode(COPY_PUT);
  1062.   setlinestyle(SOLID_LINE,0,2);
  1063.  
  1064.   save_color = getcolor();
  1065.   setcolor(LIGHTBLUE); 
  1066.   setfillstyle(SOLID_FILL,LIGHTBLUE);
  1067.  
  1068.   fillpoly(5,frame);
  1069.  
  1070.   setcolor(BLACK);
  1071.   for (i=0;i<n;i++)
  1072.   { rectangle(panel_x+L[i],panel_y+y0,panel_x+R[i],panel_y+y1);
  1073.     outtextxy(panel_x+L[i]+xspace,panel_y+y0+yspace,labels[i]);
  1074.    }
  1075.  
  1076.   outtextxy(panel_x+mes_x,panel_y+mes_y,message);
  1077.  
  1078.   setcolor(save_color);
  1079.  
  1080.   while (answer == -1)
  1081.   { 
  1082.     double x,y;
  1083.     int xpix,ypix;
  1084.  
  1085.     x_read_mouse(0,0.0,0.0,&x,&y);
  1086.  
  1087.     xpix = XPIX(x) - panel_x;
  1088.     ypix = YPIX(y) - panel_y;
  1089.  
  1090.     if ( y0 < ypix  && ypix < y1) 
  1091.     { int i = 0;
  1092.       while (i < n && R[i] < xpix) i++;
  1093.       if (i < n && L[i] < xpix)  answer = i;
  1094.      }
  1095.    }
  1096.  
  1097.  /* highlight pressed button */
  1098.  
  1099.  but[0] = panel_x+L[answer];
  1100.  but[1] = panel_y+y0;
  1101.  but[2] = panel_x+R[answer];
  1102.  but[3] = panel_y+y0;
  1103.  but[4] = panel_x+R[answer];
  1104.  but[5] = panel_y+y1;
  1105.  but[6] = panel_x+L[answer];
  1106.  but[7] = panel_y+y1;
  1107.  but[8] = panel_x+L[answer];
  1108.  but[9] = panel_y+y0;
  1109.  
  1110.  setfillstyle(SOLID_FILL,BLACK);
  1111.  fillpoly(5,but);
  1112.  outtextxy(panel_x+L[answer]+xspace,panel_y+y0+yspace,labels[answer]);
  1113.  setfillstyle(SOLID_FILL,LIGHTBLUE);
  1114.  delay(200);
  1115.  
  1116.   putimage(frame[0],frame[1],buffer,COPY_PUT);
  1117.  
  1118.   return answer;
  1119. }
  1120.  
  1121. void x_draw_message_panel(argc,argv)
  1122. int argc;
  1123. char** argv;
  1124. { }
  1125.  
  1126. void x_draw_notice()
  1127. { }
  1128.