lemon-0.x: comparison gui/graph_displayer

equal deleted inserted replaced

-:6619e8d691cb
+:a94d1af9eb48
 //we mark the location of the event to be able to calculate parameters of dragging
 window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
 active_item=(get_item_at(clicked_x, clicked_y));
 active_node=INVALID;
-for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 	{
 	  if(nodesmap[i]==active_item)
 	    {
 	      active_node=i;
 	    }
 break;
 case GDK_MOTION_NOTIFY:
 //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
 if(active_node!=INVALID)
 {
-mapstorage.modified = true;
+(mainwin.mapstorage).modified = true;
 	//new coordinates will be the old values,
 	//because the item will be moved to the
 	//new coordinate therefore the new movement
 	//has to be calculated from here
 	//repositioning node and its text
 active_item->move(dx, dy);
 	nodetextmap[active_node]->move(dx, dy);
 // the new coordinates of the centre of the node
-double coord_x = new_x - (clicked_x - mapstorage.coords[active_node].x);
+double coord_x = new_x - (clicked_x - (mainwin.mapstorage).coords[active_node].x);
-double coord_y = new_y - (clicked_y - mapstorage.coords[active_node].y);
+double coord_y = new_y - (clicked_y - (mainwin.mapstorage).coords[active_node].y);
 clicked_x=new_x;
 clicked_y=new_y;
 // write back the new coordinates to the coords map
-mapstorage.coords.set(active_node, xy<double>(coord_x, coord_y));
+(mainwin.mapstorage).coords.set(active_node, xy<double>(coord_x, coord_y));
 // reposition the coordinates text
 std::ostringstream ostr;
 ostr << "(" <<
-mapstorage.coords[active_node].x << ", " <<
+(mainwin.mapstorage).coords[active_node].x << ", " <<
-mapstorage.coords[active_node].y << ")";
+(mainwin.mapstorage).coords[active_node].y << ")";
 double radius =
 (nodesmap[active_node]->property_x2().get_value() -
 nodesmap[active_node]->property_x1().get_value()) / 2.0;
 if (coord_text)
 {
 coord_text->property_text().set_value(ostr.str());
-coord_text->property_x().set_value(mapstorage.coords[active_node].x +
+coord_text->property_x().set_value((mainwin.mapstorage).coords[active_node].x +
 radius);
-coord_text->property_y().set_value(mapstorage.coords[active_node].y -
+coord_text->property_y().set_value((mainwin.mapstorage).coords[active_node].y -
 radius);
 }
 else
 {
 coord_text = new Gnome::Canvas::Text(
 displayed_graph,
-mapstorage.coords[active_node].x + radius,
+(mainwin.mapstorage).coords[active_node].x + radius,
-mapstorage.coords[active_node].y - radius,
+(mainwin.mapstorage).coords[active_node].y - radius,
 ostr.str());
 coord_text->property_fill_color().set_value("black");
 coord_text->property_anchor().set_value(Gtk::ANCHOR_SOUTH_WEST);
 }
 	//all the edges connected to the moved point has to be redrawn
-for(OutEdgeIt ei(mapstorage.graph,active_node);ei!=INVALID;++ei)
+for(OutEdgeIt ei((mainwin.mapstorage).graph,active_node);ei!=INVALID;++ei)
 {
 Gnome::Canvas::Points coos;
 double x1, x2, y1, y2;
-nodesmap[mapstorage.graph.source(ei)]->get_bounds(x1, y1, x2, y2);
+nodesmap[(mainwin.mapstorage).graph.source(ei)]->get_bounds(x1, y1, x2, y2);
 coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
-nodesmap[mapstorage.graph.target(ei)]->get_bounds(x1, y1, x2, y2);
+nodesmap[(mainwin.mapstorage).graph.target(ei)]->get_bounds(x1, y1, x2, y2);
 coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
 	    if(isbutton==3)
 	      {
 		edgesmap[ei]->setPoints(coos);
 	    text_pos+=(xy<double>(10,10));
 	    edgetextmap[ei]->property_x().set_value(text_pos.x);
 	    edgetextmap[ei]->property_y().set_value(text_pos.y);
 }
-for(InEdgeIt ei(mapstorage.graph,active_node);ei!=INVALID;++ei)
+for(InEdgeIt ei((mainwin.mapstorage).graph,active_node);ei!=INVALID;++ei)
 {
 Gnome::Canvas::Points coos;
 double x1, x2, y1, y2;
-nodesmap[mapstorage.graph.source(ei)]->get_bounds(x1, y1, x2, y2);
+nodesmap[(mainwin.mapstorage).graph.source(ei)]->get_bounds(x1, y1, x2, y2);
 coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
-nodesmap[mapstorage.graph.target(ei)]->get_bounds(x1, y1, x2, y2);
+nodesmap[(mainwin.mapstorage).graph.target(ei)]->get_bounds(x1, y1, x2, y2);
 coos.push_back(Gnome::Art::Point((x1+x2)/2,(y1+y2)/2));
 	    if(isbutton==3)
 	      {
 		edgesmap[ei]->setPoints(coos);
 moveEventHandler(generated);
 break;
 }
 case GDK_BUTTON_RELEASE:
-mapstorage.modified = true;
+(mainwin.mapstorage).modified = true;
 isbutton=1;
-active_node=mapstorage.graph.addNode();
+active_node=(mainwin.mapstorage).graph.addNode();
 //initiating values corresponding to new node in maps
 window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
 // update coordinates
-mapstorage.coords.set(active_node, xy<double>(clicked_x, clicked_y));
+(mainwin.mapstorage).coords.set(active_node, xy<double>(clicked_x, clicked_y));
 // update all other maps
 for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-mapstorage.nodemap_storage.begin(); it !=
+(mainwin.mapstorage).nodemap_storage.begin(); it !=
-mapstorage.nodemap_storage.end(); ++it)
+(mainwin.mapstorage).nodemap_storage.end(); ++it)
 {
 if ((it->first != "coordinates_x") &&
 (it->first != "coordinates_y"))
 {
 (*(it->second))[active_node] =
-mapstorage.nodemap_default[it->first];
+(mainwin.mapstorage).nodemap_default[it->first];
 }
 }
 // increment the id map's default value
-mapstorage.nodemap_default["id"] += 1.0;
+(mainwin.mapstorage).nodemap_default["id"] += 1.0;
 nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph,
 clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
 active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
 *(nodesmap[active_node]) <<
 clicked_x+node_property_defaults[N_RADIUS]+5,
 clicked_y+node_property_defaults[N_RADIUS]+5, "");
 nodetextmap[active_node]->property_fill_color().set_value("darkblue");
 nodetextmap[active_node]->raise_to_top();
-mapwin.updateNode(active_node);
+//       mapwin.updateNode(active_node);
+propertyUpdate(active_node);
 isbutton=0;
 target_item=NULL;
 active_item=NULL;
 active_node=INVALID;
 window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
 active_item=(get_item_at(clicked_x, clicked_y));
 active_node=INVALID;
-for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 {
 if(nodesmap[i]==active_item)
 {
 active_node=i;
 }
 else
 {
 window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
 target_item=(get_item_at(clicked_x, clicked_y));
 Node target_node=INVALID;
-for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 {
 if(nodesmap[i]==target_item)
 {
 target_node=i;
 }
 //the clicked item is a node, the edge can be drawn
 if(target_node!=INVALID)
 {
 if(target_node!=active_node)
 {
-mapstorage.modified = true;
+(mainwin.mapstorage).modified = true;
 *(nodesmap[target_node]) <<
 Gnome::Canvas::Properties::fill_color("red");
 //creating new edge
-active_edge=mapstorage.graph.addEdge(active_node,
+active_edge=(mainwin.mapstorage).graph.addEdge(active_node,
 target_node);
 // update maps
 for (std::map<std::string,
 Graph::EdgeMap<double>*>::const_iterator it =
-mapstorage.edgemap_storage.begin(); it !=
+(mainwin.mapstorage).edgemap_storage.begin(); it !=
-mapstorage.edgemap_storage.end(); ++it)
+(mainwin.mapstorage).edgemap_storage.end(); ++it)
 {
 (*(it->second))[active_edge] =
-mapstorage.edgemap_default[it->first];
+(mainwin.mapstorage).edgemap_default[it->first];
 }
 // increment the id map's default value
-mapstorage.edgemap_default["id"] += 1.0;
+(mainwin.mapstorage).edgemap_default["id"] += 1.0;
 //calculating coordinates of new edge
 Gnome::Canvas::Points coos;
 double x1, x2, y1, y2;
 edgetextmap[active_edge]->property_fill_color().set_value(
 "darkgreen");
 edgetextmap[active_edge]->raise_to_top();
 //updating its properties
-mapwin.updateEdge(active_edge);
+//               mapwin.updateEdge(active_edge);
+propertyUpdate(active_edge);
 }
 else
 {
 target_node=INVALID;
 std::cerr << "Loop edge is not yet implemented!" << std::endl;
 window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
 active_item=(get_item_at(clicked_x, clicked_y));
 active_node=INVALID;
 active_edge=INVALID;
 //was it a node?
-for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 	{
 	  if(nodesmap[i]==active_item)
 	    {
 	      active_node=i;
 	    }
 	}
 //or was it an edge?
 if(active_node==INVALID)
 	{
-	  for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+	  for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 	    {
 	      if(edgesmap[i]==active_item)
 		{
 		  active_edge=i;
 		}
 	  if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
 	    {
 	      //a node was found
 	      if(active_node!=INVALID)
 		{
-mapstorage.modified = true;
+(mainwin.mapstorage).modified = true;
 		  std::set<Graph::Edge> edges_to_delete;
-		  for(OutEdgeIt e(mapstorage.graph,active_node);e!=INVALID;++e)
+		  for(OutEdgeIt e((mainwin.mapstorage).graph,active_node);e!=INVALID;++e)
 		    {
 		      edges_to_delete.insert(e);
 		    }
-		  for(InEdgeIt e(mapstorage.graph,active_node);e!=INVALID;++e)
+		  for(InEdgeIt e((mainwin.mapstorage).graph,active_node);e!=INVALID;++e)
 		    {
 		      edges_to_delete.insert(e);
 		    }
 		  //deleting collected edges
 window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
 active_item=(get_item_at(clicked_x, clicked_y));
 //find the activated item between texts
-for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 {
 //at the same time only one can be active
 if(edgetextmap[i]==active_item)
 {
 clicked_edge=i;
 }
 //if it was not between texts, search for it between edges
 if(clicked_edge==INVALID)
 {
-for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 {
 //at the same time only one can be active
 if((edgesmap[i]==active_item)||(edgetextmap[i]==active_item))
 {
 clicked_edge=i;
 {
 //activate the general variable for it
 active_edge=clicked_edge;
 //create a dialog
-Gtk::Dialog dialog("Edit value", *parentwin, true);
+Gtk::Dialog dialog("Edit value", mainwin, true);
 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
 Gtk::VBox* vbox = dialog.get_vbox();
 Gtk::SpinButton spin(0.0, 4);
 spin.set_increments(1.0, 10.0);
 case Gtk::RESPONSE_NONE:
 case Gtk::RESPONSE_CANCEL:
 break;
 case Gtk::RESPONSE_ACCEPT:
 double new_value = spin.get_value();
-(*mapstorage.edgemap_storage[edgemap_to_edit])[active_edge] =
+(*(mainwin.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
 new_value;
 std::ostringstream ostr;
 ostr << new_value;
 edgetextmap[active_edge]->property_text().set_value(
 ostr.str());
 //mapwin.updateEdge(active_edge);
-mapwin.updateEdge(Edge(INVALID));
+//                   mapwin.updateEdge(Edge(INVALID));
+propertyUpdate(Edge(INVALID));
 }
 }
 }
 break;
 }
 window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
 active_item=(get_item_at(clicked_x, clicked_y));
 //find the activated item between texts
-for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 {
 //at the same time only one can be active
 if(nodetextmap[i]==active_item)
 {
 clicked_node=i;
 }
 //if there was not, search for it between nodes
 if(clicked_node==INVALID)
 {
-for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 {
 //at the same time only one can be active
 if(nodesmap[i]==active_item)
 {
 clicked_node=i;
 {
 //activate the general variable for it
 active_node=clicked_node;
 //create a dialog
-Gtk::Dialog dialog("Edit value", *parentwin, true);
+Gtk::Dialog dialog("Edit value", mainwin, true);
 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
 Gtk::VBox* vbox = dialog.get_vbox();
 Gtk::SpinButton spin(0.0, 4);
 spin.set_increments(1.0, 10.0);
 case Gtk::RESPONSE_NONE:
 case Gtk::RESPONSE_CANCEL:
 break;
 case Gtk::RESPONSE_ACCEPT:
 double new_value = spin.get_value();
-(*mapstorage.nodemap_storage[nodemap_to_edit])[active_node] =
+(*(mainwin.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
 new_value;
 std::ostringstream ostr;
 ostr << new_value;
 nodetextmap[active_node]->property_text().set_value(
 ostr.str());
 //mapwin.updateNode(active_node);
-mapwin.updateNode(Node(INVALID));
+//                   mapwin.updateNode(Node(INVALID));
+propertyUpdate(Node(INVALID));
 }
 }
 }
 break;
 }
 void GraphDisplayerCanvas::deleteItem(Node node_to_delete)
 {
 delete(nodetextmap[node_to_delete]);
 delete(nodesmap[node_to_delete]);
-mapstorage.graph.erase(node_to_delete);
+(mainwin.mapstorage).graph.erase(node_to_delete);
 }
 void GraphDisplayerCanvas::deleteItem(Edge edge_to_delete)
 {
 delete(edgetextmap[edge_to_delete]);
 delete(edgesmap[edge_to_delete]);
-mapstorage.graph.erase(edge_to_delete);
+(mainwin.mapstorage).graph.erase(edge_to_delete);
 }
 void GraphDisplayerCanvas::textReposition(xy<double> new_place)
 {
 new_place+=(xy<double>(10,10));
 	{
 	  std::cerr << "ERROR!!!! Valid edge found!" << std::endl;
 	}
 else
 	{
-	  for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+	  for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
 	    {
 	      if(edgesmap[i]==active_bre)
 		{
 		  forming_edge=i;
 		}
 }
 int GraphDisplayerCanvas::addNewEdgeMap(double default_value, std::string mapname)
 {
 //create the new map
-Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> (mapstorage.graph, default_value);
+Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> ((mainwin.mapstorage).graph, default_value);
 //if addition was not successful addEdgeMap returns one.
 //cause can be that there is already a map named like the new one
-if(mapstorage.addEdgeMap(mapname,emptr, default_value))
+if((mainwin.mapstorage).addEdgeMap(mapname,emptr, default_value))
 {
 return 1;
 }
 //add it to the list of the displayable maps
-mapwin.registerNewEdgeMap(mapname);
+mainwin.registerNewEdgeMap(mapname);
 //display it
 changeEdgeText(mapname);
 return 0;
 }
 int GraphDisplayerCanvas::addNewNodeMap(double default_value, std::string mapname)
 {
 //create the new map
-Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> (mapstorage.graph,default_value);
+Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> ((mainwin.mapstorage).graph,default_value);
 //if addition was not successful addNodeMap returns one.
 //cause can be that there is already a map named like the new one
-if(mapstorage.addNodeMap(mapname,emptr, default_value))
+if((mainwin.mapstorage).addNodeMap(mapname,emptr, default_value))
 {
 return 1;
 }
 //add it to the list of the displayable maps
-mapwin.registerNewNodeMap(mapname);
+mainwin.registerNewNodeMap(mapname);
 //display it
 changeNodeText(mapname);
 return 0;

changeset 1843	1e386f4047c9
parent 1826	e07a7a8acd77
child 1849	a4d1362397fe