/* -*- C++ -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2003-2006

  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Research Group on Combinatorial Optimization, EGRES).

  *

  * Permission to use, modify and distribute this software is granted

  * provided that this copyright notice appears in all cop	ies. For

  * precise terms see the accompanying LICENSE file.

  *

  * This software is provided "AS IS" with no warranty of any kind,

  * express or implied, and with no claim as to its suitability for any

  * purpose.

  *

  */

 #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>

 #include <gui_reader.h>

 #include <lemon/graph_to_eps.h>

 const int i_d=20;

 const double a_d=0.05;

 const double p_d=40000;

 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);

   for(int i=0;i<NODE_PROPERTY_NUM;i++)

     {

       active_nodemaps[i]="";

     }

   active_edgemaps.resize(EDGE_PROPERTY_NUM);

   for(int i=0;i<EDGE_PROPERTY_NUM;i++)

     {

       active_edgemaps[i]="";

     }

 }

 MapStorage::~MapStorage()

 {

   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);

 }

 void MapStorage::changeActiveMap(bool itisedge, int prop, std::string mapname)

 {

   if(itisedge)

     {

       active_edgemaps[prop]=mapname;

     }

   else

     {

       active_nodemaps[prop]=mapname;

     }

   signal_prop.emit(itisedge, prop);

 }

 void MapStorage::broadcastActiveMaps()

 {

   for(int i=0;i<NODE_PROPERTY_NUM;i++)

     {

       signal_map_win.emit(false, i, active_nodemaps[i]);

     }

   for(int i=0;i<EDGE_PROPERTY_NUM;i++)

     {

       signal_map_win.emit(true, i, active_edgemaps[i]);

     }

 }

 std::string MapStorage::getActiveEdgeMap(int prop)

 {

   return active_edgemaps[prop];

 }

 std::string MapStorage::getActiveNodeMap(int prop)

 {

   return active_nodemaps[prop];

 }

 std::vector<std::string> MapStorage::getEdgeMapList(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;

   }

 }

 sigc::signal<void, bool, int> MapStorage::signal_prop_ch()

 {

   return signal_prop;

 }

 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

   {

     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;

     }

     // 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

       {

         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)

     {

       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

     {

       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 (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;

   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++)

     {

       changeActiveMap(false, i, "");

       signal_map_win.emit(false, i, "");

     }

   for(int i=0;i<EDGE_PROPERTY_NUM;i++)

     {

       changeActiveMap(true, i, "");

       signal_map_win.emit(true, i, "");

     }

   attraction=a_d;

   propulsation=p_d;

   iterations=i_d;

   signal_design_win.emit(attraction, propulsation, iterations);

 }

 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);

       }

     }

   }

   else

   {

     for(int i=0;i<NODE_PROPERTY_NUM;i++)

     {

       if(active_nodemaps[i]==mapname)

       {

         signal_prop.emit(itisedge, i);

       }

     }

   }

 }

 void MapStorage::get_design_data(double & attraction_p, double & propulsation_p, int & iterations_p)

 {

   attraction_p=attraction;

   propulsation_p=propulsation;

   iterations_p=iterations;

 }

 void MapStorage::set_attraction(double attraction_p)

 {

   attraction=attraction_p;

 }

 void MapStorage::set_propulsation(double propulsation_p)

 {

   propulsation=propulsation_p;

 }

 void MapStorage::set_iteration(int iterations_p)

 {

   iterations=iterations_p;

 }

 void MapStorage::redesign_data_changed()

 {

   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();

 }

 void MapStorage::setBackground(const std::string& file_name)

 {

   if (file_name == background_file_name) return;

   if (file_name == "")

   {

     background_file_name = "";

     background_set = false;

   }

   else

   {

     background_file_name = file_name;

     background_set = true;

   }

   signal_background.emit();

 }

 const std::string& MapStorage::getBackgroundFilename()

 {

   return background_file_name;

 }

 bool MapStorage::isBackgroundSet()

 {

   return background_set;

 }

 double MapStorage::getBackgroundScaling()

 {

   return background_scaling;

 }

 void MapStorage::setBackgroundScaling(double scaling)

 {

   background_scaling = scaling;

 }

 void MapStorage::exportGraphToEPS(std::vector<bool> options, std::string filename, std::string shapemap)

 {

   Graph::NodeMap<int> _shapes(graph, 0);

   Graph::NodeMap<int> _nodeColors(graph, 0);

   Graph::EdgeMap<int> _edgeColors(graph, 0);

   Graph::NodeMap<double> _nodeSizes(graph, 6.0);

   Graph::EdgeMap<double> _edgeWidths(graph, 1.0);

   bool _drawArrows=options[ARROWS];

   bool _enableParallel=options[PAR];

   std::string emptyString="";

   Graph::NodeMap<std::string> _nodeTextMap(graph,emptyString);

   //_nodeTextMap=(Graph::NodeMap<void> *)&emptyStringMap;

   if(options[N_MAPS])

     {

       if(active_nodemaps[N_RADIUS]!="")

 	{

 	  _nodeSizes=getNumericNodeMap(active_nodemaps[N_RADIUS]);

 	}

       if(active_nodemaps[N_COLOR]!="")

 	{

 	  for(NodeIt ni(graph);ni!=INVALID;++ni)

 	    {

 	      _nodeColors[ni]=(int)get(active_nodemaps[N_COLOR], ni);

 	    }

 	}

       if(active_nodemaps[N_TEXT]!="")

 	{

 	  for(NodeIt ni(graph);ni!=INVALID;++ni)

 	    {

 	      std::ostringstream o;

 	      o << get(active_nodemaps[N_TEXT], ni);

 	      _nodeTextMap[ni]=o.str();	      

 	    }

 	}

     }

   if(options[E_MAPS])

     {

       if(active_edgemaps[E_WIDTH]!="")

 	{

 	  _edgeWidths=getNumericEdgeMap(active_edgemaps[E_WIDTH]);

 	}

       if(active_edgemaps[E_COLOR]!="")

 	{

 	  for(EdgeIt ei(graph);ei!=INVALID;++ei)

 	    {

 	      _edgeColors[ei]=(int)get(active_edgemaps[E_COLOR], ei);

 	    }

 	}

     }

   if(shapemap!="Default values")

     {

       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))

 	{

           NumericNodeMap& map = static_cast<NumericNodeMapData*>(getNodeMapData(shapemap))->map;

           for (NodeIt n(graph); n != INVALID; ++n)

           {

             _shapes[n] = static_cast<int>(map[n]);

           }

 	}

     }

   Palette palette;

   Palette paletteW(true);

   graphToEps(graph,filename).

     title("Sample .eps figure (fits to A4)").

     copyright("(C) 2006 LEMON Project").

     absoluteNodeSizes().absoluteEdgeWidths().

     nodeScale(2).nodeSizes(_nodeSizes).

     coords(node_coords).

     nodeShapes(_shapes).

     nodeColors(composeMap(paletteW,_nodeColors)).

     edgeColors(composeMap(palette,_edgeColors)).

     edgeWidthScale(0.3).edgeWidths(_edgeWidths).

     nodeTexts(_nodeTextMap).nodeTextSize(7).

     enableParallel(_enableParallel).parEdgeDist(5).

     drawArrows(_drawArrows).arrowWidth(7).arrowLength(7).

     run();

 }