The Battle for Wesnoth  1.19.14+dev
units_dialog.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2024 - 2025
3  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 2 of the License, or
8  (at your option) any later version.
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY.
11 
12  See the COPYING file for more details.
13 */
14 
15 #define GETTEXT_DOMAIN "wesnoth-lib"
16 
18 
19 #include "font/standard_colors.hpp"
20 #include "formatter.hpp"
21 #include "game_board.hpp"
22 #include "gettext.hpp"
24 #include "gui/dialogs/message.hpp"
26 #include "gui/widgets/listbox.hpp"
27 #include "gui/widgets/button.hpp"
28 #include "gui/widgets/label.hpp"
30 #include "gui/widgets/text_box.hpp"
33 #include "gui/widgets/window.hpp"
34 #include "help/help.hpp"
35 #include "log.hpp"
36 #include "replay_helper.hpp"
37 #include "play_controller.hpp"
38 #include "resources.hpp"
39 #include "serialization/markup.hpp"
40 #include "synced_context.hpp"
41 #include "team.hpp"
42 #include "units/helper.hpp"
43 #include "units/unit.hpp"
44 #include "units/ptr.hpp"
45 #include "units/types.hpp"
46 #include "utils/ci_searcher.hpp"
47 #include "whiteboard/manager.hpp"
48 
49 #include <functional>
50 #include <string>
51 
52 static lg::log_domain log_display("display");
53 #define LOG_DP LOG_STREAM(info, log_display)
54 
55 namespace gui2::dialogs
56 {
57 
58 namespace
59 {
60 // Index 2 is by-level
61 std::pair sort_default{ std::string{"unit_name"}, sort_order::type::ascending };
62 utils::optional<decltype(sort_default)> sort_last;
63 
64 std::string star(bool starred)
65 {
66  // Filled/unfilled five-pointed stars, used as favorite unit marker
67  return starred ? "\u2605" : "\u2606";
68 }
69 
70 }
71 
72 REGISTER_DIALOG(units_dialog)
73 
75  : modal_dialog(window_id())
76  , selected_index_(-1)
77  , num_rows_(0)
78  , ok_label_(_("OK"))
79  , cancel_label_(_("Cancel"))
80  , show_rename_(false)
81  , show_dismiss_(false)
82  , show_mark_favorite_(false)
83  , show_variations_(false)
84  , sort_order_(sort_default)
85  , gender_(unit_race::GENDER::MALE)
86  , variation_()
87  , filter_options_()
88  , gender_toggle_()
89 {
90  for(widget* sort_toggle : find_widget<grid>("_header_grid")) {
91  // FIXME: only proper (non-spacer) header options are currently given an ID.
92  // We want the spacers to remain for sizing, but this is pretty fragile.
93  if(!sort_toggle->id().empty()) {
95  }
96  }
97 }
98 
99 namespace {
100 
101 template<typename T>
102 void dump_recall_list_to_console(const T& units)
103 {
104  log_scope2(log_display, "dump_recall_list_to_console()")
105 
106  LOG_DP << "size: " << units.size();
107 
108  std::size_t idx = 0;
109  for(const auto& u_ptr : units) {
110  LOG_DP << "\tunit[" << (idx++) << "]: " << u_ptr->id() << " name = '" << u_ptr->name() << "'";
111  }
112 }
113 
114 std::string get_title_suffix(int side_num)
115 {
116  if(!resources::gameboard) {
117  return "";
118  }
119 
120  unit_map& units = resources::gameboard->units();
121 
122  int controlled_recruiters = 0;
123  for(const auto& team : resources::gameboard->teams()) {
124  if(team.is_local_human() && !team.recruits().empty() && units.find_leader(team.side()) !=units.end()) {
125  ++controlled_recruiters;
126  }
127  }
128 
129  std::stringstream msg;
130  if(controlled_recruiters >= 2) {
132  if(leader != resources::gameboard->units().end() && !leader->name().empty()) {
133  msg << " (" << leader->name() << ")";
134  }
135  }
136 
137  return msg.str();
138 }
139 }
140 
142 {
143  text_box& filter = find_widget<text_box>("filter_box");
144  filter.on_modified([this](const auto& box) { filter_text_changed(box.text()); });
145 
146  listbox& list = find_widget<listbox>("main_list");
148 
150  find_widget<button>("show_help"),
151  std::bind(&units_dialog::show_help, this));
152 
154  add_to_keyboard_chain(&list);
155 
156  show_list(list);
157 
158  find_widget<label>("title").set_label(title_);
159  find_widget<button>("ok").set_label(ok_label_);
160  find_widget<button>("cancel").set_label(cancel_label_);
161  find_widget<button>("dismiss").set_visible(show_dismiss_);
162  find_widget<button>("rename").set_visible(show_rename_);
163  find_widget<button>("mark_favorite").set_visible(show_mark_favorite_);
164  find_widget<grid>("variation_gender_grid").set_visible(show_variations_);
165 
166  // Gender and variation selectors
167  if(show_variations_) {
169  find_widget<menu_button>("variation_box"), [this](auto&&...) { update_variation(); });
170 
171  auto& group = get_toggle();
172  group.add_member(find_widget<toggle_button>("male_toggle", true, true), unit_race::MALE);
173  group.add_member(find_widget<toggle_button>("female_toggle", true, true), unit_race::FEMALE);
174 
177  [this](widget&, const unit_race::GENDER& gender) { update_gender(gender); });
178  }
179 
181 }
182 
184 {
185  if (num_rows_ == 0) {
186  return;
187  }
188 
189  for(std::size_t i = 0; i < num_rows_; i++) {
190  widget_data row_data;
191 
192  // If custom filter text generator exists, use it to generate the filter text
193  if(filter_gen_) {
194  filter_options_.emplace_back(filter_gen_(i));
195  } else {
196  filter_options_.emplace_back();
197  }
198 
199  for(const auto& [id, generator] : column_generators_) {
200  auto result = std::invoke(generator, i);
201 
202  // Register labels to be filtered upon provided no filter generator exists
203  if(!filter_gen_ && id != "unit_image") {
204  filter_options_.back().push_back(result);
205  }
206 
207  row_data.emplace(id, widget_item{{ "use_markup", "true" }, { "label", std::move(result) }});
208  }
209 
210  grid& row_grid = list.add_row(row_data);
211 
212  // Generate tooltip for ith row
213  if(tooltip_gen_) {
214  row_grid.find_widget<styled_widget>("row_panel").set_tooltip(tooltip_gen_(i));
215  }
216  }
217 
218  const auto [sorter_id, order] = sort_last.value_or(sort_order_);
219  list.set_active_sorter(sorter_id, order, true);
220  if (is_selected()) { // In this case, is an entry preselected by caller?
222  fire(event::NOTIFY_MODIFIED, *this, nullptr);
223  }
224 }
225 
226 void units_dialog::rename_unit(std::vector<unit_const_ptr>& unit_list)
227 {
228  listbox& list = find_widget<listbox>("main_list");
229 
231  if (selected_index_ == -1) {
232  return;
233  }
234 
235  unit& selected_unit = const_cast<unit&>(*unit_list[selected_index_]);
236 
237  std::string name = selected_unit.name();
238 
239  if(gui2::dialogs::edit_text::execute(_("Rename Unit"), _("Name:"), name)) {
240  selected_unit.rename(name);
241 
242  list.get_row_grid(selected_index_)->find_widget<label>("unit_name").set_label(name);
243 
246 
249  }
250 }
251 
252 void units_dialog::dismiss_unit(std::vector<unit_const_ptr>& unit_list, const team& team)
253 {
254  LOG_DP << "Recall list units:"; dump_recall_list_to_console(unit_list);
255 
256  listbox& list = find_widget<listbox>("main_list");
258  if (selected_index_ == -1) {
259  return;
260  }
261 
262  const unit& u = *unit_list[selected_index_].get();
263 
264  if(!u.dismissable()) {
266  return;
267  }
268 
269  // If the unit is of level > 1, or is close to advancing, we warn the player about it
270  std::stringstream message;
271  if(u.loyal()) {
272  message << _("This unit requires no upkeep.") << " " << (u.gender() == unit_race::MALE
273  ? _("Do you really want to dismiss him?")
274  : _("Do you really want to dismiss her?"));
275 
276  } else if(u.level() > 1) {
277  message << _("This unit is an experienced one, having advanced levels.") << " " << (u.gender() == unit_race::MALE
278  ? _("Do you really want to dismiss him?")
279  : _("Do you really want to dismiss her?"));
280 
281  } else if(u.experience() > u.max_experience()/2) {
282  message << _("This unit is close to advancing a level.") << " " << (u.gender() == unit_race::MALE
283  ? _("Do you really want to dismiss him?")
284  : _("Do you really want to dismiss her?"));
285  }
286 
287  if(!message.str().empty()) {
288  const int res = gui2::show_message(_("Dismiss Unit"), message.str(), message::yes_no_buttons);
289  if(res != gui2::retval::OK) {
290  return;
291  }
292  }
293 
294  unit_list.erase(unit_list.begin() + selected_index_);
295 
296  // Remove the entry from the filter list
298 
299  // Remove the entry from the dialog list
301 
302  // This line can change selected_index_, so the erasing needs to be done before it
304 
305  assert(filter_options_.size() == list.get_item_count());
306 
307  LOG_DP << "Dismissing a unit, side = " << u.side() << ", id = '" << u.id() << "'";
308  LOG_DP << "That side's recall list:";
309  dump_recall_list_to_console(team.recall_list());
310 
311  // Find the unit in the recall list.
312  unit_const_ptr dismissed_unit = team.recall_list().find_if_matches_id(u.id());
313  assert(dismissed_unit);
314 
315  // Record the dismissal, then delete the unit.
316  synced_context::run_and_throw("disband", replay_helper::get_disband(dismissed_unit->id()));
317 
318  // Close the dialog if all units are dismissed
319  if(list.get_item_count() == 0) {
321  }
322 }
323 
324 void units_dialog::toggle_favorite(std::vector<unit_const_ptr>& unit_list)
325 {
326  listbox& list = find_widget<listbox>("main_list");
327 
329  if (selected_index_ == -1) {
330  return;
331  }
332 
333  unit& selected_unit = const_cast<unit&>(*unit_list[selected_index_]);
334  selected_unit.set_favorite(!selected_unit.favorite());
335 
336  list.get_row_grid(selected_index_)->find_widget<label>("unit_favorite")
337  .set_label(star(selected_unit.favorite()));
338 
341 }
342 
344 {
345  if (!topic_id_.empty()) {
347  }
348 }
349 
351 {
352  selected_index_ = find_widget<listbox>("main_list").get_selected_row();
353 
354  if (selected_index_ == -1) {
355  return;
356  }
357 
358  fire(event::NOTIFY_MODIFIED, *this, nullptr);
359 }
360 
362 {
363  listbox& list = find_widget<listbox>("main_list");
364  if(const auto [sorter, order] = list.get_active_sorter(); sorter) {
365  sort_last.emplace(sorter->id(), order);
366  } else {
367  sort_last.reset();
368  }
369 
371 }
372 
373 void units_dialog::filter_text_changed(const std::string& text)
374 {
375  const std::size_t shown = find_widget<listbox>("main_list")
376  .filter_rows_by([this, match = translation::make_ci_matcher(text)](std::size_t row) {
377  return match(filter_options_[row]);
378  });
379 
380  // Disable rename and dismiss buttons if no units are shown
381  find_widget<button>("rename").set_active(shown > 0);
382  find_widget<button>("dismiss").set_active(shown > 0);
383 }
384 
386 {
387  gender_ = val;
388 
389  selected_index_ = find_widget<listbox>("main_list").get_selected_row();
390  if(selected_index_ == -1) {
391  return;
392  }
393 
394  fire(event::NOTIFY_MODIFIED, *this, nullptr);
395 }
396 
398 {
399  variation_ = find_widget<menu_button>("variation_box").get_value_config()["variation_id"].str();
400 
401  selected_index_ = find_widget<listbox>("main_list").get_selected_row();
402  if(selected_index_ == -1) {
403  return;
404  }
405 
406  fire(event::NOTIFY_MODIFIED, *this, nullptr);
407 }
408 
409 // } -------------------- BUILDERS -------------------- {
410 std::unique_ptr<units_dialog> units_dialog::build_create_dialog(const std::vector<const unit_type*>& types_list)
411 {
412  auto dlg = std::make_unique<units_dialog>();
413 
414  const auto type_gen = [](const auto& type) {
415  std::string type_name = type->type_name();
416  if(type_name != type->id()) {
417  type_name += " (" + type->id() + ")";
418  }
419  return type_name;
420  };
421 
422  const auto race_gen = [](const auto& type) {
423  return type->race()->plural_name();
424  };
425 
426  const auto populate_variations = [&dlg](const unit_type& ut) {
427  // Populate variations box
428  menu_button& var_box = dlg->find_widget<menu_button>("variation_box");
429  std::vector<config> var_box_values;
430  var_box_values.emplace_back("label", _("unit_variation^Default Variation"), "variation_id", "");
431 
432  const auto& uvars = ut.variation_types();
433 
434  var_box.set_active(!uvars.empty());
435 
436  unsigned n = 0, selection = 0;
437 
438  for(const auto& [uv_id, uv] : uvars) {
439  ++n;
440 
441  std::string uv_label;
442  if(!uv.variation_name().empty()) {
443  uv_label = uv.variation_name() + " (" + uv_id + ")";
444  } else if(!uv.type_name().empty() && uv.type_name() != ut.type_name()) {
445  uv_label = uv.type_name() + " (" + uv_id + ")";
446  } else {
447  uv_label = uv_id;
448  }
449 
450  var_box_values.emplace_back("label", uv_label, "variation_id", uv_id);
451 
452  if(uv_id == dlg->variation()) {
453  selection = n;
454  }
455  }
456 
457  // If we didn't find the variation selection again then the new selected
458  // unit type doesn't have that variation id.
459  if(!selection) {
460  dlg->clear_variation();
461  }
462 
463  var_box.set_values(var_box_values, selection);
464  };
465 
466  dlg->set_title(_("Create Unit"))
467  .set_ok_label(_("Create"))
468  .set_help_topic("..units")
469  .set_row_num(types_list.size())
470  .set_show_variations(true);
471 
472  // Listbox data
473  auto set_column = dlg->make_column_builder(types_list);
474 
475  set_column("unit_name", type_gen, sort_type::generator);
476  set_column("unit_details", race_gen, sort_type::generator);
477 
478  dlg->on_modified([populate_variations, &dlg, &types_list](std::size_t index) -> const auto& {
479  const unit_type* ut = types_list[index];
480 
481  if (dlg->is_selected() && (static_cast<int>(index) == dlg->get_selected_index())) {
482  dlg->get_toggle().set_member_states(dlg->gender());
483  } else {
484  dlg->get_toggle().set_members_enabled(
485  [ut](const unit_race::GENDER& gender) { return ut->has_gender_variation(gender); });
486  }
487 
488  populate_variations(*ut);
489 
490  const auto& g = dlg->gender();
491  if(ut->has_gender_variation(g)) {
492  ut = &ut->get_gender_unit_type(g);
493  }
494 
495  const auto& var = dlg->variation();
496  if(!var.empty()) {
497  ut = &ut->get_variation(var);
498  }
499 
500  return *ut;
501  });
502 
503  return dlg;
504 }
505 
506 std::unique_ptr<units_dialog> units_dialog::build_recruit_dialog(
507  const std::vector<const unit_type*>& recruit_list,
508  recruit_msgs_map& err_msgs_map,
509  const team& team
510 )
511 {
512  auto dlg = std::make_unique<units_dialog>();
513  auto set_column = dlg->make_column_builder(recruit_list);
514 
515  set_column("unit_image", [&](const auto& recruit) {
516  std::string image_string = recruit->icon();
517  if (image_string.empty()) {
518  image_string = recruit->image();
519  }
520  image_string += "~RC(" + recruit->flag_rgb() + ">" + team.color() + ")";
521  image_string += "~SCALE_INTO(72,72)";
522  // Does the unit have error message? If so, grey out image.
523  if (!err_msgs_map[recruit].empty()) {
524  image_string += "~GS()";
525  }
526  return image_string;
527  }, sort_type::none);
528 
529  set_column("unit_details", [&](const auto& recruit) {
530  // Does the unit have error message? If so, grey out text here.
531  bool recruitable = err_msgs_map[recruit].empty();
532  return unit_helper::maybe_inactive(recruit->type_name(), recruitable)
533  + '\n'
534  + unit_helper::format_cost_string(recruit->cost(), recruitable);
536 
537  dlg->set_title(_("Recruit Unit") + get_title_suffix(team.side()))
538  .set_ok_label(_("Recruit"))
539  .set_help_topic("recruit_and_recall")
540  .set_row_num(recruit_list.size());
541 
542  dlg->set_tooltip_generator([&](std::size_t index) {
543  // Show the error message in case of disabled units, if any.
544  return err_msgs_map[recruit_list[index]];
545  });
546 
547  dlg->on_modified([&recruit_list](std::size_t index) -> const auto& { return *recruit_list[index]; });
548 
549  return dlg;
550 }
551 
552 std::unique_ptr<units_dialog> units_dialog::build_unit_list_dialog(std::vector<unit_const_ptr>& unit_list)
553 {
554  auto dlg = std::make_unique<units_dialog>();
555  dlg->set_title(_("Unit List"))
556  .set_ok_label(_("Scroll To"))
557  .set_help_topic("..units")
558  .set_row_num(unit_list.size())
559  .set_show_rename(true)
560  .set_show_favorite(true);
561 
562  // Rename functionality
563  button& rename = dlg->find_widget<button>("rename");
564  connect_signal_mouse_left_click(rename, [&](auto&&...) {
565  dlg->rename_unit(unit_list);
566  });
567 
568  // Mark favorite functionality
569  button& favorite = dlg->find_widget<button>("mark_favorite");
570  connect_signal_mouse_left_click(favorite, [&](auto&&...) {
571  dlg->toggle_favorite(unit_list);
572  });
573 
574  auto set_column = dlg->make_column_builder(unit_list);
575 
576  set_column("unit_favorite", [](const auto& unit) {
577  return star(unit->favorite());
579 
580  set_column("unit_name",
581  [](const auto& unit) {
582  return !unit->name().empty() ? unit->name().str() : font::unicode_en_dash;
584 
585  set_column("unit_details",
586  [](const auto& unit) {
587  return unit->type_name().str();
589 
590  set_column("unit_level",
591  [](const auto& unit) {
593  },
594  [](const auto& unit) {
595  return std::tuple(unit->level(), -static_cast<int>(unit->experience_to_advance()));
596  });
597 
598  set_column("unit_moves",
599  [](const auto& unit) {
601  },
602  [](const auto& unit) {
603  return unit->movement_left();
604  });
605 
606  set_column("unit_hp",
607  [](const auto& unit) {
609  },
610  [](const auto& unit) {
611  return unit->hitpoints();
612  });
613 
614  set_column("unit_xp",
615  [](const auto& unit) {
616  std::stringstream exp_str;
617  if(unit->can_advance()) {
618  exp_str << unit->experience() << "/" << unit->max_experience();
619  } else {
620  exp_str << font::unicode_en_dash;
621  }
622  return markup::span_color(unit->xp_color(), exp_str.str());
623  },
624  [](const auto& unit) {
625  // this allows 0/35, 0/100 etc to be sorted
626  // also sorts 23/35 before 0/35, after which 0/100 comes
627  return unit->experience() + unit->max_experience();
628  });
629 
630  set_column("unit_status", [](const auto& unit) {
631  // Status
632  if(unit->incapacitated()) {
633  return "misc/petrified.png";
634  }
635 
636  if(unit->poisoned()) {
637  return "misc/poisoned.png";
638  }
639 
640  if(unit->slowed()) {
641  return "misc/slowed.png";
642  }
643 
644  if(unit->invisible(unit->get_location(), false)) {
645  return "misc/invisible.png";
646  }
647 
648  return "";
649  }, sort_type::none);
650 
651  set_column("unit_traits", [](const auto& unit) {
652  return utils::join(unit->trait_names(), ", ");
654 
655  dlg->set_filter_generator([&unit_list](std::size_t index) {
656  const auto& unit = unit_list[index];
657  std::vector<std::string> filter_keys;
658 
659  filter_keys.emplace_back(unit->type_name());
660  filter_keys.emplace_back(!unit->name().empty() ? unit->name().str() : font::unicode_en_dash);
661  filter_keys.emplace_back(std::to_string(unit->level()));
662  filter_keys.emplace_back(unit_type::alignment_description(unit->alignment(), unit->gender()));
663 
664  if(const auto* race = unit->race()) {
665  filter_keys.emplace_back(race->name(unit->gender()));
666  filter_keys.emplace_back(race->plural_name());
667  }
668 
669  for(const std::string& trait : unit->trait_names()) {
670  filter_keys.emplace_back(trait);
671  }
672 
673  return filter_keys;
674  });
675 
676  dlg->on_modified([&unit_list, &rename](std::size_t index) -> const auto& {
677  auto& unit = unit_list[index];
678  rename.set_active(!unit->unrenamable());
679  return *unit;
680  });
681 
682  return dlg;
683 }
684 
685 std::unique_ptr<units_dialog> units_dialog::build_recall_dialog(
686  std::vector<unit_const_ptr>& recall_list,
687  const team& team)
688 {
689  int wb_gold = unit_helper::planned_gold_spent(team.side());
690 
691  // Lambda to check if a unit is recallable
692  const auto recallable = [wb_gold, &team](const unit& unit) {
693  // Note: Our callers apply [filter_recall], but leave it to us to apply cost-based filtering.
694  const int recall_cost = unit.recall_cost() > -1 ? unit.recall_cost() : team.recall_cost();
695  return recall_cost <= team.gold() - wb_gold;
696  };
697 
698  auto dlg = std::make_unique<units_dialog>();
699  dlg->set_title(_("Recall Unit") + get_title_suffix(team.side()))
700  .set_ok_label(_("Recall"))
701  .set_help_topic("recruit_and_recall")
702  .set_row_num(recall_list.size())
703  .set_show_rename(true)
704  .set_show_dismiss(true)
705  .set_show_favorite(true);
706 
707  // Rename functionality
708  button& rename = dlg->find_widget<button>("rename");
709  connect_signal_mouse_left_click(rename, [&](auto&&...) {
710  dlg->rename_unit(recall_list);
711  });
712 
713  // Dismiss functionality
714  button& dismiss = dlg->find_widget<button>("dismiss");
715  connect_signal_mouse_left_click(dismiss, [&](auto&&...) {
716  dlg->dismiss_unit(recall_list, team);
717  });
718 
719  // Mark favorite functionality
720  button& favorite = dlg->find_widget<button>("mark_favorite");
721  connect_signal_mouse_left_click(favorite, [&](auto&&...) {
722  dlg->toggle_favorite(recall_list);
723  });
724 
725  auto set_column = dlg->make_column_builder(recall_list);
726 
727  set_column("unit_favorite", [](const auto& unit) {
728  return star(unit->favorite());
730 
731  set_column("unit_image", [recallable](const auto& unit) {
732  std::string mods = unit->image_mods();
733  if(unit->can_recruit()) { mods += "~BLIT(" + unit::leader_crown() + ")"; }
734  for(const std::string& overlay : unit->overlays()) {
735  mods += "~BLIT(" + overlay + ")";
736  }
737  if(!recallable(*unit)) { mods += "~GS()"; }
738  mods += "~SCALE_INTO(72,72)";
739  return unit->absolute_image() + mods;
740  }, sort_type::none);
741 
742  set_column("unit_name",
743  [recallable](const auto& unit) {
744  const std::string& name = !unit->name().empty() ? unit->name().str() : font::unicode_en_dash;
745  return unit_helper::maybe_inactive(name, recallable(*unit));
746  },
747  [](const auto& unit) {
748  return unit->name().str();
749  });
750 
751  set_column("unit_details",
752  [recallable, &team](const auto& unit) {
753  std::stringstream details;
754  details << unit_helper::maybe_inactive(unit->type_name().str(), recallable(*unit)) << '\n';
755  const int recall_cost = unit->recall_cost() == -1 ? team.recall_cost() : unit->recall_cost();
756  if (recallable(*unit)) {
758  } else {
759  details << unit_helper::format_cost_string(recall_cost, false);
760  }
761  return details.str();
762  },
763  [](const auto& unit) {
764  return unit->type_name().str();
765  });
766 
767  set_column("unit_moves",
768  [recallable](const auto& unit) {
770  unit->movement_left(), unit->total_movement(), recallable(*unit));
771  },
772  [](const auto& unit) {
773  return unit->movement_left();
774  });
775 
776  set_column("unit_level",
777  [recallable](const auto& unit) {
778  return unit_helper::format_level_string(unit->level(), recallable(*unit));
779  },
780  [](const auto& unit) {
781  return std::tuple(unit->level(), -static_cast<int>(unit->experience_to_advance()));
782  });
783 
784  set_column("unit_hp",
785  [recallable](const auto& unit) {
786  const color_t& col = recallable(*unit) ? unit->hp_color() : font::GRAY_COLOR;
787  return markup::span_color(col, unit->hitpoints(), "/", unit->max_hitpoints());
788  },
789  [](const auto& unit) {
790  return unit->hitpoints();
791  });
792 
793  set_column("unit_xp",
794  [recallable](const auto& unit) {
795  const color_t& col = recallable(*unit) ? unit->xp_color() : font::GRAY_COLOR;
796  if(unit->can_advance()) {
797  return markup::span_color(col, unit->experience(), "/", unit->max_experience());
798  } else {
800  }
801  },
802  [](const auto& unit) {
803  // this allows 0/35, 0/100 etc to be sorted
804  // also sorts 23/35 before 0/35, after which 0/100 comes
805  return unit->experience() + unit->max_experience();
806  });
807 
808  set_column("unit_traits",
809  [recallable](const auto& unit) {
810  std::string traits;
811  for(const std::string& trait : unit->trait_names()) {
812  traits += (traits.empty() ? "" : "\n") + trait;
813  }
814  return unit_helper::maybe_inactive((!traits.empty() ? traits : font::unicode_en_dash), recallable(*unit));
815  },
816  [](const auto& unit) {
817  return !unit->trait_names().empty() ? unit->trait_names().front().str() : "";
818  });
819 
820 
821  dlg->set_sort_by(std::pair("unit_level", sort_order::type::descending));
822 
823  dlg->set_tooltip_generator([recallable, wb_gold, &recall_list](std::size_t index) {
824  if(recallable(*recall_list[index])) {
825  return std::string();
826  }
827 
828  // Just set the tooltip on every single element in this row.
829  if(wb_gold > 0) {
830  return _("This unit cannot be recalled because you will not have enough gold at this point in your plan.");
831  } else {
832  return _("This unit cannot be recalled because you do not have enough gold.");
833  }
834  });
835 
836  dlg->set_filter_generator([&recall_list](std::size_t index) {
837  const auto& unit = recall_list[index];
838  std::vector<std::string> filter_keys;
839 
840  filter_keys.emplace_back(unit->type_name());
841  filter_keys.emplace_back(!unit->name().empty() ? unit->name().str() : font::unicode_en_dash);
842  filter_keys.emplace_back(std::to_string(unit->level()));
843  filter_keys.emplace_back(unit_type::alignment_description(unit->alignment(), unit->gender()));
844 
845  if(const auto* race = unit->race()) {
846  filter_keys.emplace_back(race->name(unit->gender()));
847  filter_keys.emplace_back(race->plural_name());
848  }
849 
850  for(const std::string& trait : unit->trait_names()) {
851  filter_keys.emplace_back(trait);
852  }
853 
854  return filter_keys;
855  });
856 
857  dlg->on_modified([&recall_list, &rename](std::size_t index) -> const auto& {
858  const auto& unit = recall_list[index];
859  rename.set_active(!unit->unrenamable());
860  return *unit;
861  });
862 
863  return dlg;
864 }
865 
866 
867 
868 } // namespace dialogs
double g
Definition: astarsearch.cpp:63
virtual const unit_map & units() const override
Definition: game_board.hpp:107
Simple push button.
Definition: button.hpp:36
virtual void set_active(const bool active) override
See styled_widget::set_active.
Definition: button.cpp:64
Main class to show messages to the user.
Definition: message.hpp:36
@ yes_no_buttons
Shows a yes and no button.
Definition: message.hpp:81
Abstract base class for all modal dialogs.
units_dialog & set_tooltip_generator(const Generator &generator)
Sets the generator function for the tooltips.
void show_list(listbox &list)
std::pair< std::string, sort_order::type > sort_order_
std::function< std::vector< std::string >std::size_t)> filter_gen_
std::map< const unit_type *, t_string > recruit_msgs_map
units_dialog & set_ok_label(const std::string &ok_label)
std::vector< std::vector< std::string > > filter_options_
auto make_column_builder(const std::vector< Value > &list)
Creates a generator function which registers secondary generator and sorter functions for the list co...
std::function< std::string(std::size_t)> tooltip_gen_
virtual void post_show() override
Actions to be taken after the window has been shown.
void rename_unit(std::vector< unit_const_ptr > &unit_list)
units_dialog & set_help_topic(const std::string &topic_id)
units_dialog & set_show_variations(bool show=true)
group< unit_race::GENDER > & get_toggle()
void filter_text_changed(const std::string &text)
static std::unique_ptr< units_dialog > build_unit_list_dialog(std::vector< unit_const_ptr > &units_list)
units_dialog & set_row_num(const std::size_t row_num)
static std::unique_ptr< units_dialog > build_create_dialog(const std::vector< const unit_type * > &types_list)
void dismiss_unit(std::vector< unit_const_ptr > &unit_list, const team &team)
void toggle_favorite(std::vector< unit_const_ptr > &unit_list)
void on_modified(const Func &f)
Registers an function which will fired on NOTIFY_MODIFIED dialog events.
std::map< std::string_view, std::function< std::string(std::size_t)> > column_generators_
virtual void pre_show() override
Actions to be taken before showing the window.
void list_item_clicked()
Callbacks.
unit_race::GENDER gender() const
Gender choice from the user.
static std::unique_ptr< units_dialog > build_recruit_dialog(const std::vector< const unit_type * > &recruit_list, recruit_msgs_map &err_msgs_map, const team &team)
static std::unique_ptr< units_dialog > build_recall_dialog(std::vector< unit_const_ptr > &recall_list, const team &team)
void update_gender(const unit_race::GENDER val)
bool fire(const ui_event event, widget &target)
Fires an event which has no extra parameters.
Definition: dispatcher.cpp:74
Basic template class to generate new items.
Base container class.
Definition: grid.hpp:32
void on_modified(const Func &func)
Sets a common callback function for all members.
Definition: group.hpp:121
void add_member(selectable_item *w, const T &value)
Adds a widget/value pair to the group map.
Definition: group.hpp:41
void set_member_states(const T &value)
Sets the toggle values for all widgets besides the one associated with the specified value to false.
Definition: group.hpp:110
The listbox class.
Definition: listbox.hpp:41
grid & add_row(const widget_item &item, const int index=-1)
When an item in the list is selected by the user we need to update the state.
Definition: listbox.cpp:92
const grid * get_row_grid(const unsigned row) const
Returns the grid of the wanted row.
Definition: listbox.cpp:256
void set_active_sorter(std::string_view id, sort_order::type order, bool select_first=false)
Sorts the listbox by a pre-set sorting option.
Definition: listbox.cpp:598
bool select_row(const unsigned row, const bool select=true)
Selects a row.
Definition: listbox.cpp:267
std::pair< widget *, sort_order::type > get_active_sorter() const
Returns a widget pointer to the active sorter, along with its corresponding order.
Definition: listbox.cpp:612
void remove_row(const unsigned row, unsigned count=1)
Removes a row in the listbox.
Definition: listbox.cpp:108
int get_selected_row() const
Returns the first selected row.
Definition: listbox.cpp:289
unsigned get_item_count() const
Returns the number of items in the listbox.
Definition: listbox.cpp:153
void set_values(const std::vector<::config > &values, unsigned selected=0)
virtual void set_active(const bool active) override
See styled_widget::set_active.
Definition: menu_button.cpp:74
void set_tooltip(const t_string &tooltip)
virtual void set_label(const t_string &text)
A widget that allows the user to input text in single line.
Definition: text_box.hpp:125
Base class for all widgets.
Definition: widget.hpp:55
void set_visible(const visibility visible)
Definition: widget.cpp:479
@ invisible
The user set the widget invisible, that means:
T * find_widget(const std::string_view id, const bool must_be_active, const bool must_exist)
Gets a widget with the wanted id.
Definition: widget.hpp:747
void set_retval(const int retval, const bool close_window=true)
Sets there return value of the window.
Definition: window.hpp:395
void keyboard_capture(widget *widget)
Definition: window.cpp:1201
void invalidate_layout()
Updates the size of the window.
Definition: window.cpp:760
void add_to_keyboard_chain(widget *widget)
Adds the widget to the keyboard chain.
Definition: window.cpp:1215
static const std::string & type()
Static type getter that does not rely on the widget being constructed.
int get_retval()
Definition: window.hpp:402
unit_ptr find_if_matches_id(const std::string &unit_id)
Find a unit by id.
static config get_disband(const std::string &unit_id)
static bool run_and_throw(const std::string &commandname, const config &data, action_spectator &spectator=get_default_spectator())
bool empty() const
Definition: tstring.hpp:197
const std::string & str() const
Definition: tstring.hpp:201
This class stores all the data for a single 'side' (in game nomenclature).
Definition: team.hpp:74
const std::string & color() const
Definition: team.hpp:280
int side() const
Definition: team.hpp:179
int recall_cost() const
Definition: team.hpp:195
bool is_local_human() const
Definition: team.hpp:291
int gold() const
Definition: team.hpp:180
recall_list_manager & recall_list()
Definition: team.hpp:239
const std::set< std::string > & recruits() const
Definition: team.hpp:247
Container associating units to locations.
Definition: map.hpp:98
unit_iterator end()
Definition: map.hpp:428
unit_iterator find_leader(int side)
Definition: map.cpp:320
@ FEMALE
Definition: race.hpp:28
@ MALE
Definition: race.hpp:28
A single unit type that the player may recruit.
Definition: types.hpp:43
static std::string alignment_description(unit_alignments::type align, unit_race::GENDER gender=unit_race::MALE)
Implementation detail of unit_type::alignment_description.
Definition: types.cpp:796
This class represents a single unit of a specific type.
Definition: unit.hpp:132
std::size_t i
Definition: function.cpp:1032
static std::string _(const char *str)
Definition: gettext.hpp:97
void set_favorite(bool favorite)
Definition: unit.hpp:2118
bool invisible(const map_location &loc, bool see_all=true) const
Definition: unit.cpp:2611
bool favorite() const
Definition: unit.hpp:2116
int max_hitpoints() const
The max number of hitpoints this unit can have.
Definition: unit.hpp:520
unit_alignments::type alignment() const
The alignment of this unit.
Definition: unit.hpp:490
bool incapacitated() const
Check if the unit has been petrified.
Definition: unit.hpp:919
int level() const
The current level of this unit.
Definition: unit.hpp:574
const t_string & type_name() const
Gets the translatable name of this unit's type.
Definition: unit.hpp:368
bool unrenamable() const
Whether this unit can be renamed.
Definition: unit.hpp:435
int recall_cost() const
How much gold it costs to recall this unit, or -1 if the side's default recall cost is used.
Definition: unit.hpp:655
void rename(const std::string &name)
Attempts to rename this unit's translatable display name, taking the 'unrenamable' flag into account.
Definition: unit.hpp:423
int hitpoints() const
The current number of hitpoints this unit has.
Definition: unit.hpp:514
bool slowed() const
Check if the unit has been slowed.
Definition: unit.hpp:928
const unit_race * race() const
Gets this unit's race.
Definition: unit.hpp:508
int experience() const
The current number of experience points this unit has.
Definition: unit.hpp:538
t_string block_dismiss_message() const
A message of why this unit cannot be dismissed.
Definition: unit.hpp:459
bool can_recruit() const
Whether this unit can recruit other units - ie, are they a leader unit.
Definition: unit.hpp:627
const std::string & id() const
Gets this unit's id.
Definition: unit.hpp:379
int side() const
The side this unit belongs to.
Definition: unit.hpp:342
bool dismissable() const
Whether this unit can be dismissed.
Definition: unit.hpp:453
bool poisoned() const
Check if the unit has been poisoned.
Definition: unit.hpp:910
unsigned int experience_to_advance() const
The number of experience points this unit needs to level up, or 0 if current XP > max XP.
Definition: unit.hpp:556
int max_experience() const
The max number of experience points this unit can have.
Definition: unit.hpp:544
unit_race::GENDER gender() const
The gender of this unit.
Definition: unit.hpp:480
const t_string & name() const
Gets this unit's translatable display name.
Definition: unit.hpp:402
bool can_advance() const
Checks whether this unit has any options to advance to.
Definition: unit.hpp:271
color_t xp_color() const
Color for this unit's XP.
Definition: unit.cpp:1252
color_t hp_color() const
Color for this unit's current hitpoints.
Definition: unit.cpp:1208
std::string image_mods() const
Gets an IPF string containing all IPF image mods.
Definition: unit.cpp:2769
const std::vector< std::string > & overlays() const
Get the unit's overlay images.
Definition: unit.hpp:1704
std::string absolute_image() const
The name of the file to game_display (used in menus).
Definition: unit.cpp:2588
const map_location & get_location() const
The current map location this unit is at.
Definition: unit.hpp:1431
int movement_left() const
Gets how far a unit can move, considering the incapacitated flag.
Definition: unit.hpp:1356
int total_movement() const
The maximum moves this unit has.
Definition: unit.hpp:1340
const std::vector< t_string > & trait_names() const
Gets the names of the currently registered traits.
Definition: unit.hpp:1106
bool loyal() const
Gets whether this unit is loyal - ie, it costs no upkeep.
Definition: unit.cpp:1738
This file contains the window object, this object is a top level container which has the event manage...
T end(const std::pair< T, T > &p)
Standard logging facilities (interface).
#define log_scope2(domain, description)
Definition: log.hpp:276
const color_t GRAY_COLOR
const std::string unicode_en_dash
Definition: constants.cpp:43
REGISTER_DIALOG(editor_edit_unit)
@ NOTIFY_MODIFIED
Definition: handler.hpp:175
void connect_signal_notify_modified(dispatcher &dispatcher, const signal_notification &signal)
Connects a signal handler for getting a notification upon modification.
Definition: dispatcher.cpp:189
void connect_signal_mouse_left_click(dispatcher &dispatcher, const signal &signal)
Connects a signal handler for a left mouse button click.
Definition: dispatcher.cpp:163
std::map< std::string, widget_item > widget_data
Definition: widget.hpp:36
std::map< std::string, t_string > widget_item
Definition: widget.hpp:33
void show_transient_message(const std::string &title, const std::string &message, const std::string &image, const bool message_use_markup, const bool title_use_markup)
Shows a transient message to the user.
void show_message(const std::string &title, const std::string &msg, const std::string &button_caption, const bool auto_close, const bool message_use_markup, const bool title_use_markup)
Shows a message to the user.
Definition: message.cpp:148
@ OK
Dialog was closed with the OK button.
Definition: retval.hpp:35
@ CANCEL
Dialog was closed with the CANCEL button.
Definition: retval.hpp:38
void show_help(const std::string &show_topic)
Open the help browser, show topic with id show_topic.
Definition: help.cpp:139
std::string span_color(const color_t &color, Args &&... data)
Applies Pango markup to the input specifying its display color.
Definition: markup.hpp:110
game_board * gameboard
Definition: resources.cpp:20
auto make_ci_matcher(std::string_view filter_text)
Returns a function which performs locale-aware case-insensitive search.
Definition: ci_searcher.hpp:24
std::string format_level_string(const int level, bool recallable)
Definition: helper.cpp:135
std::string format_movement_string(const int moves_left, const int moves_max, bool active)
Definition: helper.cpp:154
int planned_gold_spent(int side_number)
Definition: helper.cpp:167
std::string maybe_inactive(const std::string &str, bool active)
Definition: helper.cpp:96
std::string format_cost_string(int unit_recall_cost, bool active)
Definition: helper.cpp:101
std::size_t size(std::string_view str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:85
std::size_t index(std::string_view str, const std::size_t index)
Codepoint index corresponding to the nth character in a UTF-8 string.
Definition: unicode.cpp:70
constexpr auto filter
Definition: ranges.hpp:38
std::string join(const T &v, const std::string &s=",")
Generates a new string joining container items in a list.
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:109
std::shared_ptr< const unit > unit_const_ptr
Definition: ptr.hpp:27
The basic class for representing 8-bit RGB or RGBA colour values.
Definition: color.hpp:61
static map_location::direction n
#define LOG_DP
static lg::log_domain log_display("display")