home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / prog / graphics / ged.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  39.3 KB  |  1,767 lines
  1. #include <LEDA/graph.h>
  2. #include <LEDA/d_array.h>
  3. #include <LEDA/plane.h>
  4. #include <LEDA/window.h>
  5.  
  6. #include <math.h>
  7.  
  8. declare2(GRAPH,point,int)
  9. declare(node_array,node)
  10. declare2(d_array,point,node)
  11. declare2(d_array,node,int)
  12.  
  13. void GED(string);
  14.  
  15. /*---------------------- globale Variablen --------------------------*/
  16.  
  17. string   G_filename;
  18.  
  19. window  W;
  20.  
  21. double   W_WIDTH = 100;                      // extension of gwindow W
  22.  
  23. GRAPH(point,int) G;                          // graph G
  24.  
  25. drawing_mode  W_save_mode;
  26.  
  27.  
  28. int    G_max_node_width = 15;         
  29.  
  30. double G_XMAX;
  31. double G_YMAX;
  32. double G_XMIN;
  33. double G_YMIN;
  34.  
  35. int G_node_count;                            // counter of nodes,edges,faces
  36. int G_edge_count;          
  37.  
  38. d_array(node,int)    G_node_name;            // node -> name
  39.  
  40. list(point)          error_nodes;             // error output
  41. list(segment)        error_edges;
  42.  
  43. bool                 output_enable = true;   // output-permission
  44. bool                 still_saved   = true;   // save-control
  45.  
  46.  
  47. /*------------------------------ error --------------------------------*/
  48.  
  49. void error(string text)
  50. {
  51.   if (output_enable)  cout << "\n(error) " << text << "\n";
  52. }
  53.  
  54. /*------------------------------ warn --------------------------------*/
  55.  
  56. void warn(string text)
  57. {
  58.   cout << "(warning) " << text << "\n";
  59. }
  60.  
  61. /*------------------------ draw_node_cursor ---------------------------*/
  62.  
  63. static void draw_node_cursor(double x, double y)
  64. {
  65.   W.draw_node(x,y);
  66. }
  67.  
  68. /*---------------------------- draw_node ------------------------------*/
  69.  
  70. void draw_node(node v,color c=black)
  71. {
  72.    int width = W.get_node_width();
  73.  
  74.    if (width >= 7 ) W.draw_text_node(G[v],form("%d",G_node_name[v]),c);
  75.    else             W.draw_filled_node(G[v],c);
  76. }
  77.  
  78. /*----------------------------- draw_edge -----------------------------*/
  79.  
  80. void draw_edge(edge e,color c=black)
  81. {
  82.   drawing_mode old_mode =  W.set_mode(src_mode);       // src_mode for edge-painting
  83.  
  84.   W.draw_edge_arrow(G[source(e)],G[target(e)],c);
  85.  
  86.   W.set_mode(old_mode);
  87.  
  88. } // draw_edge
  89.  
  90. /*--------------------------- redraw_graph ----------------------------*/
  91.  
  92. void redraw_graph(string clear_permission)
  93. {
  94.   node v;
  95.   edge e;
  96.  
  97.   if (clear_permission == "yes") W.clear();
  98.  
  99.   forall_nodes(v,G) draw_node(v);
  100.  
  101.   forall_edges(e,G) draw_edge(e);
  102.                  
  103. } // redraw_graph
  104.  
  105. void redraw_graph() { redraw_graph("yes"); }
  106.  
  107. /*------------------------ new_error_node --------------------------*/
  108.  
  109. void new_error_node(point p)
  110. {
  111.   if (error_nodes.search(p)==nil) error_nodes.append(p);
  112.  
  113. } // new_error_node
  114.  
  115. /*------------------------ new_error_edge --------------------------*/
  116.  
  117. void new_error_edge(segment s)
  118. {
  119.   if (error_edges.search(s)==nil) error_edges.append(s);
  120.  
  121. } // new_error_edge
  122.  
  123. /*----------------------- overlap_message -------------------------*/
  124.  
  125. void overlap_message(bool draw_permission = true)
  126. {
  127.   point   p;
  128.   segment seg;
  129.  
  130.   line_style old_style     = W.set_line_style(dotted);
  131.   drawing_mode  old_mode      = W.set_mode(src_mode);
  132.  
  133.   forall(seg,error_edges) W.draw_edge_arrow(seg.start(),seg.end());
  134.   forall(p,error_nodes)   W.draw_filled_node(p);
  135.  
  136.   W.message("         node/edge dropped on existing object");
  137.   W.message("");
  138.   W.message("                  < press button >");
  139.   W.read_mouse();
  140.   W.del_message();
  141.  
  142.   W.set_line_style(old_style);       // old-values
  143.   W.set_mode(old_mode);
  144.  
  145.   error_edges.clear();
  146.   error_nodes.clear();
  147.  
  148.   if (draw_permission) redraw_graph();
  149.  
  150. } // overlap_message
  151.  
  152. /*---------------------------- cmp ---------------------------------*/
  153.  
  154. int cmp(point& x,point& p, point& q)
  155. { 
  156.   segment s1(x,p);                   // compare relativ position of s1 & s2
  157.   segment s2(x,q);
  158.  
  159.   return compare(s1.angle(), s2.angle()); 
  160.  
  161. } // cmp
  162.  
  163. /*---------------------- get_node_at_point ---------------------------*/
  164.  
  165. node get_node_at_point(point pv)
  166. {
  167.   node w,n;         
  168.   double dist = W.get_node_width() / W.scale();
  169.  
  170.   forall_nodes(w,G)
  171.   {
  172.     point pw = G[w];
  173.  
  174.     if (pv.distance(pw) < dist)
  175.     {
  176.       n = w;
  177.       G.reset();
  178.       return n;                        // node n on clicked position pv
  179.     }
  180.   }
  181.  
  182.   return nil;                          // no node clicked
  183.  
  184. } // get_node_at_point
  185.  
  186. /*------------------------ get_max_coord ----------------------------*/
  187.  
  188. void get_max_coord()
  189. {
  190.   node n = G.choose_node();
  191.  
  192.   if (n == nil)
  193.   {
  194.     G_XMAX = W.xmin(); G_YMAX = W.ymin();        // reset max.coord. of
  195.     G_XMIN = W.xmax(); G_YMIN = W.ymax();        // empty graph G
  196.   }
  197.   else
  198.   {
  199.     point p = G[n];
  200.  
  201.     G_XMIN = G_XMAX = p.xcoord();           // set max.coord. of graph G
  202.     G_YMIN = G_YMAX = p.ycoord();           // to existing node
  203.   }
  204.  
  205.   forall_nodes(n,G)
  206.   {
  207.      real x = G[n].xcoord();
  208.      real y = G[n].ycoord();
  209.  
  210.      if ( x < G_XMIN ) G_XMIN = x;
  211.      if ( x > G_XMAX ) G_XMAX = x;
  212.      if ( y < G_YMIN ) G_YMIN = y;
  213.      if ( y > G_YMAX ) G_YMAX = y;
  214.   }
  215.  
  216. } // get_max_coord
  217.  
  218. /*------------------------ graph_extension ----------------------------*/
  219.  
  220. void graph_extension(point p)
  221. {
  222.    real x = p.xcoord();            // if node is added, max.coord can change
  223.    real y = p.ycoord();
  224.  
  225.    if ( x < G_XMIN ) G_XMIN = x;
  226.    if ( x > G_XMAX ) G_XMAX = x;
  227.    if ( y < G_YMIN ) G_YMIN = y;
  228.    if ( y > G_YMAX ) G_YMAX = y;
  229.  
  230. } // graph_extension
  231.  
  232. /*-------------------------- init_window --------------------------*/
  233.  
  234. void init_window()
  235. {
  236.   int n_width = G_max_node_width - (2 * int( W_WIDTH / 100));   // new node_width
  237.   int o_width = W.get_node_width();
  238.  
  239.   W.init(0,W_WIDTH,0);
  240.  
  241.   if (o_width >= 7)                   // '>7' = nodes with numbers 
  242.   { 
  243.     if (n_width<o_width) W.set_node_width(n_width); 
  244.     else                 W.set_node_width(o_width); 
  245.  
  246.     W.set_line_width(2);
  247.   }
  248.  
  249.   W.set_mode(xor_mode);
  250.  
  251. } // init_window
  252.  
  253. /*--------------------------- init_graph ----------------------------*/
  254.  
  255. void init_graph()
  256. {
  257.   node v;
  258.   edge e;
  259.  
  260.   G_node_count = 0;
  261.   G_edge_count = 0;
  262.  
  263.   forall_nodes(v,G)  G_node_name[v] = G_node_count++;   // rename nodes
  264.  
  265.   forall_edges(e,G)  G[e] = G_edge_count++;             // rename edges
  266.                  
  267.   get_max_coord();       // test max.coord of graph G
  268.  
  269. } // init_graph
  270.  
  271. /*--------------------------- reset_graph ----------------------------*/
  272.  
  273. void reset_graph()
  274. {
  275.   G.clear();
  276.  
  277.   G_node_count = 0;
  278.   G_edge_count = 0;
  279.  
  280.   G_XMAX = W.xmin();     // if now a node is added to the empty graph
  281.   G_YMAX = W.ymin();     // it's coord. will become the max.coord. of G,
  282.   G_XMIN = W.xmax();     // because the input must be on window W
  283.   G_YMIN = W.ymax();
  284.  
  285. } // reset_graph
  286.  
  287. /*------------------------ scroll_window ------------------------------*/
  288.  
  289. void scroll_window(real xpos,real ypos,int margin=1)
  290. {
  291.   real x,y;
  292.   real xdist,ydist;
  293.   node n;
  294.  
  295.   if (margin == 1)        // scroll to margin
  296.   {
  297.     xdist = xpos;    
  298.     ydist = ypos;   
  299.   }
  300.   else                   // scroll user-define Direction
  301.   {
  302.     W.draw_filled_node(xpos,ypos);
  303.  
  304.     W.message("                     user - scroll");
  305.     W.read_mouse_seg(xpos,ypos,x,y);
  306.  
  307.     xdist = xpos - x;  
  308.     ydist = ypos - y;   
  309.   }
  310.  
  311.   G_XMIN += xdist; G_XMAX += xdist;     // change max.coord. of graph G
  312.   G_YMIN += ydist; G_YMAX += ydist;
  313.  
  314.   vector v(xdist,ydist);
  315.  
  316.   forall_nodes(n,G)                     // change coord. of nodes
  317.   {
  318.     G[n] = G[n] + v;
  319.   }
  320.  
  321.   if (margin == 0) redraw_graph();     // user scroll
  322.  
  323. } //scroll_window 
  324.  
  325. /*------------------------ center_graph ------------------------------*/
  326.  
  327. void center_graph()
  328. {
  329.   scroll_window((W.xmax() - W.xmin() - G_XMAX - G_XMIN) / 2.0,(W.ymax() - W.ymin() - G_YMAX - G_YMIN) / 2.0);
  330.  
  331. } // center_graph
  332.  
  333. /*------------------------ scroll_menu ------------------------------*/
  334.  
  335. void scroll_menu()
  336. {
  337.   int    node_width  = W.get_node_width();
  338.   double margin_dist = (node_width / W.scale()) +1;
  339.   double xpos,ypos;
  340.  
  341.   string header = form(" Scroll-Menu :      scroll to which margin ??");
  342.  
  343.   panel P(header);
  344.  
  345.   P.button(" up-left  "); 
  346.   P.button("    up    "); 
  347.   P.button(" up-right ");
  348.   P.new_button_line();
  349.  
  350.   P.button("   left   "); 
  351.   P.button("  center  "); 
  352.   P.button("   right  ");
  353.   P.new_button_line();
  354.  
  355.   P.button("down-left "); 
  356.   P.button("   down   "); 
  357.   P.button("down-right");
  358.   P.new_button_line();
  359.  
  360.   int scr_option = P.open();
  361.  
  362.   switch(scr_option)
  363.   {
  364.     case 0 : { xpos = W.xmin() - G_XMIN + margin_dist;               // up-left
  365.                ypos = W.ymax() - G_YMAX - margin_dist;
  366.                break;
  367.              }
  368.  
  369.  
  370.     case 1 : { xpos = 0;                                             // upper
  371.                ypos = W.ymax() - G_YMAX - margin_dist;
  372.                break;
  373.              }
  374.  
  375.  
  376.     case 2 : { xpos = W.xmax() - G_XMAX - margin_dist;               // up-right
  377.                ypos = W.ymax() - G_YMAX - margin_dist;
  378.                break;
  379.              }
  380.  
  381.  
  382.     case 3 : { xpos = W.xmin() - G_XMIN + margin_dist;               // left
  383.                ypos = 0;
  384.                break;
  385.              }
  386.  
  387.  
  388.     case 4 : { xpos = (W.xmax() - W.xmin() - G_XMAX - G_XMIN) / 2.0; // center
  389.                ypos = (W.ymax() - W.ymin() - G_YMAX - G_YMIN) / 2.0;
  390.                break;
  391.              }
  392.  
  393.  
  394.     case 5 : { xpos = W.xmax() - G_XMAX - margin_dist;               // right
  395.                ypos = 0;
  396.                break;
  397.              }
  398.  
  399.  
  400.     case 6 : { xpos = W.xmin() - G_XMIN + margin_dist;              // down-left
  401.                ypos = W.ymin() - G_YMIN + margin_dist;
  402.                break;
  403.              }
  404.  
  405.  
  406.     case 7 : { xpos = 0;                                            // lower
  407.                ypos = W.ymin() - G_YMIN + margin_dist;
  408.                break;
  409.              }
  410.  
  411.  
  412.     case 8 : { xpos = W.xmax() - G_XMAX - margin_dist;             // down-right
  413.                ypos = W.ymin() - G_YMIN + margin_dist;
  414.                break;
  415.              }
  416.  
  417.   } // switch(scr_option)
  418.  
  419.   scroll_window(xpos,ypos);
  420.  
  421.   redraw_graph();
  422.  
  423. } // scroll_menu
  424.  
  425.  /*------------------------- look_edge -------------------------------*/
  426.  
  427. edge look_edge(node s,node t)
  428. {
  429.   edge e;
  430.  
  431.   forall_adj_edges(e,s)
  432.   {
  433.     if (G.target(e) == t) 
  434.     {
  435.       G.reset();
  436.       return e;
  437.     }
  438.   }
  439.  
  440.   return nil;
  441.  
  442. } // look_edge
  443.  
  444. /*---------------------- node_intersection_test --------------------*/
  445.  
  446. bool node_intersection_test(point cutp,node original = nil)
  447. {
  448.    node   n,testn;
  449.    edge   e;
  450.    circle cutc(cutp,W.get_node_width() / W.scale() );
  451.  
  452.       // test intersection with other nodes
  453.  
  454.    forall_nodes(n,G)
  455.    {
  456.      if (n != original)
  457.      {
  458.        // test: 'original' is dropped on other node ??
  459.  
  460.        testn = get_node_at_point(cutp);
  461.  
  462.        if ((testn!=nil)&&(testn!=original)) 
  463.        {
  464.          new_error_node(cutp);
  465.          G.reset();
  466.          return true;
  467.        }
  468.  
  469.        // test: 'original' overlaps on other node ??
  470.  
  471.        circle c(G[n],W.get_node_width() / W.scale() );
  472.        list(point) schnitt = cutc.intersection(c);
  473.  
  474.        if (schnitt.length()>0)
  475.        {
  476.          new_error_node(cutp);
  477.          G.reset();
  478.          return true;
  479.        }
  480.      }
  481.    }
  482.  
  483.       // test intersection with (non adjazent & inzident) edges
  484.  
  485.    forall_edges(e,G)
  486.    {
  487.       if ((G.source(e)!=original)&&(G.target(e)!=original)) 
  488.       {
  489.         segment seg(G[G.source(e)],G[G.target(e)]);
  490.         list(point) schnitt = cutc.intersection(seg);
  491.       
  492.         if (schnitt.length()>0)
  493.         {
  494.          new_error_node(cutp);
  495.          G.reset();
  496.          return true;
  497.         }
  498.       }
  499.     }
  500.  
  501.   return false;
  502.  
  503. } // node_intersection_test
  504.  
  505. /*--------------------- edge_intersection_test -----------------------*/
  506.  
  507. bool edge_intersection_test(node s, node t,node ausnahme=nil)
  508. {
  509.    node    n;
  510.    point   p;
  511.    segment st_seg(G[s],G[t]);
  512.  
  513.       // test intersection with other nodes
  514.  
  515.    forall_nodes(n,G)
  516.    {
  517.      if ((n!=s)&&(n!=t)&&(n!=ausnahme))
  518.      {
  519.        circle c(G[n],W.get_node_width() / W.scale() );
  520.        list(point) schnitt = c.intersection(st_seg);
  521.  
  522.        if (schnitt.length()>0)
  523.        {
  524.          new_error_edge(st_seg);
  525.  
  526.          G.reset();   // reset iterator
  527.          return true;
  528.         }
  529.       }
  530.     }
  531.  
  532.   return false;
  533.  
  534. } // edge_intersection_test
  535.  
  536. /*-------------------------- node_resize ---------------------------*/
  537.  
  538. void node_resize()
  539. {
  540.   int  old_node_width,new_node_width;
  541.   int  old_line_width,new_line_width;
  542.   node n;
  543.   bool schnitt = false;
  544.  
  545.   string size_header = form("             Resize Nodes :  select form of nodes !!! ");
  546.   string size[3];
  547.  
  548.   size[0] = " Cancel ";
  549.   size[1] = " without numbers ";
  550.   size[2] = " with numbers (select node_width) ";
  551.  
  552.   int size_option = W.read_panel(size_header,3,size);
  553.  
  554.   switch(size_option)
  555.   {
  556.      case 1 : new_node_width = 4;
  557.               new_line_width = 1;
  558.               newline;
  559.               break;
  560.  
  561.      case 2 : newline;
  562.               do {
  563.                    new_node_width = read_int("Resize Nodes : new size (7<=s<=15) -> ");
  564.               } while ((new_node_width<7)||(new_node_width>G_max_node_width));
  565.  
  566.               new_line_width = 2;
  567.               break;
  568.   }
  569.  
  570.   if (size_option!=0)
  571.   {
  572.     old_node_width = W.set_node_width(new_node_width);
  573.     old_line_width = W.set_line_width(new_line_width);
  574.  
  575.     redraw_graph();
  576.  
  577.     forall_nodes(n,G)
  578.     {
  579.       if (node_intersection_test(G[n],n)) schnitt = true;
  580.     }
  581.  
  582.     if (schnitt)
  583.     {
  584.       overlap_message(false);            // without redraw_graph()
  585.       W.del_message();
  586.  
  587.       W.set_node_width(old_node_width);
  588.       W.set_line_width(old_line_width);
  589.  
  590.       redraw_graph();
  591.       cout<<"RESIZE -> refused\n";
  592.     }
  593.     else cout<<"RESIZE -> ok\n";
  594.  
  595.   }
  596.  
  597. } // node_resize
  598.  
  599. /*----------------------- move_subgraph ------------------------------*/
  600.  
  601. void move_subgraph()
  602. {
  603.   node        n,s,t;
  604.   edge        e;
  605.   real        subx,suby,subX,subY,newx,newy;
  606.   list(point) pol_list;
  607.   list(node)  moved_nodes;
  608.   bool        schnitt = false;
  609.  
  610.   cout<<"\nMOVE   -> (click rectangle for location of subgraph)\n";
  611.  
  612.   W.read_mouse(subx,suby);
  613.  
  614.   point pl(subx,suby);pol_list.append(pl);
  615.   W.draw_filled_node(pl);
  616.  
  617.   W.read_mouse_rect(subx,suby,subX,subY);
  618.   W.draw_filled_node(pl);
  619.  
  620.   point pL(subx,subY);pol_list.append(pL);
  621.   point pR(subX,subY);pol_list.append(pR);
  622.   point pr(subX,suby);pol_list.append(pr);
  623.  
  624.   polygon pol(pol_list);
  625.  
  626.   W<<pol;      // mark subgraph
  627.  
  628.   cout<<"MOVE   -> (click point for location of left-down corner of new position)\n";
  629.  
  630.   W.read_mouse(newx,newy);
  631.  
  632.   W<<pol;     // reset mark subgraph
  633.  
  634.   forall_edges(e,G)              // clear old edges
  635.   {
  636.     s = G.source(e);
  637.     t = G.target(e);
  638.  
  639.     if ( (moved_nodes.search(s)!=nil)||(moved_nodes.search(t)!=nil) ) 
  640.     {
  641.       draw_edge(e,white);
  642.     }
  643.   }
  644.  
  645.     // get new position of subgraph
  646.  
  647.   vector vec(newx - subx,newy - suby);
  648.  
  649.   forall_nodes(n,G)
  650.   {
  651.     if (pol.inside(G[n]))
  652.     {
  653.       draw_node(n);             // clear old nodes
  654.  
  655.       G[n] = G[n] + vec;
  656.       moved_nodes.append(n);
  657.     }
  658.   }
  659.  
  660.     // test : move subgraph possible
  661.  
  662.   forall(n,moved_nodes)
  663.   {
  664.     draw_node(n);                // new position of nodes
  665.  
  666.     if (node_intersection_test(G[n],n)) schnitt = true;
  667.   }
  668.  
  669.   forall_edges(e,G)
  670.   {
  671.     s = G.source(e);
  672.     t = G.target(e);
  673.  
  674.     if ( (moved_nodes.search(s)!=nil)||(moved_nodes.search(t)!=nil) ) 
  675.     {
  676.       if (edge_intersection_test(s,t)) schnitt = true;
  677.       else draw_edge(e);
  678.     }
  679.   }
  680.  
  681.   if (schnitt)
  682.   {
  683.     forall(n,moved_nodes)  G[n] = G[n] + ( vec * -1 );
  684.  
  685.     overlap_message();
  686.  
  687.     cout<<"MOVE   -> refused\n";
  688.   }
  689.   else
  690.   {
  691.     cout<<"MOVE   -> ok\n";
  692.     redraw_graph();
  693.     still_saved = false;
  694.   }
  695.  
  696.   get_max_coord();
  697.  
  698. } // move_subgraph
  699.  
  700. /*-------------------------- add_node -------------------------------*/
  701.  
  702. node add_node(point p)
  703. {
  704.    node v;
  705.  
  706.    if ( node_intersection_test(p) )
  707.    {
  708.      error("add node    : node dropped on existing objects ... 'add' refused");
  709.  
  710.      return nil;
  711.    }
  712.  
  713.        // add_node possible
  714.  
  715.    v = G.new_node(p);
  716.  
  717.    G_node_name[v] = G_node_count++;
  718.    draw_node(v);
  719.  
  720.    graph_extension(p);       // test max.coord. of graph G
  721.  
  722.    return v;
  723.  
  724. } // add_node
  725.  
  726. /*------------------------- add_edge ----------------------------------*/
  727.  
  728. edge add_edge(node s,node t)
  729. {
  730.   edge      e;
  731.  
  732.   // test: e=(s,s) ??
  733.  
  734.   if (s==t)
  735.   {
  736.     error("add edge    : source = target ... 'add' refused");
  737.     return nil;
  738.   }
  739.  
  740.   // test: edge e=(s,t) still exist ??
  741.  
  742.   if (look_edge(s,t)!=nil)
  743.   {
  744.     error("add edge    : marked edge still exist ... 'add' refused");
  745.     return nil;
  746.   }
  747.  
  748.   if (edge_intersection_test(s,t))
  749.   {
  750.     error("add edge    : marked edge dropped on existing nodes ... 'add' refused");
  751.     return nil;
  752.   }
  753.  
  754.     // add new edge to G
  755.  
  756.   e = G.new_edge(s,t);
  757.  
  758.   G[e] = G_edge_count++;
  759.   draw_edge(e); 
  760.  
  761.   return e;
  762.  
  763. } // add_edge
  764.  
  765. /*------------------------ delete_edge -------------------------------*/
  766.  
  767. void delete_edge(edge e)
  768. {
  769.   node s = G.source(e);
  770.   node t = G.target(e);
  771.  
  772.   draw_edge(e,white);
  773.   G.del_edge(e);
  774.   
  775.   edge reverse = look_edge(t,s);
  776.  
  777.   if (reverse!=nil) draw_edge(reverse);
  778.  
  779. } // delete_edge
  780.  
  781. /*--------------------------- move_node ------------------------------*/
  782.  
  783. point move_node(node v)
  784. {
  785.   real       x,y;
  786.   point      p = G[v];                                // old position
  787.   node       s,t;
  788.   edge       e;
  789.   list(edge) e_list;
  790.   bool       schnitt_node = false;
  791.   bool       schnitt_edge = false;
  792.  
  793.   forall_edges(e,G)                                  // get adj.+inz. edges
  794.   {
  795.     if ( (source(e)) == v || (target(e) == v) )
  796.     {
  797.       e_list.append(e);
  798.     }
  799.   }
  800.  
  801.   draw_node(v);                                      // clear old position
  802.  
  803.   W.read_mouse_action(draw_node_cursor,x,y);
  804.  
  805.   point q(x,y);                                      // new position
  806.  
  807.   forall(e,e_list)  draw_edge(e,white);              // clear old edges
  808.  
  809.  
  810.      // test: intersection of v to other nodes
  811.  
  812.   schnitt_node = node_intersection_test(q,v);
  813.  
  814.      // test: intersection of v to other edges
  815.  
  816.   G[v] = q;    // neue position zuweisen
  817.   draw_node(v);
  818.  
  819.   forall(e,e_list)
  820.   {
  821.     s = G.source(e);
  822.     t = G.target(e);
  823.  
  824.     if (edge_intersection_test(s,t)) schnitt_edge = true;
  825.     else draw_edge(e);
  826.   }
  827.  
  828.   if (schnitt_node) error("move node   : node dropped on existing objects ... 'move' refused");
  829.  
  830.   if (schnitt_edge) error("move node   : moved edge dropped on existing node ... 'move' refused");
  831.  
  832.   if ( schnitt_node || schnitt_edge )
  833.   {
  834.     G[v] = p;
  835.     return p;
  836.   }
  837.  
  838.   get_max_coord();                                 // test max.coord of graph G
  839.   graph_extension(q);
  840.  
  841.   return q;
  842.  
  843. } // move_node
  844.  
  845. /*-------------------------- delete_node ----------------------------*/
  846.  
  847. void delete_node(node v)
  848. {
  849.   list(edge) ad_list,in_list;
  850.   edge       e;
  851.  
  852.   forall_edges(e,G) 
  853.   {
  854.     if (source(e) == v) ad_list.append(e);    // adj. edges
  855.  
  856.     if (target(e) == v) in_list.append(e);    // inz. edges
  857.   }
  858.  
  859.   forall(e,ad_list) delete_edge(e);
  860.  
  861.   if (in_list.length()>0)
  862.   {
  863.     warn("delete_node: incoming edges are deleted");
  864.     forall(e,in_list) delete_edge(e);
  865.   }
  866.  
  867.   draw_node(v); 
  868.   G.del_node(v);
  869.  
  870.   get_max_coord();              // test max.coord of graph G
  871.  
  872. } // delete_node
  873.  
  874. /*------------------------ insert_node -------------------------------*/
  875.  
  876. node insert_node(edge e)
  877. {
  878.   node  s = G.source(e);
  879.   node  t = G.target(e);
  880.  
  881.   bool  rev_exist = false;
  882.   node  n;    
  883.   edge  reverse,e1,e2,e3,e4;
  884.  
  885.   real xs = G[s].xcoord();
  886.   real ys = G[s].ycoord();
  887.   real xt = G[t].xcoord();
  888.   real yt = G[t].ycoord();
  889.  
  890.   point mid((xs+xt)/2, (ys+yt)/2);
  891.  
  892.   delete_edge(e);
  893.  
  894.   reverse = look_edge(t,s);        // if (s,t) && (t,s) in G -> insert to both
  895.   if (reverse != nil) 
  896.   {
  897.     rev_exist = true;
  898.     delete_edge(reverse);
  899.   }
  900.  
  901.   output_enable = false;
  902.  
  903.   n = add_node(mid);
  904.  
  905.   if (n!=nil)
  906.   {
  907.     e1 = add_edge(s,n);    
  908.     e2 = add_edge(n,t);    
  909.  
  910.     if (rev_exist)
  911.     {
  912.       e3 = add_edge(t,n);
  913.       e4 = add_edge(n,s);
  914.  
  915.       draw_edge(e3); draw_edge(e4);
  916.     }
  917.  
  918.     draw_edge(e1); draw_edge(e2);
  919.  
  920.     output_enable = true;
  921.  
  922.     return n;
  923.   }
  924.  
  925.   // insert impossible
  926.  
  927.   output_enable = true;
  928.  
  929.   segment s1(G[s],mid);
  930.   segment s2(mid,G[t]);
  931.   new_error_edge(s1);
  932.   new_error_edge(s2);
  933.   overlap_message();
  934.  
  935.   add_edge(s,t);
  936.   if (rev_exist) add_edge(t,s);
  937.  
  938.   error("insert edge : inserted node dropped on existing objects ... 'insert' refused");
  939.  
  940.   return nil;
  941.  
  942. } // insert_node
  943.  
  944. /*-------------------------- join_edges ------------------------------*/
  945.  
  946. void join_edges(node n)
  947. {
  948.   edge       e;
  949.   node       s,t;
  950.   bool       refuse = false;
  951.   list(edge) ad_list,in_list;
  952.  
  953.   forall_edges(e,G)      
  954.   {
  955.     if (G.source(e)==n) ad_list.append(e);         // adj. e = (n,?)
  956.     if (G.target(e)==n) in_list.append(e);         // inz. e = (?,n)
  957.   }
  958.  
  959.         // degree-test
  960.  
  961.   if ((ad_list.length()==in_list.length())&&(0<ad_list.length()<=2))
  962.   {
  963.      list(node) n_list;   // get participant nodes (n,s,t,...)
  964.  
  965.      forall(e,in_list)
  966.      {
  967.        s = G.source(e);
  968.        t = G.target(e);
  969.  
  970.        if (n_list.search(s)==nil) n_list.append(s);
  971.        if (n_list.search(t)==nil) n_list.append(t);
  972.      }
  973.  
  974.      forall(e,ad_list)
  975.      {
  976.        s = G.source(e);
  977.        t = G.target(e);
  978.  
  979.        if (n_list.search(s)==nil) n_list.append(s);
  980.        if (n_list.search(t)==nil) n_list.append(t);
  981.      }
  982.  
  983.      if (n_list.length()==3)
  984.      {
  985.        n_list.del_item(n_list.search(n));    //  get s + t
  986.        s = n_list.head();
  987.        t = n_list.tail();
  988.  
  989.        if (! edge_intersection_test(s,t,n))
  990.        {
  991.           // 'join' possible
  992.  
  993.          if (look_edge(s,t)!=nil)
  994.          {
  995.            error("join edge   : 'joined' edge still exist ... 'join' refused");
  996.            return;
  997.          }
  998.  
  999.          cout<<"\nJoin_Edge   : (";
  1000.  
  1001.          forall(e,in_list)
  1002.          {
  1003.            cout<<" ("<<G_node_name[G.source(e)]<<"-"<<G_node_name[G.target(e)]<<")";
  1004.            delete_edge(e);
  1005.          }
  1006.  
  1007.          forall(e,ad_list) 
  1008.          {
  1009.            cout<<" ("<<G_node_name[G.source(e)]<<"-"<<G_node_name[G.target(e)]<<")";
  1010.            delete_edge(e);
  1011.          }
  1012.  
  1013.          delete_node(n);
  1014.  
  1015.          cout<<" ) to (";
  1016.          cout<<" ("<<G_node_name[s]<<"-"<<G_node_name[t]<<")";
  1017.  
  1018.          add_edge(s,t);
  1019.  
  1020.          if (ad_list.length()==2) 
  1021.          {
  1022.            add_edge(t,s);
  1023.            cout<<" ("<<G_node_name[t]<<"-"<<G_node_name[s]<<")";
  1024.          }
  1025.  
  1026.          cout<<" )\n";
  1027.  
  1028.          still_saved = false;
  1029.        }
  1030.        else 
  1031.        {
  1032.          forall(e,ad_list) draw_edge(e,white);
  1033.          forall(e,in_list) draw_edge(e,white);
  1034.          draw_node(n);
  1035.  
  1036.          error("join edge   : joined edge dropped on existing node ... 'join' refused");
  1037.          overlap_message();
  1038.        }
  1039.      }
  1040.      else refuse = true;
  1041.   }
  1042.   else refuse = true;
  1043.  
  1044.   if (refuse)
  1045.   {
  1046.     error("join edge   : wrong degree of node ...  'join' refused");
  1047.   }
  1048.  
  1049. } // join_edges
  1050.  
  1051. /*---------------------------- unzoom ------------------------------*/
  1052.  
  1053. void unzoom()
  1054. {
  1055.   node   n;
  1056.  
  1057.   bool   schnitt = false;
  1058.   double minx = 0;
  1059.   double miny = 0;
  1060.  
  1061.   double factor = 2.0;                
  1062.   double old_width = W_WIDTH;
  1063.   double new_width = (factor * W_WIDTH);
  1064.  
  1065.   if (new_width > 400)  new_width = 400;
  1066.   W_WIDTH = new_width;
  1067.  
  1068.   double dist = (new_width - old_width) / 2;
  1069.   scroll_window(dist,dist);
  1070.  
  1071.   init_window();                       // get new extension 
  1072.   redraw_graph("without_W.clear");
  1073.  
  1074.   forall_nodes(n,G)
  1075.   {
  1076.     if (node_intersection_test(G[n],n)) schnitt = true;
  1077.   }
  1078.  
  1079.   if (schnitt)
  1080.   {
  1081.     overlap_message(false);            // without redraw_graph()
  1082.  
  1083.     W_WIDTH = old_width;
  1084.     scroll_window(-dist,-dist);
  1085.     init_window();
  1086.     redraw_graph("without_W.clear");
  1087.  
  1088.     cout<<"\nUNZOOM -> refused\n";
  1089.   }
  1090.   else cout<<"\nUNZOOM -> ok\n";
  1091.  
  1092. } // unzoom
  1093.  
  1094. /*----------------------------- zoom ------------------------------*/
  1095.  
  1096. void zoom()
  1097. {
  1098.   real x,y,xp,yp;
  1099.   real xdist,ydist;
  1100.   real new_width;
  1101.  
  1102.   cout<<"\nZOOM   -> click rectangle ( = screen after zoom)\n";
  1103.  
  1104.   W.read_mouse(xp,yp);
  1105.   W.draw_filled_node(xp,yp);
  1106.  
  1107.   W.read_mouse_rect(xp,yp,x,y);
  1108.  
  1109.   new_width =  W_WIDTH * (abs(x - xp) / W_WIDTH);
  1110.  
  1111.   if (new_width>0)
  1112.   {
  1113.     W_WIDTH = new_width;
  1114.     init_window();
  1115.     
  1116.     if (xp < x) xdist = xp;
  1117.     else        xdist = x;
  1118.  
  1119.     if (yp < y) ydist = yp;
  1120.     else        ydist = y;
  1121.  
  1122.     scroll_window(-xdist,-ydist);
  1123.  
  1124.     redraw_graph("without_W.clear");
  1125.  
  1126.     cout<<"ZOOM   -> ok\n";
  1127.   }
  1128.   else 
  1129.   {
  1130.     error("zoom        : grid distance out of range ... 'zoom' refused");
  1131.     cout<<"ZOOM   -> refused\n";
  1132.   }
  1133.  
  1134. } // zoom
  1135.  
  1136. /*--------------------------- read_graph -----------------------------*/
  1137.  
  1138. void read_graph(string str)
  1139. {
  1140.   node             v,s,t,knoten;
  1141.   edge             e,kante;
  1142.   real             readx,ready;
  1143.   double           minx = 0;
  1144.   double           miny = 0;
  1145.  
  1146.   GRAPH(point,int) HELP;                       // help graph
  1147.   GRAPH(point,int) old_G = G;                  // old Graph G
  1148.  
  1149.   if (str == "CANCEL")
  1150.   { 
  1151.     cout<<"READ   -> cancelled\n";
  1152.     return;
  1153.   }
  1154.  
  1155.   if (str == "")
  1156.   { 
  1157.     read_graph(read_string("READ   -> read file ( 'CANCEL' to stop ) : "));
  1158.     return;
  1159.   }
  1160.  
  1161.  
  1162.   int modus = HELP.read(str);
  1163.  
  1164.   if (modus == 1)
  1165.   {
  1166.     cout<<"(warning) read_graph: file '"<<str<<"' doesn't exist\n";
  1167.     read_graph(read_string("\nREAD   -> read file ( 'CANCEL' to stop ) : "));
  1168.     return;
  1169.   }
  1170.  
  1171.   if (modus == 2)
  1172.   {
  1173.     cout<<"(warning) read_graph  : graph '"<<str<<"' not created by Graph Editor\n";
  1174.     read_graph(read_string("\nREAD   -> read file ( 'CANCEL' to stop ) : "));
  1175.     return;
  1176.   }
  1177.  
  1178.   if (modus == 3)
  1179.   { 
  1180.     cout<<"(warning) read_graph  : file '"<<str<<"' not represent a graph\n";
  1181.     read_graph(read_string("\nREAD   -> read file ( 'CANCEL' to stop ) : "));
  1182.     return;
  1183.   }
  1184.  
  1185.         // move 'readed' graph to new position
  1186.  
  1187.   cout<<"READ   -> (click left-down corner of new subgraph)\n";
  1188.   
  1189.   W.read_mouse(readx,ready);
  1190.  
  1191.   v = HELP.choose_node();
  1192.   
  1193.   if (v!=nil)
  1194.   {
  1195.     minx = HELP[v].xcoord();
  1196.     miny = HELP[v].ycoord();
  1197.   }
  1198.  
  1199.   forall_nodes(v,HELP)              // min coord. of new_nodes
  1200.   {
  1201.     if (HELP[v].xcoord() < minx) minx = HELP[v].xcoord();
  1202.     if (HELP[v].ycoord() < miny) miny = HELP[v].ycoord();
  1203.   }
  1204.  
  1205.   vector resetvec(-minx,-miny);
  1206.   vector vec(readx,ready);
  1207.  
  1208.   forall_nodes(v,HELP) HELP[v] = HELP[v] + resetvec + vec;
  1209.  
  1210.  
  1211.   // eingelesenen Hilfs-Graphen HELP auf G kopieren
  1212.  
  1213.   bool             complete = true;
  1214.   list(node)       wrong_nodes;
  1215.  
  1216.   node_array(node) corr(HELP);
  1217.  
  1218.   output_enable = false;           // no error and warning output
  1219.  
  1220.   forall_nodes(v,HELP)
  1221.   {
  1222.     knoten = add_node(HELP[v]);
  1223.  
  1224.     if (knoten!=nil) corr[v] = knoten;
  1225.     else
  1226.     {
  1227.       complete = false;
  1228.       wrong_nodes.append(v);    // node not to G added
  1229.       new_error_node(HELP[v]);
  1230.     }
  1231.   }
  1232.  
  1233.   forall_edges(e,HELP)
  1234.   {
  1235.     s = HELP.source(e);
  1236.     t = HELP.target(e);
  1237.  
  1238.     if ( (wrong_nodes.search(s)==nil) && (wrong_nodes.search(t)==nil) )
  1239.     {
  1240.       kante = add_edge(corr[s],corr[t]);
  1241.  
  1242.       if (kante==nil) complete = false;
  1243.     }
  1244.     else 
  1245.     {
  1246.      segment seg(G[s],G[t]);
  1247.      new_error_edge(seg);
  1248.      complete = false;
  1249.     }
  1250.   }
  1251.  
  1252.   output_enable = true;
  1253.   still_saved   = false;
  1254.  
  1255.   if (complete) cout <<"READ   -> ok\n";
  1256.   else  
  1257.   {
  1258.     overlap_message(false);             // without redraw_graph()
  1259.  
  1260.     if (W.confirm(" ??? read incomplete subgraph ??? "))
  1261.     {
  1262.       cout<<"READ   -> incomplete\n";
  1263.       redraw_graph();
  1264.     }
  1265.     else
  1266.     {
  1267.       W.clear();
  1268.       reset_graph();
  1269.       
  1270.       output_enable = false;           // no error and warning output
  1271.  
  1272.       node_array(node) old_corr(old_G);
  1273.  
  1274.       forall_nodes(v,old_G)  old_corr[v] = add_node(old_G[v]);
  1275.       forall_edges(e,old_G)  add_edge(old_corr[old_G.source(e)],old_corr[old_G.target(e)]);
  1276.       output_enable = true;
  1277.       still_saved   = true;
  1278.  
  1279.       cout<<"READ   -> refused\n";
  1280.     }
  1281.   }
  1282.  
  1283.   init_graph();
  1284.  
  1285. } // read_graph
  1286.  
  1287. /*-------------------------- load_graph ------------------------------*/
  1288.  
  1289. void load_graph(string str)
  1290. {
  1291.   node v,s,t,knoten;
  1292.   edge e,kante;
  1293.  
  1294.   GRAPH(point,int) HELP;                       // help graph
  1295.  
  1296.   if (str=="CANCEL") 
  1297.   {
  1298.     cout<<"LOAD   -> cancelled\n";
  1299.     return;
  1300.   }
  1301.  
  1302.   if (str=="")
  1303.   {
  1304.     load_graph(read_string("LOAD   -> edit file ( 'CANCEL' to stop ) : "));
  1305.     return;
  1306.   }
  1307.   
  1308.  
  1309.   int modus = HELP.read(str);
  1310.  
  1311.   if (modus == 1)
  1312.   {
  1313.     cout<<"(warning) load_graph: file '"<<str<<"' doesn't exist\n";
  1314.     load_graph(read_string("\nLOAD   -> edit file ( 'CANCEL' to stop ) : "));
  1315.     return;
  1316.   }
  1317.  
  1318.   if (modus == 2)
  1319.   { 
  1320.     cout<<"(warning) load_graph  : graph '"<<str<<"' not created by Graph Editor\n";
  1321.     load_graph(read_string("\nLOAD   -> edit file ( 'CANCEL' to stop ) : "));
  1322.     return;
  1323.   }
  1324.  
  1325.   if (modus == 3)
  1326.   { 
  1327.     cout<<"(warning) load_graph  : file '"<<str<<"' doesn't represent a graph\n";
  1328.     load_graph(read_string("\nLOAD   -> edit file ( 'CANCEL' to stop ) : "));
  1329.     return;
  1330.   }
  1331.  
  1332.   G_filename = str;
  1333.   reset_graph();
  1334.   W.clear();
  1335.  
  1336.   // eingelesenen Hilfs-Graphen HELP auf G kopieren
  1337.  
  1338.   bool             complete = true;
  1339.   list(node)       wrong_nodes;
  1340.  
  1341.   node_array(node) corr(HELP);
  1342.  
  1343.   forall_nodes(v,HELP)
  1344.   {
  1345.     knoten = add_node(HELP[v]);
  1346.  
  1347.     if (knoten!=nil) corr[v] = knoten;
  1348.     else
  1349.     {
  1350.       complete = false;
  1351.       wrong_nodes.append(v);    // node not to G added
  1352.       new_error_node(HELP[v]);
  1353.     }
  1354.   }
  1355.  
  1356.   forall_edges(e,HELP)
  1357.   {
  1358.     s = HELP.source(e);
  1359.     t = HELP.target(e);
  1360.  
  1361.     if ( (wrong_nodes.search(s)==nil) && (wrong_nodes.search(t)==nil) )
  1362.     {
  1363.       kante = add_edge(corr[s],corr[t]);
  1364.  
  1365.       if (kante==nil) complete = false;
  1366.     }
  1367.     else
  1368.     {
  1369.      segment seg(G[s],G[t]);
  1370.      new_error_edge(seg);
  1371.      complete = false;
  1372.     }
  1373.   }
  1374.  
  1375.   if (complete) cout <<"LOAD   -> ok\n";
  1376.   else 
  1377.   {
  1378.      overlap_message();
  1379.      cout <<"LOAD   -> incomplete\n";
  1380.   }
  1381.  
  1382.   init_graph();
  1383.  
  1384. } //load_graph
  1385.  
  1386. /*--------------------------- save_graph -----------------------------*/
  1387. void save_graph(string f)
  1388. {
  1389.   if (f!="")
  1390.   {
  1391.     G_filename = f;
  1392.     G.write(f);
  1393.  
  1394.     cout << "SAVE   -> ok \n";
  1395.     still_saved = true;
  1396.   }
  1397.   else  save_graph(read_string("SAVE   -> write to file: "));
  1398.  
  1399. } // save_graph
  1400.  
  1401. /*-------------------------- save_test ------------------------------*/
  1402.  
  1403. void save_test()
  1404. {
  1405.   if (! still_saved)
  1406.      if (W.confirm(" ??? save old graph ??? "))
  1407.      {
  1408.          save_graph(read_string("\nSAVE   -> write to file: "));
  1409.      }
  1410.  
  1411.   still_saved = true;
  1412.  
  1413. } // save_test
  1414.  
  1415. /*--------------------------- print_help -----------------------------*/
  1416.  
  1417. void print_help()
  1418. { 
  1419.   W.clear();
  1420.   W.message("                                                   ");
  1421.   W.message("                                                   ");
  1422.   W.message("                                                   ");
  1423.   W.message("   +----------------------------------------------+");
  1424.   W.message("   |                  Graph Edit                  |"); 
  1425.   W.message("   +----------------------------------------------+");
  1426.   W.message("   | BUTTON      unshifted              shifted   |");
  1427.   W.message("   +----------------------------------------------+");
  1428.   W.message("   | LEFT:   new node  / move node    delete node |");
  1429.   W.message("   | MIDDLE: new edge  / insert node  delete edge |");
  1430.   W.message("   | RIGHT: join edges / scroll           Menu    |");
  1431.   W.message("   +----------------------------------------------+");
  1432.   W.message("                                                   ");
  1433.   W.message("                                                   ");
  1434.   W.message("                                                   ");
  1435.   W.message("                   < Press Button >                ");
  1436.  
  1437.   W.read_mouse();
  1438.   W.del_message();
  1439.   redraw_graph();
  1440.  
  1441. }
  1442.  
  1443. /*------------------------------ GED --------------------------------*/
  1444.  
  1445. void GED(string filename)
  1446. {
  1447.   node   s,t,v,w,knoten;
  1448.   edge   e,kante;
  1449.   real   x,y;
  1450.   point  p,q,pw;
  1451.   int    key = 0;
  1452.   int    fertig = 0;
  1453.   int    k;
  1454.  
  1455.   int    option   = 0;                        // choosed option in menu 
  1456.  
  1457.   G_node_count = 0;                           // reset counter
  1458.   G_edge_count = 0;          
  1459.  
  1460.   W.init(0,80,0);
  1461.  
  1462.   W_save_mode = W.set_mode(xor_mode);
  1463.  
  1464.   W.set_node_width(12);
  1465.   W.set_line_width(2);
  1466.  
  1467.   G_XMAX = W.xmin();
  1468.   G_YMAX = W.ymin();  
  1469.   G_XMIN = W.xmax();
  1470.   G_YMIN = W.ymax();
  1471.   
  1472.   cout<<"\n\n     *** Planar Graph Editor ***\n\n( Menue : <Shift> right mouse_button )\n\n";
  1473.  
  1474.   cout<<"\n\n         *** Graph Editor ***\n\n( Menue : <Shift> right mouse_button )\n\n";
  1475.  
  1476.   if (filename != "") load_graph(filename);
  1477.   else
  1478.       {
  1479.         center_graph();
  1480.         redraw_graph("without_W.clear");
  1481.       }
  1482.  
  1483.   init_graph();
  1484.  
  1485.                          /* main - routine */
  1486.  
  1487.   while (option != 15)                // option != Quit
  1488.   {
  1489.      key = W.read_mouse(x,y);
  1490.  
  1491.      p = point(x,y);
  1492.     
  1493.      v = get_node_at_point(p);                     // -> node clicked ?
  1494.  
  1495.      switch(key) {
  1496.  
  1497.      case 1:  { 
  1498.                 if (v == nil)
  1499.                 { 
  1500.                   knoten = add_node(p);            /* new node */
  1501.  
  1502.                   if (knoten!=nil) 
  1503.                   {
  1504.                     cout<<"\nAdd Node    : ("<<G_node_name[knoten]<<") \n";
  1505.                     still_saved = false;
  1506.                   }
  1507.                 }
  1508.                 else  
  1509.                 {
  1510.                   move_node(v);                       /* move node */
  1511.  
  1512.                   cout<<"\nMove Node   : ("<<G_node_name[v]<<")\n";
  1513.                   still_saved = false;
  1514.                 }
  1515.  
  1516.                 break;
  1517.  
  1518.                } // case 1
  1519.  
  1520.      case -1: { 
  1521.                 if (v != nil)  
  1522.                 {
  1523.                   cout<<"\nDelete Node : ("<<G_node_name[v]<<")\n";
  1524.  
  1525.                   delete_node(v);                     /* delete node */
  1526.  
  1527.                   still_saved = false;
  1528.                 }
  1529.                 else error("delete node : no node at mouse-position ... 'delete' refused");
  1530.  
  1531.                 break;
  1532.  
  1533.               } // case -1
  1534.  
  1535.      case 2:  {                                  /* new edge / insert node */
  1536.                 if (v != nil)
  1537.                 { 
  1538.                   p = G[v];
  1539.  
  1540.                   do {
  1541.                        W.message("                add edge / insert node");
  1542.                        k = W.read_mouse_seg(p.xcoord(),p.ycoord(),x,y);
  1543.                        W.del_message();
  1544.  
  1545.                        pw = point(x,y);
  1546.  
  1547.                        w = get_node_at_point(pw);
  1548.  
  1549.                        if (w != nil) 
  1550.                        {
  1551.                          if ((e=look_edge(v,w)) == nil) 
  1552.                          {
  1553.                            kante = add_edge(v,w);         /* new edge */
  1554.  
  1555.                            if (kante!=nil) 
  1556.                            {
  1557.                              cout<<"\nAdd Edge    : ("<<G_node_name[v]<<"-"<<G_node_name[w]<<")\n";
  1558.                              still_saved = false;
  1559.                            }
  1560.                          }
  1561.                          else                         
  1562.                          {                               /* insert node */
  1563.                            s = G.source(e);
  1564.                            t = G.target(e);
  1565.  
  1566.                            knoten = insert_node(e);
  1567.  
  1568.                            if (knoten!=nil)
  1569.                            {
  1570.                              cout<<"\nInsert Node : ("<<G_node_name[knoten]<<") to ("<<G_node_name[s]<<"-"<<G_node_name[t]<<")\n";
  1571.                              still_saved = false;
  1572.                            }
  1573.                          }  
  1574.                        }
  1575.  
  1576.                      } while ( w == nil && k == 2);
  1577.                 }
  1578.  
  1579.                 break;
  1580.  
  1581.               } // case 2
  1582.  
  1583.      case -2: {                                          /* delete edge */
  1584.                 if (v != nil) 
  1585.                 { 
  1586.                   p = G[v];
  1587.                   W.message("                     delete edge");
  1588.                   W.read_mouse_seg(p.xcoord(),p.ycoord(),x,y);
  1589.                   W.del_message();
  1590.  
  1591.                   q = point(x,y);
  1592.                   w = get_node_at_point(q);
  1593.  
  1594.                   if (w != nil)
  1595.                   {
  1596.                     e = look_edge(v,w);
  1597.                     if (e != nil) 
  1598.                     {
  1599.                       cout<<"\nDelete Edge : ("<<G_node_name[v]<<"-"<<G_node_name[w]<<")\n";
  1600.                       delete_edge(e);
  1601.  
  1602.                       still_saved = false;
  1603.                     }
  1604.                     else error("delete edge : edge doesn't exist ... 'delete' refused");
  1605.                   }
  1606.                 }
  1607.  
  1608.                 break;
  1609.  
  1610.               } // case -2
  1611.  
  1612.  
  1613.      case 3:  {                                      /* join edges / scroll  */
  1614.  
  1615.                 if (v != nil)
  1616.                 {
  1617.                    join_edges(v);
  1618.                 }
  1619.                 else
  1620.                 {
  1621.                    cout<<"\nUser Scroll : (click distance of window movement)\n";
  1622.                    scroll_window(p.xcoord(),p.ycoord(),0);   // user-scroll
  1623.                 } 
  1624.  
  1625.                 break;
  1626.               }
  1627.  
  1628.  
  1629.      case -3: {                      /* Menu */
  1630.  
  1631.                 string header = form("Graph Editor  (file : \"%s\")",~G_filename);
  1632.  
  1633.                 panel P(header);
  1634.  
  1635.                 P.button("                  Cancel                   ");
  1636.                 P.new_button_line();
  1637.  
  1638.                 P.button("  Help  "); 
  1639.                 P.button(" Resize ");
  1640.                 P.button("  Move  ");
  1641.                 P.button(" Scroll ");
  1642.                 P.new_button_line();
  1643.  
  1644.                 P.button("  Print ");
  1645.                 P.button(" Redraw ");
  1646.                 P.button("  Zoom  "); 
  1647.                 P.button(" Unzoom "); 
  1648.                 P.new_button_line();
  1649.  
  1650.                 P.button("  Load  ");
  1651.                 P.button("  Read  ");
  1652.                 P.button("  Save  "); 
  1653.                 P.button("Save as "); 
  1654.                 P.new_button_line();
  1655.  
  1656.                 P.button("       Clear        ");
  1657.                 P.button("       Quit        "); 
  1658.                 P.new_button_line();
  1659.  
  1660.  
  1661.                 option = P.open();
  1662.  
  1663.                 W.del_message();
  1664.  
  1665.                 switch (option) {
  1666.  
  1667.                 case 1 : { print_help();
  1668.                            break;
  1669.                          }
  1670.  
  1671.                 case 2 : { node_resize();
  1672.                            break;
  1673.                          }
  1674.  
  1675.                 case 3 : { move_subgraph();
  1676.                            break;
  1677.                          }
  1678.  
  1679.                 case 4 : { scroll_menu();
  1680.                            break;
  1681.                          }
  1682.  
  1683.                 case 5 : { cout<<"\nPRINT  -> graph `"<<G_filename<<"`\n";
  1684.                            G.print();
  1685.                            break;
  1686.                          }
  1687.  
  1688.                 case 6 : { redraw_graph();
  1689.                            break;
  1690.                          }
  1691.  
  1692.                 case 7 : { zoom();
  1693.                            break;
  1694.                          }
  1695.  
  1696.                 case 8 : { unzoom();
  1697.                            break;
  1698.                          }
  1699.  
  1700.                 case 9 : { save_test();
  1701.                            load_graph(read_string("\nLOAD   -> edit file: "));
  1702.                            break;
  1703.                          }
  1704.  
  1705.                case 10 : { read_graph(read_string("\nREAD   -> read file: "));
  1706.                            break;
  1707.                          }
  1708.  
  1709.                case 11 : { cout<<"\n";
  1710.                            save_graph(G_filename);
  1711.                            break;
  1712.                          }
  1713.  
  1714.                case 12 : { save_graph(read_string("\nSAVE   -> write to file: "));
  1715.                            break;
  1716.                          } 
  1717.                  
  1718.                case 14 : { save_test();
  1719.                            W.clear();
  1720.                            reset_graph();
  1721.                            init_graph();
  1722.                            G_filename="";
  1723.                            cout<<"\nCLEAR  -> Graph is empty\n";
  1724.                            break;
  1725.                          }
  1726.  
  1727.                 } // switch(option)
  1728.  
  1729.                 W.del_message();
  1730.  
  1731.                 break;
  1732.  
  1733.               } // case -3
  1734.  
  1735.  
  1736.     } // switch(key)
  1737.  
  1738.     if ( (error_nodes.length()>0) || (error_edges.length()>0) )
  1739.     {
  1740.       overlap_message();  // Fehler ausgeben
  1741.     }
  1742.  
  1743.   } // while (option != 15)
  1744.  
  1745.   save_test();
  1746.  
  1747.   W.set_mode(W_save_mode);
  1748.   W.clear();
  1749.  
  1750.   cout<<"\nQUIT   -> you leave 'Graph_Editor'\n";
  1751.   cout<<"\n\n         *** Graph Editor ***\n\n";
  1752.  
  1753. } // GED
  1754.  
  1755. /*---------------------------- main -----------------------------------*/
  1756.  
  1757. main(int argc, char** argv)
  1758. {
  1759.   string f;
  1760.  
  1761.   if (argc < 2)  f="";
  1762.   else           f=argv[1];
  1763.  
  1764.  
  1765.   GED(f);
  1766. }
  1767.