/* -*- 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 copies. 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 <nbtab.h>

#include <mapstorage.h>

#include <eps_win.h>

#include <map_win.h>

#include <design_win.h>

#include <graph_displayer_canvas.h>

NoteBookTab::NoteBookTab():mapwinexists(false), designwinexists(false), epswinexists(false)

{

  mapstorage=new MapStorage();

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

  gd_canvas=new GraphDisplayerCanvas(*this);

  pScrolledWindow->add(*gd_canvas);

  add(*pScrolledWindow);

  //connecting signals - controller character

  mapstorage->signal_prop_ch().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::propertyChange));

  mapstorage->signal_node_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewNodeMap));

  mapstorage->signal_edge_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewEdgeMap));

  mapstorage->signal_background_ch().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::setBackground));

  show_all_children();

  show();

}

void NoteBookTab::readFile(const std::string &file)

{

  mapstorage->readFromFile(file);

  mapstorage->file_name = file;

  mapstorage->modified = false;

  gd_canvas->drawGraph();

  if(mapwinexists)

    {

      mapwin->update(mapstorage->getEdgeMapList(), mapstorage->getNodeMapList());

    }

  title_changed(Glib::filename_display_basename(file));

}

void NoteBookTab::newFile()

{

  if (mapstorage->modified)

  {

    Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true,

        Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);

    mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);

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

    mdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);

    switch (mdialog.run())

    {

      case Gtk::RESPONSE_CANCEL:

        return;

      case Gtk::RESPONSE_REJECT:

        break;

      case Gtk::RESPONSE_ACCEPT:

        saveFile();

        break;

    }

  }

  gd_canvas->clear();

  mapstorage->clear();

  if(mapwinexists)

    {

      mapwin->update(mapstorage->getEdgeMapList(), mapstorage->getNodeMapList());

    }

  title_changed("unsaved file");

}

void NoteBookTab::openFile()

{

  if (mapstorage->modified)

  {

    Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true, 

        Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);

    mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);

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

    mdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);

    switch (mdialog.run())

    {

      case Gtk::RESPONSE_CANCEL:

        return;

      case Gtk::RESPONSE_REJECT:

        break;

      case Gtk::RESPONSE_ACCEPT:

        saveFile();

        break;

    }

  }

  Gtk::FileChooserDialog fcdialog("Open File");

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

  fcdialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);

  if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)

  {

    gd_canvas->clear();

    mapstorage->clear();

    Glib::ustring filename = fcdialog.get_filename();

    if (!mapstorage->readFromFile(filename))

    {

      mapstorage->file_name = filename;

      mapstorage->modified = false;

      gd_canvas->drawGraph();

      if(mapwinexists)

	{

	  mapwin->update(mapstorage->getEdgeMapList(), mapstorage->getNodeMapList());

	}

      title_changed(Glib::filename_display_basename(filename));

    }

  }

}

void NoteBookTab::saveFile()

{

  if (mapstorage->file_name == "") {

    saveFileAs();

  }

  else

  {

    mapstorage->writeToFile(mapstorage->file_name);

    mapstorage->modified = false;

    title_changed(Glib::filename_display_basename(mapstorage->file_name));

  }

}

void NoteBookTab::saveFileAs()

{

  Gtk::FileChooserDialog fcdialog("Save File", Gtk::FILE_CHOOSER_ACTION_SAVE);

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

  fcdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);

  if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)

  {

    Glib::ustring filename = fcdialog.get_filename();

    mapstorage->file_name = filename;

    mapstorage->writeToFile(filename);

    mapstorage->modified = false;

    title_changed(Glib::filename_display_basename(filename));

  }

}

void NoteBookTab::close()

{

  if (mapstorage->modified)

  {

    Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true,

        Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);

    mdialog.add_button("Close _without Saving", Gtk::RESPONSE_REJECT);

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

    mdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);

    switch (mdialog.run())

    {

      case Gtk::RESPONSE_CANCEL:

        return;

      case Gtk::RESPONSE_REJECT:

        break;

      case Gtk::RESPONSE_ACCEPT:

        saveFile();

        break;

    }

  }

  gd_canvas->clear();

  mapstorage->clear();

  if(mapwinexists)

    {

      mapwin->update(mapstorage->getEdgeMapList(), mapstorage->getNodeMapList());

    }

  title_changed("unsaved file");

}

void NoteBookTab::propertyChange(bool itisedge, int prop, std::string mapname)

{

  mapstorage->changeActiveMap(itisedge, prop, mapname);

}

sigc::signal<void, NoteBookTab *, bool> NoteBookTab::signal_newmap_needed()

{

  return signal_newmap;

}

void NoteBookTab::popupNewMapWin(bool itisedge)

{

  signal_newmap.emit(this, itisedge);

}

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

{

  return mapstorage->getActiveEdgeMap(prop);

}

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

{

  return mapstorage->getActiveNodeMap(prop);

}

void NoteBookTab::registerNewEdgeMap(std::string mapname)

{

  if(mapwinexists)

    {

      mapwin->registerNewEdgeMap(mapname);

    }

}

void NoteBookTab::registerNewNodeMap(std::string mapname)

{

  if(mapwinexists)

    {

      mapwin->registerNewNodeMap(mapname);

    }

  if(epswinexists)

    {

      epswin->registerNewNodeMap(mapname);

    }

}

void NoteBookTab::createMapWin(std::string name)

{

  if(!mapwinexists)

    {

      mapwin=new MapWin("Map Setup - "+name, mapstorage->getEdgeMapList(), mapstorage->getNodeMapList(), *this);

      mapst2mapwin=mapstorage->signal_map_win_ch().connect(sigc::mem_fun(*mapwin, &MapWin::changeEntry));

      mapwin->show();

      mapwinexists=true;

    }

}

void NoteBookTab::createExportToEPSWin(std::string name)

{

  if(!epswinexists)

    {

      epswin=new EpsWin("Export to EPS - "+name, mapstorage->getNodeMapList());

      epswin->show();

      epswinexists=true;

      epswin->signal_eps_details_ch().connect(sigc::mem_fun(*this, &NoteBookTab::exportGraphToEPS));

      epswin->signal_eps_close_ch().connect(sigc::mem_fun(*this, &NoteBookTab::closeEpsWin));

      epswin->signal_new_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::popupNewMapWin));

    }

}

void NoteBookTab::createDesignWin(std::string name)

{

  if(!designwinexists)

    {

      double attraction, propulsation;

      int iterations;

      mapstorage->get_design_data(attraction, propulsation, iterations);

      designwin=new DesignWin("Design Setup - "+name, attraction, propulsation, iterations);

      designwin->signal_attraction().connect(sigc::mem_fun(mapstorage, &MapStorage::set_attraction));

      designwin->signal_propulsation().connect(sigc::mem_fun(mapstorage, &MapStorage::set_propulsation));

      designwin->signal_iteration().connect(sigc::mem_fun(mapstorage, &MapStorage::set_iteration));

      designwin->close_run().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::reDesignGraph));

      designwin->signal_delete_event().connect(sigc::mem_fun(*this, &NoteBookTab::closeDesignWin));

      mapst2designwin=mapstorage->signal_design_win_ch().connect(sigc::mem_fun(*designwin, &DesignWin::set_data));

      designwin->show();

      designwinexists=true;

    }

}

void NoteBookTab::closeMapWin()

{

  mapst2mapwin.disconnect();

  mapwinexists=false;

  delete mapwin;

}

void NoteBookTab::closeEpsWin()

{

  epswinexists=false;

  delete epswin;

}

bool NoteBookTab::closeDesignWin(GdkEventAny * e)

{

  if(e->type==GDK_DELETE)

    {

      designwinexists=false;

      mapst2designwin.disconnect();

      delete designwin;

    }

}

sigc::signal<void, std::string> NoteBookTab::signal_title_ch()

{

  return signal_title;

}

void NoteBookTab::setView(bool autoscale, bool zoomtrack, double width, double radius)

{

  gd_canvas->setView(autoscale, zoomtrack, width, radius);

}

void NoteBookTab::getView(bool & autoscale, bool & zoomtrack, double& width, double& radius)

{

  gd_canvas->getView(autoscale, zoomtrack, width, radius);

}

void NoteBookTab::reDesignGraph()

{

  gd_canvas->reDesignGraph();

}

void NoteBookTab::active_maps_needed()

{

  mapstorage->broadcastActiveMaps();

}

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

{

  mapstorage->exportGraphToEPS(options, filename, shapemap);

}

void NoteBookTab::title_changed(std::string newtitle)

{

  signal_title.emit(newtitle);

  if(epswinexists)

    {

      epswin->set_title(newtitle);

    }

  if(designwinexists)

    {

      designwin->set_title(newtitle);

    }

}