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

#include <lemon/lgf_reader.h>

#include <lemon/lgf_writer.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_arc_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(digraph),

  node_coords_y(digraph),

  arrow_coords_x(digraph),

  arrow_coords_y(digraph),

  node_label(digraph),

  arc_label(digraph),

  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_arcmaps.resize(EDGE_PROPERTY_NUM);

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

    {

      active_arcmaps[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(digraph, def_val);

      break;

    case MapValue::STRING:

      nodemaps[name] = new StringNodeMapData(digraph, def_val);

      break;

  }

  nodemaps[name]->default_value = def_val;

  signal_node_map.emit(name, type);

}

void MapStorage::createArcMap(const std::string& name, MapValue::Type type,

    MapValue def_val)

{

  ArcMapStore::const_iterator it = arcmaps.find(name);

  if (it != arcmaps.end())

    throw Error("Arc map " + name + " already exists.");

  switch (type)

  {

    case MapValue::NUMERIC:

      arcmaps[name] = new NumericArcMapData(digraph, def_val);

      break;

    case MapValue::STRING:

      arcmaps[name] = new StringArcMapData(digraph, def_val);

      break;

  }

  arcmaps[name]->default_value = def_val;

  signal_arc_map.emit(name, type);

}

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

{

  if(itisarc)

    {

      active_arcmaps[prop]=mapname;

    }

  else

    {

      active_nodemaps[prop]=mapname;

    }

  signal_prop.emit(itisarc, 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_arcmaps[i]);

    }

}

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

{

  return active_arcmaps[prop];

}

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

{

  return active_nodemaps[prop];

}

std::vector<std::string> MapStorage::getArcMapList(MapType type)

