home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / src / graphics / _win_inp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  6.1 KB  |  342 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  _win_input.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. #include <LEDA/window.h>
  17. #include <math.h>
  18. #include "global.c"
  19.  
  20.  
  21. //------------------------------------------------------------------------------
  22. // INPUT
  23. //------------------------------------------------------------------------------
  24.  
  25. int  window::confirm(string s)     { return x_draw_confirm(~s); }
  26. void window::acknowledge(string s) { x_draw_acknowledge(~s); }
  27.  
  28.  
  29. int window::read_mouse()
  30. { double X,Y;
  31.   return x_read_mouse(0,0.0,0.0,&X,&Y);
  32. }
  33.  
  34.  
  35. int  window::read_mouse(real& x, real& y)
  36. { double X,Y;
  37.   int key = x_read_mouse(0,0.0,0.0,&X,&Y);
  38.   x =  X;
  39.   y =  Y;
  40.   return key;
  41. }
  42.  
  43. int  window::read_mouse(point& q)
  44. { double X,Y;
  45.   int key = x_read_mouse(0,0.0,0.0,&X,&Y);
  46.   q = point(X,Y);
  47.   return key;
  48. }
  49.  
  50.  
  51.  
  52. int  window::read_mouse_seg(double x0, double y0, real& x, real& y)
  53. { double X,Y;
  54.   int key = x_read_mouse(1,x0,y0,&X,&Y);
  55.   x =  X;
  56.   y =  Y;
  57.   return key;
  58. }
  59.  
  60. int  window::read_mouse_seg(point p, point& q)
  61. { double X,Y;
  62.   int key = x_read_mouse(1,p.xcoord(),p.ycoord(),&X,&Y);
  63.   q = point(X,Y);
  64.   return key;
  65. }
  66.  
  67.  
  68. int  window::read_mouse_rect(double x0, double y0, real& x, real& y)
  69. { double X,Y;
  70.   int key = x_read_mouse(2,x0,y0,&X,&Y);
  71.   x =  X;
  72.   y =  Y;
  73.   return key;
  74. }
  75.  
  76.  
  77. int  window::read_mouse_rect(point p, point& q)
  78. { double X,Y;
  79.   int key = x_read_mouse(2,p.xcoord(),p.ycoord(),&X,&Y);
  80.   q = point(X,Y);
  81.   return key;
  82. }
  83.  
  84.  
  85. int  window::read_mouse_circle(double x0, double y0, real& x, real& y)
  86. { double X,Y;
  87.   int key = x_read_mouse(3,x0,y0,&X,&Y);
  88.   x =  X;
  89.   y =  Y;
  90.   return key;
  91. }
  92.  
  93. int  window::read_mouse_circle(point p, point& q)
  94. { double X,Y;
  95.   int key = x_read_mouse(3,p.xcoord(),p.ycoord(),&X,&Y);
  96.   q = point(X,Y);
  97.   return key;
  98. }
  99.  
  100.  
  101. int window::read_mouse_action(mouse_action_func_ptr f, real& x, real& y)
  102. { double X,Y;
  103.   int key = x_read_mouse_action(f,0.0,0.0,&X,&Y);
  104.   x =  X;
  105.   y =  Y;
  106.   return key;
  107. }
  108.  
  109. int window::read_mouse_action(mouse_action_func_ptr f, point& q)
  110. { double X,Y;
  111.   int key = x_read_mouse_action(f,0.0,0.0,&X,&Y);
  112.   q = point(X,Y);
  113.   return key;
  114. }
  115.  
  116.  
  117.  
  118. window& window::read(point& p)
  119. { real x,y;
  120.   state = 1;
  121.   int k;
  122.   while ((k = read_mouse(x,y)) != 1) 
  123.    if (k == 3) 
  124.     { state = 0;
  125.       return *this;
  126.      }
  127.   p = point(x,y);
  128.   return *this;
  129.  }
  130.  
  131.  
  132. window& window::read(segment& s)
  133. { real x,y;
  134.   point p;
  135.   int key = 0;
  136.   state = 1;
  137.  
  138.   if (!read(p)) 
  139.    return *this;
  140.  
  141.   while ((key=read_mouse_seg(p.xcoord(),p.ycoord(),x,y)) != 1)
  142.   { if (key== 3)  
  143.      { state = 0;
  144.        break; 
  145.       }
  146.  
  147.     if (key==-1)
  148.       if (!read(p)) break;
  149.    }
  150.  
  151.    if (state) s = segment(p.xcoord(),p.ycoord(),x,y);
  152.  
  153.   return *this;
  154. }
  155.  
  156. window& window::read(line& l)
  157. { segment s;
  158.   state = 1;
  159.   read(s);
  160.   if (state) l = line(s);
  161.   return *this;
  162.  }
  163.  
  164.  
  165. window& window::read(circle& c)
  166. { real x,y;
  167.   point p;
  168.   int key = 0;
  169.   state = 1;
  170.  
  171.   if (!read(p)) 
  172.    return *this;
  173.  
  174.   drawing_mode save = set_mode(xor_mode);
  175.   draw(p);
  176.  
  177.   while ((key=read_mouse_circle(p.xcoord(),p.ycoord(),x,y)) != 1)
  178.   { if (key== 3)  
  179.      { state = 0;
  180.        break; 
  181.       }
  182.  
  183.     if (key==-1)
  184.     { draw(p);
  185.       if (!read(p)) break;
  186.       draw(p);
  187.      }
  188.    }
  189.    if (state) 
  190.    { double dx = x-p.xcoord();
  191.      double dy = y-p.ycoord();
  192.      c = circle(p,hypot(dx,dy));
  193.      draw(p);
  194.     }
  195.  
  196.   set_mode(save);
  197.   return *this;
  198. }
  199.  
  200. window& window::read(polygon& P)
  201. { real x,y;
  202.   int key = 0;
  203.   state = 1;
  204.   point p;
  205.  
  206.   list(point) pl;
  207.  
  208.   if (!read(p)) return *this;
  209.  
  210.   pl.append(p);
  211.  
  212.   drawing_mode save = set_mode(xor_mode);
  213.  
  214.   while ((key = read_mouse_seg(p.xcoord(),p.ycoord(),x,y)) !=2)
  215.   { 
  216.     if (key==3) break;
  217.  
  218.  
  219.     if (key==-1 && (pl.length() > 1 )) 
  220.     { point l = pl.Pop();
  221.       draw_segment(pl.tail(),l);
  222.       p = pl.tail();
  223.      }
  224.  
  225.     if (key==1)
  226.     { pl.append(point(x,y));
  227.       draw_segment(p,pl.tail());
  228.       p = pl.tail();
  229.      }
  230.   }
  231.  
  232.   point first = pl.head();
  233.  
  234.   draw_segment(pl.tail(),pl.head());
  235.  
  236.   P = polygon(pl);
  237.  
  238.   draw(P);
  239.  
  240.   if (key==3)
  241.   { state = 0;
  242.     P = 0;
  243.    }
  244.  
  245.   set_mode(save);
  246.  
  247.   return *this;
  248.  
  249. }
  250.  
  251.  
  252. window& window::operator>>(point& p)    
  253. { x_draw_set_frame_label(">> POINT");
  254.   read(p); 
  255.   x_draw_reset_frame_label();
  256.   return *this; 
  257.  }
  258.  
  259. window& window::operator>>(segment& s)  
  260. { x_draw_set_frame_label(">> SEGMENT");
  261.   read(s); 
  262.   x_draw_reset_frame_label();
  263.   return *this; 
  264.  }
  265.  
  266. window& window::operator>>(line& l)     
  267. { x_draw_set_frame_label(">> LINE");
  268.   read(l); 
  269.   x_draw_reset_frame_label();
  270.   return *this; 
  271.  }
  272.  
  273. window& window::operator>>(circle& C)   
  274. { x_draw_set_frame_label(">> CIRCLE");
  275.   read(C); 
  276.   x_draw_reset_frame_label();
  277.   return *this; 
  278.  }
  279.  
  280. window& window::operator>>(polygon& P)  
  281. { x_draw_set_frame_label(">>POLYGON");
  282.   read(P); 
  283.   x_draw_reset_frame_label();
  284.   return *this; 
  285.  }
  286.  
  287.  
  288.  
  289.  
  290.  
  291. int  window::read_panel(string header, int n, string* L)
  292. { char** p = new char*[n];
  293.   for(int i = 0; i < n; i++) p[i] = ~L[i];
  294.   return x_draw_read_panel(~header,n,p,0);
  295.  }
  296.  
  297.  
  298. int  window::read_vpanel(string header, int n, string* L)
  299. { char** p = new char*[n];
  300.   for(int i = 0; i < n; i++) p[i] = ~L[i];
  301.   return x_draw_read_panel(~header,n,p,1);
  302.  }
  303.  
  304.  
  305.  
  306. string  window::read_string(string header)
  307. { return x_draw_read_text_panel(~header,0,0,0); }
  308.  
  309.  
  310. string  window::read_string(string header,string menu_label,list(string)& L)
  311. {  char** p = new char*[L.length()];
  312.    int    i = 0;
  313.    string s;
  314.    forall(s,L) 
  315.     if (s.length() > 0) p[i++] = ~s;
  316.    return x_draw_read_text_panel(~header,~menu_label,i,p); 
  317. }
  318.  
  319. string  window::read_string(string header,list(string)& L)
  320. {  char** p = new char*[L.length()];
  321.    int    i = 0;
  322.    string s;
  323.    forall(s,L) 
  324.     if (s.length() > 0) p[i++] = ~s;
  325.    return x_draw_read_text_panel(~header,"",i,p); 
  326. }
  327.  
  328. int  window::read_int(string s)
  329. { string_istream in(x_draw_read_text_panel(~s,0,0,0));
  330.   int res;
  331.   in >> res;
  332.   return res;
  333.  }
  334.  
  335. real  window::read_real(string s)
  336. { string_istream in(x_draw_read_text_panel(~s,0,0,0));
  337.   double res;
  338.   in >> res;
  339.   return res;
  340.  }
  341.  
  342.