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

     }

 }