Changeset 201:879e47e5b731 in glemon-0.x

Timestamp:

01/02/08 22:03:09 (17 years ago)

Author:

Akos Ladanyi

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/glemon/trunk@3431

Message:

Merge branches/akos to trunk.

Files:

• Makefile.am (modified) (1 diff)
• algobox.cc (modified) (3 diffs)
• algobox.h (modified) (4 diffs)
• all_include.h (modified) (1 diff)
• configure.ac (modified) (1 diff)
• dijkstrabox.cc (modified) (6 diffs)
• eps_win.cc (modified) (3 diffs)
• eps_win.h (modified) (3 diffs)
• file_import_dialog.cc (added)
• file_import_dialog.h (added)
• gdc-broken_edge.cc (modified) (7 diffs)
• graph-displayer.cc (modified) (1 diff)
• graph_displayer_canvas-edge.cc (modified) (7 diffs)
• graph_displayer_canvas-event.cc (modified) (25 diffs)
• graph_displayer_canvas-node.cc (modified) (12 diffs)
• graph_displayer_canvas.cc (modified) (10 diffs)
• gui_reader.cc (modified) (3 diffs)
• gui_reader.h (modified) (3 diffs)
• gui_writer.cc (modified) (5 diffs)
• io_helper.cc (added)
• io_helper.h (added)
• kruskalbox.cc (modified) (2 diffs)
• main_win.cc (modified) (7 diffs)
• main_win.h (modified) (1 diff)
• map_value.cc (added)
• map_value.h (added)
• map_value_map.cc (added)
• map_value_map.h (added)
• map_win.cc (modified) (6 diffs)
• map_win.h (modified) (5 diffs)
• mapselector.cc (modified) (4 diffs)
• mapselector.h (modified) (6 diffs)
• mapstorage.cc (modified) (16 diffs)
• mapstorage.h (modified) (13 diffs)
• nbtab.cc (modified) (14 diffs)
• nbtab.h (modified) (3 diffs)
• new_map_win.cc (modified) (9 diffs)
• new_map_win.h (modified) (2 diffs)
• save_details_dialog.cc (added)
• save_details_dialog.h (added)
• save_details_widget.cc (added)
• save_details_widget.h (added)
• xml.h (modified) (2 diffs)

Makefile.am

@@ -48 +48 @@
         dijkstrabox.h \
         dijkstrabox.cc \
+        file_import_dialog.h \
+        file_import_dialog.cc \
+        map_value.h \
+        map_value.cc \
+        map_value_map.h \
+        map_value_map.cc \
+        save_details_widget.h \
+        save_details_widget.cc \
+        save_details_dialog.h \
+        save_details_dialog.cc \
+        io_helper.h \
+        io_helper.cc \
         background_chooser_dialog.h \
         background_chooser_dialog.cc \

algobox.cc

@@ -83 +83 @@
 {
   mapstorage=ms;
-  std::vector<std::string> nml;
-  std::vector<std::string> eml;
+  std::vector<std::string> n_nml;
+  std::vector<std::string> s_nml;
+  std::vector<std::string> n_eml;
+  std::vector<std::string> s_eml;
   if(mapstorage!=NULL)
     {
       mapstorage->signal_node_map_ch().connect(sigc::mem_fun(*this, &AlgoBox::nodemaplist_changed));
       mapstorage->signal_edge_map_ch().connect(sigc::mem_fun(*this, &AlgoBox::edgemaplist_changed));
-      nml=mapstorage->getNodeMapList();
-      eml=mapstorage->getEdgeMapList();
+      n_nml=mapstorage->getNodeMapList(NUM);
+      s_nml=mapstorage->getNodeMapList(STR);
+      n_eml=mapstorage->getEdgeMapList(NUM);
+      s_eml=mapstorage->getEdgeMapList(STR);
     }
   for(int i=0;i<(int)nodemapcbts.size();i++)
     {
-      (nodemapcbts[i])->update_list(nml);
+      (nodemapcbts[i])->update_list(n_nml, s_nml);
       //update_cbt(nml, *(nodemapcbts[i]));
     }
   for(int i=0;i<(int)edgemapcbts.size();i++)
     {
-      (edgemapcbts[i])->update_list(eml);
+      (edgemapcbts[i])->update_list(n_eml, s_eml);
       //update_cbt(eml, *(edgemapcbts[i]));
     }
@@ -105 +109 @@
 }
 
-void AlgoBox::nodemaplist_changed(std::string newmap)
+void AlgoBox::nodemaplist_changed(std::string newmap, MapValue::Type type)
 {
   for(int i=0;i<(int)nodemapcbts.size();i++)
     {
-      (nodemapcbts[i])->append_text(newmap);
-    }
-}
-
-void AlgoBox::edgemaplist_changed(std::string newmap)
+      (nodemapcbts[i])->append_text(newmap, type);
+    }
+}
+
+void AlgoBox::edgemaplist_changed(std::string newmap, MapValue::Type type)
 {
   for(int i=0;i<(int)edgemapcbts.size();i++)
     {
-      (edgemapcbts[i])->append_text(newmap);
+      (edgemapcbts[i])->append_text(newmap, type);
     }
 }
@@ -161 +165 @@
 }
 
-void AlgoBox::addMapSelector(std::string inputname, bool itisedge)
+void AlgoBox::addMapSelector(std::string inputname, bool itisedge, MapType type)
 {
   std::vector<std::string> empty_vector;
 
-  MapSelector * msp=new MapSelector(empty_vector,"",inputname,itisedge, false);
+  MapSelector * msp=new MapSelector(empty_vector,empty_vector,"",inputname,itisedge, false, type);
 
   if(itisedge)

algobox.h

@@ -26 +26 @@
 #include <libgnomecanvasmm.h>
 #include <libgnomecanvasmm/polygon.h>
+#include "map_value.h"
 
 ///Ancestor class of algorithm graphical interface classes.
@@ -139 +140 @@
   ///a signal is emitted by it. This signal is connected to this function, so \ref MapSelector s
   ///in \ref nodemapcbts can be notified, and those can registrate the new map. (\ref MapSelector::append_text)
-  void nodemaplist_changed(std::string);
+  void nodemaplist_changed(std::string, MapValue::Type);
 
   ///Interface, through which \ref AlgoBox can be notified about edgemap addition.
@@ -146 +147 @@
   ///a signal is emitted by it. This signal is connected to this function, so \ref MapSelector s
   ///in \ref edgemapcbts can be notified, and those can registrate the new map. (\ref MapSelector::append_text)
-  void edgemaplist_changed(std::string);
+  void edgemaplist_changed(std::string, MapValue::Type);
 
   ///Aid function to provide data for a given entry.
@@ -184 +185 @@
   ///\param label label to show in \ref MapSelector
   ///\param itisedge whether edge or nodemaps stored in \ref MapSelector
-  void addMapSelector(std::string label, bool itisedge);
+  void addMapSelector(std::string label, bool itisedge, MapType type = ALL);
 };
 #endif //ALGOBOX_H

all_include.h

@@ -66 +66 @@
 const std::string prog_name = "LEMON Graph Editor";
 
+enum MapType
+{
+  NUM  = 1 << 0,
+  STR  = 1 << 1,
+  ALL  = (1 << 0) | (1 << 1)
+};
+
 #endif // ALL_INCLUDE_H

configure.ac

@@ -27 +27 @@
 PKG_CHECK_MODULES([GTK], [libgnomecanvasmm-2.6 >= 2.6.0 gtkmm-2.4 >= 2.6])
 
-AC_ARG_WITH([lemon-prefix],
-AS_HELP_STRING([--with-lemon-prefix@<:@=PREFIX@:>@], [search for LEMON under PREFIX]), [], [with_lemon_prefix=no])
-if test x"$with_lemon_prefix" != x"no"; then
-  export PKG_CONFIG_PATH="$with_lemon_prefix/lib/pkgconfig/:$PKG_CONFIG_PATH"
+AC_ARG_WITH([lemon],
+AS_HELP_STRING([--with-lemon@<:@=PREFIX@:>@], [search for LEMON under PREFIX]), [], [with_lemon=no])
+if test x"$with_lemon" != x"no"; then
+  export PKG_CONFIG_PATH="$with_lemon/lib/pkgconfig/:$PKG_CONFIG_PATH"
 fi
 
-PKG_CHECK_MODULES([LEMON_0_5], [lemon >= 0.5],
-  [lemon_0_5_found=yes], [
-    AC_MSG_RESULT([no])
-    lemon_0_5_found=no])
-PKG_CHECK_MODULES([LEMON_SVNHEAD], [lemon = svnhead],
-  [lemon_svn_head_found=yes], [
-    AC_MSG_RESULT([no])
-    lemon_svn_head_found=no])
-if test x"$lemon_0_5_found" = x"no" -a x"$lemon_svn_head_found" = x"no"; then
-  AC_MSG_ERROR([LEMON not found.])
-else
-  if test x"$lemon_svn_head_found" = x"yes"; then
-    LEMON_CFLAGS="$LEMON_SVNHEAD_CFLAGS"
-    LEMON_LIBS="$LEMON_SVNHEAD_LIBS"
-  else
-    LEMON_CFLAGS="$LEMON_0_5_CFLAGS"
-    LEMON_LIBS="$LEMON_0_5_LIBS"
-  fi
-  AC_SUBST(LEMON_CFLAGS)
-  AC_SUBST(LEMON_LIBS)
-fi
+PKG_CHECK_MODULES([LEMON], [lemon >= 0.6.90])
 
 dnl Checks for header files.

dijkstrabox.cc

@@ -51 +51 @@
     
 void DijkstraBox::run()
+{
+  if(
+      tabcbt.get_active_text()!="" &&
+      (edgemapcbts[INPUT])->get_active_text()!="" &&
+      (edgemapcbts[OUTPUT])->get_active_text()!="" &&
+      source.get_active_text()!="" &&
+      target.get_active_text()!=""
+    )
+  {
+    const Graph &g=mapstorage->graph;
+    Node from, to;
+
+    get_from_to(from, to, (Graph&)g);
+
+    std::ostringstream o;
+
+    if(!(from==to))
+    {
+      std::string inputmapName = edgemapcbts[INPUT]->get_active_text();
+      std::string outputmapName = edgemapcbts[OUTPUT]->get_active_text();
+
+      MapStorage::NumericEdgeMap& inputmap = mapstorage->getNumericEdgeMap(inputmapName);
+      MapStorage::NumericEdgeMap& outputmap = mapstorage->getNumericEdgeMap(outputmapName);
+
+      //zero out output map
+      for (EdgeIt i(g); i!=INVALID; ++i)
+      {
+        outputmap[i]=0;
+      }
+
+      Dijkstra<Graph, MapStorage::NumericEdgeMap > dijkstra(g, inputmap);
+      dijkstra.run(from, to);
+
+      if(dijkstra.reached(to))
+      {
+        Node n=to;
+        int length=0;
+        while (n!=INVALID && n!=from)
+        {
+          Edge e=dijkstra.predEdge(n);
+          outputmap[e]=1;
+          n=dijkstra.predNode(n);
+          length++;
+        }
+        o << "Result: " << length << " long path, with cost " << dijkstra.dist(to);
+      }
+      else
+      {
+        o << "Result: failed to find shortest path between ";
+        o << source.get_active_text() << " and " << target.get_active_text();
+      }
+      resultlabel.set_text(o.str());
+
+      mapstorage->mapChanged(true, (edgemapcbts[OUTPUT])->get_active_text());
+      //   mapstorage->changeActiveMap(true, E_COLOR,
+      //                              (edgemapcbts[OUTPUT])->get_active_text());
+      //   mapstorage->changeActiveMap(true, E_TEXT,
+      //                              (edgemapcbts[INPUT])->get_active_text());
+    }
+  }
+}
+
+void SuurballeBox::run()
 {
   if(
@@ -69 +132 @@
       if(!(from==to))
         {
-          Graph::EdgeMap<double> * inputmap=
-            (mapstorage->edgemap_storage)[(edgemapcbts[INPUT])->get_active_text()];
-          Graph::EdgeMap<double> * outputmap=
-            (mapstorage->edgemap_storage)[(edgemapcbts[OUTPUT])->get_active_text()];
+          MapStorage::NumericEdgeMap& inputmap=
+            mapstorage->getNumericEdgeMap(edgemapcbts[INPUT]->get_active_text());
+          MapStorage::NumericEdgeMap& outputmap=
+            mapstorage->getNumericEdgeMap(edgemapcbts[OUTPUT]->get_active_text());
 
           //zero out output map
           for (EdgeIt i(g); i!=INVALID; ++i)
             {
-              (*outputmap)[i]=0;
+              outputmap[i]=0;
             }
           
-          Dijkstra<Graph, Graph::EdgeMap<double> > dijkstra(g, *inputmap);
-          dijkstra.run(from, to);
-          
-          if(dijkstra.reached(to))
-            {
-              Node n=to;
-              int length=0;
-              while (n!=INVALID && n!=from)
-                {
-                  Edge e=dijkstra.predEdge(n);
-                  (*outputmap)[e]=1;
-                  n=dijkstra.predNode(n);
-                  length++;
-                }
-              o << "Result: " << length << " long path, with cost " << dijkstra.dist(to);
-            }
-          else
-            {
-              o << "Result: failed to find shortest path between ";
-              o << source.get_active_text() << " and " << target.get_active_text();
-            }
-          resultlabel.set_text(o.str());
-          
-          mapstorage->mapChanged(true, (edgemapcbts[OUTPUT])->get_active_text());
-          //   mapstorage->changeActiveMap(true, E_COLOR,
-          //                          (edgemapcbts[OUTPUT])->get_active_text());
-          //   mapstorage->changeActiveMap(true, E_TEXT,
-          //                          (edgemapcbts[INPUT])->get_active_text());
-        }
-    }
-}
-
-void SuurballeBox::run()
-{
-  if(
-     tabcbt.get_active_text()!="" &&
-     (edgemapcbts[INPUT])->get_active_text()!="" &&
-     (edgemapcbts[OUTPUT])->get_active_text()!="" &&
-     source.get_active_text()!="" &&
-     target.get_active_text()!=""
-     )
-    {
-      const Graph &g=mapstorage->graph;
-      Node from, to;
-
-      get_from_to(from, to, (Graph&)g);
-
-      std::ostringstream o;
-
-      if(!(from==to))
-        {
-          Graph::EdgeMap<double> * inputmap=
-            (mapstorage->edgemap_storage)[(edgemapcbts[INPUT])->get_active_text()];
-          Graph::EdgeMap<double> * outputmap=
-            (mapstorage->edgemap_storage)[(edgemapcbts[OUTPUT])->get_active_text()];
-
-          //zero out output map
-          for (EdgeIt i(g); i!=INVALID; ++i)
-            {
-              (*outputmap)[i]=0;
-            }
-          
-          Suurballe<Graph, Graph::EdgeMap<double> > sb((Graph&)g, *inputmap, from, to);
+          Suurballe<Graph, MapStorage::NumericEdgeMap > sb((Graph&)g, inputmap, from, to);
           
           int found=sb.run(num_set->get_value_as_int());
@@ -153 +154 @@
                   for(int k=0;k<path.length();k++)
                     {
-                      (*outputmap)[path.nth(k)]=j+1;
+                      outputmap[path.nth(k)]=j+1;
                     }
                 }
@@ -181 +182 @@
   signal_upon_maplist_updated().connect(sigc::mem_fun(*this, &DijkstraBox::maplists_updated));
 
-  addMapSelector("Cost map: ", true);
-  addMapSelector("Edges of path here: ", true);
+  addMapSelector("Cost map: ", true, NUM);
+  addMapSelector("Edges of path here: ", true, NUM);
 
   Gtk::Label * source_label=new Gtk::Label("Source: ");
@@ -213 +214 @@
         {
           std::ostringstream text;
-          text << (*((mapstorage->nodemap_storage)["label"]))[i];
+          text << mapstorage->getLabel(i);
           source.prepend_text(text.str());
           target.prepend_text(text.str());
@@ -226 +227 @@
     {
       std::ostringstream text;
-      text << (*((mapstorage->nodemap_storage)["label"]))[i];
+      text << mapstorage->getLabel(i);
       if(!(text.str().compare(source.get_active_text())))
         {

eps_win.cc

@@ -32 +32 @@
 }
 
-EpsWin::EpsWin(const std::string& title, std::vector<std::string> nml):Gtk::Dialog(title, true, true)
+EpsWin::EpsWin(const std::string& title, std::vector<std::string> n_nml, std::vector<std::string> s_nml):Gtk::Dialog(title, true, true)
 {
   set_default_size(200, 50);
@@ -58 +58 @@
     }
 
-  mapselector=new MapSelector(nml, "", "Nodeshapes", false);
+  mapselector=new MapSelector(n_nml, s_nml, "", "Nodeshapes", false, true, NUM);
   mapselector->signal_newmapwin_needed().connect(sigc::mem_fun(*this, &EpsWin::newMapWinNeeded));
 
@@ -105 +105 @@
 }
 
-void EpsWin::registerNewNodeMap(std::string newmapname)
+void EpsWin::registerNewNodeMap(std::string newmapname, MapValue::Type type)
 {
-    mapselector->append_text((Glib::ustring)newmapname);
+    mapselector->append_text((Glib::ustring)newmapname, type);
 }

eps_win.h

@@ -25 +25 @@
 #include <libgnomecanvasmm.h>
 #include <libgnomecanvasmm/polygon.h>
+#include "map_value.h"
 
 ///Graph visualization setup window.
@@ -62 +63 @@
   ///\param nml nodemap list
   ///\param mw the owner \ref NoteBookTab (\ref mytab)
-  EpsWin(const std::string& title, std::vector<std::string>);
+  EpsWin(const std::string& title, std::vector<std::string>, std::vector<std::string>);
 
   ///Deregistrates \ref EpsWin in its \ref NoteBookTab (\ref mytab)
@@ -103 +104 @@
   ///\param new_name
   ///name of new map
-  void registerNewNodeMap(std::string new_name);
+  void registerNewNodeMap(std::string new_name, MapValue::Type type);
 };
 

gdc-broken_edge.cc

@@ -37 +37 @@
 {
   MapStorage& ms = *canvas.mytab.mapstorage;
-  XY center(ms.arrow_pos[edge]);
+  XY center(ms.getArrowCoords(edge));
   XY unit_norm_vector(0-unit_vector_in_dir.y, unit_vector_in_dir.x);
 
@@ -90 +90 @@
 
   //calculating coordinates of the direction indicator arrow
-  XY head(ms.coords[ms.graph.target(edge)]);
-  XY center(ms.arrow_pos[edge]);
+  XY head(ms.getNodeCoords(ms.graph.target(edge)));
+  XY center(ms.getArrowCoords(edge));
 
   XY unit_vector_in_dir(head-center);
@@ -108 +108 @@
   Node source = ms.graph.source(edge);
   Node target = ms.graph.target(edge);
-  points.push_back(Gnome::Art::Point(ms.coords[source].x,
-        ms.coords[source].y));
-  points.push_back(Gnome::Art::Point(ms.arrow_pos[edge].x,
-        ms.arrow_pos[edge].y));
-  points.push_back(Gnome::Art::Point(ms.coords[target].x,
-        ms.coords[target].y));
+  points.push_back(Gnome::Art::Point(ms.getNodeCoords(source).x,
+        ms.getNodeCoords(source).y));
+  points.push_back(Gnome::Art::Point(ms.getArrowCoords(edge).x,
+        ms.getArrowCoords(edge).y));
+  points.push_back(Gnome::Art::Point(ms.getNodeCoords(target).x,
+        ms.getNodeCoords(target).y));
   line.property_points().set_value(points);
 }
@@ -153 +153 @@
         Gnome::Canvas::Points points_new;
 
-        canvas.mytab.mapstorage->arrow_pos.set(edge, canvas.mytab.mapstorage->arrow_pos[edge] + XY(dx, dy));
+        canvas.mytab.mapstorage->setArrowCoords(edge, canvas.mytab.mapstorage->getArrowCoords(edge) + XY(dx, dy));
 
         draw();
-        canvas.textReposition(canvas.mytab.mapstorage->arrow_pos[edge]);
+        canvas.textReposition(canvas.mytab.mapstorage->getArrowCoords(edge));
 
         clicked_x=e->motion.x;
@@ -200 +200 @@
 
   Node node = ms.graph.source(edge);
-  XY center = (ms.coords[node] + ms.arrow_pos[edge]) / 2.0;
-
-  XY unit_vector_in_dir(rot90(center - ms.arrow_pos[edge]));
+  XY center = (ms.getNodeCoords(node) + ms.getArrowCoords(edge)) / 2.0;
+
+  XY unit_vector_in_dir(rot90(center - ms.getArrowCoords(edge)));
   double length = sqrt(unit_vector_in_dir.normSquare());
   unit_vector_in_dir /= length;
@@ -209 +209 @@
 
   double radius =
-    sqrt((ms.arrow_pos[edge] - ms.coords[node]).normSquare()) / 2.0;
+    sqrt((ms.getArrowCoords(edge) - ms.getNodeCoords(node)).normSquare()) / 2.0;
 
   XY p1 = center + XY(-radius,  radius);
@@ -250 +250 @@
       if(isbutton)
       {
-        canvas.mytab.mapstorage->arrow_pos.set(edge, XY(e->motion.x, e->motion.y));
+        canvas.mytab.mapstorage->setArrowCoords(edge, XY(e->motion.x, e->motion.y));
 
         draw();
-        canvas.textReposition(canvas.mytab.mapstorage->arrow_pos[edge]);
+        canvas.textReposition(canvas.mytab.mapstorage->getArrowCoords(edge));
       }
     default: break;

graph-displayer.cc

@@ -96 +96 @@
 //     }
   if(argc>=2)
+  {
+    for(int i=1;i<argc;i++)
     {
-      for(int i=1;i<argc;i++)
-        {
-          if(Glib::file_test(argv[i], Glib::FILE_TEST_IS_REGULAR))
-            {
-              mytab.readFile(argv[i]);
-            }
-        }
+      if(Glib::file_test(argv[i], Glib::FILE_TEST_IS_REGULAR))
+      {
+        mytab.readFile(argv[i]);
+      }
     }
+  }
   else
     {

graph_displayer_canvas-edge.cc

@@ -26 +26 @@
 int GraphDisplayerCanvas::resetEdgeWidth (Edge edge)
 {
+  MapStorage& ms = *mytab.mapstorage;
   double min, max;
 
   min=edge_property_defaults[E_WIDTH];
   max=edge_property_defaults[E_WIDTH];
-  Graph::EdgeMap<double> actual_map((mytab.mapstorage)->graph,edge_property_defaults[E_WIDTH]);
-  
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-        {
-          double v=fabs(actual_map[i]);
-          int w;
-          if(min==max)
-            {
-              w=(int)(edge_property_defaults[E_WIDTH]);
-            }
-          else
-            {
-              w=(int)(MIN_EDGE_WIDTH+(v-min)/(max-min)*(MAX_EDGE_WIDTH-MIN_EDGE_WIDTH));
-            }
-          if(zoomtrack)
-            {
-              double actual_ppu=get_pixels_per_unit();
-              w=(int)(w/actual_ppu*fixed_zoom_factor);
-            }
-          edgesmap[i]->setLineWidth(w);
-        }
-    }
-  else
-    {
-      int w=(int)actual_map[edge];
-      if(w>=0)
-        {
-          edgesmap[edge]->setLineWidth(w);
-        }
-    }
+  Graph::EdgeMap<double> actual_map(ms.graph,edge_property_defaults[E_WIDTH]);
+
+  if(edge==INVALID)
+  {
+    for (EdgeIt i(ms.graph); i!=INVALID; ++i)
+    {
+      double v=fabs(actual_map[i]);
+      int w;
+      if(min==max)
+      {
+        w=(int)(edge_property_defaults[E_WIDTH]);
+      }
+      else
+      {
+        w=(int)(MIN_EDGE_WIDTH+(v-min)/(max-min)*(MAX_EDGE_WIDTH-MIN_EDGE_WIDTH));
+      }
+      if(zoomtrack)
+      {
+        double actual_ppu=get_pixels_per_unit();
+        w=(int)(w/actual_ppu*fixed_zoom_factor);
+      }
+      edgesmap[i]->setLineWidth(w);
+    }
+  }
+  else
+  {
+    int w=(int)actual_map[edge];
+    if(w>=0)
+    {
+      edgesmap[edge]->setLineWidth(w);
+    }
+  }
   return 0;
 }
@@ -68 +69 @@
 int GraphDisplayerCanvas::changeEdgeWidth (std::string mapname, Edge edge)
 {
-  Graph::EdgeMap<double> * actual_map;
+  MapStorage& ms = *mytab.mapstorage;
   double min, max;
 
-  min=(mytab.mapstorage)->minOfEdgeMap(mapname);
-  max=(mytab.mapstorage)->maxOfEdgeMap(mapname);
-  actual_map=((mytab.mapstorage)->edgemap_storage)[mapname];
-
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-        {
-          double v=(*actual_map)[i];
-          int w;
-          if(autoscale)
-            {
-              if(min==max)
-                {
-                  w=(int)(edge_property_defaults[E_WIDTH]);
-                }
-              else
-                {
-                  w=(int)(minimum_edge_width+(v-min)/(max-min)*(edge_width-minimum_edge_width));
-                }
-            }
-          else
-            {
-              w=(int)(v*edge_width);
-            }
-          if(w<0)
-            {
-              edgesmap[i]->hide();
-            }
-          else
-            {
-              edgesmap[i]->show();
-              if(w<minimum_edge_width)
-                {
-                  w=minimum_edge_width;
-                }
-              if(zoomtrack)
-                {
-                  double actual_ppu=get_pixels_per_unit();
-                  w=(int)(w/actual_ppu*fixed_zoom_factor);
-                }
-              edgesmap[i]->setLineWidth(w);
-            }
-        }
-    }
-  else
-    {
-      int w=(int)(*actual_map)[edge];
-      if(w>=0)
-        {
-          edgesmap[edge]->setLineWidth(w);
-        }
-    }
+  {
+    EdgeIt e(ms.graph);
+    min = max = ms.get(mapname, e);
+    for (; e != INVALID; ++e)
+    {
+      if (static_cast<double>(ms.get(mapname, e)) > max)
+        max = ms.get(mapname, e);
+      if (static_cast<double>(ms.get(mapname, e)) < min)
+        min = ms.get(mapname, e);
+    }
+  }
+
+  if(edge==INVALID)
+  {
+    for (EdgeIt i(ms.graph); i!=INVALID; ++i)
+    {
+      double v=ms.get(mapname, i);
+      int w;
+      if(autoscale)
+      {
+        if(min==max)
+        {
+          w=(int)(edge_property_defaults[E_WIDTH]);
+        }
+        else
+        {
+          w=(int)(minimum_edge_width+(v-min)/(max-min)*(edge_width-minimum_edge_width));
+        }
+      }
+      else
+      {
+        w=(int)(v*edge_width);
+      }
+      if(w<0)
+      {
+        edgesmap[i]->hide();
+      }
+      else
+      {
+        edgesmap[i]->show();
+        if(w<minimum_edge_width)
+        {
+          w=minimum_edge_width;
+        }
+        if(zoomtrack)
+        {
+          double actual_ppu=get_pixels_per_unit();
+          w=(int)(w/actual_ppu*fixed_zoom_factor);
+        }
+        edgesmap[i]->setLineWidth(w);
+      }
+    }
+  }
+  else
+  {
+    int w=(int)ms.get(mapname, edge);
+    if(w>=0)
+    {
+      edgesmap[edge]->setLineWidth(w);
+    }
+  }
   return 0;
 };
@@ -129 +138 @@
 int GraphDisplayerCanvas::changeEdgeColor (std::string mapname, Edge edge)
 {  
+  MapStorage& ms = *mytab.mapstorage;
 
   //function maps the range of the maximum and
   //the minimum of the nodemap to the range of
   //green in RGB
-  Graph::EdgeMap<double> * actual_map;
-  actual_map=((mytab.mapstorage)->edgemap_storage)[mapname];
 
   double max, min;
 
-  max=(mytab.mapstorage)->maxOfEdgeMap(mapname);
-  min=(mytab.mapstorage)->minOfEdgeMap(mapname);
-
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+  {
+    EdgeIt e(ms.graph);
+    min = max = ms.get(mapname, e);
+    for (; e != INVALID; ++e)
+    {
+      if (static_cast<double>(ms.get(mapname, e)) > max)
+        max = ms.get(mapname, e);
+      if (static_cast<double>(ms.get(mapname, e)) < min)
+        min = ms.get(mapname, e);
+    }
+  }
+
+  if(edge==INVALID)
+    {
+      for (EdgeIt i(ms.graph); i!=INVALID; ++i)
         {
-          double w=(*actual_map)[i];
+          double w=ms.get(mapname, i);
 
           Gdk::Color color;
@@ -163 +180 @@
       Gdk::Color color;
 
-      double w=(*actual_map)[edge];
+      double w=ms.get(mapname, edge);
 
       if(max!=min)
@@ -181 +198 @@
 int GraphDisplayerCanvas::resetEdgeColor (Edge edge)
 {  
+  MapStorage& ms = *mytab.mapstorage;
 
   //function maps the range of the maximum and
   //the minimum of the nodemap to the range of
   //green in RGB
-  Graph::EdgeMap<double> actual_map((mytab.mapstorage)->graph,edge_property_defaults[E_COLOR]);
+  Graph::EdgeMap<double> actual_map(ms.graph,edge_property_defaults[E_COLOR]);
 
   double max, min;
@@ -193 +211 @@
 
   if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-        {
-          double w=actual_map[i];
-
-          Gdk::Color color;
-          if(max!=min)
-            {
-              color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
-            }
-          else
-            {
-              color.set_rgb_p (0, 100, 0);
-            }
-          edgesmap[i]->setFillColor(color);
-        }
-    }
-  else
-    {
+  {
+    for (EdgeIt i(ms.graph); i!=INVALID; ++i)
+    {
+      double w=actual_map[i];
+
       Gdk::Color color;
-
-      double w=actual_map[edge];
-
       if(max!=min)
-        {
-          color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
-        }
-      else
-        {
-          color.set_rgb_p (0, 100, 0);
-        }
-
-      edgesmap[edge]->setFillColor(color);
-    }
+      {
+        color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
+      }
+      else
+      {
+        color.set_rgb_p (0, 100, 0);
+      }
+      edgesmap[i]->setFillColor(color);
+    }
+  }
+  else
+  {
+    Gdk::Color color;
+
+    double w=actual_map[edge];
+
+    if(max!=min)
+    {
+      color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
+    }
+    else
+    {
+      color.set_rgb_p (0, 100, 0);
+    }
+
+    edgesmap[edge]->setFillColor(color);
+  }
   return 0;
 };
@@ -232 +250 @@
 int GraphDisplayerCanvas::changeEdgeText (std::string mapname, Edge edge)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   //the number in the map will be written on the edge
   //EXCEPT when the name of the map is Default, because
   //in that case empty string will be written, because
   //that is the deleter map
-  
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-        {
-          edgemap_to_edit=mapname;
-          double number=(*((mytab.mapstorage)->edgemap_storage)[mapname])[i];
-          
-          std::ostringstream ostr;
-          ostr << number;
-          
-          edgetextmap[i]->property_text().set_value(ostr.str());
-        }
-
-    }
-  else
-    {
-          double number=(*((mytab.mapstorage)->edgemap_storage)[mapname])[edge];
-
-          std::ostringstream ostr;
-          ostr << number;
-          
-          edgetextmap[edge]->property_text().set_value(ostr.str());
-    }
-
-  return 0;
-
+
+  if(edge==INVALID)
+  {
+    for (EdgeIt i(ms.graph); i!=INVALID; ++i)
+    {
+      edgemap_to_edit=mapname;
+
+      edgetextmap[i]->property_text().set_value(
+          static_cast<std::string>(ms.get(mapname, i)));
+    }
+
+  }
+  else
+  {
+    edgetextmap[edge]->property_text().set_value(
+        static_cast<std::string>(ms.get(mapname, edge)));
+  }
+
+  return 0;
 };
 
 int GraphDisplayerCanvas::resetEdgeText (Edge edge)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   //the number in the map will be written on the edge
   //EXCEPT when the name of the map is Default, because
   //in that case empty string will be written, because
   //that is the deleter map
-  
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-        {
-          edgemap_to_edit="";
-          edgetextmap[i]->property_text().set_value("");
-        }
-
-    }
-  else
-    {
-      edgetextmap[edge]->property_text().set_value("");
-    }
-
-  return 0;
-
-};
+
+  if(edge==INVALID)
+  {
+    for (EdgeIt i(ms.graph); i!=INVALID; ++i)
+    {
+      edgemap_to_edit="";
+      edgetextmap[i]->property_text().set_value("");
+    }
+  }
+  else
+  {
+    edgetextmap[edge]->property_text().set_value("");
+  }
+
+  return 0;
+};

