Changeset 94:adfdc2f70548 in glemon-0.x

Timestamp:

11/29/05 20:31:58 (19 years ago)

Author:

Hegyi Péter

Branch:

gui

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk/gui@2389

Message:

Structure of GUI is now more clear-cut than before.

Files:

• graph_displayer_canvas-edge.cc (modified) (8 diffs)
• graph_displayer_canvas-event.cc (modified) (38 diffs)
• graph_displayer_canvas-node.cc (modified) (7 diffs)
• graph_displayer_canvas.cc (modified) (9 diffs)
• graph_displayer_canvas.h (modified) (5 diffs)
• main_win.cc (modified) (8 diffs)
• main_win.h (modified) (3 diffs)
• map_win.cc (modified) (4 diffs)
• map_win.h (modified) (7 diffs)
• mapstorage.cc (modified) (2 diffs)
• mapstorage.h (modified) (4 diffs)
• mw-mapselector.cc (modified) (5 diffs)
• new_map_win.cc (modified) (9 diffs)
• new_map_win.h (modified) (3 diffs)

graph_displayer_canvas-edge.cc

@@ -9 +9 @@
   min=edge_property_defaults[E_WIDTH];
   max=edge_property_defaults[E_WIDTH];
-  Graph::EdgeMap<double> actual_map(mapstorage.graph,edge_property_defaults[E_WIDTH]);
+  Graph::EdgeMap<double> actual_map((mainwin.mapstorage).graph,edge_property_defaults[E_WIDTH]);
   
   if(edge==INVALID)
     {
-      for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+      for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           double v=fabs(actual_map[i]);
@@ -45 +45 @@
   double min, max;
 
-  min=mapstorage.minOfEdgeMap(mapname);
-  max=mapstorage.maxOfEdgeMap(mapname);
-  actual_map=(mapstorage.edgemap_storage)[mapname];
-
-  if(edge==INVALID)
-    {
-      for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+  min=(mainwin.mapstorage).minOfEdgeMap(mapname);
+  max=(mainwin.mapstorage).maxOfEdgeMap(mapname);
+  actual_map=((mainwin.mapstorage).edgemap_storage)[mapname];
+
+  if(edge==INVALID)
+    {
+      for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           double v=fabs((*actual_map)[i]);
@@ -84 +84 @@
   //green in RGB
   Graph::EdgeMap<double> * actual_map;
-  actual_map=(mapstorage.edgemap_storage)[mapname];
+  actual_map=((mainwin.mapstorage).edgemap_storage)[mapname];
 
   double max, min;
 
-  max=mapstorage.maxOfEdgeMap(mapname);
-  min=mapstorage.minOfEdgeMap(mapname);
-
-  if(edge==INVALID)
-    {
-      for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+  max=(mainwin.mapstorage).maxOfEdgeMap(mapname);
+  min=(mainwin.mapstorage).minOfEdgeMap(mapname);
+
+  if(edge==INVALID)
+    {
+      for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           double w=(*actual_map)[i];
@@ -135 +135 @@
   //the minimum of the nodemap to the range of
   //green in RGB
-  Graph::EdgeMap<double> actual_map(mapstorage.graph,edge_property_defaults[E_COLOR]);
+  Graph::EdgeMap<double> actual_map((mainwin.mapstorage).graph,edge_property_defaults[E_COLOR]);
 
   double max, min;
@@ -144 +144 @@
   if(edge==INVALID)
     {
-      for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+      for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           double w=actual_map[i];
@@ -189 +189 @@
   if(edge==INVALID)
     {
-      for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+      for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           edgemap_to_edit=mapname;
-          double number=(*(mapstorage.edgemap_storage)[mapname])[i];
+          double number=(*((mainwin.mapstorage).edgemap_storage)[mapname])[i];
           
           std::ostringstream ostr;
@@ -203 +203 @@
   else
     {
-          double number=(*(mapstorage.edgemap_storage)[mapname])[edge];
+          double number=(*((mainwin.mapstorage).edgemap_storage)[mapname])[edge];
 
           std::ostringstream ostr;
@@ -224 +224 @@
   if(edge==INVALID)
     {
-      for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+      for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           edgemap_to_edit="";

graph_displayer_canvas-event.cc

@@ -95 +95 @@
       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)
@@ -126 +126 @@
       if(active_node!=INVALID)
       {
-        mapstorage.modified = true;
+        (mainwin.mapstorage).modified = true;
 
         //new coordinates will be the old values,
@@ -145 +145 @@
 
         // the new coordinates of the centre of the node 
-        double coord_x = new_x - (clicked_x - mapstorage.coords[active_node].x);
-        double coord_y = new_y - (clicked_y - mapstorage.coords[active_node].y);
+        double coord_x = new_x - (clicked_x - (mainwin.mapstorage).coords[active_node].x);
+        double coord_y = new_y - (clicked_y - (mainwin.mapstorage).coords[active_node].y);
 
         clicked_x=new_x;
@@ -152 +152 @@
 
         // 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 << ", " <<
-          mapstorage.coords[active_node].y << ")";
+          (mainwin.mapstorage).coords[active_node].x << ", " <<
+          (mainwin.mapstorage).coords[active_node].y << ")";
         double radius =
           (nodesmap[active_node]->property_x2().get_value() -
@@ -165 +165 @@
         {
           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);
         }
@@ -174 +174 @@
           coord_text = new Gnome::Canvas::Text(
               displayed_graph,
-              mapstorage.coords[active_node].x + radius,
-              mapstorage.coords[active_node].y - radius,
+              (mainwin.mapstorage).coords[active_node].x + radius,
+              (mainwin.mapstorage).coords[active_node].y - radius,
               ostr.str());
           coord_text->property_fill_color().set_value("black");
@@ -182 +182 @@
 
         //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));
 
@@ -209 +209 @@
         }
 
-        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));
 
@@ -257 +257 @@
 
     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
@@ -268 +268 @@
 
       // 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 !=
-          mapstorage.nodemap_storage.end(); ++it)
+          (mainwin.mapstorage).nodemap_storage.begin(); it !=
+          (mainwin.mapstorage).nodemap_storage.end(); ++it)
       {
         if ((it->first != "coordinates_x") &&
@@ -279 +279 @@
         {
           (*(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,
@@ -302 +302 @@
       nodetextmap[active_node]->raise_to_top();
 
-      mapwin.updateNode(active_node);
+//       mapwin.updateNode(active_node);
+      propertyUpdate(active_node);
 
       isbutton=0;
@@ -332 +333 @@
           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)
@@ -361 +362 @@
           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)
@@ -373 +374 @@
             if(target_node!=active_node)                
             {
-              mapstorage.modified = true;
+              (mainwin.mapstorage).modified = true;
 
               *(nodesmap[target_node]) <<
@@ -379 +380 @@
 
               //creating new edge
-              active_edge=mapstorage.graph.addEdge(active_node,
+              active_edge=(mainwin.mapstorage).graph.addEdge(active_node,
                   target_node);
 
@@ -385 +386 @@
               for (std::map<std::string,
                   Graph::EdgeMap<double>*>::const_iterator it =
-                  mapstorage.edgemap_storage.begin(); it !=
-                  mapstorage.edgemap_storage.end(); ++it)
+                  (mainwin.mapstorage).edgemap_storage.begin(); 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
@@ -424 +425 @@
 
               //updating its properties
-              mapwin.updateEdge(active_edge);
+//               mapwin.updateEdge(active_edge);
+              propertyUpdate(active_edge);
             }
             else
@@ -479 +481 @@
       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)
@@ -489 +491 @@
       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)
@@ -515 +517 @@
               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);
@@ -588 +590 @@
 
           //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
@@ -600 +602 @@
           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
@@ -623 +625 @@
 
               //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);
@@ -640 +642 @@
                 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;
@@ -647 +649 @@
                       ostr.str());
                   //mapwin.updateEdge(active_edge);
-                  mapwin.updateEdge(Edge(INVALID));
+//                   mapwin.updateEdge(Edge(INVALID));
+                  propertyUpdate(Edge(INVALID));
               }
             }
@@ -675 +678 @@
 
           //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
@@ -687 +690 @@
           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
@@ -710 +713 @@
 
               //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);
@@ -727 +730 @@
                 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;
@@ -734 +737 @@
                       ostr.str());
                   //mapwin.updateNode(active_node);
-                  mapwin.updateNode(Node(INVALID));
+//                   mapwin.updateNode(Node(INVALID));
+                  propertyUpdate(Node(INVALID));
               }
             }
