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

}