OpenTTD Source: src/window.cpp Source File

OpenTTD Source 13.2.1

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 "strings_func.h"
26 #include "settings_type.h"
27 #include "settings_func.h"
28 #include "ini_type.h"
29 #include "newgrf_debug.h"
30 #include "hotkeys.h"
31 #include "toolbar_gui.h"
32 #include "statusbar_gui.h"
33 #include "error.h"
34 #include "game/game.hpp"
35 #include "video/video_driver.hpp"
36 #include "framerate_type.h"
37 #include "network/network_func.h"
38 #include "guitimer_func.h"
39 #include "news_func.h"
40
41 #include "safeguards.h"
42
44 enum ViewportAutoscrolling {
45 VA_DISABLED,
46 VA_MAIN_VIEWPORT_FULLSCREEN,
47 VA_MAIN_VIEWPORT,
48 VA_EVERY_VIEWPORT,
49 };
50
51 static Point _drag_delta;
52 static Window *_mouseover_last_w = nullptr;
53 static Window *_last_scroll_window = nullptr;
54
56 WindowList _z_windows;
57
59 /* static */ std::vector<Window *> Window::closed_windows;
60
64 /* static */ void Window::DeleteClosedWindows()
65 {
66 for (Window *w : Window::closed_windows) delete w;
67 Window::closed_windows.clear();
68
69 /* Remove dead entries from the window list */
70 _z_windows.remove(nullptr);
71 }
72
74 bool _window_highlight_colour = false;
75
76 /*
77 * Window that currently has focus. - The main purpose is to generate
78 * #FocusLost events, not to give next window in z-order focus when a
79 * window is closed.
80 */
81 Window *_focused_window;
82
83 Point _cursorpos_drag_start;
84
85 int _scrollbar_start_pos;
86 int _scrollbar_size;
87 byte _scroller_click_timeout = 0;
88
89 bool _scrolling_viewport;
90 bool _mouse_hovering;
91
92 SpecialMouseMode _special_mouse_mode;
93
98 static std::vector<WindowDesc*> *_window_descs = nullptr;
99
101 std::string _windows_file;
102
104 WindowDesc::WindowDesc(WindowPosition def_pos, const char *ini_key, int16 def_width_trad, int16 def_height_trad,
105 WindowClass window_class, WindowClass parent_class, uint32 flags,
106 const NWidgetPart *nwid_parts, int16 nwid_length, HotkeyList *hotkeys) :
107 default_pos(def_pos),
108 cls(window_class),
109 parent_cls(parent_class),
110 ini_key(ini_key),
111 flags(flags),
112 nwid_parts(nwid_parts),
113 nwid_length(nwid_length),
114 hotkeys(hotkeys),
115 pref_sticky(false),
116 pref_width(0),
117 pref_height(0),
118 default_width_trad(def_width_trad),
119 default_height_trad(def_height_trad)
120 {
121 if (_window_descs == nullptr) _window_descs = new std::vector<WindowDesc*>();
122 _window_descs->push_back(this);
123 }
124
125 WindowDesc::~WindowDesc()
126 {
127 _window_descs->erase(std::find(_window_descs->begin(), _window_descs->end(), this));
128 }
129
135 int16 WindowDesc::GetDefaultWidth() const
136 {
137 return this->pref_width != 0 ? this->pref_width : ScaleGUITrad(this->default_width_trad);
138 }
139
145 int16 WindowDesc::GetDefaultHeight() const
146 {
147 return this->pref_height != 0 ? this->pref_height : ScaleGUITrad(this->default_height_trad);
148 }
149
153 void WindowDesc::LoadFromConfig()
154 {
155 IniFile ini;
156 ini.LoadFromDisk(_windows_file, NO_DIRECTORY);
157 for (WindowDesc *wd : *_window_descs) {
158 if (wd->ini_key == nullptr) continue;
159 IniLoadWindowSettings(ini, wd->ini_key, wd);
160 }
161 }
162
166 static bool DescSorter(WindowDesc* const &a, WindowDesc* const &b)
167 {
168 if (a->ini_key != nullptr && b->ini_key != nullptr) return strcmp(a->ini_key, b->ini_key) < 0;
169 return a->ini_key != nullptr;
170 }
171
175 void WindowDesc::SaveToConfig()
176 {
177 /* Sort the stuff to get a nice ini file on first write */
178 std::sort(_window_descs->begin(), _window_descs->end(), DescSorter);
179
180 IniFile ini;
181 ini.LoadFromDisk(_windows_file, NO_DIRECTORY);
182 for (WindowDesc *wd : *_window_descs) {
183 if (wd->ini_key == nullptr) continue;
184 IniSaveWindowSettings(ini, wd->ini_key, wd);
185 }
186 ini.SaveToDisk(_windows_file);
187 }
188
192 void Window::ApplyDefaults()
193 {
194 if (this->nested_root != nullptr && this->nested_root->GetWidgetOfType(WWT_STICKYBOX) != nullptr) {
195 if (this->window_desc->pref_sticky) this->flags |= WF_STICKY;
196 } else {
197 /* There is no stickybox; clear the preference in case someone tried to be funny */
198 this->window_desc->pref_sticky = false;
199 }
200 }
201
211 int Window::GetRowFromWidget(int clickpos, int widget, int padding, int line_height) const
212 {
213 const NWidgetBase *wid = this->GetWidget<NWidgetBase>(widget);
214 if (line_height < 0) line_height = wid->resize_y;
215 if (clickpos < (int)wid->pos_y + padding) return INT_MAX;
216 return (clickpos - (int)wid->pos_y - padding) / line_height;
217 }
218
222 void Window::DisableAllWidgetHighlight()
223 {
224 for (uint i = 0; i < this->nested_array_size; i++) {
225 NWidgetBase *nwid = this->GetWidget<NWidgetBase>(i);
226 if (nwid == nullptr) continue;
227
228 if (nwid->IsHighlighted()) {
229 nwid->SetHighlighted(TC_INVALID);
230 this->SetWidgetDirty(i);
231 }
232 }
233
234 CLRBITS(this->flags, WF_HIGHLIGHTED);
235 }
236
242 void Window::SetWidgetHighlight(byte widget_index, TextColour highlighted_colour)
243 {
244 assert(widget_index < this->nested_array_size);
245
246 NWidgetBase *nwid = this->GetWidget<NWidgetBase>(widget_index);
247 if (nwid == nullptr) return;
248
249 nwid->SetHighlighted(highlighted_colour);
250 this->SetWidgetDirty(widget_index);
251
252 if (highlighted_colour != TC_INVALID) {
253 /* If we set a highlight, the window has a highlight */
254 this->flags |= WF_HIGHLIGHTED;
255 } else {
256 /* If we disable a highlight, check all widgets if anyone still has a highlight */
257 bool valid = false;
258 for (uint i = 0; i < this->nested_array_size; i++) {
259 NWidgetBase *nwid = this->GetWidget<NWidgetBase>(i);
260 if (nwid == nullptr) continue;
261 if (!nwid->IsHighlighted()) continue;
262
263 valid = true;
264 }
265 /* If nobody has a highlight, disable the flag on the window */
266 if (!valid) CLRBITS(this->flags, WF_HIGHLIGHTED);
267 }
268 }
269
275 bool Window::IsWidgetHighlighted(byte widget_index) const
276 {
277 assert(widget_index < this->nested_array_size);
278
279 const NWidgetBase *nwid = this->GetWidget<NWidgetBase>(widget_index);
280 if (nwid == nullptr) return false;
281
282 return nwid->IsHighlighted();
283 }
284
292 void Window::OnDropdownClose(Point pt, int widget, int index, bool instant_close)
293 {
294 if (widget < 0) return;
295
296 if (instant_close) {
297 /* Send event for selected option if we're still
298 * on the parent button of the dropdown (behaviour of the dropdowns in the main toolbar). */
299 if (GetWidgetFromPos(this, pt.x, pt.y) == widget) {
300 this->OnDropdownSelect(widget, index);
301 }
302 }
303
304 /* Raise the dropdown button */
305 NWidgetCore *nwi2 = this->GetWidget<NWidgetCore>(widget);
306 if ((nwi2->type & WWT_MASK) == NWID_BUTTON_DROPDOWN) {
307 nwi2->disp_flags &= ~ND_DROPDOWN_ACTIVE;
308 } else {
309 this->RaiseWidget(widget);
310 }
311 this->SetWidgetDirty(widget);
312 }
313
319 const Scrollbar *Window::GetScrollbar(uint widnum) const
320 {
321 return this->GetWidget<NWidgetScrollbar>(widnum);
322 }
323
329 Scrollbar *Window::GetScrollbar(uint widnum)
330 {
331 return this->GetWidget<NWidgetScrollbar>(widnum);
332 }
333
339 const QueryString *Window::GetQueryString(uint widnum) const
340 {
341 auto query = this->querystrings.Find(widnum);
342 return query != this->querystrings.end() ? query->second : nullptr;
343 }
344
350 QueryString *Window::GetQueryString(uint widnum)
351 {
352 SmallMap<int, QueryString*>::Pair *query = this->querystrings.Find(widnum);
353 return query != this->querystrings.End() ? query->second : nullptr;
354 }
355
359 void Window::UpdateQueryStringSize()
360 {
361 for (auto &qs : this->querystrings)
362 {
363 qs.second->text.UpdateSize();
364 }
365 }
366
371 /* virtual */ const char *Window::GetFocusedText() const
372 {
373 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
374 return this->GetQueryString(this->nested_focus->index)->GetText();
375 }
376
377 return nullptr;
378 }
379
384 /* virtual */ const char *Window::GetCaret() const
385 {
386 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
387 return this->GetQueryString(this->nested_focus->index)->GetCaret();
388 }
389
390 return nullptr;
391 }
392
398 /* virtual */ const char *Window::GetMarkedText(size_t *length) const
399 {
400 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
401 return this->GetQueryString(this->nested_focus->index)->GetMarkedText(length);
402 }
403
404 return nullptr;
405 }
406
411 /* virtual */ Point Window::GetCaretPosition() const
412 {
413 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX && !this->querystrings.empty()) {
414 return this->GetQueryString(this->nested_focus->index)->GetCaretPosition(this, this->nested_focus->index);
415 }
416
417 Point pt = {0, 0};
418 return pt;
419 }
420
427 /* virtual */ Rect Window::GetTextBoundingRect(const char *from, const char *to) const
428 {
429 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
430 return this->GetQueryString(this->nested_focus->index)->GetBoundingRect(this, this->nested_focus->index, from, to);
431 }
432
433 Rect r = {0, 0, 0, 0};
434 return r;
435 }
436
442 /* virtual */ const char *Window::GetTextCharacterAtPosition(const Point &pt) const
443 {
444 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
445 return this->GetQueryString(this->nested_focus->index)->GetCharAtPosition(this, this->nested_focus->index, pt);
446 }
447
448 return nullptr;
449 }
450
455 void SetFocusedWindow(Window *w)
456 {
457 if (_focused_window == w) return;
458
459 /* Don't focus a tooltip */
460 if (w != nullptr && w->window_class == WC_TOOLTIPS) return;
461
462 /* Invalidate focused widget */
463 if (_focused_window != nullptr) {
464 if (_focused_window->nested_focus != nullptr) _focused_window->nested_focus->SetDirty(_focused_window);
465 }
466
467 /* Remember which window was previously focused */
468 Window *old_focused = _focused_window;
469 _focused_window = w;
470
471 /* So we can inform it that it lost focus */
472 if (old_focused != nullptr) old_focused->OnFocusLost();
473 if (_focused_window != nullptr) _focused_window->OnFocus();
474 }
475
481 bool EditBoxInGlobalFocus()
482 {
483 if (_focused_window == nullptr) return false;
484
485 /* The console does not have an edit box so a special case is needed. */
486 if (_focused_window->window_class == WC_CONSOLE) return true;
487
488 return _focused_window->nested_focus != nullptr && _focused_window->nested_focus->type == WWT_EDITBOX;
489 }
490
495 bool FocusedWindowIsConsole()
496 {
497 return _focused_window && _focused_window->window_class == WC_CONSOLE;
498 }
499
503 void Window::UnfocusFocusedWidget()
504 {
505 if (this->nested_focus != nullptr) {
506 if (this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxLostFocus();
507
508 /* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */
509 this->nested_focus->SetDirty(this);
510 this->nested_focus = nullptr;
511 }
512 }
513
519 bool Window::SetFocusedWidget(int widget_index)
520 {
521 /* Do nothing if widget_index is already focused, or if it wasn't a valid widget. */
522 if ((uint)widget_index >= this->nested_array_size) return false;
523
524 assert(this->nested_array[widget_index] != nullptr); // Setting focus to a non-existing widget is a bad idea.
525 if (this->nested_focus != nullptr) {
526 if (this->GetWidget<NWidgetCore>(widget_index) == this->nested_focus) return false;
527
528 /* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */
529 this->nested_focus->SetDirty(this);
530 if (this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxLostFocus();
531 }
532 this->nested_focus = this->GetWidget<NWidgetCore>(widget_index);
533 if (this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxGainedFocus();
534 return true;
535 }
536
540 void Window::OnFocus()
541 {
542 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxGainedFocus();
543 }
544
548 void Window::OnFocusLost()
549 {
550 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxLostFocus();
551 }
552
560 void CDECL Window::SetWidgetsDisabledState(bool disab_stat, int widgets, ...)
561 {
562 va_list wdg_list;
563
564 va_start(wdg_list, widgets);
565
566 while (widgets != WIDGET_LIST_END) {
567 SetWidgetDisabledState(widgets, disab_stat);
568 widgets = va_arg(wdg_list, int);
569 }
570
571 va_end(wdg_list);
572 }
573
579 void CDECL Window::SetWidgetsLoweredState(bool lowered_stat, int widgets, ...)
580 {
581 va_list wdg_list;
582
583 va_start(wdg_list, widgets);
584
585 while (widgets != WIDGET_LIST_END) {
586 SetWidgetLoweredState(widgets, lowered_stat);
587 widgets = va_arg(wdg_list, int);
588 }
589
590 va_end(wdg_list);
591 }
592
597 void Window::RaiseButtons(bool autoraise)
598 {
599 for (uint i = 0; i < this->nested_array_size; i++) {
600 if (this->nested_array[i] == nullptr) continue;
601 WidgetType type = this->nested_array[i]->type;
602 if (((type & ~WWB_PUSHBUTTON) < WWT_LAST || type == NWID_PUSHBUTTON_DROPDOWN) &&
603 (!autoraise || (type & WWB_PUSHBUTTON) || type == WWT_EDITBOX) && this->IsWidgetLowered(i)) {
604 this->RaiseWidget(i);
605 this->SetWidgetDirty(i);
606 }
607 }
608
609 /* Special widgets without widget index */
610 NWidgetCore *wid = this->nested_root != nullptr ? (NWidgetCore*)this->nested_root->GetWidgetOfType(WWT_DEFSIZEBOX) : nullptr;
611 if (wid != nullptr) {
612 wid->SetLowered(false);
613 wid->SetDirty(this);
614 }
615 }
616
621 void Window::SetWidgetDirty(byte widget_index) const
622 {
623 /* Sometimes this function is called before the window is even fully initialized */
624 if (this->nested_array == nullptr) return;
625
626 this->nested_array[widget_index]->SetDirty(this);
627 }
628
634 EventState Window::OnHotkey(int hotkey)
635 {
636 if (hotkey < 0) return ES_NOT_HANDLED;
637
638 NWidgetCore *nw = this->GetWidget<NWidgetCore>(hotkey);
639 if (nw == nullptr || nw->IsDisabled()) return ES_NOT_HANDLED;
640
641 if (nw->type == WWT_EDITBOX) {
642 if (this->IsShaded()) return ES_NOT_HANDLED;
643
644 /* Focus editbox */
645 this->SetFocusedWidget(hotkey);
646 SetFocusedWindow(this);
647 } else {
648 /* Click button */
649 this->OnClick(Point(), hotkey, 1);
650 }
651 return ES_HANDLED;
652 }
653
659 void Window::HandleButtonClick(byte widget)
660 {
661 this->LowerWidget(widget);
662 this->SetTimeout();
663 this->SetWidgetDirty(widget);
664 }
665
666 static void StartWindowDrag(Window *w);
667 static void StartWindowSizing(Window *w, bool to_left);
668
676 static void DispatchLeftClickEvent(Window *w, int x, int y, int click_count)
677 {
678 NWidgetCore *nw = w->nested_root->GetWidgetFromPos(x, y);
679 WidgetType widget_type = (nw != nullptr) ? nw->type : WWT_EMPTY;
680
681 /* Allow dropdown close flag detection to work. */
682 if (nw != nullptr) ClrBit(nw->disp_flags, NDB_DROPDOWN_CLOSED);
683
684 bool focused_widget_changed = false;
685 /* If clicked on a window that previously did not have focus */
686 if (_focused_window != w && // We already have focus, right?
687 (w->window_desc->flags & WDF_NO_FOCUS) == 0 && // Don't lose focus to toolbars
688 widget_type != WWT_CLOSEBOX) { // Don't change focused window if 'X' (close button) was clicked
689 focused_widget_changed = true;
690 SetFocusedWindow(w);
691 }
692
693 if (nw == nullptr) return; // exit if clicked outside of widgets
694
695 /* don't allow any interaction if the button has been disabled */
696 if (nw->IsDisabled()) return;
697
698 int widget_index = nw->index;
699
700 /* Clicked on a widget that is not disabled.
701 * So unless the clicked widget is the caption bar, change focus to this widget.
702 * Exception: In the OSK we always want the editbox to stay focused. */
703 if (widget_type != WWT_CAPTION && w->window_class != WC_OSK) {
704 /* focused_widget_changed is 'now' only true if the window this widget
705 * is in gained focus. In that case it must remain true, also if the
706 * local widget focus did not change. As such it's the logical-or of
707 * both changed states.
708 *
709 * If this is not preserved, then the OSK window would be opened when
710 * a user has the edit box focused and then click on another window and
711 * then back again on the edit box (to type some text).
712 */
713 focused_widget_changed |= w->SetFocusedWidget(widget_index);
714 }
715
716 /* Dropdown window of this widget was closed so don't process click this time. */
717 if (HasBit(nw->disp_flags, NDB_DROPDOWN_CLOSED)) return;
718
719 if ((widget_type & ~WWB_PUSHBUTTON) < WWT_LAST && (widget_type & WWB_PUSHBUTTON)) w->HandleButtonClick(widget_index);
720
721 Point pt = { x, y };
722
723 switch (widget_type) {
724 case NWID_VSCROLLBAR:
725 case NWID_HSCROLLBAR:
726 ScrollbarClickHandler(w, nw, x, y);
727 break;
728
729 case WWT_EDITBOX: {
730 QueryString *query = w->GetQueryString(widget_index);
731 if (query != nullptr) query->ClickEditBox(w, pt, widget_index, click_count, focused_widget_changed);
732 break;
733 }
734
735 case WWT_CLOSEBOX: // 'X'
736 w->Close();
737 return;
738
739 case WWT_CAPTION: // 'Title bar'
740 StartWindowDrag(w);
741 return;
742
743 case WWT_RESIZEBOX:
744 /* When the resize widget is on the left size of the window
745 * we assume that that button is used to resize to the left. */
746 StartWindowSizing(w, (int)nw->pos_x < (w->width / 2));
747 nw->SetDirty(w);
748 return;
749
750 case WWT_DEFSIZEBOX: {
751 if (_ctrl_pressed) {
752 w->window_desc->pref_width = w->width;
753 w->window_desc->pref_height = w->height;
754 } else {
755 int16 def_width = std::max<int16>(std::min<int16>(w->window_desc->GetDefaultWidth(), _screen.width), w->nested_root->smallest_x);
756 int16 def_height = std::max<int16>(std::min<int16>(w->window_desc->GetDefaultHeight(), _screen.height - 50), w->nested_root->smallest_y);
757
758 int dx = (w->resize.step_width == 0) ? 0 : def_width - w->width;
759 int dy = (w->resize.step_height == 0) ? 0 : def_height - w->height;
760 /* dx and dy has to go by step.. calculate it.
761 * The cast to int is necessary else dx/dy are implicitly casted to unsigned int, which won't work. */
762 if (w->resize.step_width > 1) dx -= dx % (int)w->resize.step_width;
763 if (w->resize.step_height > 1) dy -= dy % (int)w->resize.step_height;
764 ResizeWindow(w, dx, dy, false);
765 }
766
767 nw->SetLowered(true);
768 nw->SetDirty(w);
769 w->SetTimeout();
770 break;
771 }
772
773 case WWT_DEBUGBOX:
774 w->ShowNewGRFInspectWindow();
775 break;
776
777 case WWT_SHADEBOX:
778 nw->SetDirty(w);
779 w->SetShaded(!w->IsShaded());
780 return;
781
782 case WWT_STICKYBOX:
783 w->flags ^= WF_STICKY;
784 nw->SetDirty(w);
785 if (_ctrl_pressed) w->window_desc->pref_sticky = (w->flags & WF_STICKY) != 0;
786 return;
787
788 default:
789 break;
790 }
791
792 /* Widget has no index, so the window is not interested in it. */
793 if (widget_index < 0) return;
794
795 /* Check if the widget is highlighted; if so, disable highlight and dispatch an event to the GameScript */
796 if (w->IsWidgetHighlighted(widget_index)) {
797 w->SetWidgetHighlight(widget_index, TC_INVALID);
798 Game::NewEvent(new ScriptEventWindowWidgetClick((ScriptWindow::WindowClass)w->window_class, w->window_number, widget_index));
799 }
800
801 w->OnClick(pt, widget_index, click_count);
802 }
803
810 static void DispatchRightClickEvent(Window *w, int x, int y)
811 {
812 NWidgetCore *wid = w->nested_root->GetWidgetFromPos(x, y);
813 if (wid == nullptr) return;
814
815 Point pt = { x, y };
816
817 /* No widget to handle, or the window is not interested in it. */
818 if (wid->index >= 0) {
819 if (w->OnRightClick(pt, wid->index)) return;
820 }
821
822 /* Right-click close is enabled and there is a closebox */
823 if (_settings_client.gui.right_mouse_wnd_close && w->nested_root->GetWidgetOfType(WWT_CLOSEBOX)) {
824 w->Close();
825 } else if (_settings_client.gui.hover_delay_ms == 0 && !w->OnTooltip(pt, wid->index, TCC_RIGHT_CLICK) && wid->tool_tip != 0) {
826 GuiShowTooltips(w, wid->tool_tip, 0, nullptr, TCC_RIGHT_CLICK);
827 }
828 }
829
836 static void DispatchHoverEvent(Window *w, int x, int y)
837 {
838 NWidgetCore *wid = w->nested_root->GetWidgetFromPos(x, y);
839
840 /* No widget to handle */
841 if (wid == nullptr) return;
842
843 Point pt = { x, y };
844
845 /* Show the tooltip if there is any */
846 if (!w->OnTooltip(pt, wid->index, TCC_HOVER) && wid->tool_tip != 0) {
847 GuiShowTooltips(w, wid->tool_tip);
848 return;
849 }
850
851 /* Widget has no index, so the window is not interested in it. */
852 if (wid->index < 0) return;
853
854 w->OnHover(pt, wid->index);
855 }
856
864 static void DispatchMouseWheelEvent(Window *w, NWidgetCore *nwid, int wheel)
865 {
866 if (nwid == nullptr) return;
867
868 /* Using wheel on caption/shade-box shades or unshades the window. */
869 if (nwid->type == WWT_CAPTION || nwid->type == WWT_SHADEBOX) {
870 w->SetShaded(wheel < 0);
871 return;
872 }
873
874 /* Wheeling a vertical scrollbar. */
875 if (nwid->type == NWID_VSCROLLBAR) {
876 NWidgetScrollbar *sb = static_cast<NWidgetScrollbar *>(nwid);
877 if (sb->GetCount() > sb->GetCapacity()) {
878 if (sb->UpdatePosition(wheel)) w->SetDirty();
879 }
880 return;
881 }
882
883 /* Scroll the widget attached to the scrollbar. */
884 Scrollbar *sb = (nwid->scrollbar_index >= 0 ? w->GetScrollbar(nwid->scrollbar_index) : nullptr);
885 if (sb != nullptr && sb->GetCount() > sb->GetCapacity()) {
886 if (sb->UpdatePosition(wheel)) w->SetDirty();
887 }
888 }
889
895 static bool MayBeShown(const Window *w)
896 {
897 /* If we're not modal, everything is okay. */
898 if (!HasModalProgress()) return true;
899
900 switch (w->window_class) {
901 case WC_MAIN_WINDOW:
902 case WC_MODAL_PROGRESS:
903 case WC_CONFIRM_POPUP_QUERY:
904 return true;
905
906 default:
907 return false;
908 }
909 }
910
923 static void DrawOverlappedWindow(Window *w, int left, int top, int right, int bottom)
924 {
925 Window::IteratorToFront it(w);
926 ++it;
927 for (; !it.IsEnd(); ++it) {
928 const Window *v = *it;
929 if (MayBeShown(v) &&
930 right > v->left &&
931 bottom > v->top &&
932 left < v->left + v->width &&
933 top < v->top + v->height) {
934 /* v and rectangle intersect with each other */
935 int x;
936
937 if (left < (x = v->left)) {
938 DrawOverlappedWindow(w, left, top, x, bottom);
939 DrawOverlappedWindow(w, x, top, right, bottom);
940 return;
941 }
942
943 if (right > (x = v->left + v->width)) {
944 DrawOverlappedWindow(w, left, top, x, bottom);
945 DrawOverlappedWindow(w, x, top, right, bottom);
946 return;
947 }
948
949 if (top < (x = v->top)) {
950 DrawOverlappedWindow(w, left, top, right, x);
951 DrawOverlappedWindow(w, left, x, right, bottom);
952 return;
953 }
954
955 if (bottom > (x = v->top + v->height)) {
956 DrawOverlappedWindow(w, left, top, right, x);
957 DrawOverlappedWindow(w, left, x, right, bottom);
958 return;
959 }
960
961 return;
962 }
963 }
964
965 /* Setup blitter, and dispatch a repaint event to window *wz */
966 DrawPixelInfo *dp = _cur_dpi;
967 dp->width = right - left;
968 dp->height = bottom - top;
969 dp->left = left - w->left;
970 dp->top = top - w->top;
971 dp->pitch = _screen.pitch;
972 dp->dst_ptr = BlitterFactory::GetCurrentBlitter()->MoveTo(_screen.dst_ptr, left, top);
973 dp->zoom = ZOOM_LVL_NORMAL;
974 w->OnPaint();
975 }
976
985 void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)
986 {
987 DrawPixelInfo *old_dpi = _cur_dpi;
988 DrawPixelInfo bk;
989 _cur_dpi = &bk;
990
991 for (Window *w : Window::IterateFromBack()) {
992 if (MayBeShown(w) &&
993 right > w->left &&
994 bottom > w->top &&
995 left < w->left + w->width &&
996 top < w->top + w->height) {
997 /* Window w intersects with the rectangle => needs repaint */
998 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));
999 }
1000 }
1001 _cur_dpi = old_dpi;
1002 }
1003
1008 void Window::SetDirty() const
1009 {
1010 AddDirtyBlock(this->left, this->top, this->left + this->width, this->top + this->height);
1011 }
1012
1019 void Window::ReInit(int rx, int ry)
1020 {
1021 this->SetDirty(); // Mark whole current window as dirty.
1022
1023 /* Save current size. */
1024 int window_width = this->width;
1025 int window_height = this->height;
1026
1027 this->OnInit();
1028 /* Re-initialize the window from the ground up. No need to change the nested_array, as all widgets stay where they are. */
1029 this->nested_root->SetupSmallestSize(this, false);
1030 this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
1031 this->width = this->nested_root->smallest_x;
1032 this->height = this->nested_root->smallest_y;
1033 this->resize.step_width = this->nested_root->resize_x;
1034 this->resize.step_height = this->nested_root->resize_y;
1035
1036 /* Resize as close to the original size + requested resize as possible. */
1037 window_width = std::max(window_width + rx, this->width);
1038 window_height = std::max(window_height + ry, this->height);
1039 int dx = (this->resize.step_width == 0) ? 0 : window_width - this->width;
1040 int dy = (this->resize.step_height == 0) ? 0 : window_height - this->height;
1041 /* dx and dy has to go by step.. calculate it.
1042 * The cast to int is necessary else dx/dy are implicitly casted to unsigned int, which won't work. */
1043 if (this->resize.step_width > 1) dx -= dx % (int)this->resize.step_width;
1044 if (this->resize.step_height > 1) dy -= dy % (int)this->resize.step_height;
1045
1046 ResizeWindow(this, dx, dy);
1047 /* ResizeWindow() does this->SetDirty() already, no need to do it again here. */
1048 }
1049
1055 void Window::SetShaded(bool make_shaded)
1056 {
1057 if (this->shade_select == nullptr) return;
1058
1059 int desired = make_shaded ? SZSP_HORIZONTAL : 0;
1060 if (this->shade_select->shown_plane != desired) {
1061 if (make_shaded) {
1062 if (this->nested_focus != nullptr) this->UnfocusFocusedWidget();
1063 this->unshaded_size.width = this->width;
1064 this->unshaded_size.height = this->height;
1065 this->shade_select->SetDisplayedPlane(desired);
1066 this->ReInit(0, -this->height);
1067 } else {
1068 this->shade_select->SetDisplayedPlane(desired);
1069 int dx = ((int)this->unshaded_size.width > this->width) ? (int)this->unshaded_size.width - this->width : 0;
1070 int dy = ((int)this->unshaded_size.height > this->height) ? (int)this->unshaded_size.height - this->height : 0;
1071 this->ReInit(dx, dy);
1072 }
1073 }
1074 }
1075
1082 static Window *FindChildWindow(const Window *w, WindowClass wc)
1083 {
1084 for (Window *v : Window::Iterate()) {
1085 if ((wc == WC_INVALID || wc == v->window_class) && v->parent == w) return v;
1086 }
1087
1088 return nullptr;
1089 }
1090
1095 void Window::CloseChildWindows(WindowClass wc) const
1096 {
1097 Window *child = FindChildWindow(this, wc);
1098 while (child != nullptr) {
1099 child->Close();
1100 child = FindChildWindow(this, wc);
1101 }
1102 }
1103
1107 void Window::Close()
1108 {
1109 /* Don't close twice. */
1110 if (*this->z_position == nullptr) return;
1111
1112 *this->z_position = nullptr;
1113
1114 if (_thd.window_class == this->window_class &&
1115 _thd.window_number == this->window_number) {
1116 ResetObjectToPlace();
1117 }
1118
1119 /* Prevent Mouseover() from resetting mouse-over coordinates on a non-existing window */
1120 if (_mouseover_last_w == this) _mouseover_last_w = nullptr;
1121
1122 /* We can't scroll the window when it's closed. */
1123 if (_last_scroll_window == this) _last_scroll_window = nullptr;
1124
1125 /* Make sure we don't try to access non-existing query strings. */
1126 this->querystrings.clear();
1127
1128 /* Make sure we don't try to access this window as the focused window when it doesn't exist anymore. */
1129 if (_focused_window == this) {
1130 this->OnFocusLost();
1131 _focused_window = nullptr;
1132 }
1133
1134 this->CloseChildWindows();
1135
1136 this->SetDirty();
1137
1138 Window::closed_windows.push_back(this);
1139 }
1140
1144 Window::~Window()
1145 {
1146 /* Make sure the window is closed, deletion is allowed only in Window::DeleteClosedWindows(). */
1147 assert(*this->z_position == nullptr);
1148
1149 if (this->viewport != nullptr) DeleteWindowViewport(this);
1150
1151 free(this->nested_array); // Contents is released through deletion of #nested_root.
1152 delete this->nested_root;
1153 }
1154
1161 Window *FindWindowById(WindowClass cls, WindowNumber number)
1162 {
1163 for (Window *w : Window::Iterate()) {
1164 if (w->window_class == cls && w->window_number == number) return w;
1165 }
1166
1167 return nullptr;
1168 }
1169
1176 Window *FindWindowByClass(WindowClass cls)
1177 {
1178 for (Window *w : Window::Iterate()) {
1179 if (w->window_class == cls) return w;
1180 }
1181
1182 return nullptr;
1183 }
1184
1191 void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
1192 {
1193 Window *w = FindWindowById(cls, number);
1194 if (w != nullptr && (force || (w->flags & WF_STICKY) == 0)) {
1195 w->Close();
1196 }
1197 }
1198
1203 void CloseWindowByClass(WindowClass cls)
1204 {
1205 /* Note: the container remains stable, even when deleting windows. */
1206 for (Window *w : Window::Iterate()) {
1207 if (w->window_class == cls) {
1208 w->Close();
1209 }
1210 }
1211 }
1212
1219 void CloseCompanyWindows(CompanyID id)
1220 {
1221 /* Note: the container remains stable, even when deleting windows. */
1222 for (Window *w : Window::Iterate()) {
1223 if (w->owner == id) {
1224 w->Close();
1225 }
1226 }
1227
1228 /* Also delete the company specific windows that don't have a company-colour. */
1229 CloseWindowById(WC_BUY_COMPANY, id);
1230 }
1231
1239 void ChangeWindowOwner(Owner old_owner, Owner new_owner)
1240 {
1241 for (Window *w : Window::Iterate()) {
1242 if (w->owner != old_owner) continue;
1243
1244 switch (w->window_class) {
1245 case WC_COMPANY_COLOUR:
1246 case WC_FINANCES:
1247 case WC_STATION_LIST:
1248 case WC_TRAINS_LIST:
1249 case WC_ROADVEH_LIST:
1250 case WC_SHIPS_LIST:
1251 case WC_AIRCRAFT_LIST:
1252 case WC_BUY_COMPANY:
1253 case WC_COMPANY:
1254 case WC_COMPANY_INFRASTRUCTURE:
1255 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().
1256 continue;
1257
1258 default:
1259 w->owner = new_owner;
1260 break;
1261 }
1262 }
1263 }
1264
1265 static void BringWindowToFront(Window *w, bool dirty = true);
1266
1274 Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)
1275 {
1276 Window *w = FindWindowById(cls, number);
1277
1278 if (w != nullptr) {
1279 if (w->IsShaded()) w->SetShaded(false); // Restore original window size if it was shaded.
1280
1281 w->SetWhiteBorder();
1282 BringWindowToFront(w);
1283 w->SetDirty();
1284 }
1285
1286 return w;
1287 }
1288
1289 static inline bool IsVitalWindow(const Window *w)
1290 {
1291 switch (w->window_class) {
1292 case WC_MAIN_TOOLBAR:
1293 case WC_STATUS_BAR:
1294 case WC_NEWS_WINDOW:
1295 case WC_SEND_NETWORK_MSG:
1296 return true;
1297
1298 default:
1299 return false;
1300 }
1301 }
1302
1311 static uint GetWindowZPriority(WindowClass wc)
1312 {
1313 assert(wc != WC_INVALID);
1314
1315 uint z_priority = 0;
1316
1317 switch (wc) {
1318 case WC_ENDSCREEN:
1319 ++z_priority;
1320 FALLTHROUGH;
1321
1322 case WC_HIGHSCORE:
1323 ++z_priority;
1324 FALLTHROUGH;
1325
1326 case WC_TOOLTIPS:
1327 ++z_priority;
1328 FALLTHROUGH;
1329
1330 case WC_DROPDOWN_MENU:
1331 ++z_priority;
1332 FALLTHROUGH;
1333
1334 case WC_MAIN_TOOLBAR:
1335 case WC_STATUS_BAR:
1336 ++z_priority;
1337 FALLTHROUGH;
1338
1339 case WC_OSK:
1340 ++z_priority;
1341 FALLTHROUGH;
1342
1343 case WC_QUERY_STRING:
1344 case WC_SEND_NETWORK_MSG:
1345 ++z_priority;
1346 FALLTHROUGH;
1347
1348 case WC_ERRMSG:
1349 case WC_CONFIRM_POPUP_QUERY:
1350 case WC_NETWORK_ASK_RELAY:
1351 case WC_MODAL_PROGRESS:
1352 case WC_NETWORK_STATUS_WINDOW:
1353 case WC_SAVE_PRESET:
1354 ++z_priority;
1355 FALLTHROUGH;
1356
1357 case WC_GENERATE_LANDSCAPE:
1358 case WC_SAVELOAD:
1359 case WC_GAME_OPTIONS:
1360 case WC_CUSTOM_CURRENCY:
1361 case WC_NETWORK_WINDOW:
1362 case WC_GRF_PARAMETERS:
1363 case WC_AI_LIST:
1364 case WC_AI_SETTINGS:
1365 case WC_TEXTFILE:
1366 ++z_priority;
1367 FALLTHROUGH;
1368
1369 case WC_CONSOLE:
1370 ++z_priority;
1371 FALLTHROUGH;
1372
1373 case WC_NEWS_WINDOW:
1374 ++z_priority;
1375 FALLTHROUGH;
1376
1377 default:
1378 ++z_priority;
1379 FALLTHROUGH;
1380
1381 case WC_MAIN_WINDOW:
1382 return z_priority;
1383 }
1384 }
1385
1392 static void BringWindowToFront(Window *w, bool dirty)
1393 {
1394 auto priority = GetWindowZPriority(w->window_class);
1395 WindowList::iterator dest = _z_windows.begin();
1396 while (dest != _z_windows.end() && (*dest == nullptr || GetWindowZPriority((*dest)->window_class) <= priority)) ++dest;
1397
1398 if (dest != w->z_position) {
1399 _z_windows.splice(dest, _z_windows, w->z_position);
1400 }
1401
1402 if (dirty) w->SetDirty();
1403 }
1404
1412 void Window::InitializeData(WindowNumber window_number)
1413 {
1414 /* Set up window properties; some of them are needed to set up smallest size below */
1415 this->window_class = this->window_desc->cls;
1416 this->SetWhiteBorder();
1417 if (this->window_desc->default_pos == WDP_CENTER) this->flags |= WF_CENTERED;
1418 this->owner = INVALID_OWNER;
1419 this->nested_focus = nullptr;
1420 this->window_number = window_number;
1421
1422 this->OnInit();
1423 /* Initialize nested widget tree. */
1424 if (this->nested_array == nullptr) {
1425 this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);
1426 this->nested_root->SetupSmallestSize(this, true);
1427 } else {
1428 this->nested_root->SetupSmallestSize(this, false);
1429 }
1430 /* Initialize to smallest size. */
1431 this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
1432
1433 /* Further set up window properties,
1434 * this->left, this->top, this->width, this->height, this->resize.width, and this->resize.height are initialized later. */
1435 this->resize.step_width = this->nested_root->resize_x;
1436 this->resize.step_height = this->nested_root->resize_y;
1437
1438 /* Give focus to the opened window unless a text box
1439 * of focused window has focus (so we don't interrupt typing). But if the new
1440 * window has a text box, then take focus anyway. */
1441 if (!EditBoxInGlobalFocus() || this->nested_root->GetWidgetOfType(WWT_EDITBOX) != nullptr) SetFocusedWindow(this);
1442
1443 /* Insert the window into the correct location in the z-ordering. */
1444 BringWindowToFront(this, false);
1445 }
1446
1454 void Window::InitializePositionSize(int x, int y, int sm_width, int sm_height)
1455 {
1456 this->left = x;
1457 this->top = y;
1458 this->width = sm_width;
1459 this->height = sm_height;
1460 }
1461
1472 void Window::FindWindowPlacementAndResize(int def_width, int def_height)
1473 {
1474 def_width = std::max(def_width, this->width); // Don't allow default size to be smaller than smallest size
1475 def_height = std::max(def_height, this->height);
1476 /* Try to make windows smaller when our window is too small.
1477 * w->(width|height) is normally the same as min_(width|height),
1478 * but this way the GUIs can be made a little more dynamic;
1479 * one can use the same spec for multiple windows and those
1480 * can then determine the real minimum size of the window. */
1481 if (this->width != def_width || this->height != def_height) {
1482 /* Think about the overlapping toolbars when determining the minimum window size */
1483 int free_height = _screen.height;
1484 const Window *wt = FindWindowById(WC_STATUS_BAR, 0);
1485 if (wt != nullptr) free_height -= wt->height;
1486 wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
1487 if (wt != nullptr) free_height -= wt->height;
1488
1489 int enlarge_x = std::max(std::min(def_width - this->width, _screen.width - this->width), 0);
1490 int enlarge_y = std::max(std::min(def_height - this->height, free_height - this->height), 0);
1491
1492 /* X and Y has to go by step.. calculate it.
1493 * The cast to int is necessary else x/y are implicitly casted to
1494 * unsigned int, which won't work. */
1495 if (this->resize.step_width > 1) enlarge_x -= enlarge_x % (int)this->resize.step_width;
1496 if (this->resize.step_height > 1) enlarge_y -= enlarge_y % (int)this->resize.step_height;
1497
1498 ResizeWindow(this, enlarge_x, enlarge_y);
1499 /* ResizeWindow() calls this->OnResize(). */
1500 } else {
1501 /* Always call OnResize; that way the scrollbars and matrices get initialized. */
1502 this->OnResize();
1503 }
1504
1505 int nx = this->left;
1506 int ny = this->top;
1507
1508 if (nx + this->width > _screen.width) nx -= (nx + this->width - _screen.width);
1509
1510 const Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
1511 ny = std::max(ny, (wt == nullptr || this == wt || this->top == 0) ? 0 : wt->height);
1512 nx = std::max(nx, 0);
1513
1514 if (this->viewport != nullptr) {
1515 this->viewport->left += nx - this->left;
1516 this->viewport->top += ny - this->top;
1517 }
1518 this->left = nx;
1519 this->top = ny;
1520
1521 this->SetDirty();
1522 }
1523
1536 static bool IsGoodAutoPlace1(int left, int top, int width, int height, int toolbar_y, Point &pos)
1537 {
1538 int right = width + left;
1539 int bottom = height + top;
1540
1541 if (left < 0 || top < toolbar_y || right > _screen.width || bottom > _screen.height) return false;
1542
1543 /* Make sure it is not obscured by any window. */
1544 for (const Window *w : Window::Iterate()) {
1545 if (w->window_class == WC_MAIN_WINDOW) continue;
1546
1547 if (right > w->left &&
1548 w->left + w->width > left &&
1549 bottom > w->top &&
1550 w->top + w->height > top) {
1551 return false;
1552 }
1553 }
1554
1555 pos.x = left;
1556 pos.y = top;
1557 return true;
1558 }
1559
1572 static bool IsGoodAutoPlace2(int left, int top, int width, int height, int toolbar_y, Point &pos)
1573 {
1574 bool rtl = _current_text_dir == TD_RTL;
1575
1576 /* Left part of the rectangle may be at most 1/4 off-screen,
1577 * right part of the rectangle may be at most 1/2 off-screen
1578 */
1579 if (rtl) {
1580 if (left < -(width >> 1) || left > _screen.width - (width >> 2)) return false;
1581 } else {
1582 if (left < -(width >> 2) || left > _screen.width - (width >> 1)) return false;
1583 }
1584
1585 /* Bottom part of the rectangle may be at most 1/4 off-screen */
1586 if (top < toolbar_y || top > _screen.height - (height >> 2)) return false;
1587
1588 /* Make sure it is not obscured by any window. */
1589 for (const Window *w : Window::Iterate()) {
1590 if (w->window_class == WC_MAIN_WINDOW) continue;
1591
1592 if (left + width > w->left &&
1593 w->left + w->width > left &&
1594 top + height > w->top &&
1595 w->top + w->height > top) {
1596 return false;
1597 }
1598 }
1599
1600 pos.x = left;
1601 pos.y = top;
1602 return true;
1603 }
1604
1611 static Point GetAutoPlacePosition(int width, int height)
1612 {
1613 Point pt;
1614
1615 bool rtl = _current_text_dir == TD_RTL;
1616
1617 /* First attempt, try top-left of the screen */
1618 const Window *main_toolbar = FindWindowByClass(WC_MAIN_TOOLBAR);
1619 const int toolbar_y = main_toolbar != nullptr ? main_toolbar->height : 0;
1620 if (IsGoodAutoPlace1(rtl ? _screen.width - width : 0, toolbar_y, width, height, toolbar_y, pt)) return pt;
1621
1622 /* Second attempt, try around all existing windows.
1623 * The new window must be entirely on-screen, and not overlap with an existing window.
1624 * Eight starting points are tried, two at each corner.
1625 */
1626 for (const Window *w : Window::Iterate()) {
1627 if (w->window_class == WC_MAIN_WINDOW) continue;
1628
1629 if (IsGoodAutoPlace1(w->left + w->width, w->top, width, height, toolbar_y, pt)) return pt;
1630 if (IsGoodAutoPlace1(w->left - width, w->top, width, height, toolbar_y, pt)) return pt;
1631 if (IsGoodAutoPlace1(w->left, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1632 if (IsGoodAutoPlace1(w->left, w->top - height, width, height, toolbar_y, pt)) return pt;
1633 if (IsGoodAutoPlace1(w->left + w->width, w->top + w->height - height, width, height, toolbar_y, pt)) return pt;
1634 if (IsGoodAutoPlace1(w->left - width, w->top + w->height - height, width, height, toolbar_y, pt)) return pt;
1635 if (IsGoodAutoPlace1(w->left + w->width - width, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1636 if (IsGoodAutoPlace1(w->left + w->width - width, w->top - height, width, height, toolbar_y, pt)) return pt;
1637 }
1638
1639 /* Third attempt, try around all existing windows.
1640 * The new window may be partly off-screen, and must not overlap with an existing window.
1641 * Only four starting points are tried.
1642 */
1643 for (const Window *w : Window::Iterate()) {
1644 if (w->window_class == WC_MAIN_WINDOW) continue;
1645
1646 if (IsGoodAutoPlace2(w->left + w->width, w->top, width, height, toolbar_y, pt)) return pt;
1647 if (IsGoodAutoPlace2(w->left - width, w->top, width, height, toolbar_y, pt)) return pt;
1648 if (IsGoodAutoPlace2(w->left, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1649 if (IsGoodAutoPlace2(w->left, w->top - height, width, height, toolbar_y, pt)) return pt;
1650 }
1651
1652 /* Fourth and final attempt, put window at diagonal starting from (0, toolbar_y), try multiples
1653 * of the closebox
1654 */
1655 int left = rtl ? _screen.width - width : 0, top = toolbar_y;
1656 int offset_x = rtl ? -(int)NWidgetLeaf::closebox_dimension.width : (int)NWidgetLeaf::closebox_dimension.width;
1657 int offset_y = std::max<int>(NWidgetLeaf::closebox_dimension.height, FONT_HEIGHT_NORMAL + WidgetDimensions::scaled.captiontext.Vertical());
1658
1659 restart:
1660 for (const Window *w : Window::Iterate()) {
1661 if (w->left == left && w->top == top) {
1662 left += offset_x;
1663 top += offset_y;
1664 goto restart;
1665 }
1666 }
1667
1668 pt.x = left;
1669 pt.y = top;
1670 return pt;
1671 }
1672
1679 Point GetToolbarAlignedWindowPosition(int window_width)
1680 {
1681 const Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
1682 assert(w != nullptr);
1683 Point pt = { _current_text_dir == TD_RTL ? w->left : (w->left + w->width) - window_width, w->top + w->height };
1684 return pt;
1685 }
1686
1704 static Point LocalGetWindowPlacement(const WindowDesc *desc, int16 sm_width, int16 sm_height, int window_number)
1705 {
1706 Point pt;
1707 const Window *w;
1708
1709 int16 default_width = std::max(desc->GetDefaultWidth(), sm_width);
1710 int16 default_height = std::max(desc->GetDefaultHeight(), sm_height);
1711
1712 if (desc->parent_cls != WC_NONE && (w = FindWindowById(desc->parent_cls, window_number)) != nullptr) {
1713 bool rtl = _current_text_dir == TD_RTL;
1714 if (desc->parent_cls == WC_BUILD_TOOLBAR || desc->parent_cls == WC_SCEN_LAND_GEN) {
1715 pt.x = w->left + (rtl ? w->width - default_width : 0);
1716 pt.y = w->top + w->height;
1717 return pt;
1718 } else {
1719 /* Position child window with offset of closebox, but make sure that either closebox or resizebox is visible
1720 * - Y position: closebox of parent + closebox of child + statusbar
1721 * - X position: closebox on left/right, resizebox on right/left (depending on ltr/rtl)
1722 */
1723 int indent_y = std::max<int>(NWidgetLeaf::closebox_dimension.height, FONT_HEIGHT_NORMAL + WidgetDimensions::scaled.captiontext.Vertical());
1724 if (w->top + 3 * indent_y < _screen.height) {
1725 pt.y = w->top + indent_y;
1726 int indent_close = NWidgetLeaf::closebox_dimension.width;
1727 int indent_resize = NWidgetLeaf::resizebox_dimension.width;
1728 if (_current_text_dir == TD_RTL) {
1729 pt.x = std::max(w->left + w->width - default_width - indent_close, 0);
1730 if (pt.x + default_width >= indent_close && pt.x + indent_resize <= _screen.width) return pt;
1731 } else {
1732 pt.x = std::min(w->left + indent_close, _screen.width - default_width);
1733 if (pt.x + default_width >= indent_resize && pt.x + indent_close <= _screen.width) return pt;
1734 }
1735 }
1736 }
1737 }
1738
1739 switch (desc->default_pos) {
1740 case WDP_ALIGN_TOOLBAR: // Align to the toolbar
1741 return GetToolbarAlignedWindowPosition(default_width);
1742
1743 case WDP_AUTO: // Find a good automatic position for the window
1744 return GetAutoPlacePosition(default_width, default_height);
1745
1746 case WDP_CENTER: // Centre the window horizontally
1747 pt.x = (_screen.width - default_width) / 2;
1748 pt.y = (_screen.height - default_height) / 2;
1749 break;
1750
1751 case WDP_MANUAL:
1752 pt.x = 0;
1753 pt.y = 0;
1754 break;
1755
1756 default:
1757 NOT_REACHED();
1758 }
1759
1760 return pt;
1761 }
1762
1763 /* virtual */ Point Window::OnInitialPosition(int16 sm_width, int16 sm_height, int window_number)
1764 {
1765 return LocalGetWindowPlacement(this->window_desc, sm_width, sm_height, window_number);
1766 }
1767
1775 void Window::CreateNestedTree(bool fill_nested)
1776 {
1777 int biggest_index = -1;
1778 this->nested_root = MakeWindowNWidgetTree(this->window_desc->nwid_parts, this->window_desc->nwid_length, &biggest_index, &this->shade_select);
1779 this->nested_array_size = (uint)(biggest_index + 1);
1780
1781 if (fill_nested) {
1782 this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);
1783 this->nested_root->FillNestedArray(this->nested_array, this->nested_array_size);
1784 }
1785 }
1786
1791 void Window::FinishInitNested(WindowNumber window_number)
1792 {
1793 this->InitializeData(window_number);
1794 this->ApplyDefaults();
1795 Point pt = this->OnInitialPosition(this->nested_root->smallest_x, this->nested_root->smallest_y, window_number);
1796 this->InitializePositionSize(pt.x, pt.y, this->nested_root->smallest_x, this->nested_root->smallest_y);
1797 this->FindWindowPlacementAndResize(this->window_desc->GetDefaultWidth(), this->window_desc->GetDefaultHeight());
1798 }
1799
1804 void Window::InitNested(WindowNumber window_number)
1805 {
1806 this->CreateNestedTree(false);
1807 this->FinishInitNested(window_number);
1808 }
1809
1814 Window::Window(WindowDesc *desc) : window_desc(desc), mouse_capture_widget(-1)
1815 {
1816 this->z_position = _z_windows.insert(_z_windows.end(), this);
1817 }
1818
1826 Window *FindWindowFromPt(int x, int y)
1827 {
1828 for (Window *w : Window::IterateFromFront()) {
1829 if (MayBeShown(w) && IsInsideBS(x, w->left, w->width) && IsInsideBS(y, w->top, w->height)) {
1830 return w;
1831 }
1832 }
1833
1834 return nullptr;
1835 }
1836
1840 void InitWindowSystem()
1841 {
1842 IConsoleClose();
1843
1844 _focused_window = nullptr;
1845 _mouseover_last_w = nullptr;
1846 _last_scroll_window = nullptr;
1847 _scrolling_viewport = false;
1848 _mouse_hovering = false;
1849
1850 NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
1851 NWidgetScrollbar::InvalidateDimensionCache();
1852
1853 ShowFirstError();
1854 }
1855
1859 void UnInitWindowSystem()
1860 {
1861 UnshowCriticalError();
1862
1863 for (Window *w : Window::Iterate()) w->Close();
1864
1865 Window::DeleteClosedWindows();
1866
1867 assert(_z_windows.empty());
1868 }
1869
1873 void ResetWindowSystem()
1874 {
1875 UnInitWindowSystem();
1876 InitWindowSystem();
1877 _thd.Reset();
1878 }
1879
1880 static void DecreaseWindowCounters()
1881 {
1882 static byte hundredth_tick_timeout = 100;
1883
1884 if (_scroller_click_timeout != 0) _scroller_click_timeout--;
1885 if (hundredth_tick_timeout != 0) hundredth_tick_timeout--;
1886
1887 for (Window *w : Window::Iterate()) {
1888 if (!_network_dedicated && hundredth_tick_timeout == 0) w->OnHundredthTick();
1889
1890 if (_scroller_click_timeout == 0) {
1891 /* Unclick scrollbar buttons if they are pressed. */
1892 for (uint i = 0; i < w->nested_array_size; i++) {
1893 NWidgetBase *nwid = w->nested_array[i];
1894 if (nwid != nullptr && (nwid->type == NWID_HSCROLLBAR || nwid->type == NWID_VSCROLLBAR)) {
1895 NWidgetScrollbar *sb = static_cast<NWidgetScrollbar*>(nwid);
1896 if (sb->disp_flags & (ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN)) {
1897 sb->disp_flags &= ~(ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN);
1898 w->mouse_capture_widget = -1;
1899 sb->SetDirty(w);
1900 }
1901 }
1902 }
1903 }
1904
1905 /* Handle editboxes */
1906 for (SmallMap<int, QueryString*>::Pair &pair : w->querystrings) {
1907 pair.second->HandleEditBox(w, pair.first);
1908 }
1909
1910 w->OnMouseLoop();
1911 }
1912
1913 for (Window *w : Window::Iterate()) {
1914 if ((w->flags & WF_TIMEOUT) && --w->timeout_timer == 0) {
1915 CLRBITS(w->flags, WF_TIMEOUT);
1916
1917 w->OnTimeout();
1918 w->RaiseButtons(true);
1919 }
1920 }
1921
1922 if (hundredth_tick_timeout == 0) hundredth_tick_timeout = 100;
1923 }
1924
1925 static void HandlePlacePresize()
1926 {
1927 if (_special_mouse_mode != WSM_PRESIZE) return;
1928
1929 Window *w = _thd.GetCallbackWnd();
1930 if (w == nullptr) return;
1931
1932 Point pt = GetTileBelowCursor();
1933 if (pt.x == -1) {
1934 _thd.selend.x = -1;
1935 return;
1936 }
1937
1938 w->OnPlacePresize(pt, TileVirtXY(pt.x, pt.y));
1939 }
1940
1945 static EventState HandleMouseDragDrop()
1946 {
1947 if (_special_mouse_mode != WSM_DRAGDROP) return ES_NOT_HANDLED;
1948
1949 if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED; // Dragging, but the mouse did not move.
1950
1951 Window *w = _thd.GetCallbackWnd();
1952 if (w != nullptr) {
1953 /* Send an event in client coordinates. */
1954 Point pt;
1955 pt.x = _cursor.pos.x - w->left;
1956 pt.y = _cursor.pos.y - w->top;
1957 if (_left_button_down) {
1958 w->OnMouseDrag(pt, GetWidgetFromPos(w, pt.x, pt.y));
1959 } else {
1960 w->OnDragDrop(pt, GetWidgetFromPos(w, pt.x, pt.y));
1961 }
1962 }
1963
1964 if (!_left_button_down) ResetObjectToPlace(); // Button released, finished dragging.
1965 return ES_HANDLED;
1966 }
1967
1969 static void HandleMouseOver()
1970 {
1971 Window *w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
1972
1973 /* We changed window, put an OnMouseOver event to the last window */
1974 if (_mouseover_last_w != nullptr && _mouseover_last_w != w) {
1975 /* Reset mouse-over coordinates of previous window */
1976 Point pt = { -1, -1 };
1977 _mouseover_last_w->OnMouseOver(pt, 0);
1978 }
1979
1980 /* _mouseover_last_w will get reset when the window is deleted, see DeleteWindow() */
1981 _mouseover_last_w = w;
1982
1983 if (w != nullptr) {
1984 /* send an event in client coordinates. */
1985 Point pt = { _cursor.pos.x - w->left, _cursor.pos.y - w->top };
1986 const NWidgetCore *widget = w->nested_root->GetWidgetFromPos(pt.x, pt.y);
1987 if (widget != nullptr) w->OnMouseOver(pt, widget->index);
1988 }
1989 }
1990
1992 static const int MIN_VISIBLE_TITLE_BAR = 13;
1993
1995 enum PreventHideDirection {
1996 PHD_UP,
1997 PHD_DOWN,
1998 };
1999
2010 static void PreventHiding(int *nx, int *ny, const Rect &rect, const Window *v, int px, PreventHideDirection dir)
2011 {
2012 if (v == nullptr) return;
2013
2014 const int min_visible = ScaleGUITrad(MIN_VISIBLE_TITLE_BAR);
2015
2016 int v_bottom = v->top + v->height;
2017 int v_right = v->left + v->width;
2018 int safe_y = (dir == PHD_UP) ? (v->top - min_visible - rect.top) : (v_bottom + min_visible - rect.bottom); // Compute safe vertical position.
2019
2020 if (*ny + rect.top <= v->top - min_visible) return; // Above v is enough space
2021 if (*ny + rect.bottom >= v_bottom + min_visible) return; // Below v is enough space
2022
2023 /* Vertically, the rectangle is hidden behind v. */
2024 if (*nx + rect.left + min_visible < v->left) { // At left of v.
2025 if (v->left < min_visible) *ny = safe_y; // But enough room, force it to a safe position.
2026 return;
2027 }
2028 if (*nx + rect.right - min_visible > v_right) { // At right of v.
2029 if (v_right > _screen.width - min_visible) *ny = safe_y; // Not enough room, force it to a safe position.
2030 return;
2031 }
2032
2033 /* Horizontally also hidden, force movement to a safe area. */
2034 if (px + rect.left < v->left && v->left >= min_visible) { // Coming from the left, and enough room there.
2035 *nx = v->left - min_visible - rect.left;
2036 } else if (px + rect.right > v_right && v_right <= _screen.width - min_visible) { // Coming from the right, and enough room there.
2037 *nx = v_right + min_visible - rect.right;
2038 } else {
2039 *ny = safe_y;
2040 }
2041 }
2042
2050 static void EnsureVisibleCaption(Window *w, int nx, int ny)
2051 {
2052 /* Search for the title bar rectangle. */
2053 Rect caption_rect;
2054 const NWidgetBase *caption = w->nested_root->GetWidgetOfType(WWT_CAPTION);
2055 if (caption != nullptr) {
2056 caption_rect = caption->GetCurrentRect();
2057
2058 const int min_visible = ScaleGUITrad(MIN_VISIBLE_TITLE_BAR);
2059
2060 /* Make sure the window doesn't leave the screen */
2061 nx = Clamp(nx, min_visible - caption_rect.right, _screen.width - min_visible - caption_rect.left);
2062 ny = Clamp(ny, 0, _screen.height - min_visible);
2063
2064 /* Make sure the title bar isn't hidden behind the main tool bar or the status bar. */
2065 PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_MAIN_TOOLBAR, 0), w->left, PHD_DOWN);
2066 PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_STATUS_BAR, 0), w->left, PHD_UP);
2067 }
2068
2069 if (w->viewport != nullptr) {
2070 w->viewport->left += nx - w->left;
2071 w->viewport->top += ny - w->top;
2072 }
2073
2074 w->left = nx;
2075 w->top = ny;
2076 }
2077
2088 void ResizeWindow(Window *w, int delta_x, int delta_y, bool clamp_to_screen)
2089 {
2090 if (delta_x != 0 || delta_y != 0) {
2091 if (clamp_to_screen) {
2092 /* Determine the new right/bottom position. If that is outside of the bounds of
2093 * the resolution clamp it in such a manner that it stays within the bounds. */
2094 int new_right = w->left + w->width + delta_x;
2095 int new_bottom = w->top + w->height + delta_y;
2096 if (new_right >= (int)_screen.width) delta_x -= Ceil(new_right - _screen.width, std::max(1U, w->nested_root->resize_x));
2097 if (new_bottom >= (int)_screen.height) delta_y -= Ceil(new_bottom - _screen.height, std::max(1U, w->nested_root->resize_y));
2098 }
2099
2100 w->SetDirty();
2101
2102 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);
2103 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);
2104 assert(w->nested_root->resize_x == 0 || new_xinc % w->nested_root->resize_x == 0);
2105 assert(w->nested_root->resize_y == 0 || new_yinc % w->nested_root->resize_y == 0);
2106
2107 w->nested_root->AssignSizePosition(ST_RESIZE, 0, 0, w->nested_root->smallest_x + new_xinc, w->nested_root->smallest_y + new_yinc, _current_text_dir == TD_RTL);
2108 w->width = w->nested_root->current_x;
2109 w->height = w->nested_root->current_y;
2110 }
2111
2112 EnsureVisibleCaption(w, w->left, w->top);
2113
2114 /* Always call OnResize to make sure everything is initialised correctly if it needs to be. */
2115 w->OnResize();
2116 w->SetDirty();
2117 }
2118
2124 int GetMainViewTop()
2125 {
2126 Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
2127 return (w == nullptr) ? 0 : w->top + w->height;
2128 }
2129
2135 int GetMainViewBottom()
2136 {
2137 Window *w = FindWindowById(WC_STATUS_BAR, 0);
2138 return (w == nullptr) ? _screen.height : w->top;
2139 }
2140
2141 static bool _dragging_window;
2142
2147 static EventState HandleWindowDragging()
2148 {
2149 /* Get out immediately if no window is being dragged at all. */
2150 if (!_dragging_window) return ES_NOT_HANDLED;
2151
2152 /* If button still down, but cursor hasn't moved, there is nothing to do. */
2153 if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED;
2154
2155 /* Otherwise find the window... */
2156 for (Window *w : Window::Iterate()) {
2157 if (w->flags & WF_DRAGGING) {
2158 /* Stop the dragging if the left mouse button was released */
2159 if (!_left_button_down) {
2160 w->flags &= ~WF_DRAGGING;
2161 break;
2162 }
2163
2164 w->SetDirty();
2165
2166 int x = _cursor.pos.x + _drag_delta.x;
2167 int y = _cursor.pos.y + _drag_delta.y;
2168 int nx = x;
2169 int ny = y;
2170
2171 if (_settings_client.gui.window_snap_radius != 0) {
2172 int hsnap = _settings_client.gui.window_snap_radius;
2173 int vsnap = _settings_client.gui.window_snap_radius;
2174 int delta;
2175
2176 for (const Window *v : Window::Iterate()) {
2177 if (v == w) continue; // Don't snap at yourself
2178
2179 if (y + w->height > v->top && y < v->top + v->height) {
2180 /* Your left border <-> other right border */
2181 delta = abs(v->left + v->width - x);
2182 if (delta <= hsnap) {
2183 nx = v->left + v->width;
2184 hsnap = delta;
2185 }
2186
2187 /* Your right border <-> other left border */
2188 delta = abs(v->left - x - w->width);
2189 if (delta <= hsnap) {
2190 nx = v->left - w->width;
2191 hsnap = delta;
2192 }
2193 }
2194
2195 if (w->top + w->height >= v->top && w->top <= v->top + v->height) {
2196 /* Your left border <-> other left border */
2197 delta = abs(v->left - x);
2198 if (delta <= hsnap) {
2199 nx = v->left;
2200 hsnap = delta;
2201 }
2202
2203 /* Your right border <-> other right border */
2204 delta = abs(v->left + v->width - x - w->width);
2205 if (delta <= hsnap) {
2206 nx = v->left + v->width - w->width;
2207 hsnap = delta;
2208 }
2209 }
2210
2211 if (x + w->width > v->left && x < v->left + v->width) {
2212 /* Your top border <-> other bottom border */
2213 delta = abs(v->top + v->height - y);
2214 if (delta <= vsnap) {
2215 ny = v->top + v->height;
2216 vsnap = delta;
2217 }
2218
2219 /* Your bottom border <-> other top border */
2220 delta = abs(v->top - y - w->height);
2221 if (delta <= vsnap) {
2222 ny = v->top - w->height;
2223 vsnap = delta;
2224 }
2225 }
2226
2227 if (w->left + w->width >= v->left && w->left <= v->left + v->width) {
2228 /* Your top border <-> other top border */
2229 delta = abs(v->top - y);
2230 if (delta <= vsnap) {
2231 ny = v->top;
2232 vsnap = delta;
2233 }
2234
2235 /* Your bottom border <-> other bottom border */
2236 delta = abs(v->top + v->height - y - w->height);
2237 if (delta <= vsnap) {
2238 ny = v->top + v->height - w->height;
2239 vsnap = delta;
2240 }
2241 }
2242 }
2243 }
2244
2245 EnsureVisibleCaption(w, nx, ny);
2246
2247 w->SetDirty();
2248 return ES_HANDLED;
2249 } else if (w->flags & WF_SIZING) {
2250 /* Stop the sizing if the left mouse button was released */
2251 if (!_left_button_down) {
2252 w->flags &= ~WF_SIZING;
2253 w->SetDirty();
2254 break;
2255 }
2256
2257 /* Compute difference in pixels between cursor position and reference point in the window.
2258 * If resizing the left edge of the window, moving to the left makes the window bigger not smaller.
2259 */
2260 int x, y = _cursor.pos.y - _drag_delta.y;
2261 if (w->flags & WF_SIZING_LEFT) {
2262 x = _drag_delta.x - _cursor.pos.x;
2263 } else {
2264 x = _cursor.pos.x - _drag_delta.x;
2265 }
2266
2267 /* resize.step_width and/or resize.step_height may be 0, which means no resize is possible. */
2268 if (w->resize.step_width == 0) x = 0;
2269 if (w->resize.step_height == 0) y = 0;
2270
2271 /* Check the resize button won't go past the bottom of the screen */
2272 if (w->top + w->height + y > _screen.height) {
2273 y = _screen.height - w->height - w->top;
2274 }
2275
2276 /* X and Y has to go by step.. calculate it.
2277 * The cast to int is necessary else x/y are implicitly casted to
2278 * unsigned int, which won't work. */
2279 if (w->resize.step_width > 1) x -= x % (int)w->resize.step_width;
2280 if (w->resize.step_height > 1) y -= y % (int)w->resize.step_height;
2281
2282 /* Check that we don't go below the minimum set size */
2283 if ((int)w->width + x < (int)w->nested_root->smallest_x) {
2284 x = w->nested_root->smallest_x - w->width;
2285 }
2286 if ((int)w->height + y < (int)w->nested_root->smallest_y) {
2287 y = w->nested_root->smallest_y - w->height;
2288 }
2289
2290 /* Window already on size */
2291 if (x == 0 && y == 0) return ES_HANDLED;
2292
2293 /* Now find the new cursor pos.. this is NOT _cursor, because we move in steps. */
2294 _drag_delta.y += y;
2295 if ((w->flags & WF_SIZING_LEFT) && x != 0) {
2296 _drag_delta.x -= x; // x > 0 -> window gets longer -> left-edge moves to left -> subtract x to get new position.
2297 w->SetDirty();
2298 w->left -= x; // If dragging left edge, move left window edge in opposite direction by the same amount.
2299 /* ResizeWindow() below ensures marking new position as dirty. */
2300 } else {
2301 _drag_delta.x += x;
2302 }
2303
2304 /* ResizeWindow sets both pre- and after-size to dirty for redrawal */
2305 ResizeWindow(w, x, y);
2306 return ES_HANDLED;
2307 }
2308 }
2309
2310 _dragging_window = false;
2311 return ES_HANDLED;
2312 }
2313
2318 static void StartWindowDrag(Window *w)
2319 {
2320 w->flags |= WF_DRAGGING;
2321 w->flags &= ~WF_CENTERED;
2322 _dragging_window = true;
2323
2324 _drag_delta.x = w->left - _cursor.pos.x;
2325 _drag_delta.y = w->top - _cursor.pos.y;
2326
2327 BringWindowToFront(w);
2328 }
2329
2335 static void StartWindowSizing(Window *w, bool to_left)
2336 {
2337 w->flags |= to_left ? WF_SIZING_LEFT : WF_SIZING_RIGHT;
2338 w->flags &= ~WF_CENTERED;
2339 _dragging_window = true;
2340
2341 _drag_delta.x = _cursor.pos.x;
2342 _drag_delta.y = _cursor.pos.y;
2343
2344 BringWindowToFront(w);
2345 }
2346
2351 static void HandleScrollbarScrolling(Window *w)
2352 {
2353 int i;
2354 NWidgetScrollbar *sb = w->GetWidget<NWidgetScrollbar>(w->mouse_capture_widget);
2355 bool rtl = false;
2356
2357 if (sb->type == NWID_HSCROLLBAR) {
2358 i = _cursor.pos.x - _cursorpos_drag_start.x;
2359 rtl = _current_text_dir == TD_RTL;
2360 } else {
2361 i = _cursor.pos.y - _cursorpos_drag_start.y;
2362 }
2363
2364 if (sb->disp_flags & ND_SCROLLBAR_BTN) {
2365 if (_scroller_click_timeout == 1) {
2366 _scroller_click_timeout = 3;
2367 if (sb->UpdatePosition(rtl == HasBit(sb->disp_flags, NDB_SCROLLBAR_UP) ? 1 : -1)) w->SetDirty();
2368 }
2369 return;
2370 }
2371
2372 /* Find the item we want to move to and make sure it's inside bounds. */
2373 int pos = std::min(RoundDivSU(std::max(0, i + _scrollbar_start_pos) * sb->GetCount(), _scrollbar_size), std::max(0, sb->GetCount() - sb->GetCapacity()));
2374 if (rtl) pos = std::max(0, sb->GetCount() - sb->GetCapacity() - pos);
2375 if (pos != sb->GetPosition()) {
2376 sb->SetPosition(pos);
2377 w->SetDirty();
2378 }
2379 }
2380
2385 static EventState HandleActiveWidget()
2386 {
2387 for (Window *w : Window::Iterate()) {
2388 if (w->mouse_capture_widget >= 0) {
2389 /* Abort if no button is clicked any more. */
2390 if (!_left_button_down) {
2391 w->SetWidgetDirty(w->mouse_capture_widget);
2392 w->mouse_capture_widget = -1;
2393 return ES_HANDLED;
2394 }
2395
2396 /* Handle scrollbar internally, or dispatch click event */
2397 WidgetType type = w->GetWidget<NWidgetBase>(w->mouse_capture_widget)->type;
2398 if (type == NWID_VSCROLLBAR || type == NWID_HSCROLLBAR) {
2399 HandleScrollbarScrolling(w);
2400 } else {
2401 /* If cursor hasn't moved, there is nothing to do. */
2402 if (_cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED;
2403
2404 Point pt = { _cursor.pos.x - w->left, _cursor.pos.y - w->top };
2405 w->OnClick(pt, w->mouse_capture_widget, 0);
2406 }
2407 return ES_HANDLED;
2408 }
2409 }
2410
2411 return ES_NOT_HANDLED;
2412 }
2413
2418 static EventState HandleViewportScroll()
2419 {
2420 bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
2421
2422 if (!_scrolling_viewport) return ES_NOT_HANDLED;
2423
2424 /* When we don't have a last scroll window we are starting to scroll.
2425 * When the last scroll window and this are not the same we went
2426 * outside of the window and should not left-mouse scroll anymore. */
2427 if (_last_scroll_window == nullptr) _last_scroll_window = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
2428
2429 if (_last_scroll_window == nullptr || !((_settings_client.gui.scroll_mode != VSM_MAP_LMB && _right_button_down) || scrollwheel_scrolling || (_settings_client.gui.scroll_mode == VSM_MAP_LMB && _left_button_down))) {
2430 _cursor.fix_at = false;
2431 _scrolling_viewport = false;
2432 _last_scroll_window = nullptr;
2433 return ES_NOT_HANDLED;
2434 }
2435
2436 if (_last_scroll_window == FindWindowById(WC_MAIN_WINDOW, 0) && _last_scroll_window->viewport->follow_vehicle != INVALID_VEHICLE) {
2437 /* If the main window is following a vehicle, then first let go of it! */
2438 const Vehicle *veh = Vehicle::Get(_last_scroll_window->viewport->follow_vehicle);
2439 ScrollMainWindowTo(veh->x_pos, veh->y_pos, veh->z_pos, true); // This also resets follow_vehicle
2440 return ES_NOT_HANDLED;
2441 }
2442
2443 Point delta;
2444 if (scrollwheel_scrolling) {
2445 /* We are using scrollwheels for scrolling */
2446 delta.x = _cursor.h_wheel;
2447 delta.y = _cursor.v_wheel;
2448 _cursor.v_wheel = 0;
2449 _cursor.h_wheel = 0;
2450 } else {
2451 if (_settings_client.gui.scroll_mode != VSM_VIEWPORT_RMB_FIXED) {
2452 delta.x = -_cursor.delta.x;
2453 delta.y = -_cursor.delta.y;
2454 } else {
2455 delta.x = _cursor.delta.x;
2456 delta.y = _cursor.delta.y;
2457 }
2458 }
2459
2460 /* Create a scroll-event and send it to the window */
2461 if (delta.x != 0 || delta.y != 0) _last_scroll_window->OnScroll(delta);
2462
2463 _cursor.delta.x = 0;
2464 _cursor.delta.y = 0;
2465 return ES_HANDLED;
2466 }
2467
2478 static bool MaybeBringWindowToFront(Window *w)
2479 {
2480 bool bring_to_front = false;
2481
2482 if (w->window_class == WC_MAIN_WINDOW ||
2483 IsVitalWindow(w) ||
2484 w->window_class == WC_TOOLTIPS ||
2485 w->window_class == WC_DROPDOWN_MENU) {
2486 return true;
2487 }
2488
2489 /* Use unshaded window size rather than current size for shaded windows. */
2490 int w_width = w->width;
2491 int w_height = w->height;
2492 if (w->IsShaded()) {
2493 w_width = w->unshaded_size.width;
2494 w_height = w->unshaded_size.height;
2495 }
2496
2497 Window::IteratorToFront it(w);
2498 ++it;
2499 for (; !it.IsEnd(); ++it) {
2500 Window *u = *it;
2501 /* A modal child will prevent the activation of the parent window */
2502 if (u->parent == w && (u->window_desc->flags & WDF_MODAL)) {
2503 u->SetWhiteBorder();
2504 u->SetDirty();
2505 return false;
2506 }
2507
2508 if (u->window_class == WC_MAIN_WINDOW ||
2509 IsVitalWindow(u) ||
2510 u->window_class == WC_TOOLTIPS ||
2511 u->window_class == WC_DROPDOWN_MENU) {
2512 continue;
2513 }
2514
2515 /* Window sizes don't interfere, leave z-order alone */
2516 if (w->left + w_width <= u->left ||
2517 u->left + u->width <= w->left ||
2518 w->top + w_height <= u->top ||
2519 u->top + u->height <= w->top) {
2520 continue;
2521 }
2522
2523 bring_to_front = true;
2524 }
2525
2526 if (bring_to_front) BringWindowToFront(w);
2527 return true;
2528 }
2529
2538 EventState Window::HandleEditBoxKey(int wid, WChar key, uint16 keycode)
2539 {
2540 QueryString *query = this->GetQueryString(wid);
2541 if (query == nullptr) return ES_NOT_HANDLED;
2542
2543 int action = QueryString::ACTION_NOTHING;
2544
2545 switch (query->text.HandleKeyPress(key, keycode)) {
2546 case HKPR_EDITING:
2547 this->SetWidgetDirty(wid);
2548 this->OnEditboxChanged(wid);
2549 break;
2550
2551 case HKPR_CURSOR:
2552 this->SetWidgetDirty(wid);
2553 /* For the OSK also invalidate the parent window */
2554 if (this->window_class == WC_OSK) this->InvalidateData();
2555 break;
2556
2557 case HKPR_CONFIRM:
2558 if (this->window_class == WC_OSK) {
2559 this->OnClick(Point(), WID_OSK_OK, 1);
2560 } else if (query->ok_button >= 0) {
2561 this->OnClick(Point(), query->ok_button, 1);
2562 } else {
2563 action = query->ok_button;
2564 }
2565 break;
2566
2567 case HKPR_CANCEL:
2568 if (this->window_class == WC_OSK) {
2569 this->OnClick(Point(), WID_OSK_CANCEL, 1);
2570 } else if (query->cancel_button >= 0) {
2571 this->OnClick(Point(), query->cancel_button, 1);
2572 } else {
2573 action = query->cancel_button;
2574 }
2575 break;
2576
2577 case HKPR_NOT_HANDLED:
2578 return ES_NOT_HANDLED;
2579
2580 default: break;
2581 }
2582
2583 switch (action) {
2584 case QueryString::ACTION_DESELECT:
2585 this->UnfocusFocusedWidget();
2586 break;
2587
2588 case QueryString::ACTION_CLEAR:
2589 if (query->text.bytes <= 1) {
2590 /* If already empty, unfocus instead */
2591 this->UnfocusFocusedWidget();
2592 } else {
2593 query->text.DeleteAll();
2594 this->SetWidgetDirty(wid);
2595 this->OnEditboxChanged(wid);
2596 }
2597 break;
2598
2599 default:
2600 break;
2601 }
2602
2603 return ES_HANDLED;
2604 }
2605
2610 void HandleToolbarHotkey(int hotkey)
2611 {
2612 assert(HasModalProgress() || IsLocalCompany());
2613
2614 Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
2615 if (w != nullptr) {
2616 if (w->window_desc->hotkeys != nullptr) {
2617 if (hotkey >= 0 && w->OnHotkey(hotkey) == ES_HANDLED) return;
2618 }
2619 }
2620 }
2621
2627 void HandleKeypress(uint keycode, WChar key)
2628 {
2629 /* World generation is multithreaded and messes with companies.
2630 * But there is no company related window open anyway, so _current_company is not used. */
2631 assert(HasModalProgress() || IsLocalCompany());
2632
2633 /*
2634 * The Unicode standard defines an area called the private use area. Code points in this
2635 * area are reserved for private use and thus not portable between systems. For instance,
2636 * Apple defines code points for the arrow keys in this area, but these are only printable
2637 * on a system running OS X. We don't want these keys to show up in text fields and such,
2638 * and thus we have to clear the unicode character when we encounter such a key.
2639 */
2640 if (key >= 0xE000 && key <= 0xF8FF) key = 0;
2641
2642 /*
2643 * If both key and keycode is zero, we don't bother to process the event.
2644 */
2645 if (key == 0 && keycode == 0) return;
2646
2647 /* Check if the focused window has a focused editbox */
2648 if (EditBoxInGlobalFocus()) {
2649 /* All input will in this case go to the focused editbox */
2650 if (_focused_window->window_class == WC_CONSOLE) {
2651 if (_focused_window->OnKeyPress(key, keycode) == ES_HANDLED) return;
2652 } else {
2653 if (_focused_window->HandleEditBoxKey(_focused_window->nested_focus->index, key, keycode) == ES_HANDLED) return;
2654 }
2655 }
2656
2657 /* Call the event, start with the uppermost window, but ignore the toolbar. */
2658 for (Window *w : Window::IterateFromFront()) {
2659 if (w->window_class == WC_MAIN_TOOLBAR) continue;
2660 if (w->window_desc->hotkeys != nullptr) {
2661 int hotkey = w->window_desc->hotkeys->CheckMatch(keycode);
2662 if (hotkey >= 0 && w->OnHotkey(hotkey) == ES_HANDLED) return;
2663 }
2664 if (w->OnKeyPress(key, keycode) == ES_HANDLED) return;
2665 }
2666
2667 Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
2668 /* When there is no toolbar w is null, check for that */
2669 if (w != nullptr) {
2670 if (w->window_desc->hotkeys != nullptr) {
2671 int hotkey = w->window_desc->hotkeys->CheckMatch(keycode);
2672 if (hotkey >= 0 && w->OnHotkey(hotkey) == ES_HANDLED) return;
2673 }
2674 if (w->OnKeyPress(key, keycode) == ES_HANDLED) return;
2675 }
2676
2677 HandleGlobalHotkeys(key, keycode);
2678 }
2679
2683 void HandleCtrlChanged()
2684 {
2685 /* Call the event, start with the uppermost window. */
2686 for (Window *w : Window::IterateFromFront()) {
2687 if (w->OnCTRLStateChange() == ES_HANDLED) return;
2688 }
2689 }
2690
2696 /* virtual */ void Window::InsertTextString(int wid, const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end)
2697 {
2698 QueryString *query = this->GetQueryString(wid);
2699 if (query == nullptr) return;
2700
2701 if (query->text.InsertString(str, marked, caret, insert_location, replacement_end) || marked) {
2702 this->SetWidgetDirty(wid);
2703 this->OnEditboxChanged(wid);
2704 }
2705 }
2706
2713 void HandleTextInput(const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end)
2714 {
2715 if (!EditBoxInGlobalFocus()) return;
2716
2717 _focused_window->InsertTextString(_focused_window->window_class == WC_CONSOLE ? 0 : _focused_window->nested_focus->index, str, marked, caret, insert_location, replacement_end);
2718 }
2719
2726 static int _input_events_this_tick = 0;
2727
2732 static void HandleAutoscroll()
2733 {
2734 if (_game_mode == GM_MENU || HasModalProgress()) return;
2735 if (_settings_client.gui.auto_scrolling == VA_DISABLED) return;
2736 if (_settings_client.gui.auto_scrolling == VA_MAIN_VIEWPORT_FULLSCREEN && !_fullscreen) return;
2737
2738 int x = _cursor.pos.x;
2739 int y = _cursor.pos.y;
2740 Window *w = FindWindowFromPt(x, y);
2741 if (w == nullptr || w->flags & WF_DISABLE_VP_SCROLL) return;
2742 if (_settings_client.gui.auto_scrolling != VA_EVERY_VIEWPORT && w->window_class != WC_MAIN_WINDOW) return;
2743
2744 Viewport *vp = IsPtInWindowViewport(w, x, y);
2745 if (vp == nullptr) return;
2746
2747 x -= vp->left;
2748 y -= vp->top;
2749
2750 /* here allows scrolling in both x and y axis */
2751 static const int SCROLLSPEED = 3;
2752 if (x - 15 < 0) {
2753 w->viewport->dest_scrollpos_x += ScaleByZoom((x - 15) * SCROLLSPEED, vp->zoom);
2754 } else if (15 - (vp->width - x) > 0) {
2755 w->viewport->dest_scrollpos_x += ScaleByZoom((15 - (vp->width - x)) * SCROLLSPEED, vp->zoom);
2756 }
2757 if (y - 15 < 0) {
2758 w->viewport->dest_scrollpos_y += ScaleByZoom((y - 15) * SCROLLSPEED, vp->zoom);
2759 } else if (15 - (vp->height - y) > 0) {
2760 w->viewport->dest_scrollpos_y += ScaleByZoom((15 - (vp->height - y)) * SCROLLSPEED, vp->zoom);
2761 }
2762 }
2763
2764 enum MouseClick {
2765 MC_NONE = 0,
2766 MC_LEFT,
2767 MC_RIGHT,
2768 MC_DOUBLE_LEFT,
2769 MC_HOVER,
2770
2771 MAX_OFFSET_DOUBLE_CLICK = 5,
2772 MAX_OFFSET_HOVER = 5,
2773 };
2774 extern EventState VpHandlePlaceSizingDrag();
2775
2776 const std::chrono::milliseconds TIME_BETWEEN_DOUBLE_CLICK(500);
2777
2778 static void ScrollMainViewport(int x, int y)
2779 {
2780 if (_game_mode != GM_MENU) {
2781 Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
2782 assert(w);
2783
2784 w->viewport->dest_scrollpos_x += ScaleByZoom(x, w->viewport->zoom);
2785 w->viewport->dest_scrollpos_y += ScaleByZoom(y, w->viewport->zoom);
2786 }
2787 }
2788
2798 static const int8 scrollamt[16][2] = {
2799 { 0, 0},
2800 {-2, 0},
2801 { 0, -2},
2802 {-2, -1},
2803 { 2, 0},
2804 { 0, 0},
2805 { 2, -1},
2806 { 0, -2},
2807 { 0, 2},
2808 {-2, 1},
2809 { 0, 0},
2810 {-2, 0},
2811 { 2, 1},
2812 { 0, 2},
2813 { 2, 0},
2814 { 0, 0},
2815 };
2816
2817 static void HandleKeyScrolling()
2818 {
2819 /*
2820 * Check that any of the dirkeys is pressed and that the focused window
2821 * doesn't have an edit-box as focused widget.
2822 */
2823 if (_dirkeys && !EditBoxInGlobalFocus()) {
2824 int factor = _shift_pressed ? 50 : 10;
2825 ScrollMainViewport(scrollamt[_dirkeys][0] * factor, scrollamt[_dirkeys][1] * factor);
2826 }
2827 }
2828
2829 static void MouseLoop(MouseClick click, int mousewheel)
2830 {
2831 /* World generation is multithreaded and messes with companies.
2832 * But there is no company related window open anyway, so _current_company is not used. */
2833 assert(HasModalProgress() || IsLocalCompany());
2834
2835 HandlePlacePresize();
2836 UpdateTileSelection();
2837
2838 if (VpHandlePlaceSizingDrag() == ES_HANDLED) return;
2839 if (HandleMouseDragDrop() == ES_HANDLED) return;
2840 if (HandleWindowDragging() == ES_HANDLED) return;
2841 if (HandleActiveWidget() == ES_HANDLED) return;
2842 if (HandleViewportScroll() == ES_HANDLED) return;
2843
2844 HandleMouseOver();
2845
2846 bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
2847 if (click == MC_NONE && mousewheel == 0 && !scrollwheel_scrolling) return;
2848
2849 int x = _cursor.pos.x;
2850 int y = _cursor.pos.y;
2851 Window *w = FindWindowFromPt(x, y);
2852 if (w == nullptr) return;
2853
2854 if (click != MC_HOVER && !MaybeBringWindowToFront(w)) return;
2855 Viewport *vp = IsPtInWindowViewport(w, x, y);
2856
2857 /* Don't allow any action in a viewport if either in menu or when having a modal progress window */
2858 if (vp != nullptr && (_game_mode == GM_MENU || HasModalProgress())) return;
2859
2860 if (mousewheel != 0) {
2861 /* Send mousewheel event to window, unless we're scrolling a viewport or the map */
2862 if (!scrollwheel_scrolling || (vp == nullptr && w->window_class != WC_SMALLMAP)) w->OnMouseWheel(mousewheel);
2863
2864 /* Dispatch a MouseWheelEvent for widgets if it is not a viewport */
2865 if (vp == nullptr) DispatchMouseWheelEvent(w, w->nested_root->GetWidgetFromPos(x - w->left, y - w->top), mousewheel);
2866 }
2867
2868 if (vp != nullptr) {
2869 if (scrollwheel_scrolling && !(w->flags & WF_DISABLE_VP_SCROLL)) {
2870 _scrolling_viewport = true;
2871 _cursor.fix_at = true;
2872 return;
2873 }
2874
2875 switch (click) {
2876 case MC_DOUBLE_LEFT:
2877 case MC_LEFT:
2878 if (HandleViewportClicked(vp, x, y)) return;
2879 if (!(w->flags & WF_DISABLE_VP_SCROLL) &&
2880 _settings_client.gui.scroll_mode == VSM_MAP_LMB) {
2881 _scrolling_viewport = true;
2882 _cursor.fix_at = false;
2883 return;
2884 }
2885 break;
2886
2887 case MC_RIGHT:
2888 if (!(w->flags & WF_DISABLE_VP_SCROLL) &&
2889 _settings_client.gui.scroll_mode != VSM_MAP_LMB) {
2890 _scrolling_viewport = true;
2891 _cursor.fix_at = (_settings_client.gui.scroll_mode == VSM_VIEWPORT_RMB_FIXED ||
2892 _settings_client.gui.scroll_mode == VSM_MAP_RMB_FIXED);
2893 DispatchRightClickEvent(w, x - w->left, y - w->top);
2894 return;
2895 }
2896 break;
2897
2898 default:
2899 break;
2900 }
2901 }
2902
2903 switch (click) {
2904 case MC_LEFT:
2905 case MC_DOUBLE_LEFT:
2906 DispatchLeftClickEvent(w, x - w->left, y - w->top, click == MC_DOUBLE_LEFT ? 2 : 1);
2907 return;
2908
2909 default:
2910 if (!scrollwheel_scrolling || w == nullptr || w->window_class != WC_SMALLMAP) break;
2911 /* We try to use the scrollwheel to scroll since we didn't touch any of the buttons.
2912 * Simulate a right button click so we can get started. */
2913 FALLTHROUGH;
2914
2915 case MC_RIGHT:
2916 DispatchRightClickEvent(w, x - w->left, y - w->top);
2917 return;
2918
2919 case MC_HOVER:
2920 DispatchHoverEvent(w, x - w->left, y - w->top);
2921 break;
2922 }
2923
2924 /* We're not doing anything with 2D scrolling, so reset the value. */
2925 _cursor.h_wheel = 0;
2926 _cursor.v_wheel = 0;
2927 }
2928
2932 void HandleMouseEvents()
2933 {
2934 /* World generation is multithreaded and messes with companies.
2935 * But there is no company related window open anyway, so _current_company is not used. */
2936 assert(HasModalProgress() || IsLocalCompany());
2937
2938 /* Handle sprite picker before any GUI interaction */
2939 if (_newgrf_debug_sprite_picker.mode == SPM_REDRAW && _input_events_this_tick == 0) {
2940 /* We are done with the last draw-frame, so we know what sprites we
2941 * clicked on. Reset the picker mode and invalidate the window. */
2942 _newgrf_debug_sprite_picker.mode = SPM_NONE;
2943 InvalidateWindowData(WC_SPRITE_ALIGNER, 0, 1);
2944 }
2945
2946 static std::chrono::steady_clock::time_point double_click_time = {};
2947 static Point double_click_pos = {0, 0};
2948
2949 /* Mouse event? */
2950 MouseClick click = MC_NONE;
2951 if (_left_button_down && !_left_button_clicked) {
2952 click = MC_LEFT;
2953 if (std::chrono::steady_clock::now() <= double_click_time + TIME_BETWEEN_DOUBLE_CLICK &&
2954 double_click_pos.x != 0 && abs(_cursor.pos.x - double_click_pos.x) < MAX_OFFSET_DOUBLE_CLICK &&
2955 double_click_pos.y != 0 && abs(_cursor.pos.y - double_click_pos.y) < MAX_OFFSET_DOUBLE_CLICK) {
2956 click = MC_DOUBLE_LEFT;
2957 }
2958 double_click_time = std::chrono::steady_clock::now();
2959 double_click_pos = _cursor.pos;
2960 _left_button_clicked = true;
2961 _input_events_this_tick++;
2962 } else if (_right_button_clicked) {
2963 _right_button_clicked = false;
2964 click = MC_RIGHT;
2965 _input_events_this_tick++;
2966 }
2967
2968 int mousewheel = 0;
2969 if (_cursor.wheel) {
2970 mousewheel = _cursor.wheel;
2971 _cursor.wheel = 0;
2972 _input_events_this_tick++;
2973 }
2974
2975 static std::chrono::steady_clock::time_point hover_time = {};
2976 static Point hover_pos = {0, 0};
2977
2978 if (_settings_client.gui.hover_delay_ms > 0) {
2979 if (!_cursor.in_window || click != MC_NONE || mousewheel != 0 || _left_button_down || _right_button_down ||
2980 hover_pos.x == 0 || abs(_cursor.pos.x - hover_pos.x) >= MAX_OFFSET_HOVER ||
2981 hover_pos.y == 0 || abs(_cursor.pos.y - hover_pos.y) >= MAX_OFFSET_HOVER) {
2982 hover_pos = _cursor.pos;
2983 hover_time = std::chrono::steady_clock::now();
2984 _mouse_hovering = false;
2985 } else if (!_mouse_hovering) {
2986 if (std::chrono::steady_clock::now() > hover_time + std::chrono::milliseconds(_settings_client.gui.hover_delay_ms)) {
2987 click = MC_HOVER;
2988 _input_events_this_tick++;
2989 _mouse_hovering = true;
2990 hover_time = std::chrono::steady_clock::now();
2991 }
2992 }
2993 }
2994
2995 if (click == MC_LEFT && _newgrf_debug_sprite_picker.mode == SPM_WAIT_CLICK) {
2996 /* Mark whole screen dirty, and wait for the next realtime tick, when drawing is finished. */
2997 Blitter *blitter = BlitterFactory::GetCurrentBlitter();
2998 _newgrf_debug_sprite_picker.clicked_pixel = blitter->MoveTo(_screen.dst_ptr, _cursor.pos.x, _cursor.pos.y);
2999 _newgrf_debug_sprite_picker.sprites.clear();
3000 _newgrf_debug_sprite_picker.mode = SPM_REDRAW;
3001 MarkWholeScreenDirty();
3002 } else {
3003 MouseLoop(click, mousewheel);
3004 }
3005
3006 /* We have moved the mouse the required distance,
3007 * no need to move it at any later time. */
3008 _cursor.delta.x = 0;
3009 _cursor.delta.y = 0;
3010 }
3011
3015 static void CheckSoftLimit()
3016 {
3017 if (_settings_client.gui.window_soft_limit == 0) return;
3018
3019 for (;;) {
3020 uint deletable_count = 0;
3021 Window *last_deletable = nullptr;
3022 for (Window *w : Window::IterateFromFront()) {
3023 if (w->window_class == WC_MAIN_WINDOW || IsVitalWindow(w) || (w->flags & WF_STICKY)) continue;
3024
3025 last_deletable = w;
3026 deletable_count++;
3027 }
3028
3029 /* We've not reached the soft limit yet. */
3030 if (deletable_count <= _settings_client.gui.window_soft_limit) break;
3031
3032 assert(last_deletable != nullptr);
3033 last_deletable->Close();
3034 }
3035 }
3036
3040 void InputLoop()
3041 {
3042 /* World generation is multithreaded and messes with companies.
3043 * But there is no company related window open anyway, so _current_company is not used. */
3044 assert(HasModalProgress() || IsLocalCompany());
3045
3046 CheckSoftLimit();
3047
3048 /* Process scheduled window deletion. */
3049 Window::DeleteClosedWindows();
3050
3051 if (_input_events_this_tick != 0) {
3052 /* The input loop is called only once per GameLoop() - so we can clear the counter here */
3053 _input_events_this_tick = 0;
3054 /* there were some inputs this tick, don't scroll ??? */
3055 return;
3056 }
3057
3058 /* HandleMouseEvents was already called for this tick */
3059 HandleMouseEvents();
3060 }
3061
3065 void CallWindowRealtimeTickEvent(uint delta_ms)
3066 {
3067 for (Window *w : Window::Iterate()) {
3068 w->OnRealtimeTick(delta_ms);
3069 }
3070 }
3071
3075 void UpdateWindows()
3076 {
3077 static std::chrono::steady_clock::time_point last_time = std::chrono::steady_clock::now();
3078 uint delta_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - last_time).count();
3079
3080 if (delta_ms == 0) return;
3081
3082 last_time = std::chrono::steady_clock::now();
3083
3084 PerformanceMeasurer framerate(PFE_DRAWING);
3085 PerformanceAccumulator::Reset(PFE_DRAWWORLD);
3086
3087 extern void ProcessPendingPerformanceMeasurements();
3088 ProcessPendingPerformanceMeasurements();
3089
3090 CallWindowRealtimeTickEvent(delta_ms);
3091
3092 static GUITimer network_message_timer = GUITimer(1);
3093 if (network_message_timer.Elapsed(delta_ms)) {
3094 network_message_timer.SetInterval(1000);
3095 NetworkChatMessageLoop();
3096 }
3097
3098 /* Process invalidations before anything else. */
3099 for (Window *w : Window::Iterate()) {
3100 w->ProcessScheduledInvalidations();
3101 w->ProcessHighlightedInvalidations();
3102 }
3103
3104 static GUITimer window_timer = GUITimer(1);
3105 if (window_timer.Elapsed(delta_ms)) {
3106 if (_network_dedicated) window_timer.SetInterval(MILLISECONDS_PER_TICK);
3107
3108 extern int _caret_timer;
3109 _caret_timer += 3;
3110 CursorTick();
3111
3112 HandleKeyScrolling();
3113 HandleAutoscroll();
3114 DecreaseWindowCounters();
3115 }
3116
3117 static GUITimer highlight_timer = GUITimer(1);
3118 if (highlight_timer.Elapsed(delta_ms)) {
3119 highlight_timer.SetInterval(450);
3120 _window_highlight_colour = !_window_highlight_colour;
3121 }
3122
3123 if (!_pause_mode || _game_mode == GM_EDITOR || _settings_game.construction.command_pause_level > CMDPL_NO_CONSTRUCTION) MoveAllTextEffects(delta_ms);
3124
3125 /* Skip the actual drawing on dedicated servers without screen.
3126 * But still empty the invalidation queues above. */
3127 if (_network_dedicated) return;
3128
3129 if (window_timer.HasElapsed()) {
3130 window_timer.SetInterval(MILLISECONDS_PER_TICK);
3131
3132 for (Window *w : Window::Iterate()) {
3133 if ((w->flags & WF_WHITE_BORDER) && --w->white_border_timer == 0) {
3134 CLRBITS(w->flags, WF_WHITE_BORDER);
3135 w->SetDirty();
3136 }
3137 }
3138 }
3139
3140 DrawDirtyBlocks();
3141
3142 for (Window *w : Window::Iterate()) {
3143 /* Update viewport only if window is not shaded. */
3144 if (w->viewport != nullptr && !w->IsShaded()) UpdateViewportPosition(w);
3145 }
3146 NetworkDrawChatMessage();
3147 /* Redraw mouse cursor in case it was hidden */
3148 DrawMouseCursor();
3149 }
3150
3156 void SetWindowDirty(WindowClass cls, WindowNumber number)
3157 {
3158 for (const Window *w : Window::Iterate()) {
3159 if (w->window_class == cls && w->window_number == number) w->SetDirty();
3160 }
3161 }
3162
3169 void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
3170 {
3171 for (const Window *w : Window::Iterate()) {
3172 if (w->window_class == cls && w->window_number == number) {
3173 w->SetWidgetDirty(widget_index);
3174 }
3175 }
3176 }
3177
3182 void SetWindowClassesDirty(WindowClass cls)
3183 {
3184 for (const Window *w : Window::Iterate()) {
3185 if (w->window_class == cls) w->SetDirty();
3186 }
3187 }
3188
3194 void Window::InvalidateData(int data, bool gui_scope)
3195 {
3196 this->SetDirty();
3197 if (!gui_scope) {
3198 /* Schedule GUI-scope invalidation for next redraw. */
3199 this->scheduled_invalidation_data.push_back(data);
3200 }
3201 this->OnInvalidateData(data, gui_scope);
3202 }
3203
3207 void Window::ProcessScheduledInvalidations()
3208 {
3209 for (int data : this->scheduled_invalidation_data) {
3210 if (this->window_class == WC_INVALID) break;
3211 this->OnInvalidateData(data, true);
3212 }
3213 this->scheduled_invalidation_data.clear();
3214 }
3215
3219 void Window::ProcessHighlightedInvalidations()
3220 {
3221 if ((this->flags & WF_HIGHLIGHTED) == 0) return;
3222
3223 for (uint i = 0; i < this->nested_array_size; i++) {
3224 if (this->IsWidgetHighlighted(i)) this->SetWidgetDirty(i);
3225 }
3226 }
3227
3254 void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
3255 {
3256 for (Window *w : Window::Iterate()) {
3257 if (w->window_class == cls && w->window_number == number) {
3258 w->InvalidateData(data, gui_scope);
3259 }
3260 }
3261 }
3262
3271 void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
3272 {
3273 for (Window *w : Window::Iterate()) {
3274 if (w->window_class == cls) {
3275 w->InvalidateData(data, gui_scope);
3276 }
3277 }
3278 }
3279
3283 void CallWindowGameTickEvent()
3284 {
3285 for (Window *w : Window::Iterate()) {
3286 w->OnGameTick();
3287 }
3288 }
3289
3296 void CloseNonVitalWindows()
3297 {
3298 /* Note: the container remains stable, even when deleting windows. */
3299 for (Window *w : Window::Iterate()) {
3300 if (w->window_class != WC_MAIN_WINDOW &&
3301 w->window_class != WC_SELECT_GAME &&
3302 w->window_class != WC_MAIN_TOOLBAR &&
3303 w->window_class != WC_STATUS_BAR &&
3304 w->window_class != WC_TOOLTIPS &&
3305 (w->flags & WF_STICKY) == 0) { // do not delete windows which are 'pinned'
3306
3307 w->Close();
3308 }
3309 }
3310 }
3311
3319 void CloseAllNonVitalWindows()
3320 {
3321 /* Close every window except for stickied ones, then sticky ones as well */
3322 CloseNonVitalWindows();
3323
3324 /* Note: the container remains stable, even when closing windows. */
3325 for (Window *w : Window::Iterate()) {
3326 if (w->flags & WF_STICKY) {
3327 w->Close();
3328 }
3329 }
3330 }
3331
3335 void DeleteAllMessages()
3336 {
3337 InitNewsItemStructs();
3338 InvalidateWindowData(WC_STATUS_BAR, 0, SBI_NEWS_DELETED); // invalidate the statusbar
3339 InvalidateWindowData(WC_MESSAGE_HISTORY, 0); // invalidate the message history
3340 CloseWindowById(WC_NEWS_WINDOW, 0); // close newspaper or general message window if shown
3341 }
3342
3347 void CloseConstructionWindows()
3348 {
3349 /* Note: the container remains stable, even when deleting windows. */
3350 for (Window *w : Window::Iterate()) {
3351 if (w->window_desc->flags & WDF_CONSTRUCTION) {
3352 w->Close();
3353 }
3354 }
3355
3356 for (const Window *w : Window::Iterate()) w->SetDirty();
3357 }
3358
3360 void HideVitalWindows()
3361 {
3362 CloseWindowById(WC_MAIN_TOOLBAR, 0);
3363 CloseWindowById(WC_STATUS_BAR, 0);
3364 }
3365
3366 void ReInitWindow(Window *w, bool zoom_changed)
3367 {
3368 if (w == nullptr) return;
3369 if (zoom_changed) {
3370 w->nested_root->AdjustPaddingForZoom();
3371 w->UpdateQueryStringSize();
3372 }
3373 w->ReInit();
3374 }
3375
3377 void ReInitAllWindows(bool zoom_changed)
3378 {
3379 SetupWidgetDimensions();
3380 NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
3381 NWidgetScrollbar::InvalidateDimensionCache();
3382
3383 extern void InitDepotWindowBlockSizes();
3384 InitDepotWindowBlockSizes();
3385
3386 /* When _gui_zoom has changed, we need to resize toolbar and statusbar first,
3387 * so EnsureVisibleCaption uses the updated size information. */
3388 ReInitWindow(FindWindowById(WC_MAIN_TOOLBAR, 0), zoom_changed);
3389 ReInitWindow(FindWindowById(WC_STATUS_BAR, 0), zoom_changed);
3390 for (Window *w : Window::Iterate()) {
3391 if (w->window_class == WC_MAIN_TOOLBAR || w->window_class == WC_STATUS_BAR) continue;
3392 ReInitWindow(w, zoom_changed);
3393 }
3394
3395 void NetworkReInitChatBoxSize();
3396 NetworkReInitChatBoxSize();
3397
3398 /* Make sure essential parts of all windows are visible */
3399 RelocateAllWindows(_screen.width, _screen.height);
3400 MarkWholeScreenDirty();
3401 }
3402
3410 static int PositionWindow(Window *w, WindowClass clss, int setting)
3411 {
3412 if (w == nullptr || w->window_class != clss) {
3413 w = FindWindowById(clss, 0);
3414 }
3415 if (w == nullptr) return 0;
3416
3417 int old_left = w->left;
3418 switch (setting) {
3419 case 1: w->left = (_screen.width - w->width) / 2; break;
3420 case 2: w->left = _screen.width - w->width; break;
3421 default: w->left = 0; break;
3422 }
3423 if (w->viewport != nullptr) w->viewport->left += w->left - old_left;
3424 AddDirtyBlock(0, w->top, _screen.width, w->top + w->height); // invalidate the whole row
3425 return w->left;
3426 }
3427
3433 int PositionMainToolbar(Window *w)
3434 {
3435 Debug(misc, 5, "Repositioning Main Toolbar...");
3436 return PositionWindow(w, WC_MAIN_TOOLBAR, _settings_client.gui.toolbar_pos);
3437 }
3438
3444 int PositionStatusbar(Window *w)
3445 {
3446 Debug(misc, 5, "Repositioning statusbar...");
3447 return PositionWindow(w, WC_STATUS_BAR, _settings_client.gui.statusbar_pos);
3448 }
3449
3455 int PositionNewsMessage(Window *w)
3456 {
3457 Debug(misc, 5, "Repositioning news message...");
3458 return PositionWindow(w, WC_NEWS_WINDOW, _settings_client.gui.statusbar_pos);
3459 }
3460
3466 int PositionNetworkChatWindow(Window *w)
3467 {
3468 Debug(misc, 5, "Repositioning network chat window...");
3469 return PositionWindow(w, WC_SEND_NETWORK_MSG, _settings_client.gui.statusbar_pos);
3470 }
3471
3472
3478 void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index)
3479 {
3480 for (const Window *w : Window::Iterate()) {
3481 if (w->viewport != nullptr && w->viewport->follow_vehicle == from_index) {
3482 w->viewport->follow_vehicle = to_index;
3483 w->SetDirty();
3484 }
3485 }
3486 }
3487
3488
3494 void RelocateAllWindows(int neww, int newh)
3495 {
3496 CloseWindowByClass(WC_DROPDOWN_MENU);
3497
3498 for (Window *w : Window::Iterate()) {
3499 int left, top;
3500 /* XXX - this probably needs something more sane. For example specifying
3501 * in a 'backup'-desc that the window should always be centered. */
3502 switch (w->window_class) {
3503 case WC_MAIN_WINDOW:
3504 case WC_BOOTSTRAP:
3505 ResizeWindow(w, neww, newh);
3506 continue;
3507
3508 case WC_MAIN_TOOLBAR:
3509 ResizeWindow(w, std::min<uint>(neww, _toolbar_width) - w->width, 0, false);
3510
3511 top = w->top;
3512 left = PositionMainToolbar(w); // changes toolbar orientation
3513 break;
3514
3515 case WC_NEWS_WINDOW:
3516 top = newh - w->height;
3517 left = PositionNewsMessage(w);
3518 break;
3519
3520 case WC_STATUS_BAR:
3521 ResizeWindow(w, std::min<uint>(neww, _toolbar_width) - w->width, 0, false);
3522
3523 top = newh - w->height;
3524 left = PositionStatusbar(w);
3525 break;
3526
3527 case WC_SEND_NETWORK_MSG:
3528 ResizeWindow(w, std::min<uint>(neww, _toolbar_width) - w->width, 0, false);
3529
3530 top = newh - w->height - FindWindowById(WC_STATUS_BAR, 0)->height;
3531 left = PositionNetworkChatWindow(w);
3532 break;
3533
3534 case WC_CONSOLE:
3535 IConsoleResize(w);
3536 continue;
3537
3538 default: {
3539 if (w->flags & WF_CENTERED) {
3540 top = (newh - w->height) >> 1;
3541 left = (neww - w->width) >> 1;
3542 break;
3543 }
3544
3545 left = w->left;
3546 if (left + (w->width >> 1) >= neww) left = neww - w->width;
3547 if (left < 0) left = 0;
3548
3549 top = w->top;
3550 if (top + (w->height >> 1) >= newh) top = newh - w->height;
3551 break;
3552 }
3553 }
3554
3555 EnsureVisibleCaption(w, left, top);
3556 }
3557 }
3558
3563 void PickerWindowBase::Close()
3564 {
3565 ResetObjectToPlace();
3566 this->Window::Close();
3567 }
_dirkeys
byte _dirkeys
1 = left, 2 = up, 4 = right, 8 = down
Definition: gfx.cpp:34
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:720
ShowFirstError
void ShowFirstError()
Show the first error of the queue.
Definition: error_gui.cpp:342
Window::WindowIterator
Iterator to iterate all valid Windows.
Definition: window_gui.h:758
WC_CUSTOM_CURRENCY
@ WC_CUSTOM_CURRENCY
Custom currency; Window numbers:
Definition: window_type.h:612
WC_SAVELOAD
@ WC_SAVELOAD
Saveload window; Window numbers:
Definition: window_type.h:137
ScrollbarClickHandler
void ScrollbarClickHandler(Window *w, NWidgetCore *nw, int x, int y)
Special handling for the scrollbar widget type.
Definition: widget.cpp:375
PickerWindowBase::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:3563
Window::SetTimeout
void SetTimeout()
Set the timeout flag of the window and initiate the timer.
Definition: window_gui.h:295
WC_ROADVEH_LIST
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition: window_type.h:307
MAX_OFFSET_HOVER
@ MAX_OFFSET_HOVER
Maximum mouse movement before stopping a hover event.
Definition: window.cpp:2772
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:3254
HideVitalWindows
void HideVitalWindows()
Close all always on-top windows to get an empty screen.
Definition: window.cpp:3360
factory.hpp
FindWindowFromPt
Window * FindWindowFromPt(int x, int y)
Do a search for a window at specific coordinates.
Definition: window.cpp:1826
WC_INVALID
@ WC_INVALID
Invalid window.
Definition: window_type.h:700
NWidgetCore::IsDisabled
bool IsDisabled() const
Return whether the widget is disabled.
Definition: widget_type.h:395
_mouseover_last_w
static Window * _mouseover_last_w
Window of the last OnMouseOver event.
Definition: window.cpp:52
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:66
MouseClick
MouseClick
Definition: window.cpp:2764
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:243
Window::OnHundredthTick
virtual void OnHundredthTick()
Called once every 100 (game) ticks, or once every 3s, whichever comes last.
Definition: window_gui.h:629
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:36
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:1724
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:284
WF_SIZING
@ WF_SIZING
Window is being resized.
Definition: window_gui.h:173
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3156
CheckSoftLimit
static void CheckSoftLimit()
Check the soft limit of deletable (non vital, non sticky) windows.
Definition: window.cpp:3015
UpdateTileSelection
void UpdateTileSelection()
Updates tile highlighting for all cases.
Definition: viewport.cpp:2543
querystring_gui.h
Window::OnEditboxChanged
virtual void OnEditboxChanged(int widget)
The text in an editbox has been edited.
Definition: window_gui.h:661
Window::SetWhiteBorder
void SetWhiteBorder()
Set the timeout flag of the window and initiate the timer.
Definition: window_gui.h:304
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:1082
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:455
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:283
Window::~Window
virtual ~Window()
Remove window and all its child windows from the window stack.
Definition: window.cpp:1144
Scrollbar::GetCapacity
uint16 GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition: widget_type.h:669
Window::nested_root
NWidgetBase * nested_root
Root of the nested tree.
Definition: window_gui.h:258
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:832
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:319
WDF_CONSTRUCTION
@ WDF_CONSTRUCTION
This window is used for construction; close it whenever changing company.
Definition: window_gui.h:144
PositionMainToolbar
int PositionMainToolbar(Window *w)
(Re)position main toolbar window at the screen.
Definition: window.cpp:3433
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:261
WF_SIZING_RIGHT
@ WF_SIZING_RIGHT
Window is being resized towards the right.
Definition: window_gui.h:171
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:569
_special_mouse_mode
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition: window.cpp:92
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:41
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:192
Window::ReInit
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:1019
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:2798
CloseCompanyWindows
void CloseCompanyWindows(CompanyID id)
Close all windows of a company.
Definition: window.cpp:1219
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:1704
ND_SCROLLBAR_DOWN
@ ND_SCROLLBAR_DOWN
Bit value of the 'scrollbar down' flag.
Definition: widget_type.h:306
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:223
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:786
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:1454
HandleScrollbarScrolling
static void HandleScrollbarScrolling(Window *w)
Handle scrollbar scrolling with the mouse.
Definition: window.cpp:2351
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:2713
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:435
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:285
PHD_DOWN
@ PHD_DOWN
Below v is a safe position.
Definition: window.cpp:1997
WF_DISABLE_VP_SCROLL
@ WF_DISABLE_VP_SCROLL
Window does not do autoscroll,.
Definition: window_gui.h:175
Window::viewport
ViewportData * viewport
Pointer to viewport data, if present.
Definition: window_gui.h:255
NDB_DROPDOWN_CLOSED
@ NDB_DROPDOWN_CLOSED
Dropdown menu of the dropdown widget has closed.
Definition: widget_type.h:296
_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:1775
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:92
InitWindowSystem
void InitWindowSystem()
(re)initialize the windowing system
Definition: window.cpp:1840
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:622
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:174
UpdateWindows
void UpdateWindows()
Update the continuously changing contents of the windows, such as the viewports.
Definition: window.cpp:3075
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1161
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:634
StartWindowSizing
static void StartWindowSizing(Window *w, bool to_left)
Start resizing a window.
Definition: window.cpp:2335
PerformanceMeasurer
RAII class for measuring simple elements of performance.
Definition: framerate_type.h:92
ClrBit
static T ClrBit(T &x, const uint8 y)
Clears a bit in a variable.
Definition: bitmath_func.hpp:151
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:1392
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:146
UnInitWindowSystem
void UnInitWindowSystem()
Close down the windowing system.
Definition: window.cpp:1859
VA_DISABLED
@ VA_DISABLED
Do not autoscroll when mouse is at edge of viewport.
Definition: window.cpp:45
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:38
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:133
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:253
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:676
zoom_func.h
WC_BOOTSTRAP
@ WC_BOOTSTRAP
Bootstrap; Window numbers:
Definition: window_type.h:637
Window::RaiseButtons
void RaiseButtons(bool autoraise=false)
Raise the buttons of the window.
Definition: window.cpp:597
WC_GENERATE_LANDSCAPE
@ WC_GENERATE_LANDSCAPE
Generate landscape (newgame); Window numbers:
Definition: window_type.h:449
WC_MESSAGE_HISTORY
@ WC_MESSAGE_HISTORY
News history list; Window numbers:
Definition: window_type.h:265
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:53
Window::SetWidgetHighlight
void SetWidgetHighlight(byte widget_index, TextColour highlighted_colour)
Sets the highlighted status of a widget.
Definition: window.cpp:242
WC_OSK
@ WC_OSK
On Screen Keyboard; Window numbers:
Definition: window_type.h:155
WindowDesc::cls
WindowClass cls
Class of the window,.
Definition: window_gui.h:111
SZSP_HORIZONTAL
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
Definition: widget_type.h:427
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:99
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:639
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:253
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:292
WindowNumber
int32 WindowNumber
Number to differentiate different windows of the same class.
Definition: window_type.h:713
WC_COMPANY
@ WC_COMPANY
Company view; Window numbers:
Definition: window_type.h:362
NWidgetCore::tool_tip
StringID tool_tip
Tooltip of the widget.
Definition: widget_type.h:341
NWidgetCore::SetLowered
void SetLowered(bool lowered)
Lower or raise the widget.
Definition: widget_type.h:374
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:224
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:912
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:659
Window::GetCaretPosition
virtual Point GetCaretPosition() const
Get the current caret position if an edit box has the focus.
Definition: window.cpp:411
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:194
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:636
GUISettings::toolbar_pos
uint8 toolbar_pos
position of toolbars, 0=left, 1=center, 2=right
Definition: settings_type.h:130
EditBoxInGlobalFocus
bool EditBoxInGlobalFocus()
Check if an edit box is in global focus.
Definition: window.cpp:481
HandleAutoscroll
static void HandleAutoscroll()
If needed and switched on, perform auto scrolling (automatically moving window contents when mouse is...
Definition: window.cpp:2732
Window::OnHotkey
virtual EventState OnHotkey(int hotkey)
A hotkey has been pressed.
Definition: window.cpp:634
StartWindowDrag
static void StartWindowDrag(Window *w)
Start window dragging.
Definition: window.cpp:2318
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:2627
Window::Window
Window(WindowDesc *desc)
Empty constructor, initialization has been moved to InitNested() called from the constructor of the d...
Definition: window.cpp:1814
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:975
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:256
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:1311
WC_GRF_PARAMETERS
@ WC_GRF_PARAMETERS
NewGRF parameters; Window numbers:
Definition: window_type.h:174
Window::scheduled_invalidation_data
std::vector< int > scheduled_invalidation_data
Data of scheduled OnInvalidateData() calls.
Definition: window_gui.h:222
Window::IsWidgetHighlighted
bool IsWidgetHighlighted(byte widget_index) const
Gets the highlighted status of a widget.
Definition: window.cpp:275
WC_SAVE_PRESET
@ WC_SAVE_PRESET
Save preset; Window numbers:
Definition: window_type.h:680
Window::GetCaret
virtual const char * GetCaret() const
Get the string at the caret if an edit box has the focus.
Definition: window.cpp:384
Window::OnCTRLStateChange
virtual EventState OnCTRLStateChange()
The state of the control key has changed.
Definition: window_gui.h:544
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:442
Window::querystrings
SmallMap< int, QueryString * > querystrings
QueryString associated to WWT_EDITBOX widgets.
Definition: window_gui.h:257
SmallMap
Implementation of simple mapping class.
Definition: smallmap_type.hpp:26
WC_HIGHSCORE
@ WC_HIGHSCORE
Highscore; Window numbers:
Definition: window_type.h:643
NetworkReInitChatBoxSize
void NetworkReInitChatBoxSize()
Initialize all font-dependent chat box sizes.
Definition: network_chat_gui.cpp:107
Window::ProcessScheduledInvalidations
void ProcessScheduledInvalidations()
Process all scheduled invalidations.
Definition: window.cpp:3207
WindowDesc::default_width_trad
int16 default_width_trad
Preferred initial width of the window (pixels at 1x zoom).
Definition: window_gui.h:130
PHD_UP
@ PHD_UP
Above v is a safe position.
Definition: window.cpp:1996
gfx_func.h
WindowDesc::default_pos
WindowPosition default_pos
Preferred position of the window.
Definition: window_gui.h:110
WindowDesc
High level window description.
Definition: window_gui.h:102
WC_MODAL_PROGRESS
@ WC_MODAL_PROGRESS
Progress report of landscape generation; Window numbers:
Definition: window_type.h:456
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:3169
WF_SIZING_LEFT
@ WF_SIZING_LEFT
Window is being resized towards the left.
Definition: window_gui.h:172
NWidgetLeaf::InvalidateDimensionCache
static void InvalidateDimensionCache()
Reset the cached dimensions.
Definition: widget.cpp:2544
PositionStatusbar
int PositionStatusbar(Window *w)
(Re)position statusbar window at the screen.
Definition: window.cpp:3444
Window::SetShaded
void SetShaded(bool make_shaded)
Set the shaded state of the window to make_shaded.
Definition: window.cpp:1055
Window::GetWidget
const NWID * GetWidget(uint widnum) const
Get the nested widget with number widnum from the nested widget tree.
Definition: window_gui.h:865
ND_DROPDOWN_ACTIVE
@ ND_DROPDOWN_ACTIVE
Bit value of the 'dropdown active' flag.
Definition: widget_type.h:304
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:763
GUISettings::scrollwheel_scrolling
uint8 scrollwheel_scrolling
scrolling using the scroll wheel?
Definition: settings_type.h:146
WC_CONFIRM_POPUP_QUERY
@ WC_CONFIRM_POPUP_QUERY
Popup with confirm question; Window numbers:
Definition: window_type.h:123
Window::OnFocusLost
virtual void OnFocusLost()
Called when window loses focus.
Definition: window.cpp:548
MayBeShown
static bool MayBeShown(const Window *w)
Returns whether a window may be shown or not.
Definition: window.cpp:895
PositionNewsMessage
int PositionNewsMessage(Window *w)
(Re)position news message window at the screen.
Definition: window.cpp:3455
WC_QUERY_STRING
@ WC_QUERY_STRING
Query string window; Window numbers:
Definition: window_type.h:116
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:503
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:90
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:113
ChangeVehicleViewports
void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index)
Switches viewports following vehicles, which get autoreplaced.
Definition: window.cpp:3478
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:251
_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:2726
WSM_PRESIZE
@ WSM_PRESIZE
Presizing mode (docks, tunnels).
Definition: window_gui.h:925
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:773
settings_func.h
Scrollbar::GetCount
uint16 GetCount() const
Gets the number of elements in the list.
Definition: widget_type.h:660
tilehighlight_func.h
WC_BUY_COMPANY
@ WC_BUY_COMPANY
Buyout company (merger); Window numbers:
Definition: window_type.h:576
DescSorter
static bool DescSorter(WindowDesc *const &a, WindowDesc *const &b)
Sort WindowDesc by ini_key.
Definition: window.cpp:166
Window::InitNested
void InitNested(WindowNumber number=0)
Perform complete initialization of the Window with nested widgets, to allow use.
Definition: window.cpp:1804
Window::ProcessHighlightedInvalidations
void ProcessHighlightedInvalidations()
Process all invalidation of highlighted widgets.
Definition: window.cpp:3219
CloseNonVitalWindows
void CloseNonVitalWindows()
Try to close a non-vital window.
Definition: window.cpp:3296
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:3377
NWidgetBase::type
WidgetType type
Type of the widget / nested widget.
Definition: widget_type.h:185
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:249
_toolbar_width
uint _toolbar_width
Width of the toolbar, shared by statusbar.
Definition: toolbar_gui.cpp:67
WF_CENTERED
@ WF_CENTERED
Window is centered and shall stay centered after ReInit.
Definition: window_gui.h:178
WF_WHITE_BORDER
@ WF_WHITE_BORDER
Window white border counter bit mask.
Definition: window_gui.h:176
SpecialMouseMode
SpecialMouseMode
Mouse modes.
Definition: window_gui.h:921
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:1008
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:193
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:214
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:881
NWidgetBase::GetWidgetOfType
virtual NWidgetBase * GetWidgetOfType(WidgetType tp)
Retrieve a widget by its type.
Definition: widget.cpp:1044
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:540
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:721
DispatchMouseWheelEvent
static void DispatchMouseWheelEvent(Window *w, NWidgetCore *nwid, int wheel)
Dispatch the mousewheel-action to the window.
Definition: window.cpp:864
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:3494
Window::HandleEditBoxKey
EventState HandleEditBoxKey(int wid, WChar key, uint16 keycode)
Process keypress for editbox widget.
Definition: window.cpp:2538
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:1611
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:2010
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:399
Window::DisableAllWidgetHighlight
void DisableAllWidgetHighlight()
Disable the highlighted status of all widgets.
Definition: window.cpp:222
_pause_mode
PauseMode _pause_mode
The current pause mode.
Definition: gfx.cpp:50
ProcessPendingPerformanceMeasurements
void ProcessPendingPerformanceMeasurements()
This drains the PFE_SOUND measurement data queue into _pf_data.
Definition: framerate_gui.cpp:1111
GetMainViewTop
int GetMainViewTop()
Return the top of the main view available for general use.
Definition: window.cpp:2124
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:54
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:339
Window::OnDropdownSelect
virtual void OnDropdownSelect(int widget, int index)
A dropdown option associated to this window has been selected.
Definition: window_gui.h:653
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:923
WindowDesc::GetDefaultWidth
int16 GetDefaultWidth() const
Determine default width of window.
Definition: window.cpp:135
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:146
Window::SetWidgetDisabledState
void SetWidgetDisabledState(byte widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition: window_gui.h:321
Window::DeleteClosedWindows
static void DeleteClosedWindows()
Delete all closed windows.
Definition: window.cpp:64
Window::parent
Window * parent
Parent window.
Definition: window_gui.h:266
CallWindowGameTickEvent
void CallWindowGameTickEvent()
Dispatch OnGameTick event over all windows.
Definition: window.cpp:3283
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:1679
GUISettings::hover_delay_ms
uint16 hover_delay_ms
time required to activate a hover event, in milliseconds
Definition: settings_type.h:118
Window::left
int left
x position of left edge of the window
Definition: window_gui.h:246
Window::OnDragDrop
virtual void OnDragDrop(Point pt, int widget)
A dragged 'object' has been released.
Definition: window_gui.h:591
Window::flags
WindowFlags flags
Window flags.
Definition: window_gui.h:239
_z_windows
WindowList _z_windows
List of windows opened at the screen sorted from the front to back.
Definition: window.cpp:56
WF_TIMEOUT
@ WF_TIMEOUT
Window timeout counter.
Definition: window_gui.h:168
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:313
WindowClass
WindowClass
Window classes.
Definition: window_type.h:37
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:751
HandleCtrlChanged
void HandleCtrlChanged()
State of CONTROL key has changed.
Definition: window.cpp:2683
_mouse_hovering
bool _mouse_hovering
The mouse is hovering over the same point.
Definition: window.cpp:90
WindowDesc::default_height_trad
int16 default_height_trad
Preferred initial height of the window (pixels at 1x zoom).
Definition: window_gui.h:131
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:378
_shift_pressed
bool _shift_pressed
Is Shift pressed?
Definition: gfx.cpp:39
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:3410
HandleMouseOver
static void HandleMouseOver()
Report position of the mouse to the underlying window.
Definition: window.cpp:1969
DrawDirtyBlocks
void DrawDirtyBlocks()
Repaints the rectangle blocks which are marked as 'dirty'.
Definition: gfx.cpp:1635
NDB_SCROLLBAR_UP
@ NDB_SCROLLBAR_UP
Up-button is lowered bit.
Definition: widget_type.h:292
WDF_MODAL
@ WDF_MODAL
The window is a modal child of some other window, meaning the parent is 'inactive'.
Definition: window_gui.h:145
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:100
WindowDesc::GetDefaultHeight
int16 GetDefaultHeight() const
Determine default height of window.
Definition: window.cpp:145
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:177
ScrollMainWindowTo
bool ScrollMainWindowTo(int x, int y, int z, bool instant)
Scrolls the main window to given coordinates.
Definition: smallmap_gui.cpp:1883
WindowDesc::nwid_parts
const NWidgetPart * nwid_parts
Nested widget parts describing the window.
Definition: window_gui.h:115
FocusedWindowIsConsole
bool FocusedWindowIsConsole()
Check if a console is focused.
Definition: window.cpp:495
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:197
WC_TRAINS_LIST
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition: window_type.h:301
WSM_DRAGDROP
@ WSM_DRAGDROP
Drag&drop an object.
Definition: window_gui.h:923
Window::OnInit
virtual void OnInit()
Notification that the nested widget tree gets initialized.
Definition: window_gui.h:472
Window::unshaded_size
Dimension unshaded_size
Last known unshaded size (only valid while shaded).
Definition: window_gui.h:262
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:61
WindowDesc::SaveToConfig
static void SaveToConfig()
Save all WindowDesc settings to _windows_file.
Definition: window.cpp:175
Window::SetFocusedWidget
bool SetFocusedWidget(int widget_index)
Set focus within this window to the given widget.
Definition: window.cpp:519
stdafx.h
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:241
RoundDivSU
static int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
Definition: math_func.hpp:302
ResizeInfo::step_height
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:154
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:104
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:3194
VideoDriver::GetInstance
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
Definition: video_driver.hpp:202
NWidgetStacked::SetDisplayedPlane
void SetDisplayedPlane(int plane)
Select which plane to show (for NWID_SELECTION only).
Definition: widget.cpp:1409
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:264
NWidgetBase::current_y
uint current_y
Current vertical size (after resizing).
Definition: widget_type.h:197
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:38
HandleMouseEvents
void HandleMouseEvents()
Handle a mouse event from the video driver.
Definition: window.cpp:2932
Window::AllWindows
Iterable ensemble of all valid Windows.
Definition: window_gui.h:803
GUISettings::statusbar_pos
uint8 statusbar_pos
position of statusbar, 0=left, 1=center, 2=right
Definition: settings_type.h:131
Window::nested_array
NWidgetBase ** nested_array
Array of pointers into the tree. Do not access directly, use Window::GetWidget() instead.
Definition: window_gui.h:259
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:735
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:810
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:1572
HandleViewportScroll
static EventState HandleViewportScroll()
Handle viewport scrolling with the mouse.
Definition: window.cpp:2418
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:553
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:101
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:48
WC_GAME_OPTIONS
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition: window_type.h:606
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:617
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:153
VSM_MAP_LMB
@ VSM_MAP_LMB
Map moves with mouse movement on holding left mouse button, cursor moves.
Definition: settings_type.h:102
NWidgetCore::disp_flags
NWidgetDisplay disp_flags
Flags that affect display and interaction with the widget.
Definition: widget_type.h:337
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:2771
Window::OnMouseWheel
virtual void OnMouseWheel(int wheel)
The mouse wheel has been turned.
Definition: window_gui.h:611
IniFile
Ini file that supports both loading and saving.
Definition: ini_type.h:89
WindowDesc::flags
uint32 flags
Flags.
Definition: window_gui.h:114
Window::IsShaded
bool IsShaded() const
Is window shaded currently?
Definition: window_gui.h:455
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:199
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...
DeleteAllMessages
void DeleteAllMessages()
Delete all messages and close their corresponding window (if any).
Definition: window.cpp:3335
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:44
Window::closed_windows
static std::vector< Window * > closed_windows
List of closed windows to delete.
Definition: window_gui.h:215
Window::CloseChildWindows
void CloseChildWindows(WindowClass wc=WC_INVALID) const
Close all children a window might have in a head-recursive manner.
Definition: window.cpp:1095
UnshowCriticalError
void UnshowCriticalError()
Unshow the critical error.
Definition: error_gui.cpp:356
VA_MAIN_VIEWPORT_FULLSCREEN
@ VA_MAIN_VIEWPORT_FULLSCREEN
Scroll main viewport at edge when using fullscreen.
Definition: window.cpp:46
WC_AI_LIST
@ WC_AI_LIST
AI list; Window numbers:
Definition: window_type.h:277
Window::SetWidgetsLoweredState
void CDECL SetWidgetsLoweredState(bool lowered_stat, int widgets,...)
Sets the lowered/raised status of a list of widgets.
Definition: window.cpp:579
FONT_HEIGHT_NORMAL
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:206
Window::OnTooltip
virtual bool OnTooltip(Point pt, int widget, TooltipCloseCondition close_cond)
Event to display a custom tooltip.
Definition: window_gui.h:577
WC_SCEN_LAND_GEN
@ WC_SCEN_LAND_GEN
Landscape generation (in Scenario Editor); Window numbers:
Definition: window_type.h:442
video_driver.hpp
DispatchHoverEvent
static void DispatchHoverEvent(Window *w, int x, int y)
Dispatch hover of the mouse over a window.
Definition: window.cpp:836
NO_DIRECTORY
@ NO_DIRECTORY
A path without any base directory.
Definition: fileio_type.h:125
WC_NETWORK_WINDOW
@ WC_NETWORK_WINDOW
Network window; Window numbers:
Definition: window_type.h:465
NWidgetScrollbar
Nested widget to display and control a scrollbar in a window.
Definition: widget_type.h:800
WC_CONSOLE
@ WC_CONSOLE
Console; Window numbers:
Definition: window_type.h:631
CloseWindowByClass
void CloseWindowByClass(WindowClass cls)
Close all windows of a given class.
Definition: window.cpp:1203
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:3271
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:427
WC_NETWORK_STATUS_WINDOW
@ WC_NETWORK_STATUS_WINDOW
Network status window; Window numbers:
Definition: window_type.h:478
WC_TOOLTIPS
@ WC_TOOLTIPS
Tooltip window; Window numbers:
Definition: window_type.h:109
WC_AI_SETTINGS
@ WC_AI_SETTINGS
AI settings; Window numbers:
Definition: window_type.h:168
_window_highlight_colour
bool _window_highlight_colour
If false, highlight is white, otherwise the by the widget defined colour.
Definition: window.cpp:74
Window::OnPaint
virtual void OnPaint()
The window must be repainted.
Definition: window_gui.h:489
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:560
IniSaveWindowSettings
void IniSaveWindowSettings(IniFile &ini, const char *grpname, void *desc)
Save a WindowDesc to config.
Definition: settings.cpp:797
NWidgetBase::resize_y
uint resize_y
Vertical resize step (0 means not resizable).
Definition: widget_type.h:189
Window::IsWidgetLowered
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:422
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:569
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:3317
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:605
EventState
EventState
State of handling an event.
Definition: window_type.h:719
UpdateViewportPosition
void UpdateViewportPosition(Window *w)
Update the viewport position being displayed.
Definition: viewport.cpp:1874
WindowDesc::pref_sticky
bool pref_sticky
Preferred stickyness.
Definition: window_gui.h:119
Scrollbar::GetPosition
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:678
WF_DRAGGING
@ WF_DRAGGING
Window is being dragged.
Definition: window_gui.h:170
WC_NETWORK_ASK_RELAY
@ WC_NETWORK_ASK_RELAY
Network ask relay window; Window numbers:
Definition: window_type.h:484
FindWindowByClass
Window * FindWindowByClass(WindowClass cls)
Find any window by its class.
Definition: window.cpp:1176
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:219
progress.h
NetworkChatMessageLoop
void NetworkChatMessageLoop()
Check if a message is expired.
Definition: network_chat_gui.cpp:174
Window::window_class
WindowClass window_class
Window class.
Definition: window_gui.h:240
WC_MAIN_WINDOW
@ WC_MAIN_WINDOW
Main window; Window numbers:
Definition: window_type.h:44
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1791
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:1536
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:676
WC_ENDSCREEN
@ WC_ENDSCREEN
Endscreen; Window numbers:
Definition: window_type.h:649
company_func.h
PreventHideDirection
PreventHideDirection
Direction for moving the window.
Definition: window.cpp:1995
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::UpdateQueryStringSize
void UpdateQueryStringSize()
Update size of all QueryStrings of this window.
Definition: window.cpp:359
Window::top
int top
y position of top edge of the window
Definition: window_gui.h:247
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:402
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:291
NWidgetCore::scrollbar_index
int scrollbar_index
Index of an attached scrollbar.
Definition: widget_type.h:342
network.h
NWidgetBase::SetDirty
virtual void SetDirty(const Window *w) const
Mark the widget as 'dirty' (in need of repaint).
Definition: widget.cpp:1024
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:584
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:1239
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:490
ViewportData::follow_vehicle
VehicleID follow_vehicle
VehicleID to follow if following a vehicle, INVALID_VEHICLE otherwise.
Definition: window_gui.h:193
MILLISECONDS_PER_TICK
static const uint MILLISECONDS_PER_TICK
The number of milliseconds per game tick.
Definition: gfx_type.h:316
Window::OnInitialPosition
virtual Point OnInitialPosition(int16 sm_width, int16 sm_height, int window_number)
Compute the initial position of the window.
Definition: window.cpp:1763
window_func.h
HandleActiveWidget
static EventState HandleActiveWidget()
Handle active widget (mouse draggin on widget) with the mouse.
Definition: window.cpp:2385
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:248
WindowDesc::LoadFromConfig
static void LoadFromConfig()
Load all WindowDesc settings from _windows_file.
Definition: window.cpp:153
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:985
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:196
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1767
WDP_MANUAL
@ WDP_MANUAL
Manually align the window (so no automatic location finding)
Definition: window_gui.h:89
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:1945
IConsoleClose
void IConsoleClose()
Close the in-game console.
Definition: console_gui.cpp:412
_drag_delta
static Point _drag_delta
delta between mouse cursor and upper left corner of dragged window
Definition: window.cpp:51
_dragging_window
static bool _dragging_window
A window is being dragged or resized.
Definition: window.cpp:2141
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:1191
NWidgetBase::pos_y
int pos_y
Vertical position of top-left corner of the widget in the window.
Definition: widget_type.h:200
ND_SCROLLBAR_UP
@ ND_SCROLLBAR_UP
Bit value of the 'scrollbar up' flag.
Definition: widget_type.h:305
NetworkDrawChatMessage
void NetworkDrawChatMessage()
Draw the chat message-box.
Definition: network_chat_gui.cpp:188
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:2696
QueryString::GetCaretPosition
Point GetCaretPosition(const Window *w, int wid) const
Get the current caret position.
Definition: misc_gui.cpp:852
_window_descs
static std::vector< WindowDesc * > * _window_descs
List of all WindowDescs.
Definition: window.cpp:98
Window::window_desc
WindowDesc * window_desc
Window description.
Definition: window_gui.h:238
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:327
Window::OnRealtimeTick
virtual void OnRealtimeTick(uint delta_ms)
Called periodically.
Definition: window_gui.h:634
ResetWindowSystem
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition: window.cpp:1873
ZOOM_LVL_NORMAL
@ ZOOM_LVL_NORMAL
The normal zoom level.
Definition: zoom_type.h:22
HandleWindowDragging
static EventState HandleWindowDragging()
Handle dragging/resizing of a window.
Definition: window.cpp:2147
PositionNetworkChatWindow
int PositionNetworkChatWindow(Window *w)
(Re)position network chat window at the screen.
Definition: window.cpp:3466
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:588
GUISettings::auto_scrolling
uint8 auto_scrolling
scroll when moving mouse to the edge (see ViewportAutoscrolling)
Definition: settings_type.h:116
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:3319
WindowDesc::parent_cls
WindowClass parent_cls
Class of the parent window.
Definition: window_gui.h:112
Window
Data structure for an opened window.
Definition: window_gui.h:213
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:412
InputLoop
void InputLoop()
Regular call from the global game loop.
Definition: window.cpp:3040
WC_STATUS_BAR
@ WC_STATUS_BAR
Statusbar (at the bottom of your screen); Window numbers:
Definition: window_type.h:57
GUISettings::scroll_mode
uint8 scroll_mode
viewport scroll mode
Definition: settings_type.h:122
WC_NEWS_WINDOW
@ WC_NEWS_WINDOW
News window; Window numbers:
Definition: window_type.h:241
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:562
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:3347
WC_FINANCES
@ WC_FINANCES
Finances of a company; Window numbers:
Definition: window_type.h:515
console_func.h
Window::OnScroll
virtual void OnScroll(Point delta)
Handle the request for (viewport) scrolling.
Definition: window_gui.h:597
HKPR_NOT_HANDLED
@ HKPR_NOT_HANDLED
Key does not affect editboxes.
Definition: textbuf_type.h:26
WidgetDimensions::scaled
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition: window_gui.h:68
ConstructionSettings::command_pause_level
uint8 command_pause_level
level/amount of commands that can't be executed while paused
Definition: settings_type.h:356
WC_ERRMSG
@ WC_ERRMSG
Error message; Window numbers:
Definition: window_type.h:103
Window::nested_array_size
uint nested_array_size
Size of the nested array.
Definition: window_gui.h:260
free
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: stdafx.h:470
NWidgetCore::index
int index
Index of the nested widget in the widget array of the window (-1 means 'not used').
Definition: widget_type.h:339
NWidgetCore
Base class for a 'real' widget.
Definition: widget_type.h:316
_last_scroll_window
static Window * _last_scroll_window
Window of the last scroll event.
Definition: window.cpp:53
Window::SetWidgetDirty
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:621
NWidgetLeaf::closebox_dimension
static Dimension closebox_dimension
Cached size of a closebox widget.
Definition: widget_type.h:833
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:2135
CallWindowRealtimeTickEvent
void CallWindowRealtimeTickEvent(uint delta_ms)
Dispatch OnRealtimeTick event over all windows.
Definition: window.cpp:3065
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:69
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:403
WC_DROPDOWN_MENU
@ WC_DROPDOWN_MENU
Drop down menu; Window numbers:
Definition: window_type.h:149
BringWindowToFrontById
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition: window.cpp:1274
_right_button_clicked
bool _right_button_clicked
Is right mouse button clicked?
Definition: gfx.cpp:44
NWidgetBase::resize_x
uint resize_x
Horizontal resize step (0 means not resizable).
Definition: widget_type.h:188
Window::GetMarkedText
virtual const char * GetMarkedText(size_t *length) const
Get the range of the currently marked input text.
Definition: window.cpp:398
WC_MAIN_TOOLBAR
@ WC_MAIN_TOOLBAR
Main toolbar (the long bar at the top); Window numbers:
Definition: window_type.h:51
WC_SPRITE_ALIGNER
@ WC_SPRITE_ALIGNER
Sprite aligner (debug); Window numbers:
Definition: window_type.h:668
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3182
WC_AIRCRAFT_LIST
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition: window_type.h:319
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:211
Window::OnResize
virtual void OnResize()
Called after the window got resized.
Definition: window_gui.h:646
CMDPL_NO_CONSTRUCTION
@ CMDPL_NO_CONSTRUCTION
No construction actions may be executed.
Definition: command_type.h:411
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:196
WC_TEXTFILE
@ WC_TEXTFILE
textfile; Window numbers:
Definition: window_type.h:180
WindowDesc::hotkeys
HotkeyList * hotkeys
Hotkeys for the window.
Definition: window_gui.h:117
WC_STATION_LIST
@ WC_STATION_LIST
Station list; Window numbers:
Definition: window_type.h:295
NWidgetStacked::shown_plane
int shown_plane
Plane being displayed (for NWID_SELECTION only).
Definition: widget_type.h:459
WindowPosition
WindowPosition
How do we the window to be placed?
Definition: window_gui.h:88
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition: viewport.cpp:3434
_scrolling_viewport
bool _scrolling_viewport
A viewport is being scrolled with the mouse.
Definition: window.cpp:89
WC_SMALLMAP
@ WC_SMALLMAP
Small map; Window numbers:
Definition: window_type.h:97
WDP_CENTER
@ WDP_CENTER
Center the window.
Definition: window_gui.h:91
Window::SetWidgetLoweredState
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:382
_left_button_clicked
bool _left_button_clicked
Is left mouse button clicked?
Definition: gfx.cpp:42
WindowDesc::pref_height
int16 pref_height
User-preferred height of the window. Zero if unset.
Definition: window_gui.h:121
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:2478
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:49
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:3272
Window::white_border_timer
uint8 white_border_timer
Timer value of the WF_WHITE_BORDER for flags.
Definition: window_gui.h:244
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:2050
SetupWidgetDimensions
void SetupWidgetDimensions()
Set up pre-scaled versions of Widget Dimensions.
Definition: widget.cpp:199
_right_button_down
bool _right_button_down
Is right mouse button pressed?
Definition: gfx.cpp:43
ND_SCROLLBAR_BTN
@ ND_SCROLLBAR_BTN
Bit value of the 'scrollbar up' or 'scrollbar down' flag.
Definition: widget_type.h:307
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:132
WindowDesc::pref_width
int16 pref_width
User-preferred width of the window. Zero if unset.
Definition: window_gui.h:120
WC_VEHICLE_ORDERS
@ WC_VEHICLE_ORDERS
Vehicle orders; Window numbers:
Definition: window_type.h:205
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:604
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:1412
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
HandleToolbarHotkey
void HandleToolbarHotkey(int hotkey)
Handle Toolbar hotkey events - can come from a source like the MacBook Touch Bar.
Definition: window.cpp:2610
VA_MAIN_VIEWPORT
@ VA_MAIN_VIEWPORT
Scroll main viewport at edge.
Definition: window.cpp:47
Scrollbar::SetPosition
bool SetPosition(int position)
Sets the position of the first visible element.
Definition: widget_type.h:749
TileHighlightData::GetCallbackWnd
Window * GetCallbackWnd()
Get the window that started the current highlighting.
Definition: viewport.cpp:2529
DrawPixelInfo
Data about how and where to blit pixels.
Definition: gfx_type.h:151
GUISettings::right_mouse_wnd_close
bool right_mouse_wnd_close
close window with right click
Definition: settings_type.h:149
Window::GetFocusedText
virtual const char * GetFocusedText() const
Get the current input text if an edit box has the focus.
Definition: window.cpp:371
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:2508
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
ScaleGUITrad
static RectPadding ScaleGUITrad(const RectPadding &r)
Scale a RectPadding to GUI zoom level.
Definition: widget.cpp:168
news_func.h
Window::FindWindowPlacementAndResize
virtual void FindWindowPlacementAndResize(int def_width, int def_height)
Resize window towards the default size.
Definition: window.cpp:1472
hotkeys.h
ResizeWindow
void ResizeWindow(Window *w, int delta_x, int delta_y, bool clamp_to_screen)
Resize the window.
Definition: window.cpp:2088
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:1992
Window::OnKeyPress
virtual EventState OnKeyPress(WChar key, uint16 keycode)
A key has been pressed.
Definition: window_gui.h:535
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:1107