@@ -751 +755 @@
   delete(nodetextmap[node_to_delete]);
   delete(nodesmap[node_to_delete]);
-  mapstorage.graph.erase(node_to_delete);
+  (mainwin.mapstorage).graph.erase(node_to_delete);
 }
 
@@ -758 +762 @@
   delete(edgetextmap[edge_to_delete]);
   delete(edgesmap[edge_to_delete]);
-  mapstorage.graph.erase(edge_to_delete);
+  (mainwin.mapstorage).graph.erase(edge_to_delete);
 }
 
@@ -778 +782 @@
       else
         {
-          for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+          for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
             {
               if(edgesmap[i]==active_bre)
@@ -804 +808 @@
 {
   //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;
@@ -815 +819 @@
 
   //add it to the list of the displayable maps
-  mapwin.registerNewEdgeMap(mapname);
+  mainwin.registerNewEdgeMap(mapname);
 
   //display it
@@ -826 +830 @@
 {
   //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;
@@ -836 +840 @@
 
   //add it to the list of the displayable maps
-  mapwin.registerNewNodeMap(mapname);
+  mainwin.registerNewNodeMap(mapname);
 
   //display it

graph_displayer_canvas-node.cc

@@ -7 +7 @@
   Graph::NodeMap<double> * actual_map;
   double min, max;
-  min=mapstorage.minOfNodeMap(mapname);
-  max=mapstorage.maxOfNodeMap(mapname);
-  actual_map=(mapstorage.nodemap_storage)[mapname];
-
-  if(node==INVALID)
-    {
-      for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+  min=(mainwin.mapstorage).minOfNodeMap(mapname);
+  max=(mainwin.mapstorage).maxOfNodeMap(mapname);
+  actual_map=((mainwin.mapstorage).nodemap_storage)[mapname];
+
+  if(node==INVALID)
+    {
+      for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           double v=fabs((*actual_map)[i]);
@@ -65 +65 @@
   min=node_property_defaults[N_RADIUS];
   max=node_property_defaults[N_RADIUS];
-  Graph::NodeMap<double> actual_map(mapstorage.graph,node_property_defaults[N_RADIUS]);
+  Graph::NodeMap<double> actual_map((mainwin.mapstorage).graph,node_property_defaults[N_RADIUS]);
   
   if(node==INVALID)
     {
-      for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+      for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           double v=fabs(actual_map[i]);
@@ -124 +124 @@
 
   Graph::NodeMap<double> * actual_map;
-  actual_map=(mapstorage.nodemap_storage)[mapname];
+  actual_map=((mainwin.mapstorage).nodemap_storage)[mapname];
 
   double max, min;
 
-  max=mapstorage.maxOfNodeMap(mapname);
-  min=mapstorage.minOfNodeMap(mapname);
-
-  if(node==INVALID)
-    {
-
-      for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+  max=(mainwin.mapstorage).maxOfNodeMap(mapname);
+  min=(mainwin.mapstorage).minOfNodeMap(mapname);
+
+  if(node==INVALID)
+    {
+
+      for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           Gdk::Color color;
@@ -179 +179 @@
   //green in RGB
 
-  Graph::NodeMap<double> actual_map(mapstorage.graph,node_property_defaults[N_COLOR]);
+  Graph::NodeMap<double> actual_map((mainwin.mapstorage).graph,node_property_defaults[N_COLOR]);
 
   double max, min;
@@ -189 +189 @@
     {
 
-      for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+      for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           Gdk::Color color;
@@ -236 +236 @@
 
   Graph::NodeMap<double> * actual_map=NULL;
-  actual_map=(mapstorage.nodemap_storage)[mapname];
-
-  if(node==INVALID)
-    {
-      for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+  actual_map=((mainwin.mapstorage).nodemap_storage)[mapname];
+
+  if(node==INVALID)
+    {
+      for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           nodemap_to_edit=mapname;
@@ -273 +273 @@
   if(node==INVALID)
     {
-      for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+      for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
         {
           nodemap_to_edit="";

graph_displayer_canvas.cc

@@ -2 +2 @@
 #include <cmath>
 
-GraphDisplayerCanvas::GraphDisplayerCanvas(MapStorage & ms, MapWin & mw, Gtk::Window * mainwin) :
-  nodesmap(ms.graph), edgesmap(ms.graph), edgetextmap(ms.graph),
-  nodetextmap(ms.graph), displayed_graph(*(root()), 0, 0), mapstorage(ms),
+GraphDisplayerCanvas::GraphDisplayerCanvas(MainWin & mainw) :
+  nodesmap(mainw.mapstorage.graph), edgesmap(mainw.mapstorage.graph), edgetextmap(mainw.mapstorage.graph),
+  nodetextmap(mainw.mapstorage.graph), displayed_graph(*(root()), 0, 0),
   isbutton(0), active_item(NULL), target_item(NULL), nodemap_to_edit(""),
-  edgemap_to_edit(""), mapwin(mw)
-{
-  parentwin=mainwin;
-
+  edgemap_to_edit(""), mainwin(mainw)
+{
   //base event handler is move tool
   actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
@@ -21 +19 @@
 GraphDisplayerCanvas::~GraphDisplayerCanvas()
 {
-  for (NodeIt n(mapstorage.graph); n != INVALID; ++n)
-  {
-    delete nodesmap[n];
-    delete nodetextmap[n];
-  }
-
-  for (EdgeIt e(mapstorage.graph); e != INVALID; ++e)
-  {
-    delete edgesmap[e];
-    delete edgetextmap[e];
-  }
+  for (NodeIt n((mainwin.mapstorage).graph); n != INVALID; ++n)
+    {
+      delete nodesmap[n];
+      delete nodetextmap[n];
+    }
+  
+  for (EdgeIt e((mainwin.mapstorage).graph); e != INVALID; ++e)
+    {
+      delete edgesmap[e];
+      delete edgetextmap[e];
+    }
+}
+
+void GraphDisplayerCanvas::propertyChange(bool itisedge, int prop)
+{
+  if(itisedge)
+    {
+      propertyUpdate(Edge(INVALID), prop);
+    }
+  else
+    {
+      propertyUpdate(Node(INVALID), prop);
+    }
+}
+
+void GraphDisplayerCanvas::propertyUpdate(Edge edge)
+{
+  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
+    {
+      propertyUpdate(edge, i);
+    }
+}
+
+void GraphDisplayerCanvas::propertyUpdate(Node node)
+{
+  for(int i=0;i<NODE_PROPERTY_NUM;i++)
+    {
+      propertyUpdate(node, i);
+    }
+}
+
+void GraphDisplayerCanvas::propertyUpdate(Node node, int prop, int dummy)
+{
+  dummy=dummy;
+
+  std::string mapname=mainwin.getActiveNodeMap(prop);
+
+  if(mapname!="")
+    {
+      if( ( ((mainwin.mapstorage).nodemap_storage).find(mapname) != ((mainwin.mapstorage).nodemap_storage).end() ) )
+        {
+          switch(prop)
+            {
+            case N_RADIUS:
+              changeNodeRadius(mapname, node);
+              break;
+            case N_COLOR:
+              changeNodeColor(mapname, node);
+              break;
+            case N_TEXT:
+              changeNodeText(mapname, node);
+              break;
+            default:
+              std::cerr<<"Error\n";
+            }
+        }
+    }
+  else //mapname==""
+    {
+      Node node=INVALID;        
+      switch(prop)
+        {
+        case N_RADIUS:
+          resetNodeRadius(node);
+          break;
+        case N_COLOR:
+          resetNodeColor(node);
+          break;
+        case N_TEXT:
+          resetNodeText(node);
+          break;
+        default:
+          std::cerr<<"Error\n";
+        }
+    }
+
+}
+
+void GraphDisplayerCanvas::propertyUpdate(Edge edge, int prop, int dummy)
+{
+  dummy=dummy;
+
+  std::string mapname=mainwin.getActiveEdgeMap(prop);
+
+  if(mapname!="")
+    {
+      if( ( ((mainwin.mapstorage).edgemap_storage).find(mapname) != ((mainwin.mapstorage).edgemap_storage).end() ) )
+        {
+          switch(prop)
+            {
+            case E_WIDTH:
+              changeEdgeWidth(mapname, edge);
+              break;
+            case E_COLOR:
+              changeEdgeColor(mapname, edge);
+              break;
+            case E_TEXT:
+              changeEdgeText(mapname, edge);
+              break;
+            default:
+              std::cerr<<"Error\n";
+            }
+        }
+    }
+  else //mapname==""
+    {
+      switch(prop)
+        {
+        case E_WIDTH:
+          resetEdgeWidth(edge);
+          break;
+        case E_COLOR:
+          resetEdgeColor(edge);
+          break;
+        case E_TEXT:
+          resetEdgeText(edge);
+          break;
+        default:
+          std::cerr<<"Error\n";
+        }
+    }
 }
 
@@ -38 +156 @@
   //first edges are drawn, to hide joining with nodes later
 
-  for (EdgeIt i(mapstorage.graph); i!=INVALID; ++i)
+  for (EdgeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
   {
 
@@ -45 +163 @@
     Gnome::Canvas::Points coos;
     coos.push_back(Gnome::Art::Point(
-          mapstorage.coords[mapstorage.graph.source(i)].x,
-          mapstorage.coords[mapstorage.graph.source(i)].y));
+          (mainwin.mapstorage).coords[(mainwin.mapstorage).graph.source(i)].x,
+          (mainwin.mapstorage).coords[(mainwin.mapstorage).graph.source(i)].y));
     coos.push_back(Gnome::Art::Point(
-          mapstorage.coords[mapstorage.graph.target(i)].x,
-          mapstorage.coords[mapstorage.graph.target(i)].y));
+          (mainwin.mapstorage).coords[(mainwin.mapstorage).graph.target(i)].x,
+          (mainwin.mapstorage).coords[(mainwin.mapstorage).graph.target(i)].y));
     
     edgesmap[i]=new BrokenEdge(displayed_graph, coos, *this);
@@ -69 +187 @@
   //afterwards nodes come to be drawn
 
-  for (NodeIt i(mapstorage.graph); i!=INVALID; ++i)
+  for (NodeIt i((mainwin.mapstorage).graph); i!=INVALID; ++i)
   {
     //drawing bule nodes, with black line around them
@@ -75 +193 @@
     nodesmap[i]=new Gnome::Canvas::Ellipse(
         displayed_graph,
-        mapstorage.coords[i].x-20,
-        mapstorage.coords[i].y-20,
-        mapstorage.coords[i].x+20,
-        mapstorage.coords[i].y+20);
+        (mainwin.mapstorage).coords[i].x-20,
+        (mainwin.mapstorage).coords[i].y-20,
+        (mainwin.mapstorage).coords[i].x+20,
+        (mainwin.mapstorage).coords[i].y+20);
     *(nodesmap[i]) << Gnome::Canvas::Properties::fill_color("blue");
     *(nodesmap[i]) << Gnome::Canvas::Properties::outline_color("black");
@@ -86 +204 @@
 
     xy<double> text_pos(
-        (mapstorage.coords[i].x+node_property_defaults[N_RADIUS]+5),
-        (mapstorage.coords[i].y+node_property_defaults[N_RADIUS]+5));
+        ((mainwin.mapstorage).coords[i].x+node_property_defaults[N_RADIUS]+5),
+        ((mainwin.mapstorage).coords[i].y+node_property_defaults[N_RADIUS]+5));
 
     nodetextmap[i]=new Gnome::Canvas::Text(displayed_graph,
@@ -105 +223 @@
   forming_edge=INVALID;
 
-  for (NodeIt n(mapstorage.graph); n != INVALID; ++n)
+  for (NodeIt n((mainwin.mapstorage).graph); n != INVALID; ++n)
   {
     delete nodesmap[n];
@@ -111 +229 @@
   }
 
-  for (EdgeIt e(mapstorage.graph); e != INVALID; ++e)
+  for (EdgeIt e((mainwin.mapstorage).graph); e != INVALID; ++e)
   {
     delete edgesmap[e];

graph_displayer_canvas.h

@@ -7 +7 @@
 
 #include "all_include.h"
-#include "mapstorage.h"
-#include "map_win.h"
+#include "main_win.h"
 #include <libgnomecanvasmm.h>
 #include <libgnomecanvasmm/polygon.h>
@@ -41 +40 @@
 
 public:
-  GraphDisplayerCanvas(MapStorage &, MapWin &, Gtk::Window *);
+  GraphDisplayerCanvas(MainWin &);
   virtual ~GraphDisplayerCanvas();
 
@@ -73 +72 @@
   int changeNodeText (std::string mapname, Node new_item=INVALID);
   int resetNodeText (Node new_item=INVALID);
+
+  void propertyChange(bool, int);
+  void propertyUpdate(Edge, int, int dummy=0);
+  void propertyUpdate(Node, int, int dummy=0);
+
+  void propertyUpdate(Edge);
+  void propertyUpdate(Node);
 
   ///Callback for 'ViewZoomIn' action.
@@ -166 +172 @@
   Gnome::Canvas::Group displayed_graph;
 
-public:
-  ///Here we store the maps that can be displayed through properties.
-  MapStorage & mapstorage;
-
 private:
   ///Indicates whether the button of mouse is pressed or not
@@ -194 +196 @@
   static const int zoom_step = 5;
 
-public:
-  ///We need to store mapwin, to be able to ask the appropriate values for properties of new items.
-  MapWin & mapwin;
-
-private:
-
-  ///pointer to the parent window
-  Gtk::Window * parentwin;
+private:
+
+  ///reference to the parent window
+  MainWin & mainwin;
 
 };

main_win.cc

@@ -2 +2 @@
 #include "icons/guipixbufs.h"
 
-MainWin::MainWin() :
-  mapwin("Map Setup", mapstorage, gd_canvas),
-  gd_canvas(mapstorage, mapwin, (Gtk::Window *)this)
-{
+MainWin::MainWin()
+{
+  mapwin=new MapWin("Map Setup", mapstorage.getEdgeMapList(), mapstorage.getNodeMapList(), *this);
+  gd_canvas=new GraphDisplayerCanvas(*this);
+
   set_title ("unsaved file - " + prog_name);
   set_default_size(WIN_WIDTH,WIN_HEIGHT);
   add(vbox);
 
+  //connecting signals - controller character
+  mapstorage.signal_prop_ch().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::propertyChange));
 
   // custom icons for the toolbar
@@ -93 +96 @@
   ag->add( Gtk::Action::create("ViewMenu", "_View") );
   ag->add( Gtk::Action::create("ViewZoomIn", Gtk::Stock::ZOOM_IN),
-      sigc::mem_fun(this->gd_canvas, &GraphDisplayerCanvas::zoomIn));
+      sigc::mem_fun(*(this->gd_canvas), &GraphDisplayerCanvas::zoomIn));
   ag->add( Gtk::Action::create("ViewZoomOut", Gtk::Stock::ZOOM_OUT),
-      sigc::mem_fun(this->gd_canvas, &GraphDisplayerCanvas::zoomOut));
+      sigc::mem_fun(*(this->gd_canvas), &GraphDisplayerCanvas::zoomOut));
   ag->add( Gtk::Action::create("ViewZoomFit", Gtk::Stock::ZOOM_FIT),
-      sigc::mem_fun(this->gd_canvas, &GraphDisplayerCanvas::zoomFit));
+      sigc::mem_fun(*(this->gd_canvas), &GraphDisplayerCanvas::zoomFit));
   ag->add( Gtk::Action::create("ViewZoom100", Gtk::Stock::ZOOM_100),
-      sigc::mem_fun(this->gd_canvas, &GraphDisplayerCanvas::zoom100));
+      sigc::mem_fun(*(this->gd_canvas), &GraphDisplayerCanvas::zoom100));
   
   ag->add( Gtk::Action::create("ShowMenu", "_Show") );
   ag->add( Gtk::Action::create("ShowMaps", "_Maps"),
-      sigc::mem_fun(this->mapwin, &MapWin::show));
+      sigc::mem_fun(*(this->mapwin), &MapWin::show));
 
   Gtk::RadioAction::Group tool_group;
   ag->add( Gtk::RadioAction::create(tool_group, "MoveItem", Gtk::StockID("gd-move"), "Move"),
-      sigc::bind( sigc::mem_fun ( this->gd_canvas, &GraphDisplayerCanvas::changeEditorialTool ), 0) );
+      sigc::bind( sigc::mem_fun ( *(this->gd_canvas), &GraphDisplayerCanvas::changeEditorialTool ), 0) );
   ag->add( Gtk::RadioAction::create(tool_group, "CreateNode", Gtk::StockID("gd-addnode"), "Create node"),
-      sigc::bind( sigc::mem_fun ( this->gd_canvas, &GraphDisplayerCanvas::changeEditorialTool ), 1) );
+      sigc::bind( sigc::mem_fun ( *(this->gd_canvas), &GraphDisplayerCanvas::changeEditorialTool ), 1) );
   ag->add( Gtk::RadioAction::create(tool_group, "CreateEdge", Gtk::StockID("gd-addlink"), "Create edge"),
-      sigc::bind( sigc::mem_fun ( this->gd_canvas, &GraphDisplayerCanvas::changeEditorialTool ), 2) );
+      sigc::bind( sigc::mem_fun ( *(this->gd_canvas), &GraphDisplayerCanvas::changeEditorialTool ), 2) );
   ag->add( Gtk::RadioAction::create(tool_group, "EraseItem", Gtk::StockID("gd-delete"), "Delete"),
-      sigc::bind( sigc::mem_fun ( this->gd_canvas, &GraphDisplayerCanvas::changeEditorialTool ), 3) );
+      sigc::bind( sigc::mem_fun ( *(this->gd_canvas), &GraphDisplayerCanvas::changeEditorialTool ), 3) );
 
   ag->add( Gtk::RadioAction::create(tool_group, "EditEdgeMap", Gtk::StockID("gd-editlink"), "Edit edge map"),
-      sigc::bind( sigc::mem_fun ( this->gd_canvas, &GraphDisplayerCanvas::changeEditorialTool ), 4) );
+      sigc::bind( sigc::mem_fun ( *(this->gd_canvas), &GraphDisplayerCanvas::changeEditorialTool ), 4) );
   ag->add( Gtk::RadioAction::create(tool_group, "EditNodeMap", Gtk::StockID("gd-editnode"), "Edit node map"),
-      sigc::bind( sigc::mem_fun ( this->gd_canvas, &GraphDisplayerCanvas::changeEditorialTool ), 5) );
+      sigc::bind( sigc::mem_fun ( *(this->gd_canvas), &GraphDisplayerCanvas::changeEditorialTool ), 5) );
 
   ag->add( Gtk::Action::create("AddMap", Gtk::StockID("gd-newmap")),
-      sigc::mem_fun (new NewMapWin("NewMapWin", gd_canvas), &NewMapWin::show ) );
+      sigc::mem_fun (new NewMapWin("NewMapWin", *this), &NewMapWin::show ) );
 
   uim=Gtk::UIManager::create();
@@ -195 +198 @@
   Gtk::ScrolledWindow* pScrolledWindow = manage(new Gtk::ScrolledWindow());
   pScrolledWindow->set_shadow_type(Gtk::SHADOW_IN);
-  pScrolledWindow->add(gd_canvas);
+  pScrolledWindow->add(*gd_canvas);
   vbox.pack_start(*pScrolledWindow);
 
@@ -209 +212 @@
   mapstorage.file_name = file;
   mapstorage.modified = false;
-  gd_canvas.drawGraph();
-  mapwin.update();
+  gd_canvas->drawGraph();
+  mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
   set_title(Glib::filename_display_basename(file) + " - " + prog_name);
 }
@@ -234 +237 @@
     }
   }
