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