#include "file_import_dialog.h"

#include <gtkmm/dialog.h>

#include <gtkmm/stock.h>

#include <gtkmm/notebook.h>

#include <gtkmm/messagedialog.h>

#include <gtkmm/frame.h>

#include <iostream>

FileImportDialog::FileImportDialog(ImportData* d) :

  p_data(d)

{

  add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

  add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

  Gtk::VBox* pVBox = get_vbox();

  Gtk::Notebook* nb = Gtk::manage(new Gtk::Notebook);

  pVBox->pack_start(*nb, Gtk::PACK_EXPAND_WIDGET);

  Gtk::VBox* vbNodeMaps = Gtk::manage(new Gtk::VBox(false, 18));

  vbNodeMaps->set_border_width(12);

  Gtk::VBox* vbEdgeMaps = Gtk::manage(new Gtk::VBox(false, 18));

  vbEdgeMaps->set_border_width(12);

  Gtk::VBox* vbSpecMaps = Gtk::manage(new Gtk::VBox(false, 18));

  vbSpecMaps->set_border_width(12);

  nb->append_page(*vbSpecMaps, "Special Maps");

  nb->append_page(*vbNodeMaps, "Node Maps");

  nb->append_page(*vbEdgeMaps, "Edge Maps");

  // child widgets of vbSpecMaps

  {

    Gtk::VBox* box1 = Gtk::manage(new Gtk::VBox(false, 6));

    vbSpecMaps->pack_start(*box1, Gtk::PACK_SHRINK);

    {

      Gtk::Label* label1 =

        Gtk::manage(new Gtk::Label("<b>Node Coordinates</b>"));

      label1->set_alignment(Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER);

      label1->set_use_markup();

      box1->pack_start(*label1);

      Gtk::HBox* box2 = Gtk::manage(new Gtk::HBox);

      box1->pack_start(*box2);

      Gtk::Label* fill1 = Gtk::manage(new Gtk::Label("    "));

      box2->pack_start(*fill1, Gtk::PACK_SHRINK);

      Gtk::VBox* box3 = Gtk::manage(new Gtk::VBox);

      box2->pack_start(*box3);

      Gtk::VBox* box13 = Gtk::manage(new Gtk::VBox);

      box3->pack_start(*box13);

      rbNodeCoordNone.set_label("None");

      Gtk::RadioButtonGroup group = rbNodeCoordNone.get_group();

      box13->pack_start(rbNodeCoordNone);

      Gtk::VBox* box4 = Gtk::manage(new Gtk::VBox);

      box3->pack_start(*box4);

      rbNodeCoordOneMap.set_label("One Map");

      rbNodeCoordOneMap.set_group(group);

      box4->pack_start(rbNodeCoordOneMap);

      Gtk::HBox* box5 = Gtk::manage(new Gtk::HBox);

      box4->pack_start(*box5);

      Gtk::Label* fill2 = Gtk::manage(new Gtk::Label("    "));

      box5->pack_start(*fill2, Gtk::PACK_SHRINK);

      Gtk::VBox* box6 = Gtk::manage(new Gtk::VBox);

      box5->pack_start(*box6);

      Gtk::HBox* box7 = Gtk::manage(new Gtk::HBox);

      box6->pack_start(*box7);

      Gtk::Label* label2 = Gtk::manage(new Gtk::Label("(X, Y)"));

      box7->pack_start(*label2, Gtk::PACK_SHRINK, 4);

      box7->pack_start(cbNodeCoordOneMap, Gtk::PACK_EXPAND_WIDGET);

      Gtk::VBox* box8 = Gtk::manage(new Gtk::VBox);

      box3->pack_start(*box8);

      rbNodeCoordTwoMaps.set_label("Two Maps");

      rbNodeCoordTwoMaps.set_group(group);

      box8->pack_start(rbNodeCoordTwoMaps);

      Gtk::HBox* box9 = Gtk::manage(new Gtk::HBox);

      box8->pack_start(*box9);

      Gtk::Label* fill3 = Gtk::manage(new Gtk::Label("    "));

      box9->pack_start(*fill3, Gtk::PACK_SHRINK);

      Gtk::VBox* box10 = Gtk::manage(new Gtk::VBox);

      box9->pack_start(*box10);

      Gtk::HBox* box11 = Gtk::manage(new Gtk::HBox);

      box10->pack_start(*box11);

      Gtk::Label* label3 = Gtk::manage(new Gtk::Label("X"));

      box11->pack_start(*label3, Gtk::PACK_SHRINK, 4);

      box11->pack_start(cbNodeCoordTwoMaps1, Gtk::PACK_EXPAND_WIDGET);

      Gtk::HBox* box12 = Gtk::manage(new Gtk::HBox);

      box10->pack_start(*box12);

      Gtk::Label* label4 = Gtk::manage(new Gtk::Label("Y"));

      box12->pack_start(*label4, Gtk::PACK_SHRINK, 4);

      box12->pack_start(cbNodeCoordTwoMaps2, Gtk::PACK_EXPAND_WIDGET);

      cbNodeCoordOneMap.signal_changed().connect(

          sigc::mem_fun(*this, &FileImportDialog::onNodeCoordOneMapChanged));

      cbNodeCoordTwoMaps1.signal_changed().connect(

          sigc::mem_fun(*this, &FileImportDialog::onNodeCoordTwoMaps1Changed));

      cbNodeCoordTwoMaps2.signal_changed().connect(

          sigc::mem_fun(*this, &FileImportDialog::onNodeCoordTwoMaps2Changed));

    }

    {

      Gtk::Label* label1 =

        Gtk::manage(new Gtk::Label("<b>Arrow Coordinates</b>"));

      label1->set_alignment(Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER);

      label1->set_use_markup();

      box1->pack_start(*label1);

      Gtk::HBox* box2 = Gtk::manage(new Gtk::HBox);

      box1->pack_start(*box2);

      Gtk::Label* fill1 = Gtk::manage(new Gtk::Label("    "));

      box2->pack_start(*fill1, Gtk::PACK_SHRINK);

      Gtk::VBox* box3 = Gtk::manage(new Gtk::VBox);

      box2->pack_start(*box3);

      Gtk::VBox* box13 = Gtk::manage(new Gtk::VBox);

      box3->pack_start(*box13);

      rbArrowCoordNone.set_label("None");

      Gtk::RadioButtonGroup group = rbArrowCoordNone.get_group();

      box13->pack_start(rbArrowCoordNone);

      Gtk::VBox* box4 = Gtk::manage(new Gtk::VBox);

      box3->pack_start(*box4);

      rbArrowCoordOneMap.set_label("One Map");

      rbArrowCoordOneMap.set_group(group);

      box4->pack_start(rbArrowCoordOneMap);

      Gtk::HBox* box5 = Gtk::manage(new Gtk::HBox);

      box4->pack_start(*box5);

      Gtk::Label* fill2 = Gtk::manage(new Gtk::Label("    "));

      box5->pack_start(*fill2, Gtk::PACK_SHRINK);

      Gtk::VBox* box6 = Gtk::manage(new Gtk::VBox);

      box5->pack_start(*box6);

      Gtk::HBox* box7 = Gtk::manage(new Gtk::HBox);

      box6->pack_start(*box7);

      Gtk::Label* label2 = Gtk::manage(new Gtk::Label("(X, Y)"));

      box7->pack_start(*label2, Gtk::PACK_SHRINK, 4);

      box7->pack_start(cbArrowCoordOneMap, Gtk::PACK_EXPAND_WIDGET);

      Gtk::VBox* box8 = Gtk::manage(new Gtk::VBox);

      box3->pack_start(*box8);

      rbArrowCoordTwoMaps.set_label("Two Maps");

      rbArrowCoordTwoMaps.set_group(group);

      box8->pack_start(rbArrowCoordTwoMaps);

      Gtk::HBox* box9 = Gtk::manage(new Gtk::HBox);

      box8->pack_start(*box9);

      Gtk::Label* fill3 = Gtk::manage(new Gtk::Label("    "));

      box9->pack_start(*fill3, Gtk::PACK_SHRINK);

      Gtk::VBox* box10 = Gtk::manage(new Gtk::VBox);

      box9->pack_start(*box10);

      Gtk::HBox* box11 = Gtk::manage(new Gtk::HBox);

      box10->pack_start(*box11);

      Gtk::Label* label3 = Gtk::manage(new Gtk::Label("X"));

      box11->pack_start(*label3, Gtk::PACK_SHRINK, 4);

      box11->pack_start(cbArrowCoordTwoMaps1, Gtk::PACK_EXPAND_WIDGET);

      Gtk::HBox* box12 = Gtk::manage(new Gtk::HBox);

      box10->pack_start(*box12);

      Gtk::Label* label4 = Gtk::manage(new Gtk::Label("Y"));

      box12->pack_start(*label4, Gtk::PACK_SHRINK, 4);

      box12->pack_start(cbArrowCoordTwoMaps2, Gtk::PACK_EXPAND_WIDGET);

      cbArrowCoordOneMap.signal_changed().connect(

          sigc::mem_fun(*this, &FileImportDialog::onArrowCoordOneMapChanged));

      cbArrowCoordTwoMaps1.signal_changed().connect(

          sigc::mem_fun(*this, &FileImportDialog::onArrowCoordTwoMaps1Changed));

      cbArrowCoordTwoMaps2.signal_changed().connect(

          sigc::mem_fun(*this, &FileImportDialog::onArrowCoordTwoMaps2Changed));

    }

  }

  // child widgets of vbNodeMaps

  {

    Gtk::VBox* box1 = Gtk::manage(new Gtk::VBox(false, 6));

    vbNodeMaps->pack_start(*box1, Gtk::PACK_SHRINK);

    Gtk::Label* label1 =

      Gtk::manage(new Gtk::Label("<b>Element type</b>"));

    label1->set_alignment(Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER);

    label1->set_use_markup();

    box1->pack_start(*label1, Gtk::PACK_SHRINK);

    Gtk::HBox* box2 = Gtk::manage(new Gtk::HBox);

    box1->pack_start(*box2, Gtk::PACK_SHRINK);

    Gtk::Label* fill1 = Gtk::manage(new Gtk::Label("    "));

    box2->pack_start(*fill1, Gtk::PACK_SHRINK);

    Gtk::Frame* frame = Gtk::manage(new Gtk::Frame);

    box2->pack_start(*frame, Gtk::PACK_EXPAND_WIDGET);

    Gtk::ScrolledWindow* swNodeMaps = Gtk::manage(new Gtk::ScrolledWindow);

    frame->add(*swNodeMaps);

    swNodeMaps->add(twNodeMaps);

    refNodeMapStore = Gtk::ListStore::create(NodeMapColumns);

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

        p_data->node_map_names.begin(); it != p_data->node_map_names.end();

        ++it)

    {

      node_tree_view_records.push_back(

          tree_view_record(*it, false, false, true));

    }

    twNodeMaps.set_model(refNodeMapStore);

    twNodeMaps.append_column("Name", NodeMapColumns.colName);

    {

      int col = twNodeMaps.append_column_editable("Numeric",

          NodeMapColumns.colReadAsNumeric);

      Gtk::CellRendererToggle* pRenderer =

        static_cast<Gtk::CellRendererToggle*>(

            twNodeMaps.get_column_cell_renderer(col-1));

      pRenderer->signal_toggled().connect(

          sigc::mem_fun(*this, &FileImportDialog::onNodeMapNumericToggled));

    }

    {

      int col = twNodeMaps.append_column_editable("String",

          NodeMapColumns.colReadAsString);

      Gtk::CellRendererToggle* pRenderer =

        static_cast<Gtk::CellRendererToggle*>(

            twNodeMaps.get_column_cell_renderer(col-1));

      pRenderer->signal_toggled().connect(

          sigc::mem_fun(*this, &FileImportDialog::onNodeMapStringToggled));

    }

    swNodeMaps->set_size_request(-1, 200);

    swNodeMaps->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

  }

  // child widgets of vbEdgeMaps

  {

    Gtk::VBox* box1 = Gtk::manage(new Gtk::VBox(false, 6));

    vbEdgeMaps->pack_start(*box1, Gtk::PACK_SHRINK);

    Gtk::Label* label1 =

      Gtk::manage(new Gtk::Label("<b>Element type</b>"));

    label1->set_alignment(Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER);

    label1->set_use_markup();

    box1->pack_start(*label1, Gtk::PACK_SHRINK);

    Gtk::HBox* box2 = Gtk::manage(new Gtk::HBox);

    box1->pack_start(*box2, Gtk::PACK_SHRINK);

    Gtk::Label* fill1 = Gtk::manage(new Gtk::Label("    "));

    box2->pack_start(*fill1, Gtk::PACK_SHRINK);

    Gtk::Frame* frame = Gtk::manage(new Gtk::Frame);

    box2->pack_start(*frame, Gtk::PACK_EXPAND_WIDGET);

    Gtk::ScrolledWindow* swEdgeMaps = Gtk::manage(new Gtk::ScrolledWindow);

    frame->add(*swEdgeMaps);

    swEdgeMaps->add(twEdgeMaps);

    refEdgeMapStore = Gtk::ListStore::create(EdgeMapColumns);

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

        p_data->edge_map_names.begin(); it != p_data->edge_map_names.end();

        ++it)

    {

      edge_tree_view_records.push_back(

          tree_view_record(*it, false, false, true));

    }

    twEdgeMaps.set_model(refEdgeMapStore);

    twEdgeMaps.append_column("Name", EdgeMapColumns.colName);

    {

      int col = twEdgeMaps.append_column_editable("Numeric",

          EdgeMapColumns.colReadAsNumeric);

      Gtk::CellRendererToggle* pRenderer =

        static_cast<Gtk::CellRendererToggle*>(

            twEdgeMaps.get_column_cell_renderer(col-1));

      pRenderer->signal_toggled().connect(

          sigc::mem_fun(*this, &FileImportDialog::onEdgeMapNumericToggled));

    }

    {

      int col = twEdgeMaps.append_column_editable("String",

          EdgeMapColumns.colReadAsString);

      Gtk::CellRendererToggle* pRenderer =

        static_cast<Gtk::CellRendererToggle*>(

            twEdgeMaps.get_column_cell_renderer(col-1));

      pRenderer->signal_toggled().connect(

          sigc::mem_fun(*this, &FileImportDialog::onEdgeMapStringToggled));

    }

    swEdgeMaps->set_size_request(-1, 200);

    swEdgeMaps->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

  }

  // fill in the ComboBoxes

  typedef std::vector<std::string> StrVec;

  for (StrVec::const_iterator it = p_data->node_map_names.begin();

      it != p_data->node_map_names.end(); ++it)

  {

    cbNodeCoordTwoMaps1.append_text(*it);

    cbNodeCoordTwoMaps2.append_text(*it);

  }

  for (StrVec::const_iterator it = p_data->edge_map_names.begin();

      it != p_data->edge_map_names.end(); ++it)

  {

    cbArrowCoordTwoMaps1.append_text(*it);

    cbArrowCoordTwoMaps2.append_text(*it);

  }

  for (StrVec::const_iterator it = p_data->xy_node_map_names.begin();

      it != p_data->xy_node_map_names.end(); ++it)

  {

    cbNodeCoordOneMap.append_text(*it);

  }

  for (StrVec::const_iterator it = p_data->xy_edge_map_names.begin();

      it != p_data->xy_edge_map_names.end(); ++it)

  {

    cbArrowCoordOneMap.append_text(*it);

  }

  if (p_data->isXYNodeMap("coord"))

  {

    cbNodeCoordOneMap.set_active_text("coord");

  }

  else if (p_data->isXYNodeMap("coords"))

  {

    cbNodeCoordOneMap.set_active_text("coords");

  }

  else if (p_data->isNodeMap("coord_x") &&

           p_data->isNodeMap("coord_y"))

  {

    cbNodeCoordTwoMaps1.set_active_text("coord_x");

    cbNodeCoordTwoMaps2.set_active_text("coord_y");

  }

  else if (p_data->isNodeMap("coords_x") &&

           p_data->isNodeMap("coords_y"))

  {

    cbNodeCoordTwoMaps1.set_active_text("coords_x");

    cbNodeCoordTwoMaps2.set_active_text("coords_y");

  }

  else if (p_data->isNodeMap("x") &&

           p_data->isNodeMap("y"))

  {

    cbNodeCoordTwoMaps1.set_active_text("x");

    cbNodeCoordTwoMaps2.set_active_text("y");

  }

  if (p_data->isXYEdgeMap("arrow"))

  {

    cbArrowCoordOneMap.set_active_text("arrow");

  }

  else if (p_data->isXYEdgeMap("arrows"))

  {

    cbArrowCoordOneMap.set_active_text("arrows");

  }

  else if (p_data->isXYEdgeMap("midpoint"))

  {

    cbArrowCoordOneMap.set_active_text("midpoint");

  }

  else if (p_data->isXYEdgeMap("midpoints"))

  {

    cbArrowCoordOneMap.set_active_text("midpoints");

  }

  else if (p_data->isXYEdgeMap("mid"))

  {

    cbArrowCoordOneMap.set_active_text("mid");

  }

  else if (p_data->isXYEdgeMap("mids"))

  {

    cbArrowCoordOneMap.set_active_text("mids");

  }

  else if (p_data->isEdgeMap("arrow_x") &&

           p_data->isEdgeMap("arrow_y"))

  {

    cbArrowCoordTwoMaps1.set_active_text("arrow_x");

    cbArrowCoordTwoMaps2.set_active_text("arrow_y");

  }

  else if (p_data->isEdgeMap("arrows_x") &&

           p_data->isEdgeMap("arrows_y"))

  {

    cbArrowCoordTwoMaps1.set_active_text("arrows_x");

    cbArrowCoordTwoMaps2.set_active_text("arrows_y");

  }

  else if (p_data->isEdgeMap("midpoint_x") &&

           p_data->isEdgeMap("midpoint_y"))

  {

    cbArrowCoordTwoMaps1.set_active_text("midpoint_x");

    cbArrowCoordTwoMaps2.set_active_text("midpoint_y");

  }

  else if (p_data->isEdgeMap("midpoints_x") &&

           p_data->isEdgeMap("midpoints_y"))

  {

    cbArrowCoordTwoMaps1.set_active_text("midpoints_x");

    cbArrowCoordTwoMaps2.set_active_text("midpoints_y");

  }

  else if (p_data->isEdgeMap("mid_x") &&

           p_data->isEdgeMap("mid_y"))

  {

    cbArrowCoordTwoMaps1.set_active_text("mid_x");

    cbArrowCoordTwoMaps2.set_active_text("mid_y");

  }

  else if (p_data->isEdgeMap("mids_x") &&

           p_data->isEdgeMap("mids_y"))

  {

    cbArrowCoordTwoMaps1.set_active_text("mids_x");

    cbArrowCoordTwoMaps2.set_active_text("mids_y");

  }

  {

    if (cbNodeCoordOneMap.get_active_text() != "")

      rbNodeCoordOneMap.set_active();

    else if (cbNodeCoordTwoMaps1.get_active_text() != "")

      rbNodeCoordTwoMaps.set_active();

    else

      rbNodeCoordNone.set_active();

    if (cbArrowCoordOneMap.get_active_text() != "")

      rbArrowCoordOneMap.set_active();

    else if (cbArrowCoordTwoMaps1.get_active_text() != "")

      rbArrowCoordTwoMaps.set_active();

    else

      rbArrowCoordNone.set_active();

    onNodeCoordMapNumToggled();

    onArrowCoordMapNumToggled();

    rbNodeCoordOneMap.signal_toggled().connect(

        sigc::mem_fun(*this, &FileImportDialog::onNodeCoordMapNumToggled));

    rbNodeCoordTwoMaps.signal_toggled().connect(

        sigc::mem_fun(*this, &FileImportDialog::onNodeCoordMapNumToggled));

    rbArrowCoordOneMap.signal_toggled().connect(

        sigc::mem_fun(*this, &FileImportDialog::onArrowCoordMapNumToggled));

    rbArrowCoordTwoMaps.signal_toggled().connect(

        sigc::mem_fun(*this, &FileImportDialog::onArrowCoordMapNumToggled));

  }

  signal_response().connect(

      sigc::mem_fun(*this, &FileImportDialog::onResponse));

  update_node_tree_view();

  update_edge_tree_view();

  show_all_children();

}