-  gd_canvas.clear();
+  gd_canvas->clear();
   mapstorage.clear();
-  mapwin.update();
+  mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
   set_title("unsaved file - " + prog_name);
 }
@@ -265 +268 @@
   if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)
   {
-    gd_canvas.clear();
+    gd_canvas->clear();
     mapstorage.clear();
     Glib::ustring filename = fcdialog.get_filename();
@@ -272 +275 @@
       mapstorage.file_name = filename;
       mapstorage.modified = false;
-      gd_canvas.drawGraph();
-      mapwin.update();
+      gd_canvas->drawGraph();
+      mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
       set_title(Glib::filename_display_basename(filename) + " - " + prog_name);
     }
@@ -328 +331 @@
     }
   }
-  gd_canvas.clear();
+  gd_canvas->clear();
   mapstorage.clear();
-  mapwin.update();
+  mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
   set_title("unsaved file - " + prog_name);
 }
+
+void MainWin::propertyChange(bool itisedge, int prop, std::string mapname)
+{
+  mapstorage.changeActiveMap(itisedge, prop, mapname);
+}
+
+void MainWin::popupNewMapWin(bool itisedge, int prop)
+{
+  prop=prop;
+  (new NewMapWin("NewMapWin", *this, itisedge, false))->run();
+}
+
+std::string MainWin::getActiveEdgeMap(int prop)
+{
+  return mapstorage.getActiveEdgeMap(prop);
+}
+
+std::string MainWin::getActiveNodeMap(int prop)
+{
+  return mapstorage.getActiveNodeMap(prop);
+}
+
+void MainWin::registerNewEdgeMap(std::string mapname)
+{
+  mapwin->registerNewEdgeMap(mapname);
+}
+
+void MainWin::registerNewNodeMap(std::string mapname)
+{
+  mapwin->registerNewNodeMap(mapname);
+}

