OpenTTD Source  12.0-beta2
window.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
10 #include "stdafx.h"
11 #include <stdarg.h>
12 #include "company_func.h"
13 #include "gfx_func.h"
14 #include "console_func.h"
15 #include "console_gui.h"
16 #include "viewport_func.h"
17 #include "progress.h"
18 #include "blitter/factory.hpp"
19 #include "zoom_func.h"
20 #include "vehicle_base.h"
21 #include "window_func.h"
22 #include "tilehighlight_func.h"
23 #include "network/network.h"
24 #include "querystring_gui.h"
25 #include "widgets/dropdown_func.h"
26 #include "strings_func.h"
27 #include "settings_type.h"
28 #include "settings_func.h"
29 #include "ini_type.h"
30 #include "newgrf_debug.h"
31 #include "hotkeys.h"
32 #include "toolbar_gui.h"
33 #include "statusbar_gui.h"
34 #include "error.h"
35 #include "game/game.hpp"
36 #include "video/video_driver.hpp"
37 #include "framerate_type.h"
38 #include "network/network_func.h"
39 #include "guitimer_func.h"
40 #include "news_func.h"
41 
42 #include "safeguards.h"
43 
50 };
51 
53 static Window *_mouseover_last_w = nullptr;
54 static Window *_last_scroll_window = nullptr;
55 
57 WindowList _z_windows;
58 
60 /* static */ std::vector<Window *> Window::closed_windows;
61 
65 /* static */ void Window::DeleteClosedWindows()
66 {
67  for (Window *w : Window::closed_windows) delete w;
68  Window::closed_windows.clear();
69 
70  /* Remove dead entries from the window list */
71  _z_windows.remove(nullptr);
72 }
73 
76 
77 /*
78  * Window that currently has focus. - The main purpose is to generate
79  * #FocusLost events, not to give next window in z-order focus when a
80  * window is closed.
81  */
82 Window *_focused_window;
83 
84 Point _cursorpos_drag_start;
85 
86 int _scrollbar_start_pos;
87 int _scrollbar_size;
88 byte _scroller_click_timeout = 0;
89 
92 
94 
99 static std::vector<WindowDesc*> *_window_descs = nullptr;
100 
102 std::string _windows_file;
103 
105 WindowDesc::WindowDesc(WindowPosition def_pos, const char *ini_key, int16 def_width_trad, int16 def_height_trad,
106  WindowClass window_class, WindowClass parent_class, uint32 flags,
107  const NWidgetPart *nwid_parts, int16 nwid_length, HotkeyList *hotkeys) :
108  default_pos(def_pos),
109  cls(window_class),
110  parent_cls(parent_class),
111  ini_key(ini_key),
112  flags(flags),
113  nwid_parts(nwid_parts),
114  nwid_length(nwid_length),
115  hotkeys(hotkeys),
116  pref_sticky(false),
117  pref_width(0),
118  pref_height(0),
119  default_width_trad(def_width_trad),
120  default_height_trad(def_height_trad)
121 {
122  if (_window_descs == nullptr) _window_descs = new std::vector<WindowDesc*>();
123  _window_descs->push_back(this);
124 }
125 
126 WindowDesc::~WindowDesc()
127 {
128  _window_descs->erase(std::find(_window_descs->begin(), _window_descs->end(), this));
129 }
130 
137 {
138  return this->pref_width != 0 ? this->pref_width : ScaleGUITrad(this->default_width_trad);
139 }
140 
147 {
148  return this->pref_height != 0 ? this->pref_height : ScaleGUITrad(this->default_height_trad);
149 }
150 
155 {
156  IniFile ini;
158  for (WindowDesc *wd : *_window_descs) {
159  if (wd->ini_key == nullptr) continue;
160  IniLoadWindowSettings(ini, wd->ini_key, wd);
161  }
162 }
163 
167 static bool DescSorter(WindowDesc* const &a, WindowDesc* const &b)
168 {
169  if (a->ini_key != nullptr && b->ini_key != nullptr) return strcmp(a->ini_key, b->ini_key) < 0;
170  return a->ini_key != nullptr;
171 }
172 
177 {
178  /* Sort the stuff to get a nice ini file on first write */
179  std::sort(_window_descs->begin(), _window_descs->end(), DescSorter);
180 
181  IniFile ini;
183  for (WindowDesc *wd : *_window_descs) {
184  if (wd->ini_key == nullptr) continue;
185  IniSaveWindowSettings(ini, wd->ini_key, wd);
186  }
188 }
189 
194 {
195  if (this->nested_root != nullptr && this->nested_root->GetWidgetOfType(WWT_STICKYBOX) != nullptr) {
196  if (this->window_desc->pref_sticky) this->flags |= WF_STICKY;
197  } else {
198  /* There is no stickybox; clear the preference in case someone tried to be funny */
199  this->window_desc->pref_sticky = false;
200  }
201 }
202 
212 int Window::GetRowFromWidget(int clickpos, int widget, int padding, int line_height) const
213 {
214  const NWidgetBase *wid = this->GetWidget<NWidgetBase>(widget);
215  if (line_height < 0) line_height = wid->resize_y;
216  if (clickpos < (int)wid->pos_y + padding) return INT_MAX;
217  return (clickpos - (int)wid->pos_y - padding) / line_height;
218 }
219 
224 {
225  for (uint i = 0; i < this->nested_array_size; i++) {
226  NWidgetBase *nwid = this->GetWidget<NWidgetBase>(i);
227  if (nwid == nullptr) continue;
228 
229  if (nwid->IsHighlighted()) {
230  nwid->SetHighlighted(TC_INVALID);
231  this->SetWidgetDirty(i);
232  }
233  }
234 
235  CLRBITS(this->flags, WF_HIGHLIGHTED);
236 }
237 
243 void Window::SetWidgetHighlight(byte widget_index, TextColour highlighted_colour)
244 {
245  assert(widget_index < this->nested_array_size);
246 
247  NWidgetBase *nwid = this->GetWidget<NWidgetBase>(widget_index);
248  if (nwid == nullptr) return;
249 
250  nwid->SetHighlighted(highlighted_colour);
251  this->SetWidgetDirty(widget_index);
252 
253  if (highlighted_colour != TC_INVALID) {
254  /* If we set a highlight, the window has a highlight */
255  this->flags |= WF_HIGHLIGHTED;
256  } else {
257  /* If we disable a highlight, check all widgets if anyone still has a highlight */
258  bool valid = false;
259  for (uint i = 0; i < this->nested_array_size; i++) {
260  NWidgetBase *nwid = this->GetWidget<NWidgetBase>(i);
261  if (nwid == nullptr) continue;
262  if (!nwid->IsHighlighted()) continue;
263 
264  valid = true;
265  }
266  /* If nobody has a highlight, disable the flag on the window */
267  if (!valid) CLRBITS(this->flags, WF_HIGHLIGHTED);
268  }
269 }
270 
276 bool Window::IsWidgetHighlighted(byte widget_index) const
277 {
278  assert(widget_index < this->nested_array_size);
279 
280  const NWidgetBase *nwid = this->GetWidget<NWidgetBase>(widget_index);
281  if (nwid == nullptr) return false;
282 
283  return nwid->IsHighlighted();
284 }
285 
293 void Window::OnDropdownClose(Point pt, int widget, int index, bool instant_close)
294 {
295  if (widget < 0) return;
296 
297  if (instant_close) {
298  /* Send event for selected option if we're still
299  * on the parent button of the dropdown (behaviour of the dropdowns in the main toolbar). */
300  if (GetWidgetFromPos(this, pt.x, pt.y) == widget) {
301  this->OnDropdownSelect(widget, index);
302  }
303  }
304 
305  /* Raise the dropdown button */
306  NWidgetCore *nwi2 = this->GetWidget<NWidgetCore>(widget);
307  if ((nwi2->type & WWT_MASK) == NWID_BUTTON_DROPDOWN) {
308  nwi2->disp_flags &= ~ND_DROPDOWN_ACTIVE;
309  } else {
310  this->RaiseWidget(widget);
311  }
312  this->SetWidgetDirty(widget);
313 }
314 
320 const Scrollbar *Window::GetScrollbar(uint widnum) const
321 {
322  return this->GetWidget<NWidgetScrollbar>(widnum);
323 }
324 
331 {
332  return this->GetWidget<NWidgetScrollbar>(widnum);
333 }
334 
340 const QueryString *Window::GetQueryString(uint widnum) const
341 {
342  auto query = this->querystrings.Find(widnum);
343  return query != this->querystrings.end() ? query->second : nullptr;
344 }
345 
352 {
353  SmallMap<int, QueryString*>::Pair *query = this->querystrings.Find(widnum);
354  return query != this->querystrings.End() ? query->second : nullptr;
355 }
356 
361 /* virtual */ const char *Window::GetFocusedText() const
362 {
363  if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
364  return this->GetQueryString(this->nested_focus->index)->GetText();
365  }
366 
367  return nullptr;
368 }
369 
374 /* virtual */ const char *Window::GetCaret() const
375 {
376  if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
377  return this->GetQueryString(this->nested_focus->index)->GetCaret();
378  }
379 
380  return nullptr;
381 }
382 
388 /* virtual */ const char *Window::GetMarkedText(size_t *length) const
389 {
390  if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
391  return this->GetQueryString(this->nested_focus->index)->GetMarkedText(length);
392  }
393 
394  return nullptr;
395 }
396 
401 /* virtual */ Point Window::GetCaretPosition() const
402 {
403  if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX && !this->querystrings.empty()) {
404  return this->GetQueryString(this->nested_focus->index)->GetCaretPosition(this, this->nested_focus->index);
405  }
406 
407  Point pt = {0, 0};
408  return pt;
409 }
410 
417 /* virtual */ Rect Window::GetTextBoundingRect(const char *from, const char *to) const
418 {
419  if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
420  return this->GetQueryString(this->nested_focus->index)->GetBoundingRect(this, this->nested_focus->index, from, to);
421  }
422 
423  Rect r = {0, 0, 0, 0};
424  return r;
425 }
426 
432 /* virtual */ const char *Window::GetTextCharacterAtPosition(const Point &pt) const
433 {
434  if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
435  return this->GetQueryString(this->nested_focus->index)->GetCharAtPosition(this, this->nested_focus->index, pt);
436  }
437 
438  return nullptr;
439 }
440 
446 {
447  if (_focused_window == w) return;
448 
449  /* Invalidate focused widget */
450  if (_focused_window != nullptr) {
451  if (_focused_window->nested_focus != nullptr) _focused_window->nested_focus->SetDirty(_focused_window);
452  }
453 
454  /* Remember which window was previously focused */
455  Window *old_focused = _focused_window;
456  _focused_window = w;
457 
458  /* So we can inform it that it lost focus */
459  if (old_focused != nullptr) old_focused->OnFocusLost();
460  if (_focused_window != nullptr) _focused_window->OnFocus();
461 }
462 
469 {
470  if (_focused_window == nullptr) return false;
471 
472  /* The console does not have an edit box so a special case is needed. */
473  if (_focused_window->window_class == WC_CONSOLE) return true;
474 
475  return _focused_window->nested_focus != nullptr && _focused_window->nested_focus->type == WWT_EDITBOX;
476 }
477 
483 {
484  return _focused_window && _focused_window->window_class == WC_CONSOLE;
485 }
486 
491 {
492  if (this->nested_focus != nullptr) {
494 
495  /* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */
496  this->nested_focus->SetDirty(this);
497  this->nested_focus = nullptr;
498  }
499 }
500 
506 bool Window::SetFocusedWidget(int widget_index)
507 {
508  /* Do nothing if widget_index is already focused, or if it wasn't a valid widget. */
509  if ((uint)widget_index >= this->nested_array_size) return false;
510 
511  assert(this->nested_array[widget_index] != nullptr); // Setting focus to a non-existing widget is a bad idea.
512  if (this->nested_focus != nullptr) {
513  if (this->GetWidget<NWidgetCore>(widget_index) == this->nested_focus) return false;
514 
515  /* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */
516  this->nested_focus->SetDirty(this);
518  }
519  this->nested_focus = this->GetWidget<NWidgetCore>(widget_index);
521  return true;
522 }
523 
528 {
530 }
531 
536 {
537  if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxLostFocus();
538 }
539 
547 void CDECL Window::SetWidgetsDisabledState(bool disab_stat, int widgets, ...)
548 {
549  va_list wdg_list;
550 
551  va_start(wdg_list, widgets);
552 
553  while (widgets != WIDGET_LIST_END) {
554  SetWidgetDisabledState(widgets, disab_stat);
555  widgets = va_arg(wdg_list, int);
556  }
557 
558  va_end(wdg_list);
559 }
560 
566 void CDECL Window::SetWidgetsLoweredState(bool lowered_stat, int widgets, ...)
567 {
568  va_list wdg_list;
569 
570  va_start(wdg_list, widgets);
571 
572  while (widgets != WIDGET_LIST_END) {
573  SetWidgetLoweredState(widgets, lowered_stat);
574  widgets = va_arg(wdg_list, int);
575  }
576 
577  va_end(wdg_list);
578 }
579 
584 void Window::RaiseButtons(bool autoraise)
585 {
586  for (uint i = 0; i < this->nested_array_size; i++) {
587  if (this->nested_array[i] == nullptr) continue;
588  WidgetType type = this->nested_array[i]->type;
589  if (((type & ~WWB_PUSHBUTTON) < WWT_LAST || type == NWID_PUSHBUTTON_DROPDOWN) &&
590  (!autoraise || (type & WWB_PUSHBUTTON) || type == WWT_EDITBOX) && this->IsWidgetLowered(i)) {
591  this->RaiseWidget(i);
592  this->SetWidgetDirty(i);
593  }
594  }
595 
596  /* Special widgets without widget index */
597  NWidgetCore *wid = this->nested_root != nullptr ? (NWidgetCore*)this->nested_root->GetWidgetOfType(WWT_DEFSIZEBOX) : nullptr;
598  if (wid != nullptr) {
599  wid->SetLowered(false);
600  wid->SetDirty(this);
601  }
602 }
603 
608 void Window::SetWidgetDirty(byte widget_index) const
609 {
610  /* Sometimes this function is called before the window is even fully initialized */
611  if (this->nested_array == nullptr) return;
612 
613  this->nested_array[widget_index]->SetDirty(this);
614 }
615 
622 {
623  if (hotkey < 0) return ES_NOT_HANDLED;
624 
625  NWidgetCore *nw = this->GetWidget<NWidgetCore>(hotkey);
626  if (nw == nullptr || nw->IsDisabled()) return ES_NOT_HANDLED;
627 
628  if (nw->type == WWT_EDITBOX) {
629  if (this->IsShaded()) return ES_NOT_HANDLED;
630 
631  /* Focus editbox */
632  this->SetFocusedWidget(hotkey);
633  SetFocusedWindow(this);
634  } else {
635  /* Click button */
636  this->OnClick(Point(), hotkey, 1);
637  }
638  return ES_HANDLED;
639 }
640 
646 void Window::HandleButtonClick(byte widget)
647 {
648  this->LowerWidget(widget);
649  this->SetTimeout();
650  this->SetWidgetDirty(widget);
651 }
652 
653 static void StartWindowDrag(Window *w);
654 static void StartWindowSizing(Window *w, bool to_left);
655 
663 static void DispatchLeftClickEvent(Window *w, int x, int y, int click_count)
664 {
665  NWidgetCore *nw = w->nested_root->GetWidgetFromPos(x, y);
666  WidgetType widget_type = (nw != nullptr) ? nw->type : WWT_EMPTY;
667 
668  bool focused_widget_changed = false;
669  /* If clicked on a window that previously did not have focus */
670  if (_focused_window != w && // We already have focus, right?
671  (w->window_desc->flags & WDF_NO_FOCUS) == 0 && // Don't lose focus to toolbars
672  widget_type != WWT_CLOSEBOX) { // Don't change focused window if 'X' (close button) was clicked
673  focused_widget_changed = true;
674  SetFocusedWindow(w);
675  }
676 
677  if (nw == nullptr) return; // exit if clicked outside of widgets
678 
679  /* don't allow any interaction if the button has been disabled */
680  if (nw->IsDisabled()) return;
681 
682  int widget_index = nw->index;
683 
684  /* Clicked on a widget that is not disabled.
685  * So unless the clicked widget is the caption bar, change focus to this widget.
686  * Exception: In the OSK we always want the editbox to stay focused. */
687  if (widget_type != WWT_CAPTION && w->window_class != WC_OSK) {
688  /* focused_widget_changed is 'now' only true if the window this widget
689  * is in gained focus. In that case it must remain true, also if the
690  * local widget focus did not change. As such it's the logical-or of
691  * both changed states.
692  *
693  * If this is not preserved, then the OSK window would be opened when
694  * a user has the edit box focused and then click on another window and
695  * then back again on the edit box (to type some text).
696  */
697  focused_widget_changed |= w->SetFocusedWidget(widget_index);
698  }
699 
700  /* Close any child drop down menus. If the button pressed was the drop down
701  * list's own button, then we should not process the click any further. */
702  if (HideDropDownMenu(w) == widget_index && widget_index >= 0) return;
703 
704  if ((widget_type & ~WWB_PUSHBUTTON) < WWT_LAST && (widget_type & WWB_PUSHBUTTON)) w->HandleButtonClick(widget_index);
705 
706  Point pt = { x, y };
707 
708  switch (widget_type) {
709  case NWID_VSCROLLBAR:
710  case NWID_HSCROLLBAR:
711  ScrollbarClickHandler(w, nw, x, y);
712  break;
713 
714  case WWT_EDITBOX: {
715  QueryString *query = w->GetQueryString(widget_index);
716  if (query != nullptr) query->ClickEditBox(w, pt, widget_index, click_count, focused_widget_changed);
717  break;
718  }
719 
720  case WWT_CLOSEBOX: // 'X'
721  w->Close();
722  return;
723 
724  case WWT_CAPTION: // 'Title bar'
725  StartWindowDrag(w);
726  return;
727 
728  case WWT_RESIZEBOX:
729  /* When the resize widget is on the left size of the window
730  * we assume that that button is used to resize to the left. */
731  StartWindowSizing(w, (int)nw->pos_x < (w->width / 2));
732  nw->SetDirty(w);
733  return;
734 
735  case WWT_DEFSIZEBOX: {
736  if (_ctrl_pressed) {
737  w->window_desc->pref_width = w->width;
738  w->window_desc->pref_height = w->height;
739  } else {
740  int16 def_width = std::max<int16>(std::min<int16>(w->window_desc->GetDefaultWidth(), _screen.width), w->nested_root->smallest_x);
741  int16 def_height = std::max<int16>(std::min<int16>(w->window_desc->GetDefaultHeight(), _screen.height - 50), w->nested_root->smallest_y);
742 
743  int dx = (w->resize.step_width == 0) ? 0 : def_width - w->width;
744  int dy = (w->resize.step_height == 0) ? 0 : def_height - w->height;
745  /* dx and dy has to go by step.. calculate it.
746  * The cast to int is necessary else dx/dy are implicitly casted to unsigned int, which won't work. */
747  if (w->resize.step_width > 1) dx -= dx % (int)w->resize.step_width;
748  if (w->resize.step_height > 1) dy -= dy % (int)w->resize.step_height;
749  ResizeWindow(w, dx, dy, false);
750  }
751 
752  nw->SetLowered(true);
753  nw->SetDirty(w);
754  w->SetTimeout();
755  break;
756  }
757 
758  case WWT_DEBUGBOX:
760  break;
761 
762  case WWT_SHADEBOX:
763  nw->SetDirty(w);
764  w->SetShaded(!w->IsShaded());
765  return;
766 
767  case WWT_STICKYBOX:
768  w->flags ^= WF_STICKY;
769  nw->SetDirty(w);
770  if (_ctrl_pressed) w->window_desc->pref_sticky = (w->flags & WF_STICKY) != 0;
771  return;
772 
773  default:
774  break;
775  }
776 
777  /* Widget has no index, so the window is not interested in it. */
778  if (widget_index < 0) return;
779 
780  /* Check if the widget is highlighted; if so, disable highlight and dispatch an event to the GameScript */
781  if (w->IsWidgetHighlighted(widget_index)) {
782  w->SetWidgetHighlight(widget_index, TC_INVALID);
783  Game::NewEvent(new ScriptEventWindowWidgetClick((ScriptWindow::WindowClass)w->window_class, w->window_number, widget_index));
784  }
785 
786  w->OnClick(pt, widget_index, click_count);
787 }
788 
795 static void DispatchRightClickEvent(Window *w, int x, int y)
796 {
797  NWidgetCore *wid = w->nested_root->GetWidgetFromPos(x, y);
798  if (wid == nullptr) return;
799 
800  Point pt = { x, y };
801 
802  /* No widget to handle, or the window is not interested in it. */
803  if (wid->index >= 0) {
804  if (w->OnRightClick(pt, wid->index)) return;
805  }
806 
807  /* Right-click close is enabled and there is a closebox */
809  w->Close();
810  } else if (_settings_client.gui.hover_delay_ms == 0 && !w->OnTooltip(pt, wid->index, TCC_RIGHT_CLICK) && wid->tool_tip != 0) {
811  GuiShowTooltips(w, wid->tool_tip, 0, nullptr, TCC_RIGHT_CLICK);
812  }
813 }
814 
821 static void DispatchHoverEvent(Window *w, int x, int y)
822 {
823  NWidgetCore *wid = w->nested_root->GetWidgetFromPos(x, y);
824 
825  /* No widget to handle */
826  if (wid == nullptr) return;
827 
828  Point pt = { x, y };
829 
830  /* Show the tooltip if there is any */
831  if (!w->OnTooltip(pt, wid->index, TCC_HOVER) && wid->tool_tip != 0) {
832  GuiShowTooltips(w, wid->tool_tip);
833  return;
834  }
835 
836  /* Widget has no index, so the window is not interested in it. */
837  if (wid->index < 0) return;
838 
839  w->OnHover(pt, wid->index);
840 }
841 
849 static void DispatchMouseWheelEvent(Window *w, NWidgetCore *nwid, int wheel)
850 {
851  if (nwid == nullptr) return;
852 
853  /* Using wheel on caption/shade-box shades or unshades the window. */
854  if (nwid->type == WWT_CAPTION || nwid->type == WWT_SHADEBOX) {
855  w->SetShaded(wheel < 0);
856  return;
857  }
858 
859  /* Wheeling a vertical scrollbar. */
860  if (nwid->type == NWID_VSCROLLBAR) {
861  NWidgetScrollbar *sb = static_cast<NWidgetScrollbar *>(nwid);
862  if (sb->GetCount() > sb->GetCapacity()) {
863  if (sb->UpdatePosition(wheel)) w->SetDirty();
864  }
865  return;
866  }
867 
868  /* Scroll the widget attached to the scrollbar. */
869  Scrollbar *sb = (nwid->scrollbar_index >= 0 ? w->GetScrollbar(nwid->scrollbar_index) : nullptr);
870  if (sb != nullptr && sb->GetCount() > sb->GetCapacity()) {
871  if (sb->UpdatePosition(wheel)) w->SetDirty();
872  }
873 }
874 
880 static bool MayBeShown(const Window *w)
881 {
882  /* If we're not modal, everything is okay. */
883  if (!HasModalProgress()) return true;
884 
885  switch (w->window_class) {
886  case WC_MAIN_WINDOW:
887  case WC_MODAL_PROGRESS:
889  return true;
890 
891  default:
892  return false;
893  }
894 }
895 
908 static void DrawOverlappedWindow(Window *w, int left, int top, int right, int bottom)
909 {
911  ++it;
912  for (; !it.IsEnd(); ++it) {
913  const Window *v = *it;
914  if (MayBeShown(v) &&
915  right > v->left &&
916  bottom > v->top &&
917  left < v->left + v->width &&
918  top < v->top + v->height) {
919  /* v and rectangle intersect with each other */
920  int x;
921 
922  if (left < (x = v->left)) {
923  DrawOverlappedWindow(w, left, top, x, bottom);
924  DrawOverlappedWindow(w, x, top, right, bottom);
925  return;
926  }
927 
928  if (right > (x = v->left + v->width)) {
929  DrawOverlappedWindow(w, left, top, x, bottom);
930  DrawOverlappedWindow(w, x, top, right, bottom);
931  return;
932  }
933 
934  if (top < (x = v->top)) {
935  DrawOverlappedWindow(w, left, top, right, x);
936  DrawOverlappedWindow(w, left, x, right, bottom);
937  return;
938  }
939 
940  if (bottom > (x = v->top + v->height)) {
941  DrawOverlappedWindow(w, left, top, right, x);
942  DrawOverlappedWindow(w, left, x, right, bottom);
943  return;
944  }
945 
946  return;
947  }
948  }
949 
950  /* Setup blitter, and dispatch a repaint event to window *wz */
951  DrawPixelInfo *dp = _cur_dpi;
952  dp->width = right - left;
953  dp->height = bottom - top;
954  dp->left = left - w->left;
955  dp->top = top - w->top;
956  dp->pitch = _screen.pitch;
957  dp->dst_ptr = BlitterFactory::GetCurrentBlitter()->MoveTo(_screen.dst_ptr, left, top);
958  dp->zoom = ZOOM_LVL_NORMAL;
959  w->OnPaint();
960 }
961 
970 void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)
971 {
972  DrawPixelInfo *old_dpi = _cur_dpi;
973  DrawPixelInfo bk;
974  _cur_dpi = &bk;
975 
976  for (Window *w : Window::IterateFromBack()) {
977  if (MayBeShown(w) &&
978  right > w->left &&
979  bottom > w->top &&
980  left < w->left + w->width &&
981  top < w->top + w->height) {
982  /* Window w intersects with the rectangle => needs repaint */
983  DrawOverlappedWindow(w, std::max(left, w->left), std::max(top, w->top), std::min(right, w->left + w->width), std::min(bottom, w->top + w->height));
984  }
985  }
986  _cur_dpi = old_dpi;
987 }
988 
993 void Window::SetDirty() const
994 {
995  AddDirtyBlock(this->left, this->top, this->left + this->width, this->top + this->height);
996 }
997 
1004 void Window::ReInit(int rx, int ry)
1005 {
1006  this->SetDirty(); // Mark whole current window as dirty.
1007 
1008  /* Save current size. */
1009  int window_width = this->width;
1010  int window_height = this->height;
1011 
1012  this->OnInit();
1013  /* Re-initialize the window from the ground up. No need to change the nested_array, as all widgets stay where they are. */
1014  this->nested_root->SetupSmallestSize(this, false);
1015  this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
1016  this->width = this->nested_root->smallest_x;
1017  this->height = this->nested_root->smallest_y;
1018  this->resize.step_width = this->nested_root->resize_x;
1019  this->resize.step_height = this->nested_root->resize_y;
1020 
1021  /* Resize as close to the original size + requested resize as possible. */
1022  window_width = std::max(window_width + rx, this->width);
1023  window_height = std::max(window_height + ry, this->height);
1024  int dx = (this->resize.step_width == 0) ? 0 : window_width - this->width;
1025  int dy = (this->resize.step_height == 0) ? 0 : window_height - this->height;
1026  /* dx and dy has to go by step.. calculate it.
1027  * The cast to int is necessary else dx/dy are implicitly casted to unsigned int, which won't work. */
1028  if (this->resize.step_width > 1) dx -= dx % (int)this->resize.step_width;
1029  if (this->resize.step_height > 1) dy -= dy % (int)this->resize.step_height;
1030 
1031  ResizeWindow(this, dx, dy);
1032  /* ResizeWindow() does this->SetDirty() already, no need to do it again here. */
1033 }
1034 
1040 void Window::SetShaded(bool make_shaded)
1041 {
1042  if (this->shade_select == nullptr) return;
1043 
1044  int desired = make_shaded ? SZSP_HORIZONTAL : 0;
1045  if (this->shade_select->shown_plane != desired) {
1046  if (make_shaded) {
1047  if (this->nested_focus != nullptr) this->UnfocusFocusedWidget();
1048  this->unshaded_size.width = this->width;
1049  this->unshaded_size.height = this->height;
1050  this->shade_select->SetDisplayedPlane(desired);
1051  this->ReInit(0, -this->height);
1052  } else {
1053  this->shade_select->SetDisplayedPlane(desired);
1054  int dx = ((int)this->unshaded_size.width > this->width) ? (int)this->unshaded_size.width - this->width : 0;
1055  int dy = ((int)this->unshaded_size.height > this->height) ? (int)this->unshaded_size.height - this->height : 0;
1056  this->ReInit(dx, dy);
1057  }
1058  }
1059 }
1060 
1068 {
1069  for (Window *v : Window::Iterate()) {
1070  if ((wc == WC_INVALID || wc == v->window_class) && v->parent == w) return v;
1071  }
1072 
1073  return nullptr;
1074 }
1075 
1081 {
1082  Window *child = FindChildWindow(this, wc);
1083  while (child != nullptr) {
1084  child->Close();
1085  child = FindChildWindow(this, wc);
1086  }
1087 }
1088 
1093 {
1094  /* Don't close twice. */
1095  if (*this->z_position == nullptr) return;
1096 
1097  *this->z_position = nullptr;
1098 
1099  if (_thd.window_class == this->window_class &&
1100  _thd.window_number == this->window_number) {
1102  }
1103 
1104  /* Prevent Mouseover() from resetting mouse-over coordinates on a non-existing window */
1105  if (_mouseover_last_w == this) _mouseover_last_w = nullptr;
1106 
1107  /* We can't scroll the window when it's closed. */
1108  if (_last_scroll_window == this) _last_scroll_window = nullptr;
1109 
1110  /* Make sure we don't try to access non-existing query strings. */
1111  this->querystrings.clear();
1112 
1113  /* Make sure we don't try to access this window as the focused window when it doesn't exist anymore. */
1114  if (_focused_window == this) {
1115  this->OnFocusLost();
1116  _focused_window = nullptr;
1117  }
1118 
1119  this->CloseChildWindows();
1120 
1121  this->SetDirty();
1122 
1123  Window::closed_windows.push_back(this);
1124 }
1125 
1130 {
1131  /* Make sure the window is closed, deletion is allowed only in Window::DeleteClosedWindows(). */
1132  assert(*this->z_position == nullptr);
1133 
1134  if (this->viewport != nullptr) DeleteWindowViewport(this);
1135 
1136  free(this->nested_array); // Contents is released through deletion of #nested_root.
1137  delete this->nested_root;
1138 }
1139 
1147 {
1148  for (Window *w : Window::Iterate()) {
1149  if (w->window_class == cls && w->window_number == number) return w;
1150  }
1151 
1152  return nullptr;
1153 }
1154 
1162 {
1163  for (Window *w : Window::Iterate()) {
1164  if (w->window_class == cls) return w;
1165  }
1166 
1167  return nullptr;
1168 }
1169 
1176 void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
1177 {
1178  Window *w = FindWindowById(cls, number);
1179  if (w != nullptr && (force || (w->flags & WF_STICKY) == 0)) {
1180  w->Close();
1181  }
1182 }
1183 
1189 {
1190  /* Note: the container remains stable, even when deleting windows. */
1191  for (Window *w : Window::Iterate()) {
1192  if (w->window_class == cls) {
1193  w->Close();
1194  }
1195  }
1196 }
1197 
1205 {
1206  /* Note: the container remains stable, even when deleting windows. */
1207  for (Window *w : Window::Iterate()) {
1208  if (w->owner == id) {
1209  w->Close();
1210  }
1211  }
1212 
1213  /* Also delete the company specific windows that don't have a company-colour. */
1215 }
1216 
1224 void ChangeWindowOwner(Owner old_owner, Owner new_owner)
1225 {
1226  for (Window *w : Window::Iterate()) {
1227  if (w->owner != old_owner) continue;
1228 
1229  switch (w->window_class) {
1230  case WC_COMPANY_COLOUR:
1231  case WC_FINANCES:
1232  case WC_STATION_LIST:
1233  case WC_TRAINS_LIST:
1234  case WC_ROADVEH_LIST:
1235  case WC_SHIPS_LIST:
1236  case WC_AIRCRAFT_LIST:
1237  case WC_BUY_COMPANY:
1238  case WC_COMPANY:
1240  case WC_VEHICLE_ORDERS: // Changing owner would also require changing WindowDesc, which is not possible; however keeping the old one crashes because of missing widgets etc.. See ShowOrdersWindow().
1241  continue;
1242 
1243  default:
1244  w->owner = new_owner;
1245  break;
1246  }
1247  }
1248 }
1249 
1250 static void BringWindowToFront(Window *w, bool dirty = true);
1251 
1260 {
1261  Window *w = FindWindowById(cls, number);
1262 
1263  if (w != nullptr) {
1264  if (w->IsShaded()) w->SetShaded(false); // Restore original window size if it was shaded.
1265 
1266  w->SetWhiteBorder();
1267  BringWindowToFront(w);
1268  w->SetDirty();
1269  }
1270 
1271  return w;
1272 }
1273 
1274 static inline bool IsVitalWindow(const Window *w)
1275 {
1276  switch (w->window_class) {
1277  case WC_MAIN_TOOLBAR:
1278  case WC_STATUS_BAR:
1279  case WC_NEWS_WINDOW:
1280  case WC_SEND_NETWORK_MSG:
1281  return true;
1282 
1283  default:
1284  return false;
1285  }
1286 }
1287 
1297 {
1298  assert(wc != WC_INVALID);
1299 
1300  uint z_priority = 0;
1301 
1302  switch (wc) {
1303  case WC_ENDSCREEN:
1304  ++z_priority;
1305  FALLTHROUGH;
1306 
1307  case WC_HIGHSCORE:
1308  ++z_priority;
1309  FALLTHROUGH;
1310 
1311  case WC_TOOLTIPS:
1312  ++z_priority;
1313  FALLTHROUGH;
1314 
1315  case WC_DROPDOWN_MENU:
1316  ++z_priority;
1317  FALLTHROUGH;
1318 
1319  case WC_MAIN_TOOLBAR:
1320  case WC_STATUS_BAR:
1321  ++z_priority;
1322  FALLTHROUGH;
1323 
1324  case WC_OSK:
1325  ++z_priority;
1326  FALLTHROUGH;
1327 
1328  case WC_QUERY_STRING:
1329  case WC_SEND_NETWORK_MSG:
1330  ++z_priority;
1331  FALLTHROUGH;
1332 
1333  case WC_ERRMSG:
1335  case WC_NETWORK_ASK_RELAY:
1336  case WC_MODAL_PROGRESS:
1338  case WC_SAVE_PRESET:
1339  ++z_priority;
1340  FALLTHROUGH;
1341 
1342  case WC_GENERATE_LANDSCAPE:
1343  case WC_SAVELOAD:
1344  case WC_GAME_OPTIONS:
1345  case WC_CUSTOM_CURRENCY:
1346  case WC_NETWORK_WINDOW:
1347  case WC_GRF_PARAMETERS:
1348  case WC_AI_LIST:
1349  case WC_AI_SETTINGS:
1350  case WC_TEXTFILE:
1351  ++z_priority;
1352  FALLTHROUGH;
1353 
1354  case WC_CONSOLE:
1355  ++z_priority;
1356  FALLTHROUGH;
1357 
1358  case WC_NEWS_WINDOW:
1359  ++z_priority;
1360  FALLTHROUGH;
1361 
1362  default:
1363  ++z_priority;
1364  FALLTHROUGH;
1365 
1366  case WC_MAIN_WINDOW:
1367  return z_priority;
1368  }
1369 }
1370 
1377 static void BringWindowToFront(Window *w, bool dirty)
1378 {
1379  auto priority = GetWindowZPriority(w->window_class);
1380  WindowList::iterator dest = _z_windows.begin();
1381  while (dest != _z_windows.end() && (*dest == nullptr || GetWindowZPriority((*dest)->window_class) <= priority)) ++dest;
1382 
1383  if (dest != w->z_position) {
1384  _z_windows.splice(dest, _z_windows, w->z_position);
1385  }
1386 
1387  if (dirty) w->SetDirty();
1388 }
1389 
1398 {
1399  /* Set up window properties; some of them are needed to set up smallest size below */
1400  this->window_class = this->window_desc->cls;
1401  this->SetWhiteBorder();
1402  if (this->window_desc->default_pos == WDP_CENTER) this->flags |= WF_CENTERED;
1403  this->owner = INVALID_OWNER;
1404  this->nested_focus = nullptr;
1405  this->window_number = window_number;
1406 
1407  this->OnInit();
1408  /* Initialize nested widget tree. */
1409  if (this->nested_array == nullptr) {
1410  this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);
1411  this->nested_root->SetupSmallestSize(this, true);
1412  } else {
1413  this->nested_root->SetupSmallestSize(this, false);
1414  }
1415  /* Initialize to smallest size. */
1416  this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
1417 
1418  /* Further set up window properties,
1419  * this->left, this->top, this->width, this->height, this->resize.width, and this->resize.height are initialized later. */
1420  this->resize.step_width = this->nested_root->resize_x;
1421  this->resize.step_height = this->nested_root->resize_y;
1422 
1423  /* Give focus to the opened window unless a text box
1424  * of focused window has focus (so we don't interrupt typing). But if the new
1425  * window has a text box, then take focus anyway. */
1426  if (!EditBoxInGlobalFocus() || this->nested_root->GetWidgetOfType(WWT_EDITBOX) != nullptr) SetFocusedWindow(this);
1427 
1428  /* Insert the window into the correct location in the z-ordering. */
1429  BringWindowToFront(this, false);
1430 }
1431 
1439 void Window::InitializePositionSize(int x, int y, int sm_width, int sm_height)
1440 {
1441  this->left = x;
1442  this->top = y;
1443  this->width = sm_width;
1444  this->height = sm_height;
1445 }
1446 
1457 void Window::FindWindowPlacementAndResize(int def_width, int def_height)
1458 {
1459  def_width = std::max(def_width, this->width); // Don't allow default size to be smaller than smallest size
1460  def_height = std::max(def_height, this->height);
1461  /* Try to make windows smaller when our window is too small.
1462  * w->(width|height) is normally the same as min_(width|height),
1463  * but this way the GUIs can be made a little more dynamic;
1464  * one can use the same spec for multiple windows and those
1465  * can then determine the real minimum size of the window. */
1466  if (this->width != def_width || this->height != def_height) {
1467  /* Think about the overlapping toolbars when determining the minimum window size */
1468  int free_height = _screen.height;
1469  const Window *wt = FindWindowById(WC_STATUS_BAR, 0);
1470  if (wt != nullptr) free_height -= wt->height;
1472  if (wt != nullptr) free_height -= wt->height;
1473 
1474  int enlarge_x = std::max(std::min(def_width - this->width, _screen.width - this->width), 0);
1475  int enlarge_y = std::max(std::min(def_height - this->height, free_height - this->height), 0);
1476 
1477  /* X and Y has to go by step.. calculate it.
1478  * The cast to int is necessary else x/y are implicitly casted to
1479  * unsigned int, which won't work. */
1480  if (this->resize.step_width > 1) enlarge_x -= enlarge_x % (int)this->resize.step_width;
1481  if (this->resize.step_height > 1) enlarge_y -= enlarge_y % (int)this->resize.step_height;
1482 
1483  ResizeWindow(this, enlarge_x, enlarge_y);
1484  /* ResizeWindow() calls this->OnResize(). */
1485  } else {
1486  /* Always call OnResize; that way the scrollbars and matrices get initialized. */
1487  this->OnResize();
1488  }
1489 
1490  int nx = this->left;
1491  int ny = this->top;
1492 
1493  if (nx + this->width > _screen.width) nx -= (nx + this->width - _screen.width);
1494 
1495  const Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
1496  ny = std::max(ny, (wt == nullptr || this == wt || this->top == 0) ? 0 : wt->height);
1497  nx = std::max(nx, 0);
1498 
1499  if (this->viewport != nullptr) {
1500  this->viewport->left += nx - this->left;
1501  this->viewport->top += ny - this->top;
1502  }
1503  this->left = nx;
1504  this->top = ny;
1505 
1506  this->SetDirty();
1507 }
1508 
1521 static bool IsGoodAutoPlace1(int left, int top, int width, int height, int toolbar_y, Point &pos)
1522 {
1523  int right = width + left;
1524  int bottom = height + top;
1525 
1526  if (left < 0 || top < toolbar_y || right > _screen.width || bottom > _screen.height) return false;
1527 
1528  /* Make sure it is not obscured by any window. */
1529  for (const Window *w : Window::Iterate()) {
1530  if (w->window_class == WC_MAIN_WINDOW) continue;
1531 
1532  if (right > w->left &&
1533  w->left + w->width > left &&
1534  bottom > w->top &&
1535  w->top + w->height > top) {
1536  return false;
1537  }
1538  }
1539 
1540  pos.x = left;
1541  pos.y = top;
1542  return true;
1543 }
1544 
1557 static bool IsGoodAutoPlace2(int left, int top, int width, int height, int toolbar_y, Point &pos)
1558 {
1559  bool rtl = _current_text_dir == TD_RTL;
1560 
1561  /* Left part of the rectangle may be at most 1/4 off-screen,
1562  * right part of the rectangle may be at most 1/2 off-screen
1563  */
1564  if (rtl) {
1565  if (left < -(width >> 1) || left > _screen.width - (width >> 2)) return false;
1566  } else {
1567  if (left < -(width >> 2) || left > _screen.width - (width >> 1)) return false;
1568  }
1569 
1570  /* Bottom part of the rectangle may be at most 1/4 off-screen */
1571  if (top < toolbar_y || top > _screen.height - (height >> 2)) return false;
1572 
1573  /* Make sure it is not obscured by any window. */
1574  for (const Window *w : Window::Iterate()) {
1575  if (w->window_class == WC_MAIN_WINDOW) continue;
1576 
1577  if (left + width > w->left &&
1578  w->left + w->width > left &&
1579  top + height > w->top &&
1580  w->top + w->height > top) {
1581  return false;
1582  }
1583  }
1584 
1585  pos.x = left;
1586  pos.y = top;
1587  return true;
1588 }
1589 
1596 static Point GetAutoPlacePosition(int width, int height)
1597 {
1598  Point pt;
1599 
1600  bool rtl = _current_text_dir == TD_RTL;
1601 
1602  /* First attempt, try top-left of the screen */
1603  const Window *main_toolbar = FindWindowByClass(WC_MAIN_TOOLBAR);
1604  const int toolbar_y = main_toolbar != nullptr ? main_toolbar->height : 0;
1605  if (IsGoodAutoPlace1(rtl ? _screen.width - width : 0, toolbar_y, width, height, toolbar_y, pt)) return pt;
1606 
1607  /* Second attempt, try around all existing windows.
1608  * The new window must be entirely on-screen, and not overlap with an existing window.
1609  * Eight starting points are tried, two at each corner.
1610  */
1611  for (const Window *w : Window::Iterate()) {
1612  if (w->window_class == WC_MAIN_WINDOW) continue;
1613 
1614  if (IsGoodAutoPlace1(w->left + w->width, w->top, width, height, toolbar_y, pt)) return pt;
1615  if (IsGoodAutoPlace1(w->left - width, w->top, width, height, toolbar_y, pt)) return pt;
1616  if (IsGoodAutoPlace1(w->left, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1617  if (IsGoodAutoPlace1(w->left, w->top - height, width, height, toolbar_y, pt)) return pt;
1618  if (IsGoodAutoPlace1(w->left + w->width, w->top + w->height - height, width, height, toolbar_y, pt)) return pt;
1619  if (IsGoodAutoPlace1(w->left - width, w->top + w->height - height, width, height, toolbar_y, pt)) return pt;
1620  if (IsGoodAutoPlace1(w->left + w->width - width, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1621  if (IsGoodAutoPlace1(w->left + w->width - width, w->top - height, width, height, toolbar_y, pt)) return pt;
1622  }
1623 
1624  /* Third attempt, try around all existing windows.
1625  * The new window may be partly off-screen, and must not overlap with an existing window.
1626  * Only four starting points are tried.
1627  */
1628  for (const Window *w : Window::Iterate()) {
1629  if (w->window_class == WC_MAIN_WINDOW) continue;
1630 
1631  if (IsGoodAutoPlace2(w->left + w->width, w->top, width, height, toolbar_y, pt)) return pt;
1632  if (IsGoodAutoPlace2(w->left - width, w->top, width, height, toolbar_y, pt)) return pt;
1633  if (IsGoodAutoPlace2(w->left, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1634  if (IsGoodAutoPlace2(w->left, w->top - height, width, height, toolbar_y, pt)) return pt;
1635  }
1636 
1637  /* Fourth and final attempt, put window at diagonal starting from (0, toolbar_y), try multiples
1638  * of the closebox
1639  */
1640  int left = rtl ? _screen.width - width : 0, top = toolbar_y;
1641  int offset_x = rtl ? -(int)NWidgetLeaf::closebox_dimension.width : (int)NWidgetLeaf::closebox_dimension.width;
1643 
1644 restart:
1645  for (const Window *w : Window::Iterate()) {
1646  if (w->left == left && w->top == top) {
1647  left += offset_x;
1648  top += offset_y;
1649  goto restart;
1650  }
1651  }
1652 
1653  pt.x = left;
1654  pt.y = top;
1655  return pt;
1656 }
1657 
1665 {
1666  const Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
1667  assert(w != nullptr);
1668  Point pt = { _current_text_dir == TD_RTL ? w->left : (w->left + w->width) - window_width, w->top + w->height };
1669  return pt;
1670 }
1671 
1689 static Point LocalGetWindowPlacement(const WindowDesc *desc, int16 sm_width, int16 sm_height, int window_number)
1690 {
1691  Point pt;
1692  const Window *w;
1693 
1694  int16 default_width = std::max(desc->GetDefaultWidth(), sm_width);
1695  int16 default_height = std::max(desc->GetDefaultHeight(), sm_height);
1696 
1697  if (desc->parent_cls != WC_NONE && (w = FindWindowById(desc->parent_cls, window_number)) != nullptr) {
1698  bool rtl = _current_text_dir == TD_RTL;
1699  if (desc->parent_cls == WC_BUILD_TOOLBAR || desc->parent_cls == WC_SCEN_LAND_GEN) {
1700  pt.x = w->left + (rtl ? w->width - default_width : 0);
1701  pt.y = w->top + w->height;
1702  return pt;
1703  } else {
1704  /* Position child window with offset of closebox, but make sure that either closebox or resizebox is visible
1705  * - Y position: closebox of parent + closebox of child + statusbar
1706  * - X position: closebox on left/right, resizebox on right/left (depending on ltr/rtl)
1707  */
1709  if (w->top + 3 * indent_y < _screen.height) {
1710  pt.y = w->top + indent_y;
1711  int indent_close = NWidgetLeaf::closebox_dimension.width;
1712  int indent_resize = NWidgetLeaf::resizebox_dimension.width;
1713  if (_current_text_dir == TD_RTL) {
1714  pt.x = std::max(w->left + w->width - default_width - indent_close, 0);
1715  if (pt.x + default_width >= indent_close && pt.x + indent_resize <= _screen.width) return pt;
1716  } else {
1717  pt.x = std::min(w->left + indent_close, _screen.width - default_width);
1718  if (pt.x + default_width >= indent_resize && pt.x + indent_close <= _screen.width) return pt;
1719  }
1720  }
1721  }
1722  }
1723 
1724  switch (desc->default_pos) {
1725  case WDP_ALIGN_TOOLBAR: // Align to the toolbar
1726  return GetToolbarAlignedWindowPosition(default_width);
1727 
1728  case WDP_AUTO: // Find a good automatic position for the window
1729  return GetAutoPlacePosition(default_width, default_height);
1730 
1731  case WDP_CENTER: // Centre the window horizontally
1732  pt.x = (_screen.width - default_width) / 2;
1733  pt.y = (_screen.height - default_height) / 2;
1734  break;
1735 
1736  case WDP_MANUAL:
1737  pt.x = 0;
1738  pt.y = 0;
1739  break;
1740 
1741  default:
1742  NOT_REACHED();
1743  }
1744 
1745  return pt;
1746 }
1747 
1748 /* virtual */ Point Window::OnInitialPosition(int16 sm_width, int16 sm_height, int window_number)
1749 {
1750  return LocalGetWindowPlacement(this->window_desc, sm_width, sm_height, window_number);
1751 }
1752 
1760 void Window::CreateNestedTree(bool fill_nested)
1761 {
1762  int biggest_index = -1;
1763  this->nested_root = MakeWindowNWidgetTree(this->window_desc->nwid_parts, this->window_desc->nwid_length, &biggest_index, &this->shade_select);
1764  this->nested_array_size = (uint)(biggest_index + 1);
1765 
1766  if (fill_nested) {
1767  this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);
1769  }
1770 }
1771 
1777 {
1778  this->InitializeData(window_number);
1779  this->ApplyDefaults();
1780  Point pt = this->OnInitialPosition(this->nested_root->smallest_x, this->nested_root->smallest_y, window_number);
1781  this->InitializePositionSize(pt.x, pt.y, this->nested_root->smallest_x, this->nested_root->smallest_y);
1782  this->FindWindowPlacementAndResize(this->window_desc->GetDefaultWidth(), this->window_desc->GetDefaultHeight());
1783 }
1784 
1790 {
1791  this->CreateNestedTree(false);
1792  this->FinishInitNested(window_number);
1793 }
1794 
1799 Window::Window(WindowDesc *desc) : window_desc(desc), mouse_capture_widget(-1)
1800 {
1801  this->z_position = _z_windows.insert(_z_windows.end(), this);
1802 }
1803 
1811 Window *FindWindowFromPt(int x, int y)
1812 {
1813  for (Window *w : Window::IterateFromFront()) {
1814  if (MayBeShown(w) && IsInsideBS(x, w->left, w->width) && IsInsideBS(y, w->top, w->height)) {
1815  return w;
1816  }
1817  }
1818 
1819  return nullptr;
1820 }
1821 
1826 {
1827  IConsoleClose();
1828 
1829  _focused_window = nullptr;
1830  _mouseover_last_w = nullptr;
1831  _last_scroll_window = nullptr;
1832  _scrolling_viewport = false;
1833  _mouse_hovering = false;
1834 
1835  NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
1836  NWidgetScrollbar::InvalidateDimensionCache();
1837 
1838  ShowFirstError();
1839 }
1840 
1845 {
1847 
1848  for (Window *w : Window::Iterate()) w->Close();
1849 
1851 
1852  assert(_z_windows.empty());
1853 }
1854 
1859 {
1861  InitWindowSystem();
1862  _thd.Reset();
1863 }
1864 
1865 static void DecreaseWindowCounters()
1866 {
1867  static byte hundredth_tick_timeout = 100;
1868 
1869  if (_scroller_click_timeout != 0) _scroller_click_timeout--;
1870  if (hundredth_tick_timeout != 0) hundredth_tick_timeout--;
1871 
1872  for (Window *w : Window::Iterate()) {
1873  if (!_network_dedicated && hundredth_tick_timeout == 0) w->OnHundredthTick();
1874 
1875  if (_scroller_click_timeout == 0) {
1876  /* Unclick scrollbar buttons if they are pressed. */
1877  for (uint i = 0; i < w->nested_array_size; i++) {
1878  NWidgetBase *nwid = w->nested_array[i];
1879  if (nwid != nullptr && (nwid->type == NWID_HSCROLLBAR || nwid->type == NWID_VSCROLLBAR)) {
1880  NWidgetScrollbar *sb = static_cast<NWidgetScrollbar*>(nwid);
1883  w->mouse_capture_widget = -1;
1884  sb->SetDirty(w);
1885  }
1886  }
1887  }
1888  }
1889 
1890  /* Handle editboxes */
1892  pair.second->HandleEditBox(w, pair.first);
1893  }
1894 
1895  w->OnMouseLoop();
1896  }
1897 
1898  for (Window *w : Window::Iterate()) {
1899  if ((w->flags & WF_TIMEOUT) && --w->timeout_timer == 0) {
1900  CLRBITS(w->flags, WF_TIMEOUT);
1901 
1902  w->OnTimeout();
1903  w->RaiseButtons(true);
1904  }
1905  }
1906 
1907  if (hundredth_tick_timeout == 0) hundredth_tick_timeout = 100;
1908 }
1909 
1910 static void HandlePlacePresize()
1911 {
1912  if (_special_mouse_mode != WSM_PRESIZE) return;
1913 
1914  Window *w = _thd.GetCallbackWnd();
1915  if (w == nullptr) return;
1916 
1917  Point pt = GetTileBelowCursor();
1918  if (pt.x == -1) {
1919  _thd.selend.x = -1;
1920  return;
1921  }
1922 
1923  w->OnPlacePresize(pt, TileVirtXY(pt.x, pt.y));
1924 }
1925 
1931 {
1933 
1934  if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED; // Dragging, but the mouse did not move.
1935 
1936  Window *w = _thd.GetCallbackWnd();
1937  if (w != nullptr) {
1938  /* Send an event in client coordinates. */
1939  Point pt;
1940  pt.x = _cursor.pos.x - w->left;
1941  pt.y = _cursor.pos.y - w->top;
1942  if (_left_button_down) {
1943  w->OnMouseDrag(pt, GetWidgetFromPos(w, pt.x, pt.y));
1944  } else {
1945  w->OnDragDrop(pt, GetWidgetFromPos(w, pt.x, pt.y));
1946  }
1947  }
1948 
1949  if (!_left_button_down) ResetObjectToPlace(); // Button released, finished dragging.
1950  return ES_HANDLED;
1951 }
1952 
1954 static void HandleMouseOver()
1955 {
1956  Window *w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
1957 
1958  /* We changed window, put an OnMouseOver event to the last window */
1959  if (_mouseover_last_w != nullptr && _mouseover_last_w != w) {
1960  /* Reset mouse-over coordinates of previous window */
1961  Point pt = { -1, -1 };
1963  }
1964 
1965  /* _mouseover_last_w will get reset when the window is deleted, see DeleteWindow() */
1966  _mouseover_last_w = w;
1967 
1968  if (w != nullptr) {
1969  /* send an event in client coordinates. */
1970  Point pt = { _cursor.pos.x - w->left, _cursor.pos.y - w->top };
1971  const NWidgetCore *widget = w->nested_root->GetWidgetFromPos(pt.x, pt.y);
1972  if (widget != nullptr) w->OnMouseOver(pt, widget->index);
1973  }
1974 }
1975 
1977 static const int MIN_VISIBLE_TITLE_BAR = 13;
1978 
1983 };
1984 
1995 static void PreventHiding(int *nx, int *ny, const Rect &rect, const Window *v, int px, PreventHideDirection dir)
1996 {
1997  if (v == nullptr) return;
1998 
1999  int v_bottom = v->top + v->height;
2000  int v_right = v->left + v->width;
2001  int safe_y = (dir == PHD_UP) ? (v->top - MIN_VISIBLE_TITLE_BAR - rect.top) : (v_bottom + MIN_VISIBLE_TITLE_BAR - rect.bottom); // Compute safe vertical position.
2002 
2003  if (*ny + rect.top <= v->top - MIN_VISIBLE_TITLE_BAR) return; // Above v is enough space
2004  if (*ny + rect.bottom >= v_bottom + MIN_VISIBLE_TITLE_BAR) return; // Below v is enough space
2005 
2006  /* Vertically, the rectangle is hidden behind v. */
2007  if (*nx + rect.left + MIN_VISIBLE_TITLE_BAR < v->left) { // At left of v.
2008  if (v->left < MIN_VISIBLE_TITLE_BAR) *ny = safe_y; // But enough room, force it to a safe position.
2009  return;
2010  }
2011  if (*nx + rect.right - MIN_VISIBLE_TITLE_BAR > v_right) { // At right of v.
2012  if (v_right > _screen.width - MIN_VISIBLE_TITLE_BAR) *ny = safe_y; // Not enough room, force it to a safe position.
2013  return;
2014  }
2015 
2016  /* Horizontally also hidden, force movement to a safe area. */
2017  if (px + rect.left < v->left && v->left >= MIN_VISIBLE_TITLE_BAR) { // Coming from the left, and enough room there.
2018  *nx = v->left - MIN_VISIBLE_TITLE_BAR - rect.left;
2019  } else if (px + rect.right > v_right && v_right <= _screen.width - MIN_VISIBLE_TITLE_BAR) { // Coming from the right, and enough room there.
2020  *nx = v_right + MIN_VISIBLE_TITLE_BAR - rect.right;
2021  } else {
2022  *ny = safe_y;
2023  }
2024 }
2025 
2033 static void EnsureVisibleCaption(Window *w, int nx, int ny)
2034 {
2035  /* Search for the title bar rectangle. */
2036  Rect caption_rect;
2037  const NWidgetBase *caption = w->nested_root->GetWidgetOfType(WWT_CAPTION);
2038  if (caption != nullptr) {
2039  caption_rect = caption->GetCurrentRect();
2040 
2041  /* Make sure the window doesn't leave the screen */
2042  nx = Clamp(nx, MIN_VISIBLE_TITLE_BAR - caption_rect.right, _screen.width - MIN_VISIBLE_TITLE_BAR - caption_rect.left);
2043  ny = Clamp(ny, 0, _screen.height - MIN_VISIBLE_TITLE_BAR);
2044 
2045  /* Make sure the title bar isn't hidden behind the main tool bar or the status bar. */
2046  PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_MAIN_TOOLBAR, 0), w->left, PHD_DOWN);
2047  PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_STATUS_BAR, 0), w->left, PHD_UP);
2048  }
2049 
2050  if (w->viewport != nullptr) {
2051  w->viewport->left += nx - w->left;
2052  w->viewport->top += ny - w->top;
2053  }
2054 
2055  w->left = nx;
2056  w->top = ny;
2057 }
2058 
2069 void ResizeWindow(Window *w, int delta_x, int delta_y, bool clamp_to_screen)
2070 {
2071  if (delta_x != 0 || delta_y != 0) {
2072  if (clamp_to_screen) {
2073  /* Determine the new right/bottom position. If that is outside of the bounds of
2074  * the resolution clamp it in such a manner that it stays within the bounds. */
2075  int new_right = w->left + w->width + delta_x;
2076  int new_bottom = w->top + w->height + delta_y;
2077  if (new_right >= (int)_screen.width) delta_x -= Ceil(new_right - _screen.width, std::max(1U, w->nested_root->resize_x));
2078  if (new_bottom >= (int)_screen.height) delta_y -= Ceil(new_bottom - _screen.height, std::max(1U, w->nested_root->resize_y));
2079  }
2080 
2081  w->SetDirty();
2082 
2083  uint new_xinc = std::max(0, (w->nested_root->resize_x == 0) ? 0 : (int)(w->nested_root->current_x - w->nested_root->smallest_x) + delta_x);
2084  uint new_yinc = std::max(0, (w->nested_root->resize_y == 0) ? 0 : (int)(w->nested_root->current_y - w->nested_root->smallest_y) + delta_y);
2085  assert(w->nested_root->resize_x == 0 || new_xinc % w->nested_root->resize_x == 0);
2086  assert(w->nested_root->resize_y == 0 || new_yinc % w->nested_root->resize_y == 0);
2087 
2089  w->width = w->nested_root->current_x;
2090  w->height = w->nested_root->current_y;
2091  }
2092 
2093  EnsureVisibleCaption(w, w->left, w->top);
2094 
2095  /* Always call OnResize to make sure everything is initialised correctly if it needs to be. */
2096  w->OnResize();
2097  w->SetDirty();
2098 }
2099 
2106 {
2108  return (w == nullptr) ? 0 : w->top + w->height;
2109 }
2110 
2117 {
2119  return (w == nullptr) ? _screen.height : w->top;
2120 }
2121 
2122 static bool _dragging_window;
2123 
2129 {
2130  /* Get out immediately if no window is being dragged at all. */
2131  if (!_dragging_window) return ES_NOT_HANDLED;
2132 
2133  /* If button still down, but cursor hasn't moved, there is nothing to do. */
2134  if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED;
2135 
2136  /* Otherwise find the window... */
2137  for (Window *w : Window::Iterate()) {
2138  if (w->flags & WF_DRAGGING) {
2139  /* Stop the dragging if the left mouse button was released */
2140  if (!_left_button_down) {
2141  w->flags &= ~WF_DRAGGING;
2142  break;
2143  }
2144 
2145  w->SetDirty();
2146 
2147  int x = _cursor.pos.x + _drag_delta.x;
2148  int y = _cursor.pos.y + _drag_delta.y;
2149  int nx = x;
2150  int ny = y;
2151 
2155  int delta;
2156 
2157  for (const Window *v : Window::Iterate()) {
2158  if (v == w) continue; // Don't snap at yourself
2159 
2160  if (y + w->height > v->top && y < v->top + v->height) {
2161  /* Your left border <-> other right border */
2162  delta = abs(v->left + v->width - x);
2163  if (delta <= hsnap) {
2164  nx = v->left + v->width;
2165  hsnap = delta;
2166  }
2167 
2168  /* Your right border <-> other left border */
2169  delta = abs(v->left - x - w->width);
2170  if (delta <= hsnap) {
2171  nx = v->left - w->width;
2172  hsnap = delta;
2173  }
2174  }
2175 
2176  if (w->top + w->height >= v->top && w->top <= v->top + v->height) {
2177  /* Your left border <-> other left border */
2178  delta = abs(v->left - x);
2179  if (delta <= hsnap) {
2180  nx = v->left;
2181  hsnap = delta;
2182  }
2183 
2184  /* Your right border <-> other right border */
2185  delta = abs(v->left + v->width - x - w->width);
2186  if (delta <= hsnap) {
2187  nx = v->left + v->width - w->width;
2188  hsnap = delta;
2189  }
2190  }
2191 
2192  if (x + w->width > v->left && x < v->left + v->width) {
2193  /* Your top border <-> other bottom border */
2194  delta = abs(v->top + v->height - y);
2195  if (delta <= vsnap) {
2196  ny = v->top + v->height;
2197  vsnap = delta;
2198  }
2199 
2200  /* Your bottom border <-> other top border */
2201  delta = abs(v->top - y - w->height);
2202  if (delta <= vsnap) {
2203  ny = v->top - w->height;
2204  vsnap = delta;
2205  }
2206  }
2207 
2208  if (w->left + w->width >= v->left && w->left <= v->left + v->width) {
2209  /* Your top border <-> other top border */
2210  delta = abs(v->top - y);
2211  if (delta <= vsnap) {
2212  ny = v->top;
2213  vsnap = delta;
2214  }
2215 
2216  /* Your bottom border <-> other bottom border */
2217  delta = abs(v->top + v->height - y - w->height);
2218  if (delta <= vsnap) {
2219  ny = v->top + v->height - w->height;
2220  vsnap = delta;
2221  }
2222  }
2223  }
2224  }
2225 
2226  EnsureVisibleCaption(w, nx, ny);
2227 
2228  w->SetDirty();
2229  return ES_HANDLED;
2230  } else if (w->flags & WF_SIZING) {
2231  /* Stop the sizing if the left mouse button was released */
2232  if (!_left_button_down) {
2233  w->flags &= ~WF_SIZING;
2234  w->SetDirty();
2235  break;
2236  }
2237 
2238  /* Compute difference in pixels between cursor position and reference point in the window.
2239  * If resizing the left edge of the window, moving to the left makes the window bigger not smaller.
2240  */
2241  int x, y = _cursor.pos.y - _drag_delta.y;
2242  if (w->flags & WF_SIZING_LEFT) {
2243  x = _drag_delta.x - _cursor.pos.x;
2244  } else {
2245  x = _cursor.pos.x - _drag_delta.x;
2246  }
2247 
2248  /* resize.step_width and/or resize.step_height may be 0, which means no resize is possible. */
2249  if (w->resize.step_width == 0) x = 0;
2250  if (w->resize.step_height == 0) y = 0;
2251 
2252  /* Check the resize button won't go past the bottom of the screen */
2253  if (w->top + w->height + y > _screen.height) {
2254  y = _screen.height - w->height - w->top;
2255  }
2256 
2257  /* X and Y has to go by step.. calculate it.
2258  * The cast to int is necessary else x/y are implicitly casted to
2259  * unsigned int, which won't work. */
2260  if (w->resize.step_width > 1) x -= x % (int)w->resize.step_width;
2261  if (w->resize.step_height > 1) y -= y % (int)w->resize.step_height;
2262 
2263  /* Check that we don't go below the minimum set size */
2264  if ((int)w->width + x < (int)w->nested_root->smallest_x) {
2265  x = w->nested_root->smallest_x - w->width;
2266  }
2267  if ((int)w->height + y < (int)w->nested_root->smallest_y) {
2268  y = w->nested_root->smallest_y - w->height;
2269  }
2270 
2271  /* Window already on size */
2272  if (x == 0 && y == 0) return ES_HANDLED;
2273 
2274  /* Now find the new cursor pos.. this is NOT _cursor, because we move in steps. */
2275  _drag_delta.y += y;
2276  if ((w->flags & WF_SIZING_LEFT) && x != 0) {
2277  _drag_delta.x -= x; // x > 0 -> window gets longer -> left-edge moves to left -> subtract x to get new position.
2278  w->SetDirty();
2279  w->left -= x; // If dragging left edge, move left window edge in opposite direction by the same amount.
2280  /* ResizeWindow() below ensures marking new position as dirty. */
2281  } else {
2282  _drag_delta.x += x;
2283  }
2284 
2285  /* ResizeWindow sets both pre- and after-size to dirty for redrawal */
2286  ResizeWindow(w, x, y);
2287  return ES_HANDLED;
2288  }
2289  }
2290 
2291  _dragging_window = false;
2292  return ES_HANDLED;
2293 }
2294 
2299 static void StartWindowDrag(Window *w)
2300 {
2301  w->flags |= WF_DRAGGING;
2302  w->flags &= ~WF_CENTERED;
2303  _dragging_window = true;
2304 
2305  _drag_delta.x = w->left - _cursor.pos.x;
2306  _drag_delta.y = w->top - _cursor.pos.y;
2307 
2308  BringWindowToFront(w);
2310 }
2311 
2317 static void StartWindowSizing(Window *w, bool to_left)
2318 {
2319  w->flags |= to_left ? WF_SIZING_LEFT : WF_SIZING_RIGHT;
2320  w->flags &= ~WF_CENTERED;
2321  _dragging_window = true;
2322 
2323  _drag_delta.x = _cursor.pos.x;
2324  _drag_delta.y = _cursor.pos.y;
2325 
2326  BringWindowToFront(w);
2328 }
2329 
2335 {
2336  int i;
2338  bool rtl = false;
2339 
2340  if (sb->type == NWID_HSCROLLBAR) {
2341  i = _cursor.pos.x - _cursorpos_drag_start.x;
2342  rtl = _current_text_dir == TD_RTL;
2343  } else {
2344  i = _cursor.pos.y - _cursorpos_drag_start.y;
2345  }
2346 
2347  if (sb->disp_flags & ND_SCROLLBAR_BTN) {
2348  if (_scroller_click_timeout == 1) {
2349  _scroller_click_timeout = 3;
2350  if (sb->UpdatePosition(rtl == HasBit(sb->disp_flags, NDB_SCROLLBAR_UP) ? 1 : -1)) w->SetDirty();
2351  }
2352  return;
2353  }
2354 
2355  /* Find the item we want to move to and make sure it's inside bounds. */
2356  int pos = std::min(RoundDivSU(std::max(0, i + _scrollbar_start_pos) * sb->GetCount(), _scrollbar_size), std::max(0, sb->GetCount() - sb->GetCapacity()));
2357  if (rtl) pos = std::max(0, sb->GetCount() - sb->GetCapacity() - pos);
2358  if (pos != sb->GetPosition()) {
2359  sb->SetPosition(pos);
2360  w->SetDirty();
2361  }
2362 }
2363 
2369 {
2370  for (Window *w : Window::Iterate()) {
2371  if (w->mouse_capture_widget >= 0) {
2372  /* Abort if no button is clicked any more. */
2373  if (!_left_button_down) {
2375  w->mouse_capture_widget = -1;
2376  return ES_HANDLED;
2377  }
2378 
2379  /* Handle scrollbar internally, or dispatch click event */
2381  if (type == NWID_VSCROLLBAR || type == NWID_HSCROLLBAR) {
2383  } else {
2384  /* If cursor hasn't moved, there is nothing to do. */
2385  if (_cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED;
2386 
2387  Point pt = { _cursor.pos.x - w->left, _cursor.pos.y - w->top };
2388  w->OnClick(pt, w->mouse_capture_widget, 0);
2389  }
2390  return ES_HANDLED;
2391  }
2392  }
2393 
2394  return ES_NOT_HANDLED;
2395 }
2396 
2402 {
2403  bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
2404 
2405  if (!_scrolling_viewport) return ES_NOT_HANDLED;
2406 
2407  /* When we don't have a last scroll window we are starting to scroll.
2408  * When the last scroll window and this are not the same we went
2409  * outside of the window and should not left-mouse scroll anymore. */
2410  if (_last_scroll_window == nullptr) _last_scroll_window = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
2411 
2413  _cursor.fix_at = false;
2414  _scrolling_viewport = false;
2415  _last_scroll_window = nullptr;
2416  return ES_NOT_HANDLED;
2417  }
2418 
2420  /* If the main window is following a vehicle, then first let go of it! */
2422  ScrollMainWindowTo(veh->x_pos, veh->y_pos, veh->z_pos, true); // This also resets follow_vehicle
2423  return ES_NOT_HANDLED;
2424  }
2425 
2426  Point delta;
2427  if (scrollwheel_scrolling) {
2428  /* We are using scrollwheels for scrolling */
2429  delta.x = _cursor.h_wheel;
2430  delta.y = _cursor.v_wheel;
2431  _cursor.v_wheel = 0;
2432  _cursor.h_wheel = 0;
2433  } else {
2435  delta.x = -_cursor.delta.x;
2436  delta.y = -_cursor.delta.y;
2437  } else {
2438  delta.x = _cursor.delta.x;
2439  delta.y = _cursor.delta.y;
2440  }
2441  }
2442 
2443  /* Create a scroll-event and send it to the window */
2444  if (delta.x != 0 || delta.y != 0) _last_scroll_window->OnScroll(delta);
2445 
2446  _cursor.delta.x = 0;
2447  _cursor.delta.y = 0;
2448  return ES_HANDLED;
2449 }
2450 
2462 {
2463  bool bring_to_front = false;
2464 
2465  if (w->window_class == WC_MAIN_WINDOW ||
2466  IsVitalWindow(w) ||
2467  w->window_class == WC_TOOLTIPS ||
2469  return true;
2470  }
2471 
2472  /* Use unshaded window size rather than current size for shaded windows. */
2473  int w_width = w->width;
2474  int w_height = w->height;
2475  if (w->IsShaded()) {
2476  w_width = w->unshaded_size.width;
2477  w_height = w->unshaded_size.height;
2478  }
2479 
2481  ++it;
2482  for (; !it.IsEnd(); ++it) {
2483  Window *u = *it;
2484  /* A modal child will prevent the activation of the parent window */
2485  if (u->parent == w && (u->window_desc->flags & WDF_MODAL)) {
2486  u->SetWhiteBorder();
2487  u->SetDirty();
2488  return false;
2489  }
2490 
2491  if (u->window_class == WC_MAIN_WINDOW ||
2492  IsVitalWindow(u) ||
2493  u->window_class == WC_TOOLTIPS ||
2495  continue;
2496  }
2497 
2498  /* Window sizes don't interfere, leave z-order alone */
2499  if (w->left + w_width <= u->left ||
2500  u->left + u->width <= w->left ||
2501  w->top + w_height <= u->top ||
2502  u->top + u->height <= w->top) {
2503  continue;
2504  }
2505 
2506  bring_to_front = true;
2507  }
2508 
2509  if (bring_to_front) BringWindowToFront(w);
2510  return true;
2511 }
2512 
2521 EventState Window::HandleEditBoxKey(int wid, WChar key, uint16 keycode)
2522 {
2523  QueryString *query = this->GetQueryString(wid);
2524  if (query == nullptr) return ES_NOT_HANDLED;
2525 
2526  int action = QueryString::ACTION_NOTHING;
2527 
2528  switch (query->text.HandleKeyPress(key, keycode)) {
2529  case HKPR_EDITING:
2530  this->SetWidgetDirty(wid);
2531  this->OnEditboxChanged(wid);
2532  break;
2533 
2534  case HKPR_CURSOR:
2535  this->SetWidgetDirty(wid);
2536  /* For the OSK also invalidate the parent window */
2537  if (this->window_class == WC_OSK) this->InvalidateData();
2538  break;
2539 
2540  case HKPR_CONFIRM:
2541  if (this->window_class == WC_OSK) {
2542  this->OnClick(Point(), WID_OSK_OK, 1);
2543  } else if (query->ok_button >= 0) {
2544  this->OnClick(Point(), query->ok_button, 1);
2545  } else {
2546  action = query->ok_button;
2547  }
2548  break;
2549 
2550  case HKPR_CANCEL:
2551  if (this->window_class == WC_OSK) {
2552  this->OnClick(Point(), WID_OSK_CANCEL, 1);
2553  } else if (query->cancel_button >= 0) {
2554  this->OnClick(Point(), query->cancel_button, 1);
2555  } else {
2556  action = query->cancel_button;
2557  }
2558  break;
2559 
2560  case HKPR_NOT_HANDLED:
2561  return ES_NOT_HANDLED;
2562 
2563  default: break;
2564  }
2565 
2566  switch (action) {
2568  this->UnfocusFocusedWidget();
2569  break;
2570 
2572  if (query->text.bytes <= 1) {
2573  /* If already empty, unfocus instead */
2574  this->UnfocusFocusedWidget();
2575  } else {
2576  query->text.DeleteAll();
2577  this->SetWidgetDirty(wid);
2578  this->OnEditboxChanged(wid);
2579  }
2580  break;
2581 
2582  default:
2583  break;
2584  }
2585 
2586  return ES_HANDLED;
2587 }
2588 
2594 void HandleKeypress(uint keycode, WChar key)
2595 {
2596  /* World generation is multithreaded and messes with companies.
2597  * But there is no company related window open anyway, so _current_company is not used. */
2598  assert(HasModalProgress() || IsLocalCompany());
2599 
2600  /*
2601  * The Unicode standard defines an area called the private use area. Code points in this
2602  * area are reserved for private use and thus not portable between systems. For instance,
2603  * Apple defines code points for the arrow keys in this area, but these are only printable
2604  * on a system running OS X. We don't want these keys to show up in text fields and such,
2605  * and thus we have to clear the unicode character when we encounter such a key.
2606  */
2607  if (key >= 0xE000 && key <= 0xF8FF) key = 0;
2608 
2609  /*
2610  * If both key and keycode is zero, we don't bother to process the event.
2611  */
2612  if (key == 0 && keycode == 0) return;
2613 
2614  /* Check if the focused window has a focused editbox */
2615  if (EditBoxInGlobalFocus()) {
2616  /* All input will in this case go to the focused editbox */
2617  if (_focused_window->window_class == WC_CONSOLE) {
2618  if (_focused_window->OnKeyPress(key, keycode) == ES_HANDLED) return;
2619  } else {
2620  if (_focused_window->HandleEditBoxKey(_focused_window->nested_focus->index, key, keycode) == ES_HANDLED) return;
2621  }
2622  }
2623 
2624  /* Call the event, start with the uppermost window, but ignore the toolbar. */
2625  for (Window *w : Window::IterateFromFront()) {
2626  if (w->window_class == WC_MAIN_TOOLBAR) continue;
2627  if (w->window_desc->hotkeys != nullptr) {
2628  int hotkey = w->window_desc->hotkeys->CheckMatch(keycode);
2629  if (hotkey >= 0 && w->OnHotkey(hotkey) == ES_HANDLED) return;
2630  }
2631  if (w->OnKeyPress(key, keycode) == ES_HANDLED) return;
2632  }
2633 
2635  /* When there is no toolbar w is null, check for that */
2636  if (w != nullptr) {
2637  if (w->window_desc->hotkeys != nullptr) {
2638  int hotkey = w->window_desc->hotkeys->CheckMatch(keycode);
2639  if (hotkey >= 0 && w->OnHotkey(hotkey) == ES_HANDLED) return;
2640  }
2641  if (w->OnKeyPress(key, keycode) == ES_HANDLED) return;
2642  }
2643 
2644  HandleGlobalHotkeys(key, keycode);
2645 }
2646 
2651 {
2652  /* Call the event, start with the uppermost window. */
2653  for (Window *w : Window::IterateFromFront()) {
2654  if (w->OnCTRLStateChange() == ES_HANDLED) return;
2655  }
2656 }
2657 
2663 /* virtual */ void Window::InsertTextString(int wid, const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end)
2664 {
2665  QueryString *query = this->GetQueryString(wid);
2666  if (query == nullptr) return;
2667 
2668  if (query->text.InsertString(str, marked, caret, insert_location, replacement_end) || marked) {
2669  this->SetWidgetDirty(wid);
2670  this->OnEditboxChanged(wid);
2671  }
2672 }
2673 
2680 void HandleTextInput(const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end)
2681 {
2682  if (!EditBoxInGlobalFocus()) return;
2683 
2684  _focused_window->InsertTextString(_focused_window->window_class == WC_CONSOLE ? 0 : _focused_window->nested_focus->index, str, marked, caret, insert_location, replacement_end);
2685 }
2686 
2694 
2699 static void HandleAutoscroll()
2700 {
2701  if (_game_mode == GM_MENU || HasModalProgress()) return;
2703  if (_settings_client.gui.auto_scrolling == VA_MAIN_VIEWPORT_FULLSCREEN && !_fullscreen) return;
2704 
2705  int x = _cursor.pos.x;
2706  int y = _cursor.pos.y;
2707  Window *w = FindWindowFromPt(x, y);
2708  if (w == nullptr || w->flags & WF_DISABLE_VP_SCROLL) return;
2710 
2711  Viewport *vp = IsPtInWindowViewport(w, x, y);
2712  if (vp == nullptr) return;
2713 
2714  x -= vp->left;
2715  y -= vp->top;
2716 
2717  /* here allows scrolling in both x and y axis */
2718  static const int SCROLLSPEED = 3;
2719  if (x - 15 < 0) {
2720  w->viewport->dest_scrollpos_x += ScaleByZoom((x - 15) * SCROLLSPEED, vp->zoom);
2721  } else if (15 - (vp->width - x) > 0) {
2722  w->viewport->dest_scrollpos_x += ScaleByZoom((15 - (vp->width - x)) * SCROLLSPEED, vp->zoom);
2723  }
2724  if (y - 15 < 0) {
2725  w->viewport->dest_scrollpos_y += ScaleByZoom((y - 15) * SCROLLSPEED, vp->zoom);
2726  } else if (15 - (vp->height - y) > 0) {
2727  w->viewport->dest_scrollpos_y += ScaleByZoom((15 - (vp->height - y)) * SCROLLSPEED, vp->zoom);
2728  }
2729 }
2730 
2732  MC_NONE = 0,
2733  MC_LEFT,
2734  MC_RIGHT,
2735  MC_DOUBLE_LEFT,
2736  MC_HOVER,
2737 
2740 };
2742 
2743 const std::chrono::milliseconds TIME_BETWEEN_DOUBLE_CLICK(500);
2744 
2745 static void ScrollMainViewport(int x, int y)
2746 {
2747  if (_game_mode != GM_MENU) {
2749  assert(w);
2750 
2753  }
2754 }
2755 
2765 static const int8 scrollamt[16][2] = {
2766  { 0, 0},
2767  {-2, 0},
2768  { 0, -2},
2769  {-2, -1},
2770  { 2, 0},
2771  { 0, 0},
2772  { 2, -1},
2773  { 0, -2},
2774  { 0, 2},
2775  {-2, 1},
2776  { 0, 0},
2777  {-2, 0},
2778  { 2, 1},
2779  { 0, 2},
2780  { 2, 0},
2781  { 0, 0},
2782 };
2783 
2784 static void HandleKeyScrolling()
2785 {
2786  /*
2787  * Check that any of the dirkeys is pressed and that the focused window
2788  * doesn't have an edit-box as focused widget.
2789  */
2790  if (_dirkeys && !EditBoxInGlobalFocus()) {
2791  int factor = _shift_pressed ? 50 : 10;
2792  ScrollMainViewport(scrollamt[_dirkeys][0] * factor, scrollamt[_dirkeys][1] * factor);
2793  }
2794 }
2795 
2796 static void MouseLoop(MouseClick click, int mousewheel)
2797 {
2798  /* World generation is multithreaded and messes with companies.
2799  * But there is no company related window open anyway, so _current_company is not used. */
2800  assert(HasModalProgress() || IsLocalCompany());
2801 
2802  HandlePlacePresize();
2804 
2805  if (VpHandlePlaceSizingDrag() == ES_HANDLED) return;
2806  if (HandleMouseDragDrop() == ES_HANDLED) return;
2807  if (HandleWindowDragging() == ES_HANDLED) return;
2808  if (HandleActiveWidget() == ES_HANDLED) return;
2809  if (HandleViewportScroll() == ES_HANDLED) return;
2810 
2811  HandleMouseOver();
2812 
2813  bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
2814  if (click == MC_NONE && mousewheel == 0 && !scrollwheel_scrolling) return;
2815 
2816  int x = _cursor.pos.x;
2817  int y = _cursor.pos.y;
2818  Window *w = FindWindowFromPt(x, y);
2819  if (w == nullptr) return;
2820 
2821  if (click != MC_HOVER && !MaybeBringWindowToFront(w)) return;
2822  Viewport *vp = IsPtInWindowViewport(w, x, y);
2823 
2824  /* Don't allow any action in a viewport if either in menu or when having a modal progress window */
2825  if (vp != nullptr && (_game_mode == GM_MENU || HasModalProgress())) return;
2826 
2827  if (mousewheel != 0) {
2828  /* Send mousewheel event to window, unless we're scrolling a viewport or the map */
2829  if (!scrollwheel_scrolling || (vp == nullptr && w->window_class != WC_SMALLMAP)) w->OnMouseWheel(mousewheel);
2830 
2831  /* Dispatch a MouseWheelEvent for widgets if it is not a viewport */
2832  if (vp == nullptr) DispatchMouseWheelEvent(w, w->nested_root->GetWidgetFromPos(x - w->left, y - w->top), mousewheel);
2833  }
2834 
2835  if (vp != nullptr) {
2836  if (scrollwheel_scrolling && !(w->flags & WF_DISABLE_VP_SCROLL)) {
2837  _scrolling_viewport = true;
2838  _cursor.fix_at = true;
2839  return;
2840  }
2841 
2842  switch (click) {
2843  case MC_DOUBLE_LEFT:
2844  case MC_LEFT:
2845  if (HandleViewportClicked(vp, x, y)) return;
2846  if (!(w->flags & WF_DISABLE_VP_SCROLL) &&
2848  _scrolling_viewport = true;
2849  _cursor.fix_at = false;
2850  return;
2851  }
2852  break;
2853 
2854  case MC_RIGHT:
2855  if (!(w->flags & WF_DISABLE_VP_SCROLL) &&
2857  _scrolling_viewport = true;
2860  return;
2861  }
2862  break;
2863 
2864  default:
2865  break;
2866  }
2867  }
2868 
2869  if (vp == nullptr || (w->flags & WF_DISABLE_VP_SCROLL)) {
2870  switch (click) {
2871  case MC_LEFT:
2872  case MC_DOUBLE_LEFT:
2873  DispatchLeftClickEvent(w, x - w->left, y - w->top, click == MC_DOUBLE_LEFT ? 2 : 1);
2874  return;
2875 
2876  default:
2877  if (!scrollwheel_scrolling || w == nullptr || w->window_class != WC_SMALLMAP) break;
2878  /* We try to use the scrollwheel to scroll since we didn't touch any of the buttons.
2879  * Simulate a right button click so we can get started. */
2880  FALLTHROUGH;
2881 
2882  case MC_RIGHT:
2883  DispatchRightClickEvent(w, x - w->left, y - w->top);
2884  return;
2885 
2886  case MC_HOVER:
2887  DispatchHoverEvent(w, x - w->left, y - w->top);
2888  break;
2889  }
2890  }
2891 
2892  /* We're not doing anything with 2D scrolling, so reset the value. */
2893  _cursor.h_wheel = 0;
2894  _cursor.v_wheel = 0;
2895 }
2896 
2901 {
2902  /* World generation is multithreaded and messes with companies.
2903  * But there is no company related window open anyway, so _current_company is not used. */
2904  assert(HasModalProgress() || IsLocalCompany());
2905 
2906  /* Handle sprite picker before any GUI interaction */
2907  if (_newgrf_debug_sprite_picker.mode == SPM_REDRAW && _input_events_this_tick == 0) {
2908  /* We are done with the last draw-frame, so we know what sprites we
2909  * clicked on. Reset the picker mode and invalidate the window. */
2910  _newgrf_debug_sprite_picker.mode = SPM_NONE;
2912  }
2913 
2914  static std::chrono::steady_clock::time_point double_click_time = {};
2915  static Point double_click_pos = {0, 0};
2916 
2917  /* Mouse event? */
2918  MouseClick click = MC_NONE;
2920  click = MC_LEFT;
2921  if (std::chrono::steady_clock::now() <= double_click_time + TIME_BETWEEN_DOUBLE_CLICK &&
2922  double_click_pos.x != 0 && abs(_cursor.pos.x - double_click_pos.x) < MAX_OFFSET_DOUBLE_CLICK &&
2923  double_click_pos.y != 0 && abs(_cursor.pos.y - double_click_pos.y) < MAX_OFFSET_DOUBLE_CLICK) {
2924  click = MC_DOUBLE_LEFT;
2925  }
2926  double_click_time = std::chrono::steady_clock::now();
2927  double_click_pos = _cursor.pos;
2928  _left_button_clicked = true;
2930  } else if (_right_button_clicked) {
2931  _right_button_clicked = false;
2932  click = MC_RIGHT;
2934  }
2935 
2936  int mousewheel = 0;
2937  if (_cursor.wheel) {
2938  mousewheel = _cursor.wheel;
2939  _cursor.wheel = 0;
2941  }
2942 
2943  static std::chrono::steady_clock::time_point hover_time = {};
2944  static Point hover_pos = {0, 0};
2945 
2947  if (!_cursor.in_window || click != MC_NONE || mousewheel != 0 || _left_button_down || _right_button_down ||
2948  hover_pos.x == 0 || abs(_cursor.pos.x - hover_pos.x) >= MAX_OFFSET_HOVER ||
2949  hover_pos.y == 0 || abs(_cursor.pos.y - hover_pos.y) >= MAX_OFFSET_HOVER) {
2950  hover_pos = _cursor.pos;
2951  hover_time = std::chrono::steady_clock::now();
2952  _mouse_hovering = false;
2953  } else {
2954  if (std::chrono::steady_clock::now() > hover_time + std::chrono::milliseconds(_settings_client.gui.hover_delay_ms)) {
2955  click = MC_HOVER;
2957  _mouse_hovering = true;
2958  }
2959  }
2960  }
2961 
2962  if (click == MC_LEFT && _newgrf_debug_sprite_picker.mode == SPM_WAIT_CLICK) {
2963  /* Mark whole screen dirty, and wait for the next realtime tick, when drawing is finished. */
2965  _newgrf_debug_sprite_picker.clicked_pixel = blitter->MoveTo(_screen.dst_ptr, _cursor.pos.x, _cursor.pos.y);
2967  _newgrf_debug_sprite_picker.mode = SPM_REDRAW;
2969  } else {
2970  MouseLoop(click, mousewheel);
2971  }
2972 
2973  /* We have moved the mouse the required distance,
2974  * no need to move it at any later time. */
2975  _cursor.delta.x = 0;
2976  _cursor.delta.y = 0;
2977 }
2978 
2982 static void CheckSoftLimit()
2983 {
2984  if (_settings_client.gui.window_soft_limit == 0) return;
2985 
2986  for (;;) {
2987  uint deletable_count = 0;
2988  Window *last_deletable = nullptr;
2989  for (Window *w : Window::IterateFromFront()) {
2990  if (w->window_class == WC_MAIN_WINDOW || IsVitalWindow(w) || (w->flags & WF_STICKY)) continue;
2991 
2992  last_deletable = w;
2993  deletable_count++;
2994  }
2995 
2996  /* We've not reached the soft limit yet. */
2997  if (deletable_count <= _settings_client.gui.window_soft_limit) break;
2998 
2999  assert(last_deletable != nullptr);
3000  last_deletable->Close();
3001  }
3002 }
3003 
3008 {
3009  /* World generation is multithreaded and messes with companies.
3010  * But there is no company related window open anyway, so _current_company is not used. */
3011  assert(HasModalProgress() || IsLocalCompany());
3012 
3013  CheckSoftLimit();
3014 
3015  /* Process scheduled window deletion. */
3017 
3018  if (_input_events_this_tick != 0) {
3019  /* The input loop is called only once per GameLoop() - so we can clear the counter here */
3021  /* there were some inputs this tick, don't scroll ??? */
3022  return;
3023  }
3024 
3025  /* HandleMouseEvents was already called for this tick */
3027 }
3028 
3032 void CallWindowRealtimeTickEvent(uint delta_ms)
3033 {
3034  for (Window *w : Window::Iterate()) {
3035  w->OnRealtimeTick(delta_ms);
3036  }
3037 }
3038 
3043 {
3044  static std::chrono::steady_clock::time_point last_time = std::chrono::steady_clock::now();
3045  uint delta_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - last_time).count();
3046 
3047  if (delta_ms == 0) return;
3048 
3049  last_time = std::chrono::steady_clock::now();
3050 
3051  PerformanceMeasurer framerate(PFE_DRAWING);
3053 
3054  CallWindowRealtimeTickEvent(delta_ms);
3055 
3056  static GUITimer network_message_timer = GUITimer(1);
3057  if (network_message_timer.Elapsed(delta_ms)) {
3058  network_message_timer.SetInterval(1000);
3060  }
3061 
3062  /* Process invalidations before anything else. */
3063  for (Window *w : Window::Iterate()) {
3066  }
3067 
3068  static GUITimer window_timer = GUITimer(1);
3069  if (window_timer.Elapsed(delta_ms)) {
3070  if (_network_dedicated) window_timer.SetInterval(MILLISECONDS_PER_TICK);
3071 
3072  extern int _caret_timer;
3073  _caret_timer += 3;
3074  CursorTick();
3075 
3076  HandleKeyScrolling();
3077  HandleAutoscroll();
3078  DecreaseWindowCounters();
3079  }
3080 
3081  static GUITimer highlight_timer = GUITimer(1);
3082  if (highlight_timer.Elapsed(delta_ms)) {
3083  highlight_timer.SetInterval(450);
3085  }
3086 
3087  if (!_pause_mode || _game_mode == GM_EDITOR || _settings_game.construction.command_pause_level > CMDPL_NO_CONSTRUCTION) MoveAllTextEffects(delta_ms);
3088 
3089  /* Skip the actual drawing on dedicated servers without screen.
3090  * But still empty the invalidation queues above. */
3091  if (_network_dedicated) return;
3092 
3093  if (window_timer.HasElapsed()) {
3094  window_timer.SetInterval(MILLISECONDS_PER_TICK);
3095 
3096  for (Window *w : Window::Iterate()) {
3097  if ((w->flags & WF_WHITE_BORDER) && --w->white_border_timer == 0) {
3099  w->SetDirty();
3100  }
3101  }
3102  }
3103 
3104  DrawDirtyBlocks();
3105 
3106  for (Window *w : Window::Iterate()) {
3107  /* Update viewport only if window is not shaded. */
3108  if (w->viewport != nullptr && !w->IsShaded()) UpdateViewportPosition(w);
3109  }
3111  /* Redraw mouse cursor in case it was hidden */
3112  DrawMouseCursor();
3113 }
3114 
3121 {
3122  for (const Window *w : Window::Iterate()) {
3123  if (w->window_class == cls && w->window_number == number) w->SetDirty();
3124  }
3125 }
3126 
3133 void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
3134 {
3135  for (const Window *w : Window::Iterate()) {
3136  if (w->window_class == cls && w->window_number == number) {
3137  w->SetWidgetDirty(widget_index);
3138  }
3139  }
3140 }
3141 
3147 {
3148  for (const Window *w : Window::Iterate()) {
3149  if (w->window_class == cls) w->SetDirty();
3150  }
3151 }
3152 
3158 void Window::InvalidateData(int data, bool gui_scope)
3159 {
3160  this->SetDirty();
3161  if (!gui_scope) {
3162  /* Schedule GUI-scope invalidation for next redraw. */
3163  this->scheduled_invalidation_data.push_back(data);
3164  }
3165  this->OnInvalidateData(data, gui_scope);
3166 }
3167 
3172 {
3173  for (int data : this->scheduled_invalidation_data) {
3174  if (this->window_class == WC_INVALID) break;
3175  this->OnInvalidateData(data, true);
3176  }
3177  this->scheduled_invalidation_data.clear();
3178 }
3179 
3184 {
3185  if ((this->flags & WF_HIGHLIGHTED) == 0) return;
3186 
3187  for (uint i = 0; i < this->nested_array_size; i++) {
3188  if (this->IsWidgetHighlighted(i)) this->SetWidgetDirty(i);
3189  }
3190 }
3191 
3218 void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
3219 {
3220  for (Window *w : Window::Iterate()) {
3221  if (w->window_class == cls && w->window_number == number) {
3222  w->InvalidateData(data, gui_scope);
3223  }
3224  }
3225 }
3226 
3235 void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
3236 {
3237  for (Window *w : Window::Iterate()) {
3238  if (w->window_class == cls) {
3239  w->InvalidateData(data, gui_scope);
3240  }
3241  }
3242 }
3243 
3248 {
3249  for (Window *w : Window::Iterate()) {
3250  w->OnGameTick();
3251  }
3252 }
3253 
3261 {
3262  /* Note: the container remains stable, even when deleting windows. */
3263  for (Window *w : Window::Iterate()) {
3264  if (w->window_class != WC_MAIN_WINDOW &&
3265  w->window_class != WC_SELECT_GAME &&
3266  w->window_class != WC_MAIN_TOOLBAR &&
3267  w->window_class != WC_STATUS_BAR &&
3268  w->window_class != WC_TOOLTIPS &&
3269  (w->flags & WF_STICKY) == 0) { // do not delete windows which are 'pinned'
3270 
3271  w->Close();
3272  }
3273  }
3274 }
3275 
3284 {
3285  /* Close every window except for stickied ones, then sticky ones as well */
3287 
3288  /* Note: the container remains stable, even when closing windows. */
3289  for (Window *w : Window::Iterate()) {
3290  if (w->flags & WF_STICKY) {
3291  w->Close();
3292  }
3293  }
3294 }
3295 
3300 {
3302  InvalidateWindowData(WC_STATUS_BAR, 0, SBI_NEWS_DELETED); // invalidate the statusbar
3303  InvalidateWindowData(WC_MESSAGE_HISTORY, 0); // invalidate the message history
3304  CloseWindowById(WC_NEWS_WINDOW, 0); // close newspaper or general message window if shown
3305 }
3306 
3312 {
3313  /* Note: the container remains stable, even when deleting windows. */
3314  for (Window *w : Window::Iterate()) {
3315  if (w->window_desc->flags & WDF_CONSTRUCTION) {
3316  w->Close();
3317  }
3318  }
3319 
3320  for (const Window *w : Window::Iterate()) w->SetDirty();
3321 }
3322 
3325 {
3328 }
3329 
3331 void ReInitAllWindows(bool zoom_changed)
3332 {
3333  NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
3334  NWidgetScrollbar::InvalidateDimensionCache();
3335 
3336  extern void InitDepotWindowBlockSizes();
3338 
3339  for (Window *w : Window::Iterate()) {
3340  if (zoom_changed) w->nested_root->AdjustPaddingForZoom();
3341  w->ReInit();
3342  }
3343 
3344  void NetworkReInitChatBoxSize();
3346 
3347  /* Make sure essential parts of all windows are visible */
3348  RelocateAllWindows(_screen.width, _screen.height);
3350 }
3351 
3359 static int PositionWindow(Window *w, WindowClass clss, int setting)
3360 {
3361  if (w == nullptr || w->window_class != clss) {
3362  w = FindWindowById(clss, 0);
3363  }
3364  if (w == nullptr) return 0;
3365 
3366  int old_left = w->left;
3367  switch (setting) {
3368  case 1: w->left = (_screen.width - w->width) / 2; break;
3369  case 2: w->left = _screen.width - w->width; break;
3370  default: w->left = 0; break;
3371  }
3372  if (w->viewport != nullptr) w->viewport->left += w->left - old_left;
3373  AddDirtyBlock(0, w->top, _screen.width, w->top + w->height); // invalidate the whole row
3374  return w->left;
3375 }
3376 
3383 {
3384  Debug(misc, 5, "Repositioning Main Toolbar...");
3386 }
3387 
3394 {
3395  Debug(misc, 5, "Repositioning statusbar...");
3397 }
3398 
3405 {
3406  Debug(misc, 5, "Repositioning news message...");
3408 }
3409 
3416 {
3417  Debug(misc, 5, "Repositioning network chat window...");
3419 }
3420 
3421 
3427 void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index)
3428 {
3429  for (const Window *w : Window::Iterate()) {
3430  if (w->viewport != nullptr && w->viewport->follow_vehicle == from_index) {
3431  w->viewport->follow_vehicle = to_index;
3432  w->SetDirty();
3433  }
3434  }
3435 }
3436 
3437 
3443 void RelocateAllWindows(int neww, int newh)
3444 {
3446 
3447  for (Window *w : Window::Iterate()) {
3448  int left, top;
3449  /* XXX - this probably needs something more sane. For example specifying
3450  * in a 'backup'-desc that the window should always be centered. */
3451  switch (w->window_class) {
3452  case WC_MAIN_WINDOW:
3453  case WC_BOOTSTRAP:
3454  ResizeWindow(w, neww, newh);
3455  continue;
3456 
3457  case WC_MAIN_TOOLBAR:
3458  ResizeWindow(w, std::min<uint>(neww, _toolbar_width) - w->width, 0, false);
3459 
3460  top = w->top;
3461  left = PositionMainToolbar(w); // changes toolbar orientation
3462  break;
3463 
3464  case WC_NEWS_WINDOW:
3465  top = newh - w->height;
3466  left = PositionNewsMessage(w);
3467  break;
3468 
3469  case WC_STATUS_BAR:
3470  ResizeWindow(w, std::min<uint>(neww, _toolbar_width) - w->width, 0, false);
3471 
3472  top = newh - w->height;
3473  left = PositionStatusbar(w);
3474  break;
3475 
3476  case WC_SEND_NETWORK_MSG:
3477  ResizeWindow(w, std::min<uint>(neww, _toolbar_width) - w->width, 0, false);
3478 
3479  top = newh - w->height - FindWindowById(WC_STATUS_BAR, 0)->height;
3480  left = PositionNetworkChatWindow(w);
3481  break;
3482 
3483  case WC_CONSOLE:
3484  IConsoleResize(w);
3485  continue;
3486 
3487  default: {
3488  if (w->flags & WF_CENTERED) {
3489  top = (newh - w->height) >> 1;
3490  left = (neww - w->width) >> 1;
3491  break;
3492  }
3493 
3494  left = w->left;
3495  if (left + (w->width >> 1) >= neww) left = neww - w->width;
3496  if (left < 0) left = 0;
3497 
3498  top = w->top;
3499  if (top + (w->height >> 1) >= newh) top = newh - w->height;
3500  break;
3501  }
3502  }
3503 
3504  EnsureVisibleCaption(w, left, top);
3505  }
3506 }
3507 
3513 {
3515  this->Window::Close();
3516 }
_dirkeys
byte _dirkeys
1 = left, 2 = up, 4 = right, 8 = down
Definition: gfx.cpp:31
game.hpp
NewGrfDebugSpritePicker::clicked_pixel
void * clicked_pixel
Clicked pixel (pointer to blitter buffer)
Definition: newgrf_debug.h:28
ES_HANDLED
@ ES_HANDLED
The passed event is handled.
Definition: window_type.h:718
ShowFirstError
void ShowFirstError()
Show the first error of the queue.
Definition: error_gui.cpp:348
Window::WindowIterator
Iterator to iterate all valid Windows.
Definition: window_gui.h:814
WC_CUSTOM_CURRENCY
@ WC_CUSTOM_CURRENCY
Custom currency; Window numbers:
Definition: window_type.h:610
WC_SAVELOAD
@ WC_SAVELOAD
Saveload window; Window numbers:
Definition: window_type.h:136
ScrollbarClickHandler
void ScrollbarClickHandler(Window *w, NWidgetCore *nw, int x, int y)
Special handling for the scrollbar widget type.
Definition: widget.cpp:170
PickerWindowBase::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:3512
Window::SetTimeout
void SetTimeout()
Set the timeout flag of the window and initiate the timer.
Definition: window_gui.h:360
WC_ROADVEH_LIST
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition: window_type.h:306
MAX_OFFSET_HOVER
@ MAX_OFFSET_HOVER
Maximum mouse movement before stopping a hover event.
Definition: window.cpp:2739
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3218
HideVitalWindows
void HideVitalWindows()
Close all always on-top windows to get an empty screen.
Definition: window.cpp:3324
factory.hpp
FindWindowFromPt
Window * FindWindowFromPt(int x, int y)
Do a search for a window at specific coordinates.
Definition: window.cpp:1811
WC_INVALID
@ WC_INVALID
Invalid window.
Definition: window_type.h:698
NWidgetCore::IsDisabled
bool IsDisabled() const
Return whether the widget is disabled.
Definition: widget_type.h:390
_mouseover_last_w
static Window * _mouseover_last_w
Window of the last OnMouseOver event.
Definition: window.cpp:53
Pool::PoolItem<&_vehicle_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
WC_BUILD_TOOLBAR
@ WC_BUILD_TOOLBAR
Build toolbar; Window numbers:
Definition: window_type.h:65
MouseClick
MouseClick
Definition: window.cpp:2731
QueryString::ok_button
int ok_button
Widget button of parent window to simulate when pressing OK in OSK.
Definition: querystring_gui.h:27
Window::timeout_timer
uint8 timeout_timer
Timer value of the WF_TIMEOUT for flags.
Definition: window_gui.h:309
Window::OnHundredthTick
virtual void OnHundredthTick()
Called once every 100 (game) ticks, or once every 3s, whichever comes last.
Definition: window_gui.h:694
HKPR_EDITING
@ HKPR_EDITING
Textbuf content changed.
Definition: textbuf_type.h:22
WChar
char32_t WChar
Type for wide characters, i.e.
Definition: string_type.h:35
AddDirtyBlock
void AddDirtyBlock(int left, int top, int right, int bottom)
Extend the internal _invalid_rect rectangle to contain the rectangle defined by the given parameters.
Definition: gfx.cpp:1646
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:281
WF_SIZING
@ WF_SIZING
Window is being resized.
Definition: window_gui.h:239
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3120
CheckSoftLimit
static void CheckSoftLimit()
Check the soft limit of deletable (non vital, non sticky) windows.
Definition: window.cpp:2982
UpdateTileSelection
void UpdateTileSelection()
Updates tile highlighting for all cases.
Definition: viewport.cpp:2532
querystring_gui.h
Window::OnEditboxChanged
virtual void OnEditboxChanged(int widget)
The text in an editbox has been edited.
Definition: window_gui.h:726
Window::SetWhiteBorder
void SetWhiteBorder()
Set the timeout flag of the window and initiate the timer.
Definition: window_gui.h:369
HotkeyList
List of hotkeys for a window.
Definition: hotkeys.h:40
FindChildWindow
static Window * FindChildWindow(const Window *w, WindowClass wc)
Find the Window whose parent pointer points to this window.
Definition: window.cpp:1067
QueryString::GetText
const char * GetText() const
Get the current text.
Definition: querystring_gui.h:63
SetFocusedWindow
void SetFocusedWindow(Window *w)
Set the window that has the focus.
Definition: window.cpp:445
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:280
Window::~Window
virtual ~Window()
Remove window and all its child windows from the window stack.
Definition: window.cpp:1129
Scrollbar::GetCapacity
uint16 GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition: widget_type.h:662
Window::nested_root
NWidgetBase * nested_root
Root of the nested tree.
Definition: window_gui.h:324
HKPR_CONFIRM
@ HKPR_CONFIRM
Return or enter key pressed.
Definition: textbuf_type.h:24
NWidgetLeaf::resizebox_dimension
static Dimension resizebox_dimension
Cached size of a resizebox widget.
Definition: widget_type.h:827
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
Window::GetScrollbar
const Scrollbar * GetScrollbar(uint widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:320
WDF_CONSTRUCTION
@ WDF_CONSTRUCTION
This window is used for construction; close it whenever changing company.
Definition: window_gui.h:210
PositionMainToolbar
int PositionMainToolbar(Window *w)
(Re)position main toolbar window at the screen.
Definition: window.cpp:3382
Window::shade_select
NWidgetStacked * shade_select
Selection widget (NWID_SELECTION) to use for shading the window. If nullptr, window cannot shade.
Definition: window_gui.h:327
WF_SIZING_RIGHT
@ WF_SIZING_RIGHT
Window is being resized towards the right.
Definition: window_gui.h:237
dropdown_func.h
Window::OnHover
virtual void OnHover(Point pt, int widget)
The mouse is hovering over a widget in the window, perform an action for it.
Definition: window_gui.h:634
_special_mouse_mode
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition: window.cpp:93
WID_OSK_OK
@ WID_OSK_OK
Ok key.
Definition: osk_widget.h:18
toolbar_gui.h
_left_button_down
bool _left_button_down
Is left mouse button pressed?
Definition: gfx.cpp:38
guitimer_func.h
statusbar_gui.h
Window::ApplyDefaults
virtual void ApplyDefaults()
Read default values from WindowDesc configuration an apply them to the window.
Definition: window.cpp:193
Window::ReInit
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:1004
scrollamt
static const int8 scrollamt[16][2]
Describes all the different arrow key combinations the game allows when it is in scrolling mode.
Definition: window.cpp:2765
CloseCompanyWindows
void CloseCompanyWindows(CompanyID id)
Close all windows of a company.
Definition: window.cpp:1204
LocalGetWindowPlacement
static Point LocalGetWindowPlacement(const WindowDesc *desc, int16 sm_width, int16 sm_height, int window_number)
Compute the position of the top-left corner of a new window that is opened.
Definition: window.cpp:1689
ND_SCROLLBAR_DOWN
@ ND_SCROLLBAR_DOWN
Bit value of the 'scrollbar down' flag.
Definition: widget_type.h:302
NWID_HSCROLLBAR
@ NWID_HSCROLLBAR
Horizontal scrollbar.
Definition: widget_type.h:81
WC_COMPANY_COLOUR
@ WC_COMPANY_COLOUR
Company colour selection; Window numbers:
Definition: window_type.h:222
Blitter
How all blitters should look like.
Definition: base.hpp:28
IniLoadWindowSettings
void IniLoadWindowSettings(IniFile &ini, const char *grpname, void *desc)
Load a WindowDesc from config.
Definition: settings.cpp:780
Window::InitializePositionSize
void InitializePositionSize(int x, int y, int min_width, int min_height)
Set the position and smallest size of the window.
Definition: window.cpp:1439
HandleScrollbarScrolling
static void HandleScrollbarScrolling(Window *w)
Handle scrollbar scrolling with the mouse.
Definition: window.cpp:2334
HandleTextInput
void HandleTextInput(const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end)
Handle text input.
Definition: window.cpp:2680
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
WC_SELECT_GAME
@ WC_SELECT_GAME
Select game window; Window numbers:
Definition: window_type.h:434
Viewport::width
int width
Screen width of the viewport.
Definition: viewport_type.h:25
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:282
PHD_DOWN
@ PHD_DOWN
Below v is a safe position.
Definition: window.cpp:1982
WF_DISABLE_VP_SCROLL
@ WF_DISABLE_VP_SCROLL
Window does not do autoscroll,.
Definition: window_gui.h:241
Window::viewport
ViewportData * viewport
Pointer to viewport data, if present.
Definition: window_gui.h:321
_newgrf_debug_sprite_picker
NewGrfDebugSpritePicker _newgrf_debug_sprite_picker
The sprite picker.
Definition: newgrf_debug_gui.cpp:48
Viewport::height
int height
Screen height of the viewport.
Definition: viewport_type.h:26
WWT_DEFSIZEBOX
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX)
Definition: widget_type.h:63
Window::CreateNestedTree
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1760
NewGrfDebugSpritePicker::sprites
std::vector< SpriteID > sprites
Sprites found.
Definition: newgrf_debug.h:29
WDP_ALIGN_TOOLBAR
@ WDP_ALIGN_TOOLBAR
Align toward the toolbar.
Definition: window_gui.h:158
InitWindowSystem
void InitWindowSystem()
(re)initialize the windowing system
Definition: window.cpp:1825
NewGrfDebugSpritePicker::mode
NewGrfDebugSpritePickerMode mode
Current state.
Definition: newgrf_debug.h:27
Window::OnGameTick
virtual void OnGameTick()
Called once per (game) tick.
Definition: window_gui.h:687
Viewport::top
int top
Screen coordinate top edge of the viewport.
Definition: viewport_type.h:24
WF_STICKY
@ WF_STICKY
Window is made sticky by user.
Definition: window_gui.h:240
UpdateWindows
void UpdateWindows()
Update the continuously changing contents of the windows, such as the viewports.
Definition: window.cpp:3042
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1146
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
InitNewsItemStructs
void InitNewsItemStructs()
Initialize the news-items data structures.
Definition: news_gui.cpp:614
StartWindowSizing
static void StartWindowSizing(Window *w, bool to_left)
Start resizing a window.
Definition: window.cpp:2317
PerformanceMeasurer
RAII class for measuring simple elements of performance.
Definition: framerate_type.h:92
BringWindowToFront
static void BringWindowToFront(Window *w, bool dirty=true)
On clicking on a window, make it the frontmost window of all windows with an equal or lower z-priorit...
Definition: window.cpp:1377
valid
uint8 valid
Bits indicating what variable is valid (for each bit, 0 is invalid, 1 is valid).
Definition: newgrf_station.cpp:248
WDF_NO_FOCUS
@ WDF_NO_FOCUS
This window won't get focus/make any other window lose focus when click.
Definition: window_gui.h:212
UnInitWindowSystem
void UnInitWindowSystem()
Close down the windowing system.
Definition: window.cpp:1844
VA_DISABLED
@ VA_DISABLED
Do not autoscroll when mouse is at edge of viewport.
Definition: window.cpp:46
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:35
GUISettings::window_soft_limit
uint8 window_soft_limit
soft limit of maximum number of non-stickied non-vital windows (0 = no limit)
Definition: settings_type.h:128
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:250
vehicle_base.h
Window::OnInvalidateData
virtual void OnInvalidateData(int data=0, bool gui_scope=true)
Some data on this window has become invalid.
Definition: window_gui.h:741
zoom_func.h
WC_BOOTSTRAP
@ WC_BOOTSTRAP
Bootstrap; Window numbers:
Definition: window_type.h:635
Window::RaiseButtons
void RaiseButtons(bool autoraise=false)
Raise the buttons of the window.
Definition: window.cpp:584
WC_GENERATE_LANDSCAPE
@ WC_GENERATE_LANDSCAPE
Generate landscape (newgame); Window numbers:
Definition: window_type.h:448
WC_MESSAGE_HISTORY
@ WC_MESSAGE_HISTORY
News history list; Window numbers:
Definition: window_type.h:264
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:52
Window::SetWidgetHighlight
void SetWidgetHighlight(byte widget_index, TextColour highlighted_colour)
Sets the highlighted status of a widget.
Definition: window.cpp:243
WC_OSK
@ WC_OSK
On Screen Keyboard; Window numbers:
Definition: window_type.h:154
WindowDesc::cls
WindowClass cls
Class of the window,.
Definition: window_gui.h:177
SZSP_HORIZONTAL
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
Definition: widget_type.h:422
VSM_VIEWPORT_RMB_FIXED
@ VSM_VIEWPORT_RMB_FIXED
Viewport moves with mouse movement on holding right mouse button, cursor position is fixed.
Definition: settings_type.h:95
WWT_EMPTY
@ WWT_EMPTY
Empty widget, place holder to reserve space in widget array.
Definition: widget_type.h:46
Window::OnTimeout
virtual void OnTimeout()
Called when this window's timeout has been reached.
Definition: window_gui.h:704
newgrf_debug.h
Window::owner
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition: window_gui.h:319
NWidgetBase::FillNestedArray
virtual void FillNestedArray(NWidgetBase **array, uint length)=0
Window::OnDropdownClose
virtual void OnDropdownClose(Point pt, int widget, int index, bool instant_close)
A dropdown window associated to this window has been closed.
Definition: window.cpp:293
WindowNumber
int32 WindowNumber
Number to differentiate different windows of the same class.
Definition: window_type.h:711
WC_COMPANY
@ WC_COMPANY
Company view; Window numbers:
Definition: window_type.h:361
NWidgetCore::tool_tip
StringID tool_tip
Tooltip of the widget.
Definition: widget_type.h:336
NWidgetCore::SetLowered
void SetLowered(bool lowered)
Lower or raise the widget.
Definition: widget_type.h:369
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:221
QueryString::GetCharAtPosition
const char * GetCharAtPosition(const Window *w, int wid, const Point &pt) const
Get the character that is rendered at a position.
Definition: misc_gui.cpp:911
Window::HandleButtonClick
void HandleButtonClick(byte widget)
Do all things to make a button look clicked and mark it to be unclicked in a few ticks.
Definition: window.cpp:646
Window::GetCaretPosition
virtual Point GetCaretPosition() const
Get the current caret position if an edit box has the focus.
Definition: window.cpp:401
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
NWidgetBase::smallest_y
uint smallest_y
Smallest vertical size of the widget in a filled window.
Definition: widget_type.h:184
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:629
GUISettings::toolbar_pos
uint8 toolbar_pos
position of toolbars, 0=left, 1=center, 2=right
Definition: settings_type.h:125
EditBoxInGlobalFocus
bool EditBoxInGlobalFocus()
Check if an edit box is in global focus.
Definition: window.cpp:468
HandleAutoscroll
static void HandleAutoscroll()
If needed and switched on, perform auto scrolling (automatically moving window contents when mouse is...
Definition: window.cpp:2699
Window::OnHotkey
virtual EventState OnHotkey(int hotkey)
A hotkey has been pressed.
Definition: window.cpp:621
StartWindowDrag
static void StartWindowDrag(Window *w)
Start window dragging.
Definition: window.cpp:2299
IsLocalCompany
static bool IsLocalCompany()
Is the current company the local company?
Definition: company_func.h:43
HandleKeypress
void HandleKeypress(uint keycode, WChar key)
Handle keyboard input.
Definition: window.cpp:2594
Window::Window
Window(WindowDesc *desc)
Empty constructor, initialization has been moved to InitNested() called from the constructor of the d...
Definition: window.cpp:1799
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:971
Textbuf::InsertString
bool InsertString(const char *str, bool marked, const char *caret=nullptr, const char *insert_location=nullptr, const char *replacement_end=nullptr)
Insert a string into the text buffer.
Definition: textbuf.cpp:162
Window::nested_focus
const NWidgetCore * nested_focus
Currently focused nested widget, or nullptr if no nested widget has focus.
Definition: window_gui.h:322
QueryString
Data stored about a string that can be modified in the GUI.
Definition: querystring_gui.h:20
GetWindowZPriority
static uint GetWindowZPriority(WindowClass wc)
Get the z-priority for a given window.
Definition: window.cpp:1296
WC_GRF_PARAMETERS
@ WC_GRF_PARAMETERS
NewGRF parameters; Window numbers:
Definition: window_type.h:173
Window::scheduled_invalidation_data
std::vector< int > scheduled_invalidation_data
Data of scheduled OnInvalidateData() calls.
Definition: window_gui.h:288
Window::IsWidgetHighlighted
bool IsWidgetHighlighted(byte widget_index) const
Gets the highlighted status of a widget.
Definition: window.cpp:276
WC_SAVE_PRESET
@ WC_SAVE_PRESET
Save preset; Window numbers:
Definition: window_type.h:678
Window::GetCaret
virtual const char * GetCaret() const
Get the string at the caret if an edit box has the focus.
Definition: window.cpp:374
Window::OnCTRLStateChange
virtual EventState OnCTRLStateChange()
The state of the control key has changed.
Definition: window_gui.h:609
Window::GetTextCharacterAtPosition
virtual const char * GetTextCharacterAtPosition(const Point &pt) const
Get the character that is rendered at a position by the focused edit box.
Definition: window.cpp:432
Window::querystrings
SmallMap< int, QueryString * > querystrings
QueryString associated to WWT_EDITBOX widgets.
Definition: window_gui.h:323
SmallMap
Implementation of simple mapping class.
Definition: smallmap_type.hpp:26
WC_HIGHSCORE
@ WC_HIGHSCORE
Highscore; Window numbers:
Definition: window_type.h:641
NetworkReInitChatBoxSize
void NetworkReInitChatBoxSize()
Initialize all font-dependent chat box sizes.
Definition: network_chat_gui.cpp:106
Window::ProcessScheduledInvalidations
void ProcessScheduledInvalidations()
Process all scheduled invalidations.
Definition: window.cpp:3171
WindowDesc::default_width_trad
int16 default_width_trad
Preferred initial width of the window (pixels at 1x zoom).
Definition: window_gui.h:196
PHD_UP
@ PHD_UP
Above v is a safe position.
Definition: window.cpp:1981
gfx_func.h
WindowDesc::default_pos
WindowPosition default_pos
Preferred position of the window.
Definition: window_gui.h:176
WindowDesc
High level window description.
Definition: window_gui.h:168
WC_MODAL_PROGRESS
@ WC_MODAL_PROGRESS
Progress report of landscape generation; Window numbers:
Definition: window_type.h:455
SetWindowWidgetDirty
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting)
Definition: window.cpp:3133
WF_SIZING_LEFT
@ WF_SIZING_LEFT
Window is being resized towards the left.
Definition: window_gui.h:238
NWidgetLeaf::InvalidateDimensionCache
static void InvalidateDimensionCache()
Reset the cached dimensions.
Definition: widget.cpp:2291
PositionStatusbar
int PositionStatusbar(Window *w)
(Re)position statusbar window at the screen.
Definition: window.cpp:3393
Window::SetShaded
void SetShaded(bool make_shaded)
Set the shaded state of the window to make_shaded.
Definition: window.cpp:1040
Window::GetWidget
const NWID * GetWidget(uint widnum) const
Get the nested widget with number widnum from the nested widget tree.
Definition: window_gui.h:908
ND_DROPDOWN_ACTIVE
@ ND_DROPDOWN_ACTIVE
Bit value of the 'dropdown active' flag.
Definition: widget_type.h:300
Scrollbar::UpdatePosition
bool UpdatePosition(int difference, ScrollbarStepping unit=SS_SMALL)
Updates the position of the first visible element by the given amount.
Definition: widget_type.h:758
GUISettings::scrollwheel_scrolling
uint8 scrollwheel_scrolling
scrolling using the scroll wheel?
Definition: settings_type.h:141
WC_CONFIRM_POPUP_QUERY
@ WC_CONFIRM_POPUP_QUERY
Popup with confirm question; Window numbers:
Definition: window_type.h:122
Window::OnFocusLost
virtual void OnFocusLost()
Called when window loses focus.
Definition: window.cpp:535
MayBeShown
static bool MayBeShown(const Window *w)
Returns whether a window may be shown or not.
Definition: window.cpp:880
PositionNewsMessage
int PositionNewsMessage(Window *w)
(Re)position news message window at the screen.
Definition: window.cpp:3404
WC_QUERY_STRING
@ WC_QUERY_STRING
Query string window; Window numbers:
Definition: window_type.h:115
Viewport
Data structure for viewport, display of a part of the world.
Definition: viewport_type.h:22
GUITimer
Definition: guitimer_func.h:13
Window::UnfocusFocusedWidget
void UnfocusFocusedWidget()
Makes no widget on this window have focus.
Definition: window.cpp:490
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:156
WindowDesc::ini_key
const char * ini_key
Key to store window defaults in openttd.cfg. nullptr if nothing shall be stored.
Definition: window_gui.h:179
ChangeVehicleViewports
void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index)
Switches viewports following vehicles, which get autoreplaced.
Definition: window.cpp:3427
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:317
_input_events_this_tick
static int _input_events_this_tick
Local counter that is incremented each time an mouse input event is detected.
Definition: window.cpp:2693
WSM_PRESIZE
@ WSM_PRESIZE
Presizing mode (docks, tunnels).
Definition: window_gui.h:968
ST_SMALLEST
@ ST_SMALLEST
Initialize nested widget tree to smallest size. Also updates current_x and current_y.
Definition: widget_type.h:112
GuiShowTooltips
void GuiShowTooltips(Window *parent, StringID str, uint paramcount, const uint64 params[], TooltipCloseCondition close_tooltip)
Shows a tooltip.
Definition: misc_gui.cpp:767
settings_func.h
Scrollbar::GetCount
uint16 GetCount() const
Gets the number of elements in the list.
Definition: widget_type.h:653
tilehighlight_func.h
WC_BUY_COMPANY
@ WC_BUY_COMPANY
Buyout company (merger); Window numbers:
Definition: window_type.h:575
DescSorter
static bool DescSorter(WindowDesc *const &a, WindowDesc *const &b)
Sort WindowDesc by ini_key.
Definition: window.cpp:167
Window::InitNested
void InitNested(WindowNumber number=0)
Perform complete initialization of the Window with nested widgets, to allow use.
Definition: window.cpp:1789
Window::ProcessHighlightedInvalidations
void ProcessHighlightedInvalidations()
Process all invalidation of highlighted widgets.
Definition: window.cpp:3183
CloseNonVitalWindows
void CloseNonVitalWindows()
Try to close a non-vital window.
Definition: window.cpp:3260
WWT_EDITBOX
@ WWT_EDITBOX
a textbox for typing
Definition: widget_type.h:69
ReInitAllWindows
void ReInitAllWindows(bool zoom_changed)
Re-initialize all windows.
Definition: window.cpp:3331
NWidgetBase::type
WidgetType type
Type of the widget / nested widget.
Definition: widget_type.h:175
TileHighlightData::window_number
WindowNumber window_number
The WindowNumber of the window that is responsible for the selection mode.
Definition: tilehighlight_type.h:69
TIME_BETWEEN_DOUBLE_CLICK
const std::chrono::milliseconds TIME_BETWEEN_DOUBLE_CLICK(500)
Time between 2 left clicks before it becoming a double click.
Window::height
int height
Height of the window (number of pixels down in y direction)
Definition: window_gui.h:315
_toolbar_width
uint _toolbar_width
Width of the toolbar, shared by statusbar.
Definition: toolbar_gui.cpp:63
WF_CENTERED
@ WF_CENTERED
Window is centered and shall stay centered after ReInit.
Definition: window_gui.h:244
WF_WHITE_BORDER
@ WF_WHITE_BORDER
Window white border counter bit mask.
Definition: window_gui.h:242
SpecialMouseMode
SpecialMouseMode
Mouse modes.
Definition: window_gui.h:964
INVALID_VEHICLE
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:55
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:993
Viewport::left
int left
Screen coordinate left edge of the viewport.
Definition: viewport_type.h:23
NWidgetBase::smallest_x
uint smallest_x
Smallest horizontal size of the widget in a filled window.
Definition: widget_type.h:183
SBI_NEWS_DELETED
@ SBI_NEWS_DELETED
abort current news display (active news were deleted)
Definition: statusbar_gui.h:19
NWidgetBase::AssignSizePosition
virtual void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl)=0
IsInsideBS
static bool IsInsideBS(const T x, const size_t base, const size_t size)
Checks if a value is between a window started at some base point.
Definition: math_func.hpp:188
QueryString::GetBoundingRect
Rect GetBoundingRect(const Window *w, int wid, const char *from, const char *to) const
Get the bounding rectangle for a range of the query string.
Definition: misc_gui.cpp:874
NWidgetBase::GetWidgetOfType
virtual NWidgetBase * GetWidgetOfType(WidgetType tp)
Retrieve a widget by its type.
Definition: widget.cpp:827
INVALID_OWNER
@ INVALID_OWNER
An invalid owner.
Definition: company_type.h:29
Window::OnFocus
virtual void OnFocus()
Called when window gains focus.
Definition: window.cpp:527
IniFile::SaveToDisk
bool SaveToDisk(const std::string &filename)
Save the Ini file's data to the disk.
Definition: ini.cpp:46
ES_NOT_HANDLED
@ ES_NOT_HANDLED
The passed event is not handled.
Definition: window_type.h:719
DispatchMouseWheelEvent
static void DispatchMouseWheelEvent(Window *w, NWidgetCore *nwid, int wheel)
Dispatch the mousewheel-action to the window.
Definition: window.cpp:849
NWidgetBase
Baseclass for nested widgets.
Definition: widget_type.h:126
RelocateAllWindows
void RelocateAllWindows(int neww, int newh)
Relocate all windows to fit the new size of the game application screen.
Definition: window.cpp:3443
Window::HandleEditBoxKey
EventState HandleEditBoxKey(int wid, WChar key, uint16 keycode)
Process keypress for editbox widget.
Definition: window.cpp:2521
GetAutoPlacePosition
static Point GetAutoPlacePosition(int width, int height)
Find a good place for opening a new window of a given width and height.
Definition: window.cpp:1596
PreventHiding
static void PreventHiding(int *nx, int *ny, const Rect &rect, const Window *v, int px, PreventHideDirection dir)
Do not allow hiding of the rectangle with base coordinates nx and ny behind window v.
Definition: window.cpp:1995
GetWidgetFromPos
int GetWidgetFromPos(const Window *w, int x, int y)
Returns the index for the widget located at the given position relative to the window.
Definition: widget.cpp:194
Window::DisableAllWidgetHighlight
void DisableAllWidgetHighlight()
Disable the highlighted status of all widgets.
Definition: window.cpp:223
_pause_mode
PauseMode _pause_mode
The current pause mode.
Definition: gfx.cpp:47
GetMainViewTop
int GetMainViewTop()
Return the top of the main view available for general use.
Definition: window.cpp:2105
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:53
BlitterFactory::GetCurrentBlitter
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition: factory.hpp:141
Window::GetQueryString
const QueryString * GetQueryString(uint widnum) const
Return the querystring associated to a editbox.
Definition: window.cpp:340
Window::OnDropdownSelect
virtual void OnDropdownSelect(int widget, int index)
A dropdown option associated to this window has been selected.
Definition: window_gui.h:718
DrawOverlappedWindow
static void DrawOverlappedWindow(Window *w, int left, int top, int right, int bottom)
Generate repaint events for the visible part of window w within the rectangle.
Definition: window.cpp:908
WindowDesc::GetDefaultWidth
int16 GetDefaultWidth() const
Determine default width of window.
Definition: window.cpp:136
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:141
Window::SetWidgetDisabledState
void SetWidgetDisabledState(byte widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition: window_gui.h:386
Window::DeleteClosedWindows
static void DeleteClosedWindows()
Delete all closed windows.
Definition: window.cpp:65
Window::parent
Window * parent
Parent window.
Definition: window_gui.h:332
CallWindowGameTickEvent
void CallWindowGameTickEvent()
Dispatch OnGameTick event over all windows.
Definition: window.cpp:3247
safeguards.h
GetToolbarAlignedWindowPosition
Point GetToolbarAlignedWindowPosition(int window_width)
Computer the position of the top-left corner of a window to be opened right under the toolbar.
Definition: window.cpp:1664
GUISettings::hover_delay_ms
uint16 hover_delay_ms
time required to activate a hover event, in milliseconds
Definition: settings_type.h:114
Window::left
int left
x position of left edge of the window
Definition: window_gui.h:312
Window::OnDragDrop
virtual void OnDragDrop(Point pt, int widget)
A dragged 'object' has been released.
Definition: window_gui.h:656
Window::flags
WindowFlags flags
Window flags.
Definition: window_gui.h:305
_z_windows
WindowList _z_windows
List of windows opened at the screen sorted from the front to back.
Definition: window.cpp:57
WF_TIMEOUT
@ WF_TIMEOUT
Window timeout counter.
Definition: window_gui.h:234
CursorVars::fix_at
bool fix_at
mouse is moving, but cursor is not (used for scrolling)
Definition: gfx_type.h:120
WC_SHIPS_LIST
@ WC_SHIPS_LIST
Ships list; Window numbers:
Definition: window_type.h:312
WindowClass
WindowClass
Window classes.
Definition: window_type.h:36
WWT_LAST
@ WWT_LAST
Last Item. use WIDGETS_END to fill up padding!!
Definition: widget_type.h:70
Window::ShowNewGRFInspectWindow
virtual void ShowNewGRFInspectWindow() const
Show the NewGRF inspection window.
Definition: window_gui.h:807
HandleCtrlChanged
void HandleCtrlChanged()
State of CONTROL key has changed.
Definition: window.cpp:2650
_mouse_hovering
bool _mouse_hovering
The mouse is hovering over the same point.
Definition: window.cpp:91
WindowDesc::default_height_trad
int16 default_height_trad
Preferred initial height of the window (pixels at 1x zoom).
Definition: window_gui.h:197
IConsoleResize
void IConsoleResize(Window *w)
Change the size of the in-game console window after the screen size changed, or the window state chan...
Definition: console_gui.cpp:420
_shift_pressed
bool _shift_pressed
Is Shift pressed?
Definition: gfx.cpp:36
CursorVars::wheel
int wheel
mouse wheel movement
Definition: gfx_type.h:119
PositionWindow
static int PositionWindow(Window *w, WindowClass clss, int setting)
(Re)position a window at the screen.
Definition: window.cpp:3359
HandleMouseOver
static void HandleMouseOver()
Report position of the mouse to the underlying window.
Definition: window.cpp:1954
DrawDirtyBlocks
void DrawDirtyBlocks()
Repaints the rectangle blocks which are marked as 'dirty'.
Definition: gfx.cpp:1557
NDB_SCROLLBAR_UP
@ NDB_SCROLLBAR_UP
Up-button is lowered bit.
Definition: widget_type.h:289
WDF_MODAL
@ WDF_MODAL
The window is a modal child of some other window, meaning the parent is 'inactive'.
Definition: window_gui.h:211
settings_type.h
PFE_DRAWING
@ PFE_DRAWING
Speed of drawing world and GUI.
Definition: framerate_type.h:57
VSM_MAP_RMB_FIXED
@ VSM_MAP_RMB_FIXED
Map moves with mouse movement on holding right mouse button, cursor position is fixed.
Definition: settings_type.h:96
WindowDesc::GetDefaultHeight
int16 GetDefaultHeight() const
Determine default height of window.
Definition: window.cpp:146
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
WF_HIGHLIGHTED
@ WF_HIGHLIGHTED
Window has a widget that has a highlight.
Definition: window_gui.h:243
ScrollMainWindowTo
bool ScrollMainWindowTo(int x, int y, int z, bool instant)
Scrolls the main window to given coordinates.
Definition: smallmap_gui.cpp:1879
WindowDesc::nwid_parts
const NWidgetPart * nwid_parts
Nested widget parts describing the window.
Definition: window_gui.h:181
FocusedWindowIsConsole
bool FocusedWindowIsConsole()
Check if a console is focused.
Definition: window.cpp:482
error.h
ViewportData::dest_scrollpos_y
int32 dest_scrollpos_y
Current destination y coordinate to display (virtual screen coordinate of topleft corner of the viewp...
Definition: window_gui.h:263
WC_TRAINS_LIST
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition: window_type.h:300
WSM_DRAGDROP
@ WSM_DRAGDROP
Drag&drop an object.
Definition: window_gui.h:966
Window::OnInit
virtual void OnInit()
Notification that the nested widget tree gets initialized.
Definition: window_gui.h:537
Window::unshaded_size
Dimension unshaded_size
Last known unshaded size (only valid while shaded).
Definition: window_gui.h:328
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:59
WindowDesc::SaveToConfig
static void SaveToConfig()
Save all WindowDesc settings to _windows_file.
Definition: window.cpp:176
Window::SetFocusedWidget
bool SetFocusedWidget(int widget_index)
Set focus within this window to the given widget.
Definition: window.cpp:506
stdafx.h
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:307
RoundDivSU
static int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
Definition: math_func.hpp:276
ResizeInfo::step_height
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:220
WindowDesc::WindowDesc
WindowDesc(WindowPosition default_pos, const char *ini_key, int16 def_width_trad, int16 def_height_trad, WindowClass window_class, WindowClass parent_class, uint32 flags, const NWidgetPart *nwid_parts, int16 nwid_length, HotkeyList *hotkeys=nullptr)
Window description constructor.
Definition: window.cpp:105
Window::InvalidateData
void InvalidateData(int data=0, bool gui_scope=true)
Mark this window's data as invalid (in need of re-computing)
Definition: window.cpp:3158
VideoDriver::GetInstance
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
Definition: video_driver.hpp:199
NWidgetStacked::SetDisplayedPlane
void SetDisplayedPlane(int plane)
Select which plane to show (for NWID_SELECTION only).
Definition: widget.cpp:1195
viewport_func.h
Window::mouse_capture_widget
int mouse_capture_widget
Widgetindex of current mouse capture widget (e.g. dragged scrollbar). -1 if no widget has mouse captu...
Definition: window_gui.h:330
NWidgetBase::current_y
uint current_y
Current vertical size (after resizing).
Definition: widget_type.h:187
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:37
HandleMouseEvents
void HandleMouseEvents()
Handle a mouse event from the video driver.
Definition: window.cpp:2900
Window::AllWindows
Iterable ensemble of all valid Windows.
Definition: window_gui.h:859
GUISettings::statusbar_pos
uint8 statusbar_pos
position of statusbar, 0=left, 1=center, 2=right
Definition: settings_type.h:126
Window::nested_array
NWidgetBase ** nested_array
Array of pointers into the tree. Do not access directly, use Window::GetWidget() instead.
Definition: window_gui.h:325
WidgetType
WidgetType
Window widget types, nested widget types, and nested widget part types.
Definition: widget_type.h:44
Window::OnPlacePresize
virtual void OnPlacePresize(Point pt, TileIndex tile)
The user moves over the map when a tile highlight mode has been set when the special mouse mode has b...
Definition: window_gui.h:791
QueryString::GetCaret
const char * GetCaret() const
Get the position of the caret in the text buffer.
Definition: querystring_gui.h:72
WWT_CLOSEBOX
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition: widget_type.h:67
WWT_RESIZEBOX
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:66
NWidgetBase::GetWidgetFromPos
virtual NWidgetCore * GetWidgetFromPos(int x, int y)=0
DispatchRightClickEvent
static void DispatchRightClickEvent(Window *w, int x, int y)
Dispatch right mouse-button click in window.
Definition: window.cpp:795
IsGoodAutoPlace2
static bool IsGoodAutoPlace2(int left, int top, int width, int height, int toolbar_y, Point &pos)
Decide whether a given rectangle is a good place to open a mostly visible new window.
Definition: window.cpp:1557
HandleViewportScroll
static EventState HandleViewportScroll()
Handle viewport scrolling with the mouse.
Definition: window.cpp:2401
Window::OnClick
virtual void OnClick(Point pt, int widget, int click_count)
A click with the left mouse button has been made on the window.
Definition: window_gui.h:618
Textbuf::bytes
uint16 bytes
the current size of the string in bytes (including terminating '\0')
Definition: textbuf_type.h:35
_windows_file
std::string _windows_file
Config file to store WindowDesc.
Definition: window.cpp:102
QueryString::cancel_button
int cancel_button
Widget button of parent window to simulate when pressing CANCEL in OSK.
Definition: querystring_gui.h:28
VA_EVERY_VIEWPORT
@ VA_EVERY_VIEWPORT
Scroll all viewports at their edges.
Definition: window.cpp:49
WC_GAME_OPTIONS
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition: window_type.h:604
Clamp
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:77
Window::OnMouseLoop
virtual void OnMouseLoop()
Called for every mouse loop run, which is at least once per (game) tick.
Definition: window_gui.h:682
strings_func.h
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:82
ScaleByZoom
static int ScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift left (when zoom > ZOOM_LVL_NORMAL) When shifting right,...
Definition: zoom_func.h:22
ResizeInfo::step_width
uint step_width
Step-size of width resize changes.
Definition: window_gui.h:219
VSM_MAP_LMB
@ VSM_MAP_LMB
Map moves with mouse movement on holding left mouse button, cursor moves.
Definition: settings_type.h:98
NWidgetCore::disp_flags
NWidgetDisplay disp_flags
Flags that affect display and interaction with the widget.
Definition: widget_type.h:332
MAX_OFFSET_DOUBLE_CLICK
@ MAX_OFFSET_DOUBLE_CLICK
How much the mouse is allowed to move to call it a double click.
Definition: window.cpp:2738
Window::OnMouseWheel
virtual void OnMouseWheel(int wheel)
The mouse wheel has been turned.
Definition: window_gui.h:676
IniFile
Ini file that supports both loading and saving.
Definition: ini_type.h:89
WindowDesc::flags
uint32 flags
Flags.
Definition: window_gui.h:180
Window::IsShaded
bool IsShaded() const
Is window shaded currently?
Definition: window_gui.h:520
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:189
ST_RESIZE
@ ST_RESIZE
Resize the nested widget tree.
Definition: widget_type.h:113
Blitter::MoveTo
virtual void * MoveTo(void *video, int x, int y)=0
Move the destination pointer the requested amount x and y, keeping in mind any pitch and bpp of the r...
HideDropDownMenu
int HideDropDownMenu(Window *pw)
Delete the drop-down menu from window pw.
Definition: dropdown.cpp:498
DeleteAllMessages
void DeleteAllMessages()
Delete all messages and close their corresponding window (if any).
Definition: window.cpp:3299
WIDGET_LIST_END
static const int WIDGET_LIST_END
indicate the end of widgets' list for vararg functions
Definition: widget_type.h:20
ViewportAutoscrolling
ViewportAutoscrolling
Values for _settings_client.gui.auto_scrolling.
Definition: window.cpp:45
Window::closed_windows
static std::vector< Window * > closed_windows
List of closed windows to delete.
Definition: window_gui.h:281
Window::CloseChildWindows
void CloseChildWindows(WindowClass wc=WC_INVALID) const
Close all children a window might have in a head-recursive manner.
Definition: window.cpp:1080
UnshowCriticalError
void UnshowCriticalError()
Unshow the critical error.
Definition: error_gui.cpp:362
VA_MAIN_VIEWPORT_FULLSCREEN
@ VA_MAIN_VIEWPORT_FULLSCREEN
Scroll main viewport at edge when using fullscreen.
Definition: window.cpp:47
WC_AI_LIST
@ WC_AI_LIST
AI list; Window numbers:
Definition: window_type.h:276
Window::SetWidgetsLoweredState
void CDECL SetWidgetsLoweredState(bool lowered_stat, int widgets,...)
Sets the lowered/raised status of a list of widgets.
Definition: window.cpp:566
WD_CAPTIONTEXT_TOP
@ WD_CAPTIONTEXT_TOP
Offset of the caption text at the top.
Definition: window_gui.h:129
FONT_HEIGHT_NORMAL
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:165
Window::OnTooltip
virtual bool OnTooltip(Point pt, int widget, TooltipCloseCondition close_cond)
Event to display a custom tooltip.
Definition: window_gui.h:642
WC_SCEN_LAND_GEN
@ WC_SCEN_LAND_GEN
Landscape generation (in Scenario Editor); Window numbers:
Definition: window_type.h:441
video_driver.hpp
DispatchHoverEvent
static void DispatchHoverEvent(Window *w, int x, int y)
Dispatch hover of the mouse over a window.
Definition: window.cpp:821
NO_DIRECTORY
@ NO_DIRECTORY
A path without any base directory.
Definition: fileio_type.h:125
ScaleGUITrad
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:76
WC_NETWORK_WINDOW
@ WC_NETWORK_WINDOW
Network window; Window numbers:
Definition: window_type.h:464
NWidgetScrollbar
Nested widget to display and control a scrollbar in a window.
Definition: widget_type.h:795
WC_CONSOLE
@ WC_CONSOLE
Console; Window numbers:
Definition: window_type.h:629
CloseWindowByClass
void CloseWindowByClass(WindowClass cls)
Close all windows of a given class.
Definition: window.cpp:1188
framerate_type.h
InvalidateWindowClassesData
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition: window.cpp:3235
Window::GetTextBoundingRect
virtual Rect GetTextBoundingRect(const char *from, const char *to) const
Get the bounding rectangle for a text range if an edit box has the focus.
Definition: window.cpp:417
WC_NETWORK_STATUS_WINDOW
@ WC_NETWORK_STATUS_WINDOW
Network status window; Window numbers:
Definition: window_type.h:477
WC_TOOLTIPS
@ WC_TOOLTIPS
Tooltip window; Window numbers:
Definition: window_type.h:108
WC_AI_SETTINGS
@ WC_AI_SETTINGS
AI settings; Window numbers:
Definition: window_type.h:167
_window_highlight_colour
bool _window_highlight_colour
If false, highlight is white, otherwise the by the widget defined colour.
Definition: window.cpp:75
Window::OnPaint
virtual void OnPaint()
The window must be repainted.
Definition: window_gui.h:554
CursorVars::delta
Point delta
relative mouse movement in this tick
Definition: gfx_type.h:118
Window::SetWidgetsDisabledState
void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets,...)
Sets the enabled/disabled status of a list of widgets.
Definition: window.cpp:547
IniSaveWindowSettings
void IniSaveWindowSettings(IniFile &ini, const char *grpname, void *desc)
Save a WindowDesc to config.
Definition: settings.cpp:791
NWidgetBase::resize_y
uint resize_y
Vertical resize step (0 means not resizable).
Definition: widget_type.h:179
Window::IsWidgetLowered
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:487
QueryString::GetMarkedText
const char * GetMarkedText(size_t *length) const
Get the currently marked text.
Definition: querystring_gui.h:82
WC_COMPANY_INFRASTRUCTURE
@ WC_COMPANY_INFRASTRUCTURE
Company infrastructure overview; Window numbers:
Definition: window_type.h:568
HKPR_CANCEL
@ HKPR_CANCEL
Escape key pressed.
Definition: textbuf_type.h:25
WID_OSK_CANCEL
@ WID_OSK_CANCEL
Cancel key.
Definition: osk_widget.h:17
VpHandlePlaceSizingDrag
EventState VpHandlePlaceSizingDrag()
Handle the mouse while dragging for placement/resizing.
Definition: viewport.cpp:3306
Window::OnMouseOver
virtual void OnMouseOver(Point pt, int widget)
The mouse is currently moving over the window or has just moved outside of the window.
Definition: window_gui.h:670
EventState
EventState
State of handling an event.
Definition: window_type.h:717
UpdateViewportPosition
void UpdateViewportPosition(Window *w)
Update the viewport position being displayed.
Definition: viewport.cpp:1863
WindowDesc::pref_sticky
bool pref_sticky
Preferred stickyness.
Definition: window_gui.h:185
Scrollbar::GetPosition
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:671
WF_DRAGGING
@ WF_DRAGGING
Window is being dragged.
Definition: window_gui.h:236
WC_NETWORK_ASK_RELAY
@ WC_NETWORK_ASK_RELAY
Network ask relay window; Window numbers:
Definition: window_type.h:483
FindWindowByClass
Window * FindWindowByClass(WindowClass cls)
Find any window by its class.
Definition: window.cpp:1161
InitDepotWindowBlockSizes
void InitDepotWindowBlockSizes()
Set the size of the blocks in the window so we can be sure that they are big enough for the vehicle s...
Definition: depot_gui.cpp:215
progress.h
NetworkChatMessageLoop
void NetworkChatMessageLoop()
Check if a message is expired.
Definition: network_chat_gui.cpp:173
Window::window_class
WindowClass window_class
Window class.
Definition: window_gui.h:306
WC_MAIN_WINDOW
@ WC_MAIN_WINDOW
Main window; Window numbers:
Definition: window_type.h:43
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1776
IsGoodAutoPlace1
static bool IsGoodAutoPlace1(int left, int top, int width, int height, int toolbar_y, Point &pos)
Decide whether a given rectangle is a good place to open a completely visible new window.
Definition: window.cpp:1521
DispatchLeftClickEvent
static void DispatchLeftClickEvent(Window *w, int x, int y, int click_count)
Dispatch left mouse-button (possibly double) click in window.
Definition: window.cpp:663
WC_ENDSCREEN
@ WC_ENDSCREEN
Endscreen; Window numbers:
Definition: window_type.h:647
company_func.h
PreventHideDirection
PreventHideDirection
Direction for moving the window.
Definition: window.cpp:1980
HotkeyList::CheckMatch
int CheckMatch(uint16 keycode, bool global_only=false) const
Check if a keycode is bound to something.
Definition: hotkeys.cpp:325
QueryString::ACTION_CLEAR
static const int ACTION_CLEAR
Clear editbox.
Definition: querystring_gui.h:24
Window::top
int top
y position of top edge of the window
Definition: window_gui.h:313
abs
static T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:21
IsPtInWindowViewport
Viewport * IsPtInWindowViewport(const Window *w, int x, int y)
Is a xy position inside the viewport of the window?
Definition: viewport.cpp:400
GUITimer::Elapsed
bool Elapsed(uint delta)
Test if a timer has elapsed.
Definition: guitimer_func.h:55
VehicleID
uint32 VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
Ceil
static uint Ceil(uint a, uint b)
Computes ceil(a / b) * b for non-negative a and b.
Definition: math_func.hpp:265
NWidgetCore::scrollbar_index
int scrollbar_index
Index of an attached scrollbar.
Definition: widget_type.h:337
network.h
NWidgetBase::SetDirty
virtual void SetDirty(const Window *w) const
Mark the widget as 'dirty' (in need of repaint).
Definition: widget.cpp:807
Window::OnMouseDrag
virtual void OnMouseDrag(Point pt, int widget)
An 'object' is being dragged at the provided position, highlight the target if possible.
Definition: window_gui.h:649
ChangeWindowOwner
void ChangeWindowOwner(Owner old_owner, Owner new_owner)
Change the owner of all the windows one company can take over from another company in the case of a c...
Definition: window.cpp:1224
SmallMap::Find
std::vector< Pair >::const_iterator Find(const T &key) const
Finds given key in this map.
Definition: smallmap_type.hpp:41
WC_SEND_NETWORK_MSG
@ WC_SEND_NETWORK_MSG
Chatbox; Window numbers:
Definition: window_type.h:489
ViewportData::follow_vehicle
VehicleID follow_vehicle
VehicleID to follow if following a vehicle, INVALID_VEHICLE otherwise.
Definition: window_gui.h:259
MILLISECONDS_PER_TICK
static const uint MILLISECONDS_PER_TICK
The number of milliseconds per game tick.
Definition: gfx_type.h:310
Window::OnInitialPosition
virtual Point OnInitialPosition(int16 sm_width, int16 sm_height, int window_number)
Compute the initial position of the window.
Definition: window.cpp:1748
window_func.h
HandleActiveWidget
static EventState HandleActiveWidget()
Handle active widget (mouse draggin on widget) with the mouse.
Definition: window.cpp:2368
Debug
#define Debug(name, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
Window::width
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:314
WindowDesc::LoadFromConfig
static void LoadFromConfig()
Load all WindowDesc settings from _windows_file.
Definition: window.cpp:154
Viewport::zoom
ZoomLevel zoom
The zoom level of the viewport.
Definition: viewport_type.h:33
DrawOverlappedWindowForAll
void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)
From a rectangle that needs redrawing, find the windows that intersect with the rectangle.
Definition: window.cpp:970
ViewportData::dest_scrollpos_x
int32 dest_scrollpos_x
Current destination x coordinate to display (virtual screen coordinate of topleft corner of the viewp...
Definition: window_gui.h:262
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1689
WD_CAPTIONTEXT_BOTTOM
@ WD_CAPTIONTEXT_BOTTOM
Offset of the caption text at the bottom.
Definition: window_gui.h:130
WDP_MANUAL
@ WDP_MANUAL
Manually align the window (so no automatic location finding)
Definition: window_gui.h:155
TileHighlightData::window_class
WindowClass window_class
The WindowClass of the window that is responsible for the selection mode.
Definition: tilehighlight_type.h:68
HandleMouseDragDrop
static EventState HandleMouseDragDrop()
Handle dragging and dropping in mouse dragging mode (WSM_DRAGDROP).
Definition: window.cpp:1930
IConsoleClose
void IConsoleClose()
Close the in-game console.
Definition: console_gui.cpp:454
_drag_delta
static Point _drag_delta
delta between mouse cursor and upper left corner of dragged window
Definition: window.cpp:52
_dragging_window
static bool _dragging_window
A window is being dragged or resized.
Definition: window.cpp:2122
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1176
NWidgetBase::pos_y
int pos_y
Vertical position of top-left corner of the widget in the window.
Definition: widget_type.h:190
ND_SCROLLBAR_UP
@ ND_SCROLLBAR_UP
Bit value of the 'scrollbar up' flag.
Definition: widget_type.h:301
NetworkDrawChatMessage
void NetworkDrawChatMessage()
Draw the chat message-box.
Definition: network_chat_gui.cpp:187
Window::InsertTextString
virtual void InsertTextString(int wid, const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end)
Insert a text string at the cursor position into the edit box widget.
Definition: window.cpp:2663
QueryString::GetCaretPosition
Point GetCaretPosition(const Window *w, int wid) const
Get the current caret position.
Definition: misc_gui.cpp:844
_window_descs
static std::vector< WindowDesc * > * _window_descs
List of all WindowDescs.
Definition: window.cpp:99
Window::window_desc
WindowDesc * window_desc
Window description.
Definition: window_gui.h:304
console_gui.h
PerformanceAccumulator::Reset
static void Reset(PerformanceElement elem)
Store the previous accumulator value and reset for a new cycle of accumulating measurements.
Definition: framerate_gui.cpp:305
Window::OnRealtimeTick
virtual void OnRealtimeTick(uint delta_ms)
Called periodically.
Definition: window_gui.h:699
ResetWindowSystem
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition: window.cpp:1858
ZOOM_LVL_NORMAL
@ ZOOM_LVL_NORMAL
The normal zoom level.
Definition: zoom_type.h:24
HandleWindowDragging
static EventState HandleWindowDragging()
Handle dragging/resizing of a window.
Definition: window.cpp:2128
PositionNetworkChatWindow
int PositionNetworkChatWindow(Window *w)
(Re)position network chat window at the screen.
Definition: window.cpp:3415
VideoDriver::EditBoxLostFocus
virtual void EditBoxLostFocus()
An edit box lost the input focus.
Definition: video_driver.hpp:153
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:577
GUISettings::auto_scrolling
uint8 auto_scrolling
scroll when moving mouse to the edge (see ViewportAutoscrolling)
Definition: settings_type.h:112
CloseAllNonVitalWindows
void CloseAllNonVitalWindows()
It is possible that a stickied window gets to a position where the 'close' button is outside the gami...
Definition: window.cpp:3283
WindowDesc::parent_cls
WindowClass parent_cls
Class of the parent window.
Definition: window_gui.h:178
Window
Data structure for an opened window.
Definition: window_gui.h:279
QueryString::ACTION_DESELECT
static const int ACTION_DESELECT
Deselect editbox.
Definition: querystring_gui.h:23
Window::RaiseWidget
void RaiseWidget(byte widget_index)
Marks a widget as raised.
Definition: window_gui.h:477
InputLoop
void InputLoop()
Regular call from the global game loop.
Definition: window.cpp:3007
WC_STATUS_BAR
@ WC_STATUS_BAR
Statusbar (at the bottom of your screen); Window numbers:
Definition: window_type.h:56
GUISettings::scroll_mode
uint8 scroll_mode
viewport scroll mode
Definition: settings_type.h:117
WC_NEWS_WINDOW
@ WC_NEWS_WINDOW
News window; Window numbers:
Definition: window_type.h:240
Window::OnRightClick
virtual bool OnRightClick(Point pt, int widget)
A click with the right mouse button has been made on the window.
Definition: window_gui.h:627
HasModalProgress
static bool HasModalProgress()
Check if we are currently in a modal progress state.
Definition: progress.h:17
CloseConstructionWindows
void CloseConstructionWindows()
Close all windows that are used for construction of vehicle etc.
Definition: window.cpp:3311
WC_FINANCES
@ WC_FINANCES
Finances of a company; Window numbers:
Definition: window_type.h:514
console_func.h
Window::OnScroll
virtual void OnScroll(Point delta)
Handle the request for (viewport) scrolling.
Definition: window_gui.h:662
HKPR_NOT_HANDLED
@ HKPR_NOT_HANDLED
Key does not affect editboxes.
Definition: textbuf_type.h:26
ConstructionSettings::command_pause_level
uint8 command_pause_level
level/amount of commands that can't be executed while paused
Definition: settings_type.h:347
WC_ERRMSG
@ WC_ERRMSG
Error message; Window numbers:
Definition: window_type.h:102
Window::nested_array_size
uint nested_array_size
Size of the nested array.
Definition: window_gui.h:326
free
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: stdafx.h:460
NWidgetCore::index
int index
Index of the nested widget in the widget array of the window (-1 means 'not used').
Definition: widget_type.h:334
NWidgetCore
Base class for a 'real' widget.
Definition: widget_type.h:311
_last_scroll_window
static Window * _last_scroll_window
Window of the last scroll event.
Definition: window.cpp:54
Window::SetWidgetDirty
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:608
NWidgetLeaf::closebox_dimension
static Dimension closebox_dimension
Cached size of a closebox widget.
Definition: widget_type.h:828
IniLoadFile::LoadFromDisk
void LoadFromDisk(const std::string &filename, Subdirectory subdir)
Load the Ini file's data from the disk.
Definition: ini_load.cpp:215
GetMainViewBottom
int GetMainViewBottom()
Return the bottom of the main view available for general use.
Definition: window.cpp:2116
CallWindowRealtimeTickEvent
void CallWindowRealtimeTickEvent(uint delta_ms)
Dispatch OnRealtimeTick event over all windows.
Definition: window.cpp:3032
WWT_DEBUGBOX
@ WWT_DEBUGBOX
NewGRF debug box (at top-right of a window, between WWT_CAPTION and WWT_SHADEBOX)
Definition: widget_type.h:61
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
CursorVars::pos
Point pos
logical mouse position
Definition: gfx_type.h:117
Window::LowerWidget
void LowerWidget(byte widget_index)
Marks a widget as lowered.
Definition: window_gui.h:468
WC_DROPDOWN_MENU
@ WC_DROPDOWN_MENU
Drop down menu; Window numbers:
Definition: window_type.h:148
BringWindowToFrontById
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition: window.cpp:1259
_right_button_clicked
bool _right_button_clicked
Is right mouse button clicked?
Definition: gfx.cpp:41
NWidgetBase::resize_x
uint resize_x
Horizontal resize step (0 means not resizable).
Definition: widget_type.h:178
Window::GetMarkedText
virtual const char * GetMarkedText(size_t *length) const
Get the range of the currently marked input text.
Definition: window.cpp:388
WC_MAIN_TOOLBAR
@ WC_MAIN_TOOLBAR
Main toolbar (the long bar at the top); Window numbers:
Definition: window_type.h:50
WC_SPRITE_ALIGNER
@ WC_SPRITE_ALIGNER
Sprite aligner (debug); Window numbers:
Definition: window_type.h:666
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3146
WC_AIRCRAFT_LIST
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition: window_type.h:318
Window::GetRowFromWidget
int GetRowFromWidget(int clickpos, int widget, int padding, int line_height=-1) const
Compute the row of a widget that a user clicked in.
Definition: window.cpp:212
Window::OnResize
virtual void OnResize()
Called after the window got resized.
Definition: window_gui.h:711
CMDPL_NO_CONSTRUCTION
@ CMDPL_NO_CONSTRUCTION
No construction actions may be executed.
Definition: command_type.h:423
CursorVars::in_window
bool in_window
mouse inside this window, determines drawing logic
Definition: gfx_type.h:141
CLRBITS
#define CLRBITS(x, y)
Clears several bits in a variable.
Definition: bitmath_func.hpp:166
ini_type.h
NWidgetBase::current_x
uint current_x
Current horizontal size (after resizing).
Definition: widget_type.h:186
WC_TEXTFILE
@ WC_TEXTFILE
textfile; Window numbers:
Definition: window_type.h:179
WindowDesc::hotkeys
HotkeyList * hotkeys
Hotkeys for the window.
Definition: window_gui.h:183
WC_STATION_LIST
@ WC_STATION_LIST
Station list; Window numbers:
Definition: window_type.h:294
NWidgetStacked::shown_plane
int shown_plane
Plane being displayed (for NWID_SELECTION only).
Definition: widget_type.h:454
WindowPosition
WindowPosition
How do we the window to be placed?
Definition: window_gui.h:154
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition: viewport.cpp:3423
_scrolling_viewport
bool _scrolling_viewport
A viewport is being scrolled with the mouse.
Definition: window.cpp:90
WC_SMALLMAP
@ WC_SMALLMAP
Small map; Window numbers:
Definition: window_type.h:96
WDP_CENTER
@ WDP_CENTER
Center the window.
Definition: window_gui.h:157
Window::SetWidgetLoweredState
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:447
_left_button_clicked
bool _left_button_clicked
Is left mouse button clicked?
Definition: gfx.cpp:39
WindowDesc::pref_height
int16 pref_height
User-preferred height of the window. Zero if unset.
Definition: window_gui.h:187
MaybeBringWindowToFront
static bool MaybeBringWindowToFront(Window *w)
Check if a window can be made relative top-most window, and if so do it.
Definition: window.cpp:2461
Textbuf::DeleteAll
void CDECL void DeleteAll()
Delete every character in the textbuffer.
Definition: textbuf.cpp:116
TD_RTL
@ TD_RTL
Text is written right-to-left by default.
Definition: strings_type.h:24
network_func.h
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:48
MakeWindowNWidgetTree
NWidgetContainer * MakeWindowNWidgetTree(const NWidgetPart *parts, int count, int *biggest_index, NWidgetStacked **shade_select)
Make a nested widget tree for a window from a parts array.
Definition: widget.cpp:3037
Window::white_border_timer
uint8 white_border_timer
Timer value of the WF_WHITE_BORDER for flags.
Definition: window_gui.h:310
EnsureVisibleCaption
static void EnsureVisibleCaption(Window *w, int nx, int ny)
Make sure at least a part of the caption bar is still visible by moving the window if necessary.
Definition: window.cpp:2033
_right_button_down
bool _right_button_down
Is right mouse button pressed?
Definition: gfx.cpp:40
ND_SCROLLBAR_BTN
@ ND_SCROLLBAR_BTN
Bit value of the 'scrollbar up' or 'scrollbar down' flag.
Definition: widget_type.h:303
PFE_DRAWWORLD
@ PFE_DRAWWORLD
Time spent drawing world viewports in GUI.
Definition: framerate_type.h:58
GUISettings::window_snap_radius
uint8 window_snap_radius
windows snap at each other if closer than this
Definition: settings_type.h:127
WindowDesc::pref_width
int16 pref_width
User-preferred width of the window. Zero if unset.
Definition: window_gui.h:186
WC_VEHICLE_ORDERS
@ WC_VEHICLE_ORDERS
Vehicle orders; Window numbers:
Definition: window_type.h:204
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:593
VideoDriver::EditBoxGainedFocus
virtual void EditBoxGainedFocus()
An edit box gained the input focus.
Definition: video_driver.hpp:158
Window::InitializeData
void InitializeData(WindowNumber window_number)
Initializes the data (except the position and initial size) of a new Window.
Definition: window.cpp:1397
TileHighlightData::selend
Point selend
The location where the drag currently ends.
Definition: tilehighlight_type.h:61
NWID_BUTTON_DROPDOWN
@ NWID_BUTTON_DROPDOWN
Button with a drop-down.
Definition: widget_type.h:80
VA_MAIN_VIEWPORT
@ VA_MAIN_VIEWPORT
Scroll main viewport at edge.
Definition: window.cpp:48
Scrollbar::SetPosition
bool SetPosition(int position)
Sets the position of the first visible element.
Definition: widget_type.h:742
TileHighlightData::GetCallbackWnd
Window * GetCallbackWnd()
Get the window that started the current highlighting.
Definition: viewport.cpp:2518
DrawPixelInfo
Data about how and where to blit pixels.
Definition: gfx_type.h:155
GUISettings::right_mouse_wnd_close
bool right_mouse_wnd_close
close window with right click
Definition: settings_type.h:144
Window::GetFocusedText
virtual const char * GetFocusedText() const
Get the current input text if an edit box has the focus.
Definition: window.cpp:361
HKPR_CURSOR
@ HKPR_CURSOR
Non-text change, e.g. cursor position.
Definition: textbuf_type.h:23
TileHighlightData::Reset
void Reset()
Reset tile highlighting.
Definition: viewport.cpp:2497
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
news_func.h
Window::FindWindowPlacementAndResize
virtual void FindWindowPlacementAndResize(int def_width, int def_height)
Resize window towards the default size.
Definition: window.cpp:1457
hotkeys.h
ResizeWindow
void ResizeWindow(Window *w, int delta_x, int delta_y, bool clamp_to_screen)
Resize the window.
Definition: window.cpp:2069
QueryString::ACTION_NOTHING
static const int ACTION_NOTHING
Nothing.
Definition: querystring_gui.h:22
MIN_VISIBLE_TITLE_BAR
static const int MIN_VISIBLE_TITLE_BAR
The minimum number of pixels of the title bar must be visible in both the X or Y direction.
Definition: window.cpp:1977
Window::OnKeyPress
virtual EventState OnKeyPress(WChar key, uint16 keycode)
A key has been pressed.
Definition: window_gui.h:600
NWidgetBase::SetupSmallestSize
virtual void SetupSmallestSize(Window *w, bool init_array)=0
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62
Window::Close
virtual void Close()
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:1092