#include <map_win.h>

 #include <set>

 bool MapWin::closeIfEscapeIsPressed(GdkEventKey* e)

 {

   if(e->keyval==GDK_Escape)

   {

     hide();

   }

   return true;

 }

 MapWin::MapWin(const std::string& title, MapStorage & mapst, GraphDisplayerCanvas & grdispc):gdc(grdispc),ms(mapst)

 {

   set_title(title);

   set_default_size(200, 50);

   signal_key_press_event().connect(sigc::mem_fun(*this, &MapWin::closeIfEscapeIsPressed));

   e_combo_array=new Gtk::Combo [EDGE_PROPERTY_NUM];

   table=new Gtk::Table(EDGE_PROPERTY_NUM, 2, false);

   for(int i=0;i<EDGE_PROPERTY_NUM;i++)

   {

     //filling in combo box with choices

     std::list<Glib::ustring> listStrings;

     listStrings.push_back("Default");

     std::map< std::string,Graph::EdgeMap<double> * >::iterator emsi=ms.beginOfEdgeMaps();

     for(;emsi!=ms.endOfEdgeMaps();emsi++)

     {

 	listStrings.push_back(emsi->first);

     }

     e_combo_array[i].set_popdown_strings(listStrings);

     //Restrict it to these choices only:

     e_combo_array[i].set_value_in_list();

     //binding signal to the actual entry

     e_combo_array[i].get_entry()->signal_changed().connect

     (

      sigc::bind

      (

       sigc::mem_fun(*this, &MapWin::eComboChanged),

       i

      )

     );

     //placing actual entry in the right place

     label=new Gtk::Label;

     label->set_text(edge_property_strings[i]);

     (*table).attach(*label,0,1,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);

     (*table).attach(e_combo_array[i],1,2,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);

   }

   vbox.pack_start(*(new Gtk::Label("Edge properties")));

   vbox.pack_start(*table);

   vbox.pack_start(*(new Gtk::HSeparator));

   n_combo_array=new Gtk::Combo [NODE_PROPERTY_NUM];

   table=new Gtk::Table(NODE_PROPERTY_NUM, 2, false);

   for(int i=0;i<NODE_PROPERTY_NUM;i++)

   {

     //filling in combo box with choices

     std::list<Glib::ustring> listStrings;

     listStrings.push_back("Default");

     std::map< std::string,Graph::NodeMap<double> * >::iterator emsi=ms.beginOfNodeMaps();

     for(;emsi!=ms.endOfNodeMaps();emsi++)

     {

       listStrings.push_back(emsi->first);

     }

     n_combo_array[i].set_popdown_strings(listStrings);

     //Restrict it to these choices only:

     n_combo_array[i].set_value_in_list();

     //binding signal to thew actual entry

     n_combo_array[i].get_entry()->signal_changed().connect

     (

      sigc::bind

      (

       sigc::mem_fun(*this, &MapWin::nComboChanged),

       i

      )

     );

     //placing actual entry in the right place

     label=new Gtk::Label;

     label->set_text(node_property_strings[i]);

     (*table).attach(*label,0,1,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);

     (*table).attach(n_combo_array[i],1,2,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);

   }

   add(vbox);

   vbox.pack_start(*(new Gtk::Label("Node properties")));

   vbox.pack_start(*table);

   show_all_children();

 }

 void MapWin::eComboChanged(int prop)

 {

   Gtk::Entry* entry = e_combo_array[prop].get_entry();

   if(entry)

   {

     Glib::ustring mapname = entry->get_text();

     if(!(mapname.empty())) //We seem to get 2 signals, one when the text is empty.

     {

       if( ( (ms.edgemap_storage).find(mapname) != (ms.edgemap_storage).end() ) || (mapname=="Default") )

       {

 	switch(prop)

 	{

           case E_WIDTH:

 	    gdc.changeEdgeWidth(mapname);

 	    break;

           case E_COLOR:

 	    gdc.changeEdgeColor(mapname);

 	    break;

           case E_TEXT:

 	    gdc.changeEdgeText(mapname);

 	    break;

           default:

 	    std::cout<<"Error\n";

 	}

       }

     }

   }

 };

 void MapWin::nComboChanged(int prop)

 {

   Gtk::Entry* entry = n_combo_array[prop].get_entry();

   if(entry)

   {

     Glib::ustring mapname = entry->get_text();

     if(!(mapname.empty())) //We seem to get 2 signals, one when the text is empty.

     {

       if( ( (ms.nodemap_storage).find(mapname) != (ms.nodemap_storage).end() ) || (mapname=="Default") )

       {

 	switch(prop)

 	{

           case N_RADIUS:

 	    gdc.changeNodeRadius(mapname);

 	    break;

           case N_COLOR:

 	    gdc.changeNodeColor(mapname);

 	    break;

           case N_TEXT:

 	    gdc.changeNodeText(mapname);

 	    break;

           default:

 	    std::cout<<"Error\n";

 	}

       }

     }

   }

 };

 void MapWin::updateNode(Graph::Node node)

 {

   for(int i=0;i<NODE_PROPERTY_NUM;i++)

     {

       Gtk::Entry* entry = n_combo_array[i].get_entry();

       if(entry)

 	{

 	  Glib::ustring mapname = entry->get_text();

 	  if(!(mapname.empty())) //We seem to get 2 signals, one when the text is empty.

 	    {

 	      if( ( (ms.nodemap_storage).find(mapname) != (ms.nodemap_storage).end() ) || (mapname=="Default") )

 		{

 		  switch(i)

 		    {

 		    case N_RADIUS:

 		      gdc.changeNodeRadius(mapname, node);

 		      break;

 		    case N_COLOR:

 		      gdc.changeNodeColor(mapname, node);

 		      break;

 		    case N_TEXT:

 		      gdc.changeNodeText(mapname, node);

 		      break;

 		    default:

 		      std::cout<<"Error\n";

 		    }

 		}

 	    }

 	}

     }

 }

 void MapWin::updateEdge(Graph::Edge edge)

 {

   for(int i=0;i<EDGE_PROPERTY_NUM;i++)

     {

       Gtk::Entry* entry = e_combo_array[i].get_entry();

       if(entry)

 	{

 	  Glib::ustring mapname = entry->get_text();

 	  if(!(mapname.empty())) //We seem to get 2 signals, one when the text is empty.

 	    {

 	      if( ( (ms.edgemap_storage).find(mapname) != (ms.edgemap_storage).end() ) || (mapname=="Default") )

 		{

 		  switch(i)

 		    {

 		    case E_WIDTH:

 		      gdc.changeEdgeWidth(mapname, edge);

 		      break;

 		    case E_COLOR:

 		      gdc.changeEdgeColor(mapname, edge);

 		      break;

 		    case E_TEXT:

 		      gdc.changeEdgeText(mapname, edge);

 		      break;

 		    default:

 		      std::cout<<"Error\n";

 		    }

 		}

 	    }

 	}

     }

 }

 void MapWin::registerNewEdgeMap(std::string)

 {

   std::cout << "void MapWin::registerNewEdgeMap(std::string) is not yet implemented" << std::endl;

 }

 void MapWin::registerNewNodeMap(std::string)

 {

   std::cout << "void MapWin::registerNewNodeMap(std::string) is not yet implemented" << std::endl;

 }