main_win.h

@@ -3 +3 @@
 #ifndef MAIN_WIN_H
 #define MAIN_WIN_H
+
+class MainWin;
 
 #include "all_include.h"
@@ -27 +29 @@
 protected:
   ///Window of map-showing setup. Its type is \ref MapWin
-  MapWin mapwin;
+  MapWin * mapwin;
 
   ///The graph will be drawn on this \ref GraphDisplayerCanvas
-  GraphDisplayerCanvas gd_canvas;
+  GraphDisplayerCanvas * gd_canvas;
 
   ///ActionGroup for menu
@@ -54 +56 @@
   ///Callback for 'Close' action.
   virtual void close();
+
+public:
+  void propertyChange(bool, int, std::string);
+  void popupNewMapWin(bool, int);
+
+  std::string getActiveEdgeMap(int);
+  std::string getActiveNodeMap(int);
+
+  void registerNewEdgeMap(std::string);
+  void registerNewNodeMap(std::string);
+
 };
 

map_win.cc

@@ -11 +11 @@
 }
 
-MapWin::MapWin(const std::string& title, MapStorage & mapst, GraphDisplayerCanvas & grdispc):gdc(grdispc),ms(mapst)
+MapWin::MapWin(const std::string& title, std::vector<std::string> eml, std::vector<std::string> nml, MainWin & mw):mainwin(mw)
 {
   set_title(title);
@@ -24 +24 @@
   for(int i=0;i<EDGE_PROPERTY_NUM;i++)
   {
-    e_combo_array[i]=new MapSelector(gdc, ms, i, true);
+    e_combo_array[i]=new MapSelector(eml, i, true);
 
     (*table).attach((*(e_combo_array[i])),0,1,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);
+
+    e_combo_array[i]->signal_cbt_ch().connect(sigc::bind(sigc::mem_fun(*this, &MapWin::edgeMapChanged), i));
+    e_combo_array[i]->signal_newmapwin_needed().connect(sigc::bind(sigc::mem_fun(*this, &MapWin::newMapWinNeeded), i));
   }
 
@@ -41 +44 @@
   for(int i=0;i<NODE_PROPERTY_NUM;i++)
   {
-    n_combo_array[i]=new MapSelector(gdc, ms, i, false);
+    n_combo_array[i]=new MapSelector(nml, i, false);
 
     (*table).attach((*(n_combo_array[i])),0,1,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);
+
+    n_combo_array[i]->signal_cbt_ch().connect(sigc::bind(sigc::mem_fun(*this, &MapWin::nodeMapChanged), i));
+    n_combo_array[i]->signal_newmapwin_needed().connect(sigc::bind(sigc::mem_fun(*this, &MapWin::newMapWinNeeded), i));
   }
 
@@ -56 +62 @@
 }
 