void FileImportDialog::onNodeCoordMapNumToggled()

{

  if (rbNodeCoordOneMap.get_active())

  {

    cbNodeCoordOneMap.get_parent()->set_sensitive(true);

    cbNodeCoordTwoMaps1.get_parent()->set_sensitive(false);

    cbNodeCoordTwoMaps2.get_parent()->set_sensitive(false);

    p_data->node_coord_load_from = ImportData::ONE_MAP;

  }

  else if (rbNodeCoordTwoMaps.get_active())

  {

    cbNodeCoordOneMap.get_parent()->set_sensitive(false);

    cbNodeCoordTwoMaps1.get_parent()->set_sensitive(true);

    cbNodeCoordTwoMaps2.get_parent()->set_sensitive(true);

    p_data->node_coord_load_from = ImportData::TWO_MAPS;

  }

  else if (rbNodeCoordNone.get_active())

  {

    cbNodeCoordOneMap.get_parent()->set_sensitive(false);

    cbNodeCoordTwoMaps1.get_parent()->set_sensitive(false);

    cbNodeCoordTwoMaps2.get_parent()->set_sensitive(false);

    p_data->node_coord_load_from = ImportData::DONT_READ;

  }

  update_node_tree_view();

}

void FileImportDialog::onArrowCoordMapNumToggled()

