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

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

数值算法/人工智能

开发平台：

MultiPlatform

window.h：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  window.h
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  13. #ifndef LEDA_WINDOW_H
  14. #define LEDA_WINDOW_H
  16. #include <LEDA/basic.h>
  17. #include <LEDA/plane.h>
  18. #include <LEDA/leda_window.h>
  19. #include <LEDA/leda_panel.h>
  23. /*{Manpage {window} {} {Graphic Windows}}*/
  25. class window : public LEDA_WINDOW {
  27. /*{Mdefinition
  28. The data type $window$ provides an interface for the input and
  29. output of basic two-dimensional geometric objects (cf.~section 5.1) using the
  30. X11 window system.  Application programs using data type $window$ have to
  31. be linked with {em libWx.a} and the X11 library (cf.~section~1.6):
  33. CC $prog.c$ -lP -lG -lL -lWx -lX11 -lm
  37. An instance $W$ of the data type $window$ is an iso-oriented
  38. rectangular window in the two-dimensional plane.
  39. The default representation of $W$ on the screen is a square of maximal possible
  40. edge length positioned in the upper right corner (cf.~creation, variant c)).
  41. The coordinates and scaling of $W$ used for drawing operations are defined
  42. by three double parameters:
  43. $x_0$, the x-coordinate of the left side, $x_1$, the x-coordinate of the right
  44. side, and $y_0$, the y-coordinate of the bottom side.
  45. The y-coordinate of the top side of $W$ is determined by the current size and
  46. shape of the window on the screen, which can be changed interactively.
  47. A graphic window supports operations for drawing points, lines, segments,
  48. arrows, circles, polygons, graphs, dots and for graphical input of all these
  49. objects using the mouse input device. Most of the drawing operations have an
  50. optional color argument. Possible colors are $black$ (default), $white$,
  51. $blue$, $green$, $red$, $violet$, and $orange$. On monochrome displays all
  52. colors different from $white$ are turned to $black$. There are 6 parameters
  53. used by the drawing operations:
  55. begin{enumerate}
  56. item
  57. The {sl line width} parameter (default value 1 pixel) defines the width of all
  58. kinds of lines (segments, arrows, edges, circles, polygons).
  60. item
  61. The {sl line style} parameter defines the style of lines. Possible line
  62. styles are $solid$ (default), $dashed$, and $dotted$.
  64. item
  65. The {sl node width} parameter (default value 10 pixels) defines the diameter
  66. of nodes created by the draw_node and draw_filled_node operations.
  68. item
  69. The {sl text mode} parameter defines how text is inserted into the window.
  70. Possible values are $transparent$ (default)  and $opaque$.
  72. item
  73. The {sl drawing mode} parameter defines the logical operation that is used
  74. for setting pixels in all drawing operations. Possible values are
  75. $src_mode$ (default) and $xor_mode$. In $src_mode$ pixels are set to
  76. the respective color value, in $xor_mode$ the value is bitwise added to the
  77. current pixel value.
  79. item
  80. The {sl redraw function} parameter is used to redraw the entire window
  81. whenever a redrawing is necessary, e.g., if the window shape on the screen
  82. has  been changed. Its type is pointer to a void-function taking no arguments,
  83. i.e., void (*F)();
  85. end{enumerate} }*/
  87. public:
  89. /*{Mcreation W }*/ 
  91. enum placement {min = -1, center =-2, max = -3 };
  94. window(float width, float height, float xpos, float ypos, const char* = LEDA::version_string);
  96. /*
  97. window(float xpix, float ypix, float xpos, float ypos);
  98. */
  99. /*{Mcreate creates a window $W$ of physical size $xpix times ypix$ pixels
  100.     with its upper left corner at position ($xpos,ypos$) on the screen.}*/
  103. window(float width, float height, const char* = LEDA::version_string);
  105. /*
  106. window(float xpix, float ypix);
  107. */
  108. /*{Mcreate creates a window $W$ of physical size $xpix times ypix$ pixels
  109.     positioned into the upper right corner of the screen.}*/
  112. window(const char* = LEDA::version_string);
  114. /*
  115. window();
  116. */
  117. /*{Mcreate creates a maximal squared window $W$ positioned into the 
  118.     upper right corner of the screen.}*/
  120. /*{Mtext
  122. medskip
  123. All three variants initialize the coordinates of $W$ to $x_0 = 0$,
  124. $x_1 = 100$ and $y_0 = 0$. The $init$ operation (see  below) can later
  125. be used to change the window coordinates and scaling.}*/
  128.  window(int);  // just create, do not open
  130.  window(const window& w) : LEDA_WINDOW(w) {}
  131. ~window() {}   // ~LEDA_WINDOW does this job
  133.  window& operator=(const window& w) 
  134.  { LEDA_WINDOW::operator=(w); return *this; }
  135.  
  137. /*{Moperations 3.1 4.4}*/
  139. /*{Mtext
  140. medskip
  141. {bf 3.1 Initialization} }*/
  143. void init(double x0,double x1,double y0) { LEDA_WINDOW::init(x0,x1,y0); }
  144. /*{Mopl     sets the coordinates of $W$ to $x_0$, $x_1$, and $y_0$.}*/
  147. void set_grid_mode(int d) {LEDA_WINDOW::set_grid_mode(d);}
  148. /*{Mopl     adds a rectangular grid with integer coordinates and  
  149.              grid distance $d$ to $W$, if $d > 0$. Removes grid from
  150.              $W$, if $dle 0$.}*/
  153. void init(double x0, double x1, double y0, int d) { LEDA_WINDOW::init(x0,x1,y0,d);}
  154. /*{Mopl     like init($x_0,x_1,y_0$) followed by set_grid_mode($d$).}*/
  157. void clear(color c=BG_color) { LEDA_WINDOW::clear(c); };
  158. /*{Mopl      clears $W$.}*/
  160. /*{Mtext
  161. medskip
  162. {bf 3.2 Setting parameters} }*/
  164. int set_line_width(int pix){return LEDA_WINDOW::set_line_width(pix);}
  165. /*{Mopl     sets the line width parameter to $pix$ pixels and
  166.      returns its previous value.}*/
  168. line_style set_line_style(line_style s)
  169. {return LEDA_WINDOW::set_line_style(s);}
  170. /*{Mopl     sets the line style parameter to $s$ and returns its
  171.      previous value.}*/
  173. int set_node_width(int pix) {return LEDA_WINDOW::set_node_width(pix);}
  174. /*{Mopl     sets the node width parameter to $pix$ pixels and
  175.      returns its previous value.}*/
  177. text_mode set_text_mode(text_mode m)
  178. {return LEDA_WINDOW::set_text_mode(m);}
  179. /*{Mopl     sets the text mode parameter to $m$ and returns
  180.      its previous value.}*/
  182. drawing_mode set_mode(drawing_mode m)
  183. {return LEDA_WINDOW::set_mode(m);}
  184. /*{Mopl     sets the drawing mode parameter to $m$ and returns 
  185.      its previous value.}*/
  187. void set_frame_label(string s){ LEDA_WINDOW::set_frame_label(s); }
  188. /*{Mopl     makes $s$ the window frame label. }*/
  190. void reset_frame_label() { LEDA_WINDOW::reset_frame_label(); }
  191. /*{Mop      restores the standard LEDA frame label. }*/
  193. void set_redraw(void (*F)()) { LEDA_WINDOW::set_redraw(*F);}
  194. /*{Mopl     sets the redraw function parameter to $F$.}*/
  197. void set_flush(bool b)     { LEDA_WINDOW::set_flush(b); }
  198. /*{Mopl      flushes $X11$ output stream after each draw action 
  199.              iff $b = true$.}*/
  201. bool load_text_font(string fn)    { return LEDA_WINDOW::load_text_font(fn); }
  202. /*{Mopl      loads $X11$ font $fn$ and uses it as text font. Returns true
  203.              on success and false if the font is not available.}*/
  205. bool load_bold_font(string fn)    { return LEDA_WINDOW::load_bold_font(fn); }
  206. /*{Mopl      loads $X11$ font $fn$ and uses it as bold font. Returns true
  207.              on success and false if the font is not available.}*/
  209. bool load_message_font(string fn) { return LEDA_WINDOW::load_message_font(fn); }
  210. /*{Mopl      load $X11$ font $fn$ and use it as message font. Returns true
  211.              on success and false if the font is not available.}*/
  214. /*{Mtext
  215. medskip
  216. {bf 3.3 Reading parameters and window coordinates} }*/
  218. int get_line_width() {return LEDA_WINDOW::get_line_width();}
  219. /*{Mop      returns the current line width.}*/ 
  221. line_style get_line_style() {return LEDA_WINDOW::get_line_style();}
  222. /*{Mop      returns the current line style.}*/ 
  224. int get_node_width() {return LEDA_WINDOW::get_node_width();}
  225. /*{Mop      returns the current node width.}*/ 
  227. text_mode get_text_mode() {return LEDA_WINDOW::get_text_mode();}
  228. /*{Mop      returns the current text mode.}*/ 
  230. drawing_mode get_mode() {return LEDA_WINDOW::get_mode();}
  231. /*{Mop      returns the current drawing mode.}*/ 
  233. double xmin() {return LEDA_WINDOW::xmin();}
  234. /*{Mop      returns $x_0$, the minimal x-coordinate of $W$.}*/ 
  236. double ymin() {return LEDA_WINDOW::ymin();}
  237. /*{Mop      returns $y_0$, the minimal y-coordinate of $W$.}*/ 
  239. double xmax() {return LEDA_WINDOW::xmax();}
  240. /*{Mop      returns $x_1$, the maximal x-coordinate of $W$.}*/ 
  242. double ymax() {return LEDA_WINDOW::ymax();}
  243. /*{Mop      returns $y_1$, the maximal y-coordinate of $W$.}*/ 
  245. double scale() {return LEDA_WINDOW::scale();}
  246. /*{Mop      returns the number of pixels of a unit length 
  247.      line segment.}*/
  249. operator void*() { return (state==0) ? 0 : this; }
  253. // points
  254. /*{Mtext
  255. medskip
  256. {bf 3.4 Drawing points} 
  257. setopdims 1.2 4.4
  258. }*/
  260. void draw_point(double x, double y, color c=FG_color);
  261. /*{Mopl     draws the point $(x,y)$ as a cross of a vertical 
  262.      and a horizontal segment intersecting at $(x,y)$.}*/
  264. void draw_point(const point& p, color c=FG_color);
  265. /*{Mopl     draws point ($p$.xcoord(),$p$.ycoord()).}*/
  267. void draw_pix(double x, double y, color c=FG_color);
  268. void draw_pixel(double x, double y, color c=FG_color) { draw_pix(x,y,c); }
  269. /*{Mopl     sets the color of the pixel at position $(x,y)$ to $c$. }*/
  271. void draw_pix(const point& p, color c=FG_color);
  272. void draw_pixel(const point& p, color c=FG_color) { draw_pix(p,c); }
  273. /*{Mopl     sets the color of the pixel at position $p$ to $c$. }*/
  276. // drawing segments
  277. /*{Mtext
  278. medskip
  279. {bf 3.5 Drawing line segments}
  280. }*/
  282. void draw_segment(double x1, double y1, double x2, double y2, color c=FG_color);
  283. /*{Mopl     draws a line segment from $(x_1,y_1)$ to $(x_2,y_2)$.}*/
  285. void draw_segment(const point& p, const point& q, color c=FG_color );
  286. /*{Mopl     draws a line segment from point $p$ to point $q$.}*/
  288. void draw_segment(const segment& s, color c=FG_color );
  289. /*{Mopl     draws line segment $s$.}*/
  291. // lines
  292. /*{Mtext
  293. medskip
  294. {bf 3.6 Drawing lines}
  295. }*/
  297. void draw_line(double x1, double y1, double x2, double y2, color c=FG_color );
  298. /*{Mopl     draws a straight line passing through points $(x_1,y_1)$ and 
  299.      $(x_2,y_2)$.}*/
  301. void draw_line(const point& p, const point& q, color c=FG_color);
  302. /*{Mopl     draws a straight line passing through points $p$ and $q$.}*/
  304. void draw_line(const segment& s, color c=FG_color);
  305. /*{Mopl     draws the line supporting $s$.}*/
  308. void draw_line(const line& l, color c=FG_color);
  309. /*{Mopl     draws line $l$.}*/
  311. void draw_hline(double y, color c=FG_color );
  312. /*{Mopl     draws a horizontal line with y-coordinate $y$. }*/
  314. void draw_vline(double x, color c=FG_color );
  315. /*{Mopl     draws a vertical line with x-coordinate $x$. }*/
  318. // drawing arcs
  320. void draw_arc(double x1, double y1, double x2, double y2, double r, color c=FG_color);
  321. void draw_arc(const segment&, double, color c=FG_color);
  322. void draw_arc(const point& p, const point& q, double r , color c=FG_color);
  323. /*{Mopl     draws a circular arc with radius r from p to q 
  324.              with the center lying  to the right of the
  325.              directed segment $plongrightarrow q$.  }*/
  329. // arrows
  330. /*{Mtext
  331. medskip
  332. {bf 3.7 Drawing arrows}
  333. }*/
  335. point draw_arrow_head(const point& q, double dir, color c=FG_color);
  337. void draw_arrow(double x1, double y1, double x2, double y2, color c =FG_color );
  338. /*{Mopl     draws an arrow pointing from $(x_1,y_1)$ to $(x_2,y_2)$.}*/
  340. void draw_arrow(const point& p, const point& q, color c=FG_color );
  341. /*{Mopl     draws an arrow pointing from point $p$ to point $q$.}*/
  343. void draw_arrow(const segment& s, color=FG_color );
  344. /*{Mopl     draws an arrow pointing from $s$.start() to $s$.end().}*/
  346. void draw_arc_arrow(double x1, double y1, double x2, double y2, double r,color c=FG_color);
  347. void draw_arc_arrow(const segment& s, double r, color c=FG_color);
  348. void draw_arc_arrow(const point& p , const point& q, double r, color c=FG_color);
  349. /*{Mopl      draws a circular arc arrow with radius r pointing from 
  350.              p to q with the center lying  to the right of the
  351.              directed segment $plongrightarrow q$.  }*/
  355. //circles
  356. /*{Mtext
  357. medskip
  358. {bf 3.8 Drawing circles}
  359. }*/
  361. void draw_circle(double x, double y, double r, color c=FG_color);
  362. /*{Mopl     draws the circle with center $(x,y)$ and radius $r$.}*/
  364. void draw_circle(const point& p, double r, color c=FG_color);
  365. /*{Mopl     draws the circle with center $p$ and radius $r$.}*/
  367. void draw_circle(const circle& C, color c=FG_color);
  368. /*{Mopl     draws circle $C$.}*/
  370. void draw_ellipse(double x, double y, double r1, double r2, color c=FG_color);
  371. /*{Mopl     draws the ellipse with center $(x,y)$ and radii $r1$ and $r2$.}*/
  373. void draw_ellipse(const point& p, double r1, double r2, color c=FG_color);
  374. /*{Mopl     draws the ellipse with center $p$ and radii $r1$ and $r2$.}*/
  378. /*{Mtext
  379. medskip
  380. {bf 3.9 Drawing discs}
  381. }*/
  383. void draw_disc(double x, double y, double r, color c=FG_color);
  384. /*{Mopl     draws a filled circle with center $(x,y)$ and radius $r$.}*/
  386. void draw_disc(const point& p, double r, color c=FG_color);
  387. /*{Mopl     draws a filled circle with center $p$ and radius $r$.}*/
  389. void draw_disc(const circle& C, color c=FG_color);
  390. /*{Mopl     draws filled circle $C$.}*/
  393. void draw_filled_ellipse(double x, double y, double r1, double r2, color c=FG_color);
  394. /*{Mopl  draws a filled ellipse with center $(x,y)$ and radii $r1$ and $r2$.}*/
  396. void draw_filled_ellipse(const point& p, double r1, double r2, color c=FG_color);
  397. /*{Mopl  draws a filled ellipse with center $p$ and radii $r1$ and $r2$.}*/
  400. //polygons 
  401. /*{Mtext
  402. medskip
  403. {bf 3.10 Drawing polygons }
  404. }*/
  406. void draw_polygon(const list<point>& lp, color c=FG_color );
  407. /*{Mopl     draws the polygon with vertex sequence $lp$.}*/
  409. void draw_polygon(const polygon& P, color c=FG_color );
  410. /*{Mopl     draws polygon $P$.}*/
  412. void draw_filled_polygon(const list<point>& lp, color c=FG_color );
  413. /*{Mopl     draws the filled polygon with vertex sequence $lp$.}*/
  415. void draw_filled_polygon(const polygon& P, color c=FG_color );
  416. /*{Mopl     draws filled polygon $P$.}*/
  418. void draw_rectangle(double a, double  b, double c, double d, color=FG_color);
  419. void draw_filled_rectangle(double a, double  b, double c, double d, color=FG_color);
  422. // functions
  423. /*{Mtext
  424. medskip
  425. {bf 3.11 Drawing functions}
  426. }*/
  428. void plot_xy(double x0, double x1, draw_func_ptr F, color c=FG_color);
  429. /*{Mopl     draws function $F$ in range $[x_0,x_1]$, i.e., all points 
  430.      $(x,y)$ with $y = F(x)$ and $x_0le xle x_1$.}*/
  432. void plot_yx(double y0, double y1, draw_func_ptr F, color c=FG_color);
  433. /*{Mopl     draws function $F$ in range $[y_0,y_1]$, i.e., all points 
  434.      $(x,y)$ with $x = F(y)$ and $y_0le yle y_1$.}*/
  439. // text
  440. /*{Mtext
  441. medskip
  442. {bf 3.12 Drawing text}
  443. }*/
  445. void draw_text(double x, double y, string s, color c=FG_color);
  446. /*{Mopl     writes string $s$ starting at position $(x,y)$.}*/
  448. void draw_text(const point& p, string s, color c=FG_color);
  449. /*{Mopl     writes string $s$ starting at position $p$.}*/
  451. void draw_ctext(double x, double y, string s, color c=FG_color);
  452. /*{Mopl     writes string $s$ centered at position $(x,y)$.}*/
  454. void draw_ctext(const point& p, string s, color c=FG_color);
  455. /*{Mopl     writes string $s$ centered at position $p$.}*/
  459. // nodes
  460. /*{Mtext
  461. medskip
  462. {bf 3.13 Drawing nodes}
  463. %Nodes are circles of diameter $node_width$.
  464. }*/
  466. void draw_node(double x0, double y0, color c=FG_color);
  467. /*{Mopl     draws a node at position $(x_0,y_0)$.}*/
  469. void draw_node(const point& p, color c=FG_color);
  470. /*{Mopl     draws a node at position $p$.}*/
  472. void draw_filled_node(double x0, double y0, color c=FG_color);
  473. /*{Mopl     draws a filled node at position $(x_0,y_0)$.}*/
  475. void draw_filled_node(const point& p, color c=FG_color);
  476. /*{Mopl     draws a filled node at position $p$.}*/
  478. void draw_text_node(double x, double y, string s, color c=BG_color);
  479. /*{Mopl     draws a node with label $s$ at position $(x,y)$. }*/
  481. void draw_text_node(const point& p, string s, color c=BG_color);
  482. /*{Mopl     draws a node with label $s$ at position $p$. }*/
  484. void draw_int_node(double x, double y, int i, color c=BG_color);
  485. /*{Mopl     draws a node with integer label $i$ at position 
  486.      $(x,y)$. }*/
  488. void draw_int_node(const point& p, int i, color c=BG_color);
  489. /*{Mopl     draws a node with integer label $i$ at position  $p$. }*/
  493. // edges
  494. /*{Mtext
  495. medskip
  496. {bf 3.14 Drawing edges}
  497. %Edges are straigth line segments or arrows with a clearance of 
  498. %$node_width/2$ at each end.
  499. }*/
  501. void draw_edge(double x1, double y1, double x2, double y2, color c=FG_color);
  502. /*{Mopl     draws an edge from $(x_1,y_1)$ to $(x_2,y_2)$.}*/
  504. void draw_edge(const point& p, const point& q, color c=FG_color);
  505. /*{Mopl     draws an edge from $p$ to $q$.}*/
  507. void draw_edge(const segment& s, color c=FG_color);
  508. /*{Mopl     draws an edge from $s$.start() to $s$.end().}*/
  510. void draw_edge_arrow(double x1, double y1, double x2, double y2, color c=FG_color);
  511. /*{Mopl     draws a directed edge from $(x_1,y_1)$ to $(x_2,y_2)$.}*/
  513. void draw_edge_arrow(const point& p, const point& q, color c=FG_color);
  514. /*{Mopl     draws a directed edge from $p$ to $q$.}*/
  516. void draw_edge_arrow(const segment& s, color c=FG_color);
  517. /*{Mopl     draws a directed edge from $s$.start() to $s$.end().}*/ 
  519. void draw_arc_edge(double x1, double y1, double x2, double y2, color c=FG_color);
  520. void draw_arc_edge(const segment& s, double r, color c=FG_color);
  521. void draw_arc_edge(const point& p, const point& q, double r, color c=FG_color);
  522. /*{Mopl     draws a circular edge arc with radius r from p to q 
  523.              with the center lying  to the right of the
  524.              directed segment $plongrightarrow q$.  }*/
  526. void draw_arc_edge_arrow(double x1, double y1, double x2, double y2, color c=FG_color);
  527. void draw_arc_edge_arrow(const segment& s, double r, color c=FG_color );
  528. void draw_arc_edge_arrow(const point& p, const point& q, double r, color c=FG_color);
  529. /*{Mopl     draws a circular directed edge arc with radius r from p 
  530.              to q with the center lying  to the right of the
  531.              directed segment $plongrightarrow q$.  }*/
  536. // mouse input
  537. /*{Mtext
  538. medskip
  539. {bf 3.15 Mouse Input}
  540. }*/
  543. int read_mouse();
  544. /*{Mop      displays the mouse cursor until a button is pressed.
  545.      Returns integer 1 for the left, 2 for the middle, and
  546.      3 for the right button (-1,-2,-3, if the shift key is
  547.      pressed simultaneously).}*/
  549. int read_mouse(double& x, double& y);
  550. /*{Mopl     displays the mouse cursor on the screen until a
  551.      button is pressed. When a button is pressed the
  552.              current position of the cursor is assigned
  553.              to $(x,y)$ and the pressed button is returned.}*/
  555. int read_mouse(point& p);
  556. /*{Mopl     displays the mouse cursor on the screen until a
  557.      button is pressed. When a button is pressed the
  558.              current position of the cursor is assigned
  559.              to $p$ and the pressed button is returned.}*/
  562. int read_mouse_seg(double x0, double y0, double& x, double& y);
  563. /*{Mopl     displays a line segment from $(x_0,y_0)$ to the
  564.      current cursor position until a mouse button is
  565.      pressed. When a button is pressed the current
  566.      position is assigned to $(x,y)$ and the pressed
  567.      button is returned.}*/
  569. int read_mouse_seg(const point& p, point& q);
  570. /*{Mopl     displays a line segment from $p$ to the current 
  571.              cursor position until a mouse button is
  572.      pressed. When a button is pressed the current
  573.      position is assigned to $q$ and the pressed
  574.      button is returned.}*/
  576. int read_mouse_rect(double x0, double y0, double& x, double& y);
  577. /*{Mopl     displays a rectangle with diagonal from $(x_0,y_0)$ 
  578.            to the current cursor position until a mouse button 
  579.      is pressed. When a button is pressed the current 
  580.      position is assigned to $(x,y)$ and the pressed 
  581.      button is returned.}*/
  583. int read_mouse_rect(const point& p, point& q);
  584. /*{Mopl     displays a rectangle with diagonal from $p$ 
  585.            to the current cursor position until a mouse button 
  586.      is pressed. When a button is pressed the current 
  587.      position is assigned to $q$ and the pressed 
  588.      button is returned.}*/
  590. int read_mouse_circle(double x0, double y0, double& x, double& y);
  591. /*{Mopl     displays a circle with center $(x_0,y_0)$ passing 
  592.      through the current cursor position until a mouse 
  593.      button is pressed. When a button is pressed the 
  594.      current position is assigned to $(x,y)$ and the 
  595.      pressed button is returned.}*/
  597. int read_mouse_circle(const point& p, point& q);
  598. /*{Mopl     displays a circle with center $p$ passing 
  599.      through the current cursor position until a mouse 
  600.      button is pressed. When a button is pressed the 
  601.      current position is assigned to $q$ and the 
  602.      pressed button is returned.}*/
  604. int read_mouse_action(mouse_action_func_ptr, double&, double&);
  605. int read_mouse_action(mouse_action_func_ptr, point&);
  608. int get_button();
  609. /*{Mop     non-blocking read operation, i.e., if a button was pressed 
  610.             its number is returned, otherwise $0$ is returned. }*/
  612. int get_button(double& x, double& y);
  613. /*{Mopl     if a button was pressed the corresponding position is
  614.             assigned to $(x,y)$ and the button number is returned, 
  615.             otherwise $0$ is returned. }*/
  617. int get_button(point& p);
  618. /*{Mop     if a button was pressed the corresponding position is
  619.             assigned to $p$ and the button number is returned, 
  620.             otherwise $0$ is returned. }*/
  622. /*{Mtext
  623. bigskip
  624. {bf 3.16 Events}
  625. }*/
  627. /* inherited:
  628. int  read_event(int& val, double& x, double& y);
  629. */
  630. /*{Mop    waits for next event in window W and returns it. 
  631.             Assigns the button or key to $val$ and the position
  632.             in $W$ to  $(x,y)$. Possible events are 
  633.             (cf. <LEDA/impl/x_window.h>): 
  634.             key_press_event, key_release_event,
  635.             button_press_event, button_release_event, 
  636.             configure_event,motion_event, destroy_event. }*/
  639. /* inherited:
  640. unsigned button_press_time();
  641. */
  642. /*{Mop     returns $X11$ time-stamp of last button press event. }*/
  645. /* inherited:
  646. unsigned button_release_time();
  647. */
  648. /*{Mop     returns $X11$ time-stamp of last button release event. }*/
  649.         
  650.  
  652. /*{Mtext
  653. bigskip
  654. {bf 3.17 Panel Input}
  655. }*/
  657. int     confirm(string s);
  658. /*{Mop      displays string $s$ and asks for confirmation. 
  659.      Returns true iff the answer was ``yes''.}*/
  661. void    notice(string s);
  662. void    acknowledge(string s);
  663. /*{Mopl     displays string $s$ and asks for acknowledgement.}*/
  666. int     read_panel(string h, int n, string*);
  667. /*{Mopl     displays a panel with header $h$ and an array $S[1..n]$  
  668.      of $n$ string buttons, returns the index of the selected 
  669.      button.}*/
  671. int     read_vpanel(string h, int n, string*);
  672. /*{Mopl     like read_panel with vertical button layout.}*/
  674. string  read_string(string p);
  675. /*{Mop      displays a panel with prompt $p$ for string input, 
  676.           returns the input.}*/
  678. double  read_real(string p);
  679. /*{Mop      displays a panel with prompt $p$ for real input 
  680.        returns the input.}*/
  682. int     read_int(string p);
  683. /*{Mop      displays a panel with prompt $p$ for integer input, 
  684.      returns the input.}*/
  689. // miscellaneous
  692. void message(string s) {LEDA_WINDOW::message(s);};
  693. /*{Mop      displays message $s$ (each call adds a new line).}*/
  695. void del_message()  { LEDA_WINDOW::del_messages(); };
  696. void del_messages() { LEDA_WINDOW::del_messages(); };
  697. /*{Mop      deletes the text written by all previous message 
  698.      operations.}*/
  700. void fill(double x, double y, color c=FG_color);
  702. void copy_rect(double x1, double y1, double x2, double y2, double x, double y);
  703. void move_rect(double x1, double y1, double x2, double y2, double x, double y);
  704. void copy(double x1, double y1, double x2, double y2, int i=0);
  705. void cut(double x1, double y1, double x2, double y2, int i=0);
  706. void paste(int i, double x, double y);
  707. void paste(double x, double y);
  708. void clear_buf(int i=0);
  714. // I/O operators
  715. /*{Mtext
  716. bigskip
  717. {bf 3.18 Input and output operators}
  719. For input and output of basic geometric objects in the plane such as points, 
  720. lines, line segments, circles, and polygons the $<<$ and $>>$ operators can 
  721. be used. Similar to CC input streams windows have an internal state indicating
  722. whether there is more input to read or not. Its initial value is true and it 
  723. is turned to false if an input sequence is terminated  by clicking the right 
  724. mouse button (similar to ending stream input by the eof character). In 
  725. conditional statements objects of type $window$ are automatically converted 
  726. to boolean by returning this internal state. Thus, they can be used in 
  727. conditional statements in the same way as CC input streams. For example,
  728. to read a sequence of points terminated by a right button click,  use 
  729. `` {bf while} ($W >> p$) ${  dots }$ ''. 
  730. }*/
  732. /*{Mtext
  733. medskip
  734. {bf 3.18.1 Output}
  735. setopdims 2.5 4.4
  736. }*/
  738. window& draw(const point& p,color c=FG_color)   
  739. { draw_point(p,c); return *this; }
  741. window& draw(const segment& s,color c=FG_color) 
  742. { draw_segment(s,c); return *this;}
  744. window& draw(const line& l,color c=FG_color)    
  745. { draw_line(l,c); return *this; }
  747. window& draw(const circle& C,color c=FG_color)  
  748. { draw_circle(C,c); return *this;}
  750. window& draw(const polygon& P,color c=FG_color )
  751. { draw_polygon(P,c); return *this;}
  753. window& operator<<(const point& p)   { return draw(p); }
  754. /*{Mbinop   like $W$.draw_point($p$).}*/
  756. window& operator<<(const segment& s) { return draw(s); }
  757. /*{Mbinop   like $W$.draw_segment($s$).}*/
  759. window& operator<<(const line& l)    { return draw(l); }
  760. /*{Mbinop   like $W$.draw_line($l$).}*/
  762. window& operator<<(const circle& C)  { return draw(C); }
  763. /*{Mbinop   like $W$.draw_circle($C$).}*/
  765. window& operator<<(const polygon& P) { return draw(P); }
  766. /*{Mbinop   like $W$.draw_polygon($P$).}*/
  768. /*{Mtext
  769. bigskip
  770. {bf 3.18.2 Input}
  771. }*/
  773. window& read(point&);
  774. window& read(segment&);
  775. window& read(line&);
  776. window& read(circle&);
  777. window& read(polygon&);
  779. window& operator>>(point& p);
  780. /*{Mbinop   reads a point $p$: clicking the left button 
  781.      assigns the current cursor position to $p$.}*/
  783. window& operator>>(segment& s);
  784. /*{Mbinop   reads a segment $s$: use the left button to input 
  785.      the start and end point of $s$.}*/
  787. window& operator>>(line& l);
  788. /*{Mbinop   reads a line $l$: use the left button to input 
  789.      two different points on $l$.}*/
  791. window& operator>>(circle& C);
  792. /*{Mbinop   reads a circle $C$: use the left button to input 
  793.      the center of $C$ and a point on $C$.}*/
  795. window& operator>>(polygon& P);
  796. /*{Mbinop   reads a polygon $P$: use the left button to input 
  797.      the sequence of vertices of $P$, end the sequence 
  798.      by clicking the middle button.}*/
  800. /*{Mtext
  801. As long as an input operation has not been completed the last read point can 
  802. be erased by simultaneously pressing the shift key and the left mouse button.
  803. }*/
  806. /*{Mtext
  807. bigskip
  808. {bf 3.19 Non-Member Functions} 
  809. }*/
  812. friend int read_mouse(window*& w, double& x, double& y)
  813. { return LEDA_WINDOW::read_mouse((LEDA_WINDOW*&)w,x,y); }
  814. /*{Mfunc   waits for mouse input, assigns a pointer to the 
  815.             corresonding window to $w$ and the position in 
  816.             $*w$ to $(x,y)$ and returns the pressed button. }*/
  819.  
  820.         
  821. /*
  822. friend void put_back_event();
  823. */
  824. /*{Mfunc   puts last read event back to the input stream of events. }*/
  825.  
  827. }; // end of class window
  828.  
  830. #include <LEDA/panel.h>
  832. #endif