-void MapWin::update()
+void MapWin::nodeMapChanged(std::string mapname, int prop)
+{
+  mainwin.propertyChange(false, prop, mapname);
+}
+
+void MapWin::edgeMapChanged(std::string mapname, int prop)
+{
+  mainwin.propertyChange(true, prop, mapname);
+}
+
+void MapWin::newMapWinNeeded(bool itisedge, int prop)
+{
+  mainwin.popupNewMapWin(itisedge, prop);
+}
+
+void MapWin::update(std::vector<std::string> eml, std::vector<std::string> nml)
 {
   for(int i=0;i<EDGE_PROPERTY_NUM;i++)
   {
-    e_combo_array[i]->update_list();
+    e_combo_array[i]->update_list(eml);
   }
 
   for(int i=0;i<NODE_PROPERTY_NUM;i++)
   {
-    n_combo_array[i]->update_list();
+    n_combo_array[i]->update_list(nml);
   }
-}
-
-
-void MapWin::updateNode(Node node)
-{
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      n_combo_array[i]->update(node);
-    }
-}
-
-void MapWin::updateEdge(Edge edge)
-{
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      e_combo_array[i]->update(edge);
-    }
 }
 

map_win.h

@@ -6 +6 @@
 class MapWin;
 
-#include "all_include.h"
-#include "graph_displayer_canvas.h"
-#include "mapstorage.h"
-#include "new_map_win.h"
+#include <all_include.h>
+#include <main_win.h>
 #include <libgnomecanvasmm.h>
 #include <libgnomecanvasmm/polygon.h>
