The Battle for Wesnoth  1.15.0-dev
addon_list.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2016 - 2018 by the Battle for Wesnoth Project https://www.wesnoth.org/
3 
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation; either version 2 of the License, or
7  (at your option) any later version.
8  This program is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY.
10 
11  See the COPYING file for more details.
12 */
13 
14 #define GETTEXT_DOMAIN "wesnoth-lib"
15 
17 
18 #include "addon/client.hpp"
19 #include "color.hpp"
20 #include "font/text_formatting.hpp"
21 #include "formatter.hpp"
22 #include "gettext.hpp"
26 #include "gui/widgets/button.hpp"
28 #include "gui/widgets/label.hpp"
29 #include "gui/widgets/listbox.hpp"
32 #include "gui/widgets/window.hpp"
33 #include "wml_exception.hpp"
34 
35 #include <algorithm>
36 
37 namespace gui2
38 {
39 namespace
40 {
41 const color_t color_outdated {255, 127, 0};
42 
43 const unsigned CONTROL_STACK_LAYER_INSTALL = 0;
44 const unsigned CONTROL_STACK_LAYER_UPDATE = 1;
45 const unsigned CONTROL_STACK_LAYER_PUBLISH = 2;
46 
47 } // end anon namespace
48 
49 REGISTER_WIDGET(addon_list)
50 
51 addon_list::addon_list(const implementation::builder_addon_list& builder)
52  : container_base(builder, type())
53  , addon_vector_()
54  , install_status_visibility_(visibility::visible)
55  , install_buttons_visibility_(visibility::invisible)
56  , install_function_()
57  , uninstall_function_()
58  , publish_function_()
59  , delete_function_()
60 {
61 }
62 
63 std::string addon_list::colorize_addon_state_string(const std::string& str, ADDON_STATUS state, bool verbose)
64 {
65  color_t colorname = font::NORMAL_COLOR;
66 
67  switch(state) {
68  case ADDON_NONE:
69  if(!verbose) {
70  return str;
71  }
72  colorname = font::weapon_details_color;
73  break;
74  case ADDON_INSTALLED:
76  case ADDON_NOT_TRACKED:
77  colorname = font::GOOD_COLOR;
78  break;
80  colorname = font::YELLOW_COLOR;
81  break;
83  colorname = color_outdated;
84  break;
86  colorname = font::BAD_COLOR;
87  break;
88  default:
89  colorname = font::GRAY_COLOR;
90  break;
91  }
92 
93  return font::span_color(colorname) + str + "</span>";
94 }
95 
97 {
98  std::string tx;
99 
100  switch(info.state) {
101  case ADDON_NONE:
102  tx = info.can_publish ? _("addon_state^Published, not installed") : _("addon_state^Not installed");
103  break;
104 
105  case ADDON_INSTALLED:
106  case ADDON_NOT_TRACKED:
107  // Consider add-ons without version information as installed
108  // for the main display. Their Description info should elaborate
109  // on their status.
110  tx = info.can_publish ? _("addon_state^Published") : _("addon_state^Installed");
111  break;
113  tx = info.can_publish ? _("addon_state^Ready to publish") : _("addon_state^Installed, not ready to publish");
114  break;
115 
117  tx = info.can_publish ? _("addon_state^Published, upgradable") : _("addon_state^Installed, upgradable");
118  break;
119 
121  tx = info.can_publish ? _("addon_state^Published, outdated on server") : _("addon_state^Installed, outdated on server");
122  break;
123 
125  tx = info.can_publish ? _("addon_state^Published, broken") : _("addon_state^Installed, broken");
126  break;
127 
128  default:
129  tx = _("addon_state^Unknown");
130  }
131 
132  return colorize_addon_state_string(tx, info.state, true);
133 }
134 
135 void addon_list::addon_action_wrapper(addon_op_func_t& func, const addon_info& addon, bool& handled, bool& halt)
136 {
137  try {
138  func(addon);
139 
140  handled = halt = true;
141  } catch(const addons_client::user_exit&) {
142  // User canceled the op.
143  }
144 }
145 
147 {
148  listbox& list = get_listbox();
149  list.clear();
150 
151  addon_vector_.clear();
152 
153  for(const auto& a : addons) {
154  const addon_info& addon = a.second;
155  addon_tracking_info tracking_info = get_addon_tracking_info(addon);
156 
157  addon_vector_.push_back(&addon);
158 
159  widget_data data;
160  widget_item item;
161 
162  if(!tracking_info.can_publish) {
163  item["label"] = addon.display_icon();
164  data.emplace("icon", item);
165 
166  item["label"] = addon.display_title();
167  data.emplace("name", item);
168  } else {
169  item["label"] = addon.display_icon() + "~BLIT(icons/icon-addon-publish.png)";
170  data.emplace("icon", item);
171 
172  const std::string publish_name = formatter()
174  << addon.display_title()
175  << "</span>";
176 
177  item["label"] = publish_name;
178  data.emplace("name", item);
179  }
180 
181  item["label"] = describe_status(tracking_info);
182  data.emplace("installation_status", item);
183 
184  // If the addon is upgradable or ourdated on server, we display the two relevant
185  // versions directly in the list for convenience.
186  const bool special_version_display =
187  tracking_info.state == ADDON_INSTALLED_UPGRADABLE ||
188  tracking_info.state == ADDON_INSTALLED_OUTDATED;
189 
190  std::ostringstream ss;
191  if(special_version_display) {
192  ss << tracking_info.installed_version.str() << "\n";
193  }
194 
195  ss << addon.version.str();
196 
197  if(special_version_display) {
198  ss.str(colorize_addon_state_string(ss.str(), tracking_info.state, false));
199  }
200 
201  item["label"] = ss.str();
202  data.emplace("version", item);
203 
204  item["label"] = addon.author;
205  data.emplace("author", item);
206 
207  item["label"] = size_display_string(addon.size);
208  data.emplace("size", item);
209 
210  item["label"] = std::to_string(addon.downloads);
211  data.emplace("downloads", item);
212 
213  item["label"] = addon.display_type();
214  data.emplace("type", item);
215 
216  grid* row_grid = &list.add_row(data);
217 
218  // Set special retval for the toggle panels
219  find_widget<toggle_panel>(row_grid, "list_panel", false).set_retval(DEFAULT_ACTION_RETVAL);
220 
221  // The control button grid is excluded on lower resolutions.
222  grid* control_grid = find_widget<grid>(row_grid, "single_install_buttons", false, false);
223  if(!control_grid) {
224  continue;
225  }
226 
227  //
228  // Set up the inline control buttons.
229  //
230  stacked_widget& install_update_stack = find_widget<stacked_widget>(control_grid, "install_update_stack", false);
231 
232  // These three buttons are in the install_update_stack. Only one is shown depending on the addon's state.
233  button& install_button = find_widget<button>(control_grid, "single_install", false);
234  button& update_button = find_widget<button>(control_grid, "single_update", false);
235  button& publish_button = find_widget<button>(control_grid, "single_publish", false);
236 
237  // This button is always shown.
238  button& uninstall_button = find_widget<button>(control_grid, "single_uninstall", false);
239 
240  const bool is_installed = is_installed_addon_status(tracking_info.state);
241  const bool is_local = tracking_info.state == ADDON_INSTALLED_LOCAL_ONLY;
242 
243  // Select the right button layer and set its callback.
244  if(tracking_info.can_publish) {
245  install_update_stack.select_layer(CONTROL_STACK_LAYER_PUBLISH);
246 
247  publish_button.set_active(true);
248 
249  if(publish_function_ != nullptr) {
250  connect_signal_mouse_left_click(publish_button,
251  std::bind(&addon_list::addon_action_wrapper, this, publish_function_, std::ref(addon), _3, _4));
252 
253  install_button.set_tooltip(_("Publish add-on"));
254  }
255  } else if(tracking_info.state == ADDON_INSTALLED_UPGRADABLE) {
256  install_update_stack.select_layer(CONTROL_STACK_LAYER_UPDATE);
257 
258  update_button.set_active(true);
259 
260  if(update_function_ != nullptr) {
261  connect_signal_mouse_left_click(update_button,
262  std::bind(&addon_list::addon_action_wrapper, this, update_function_, std::ref(addon), _3, _4));
263  }
264  } else {
265  install_update_stack.select_layer(CONTROL_STACK_LAYER_INSTALL);
266 
267  install_button.set_active(!is_installed);
268 
269  if(install_function_ != nullptr) {
270  connect_signal_mouse_left_click(install_button,
271  std::bind(&addon_list::addon_action_wrapper, this, install_function_, std::ref(addon), _3, _4));
272  }
273  }
274 
275  // Set up the Uninstall button.
276  if(tracking_info.can_publish) {
277  // Use the uninstall button as a delete-from-server button if the addon's already been published...
278  uninstall_button.set_active(!is_local);
279 
280  if(!is_local && delete_function_ != nullptr) {
281  connect_signal_mouse_left_click(uninstall_button,
282  std::bind(&addon_list::addon_action_wrapper, this, delete_function_, std::ref(addon), _3, _4));
283 
284  uninstall_button.set_tooltip(_("Delete add-on from server"));
285  }
286  } else {
287  // ... else it functions as normal.
288  uninstall_button.set_active(is_installed);
289 
290  if(is_installed && uninstall_function_ != nullptr) {
291  connect_signal_mouse_left_click(uninstall_button,
292  std::bind(&addon_list::addon_action_wrapper, this, uninstall_function_, std::ref(addon), _3, _4));
293  }
294  }
295 
296  control_grid->set_visible(install_buttons_visibility_);
297  find_widget<label>(row_grid, "installation_status", false).set_visible(install_status_visibility_);
298  }
299 
301 }
302 
304 {
305  const listbox& list = find_widget<const listbox>(&get_grid(), "addons", false);
306 
307  try {
308  return addon_vector_.at(list.get_selected_row());
309  } catch(const std::out_of_range&) {
310  return nullptr;
311  }
312 }
313 
315 {
316  const addon_info* addon = get_selected_addon();
317  if(addon == nullptr || !get_addon_tracking_info(*addon).can_publish) {
318  return "";
319  } else {
320  return addon->id;
321  }
322 }
323 
324 void addon_list::select_addon(const std::string& id)
325 {
326  listbox& list = get_listbox();
327 
328  auto iter = std::find_if(addon_vector_.begin(), addon_vector_.end(),
329  [&id](const addon_info* a) { return a->id == id; }
330  );
331 
332  // Corner case: if you publish an addon with an out-of-folder .pbl file and
333  // delete it locally before deleting it from the server, the game will try
334  // to reselect an addon that now doesn't exist.
335  //
336  // I don't anticipate this check will match very often, but in the case that
337  // some other weird corner case crops up, it's probably better to just exit
338  // silently than asserting, as was the pervious behavior.
339  if(iter == addon_vector_.end()) {
340  return;
341  }
342 
343  const addon_info& info = **iter;
344 
345  for(unsigned int i = 0u; i < list.get_item_count(); ++i) {
346  grid* row = list.get_row_grid(i);
347 
348  const label& name_label = find_widget<label>(row, "name", false);
349  if(name_label.get_label().base_str() == info.display_title()) {
350  list.select_row(i);
351  }
352  }
353 }
354 
356 {
357  return find_widget<listbox>(&get_grid(), "addons", false);
358 }
359 
361 {
362  if(window* window = get_window()) {
364  }
365 }
366 
368 {
369  listbox& list = get_listbox();
370 
371  list.register_translatable_sorting_option(0, [this](const int i) { return addon_vector_[i]->title; });
372  list.register_sorting_option(1, [this](const int i) { return addon_vector_[i]->author; });
373  list.register_sorting_option(2, [this](const int i) { return addon_vector_[i]->size; });
374  list.register_sorting_option(3, [this](const int i) { return addon_vector_[i]->downloads; });
375  list.register_translatable_sorting_option(4, [this](const int i) { return addon_vector_[i]->display_type(); });
376 
377  auto order = std::make_pair(0, gui2::listbox::SORT_ASCENDING);
378  list.set_active_sorting_option(order);
379 }
380 
382 {
383  listbox& list = get_listbox();
384 
385  generator_base::order_func generator_func = [this, func](unsigned a, unsigned b)
386  {
387  return func(*addon_vector_[a], *addon_vector_[b]);
388  };
389 
390  list.mark_as_unsorted();
391  list.order_by(generator_func);
392 }
393 
395 {
396  if(addon_vector_.empty()) {
397  // Happens in the dialog unit test.
398  return;
399  }
400 
401  const addon_info* first_addon = addon_vector_[0];
402 
403  for(const addon_info* a : addon_vector_) {
404  if(a->display_title().compare(first_addon->display_title()) < 0) {
405  first_addon = a;
406  }
407  }
408 
409  select_addon(first_addon->id);
410 }
411 
414 {
415  DBG_GUI_P << "Parsing add-on list " << id << "\n";
416 
417  load_resolutions<resolution>(cfg);
418 }
419 
421  : resolution_definition(cfg), grid(nullptr)
422 {
423  // Add a dummy state since every widget needs a state.
424  static config dummy("draw");
425  state.emplace_back(dummy);
426 
427  const config& child = cfg.child("grid");
428  VALIDATE(child, _("No grid defined."));
429 
430  grid = std::make_shared<builder_grid>(child);
431 }
432 
433 namespace implementation
434 {
435 
436 static widget::visibility parse_visibility(const std::string& str)
437 {
438  if(str == "visible") {
440  } else if(str == "hidden") {
442  } else if(str == "invisible") {
444  } else {
445  FAIL("Invalid visibility value");
446  }
447 }
448 
449 builder_addon_list::builder_addon_list(const config& cfg)
450  : builder_styled_widget(cfg)
451  , install_status_visibility_(widget::visibility::visible)
452  , install_buttons_visibility_(widget::visibility::invisible)
453 {
454  if(cfg.has_attribute("install_status_visibility")) {
455  install_status_visibility_ = parse_visibility(cfg["install_status_visibility"]);
456  }
457 
458  if(cfg.has_attribute("install_buttons_visibility")) {
459  install_buttons_visibility_ = parse_visibility(cfg["install_buttons_visibility"]);
460  }
461 }
462 
464 {
465  auto widget = std::make_shared<addon_list>(*this);
466 
467  DBG_GUI_G << "Window builder: placed add-on list '" << id <<
468  "' with definition '" << definition << "'.\n";
469 
470  const auto conf = widget->cast_config_to<addon_list_definition>();
471  assert(conf != nullptr);
472 
473  widget->init_grid(conf->grid);
474 
475  widget->set_install_status_visibility(install_status_visibility_);
476  widget->set_install_buttons_visibility(install_buttons_visibility_);
477 
478  widget->finalize_setup();
479 
480  return widget;
481 }
482 
483 } // end namespace implementation
484 
485 } // end namespace gui2
int size
Definition: info.hpp:41
Base class of a resolution, contains the common keys for a resolution.
listbox & get_listbox()
Returns the underlying list box.
Definition: addon_list.cpp:355
#define DBG_GUI_P
Definition: log.hpp:68
visibility install_status_visibility_
Definition: addon_list.hpp:160
void set_active_sorting_option(const order_pair &sort_by, const bool select_first=false)
Sorts the listbox by a pre-set sorting option.
Definition: listbox.cpp:621
ADDON_STATUS state
Definition: state.hpp:56
void addon_action_wrapper(addon_op_func_t &func, const addon_info &addon, bool &handled, bool &halt)
Helper to wrap the execution of any of the addon operation functions.
Definition: addon_list.cpp:135
config & child(config_key_type key, int n=0)
Returns the nth child with the given key, or a reference to an invalid config if there is none...
Definition: config.cpp:423
static std::string describe_status(const addon_tracking_info &info)
Definition: addon_list.cpp:96
std::vector< state_definition > state
std::function< bool(const addon_info &, const addon_info &)> addon_sort_func
Definition: addon_list.hpp:41
int dummy
Definition: lstrlib.cpp:1125
const addon_info * get_selected_addon() const
Returns the selected add-on.
Definition: addon_list.cpp:303
void mark_as_unsorted()
Deactivates all sorting toggle buttons at the top, making the list look like it&#39;s not sorted...
Definition: listbox.cpp:653
const color_t GRAY_COLOR
virtual widget_ptr build() const override
Definition: addon_list.cpp:463
const grid & get_grid() const
std::string display_title() const
Get a title or automatic title for display.
Definition: info.cpp:126
Add a special kind of assert to validate whether the input from WML doesn&#39;t contain any problems that...
const color_t GOOD_COLOR
addon_list_definition(const config &cfg)
Definition: addon_list.cpp:412
bool has_attribute(config_key_type key) const
Definition: config.cpp:217
logger & info()
Definition: log.cpp:90
void add_list_to_keyboard_chain()
Adds the internal listbox to the keyboard event chain.
Definition: addon_list.cpp:360
#define a
static widget::visibility parse_visibility(const std::string &str)
Definition: addon_list.cpp:436
const std::string & id() const
Definition: widget.cpp:106
This file contains the window object, this object is a top level container which has the event manage...
ADDON_STATUS
Defines various add-on installation statuses.
Definition: state.hpp:21
Base class for all widgets.
Definition: widget.hpp:48
std::function< bool(unsigned, unsigned)> order_func
Definition: generator.hpp:251
std::string get_remote_addon_id()
Returns the selected add-on id, for use with remote publish/delete ops.
Definition: addon_list.cpp:314
addon_op_func_t delete_function_
Definition: addon_list.hpp:168
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:65
void register_translatable_sorting_option(const int col, translatable_sorter_func_t f)
Registers a special sorting function specifically for translatable values.
Definition: listbox.cpp:613
Label showing a text.
Definition: label.hpp:32
int get_selected_row() const
Returns the first selected row.
Definition: listbox.cpp:269
void add_to_keyboard_chain(widget *widget)
Adds the widget to the keyboard chain.
Definition: window.cpp:1080
version_info installed_version
Definition: state.hpp:59
No tracking information available.
Definition: state.hpp:36
Add-on is not installed.
Definition: state.hpp:23
bool select_row(const unsigned row, const bool select=true)
Selects a row.
Definition: listbox.cpp:247
Generic file dialog.
Definition: field-fwd.hpp:22
#define b
The listbox class.
Definition: listbox.hpp:40
std::string span_color(const color_t &color)
Returns a Pango formatting string using the provided color_t object.
Base container class.
Definition: grid.hpp:30
visibility install_buttons_visibility_
Definition: addon_list.hpp:161
static UNUSEDNOWARN std::string _(const char *str)
Definition: gettext.hpp:89
std::string definition
Parameters for the styled_widget.
Version in the server is older than local installation.
Definition: state.hpp:29
std::map< std::string, t_string > widget_item
Definition: widget.hpp:27
bool is_installed_addon_status(ADDON_STATUS s)
Definition: state.hpp:39
#define VALIDATE(cond, message)
The macro to use for the validation of WML.
void set_addon_order(addon_sort_func func)
Definition: addon_list.cpp:381
std::ostringstream wrapper.
Definition: formatter.hpp:38
void clear()
Removes all the rows in the listbox, clearing it.
Definition: listbox.cpp:124
std::shared_ptr< widget > widget_ptr
Definition: widget.hpp:732
void set_visible(const visibility visible)
Definition: widget.cpp:445
void connect_signal_mouse_left_click(dispatcher &dispatcher, const signal_function &signal)
Connects a signal handler for a left mouse button click.
Definition: dispatcher.cpp:163
std::string display_icon() const
Get an icon path fixed for display (e.g.
Definition: info.cpp:135
std::string id
Definition: info.hpp:31
Version in the server is newer than local installation.
Definition: state.hpp:27
std::string display_type() const
Get an add-on type identifier for display in the user&#39;s language.
Definition: info.cpp:152
std::vector< const addon_info * > addon_vector_
Definition: addon_list.hpp:158
unsigned get_item_count() const
Returns the number of items in the listbox.
Definition: listbox.cpp:130
void set_addons(const addons_list &addons)
Sets the add-ons to show.
Definition: addon_list.cpp:146
const color_t YELLOW_COLOR
Dependencies not satisfied.
Definition: state.hpp:34
widget::visibility install_buttons_visibility_
Definition: addon_list.hpp:221
const color_t NORMAL_COLOR
#define REGISTER_WIDGET(id)
Wrapper for REGISTER_WIDGET3.
void order_by(const generator_base::order_func &func)
Definition: listbox.cpp:597
const color_t weapon_details_color
void select_addon(const std::string &id)
Selects the add-on with the given ID.
Definition: addon_list.cpp:324
void select_first_addon()
Needed because otherwise the add-on with the first ID would be initially selected.
Definition: addon_list.cpp:394
addon_op_func_t uninstall_function_
Definition: addon_list.hpp:164
std::size_t i
Definition: function.cpp:933
The user set the widget invisible, that means:
window * get_window()
Get the parent window.
Definition: widget.cpp:113
std::string size_display_string(double size)
Get a human-readable representation of the specified byte count.
Definition: info.cpp:217
visibility
Visibility settings done by the user.
Definition: widget.hpp:58
No version in the server.
Definition: state.hpp:31
A generic container base class.
void select_layer(const int layer)
Selects and displays a particular layer.
static std::string colorize_addon_state_string(const std::string &str, ADDON_STATUS state, bool verbose=false)
Changes the color of an add-on state string (installed, outdated, etc.) according to the state itself...
Definition: addon_list.cpp:63
addon_op_func_t publish_function_
Definition: addon_list.hpp:167
const grid * get_row_grid(const unsigned row) const
Returns the grid of the wanted row.
Definition: listbox.cpp:234
const t_string & get_label() const
The user sets the widget visible, that means:
addon_op_func_t install_function_
Definition: addon_list.hpp:163
addon_tracking_info get_addon_tracking_info(const addon_info &addon)
Get information about an add-on comparing its local state with the add-ons server entry...
Definition: state.cpp:24
The user sets the widget hidden, that means:
Simple push button.
Definition: button.hpp:35
std::string str() const
Serializes the version number into string form.
version_info version
Definition: info.hpp:37
std::string base_str() const
Definition: tstring.hpp:190
std::map< std::string, widget_item > widget_data
Definition: widget.hpp:30
#define FAIL(message)
Stores additional status information about add-ons.
Definition: state.hpp:45
std::function< void(const addon_info &)> addon_op_func_t
Definition: addon_list.hpp:66
int downloads
Definition: info.hpp:42
void register_sorting_option(const int col, const Func &f)
Definition: listbox.hpp:268
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:68
std::map< std::string, addon_info > addons_list
Definition: info.hpp:26
base class of top level items, the only item which needs to store the final canvases to draw on ...
Definition: window.hpp:62
#define DBG_GUI_G
Definition: log.hpp:40
static const int DEFAULT_ACTION_RETVAL
Special retval for the toggle panels in the addons list.
Definition: addon_list.hpp:46
std::string author
Definition: info.hpp:39
Contains the implementation details for lexical_cast and shouldn&#39;t be used directly.
const color_t BAD_COLOR
Version in the server matches local installation.
Definition: state.hpp:25
addon_op_func_t update_function_
Definition: addon_list.hpp:165