mapselector.cc
branchgui
changeset 81 5ad61c33487c
child 82 ee009c0f4bcf
equal deleted inserted replaced
-1:000000000000 0:9234db283e9b
       
     1 #include "mapselector.h"
       
     2 
       
     3 MapSelector::MapSelector(GraphDisplayerCanvas & grdispc, MapStorage & mapst, MapWin & mapw, int identifier, bool edge):gdc(grdispc),ms(mapst),mw(mapw),id(identifier),itisedge(edge),default_state(true),node_to_update(INVALID),edge_to_update(INVALID)
       
     4 {
       
     5   update_list();
       
     6 
       
     7   cbt.set_active(0);
       
     8 
       
     9   //binding signal to the actual entry
       
    10   cbt.signal_changed().connect
       
    11     (
       
    12      sigc::mem_fun((*this), &MapSelector::comboChanged),
       
    13      false
       
    14      );
       
    15   
       
    16   if(itisedge)
       
    17     {
       
    18       label=new Gtk::Label(edge_property_strings[id]);
       
    19     }
       
    20   else
       
    21     {
       
    22       label=new Gtk::Label(node_property_strings[id]);
       
    23     }
       
    24 
       
    25   label->set_width_chars(longest_property_string_length);
       
    26 
       
    27   defbut=new Gtk::Button();
       
    28   defbut->set_label("Reset");
       
    29 
       
    30   defbut->signal_pressed().connect
       
    31     (
       
    32      sigc::mem_fun(*this, &MapSelector::reset)
       
    33      );
       
    34 
       
    35   newbut=new Gtk::Button(Gtk::Stock::NEW);
       
    36 
       
    37   add(*label);
       
    38 
       
    39   add(cbt);
       
    40 
       
    41   add(*defbut);
       
    42   add(*newbut);
       
    43 }
       
    44 
       
    45 void MapSelector::update_list()
       
    46 {
       
    47   cbt.clear();
       
    48   if(itisedge)
       
    49     {
       
    50       std::map< std::string,Graph::EdgeMap<double> * >::iterator emsi=ms.beginOfEdgeMaps();
       
    51       for(;emsi!=ms.endOfEdgeMaps();emsi++)
       
    52 	{
       
    53 	  cbt.append_text(emsi->first);
       
    54 	}
       
    55     }
       
    56   else
       
    57     {
       
    58       std::map< std::string,Graph::NodeMap<double> * >::iterator emsi=ms.beginOfNodeMaps();
       
    59       for(;emsi!=ms.endOfNodeMaps();emsi++)
       
    60 	{
       
    61 	  cbt.append_text(emsi->first);
       
    62 	}
       
    63     }
       
    64   cbt.prepend_text("Default values");
       
    65 }
       
    66 
       
    67 void MapSelector::comboChanged()
       
    68 {
       
    69   if(cbt.get_active_row_number()!=0)
       
    70     {
       
    71       default_state=false;
       
    72       Glib::ustring mapname = cbt.get_active_text();
       
    73       if(!(mapname.empty())) //We seem to get 2 signals, one when the text is empty.
       
    74 	{
       
    75 	  if(itisedge)
       
    76 	    {
       
    77 	      if( ( (ms.edgemap_storage).find(mapname) != (ms.edgemap_storage).end() ) )
       
    78 		{
       
    79 		  Edge edge=edge_to_update;
       
    80 		  switch(id)
       
    81 		    {
       
    82 		    case E_WIDTH:
       
    83 		      gdc.changeEdgeWidth(mapname, edge);
       
    84 		      break;
       
    85 		    case E_COLOR:
       
    86 		      gdc.changeEdgeColor(mapname, edge);
       
    87 		      break;
       
    88 		    case E_TEXT:
       
    89 		      gdc.changeEdgeText(mapname, edge);
       
    90 		      break;
       
    91 		    default:
       
    92 		      std::cerr<<"Error\n";
       
    93 		    }
       
    94 		}
       
    95 	    }
       
    96 	  else
       
    97 	    {
       
    98 	      if( ( (ms.nodemap_storage).find(mapname) != (ms.nodemap_storage).end() ) )
       
    99 		{
       
   100 		  Node node=node_to_update;
       
   101 		  switch(id)
       
   102 		    {
       
   103 		    case N_RADIUS:
       
   104 		      gdc.changeNodeRadius(mapname, node);
       
   105 		      break;
       
   106 		    case N_COLOR:
       
   107 		      gdc.changeNodeColor(mapname, node);
       
   108 		      break;
       
   109 		    case N_TEXT:
       
   110 		      gdc.changeNodeText(mapname, node);
       
   111 		      break;
       
   112 		    default:
       
   113 		      std::cerr<<"Error\n";
       
   114 		    }
       
   115 		}
       
   116 	    }
       
   117 	}
       
   118     }
       
   119   else if((!default_state)&&(cbt.get_active_row_number()==0))
       
   120     {
       
   121       reset();
       
   122     }
       
   123 }
       
   124 
       
   125 void MapSelector::reset()
       
   126 {
       
   127   default_state=true;
       
   128   cbt.set_active(0);
       
   129 
       
   130   if(itisedge)
       
   131     {
       
   132       Edge edge=edge_to_update;
       
   133       switch(id)
       
   134 	{
       
   135 	case E_WIDTH:
       
   136 	  gdc.resetEdgeWidth(edge);
       
   137 	  break;
       
   138 	case E_COLOR:
       
   139 	  gdc.resetEdgeColor(edge);
       
   140 	  break;
       
   141 	case E_TEXT:
       
   142 	  gdc.resetEdgeText(edge);
       
   143 	  break;
       
   144 	default:
       
   145 	  std::cerr<<"Error\n";
       
   146 	}
       
   147     }
       
   148   else
       
   149     {
       
   150       Node node=node_to_update;	
       
   151       switch(id)
       
   152 	{
       
   153 	case N_RADIUS:
       
   154 	  gdc.resetNodeRadius(node);
       
   155 	  break;
       
   156 	case N_COLOR:
       
   157 	  gdc.resetNodeColor(node);
       
   158 	  break;
       
   159 	case N_TEXT:
       
   160 	  gdc.resetNodeText(node);
       
   161 	  break;
       
   162 	default:
       
   163 	  std::cerr<<"Error\n";
       
   164 	}
       
   165     }
       
   166 }
       
   167 
       
   168 void MapSelector::update(Node node)
       
   169 {
       
   170   node_to_update=node;
       
   171   if(default_state)
       
   172     {
       
   173       reset();
       
   174     }
       
   175   else
       
   176     {
       
   177       comboChanged();
       
   178     }
       
   179   node_to_update=INVALID;
       
   180 }
       
   181 
       
   182 void MapSelector::update(Edge edge)
       
   183 {
       
   184   edge_to_update=edge;
       
   185   if(default_state)
       
   186     {
       
   187       reset();
       
   188     }
       
   189   else
       
   190     {
       
   191       comboChanged();
       
   192     }
       
   193   edge_to_update=INVALID;
       
   194 }
       
   195 
       
   196 Glib::ustring MapSelector::get_active_text()
       
   197 {
       
   198   return cbt.get_active_text();
       
   199 }
       
   200 
       
   201 void MapSelector::set_active_text(Glib::ustring text)
       
   202 {
       
   203   cbt.set_active_text(text);
       
   204 }
       
   205 
       
   206 void MapSelector::append_text(Glib::ustring text)
       
   207 {
       
   208   cbt.append_text(text);
       
   209 }