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

 NoteBookTab::NoteBookTab():mapwinexists(false), designwinexists(false), mapstorage(*this)

 {

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

   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());

     }

   signal_title.emit(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());

     }

   signal_title.emit("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());

 	}

       signal_title.emit(Glib::filename_display_basename(filename));

     }

   }

 }

 void NoteBookTab::saveFile()

 {

   if (mapstorage.file_name == "") {

     saveFileAs();

   }

   else

   {

     mapstorage.writeToFile(mapstorage.file_name);

     mapstorage.modified = false;

     signal_title.emit(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;

     signal_title.emit(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());

     }

   signal_title.emit("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);

     }

 }

 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, *this);

       epswin->show();

       epswinexists=true;

     }

 }

 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, *this);

       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)

 {

   mapstorage.exportGraphToEPS(options, filename);

 }