@@ -22 +20 @@
   {
   protected:
-    GraphDisplayerCanvas & gdc;
-    ///The \ref MapStorage in which the visualizable maps are stored
-    MapStorage & ms;
+    sigc::signal<void, std::string> signal_cbt;
+    sigc::signal<void, bool> signal_newmapwin;
 
     int id;
@@ -42 +39 @@
     Gtk::Label * label;
 
-    Node node_to_update;
-    Edge edge_to_update;
-
-
   public:
 
-    MapSelector(GraphDisplayerCanvas &, MapStorage &, int, bool);
+    MapSelector(std::vector<std::string>, int, bool);
 
-    void update_list();
+    sigc::signal<void, std::string> signal_cbt_ch();
+    sigc::signal<void, bool> signal_newmapwin_needed();
+
+    void update_list( std::vector<std::string> );
 
     ///If a radiobutton is clicked, this function determines
@@ -62 +58 @@
     virtual void reset();
 
-    virtual void update(Node node);
-    virtual void update(Edge edge);
-
     Glib::ustring get_active_text();
     void set_active_text(Glib::ustring);
@@ -73 +66 @@
 
 protected:
-  ///The \ref GraphDisplayerCanvas on which the graph will be drawn.
-  ///It has to be known for this class, because
-  ///when a map assigned to a certain attribute
-  ///a function of the \ref GraphDisplayerCanvas will be called.
-  GraphDisplayerCanvas & gdc;
-
-  ///The \ref MapStorage in which the visualizable maps are stored
-  MapStorage & ms;
+  MainWin & mainwin;
 
   Gtk::Table * table;
@@ -92 +78 @@
 public:
   ///Constructor of MapWin creates the widgets shown in MapWin.
-  MapWin(const std::string& title, MapStorage &, GraphDisplayerCanvas &);
+  MapWin(const std::string& title, std::vector<std::string>, std::vector<std::string>, MainWin & mw);
 
-  ///This function is created to set the appropriate maps on the newly created node
-  void updateNode(Graph::Node);
+  void nodeMapChanged(std::string, int);
 
-  ///This function is created to set the appropriate maps on the newly created edge
-  void updateEdge(Graph::Edge);
+  void edgeMapChanged(std::string, int);
+
+  void newMapWinNeeded(bool, int);
 
   ///This function inserts name of the new edgemap in the list in the combo box
@@ -108 +94 @@
   virtual bool closeIfEscapeIsPressed(GdkEventKey*);
 
-  void update();
+  void update(std::vector<std::string>, std::vector<std::string>);
 };
 

mapstorage.cc

@@ -17 +17 @@
   nodemap_default["id"] = 1.0;
   edgemap_default["id"] = 1.0;
+
+  active_nodemaps.resize(NODE_PROPERTY_NUM);
+  for(int i=0;i<NODE_PROPERTY_NUM;i++)
+    {
+      active_nodemaps[i]="";
+    }
+
+  active_edgemaps.resize(EDGE_PROPERTY_NUM);
+  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
+    {
+      active_edgemaps[i]="";
+    }
 }
 
@@ -43 +55 @@
     }
   return 1;
+}
+
+void MapStorage::changeActiveMap(bool itisedge, int prop, std::string mapname)
+{
+  if(itisedge)
+    {
+      active_edgemaps[prop]=mapname;
+    }
+  else
+    {
+      active_nodemaps[prop]=mapname;
+    }
+  signal_prop.emit(itisedge, prop);
+}
+
+std::string MapStorage::getActiveEdgeMap(int prop)
+{
+  return active_edgemaps[prop];
+}
+
+std::string MapStorage::getActiveNodeMap(int prop)
+{
+  return active_nodemaps[prop];
+}
+
+std::vector<std::string> MapStorage::getEdgeMapList()
+{
+  std::vector<std::string> eml;
+  eml.resize(edgemap_storage.size());
+  int i=0;
+  std::map< std::string,Graph::EdgeMap<double> * >::iterator emsi=beginOfEdgeMaps();
+  for(;emsi!=endOfEdgeMaps();emsi++)
+    {
+      eml[i]=(emsi->first);
+      i++;
+    }
+  return eml;
+}
+
+std::vector<std::string> MapStorage::getNodeMapList()
+{
+  std::vector<std::string> nml;
+  nml.resize(nodemap_storage.size());
+  int i=0;
+  std::map< std::string,Graph::NodeMap<double> * >::iterator nmsi=beginOfNodeMaps();
+  for(;nmsi!=endOfNodeMaps();nmsi++)
+    {
+      nml[i]=(nmsi->first);
+      i++;
+    }
+  return nml;
+}
+
+MapStorage::Signal_Prop MapStorage::signal_prop_ch()
+{
+  return signal_prop;
 }
 