{

  if (rbArrowCoordOneMap.get_active())

  {

    cbArrowCoordOneMap.get_parent()->set_sensitive(true);

    cbArrowCoordTwoMaps1.get_parent()->set_sensitive(false);

    cbArrowCoordTwoMaps2.get_parent()->set_sensitive(false);

    p_data->arrow_coord_load_from = ImportData::ONE_MAP;

  }

  else if (rbArrowCoordTwoMaps.get_active())

  {

    cbArrowCoordOneMap.get_parent()->set_sensitive(false);

    cbArrowCoordTwoMaps1.get_parent()->set_sensitive(true);

    cbArrowCoordTwoMaps2.get_parent()->set_sensitive(true);

    p_data->arrow_coord_load_from = ImportData::TWO_MAPS;

  }

  else if (rbArrowCoordNone.get_active())

  {

    cbArrowCoordOneMap.get_parent()->set_sensitive(false);

    cbArrowCoordTwoMaps1.get_parent()->set_sensitive(false);

    cbArrowCoordTwoMaps2.get_parent()->set_sensitive(false);

    p_data->arrow_coord_load_from = ImportData::DONT_READ;

  }

  update_edge_tree_view();

}

FileImportDialog::~FileImportDialog()

{

}

void FileImportDialog::onResponse(int id)

