void pre_show(twindow& window)
{
LOG_CHAT_LOG << "Entering tchat_log::view::pre_show" << std::endl;
controller_.update_view_from_model(true);
window.invalidate_layout(); // workaround for assertion failure
LOG_CHAT_LOG << "Exiting tchat_log::view::pre_show" << std::endl;
}
void teditor_settings::update_selected_tod_info(twindow& window)
{
bool custom = custom_tod_toggle_->get_value();
if (custom) {
current_tod_label_->set_label(_("Custom setting"));
} else {
std::stringstream ss;
ss << (current_tod_ + 1);
ss << "/" << tods_.size();
ss << ": " << get_selected_tod().name;
current_tod_label_->set_label(ss.str());
/**
* @todo Implement the showing of the ToD icon.
*
* Note at the moment the icon is a label widget, should become an
* image widget.
*/
//current_tod_image_->set_icon_name(get_selected_tod().image);
custom_tod_red_->set_value(get_selected_tod().red);
custom_tod_green_->set_value(get_selected_tod().green);
custom_tod_blue_->set_value(get_selected_tod().blue);
custom_tod_red_field_->set_cache_value(get_selected_tod().red);
custom_tod_green_field_->set_cache_value(get_selected_tod().green);
custom_tod_blue_field_->set_cache_value(get_selected_tod().blue);
}
custom_tod_red_->set_active(custom);
custom_tod_green_->set_active(custom);
custom_tod_blue_->set_active(custom);
current_tod_label_->set_active(!custom);
update_tod_display(window);
window.invalidate_layout();
}
void tlobby_player_info::update_relation(twindow& w)
{
add_to_friends_->set_active(false);
add_to_ignores_->set_active(false);
remove_from_list_->set_active(false);
switch(info_.relation) {
case user_info::FRIEND:
relation_->set_label(_("On friends list"));
add_to_ignores_->set_active(true);
remove_from_list_->set_active(true);
break;
case user_info::IGNORED:
relation_->set_label(_("On ignores list"));
add_to_friends_->set_active(true);
remove_from_list_->set_active(true);
break;
case user_info::NEUTRAL:
relation_->set_label(_("Neither a friend nor ignored"));
add_to_friends_->set_active(true);
add_to_ignores_->set_active(true);
break;
case user_info::ME:
relation_->set_label(_("You"));
break;
default:
relation_->set_label(_("Error"));
}
w.invalidate_layout();
}
void tcustom_tod::update_tod_display(twindow& window)
{
image::set_color_adjustment(tod_red_field_->get_value(),
tod_green_field_->get_value(),
tod_blue_field_->get_value());
if(!display_) {
return;
}
// Prevent a floating slice of window appearing alone over the
// theme UI sidebar after redrawing tiles and before we have a
// chance to redraw the rest of this window.
window.undraw();
// NOTE: We only really want to re-render the gamemap tiles here.
// Redrawing everything is a significantly more expensive task.
// At this time, tiles are the only elements on which ToD tint is
// meant to have a visible effect. This is very strongly tied to
// the image caching mechanism.
//
// If this ceases to be the case in the future, you'll need to call
// redraw_everything() instead.
// invalidate all tiles so they are redrawn with the new ToD tint next
display_->invalidate_all();
// redraw tiles
display_->draw(false);
window.invalidate_layout();
}
void trecruit::switch_type_internal(twindow& window)
{
int side_num = city_.side();
std::stringstream str;
int gold = current_team_.gold();
tlistbox* list = find_widget<tlistbox>(&window, "type_list", false, true);
list->clear();
unit_types_.clear();
const std::vector<const unit_type*>& recruits = city_.recruits(game_config::current_level);
for (std::vector<const unit_type*>::const_iterator it = recruits.begin(); it != recruits.end(); ++it) {
/*** Add list item ***/
const unit_type* type = *it;
VALIDATE(type, std::string("could not find unit type ") + type->id());
string_map list_item;
std::map<std::string, string_map> list_item_item;
if (gold >= type->cost() * cost_exponent_ / 100) {
list_item["label"] = type->image() + "~RC(" + type->flag_rgb() + ">" + team::get_side_color_index(side_num) + ")";
} else {
list_item["label"] = type->image() + "~GS()";
}
list_item_item.insert(std::make_pair("icon", list_item));
list_item["label"] = type->type_name();
list_item_item.insert(std::make_pair("name", list_item));
str.str("");
str << type->cost() * cost_exponent_ / 100 << " " << sngettext("unit^Gold", "Gold", type->cost() * cost_exponent_ / 100);
list_item["label"] = str.str();
list_item_item.insert(std::make_pair("cost", list_item));
list->add_row(list_item_item);
tgrid* grid_ptr = list->get_row_grid(unit_types_.size());
twidget* widget = grid_ptr->find("leader", false);
widget->set_visible(type->leader()? twidget::VISIBLE: twidget::INVISIBLE);
unit_types_.push_back(type);
}
window.invalidate_layout();
if (type_index_ >= (int)list->get_item_count()) {
type_index_ = list->get_item_count() - 1;
}
list->select_row(type_index_);
tbutton* prev = find_widget<tbutton>(&window, "prev", false, true);
prev->set_active(game_config::current_level != game_config::min_level);
tbutton* next = find_widget<tbutton>(&window, "next", false, true);
next->set_active(game_config::current_level != game_config::max_level);
str.str("");
str << "misc/digit-big.png~CROP(" << 30 * game_config::current_level << ", 0, 30, 45)";
find_widget<tcontrol>(&window, "level", false, false)->set_label(str.str());
type_selected(window);
}
void pre_show(twindow& window)
{
model_.clear_sides();
controller_.show_sides_list();
model_.clear_nicks();
controller_.update_view_from_model();
window.invalidate_layout(); // workaround for assertion failure
}
void teditor_generate_map::update_current_generator_label(twindow& window)
{
std::stringstream ss;
ss << lexical_cast<std::string>(current_map_generator_ + 1);
ss << "/" << lexical_cast<std::string>(map_generators_.size());
ss << ": " << get_selected_map_generator()->name() << ", " << get_selected_map_generator()->config_name();
current_generator_label_->set_label(ss.str());
window.invalidate_layout();
}
void tgame_load::display_savegame(twindow& window)
{
const int selected_row = savegame_list_->get_selected_row();
twidget& preview_pane =
find_widget<twidget>(&window, "preview_pane", false);
if (selected_row == -1) {
preview_pane.set_visible(twidget::HIDDEN);
} else if (current_page_ == LOCAL_PAGE) {
preview_pane.set_visible(twidget::VISIBLE);
savegame::save_info& game = games_[selected_row];
filename_ = game.name;
config cfg_summary;
std::string dummy;
try {
savegame::manager::load_summary(game.name, cfg_summary, &dummy);
} catch(game::load_game_failed&) {
cfg_summary["corrupt"] = "yes";
}
find_widget<timage>(&window, "imgLeader", false).
set_label(cfg_summary["leader_image"]);
find_widget<tminimap>(&window, "minimap", false).
set_map_data(cfg_summary["map_data"]);
find_widget<tlabel>(&window, "lblScenario", false).set_label(game.name);
std::stringstream str;
str << format_time_local(cfg_summary["create"].to_long()) << "\n";
str << _("Total time") << ": " << format_time_elapse(cfg_summary["duration"].to_int());
str << "(" << help::tintegrate::generate_format(cfg_summary["hash"].to_int(), "yellow") << ")";
evaluate_summary_string(str, cfg_summary);
find_widget<tlabel>(&window, "lblSummary", false).set_label(str.str());
window.invalidate_layout();
} else if (current_page_ == NETWORK_PAGE) {
preview_pane.set_visible(twidget::VISIBLE);
savegame::www_save_info& game = www_saves_[selected_row];
filename_ = game.name;
find_widget<tminimap>(&window, "minimap", false).set_map_data("");
find_widget<tlabel>(&window, "lblScenario", false).set_label(game.name);
find_widget<tlabel>(&window, "lblSummary", false).set_label("");
}
}
void tcampaign_selection::campaign_selected(twindow& window, tlistbox& list, const int type)
{
const int selected_row = list.get_selected_row();
tscrollbar_panel& multi_page = find_widget<tscrollbar_panel>(&window, "campaign_details", false);
tscroll_label& label = find_widget<tscroll_label>(&window, "description", false);
label.set_label(campaigns_[selected_row].description);
tcontrol& image = find_widget<tcontrol>(&window, "image", false);
image.set_label(campaigns_[selected_row].image);
window.invalidate_layout();
}
void tlobby_main::show_preferences_button_callback(twindow& window)
{
if(preferences_callback_) {
preferences_callback_();
/**
* The screen size might have changed force an update of the size.
*
* @todo This might no longer be needed when gui2 is done.
*/
window.invalidate_layout();
wesnothd_connection_.send_data(config("refresh_lobby"));
}
}
void ttitle_screen::update_tip(twindow& window, const bool previous)
{
next_tip_of_day(tips_, previous);
const config *tip = get_tip_of_day(tips_);
assert(tip);
find_widget<tlabel>(&window, "tip", false).set_label((*tip)["text"]);
find_widget<tlabel>(&window, "source", false).set_label((*tip)["source"]);
/**
* @todo Convert the code to use a multi_page so the invalidate is not
* needed.
*/
window.invalidate_layout();
}
void ttreasure::set_internal(twindow& window)
{
const std::vector<size_t>& holded_treasures = current_team_.holded_treasures();
treasure_list_->clear();
human_list_->clear();
fill_2list(window);
window.invalidate_layout();
treasure_index_ = treasure_list_->get_item_count() - 1;
if (treasure_index_ >= 0) {
treasure_list_->select_row(treasure_index_);
}
human_list_->select_row(human_index_);
const hero& h = heros_[human_pairs_[human_index_].first];
refresh_3button(window, h);
}
void tcamp_armory::refresh_according_to_hero(twindow& window, const int curr)
{
char id[24];
unit& u = *candidate_troops_[prev_troop_];
hero* replaced_hero = NULL;
ttoggle_button* toggle;
// extra replaced hero pointer
if (prev_captain_ == 0) {
replaced_hero = &u.master();
} else if (prev_captain_ == 1) {
if (u.second().valid()) {
replaced_hero = &u.second();
}
} else if (prev_captain_ == 2) {
if (u.third().valid()) {
replaced_hero = &u.third();
}
}
if (!replaced_hero && curr == candidate_heros_.size()) {
sprintf(id, "candidate_hero%u", curr);
toggle = find_widget<ttoggle_button>(&window, id, false, false);
toggle->set_value(false);
return;
} else if (u.type()->require() == unit_type::REQUIRE_LEADER) {
if (replaced_hero && replaced_hero->official_ == hero_official_leader) {
sprintf(id, "candidate_hero%u", curr);
toggle = find_widget<ttoggle_button>(&window, id, false, false);
toggle->set_value(false);
return;
}
} else if (u.type()->require() == unit_type::REQUIRE_FEMALE) {
if (replaced_hero && curr != candidate_heros_.size() && candidate_heros_[curr]->gender_ != hero_gender_female) {
bool other_has_female = false;
if (candidate_heros_[curr]->official_ != hero_official_leader) {
if (u.master().number_ != replaced_hero->number_ && u.master().gender_ == hero_gender_female) {
other_has_female = true;
}
if (!other_has_female && u.second().valid() && u.second().number_ != replaced_hero->number_ && u.second().gender_ == hero_gender_female) {
other_has_female = true;
}
if (!other_has_female && u.third().valid() && u.third().number_ != replaced_hero->number_ && u.third().gender_ == hero_gender_female) {
other_has_female = true;
}
} else {
other_has_female = candidate_heros_[curr]->gender_ == hero_gender_female;
}
if (!other_has_female) {
sprintf(id, "candidate_hero%u", curr);
toggle = find_widget<ttoggle_button>(&window, id, false, false);
toggle->set_value(false);
return;
}
}
}
// replace!!
std::vector<hero*> used_heros;
used_heros.push_back(&u.master());
if (u.second().valid()) {
used_heros.push_back(&u.second());
}
if (u.third().valid()) {
used_heros.push_back(&u.third());
}
if (prev_captain_ < (int)used_heros.size()) {
used_heros.erase(used_heros.begin() + prev_captain_);
}
if (curr != candidate_heros_.size()) {
used_heros.push_back(candidate_heros_[curr]);
}
// sort
std::sort(used_heros.begin(), used_heros.end(), sort_recruit(u.type()));
u.replace_captains(used_heros);
// update candidate heros
if (replaced_hero) {
if (curr != candidate_heros_.size()) {
candidate_heros_[curr] = replaced_hero;
} else {
candidate_heros_.push_back(replaced_hero);
}
// sort
// std::sort(candidate_heros_.begin(), candidate_heros_.end(), compare_leadership);
} else if (curr != candidate_heros_.size()) {
candidate_heros_.erase(candidate_heros_.begin() + curr);
}
sprintf(id, "candidate_hero%u", curr);
toggle = find_widget<ttoggle_button>(&window, id, false, false);
toggle->set_value(false);
refresh_buttons_from_armory_cfg(window);
if (rpg::stratum == hero_stratum_citizen) {
bool found = false;
for (size_t i = reserve_heros_; i < candidate_heros_.size(); i ++) {
if (candidate_heros_[i] == rpg::h) {
found = true;
break;
}
}
tbutton* ok = find_widget<tbutton>(&window, "ok", false, false);
ok->set_active(!found);
}
window.invalidate_layout();
}
void tcamp_armory::refresh_according_to_troop(twindow& window, const int curr)
{
std::stringstream str;
size_t i;
if (candidate_troops_.empty()) {
return;
}
if (prev_troop_ == curr) {
if (prev_troop_ != -1) {
str.str("");
str << "candidate_troop" << prev_troop_;
ttoggle_button* prev_troop = find_widget<ttoggle_button>(&window, str.str(), false, false);
prev_troop->set_value(true);
}
return;
}
if (prev_troop_ != -1) {
str.str("");
str << "candidate_troop" << prev_troop_;
ttoggle_button* prev_troop = find_widget<ttoggle_button>(&window, str.str(), false, false);
prev_troop->set_value(false);
prev_troop->set_dirty();
window.invalidate_layout();
}
// current troop
str.str("");
str << "candidate_troop" << curr;
ttoggle_button* curr_troop = find_widget<ttoggle_button>(&window, str.str(), false, false);
// curr_troop->set_value(true);
curr_troop->set_dirty();
// remember this index
prev_troop_ = curr;
unit& u = *candidate_troops_[curr];
ttoggle_button* toggle = NULL;
toggle = find_widget<ttoggle_button>(&window, "hero0", false, false);
for (i = 0; i < 6; i ++) {
toggle->canvas()[i].set_variable("image", variant(u.master().image()));
}
toggle->set_value(false);
toggle = find_widget<ttoggle_button>(&window, "hero1", false, false);
for (i = 0; i < 6; i ++) {
if (u.second().valid()) {
toggle->canvas()[i].set_variable("image", variant(u.second().image()));
} else {
toggle->canvas()[i].set_variable("image", variant(""));
}
}
toggle->set_value(false);
toggle = find_widget<ttoggle_button>(&window, "hero2", false, false);
for (i = 0; i < 6; i ++) {
if (u.third().valid()) {
toggle->canvas()[i].set_variable("image", variant(u.third().image()));
} else {
toggle->canvas()[i].set_variable("image", variant(""));
}
}
toggle->set_value(false);
int last_captain;
if (u.second().valid()) {
toggle->set_active(true);
if (u.third().valid()) {
last_captain = 2;
} else {
last_captain = 1;
}
} else {
toggle->set_active(false);
last_captain = 0;
}
if (prev_captain_ == 0) {
prev_captain_ = -1;
}
refresh_according_to_captain(window, (last_captain + 1) % 3);
// image of arms
toggle = find_widget<ttoggle_button>(&window, "arms_image", false, false);
update_troop_ui2(toggle, &u);
toggle->set_active(false);
tlabel* label;
/* // leadership
label = find_widget<tlabel>(&window, "tip_leadership", false, true);
label->set_label(lexical_cast<std::string>(u.leadership_));
// force
label = find_widget<tlabel>(&window, "tip_force", false, true);
label->set_label(lexical_cast<std::string>(u.force_));
// intellect
label = find_widget<tlabel>(&window, "tip_intellect", false, true);
label->set_label(lexical_cast<std::string>(u.intellect_));
// spirit
label = find_widget<tlabel>(&window, "tip_spirit", false, true);
label->set_label(lexical_cast<std::string>(u.spirit_));
// charm
label = find_widget<tlabel>(&window, "tip_charm", false, true);
label->set_label(lexical_cast<std::string>(u.charm_));
*/
// hp
label = find_widget<tlabel>(&window, "tip_hp", false, true);
str.str("");
str << "HP: " << u.max_hitpoints();
label->set_label(str.str());
// xp
label = find_widget<tlabel>(&window, "tip_xp", false, true);
str.str("");
str << "XP: " << u.max_experience();
label->set_label(str.str());
// mp
label = find_widget<tlabel>(&window, "tip_mp", false, true);
str.str("");
str << "MP: " << u.total_movement();
label->set_label(str.str());
// traits
tscroll_label* label2 = find_widget<tscroll_label>(&window, "tip_traits", false, true);
label2->set_label(u.form_tip(true));
str.str("");
str << "candidate_hero" << candidate_heros_.size();
toggle = find_widget<ttoggle_button>(&window, str.str(), false, false);
if (toggle) {
toggle->set_active(u.second().valid()? true: false);
}
}
void handle_nicks_list_item_clicked(twindow& window)
{
controller_.handle_nicks_list_item_clicked();
window.invalidate_layout(); // workaround for assertion failure
}
void texile::fill_exile_table(twindow& window, int cursel)
{
std::stringstream strstr;
int value;
tlistbox* list = find_widget<tlistbox>(&window, "type_list", false, true);
list->clear();
const std::vector<tgroup::tmember>& exiles = group_.exiles();
for (std::vector<tgroup::tmember>::const_iterator it = exiles.begin(); it != exiles.end(); ++ it) {
const tgroup::tmember& m = *it;
hero& h = *m.h;
/*** Add list item ***/
string_map list_item;
std::map<std::string, string_map> list_item_item;
strstr.str("");
strstr << (std::distance(exiles.begin(), it) + 1);
list_item["label"] = strstr.str();
list_item_item.insert(std::make_pair("index", list_item));
strstr.str("");
strstr << h.image();
list_item["label"] = strstr.str();
list_item_item.insert(std::make_pair("icon", list_item));
// name
strstr.str("");
if (h.utype_ != HEROS_NO_UTYPE) {
const unit_type* ut = unit_types.keytype(h.utype_);
strstr << tintegrate::generate_img(ut->icon()) << "\n";
}
strstr << h.name();
list_item["label"] = strstr.str();
list_item_item.insert(std::make_pair("name", list_item));
// level
strstr.str("");
if (m.level / game_config::levels_per_rank >= 2) {
strstr << _("rank^Gold");
} else if (m.level / game_config::levels_per_rank >= 1) {
strstr << _("rank^Silver");
} else {
strstr << _("rank^Copper");
}
strstr << "(" << (m.level % game_config::levels_per_rank + 1) << ")";
list_item["label"] = "--";
list_item_item.insert(std::make_pair("level", list_item));
// cost
strstr.str("");
value = h.cost_;
strstr << value;
list_item["label"] = strstr.str();
list_item_item.insert(std::make_pair("cost", list_item));
// leadership
strstr.str("");
strstr << fxptoi9(h.leadership_);
list_item["label"] = strstr.str();
list_item_item.insert(std::make_pair("leadership", list_item));
// charm
strstr.str("");
strstr << fxptoi9(h.charm_);
list_item["label"] = strstr.str();
list_item_item.insert(std::make_pair("charm", list_item));
// feature
strstr.str("");
strstr << hero::feature_str(h.feature_);
list_item["label"] = strstr.str();
list_item_item.insert(std::make_pair("feature", list_item));
// tactic
strstr.str("");
if (h.tactic_ != HEROS_NO_TACTIC) {
strstr << unit_types.tactic(h.tactic_).name();
} else if (m.base->tactic_ != HEROS_NO_TACTIC) {
strstr << tintegrate::generate_format(unit_types.tactic(m.base->tactic_).name(), "red");
}
list_item["label"] = strstr.str();
list_item_item.insert(std::make_pair("tactic", list_item));
list->add_row(list_item_item);
tgrid* grid = list->get_row_grid(list->get_item_count() - 1);
ttoggle_panel* toggle = dynamic_cast<ttoggle_panel*>(grid->find("_toggle", true));
toggle->set_data(h.number_);
}
if (cursel >= (int)exiles.size()) {
cursel = (int)exiles.size() - 1;
}
if (!exiles.empty()) {
list->select_row(cursel);
}
selected_number_ = exiles.size()? exiles[cursel].h->number_: HEROS_INVALID_NUMBER;
refresh_title_flag(window);
set_2button_active(window);
window.invalidate_layout();
}
void filter(twindow& window)
{
controller_.filter();
window.invalidate_layout(); // workaround for assertion failure
}
void previous_page(twindow& window)
{
controller_.previous_page();
window.invalidate_layout(); // workaround for assertion failure
}
void handle_page_number_changed(twindow& window)
{
controller_.handle_page_number_changed();
window.invalidate_layout(); // workaround for assertion failure
}
void tmp_side_wait::generate_menu(twindow& window)
{
if (stop_updates_) {
return;
}
std::stringstream strstr;
users_.clear();
sides_table_->clear();
std::vector<std::set<int> > team_names = generate_team_names_from_side(level_);
std::vector<int> allies = generate_allies_from_team_names(team_names);
int side = 0;
BOOST_FOREACH (const config &sd, level_.child_range("side")) {
if (!sd["current_player"].empty()) {
const std::string player_id = sd["current_player"].str();
connected_user_list::const_iterator it = users_.begin();
for (; it != users_.end(); ++ it) {
if (it->name == player_id) {
break;
}
}
if (it == users_.end()) {
users_.push_back(connected_user(player_id, (player_id == preferences::login())? CNTR_LOCAL: CNTR_NETWORK, 0));
}
}
}
regenerate_hero_map_from_users(disp_, heros_, users_, member_users_);
BOOST_FOREACH (const config &sd, level_.child_range("side")) {
if (!sd["allow_player"].to_bool(true)) {
side ++;
continue;
}
// std::stringstream str;
std::map<std::string, string_map> data;
data["number"]["label"] = sd["side"].str();
strstr.str("");
if (!sd["current_player"].empty()) {
strstr << sd["current_player"].str();
} else {
std::string controller = sd["controller"].str();
if (controller == "network") {
strstr << _("Network Player");
} else if (controller == "ai") {
strstr << _("Computer Player");
} else if (controller == "null") {
strstr << _("Empty");
}
}
data["player"]["label"] = strstr.str();
if (!sd["leader"].empty()) {
hero& leader = heros_[sd["leader"].to_int()];
data["faction"]["label"] = leader.name();
data["portrait"]["label"] = leader.image();
data["feature"]["label"] = hero::feature_str(leader.side_feature_);
} else {
data["faction"]["label"] = _("Random");
data["portrait"]["label"] = "hero-64/random.png";
data["feature"]["label"] = hero::feature_str(HEROS_NO_FEATURE);
}
strstr.str("");
strstr << allies[side];
data["ally"]["label"] = strstr.str();
strstr.str("");
strstr << sd["gold"].to_int() << "/" << sd["income"].to_int();
data["income"]["label"] = strstr.str();
sides_table_->add_row(data);
tgrid* grid_ptr = sides_table_->get_row_grid(side);
side ++;
}
update_playerlist();
window.invalidate_layout();
}
void tmp_side_wait::generate_menu(twindow& window)
{
if (stop_updates_) {
foreach (const config &sd, level_.child_range("side")) {
hero& leader = heros_[sd["leader"].to_int()];
int selected_feature = sd["selected_feature"].to_int();
if (selected_feature >= COMBO_FEATURES_MIN_VALID) {
leader.side_feature_ = hero::valid_features()[selected_feature - COMBO_FEATURES_MIN_VALID];
} else if (selected_feature == COMBO_FEATURES_NONE) {
leader.side_feature_ = HEROS_NO_FEATURE;
}
}
return;
}
/*
if (sides_table_->get_item_count()) {
return;
}
*/
std::vector<std::string> details;
users_.clear();
sides_table_->clear();
int side = 0;
foreach (const config &sd, level_.child_range("side")) {
if (!sd["allow_player"].to_bool(true)) {
side ++;
continue;
}
if (!sd["current_player"].empty()) {
const std::string player_id = sd["current_player"].str();
connected_user_list::const_iterator it = users_.begin();
for (; it != users_.end(); ++ it) {
if (it->name == player_id) {
break;
}
}
if (it == users_.end()) {
users_.push_back(connected_user(player_id, (player_id == preferences::login())? CNTR_LOCAL: CNTR_NETWORK, 0));
}
}
// std::stringstream str;
std::map<std::string, string_map> data;
data["number"]["label"] = sd["side"].str();
data["player"]["label"] = sd["user_description"];
if (!sd["leader"].empty()) {
hero& leader = heros_[sd["leader"].to_int()];
data["faction"]["label"] = leader.name();
data["portrait"]["label"] = leader.image();
} else {
data["faction"]["label"] = _("Random");
data["portrait"]["label"] = "hero-64/random.png";
}
std::string feature_str;
int selected_feature = sd["selected_feature"].to_int();
if (selected_feature == COMBO_FEATURES_RANDOM) {
data["feature"]["label"] = _("Random");
} else if (selected_feature >= COMBO_FEATURES_MIN_VALID) {
data["feature"]["label"] = hero::feature_str(hero::valid_features()[selected_feature - COMBO_FEATURES_MIN_VALID]);
}
data["income"]["label"] = sd["income"].str();
data["color"]["label"] = get_color_string(side);
// data["label"]["use_markup"] = "true";
sides_table_->add_row(data);
tgrid* grid_ptr = sides_table_->get_row_grid(side);
tlabel* label = find_widget<tlabel>(grid_ptr, "color", false, true);
label->set_use_markup(true);
side ++;
}
update_playerlist();
window.invalidate_layout();
}