mapstorage.h

@@ -4 +4 @@
 #define MAPSTORAGE_H
 
+class Mapstorage;
+
 #include "all_include.h"
 #include "xymap.h"
+#include <libgnomecanvasmm.h>
 
 ///Class MapStorage is responsible for storing
@@ -38 +41 @@
   std::vector<Graph::EdgeMap<double> > default_edgemaps;
 
+  //Stores the active maps for the different visualization node attributes
+  std::vector< std::string > active_nodemaps;
+
+  //Stores the active maps for the different visualization edge attributes
+  std::vector< std::string > active_edgemaps;
+
   // Default values for the maps
   std::map< std::string, double > nodemap_default;
@@ -43 +52 @@
   // Default values for the maps
   std::map< std::string, double > edgemap_default;
+
+protected:
+  typedef sigc::signal<void, bool, int> Signal_Prop;
+  Signal_Prop signal_prop;
 
 public:
@@ -54 +67 @@
 
   ~MapStorage();
+
+  void changeActiveMap(bool, int, std::string);
+
+  std::string getActiveEdgeMap(int);
+  std::string getActiveNodeMap(int);
+
+  std::vector<std::string> getEdgeMapList();
+  std::vector<std::string> getNodeMapList();
+
+  Signal_Prop signal_prop_ch();
 
   ///Adds given map to storage. A name and the map itself has to be provided.

mw-mapselector.cc

@@ -1 +1 @@
 #include "map_win.h"
 
-MapWin::MapSelector::MapSelector(GraphDisplayerCanvas & grdispc, MapStorage & mapst, int identifier, bool edge):gdc(grdispc),ms(mapst),id(identifier),itisedge(edge),default_state(true),set_new_map(false),node_to_update(INVALID),edge_to_update(INVALID)
+MapWin::MapSelector::MapSelector(std::vector<std::string> ml, int identifier, bool edge):id(identifier),itisedge(edge),default_state(true),set_new_map(false)
 {
-  update_list();
+  update_list(ml);
 
   cbt.set_active(0);
@@ -51 +51 @@
 {
   set_new_map=true;
-  (new NewMapWin("NewMapWin", gdc, itisedge, false))->run();
+  signal_newmapwin.emit(itisedge);
 }
 
-void MapWin::MapSelector::update_list()
+void MapWin::MapSelector::update_list( std::vector< std::string > ml )
 {
   cbt.clear();
-  if(itisedge)
+  std::vector< std::string >::iterator emsi=ml.begin();
+  for(;emsi!=ml.end();emsi++)
     {
-      std::map< std::string,Graph::EdgeMap<double> * >::iterator emsi=ms.beginOfEdgeMaps();
-      for(;emsi!=ms.endOfEdgeMaps();emsi++)
-        {
-          cbt.append_text(emsi->first);
-        }
-    }
-  else
-    {
-      std::map< std::string,Graph::NodeMap<double> * >::iterator emsi=ms.beginOfNodeMaps();
-      for(;emsi!=ms.endOfNodeMaps();emsi++)
-        {
-          cbt.append_text(emsi->first);
-        }
+      cbt.append_text(*emsi);
     }
   cbt.prepend_text("Default values");
@@ -84 +73 @@
       if(!(mapname.empty())) //We seem to get 2 signals, one when the text is empty.
         {
-          if(itisedge)
-            {
-              if( ( (ms.edgemap_storage).find(mapname) != (ms.edgemap_storage).end() ) )
-                {
-                  Edge edge=edge_to_update;
-                  switch(id)
-                    {
-                    case E_WIDTH:
-                      gdc.changeEdgeWidth(mapname, edge);
-                      break;
-                    case E_COLOR:
-                      gdc.changeEdgeColor(mapname, edge);
-                      break;
-                    case E_TEXT:
-                      gdc.changeEdgeText(mapname, edge);
-                      break;
-                    default:
-                      std::cerr<<"Error\n";
-                    }
-                }
-            }
-          else
-            {
-              if( ( (ms.nodemap_storage).find(mapname) != (ms.nodemap_storage).end() ) )
-                {
-                  Node node=node_to_update;
-                  switch(id)
-                    {
-                    case N_RADIUS:
-                      gdc.changeNodeRadius(mapname, node);
-                      break;
-                    case N_COLOR:
-                      gdc.changeNodeColor(mapname, node);
-                      break;
-                    case N_TEXT:
-                      gdc.changeNodeText(mapname, node);
-                      break;
-                    default:
-                      std::cerr<<"Error\n";
-                    }
-                }
-            }
+          signal_cbt.emit(mapname);
         }
     }
   else if((!default_state)&&(cbt.get_active_row_number()==0))
     {
+      signal_cbt.emit("");
       reset();
     }
@@ -139 +88 @@
   cbt.set_active(0);
 
-  if(itisedge)
-    {
-      Edge edge=edge_to_update;
-      switch(id)
-        {
-        case E_WIDTH:
-          gdc.resetEdgeWidth(edge);
-          break;
-        case E_COLOR:
-          gdc.resetEdgeColor(edge);
-          break;
-        case E_TEXT:
-          gdc.resetEdgeText(edge);
-          break;
-        default:
-          std::cerr<<"Error\n";
-        }
-    }
-  else
-    {
-      Node node=node_to_update; 
-      switch(id)
-        {
-        case N_RADIUS:
-          gdc.resetNodeRadius(node);
-          break;
-        case N_COLOR:
-          gdc.resetNodeColor(node);
-          break;
-        case N_TEXT:
-          gdc.resetNodeText(node);
-          break;
-        default:
-          std::cerr<<"Error\n";
-        }
-    }
+  signal_cbt.emit("");
 }
 