{

  if (id == Gtk::RESPONSE_OK)

  {

    if ((rbNodeCoordOneMap.get_active() &&

          cbNodeCoordOneMap.get_active_text() == "") ||

        (rbNodeCoordTwoMaps.get_active() &&

         (cbNodeCoordTwoMaps1.get_active_text() == "" ||

          cbNodeCoordTwoMaps2.get_active_text() == "")))

    {

      Gtk::MessageDialog mdialog("No node map selected.",

          false, Gtk::MESSAGE_ERROR);

      mdialog.run();

      return;

    }

    else if (rbNodeCoordTwoMaps.get_active() &&

             cbNodeCoordTwoMaps1.get_active_text() == 

             cbNodeCoordTwoMaps2.get_active_text())

    {

      Gtk::MessageDialog mdialog(

          "Same node map selected for both coordinates.",

          false, Gtk::MESSAGE_ERROR);

      mdialog.run();

      return;

    }

    if ((rbArrowCoordOneMap.get_active() &&

          cbArrowCoordOneMap.get_active_text() == "") ||

        (rbArrowCoordTwoMaps.get_active() &&

         (cbArrowCoordTwoMaps1.get_active_text() == "" ||

          cbArrowCoordTwoMaps2.get_active_text() == "")))

    {

      Gtk::MessageDialog mdialog("No edge map selected.",

          false, Gtk::MESSAGE_ERROR);

      mdialog.run();

      return;

    }

    else if (rbArrowCoordTwoMaps.get_active() &&

             cbArrowCoordTwoMaps1.get_active_text() == 

             cbArrowCoordTwoMaps2.get_active_text())

    {

      Gtk::MessageDialog mdialog(

          "Same edge map selected for both coordinates.",

          false, Gtk::MESSAGE_ERROR);

      mdialog.run();

      return;

    }

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

        node_tree_view_records.begin(); it != node_tree_view_records.end();

        ++it)

    {

      if (it->visible)

      {

        if (it->numeric)

          p_data->numeric_node_map_names.push_back(it->name);

        if (it->string)

          p_data->string_node_map_names.push_back(it->name);

      }

    }

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

        edge_tree_view_records.begin(); it != edge_tree_view_records.end();

        ++it)

    {

      if (it->visible)

      {

        if (it->numeric)

          p_data->numeric_edge_map_names.push_back(it->name);

        if (it->string)

          p_data->string_edge_map_names.push_back(it->name);

      }

    }

  }

}

