leader_list.cpp

Go to the documentation of this file.
00001 /* $Id: leader_list.cpp 25703 2008-04-09 14:46:08Z esr $ */
00002 /*
00003    Copyright (C) 2007 - 2008
00004    Part of the Battle for Wesnoth Project http://www.wesnoth.org
00005 
00006    This program is free software; you can redistribute it and/or modify
00007    it under the terms of the GNU General Public License
00008    or at your option any later version.
00009    This program is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY.
00011 
00012    See the COPYING file for more details.
00013 */
00014 
00015 //! @file leader_list.cpp
00016 //! Manage the selection of a leader, and select his/her gender.
00017 
00018 #include "global.hpp"
00019 
00020 #include "gettext.hpp"
00021 #include "leader_list.hpp"
00022 #include "wml_separators.hpp"
00023 #include "serialization/string_utils.hpp"
00024 #include "widgets/combo.hpp"
00025 #include "widgets/menu.hpp"
00026 
00027 const std::string leader_list_manager::random_enemy_picture("random-dice.png~RC(magenta>1)");
00028 
00029 leader_list_manager::leader_list_manager(const config::child_list& side_list,
00030         gui::combo* leader_combo , gui::combo* gender_combo):
00031     leaders_(),
00032     genders_(),
00033     gender_ids_(),
00034     side_list_(side_list),
00035     leader_combo_(leader_combo),
00036     gender_combo_(gender_combo)
00037 {
00038 }
00039 
00040 void leader_list_manager::set_leader_combo(gui::combo* combo)
00041 {
00042     int selected = leader_combo_ != NULL ? leader_combo_->selected() : 0;
00043     leader_combo_ = combo;
00044 
00045     if(leader_combo_ != NULL) {
00046         if(leaders_.empty()) {
00047             update_leader_list(0);
00048         } else {
00049             populate_leader_combo(selected);
00050         }
00051     }
00052 }
00053 
00054 void leader_list_manager::set_gender_combo(gui::combo* combo)
00055 {
00056     gender_combo_ = combo;
00057 
00058     if(gender_combo_ != NULL) {
00059         if(!leaders_.empty()) {
00060             update_gender_list(get_leader());
00061         }
00062     }
00063 }
00064 
00065 void leader_list_manager::update_leader_list(int side_index)
00066 {
00067     const config& side = *side_list_[side_index];
00068 
00069     leaders_.clear();
00070 
00071     if(utils::string_bool(side["random_faction"])) {
00072         if(leader_combo_ != NULL) {
00073             std::vector<std::string> dummy;
00074             dummy.push_back("-");
00075             leader_combo_->enable(false);
00076             leader_combo_->set_items(dummy);
00077             leader_combo_->set_selected(0);
00078         }
00079         return;
00080     } else {
00081         if(leader_combo_ != NULL)
00082             leader_combo_->enable(true);
00083         if(gender_combo_ != NULL)
00084             gender_combo_->enable(true);
00085     }
00086 
00087     if(!side["leader"].empty()) {
00088         leaders_ = utils::split(side["leader"]);
00089     }
00090 
00091     const std::string default_leader = side["type"];
00092     size_t default_index = 0;
00093 
00094     std::vector<std::string>::const_iterator itor;
00095 
00096     for (itor = leaders_.begin(); itor != leaders_.end(); ++itor) {
00097         if (*itor == default_leader) {
00098             break;
00099         }
00100         default_index++;
00101     }
00102 
00103     if (default_index == leaders_.size()) {
00104         leaders_.push_back(default_leader);
00105     }
00106 
00107     leaders_.push_back("random");
00108     populate_leader_combo(default_index);
00109 }
00110 
00111 void leader_list_manager::update_gender_list(const std::string& leader)
00112 {
00113     int gender_index = gender_combo_ != NULL ? gender_combo_->selected() : 0;
00114     genders_.clear();
00115     gender_ids_.clear();
00116     if (leader == "random" || leader == "-" || leader == "?") {
00117         // Assume random/unknown leader/faction == unknown gender
00118         gender_ids_.push_back("null");
00119         genders_.push_back("-");
00120         if (gender_combo_ != NULL) {
00121             gender_combo_->enable(false);
00122             gender_combo_->set_items(genders_);
00123             gender_combo_->set_selected(0);
00124         }
00125         return;
00126     }
00127 
00128     unit_type_data::unit_type_map_wrapper& utypes = unit_type_data::types();
00129     if (utypes.find(leader) != utypes.end()) {
00130         const unit_type* ut;
00131         const unit_type* utg;
00132         ut = &(utypes.find(leader)->second);
00133         const std::vector<unit_race::GENDER> genders = ut->genders();
00134         if ( (genders.size() < 2) && (gender_combo_ != NULL) ) {
00135             gender_combo_->enable(false);
00136         } else {
00137             gender_ids_.push_back("random");
00138             genders_.push_back(IMAGE_PREFIX + random_enemy_picture + COLUMN_SEPARATOR + _("gender^Random"));
00139             if (gender_combo_ != NULL) gender_combo_->enable(true);
00140         }
00141         for (std::vector<unit_race::GENDER>::const_iterator i=genders.begin(); i != genders.end(); ++i) {
00142             utg = &(ut->get_gender_unit_type(*i));
00143 
00144             // Make the internationalized titles for each gender, along with the WML ids
00145             if (*i == unit_race::FEMALE)
00146             {
00147                 gender_ids_.push_back("female");
00148 #ifdef LOW_MEM
00149                 genders_.push_back(IMAGE_PREFIX + utg->image() + COLUMN_SEPARATOR + _("Female ♀"));
00150 #else
00151                 genders_.push_back(IMAGE_PREFIX + utg->image() + std::string("~RC(" + utg->flag_rgb() + ">1)") + COLUMN_SEPARATOR + _("Female ♀"));
00152 #endif
00153             }
00154             else
00155             {
00156                 gender_ids_.push_back("male");
00157 #ifdef LOW_MEM
00158                 genders_.push_back(IMAGE_PREFIX + utg->image() + COLUMN_SEPARATOR + _("Male ♂"));
00159 #else
00160                 genders_.push_back(IMAGE_PREFIX + utg->image() + std::string("~RC(" + utg->flag_rgb() + ">1)") + COLUMN_SEPARATOR + _("Male ♂"));
00161 #endif
00162             }
00163         }
00164         if (gender_combo_ != NULL) {
00165             gender_combo_->set_items(genders_);
00166             gender_index %= genders_.size();
00167             gender_combo_->set_selected(gender_index);
00168         }
00169     } else {
00170         gender_ids_.push_back("random");
00171         genders_.push_back(IMAGE_PREFIX + random_enemy_picture + COLUMN_SEPARATOR + _("Random"));
00172         if (gender_combo_ != NULL) {
00173             gender_combo_->enable(false);
00174             gender_combo_->set_items(genders_);
00175             gender_combo_->set_selected(0);
00176         }
00177     }
00178 }
00179 
00180 void leader_list_manager::populate_leader_combo(int selected_index) {
00181     std::vector<std::string>::const_iterator itor;
00182     std::vector<std::string> leader_strings;
00183     for(itor = leaders_.begin(); itor != leaders_.end(); ++itor) {
00184 
00185         unit_type_data::unit_type_map_wrapper& utypes = unit_type_data::types();
00186 
00187         //const std::string name = data_->unit_types->find(*itor).type_name();
00188         if (utypes.find(*itor) != utypes.end()) {
00189             const unit_type* ut;
00190             ut = &(utypes.find(*itor)->second);
00191             if (gender_combo_ != NULL && !genders_.empty() && size_t(gender_combo_->selected()) < genders_.size()) {
00192                 if (gender_ids_[gender_combo_->selected()] == "male"){
00193                     ut = &(utypes.find(*itor)->second.get_gender_unit_type(unit_race::MALE));
00194                 } else if (gender_ids_[gender_combo_->selected()] == "female") {
00195                     ut = &(utypes.find(*itor)->second.get_gender_unit_type(unit_race::FEMALE));
00196                 }
00197             }
00198             const std::string name =  ut->type_name();
00199             const std::string image = ut->image();
00200 
00201 #ifdef LOW_MEM
00202             leader_strings.push_back(IMAGE_PREFIX + image + COLUMN_SEPARATOR + name);
00203 #else
00204             leader_strings.push_back(IMAGE_PREFIX + image + std::string("~RC(" + ut->flag_rgb() + ">1)") + COLUMN_SEPARATOR + name);
00205 #endif
00206         } else {
00207             if(*itor == "random") {
00208                 leader_strings.push_back(IMAGE_PREFIX + random_enemy_picture + COLUMN_SEPARATOR + _("Random"));
00209             } else {
00210                 leader_strings.push_back("?");
00211             }
00212         }
00213     }
00214 
00215     if(leader_combo_ != NULL) {
00216         leader_combo_->set_items(leader_strings);
00217         leader_combo_->set_selected(selected_index);
00218     }
00219 }
00220 
00221 void leader_list_manager::set_leader(const std::string& leader)
00222 {
00223     if(leader_combo_ == NULL)
00224         return;
00225 
00226     int leader_index = 0;
00227     for(std::vector<std::string>::const_iterator itor = leaders_.begin();
00228             itor != leaders_.end(); ++itor) {
00229         if(leader == *itor) {
00230             leader_combo_->set_selected(leader_index);
00231             return;
00232         }
00233         ++leader_index;
00234     }
00235 }
00236 
00237 void leader_list_manager::set_gender(const std::string& gender)
00238 {
00239     if(gender_combo_ == NULL)
00240         return;
00241 
00242     int gender_index = 0;
00243     for(std::vector<std::string>::const_iterator itor = gender_ids_.begin();
00244             itor != gender_ids_.end(); ++itor) {
00245         if(gender == *itor) {
00246             gender_combo_->set_selected(gender_index);
00247             return;
00248         }
00249         ++gender_index;
00250     }
00251 }
00252 
00253 std::string leader_list_manager::get_leader() const
00254 {
00255     if(leader_combo_ == NULL)
00256         return _("?");
00257 
00258     if(leaders_.empty())
00259         return "random";
00260 
00261     if(size_t(leader_combo_->selected()) >= leaders_.size())
00262         return _("?");
00263 
00264     return leaders_[leader_combo_->selected()];
00265 }
00266 
00267 std::string leader_list_manager::get_gender() const
00268 {
00269     if(gender_combo_ == NULL || genders_.empty() || size_t(gender_combo_->selected()) >= genders_.size())
00270         return "null";
00271     return gender_ids_[gender_combo_->selected()];
00272 }

Generated by doxygen 1.5.5 on 23 May 2008 for The Battle for Wesnoth
Gna! | Forum | Wiki | CIA | devdocs