graph_displayer_canvas-event.cc

@@ -34 +34 @@
 {
   if(actual_tool!=newtool)
-    {
-
-      actual_handler.disconnect();
-
-      switch(actual_tool)
-        {
-        case CREATE_EDGE:
-          {
-            GdkEvent * generated=new GdkEvent();
-            generated->type=GDK_BUTTON_RELEASE;
-            generated->button.button=3;
-            createEdgeEventHandler(generated);      
-            break;
-          }
-        case MAP_EDIT:
-          {
-            break;
-          }
-        default:
-          break;
-        }
-
-      active_item=NULL; 
-      target_item=NULL; 
-      active_edge=INVALID;      
-      active_node=INVALID;      
-
-
-      actual_tool=newtool;
-  
-      switch(newtool)
-        {
-        case MOVE:
-          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
-          break;
-
-        case CREATE_NODE:
-          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
-          break;
-
-        case CREATE_EDGE:
-          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
-          break;
-
-        case ERASER:
-          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
-          break;
-
-        case MAP_EDIT:
-          grab_focus();
-          actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
-          break;
-
-        default:
-          break;
-        }
-    }
+  {
+
+    actual_handler.disconnect();
+
+    switch(actual_tool)
+    {
+      case CREATE_EDGE:
+        {
+          GdkEvent * generated=new GdkEvent();
+          generated->type=GDK_BUTTON_RELEASE;
+          generated->button.button=3;
+          createEdgeEventHandler(generated);      
+          break;
+        }
+      case MAP_EDIT:
+        {
+          break;
+        }
+      default:
+        break;
+    }
+
+    active_item=NULL; 
+    target_item=NULL; 
+    active_edge=INVALID;        
+    active_node=INVALID;        
+
+
+    actual_tool=newtool;
+
+    switch(newtool)
+    {
+      case MOVE:
+        actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
+        break;
+
+      case CREATE_NODE:
+        actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
+        break;
+
+      case CREATE_EDGE:
+        actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
+        break;
+
+      case ERASER:
+        actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
+        break;
+
+      case MAP_EDIT:
+        grab_focus();
+        actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
+        break;
+
+      default:
+        break;
+    }
+  }
 }
 
@@ -139 +139 @@
 bool GraphDisplayerCanvas::moveEventHandler(GdkEvent* e)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   static Gnome::Canvas::Text *coord_text = 0;
   switch(e->type)