FileImportDialog::ImportData::ImportData(

    const std::vector<std::string>& _node_map_names,

    const std::vector<std::string>& _edge_map_names) :

  node_map_names(_node_map_names),

  edge_map_names(_edge_map_names)

{

  typedef std::vector<std::string> StrVec;

  {

    StrVec xMaps;

    StrVec yMaps;

    // collect map names ending with ":x" and ":y"

    for (StrVec::const_iterator it = node_map_names.begin();

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

    {

      if ((it->length() >= 3) &&

          (it->substr(it->length()-2, it->length())  == ":x"))

      {

        xMaps.push_back(it->substr(0, it->length()-2));

      }

      if ((it->length() >= 3) &&

          (it->substr(it->length()-2, it->length())  == ":y"))

      {

        yMaps.push_back(it->substr(0, it->length()-2));

      }

    }

    for (StrVec::const_iterator it1 = xMaps.begin();

        it1 != xMaps.end(); ++it1)

    {

      for (StrVec::const_iterator it2 = yMaps.begin();

          it2 != yMaps.end(); ++it2)

      {

        if (*it1 == *it2) xy_node_map_names.push_back(*it1);

      }

    }

  }

  {

    StrVec xMaps;

    StrVec yMaps;

    // collect map names ending with ":x" and ":y"

    for (StrVec::const_iterator it = edge_map_names.begin();

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

    {

      if ((it->length() >= 3) &&

          (it->substr(it->length()-2, it->length())  == ":x"))

      {

        xMaps.push_back(it->substr(0, it->length()-2));

      }

      if ((it->length() >= 3) &&

          (it->substr(it->length()-2, it->length())  == ":y"))

      {

        yMaps.push_back(it->substr(0, it->length()-2));

      }

    }

    for (StrVec::const_iterator it1 = xMaps.begin();

        it1 != xMaps.end(); ++it1)

    {

      for (StrVec::const_iterator it2 = yMaps.begin();

          it2 != yMaps.end(); ++it2)

      {

        if (*it1 == *it2) xy_edge_map_names.push_back(*it1);

      }

    }

  }

}

FileImportDialog::ImportData::~ImportData()

{

}

bool FileImportDialog::ImportData::isXYNodeMap(const std::string& name)

{

  if (isNodeMap(name + ":x") && isNodeMap(name + ":y")) return true;

  return false;

}

bool FileImportDialog::ImportData::isXYEdgeMap(const std::string& name)

{

  if (isEdgeMap(name + ":x") && isEdgeMap(name + ":y")) return true;

  return false;

}

bool FileImportDialog::ImportData::isNodeMap(const std::string& name)

{

  if (contains(node_map_names, name)) return true;

  return false;

}

bool FileImportDialog::ImportData::isEdgeMap(const std::string& name)

{

  if (contains(edge_map_names, name)) return true;

  return false;

}

bool FileImportDialog::ImportData::contains(const std::vector<std::string>& vec,

    const std::string& str)

{

  for (std::vector<std::string>::const_iterator it = vec.begin();

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

  {

    if (*it == str) return true;

  }

  return false;

}

void FileImportDialog::onNodeCoordOneMapChanged()

{

  p_data->node_coord_one_map_name = cbNodeCoordOneMap.get_active_text();

  update_node_tree_view();

}

void FileImportDialog::onNodeCoordTwoMaps1Changed()

{

  p_data->node_coord_two_maps_1_name = cbNodeCoordTwoMaps1.get_active_text();

  update_node_tree_view();

}

void FileImportDialog::onNodeCoordTwoMaps2Changed()

{

  p_data->node_coord_two_maps_2_name = cbNodeCoordTwoMaps2.get_active_text();

  update_node_tree_view();

}

void FileImportDialog::onArrowCoordOneMapChanged()

{

  p_data->arrow_coord_one_map_name = cbArrowCoordOneMap.get_active_text();

  update_edge_tree_view();

}

void FileImportDialog::onArrowCoordTwoMaps1Changed()

{

  p_data->arrow_coord_two_maps_1_name = cbArrowCoordTwoMaps1.get_active_text();

  update_edge_tree_view();

}

void FileImportDialog::onArrowCoordTwoMaps2Changed()

{

  p_data->arrow_coord_two_maps_2_name = cbArrowCoordTwoMaps2.get_active_text();

  update_edge_tree_view();

}

void FileImportDialog::onNodeMapNumericToggled(const Glib::ustring& path)

{

  Gtk::TreeModel::iterator iter = refNodeMapStore->get_iter(

      Gtk::TreeModel::Path(path));

  Gtk::TreeModel::Row row = *iter;

  std::vector<tree_view_record>::iterator it;

  for (it = node_tree_view_records.begin();

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

  {

    if (it->name == row[NodeMapColumns.colName]) break;

  }

  if (row[NodeMapColumns.colReadAsNumeric])

  {

    row[NodeMapColumns.colReadAsString] = false;

    it->string = false;

    it->numeric = true;

  }

}

void FileImportDialog::onNodeMapStringToggled(const Glib::ustring& path)

{

  Gtk::TreeModel::iterator iter = refNodeMapStore->get_iter(

      Gtk::TreeModel::Path(path));

  Gtk::TreeModel::Row row = *iter;

  std::vector<tree_view_record>::iterator it;

  for (it = node_tree_view_records.begin();

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

  {

    if (it->name == row[NodeMapColumns.colName]) break;

  }

  if (row[NodeMapColumns.colReadAsString])

  {

    row[NodeMapColumns.colReadAsNumeric] = false;

    it->string = true;

    it->numeric = false;

  }

}

void FileImportDialog::update_node_tree_view()

{

  for (std::vector<tree_view_record>::iterator it =

      node_tree_view_records.begin(); it != node_tree_view_records.end(); ++it)

  {

    it->visible = true;

  }

  switch (p_data->node_coord_load_from)

  {

    case ImportData::ONE_MAP:

      for (std::vector<tree_view_record>::iterator it =

          node_tree_view_records.begin(); it !=

          node_tree_view_records.end(); ++it)

      {

        if (it->name == p_data->node_coord_one_map_name)

          it->visible = false;

      }

      break;

    case ImportData::TWO_MAPS:

      for (std::vector<tree_view_record>::iterator it =

          node_tree_view_records.begin(); it !=

          node_tree_view_records.end(); ++it)

      {

        if ((it->name == p_data->node_coord_two_maps_1_name) ||

            (it->name == p_data->node_coord_two_maps_2_name))

          it->visible = false;

      }

      break;

    case ImportData::DONT_READ:

      break;

  }

  refNodeMapStore->clear();

  for (std::vector<tree_view_record>::iterator it =

      node_tree_view_records.begin(); it != node_tree_view_records.end(); ++it)

  {

    if (it->visible)

    {

      Gtk::TreeModel::Row row = *(refNodeMapStore->append());

      row[NodeMapColumns.colName] = it->name;

      row[NodeMapColumns.colReadAsNumeric] = it->numeric;

      row[NodeMapColumns.colReadAsString] = it->string;

    }

  }

}

void FileImportDialog::onEdgeMapNumericToggled(const Glib::ustring& path)

{

  Gtk::TreeModel::iterator iter = refEdgeMapStore->get_iter(

      Gtk::TreeModel::Path(path));

  Gtk::TreeModel::Row row = *iter;

  std::vector<tree_view_record>::iterator it;

  for (it = edge_tree_view_records.begin();

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

  {

    if (it->name == row[EdgeMapColumns.colName]) break;

  }

  if (row[EdgeMapColumns.colReadAsNumeric])

  {

    row[EdgeMapColumns.colReadAsString] = false;

    it->string = false;

    it->numeric = true;

  }

}

void FileImportDialog::onEdgeMapStringToggled(const Glib::ustring& path)

{

  Gtk::TreeModel::iterator iter = refEdgeMapStore->get_iter(

      Gtk::TreeModel::Path(path));

  Gtk::TreeModel::Row row = *iter;

  std::vector<tree_view_record>::iterator it;

  for (it = edge_tree_view_records.begin();

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

  {

    if (it->name == row[EdgeMapColumns.colName]) break;

  }

  if (row[EdgeMapColumns.colReadAsString])

  {

    row[EdgeMapColumns.colReadAsNumeric] = false;

    it->string = true;

    it->numeric = false;

  }

}

void FileImportDialog::update_edge_tree_view()

{

  for (std::vector<tree_view_record>::iterator it =

      edge_tree_view_records.begin(); it != edge_tree_view_records.end(); ++it)

  {

    it->visible = true;

  }

  switch (p_data->arrow_coord_load_from)

  {

    case ImportData::ONE_MAP:

      for (std::vector<tree_view_record>::iterator it =

          edge_tree_view_records.begin(); it !=

          edge_tree_view_records.end(); ++it)

      {

        if (it->name == p_data->arrow_coord_one_map_name)

          it->visible = false;

      }

      break;

    case ImportData::TWO_MAPS:

      for (std::vector<tree_view_record>::iterator it =

          edge_tree_view_records.begin(); it !=

          edge_tree_view_records.end(); ++it)

      {

        if ((it->name == p_data->arrow_coord_two_maps_1_name) ||

            (it->name == p_data->arrow_coord_two_maps_2_name))

          it->visible = false;

      }

      break;

    case ImportData::DONT_READ:

      break;

  }

  refEdgeMapStore->clear();

  for (std::vector<tree_view_record>::iterator it =

      edge_tree_view_records.begin(); it != edge_tree_view_records.end(); ++it)

  {

    if (it->visible)

    {

      Gtk::TreeModel::Row row = *(refEdgeMapStore->append());

      row[EdgeMapColumns.colName] = it->name;

      row[EdgeMapColumns.colReadAsNumeric] = it->numeric;

      row[EdgeMapColumns.colReadAsString] = it->string;

    }

  }

}