home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / prog / graphics / ged1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  7.2 KB  |  375 lines
  1. #include <LEDA/graph.h>
  2. #include <LEDA/d_array.h>
  3. #include <LEDA/plane.h>
  4. #include <LEDA/window.h>
  5.  
  6. declare2(GRAPH,point,int)
  7.  
  8. declare2(d_array,point,node)
  9. declare2(d_array,node,int)
  10.  
  11. declare(node_array,node)
  12.  
  13. string filename;
  14.  
  15. GRAPH(point,int) G;
  16.  
  17. int node_count = 0;
  18.  
  19. window* Wp;
  20.  
  21. panel file_panel("FILE PANEL");
  22. panel init_panel("INIT PANEL");
  23.  
  24. int node_width = 12;
  25. int edge_width = 2;
  26. int xmin =  0;
  27. int xmax = 50;
  28. int ymin =  0;
  29.  
  30. color node_color = blue;
  31. color edge_color = red;
  32.  
  33. d_array(point,node)   V(nil);
  34. d_array(node,int)     name;
  35.  
  36.  
  37.  
  38. static void draw_node_cursor(double x, double y)
  39. { 
  40.   Wp->draw_node(x,y);
  41.  }
  42.  
  43.  
  44.  
  45. void draw_node(node v)
  46. { Wp->draw_text_node(G[v],form("%d",name[v]),node_color);
  47.  }
  48.  
  49.  
  50.  
  51. void draw_edge(edge e)
  52. { 
  53.   Wp->draw_edge_arrow(G[source(e)],G[target(e)],edge_color);
  54.  }
  55.  
  56. void message(string s)
  57. { s += "                              ";
  58.   Wp->del_message();
  59.   Wp->message(s);
  60. }
  61.  
  62.  
  63. void load_graph(string s)
  64. {
  65.  
  66.  
  67.   node v;
  68.   edge e;
  69.  
  70.   G.clear();
  71.   Wp->clear();
  72.  
  73.   if (s=="")
  74.     { message("Empty buffer");
  75.       return;
  76.      }
  77.   else
  78.     message(form("Reading file %s",~s));
  79.  
  80.   int x = G.read(s);
  81.  
  82.   if (x == 1) message("new file");
  83.  
  84.   if (x == 3) message("Warning: Illegal file type.");
  85.  
  86.   if (x == 2 )
  87.   { init_random();
  88.     message("Warning: Graph not created by graph edit.");
  89.     forall_nodes(v,G)
  90.       G[v] = point(2*random(1,24), 2*random(1,24));
  91.    }
  92.  
  93.  
  94.   forall_nodes(v,G) 
  95.   { name[v] = node_count++;
  96.     V[G[v]] = v;
  97.     draw_node(v);
  98.    }
  99.  
  100.   forall_edges(e,G) draw_edge(e);
  101.                  
  102. }
  103.  
  104. void read_graph(string s)
  105. {
  106.   message(form("Reading file %s",~s));
  107.  
  108.   GRAPH(point,int) X;
  109.   node v;
  110.   edge e;
  111.  
  112.   int x = X.read(s);
  113.  
  114.   if (x == 1) message("empty file");
  115.  
  116.   if (x == 2)
  117.   { message("Warning: File not created by graph edit.");
  118.     forall_nodes(v,X)
  119.       X[v] = point(random(1,49), random(1,49));
  120.    }
  121.  
  122.   node_array(node) corr(X);
  123.  
  124.   forall_nodes(v,X) 
  125.   { node u = G.new_node(G[v]);
  126.     corr[v] = u;
  127.     name[u] = node_count++;
  128.     V[G[u]] = u;
  129.     draw_node(u);
  130.    }
  131.  
  132.   forall_edges(e,X) 
  133.   { G.new_edge(corr[source(e)],corr[target(e)]);
  134.     draw_edge(e);
  135.    }
  136. }
  137.  
  138.  
  139. void save_graph(string f)
  140. { message(form("writing to file %s",~f));
  141.   G.write(f);
  142.  }
  143.  
  144. void panel_init()
  145. {
  146.   init_panel.text_item(" BUTTON        unshifted              shifted     ");
  147.   init_panel.text_item("                                                ");
  148.   init_panel.text_item(" LEFT          insert/move node       delete node ");
  149.   init_panel.text_item(" MIDDLE        insert edge            delete edge ");
  150.   init_panel.text_item(" RIGHT         File Menu              Help        ");
  151.   init_panel.text_item("                                                ");
  152.   init_panel.int_item("xmin",xmin);
  153.   init_panel.int_item("xmax",xmax);
  154.   init_panel.int_item("ymin",ymin);
  155.   init_panel.int_item("node width",node_width,5,20);
  156.   init_panel.int_item("edge width",edge_width,1,8);
  157.   init_panel.color_item("node color",node_color);
  158.   init_panel.color_item("edge color",edge_color);
  159.  
  160.   file_panel.string_item("file",filename);
  161.   file_panel.button("Cancel"); 
  162.   file_panel.button("Edit");
  163.   file_panel.button("Read");
  164.   file_panel.button("Save"); 
  165.   file_panel.button("Quit"); 
  166. }
  167.  
  168.  
  169. void ged_init()
  170. { 
  171.  
  172.   init_panel.open();
  173.  
  174.   Wp->init(xmin,xmax,ymin,1);
  175.   Wp->set_mode(xor_mode);
  176.   Wp->set_node_width(node_width);
  177.   Wp->set_line_width(edge_width);
  178.  
  179.   node v;
  180.   forall_nodes(v,G) draw_node(v);
  181.  
  182.   edge e;
  183.   forall_edges(e,G) draw_edge(e);
  184. }
  185.  
  186.  
  187.  
  188. void graph_edit(window& W, string s)
  189. {
  190.   real  x,y;
  191.   point p,q;
  192.   int   key = 0;
  193.   int k;
  194.  
  195.   Wp = &W;
  196.  
  197.   filename = s;
  198.  
  199.   drawing_mode save = W.get_mode();
  200.  
  201.  
  202.   panel_init();
  203.  
  204.   ged_init();
  205.  
  206.  
  207.   load_graph(filename);
  208.  
  209.  
  210.   for(;;)
  211.   {
  212.      key = W.read_mouse(x,y);
  213.  
  214.      W.del_message();
  215.  
  216.      p = point(x,y);
  217.  
  218.      switch(key) {
  219.  
  220.      case 1:  { 
  221.                 node v;
  222.  
  223.                 if (V[p] == nil)        // new node
  224.                 { v  = G.new_node(p);
  225.                   name[v] = node_count++;
  226.                   draw_node(v);
  227.                   V[p] = v;
  228.                  }
  229.                 else                    // move node
  230.                 { v = V[p];
  231.  
  232.                   draw_node(v);
  233.  
  234.                   W.read_mouse_action(draw_node_cursor,x,y);
  235.  
  236.                   point q(x,y);           // new position
  237.  
  238.                   if (V[q] != nil)        // position not free
  239.                   { draw_node(v);
  240.                     break;
  241.                    }
  242.  
  243.                   V[p] = nil;
  244.  
  245.                   edge e;
  246.  
  247.                   forall_edges(e,G) 
  248.                     if (source(e) == v || target(e) == v) draw_edge(e);
  249.  
  250.                   G[v] = q;
  251.                   V[q] = v;
  252.                   draw_node(v);
  253.  
  254.                   forall_edges(e,G) 
  255.                     if (source(e) == v || target(e) == v) draw_edge(e);
  256.  
  257.                  }
  258.                 break;
  259.                }
  260.  
  261.      case -1: { // delete node
  262.  
  263.                 node v = V[p];
  264.  
  265.                 edge e;
  266.                 if (v != nil) 
  267.                 { forall_edges(e,G) 
  268.                     if (source(e) == v || target(e) == v) draw_edge(e);
  269.  
  270.                   draw_node(v);
  271.  
  272.                   G.del_node(v);
  273.                   V[p] = nil;
  274.                  }
  275.  
  276.                 }
  277.  
  278.      case 2:  { // new edge
  279.                 int k;
  280.                 node v = V[p];
  281.                 node w;
  282.      
  283.                 if (v != nil) 
  284.                 { W.draw_filled_node(p);
  285.                   do { k = W.read_mouse_seg(p.xcoord(),p.ycoord(),x,y);
  286.                        w = V[point(x,y)];
  287.                        if (w != nil) 
  288.                          draw_edge(G.new_edge(v,w));
  289.                       } while ( w == nil && k == 2);
  290.                   W.draw_filled_node(p);
  291.                  }
  292.                 break;
  293.                }
  294.  
  295.      case -2: { // delete edge
  296.  
  297.                 node v = V[p];
  298.  
  299.                 if (v != nil) 
  300.                 { W.read_mouse_seg(p.xcoord(),p.ycoord(),x,y);
  301.                   q = point(x,y);
  302.                   node w = V[q];
  303.                   if (w != nil)
  304.                   { //linear search
  305.                     edge e = G.first_adj_edge(v);
  306.                     while (e != nil && target(e) != w) e = G.adj_succ(e);
  307.                     if (e != nil)
  308.                     { draw_edge(e);
  309.                       G.del_edge(e);
  310.                      }
  311.                    }
  312.                  }
  313.                 break;
  314.                }
  315.  
  316.  
  317.  
  318.      case  3: { //Menu
  319.  
  320.  
  321.                 k = file_panel.open();
  322.  
  323.                 switch (k) {
  324.  
  325.                  case 0 : // cancel
  326.                           break;
  327.  
  328.                  case 1 : // edit
  329.                           load_graph(filename);
  330.                           break;
  331.  
  332.                  case 2 : // read
  333.                           read_graph(filename);
  334.                           break;
  335.  
  336.                  case 3 : // save
  337.                           save_graph(filename);
  338.                           break;
  339.  
  340.                  case 4 : // quit
  341.                           exit(0);
  342.                           break;  
  343.                   }
  344.  
  345.                 break;
  346.               }
  347.  
  348.  
  349.      case -3:  { ged_init();
  350.                  break;
  351.                 }
  352.  
  353.  
  354.  
  355.     } // switch
  356.  
  357.   } // for(;;)
  358.  
  359.   W.set_mode(save);
  360.  
  361. }
  362.  
  363.  
  364. main(int argc, char** argv)
  365. {
  366.   window W;
  367.  
  368.   if (argc > 1)  
  369.      graph_edit(W,argv[1]);
  370.   else 
  371.      graph_edit(W,"");
  372.  
  373.  
  374. }
  375.