-    {
+  {
     case GDK_BUTTON_PRESS:
       //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((mytab.mapstorage)->graph); i!=INVALID; ++i)
-        {
-          if(nodesmap[i]==active_item)
-            {
-              active_node=i;
-            }
-        }
+      for (NodeIt i(ms.graph); i!=INVALID; ++i)
+      {
+        if(nodesmap[i]==active_item)
+        {
+          active_node=i;
+        }
+      }
       isbutton=e->button.button;
       break;
     case GDK_BUTTON_RELEASE:
       if (coord_text)
-        {
-          delete coord_text;
-          coord_text = 0;
-        }
+      {
+        delete coord_text;
+        coord_text = 0;
+      }
       isbutton=0;
       active_item=NULL;
@@ -170 +172 @@
       //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)
-        {
-          (mytab.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
-          
-          double new_x, new_y;
-          
-          window_to_world (e->motion.x, e->motion.y, new_x, new_y);
-          
-          double dx=new_x-clicked_x;
-          double dy=new_y-clicked_y;
-          
-          moveNode(dx, dy);
-
-          clicked_x=new_x;
-          clicked_y=new_y;
-
-          // reposition the coordinates text
-          std::ostringstream ostr;
-          ostr << "(" <<
-            (mytab.mapstorage)->coords[active_node].x << ", " <<
-            (mytab.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((mytab.mapstorage)->coords[active_node].x +
-                                                 radius);
-              coord_text->property_y().set_value((mytab.mapstorage)->coords[active_node].y -
-                                                 radius);
-            }
-          else
-            {
-              coord_text = new Gnome::Canvas::Text(
-                                                   displayed_graph,
-                                                   (mytab.mapstorage)->coords[active_node].x + radius,
-                                                   (mytab.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);
-            }
-
-
-        }
+      {
+        ms.setModified();
+
+        //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
+
+        double new_x, new_y;
+
+        window_to_world (e->motion.x, e->motion.y, new_x, new_y);
+
+        double dx=new_x-clicked_x;
+        double dy=new_y-clicked_y;
+
+        moveNode(dx, dy);
+
+        clicked_x=new_x;
+        clicked_y=new_y;
+
+        // reposition the coordinates text
+        std::ostringstream ostr;
+        ostr << "(" <<
+          ms.getNodeCoords(active_node).x << ", " <<
+          ms.getNodeCoords(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(
+              ms.getNodeCoords(active_node).x + radius);
+          coord_text->property_y().set_value(
+              ms.getNodeCoords(active_node).y - radius);
+        }
+        else
+        {
+          coord_text = new Gnome::Canvas::Text(
+              displayed_graph,
+              ms.getNodeCoords(active_node).x + radius,
+              ms.getNodeCoords(active_node).y - radius,
+              ostr.str());
+          coord_text->property_fill_color().set_value("black");
+          coord_text->property_anchor().set_value(Gtk::ANCHOR_SOUTH_WEST);
+        }
+
+
+      }
     default: break;
-    }
-
-return false;
+  }
+
+  return false;
 }
 
@@ -228 +230 @@
 {
   switch(move_code)
-    {
+  {
     case 1:
       return XY((moved_node_2.x + fix_node.x) / 2.0, (moved_node_2.y + fix_node.y) / 2.0);
@@ -237 +239 @@
     case 3:
       {
-        //////////////////////////////////////////////////////////////////////////////////////////////////////
-        /////////// keeps shape-with scalar multiplication - version 2.
-        //////////////////////////////////////////////////////////////////////////////////////////////////////
-
-        //old vector from one to the other node - a
-        XY a_v(moved_node_1.x-fix_node.x,moved_node_1.y-fix_node.y);
-        //new vector from one to the other node - b
-        XY b_v(moved_node_2.x-fix_node.x,moved_node_2.y-fix_node.y);
-
-        double absa=sqrt(a_v.normSquare());
-        double absb=sqrt(b_v.normSquare());
-
-        if ((absa == 0.0) || (absb == 0.0))
-          {
-            return old_arrow_pos;
-          }
-        else
-          {
-            //old vector from one node to the breakpoint - c
-            XY c_v(old_arrow_pos.x-fix_node.x,old_arrow_pos.y-fix_node.y);
-
-            //unit vector with the same direction to a_v
-            XY a_v_u(a_v.x/absa,a_v.y/absa);
-
-            //normal vector of unit vector with the same direction to a_v
-            XY a_v_u_n(((-1)*a_v_u.y),a_v_u.x);
-
-            //unit vector with the same direction to b_v
-            XY b_v_u(b_v.x/absb,b_v.y/absb);
-
-            //normal vector of unit vector with the same direction to b_v
-            XY b_v_u_n(((-1)*b_v_u.y),b_v_u.x);
-
-            //vector c in a_v_u and a_v_u_n co-ordinate system
-            XY c_a(c_v*a_v_u,c_v*a_v_u_n);
-
-            //new vector from one node to the breakpoint - d - we have to calculate this one
-            XY d_v=absb/absa*(c_a.x*b_v_u+c_a.y*b_v_u_n);
-
-            return XY(d_v.x+fix_node.x,d_v.y+fix_node.y);
-          }
-        break;
+        //////////////////////////////////////////////////////////////////////////////////////////////////////
+        /////////// keeps shape-with scalar multiplication - version 2.
+        //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+        //old vector from one to the other node - a
+        XY a_v(moved_node_1.x-fix_node.x,moved_node_1.y-fix_node.y);
+        //new vector from one to the other node - b
+        XY b_v(moved_node_2.x-fix_node.x,moved_node_2.y-fix_node.y);
+
+        double absa=sqrt(a_v.normSquare());
+        double absb=sqrt(b_v.normSquare());
+
+        if ((absa == 0.0) || (absb == 0.0))
+        {
+          return old_arrow_pos;
+        }
+        else
+        {
+          //old vector from one node to the breakpoint - c
+          XY c_v(old_arrow_pos.x-fix_node.x,old_arrow_pos.y-fix_node.y);
+
+          //unit vector with the same direction to a_v
+          XY a_v_u(a_v.x/absa,a_v.y/absa);
+
+          //normal vector of unit vector with the same direction to a_v
+          XY a_v_u_n(((-1)*a_v_u.y),a_v_u.x);
+
+          //unit vector with the same direction to b_v
+          XY b_v_u(b_v.x/absb,b_v.y/absb);
+
+          //normal vector of unit vector with the same direction to b_v
+          XY b_v_u_n(((-1)*b_v_u.y),b_v_u.x);
+
+          //vector c in a_v_u and a_v_u_n co-ordinate system
+          XY c_a(c_v*a_v_u,c_v*a_v_u_n);
+
+          //new vector from one node to the breakpoint - d - we have to calculate this one
+          XY d_v=absb/absa*(c_a.x*b_v_u+c_a.y*b_v_u_n);
+
+          return XY(d_v.x+fix_node.x,d_v.y+fix_node.y);
+        }
+        break;
       }
     default:
       break;
-    }
+  }
 }
 
@@ -288 +290 @@
 bool GraphDisplayerCanvas::createNodeEventHandler(GdkEvent* e)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   switch(e->type)
   {
@@ -302 +306 @@
 
     case GDK_BUTTON_RELEASE:
-      (mytab.mapstorage)->modified = true;
+      ms.setModified();
 
       is_drawn=true;
@@ -308 +312 @@
       isbutton=1;
 
-      active_node=(mytab.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
-      (mytab.mapstorage)->coords.set(active_node, XY(clicked_x, clicked_y));
-
-      // update all other maps
-      for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-          (mytab.mapstorage)->nodemap_storage.begin(); it !=
-          (mytab.mapstorage)->nodemap_storage.end(); ++it)
-      {
-        if ((it->first != "coordinates_x") &&
-            (it->first != "coordinates_y"))
-        {
-          (*(it->second))[active_node] =
-            (mytab.mapstorage)->nodemap_default[it->first];
-        }
-      }
-      // increment the id map's default value
-      (mytab.mapstorage)->nodemap_default["label"] += 1.0;
+      active_node = ms.addNode(XY(clicked_x, clicked_y));
 
       nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph,
@@ -349 +333 @@
       nodetextmap[active_node]->raise_to_top();
 
-//       mapwin.updateNode(active_node);
+      //       mapwin.updateNode(active_node);
       propertyUpdate(active_node);
 
@@ -365 +349 @@
 bool GraphDisplayerCanvas::createEdgeEventHandler(GdkEvent* e)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   switch(e->type)
   {
@@ -380 +366 @@
           active_item=(get_item_at(clicked_x, clicked_y));
           active_node=INVALID;
-          for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+          for (NodeIt i(ms.graph); i!=INVALID; ++i)
           {
             if(nodesmap[i]==active_item)
@@ -409 +395 @@
           target_item=(get_item_at(clicked_x, clicked_y));
           Node target_node=INVALID;
-          for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+          for (NodeIt i(ms.graph); i!=INVALID; ++i)
           {
             if(nodesmap[i]==target_item)
@@ -419 +405 @@
           if(target_node!=INVALID)
           {
-            (mytab.mapstorage)->modified = true;
+            ms.setModified();
 
             *(nodesmap[target_node]) <<
               Gnome::Canvas::Properties::fill_color("red");
 
-            //creating new edge
-            active_edge=(mytab.mapstorage)->graph.addEdge(active_node,
-                target_node);
-
-            // update maps
-            for (std::map<std::string,
-                Graph::EdgeMap<double>*>::const_iterator it =
-                (mytab.mapstorage)->edgemap_storage.begin(); it !=
-                (mytab.mapstorage)->edgemap_storage.end(); ++it)
-            {
-              (*(it->second))[active_edge] =
-                (mytab.mapstorage)->edgemap_default[it->first];
-            }
-            // increment the id map's default value
-            (mytab.mapstorage)->edgemap_default["label"] += 1.0;
+            active_edge = ms.addEdge(active_node, target_node);
 
             if(target_node!=active_node)                
             {
-              // set the coordinates of the arrow on the new edge
-              MapStorage& ms = *mytab.mapstorage;
-              ms.arrow_pos.set(active_edge,
-                  (ms.coords[ms.graph.source(active_edge)] +
-                   ms.coords[ms.graph.target(active_edge)])/ 2.0);
-
-              //drawing new edge
-              edgesmap[active_edge]=new BrokenEdge(displayed_graph, active_edge,
-                  *this);
+              edgesmap[active_edge]=new BrokenEdge(displayed_graph, active_edge, *this);
             }
             else
             {
-              // set the coordinates of the arrow on the new edge
-              MapStorage& ms = *mytab.mapstorage;
-              ms.arrow_pos.set(active_edge,
-                  (ms.coords[ms.graph.source(active_edge)] +
-                   XY(0.0, 80.0)));
-
-              //drawing new edge
-              edgesmap[active_edge]=new LoopEdge(displayed_graph, active_edge,
-                  *this);
+              edgesmap[active_edge]=new LoopEdge(displayed_graph, active_edge, *this);
             }
 
             //initializing edge-text as well, to empty string
-            XY text_pos=mytab.mapstorage->arrow_pos[active_edge];
+            XY text_pos=ms.getArrowCoords(active_edge);
             text_pos+=(XY(10,10));
 
@@ -495 +451 @@
         if(active_item)
         {
-          propertyUpdate(active_node,N_COLOR);
+          propertyUpdate(active_node,N_COLOR);
           active_item=NULL;
         }
         if(target_item)
         {
-          propertyUpdate((mytab.mapstorage)->graph.target(active_edge),N_COLOR);
+          propertyUpdate(ms.graph.target(active_edge),N_COLOR);
           target_item=NULL;
         }
@@ -515 +471 @@
 bool GraphDisplayerCanvas::eraserEventHandler(GdkEvent* e)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   switch(e->type)
-    {
+  {
     case GDK_BUTTON_PRESS:
       //finding the clicked items
@@ -524 +482 @@
       active_edge=INVALID;
       //was it a node?
-      for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-        {
-          if(nodesmap[i]==active_item)
-            {
-              active_node=i;
-            }
-        }
+      for (NodeIt i(ms.graph); i!=INVALID; ++i)
+      {
+        if(nodesmap[i]==active_item)
+        {
+          active_node=i;
+        }
+      }
       //or was it an edge?
       if(active_node==INVALID)
-        {
-          for (EdgeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-            {
-              if(edgesmap[i]->getLine()==active_item)
-                {
-                  active_edge=i;
-                }
-            }
-        }
+      {
+        for (EdgeIt i(ms.graph); i!=INVALID; ++i)
+        {
+          if(edgesmap[i]->getLine()==active_item)
+          {
+            active_edge=i;
+          }
+        }
+      }
 
       // return if the clicked object is neither an edge nor a node
       if (active_edge == INVALID) return false;
-      
+
       //recolor activated item
       if(active_item)
-        {
-          *active_item << Gnome::Canvas::Properties::fill_color("red");
-        }
+      {
+        *active_item << Gnome::Canvas::Properties::fill_color("red");
+      }
       break;
 
@@ -556 +514 @@
       window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
       if(active_item)
-        {
-          //the cursor was not moved since pressing it
-          if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
-            {
-              //a node was found
-              if(active_node!=INVALID)
-                {
-                  (mytab.mapstorage)->modified = true;
-
-                  std::set<Graph::Edge> edges_to_delete;
-
-                  for(OutEdgeIt e((mytab.mapstorage)->graph,active_node);e!=INVALID;++e)
-                    {
-                      edges_to_delete.insert(e);
-                    }
-                  
-                  for(InEdgeIt e((mytab.mapstorage)->graph,active_node);e!=INVALID;++e)
-                    {
-                      edges_to_delete.insert(e);
-                    }
-                  
-                  //deleting collected edges
-                  for(std::set<Graph::Edge>::iterator
-                        edge_set_it=edges_to_delete.begin();
-                      edge_set_it!=edges_to_delete.end();
-                      ++edge_set_it)
-                    {
-                      deleteItem(*edge_set_it);
-                    }
-                  deleteItem(active_node);
-                }
-              //a simple edge was chosen
-              else if (active_edge != INVALID)
-                {
-                  deleteItem(active_edge);
-                }
-            }
-          //pointer was moved, deletion is cancelled
-          else
-            {
-              if(active_node!=INVALID)
-                {
-                  *active_item << Gnome::Canvas::Properties::fill_color("blue");
-                }
-              else if (active_edge != INVALID)
-                {
-                  *active_item << Gnome::Canvas::Properties::fill_color("green");
-                }
-            }
-        }
+      {
+        //the cursor was not moved since pressing it
+        if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
+        {
+          //a node was found
+          if(active_node!=INVALID)
+          {
+            ms.setModified();
+
+            std::set<Graph::Edge> edges_to_delete;
+
+            for(OutEdgeIt e(ms.graph,active_node);e!=INVALID;++e)
+            {
+              edges_to_delete.insert(e);
+            }
+
+            for(InEdgeIt e(ms.graph,active_node);e!=INVALID;++e)
+            {
+              edges_to_delete.insert(e);
+            }
+
+            //deleting collected edges
+            for(std::set<Graph::Edge>::iterator
+                edge_set_it=edges_to_delete.begin();
+                edge_set_it!=edges_to_delete.end();
+                ++edge_set_it)
+            {
+              deleteItem(*edge_set_it);
+            }
+            deleteItem(active_node);
+          }
+          //a simple edge was chosen
+          else if (active_edge != INVALID)
+          {
+            deleteItem(active_edge);
+          }
+        }
+        //pointer was moved, deletion is cancelled
+        else
+        {
+          if(active_node!=INVALID)
+          {
+            *active_item << Gnome::Canvas::Properties::fill_color("blue");
+          }
+          else if (active_edge != INVALID)
+          {
+            *active_item << Gnome::Canvas::Properties::fill_color("green");
+          }
+        }
+      }
       //reseting datas
       active_item=NULL;
@@ -617 +575 @@
     default:
       break;
-    }
+  }
   return false;
 }
@@ -623 +581 @@
 bool GraphDisplayerCanvas::mapEditEventHandler(GdkEvent* e)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   if(actual_tool==MAP_EDIT)
-    {
-      switch(e->type)
-        {
-        case GDK_BUTTON_PRESS:
-          {
-            //for determine, whether it was an edge
-            Edge clicked_edge=INVALID;
-            //for determine, whether it was a node
-            Node clicked_node=INVALID;
-
-            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 text of nodes
-            for (NodeIt i((mytab.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((mytab.mapstorage)->graph); i!=INVALID; ++i)
-                  {
-                    //at the same time only one can be active
-                    if(nodesmap[i]==active_item)
-                      {
-                        clicked_node=i;
-                      }
-                  }
-              }
-
-            if(clicked_node==INVALID)
-              {
-                //find the activated item between texts
-                for (EdgeIt i((mytab.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((mytab.mapstorage)->graph); i!=INVALID; ++i)
-                      {
-                        //at the same time only one can be active
-                        if((edgesmap[i]->getLine())==active_item)
-                          {
-                            clicked_edge=i;
-                          }
-                      }
-                  }
-              }
-
-            //if it was really a node...
-            if(clicked_node!=INVALID)
-              {
-                // the id map is not editable
-                if (nodemap_to_edit == "label") return 0;
-
-                //and there is activated map
-                if(nodetextmap[clicked_node]->property_text().get_value()!="")
-                  {
-                    //activate the general variable for it
-                    active_node=clicked_node;
-
-                    //create a dialog
-                    Gtk::Dialog dialog("Edit value", 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);
-                    spin.set_range(-1000000.0, 1000000.0);
-                    spin.set_numeric(true);
-                    spin.set_value(atof(nodetextmap[active_node]->property_text().get_value().c_str()));
-                    vbox->add(spin);
-                    spin.show();
-                    switch (dialog.run())
-                      {
-                      case Gtk::RESPONSE_NONE:
-                      case Gtk::RESPONSE_CANCEL:
-                        break;
-                      case Gtk::RESPONSE_ACCEPT:
-                        double new_value = spin.get_value();
-                        (*(mytab.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));
-                        propertyUpdate(Node(INVALID));
-                      }
-                  }
-              }
-            else
-              //if it was really an edge...
-              if(clicked_edge!=INVALID)
-                {
-                  // the id map is not editable
-                  if (edgemap_to_edit == "label") return 0;
-
-                  //and there is activated map
-                  if(edgetextmap[clicked_edge]->property_text().get_value()!="")
-                    {
-                      //activate the general variable for it
-                      active_edge=clicked_edge;
-
-                      //create a dialog
-                      Gtk::Dialog dialog("Edit value", 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);
-                      spin.set_range(-1000000.0, 1000000.0);
-                      spin.set_numeric(true);
-                      spin.set_value(atof(edgetextmap[active_edge]->property_text().get_value().c_str()));
-                      vbox->add(spin);
-                      spin.show();
-                      switch (dialog.run())
-                        {
-                        case Gtk::RESPONSE_NONE:
-                        case Gtk::RESPONSE_CANCEL:
-                          break;
-                        case Gtk::RESPONSE_ACCEPT:
-                          double new_value = spin.get_value();
-                          (*(mytab.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));
-                          propertyUpdate(Edge(INVALID));
-                        }
-                    }
-                }
-            break;
-          }
-        default:
-          break;
-        }
-    }
+  {
+    switch(e->type)
+    {
+      case GDK_BUTTON_PRESS:
+        {
+          //for determine, whether it was an edge
+          Edge clicked_edge=INVALID;
+          //for determine, whether it was a node
+          Node clicked_node=INVALID;
+
+          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 text of nodes
+          for (NodeIt i(ms.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(ms.graph); i!=INVALID; ++i)
+            {
+              //at the same time only one can be active
+              if(nodesmap[i]==active_item)
+              {
+                clicked_node=i;
+              }
+            }
+          }
+
+          if(clicked_node==INVALID)
+          {
+            //find the activated item between texts
+            for (EdgeIt i(ms.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(ms.graph); i!=INVALID; ++i)
+              {
+                //at the same time only one can be active
+                if((edgesmap[i]->getLine())==active_item)
+                {
+                  clicked_edge=i;
+                }
+              }
+            }
+          }
+
+          //if it was really a node...
+          if(clicked_node!=INVALID)
+          {
+            // the id map is not editable
+            if (nodemap_to_edit == "label") return 0;
+
+            //and there is activated map
+            if(nodetextmap[clicked_node]->property_text().get_value()!="")
+            {
+              //activate the general variable for it
+              active_node=clicked_node;
+
+              //create a dialog
+              Gtk::Dialog dialog("Edit value", 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);
+              spin.set_range(-1000000.0, 1000000.0);
+              spin.set_numeric(true);
+              spin.set_value(atof(nodetextmap[active_node]->property_text().get_value().c_str()));
+              vbox->add(spin);
+              spin.show();
+              */
+              Gtk::Entry entry;
+              entry.set_text(nodetextmap[active_node]->property_text().get_value());
+              vbox->add(entry);
+              entry.show();
+
+              switch (dialog.run())
+              {
+                case Gtk::RESPONSE_NONE:
+                case Gtk::RESPONSE_CANCEL:
+                  break;
+                case Gtk::RESPONSE_ACCEPT:
+                  switch (ms.getNodeMapElementType(nodemap_to_edit))
+                  {
+                    case MapValue::NUMERIC:
+                      ms.set(nodemap_to_edit, active_node,
+                          atof(entry.get_text().c_str()));
+                      break;
+                    case MapValue::STRING:
+                      ms.set(nodemap_to_edit, active_node,
+                          static_cast<std::string>(entry.get_text()));
+                      break;
+                  }
+                  nodetextmap[active_node]->property_text().set_value(
+                      static_cast<std::string>(ms.get(nodemap_to_edit, active_node)));
+
+                  //mapwin.updateNode(active_node);
+                  //mapwin.updateNode(Node(INVALID));
+                  propertyUpdate(Node(INVALID));
+              }
+            }
+          }
+          else
+            //if it was really an edge...
+            if(clicked_edge!=INVALID)
+            {
+              // the id map is not editable
+              if (edgemap_to_edit == "label") return 0;
+
+              //and there is activated map
+              if(edgetextmap[clicked_edge]->property_text().get_value()!="")
+              {
+                //activate the general variable for it
+                active_edge=clicked_edge;
+
+                //create a dialog
+                Gtk::Dialog dialog("Edit value", 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);
+                spin.set_range(-1000000.0, 1000000.0);
+                spin.set_numeric(true);
+                spin.set_value(atof(edgetextmap[active_edge]->property_text().get_value().c_str()));
+                vbox->add(spin);
+                spin.show();
+                */
+                Gtk::Entry entry;
+                entry.set_text(edgetextmap[active_edge]->property_text().get_value());
+                vbox->add(entry);
+                entry.show();
+
+                std::cout << edgemap_to_edit << std::endl;
+                switch (dialog.run())
+                {
+                  case Gtk::RESPONSE_NONE:
+                  case Gtk::RESPONSE_CANCEL:
+                    break;
+                  case Gtk::RESPONSE_ACCEPT:
+                    switch (ms.getEdgeMapElementType(edgemap_to_edit))
+                    {
+                      case MapValue::NUMERIC:
+                        ms.set(edgemap_to_edit, active_edge,
+                            atof(entry.get_text().c_str()));
+                        break;
+                      case MapValue::STRING:
+                        ms.set(edgemap_to_edit, active_edge,
+                            static_cast<std::string>(entry.get_text()));
+                        break;
+                    }
+                    edgetextmap[active_edge]->property_text().set_value(
+                        static_cast<std::string>(ms.get(edgemap_to_edit, active_edge)));
+
+                    //mapwin.updateEdge(active_edge);
+                    //                   mapwin.updateEdge(Edge(INVALID));
+                    propertyUpdate(Edge(INVALID));
+                }
+              }
+            }
+          break;
+        }
+      default:
+        break;
+    }
+  }
   return false;  
 }
@@ -785 +777 @@
   delete(nodetextmap[node_to_delete]);
   delete(nodesmap[node_to_delete]);
-  (mytab.mapstorage)->graph.erase(node_to_delete);
+  mytab.mapstorage->graph.erase(node_to_delete);
 }
 
@@ -792 +784 @@
   delete(edgetextmap[edge_to_delete]);
   delete(edgesmap[edge_to_delete]);
-  (mytab.mapstorage)->graph.erase(edge_to_delete);
+  mytab.mapstorage->graph.erase(edge_to_delete);
 }
 
@@ -812 +804 @@
     else
     {
-      for (EdgeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+      for (EdgeIt i(mytab.mapstorage->graph); i!=INVALID; ++i)
       {
         if(edgesmap[i]==active_bre)
@@ -822 +814 @@
   }
   else
-    {
-      if(forming_edge!=INVALID)
-        {
-          forming_edge=INVALID;
-        }
-      else
-        {
-          std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
-        }
-    }
+  {
+    if(forming_edge!=INVALID)
+    {
+      forming_edge=INVALID;
+    }
+    else
+    {
+      std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
+    }
+  }
 }
 
 void GraphDisplayerCanvas::moveNode(double dx, double dy, Gnome::Canvas::Item * item, Node node)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   Gnome::Canvas::Item * moved_item=item;
   Node moved_node=node;
 
   if(item==NULL && node==INVALID)
-    {
-      moved_item=active_item;
-      moved_node=active_node;
-    }
+  {
+    moved_item=active_item;
+    moved_node=active_node;
+  }
   else
-    {
-      isbutton=1;
-    }
+  {
+    isbutton=1;
+  }
 
   //repositioning node and its text
@@ -854 +848 @@
 
   // the new coordinates of the centre of the node 
-  double coord_x = dx + (mytab.mapstorage)->coords[moved_node].x;
-  double coord_y = dy + (mytab.mapstorage)->coords[moved_node].y;
+  double coord_x = dx + ms.getNodeCoords(moved_node).x;
+  double coord_y = dy + ms.getNodeCoords(moved_node).y;
 
   // write back the new coordinates to the coords map
-  (mytab.mapstorage)->coords.set(moved_node, XY(coord_x, coord_y));
+  ms.setNodeCoords(moved_node, XY(coord_x, coord_y));
 
   //all the edges connected to the moved point has to be redrawn
-  for(OutEdgeIt ei((mytab.mapstorage)->graph,moved_node);ei!=INVALID;++ei)
-    {
+  for(OutEdgeIt ei(ms.graph,moved_node);ei!=INVALID;++ei)
+  {
+    XY arrow_pos;
+
+    if (ms.graph.source(ei) == ms.graph.target(ei))
+    {
+      arrow_pos = ms.getArrowCoords(ei) + XY(dx, dy);
+    }
+    else
+    {
+      XY moved_node_1(coord_x - dx, coord_y - dy);
+      XY moved_node_2(coord_x, coord_y);
+      Node target = ms.graph.target(ei);
+      XY fix_node = ms.getNodeCoords(target);
+      XY old_arrow_pos(ms.getArrowCoords(ei));
+
+      arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
+    }
+
+    ms.setArrowCoords(ei, arrow_pos);
+    edgesmap[ei]->draw();
+
+    //reposition of edgetext
+    XY text_pos=ms.getArrowCoords(ei);
+    text_pos+=(XY(10,10));
+    edgetextmap[ei]->property_x().set_value(text_pos.x);
+    edgetextmap[ei]->property_y().set_value(text_pos.y);
+  }
+
+  for(InEdgeIt ei(ms.graph,moved_node);ei!=INVALID;++ei)
+  {
+    if (ms.graph.source(ei) != ms.graph.target(ei))
+    {
+      XY moved_node_1(coord_x - dx, coord_y - dy);
+      XY moved_node_2(coord_x, coord_y);
+      Node source = ms.graph.source(ei);
+      XY fix_node = ms.getNodeCoords(source);
+      XY old_arrow_pos(ms.getArrowCoords(ei));
+
       XY arrow_pos;
-
-      if (mytab.mapstorage->graph.source(ei) == mytab.mapstorage->graph.target(ei))
-        {
-          arrow_pos = mytab.mapstorage->arrow_pos[ei] + XY(dx, dy);
-        }
-      else
-        {
-          XY moved_node_1(coord_x - dx, coord_y - dy);
-          XY moved_node_2(coord_x, coord_y);
-          Node target = mytab.mapstorage->graph.target(ei);
-          XY fix_node(mytab.mapstorage->coords[target].x,
-                      mytab.mapstorage->coords[target].y);
-          XY old_arrow_pos(mytab.mapstorage->arrow_pos[ei]);
-
-          arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
-        }
-
-      mytab.mapstorage->arrow_pos.set(ei, arrow_pos);
+      arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
+
+      ms.setArrowCoords(ei, arrow_pos);
       edgesmap[ei]->draw();
 
       //reposition of edgetext
-      XY text_pos=mytab.mapstorage->arrow_pos[ei];
+      XY text_pos=ms.getArrowCoords(ei);
       text_pos+=(XY(10,10));
       edgetextmap[ei]->property_x().set_value(text_pos.x);
       edgetextmap[ei]->property_y().set_value(text_pos.y);
     }
-
-  for(InEdgeIt ei((mytab.mapstorage)->graph,moved_node);ei!=INVALID;++ei)
-    {
-      if (mytab.mapstorage->graph.source(ei) != mytab.mapstorage->graph.target(ei))
-        {
-          XY moved_node_1(coord_x - dx, coord_y - dy);
-          XY moved_node_2(coord_x, coord_y);
-          Node source = mytab.mapstorage->graph.source(ei);
-          XY fix_node(mytab.mapstorage->coords[source].x,
-                      mytab.mapstorage->coords[source].y);
-          XY old_arrow_pos(mytab.mapstorage->arrow_pos[ei]);
-
-          XY arrow_pos;
-          arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
-
-          mytab.mapstorage->arrow_pos.set(ei, arrow_pos);
-          edgesmap[ei]->draw();
-
-          //reposition of edgetext
-          XY text_pos=mytab.mapstorage->arrow_pos[ei];
-          text_pos+=(XY(10,10));
-          edgetextmap[ei]->property_x().set_value(text_pos.x);
-          edgetextmap[ei]->property_y().set_value(text_pos.y);
-        }
-    }
+  }
 }
 
@@ -929 +921 @@
   //the actual value belongs to
   for (int i=0;i<=5;i++)
-    {
-      if(((double)i/6<pos)&&(pos<=(double(i+1)/6)))
-        {
-          phase=i;
-        }
-    }
+  {
+    if(((double)i/6<pos)&&(pos<=(double(i+1)/6)))
+    {
+      phase=i;
+    }
+  }
   if(phase<6)
-    {
-      //within its 1/6 long phase the relativ position
-      //determines the power of the color changed in
-      //that phase
-      //we normalize that to one, to be able to give percentage
-      //value for the function
-      double rel_pos=(pos-(phase/6.0))*6.0;
-
-      switch(phase)
-        {
-        case 0:
-          color.set_rgb_p (1, 0, 1-rel_pos);
-          break;
-        case 1:
-          color.set_rgb_p (1, rel_pos, 0);
-          break;
-        case 2:
-          color.set_rgb_p (1-rel_pos, 1, 0);
-          break;
-        case 3:
-          color.set_rgb_p (0, 1, rel_pos);
-          break;
-        case 4:
-          color.set_rgb_p (0, 1-rel_pos, 1);
-          break;
-        case 5:
-          color.set_rgb_p ((rel_pos/3.0), 0, 1);
-          break;
-        default:
-          std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
-        }
-    }
+  {
+    //within its 1/6 long phase the relativ position
+    //determines the power of the color changed in
+    //that phase
+    //we normalize that to one, to be able to give percentage
+    //value for the function
+    double rel_pos=(pos-(phase/6.0))*6.0;
+
+    switch(phase)
+    {
+      case 0:
+        color.set_rgb_p (1, 0, 1-rel_pos);
+        break;
+      case 1:
+        color.set_rgb_p (1, rel_pos, 0);
+        break;
+      case 2:
+        color.set_rgb_p (1-rel_pos, 1, 0);
+        break;
+      case 3:
+        color.set_rgb_p (0, 1, rel_pos);
+        break;
+      case 4:
+        color.set_rgb_p (0, 1-rel_pos, 1);
+        break;
+      case 5:
+        color.set_rgb_p ((rel_pos/3.0), 0, 1);
+        break;
+      default:
+        std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
+    }
+  }
   else
-    {
-      std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
-    }
+  {
+    std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
+  }
   return color;
 }

graph_displayer_canvas-node.cc

@@ -26 +26 @@
 int GraphDisplayerCanvas::changeNodeRadius (std::string mapname, Node node)
 {
-  Graph::NodeMap<double> * actual_map;
+  MapStorage& ms = *mytab.mapstorage;
+
   double min, max;
-  min=(mytab.mapstorage)->minOfNodeMap(mapname);
-  max=(mytab.mapstorage)->maxOfNodeMap(mapname);
-  actual_map=((mytab.mapstorage)->nodemap_storage)[mapname];
-
-  if(node==INVALID)
-    {
-      for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-        {
-          double v=fabs((*actual_map)[i]);
+
+  {
+    NodeIt n(ms.graph);
+    min = max = ms.get(mapname, n);
+    for (; n != INVALID; ++n)
+    {
+      if (static_cast<double>(ms.get(mapname, n)) > max)
+        max = ms.get(mapname, n);
+      if (static_cast<double>(ms.get(mapname, n)) < min)
+        min = ms.get(mapname, n);
+    }
+  }
+
+  if(node==INVALID)
+    {
+      for (NodeIt i(ms.graph); i!=INVALID; ++i)
+        {
+          double v=fabs(ms.get(mapname,i));
           int w;
           if(autoscale)
@@ -103 +113 @@
 int GraphDisplayerCanvas::resetNodeRadius (Node node)
 {
+  MapStorage& ms = *mytab.mapstorage;
+
   double min, max;
   min=node_property_defaults[N_RADIUS];
   max=node_property_defaults[N_RADIUS];
-  Graph::NodeMap<double> actual_map((mytab.mapstorage)->graph,node_property_defaults[N_RADIUS]);
+  Graph::NodeMap<double> actual_map(ms.graph,node_property_defaults[N_RADIUS]);
   
   if(node==INVALID)
     {
-      for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+      for (NodeIt i(ms.graph); i!=INVALID; ++i)
         {
           double v=fabs(actual_map[i]);
@@ -164 +176 @@
 int GraphDisplayerCanvas::changeNodeColor (std::string mapname, Node node)
 {  
+  MapStorage& ms = *mytab.mapstorage;
 
   //function maps the range of the maximum and
@@ -169 +182 @@
   //green in RGB
 
-  Graph::NodeMap<double> * actual_map;
-  actual_map=((mytab.mapstorage)->nodemap_storage)[mapname];
-
   double max, min;
 
-  max=(mytab.mapstorage)->maxOfNodeMap(mapname);
-  min=(mytab.mapstorage)->minOfNodeMap(mapname);
-
-  if(node==INVALID)
-    {
-
-      for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+  {
+    NodeIt n(ms.graph);
+    min = max = ms.get(mapname, n);
+    for (; n != INVALID; ++n)
+    {
+      if (static_cast<double>(ms.get(mapname, n)) > max)
+        max = ms.get(mapname, n);
+      if (static_cast<double>(ms.get(mapname, n)) < min)
+        min = ms.get(mapname, n);
+    }
+  }
+
+  if(node==INVALID)
+    {
+
+      for (NodeIt i(ms.graph); i!=INVALID; ++i)
         {
           Gdk::Color color;
 
-          double w=(*actual_map)[i];
+          double w=ms.get(mapname, i);
 
           if(max!=min)
@@ -202 +221 @@
       Gdk::Color color;
 
-      double w=(*actual_map)[node];
+      double w=ms.get(mapname, node);
 
       if(max!=min)
@@ -220 +239 @@
 int GraphDisplayerCanvas::resetNodeColor (Node node)
 {  
+  MapStorage& ms = *mytab.mapstorage;
 
   //function maps the range of the maximum and
@@ -225 +245 @@
   //green in RGB
 
-  Graph::NodeMap<double> actual_map((mytab.mapstorage)->graph,node_property_defaults[N_COLOR]);
+  Graph::NodeMap<double> actual_map(ms.graph,node_property_defaults[N_COLOR]);
 
   double max, min;
@@ -235 +255 @@
     {
 
-      for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+      for (NodeIt i(ms.graph); i!=INVALID; ++i)
         {
           Gdk::Color color;
@@ -275 +295 @@
 int GraphDisplayerCanvas::changeNodeText (std::string mapname, Node node)
 {
+  MapStorage& ms = *mytab.mapstorage;
 
   //the number in the map will be written on the node
@@ -281 +302 @@
   //that is the deleter map
 
-  Graph::NodeMap<double> * actual_map=NULL;
-  actual_map=((mytab.mapstorage)->nodemap_storage)[mapname];
-
-  if(node==INVALID)
-    {
-      for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+  if(node==INVALID)
+    {
+      for (NodeIt i(ms.graph); i!=INVALID; ++i)
         {
           nodemap_to_edit=mapname;
-          double number=(*actual_map)[i];
-
-          std::ostringstream ostr;
-          ostr << number;
-              
-          nodetextmap[i]->property_text().set_value(ostr.str());
-        }
-    }
-  else
-    {
-      double number=(*actual_map)[node];
-
-      std::ostringstream ostr;
-      ostr << number;
-              
-      nodetextmap[node]->property_text().set_value(ostr.str());
+
+          nodetextmap[i]->property_text().set_value(
+              static_cast<std::string>(ms.get(mapname, i)));
+        }
+    }
+  else
+    {
+      nodetextmap[node]->property_text().set_value(
+          static_cast<std::string>(ms.get(mapname, node)));
     }
   return 0;
@@ -311 +322 @@
 int GraphDisplayerCanvas::resetNodeText (Node node)
 {
+  MapStorage& ms = *mytab.mapstorage;
 
   //the number in the map will be written on the node
@@ -319 +331 @@
   if(node==INVALID)
     {
-      for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+      for (NodeIt i(ms.graph); i!=INVALID; ++i)
         {
           nodemap_to_edit="";

graph_displayer_canvas.cc

@@ -118 +118 @@
 
   if(is_drawn)
-    {
-      if(mapname!="")
-        {
-          if( ( ((mytab.mapstorage)->nodemap_storage).find(mapname) != ((mytab.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";
-            }
-        }
-    }
+  {
+    if(mapname!="")
+    {
+      std::vector<std::string> nodemaps = mytab.mapstorage->getNodeMapList();
+      bool found = false;
+      for (std::vector<std::string>::const_iterator it = nodemaps.begin();
+          it != nodemaps.end(); ++it)
+      {
+        if (*it == mapname)
+        {
+          found = true;
+          break;
+        }
+      }
+      if (found)
+      {
+        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";
+      }
+    }
+  }
 }
 
@@ -165 +176 @@
 
   if(is_drawn)
-    {
-      if(mapname!="")
-        {
-          if( ( ((mytab.mapstorage)->edgemap_storage).find(mapname) != ((mytab.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";
-            }
-        }
-    }
+  {
+    if(mapname!="")
+    {
+      std::vector<std::string> edgemaps = mytab.mapstorage->getEdgeMapList();
+      bool found = false;
+      for (std::vector<std::string>::const_iterator it = edgemaps.begin();
+          it != edgemaps.end(); ++it)
+      {
+        if (*it == mapname)
+        {
+          found = true;
+          break;
+        }
+      }
+      if (found)
+      {
+        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";
+      }
+    }
+  }
 }
 
@@ -222 +244 @@
     //initializing edge-text as well, to empty string
 
-    XY text_pos=mytab.mapstorage->arrow_pos[i];
+    XY text_pos=mytab.mapstorage->getArrowCoords(i);
     text_pos+=(XY(10,10));
 
@@ -239 +261 @@
     nodesmap[i]=new Gnome::Canvas::Ellipse(
         displayed_graph,
-        (mytab.mapstorage)->coords[i].x-20,
-        (mytab.mapstorage)->coords[i].y-20,
-        (mytab.mapstorage)->coords[i].x+20,
-        (mytab.mapstorage)->coords[i].y+20);
+        mytab.mapstorage->getNodeCoords(i).x-20,
+        mytab.mapstorage->getNodeCoords(i).y-20,
+        mytab.mapstorage->getNodeCoords(i).x+20,
+        mytab.mapstorage->getNodeCoords(i).y+20);
     *(nodesmap[i]) << Gnome::Canvas::Properties::fill_color("blue");
     *(nodesmap[i]) << Gnome::Canvas::Properties::outline_color("black");
@@ -250 +272 @@
 
     XY text_pos(
-        ((mytab.mapstorage)->coords[i].x+node_property_defaults[N_RADIUS]+5),
-        ((mytab.mapstorage)->coords[i].y+node_property_defaults[N_RADIUS]+5));
+        (mytab.mapstorage->getNodeCoords(i).x+node_property_defaults[N_RADIUS]+5),
+        (mytab.mapstorage->getNodeCoords(i).y+node_property_defaults[N_RADIUS]+5));
 
     nodetextmap[i]=new Gnome::Canvas::Text(displayed_graph,
@@ -326 +348 @@
 void GraphDisplayerCanvas::reDesignGraph()
 {
-  NodeIt firstnode((mytab.mapstorage)->graph);
+  MapStorage& ms = *mytab.mapstorage;
+  NodeIt firstnode(ms.graph);
   //is it not an empty graph?
   if(firstnode!=INVALID)
@@ -336 +359 @@
       if(!was_redesigned)
         {
-          NodeIt i((mytab.mapstorage)->graph);
+          NodeIt i(ms.graph);
 
           dim2::Point<double> init(init_vector_length*rnd(),
@@ -348 +371 @@
       int iterations;
 
-      (mytab.mapstorage)->get_design_data(attraction, propulsation, iterations);
+      ms.get_design_data(attraction, propulsation, iterations);
 
       //iteration counter
       for(int l=0;l<iterations;l++)
         {
-          Graph::NodeMap<double> x(mytab.mapstorage->graph);
-          Graph::NodeMap<double> y(mytab.mapstorage->graph);
+          Graph::NodeMap<double> x(ms.graph);
+          Graph::NodeMap<double> y(ms.graph);
           XYMap<Graph::NodeMap<double> > actual_forces;
           actual_forces.setXMap(x);
@@ -360 +383 @@
 
           //count actual force for each nodes
-          for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
+          for (NodeIt i(ms.graph); i!=INVALID; ++i)
             {
               //propulsation of nodes
-              for (NodeIt j((mytab.mapstorage)->graph); j!=INVALID; ++j)
+              for (NodeIt j(ms.graph); j!=INVALID; ++j)
                 {
                   if(i!=j)
                     {
                       lemon::dim2::Point<double> delta =
-                        ((mytab.mapstorage)->coords[i]-
-                         (mytab.mapstorage)->coords[j]);
+                        (ms.getNodeCoords(i)-
+                         ms.getNodeCoords(j));
 
                       const double length_sqr=std::max(delta.normSquare(),min_dist);
@@ -383 +406 @@
                     }
                 }
-              //attraction of nodes, to which actual node is bound
-              for(OutEdgeIt ei((mytab.mapstorage)->graph,i);ei!=INVALID;++ei)
+            //attraction of nodes, to which actual node is bound
+            for(OutEdgeIt ei(ms.graph,i);ei!=INVALID;++ei)
+              {
+                lemon::dim2::Point<double> delta =
+                  (ms.getNodeCoords(i)-
+                   ms.getNodeCoords(ms.graph.target(ei)));
+
+                //calculating attraction strength
+                //greater distance means greater strength
+                delta*=attraction;
+
+                actual_forces.set(i,actual_forces[i]-delta);
+              }
+                    for(InEdgeIt ei(ms.graph,i);ei!=INVALID;++ei)
+              {
+                lemon::dim2::Point<double> delta =
+                  (ms.getNodeCoords(i)-
+                   ms.getNodeCoords(ms.graph.source(ei)));
+
+                //calculating attraction strength
+                //greater distance means greater strength
+                delta*=attraction;
+
+                actual_forces.set(i,actual_forces[i]-delta);
+              }
+            }
+          for (NodeIt i(ms.graph); i!=INVALID; ++i)
+            {
+              if((ms.getNodeCoords(i).x)+actual_forces[i].x>max_coord)
                 {
-                  lemon::dim2::Point<double> delta =
-                    ((mytab.mapstorage)->coords[i]-
-                     (mytab.mapstorage)->coords[mytab.mapstorage->
-                                               graph.target(ei)]);
-                
-                  //calculating attraction strength
-                  //greater distance means greater strength
-                  delta*=attraction;
-                
-                  actual_forces.set(i,actual_forces[i]-delta);
+                  actual_forces[i].x=max_coord-(ms.getNodeCoords(i).x);
+                  std::cout << "Correction! " << ((ms.getNodeCoords(i).x)+actual_forces[i].x) << std::endl;
                 }
-              for(InEdgeIt ei((mytab.mapstorage)->graph,i);ei!=INVALID;++ei)
+              else if((ms.getNodeCoords(i).x)+actual_forces[i].x<(0-max_coord))
                 {
-                  lemon::dim2::Point<double> delta =
-                    ((mytab.mapstorage)->coords[i]-
-                     (mytab.mapstorage)->coords[mytab.mapstorage->
-                                               graph.source(ei)]);
-                
-                  //calculating attraction strength
-                  //greater distance means greater strength
-                  delta*=attraction;
-                
-                  actual_forces.set(i,actual_forces[i]-delta);
+                  actual_forces[i].x=0-max_coord-(ms.getNodeCoords(i).x);
+                  std::cout << "Correction! " << ((ms.getNodeCoords(i).x)+actual_forces[i].x) << std::endl;
                 }
-            }
-          for (NodeIt i((mytab.mapstorage)->graph); i!=INVALID; ++i)
-            {
-              if(((mytab.mapstorage)->coords[i].x)+actual_forces[i].x>max_coord)
+              if((ms.getNodeCoords(i).y)+actual_forces[i].y>max_coord)
                 {
-                  actual_forces[i].x=max_coord-((mytab.mapstorage)->coords[i].x);
-                  std::cout << "Correction! " << (((mytab.mapstorage)->coords[i].x)+actual_forces[i].x) << std::endl;
+                  actual_forces[i].y=max_coord-(ms.getNodeCoords(i).y);
+                  std::cout << "Correction! " << ((ms.getNodeCoords(i).y)+actual_forces[i].y) << std::endl;
                 }
-              else if(((mytab.mapstorage)->coords[i].x)+actual_forces[i].x<(0-max_coord))
+              else if((ms.getNodeCoords(i).y)+actual_forces[i].y<(0-max_coord))
                 {
-                  actual_forces[i].x=0-max_coord-((mytab.mapstorage)->coords[i].x);
-                  std::cout << "Correction! " << (((mytab.mapstorage)->coords[i].x)+actual_forces[i].x) << std::endl;
-                }
-              if(((mytab.mapstorage)->coords[i].y)+actual_forces[i].y>max_coord)
-                {
-                  actual_forces[i].y=max_coord-((mytab.mapstorage)->coords[i].y);
-                  std::cout << "Correction! " << (((mytab.mapstorage)->coords[i].y)+actual_forces[i].y) << std::endl;
-                }
-              else if(((mytab.mapstorage)->coords[i].y)+actual_forces[i].y<(0-max_coord))
-                {
-                  actual_forces[i].y=0-max_coord-((mytab.mapstorage)->coords[i].y);
-                  std::cout << "Correction! " << (((mytab.mapstorage)->coords[i].y)+actual_forces[i].y) << std::endl;
+                  actual_forces[i].y=0-max_coord-(ms.getNodeCoords(i).y);
+                  std::cout << "Correction! " << ((ms.getNodeCoords(i).y)+actual_forces[i].y) << std::endl;
                 }
               moveNode(actual_forces[i].x, actual_forces[i].y, nodesmap[i], i);

gui_reader.cc

@@ -21 +21 @@
 
 #include <xml.h>
+#include "io_helper.h"
 #include <lemon/dim2.h>
 #include <vector>
@@ -34 +35 @@
 void GuiReader::read(std::istream& is)
 {
+  using std::vector;
+  using std::string;
+  using std::pair;
+  using std::make_pair;
+  using std::string;
+  using std::map;
+
   XmlIo x(is);
-  std::map<int, XY > m;
-  x("arrow_pos", m);
 
-  if ((int)m.size() == countEdges(mapstorage->graph))
+  { x("main_node_map_names", gui_data.main_node_map_names); }
+  { x("gui_node_map_names", gui_data.gui_node_map_names); }
+
+  { x("node_map_types", gui_data.node_map_types); }
+
+  { x("main_edge_map_names", gui_data.main_edge_map_names); }
+  { x("gui_edge_map_names", gui_data.gui_edge_map_names); }
+
+  { x("edge_map_types", gui_data.edge_map_types); }
+
+  for (vector<string>::const_iterator it = gui_data.gui_node_map_names.begin();
+      it != gui_data.gui_node_map_names.end(); ++it)
+  {
+    MapValue::Type type = gui_data.node_map_types[*it];
+    switch (type)
     {
-      for (EdgeIt e(mapstorage->graph); e != INVALID; ++e)
-        {
-          int edgeid = (int)(*mapstorage->edgemap_storage["label"])[e];
-          mapstorage->arrow_pos.set(e, m[edgeid]);
-        }
-      mapstorage->ArrowPosReadOK();
+      case MapValue::NUMERIC:
+        {
+          map<int, double>* p_map_data =
+            new map<int, double>;
+          gui_data.numeric_node_maps[*it] = p_map_data;
+          { x(*it, *p_map_data); }
+        }
+        break;
+      case MapValue::STRING:
+        {
+          map<int, string>* p_map_data =
+            new map<int, string>;
+          gui_data.string_node_maps[*it] = p_map_data;
+          { x(*it, *p_map_data); }
+        }
+        break;
     }
-  
+  }
+
+  for (vector<string>::const_iterator it = gui_data.gui_edge_map_names.begin();
+      it != gui_data.gui_edge_map_names.end(); ++it)
+  {
+    MapValue::Type type = gui_data.edge_map_types[*it];
+    switch (type)
+    {
+      case MapValue::NUMERIC:
+        {
+          map<int, double>* p_map_data =
+            new map<int, double>;
+          gui_data.numeric_edge_maps[*it] = p_map_data;
+          { x(*it, *p_map_data); }
+        }
+        break;
+      case MapValue::STRING:
+        {
+          map<int, string>* p_map_data =
+            new map<int, string>;
+          gui_data.string_edge_maps[*it] = p_map_data;
+          { x(*it, *p_map_data); }
+        }
+        break;
+    }
+  }
+
+  {
+    std::string node_coords_save_dest;
+    { x("node_coords_save_dest", node_coords_save_dest); }
+    if (node_coords_save_dest == "gui_sect")
+    {
+      // read the node coorinates
+      gui_data.node_coords_save_dest = MapStorage::SpecMapSaveOpts::GUI_SECT;
+      { x("node_coord_map", gui_data.node_coord_map); }
+    }
+    else if (node_coords_save_dest == "nodeset_sect_1_map")
+    {
+      gui_data.node_coords_save_dest = MapStorage::SpecMapSaveOpts::NESET_SECT;
+      gui_data.node_coords_save_map_num = MapStorage::SpecMapSaveOpts::ONE_MAP;
+      { x("map_name", gui_data.node_coords_one_map_name); }
+    }
+    else if (node_coords_save_dest == "nodeset_sect_2_maps")
+    {
+      gui_data.node_coords_save_dest = MapStorage::SpecMapSaveOpts::NESET_SECT;
+      gui_data.node_coords_save_map_num = MapStorage::SpecMapSaveOpts::TWO_MAPS;
+      { x("map1_name", gui_data.node_coords_two_maps_1_name); }
+      { x("map2_name", gui_data.node_coords_two_maps_2_name); }
+    }
+  }
+
+  {
+    std::string arrow_coords_save_dest;
+    { x("arrow_coords_save_dest", arrow_coords_save_dest); }
+    if (arrow_coords_save_dest == "gui_sect")
+    {
+      // read the arrow coorinates
+      gui_data.arrow_coords_save_dest = MapStorage::SpecMapSaveOpts::GUI_SECT;
+      { x("arrow_coord_map", gui_data.arrow_coord_map); }
+    }
+    else if (arrow_coords_save_dest == "edgeset_sect_1_map")
+    {
+      gui_data.arrow_coords_save_dest = MapStorage::SpecMapSaveOpts::NESET_SECT;
+      gui_data.arrow_coords_save_map_num = MapStorage::SpecMapSaveOpts::ONE_MAP;
+      { x("map_name", gui_data.arrow_coords_one_map_name); }
+    }
+    else if (arrow_coords_save_dest == "edgeset_sect_2_maps")
+    {
+      gui_data.arrow_coords_save_dest = MapStorage::SpecMapSaveOpts::NESET_SECT;
+      gui_data.arrow_coords_save_map_num = MapStorage::SpecMapSaveOpts::TWO_MAPS;
+      { x("map1_name", gui_data.arrow_coords_two_maps_1_name); }
+      { x("map2_name", gui_data.arrow_coords_two_maps_2_name); }
+    }
+  }
+
+
+
   std::map<int, std::string> nm;
   x("active_nodemaps", nm);
 
   for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      mapstorage->changeActiveMap(false, i, nm[i]);
-    }
+  {
+    mapstorage->changeActiveMap(false, i, nm[i]);
+  }
 
   std::map<int, std::string> em;
   x("active_edgemaps", em);
   for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      mapstorage->changeActiveMap(true, i, em[i]);
-    }
+  {
+    mapstorage->changeActiveMap(true, i, em[i]);
+  }
 
   double attraction;
@@ -78 +184 @@
 }
 
-GuiReader::GuiReader(LemonReader& reader, MapStorage* ms) : Parent(reader), mapstorage(ms)
+GuiReader::GuiReader(LemonReader& reader, MapStorage* _mapstorage,
+    MapStorage::GUISectData& _gui_data) :
+  Parent(reader),
+  mapstorage(_mapstorage),
+  gui_data(_gui_data)
 {
 }

gui_reader.h

@@ -21 +21 @@
 #include <lemon/lemon_reader.h>
 
-class MapStorage;
+#include "mapstorage.h"
 
 using lemon::LemonReader;
@@ -29 +29 @@
   private:
     MapStorage* mapstorage;
+    MapStorage::GUISectData& gui_data;
   protected:
     virtual bool header(const std::string&);
@@ -34 +35 @@
   public:
     typedef LemonReader::SectionReader Parent;
-    GuiReader(LemonReader&, MapStorage*);
+    GuiReader(LemonReader&, MapStorage*, MapStorage::GUISectData&);
 };
 

gui_writer.cc

@@ -17 +17 @@
  */
 
-#include <xml.h>
+#include "gui_writer.h"
+#include "io_helper.h"
+#include "mapstorage.h"
+#include "xml.h"
 #include <lemon/dim2.h>
 #include <vector>
@@ -31 +34 @@
 void GuiWriter::write(std::ostream& os)
 {
+  using std::vector;
+  using std::string;
+  using std::map;
+  using std::string;
+
   XmlIo x(os);
-  std::map<int, XY > m;
-  for (EdgeIt e(mapstorage->graph); e != INVALID; ++e)
-  {
-    int edgeid = (int)(*(mapstorage->edgemap_storage["label"]))[e];
-    m[edgeid] = mapstorage->arrow_pos[e];
-  }
-  x("arrow_pos", m);
+
+  vector<string> all_node_map_names = mapstorage->getNodeMapList();
+  // name of the maps saved to the nodeset section
+  vector<string> main_node_map_names;
+  // name of the maps saved to the gui section
+  vector<string> gui_node_map_names;
+
+  for (vector<string>::const_iterator it = all_node_map_names.begin();
+      it != all_node_map_names.end(); ++it)
+  {
+    if (mapstorage->getNodeMapSaveDest(*it) == MapStorage::NESET_SECT)
+      main_node_map_names.push_back(*it);
+    else if (mapstorage->getNodeMapSaveDest(*it) == MapStorage::GUI_SECT)
+      gui_node_map_names.push_back(*it);
+  }
+
+  { x("main_node_map_names", main_node_map_names); }
+  { x("gui_node_map_names", gui_node_map_names); }
+
+  map<string, MapValue::Type> node_map_types;
+  for (vector<string>::const_iterator it = main_node_map_names.begin();
+      it != main_node_map_names.end(); ++it)
+  {
+    node_map_types[*it] = mapstorage->getNodeMapElementType(*it);
+  }
+  for (vector<string>::const_iterator it = gui_node_map_names.begin();
+      it != gui_node_map_names.end(); ++it)
+  {
+    node_map_types[*it] = mapstorage->getNodeMapElementType(*it);
+  }
+
+  { x("node_map_types", node_map_types); }
+
+
+  vector<string> all_edge_map_names = mapstorage->getEdgeMapList();
+  // name of the maps saved to the edgeset section
+  vector<string> main_edge_map_names;
+  // name of the maps saved to the gui section
+  vector<string> gui_edge_map_names;
+
+  for (vector<string>::const_iterator it = all_edge_map_names.begin();
+      it != all_edge_map_names.end(); ++it)
+  {
+    if (mapstorage->getEdgeMapSaveDest(*it) == MapStorage::NESET_SECT)
+      main_edge_map_names.push_back(*it);
+    if (mapstorage->getEdgeMapSaveDest(*it) == MapStorage::GUI_SECT)
+      gui_edge_map_names.push_back(*it);
+  }
+
+  { x("main_edge_map_names", main_edge_map_names); }
+  { x("gui_edge_map_names", gui_edge_map_names); }
+
+  map<string, MapValue::Type> edge_map_types;
+  for (vector<string>::const_iterator it = main_edge_map_names.begin();
+      it != main_edge_map_names.end(); ++it)
+  {
+    edge_map_types[*it] = mapstorage->getEdgeMapElementType(*it);
+  }
+  for (vector<string>::const_iterator it = gui_edge_map_names.begin();
+      it != gui_edge_map_names.end(); ++it)
+  {
+    edge_map_types[*it] = mapstorage->getEdgeMapElementType(*it);
+  }
+
+  { x("edge_map_types", edge_map_types); }
+
+  // write the gui node maps
+  for (vector<string>::const_iterator it = gui_node_map_names.begin();
+      it != gui_node_map_names.end(); ++it)
+  {
+    MapValue::Type type = mapstorage->getNodeMapElementType(*it);
+    const MapStorage::NodeLabelMap& labels = mapstorage->getNodeLabelMap();
+    switch (type)
+    {
+      case MapValue::NUMERIC:
+        {
+          std::map<int, double> map_data;
+          MapStorage::NumericNodeMap& map =
+            mapstorage->getNumericNodeMap(*it);
+          for (NodeIt n(mapstorage->getGraph()); n != INVALID; ++n)
+          {
+            map_data[labels[n]] = map[n];
+          }
+          { x(*it, map_data); }
+        }
+        break;
+      case MapValue::STRING:
+        {
+          std::map<int, std::string> map_data;
+          MapStorage::StringNodeMap& map =
+            mapstorage->getStringNodeMap(*it);
+          for (NodeIt n(mapstorage->getGraph()); n != INVALID; ++n)
+          {
+            map_data[labels[n]] = map[n];
+          }
+          { x(*it, map_data); }
+        }
+        break;
+    }
+  }
+
+  // write the gui edge maps
+  for (vector<string>::const_iterator it = gui_edge_map_names.begin();
+      it != gui_edge_map_names.end(); ++it)
+  {
+    MapValue::Type type = mapstorage->getEdgeMapElementType(*it);
+    const MapStorage::EdgeLabelMap& labels = mapstorage->getEdgeLabelMap();
+    switch (type)
+    {
+      case MapValue::NUMERIC:
+        {
+          std::map<int, double> map_data;
+          MapStorage::NumericEdgeMap& map =
+            mapstorage->getNumericEdgeMap(*it);
+          for (EdgeIt e(mapstorage->getGraph()); e != INVALID; ++e)
+          {
+            map_data[labels[e]] = map[e];
+          }
+          { x(*it, map_data); }
+        }
+        break;
+      case MapValue::STRING:
+        {
+          std::map<int, std::string> map_data;
+          MapStorage::StringEdgeMap& map =
+            mapstorage->getStringEdgeMap(*it);
+          for (EdgeIt e(mapstorage->getGraph()); e != INVALID; ++e)
+          {
+            map_data[labels[e]] = map[e];
+          }
+          { x(*it, map_data); }
+        }
+        break;
+    }
+  }
+
+  {
+    switch (mapstorage->getNodeCoordsSaveDest())
+    {
+      case MapStorage::SpecMapSaveOpts::GUI_SECT:
+        { x("node_coords_save_dest", string("gui_sect")); }
+        // write the node coorinates
+        {
+          const MapStorage::NodeLabelMap& labels =
+            mapstorage->getNodeLabelMap();
+          std::map<int, XY> node_coord_map;
+          MapStorage::NodeCoordMap& map = mapstorage->getNodeCoordMap();
+          for (NodeIt n(mapstorage->getGraph()); n != INVALID; ++n)
+          {
+            node_coord_map[labels[n]] = map[n];
+          }
+          { x("node_coord_map", node_coord_map); }
+        }
+        break;
+      case MapStorage::SpecMapSaveOpts::NESET_SECT:
+        switch (mapstorage->getNodeCoordsSaveMapNum())
+        {
+          case MapStorage::SpecMapSaveOpts::ONE_MAP:
+            { x("node_coords_save_dest", string("nodeset_sect_1_map")); }
+            { x("map_name", mapstorage->getNodeCoordsOneMapName()); }
+            break;
+          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
+            { x("node_coords_save_dest", string("nodeset_sect_2_maps")); }
+            { x("map1_name", mapstorage->getNodeCoordsTwoMaps1Name()); }
+            { x("map2_name", mapstorage->getNodeCoordsTwoMaps2Name()); }
+            break;
+        }
+        break;
+    }
+  }
+
+  {
+    switch (mapstorage->getArrowCoordsSaveDest())
+    {
+      case MapStorage::SpecMapSaveOpts::GUI_SECT:
+        { x("arrow_coords_save_dest", string("gui_sect")); }
+        // write the arrow coorinates
+        {
+          const MapStorage::EdgeLabelMap& labels =
+            mapstorage->getEdgeLabelMap();
+          std::map<int, XY> arrow_coord_map;
+          MapStorage::ArrowCoordMap& map = mapstorage->getArrowCoordMap();
+          for (EdgeIt e(mapstorage->getGraph()); e != INVALID; ++e)
+          {
+            arrow_coord_map[labels[e]] = map[e];
+          }
+          { x("arrow_coord_map", arrow_coord_map); }
+        }
+        break;
+      case MapStorage::SpecMapSaveOpts::NESET_SECT:
+        switch (mapstorage->getArrowCoordsSaveMapNum())
+        {
+          case MapStorage::SpecMapSaveOpts::ONE_MAP:
+            { x("arrow_coords_save_dest", string("edgeset_sect_1_map")); }
+            { x("map_name", mapstorage->getArrowCoordsOneMapName()); }
+            break;
+          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
+            { x("arrow_coords_save_dest", string("edgeset_sect_2_maps")); }
+            { x("map1_name", mapstorage->getArrowCoordsTwoMaps1Name()); }
+            { x("map2_name", mapstorage->getArrowCoordsTwoMaps2Name()); }
+            break;
+        }
+        break;
+    }
+  }
+
 
   std::map<int, std::string> nm;
@@ -45 +252 @@
       nm[i]=mapstorage->active_nodemaps[i];
     }
-  x("active_nodemaps", nm);
+  { x("active_nodemaps", nm); }
 
   std::map<int, std::string> em;
@@ -52 +259 @@
       em[i]=mapstorage->active_edgemaps[i];
     }
-  x("active_edgemaps", em);
+  { x("active_edgemaps", em); }
 
   double attraction;
@@ -60 +267 @@
   mapstorage->get_design_data(attraction, propulsation, iteration);
 
-  x("redesign-attraction", attraction);
-  x("redesign-propulsation", propulsation);
-  x("redesign-iteration", iteration);
+  { x("redesign-attraction", attraction); }
+  { x("redesign-propulsation", propulsation); }
+  { x("redesign-iteration", iteration); }
 }
 
-GuiWriter::GuiWriter(LemonWriter& writer, MapStorage* ms) : Parent(writer), mapstorage(ms)
+GuiWriter::GuiWriter(LemonWriter& writer, MapStorage* ms) :
+  Parent(writer),
+  mapstorage(ms)
 {
 }

kruskalbox.cc

@@ -34 +34 @@
 {
   if(
-     tabcbt.get_active_text()!="" &&
-     (edgemapcbts[INPUT])->get_active_text()!="" &&
-     (edgemapcbts[OUTPUT])->get_active_text()!=""
-     )
+      tabcbt.get_active_text()!="" &&
+      (edgemapcbts[INPUT])->get_active_text()!="" &&
+      (edgemapcbts[OUTPUT])->get_active_text()!=""
+    )
+  {
+
+    const Graph &g=mapstorage->getGraph();
+    std::string input_map_name = edgemapcbts[INPUT]->get_active_text();
+    Graph::EdgeMap<bool> outputmap(g);
+    const MapStorage::NumericEdgeMap& inputmap=
+      mapstorage->getNumericEdgeMap(input_map_name);
+    double res=kruskal(g, inputmap, outputmap);
+
+    for (EdgeIt i(g); i!=INVALID; ++i)
     {
+      if(outputmap[i])
+      {
+        mapstorage->set(edgemapcbts[OUTPUT]->get_active_text(), i, 1.0);
+      }
+      else
+      {
+        mapstorage->set(edgemapcbts[OUTPUT]->get_active_text(), i, 0.0);
+      }
+    }
 
-      const Graph &g=mapstorage->graph;
-      Graph::EdgeMap<double> * inputmap=
-        ((mapstorage->edgemap_storage)[(edgemapcbts[INPUT])->get_active_text()]);
-      Graph::EdgeMap<bool> outputmap(g);
-      double res=kruskal(g, *inputmap, outputmap);
+    std::ostringstream o;
+    o << "Result: " << res;
+    resultlabel.set_text(o.str());
 
-      for (EdgeIt i(g); i!=INVALID; ++i)
-        {
-          if(outputmap[i])
-            {
-              (*((mapstorage->edgemap_storage)[(edgemapcbts[OUTPUT])->
-                                               get_active_text()]))[i]=1;
-            }
-          else
-            {
-              (*((mapstorage->edgemap_storage)[(edgemapcbts[OUTPUT])->
-                                               get_active_text()]))[i]=0;
-            }
-        }
+    mapstorage->mapChanged(true, (edgemapcbts[OUTPUT])->get_active_text());
+    //   mapstorage->changeActiveMap(true, E_COLOR,
+    //                        (edgemapcbts[OUTPUT])->get_active_text());
+    //   mapstorage->changeActiveMap(true, E_TEXT,
+    //                        (edgemapcbts[INPUT])->get_active_text());
 
-      std::ostringstream o;
-      o << "Result: " << res;
-      resultlabel.set_text(o.str());
-
-      mapstorage->mapChanged(true, (edgemapcbts[OUTPUT])->get_active_text());
-      //   mapstorage->changeActiveMap(true, E_COLOR,
-      //                              (edgemapcbts[OUTPUT])->get_active_text());
-      //   mapstorage->changeActiveMap(true, E_TEXT,
-      //                              (edgemapcbts[INPUT])->get_active_text());
-  
-    }
+  }
 }
     
@@ -77 +76 @@
   std::vector<std::string> empty_vector;
 
-  addMapSelector("Edgecosts: ", true);
-  addMapSelector("Edges of tree here: ", true);
+  addMapSelector("Edgecosts: ", true, NUM);
+  addMapSelector("Edges of tree here: ", true, NUM);
 
   resultlabel.set_text("Result: algorithm is not run yet.");

main_win.cc

@@ -21 +21 @@
 #endif
 
-#include <main_win.h>
-#include <guipixbufs.h>
-#include <background_chooser_dialog.h>
+#include "main_win.h"
+#include "guipixbufs.h"
+#include "save_details_dialog.h"
+#include "background_chooser_dialog.h"
 
 #include <mapstorage.h>
@@ -115 +116 @@
   ag->add( Gtk::Action::create("FileSaveAs", Gtk::Stock::SAVE_AS),
       sigc::mem_fun(*this, &MainWin::saveFileAs));
+  ag->add( Gtk::Action::create("SaveDetails", _("Save _Details...")),
+           sigc::mem_fun(*this, &MainWin::createSaveDetailsDialog));
   ag->add( Gtk::Action::create("Close", Gtk::Stock::CLOSE),
       sigc::mem_fun(*this, &MainWin::closeTab));
@@ -161 +164 @@
       sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 4) );
 
-  ag->add( Gtk::Action::create("AddMap", Gtk::StockID("gd-newmap")),
+  ag->add( Gtk::Action::create("AddMap", Gtk::StockID("gd-newmap"), "New map"),
       sigc::mem_fun ( *this , &MainWin::createNewMapWin ) );
 
@@ -167 +170 @@
       sigc::mem_fun ( *this , &MainWin::reDesignGraph ) );
 
-  ag->add( Gtk::Action::create("Eps", Gtk::StockID("gd-eps")),
+  ag->add( Gtk::Action::create("Eps", Gtk::StockID("gd-eps"), "Export to EPS"),
       sigc::mem_fun ( *this , &MainWin::exportToEPS ) );
 
@@ -186 +189 @@
       "      <menuitem action='FileSave'/>"
       "      <menuitem action='FileSaveAs'/>"
+      "      <menuitem action='SaveDetails'/>"
       "      <menuitem action='Close'/>"
       "      <menuitem action='Quit'/>"
@@ -371 +375 @@
   if(active_tab!=-1)
     {
-      if (tabs[active_tab]->mapstorage->modified)
+      if (tabs[active_tab]->mapstorage->getModified())
         {
           Gtk::MessageDialog mdialog(_("<b>Save changes before closing?</b>"), true, 
@@ -629 +633 @@
 }
 
+void MainWin::createSaveDetailsDialog()
+{
+  SaveDetailsDialog dialog(tabs[active_tab]->mapstorage);
+  dialog.run();
+}
+
 void MainWin::exportToEPS()
 {

main_win.h

@@ -261 +261 @@
   virtual void reDesignGraph();
 
+  /// Pops up a SaveDetailsDialog.
+  void createSaveDetailsDialog();
+
   virtual void exportToEPS();
 

map_win.cc

@@ -32 +32 @@
 }
 
-MapWin::MapWin(const std::string& title, std::vector<std::string> eml, std::vector<std::string> nml, NoteBookTab & mw):mytab(mw)
+MapWin::MapWin(const std::string& title,
+    std::vector<std::string> n_eml,
+    std::vector<std::string> s_eml,
+    std::vector<std::string> n_nml,
+    std::vector<std::string> s_nml,
+    NoteBookTab & mw):mytab(mw)
 {
   set_title(title);
@@ -49 +54 @@
   for(int i=0;i<EDGE_PROPERTY_NUM;i++)
   {
-    e_combo_array[i]=new MapSelector(eml, mytab.getActiveEdgeMap(i), edge_property_strings[i], true);
+    switch (i)
+    {
+      case E_WIDTH:
+        e_combo_array[i]=new MapSelector(n_eml, s_eml,
+            mytab.getActiveEdgeMap(i), edge_property_strings[i],
+            true, true, NUM);
+        break;
+      case E_COLOR:
+        e_combo_array[i]=new MapSelector(n_eml, s_eml,
+            mytab.getActiveEdgeMap(i), edge_property_strings[i],
+            true, true, NUM);
+        break;
+      case E_TEXT:
+        e_combo_array[i]=new MapSelector(n_eml, s_eml,
+            mytab.getActiveEdgeMap(i), edge_property_strings[i],
+            true, true, ALL);
+        break;
+    }
 
     (*table).attach((*(e_combo_array[i])),0,1,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);
@@ -69 +91 @@
   for(int i=0;i<NODE_PROPERTY_NUM;i++)
   {
-    n_combo_array[i]=new MapSelector(nml, mytab.getActiveNodeMap(i), node_property_strings[i], false);
+    switch (i)
+    {
+      case N_RADIUS:
+        n_combo_array[i]=new MapSelector(n_nml, s_nml,
+            mytab.getActiveNodeMap(i), node_property_strings[i],
+            false, true, NUM);
+        break;
+      case N_COLOR:
+        n_combo_array[i]=new MapSelector(n_nml, s_nml,
+            mytab.getActiveNodeMap(i), node_property_strings[i],
+            false, true, NUM);
+        break;
+      case N_TEXT:
+        n_combo_array[i]=new MapSelector(n_nml, s_nml,
+            mytab.getActiveNodeMap(i), node_property_strings[i],
+            false, true, ALL);
+        break;
+    }
 
     (*table).attach((*(n_combo_array[i])),0,1,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);
@@ -83 +122 @@
   vbox.pack_start(*table);
 
+  update(n_eml, s_eml, n_nml, s_nml);
+
   show_all_children();
 
@@ -102 +143 @@
 }
 
-void MapWin::update(std::vector<std::string> eml, std::vector<std::string> nml)
+void MapWin::update(
+    std::vector<std::string> n_eml,
+    std::vector<std::string> s_eml,
+    std::vector<std::string> n_nml,
+    std::vector<std::string> s_nml)
 {
   for(int i=0;i<EDGE_PROPERTY_NUM;i++)
   {
-    e_combo_array[i]->update_list(eml);
+    e_combo_array[i]->update_list(n_eml, s_eml);
   }
 
   for(int i=0;i<NODE_PROPERTY_NUM;i++)
   {
-    n_combo_array[i]->update_list(nml);
+    n_combo_array[i]->update_list(n_nml, s_nml);
   }
 
@@ -117 +162 @@
 }
 
-void MapWin::registerNewEdgeMap(std::string newmapname)
+void MapWin::registerNewEdgeMap(std::string newmapname, MapValue::Type type)
 {
   for(int i=0;i<EDGE_PROPERTY_NUM;i++)
   {
     //filling in combo box with choices
-    e_combo_array[i]->append_text((Glib::ustring)newmapname);
-  }
-}
-
-void MapWin::registerNewNodeMap(std::string newmapname)
+    e_combo_array[i]->append_text((Glib::ustring)newmapname, type);
+  }
+}
+
+void MapWin::registerNewNodeMap(std::string newmapname, MapValue::Type type)
 {
   for(int i=0;i<NODE_PROPERTY_NUM;i++)
   {
     //filling in combo box with choices
-    n_combo_array[i]->append_text((Glib::ustring)newmapname);
+    n_combo_array[i]->append_text((Glib::ustring)newmapname, type);
   }
 }

map_win.h

@@ -26 +26 @@
 #include <libgnomecanvasmm.h>
 #include <libgnomecanvasmm/polygon.h>
+#include "map_value.h"
 
 ///Graph visualization setup window.
@@ -65 +66 @@
   ///binds the needed signal to the correct place.
   ///\param title title of window
-  ///\param eml edgemap list
-  ///\param nml nodemap list
   ///\param mw the owner \ref NoteBookTab (\ref mytab)
-  MapWin(const std::string& title, std::vector<std::string> eml, std::vector<std::string> nml, NoteBookTab & mw);
+  MapWin(const std::string& title, 
+      std::vector<std::string> n_eml,
+      std::vector<std::string> s_eml,
+      std::vector<std::string> n_nml,
+      std::vector<std::string> s_nml,
+      NoteBookTab & mw);
 
   ///Deregistrates \ref MapWin in its \ref NoteBookTab (\ref mytab)
@@ -107 +111 @@
   ///\param new_name
   ///name of new map
-  void registerNewEdgeMap(std::string new_name);
+  void registerNewEdgeMap(std::string new_name, MapValue::Type type);
 
   ///This function inserts name of the new nodemap in the name list in \ref MapSelector s
@@ -113 +117 @@
   ///\param new_name
   ///name of new map
-  void registerNewNodeMap(std::string new_name);
+  void registerNewNodeMap(std::string new_name, MapValue::Type type);
 
   ///Close window if Esc key pressed.
@@ -125 +129 @@
   ///has to call this function or not from the \ref NoteBookTab::mapwinexists
   ///variable.
-  ///\param eml edge map list
-  ///\param nml node map list
-  void update(std::vector<std::string> eml, std::vector<std::string> nml);
+  void update(
+    std::vector<std::string> n_eml,
+    std::vector<std::string> s_eml,
+    std::vector<std::string> n_nml,
+    std::vector<std::string> s_nml);
 
   void changeEntry(bool, int, std::string);

mapselector.cc

@@ -19 +19 @@
 #include <mapselector.h>
 
-MapSelector::MapSelector(std::vector<std::string> ml, std::string act, std::string labeltext, bool edge, bool d):def(d),itisedge(edge),set_new_map(false)
+MapSelector::MapSelector(std::vector<std::string> n_ml,
+    std::vector<std::string> s_ml, std::string act,
+    std::string labeltext, bool edge, bool d, MapType type) :
+  def(d),
+  itisedge(edge),
+  set_new_map(false),
+  label(labeltext),
+  map_type(type),
+  newbut(Gtk::Stock::NEW)
 {
-  update_list(ml);
+  update_list(n_ml, s_ml);
 
   if(act=="")
-    {
-      cbt.set_active(0);
-      default_state=true;
-    }
+  {
+    cbt.set_active(0);
+    default_state=true;
+  }
   else
-    {
-      cbt.set_active_text((Glib::ustring)act);
-      default_state=false;
-    }
+  {
+    cbt.set_active_text((Glib::ustring)act);
+    default_state=false;
+  }
 
   //binding signal to the actual entry
@@ -39 +47 @@
      sigc::mem_fun((*this), &MapSelector::comboChanged),
      false
-     );
-  
-  label=new Gtk::Label(labeltext);
+    );
 
-  label->set_width_chars(longest_property_string_length);
+  label.set_width_chars(longest_property_string_length);
 
-  defbut=NULL;
   if(def)
-    {
-      defbut=new Gtk::Button();
-      defbut->set_label("Reset");
-      
-      defbut->signal_pressed().connect
-        (
-         sigc::mem_fun(*this, &MapSelector::reset)
-         );
-    }
+  {
+    defbut.set_label("Reset");
+    defbut.signal_pressed().connect
+      (
+       sigc::mem_fun(*this, &MapSelector::reset)
+      );
+  }
 
-  newbut=new Gtk::Button(Gtk::Stock::NEW);
 
-  newbut->signal_pressed().connect
+  newbut.signal_pressed().connect
     (
      sigc::mem_fun(*this, &MapSelector::new_but_pressed)
-     );
+    );
 
-  add(*label);
+  add(label);
 
   add(cbt);
 
   if(def)
-    {
-      add(*defbut);
-    }
+  {
+    add(defbut);
+  }
 
-  add(*newbut);
+  add(newbut);
 }
 
@@ -82 +84 @@
 }
 
-void MapSelector::update_list( std::vector< std::string > ml )
+void MapSelector::update_list(std::vector<std::string> n_ml,
+    std::vector<std::string> s_ml)
 {
   int prev_act=cbt.get_active_row_number();
   cbt.clear();
   cbt_content.clear();
-  std::vector< std::string >::iterator emsi=ml.begin();
-  for(;emsi!=ml.end();emsi++)
+
+  if (map_type & NUM)
+  {
+    std::vector< std::string >::iterator emsi=n_ml.begin();
+    for(;emsi!=n_ml.end();emsi++)
     {
       cbt.append_text(*emsi);
       cbt_content.push_back(*emsi);
     }
+  }
+  if (map_type & STR)
+  {
+    std::vector< std::string >::iterator emsi=s_ml.begin();
+    for(;emsi!=s_ml.end();emsi++)
+    {
+      cbt.append_text(*emsi);
+      cbt_content.push_back(*emsi);
+    }
+  }
   if(def)
     {
@@ -148 +164 @@
 }
 
-void MapSelector::append_text(Glib::ustring text)
+void MapSelector::append_text(Glib::ustring text, MapValue::Type type)
 {
-  cbt.append_text(text);
-  cbt_content.push_back(text);
+  if (type & map_type)
+  {
+    cbt.append_text(text);
+    cbt_content.push_back(text);
 
-  if(set_new_map)
+    if(set_new_map)
     {
       set_active_text(text);
       set_new_map=false;
     }
+  }
 }
 

mapselector.h

@@ -23 +23 @@
 #include <libgnomecanvasmm.h>
 #include <libgnomecanvasmm/polygon.h>
+#include "map_value.h"
 
 ///A widget by which node and edgemaps can be selected, deselected and created.
@@ -81 +82 @@
   ///By pressing it
   ///\ref NewMapWin wilol pop-up
-  Gtk::Button * newbut;
+  Gtk::Button newbut;
 
   ///Reset button.
@@ -89 +90 @@
   ///
   ///It is visible only if \ref def is true.
-  Gtk::Button * defbut;
-
-  ///Container in which GUI elements are packed.
-  Gtk::HBox hbox;
+  Gtk::Button defbut;
 
   ///Shows purpose of \ref MapSelector piece.
-  Gtk::Label * label;
+  Gtk::Label label;
+
+  /// Which types of maps (integer, string, ...) to display.
+  MapType map_type;
 
  public:
@@ -102 +103 @@
 
   ///Creates the layout and binds signal to the correct place.
-  ///\param optionlist list of names to place in \ref cbt
+  ///\param mapstorage Pointer to the \ref MapStorage to get the map list from.
   ///\param act preselected option
   ///\param purpose text of label indicating purpose of \ref MapStorage
   ///\param itisedge do \ref MapSelector contains edgemap names or nodemapnames.
   ///\param def do we need 'Default' option. See \ref def.
-  MapSelector(std::vector<std::string> optionlist, std::string act, std::string purpose, bool itisedge, bool def=true);
+  ///\param type Specifies which types of maps to display.
+  MapSelector(std::vector<std::string> n_ml,
+      std::vector<std::string> s_ml, std::string act, std::string labeltext,
+      bool edge, bool d = true, MapType type = ALL);
 
   ///Returns signal emitted if the user has changed the selection. (\ref signal_cbt)
@@ -120 +124 @@
   ///into account that the previously selected option
   ///has to be set back after the operation.
-  void update_list( std::vector<std::string> );
+  void update_list(std::vector<std::string> n_ml,
+      std::vector<std::string> s_ml);
 
   ///Handles changement in \ref cbt.
@@ -169 +174 @@
   ///this function  will set \ref cbt to the new option.
   ///\param new_option new option to append
-  void append_text(Glib::ustring new_option);
+  void append_text(Glib::ustring new_option, MapValue::Type);
 };
 #endif //MAPSELECTOR_H

mapstorage.cc

@@ -8 +8 @@
  *
  * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
+ * provided that this copyright notice appears in all cop       ies. For
  * precise terms see the accompanying LICENSE file.
  *
@@ -17 +17 @@
  */
 
+#include "i18n.h"
 #include <limits>
 #include <cmath>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <algorithm>
 #include <gtkmm.h>
-
+#include "file_import_dialog.h"
 #include <mapstorage.h>
 #include <gui_writer.h>
@@ -30 +35 @@
 const double p_d=40000;
 
-MapStorage::MapStorage() : modified(false), file_name(""), arrow_pos_read_ok(false), iterations(i_d), attraction(a_d), propulsation(p_d), background_set(false)
-{
-  nodemap_storage["coordinates_x"] = new Graph::NodeMap<double>(graph);
-  coords.setXMap(*nodemap_storage["coordinates_x"]);
-  nodemap_storage["coordinates_y"] = new Graph::NodeMap<double>(graph);
-  coords.setYMap(*nodemap_storage["coordinates_y"]);
-
-  edgemap_storage["arrow_pos_x"] = new Graph::EdgeMap<double>(graph);
-  arrow_pos.setXMap(*edgemap_storage["arrow_pos_x"]);
-  edgemap_storage["arrow_pos_y"] = new Graph::EdgeMap<double>(graph);
-  arrow_pos.setYMap(*edgemap_storage["arrow_pos_y"]);
-
-  nodemap_storage["label"] = new Graph::NodeMap<double>(graph);
-  edgemap_storage["label"] = new Graph::EdgeMap<double>(graph);
-
-  nodemap_default["label"] = 1.0;
-  edgemap_default["label"] = 1.0;
+MapStorage::MapStorage() :
+  gui_sect_save_dest(LGF_FILE),
+  node_coords_save_dest(SpecMapSaveOpts::GUI_SECT),
+  arrow_coords_save_dest(SpecMapSaveOpts::GUI_SECT),
+  modified(false),
+  file_name(""),
+  max_node_label(0),
+  max_edge_label(0),
+  node_coords_one_map_name("coord"),
+  node_coords_two_maps_1_name("coord_x"),
+  node_coords_two_maps_2_name("coord_y"),
+  arrow_coords_one_map_name("arrow"),
+  arrow_coords_two_maps_1_name("arrow_x"),
+  arrow_coords_two_maps_2_name("arrow_y"),
+  iterations(i_d),
+  attraction(a_d),
+  propulsation(p_d),
+  node_coords_x(graph),
+  node_coords_y(graph),
+  arrow_coords_x(graph),
+  arrow_coords_y(graph),
+  node_label(graph),
+  edge_label(graph),
+  background_set(false)
+{
+  node_coords.setXMap(node_coords_x);
+  node_coords.setYMap(node_coords_y);
+  arrow_coords.setXMap(arrow_coords_x);
+  arrow_coords.setYMap(arrow_coords_y);
 
   active_nodemaps.resize(NODE_PROPERTY_NUM);
@@ -63 +80 @@
 MapStorage::~MapStorage()
 {
-  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
-  {
-    delete it->second;
-  }
-  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
-      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
-  {
-    delete it->second;
-  }
-}
-
-int MapStorage::addNodeMap(const std::string & name, Graph::NodeMap<double> *nodemap, double default_value)
-{
-  if( nodemap_storage.find(name) == nodemap_storage.end() )
-    {
-      nodemap_storage[name]=nodemap;
-      // set the maps default value
-      nodemap_default[name] = default_value;
-
-      //announce changement in maps
-      signal_node_map.emit(name);
-      return 0;
-    }
-  return 1;
+  clear();
+}
+
+void MapStorage::createNodeMap(const std::string& name, MapValue::Type type,
+    MapValue def_val)
+{
+  NodeMapStore::const_iterator it = nodemaps.find(name);
+  if (it != nodemaps.end())
+    throw Error("Node map " + name + " already exists.");
+
+  switch (type)
+  {
+    case MapValue::NUMERIC:
+      nodemaps[name] = new NumericNodeMapData(graph, def_val);
+      break;
+    case MapValue::STRING:
+      nodemaps[name] = new StringNodeMapData(graph, def_val);
+      break;
+  }
+
+  nodemaps[name]->default_value = def_val;
+
+  signal_node_map.emit(name, type);
+}
+
+void MapStorage::createEdgeMap(const std::string& name, MapValue::Type type,
+    MapValue def_val)
+{
+  EdgeMapStore::const_iterator it = edgemaps.find(name);
+  if (it != edgemaps.end())
+    throw Error("Edge map " + name + " already exists.");
+
+  switch (type)
+  {
+    case MapValue::NUMERIC:
+      edgemaps[name] = new NumericEdgeMapData(graph, def_val);
+      break;
+    case MapValue::STRING:
+      edgemaps[name] = new StringEdgeMapData(graph, def_val);
+      break;
+  }
+
+  edgemaps[name]->default_value = def_val;
+
+  signal_edge_map.emit(name, type);
 }
 
@@ -116 +153 @@
 }
 
-
 std::string MapStorage::getActiveEdgeMap(int prop)
 {
@@ -127 +163 @@
 }
 
-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;
+std::vector<std::string> MapStorage::getEdgeMapList(MapType type)
+{
+  if (type == ALL)
+  {
+    std::vector<std::string> ret;
+    for (EdgeMapStore::const_iterator it = edgemaps.begin();
+        it != edgemaps.end(); ++it)
+    {
+      ret.push_back(it->first);
+    }
+    return ret;
+  }
+  else
+  {
+    std::vector<std::string> ret;
+    for (EdgeMapStore::const_iterator it = edgemaps.begin();
+        it != edgemaps.end(); ++it)
+    {
+      EdgeMapData* data = getEdgeMapData(it->first);
+      MapValue::Type t = data->type();
+      if ((t == MapValue::NUMERIC && (type & NUM)) ||
+          (t == MapValue::STRING && (type & STR)))
+      {
+        ret.push_back(it->first);
+      }
+    }
+    return ret;
+  }
+}
+
+std::vector<std::string> MapStorage::getNodeMapList(MapType type)
+{
+  if (type == ALL)
+  {
+    std::vector<std::string> ret;
+    for (NodeMapStore::const_iterator it = nodemaps.begin();
+        it != nodemaps.end(); ++it)
+    {
+      ret.push_back(it->first);
+    }
+    return ret;
+  }
+  else
+  {
+    std::vector<std::string> ret;
+    for (NodeMapStore::const_iterator it = nodemaps.begin();
+        it != nodemaps.end(); ++it)
+    {
+      NodeMapData* data = getNodeMapData(it->first);
+      MapValue::Type t = data->type();
+      if ((t == MapValue::NUMERIC && (type & NUM)) ||
+          (t == MapValue::STRING && (type & STR)))
+      {
+        ret.push_back(it->first);
+      }
+    }
+    return ret;
+  }
 }
 
@@ -160 +228 @@
 }
 
-int MapStorage::addEdgeMap(const std::string & name, Graph::EdgeMap<double> *edgemap, double default_value)
-{
-  if( edgemap_storage.find(name) == edgemap_storage.end() )
-    {
-      edgemap_storage[name]=edgemap;
-      // set the maps default value
-      edgemap_default[name] = default_value;
-
-      //announce changement in maps
-      signal_edge_map.emit(name);
-      return 0;
-    }
-  return 1;
-}
-
-double MapStorage::maxOfNodeMap(const std::string & name)
-{
-  double max=0;
-  for (NodeIt j(graph); j!=INVALID; ++j)
-  {
-    if( (*nodemap_storage[name])[j]>max )
-    {
-      max=(*nodemap_storage[name])[j];
-    }
-  }
-  return max;
-}
-
-double MapStorage::maxOfEdgeMap(const std::string & name)
-{
-  double max=0;
-  for (EdgeIt j(graph); j!=INVALID; ++j)
-  {
-    if( (*edgemap_storage[name])[j]>max )
-    {
-      max=(*edgemap_storage[name])[j];
-    }
-  }
-  return max;
-}
-
-double MapStorage::minOfNodeMap(const std::string & name)
-{
-  NodeIt j(graph);
-  double min;
-  if(j!=INVALID)
-    {
-      min=(*nodemap_storage[name])[j];
-    }
+int MapStorage::readFromFile(const std::string &filename)
+{
+  using std::vector;
+  using std::map;
+  using std::string;
+
+  // check whether the .conf file exists
+  bool gui_data_in_conf = g_file_test((filename + ".conf").c_str(),
+      (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR));
+
+  // check whether the .lgf file contains a gui section
+  bool gui_data_in_lgf = false;
+  {
+    std::ifstream ifs(filename.c_str());
+    std::string line;
+    while (getline(ifs, line))
+    {
+      int pos = line.find("@gui");
+      if (pos != std::string::npos)
+      {
+        bool only_whitespace_before = true;
+        for (int i = 0; i < pos; ++i)
+        {
+          if (!std::isspace(line[i]))
+          {
+            only_whitespace_before = false;
+            break;
+          }
+        }
+        if (only_whitespace_before) gui_data_in_lgf = true;
+      }
+    }
+  }
+
+  bool gui_data_found = gui_data_in_lgf || gui_data_in_conf;
+
+  // ask for user input if both exist
+  bool use_gui_data_in_lgf = false;
+  if (gui_data_in_conf && gui_data_in_lgf)
+  {
+    Gtk::MessageDialog mdialog(_("<b>Found both ") + filename +
+        _(".conf and a gui section in ") + filename + _(".</b>"), true,
+        Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE);
+          mdialog.add_button(_("Use the ._conf file"), 1);
+          mdialog.add_button(_("Use the _gui section"), 2);
+    switch (mdialog.run())
+    {
+      case 1:
+        use_gui_data_in_lgf = false;
+        break;
+      case 2:
+        use_gui_data_in_lgf = true;
+        break;
+      case Gtk::RESPONSE_NONE:
+        return 1;
+    }
+  }
   else
-    {
-      min=0;
-    }
-  for (; j!=INVALID; ++j)
-  {
-    if( (*nodemap_storage[name])[j]<min )
-    {
-      min=(*nodemap_storage[name])[j];
-    }
-  }
-  return min;
-}
-
-double MapStorage::minOfEdgeMap(const std::string & name)
-{
-  EdgeIt j(graph);
-  double min;
-  if(j!=INVALID)
-    {
-      min=(*edgemap_storage[name])[j];
-    }
-  else
-    {
-      min=0;
-    }
-  for (EdgeIt j(graph); j!=INVALID; ++j)
-  {
-    if( (*edgemap_storage[name])[j]<min )
-    {
-      min=(*edgemap_storage[name])[j];
-    }
-  }
-  return min;
-}
-
-int MapStorage::readFromFile(const std::string &filename)
-{
-  bool read_x = false;
-  bool read_y = false;
-  bool read_edge_id = false;
-
-  try {
-    LemonReader lreader(filename);
-    ContentReader content(lreader);
-    lreader.run();
-
-    if (content.nodeSetNum() < 1)
-    {
-      Gtk::MessageDialog mdialog("No nodeset found in file.");
-      mdialog.run();
+  {
+    use_gui_data_in_lgf = gui_data_in_lgf;
+  }
+
+  if (gui_data_found)
+  {
+    GUISectData gui_data;
+    if (use_gui_data_in_lgf)
+    {
+      // read the gui section from the .lgf file
+      try
+      {
+        LemonReader lreader(filename);
+        GuiReader gui_reader(lreader, this, gui_data);
+        lreader.run();
+        gui_sect_save_dest = LGF_FILE;
+      }
+      catch (Exception& error)
+      {
+        clear();
+        return 1;
+      }
+    }
+    else
+    {
+      // read the gui section from the .conf file
+      try
+      {
+        LemonReader lreader(filename + ".conf");
+        GuiReader gui_reader(lreader, this, gui_data);
+        lreader.run();
+        gui_sect_save_dest = CONF_FILE;
+      }
+      catch (Exception& error)
+      {
+        clear();
+        return 1;
+      }
+    }
+
+    // read the graph and maps form the .lgf file
+    try
+    {
+      std::string node_coord_xmap_name, node_coord_ymap_name;
+      std::string arrow_coord_xmap_name, arrow_coord_ymap_name;
+
+      if (gui_data.node_coords_save_dest ==
+          MapStorage::SpecMapSaveOpts::NESET_SECT)
+      {
+        switch (gui_data.node_coords_save_map_num)
+        {
+          case SpecMapSaveOpts::ONE_MAP:
+            node_coord_xmap_name = gui_data.node_coords_one_map_name + ":x";
+            node_coord_ymap_name = gui_data.node_coords_one_map_name + ":y";
+            node_coords_one_map_name = gui_data.node_coords_one_map_name;
+            break;
+          case SpecMapSaveOpts::TWO_MAPS:
+            node_coord_xmap_name = gui_data.node_coords_two_maps_1_name;
+            node_coord_ymap_name = gui_data.node_coords_two_maps_2_name;
+            node_coords_two_maps_1_name = gui_data.node_coords_two_maps_1_name;
+            node_coords_two_maps_2_name = gui_data.node_coords_two_maps_2_name;
+            break;
+        }
+        node_coords_save_dest = gui_data.node_coords_save_dest;
+        node_coords_save_map_num = gui_data.node_coords_save_map_num;
+      }
+
+      if (gui_data.arrow_coords_save_dest ==
+          MapStorage::SpecMapSaveOpts::NESET_SECT)
+      {
+        switch (gui_data.arrow_coords_save_map_num)
+        {
+          case SpecMapSaveOpts::ONE_MAP:
+            arrow_coord_xmap_name = gui_data.arrow_coords_one_map_name + ":x";
+            arrow_coord_ymap_name = gui_data.arrow_coords_one_map_name + ":y";
+            arrow_coords_one_map_name = gui_data.arrow_coords_one_map_name;
+            break;
+          case SpecMapSaveOpts::TWO_MAPS:
+            arrow_coord_xmap_name = gui_data.arrow_coords_two_maps_1_name;
+            arrow_coord_ymap_name = gui_data.arrow_coords_two_maps_2_name;
+            arrow_coords_two_maps_1_name =
+              gui_data.arrow_coords_two_maps_1_name;
+            arrow_coords_two_maps_2_name =
+              gui_data.arrow_coords_two_maps_2_name;
+            break;
+        }
+        arrow_coords_save_dest = gui_data.arrow_coords_save_dest;
+        arrow_coords_save_map_num = gui_data.arrow_coords_save_map_num;
+      }
+      readLGF(filename, true,
+          gui_data.main_node_map_names, gui_data.main_edge_map_names,
+          gui_data.node_map_types, gui_data.edge_map_types,
+          node_coord_xmap_name, node_coord_ymap_name,
+          arrow_coord_xmap_name, arrow_coord_ymap_name);
+    }
+    catch (Exception& error)
+    {
       clear();
       return 1;
     }
 
-    if (content.edgeSetNum() < 1)
-    {
-      Gtk::MessageDialog mdialog("No edgeset found in file.");
-      mdialog.run();
-      clear();
-      return 1;
-    }
-
-    const std::vector<std::string>& nodeMapNames = content.nodeSetMaps(0);
-    const std::vector<std::string>& edgeMapNames = content.edgeSetMaps(0);
-
-    GraphReader<Graph> greader(filename, graph);
-    for (std::vector<std::string>::const_iterator it = nodeMapNames.begin();
-        it != nodeMapNames.end(); ++it)
-    {
-      if (*it == "coordinates_x")
-      {
-        read_x = true;
-        //std::cout << "read X nodemap" << std::endl;
-      }
-      else if (*it == "coordinates_y")
-      {
-        read_y = true;
-        //std::cout << "read Y nodemap" << std::endl;
-      }
-      else if (*it == "label")
-      {
-        //std::cout << "read id nodemap" << std::endl;
+    // add the maps from the gui section
+    for (vector<string>::const_iterator
+        it = gui_data.gui_node_map_names.begin();
+        it != gui_data.gui_node_map_names.end(); ++it)
+    {
+      string map_name = *it;
+      switch (gui_data.node_map_types[map_name])
+      {
+        case MapValue::NUMERIC:
+          {
+            createNodeMap(map_name, MapValue::NUMERIC, double());
+            NumericNodeMap& dmap = getNumericNodeMap(map_name);
+            map<int, double>& smap = *gui_data.numeric_node_maps[map_name];
+            for (NodeIt n(graph); n != INVALID; ++n)
+            {
+              dmap[n] = smap[node_label[n]];
+            }
+            break;
+          }
+        case MapValue::STRING:
+          {
+            createNodeMap(map_name, MapValue::STRING, string());
+            StringNodeMap& dmap = getStringNodeMap(map_name);
+            map<int, string>& smap = *gui_data.string_node_maps[map_name];
+            for (NodeIt n(graph); n != INVALID; ++n)
+            {
+              dmap[n] = smap[node_label[n]];
+            }
+            break;
+          }
+      }
+      getNodeMapData(map_name)->save_dest = GUI_SECT;
+    }
+    for (vector<string>::const_iterator
+        it = gui_data.gui_edge_map_names.begin();
+        it != gui_data.gui_edge_map_names.end(); ++it)
+    {
+      string map_name = *it;
+      switch (gui_data.edge_map_types[map_name])
+      {
+        case MapValue::NUMERIC:
+          {
+            createEdgeMap(map_name, MapValue::NUMERIC, double());
+            NumericEdgeMap& dmap = getNumericEdgeMap(map_name);
+            map<int, double>& smap = *gui_data.numeric_edge_maps[map_name];
+            for (EdgeIt e(graph); e != INVALID; ++e)
+            {
+              dmap[e] = smap[edge_label[e]];
+            }
+            break;
+          }
+        case MapValue::STRING:
+          {
+            createEdgeMap(map_name, MapValue::STRING, string());
+            StringEdgeMap& dmap = getStringEdgeMap(map_name);
+            map<int, string>& smap = *gui_data.string_edge_maps[map_name];
+            for (EdgeIt e(graph); e != INVALID; ++e)
+            {
+              dmap[e] = smap[edge_label[e]];
+            }
+            break;
+          }
+      }
+      getEdgeMapData(map_name)->save_dest = GUI_SECT;
+    }
+
+    // restore the node coordinate maps
+    if (gui_data.node_coords_save_dest ==
+        MapStorage::SpecMapSaveOpts::GUI_SECT)
+    {
+      for (NodeIt n(graph); n != INVALID; ++n)
+      {
+        node_coords.set(n, gui_data.node_coord_map[node_label[n]]);
+      }
+      node_coords_save_dest = gui_data.node_coords_save_dest;
+    }
+    // restore the arrow coordinate maps
+    if (gui_data.arrow_coords_save_dest ==
+        MapStorage::SpecMapSaveOpts::GUI_SECT)
+    {
+      for (EdgeIt e(graph); e != INVALID; ++e)
+      {
+        arrow_coords.set(e, gui_data.arrow_coord_map[edge_label[e]]);
+      }
+      arrow_coords_save_dest = gui_data.arrow_coords_save_dest;
+    }
+  }
+  else
+  {
+    // there is no gui section neither in the .lgf file nor in the .conf file
+    {
+      LemonReader lreader(filename);
+      ContentReader content(lreader);
+      try
+      {
+        lreader.run();
+      }
+      catch (Exception& error)
+      {
+        Gtk::MessageDialog mdialog(error.what());
+        mdialog.run();
+        clear();
+        return 1;
+      }
+
+      if (content.nodeSetNum() < 1)
+      {
+        Gtk::MessageDialog mdialog("No nodeset found in file.");
+        mdialog.run();
+        clear();
+        return 1;
+      }
+
+      if (content.edgeSetNum() < 1)
+      {
+        Gtk::MessageDialog mdialog("No edgeset found in file.");
+        mdialog.run();
+        clear();
+        return 1;
+      }
+
+      std::vector<std::string> nodeMapNames = content.nodeSetMaps(0);
+      std::vector<std::string> edgeMapNames = content.edgeSetMaps(0);
+      
+      bool read_edge_label = true;
+      if (std::find(edgeMapNames.begin(), edgeMapNames.end(), "label") ==
+          edgeMapNames.end())
+      {
+        read_edge_label = false;
+      }
+
+      nodeMapNames.erase(
+          std::remove(nodeMapNames.begin(), nodeMapNames.end(), "label"),
+          nodeMapNames.end());
+
+      edgeMapNames.erase(
+          std::remove(edgeMapNames.begin(), edgeMapNames.end(), "label"),
+          edgeMapNames.end());
+
+      FileImportDialog::ImportData data(nodeMapNames, edgeMapNames);
+      FileImportDialog fidialog(&data);
+      int response = fidialog.run();
+      if (response == Gtk::RESPONSE_OK)
+      {
+        try
+        {
+          std::string node_coord_xmap_name, node_coord_ymap_name;
+          std::string arrow_coord_xmap_name, arrow_coord_ymap_name;
+          bool gen_node_coords = false;
+          bool gen_arrow_coords = false;
+
+          switch (data.node_coord_load_from)
+          {
+            case FileImportDialog::ImportData::ONE_MAP:
+              node_coord_xmap_name = data.node_coord_one_map_name + ":x";
+              node_coord_ymap_name = data.node_coord_one_map_name + ":y";
+              node_coords_one_map_name = data.node_coord_one_map_name;
+
+              node_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
+              node_coords_save_map_num = SpecMapSaveOpts::ONE_MAP;
+              break;
+            case FileImportDialog::ImportData::TWO_MAPS:
+              node_coord_xmap_name = data.node_coord_two_maps_1_name;
+              node_coord_ymap_name = data.node_coord_two_maps_2_name;
+              node_coords_two_maps_1_name = data.node_coord_two_maps_1_name;
+              node_coords_two_maps_2_name = data.node_coord_two_maps_2_name;
+
+              node_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
+              node_coords_save_map_num = SpecMapSaveOpts::TWO_MAPS;
+              break;
+            case FileImportDialog::ImportData::DONT_READ:
+              node_coord_xmap_name = "";
+              node_coord_ymap_name = "";
+
+              node_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
+              gen_node_coords = true;
+              break;
+          }
+
+          switch (data.arrow_coord_load_from)
+          {
+            case FileImportDialog::ImportData::ONE_MAP:
+              arrow_coord_xmap_name = data.arrow_coord_one_map_name + ":x";
+              arrow_coord_ymap_name = data.arrow_coord_one_map_name + ":y";
+              arrow_coords_one_map_name = data.arrow_coord_one_map_name;
+
+              arrow_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
+              arrow_coords_save_map_num = SpecMapSaveOpts::ONE_MAP;
+              break;
+            case FileImportDialog::ImportData::TWO_MAPS:
+              arrow_coord_xmap_name = data.arrow_coord_two_maps_1_name;
+              arrow_coord_ymap_name = data.arrow_coord_two_maps_2_name;
+              arrow_coords_two_maps_1_name = data.arrow_coord_two_maps_1_name;
+              arrow_coords_two_maps_2_name = data.arrow_coord_two_maps_2_name;
+
+              arrow_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
+              arrow_coords_save_map_num = SpecMapSaveOpts::TWO_MAPS;
+              break;
+            case FileImportDialog::ImportData::DONT_READ:
+              arrow_coord_xmap_name = "";
+              arrow_coord_ymap_name = "";
+
+              arrow_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
+              gen_arrow_coords = true;
+              break;
+          }
+
+          // read edge and node maps
+          std::vector<std::string> node_map_names;
+          std::vector<std::string> edge_map_names;
+          std::map<std::string, MapValue::Type> node_map_types;
+          std::map<std::string, MapValue::Type> edge_map_types;
+          for (std::vector<std::string>::const_iterator it =
+              data.numeric_node_map_names.begin();
+              it != data.numeric_node_map_names.end(); ++it)
+          {
+            node_map_names.push_back(*it);
+            node_map_types[*it] = MapValue::NUMERIC;
+          }
+          for (std::vector<std::string>::const_iterator it =
+              data.string_node_map_names.begin();
+              it != data.string_node_map_names.end(); ++it)
+          {
+            node_map_names.push_back(*it);
+            node_map_types[*it] = MapValue::STRING;
+          }
+          for (std::vector<std::string>::const_iterator it =
+              data.numeric_edge_map_names.begin();
+              it != data.numeric_edge_map_names.end(); ++it)
+          {
+            edge_map_names.push_back(*it);
+            edge_map_types[*it] = MapValue::NUMERIC;
+          }
+          for (std::vector<std::string>::const_iterator it =
+              data.string_edge_map_names.begin();
+              it != data.string_edge_map_names.end(); ++it)
+          {
+            edge_map_names.push_back(*it);
+            edge_map_types[*it] = MapValue::STRING;
+          }
+
+          readLGF(filename, read_edge_label,
+              node_map_names, edge_map_names,
+              node_map_types, edge_map_types,
+              node_coord_xmap_name, node_coord_ymap_name,
+              arrow_coord_xmap_name, arrow_coord_ymap_name);
+
+          // generate edge labels
+          if (!read_edge_label)
+          {
+            int l = 0;
+            for (EdgeIt e(graph); e != INVALID; ++e)
+            {
+              edge_label[e] = l++;
+            }
+          }
+
+          if (gen_node_coords)
+          {
+            // generate node coordinates
+            int node_num = 0;
+            for (NodeIt n(graph); n != INVALID; ++n) { node_num++; }
+            const double pi = 3.142;
+            double step = 2 * pi / (double) node_num;
+            int i = 0;
+            for (NodeIt n(graph); n != INVALID; ++n)
+            {
+              setNodeCoords(n,
+                  XY(250.0 * std::cos(i * step),
+                    250.0 * std::sin(i * step)));
+              i++;
+            }
+          }
+          if (gen_arrow_coords)
+          {
+            // generate arrow coordinates
+            for (EdgeIt e(graph); e != INVALID; ++e)
+            {
+              if (graph.source(e) == graph.target(e))
+              {
+                setArrowCoords(e,
+                    getNodeCoords(graph.source(e)) + XY(0.0, 80.0));
+              }
+              else
+              {
+                setArrowCoords(e,
+                    (getNodeCoords(graph.source(e)) +
+                     getNodeCoords(graph.target(e))) / 2.0);
+              }
+            }
+          }
+        }
+        catch (Exception& error)
+        {
+          clear();
+          return 1;
+        }
       }
       else
       {
-        nodemap_storage[*it] = new Graph::NodeMap<double>(graph);
-        //std::cout << "read " << *it << " nodemap" << std::endl;
-      }
-      greader.readNodeMap(*it, *nodemap_storage[*it]);
-    }
-    for (std::vector<std::string>::const_iterator it = edgeMapNames.begin();
-        it != edgeMapNames.end(); ++it)
-    {
-      if (*it == "label")
-      {
-        //std::cout << "read id edgemap" << std::endl;
-        read_edge_id = true;
-      }
-      else
-      {
-        edgemap_storage[*it] = new Graph::EdgeMap<double>(graph);
-        //std::cout << "read " << *it << " edgemap" << std::endl;
-      }
-      greader.readEdgeMap(*it, *edgemap_storage[*it]);
-    }
-    GuiReader gui_reader(greader, this);
-    greader.run();
-  } catch (Exception& error) {
-    Gtk::MessageDialog mdialog(error.what());
-    mdialog.run();
-    clear();
-    return 1;
-  }
-
-  if (!read_edge_id)
-  {
-    edgemap_storage["label"] = new Graph::EdgeMap<double>(graph);
-    int i = 1;
+        clear();
+        return 1;
+      }
+    }
+  }
+
+  // set max_node_label
+  {
+    max_node_label = std::numeric_limits<int>::min();
+    for (NodeIt n(graph); n != INVALID; ++n)
+    {
+      if (node_label[n] > max_node_label)
+      {
+        max_node_label = node_label[n];
+      }
+    }
+  }
+  // set max_edge_label
+  {
+    max_edge_label = std::numeric_limits<int>::min();
     for (EdgeIt e(graph); e != INVALID; ++e)
     {
-      (*edgemap_storage["label"])[e] = i++;
-    }
-  }
-
-  if (!read_x || !read_y)
-  {
-    int node_num = 0;
-    for (NodeIt n(graph); n != INVALID; ++n)
-    {
-      node_num++;
-    }
-    const double pi = 3.142;
-    double step = 2 * pi / (double) node_num;
-    int i = 0;
-    for (NodeIt n(graph); n != INVALID; ++n)
-    {
-      nodemap_storage["coordinates_x"]->set(n, 250.0 * std::cos(i * step));
-      nodemap_storage["coordinates_y"]->set(n, 250.0 * std::sin(i * step));
-      i++;
-    }
-  }
-
-  if (!arrow_pos_read_ok)
-  {
-    arrow_pos_read_ok = false;
-    for (EdgeIt e(graph); e != INVALID; ++e)
-    {
-      if (graph.source(e) == graph.target(e))
-      {
-        arrow_pos.set(e, coords[graph.source(e)] + XY(0.0, 80.0));
-      }
-      else
-      {
-        arrow_pos.set(e, (coords[graph.source(e)] + coords[graph.target(e)]) / 2.0);
-      }
-    }
-  }
-
-  // fill in the default values for the maps
-  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
-  {
-    if ((it->first != "label") &&
-        (it->first != "coordiantes_x") &&
-        (it->first != "coordinates_y"))
-    {
-      nodemap_default[it->first] = 0.0;
-    }
-    else if (it->first == "label")
-    {
-      NodeIt n(graph);
-      double max = (*nodemap_storage["label"])[n];
-      for (; n != INVALID; ++n)
-      {
-        if ((*nodemap_storage["label"])[n] > max)
-          max = (*nodemap_storage["label"])[n];
-      }
-      nodemap_default["label"] = max + 1.0;
-    }
-  }
-  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
-      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
-  {
-    if (it->first != "label")
-    {
-      edgemap_default[it->first] = 0.0;
+      if (edge_label[e] > max_edge_label)
+      {
+        max_edge_label = edge_label[e];
+      }
+    }
+  }
+
+  return 0;
+}
+
+void MapStorage::writeToFile(const std::string &filename)
+{
+  // relabel nodes and edges
+  int i = 0;
+  for (NodeIt n(graph); n != INVALID; ++n)
+  {
+    node_label[n] = i++;
+  }
+  max_node_label = i-1;
+  i = 0;
+  for (EdgeIt e(graph); e != INVALID; ++e)
+  {
+    edge_label[e] = i++;
+  }
+  max_edge_label = i-1;
+
+  // write .lgf file
+  {
+    GraphWriter<Graph> gwriter(filename, graph);
+
+    gwriter.writeNodeMap("label", node_label);
+    gwriter.writeEdgeMap("label", edge_label);
+
+    // write node maps
+    for (NodeMapStore::const_iterator it = nodemaps.begin();
+        it != nodemaps.end(); ++it)
+    {
+      if (it->second->save_dest == NESET_SECT)
+      {
+        switch (it->second->type())
+        {
+          case MapValue::NUMERIC:
+            gwriter.writeNodeMap(it->first, getNumericNodeMap(it->first));
+            break;
+          case MapValue::STRING:
+            gwriter.writeNodeMap(it->first, getStringNodeMap(it->first));
+            break;
+        }
+      }
+    }
+
+    // write edge maps
+    for (EdgeMapStore::const_iterator it = edgemaps.begin();
+        it != edgemaps.end(); ++it)
+    {
+      if (it->second->save_dest == NESET_SECT)
+      {
+        switch (it->second->type())
+        {
+          case MapValue::NUMERIC:
+            gwriter.writeEdgeMap(it->first, getNumericEdgeMap(it->first));
+            break;
+          case MapValue::STRING:
+            gwriter.writeEdgeMap(it->first, getStringEdgeMap(it->first));
+            break;
+        }
+      }
+    }
+
+    // write node coordinates
+    switch (getNodeCoordsSaveDest())
+    {
+      case MapStorage::SpecMapSaveOpts::GUI_SECT:
+        break;
+      case MapStorage::SpecMapSaveOpts::NESET_SECT:
+        switch (getNodeCoordsSaveMapNum())
+        {
+          case MapStorage::SpecMapSaveOpts::ONE_MAP:
+            gwriter.writeNodeMap(node_coords_one_map_name + ":x",
+                node_coords_x);
+            gwriter.writeNodeMap(node_coords_one_map_name + ":y",
+                node_coords_y);
+            break;
+          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
+            gwriter.writeNodeMap(node_coords_two_maps_1_name,
+                node_coords_x);
+            gwriter.writeNodeMap(node_coords_two_maps_2_name,
+                node_coords_y);
+            break;
+        }
+        break;
+    }
+
+    // write arrow coordinates
+    switch (getArrowCoordsSaveDest())
+    {
+      case MapStorage::SpecMapSaveOpts::GUI_SECT:
+        break;
+      case MapStorage::SpecMapSaveOpts::NESET_SECT:
+        switch (getArrowCoordsSaveMapNum())
+        {
+          case MapStorage::SpecMapSaveOpts::ONE_MAP:
+            gwriter.writeEdgeMap(arrow_coords_one_map_name + ":x",
+                arrow_coords_x);
+            gwriter.writeEdgeMap(arrow_coords_one_map_name + ":y",
+                arrow_coords_y);
+            break;
+          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
+            gwriter.writeEdgeMap(arrow_coords_two_maps_1_name,
+                arrow_coords_x);
+            gwriter.writeEdgeMap(arrow_coords_two_maps_2_name,
+                arrow_coords_y);
+            break;
+        }
+        break;
+    }
+
+    if (gui_sect_save_dest == LGF_FILE)
+    {
+      GuiWriter gui_writer(gwriter, this);
+      gwriter.run();
     }
     else
     {
-      double max = std::numeric_limits<double>::min();
-      for (EdgeIt e(graph); e != INVALID; ++e)
-      {
-        if ((*edgemap_storage["label"])[e] > max)
-          max = (*edgemap_storage["label"])[e];
-      }
-      if (max > std::numeric_limits<double>::min())
-        edgemap_default["label"] = max + 1.0;
-      else
-        edgemap_default["label"] = 1.0;
-    }
-  }
-
-  return 0;
-}
-
-void MapStorage::writeToFile(const std::string &filename)
-{
-  GraphWriter<Graph> gwriter(filename, graph);
-
-  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
-  {
-    gwriter.writeNodeMap(it->first, *(it->second));
-  }
-  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
-      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
-  {
-    if ((it->first != "arrow_pos_x") &&
-        (it->first != "arrow_pos_y"))
-    {
-      gwriter.writeEdgeMap(it->first, *(it->second));
-    }
-  }
-
-  GuiWriter gui_writer(gwriter, this);
-
-  gwriter.run();
+      gwriter.run();
+    }
+  }
+
+  // write .conf file
+  if (gui_sect_save_dest == CONF_FILE)
+  {
+    LemonWriter lwriter(filename + ".conf");
+    GuiWriter gui_writer(lwriter, this);
+    lwriter.run();
+  }
 }
 
 void MapStorage::clear()
 {
-  for (std::map<std::string, Graph::NodeMap<double>*>::iterator it =
-      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
-  {
-    if ((it->first != "coordinates_x") &&
-        (it->first != "coordinates_y") &&
-        (it->first != "label"))
-    {
-      delete it->second;
-      nodemap_storage.erase(it);
-    }
-  }
-  for (std::map<std::string, Graph::EdgeMap<double>*>::iterator it =
-      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
-  {
-    if ((it->first != "label") &&
-        (it->first != "arrow_pos_x") &&
-        (it->first != "arrow_pos_y"))
-    {
-      delete it->second;
-      edgemap_storage.erase(it);
-    }
-  }
-  for (std::map<std::string, double>::iterator it =
-      nodemap_default.begin(); it != nodemap_default.end(); ++it)
-  {
-    if (it->first != "label")
-      nodemap_default.erase(it);
-  }
-  for (std::map<std::string, double>::iterator it =
-      edgemap_default.begin(); it != edgemap_default.end(); ++it)
-  {
-    if (it->first != "label")
-      edgemap_default.erase(it);
+  for (NodeMapStore::iterator it = nodemaps.begin(); it != nodemaps.end(); ++it)
+  {
+    delete it->second;
+    nodemaps.erase(it);
+  }
+  for (EdgeMapStore::iterator it = edgemaps.begin(); it != edgemaps.end(); ++it)
+  {
+    delete it->second;
+    edgemaps.erase(it);
   }
   graph.clear();
   file_name = "";
   modified = false;
-
-  arrow_pos_read_ok = false;
-  
+  max_node_label = 0;
+  max_edge_label = 0;
+  background_set = false;
+
+  gui_sect_save_dest = LGF_FILE;
+  node_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
+  arrow_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
+  node_coords_one_map_name = "coord";
+  node_coords_two_maps_1_name = "coord_x";
+  node_coords_two_maps_2_name = "coord_y";
+  arrow_coords_one_map_name = "arrow";
+  arrow_coords_two_maps_1_name = "arrow_x";
+  arrow_coords_two_maps_2_name = "arrow_y";
+
   for(int i=0;i<NODE_PROPERTY_NUM;i++)
     {
@@ -500 +894 @@
 }
 
-void MapStorage::ArrowPosReadOK()
-{
-  arrow_pos_read_ok = true;
-}
-
 void MapStorage::mapChanged(bool itisedge, std::string mapname)
 {
   if(itisedge)
-    {
-      for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-        {
-          if(active_edgemaps[i]==mapname)
-            {
-              signal_prop.emit(itisedge, i);
-            }
-        }
-    }
+  {
+    for(int i=0;i<EDGE_PROPERTY_NUM;i++)
+    {
+      if(active_edgemaps[i]==mapname)
+      {
+        signal_prop.emit(itisedge, i);
+      }
+    }
+  }
   else
-    {
-      for(int i=0;i<NODE_PROPERTY_NUM;i++)
-        {
-          if(active_nodemaps[i]==mapname)
-            {
-              signal_prop.emit(itisedge, i);
-            }
-        }
-    }
+  {
+    for(int i=0;i<NODE_PROPERTY_NUM;i++)
+    {
+      if(active_nodemaps[i]==mapname)
+      {
+        signal_prop.emit(itisedge, i);
+      }
+    }
+  }
 }
 
@@ -554 +943 @@
 {
   signal_design_win.emit(attraction, propulsation, iterations);
+}
+
+XY MapStorage::getNodeCoords(Node n) const
+{
+  return node_coords[n];
+}
+
+void MapStorage::setNodeCoords(Node n, XY c)
+{
+  node_coords.set(n, c);
+}
+
+XY MapStorage::getArrowCoords(Edge e) const
+{
+  return arrow_coords[e];
+}
+
+void MapStorage::setArrowCoords(Edge e, XY c)
+{
+  arrow_coords.set(e, c);
+}
+
+MapValue MapStorage::get(const std::string& name, Node node) const
+{
+  NodeMapData* data = getNodeMapData(name);
+  return data->get(node);
+}
+
+void MapStorage::set(const std::string& name, Node node, MapValue val)
+{
+  NodeMapData* data = getNodeMapData(name);
+  data->set(node, val);
+}
+
+MapValue MapStorage::get(const std::string& name, Edge edge) const
+{
+  EdgeMapData* data = getEdgeMapData(name);
+  return data->get(edge);
+}
+
+void MapStorage::set(const std::string& name, Edge edge, MapValue val)
+{
+  EdgeMapData* data = getEdgeMapData(name);
+  data->set(edge, val);
+}
+
+const std::string& MapStorage::getFileName() const
+{
+  return file_name;
+}
+
+void MapStorage::setFileName(const std::string& fn)
+{
+  file_name = fn;
+}
+
+bool MapStorage::getModified() const
+{
+  return modified;
+}
+
+void MapStorage::setModified(bool m)
+{
+  modified = m;
+}
+
+Node MapStorage::addNode(XY coords)
+{
+  Node node = graph.addNode();
+
+  setNodeCoords(node, coords);
+
+  max_node_label++;
+
+  node_label[node] = max_node_label;
+
+  std::vector<std::string> node_maps = getNodeMapList();
+  for (std::vector<std::string>::const_iterator it = node_maps.begin();
+      it != node_maps.end(); ++it)
+  {
+    NodeMapData* data = getNodeMapData(*it);
+    set(*it, node, data->default_value);
+  }
+
+  return node;
+}
+
+Edge MapStorage::addEdge(Node from, Node to)
+{
+  Edge edge = graph.addEdge(from, to);
+
+  if (from == to)
+  {
+    setArrowCoords(edge, getNodeCoords(from) + XY(0.0, 80.0));
+  }
+  else
+  {
+    setArrowCoords(edge, (getNodeCoords(from) + getNodeCoords(to)) / 2.0);
+  }
+
+  max_edge_label++;
+
+  edge_label[edge] = max_edge_label;
+
+  std::vector<std::string> edge_maps = getEdgeMapList();
+  for (std::vector<std::string>::const_iterator it = edge_maps.begin();
+      it != edge_maps.end(); ++it)
+  {
+    EdgeMapData* data = getEdgeMapData(*it);
+    set(*it, edge, data->default_value);
+  }
+  return edge;
+}
+
+MapStorage::NumericNodeMap& MapStorage::getNumericNodeMap(const std::string& name)
+{
+  NodeMapData* data = getNodeMapData(name);
+  if (data->type() != MapValue::NUMERIC)
+    throw Error("Numeric node map " + name + " does not exists.");
+  return static_cast<NumericNodeMapData*>(data)->map;
+}
+
+MapStorage::StringNodeMap& MapStorage::getStringNodeMap(const std::string& name)
+{
+  NodeMapData* data = getNodeMapData(name);
+  if (data->type() != MapValue::STRING)
+    throw Error("String node map " + name + " does not exists.");
+  return static_cast<StringNodeMapData*>(data)->map;
+}
+
+MapStorage::NumericEdgeMap& MapStorage::getNumericEdgeMap(const std::string& name)
+{
+  EdgeMapData* data = getEdgeMapData(name);
+  if (data->type() != MapValue::NUMERIC)
+    throw Error("Numeric edge map " + name + " does not exists.");
+  return static_cast<NumericEdgeMapData*>(data)->map;
+}
+
+MapStorage::StringEdgeMap& MapStorage::getStringEdgeMap(const std::string& name)
+{
+  EdgeMapData* data = getEdgeMapData(name);
+  if (data->type() != MapValue::STRING)
+    throw Error("String edge map " + name + " does not exists.");
+  return static_cast<StringEdgeMapData*>(data)->map;
+}
+
+MapValueEdgeMap MapStorage::getEdgeMap(const std::string& name)
+{
+  return MapValueEdgeMap(name, this);
+}
+
+MapValueNodeMap MapStorage::getNodeMap(const std::string& name)
+{
+  return MapValueNodeMap(name, this);
+}
+
+int MapStorage::getLabel(Node n) const
+{
+  return node_label[n];
+}
+
+int MapStorage::getLabel(Edge e) const
+{
+  return edge_label[e];
+}
+
+MapStorage::GuiSectSaveDest MapStorage::getGUIDataSaveLocation()
+{
+  return gui_sect_save_dest;
+}
+
+void MapStorage::setGUIDataSaveLocation(MapStorage::GuiSectSaveDest dest)
+{
+  gui_sect_save_dest = dest;
+}
+
+MapStorage::MapSaveDest MapStorage::getNodeMapSaveDest(std::string name) const
+{
+  NodeMapData *data = getNodeMapData(name);
+  return data->save_dest;
+}
+
+MapStorage::MapSaveDest MapStorage::getEdgeMapSaveDest(std::string name) const
+{
+  EdgeMapData *data = getEdgeMapData(name);
+  return data->save_dest;
+}
+
+void MapStorage::setNodeMapSaveDest(std::string name, MapStorage::MapSaveDest dest)
+{
+  NodeMapData *data = getNodeMapData(name);
+  data->save_dest = dest;
+}
+
+void MapStorage::setEdgeMapSaveDest(std::string name, MapStorage::MapSaveDest dest)
+{
+  EdgeMapData *data = getEdgeMapData(name);
+  data->save_dest = dest;
+}
+
+MapStorage::EdgeMapData* MapStorage::getEdgeMapData(std::string name) const
+{
+  EdgeMapStore::const_iterator it = edgemaps.find(name);
+  if (it != edgemaps.end())
+    return it->second;
+  else
+    throw Error("Edge map " + name + " does not exists.");
+}
+
+MapStorage::NodeMapData* MapStorage::getNodeMapData(std::string name) const
+{
+  NodeMapStore::const_iterator it = nodemaps.find(name);
+  if (it != nodemaps.end())
+    return it->second;
+  else
+    throw Error("Node map " + name + " does not exists.");
+}
+
+MapValue::Type MapStorage::getNodeMapElementType(std::string name) const
+{
+  NodeMapData *data = getNodeMapData(name);
+  return data->type();
+}
+
+MapValue::Type MapStorage::getEdgeMapElementType(std::string name) const
+{
+  EdgeMapData *data = getEdgeMapData(name);
+  return data->type();
+}
+
+const MapStorage::NodeLabelMap& MapStorage::getNodeLabelMap()
+{
+  return node_label;
+}
+
+const MapStorage::EdgeLabelMap& MapStorage::getEdgeLabelMap()
+{
+  return edge_label;
+}
+
+const Graph& MapStorage::getGraph()
+{
+  return graph;
+}
+
+bool MapStorage::nodeMapExists(std::string name)
+{
+  NodeMapStore::const_iterator it = nodemaps.find(name);
+  if (it == nodemaps.end())
+    return false;
+  else
+    return true;
+}
+
+bool MapStorage::edgeMapExists(std::string name)
+{
+  EdgeMapStore::const_iterator it = edgemaps.find(name);
+  if (it == edgemaps.end())
+    return false;
+  else
+    return true;
+}
+
+std::vector<std::string> MapStorage::getEdgeMaps(MapType type)
+{
+  std::vector<std::string> maps;
+  for (EdgeMapStore::const_iterator it = edgemaps.begin(); it != edgemaps.end(); ++it)
+  {
+    if (it->second->type() & type)
+    {
+      maps.push_back(it->first);
+    }
+  }
+  return maps;
+}
+
+std::vector<std::string> MapStorage::getNodeMaps(MapType type)
+{
+  std::vector<std::string> maps;
+  for (NodeMapStore::const_iterator it = nodemaps.begin(); it != nodemaps.end(); ++it)
+  {
+    if (it->second->type() & type)
+    {
+      maps.push_back(it->first);
+    }
+  }
+  return maps;
+}
+
+MapStorage::NodeCoordMap& MapStorage::getNodeCoordMap()
+{
+  return node_coords;
+}
+
+MapStorage::ArrowCoordMap& MapStorage::getArrowCoordMap()
+{
+  return arrow_coords;
+}
+
+MapStorage::SpecMapSaveOpts::Dest MapStorage::getNodeCoordsSaveDest()
+{
+  return node_coords_save_dest;
+}
+
+MapStorage::SpecMapSaveOpts::Dest MapStorage::getArrowCoordsSaveDest()
+{
+  return arrow_coords_save_dest;
+}
+
+void MapStorage::setNodeCoordsSaveDest(MapStorage::SpecMapSaveOpts::Dest dest)
+{
+  node_coords_save_dest = dest;
+}
+
+void MapStorage::setArrowCoordsSaveDest(MapStorage::SpecMapSaveOpts::Dest dest)
+{
+  arrow_coords_save_dest = dest;
+}
+
+MapStorage::SpecMapSaveOpts::MapNum MapStorage::getNodeCoordsSaveMapNum()
+{
+  return node_coords_save_map_num;
+}
+
+MapStorage::SpecMapSaveOpts::MapNum MapStorage::getArrowCoordsSaveMapNum()
+{
+  return arrow_coords_save_map_num;
+}
+
+void MapStorage::setNodeCoordsSaveMapNum(MapStorage::SpecMapSaveOpts::MapNum num)
+{
+  node_coords_save_map_num = num;
+}
+
+void MapStorage::setArrowCoordsSaveMapNum(MapStorage::SpecMapSaveOpts::MapNum num)
+{
+  arrow_coords_save_map_num = num;
+}
+
+const std::string& MapStorage::getNodeCoordsOneMapName()
+{
+  return node_coords_one_map_name;
+}
+const std::string& MapStorage::getNodeCoordsTwoMaps1Name()
+{
+  return node_coords_two_maps_1_name;
+}
+const std::string& MapStorage::getNodeCoordsTwoMaps2Name()
+{
+  return node_coords_two_maps_2_name;
+}
+
+void MapStorage::setNodeCoordsOneMapName(const std::string& name)
+{
+  node_coords_one_map_name = name;
+}
+void MapStorage::setNodeCoordsTwoMaps1Name(const std::string& name)
+{
+  node_coords_two_maps_1_name = name;
+}
+void MapStorage::setNodeCoordsTwoMaps2Name(const std::string& name)
+{
+  node_coords_two_maps_2_name = name;
+}
+
+const std::string& MapStorage::getArrowCoordsOneMapName()
+{
+  return arrow_coords_one_map_name;
+}
+const std::string& MapStorage::getArrowCoordsTwoMaps1Name()
+{
+  return arrow_coords_two_maps_1_name;
+}
+const std::string& MapStorage::getArrowCoordsTwoMaps2Name()
+{
+  return arrow_coords_two_maps_2_name;
+}
+
+void MapStorage::setArrowCoordsOneMapName(const std::string& name)
+{
+  arrow_coords_one_map_name = name;
+}
+void MapStorage::setArrowCoordsTwoMaps1Name(const std::string& name)
+{
+  arrow_coords_two_maps_1_name = name;
+}
+void MapStorage::setArrowCoordsTwoMaps2Name(const std::string& name)
+{
+  arrow_coords_two_maps_2_name = name;
+}
+
+void MapStorage::readLGF(
+    const std::string& filename,
+    bool read_edge_label,
+    const std::vector<std::string>& node_map_names,
+    const std::vector<std::string>& edge_map_names,
+    const std::map<std::string, MapValue::Type>& node_map_types,
+    const std::map<std::string, MapValue::Type>& edge_map_types,
+    const std::string& node_coord_xmap_name,
+    const std::string& node_coord_ymap_name,
+    const std::string& arrow_coord_xmap_name,
+    const std::string& arrow_coord_ymap_name)
+{
+  using std::vector;
+  using std::map;
+  using std::string;
+
+  GraphReader<Graph> greader(filename, graph);
+
+  // read the label maps
+  greader.readNodeMap("label", node_label);
+  if (read_edge_label)
+    greader.readEdgeMap("label", edge_label);
+
+  // read the node maps
+  for (vector<string>::const_iterator
+      it = node_map_names.begin();
+      it != node_map_names.end(); ++it)
+  {
+    switch (node_map_types.find(*it)->second)
+    {
+      case MapValue::NUMERIC:
+        {
+          createNodeMap(*it, MapValue::NUMERIC, double());
+          greader.readNodeMap(*it, getNumericNodeMap(*it));
+          break;
+        }
+      case MapValue::STRING:
+        {
+          createNodeMap(*it, MapValue::STRING, string());
+          greader.readNodeMap(*it, getStringNodeMap(*it));
+          break;
+        }
+    }
+    getNodeMapData(*it)->save_dest = NESET_SECT;
+  }
+
+  // read the edge maps
+  for (vector<string>::const_iterator
+      it = edge_map_names.begin();
+      it != edge_map_names.end(); ++it)
+  {
+    switch (edge_map_types.find(*it)->second)
+    {
+      case MapValue::NUMERIC:
+        {
+          createEdgeMap(*it, MapValue::NUMERIC, double());
+          greader.readEdgeMap(*it, getNumericEdgeMap(*it));
+          break;
+        }
+      case MapValue::STRING:
+        {
+          createEdgeMap(*it, MapValue::STRING, string());
+          greader.readEdgeMap(*it, getStringEdgeMap(*it));
+          break;
+        }
+    }
+    getEdgeMapData(*it)->save_dest = NESET_SECT;
+  }
+
+  // read the node coordinate maps
+  if (node_coord_xmap_name != "")
+    greader.readNodeMap(node_coord_xmap_name, node_coords_x);
+  if (node_coord_ymap_name != "")
+    greader.readNodeMap(node_coord_ymap_name, node_coords_y);
+
+  // read the arrow coordinate maps
+  if (arrow_coord_xmap_name != "")
+    greader.readEdgeMap(arrow_coord_xmap_name, arrow_coords_x);
+  if (arrow_coord_ymap_name != "")
+    greader.readEdgeMap(arrow_coord_ymap_name, arrow_coords_y);
+
+  greader.run();
 }
 
@@ -611 +1473 @@
       if(active_nodemaps[N_RADIUS]!="")
         {
-          _nodeSizes=*(nodemap_storage[active_nodemaps[N_RADIUS]]);
+          _nodeSizes=getNumericNodeMap(active_nodemaps[N_RADIUS]);
         }
       if(active_nodemaps[N_COLOR]!="")
@@ -617 +1479 @@
           for(NodeIt ni(graph);ni!=INVALID;++ni)
             {
-              _nodeColors[ni]=(int)((*(nodemap_storage[active_nodemaps[N_COLOR]]))[ni]);
+              _nodeColors[ni]=(int)get(active_nodemaps[N_COLOR], ni);
             }
         }
@@ -625 +1487 @@
             {
               std::ostringstream o;
-              o << ((*(nodemap_storage[active_nodemaps[N_TEXT]]))[ni]);
+              o << get(active_nodemaps[N_TEXT], ni);
               _nodeTextMap[ni]=o.str();       
             }
@@ -634 +1496 @@
       if(active_edgemaps[E_WIDTH]!="")
         {
-          _edgeWidths=*(edgemap_storage[active_edgemaps[E_WIDTH]]);
+          _edgeWidths=getNumericEdgeMap(active_edgemaps[E_WIDTH]);
         }
       if(active_edgemaps[E_COLOR]!="")
@@ -640 +1502 @@
           for(EdgeIt ei(graph);ei!=INVALID;++ei)
             {
-              _edgeColors[ei]=(int)((*(edgemap_storage[active_edgemaps[E_COLOR]]))[ei]);
+              _edgeColors[ei]=(int)get(active_edgemaps[E_COLOR], ei);
             }
         }
@@ -646 +1508 @@
   if(shapemap!="Default values")
     {
-      if((minOfNodeMap(shapemap)>=0)&&(maxOfNodeMap(shapemap)<=4))
+      double min = std::numeric_limits<double>::max();
+      double max = std::numeric_limits<double>::min();
+      for (NodeIt n(graph); n != INVALID; ++n)
+      {
+        double v = static_cast<double>(get(shapemap, n));
+        if (v < min) min = v;
+        if (v > max) max = v;
+      }
+      if((min>=0)&&(max<=4))
         {
-          _shapes=*(nodemap_storage[shapemap]);
+          NumericNodeMap& map = static_cast<NumericNodeMapData*>(getNodeMapData(shapemap))->map;
+          for (NodeIt n(graph); n != INVALID; ++n)
+          {
+            _shapes[n] = static_cast<int>(map[n]);
+          }
         }
     }
@@ -660 +1534 @@
     absoluteNodeSizes().absoluteEdgeWidths().
     nodeScale(2).nodeSizes(_nodeSizes).
-    coords(coords).
+    coords(node_coords).
     nodeShapes(_shapes).
     nodeColors(composeMap(paletteW,_nodeColors)).

mapstorage.h

@@ -20 +20 @@
 #define MAPSTORAGE_H
 
-#include <all_include.h>
-#include <xymap.h>
+class Mapstorage;
+
+#include <vector>
+#include <map>
+#include <string>
+#include "all_include.h"
+#include "xymap.h"
 #include <libgnomecanvasmm.h>
+#include "map_value.h"
+#include "map_value_map.h"
 
 ///class MapStorage handles NodeMaps and EdgeMaps.
@@ -42 +49 @@
   double background_scaling;
 public:
+  class Error : public std::exception
+  {
+    private:
+      std::string message;
+    public:
+      Error(const std::string& msg) : message(msg) {}
+      virtual const char* what() const throw()
+      {
+        return message.c_str();
+      }
+      ~Error() throw() {}
+  };
+
   void setBackground(const std::string& file_name);
   const std::string& getBackgroundFilename();
@@ -47 +67 @@
   double getBackgroundScaling();
   void setBackgroundScaling(double scaling);
+
+  enum MapSaveDest { GUI_SECT, NESET_SECT, DONT_SAVE };
+  enum GuiSectSaveDest { LGF_FILE, CONF_FILE };
+  struct SpecMapSaveOpts
+  {
+    enum Dest { GUI_SECT, NESET_SECT };
+    enum MapNum { ONE_MAP, TWO_MAPS };
+  };
+
+  typedef Graph::NodeMap<double> NumericNodeMap;
+  typedef Graph::NodeMap<std::string> StringNodeMap;
+  typedef Graph::EdgeMap<double> NumericEdgeMap;
+  typedef Graph::EdgeMap<std::string> StringEdgeMap;
+  typedef Graph::NodeMap<int> NodeLabelMap;
+  typedef Graph::EdgeMap<int> EdgeLabelMap;
+  typedef XYMap<Graph::NodeMap<double> > NodeCoordMap;
+  typedef XYMap<Graph::EdgeMap<double> > ArrowCoordMap;
+
+  struct EdgeMapData
+  {
+    /// where to save the map
+    MapSaveDest save_dest;
+    /// read-only or read-write
+    bool writeable;
+    /// default value
+    MapValue default_value;
+    virtual MapValue::Type type() = 0;
+    virtual MapValue get(Edge e) = 0;
+    virtual void set(Edge e, MapValue v) = 0;
+    EdgeMapData(MapValue def_val) :
+      save_dest(GUI_SECT),
+      writeable(true),
+      default_value(def_val)
+    {}
+  };
+
+  struct NumericEdgeMapData : public EdgeMapData
+  {
+    NumericEdgeMap map;
+    MapValue::Type type() { return MapValue::NUMERIC; }
+    MapValue get(Edge e) { return MapValue(map[e]); }
+    void set(Edge e, MapValue v) { map.set(e, static_cast<double>(v)); }
+    NumericEdgeMapData(Graph& g, double def_val) :
+      EdgeMapData(MapValue(def_val)),
+      map(g, def_val)
+    {}
+  };
+
+  struct StringEdgeMapData : public EdgeMapData
+  {
+    StringEdgeMap map;
+    MapValue::Type type() { return MapValue::STRING; }
+    MapValue get(Edge e) { return MapValue(map[e]); }
+    void set(Edge e, MapValue v) { map.set(e, static_cast<std::string>(v)); }
+    StringEdgeMapData(Graph& g, std::string def_val) :
+      EdgeMapData(MapValue(def_val)),
+      map(g, def_val)
+    {}
+  };
+
+  struct NodeMapData
+  {
+    /// where to save the map
+    MapSaveDest save_dest;
+    /// read-only or read-write
+    bool writeable;
+    /// default value
+    MapValue default_value;
+    virtual MapValue::Type type() = 0;
+    virtual MapValue get(Node e) = 0;
+    virtual void set(Node e, MapValue v) = 0;
+    NodeMapData(MapValue def_val) :
+      save_dest(GUI_SECT),
+      writeable(true),
+      default_value(def_val)
+    {}
+  };
+
+  struct NumericNodeMapData : public NodeMapData
+  {
+    NumericNodeMap map;
+    MapValue::Type type() { return MapValue::NUMERIC; }
+    MapValue get(Node e) { return MapValue(map[e]); }
+    void set(Node e, MapValue v) { map.set(e, static_cast<double>(v)); }
+    NumericNodeMapData(Graph& g, double def_val) :
+      NodeMapData(MapValue(def_val)),
+      map(g, def_val)
+    {}
+  };
+
+  struct StringNodeMapData : public NodeMapData
+  {
+    StringNodeMap map;
+    MapValue::Type type() { return MapValue::STRING; }
+    MapValue get(Node e) { return MapValue(map[e]); }
+    void set(Node e, MapValue v) { map.set(e, static_cast<std::string>(v)); }
+    StringNodeMapData(Graph& g, std::string def_val) :
+      NodeMapData(MapValue(def_val)),
+      map(g, def_val)
+    {}
+  };
+
+  typedef std::map<std::string, NodeMapData*> NodeMapStore;
+  typedef std::map<std::string, EdgeMapData*> EdgeMapStore;
+
+  struct GUISectData
+  {
+    std::vector<std::string> main_node_map_names;
+    std::vector<std::string> main_edge_map_names;
+
+    std::vector<std::string> gui_node_map_names;
+    std::vector<std::string> gui_edge_map_names;
+
+    std::map<std::string, MapValue::Type> node_map_types;
+    std::map<std::string, MapValue::Type> edge_map_types;
+
+    std::map<std::string, std::map<int, double>* > numeric_node_maps;
+    std::map<std::string, std::map<int, std::string>* > string_node_maps;
+
+    std::map<std::string, std::map<int, double>* > numeric_edge_maps;
+    std::map<std::string, std::map<int, std::string>* > string_edge_maps;
+
+    std::map<int, XY> node_coord_map;
+    std::map<int, XY> arrow_coord_map;
+
+    SpecMapSaveOpts::Dest node_coords_save_dest;
+    SpecMapSaveOpts::MapNum node_coords_save_map_num;
+    std::string node_coords_one_map_name;
+    std::string node_coords_two_maps_1_name;
+    std::string node_coords_two_maps_2_name;
+
+    SpecMapSaveOpts::Dest arrow_coords_save_dest;
+    SpecMapSaveOpts::MapNum arrow_coords_save_map_num;
+    std::string arrow_coords_one_map_name;
+    std::string arrow_coords_two_maps_1_name;
+    std::string arrow_coords_two_maps_2_name;
+
+    ~GUISectData()
+    {
+      using std::map;
+      using std::vector;
+      using std::pair;
+      using std::string;
+
+      for (map<string, map<int, double>* >::iterator it =
+          numeric_node_maps.begin(); it != numeric_node_maps.end(); ++it)
+      {
+        delete it->second;
+      }
+      for (map<string, map<int, string>* >::iterator it =
+          string_node_maps.begin(); it != string_node_maps.end(); ++it)
+      {
+        delete it->second;
+      }
+      for (map<string, map<int, double>* >::iterator it =
+          numeric_edge_maps.begin(); it != numeric_edge_maps.end(); ++it)
+      {
+        delete it->second;
+      }
+      for (map<string, map<int, string>* >::iterator it =
+          string_edge_maps.begin(); it != string_edge_maps.end(); ++it)
+      {
+        delete it->second;
+      }
+    }
+  };
+public:
   ///The graph for which the datas are stored.
   Graph graph;
+  const Graph& getGraph();
+
+private:
+  GuiSectSaveDest gui_sect_save_dest;
+
+  SpecMapSaveOpts::Dest node_coords_save_dest;
+  SpecMapSaveOpts::MapNum node_coords_save_map_num;
+  SpecMapSaveOpts::Dest arrow_coords_save_dest;
+  SpecMapSaveOpts::MapNum arrow_coords_save_map_num;
+
+  NodeMapStore nodemaps;
+  EdgeMapStore edgemaps;
+
+  NodeLabelMap node_label;
+  EdgeLabelMap edge_label;
+
   /// the coordinates of the nodes
-  XYMap<Graph::NodeMap<double> > coords;
+  NodeCoordMap node_coords;
+  Graph::NodeMap<double> node_coords_x;
+  Graph::NodeMap<double> node_coords_y;
+
   /// the coordinates of the arrows on the edges
-  XYMap<Graph::EdgeMap<double> > arrow_pos;
+  ArrowCoordMap arrow_coords;
+  Graph::EdgeMap<double> arrow_coords_x;
+  Graph::EdgeMap<double> arrow_coords_y;
 
   ///The content of the object has changed, update is needed.
@@ -60 +268 @@
   std::string file_name;
 
-  ///Stores double type NodeMaps
-  std::map< std::string,Graph::NodeMap<double> * > nodemap_storage;
-
-  ///Stores double type EdgeMaps
-  std::map< std::string,Graph::EdgeMap<double> * > edgemap_storage;
-
+  // the largest node label
+  int max_node_label;
+
+  // the largest edge label
+  int max_edge_label;
+
+  std::string node_coords_one_map_name;
+  std::string node_coords_two_maps_1_name;
+  std::string node_coords_two_maps_2_name;
+
+  std::string arrow_coords_one_map_name;
+  std::string arrow_coords_two_maps_1_name;
+  std::string arrow_coords_two_maps_2_name;
+
+public:
   ///Stores the default values for the different visualization node attributes
   std::vector<Graph::NodeMap<double> > default_nodemaps;
@@ -77 +294 @@
   /// 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;
-
-  /// Default values for the maps
-  std::map< std::string, double > edgemap_default;
-
-  bool arrow_pos_read_ok;
 
 protected:
@@ -99 +308 @@
   /// std::string is the
   ///name of the new map
-  sigc::signal<void, std::string> signal_node_map;
+  sigc::signal<void, std::string, MapValue::Type> signal_node_map;
 
   /// Signal emitted in the case of edgemap addition
@@ -105 +314 @@
   /// std::string is the
   ///name of the new map
-  sigc::signal<void, std::string> signal_edge_map;
+  sigc::signal<void, std::string, MapValue::Type> signal_edge_map;
 
   /// Signal emitted, when entry in \ref MapWin should be changed.
@@ -165 +374 @@
 
   /// Returns the names of the edgemaps stored here.
-  std::vector<std::string> getEdgeMapList();
+  std::vector<std::string> getEdgeMapList(MapType type = ALL);
 
   /// Returns the names of the nodemaps stored here.
-  std::vector<std::string> getNodeMapList();
+  std::vector<std::string> getNodeMapList(MapType type = ALL);
 
   ///returns \ref signal_prop to be able to connect functions to it
@@ -174 +383 @@
 
 &nb