{

  if (type == ALL)

  {

    std::vector<std::string> ret;

    for (ArcMapStore::const_iterator it = arcmaps.begin();

        it != arcmaps.end(); ++it)

    {

      ret.push_back(it->first);

    }

    return ret;

  }

  else

  {

    std::vector<std::string> ret;

    for (ArcMapStore::const_iterator it = arcmaps.begin();

        it != arcmaps.end(); ++it)

    {

      ArcMapData* data = getArcMapData(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;

  //reading content of file

  LgfContents content(filename);

  try

    {

      content.run();

    }

  catch (Exception& error)

    {

      Gtk::MessageDialog mdialog(error.what());

      mdialog.run();

      clear();

      return 1;

    }

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

  {

    for(int i=0;i<content.extraSectionNum();i++)

      {

	if(content.extraSection(i)=="gui")

	  {

	    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

      {

	sectionReader(filename).sectionStream("gui", GuiReader(this, gui_data)).run();

        gui_sect_save_dest = LGF_FILE;

      }

      catch (Exception& error)

      {

        clear();

        return 1;

      }

    }

    else

    {

      // read the gui section from the .conf file

      try

      {

	sectionReader(filename + ".conf").sectionStream("gui", GuiReader(this, gui_data)).run();

        gui_sect_save_dest = CONF_FILE;

      }

      catch (Exception& error)

      {

        clear();

        return 1;

      }

    }

    // read the digraph 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_arc_map_names,

          gui_data.node_map_types, gui_data.arc_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(digraph); 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(digraph); 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_arc_map_names.begin();

        it != gui_data.gui_arc_map_names.end(); ++it)

    {

      string map_name = *it;

      switch (gui_data.arc_map_types[map_name])

      {

        case MapValue::NUMERIC:

          {

            createArcMap(map_name, MapValue::NUMERIC, double());

            NumericArcMap& dmap = getNumericArcMap(map_name);

            map<int, double>& smap = *gui_data.numeric_arc_maps[map_name];

            for (ArcIt e(digraph); e != INVALID; ++e)

            {

              dmap[e] = smap[arc_label[e]];

            }

            break;

          }

        case MapValue::STRING:

          {

            createArcMap(map_name, MapValue::STRING, string());

            StringArcMap& dmap = getStringArcMap(map_name);

            map<int, string>& smap = *gui_data.string_arc_maps[map_name];

            for (ArcIt e(digraph); e != INVALID; ++e)

            {

              dmap[e] = smap[arc_label[e]];

            }

            break;

          }

      }

      getArcMapData(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(digraph); 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 (ArcIt e(digraph); e != INVALID; ++e)

      {

        arrow_coords.set(e, gui_data.arrow_coord_map[arc_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

    {

      if (content.nodeSectionNum() < 1)

      {

        Gtk::MessageDialog mdialog("No nodeset found in file.");

        mdialog.run();

        clear();

        return 1;

      }

      if (content.arcSectionNum() < 1)

      {

        Gtk::MessageDialog mdialog("No arcset found in file.");

        mdialog.run();

        clear();

        return 1;

      }

      std::vector<std::string> nodeMapNames = content.nodeMapNames(0);

      std::vector<std::string> arcMapNames = content.arcMapNames(0);

      bool read_arc_label = true;

      if (std::find(arcMapNames.begin(), arcMapNames.end(), "label") ==

          arcMapNames.end())

      {

        read_arc_label = false;

      }

      nodeMapNames.erase(

          std::remove(nodeMapNames.begin(), nodeMapNames.end(), "label"),

          nodeMapNames.end());

      arcMapNames.erase(

          std::remove(arcMapNames.begin(), arcMapNames.end(), "label"),

          arcMapNames.end());

      FileImportDialog::ImportData data(nodeMapNames, arcMapNames);

      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 arc and node maps

          std::vector<std::string> node_map_names;

          std::vector<std::string> arc_map_names;

          std::map<std::string, MapValue::Type> node_map_types;

          std::map<std::string, MapValue::Type> arc_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_arc_map_names.begin();

              it != data.numeric_arc_map_names.end(); ++it)

          {

            arc_map_names.push_back(*it);

            arc_map_types[*it] = MapValue::NUMERIC;

          }

          for (std::vector<std::string>::const_iterator it =

              data.string_arc_map_names.begin();

              it != data.string_arc_map_names.end(); ++it)

          {

            arc_map_names.push_back(*it);

            arc_map_types[*it] = MapValue::STRING;

          }

          readLGF(filename, read_arc_label,

              node_map_names, arc_map_names,

              node_map_types, arc_map_types,

              node_coord_xmap_name, node_coord_ymap_name,

              arrow_coord_xmap_name, arrow_coord_ymap_name);

          // generate arc labels

          if (!read_arc_label)

          {

            int l = 0;

            for (ArcIt e(digraph); e != INVALID; ++e)

            {

              arc_label[e] = l++;

            }

          }

          if (gen_node_coords)

          {

            // generate node coordinates

            int node_num = 0;

            for (NodeIt n(digraph); n != INVALID; ++n) { node_num++; }

            const double pi = 3.142;

            double step = 2 * pi / (double) node_num;

            int i = 0;

            for (NodeIt n(digraph); 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 (ArcIt e(digraph); e != INVALID; ++e)

            {

              if (digraph.source(e) == digraph.target(e))

              {

                setArrowCoords(e,

                    getNodeCoords(digraph.source(e)) + XY(0.0, 80.0));

              }

              else

              {

                setArrowCoords(e,

                    (getNodeCoords(digraph.source(e)) +

                     getNodeCoords(digraph.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(digraph); n != INVALID; ++n)

    {

      if (node_label[n] > max_node_label)

      {

        max_node_label = node_label[n];

      }

    }

  }

  // set max_arc_label

  {

    max_arc_label = std::numeric_limits<int>::min();

    for (ArcIt e(digraph); e != INVALID; ++e)

    {

      if (arc_label[e] > max_arc_label)

      {

        max_arc_label = arc_label[e];

      }

    }

  }

  return 0;

}

void MapStorage::writeToFile(const std::string &filename)

{

  // relabel nodes and arcs

  int i = 0;

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

  {

    node_label[n] = i++;

  }

  max_node_label = i-1;

  i = 0;

  for (ArcIt e(digraph); e != INVALID; ++e)

  {

    arc_label[e] = i++;

  }

  max_arc_label = i-1;

  // write .lgf file

  {

    DigraphWriter<Digraph> gwriter(filename, digraph);

    gwriter.nodeMap("label", node_label);

    gwriter.arcMap("label", arc_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.nodeMap(it->first, getNumericNodeMap(it->first));

            break;

          case MapValue::STRING:

            gwriter.nodeMap(it->first, getStringNodeMap(it->first));

            break;

        }

      }

    }

    // write arc maps

    for (ArcMapStore::const_iterator it = arcmaps.begin();

        it != arcmaps.end(); ++it)

    {

      if (it->second->save_dest == NESET_SECT)

      {

        switch (it->second->type())

        {

          case MapValue::NUMERIC:

            gwriter.arcMap(it->first, getNumericArcMap(it->first));

            break;

          case MapValue::STRING:

            gwriter.arcMap(it->first, getStringArcMap(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.nodeMap(node_coords_one_map_name + ":x",

                node_coords_x);

            gwriter.nodeMap(node_coords_one_map_name + ":y",

                node_coords_y);

            break;

          case MapStorage::SpecMapSaveOpts::TWO_MAPS:

            gwriter.nodeMap(node_coords_two_maps_1_name,

                node_coords_x);

            gwriter.nodeMap(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.arcMap(arrow_coords_one_map_name + ":x",

                arrow_coords_x);

            gwriter.arcMap(arrow_coords_one_map_name + ":y",

                arrow_coords_y);

            break;

          case MapStorage::SpecMapSaveOpts::TWO_MAPS:

            gwriter.arcMap(arrow_coords_two_maps_1_name,

                arrow_coords_x);

            gwriter.arcMap(arrow_coords_two_maps_2_name,

                arrow_coords_y);

            break;

        }

        break;

    }

    if (gui_sect_save_dest == LGF_FILE)

    {

      GuiWriter gui_writer(this);

      gui_writer.write(gwriter.ostream());

      gwriter.run();

    }

    else

    {

      gwriter.run();

    }

  }

  // write .conf file

  if (gui_sect_save_dest == CONF_FILE)

  {

    DigraphWriter<Digraph> lwriter(filename + ".conf", digraph);

    GuiWriter gui_writer(this);

    gui_writer.write(lwriter.ostream());

    lwriter.run();

  }

}

void MapStorage::clear()

{

  for (NodeMapStore::iterator it = nodemaps.begin(); it != nodemaps.end(); ++it)

  {

    delete it->second;

    nodemaps.erase(it);

  }

  for (ArcMapStore::iterator it = arcmaps.begin(); it != arcmaps.end(); ++it)

  {

    delete it->second;

    arcmaps.erase(it);

  }

  digraph.clear();

  file_name = "";

  modified = false;

  max_node_label = 0;

  max_arc_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 itisarc, std::string mapname)

{

  if(itisarc)

  {

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

    {

      if(active_arcmaps[i]==mapname)

      {

        signal_prop.emit(itisarc, i);

      }

    }

  }

  else

  {

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

    {

      if(active_nodemaps[i]==mapname)

      {

        signal_prop.emit(itisarc, 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(Arc e) const

{

  return arrow_coords[e];

}

void MapStorage::setArrowCoords(Arc 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, Arc arc) const

{

  ArcMapData* data = getArcMapData(name);

  return data->get(arc);

}

void MapStorage::set(const std::string& name, Arc arc, MapValue val)

{

  ArcMapData* data = getArcMapData(name);

  data->set(arc, 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)