-void MapWin::MapSelector::update(Node node)
-{
-  node_to_update=node;
-  if(default_state)
-    {
-      reset();
-    }
-  else
-    {
-      comboChanged();
-    }
-  node_to_update=INVALID;
-}
-
-void MapWin::MapSelector::update(Edge edge)
-{
-  edge_to_update=edge;
-  if(default_state)
-    {
-      reset();
-    }
-  else
-    {
-      comboChanged();
-    }
-  edge_to_update=INVALID;
-}
 
 Glib::ustring MapWin::MapSelector::get_active_text()
@@ -224 +111 @@
     }
 }
+
+sigc::signal<void, std::string> MapWin::MapSelector::signal_cbt_ch()
+{
+  return signal_cbt;
+}
+
+sigc::signal<void, bool> MapWin::MapSelector::signal_newmapwin_needed()
+{
+  return signal_newmapwin;
+}

new_map_win.cc

@@ -10 +10 @@
 }
 
-NewMapWin::NewMapWin(const std::string& title, GraphDisplayerCanvas & grdispc, bool itisedge, bool edgenode):Gtk::Dialog(title, true, true),gdc(grdispc),node("Create NodeMap"),edge("Create EdgeMap")
+NewMapWin::NewMapWin(const std::string& title, MainWin & mw, bool itisedge, bool edgenode):Gtk::Dialog(title, true, true),mainwin(mw),node("Create NodeMap"),edge("Create EdgeMap")
 {
   set_default_size(200, 50);
@@ -84 +84 @@
             {
               //create the new map
-              Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> (gdc.mapstorage.graph);
+              Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> (mainwin.mapstorage.graph);
 
               std::stack<double> polishstack;
   
-              for(EdgeIt k(gdc.mapstorage.graph); k!=INVALID; ++k)
+              for(EdgeIt k(mainwin.mapstorage.graph); k!=INVALID; ++k)
                 {
                   for(int i=0;i<(int)polishform.size();i++)
@@ -107 +107 @@
                         default:
                           //substitute variable
-                          std::map< std::string,Graph::EdgeMap<double> * > ems=gdc.mapstorage.edgemap_storage;
+                          std::map< std::string,Graph::EdgeMap<double> * > ems=mainwin.mapstorage.edgemap_storage;
                           bool itisvar=(ems.find(ch2var[ polishform[i] ])!=ems.end());
                           if(itisvar)
                             {
-                              polishstack.push( (*(gdc.mapstorage.edgemap_storage[ ch2var[ polishform[i] ] ]))[k]);
+                              polishstack.push( (*(mainwin.mapstorage.edgemap_storage[ ch2var[ polishform[i] ] ]))[k]);
                             }
                           else
@@ -154 +154 @@
               //if addition was not successful addEdgeMap returns one.
               //cause can be that there is already a map named like the new one
-              if(gdc.mapstorage.addEdgeMap(mapname, emptr, def_val))
+              if(mainwin.mapstorage.addEdgeMap(mapname, emptr, def_val))
                 {
                   abortion=1;
@@ -160 +160 @@
 
               //add it to the list of the displayable maps
-              gdc.mapwin.registerNewEdgeMap(mapname);
+              mainwin.registerNewEdgeMap(mapname);
 
               //display it
-              gdc.changeEdgeText(mapname);
+              //gdc.changeEdgeText(mapname);
             }
           else //!edge.get_active()
             {
               //create the new map
-              Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> (gdc.mapstorage.graph);
+              Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> (mainwin.mapstorage.graph);
 
               std::stack<double> polishstack;
   
-              for(NodeIt k(gdc.mapstorage.graph); k!=INVALID; ++k)
+              for(NodeIt k(mainwin.mapstorage.graph); k!=INVALID; ++k)
                 {
                   for(int i=0;i<(int)polishform.size();i++)
@@ -190 +190 @@
                           break;
                         default:
-                          std::map< std::string,Graph::NodeMap<double> * > nms=gdc.mapstorage.nodemap_storage;
+                          std::map< std::string,Graph::NodeMap<double> * > nms=mainwin.mapstorage.nodemap_storage;
                           bool itisvar=(nms.find(ch2var[ polishform[i] ])!=nms.end());
                           if(itisvar)
                             {
-                              polishstack.push( (*(gdc.mapstorage.nodemap_storage[ ch2var[ polishform[i] ] ]))[k]);
+                              polishstack.push( (*(mainwin.mapstorage.nodemap_storage[ ch2var[ polishform[i] ] ]))[k]);
                             }
                           else
@@ -237 +237 @@
               //if addition was not successful addNodeMap returns one.
               //cause can be that there is already a map named like the new one
-              if(gdc.mapstorage.addNodeMap(mapname,emptr, def_val))
+              if(mainwin.mapstorage.addNodeMap(mapname,emptr, def_val))
                 {
                   abortion=1;
@@ -243 +243 @@
 
               //add it to the list of the displayable maps
-              gdc.mapwin.registerNewNodeMap(mapname);
+              mainwin.registerNewNodeMap(mapname);
 
               //display it
@@ -432 +432 @@
   if(itisedge)
     {
-      cancel=(gdc.mapstorage.edgemap_storage.find(variable)==gdc.mapstorage.edgemap_storage.end());
+      cancel=(mainwin.mapstorage.edgemap_storage.find(variable)==mainwin.mapstorage.edgemap_storage.end());
     }
   else
     {
-      cancel=(gdc.mapstorage.nodemap_storage.find(variable)==gdc.mapstorage.nodemap_storage.end());
+      cancel=(mainwin.mapstorage.nodemap_storage.find(variable)==mainwin.mapstorage.nodemap_storage.end());
     }
   //maybe it is number

new_map_win.h

@@ -7 +7 @@
 
 #include <all_include.h>
-#include <graph_displayer_canvas.h>
+#include <main_win.h>
 #include <libgnomecanvasmm.h>
 #include <libgnomecanvasmm/polygon.h>
@@ -17 +17 @@
 class NewMapWin : public Gtk::Dialog
 {
-  ///The \ref GraphDisplayerCanvas on which the graph will be drawn.
-  ///It has to be known for this class, because
-  ///when a map is created
-  ///a function of the \ref GraphDisplayerCanvas will be called.
-  GraphDisplayerCanvas & gdc;
+  MainWin & mainwin;
 
 public:
@@ -32 +28 @@
   
   ///Constructor of NewMapWin creates the widgets shown in NewMapWin.
-  NewMapWin(const std::string& title, GraphDisplayerCanvas &, bool itisedge=true, bool edgenode=true);
+  NewMapWin(const std::string& title, MainWin &, bool itisedge=true, bool edgenode=true);
   
   ///Signal on button is connected to this function,