mapselector.cc
changeset 201 879e47e5b731
parent 194 6b2b718420eb
equal deleted inserted replaced
8:b8baf07a5ab3 9:d6e35c5fc358
    16  *
    16  *
    17  */
    17  */
    18 
    18 
    19 #include <mapselector.h>
    19 #include <mapselector.h>
    20 
    20 
    21 MapSelector::MapSelector(std::vector<std::string> ml, std::string act, std::string labeltext, bool edge, bool d):def(d),itisedge(edge),set_new_map(false)
    21 MapSelector::MapSelector(std::vector<std::string> n_ml,
       
    22     std::vector<std::string> s_ml, std::string act,
       
    23     std::string labeltext, bool edge, bool d, MapType type) :
       
    24   def(d),
       
    25   itisedge(edge),
       
    26   set_new_map(false),
       
    27   label(labeltext),
       
    28   map_type(type),
       
    29   newbut(Gtk::Stock::NEW)
    22 {
    30 {
    23   update_list(ml);
    31   update_list(n_ml, s_ml);
    24 
    32 
    25   if(act=="")
    33   if(act=="")
    26     {
    34   {
    27       cbt.set_active(0);
    35     cbt.set_active(0);
    28       default_state=true;
    36     default_state=true;
    29     }
    37   }
    30   else
    38   else
    31     {
    39   {
    32       cbt.set_active_text((Glib::ustring)act);
    40     cbt.set_active_text((Glib::ustring)act);
    33       default_state=false;
    41     default_state=false;
    34     }
    42   }
    35 
    43 
    36   //binding signal to the actual entry
    44   //binding signal to the actual entry
    37   cbt.signal_changed().connect
    45   cbt.signal_changed().connect
    38     (
    46     (
    39      sigc::mem_fun((*this), &MapSelector::comboChanged),
    47      sigc::mem_fun((*this), &MapSelector::comboChanged),
    40      false
    48      false
    41      );
    49     );
    42   
       
    43   label=new Gtk::Label(labeltext);
       
    44 
    50 
    45   label->set_width_chars(longest_property_string_length);
    51   label.set_width_chars(longest_property_string_length);
    46 
    52 
    47   defbut=NULL;
       
    48   if(def)
    53   if(def)
    49     {
    54   {
    50       defbut=new Gtk::Button();
    55     defbut.set_label("Reset");
    51       defbut->set_label("Reset");
    56     defbut.signal_pressed().connect
    52       
    57       (
    53       defbut->signal_pressed().connect
    58        sigc::mem_fun(*this, &MapSelector::reset)
    54 	(
    59       );
    55 	 sigc::mem_fun(*this, &MapSelector::reset)
    60   }
    56 	 );
       
    57     }
       
    58 
    61 
    59   newbut=new Gtk::Button(Gtk::Stock::NEW);
       
    60 
    62 
    61   newbut->signal_pressed().connect
    63   newbut.signal_pressed().connect
    62     (
    64     (
    63      sigc::mem_fun(*this, &MapSelector::new_but_pressed)
    65      sigc::mem_fun(*this, &MapSelector::new_but_pressed)
    64      );
    66     );
    65 
    67 
    66   add(*label);
    68   add(label);
    67 
    69 
    68   add(cbt);
    70   add(cbt);
    69 
    71 
    70   if(def)
    72   if(def)
    71     {
    73   {
    72       add(*defbut);
    74     add(defbut);
    73     }
    75   }
    74 
    76 
    75   add(*newbut);
    77   add(newbut);
    76 }
    78 }
    77 
    79 
    78 void MapSelector::new_but_pressed()
    80 void MapSelector::new_but_pressed()
    79 {
    81 {
    80   set_new_map=true;
    82   set_new_map=true;
    81   signal_newmapwin.emit(itisedge);
    83   signal_newmapwin.emit(itisedge);
    82 }
    84 }
    83 
    85 
    84 void MapSelector::update_list( std::vector< std::string > ml )
    86 void MapSelector::update_list(std::vector<std::string> n_ml,
       
    87     std::vector<std::string> s_ml)
    85 {
    88 {
    86   int prev_act=cbt.get_active_row_number();
    89   int prev_act=cbt.get_active_row_number();
    87   cbt.clear();
    90   cbt.clear();
    88   cbt_content.clear();
    91   cbt_content.clear();
    89   std::vector< std::string >::iterator emsi=ml.begin();
    92 
    90   for(;emsi!=ml.end();emsi++)
    93   if (map_type & NUM)
       
    94   {
       
    95     std::vector< std::string >::iterator emsi=n_ml.begin();
       
    96     for(;emsi!=n_ml.end();emsi++)
    91     {
    97     {
    92       cbt.append_text(*emsi);
    98       cbt.append_text(*emsi);
    93       cbt_content.push_back(*emsi);
    99       cbt_content.push_back(*emsi);
    94     }
   100     }
       
   101   }
       
   102   if (map_type & STR)
       
   103   {
       
   104     std::vector< std::string >::iterator emsi=s_ml.begin();
       
   105     for(;emsi!=s_ml.end();emsi++)
       
   106     {
       
   107       cbt.append_text(*emsi);
       
   108       cbt_content.push_back(*emsi);
       
   109     }
       
   110   }
    95   if(def)
   111   if(def)
    96     {
   112     {
    97       cbt.prepend_text("Default values");
   113       cbt.prepend_text("Default values");
    98       cbt_content.push_back("Default values");
   114       cbt_content.push_back("Default values");
    99     }
   115     }
   145     { 
   161     { 
   146       cbt.set_active_text("Default values");
   162       cbt.set_active_text("Default values");
   147     }
   163     }
   148 }
   164 }
   149 
   165 
   150 void MapSelector::append_text(Glib::ustring text)
   166 void MapSelector::append_text(Glib::ustring text, MapValue::Type type)
   151 {
   167 {
   152   cbt.append_text(text);
   168   if (type & map_type)
   153   cbt_content.push_back(text);
   169   {
       
   170     cbt.append_text(text);
       
   171     cbt_content.push_back(text);
   154 
   172 
   155   if(set_new_map)
   173     if(set_new_map)
   156     {
   174     {
   157       set_active_text(text);
   175       set_active_text(text);
   158       set_new_map=false;
   176       set_new_map=false;
   159     }
   177     }
       
   178   }
   160 }
   179 }
   161 
   180 
   162 sigc::signal<void, std::string> MapSelector::signal_cbt_ch()
   181 sigc::signal<void, std::string> MapSelector::signal_cbt_ch()
   163 {
   182 {
   164   return signal_cbt;
   183   return signal_cbt;