File graph_displayer is split in functional parts. gui
authorhegyi
Fri, 24 Jun 2005 07:58:18 +0000
branchgui
changeset 27e2c86ae158cf
parent 26 b0c76a4d5801
child 28 fa28f1071bd6
File graph_displayer is split in functional parts.
Makefile.am
graph_displayer_canvas-edge.cc
graph_displayer_canvas-event.cc
graph_displayer_canvas-zoom.cc
graph_displayer_canvas.cc
     1.1 --- a/Makefile.am	Thu Jun 23 17:56:24 2005 +0000
     1.2 +++ b/Makefile.am	Fri Jun 24 07:58:18 2005 +0000
     1.3 @@ -6,6 +6,9 @@
     1.4  gd_SOURCES = \
     1.5  	all_include.h \
     1.6  	graph_displayer_canvas.cc \
     1.7 +	graph_displayer_canvas-edge.cc \
     1.8 +	graph_displayer_canvas-event.cc \
     1.9 +	graph_displayer_canvas-zoom.cc \
    1.10  	graph_displayer_canvas.h \
    1.11  	graph-displayer.cc \
    1.12  	main_win.cc \
     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/graph_displayer_canvas-edge.cc	Fri Jun 24 07:58:18 2005 +0000
     2.3 @@ -0,0 +1,93 @@
     2.4 +#include <graph_displayer_canvas.h>
     2.5 +#include <broken_edge.h>
     2.6 +#include <math.h>
     2.7 +
     2.8 +
     2.9 +int GraphDisplayerCanvas::changeLineWidth (std::string mapname)
    2.10 +{
    2.11 +  for (EdgeIt i(g); i!=INVALID; ++i)
    2.12 +    {
    2.13 +      int w=(int)(*(mapstorage.edgemap_storage)[mapname])[i];
    2.14 +      if(w>=0)
    2.15 +	{
    2.16 +	  edgesmap[i]->property_width_pixels().set_value(w);
    2.17 +	}
    2.18 +    }
    2.19 +  return 0;
    2.20 +};
    2.21 +
    2.22 +int GraphDisplayerCanvas::changeColor (std::string mapname)
    2.23 +{  
    2.24 +
    2.25 +  //function maps the range of the maximum and
    2.26 +  //the minimum of the nodemap to the range of
    2.27 +  //green in RGB
    2.28 +
    2.29 +  for (EdgeIt i(g); i!=INVALID; ++i)
    2.30 +  {
    2.31 +    double w=(*(mapstorage.edgemap_storage)[mapname])[i];
    2.32 +    double max=mapstorage.maxOfEdgeMap(mapname);
    2.33 +    double min=mapstorage.minOfEdgeMap(mapname);
    2.34 +      
    2.35 +    //std::cout<<w<<" "<<max<<" "<<min<<" "<<100*(w-min)/(max-min)<<std::endl;
    2.36 +    Gdk::Color color;
    2.37 +    if(max!=min)
    2.38 +    {
    2.39 +      color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
    2.40 +    }
    2.41 +    else
    2.42 +    {
    2.43 +      color.set_rgb_p (0, 100, 0);
    2.44 +    }
    2.45 +
    2.46 +    edgesmap[i]->property_fill_color_gdk().set_value(color);
    2.47 +  }
    2.48 +  return 0;
    2.49 +};
    2.50 +
    2.51 +int GraphDisplayerCanvas::changeText (std::string mapname)
    2.52 +{
    2.53 +
    2.54 +  //the number in the map will be written on the edge
    2.55 +  //EXCEPT when the name of the map is Text, because
    2.56 +  //in that case empty string will be written, because
    2.57 +  //that is the deleter map
    2.58 +  //\todo isn't it a bit woodcutter?
    2.59 +
    2.60 +  for (EdgeIt i(g); i!=INVALID; ++i)
    2.61 +    {
    2.62 +      if(mapname!="Text")
    2.63 +	{
    2.64 +	  double number=(*(mapstorage.edgemap_storage)[mapname])[i];
    2.65 +	  int length=1;
    2.66 +	  //if number is smaller than one, length would be negative, or invalid
    2.67 +	  if(number>=1)
    2.68 +	    {
    2.69 +	      length=(int)(floor(log(number)/log(10)))+1;
    2.70 +	    }
    2.71 +	  int maxpos=(int)(pow(10,length-1));
    2.72 +	  int strl=length+1+RANGE;
    2.73 +	  char * str=new char[strl];
    2.74 +	  str[length]='.';
    2.75 +	  str[strl]='\0';
    2.76 +      
    2.77 +	  for(int j=0;j<strl;j++)
    2.78 +	    {
    2.79 +	      if(j!=length)
    2.80 +		{
    2.81 +		  int digit=(int)(number/maxpos);
    2.82 +		  str[j]=(digit+'0');
    2.83 +		  number-=digit*maxpos;
    2.84 +		  number*=10;
    2.85 +		}
    2.86 +	    }
    2.87 +      
    2.88 +	  edgetextmap[i]->property_text().set_value(str);
    2.89 +	}
    2.90 +      else
    2.91 +	{
    2.92 +	  edgetextmap[i]->property_text().set_value("");
    2.93 +	}
    2.94 +    }
    2.95 +  return 0;
    2.96 +};
     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/graph_displayer_canvas-event.cc	Fri Jun 24 07:58:18 2005 +0000
     3.3 @@ -0,0 +1,492 @@
     3.4 +#include <graph_displayer_canvas.h>
     3.5 +#include <broken_edge.h>
     3.6 +#include <math.h>
     3.7 +
     3.8 +
     3.9 +bool GraphDisplayerCanvas::on_expose_event(GdkEventExpose *event)
    3.10 +{
    3.11 +  Gnome::Canvas::CanvasAA::on_expose_event(event);
    3.12 +  //usleep(10000);
    3.13 +  //rezoom();
    3.14 +  return true;
    3.15 +}
    3.16 +
    3.17 +void GraphDisplayerCanvas::changeEditorialTool(int newtool)
    3.18 +{
    3.19 +  actual_handler.disconnect();
    3.20 +
    3.21 +  if(actual_tool==CREATE_EDGE)
    3.22 +    {
    3.23 +	GdkEvent * generated=new GdkEvent();
    3.24 +	generated->type=GDK_BUTTON_RELEASE;
    3.25 +	generated->button.button=3;
    3.26 +	create_edge_event_handler(generated);      
    3.27 +    }
    3.28 +
    3.29 +  actual_tool=newtool;
    3.30 +
    3.31 +  switch(newtool)
    3.32 +    {
    3.33 +    case MOVE:
    3.34 +      actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::move_event_handler), false);
    3.35 +      break;
    3.36 +
    3.37 +      //it has to assigned to canvas, because all the canvas has to be monitored, not only the elements of the already drawn group
    3.38 +    case CREATE_NODE:
    3.39 +      actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::create_node_event_handler), false);
    3.40 +      break;
    3.41 +
    3.42 +    case CREATE_EDGE:
    3.43 +      actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::create_edge_event_handler), false);
    3.44 +      break;
    3.45 +
    3.46 +    case ERASER:
    3.47 +      actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraser_event_handler), false);
    3.48 +      break;
    3.49 +
    3.50 +    default:
    3.51 +      break;
    3.52 +    }
    3.53 +}
    3.54 +
    3.55 +int GraphDisplayerCanvas::get_actual_tool()
    3.56 +{
    3.57 +  return actual_tool;
    3.58 +}
    3.59 +
    3.60 +bool GraphDisplayerCanvas::move_event_handler(GdkEvent* e)
    3.61 +{
    3.62 +  switch(e->type)
    3.63 +  {
    3.64 +    case GDK_BUTTON_PRESS:
    3.65 +      //we mark the location of the event to be able to calculate parameters of dragging
    3.66 +      clicked_x=e->button.x;
    3.67 +      clicked_y=e->button.y;
    3.68 +      active_item=(get_item_at(e->button.x, e->button.y));
    3.69 +      active_node=INVALID;
    3.70 +      for (NodeIt i(g); i!=INVALID; ++i)
    3.71 +	{
    3.72 +	  if(nodesmap[i]==active_item)
    3.73 +	    {
    3.74 +	      active_node=i;
    3.75 +	    }
    3.76 +	}
    3.77 +      switch(e->button.button)
    3.78 +	{
    3.79 +	case 3:      
    3.80 +	  isbutton=3;
    3.81 +	  break;
    3.82 +	default:
    3.83 +	  isbutton=1;
    3.84 +	  break;
    3.85 +	}
    3.86 +      break;
    3.87 +    case GDK_BUTTON_RELEASE:
    3.88 +      isbutton=0;
    3.89 +      active_item=NULL;
    3.90 +      active_node=INVALID;
    3.91 +      updateScrollRegion();
    3.92 +      break;
    3.93 +    case GDK_MOTION_NOTIFY:
    3.94 +      //we only have to do sg. if the mouse button is pressed AND the click was on a node that was found in the set of nodes
    3.95 +      if(active_node!=INVALID)
    3.96 +      {
    3.97 +	//new coordinates will be the old values,
    3.98 +	//because the item will be moved to the
    3.99 +	//new coordinate therefore the new movement
   3.100 +	//has to be calculated from here
   3.101 +
   3.102 +        double dx=e->motion.x-clicked_x;
   3.103 +        double dy=e->motion.y-clicked_y;
   3.104 +
   3.105 +        active_item->move(dx, dy);
   3.106 +
   3.107 +        clicked_x=e->motion.x;
   3.108 +        clicked_y=e->motion.y;
   3.109 +
   3.110 +	//all the edges connected to the moved point has to be redrawn
   3.111 +        EdgeIt ei;
   3.112 +
   3.113 +        g.firstOut(ei,active_node);
   3.114 +
   3.115 +        for(;ei!=INVALID;g.nextOut(ei))
   3.116 +        {
   3.117 +            Gnome::Canvas::Points coos;
   3.118 +            double x1, x2, y1, y2;
   3.119 +
   3.120 +            nodesmap[g.source(ei)]->get_bounds(x1, y1, x2, y2);
   3.121 +            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   3.122 +
   3.123 +            nodesmap[g.target(ei)]->get_bounds(x1, y1, x2, y2);
   3.124 +            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   3.125 +
   3.126 +	    if(isbutton==3)
   3.127 +	      {
   3.128 +		edgesmap[ei]->set_points(coos);
   3.129 +	      }
   3.130 +	    else
   3.131 +	      {
   3.132 +		edgesmap[ei]->set_points(coos,true);
   3.133 +	      }
   3.134 +
   3.135 +	    xy<double> text_pos=edgesmap[ei]->get_arrow_pos();
   3.136 +	    text_pos+=(xy<double>(10,10));
   3.137 +	    edgetextmap[ei]->property_x().set_value(text_pos.x);
   3.138 +	    edgetextmap[ei]->property_y().set_value(text_pos.y);
   3.139 +        }
   3.140 +
   3.141 +        g.firstIn(ei,active_node);
   3.142 +        for(;ei!=INVALID;g.nextIn(ei))
   3.143 +        {
   3.144 +            Gnome::Canvas::Points coos;
   3.145 +            double x1, x2, y1, y2;
   3.146 +
   3.147 +            nodesmap[g.source(ei)]->get_bounds(x1, y1, x2, y2);
   3.148 +            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   3.149 +
   3.150 +            nodesmap[g.target(ei)]->get_bounds(x1, y1, x2, y2);
   3.151 +            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   3.152 +
   3.153 +	    if(isbutton==3)
   3.154 +	      {
   3.155 +		edgesmap[ei]->set_points(coos);
   3.156 +	      }
   3.157 +	    else
   3.158 +	      {
   3.159 +		edgesmap[ei]->set_points(coos,true);
   3.160 +	      }
   3.161 +
   3.162 +	    xy<double> text_pos=edgesmap[ei]->get_arrow_pos();
   3.163 +	    text_pos+=(xy<double>(10,10));
   3.164 +	    edgetextmap[ei]->property_x().set_value(text_pos.x);
   3.165 +	    edgetextmap[ei]->property_y().set_value(text_pos.y);
   3.166 +        }
   3.167 +      }
   3.168 +    default: break;
   3.169 +  }
   3.170 +
   3.171 +  return true;
   3.172 +}
   3.173 +
   3.174 +bool GraphDisplayerCanvas::create_node_event_handler(GdkEvent* e)
   3.175 +{
   3.176 +  switch(e->type)
   3.177 +    {
   3.178 +
   3.179 +      //draw the new node in red at the clicked place
   3.180 +    case GDK_BUTTON_PRESS:
   3.181 +      isbutton=1;
   3.182 +
   3.183 +      active_node=NodeIt(g,g.addNode());
   3.184 +
   3.185 +      //initiating values corresponding to new node in maps
   3.186 +      
   3.187 +
   3.188 +      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
   3.189 +
   3.190 +      nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph, clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
   3.191 +      active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
   3.192 +      *(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
   3.193 +      *(nodesmap[active_node]) << Gnome::Canvas::Properties::outline_color("black");
   3.194 +      (nodesmap[active_node])->show();
   3.195 +      break;
   3.196 +
   3.197 +      //move the new node
   3.198 +    case GDK_MOTION_NOTIFY:
   3.199 +      {
   3.200 +	double world_motion_x, world_motion_y;
   3.201 +	GdkEvent * generated=new GdkEvent();
   3.202 +	window_to_world (e->motion.x, e->motion.y, world_motion_x, world_motion_y);
   3.203 +	generated->motion.x=world_motion_x;
   3.204 +	generated->motion.y=world_motion_y;
   3.205 +	generated->type=GDK_MOTION_NOTIFY;
   3.206 +	move_event_handler(generated);      
   3.207 +	break;
   3.208 +      }
   3.209 +
   3.210 +      //finalize the new node
   3.211 +    case GDK_BUTTON_RELEASE:
   3.212 +      isbutton=0;
   3.213 +      *active_item << Gnome::Canvas::Properties::fill_color("blue");
   3.214 +      active_item=NULL;
   3.215 +      active_node=INVALID;
   3.216 +      updateScrollRegion();
   3.217 +      break;
   3.218 +    default:
   3.219 +      break;
   3.220 +    }
   3.221 +  return false;
   3.222 +}
   3.223 +
   3.224 +bool GraphDisplayerCanvas::create_edge_event_handler(GdkEvent* e)
   3.225 +{
   3.226 +  switch(e->type)
   3.227 +    {
   3.228 +    case GDK_BUTTON_PRESS:
   3.229 +      //in edge creation right button has special meaning
   3.230 +      if(e->button.button!=3)
   3.231 +	{
   3.232 +	  //there is not yet selected node
   3.233 +	  if(active_node==INVALID)
   3.234 +	    {
   3.235 +	      //we mark the location of the event to be able to calculate parameters of dragging
   3.236 +	      clicked_x=e->button.x;
   3.237 +	      clicked_y=e->button.y;
   3.238 +	      active_item=(get_item_at(e->button.x, e->button.y));
   3.239 +	      active_node=INVALID;
   3.240 +	      for (NodeIt i(g); i!=INVALID; ++i)
   3.241 +		{
   3.242 +		  if(nodesmap[i]==active_item)
   3.243 +		    {
   3.244 +		      active_node=i;
   3.245 +		    }
   3.246 +		}
   3.247 +	      //the clicked item is really a node
   3.248 +	      if(active_node!=INVALID)
   3.249 +		{
   3.250 +		  *(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
   3.251 +		  isbutton=1;
   3.252 +		}
   3.253 +	      //clicked item was not a node. It could be e.g. edge.
   3.254 +	      else
   3.255 +		{
   3.256 +		  active_item=NULL;
   3.257 +		}
   3.258 +	    }
   3.259 +	  //we only have to do sg. if the mouse button
   3.260 +	  // is pressed already once AND the click was
   3.261 +	  // on a node that was found in the set of 
   3.262 +	  //nodes, and now we only search for the second 
   3.263 +	  //node
   3.264 +	  else
   3.265 +	    {
   3.266 +	      target_item=(get_item_at(e->button.x, e->button.y));
   3.267 +	      Graph::NodeIt target_node=INVALID;
   3.268 +	      for (NodeIt i(g); i!=INVALID; ++i)
   3.269 +		{
   3.270 +		  if(nodesmap[i]==target_item)
   3.271 +		    {
   3.272 +		      target_node=i;
   3.273 +		    }
   3.274 +		}
   3.275 +	      //the clicked item is a node, the edge can be drawn
   3.276 +	      if(target_node!=INVALID)
   3.277 +		{
   3.278 +		  *(nodesmap[target_node]) << Gnome::Canvas::Properties::fill_color("red");
   3.279 +
   3.280 +		  //creating new edge
   3.281 +		  active_edge=EdgeIt(g,g.addEdge(active_node, target_node));
   3.282 +
   3.283 +		  //initiating values corresponding to new edge in maps
   3.284 +		  mapstorage.init_maps_for_edge(active_edge);
   3.285 +	  
   3.286 +		  //calculating coordinates of new edge
   3.287 +		  Gnome::Canvas::Points coos;
   3.288 +		  double x1, x2, y1, y2;
   3.289 +	  
   3.290 +		  active_item->get_bounds(x1, y1, x2, y2);
   3.291 +		  coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   3.292 +
   3.293 +		  target_item->get_bounds(x1, y1, x2, y2);
   3.294 +		  coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   3.295 +
   3.296 +		  //drawing new edge
   3.297 +		  edgesmap[active_edge]=new BrokenEdge(displayed_graph, coos, *this);
   3.298 +		  *(edgesmap[active_edge]) << Gnome::Canvas::Properties::fill_color("green");
   3.299 +		  edgesmap[active_edge]->property_width_pixels().set_value(10);
   3.300 +
   3.301 +		  //redraw nodes to blank terminations of the new edge
   3.302 +		  target_item->raise_to_top();
   3.303 +		  active_item->raise_to_top();
   3.304 +
   3.305 +		  //initializing edge-text as well, to empty string
   3.306 +		  xy<double> text_pos=edgesmap[active_edge]->get_arrow_pos();
   3.307 +		  text_pos+=(xy<double>(10,10));
   3.308 +
   3.309 +		  edgetextmap[active_edge]=new Gnome::Canvas::Text(displayed_graph, text_pos.x, text_pos.y, "");
   3.310 +		  edgetextmap[active_edge]->property_fill_color().set_value("black");
   3.311 +		}
   3.312 +	      //clicked item was not a node. it could be an e.g. edge. we do not deal with it furthermore.
   3.313 +	      else
   3.314 +		{
   3.315 +		  target_item=NULL;
   3.316 +		}
   3.317 +	    }
   3.318 +	}
   3.319 +      break;
   3.320 +    case GDK_BUTTON_RELEASE:
   3.321 +      isbutton=0;
   3.322 +      //we clear settings in two cases
   3.323 +      //1: the edge is ready (target_item has valid value)
   3.324 +      //2: the edge creation is cancelled with right button
   3.325 +      if((target_item)||(e->button.button==3))
   3.326 +	{
   3.327 +	  if(active_item)
   3.328 +	    {
   3.329 +	      *active_item << Gnome::Canvas::Properties::fill_color("blue");
   3.330 +	      active_item=NULL;
   3.331 +	    }
   3.332 +	  if(target_item)
   3.333 +	    {
   3.334 +	      *target_item << Gnome::Canvas::Properties::fill_color("blue");
   3.335 +	      target_item=NULL;
   3.336 +	    }
   3.337 +	  active_node=INVALID;
   3.338 +	  active_edge=INVALID;
   3.339 +	}
   3.340 +      break;
   3.341 +    default:
   3.342 +      break;
   3.343 +    }
   3.344 +  return false;
   3.345 +}
   3.346 +
   3.347 +bool GraphDisplayerCanvas::eraser_event_handler(GdkEvent* e)
   3.348 +{
   3.349 +  switch(e->type)
   3.350 +    {
   3.351 +    case GDK_BUTTON_PRESS:
   3.352 +      active_item=(get_item_at(e->button.x, e->button.y));
   3.353 +      active_node=INVALID;
   3.354 +      active_edge=INVALID;
   3.355 +      for (NodeIt i(g); i!=INVALID; ++i)
   3.356 +	{
   3.357 +	  if(nodesmap[i]==active_item)
   3.358 +	    {
   3.359 +	      active_node=i;
   3.360 +	    }
   3.361 +	}
   3.362 +      if(active_node==INVALID)
   3.363 +	{
   3.364 +	  for (EdgeIt i(g); i!=INVALID; ++i)
   3.365 +	    {
   3.366 +	      if(edgesmap[i]==active_item)
   3.367 +		{
   3.368 +		  active_edge=i;
   3.369 +		}
   3.370 +	    }
   3.371 +	}
   3.372 +    *active_item << Gnome::Canvas::Properties::fill_color("red");
   3.373 +      break;
   3.374 +
   3.375 +    case GDK_BUTTON_RELEASE:
   3.376 +      if(active_item==(get_item_at(e->button.x, e->button.y)))
   3.377 +	{
   3.378 +	  if(active_node!=INVALID)
   3.379 +	    {
   3.380 +
   3.381 +	      //collecting edges to delete
   3.382 +	      EdgeIt e;
   3.383 +	      std::set<Graph::Edge> edges_to_delete;
   3.384 +
   3.385 +	      g.firstOut(e,active_node);
   3.386 +	      for(;e!=INVALID;g.nextOut(e))
   3.387 +		{
   3.388 +		      edges_to_delete.insert(e);
   3.389 +		}
   3.390 +
   3.391 +	      g.firstIn(e,active_node);
   3.392 +	      for(;e!=INVALID;g.nextIn(e))
   3.393 +		{
   3.394 +		      edges_to_delete.insert(e);
   3.395 +		}
   3.396 +
   3.397 +	      //deleting collected edges
   3.398 +	      for(std::set<Graph::Edge>::iterator edge_set_it=edges_to_delete.begin();edge_set_it!=edges_to_delete.end();edge_set_it++)
   3.399 +		{
   3.400 +		  delete_item(*edge_set_it);
   3.401 +		}
   3.402 +	      delete_item(active_node);
   3.403 +	    }
   3.404 +	  //a simple edge was chosen
   3.405 +	  else
   3.406 +	    {
   3.407 +	      delete_item(active_edge);
   3.408 +	    }
   3.409 +
   3.410 +	  
   3.411 +	}
   3.412 +      //pointer was moved, deletion is cancelled
   3.413 +      else
   3.414 +	{
   3.415 +	  if(active_node!=INVALID)
   3.416 +	    {
   3.417 +	      *active_item << Gnome::Canvas::Properties::fill_color("blue");
   3.418 +	    }
   3.419 +	  else
   3.420 +	    {
   3.421 +	      *active_item << Gnome::Canvas::Properties::fill_color("green");
   3.422 +	    }
   3.423 +	}
   3.424 +      //reseting datas
   3.425 +      active_item=NULL;
   3.426 +      active_edge=INVALID;
   3.427 +      active_node=INVALID;
   3.428 +      break;
   3.429 +
   3.430 +    case GDK_MOTION_NOTIFY:
   3.431 +      break;
   3.432 +
   3.433 +    default:
   3.434 +      break;
   3.435 +    }
   3.436 +  return true;
   3.437 +}
   3.438 +
   3.439 +void GraphDisplayerCanvas::delete_item(NodeIt node_to_delete)
   3.440 +{
   3.441 +  delete(nodesmap[node_to_delete]);
   3.442 +  g.erase(node_to_delete);
   3.443 +}
   3.444 +
   3.445 +void GraphDisplayerCanvas::delete_item(EdgeIt edge_to_delete)
   3.446 +{
   3.447 +  delete(edgesmap[edge_to_delete]);
   3.448 +  g.erase(edge_to_delete);
   3.449 +}
   3.450 +
   3.451 +void GraphDisplayerCanvas::delete_item(Graph::Edge edge_to_delete)
   3.452 +{
   3.453 +  delete(edgesmap[edge_to_delete]);
   3.454 +  g.erase(edge_to_delete);
   3.455 +}
   3.456 +
   3.457 +void GraphDisplayerCanvas::text_reposition(xy<double> new_place)
   3.458 +{
   3.459 +  new_place+=(xy<double>(10,10));
   3.460 +  edgetextmap[active_edge]->property_x().set_value(new_place.x);
   3.461 +  edgetextmap[active_edge]->property_y().set_value(new_place.y);
   3.462 +}
   3.463 +
   3.464 +void GraphDisplayerCanvas::toggle_edge_activity(BrokenEdge* active_bre, bool on)
   3.465 +{
   3.466 +  if(on)
   3.467 +    {
   3.468 +      if(active_edge!=INVALID)
   3.469 +	{
   3.470 +	  std::cout << "ERROR!!!! Valid edge found!" << std::endl;
   3.471 +	}
   3.472 +      else
   3.473 +	{
   3.474 +	  for (EdgeIt i(g); i!=INVALID; ++i)
   3.475 +	    {
   3.476 +	      if(edgesmap[i]==active_bre)
   3.477 +		{
   3.478 +		  active_edge=i;
   3.479 +		}
   3.480 +	    }
   3.481 +	}
   3.482 +    }
   3.483 +  else
   3.484 +    {
   3.485 +      if(active_edge!=INVALID)
   3.486 +	{
   3.487 +	  active_edge=INVALID;
   3.488 +	}
   3.489 +      else
   3.490 +	{
   3.491 +	  std::cout << "ERROR!!!! Invalid edge found!" << std::endl;
   3.492 +	}
   3.493 +    }
   3.494 +
   3.495 +}
     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/graph_displayer_canvas-zoom.cc	Fri Jun 24 07:58:18 2005 +0000
     4.3 @@ -0,0 +1,49 @@
     4.4 +#include <graph_displayer_canvas.h>
     4.5 +#include <broken_edge.h>
     4.6 +#include <math.h>
     4.7 +
     4.8 +void GraphDisplayerCanvas::zoomIn()
     4.9 +{
    4.10 +  set_pixels_per_unit(
    4.11 +      (1.0 + (double) zoom_step / 100.0) * get_pixels_per_unit());
    4.12 +}
    4.13 +
    4.14 +void GraphDisplayerCanvas::zoomOut()
    4.15 +{
    4.16 +  set_pixels_per_unit(
    4.17 +      (1.0 - (double) zoom_step / 100.0) * get_pixels_per_unit());
    4.18 +}
    4.19 +
    4.20 +void GraphDisplayerCanvas::zoomFit()
    4.21 +{
    4.22 +  // get the height and width of the canvas
    4.23 +  Gtk::Allocation a = get_allocation();
    4.24 +  int aw = a.get_width();
    4.25 +  int ah = a.get_height();
    4.26 +  // add some space
    4.27 +  aw -= 5; if (aw < 0) aw = 0;
    4.28 +  ah -= 5; if (ah < 0) ah = 0;
    4.29 +
    4.30 +  // get the bounding box of the graph
    4.31 +  double wx1, wy1, wx2, wy2;
    4.32 +  Gnome::Canvas::Item* pCanvasItem = root();
    4.33 +  pCanvasItem->get_bounds(wx1, wy1, wx2, wy2);
    4.34 +
    4.35 +  // fit the graph to the window
    4.36 +  double ppu1 = (double) aw / fabs(wx2 - wx1);
    4.37 +  double ppu2 = (double) ah / fabs(wy2 - wy1);
    4.38 +  set_pixels_per_unit((ppu1 < ppu2) ? ppu1 : ppu2);
    4.39 +}
    4.40 +
    4.41 +void GraphDisplayerCanvas::zoom100()
    4.42 +{
    4.43 +  set_pixels_per_unit(1.0);
    4.44 +}
    4.45 +
    4.46 +void GraphDisplayerCanvas::updateScrollRegion()
    4.47 +{
    4.48 +  double wx1, wy1, wx2, wy2;
    4.49 +  Gnome::Canvas::Item* pCanvasItem = root();
    4.50 +  pCanvasItem->get_bounds(wx1, wy1, wx2, wy2);
    4.51 +  set_scroll_region(wx1, wy1, wx2, wy2);
    4.52 +}
     5.1 --- a/graph_displayer_canvas.cc	Thu Jun 23 17:56:24 2005 +0000
     5.2 +++ b/graph_displayer_canvas.cc	Fri Jun 24 07:58:18 2005 +0000
     5.3 @@ -91,706 +91,3 @@
     5.4    writer.writeNodeMap("coordinates_y", yc);
     5.5    writer.run();
     5.6  }
     5.7 -
     5.8 -int GraphDisplayerCanvas::changeLineWidth (std::string mapname)
     5.9 -{
    5.10 -  for (EdgeIt i(g); i!=INVALID; ++i)
    5.11 -    {
    5.12 -      int w=(int)(*(mapstorage.edgemap_storage)[mapname])[i];
    5.13 -      if(w>=0)
    5.14 -	{
    5.15 -	  edgesmap[i]->property_width_pixels().set_value(w);
    5.16 -	}
    5.17 -    }
    5.18 -  return 0;
    5.19 -};
    5.20 -
    5.21 -int GraphDisplayerCanvas::changeColor (std::string mapname)
    5.22 -{  
    5.23 -
    5.24 -  //function maps the range of the maximum and
    5.25 -  //the minimum of the nodemap to the range of
    5.26 -  //green in RGB
    5.27 -
    5.28 -  for (EdgeIt i(g); i!=INVALID; ++i)
    5.29 -  {
    5.30 -    double w=(*(mapstorage.edgemap_storage)[mapname])[i];
    5.31 -    double max=mapstorage.maxOfEdgeMap(mapname);
    5.32 -    double min=mapstorage.minOfEdgeMap(mapname);
    5.33 -      
    5.34 -    //std::cout<<w<<" "<<max<<" "<<min<<" "<<100*(w-min)/(max-min)<<std::endl;
    5.35 -    Gdk::Color color;
    5.36 -    if(max!=min)
    5.37 -    {
    5.38 -      color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
    5.39 -    }
    5.40 -    else
    5.41 -    {
    5.42 -      color.set_rgb_p (0, 100, 0);
    5.43 -    }
    5.44 -
    5.45 -    edgesmap[i]->property_fill_color_gdk().set_value(color);
    5.46 -  }
    5.47 -  return 0;
    5.48 -};
    5.49 -
    5.50 -int GraphDisplayerCanvas::changeText (std::string mapname)
    5.51 -{
    5.52 -
    5.53 -  //the number in the map will be written on the edge
    5.54 -  //EXCEPT when the name of the map is Text, because
    5.55 -  //in that case empty string will be written, because
    5.56 -  //that is the deleter map
    5.57 -  //\todo isn't it a bit woodcutter?
    5.58 -
    5.59 -  for (EdgeIt i(g); i!=INVALID; ++i)
    5.60 -    {
    5.61 -      if(mapname!="Text")
    5.62 -	{
    5.63 -	  double number=(*(mapstorage.edgemap_storage)[mapname])[i];
    5.64 -	  int length=1;
    5.65 -	  //if number is smaller than one, length would be negative, or invalid
    5.66 -	  if(number>=1)
    5.67 -	    {
    5.68 -	      length=(int)(floor(log(number)/log(10)))+1;
    5.69 -	    }
    5.70 -	  int maxpos=(int)(pow(10,length-1));
    5.71 -	  int strl=length+1+RANGE;
    5.72 -	  char * str=new char[strl];
    5.73 -	  str[length]='.';
    5.74 -	  str[strl]='\0';
    5.75 -      
    5.76 -	  for(int j=0;j<strl;j++)
    5.77 -	    {
    5.78 -	      if(j!=length)
    5.79 -		{
    5.80 -		  int digit=(int)(number/maxpos);
    5.81 -		  str[j]=(digit+'0');
    5.82 -		  number-=digit*maxpos;
    5.83 -		  number*=10;
    5.84 -		}
    5.85 -	    }
    5.86 -      
    5.87 -	  edgetextmap[i]->property_text().set_value(str);
    5.88 -	}
    5.89 -      else
    5.90 -	{
    5.91 -	  edgetextmap[i]->property_text().set_value("");
    5.92 -	}
    5.93 -    }
    5.94 -  return 0;
    5.95 -};
    5.96 -
    5.97 -//Deprecated
    5.98 -bool GraphDisplayerCanvas::event_handler(GdkEvent* e, Node n)
    5.99 -{
   5.100 -  switch(e->type)
   5.101 -  {
   5.102 -    case GDK_BUTTON_PRESS:
   5.103 -      //we mark the location of the event to be able to calculate parameters of dragging
   5.104 -      clicked_x=e->button.x;
   5.105 -      clicked_y=e->button.y;
   5.106 -      active_item=(get_item_at(e->button.x, e->button.y));
   5.107 -      isbutton=1;
   5.108 -      break;
   5.109 -    case GDK_BUTTON_RELEASE:
   5.110 -      isbutton=0;
   5.111 -      active_item=NULL;
   5.112 -      updateScrollRegion();
   5.113 -      break;
   5.114 -    case GDK_MOTION_NOTIFY:
   5.115 -      //we only have to do sg. if the mouse button is pressed
   5.116 -      if(isbutton)
   5.117 -      {
   5.118 -	//new coordinates will be the old values,
   5.119 -	//because the item will be moved to the
   5.120 -	//new coordinate therefore the new movement
   5.121 -	//has to be calculated from here
   5.122 -
   5.123 -        double dx=e->motion.x-clicked_x;
   5.124 -        double dy=e->motion.y-clicked_y;
   5.125 -        active_item->move(dx, dy);
   5.126 -        clicked_x=e->motion.x;
   5.127 -        clicked_y=e->motion.y;
   5.128 -
   5.129 -	//all the edges connected to the moved point has to be redrawn
   5.130 -
   5.131 -        EdgeIt e;
   5.132 -        g.firstOut(e,n);
   5.133 -        for(;e!=INVALID;g.nextOut(e))
   5.134 -        {
   5.135 -            Gnome::Canvas::Points coos;
   5.136 -            double x1, x2, y1, y2;
   5.137 -
   5.138 -            nodesmap[g.source(e)]->get_bounds(x1, y1, x2, y2);
   5.139 -            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.140 -
   5.141 -            nodesmap[g.target(e)]->get_bounds(x1, y1, x2, y2);
   5.142 -            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.143 -
   5.144 -            edgesmap[e]->property_points().set_value(coos);
   5.145 -
   5.146 -	    edgesmap[e]->get_bounds(x1, y1, x2, y2);
   5.147 -
   5.148 -	    edgetextmap[e]->property_x().set_value((x1+x2)/2);
   5.149 -	    edgetextmap[e]->property_y().set_value((y1+y2)/2);
   5.150 -        }
   5.151 -
   5.152 -        g.firstIn(e,n);
   5.153 -        for(;e!=INVALID;g.nextIn(e))
   5.154 -        {
   5.155 -            Gnome::Canvas::Points coos;
   5.156 -            double x1, x2, y1, y2;
   5.157 -
   5.158 -            nodesmap[g.source(e)]->get_bounds(x1, y1, x2, y2);
   5.159 -            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.160 -
   5.161 -            nodesmap[g.target(e)]->get_bounds(x1, y1, x2, y2);
   5.162 -            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.163 -
   5.164 -            edgesmap[e]->property_points().set_value(coos);
   5.165 -
   5.166 -	    edgesmap[e]->get_bounds(x1, y1, x2, y2);
   5.167 -
   5.168 -	    edgetextmap[e]->property_x().set_value((x1+x2)/2);
   5.169 -	    edgetextmap[e]->property_y().set_value((y1+y2)/2);
   5.170 -        }
   5.171 -      }
   5.172 -    default: break;
   5.173 -  }
   5.174 -  return true;
   5.175 -}
   5.176 -
   5.177 -bool GraphDisplayerCanvas::on_expose_event(GdkEventExpose *event)
   5.178 -{
   5.179 -  Gnome::Canvas::CanvasAA::on_expose_event(event);
   5.180 -  //usleep(10000);
   5.181 -  //rezoom();
   5.182 -  return true;
   5.183 -}
   5.184 -
   5.185 -void GraphDisplayerCanvas::zoomIn()
   5.186 -{
   5.187 -  set_pixels_per_unit(
   5.188 -      (1.0 + (double) zoom_step / 100.0) * get_pixels_per_unit());
   5.189 -}
   5.190 -
   5.191 -void GraphDisplayerCanvas::zoomOut()
   5.192 -{
   5.193 -  set_pixels_per_unit(
   5.194 -      (1.0 - (double) zoom_step / 100.0) * get_pixels_per_unit());
   5.195 -}
   5.196 -
   5.197 -void GraphDisplayerCanvas::zoomFit()
   5.198 -{
   5.199 -  // get the height and width of the canvas
   5.200 -  Gtk::Allocation a = get_allocation();
   5.201 -  int aw = a.get_width();
   5.202 -  int ah = a.get_height();
   5.203 -  // add some space
   5.204 -  aw -= 5; if (aw < 0) aw = 0;
   5.205 -  ah -= 5; if (ah < 0) ah = 0;
   5.206 -
   5.207 -  // get the bounding box of the graph
   5.208 -  double wx1, wy1, wx2, wy2;
   5.209 -  Gnome::Canvas::Item* pCanvasItem = root();
   5.210 -  pCanvasItem->get_bounds(wx1, wy1, wx2, wy2);
   5.211 -
   5.212 -  // fit the graph to the window
   5.213 -  double ppu1 = (double) aw / fabs(wx2 - wx1);
   5.214 -  double ppu2 = (double) ah / fabs(wy2 - wy1);
   5.215 -  set_pixels_per_unit((ppu1 < ppu2) ? ppu1 : ppu2);
   5.216 -}
   5.217 -
   5.218 -void GraphDisplayerCanvas::zoom100()
   5.219 -{
   5.220 -  set_pixels_per_unit(1.0);
   5.221 -}
   5.222 -
   5.223 -void GraphDisplayerCanvas::updateScrollRegion()
   5.224 -{
   5.225 -  double wx1, wy1, wx2, wy2;
   5.226 -  Gnome::Canvas::Item* pCanvasItem = root();
   5.227 -  pCanvasItem->get_bounds(wx1, wy1, wx2, wy2);
   5.228 -  set_scroll_region(wx1, wy1, wx2, wy2);
   5.229 -}
   5.230 -
   5.231 -void GraphDisplayerCanvas::changeEditorialTool(int newtool)
   5.232 -{
   5.233 -  actual_handler.disconnect();
   5.234 -
   5.235 -  if(actual_tool==CREATE_EDGE)
   5.236 -    {
   5.237 -	GdkEvent * generated=new GdkEvent();
   5.238 -	generated->type=GDK_BUTTON_RELEASE;
   5.239 -	generated->button.button=3;
   5.240 -	create_edge_event_handler(generated);      
   5.241 -    }
   5.242 -
   5.243 -  actual_tool=newtool;
   5.244 -
   5.245 -  switch(newtool)
   5.246 -    {
   5.247 -    case MOVE:
   5.248 -      actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::move_event_handler), false);
   5.249 -      break;
   5.250 -
   5.251 -      //it has to assigned to canvas, because all the canvas has to be monitored, not only the elements of the already drawn group
   5.252 -    case CREATE_NODE:
   5.253 -      actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::create_node_event_handler), false);
   5.254 -      break;
   5.255 -
   5.256 -    case CREATE_EDGE:
   5.257 -      actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::create_edge_event_handler), false);
   5.258 -      break;
   5.259 -
   5.260 -    case ERASER:
   5.261 -      actual_handler=displayed_graph.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraser_event_handler), false);
   5.262 -      break;
   5.263 -
   5.264 -    default:
   5.265 -      break;
   5.266 -    }
   5.267 -}
   5.268 -
   5.269 -int GraphDisplayerCanvas::get_actual_tool()
   5.270 -{
   5.271 -  return actual_tool;
   5.272 -}
   5.273 -
   5.274 -bool GraphDisplayerCanvas::move_event_handler(GdkEvent* e)
   5.275 -{
   5.276 -  switch(e->type)
   5.277 -  {
   5.278 -    case GDK_BUTTON_PRESS:
   5.279 -      //we mark the location of the event to be able to calculate parameters of dragging
   5.280 -      clicked_x=e->button.x;
   5.281 -      clicked_y=e->button.y;
   5.282 -      active_item=(get_item_at(e->button.x, e->button.y));
   5.283 -      active_node=INVALID;
   5.284 -      for (NodeIt i(g); i!=INVALID; ++i)
   5.285 -	{
   5.286 -	  if(nodesmap[i]==active_item)
   5.287 -	    {
   5.288 -	      active_node=i;
   5.289 -	    }
   5.290 -	}
   5.291 -      switch(e->button.button)
   5.292 -	{
   5.293 -	case 3:      
   5.294 -	  isbutton=3;
   5.295 -	  break;
   5.296 -	default:
   5.297 -	  isbutton=1;
   5.298 -	  break;
   5.299 -	}
   5.300 -      break;
   5.301 -    case GDK_BUTTON_RELEASE:
   5.302 -      isbutton=0;
   5.303 -      active_item=NULL;
   5.304 -      active_node=INVALID;
   5.305 -      updateScrollRegion();
   5.306 -      break;
   5.307 -    case GDK_MOTION_NOTIFY:
   5.308 -      //we only have to do sg. if the mouse button is pressed AND the click was on a node that was found in the set of nodes
   5.309 -      if(active_node!=INVALID)
   5.310 -      {
   5.311 -	//new coordinates will be the old values,
   5.312 -	//because the item will be moved to the
   5.313 -	//new coordinate therefore the new movement
   5.314 -	//has to be calculated from here
   5.315 -
   5.316 -        double dx=e->motion.x-clicked_x;
   5.317 -        double dy=e->motion.y-clicked_y;
   5.318 -
   5.319 -        active_item->move(dx, dy);
   5.320 -
   5.321 -        clicked_x=e->motion.x;
   5.322 -        clicked_y=e->motion.y;
   5.323 -
   5.324 -	//all the edges connected to the moved point has to be redrawn
   5.325 -        EdgeIt ei;
   5.326 -
   5.327 -        g.firstOut(ei,active_node);
   5.328 -
   5.329 -        for(;ei!=INVALID;g.nextOut(ei))
   5.330 -        {
   5.331 -            Gnome::Canvas::Points coos;
   5.332 -            double x1, x2, y1, y2;
   5.333 -
   5.334 -            nodesmap[g.source(ei)]->get_bounds(x1, y1, x2, y2);
   5.335 -            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.336 -
   5.337 -            nodesmap[g.target(ei)]->get_bounds(x1, y1, x2, y2);
   5.338 -            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.339 -
   5.340 -	    if(isbutton==3)
   5.341 -	      {
   5.342 -		edgesmap[ei]->set_points(coos);
   5.343 -	      }
   5.344 -	    else
   5.345 -	      {
   5.346 -		edgesmap[ei]->set_points(coos,true);
   5.347 -	      }
   5.348 -
   5.349 -	    xy<double> text_pos=edgesmap[ei]->get_arrow_pos();
   5.350 -	    text_pos+=(xy<double>(10,10));
   5.351 -	    edgetextmap[ei]->property_x().set_value(text_pos.x);
   5.352 -	    edgetextmap[ei]->property_y().set_value(text_pos.y);
   5.353 -        }
   5.354 -
   5.355 -        g.firstIn(ei,active_node);
   5.356 -        for(;ei!=INVALID;g.nextIn(ei))
   5.357 -        {
   5.358 -            Gnome::Canvas::Points coos;
   5.359 -            double x1, x2, y1, y2;
   5.360 -
   5.361 -            nodesmap[g.source(ei)]->get_bounds(x1, y1, x2, y2);
   5.362 -            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.363 -
   5.364 -            nodesmap[g.target(ei)]->get_bounds(x1, y1, x2, y2);
   5.365 -            coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.366 -
   5.367 -	    if(isbutton==3)
   5.368 -	      {
   5.369 -		edgesmap[ei]->set_points(coos);
   5.370 -	      }
   5.371 -	    else
   5.372 -	      {
   5.373 -		edgesmap[ei]->set_points(coos,true);
   5.374 -	      }
   5.375 -
   5.376 -	    xy<double> text_pos=edgesmap[ei]->get_arrow_pos();
   5.377 -	    text_pos+=(xy<double>(10,10));
   5.378 -	    edgetextmap[ei]->property_x().set_value(text_pos.x);
   5.379 -	    edgetextmap[ei]->property_y().set_value(text_pos.y);
   5.380 -        }
   5.381 -      }
   5.382 -    default: break;
   5.383 -  }
   5.384 -
   5.385 -  return true;
   5.386 -}
   5.387 -
   5.388 -bool GraphDisplayerCanvas::create_node_event_handler(GdkEvent* e)
   5.389 -{
   5.390 -  switch(e->type)
   5.391 -    {
   5.392 -
   5.393 -      //draw the new node in red at the clicked place
   5.394 -    case GDK_BUTTON_PRESS:
   5.395 -      isbutton=1;
   5.396 -
   5.397 -      active_node=NodeIt(g,g.addNode());
   5.398 -
   5.399 -      //initiating values corresponding to new node in maps
   5.400 -      
   5.401 -
   5.402 -      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
   5.403 -
   5.404 -      nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph, clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
   5.405 -      active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
   5.406 -      *(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
   5.407 -      *(nodesmap[active_node]) << Gnome::Canvas::Properties::outline_color("black");
   5.408 -      (nodesmap[active_node])->show();
   5.409 -      break;
   5.410 -
   5.411 -      //move the new node
   5.412 -    case GDK_MOTION_NOTIFY:
   5.413 -      {
   5.414 -	double world_motion_x, world_motion_y;
   5.415 -	GdkEvent * generated=new GdkEvent();
   5.416 -	window_to_world (e->motion.x, e->motion.y, world_motion_x, world_motion_y);
   5.417 -	generated->motion.x=world_motion_x;
   5.418 -	generated->motion.y=world_motion_y;
   5.419 -	generated->type=GDK_MOTION_NOTIFY;
   5.420 -	move_event_handler(generated);      
   5.421 -	break;
   5.422 -      }
   5.423 -
   5.424 -      //finalize the new node
   5.425 -    case GDK_BUTTON_RELEASE:
   5.426 -      isbutton=0;
   5.427 -      *active_item << Gnome::Canvas::Properties::fill_color("blue");
   5.428 -      active_item=NULL;
   5.429 -      active_node=INVALID;
   5.430 -      updateScrollRegion();
   5.431 -      break;
   5.432 -    default:
   5.433 -      break;
   5.434 -    }
   5.435 -  return false;
   5.436 -}
   5.437 -
   5.438 -bool GraphDisplayerCanvas::create_edge_event_handler(GdkEvent* e)
   5.439 -{
   5.440 -  switch(e->type)
   5.441 -    {
   5.442 -    case GDK_BUTTON_PRESS:
   5.443 -      //in edge creation right button has special meaning
   5.444 -      if(e->button.button!=3)
   5.445 -	{
   5.446 -	  //there is not yet selected node
   5.447 -	  if(active_node==INVALID)
   5.448 -	    {
   5.449 -	      //we mark the location of the event to be able to calculate parameters of dragging
   5.450 -	      clicked_x=e->button.x;
   5.451 -	      clicked_y=e->button.y;
   5.452 -	      active_item=(get_item_at(e->button.x, e->button.y));
   5.453 -	      active_node=INVALID;
   5.454 -	      for (NodeIt i(g); i!=INVALID; ++i)
   5.455 -		{
   5.456 -		  if(nodesmap[i]==active_item)
   5.457 -		    {
   5.458 -		      active_node=i;
   5.459 -		    }
   5.460 -		}
   5.461 -	      //the clicked item is really a node
   5.462 -	      if(active_node!=INVALID)
   5.463 -		{
   5.464 -		  *(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
   5.465 -		  isbutton=1;
   5.466 -		}
   5.467 -	      //clicked item was not a node. It could be e.g. edge.
   5.468 -	      else
   5.469 -		{
   5.470 -		  active_item=NULL;
   5.471 -		}
   5.472 -	    }
   5.473 -	  //we only have to do sg. if the mouse button
   5.474 -	  // is pressed already once AND the click was
   5.475 -	  // on a node that was found in the set of 
   5.476 -	  //nodes, and now we only search for the second 
   5.477 -	  //node
   5.478 -	  else
   5.479 -	    {
   5.480 -	      target_item=(get_item_at(e->button.x, e->button.y));
   5.481 -	      Graph::NodeIt target_node=INVALID;
   5.482 -	      for (NodeIt i(g); i!=INVALID; ++i)
   5.483 -		{
   5.484 -		  if(nodesmap[i]==target_item)
   5.485 -		    {
   5.486 -		      target_node=i;
   5.487 -		    }
   5.488 -		}
   5.489 -	      //the clicked item is a node, the edge can be drawn
   5.490 -	      if(target_node!=INVALID)
   5.491 -		{
   5.492 -		  *(nodesmap[target_node]) << Gnome::Canvas::Properties::fill_color("red");
   5.493 -
   5.494 -		  //creating new edge
   5.495 -		  active_edge=EdgeIt(g,g.addEdge(active_node, target_node));
   5.496 -
   5.497 -		  //initiating values corresponding to new edge in maps
   5.498 -		  mapstorage.init_maps_for_edge(active_edge);
   5.499 -	  
   5.500 -		  //calculating coordinates of new edge
   5.501 -		  Gnome::Canvas::Points coos;
   5.502 -		  double x1, x2, y1, y2;
   5.503 -	  
   5.504 -		  active_item->get_bounds(x1, y1, x2, y2);
   5.505 -		  coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.506 -
   5.507 -		  target_item->get_bounds(x1, y1, x2, y2);
   5.508 -		  coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
   5.509 -
   5.510 -		  //drawing new edge
   5.511 -		  edgesmap[active_edge]=new BrokenEdge(displayed_graph, coos, *this);
   5.512 -		  *(edgesmap[active_edge]) << Gnome::Canvas::Properties::fill_color("green");
   5.513 -		  edgesmap[active_edge]->property_width_pixels().set_value(10);
   5.514 -
   5.515 -		  //redraw nodes to blank terminations of the new edge
   5.516 -		  target_item->raise_to_top();
   5.517 -		  active_item->raise_to_top();
   5.518 -
   5.519 -		  //initializing edge-text as well, to empty string
   5.520 -		  xy<double> text_pos=edgesmap[active_edge]->get_arrow_pos();
   5.521 -		  text_pos+=(xy<double>(10,10));
   5.522 -
   5.523 -		  edgetextmap[active_edge]=new Gnome::Canvas::Text(displayed_graph, text_pos.x, text_pos.y, "");
   5.524 -		  edgetextmap[active_edge]->property_fill_color().set_value("black");
   5.525 -		}
   5.526 -	      //clicked item was not a node. it could be an e.g. edge. we do not deal with it furthermore.
   5.527 -	      else
   5.528 -		{
   5.529 -		  target_item=NULL;
   5.530 -		}
   5.531 -	    }
   5.532 -	}
   5.533 -      break;
   5.534 -    case GDK_BUTTON_RELEASE:
   5.535 -      isbutton=0;
   5.536 -      //we clear settings in two cases
   5.537 -      //1: the edge is ready (target_item has valid value)
   5.538 -      //2: the edge creation is cancelled with right button
   5.539 -      if((target_item)||(e->button.button==3))
   5.540 -	{
   5.541 -	  if(active_item)
   5.542 -	    {
   5.543 -	      *active_item << Gnome::Canvas::Properties::fill_color("blue");
   5.544 -	      active_item=NULL;
   5.545 -	    }
   5.546 -	  if(target_item)
   5.547 -	    {
   5.548 -	      *target_item << Gnome::Canvas::Properties::fill_color("blue");
   5.549 -	      target_item=NULL;
   5.550 -	    }
   5.551 -	  active_node=INVALID;
   5.552 -	  active_edge=INVALID;
   5.553 -	}
   5.554 -      break;
   5.555 -    default:
   5.556 -      break;
   5.557 -    }
   5.558 -  return false;
   5.559 -}
   5.560 -
   5.561 -bool GraphDisplayerCanvas::eraser_event_handler(GdkEvent* e)
   5.562 -{
   5.563 -  switch(e->type)
   5.564 -    {
   5.565 -    case GDK_BUTTON_PRESS:
   5.566 -      active_item=(get_item_at(e->button.x, e->button.y));
   5.567 -      active_node=INVALID;
   5.568 -      active_edge=INVALID;
   5.569 -      for (NodeIt i(g); i!=INVALID; ++i)
   5.570 -	{
   5.571 -	  if(nodesmap[i]==active_item)
   5.572 -	    {
   5.573 -	      active_node=i;
   5.574 -	    }
   5.575 -	}
   5.576 -      if(active_node==INVALID)
   5.577 -	{
   5.578 -	  for (EdgeIt i(g); i!=INVALID; ++i)
   5.579 -	    {
   5.580 -	      if(edgesmap[i]==active_item)
   5.581 -		{
   5.582 -		  active_edge=i;
   5.583 -		}
   5.584 -	    }
   5.585 -	}
   5.586 -    *active_item << Gnome::Canvas::Properties::fill_color("red");
   5.587 -      break;
   5.588 -
   5.589 -    case GDK_BUTTON_RELEASE:
   5.590 -      if(active_item==(get_item_at(e->button.x, e->button.y)))
   5.591 -	{
   5.592 -	  if(active_node!=INVALID)
   5.593 -	    {
   5.594 -
   5.595 -	      //collecting edges to delete
   5.596 -	      EdgeIt e;
   5.597 -	      std::set<Graph::Edge> edges_to_delete;
   5.598 -
   5.599 -	      g.firstOut(e,active_node);
   5.600 -	      for(;e!=INVALID;g.nextOut(e))
   5.601 -		{
   5.602 -		      edges_to_delete.insert(e);
   5.603 -		}
   5.604 -
   5.605 -	      g.firstIn(e,active_node);
   5.606 -	      for(;e!=INVALID;g.nextIn(e))
   5.607 -		{
   5.608 -		      edges_to_delete.insert(e);
   5.609 -		}
   5.610 -
   5.611 -	      //deleting collected edges
   5.612 -	      for(std::set<Graph::Edge>::iterator edge_set_it=edges_to_delete.begin();edge_set_it!=edges_to_delete.end();edge_set_it++)
   5.613 -		{
   5.614 -		  delete_item(*edge_set_it);
   5.615 -		}
   5.616 -	      delete_item(active_node);
   5.617 -	    }
   5.618 -	  //a simple edge was chosen
   5.619 -	  else
   5.620 -	    {
   5.621 -	      delete_item(active_edge);
   5.622 -	    }
   5.623 -
   5.624 -	  
   5.625 -	}
   5.626 -      //pointer was moved, deletion is cancelled
   5.627 -      else
   5.628 -	{
   5.629 -	  if(active_node!=INVALID)
   5.630 -	    {
   5.631 -	      *active_item << Gnome::Canvas::Properties::fill_color("blue");
   5.632 -	    }
   5.633 -	  else
   5.634 -	    {
   5.635 -	      *active_item << Gnome::Canvas::Properties::fill_color("green");
   5.636 -	    }
   5.637 -	}
   5.638 -      //reseting datas
   5.639 -      active_item=NULL;
   5.640 -      active_edge=INVALID;
   5.641 -      active_node=INVALID;
   5.642 -      break;
   5.643 -
   5.644 -    case GDK_MOTION_NOTIFY:
   5.645 -      break;
   5.646 -
   5.647 -    default:
   5.648 -      break;
   5.649 -    }
   5.650 -  return true;
   5.651 -}
   5.652 -
   5.653 -void GraphDisplayerCanvas::delete_item(NodeIt node_to_delete)
   5.654 -{
   5.655 -  delete(nodesmap[node_to_delete]);
   5.656 -  g.erase(node_to_delete);
   5.657 -}
   5.658 -
   5.659 -void GraphDisplayerCanvas::delete_item(EdgeIt edge_to_delete)
   5.660 -{
   5.661 -  delete(edgesmap[edge_to_delete]);
   5.662 -  g.erase(edge_to_delete);
   5.663 -}
   5.664 -
   5.665 -void GraphDisplayerCanvas::delete_item(Graph::Edge edge_to_delete)
   5.666 -{
   5.667 -  delete(edgesmap[edge_to_delete]);
   5.668 -  g.erase(edge_to_delete);
   5.669 -}
   5.670 -
   5.671 -void GraphDisplayerCanvas::text_reposition(xy<double> new_place)
   5.672 -{
   5.673 -  new_place+=(xy<double>(10,10));
   5.674 -  edgetextmap[active_edge]->property_x().set_value(new_place.x);
   5.675 -  edgetextmap[active_edge]->property_y().set_value(new_place.y);
   5.676 -}
   5.677 -
   5.678 -void GraphDisplayerCanvas::toggle_edge_activity(BrokenEdge* active_bre, bool on)
   5.679 -{
   5.680 -  if(on)
   5.681 -    {
   5.682 -      if(active_edge!=INVALID)
   5.683 -	{
   5.684 -	  std::cout << "ERROR!!!! Valid edge found!" << std::endl;
   5.685 -	}
   5.686 -      else
   5.687 -	{
   5.688 -	  for (EdgeIt i(g); i!=INVALID; ++i)
   5.689 -	    {
   5.690 -	      if(edgesmap[i]==active_bre)
   5.691 -		{
   5.692 -		  active_edge=i;
   5.693 -		}
   5.694 -	    }
   5.695 -	}
   5.696 -    }
   5.697 -  else
   5.698 -    {
   5.699 -      if(active_edge!=INVALID)
   5.700 -	{
   5.701 -	  active_edge=INVALID;
   5.702 -	}
   5.703 -      else
   5.704 -	{
   5.705 -	  std::cout << "ERROR!!!! Invalid edge found!" << std::endl;
   5.706 -	}
   5.707 -    }
   5.708 -
   5.709 -}