The Battle for Wesnoth  1.17.0-dev
window.hpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2007 - 2021
3  by Mark de Wever <koraq@xs4all.nl>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 /**
17  * @file
18  * This file contains the window object, this object is a top level container
19  * which has the event management as well.
20  */
21 
22 #pragma once
23 
24 #include "formula/callable.hpp"
25 #include "formula/function.hpp"
29 #include "gui/widgets/panel.hpp"
30 #include "gui/widgets/retval.hpp"
31 
32 #include <functional>
33 #include <map>
34 #include <memory>
35 #include <string>
36 #include <vector>
37 
38 class CVideo;
39 class surface;
40 struct point;
41 
42 namespace gui2
43 {
44 
45 class widget;
46 namespace event { struct message; }
47 
48 // ------------ WIDGET -----------{
49 
50 namespace dialogs { class modal_dialog; }
51 class debug_layout_graph;
52 class pane;
53 
54 namespace event
55 {
56 class distributor;
57 } // namespace event
58 
59 /**
60  * @ingroup GUIWidgetWML
61  *
62  * base class of top level items, the only item which needs to store the final canvases to draw on.
63  * A window is a kind of panel see the panel for which fields exist.
64  */
65 class window : public panel
66 {
67  friend class debug_layout_graph;
68  friend std::unique_ptr<window> build(const builder_window::window_resolution&);
69  friend struct window_implementation;
71  friend class pane;
72 
73 public:
74  explicit window(const builder_window::window_resolution& definition);
75 
76  ~window();
77 
78  /**
79  * Returns the instance of a window.
80  *
81  * @param handle The instance id of the window.
82  *
83  * @returns The window or nullptr.
84  */
85  static window* window_instance(const unsigned handle);
86 
87  /** Gets the retval for the default buttons. */
88  static retval get_retval_by_id(const std::string& id);
89 
90  /**
91  * @todo Clean up the show functions.
92  *
93  * the show functions are a bit messy and can use a proper cleanup.
94  */
95 
96  /**
97  * Shows the window.
98  *
99  * @param restore Restore the screenarea the window was on
100  * after closing it?
101  * @param auto_close_timeout The time in ms after which the window will
102  * automatically close, if 0 it doesn't close.
103  * @note the timeout is a minimum time and
104  * there's no guarantee about how fast it closes
105  * after the minimum.
106  *
107  * @returns The close code of the window, predefined
108  * values are listed in retval.
109  */
110  int show(const bool restore = true, const unsigned auto_close_timeout = 0);
111 
112  /**
113  * Shows the window as a tooltip.
114  *
115  * A tooltip can't be interacted with and is just shown.
116  *
117  * @todo implement @p auto_close_timeout.
118  *
119  * @p auto_close_timeout The time in ms after which the window will
120  * automatically close, if 0 it doesn't close.
121  * @note the timeout is a minimum time and
122  * there's no guarantee about how fast it closes
123  * after the minimum.
124  */
125  void show_tooltip(/*const unsigned auto_close_timeout = 0*/);
126 
127  /**
128  * Shows the window non modal.
129  *
130  * A tooltip can be interacted with unlike the tooltip.
131  *
132  * @todo implement @p auto_close_timeout.
133  *
134  * @p auto_close_timeout The time in ms after which the window will
135  * automatically close, if 0 it doesn't close.
136  * @note the timeout is a minimum time and
137  * there's no guarantee about how fast it closes
138  * after the minimum.
139  */
140  void show_non_modal(/*const unsigned auto_close_timeout = 0*/);
141 
142  /**
143  * Draws the window.
144  *
145  * This routine draws the window if needed, it's called from the event
146  * handler. This is done by a drawing event. When a window is shown it
147  * manages an SDL timer which fires a drawing event every X milliseconds,
148  * that event calls this routine. Don't call it manually.
149  */
150  void draw();
151 
152  /**
153  * Undraws the window.
154  */
155  void undraw();
156 
157  /**
158  * Adds an item to the dirty_list_.
159  *
160  * @param call_stack The list of widgets traversed to get to the
161  * dirty widget.
162  */
163  void add_to_dirty_list(const std::vector<widget*>& call_stack)
164  {
165  dirty_list_.push_back(call_stack);
166  }
167 
168  /** The status of the window. */
169  enum class status {
170  NEW, /**< The window is new and not yet shown. */
171  SHOWING, /**< The window is being shown. */
172  REQUEST_CLOSE, /**< The window has been requested to be closed but still needs to evaluate the request. */
173  CLOSED /**< The window has been closed. */
174  };
175 
176  /**
177  * Requests to close the window.
178  *
179  * At the moment the request is always honored but that might change in the
180  * future.
181  */
182  void close()
183  {
184  status_ = status::REQUEST_CLOSE;
185  }
186 
187  /**
188  * Helper class to block invalidate_layout.
189  *
190  * Some widgets can handling certain layout aspects without help. For
191  * example a listbox can handle hiding and showing rows without help but
192  * setting the visibility calls invalidate_layout(). When this blocker is
193  * Instantiated the call to invalidate_layout() becomes a nop.
194  *
195  * @note The class can't be used recursively.
196  */
198  {
199  public:
202 
203  private:
204  window& window_;
205  };
206 
207  /** Is invalidate_layout blocked, see invalidate_layout_blocker. */
209  {
210  return invalidate_layout_blocked_;
211  }
212 
213  /**
214  * Updates the size of the window.
215  *
216  * If the window has automatic placement set this function recalculates the
217  * window. To be used after creation and after modification or items which
218  * can have different sizes eg listboxes.
219  */
220  void invalidate_layout();
221 
222  /** See @ref widget::find_at. */
223  virtual widget* find_at(const point& coordinate,
224  const bool must_be_active) override;
225 
226  /** See @ref widget::find_at. */
227  virtual const widget* find_at(const point& coordinate,
228  const bool must_be_active) const override;
229 
230  /** Inherited from widget. */
232  {
233  return owner_;
234  }
235 
236  /** See @ref widget::find. */
237  widget* find(const std::string& id, const bool must_be_active) override;
238 
239  /** See @ref widget::find. */
240  const widget* find(const std::string& id,
241  const bool must_be_active) const override;
242 
243 #if 0
244  /** @todo Implement these functions. */
245  /**
246  * Register a widget that prevents easy closing.
247  *
248  * Duplicate registration are ignored. See click_dismiss_ for more info.
249  *
250  * @param id The id of the widget to register.
251  */
252  void add_click_dismiss_blocker(const std::string& id);
253 
254  /**
255  * Unregister a widget the prevents easy closing.
256  *
257  * Removing a non registered id is allowed but will do nothing. See
258  * click_dismiss_ for more info.
259  *
260  * @param id The id of the widget to register.
261  */
262  void remove_click_dismiss_blocker(const std::string& id);
263 #endif
264 
265  /**
266  * Does the window close easily?
267  *
268  * The behavior can change at run-time, but that might cause oddities
269  * with the easy close button (when one is needed).
270  *
271  * @returns Whether or not the window closes easily.
272  */
273  bool does_click_dismiss() const
274  {
275  return click_dismiss_ && !disable_click_dismiss();
276  }
277 
278  /**
279  * Disable the enter key.
280  *
281  * This is added to block dialogs from being closed automatically.
282  *
283  * @todo this function should be merged with the hotkey support once
284  * that has been added.
285  */
286  void set_enter_disabled(const bool enter_disabled)
287  {
288  enter_disabled_ = enter_disabled;
289  }
290 
291  /**
292  * Disable the escape key.
293  *
294  * This is added to block dialogs from being closed automatically.
295  *
296  * @todo this function should be merged with the hotkey support once
297  * that has been added.
298  */
299  void set_escape_disabled(const bool escape_disabled)
300  {
301  escape_disabled_ = escape_disabled;
302  }
303 
304  /**
305  * Initializes a linked size group.
306  *
307  * Note at least one of fixed_width or fixed_height must be true.
308  *
309  * @param id The id of the group.
310  * @param fixed_width Does the group have a fixed width?
311  * @param fixed_height Does the group have a fixed height?
312  */
313  void init_linked_size_group(const std::string& id,
314  const bool fixed_width,
315  const bool fixed_height);
316 
317  /**
318  * Is the linked size group defined for this window?
319  *
320  * @param id The id of the group.
321  *
322  * @returns True if defined, false otherwise.
323  */
324  bool has_linked_size_group(const std::string& id);
325 
326  /**
327  * Adds a widget to a linked size group.
328  *
329  * The group needs to exist, which is done by calling
330  * init_linked_size_group. A widget may only be member of one group.
331  * @todo Untested if a new widget is added after showing the widgets.
332  *
333  * @param id The id of the group.
334  * @param widget The widget to add to the group.
335  */
336  void add_linked_widget(const std::string& id, widget* widget);
337 
338  /**
339  * Removes a widget from a linked size group.
340  *
341  * The group needs to exist, which is done by calling
342  * init_linked_size_group. If the widget is no member of the group the
343  * function does nothing.
344  *
345  * @param id The id of the group.
346  * @param widget The widget to remove from the group.
347  */
348  void remove_linked_widget(const std::string& id, const widget* widget);
349 
350  /***** ***** ***** setters / getters for members ***** ****** *****/
351 
352  /**
353  * Sets there return value of the window.
354  *
355  * @param retval The return value for the window.
356  * @param close_window Close the window after setting the value.
357  */
358  void set_retval(const int retval, const bool close_window = true)
359  {
360  retval_ = retval;
361  if(close_window)
362  close();
363  }
364 
366  {
367  return retval_;
368  }
369 
371  {
372  owner_ = owner;
373  }
374 
375  void set_click_dismiss(const bool click_dismiss)
376  {
377  click_dismiss_ = click_dismiss;
378  }
379 
380  bool get_need_layout() const
381  {
382  return need_layout_;
383  }
384 
385  void set_variable(const std::string& key, const wfl::variant& value)
386  {
387  variables_.add(key, value);
388  set_is_dirty(true);
389  }
390  point get_linked_size(const std::string& linked_group_id) const
391  {
392  std::map<std::string, linked_size>::const_iterator it = linked_size_.find(linked_group_id);
393  if(it != linked_size_.end()) {
394  return point(it->second.width, it->second.height);
395  }
396 
397  return point(-1, -1);
398  }
399 
400  /**
401  * Sets the window's exit hook.
402  *
403  * A window will only close if this function returns true.
404  *
405  * @param func A function taking a window reference and returning a boolean result.
406  */
407  void set_exit_hook(std::function<bool(window&)> func)
408  {
409  exit_hook_ = func;
410  }
411 
412  void set_exit_hook_ok_only(std::function<bool(window&)> func)
413  {
414  exit_hook_ = [func](window& w)->bool { return w.get_retval() != OK || func(w); };
415  }
416 
417  /**
418  * Sets a callback that will be called after the window is drawn next time.
419  * The callback is automatically removed after calling it once.
420  * Useful if you need to do something after the window is drawn for the first time
421  * and it's timing-sensitive (i.e. pre_show is too early).
422  */
423  void set_callback_next_draw(std::function<void()> func)
424  {
425  callback_next_draw_ = func;
426  }
427 
428  enum class show_mode {
429  none,
430  modal,
431  modeless,
432  tooltip
433  };
434 
435 private:
436  /** Needed so we can change what's drawn on the screen. */
438 
439  /** The status of the window. */
441 
442  /**
443  * The mode in which the window is shown.
444  *
445  * This is used to determine whether or not to remove the tip.
446  */
448 
449  // return value of the window, 0 default.
450  int retval_;
451 
452  /** The dialog that owns the window. */
454 
455  /**
456  * When set the form needs a full layout redraw cycle.
457  *
458  * This happens when either a widget changes it's size or visibility or
459  * the window is resized.
460  */
462 
463  /** The variables of the canvas. */
465 
466  /** Is invalidate_layout blocked, see invalidate_layout_blocker. */
468 
469  /** Avoid drawing the window. */
471 
472  /** Whether the window should undraw the window using restorer_ */
473  bool restore_;
474 
475  /** Whether the window has other windows behind it */
477 
478  /** When the window closes this surface is used to undraw the window. */
480 
481  /** Do we wish to place the widget automatically? */
483 
484  /**
485  * Sets the horizontal placement.
486  *
487  * Only used if automatic_placement_ is true.
488  * The value should be a grid placement flag.
489  */
490  const unsigned horizontal_placement_;
491 
492  /**
493  * Sets the vertical placement.
494  *
495  * Only used if automatic_placement_ is true.
496  * The value should be a grid placement flag.
497  */
498  const unsigned vertical_placement_;
499 
500  /** The maximum width if automatic_placement_ is true. */
502 
503  /** The maximum height if automatic_placement_ is true. */
505 
506  /** The formula to calculate the x value of the dialog. */
508 
509  /** The formula to calculate the y value of the dialog. */
511 
512  /** The formula to calculate the width of the dialog. */
514 
515  /** The formula to calculate the height of the dialog. */
517 
518  /** The formula to determine whether the size is good. */
520 
521  /** The formula definitions available for the calculation formulas. */
523 
524  /** The settings for the tooltip. */
526 
527  /** The settings for the helptip. */
529 
530  /**
531  * Do we want to have easy close behavior?
532  *
533  * Easy closing means that whenever a mouse click is done the dialog will
534  * be closed. The widgets in the window may override this behavior by
535  * registering themselves as blockers. This is tested by the function
536  * disable_click_dismiss().
537  *
538  * The handling of easy close is done in the window, in order to do so a
539  * window either needs a click_dismiss or an ok button. Both will be hidden
540  * when not needed and when needed first the ok is tried and then the
541  * click_dismiss button. this allows adding a click_dismiss button to the
542  * window definition and use the ok from the window instance.
543  *
544  * @todo After testing the click dismiss feature it should be documented in
545  * the wiki.
546  */
548 
549  /** Disable the enter key see our setter for more info. */
551 
552  /** Disable the escape key see our setter for more info. */
554 
555  /**
556  * Helper struct to force widgets the have the same size.
557  *
558  * Widget which are linked will get the same width and/or height. This
559  * can especially be useful for listboxes, but can also be used for other
560  * applications.
561  */
562  struct linked_size
563  {
564  linked_size(const bool width = false, const bool height = false)
565  : widgets(), width(width ? 0 : -1), height(height ? 0 : -1)
566  {
567  }
568 
569  /** The widgets linked. */
570  std::vector<widget*> widgets;
571 
572  /** The current width of all widgets in the group, -1 if the width is not linked. */
573  int width;
574 
575  /** The current height of all widgets in the group, -1 if the height is not linked. */
576  int height;
577  };
578 
579  /** List of the widgets, whose size are linked together. */
580  std::map<std::string, linked_size> linked_size_;
581 
582  /** List of widgets in the tabbing order. */
583  std::vector<widget*> tab_order;
584 
585  /**
586  * Layouts the window.
587  *
588  * This part does the pre and post processing for the actual layout
589  * algorithm.
590  *
591  * See @ref layout_algorithm for more information.
592  */
593  void layout();
594 
595  /**
596  * Layouts the linked widgets.
597  *
598  * See @ref layout_algorithm for more information.
599  */
600  void layout_linked_widgets();
601 
602  /**
603  * Handles a mouse click event for dismissing the dialog.
604  *
605  * @param mouse_button_mask The SDL_BUTTON mask for the button used to
606  * dismiss the click. If the caller is from the
607  * keyboard code the value should be 0.
608  *
609  * @return Whether the event should be considered as
610  * handled.
611  */
612  bool click_dismiss(const int mouse_button_mask);
613 
614  /**
615  * The state of the mouse button.
616  *
617  * When click dismissing a dialog in the past the DOWN event was used.
618  * This lead to a bug [1]. The obvious change was to switch to the UP
619  * event, this lead to another bug; the dialog was directly dismissed.
620  * Since the game map code uses the UP and DOWN event to select a unit
621  * there is no simple solution.
622  *
623  * Upon entry this value stores the mouse button state at entry. When a
624  * button is DOWN and goes UP that button does \em not trigger a dismissal
625  * of the dialog, instead that button's down state is removed from this
626  * variable. Therefore the next UP event does dismiss the dialog.
627  *
628  * [1] https://gna.org/bugs/index.php?18970
629  */
631 
632 public:
633  /** Static type getter that does not rely on the widget being constructed. */
634  static const std::string& type();
635 
636 private:
637  /** Inherited from styled_widget, implemented by REGISTER_WIDGET. */
638  virtual const std::string& get_control_type() const override;
639 
640  /**
641  * The list with dirty items in the window.
642  *
643  * When drawing only the widgets that are dirty are updated. The draw()
644  * function has more information about the dirty_list_.
645  */
646  std::vector<std::vector<widget*>> dirty_list_;
647 
648  /**
649  * In how many consecutive frames the window has changed. This is used to
650  * detect the situation where the title screen changes in every frame,
651  * forcing all other windows to redraw everything all the time.
652  */
653  unsigned int consecutive_changed_frames_ = 0u;
654 
655  /** Schedules windows on top of us (if any) to redraw. */
656  void redraw_windows_on_top() const;
657 
658  /**
659  * Finishes the initialization of the grid.
660  *
661  * @param content_grid The new contents for the content grid.
662  */
663  void finalize(const builder_grid& content_grid);
664 
665 #ifdef DEBUG_WINDOW_LAYOUT_GRAPHS
666  debug_layout_graph* debug_layout_;
667 
668 public:
669  /** wrapper for debug_layout_graph::generate_dot_file. */
670  void generate_dot_file(const std::string& generator, const unsigned domain);
671 
672 private:
673 #else
674  void generate_dot_file(const std::string&, const unsigned)
675  {
676  }
677 #endif
678 
679  std::unique_ptr<event::distributor> event_distributor_;
680 
681 public:
682  /** Gets a reference to the window's distributor to allow some state peeking. */
684  {
685  return *event_distributor_;
686  }
687 
688  /** Returns the dialog mode for this window. */
689  show_mode mode() const
690  {
691  return show_mode_;
692  }
693 
694  // mouse and keyboard_capture should be renamed and stored in the
695  // dispatcher. Chaining probably should remain exclusive to windows.
696  void mouse_capture(const bool capture = true);
697  void keyboard_capture(widget* widget);
698 
699  /**
700  * Adds the widget to the keyboard chain.
701  *
702  * @todo rename to keyboard_add_to_chain.
703  * @param widget The widget to add to the chain. The widget
704  * should be valid widget, which hasn't been
705  * added to the chain yet.
706  */
707  void add_to_keyboard_chain(widget* widget);
708 
709  /**
710  * Remove the widget from the keyboard chain.
711  *
712  * @todo rename to keyboard_remove_from_chain.
713  *
714  * @param widget The widget to be removed from the chain.
715  */
716  void remove_from_keyboard_chain(widget* widget);
717 
718  /**
719  * Add the widget to the tabbing order
720  * @param widget The widget to be added to the tabbing order
721  * @param at A hint for where to place the widget in the tabbing order
722  */
723  void add_to_tab_order(widget* widget, int at = -1);
724 
725 private:
726  /***** ***** ***** signal handlers ***** ****** *****/
727 
728  void signal_handler_sdl_video_resize(const event::ui_event event,
729  bool& handled,
730  const point& new_size);
731 
732  /**
733  * The handler for the click dismiss mouse 'event'.
734  *
735  * @param event See @ref event::dispatcher::fire.
736  * @param handled See @ref event::dispatcher::fire.
737  * @param halt See @ref event::dispatcher::fire.
738  * @param mouse_button_mask Forwared to @ref click_dismiss.
739  */
740  void signal_handler_click_dismiss(const event::ui_event event,
741  bool& handled,
742  bool& halt,
743  const int mouse_button_mask);
744 
745  void signal_handler_sdl_key_down(const event::ui_event event,
746  bool& handled,
747  const SDL_Keycode key,
748  const SDL_Keymod mod,
749  bool handle_tab);
750 
751  void signal_handler_message_show_tooltip(const event::ui_event event,
752  bool& handled,
753  const event::message& message);
754 
755  void signal_handler_message_show_helptip(const event::ui_event event,
756  bool& handled,
757  const event::message& message);
758 
759  void signal_handler_request_placement(const event::ui_event event,
760  bool& handled);
761 
762  void signal_handler_close_window();
763 
764  std::function<bool(window&)> exit_hook_;
765  std::function<void()> callback_next_draw_;
766 };
767 
768 // }---------- DEFINITION ---------{
769 
771 {
772  explicit window_definition(const config& cfg);
773 
775  {
776  explicit resolution(const config& cfg);
777 
779  };
780 };
781 
782 // }------------ END --------------
783 
784 } // namespace gui2
bool click_dismiss_
Do we want to have easy close behavior?
Definition: window.hpp:547
wfl::function_symbol_table functions_
The formula definitions available for the calculation formulas.
Definition: window.hpp:522
void close()
Requests to close the window.
Definition: window.hpp:182
show_mode mode() const
Returns the dialog mode for this window.
Definition: window.hpp:689
void set_exit_hook_ok_only(std::function< bool(window &)> func)
Definition: window.hpp:412
typed_formula< unsigned > maximum_height_
The maximum height if automatic_placement_ is true.
Definition: window.hpp:504
bool does_click_dismiss() const
Does the window close easily?
Definition: window.hpp:273
std::function< bool(window &)> exit_hook_
Definition: window.hpp:764
Helper class to block invalidate_layout.
Definition: window.hpp:197
typed_formula< unsigned > h_
The formula to calculate the height of the dialog.
Definition: window.hpp:516
Key Type Default Description window_width unsigned 0 Width of the application window.
const unsigned horizontal_placement_
Sets the horizontal placement.
Definition: window.hpp:490
A panel is a visible container to hold multiple widgets.
Definition: panel.hpp:58
Main class to show messages to the user.
Definition: message.hpp:35
CVideo & video_
Needed so we can change what&#39;s drawn on the screen.
Definition: window.hpp:437
Definition: video.hpp:32
void generate_dot_file(const std::string &, const unsigned)
Definition: window.hpp:674
Helper struct to force widgets the have the same size.
Definition: window.hpp:562
Base class for all widgets.
Definition: widget.hpp:49
void set_click_dismiss(const bool click_dismiss)
Definition: window.hpp:375
void set_escape_disabled(const bool escape_disabled)
Disable the escape key.
Definition: window.hpp:299
typed_formula< unsigned > w_
The formula to calculate the width of the dialog.
Definition: window.hpp:513
status
The status of the window.
Definition: window.hpp:169
int mouse_button_state_
The state of the mouse button.
Definition: window.hpp:630
Generic file dialog.
Definition: field-fwd.hpp:23
int width
The current width of all widgets in the group, -1 if the width is not linked.
Definition: window.hpp:573
point get_linked_size(const std::string &linked_group_id) const
Definition: window.hpp:390
The message callbacks hold a reference to a message.
Definition: message.hpp:45
The event handler class for the widget library.
static std::string at(const std::string &file, int line)
status status_
The status of the window.
Definition: window.hpp:440
std::vector< widget * > widgets
The widgets linked.
Definition: window.hpp:570
surface restorer_
When the window closes this surface is used to undraw the window.
Definition: window.hpp:479
bool suspend_drawing_
Avoid drawing the window.
Definition: window.hpp:470
bool enter_disabled_
Disable the enter key see our setter for more info.
Definition: window.hpp:550
bool invalidate_layout_blocked_
Is invalidate_layout blocked, see invalidate_layout_blocker.
Definition: window.hpp:467
bool need_layout_
When set the form needs a full layout redraw cycle.
Definition: window.hpp:461
typed_formula< bool > reevaluate_best_size_
The formula to determine whether the size is good.
Definition: window.hpp:519
builder_window::window_resolution::tooltip_info helptip_
The settings for the helptip.
Definition: window.hpp:528
bool is_toplevel_
Whether the window has other windows behind it.
Definition: window.hpp:476
static thread_local std::deque< std::string > call_stack
For printing error messages when WFL parsing or evaluation fails, this contains the names of the WFL ...
Definition: function.cpp:47
typed_formula< unsigned > y_
The formula to calculate the y value of the dialog.
Definition: window.hpp:510
Basic template class to generate new items.
const bool automatic_placement_
Do we wish to place the widget automatically?
Definition: window.hpp:482
typed_formula< unsigned > maximum_width_
The maximum width if automatic_placement_ is true.
Definition: window.hpp:501
static void show_tooltip(const tooltip &tip)
Definition: tooltips.cpp:61
typed_formula< unsigned > x_
The formula to calculate the x value of the dialog.
Definition: window.hpp:507
std::vector< std::vector< widget * > > dirty_list_
The list with dirty items in the window.
Definition: window.hpp:646
bool escape_disabled_
Disable the escape key see our setter for more info.
Definition: window.hpp:553
A pane is a container where new members can be added and removed during run-time. ...
Definition: pane.hpp:43
Various uncategorised dialogs.
int get_retval()
Definition: window.hpp:365
linked_size(const bool width=false, const bool height=false)
Definition: window.hpp:564
void add_to_dirty_list(const std::vector< widget *> &call_stack)
Adds an item to the dirty_list_.
Definition: window.hpp:163
Helper to implement private functions without modifying the header.
const unsigned vertical_placement_
Sets the vertical placement.
Definition: window.hpp:498
std::vector< widget * > tab_order
List of widgets in the tabbing order.
Definition: window.hpp:583
Holds a 2D point.
Definition: point.hpp:24
int w
bool invalidate_layout_blocked() const
Is invalidate_layout blocked, see invalidate_layout_blocker.
Definition: window.hpp:208
void set_retval(const int retval, const bool close_window=true)
Sets there return value of the window.
Definition: window.hpp:358
builder_window::window_resolution::tooltip_info tooltip_
The settings for the tooltip.
Definition: window.hpp:525
show_mode show_mode_
The mode in which the window is shown.
Definition: window.hpp:447
void set_exit_hook(std::function< bool(window &)> func)
Sets the window&#39;s exit hook.
Definition: window.hpp:407
Helper struct to store information about the tips.
bool restore_
Whether the window should undraw the window using restorer_.
Definition: window.hpp:473
bool get_need_layout() const
Definition: window.hpp:380
Abstract base class for all modal dialogs.
std::unique_ptr< event::distributor > event_distributor_
Definition: window.hpp:679
Class to show the tips.
Definition: tooltip.cpp:57
point resolution()
Definition: general.cpp:393
dialogs::modal_dialog * owner_
The dialog that owns the window.
Definition: window.hpp:453
retval
Default window/dialog return values.
Definition: retval.hpp:29
std::unique_ptr< window > build(const builder_window::window_resolution &definition)
Builds a window.
dialogs::modal_dialog * dialog()
Inherited from widget.
Definition: window.hpp:231
Dialog was closed with the OK button.
Definition: retval.hpp:35
map_location coordinate
Contains an x and y coordinate used for starting positions in maps.
int height
The current height of all widgets in the group, -1 if the height is not linked.
Definition: window.hpp:576
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:61
std::shared_ptr< halo_record > handle
Definition: halo.hpp:30
base class of top level items, the only item which needs to store the final canvases to draw on...
Definition: window.hpp:65
std::shared_ptr< builder_grid > builder_grid_ptr
std::map< std::string, linked_size > linked_size_
List of the widgets, whose size are linked together.
Definition: window.hpp:580
wfl::map_formula_callable variables_
The variables of the canvas.
Definition: window.hpp:464
ui_event
The event send to the dispatcher.
Definition: handler.hpp:48
void set_callback_next_draw(std::function< void()> func)
Sets a callback that will be called after the window is drawn next time.
Definition: window.hpp:423
void set_owner(dialogs::modal_dialog *owner)
Definition: window.hpp:370
void show(const std::string &window_id, const t_string &message, const point &mouse, const SDL_Rect &source_rect)
Shows a tip.
Definition: tooltip.cpp:140
const event::distributor & get_distributor() const
Gets a reference to the window&#39;s distributor to allow some state peeking.
Definition: window.hpp:683
void set_variable(const std::string &key, const wfl::variant &value)
Definition: window.hpp:385
std::function< void()> callback_next_draw_
Definition: window.hpp:765
void set_enter_disabled(const bool enter_disabled)
Disable the enter key.
Definition: window.hpp:286