OpenTTD Source: src/window.cpp Source File

OpenTTD Source 15.0-RC2

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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
10#include "stdafx.h"
11#include "company_func.h"
12#include "gfx_func.h"
13#include "console_func.h"
14#include "console_gui.h"
15#include "viewport_func.h"
16#include "progress.h"
17#include "blitter/factory.hpp"
18#include "zoom_func.h"
19#include "vehicle_base.h"
20#include "depot_func.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 "news_func.h"
39#include "sound_func.h"
40#include "timer/timer.h"
41#include "timer/timer_window.h"
42
43#include "table/strings.h"
44
45#include "safeguards.h"
46
48 enum ViewportAutoscrolling : uint8_t {
49 VA_DISABLED,
50 VA_MAIN_VIEWPORT_FULLSCREEN,
51 VA_MAIN_VIEWPORT,
52 VA_EVERY_VIEWPORT,
53};
54
55 static Point _drag_delta;
56 static Window *_mouseover_last_w = nullptr;
57 static Window *_last_scroll_window = nullptr;
58
60WindowList _z_windows;
61
63/* static */ std::vector<Window *> Window::closed_windows;
64
68/* static */ void Window::DeleteClosedWindows()
69{
70 for (Window *w : Window::closed_windows) delete w;
71 Window::closed_windows.clear();
72
73 /* Remove dead entries from the window list */
74 _z_windows.remove(nullptr);
75}
76
78 bool _window_highlight_colour = false;
79
80/*
81 * Window that currently has focus. - The main purpose is to generate
82 * #FocusLost events, not to give next window in z-order focus when a
83 * window is closed.
84 */
85 Window *_focused_window;
86
87 Point _cursorpos_drag_start;
88
89int _scrollbar_start_pos;
90int _scrollbar_size;
91uint8_t _scroller_click_timeout = 0;
92
93 bool _scrolling_viewport;
94 bool _mouse_hovering;
95
96 SpecialMouseMode _special_mouse_mode;
97
102std::vector<WindowDesc*> *_window_descs = nullptr;
103
105std::string _windows_file;
106
108WindowDesc::WindowDesc(WindowPosition def_pos, std::string_view ini_key, int16_t def_width_trad, int16_t def_height_trad,
109 WindowClass window_class, WindowClass parent_class, WindowDefaultFlags flags,
110 const std::span<const NWidgetPart> nwid_parts, HotkeyList *hotkeys,
111 const std::source_location location) :
112 source_location(location),
113 default_pos(def_pos),
114 cls(window_class),
115 parent_cls(parent_class),
116 ini_key(ini_key),
117 flags(flags),
118 nwid_parts(nwid_parts),
119 hotkeys(hotkeys),
120 default_width_trad(def_width_trad),
121 default_height_trad(def_height_trad)
122{
123 if (_window_descs == nullptr) _window_descs = new std::vector<WindowDesc*>();
124 _window_descs->push_back(this);
125}
126
127WindowDesc::~WindowDesc()
128{
129 _window_descs->erase(std::ranges::find(*_window_descs, this));
130}
131
137int16_t WindowDesc::GetDefaultWidth() const
138{
139 return this->pref_width != 0 ? this->pref_width : ScaleGUITrad(this->default_width_trad);
140}
141
147int16_t WindowDesc::GetDefaultHeight() const
148{
149 return this->pref_height != 0 ? this->pref_height : ScaleGUITrad(this->default_height_trad);
150}
151
155 void WindowDesc::LoadFromConfig()
156{
157 IniFile ini;
158 ini.LoadFromDisk(_windows_file, NO_DIRECTORY);
159 for (WindowDesc *wd : *_window_descs) {
160 if (wd->ini_key.empty()) continue;
161 IniLoadWindowSettings(ini, wd->ini_key, wd);
162 }
163}
164
168 static bool DescSorter(WindowDesc * const &a, WindowDesc * const &b)
169{
170 return a->ini_key < b->ini_key;
171}
172
176 void WindowDesc::SaveToConfig()
177{
178 /* Sort the stuff to get a nice ini file on first write */
179 std::sort(_window_descs->begin(), _window_descs->end(), DescSorter);
180
181 IniFile ini;
182 ini.LoadFromDisk(_windows_file, NO_DIRECTORY);
183 for (WindowDesc *wd : *_window_descs) {
184 if (wd->ini_key.empty()) continue;
185 IniSaveWindowSettings(ini, wd->ini_key, wd);
186 }
187 ini.SaveToDisk(_windows_file);
188}
189
193 void Window::ApplyDefaults()
194{
195 if (this->nested_root != nullptr && this->nested_root->GetWidgetOfType(WWT_STICKYBOX) != nullptr) {
196 if (this->window_desc.pref_sticky) this->flags.Set(WindowFlag::Sticky);
197 } else {
198 /* There is no stickybox; clear the preference in case someone tried to be funny */
199 this->window_desc.pref_sticky = false;
200 }
201}
202
212 int Window::GetRowFromWidget(int clickpos, WidgetID widget, int padding, int line_height) const
213{
214 const NWidgetBase *wid = this->GetWidget<NWidgetBase>(widget);
215 if (line_height < 0) line_height = wid->resize_y;
216 if (clickpos < wid->pos_y + padding) return INT_MAX;
217 return (clickpos - wid->pos_y - padding) / line_height;
218}
219
223 void Window::DisableAllWidgetHighlight()
224{
225 for (auto &pair : this->widget_lookup) {
226 NWidgetBase *nwid = pair.second;
227 if (nwid->IsHighlighted()) {
228 nwid->SetHighlighted(TC_INVALID);
229 nwid->SetDirty(this);
230 }
231 }
232
233 this->flags.Reset(WindowFlag::Highlighted);
234}
235
241 void Window::SetWidgetHighlight(WidgetID widget_index, TextColour highlighted_colour)
242{
243 NWidgetBase *nwid = this->GetWidget<NWidgetBase>(widget_index);
244 if (nwid == nullptr) return;
245
246 nwid->SetHighlighted(highlighted_colour);
247 nwid->SetDirty(this);
248
249 if (highlighted_colour != TC_INVALID) {
250 /* If we set a highlight, the window has a highlight */
251 this->flags.Set(WindowFlag::Highlighted);
252 } else {
253 /* If we disable a highlight, check all widgets if anyone still has a highlight */
254 bool valid = false;
255 for (const auto &pair : this->widget_lookup) {
256 nwid = pair.second;
257 if (!nwid->IsHighlighted()) continue;
258
259 valid = true;
260 }
261 /* If nobody has a highlight, disable the flag on the window */
262 if (!valid) this->flags.Reset(WindowFlag::Highlighted);
263 }
264}
265
271 bool Window::IsWidgetHighlighted(WidgetID widget_index) const
272{
273 const NWidgetBase *nwid = this->GetWidget<NWidgetBase>(widget_index);
274 if (nwid == nullptr) return false;
275
276 return nwid->IsHighlighted();
277}
278
286 void Window::OnDropdownClose(Point pt, WidgetID widget, int index, int click_result, bool instant_close)
287{
288 if (widget < 0) return;
289
290 if (instant_close) {
291 /* Send event for selected option if we're still
292 * on the parent button of the dropdown (behaviour of the dropdowns in the main toolbar). */
293 if (GetWidgetFromPos(this, pt.x, pt.y) == widget) {
294 this->OnDropdownSelect(widget, index, click_result);
295 }
296 }
297
298 /* Raise the dropdown button */
299 NWidgetCore *nwi2 = this->GetWidget<NWidgetCore>(widget);
300 if ((nwi2->type & WWT_MASK) == NWID_BUTTON_DROPDOWN) {
301 nwi2->disp_flags.Reset(NWidgetDisplayFlag::DropdownActive);
302 } else {
303 this->RaiseWidget(widget);
304 }
305 this->SetWidgetDirty(widget);
306}
307
313 const Scrollbar *Window::GetScrollbar(WidgetID widnum) const
314{
315 return this->GetWidget<NWidgetScrollbar>(widnum);
316}
317
323 Scrollbar *Window::GetScrollbar(WidgetID widnum)
324{
325 return this->GetWidget<NWidgetScrollbar>(widnum);
326}
327
333 const QueryString *Window::GetQueryString(WidgetID widnum) const
334{
335 auto query = this->querystrings.find(widnum);
336 return query != this->querystrings.end() ? query->second : nullptr;
337}
338
344 QueryString *Window::GetQueryString(WidgetID widnum)
345{
346 auto query = this->querystrings.find(widnum);
347 return query != this->querystrings.end() ? query->second : nullptr;
348}
349
353 void Window::UpdateQueryStringSize()
354{
355 for (auto &qs : this->querystrings) {
356 qs.second->text.UpdateSize();
357 }
358}
359
364/* virtual */ const Textbuf *Window::GetFocusedTextbuf() const
365{
366 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
367 return &this->GetQueryString(this->nested_focus->GetIndex())->text;
368 }
369
370 return nullptr;
371}
372
377/* virtual */ Point Window::GetCaretPosition() const
378{
379 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX && !this->querystrings.empty()) {
380 return this->GetQueryString(this->nested_focus->GetIndex())->GetCaretPosition(this, this->nested_focus->GetIndex());
381 }
382
383 Point pt = {0, 0};
384 return pt;
385}
386
393/* virtual */ Rect Window::GetTextBoundingRect(size_t from, size_t to) const
394{
395 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
396 return this->GetQueryString(this->nested_focus->GetIndex())->GetBoundingRect(this, this->nested_focus->GetIndex(), from, to);
397 }
398
399 Rect r = {0, 0, 0, 0};
400 return r;
401}
402
408/* virtual */ ptrdiff_t Window::GetTextCharacterAtPosition(const Point &pt) const
409{
410 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) {
411 return this->GetQueryString(this->nested_focus->GetIndex())->GetCharAtPosition(this, this->nested_focus->GetIndex(), pt);
412 }
413
414 return -1;
415}
416
421 void SetFocusedWindow(Window *w)
422{
423 if (_focused_window == w) return;
424
425 /* Don't focus a tooltip */
426 if (w != nullptr && w->window_class == WC_TOOLTIPS) return;
427
428 /* Invalidate focused widget */
429 if (_focused_window != nullptr) {
430 if (_focused_window->nested_focus != nullptr) _focused_window->nested_focus->SetDirty(_focused_window);
431 }
432
433 /* Remember which window was previously focused */
434 Window *old_focused = _focused_window;
435 _focused_window = w;
436
437 /* So we can inform it that it lost focus */
438 if (old_focused != nullptr) old_focused->OnFocusLost(false);
439 if (_focused_window != nullptr) _focused_window->OnFocus();
440}
441
447 bool EditBoxInGlobalFocus()
448{
449 if (_focused_window == nullptr) return false;
450
451 /* The console does not have an edit box so a special case is needed. */
452 if (_focused_window->window_class == WC_CONSOLE) return true;
453
454 return _focused_window->nested_focus != nullptr && _focused_window->nested_focus->type == WWT_EDITBOX;
455}
456
461 bool FocusedWindowIsConsole()
462{
463 return _focused_window && _focused_window->window_class == WC_CONSOLE;
464}
465
469 void Window::UnfocusFocusedWidget()
470{
471 if (this->nested_focus != nullptr) {
472 if (this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxLostFocus();
473
474 /* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */
475 this->nested_focus->SetDirty(this);
476 this->nested_focus = nullptr;
477 }
478}
479
485 bool Window::SetFocusedWidget(WidgetID widget_index)
486{
487 NWidgetCore *widget = this->GetWidget<NWidgetCore>(widget_index);
488 assert(widget != nullptr); /* Setting focus to a non-existing widget is a bad idea. */
489
490 if (this->nested_focus != nullptr) {
491 /* Do nothing if widget_index is already focused. */
492 if (widget == this->nested_focus) return false;
493
494 /* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */
495 this->nested_focus->SetDirty(this);
496 if (this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxLostFocus();
497 }
498
499 this->nested_focus = widget;
500 if (this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxGainedFocus();
501 return true;
502}
503
504std::string Window::GetWidgetString([[maybe_unused]] WidgetID widget, StringID stringid) const
505{
506 if (stringid == STR_NULL) return {};
507 return GetString(stringid);
508}
509
513 void Window::OnFocus()
514{
515 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxGainedFocus();
516}
517
521 void Window::OnFocusLost(bool)
522{
523 if (this->nested_focus != nullptr && this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxLostFocus();
524}
525
530 void Window::RaiseButtons(bool autoraise)
531{
532 for (auto &pair : this->widget_lookup) {
533 WidgetType type = pair.second->type;
534 NWidgetCore *wid = dynamic_cast<NWidgetCore *>(pair.second);
535 if (wid != nullptr && ((type & ~WWB_PUSHBUTTON) < WWT_LAST || type == NWID_PUSHBUTTON_DROPDOWN) &&
536 (!autoraise || (type & WWB_PUSHBUTTON) || type == WWT_EDITBOX) && wid->IsLowered()) {
537 wid->SetLowered(false);
538 wid->SetDirty(this);
539 }
540 }
541
542 /* Special widgets without widget index */
543 {
544 NWidgetCore *wid = this->nested_root != nullptr ? dynamic_cast<NWidgetCore *>(this->nested_root->GetWidgetOfType(WWT_DEFSIZEBOX)) : nullptr;
545 if (wid != nullptr) {
546 wid->SetLowered(false);
547 wid->SetDirty(this);
548 }
549 }
550}
551
556 void Window::SetWidgetDirty(WidgetID widget_index) const
557{
558 /* Sometimes this function is called before the window is even fully initialized */
559 auto it = this->widget_lookup.find(widget_index);
560 if (it == std::end(this->widget_lookup)) return;
561
562 it->second->SetDirty(this);
563}
564
570 EventState Window::OnHotkey(int hotkey)
571{
572 if (hotkey < 0) return ES_NOT_HANDLED;
573
574 NWidgetCore *nw = this->GetWidget<NWidgetCore>(hotkey);
575 if (nw == nullptr || nw->IsDisabled()) return ES_NOT_HANDLED;
576
577 if (nw->type == WWT_EDITBOX) {
578 if (this->IsShaded()) return ES_NOT_HANDLED;
579
580 /* Focus editbox */
581 this->SetFocusedWidget(hotkey);
582 SetFocusedWindow(this);
583 } else {
584 /* Click button */
585 this->OnClick(Point(), hotkey, 1);
586 }
587 return ES_HANDLED;
588}
589
595 void Window::HandleButtonClick(WidgetID widget)
596{
597 /* Button click for this widget may already have been handled. */
598 if (this->IsWidgetLowered(widget) && this->timeout_timer == TIMEOUT_DURATION) return;
599
600 this->LowerWidget(widget);
601 this->SetTimeout();
602 this->SetWidgetDirty(widget);
603 SndClickBeep();
604}
605
606static void StartWindowDrag(Window *w);
607static void StartWindowSizing(Window *w, bool to_left);
608
616 static void DispatchLeftClickEvent(Window *w, int x, int y, int click_count)
617{
618 NWidgetCore *nw = w->nested_root->GetWidgetFromPos(x, y);
619 WidgetType widget_type = (nw != nullptr) ? nw->type : WWT_EMPTY;
620
621 /* Allow dropdown close flag detection to work. */
622 if (nw != nullptr) nw->disp_flags.Reset(NWidgetDisplayFlag::DropdownClosed);
623
624 bool focused_widget_changed = false;
625
626 /* If clicked on a window that previously did not have focus */
627 if (_focused_window != w) {
628 /* Don't switch focus to an unfocusable window, or if the 'X' (close button) was clicked. */
629 if (!w->window_desc.flags.Test(WindowDefaultFlag::NoFocus) && widget_type != WWT_CLOSEBOX) {
630 focused_widget_changed = true;
631 SetFocusedWindow(w);
632 } else if (_focused_window != nullptr && _focused_window->window_class == WC_DROPDOWN_MENU) {
633 /* The previously focused window was a dropdown menu, but the user clicked on another window that
634 * isn't focusable. Close the dropdown menu anyway. */
635 SetFocusedWindow(nullptr);
636 }
637 }
638
639 if (nw == nullptr) return; // exit if clicked outside of widgets
640
641 /* don't allow any interaction if the button has been disabled */
642 if (nw->IsDisabled()) return;
643
644 WidgetID widget_index = nw->GetIndex();
645
646 /* Clicked on a widget that is not disabled.
647 * So unless the clicked widget is the caption bar, change focus to this widget.
648 * Exception: In the OSK we always want the editbox to stay focused. */
649 if (widget_index >= 0 && widget_type != WWT_CAPTION && w->window_class != WC_OSK) {
650 /* focused_widget_changed is 'now' only true if the window this widget
651 * is in gained focus. In that case it must remain true, also if the
652 * local widget focus did not change. As such it's the logical-or of
653 * both changed states.
654 *
655 * If this is not preserved, then the OSK window would be opened when
656 * a user has the edit box focused and then click on another window and
657 * then back again on the edit box (to type some text).
658 */
659 focused_widget_changed |= w->SetFocusedWidget(widget_index);
660 }
661
662 /* Dropdown window of this widget was closed so don't process click this time. */
663 if (nw->disp_flags.Test(NWidgetDisplayFlag::DropdownClosed)) return;
664
665 if ((widget_type & ~WWB_PUSHBUTTON) < WWT_LAST && (widget_type & WWB_PUSHBUTTON)) w->HandleButtonClick(widget_index);
666
667 Point pt = { x, y };
668
669 switch (widget_type) {
670 case NWID_VSCROLLBAR:
671 case NWID_HSCROLLBAR:
672 ScrollbarClickHandler(w, nw, x, y);
673 break;
674
675 case WWT_EDITBOX: {
676 QueryString *query = w->GetQueryString(widget_index);
677 if (query != nullptr) query->ClickEditBox(w, pt, widget_index, click_count, focused_widget_changed);
678 break;
679 }
680
681 case WWT_CLOSEBOX: // 'X'
682 w->Close();
683 return;
684
685 case WWT_CAPTION: // 'Title bar'
686 StartWindowDrag(w);
687 return;
688
689 case WWT_RESIZEBOX:
690 /* When the resize widget is on the left size of the window
691 * we assume that that button is used to resize to the left. */
692 StartWindowSizing(w, nw->pos_x < (w->width / 2));
693 nw->SetDirty(w);
694 return;
695
696 case WWT_DEFSIZEBOX: {
697 if (_ctrl_pressed) {
698 if (click_count > 1) {
699 w->window_desc.pref_width = 0;
700 w->window_desc.pref_height = 0;
701 } else {
702 w->window_desc.pref_width = w->width;
703 w->window_desc.pref_height = w->height;
704 }
705 } else {
706 int16_t def_width = std::max<int16_t>(std::min<int16_t>(w->window_desc.GetDefaultWidth(), _screen.width), w->nested_root->smallest_x);
707 int16_t def_height = std::max<int16_t>(std::min<int16_t>(w->window_desc.GetDefaultHeight(), _screen.height - 50), w->nested_root->smallest_y);
708
709 int dx = (w->resize.step_width == 0) ? 0 : def_width - w->width;
710 int dy = (w->resize.step_height == 0) ? 0 : def_height - w->height;
711 /* dx and dy has to go by step.. calculate it.
712 * The cast to int is necessary else dx/dy are implicitly cast to unsigned int, which won't work. */
713 if (w->resize.step_width > 1) dx -= dx % (int)w->resize.step_width;
714 if (w->resize.step_height > 1) dy -= dy % (int)w->resize.step_height;
715 ResizeWindow(w, dx, dy, false);
716 }
717
718 nw->SetLowered(true);
719 nw->SetDirty(w);
720 w->SetTimeout();
721 break;
722 }
723
724 case WWT_DEBUGBOX:
725 w->ShowNewGRFInspectWindow();
726 break;
727
728 case WWT_SHADEBOX:
729 nw->SetDirty(w);
730 w->SetShaded(!w->IsShaded());
731 return;
732
733 case WWT_STICKYBOX:
734 w->flags.Flip(WindowFlag::Sticky);
735 nw->SetDirty(w);
736 if (_ctrl_pressed) w->window_desc.pref_sticky = w->flags.Test(WindowFlag::Sticky);
737 return;
738
739 default:
740 break;
741 }
742
743 /* Widget has no index, so the window is not interested in it. */
744 if (widget_index < 0) return;
745
746 /* Check if the widget is highlighted; if so, disable highlight and dispatch an event to the GameScript */
747 if (w->IsWidgetHighlighted(widget_index)) {
748 w->SetWidgetHighlight(widget_index, TC_INVALID);
749 Game::NewEvent(new ScriptEventWindowWidgetClick((ScriptWindow::WindowClass)w->window_class, w->window_number, widget_index));
750 }
751
752 w->OnClick(pt, widget_index, click_count);
753}
754
761 static void DispatchRightClickEvent(Window *w, int x, int y)
762{
763 NWidgetCore *wid = w->nested_root->GetWidgetFromPos(x, y);
764 if (wid == nullptr) return;
765
766 Point pt = { x, y };
767
768 /* No widget to handle, or the window is not interested in it. */
769 if (wid->GetIndex() >= 0) {
770 if (w->OnRightClick(pt, wid->GetIndex())) return;
771 }
772
773 /* Right-click close is enabled and there is a closebox. */
774 if (_settings_client.gui.right_click_wnd_close == RCC_YES && !w->window_desc.flags.Test(WindowDefaultFlag::NoClose)) {
775 w->Close();
776 } else if (_settings_client.gui.right_click_wnd_close == RCC_YES_EXCEPT_STICKY && !w->flags.Test(WindowFlag::Sticky) && !w->window_desc.flags.Test(WindowDefaultFlag::NoClose)) {
777 /* Right-click close is enabled, but excluding sticky windows. */
778 w->Close();
779 } else if (_settings_client.gui.hover_delay_ms == 0 && !w->OnTooltip(pt, wid->GetIndex(), TCC_RIGHT_CLICK) && wid->GetToolTip() != STR_NULL) {
780 GuiShowTooltips(w, GetEncodedString(wid->GetToolTip()), TCC_RIGHT_CLICK);
781 }
782}
783
790 static void DispatchHoverEvent(Window *w, int x, int y)
791{
792 NWidgetCore *wid = w->nested_root->GetWidgetFromPos(x, y);
793
794 /* No widget to handle */
795 if (wid == nullptr) return;
796
797 Point pt = { x, y };
798
799 /* Show the tooltip if there is any */
800 if (!w->OnTooltip(pt, wid->GetIndex(), TCC_HOVER) && wid->GetToolTip() != STR_NULL) {
801 GuiShowTooltips(w, GetEncodedString(wid->GetToolTip()), TCC_HOVER);
802 return;
803 }
804
805 /* Widget has no index, so the window is not interested in it. */
806 if (wid->GetIndex() < 0) return;
807
808 w->OnHover(pt, wid->GetIndex());
809}
810
818 static void DispatchMouseWheelEvent(Window *w, NWidgetCore *nwid, int wheel)
819{
820 if (nwid == nullptr) return;
821
822 /* Using wheel on caption/shade-box shades or unshades the window. */
823 if (nwid->type == WWT_CAPTION || nwid->type == WWT_SHADEBOX) {
824 w->SetShaded(wheel < 0);
825 return;
826 }
827
828 /* Wheeling a vertical scrollbar. */
829 if (nwid->type == NWID_VSCROLLBAR) {
830 NWidgetScrollbar *sb = static_cast<NWidgetScrollbar *>(nwid);
831 if (sb->GetCount() > sb->GetCapacity()) {
832 if (sb->UpdatePosition(wheel)) {
833 w->OnScrollbarScroll(nwid->GetIndex());
834 w->SetDirty();
835 }
836 }
837 return;
838 }
839
840 /* Scroll the widget attached to the scrollbar. */
841 Scrollbar *sb = (nwid->GetScrollbarIndex() >= 0 ? w->GetScrollbar(nwid->GetScrollbarIndex()) : nullptr);
842 if (sb != nullptr && sb->GetCount() > sb->GetCapacity()) {
843 if (sb->UpdatePosition(wheel)) {
844 w->OnScrollbarScroll(nwid->GetScrollbarIndex());
845 w->SetDirty();
846 }
847 }
848}
849
855 static bool MayBeShown(const Window *w)
856{
857 /* If we're not modal, everything is okay. */
858 if (!HasModalProgress()) return true;
859
860 switch (w->window_class) {
861 case WC_MAIN_WINDOW:
862 case WC_MODAL_PROGRESS:
863 case WC_CONFIRM_POPUP_QUERY:
864 return true;
865
866 default:
867 return false;
868 }
869}
870
883 static void DrawOverlappedWindow(Window *w, int left, int top, int right, int bottom)
884{
885 Window::IteratorToFront it(w);
886 ++it;
887 for (; !it.IsEnd(); ++it) {
888 const Window *v = *it;
889 if (MayBeShown(v) &&
890 right > v->left &&
891 bottom > v->top &&
892 left < v->left + v->width &&
893 top < v->top + v->height) {
894 /* v and rectangle intersect with each other */
895 int x;
896
897 if (left < (x = v->left)) {
898 DrawOverlappedWindow(w, left, top, x, bottom);
899 DrawOverlappedWindow(w, x, top, right, bottom);
900 return;
901 }
902
903 if (right > (x = v->left + v->width)) {
904 DrawOverlappedWindow(w, left, top, x, bottom);
905 DrawOverlappedWindow(w, x, top, right, bottom);
906 return;
907 }
908
909 if (top < (x = v->top)) {
910 DrawOverlappedWindow(w, left, top, right, x);
911 DrawOverlappedWindow(w, left, x, right, bottom);
912 return;
913 }
914
915 if (bottom > (x = v->top + v->height)) {
916 DrawOverlappedWindow(w, left, top, right, x);
917 DrawOverlappedWindow(w, left, x, right, bottom);
918 return;
919 }
920
921 return;
922 }
923 }
924
925 /* Setup blitter, and dispatch a repaint event to window *wz */
926 DrawPixelInfo *dp = _cur_dpi;
927 dp->width = right - left;
928 dp->height = bottom - top;
929 dp->left = left - w->left;
930 dp->top = top - w->top;
931 dp->pitch = _screen.pitch;
932 dp->dst_ptr = BlitterFactory::GetCurrentBlitter()->MoveTo(_screen.dst_ptr, left, top);
933 dp->zoom = ZoomLevel::Min;
934 w->OnPaint();
935}
936
945 void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)
946{
947 DrawPixelInfo bk;
948 AutoRestoreBackup dpi_backup(_cur_dpi, &bk);
949
950 for (Window *w : Window::IterateFromBack()) {
951 if (MayBeShown(w) &&
952 right > w->left &&
953 bottom > w->top &&
954 left < w->left + w->width &&
955 top < w->top + w->height) {
956 /* Window w intersects with the rectangle => needs repaint */
957 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));
958 }
959 }
960}
961
966 void Window::SetDirty() const
967{
968 AddDirtyBlock(this->left, this->top, this->left + this->width, this->top + this->height);
969}
970
978 void Window::ReInit(int rx, int ry, bool reposition)
979{
980 this->SetDirty(); // Mark whole current window as dirty.
981
982 /* Save current size. */
983 int window_width = this->width * _gui_scale / this->scale;
984 int window_height = this->height * _gui_scale / this->scale;
985 this->scale = _gui_scale;
986
987 this->OnInit();
988 /* Re-initialize window smallest size. */
989 this->nested_root->SetupSmallestSize(this);
990 this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
991 this->width = this->nested_root->smallest_x;
992 this->height = this->nested_root->smallest_y;
993 this->resize.step_width = this->nested_root->resize_x;
994 this->resize.step_height = this->nested_root->resize_y;
995
996 /* Resize as close to the original size + requested resize as possible. */
997 window_width = std::max(window_width + rx, this->width);
998 window_height = std::max(window_height + ry, this->height);
999 int dx = (this->resize.step_width == 0) ? 0 : window_width - this->width;
1000 int dy = (this->resize.step_height == 0) ? 0 : window_height - this->height;
1001 /* dx and dy has to go by step.. calculate it.
1002 * The cast to int is necessary else dx/dy are implicitly cast to unsigned int, which won't work. */
1003 if (this->resize.step_width > 1) dx -= dx % (int)this->resize.step_width;
1004 if (this->resize.step_height > 1) dy -= dy % (int)this->resize.step_height;
1005
1006 if (reposition) {
1007 Point pt = this->OnInitialPosition(this->nested_root->smallest_x, this->nested_root->smallest_y, window_number);
1008 this->InitializePositionSize(pt.x, pt.y, this->nested_root->smallest_x, this->nested_root->smallest_y);
1009 this->FindWindowPlacementAndResize(this->window_desc.GetDefaultWidth(), this->window_desc.GetDefaultHeight(), false);
1010 }
1011
1012 ResizeWindow(this, dx, dy, true, false);
1013 /* ResizeWindow() does this->SetDirty() already, no need to do it again here. */
1014}
1015
1021 void Window::SetShaded(bool make_shaded)
1022{
1023 if (this->shade_select == nullptr) return;
1024
1025 int desired = make_shaded ? SZSP_HORIZONTAL : 0;
1026 if (this->shade_select->shown_plane != desired) {
1027 if (make_shaded) {
1028 if (this->nested_focus != nullptr) this->UnfocusFocusedWidget();
1029 this->unshaded_size.width = this->width;
1030 this->unshaded_size.height = this->height;
1031 this->shade_select->SetDisplayedPlane(desired);
1032 this->ReInit(0, -this->height);
1033 } else {
1034 this->shade_select->SetDisplayedPlane(desired);
1035 int dx = ((int)this->unshaded_size.width > this->width) ? (int)this->unshaded_size.width - this->width : 0;
1036 int dy = ((int)this->unshaded_size.height > this->height) ? (int)this->unshaded_size.height - this->height : 0;
1037 this->ReInit(dx, dy);
1038 }
1039 }
1040}
1041
1047 Window *Window::FindChildWindow(WindowClass wc) const
1048{
1049 for (Window *v : Window::Iterate()) {
1050 if ((wc == WC_INVALID || wc == v->window_class) && v->parent == this) return v;
1051 }
1052
1053 return nullptr;
1054}
1055
1062 Window *Window::FindChildWindowById(WindowClass wc, WindowNumber number) const
1063{
1064 for (Window *v : Window::Iterate()) {
1065 if (wc == v->window_class && number == v->window_number && v->parent == this) return v;
1066 }
1067
1068 return nullptr;
1069}
1070
1075 void Window::CloseChildWindows(WindowClass wc) const
1076{
1077 Window *child = this->FindChildWindow(wc);
1078 while (child != nullptr) {
1079 child->Close();
1080 child = this->FindChildWindow(wc);
1081 }
1082}
1083
1084
1090 void Window::CloseChildWindowById(WindowClass wc, WindowNumber number) const
1091{
1092 Window *child = this->FindChildWindowById(wc, number);
1093 while (child != nullptr) {
1094 child->Close();
1095 child = this->FindChildWindowById(wc, number);
1096 }
1097}
1098
1102 void Window::Close([[maybe_unused]] int data)
1103{
1104 /* Don't close twice. */
1105 if (*this->z_position == nullptr) return;
1106
1107 *this->z_position = nullptr;
1108
1109 if (_thd.window_class == this->window_class &&
1110 _thd.window_number == this->window_number) {
1111 ResetObjectToPlace();
1112 }
1113
1114 /* Prevent Mouseover() from resetting mouse-over coordinates on a non-existing window */
1115 if (_mouseover_last_w == this) _mouseover_last_w = nullptr;
1116
1117 /* We can't scroll the window when it's closed. */
1118 if (_last_scroll_window == this) _last_scroll_window = nullptr;
1119
1120 /* Make sure we don't try to access non-existing query strings. */
1121 this->querystrings.clear();
1122
1123 /* Make sure we don't try to access this window as the focused window when it doesn't exist anymore. */
1124 if (_focused_window == this) {
1125 this->OnFocusLost(true);
1126 _focused_window = nullptr;
1127 }
1128
1129 this->CloseChildWindows();
1130
1131 this->SetDirty();
1132
1133 Window::closed_windows.push_back(this);
1134}
1135
1139Window::~Window()
1140{
1141 /* Make sure the window is closed, deletion is allowed only in Window::DeleteClosedWindows(). */
1142 assert(*this->z_position == nullptr);
1143}
1144
1151 Window *FindWindowById(WindowClass cls, WindowNumber number)
1152{
1153 for (Window *w : Window::Iterate()) {
1154 if (w->window_class == cls && w->window_number == number) return w;
1155 }
1156
1157 return nullptr;
1158}
1159
1166 Window *FindWindowByClass(WindowClass cls)
1167{
1168 for (Window *w : Window::Iterate()) {
1169 if (w->window_class == cls) return w;
1170 }
1171
1172 return nullptr;
1173}
1174
1180 Window *GetMainWindow()
1181{
1182 Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
1183 assert(w != nullptr);
1184 return w;
1185}
1186
1193 void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
1194{
1195 Window *w = FindWindowById(cls, number);
1196 if (w != nullptr && (force || !w->flags.Test(WindowFlag::Sticky))) {
1197 w->Close(data);
1198 }
1199}
1200
1205 void CloseWindowByClass(WindowClass cls, int data)
1206{
1207 /* Note: the container remains stable, even when deleting windows. */
1208 for (Window *w : Window::Iterate()) {
1209 if (w->window_class == cls) {
1210 w->Close(data);
1211 }
1212 }
1213}
1214
1221 void CloseCompanyWindows(CompanyID id)
1222{
1223 /* Note: the container remains stable, even when deleting windows. */
1224 for (Window *w : Window::Iterate()) {
1225 if (w->owner == id) {
1226 w->Close();
1227 }
1228 }
1229
1230 /* Also delete the company specific windows that don't have a company-colour. */
1231 CloseWindowById(WC_BUY_COMPANY, id);
1232}
1233
1241 void ChangeWindowOwner(Owner old_owner, Owner new_owner)
1242{
1243 for (Window *w : Window::Iterate()) {
1244 if (w->owner != old_owner) continue;
1245
1246 switch (w->window_class) {
1247 case WC_COMPANY_COLOUR:
1248 case WC_FINANCES:
1249 case WC_STATION_LIST:
1250 case WC_TRAINS_LIST:
1251 case WC_ROADVEH_LIST:
1252 case WC_SHIPS_LIST:
1253 case WC_AIRCRAFT_LIST:
1254 case WC_BUY_COMPANY:
1255 case WC_COMPANY:
1256 case WC_COMPANY_INFRASTRUCTURE:
1257 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().
1258 continue;
1259
1260 default:
1261 w->owner = new_owner;
1262 break;
1263 }
1264 }
1265}
1266
1267static void BringWindowToFront(Window *w, bool dirty = true);
1268
1276 Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)
1277{
1278 Window *w = FindWindowById(cls, number);
1279
1280 if (w != nullptr) {
1281 if (w->IsShaded()) w->SetShaded(false); // Restore original window size if it was shaded.
1282
1283 w->SetWhiteBorder();
1284 BringWindowToFront(w);
1285 w->SetDirty();
1286 }
1287
1288 return w;
1289}
1290
1291static inline bool IsVitalWindow(const Window *w)
1292{
1293 switch (w->window_class) {
1294 case WC_MAIN_TOOLBAR:
1295 case WC_STATUS_BAR:
1296 case WC_NEWS_WINDOW:
1297 case WC_SEND_NETWORK_MSG:
1298 return true;
1299
1300 default:
1301 return false;
1302 }
1303}
1304
1313 static uint GetWindowZPriority(WindowClass wc)
1314{
1315 assert(wc != WC_INVALID);
1316
1317 uint z_priority = 0;
1318
1319 switch (wc) {
1320 case WC_TOOLTIPS:
1321 ++z_priority;
1322 [[fallthrough]];
1323
1324 case WC_ERRMSG:
1325 case WC_CONFIRM_POPUP_QUERY:
1326 ++z_priority;
1327 [[fallthrough]];
1328
1329 case WC_ENDSCREEN:
1330 ++z_priority;
1331 [[fallthrough]];
1332
1333 case WC_HIGHSCORE:
1334 ++z_priority;
1335 [[fallthrough]];
1336
1337 case WC_DROPDOWN_MENU:
1338 ++z_priority;
1339 [[fallthrough]];
1340
1341 case WC_MAIN_TOOLBAR:
1342 case WC_STATUS_BAR:
1343 ++z_priority;
1344 [[fallthrough]];
1345
1346 case WC_OSK:
1347 ++z_priority;
1348 [[fallthrough]];
1349
1350 case WC_QUERY_STRING:
1351 case WC_SEND_NETWORK_MSG:
1352 ++z_priority;
1353 [[fallthrough]];
1354
1355 case WC_NETWORK_ASK_RELAY:
1356 case WC_MODAL_PROGRESS:
1357 case WC_NETWORK_STATUS_WINDOW:
1358 case WC_SAVE_PRESET:
1359 ++z_priority;
1360 [[fallthrough]];
1361
1362 case WC_GENERATE_LANDSCAPE:
1363 case WC_SAVELOAD:
1364 case WC_GAME_OPTIONS:
1365 case WC_CUSTOM_CURRENCY:
1366 case WC_NETWORK_WINDOW:
1367 case WC_GRF_PARAMETERS:
1368 case WC_SCRIPT_LIST:
1369 case WC_SCRIPT_SETTINGS:
1370 case WC_TEXTFILE:
1371 ++z_priority;
1372 [[fallthrough]];
1373
1374 case WC_CONSOLE:
1375 ++z_priority;
1376 [[fallthrough]];
1377
1378 case WC_NEWS_WINDOW:
1379 ++z_priority;
1380 [[fallthrough]];
1381
1382 default:
1383 ++z_priority;
1384 [[fallthrough]];
1385
1386 case WC_MAIN_WINDOW:
1387 return z_priority;
1388 }
1389}
1390
1397 static void BringWindowToFront(Window *w, bool dirty)
1398{
1399 auto priority = GetWindowZPriority(w->window_class);
1400 WindowList::iterator dest = _z_windows.begin();
1401 while (dest != _z_windows.end() && (*dest == nullptr || GetWindowZPriority((*dest)->window_class) <= priority)) ++dest;
1402
1403 if (dest != w->z_position) {
1404 _z_windows.splice(dest, _z_windows, w->z_position);
1405 }
1406
1407 if (dirty) w->SetDirty();
1408}
1409
1417 void Window::InitializeData(WindowNumber window_number)
1418{
1419 /* Set up window properties; some of them are needed to set up smallest size below */
1420 this->window_class = this->window_desc.cls;
1421 this->SetWhiteBorder();
1422 if (this->window_desc.default_pos == WDP_CENTER) this->flags.Set(WindowFlag::Centred);
1423 this->owner = INVALID_OWNER;
1424 this->nested_focus = nullptr;
1425 this->window_number = window_number;
1426
1427 this->OnInit();
1428 /* Initialize smallest size. */
1429 this->nested_root->SetupSmallestSize(this);
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 dropdown menu has focus or a text box of the focused window has focus
1439 * (so we don't interrupt typing) unless the new window has a text box. */
1440 bool dropdown_active = _focused_window != nullptr && _focused_window->window_class == WC_DROPDOWN_MENU;
1441 bool editbox_active = EditBoxInGlobalFocus() && this->nested_root->GetWidgetOfType(WWT_EDITBOX) == nullptr;
1442 if (!dropdown_active && !editbox_active) SetFocusedWindow(this);
1443
1444 /* Insert the window into the correct location in the z-ordering. */
1445 BringWindowToFront(this, false);
1446}
1447
1455 void Window::InitializePositionSize(int x, int y, int sm_width, int sm_height)
1456{
1457 this->left = x;
1458 this->top = y;
1459 this->width = sm_width;
1460 this->height = sm_height;
1461}
1462
1474 void Window::FindWindowPlacementAndResize(int def_width, int def_height, bool allow_resize)
1475{
1476 if (allow_resize) {
1477 def_width = std::max(def_width, this->width); // Don't allow default size to be smaller than smallest size
1478 def_height = std::max(def_height, this->height);
1479 /* Try to make windows smaller when our window is too small.
1480 * w->(width|height) is normally the same as min_(width|height),
1481 * but this way the GUIs can be made a little more dynamic;
1482 * one can use the same spec for multiple windows and those
1483 * can then determine the real minimum size of the window. */
1484 if (this->width != def_width || this->height != def_height) {
1485 /* Think about the overlapping toolbars when determining the minimum window size */
1486 int free_height = _screen.height;
1487 const Window *wt = FindWindowById(WC_STATUS_BAR, 0);
1488 if (wt != nullptr) free_height -= wt->height;
1489 wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
1490 if (wt != nullptr) free_height -= wt->height;
1491
1492 int enlarge_x = std::max(std::min(def_width - this->width, _screen.width - this->width), 0);
1493 int enlarge_y = std::max(std::min(def_height - this->height, free_height - this->height), 0);
1494
1495 /* X and Y has to go by step.. calculate it.
1496 * The cast to int is necessary else x/y are implicitly cast to
1497 * unsigned int, which won't work. */
1498 if (this->resize.step_width > 1) enlarge_x -= enlarge_x % (int)this->resize.step_width;
1499 if (this->resize.step_height > 1) enlarge_y -= enlarge_y % (int)this->resize.step_height;
1500
1501 ResizeWindow(this, enlarge_x, enlarge_y, true, false);
1502 /* ResizeWindow() calls this->OnResize(). */
1503 } else {
1504 /* Always call OnResize; that way the scrollbars and matrices get initialized. */
1505 this->OnResize();
1506 }
1507 }
1508
1509 int nx = this->left;
1510 int ny = this->top;
1511
1512 if (nx + this->width > _screen.width) nx -= (nx + this->width - _screen.width);
1513
1514 const Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
1515 ny = std::max(ny, (wt == nullptr || this == wt || this->top == 0) ? 0 : wt->height);
1516 nx = std::max(nx, 0);
1517
1518 if (this->viewport != nullptr) {
1519 this->viewport->left += nx - this->left;
1520 this->viewport->top += ny - this->top;
1521 }
1522 this->left = nx;
1523 this->top = ny;
1524
1525 this->SetDirty();
1526}
1527
1540 static bool IsGoodAutoPlace1(int left, int top, int width, int height, int toolbar_y, Point &pos)
1541{
1542 int right = width + left;
1543 int bottom = height + top;
1544
1545 if (left < 0 || top < toolbar_y || right > _screen.width || bottom > _screen.height) return false;
1546
1547 /* Make sure it is not obscured by any window. */
1548 for (const Window *w : Window::Iterate()) {
1549 if (w->window_class == WC_MAIN_WINDOW) continue;
1550
1551 if (right > w->left &&
1552 w->left + w->width > left &&
1553 bottom > w->top &&
1554 w->top + w->height > top) {
1555 return false;
1556 }
1557 }
1558
1559 pos.x = left;
1560 pos.y = top;
1561 return true;
1562}
1563
1576 static bool IsGoodAutoPlace2(int left, int top, int width, int height, int toolbar_y, Point &pos)
1577{
1578 bool rtl = _current_text_dir == TD_RTL;
1579
1580 /* Left part of the rectangle may be at most 1/4 off-screen,
1581 * right part of the rectangle may be at most 1/2 off-screen
1582 */
1583 if (rtl) {
1584 if (left < -(width >> 1) || left > _screen.width - (width >> 2)) return false;
1585 } else {
1586 if (left < -(width >> 2) || left > _screen.width - (width >> 1)) return false;
1587 }
1588
1589 /* Bottom part of the rectangle may be at most 1/4 off-screen */
1590 if (top < toolbar_y || top > _screen.height - (height >> 2)) return false;
1591
1592 /* Make sure it is not obscured by any window. */
1593 for (const Window *w : Window::Iterate()) {
1594 if (w->window_class == WC_MAIN_WINDOW) continue;
1595
1596 if (left + width > w->left &&
1597 w->left + w->width > left &&
1598 top + height > w->top &&
1599 w->top + w->height > top) {
1600 return false;
1601 }
1602 }
1603
1604 pos.x = left;
1605 pos.y = top;
1606 return true;
1607}
1608
1615 static Point GetAutoPlacePosition(int width, int height)
1616{
1617 Point pt;
1618
1619 bool rtl = _current_text_dir == TD_RTL;
1620
1621 /* First attempt, try top-left of the screen */
1622 const Window *main_toolbar = FindWindowByClass(WC_MAIN_TOOLBAR);
1623 const int toolbar_y = main_toolbar != nullptr ? main_toolbar->height : 0;
1624 if (IsGoodAutoPlace1(rtl ? _screen.width - width : 0, toolbar_y, width, height, toolbar_y, pt)) return pt;
1625
1626 /* Second attempt, try around all existing windows.
1627 * The new window must be entirely on-screen, and not overlap with an existing window.
1628 * Eight starting points are tried, two at each corner.
1629 */
1630 for (const Window *w : Window::Iterate()) {
1631 if (w->window_class == WC_MAIN_WINDOW) continue;
1632
1633 if (IsGoodAutoPlace1(w->left + w->width, w->top, width, height, toolbar_y, pt)) return pt;
1634 if (IsGoodAutoPlace1(w->left - width, w->top, width, height, toolbar_y, pt)) return pt;
1635 if (IsGoodAutoPlace1(w->left, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1636 if (IsGoodAutoPlace1(w->left, w->top - height, width, height, toolbar_y, pt)) return pt;
1637 if (IsGoodAutoPlace1(w->left + w->width, w->top + w->height - height, width, height, toolbar_y, pt)) return pt;
1638 if (IsGoodAutoPlace1(w->left - width, w->top + w->height - height, width, height, toolbar_y, pt)) return pt;
1639 if (IsGoodAutoPlace1(w->left + w->width - width, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1640 if (IsGoodAutoPlace1(w->left + w->width - width, w->top - height, width, height, toolbar_y, pt)) return pt;
1641 }
1642
1643 /* Third attempt, try around all existing windows.
1644 * The new window may be partly off-screen, and must not overlap with an existing window.
1645 * Only four starting points are tried.
1646 */
1647 for (const Window *w : Window::Iterate()) {
1648 if (w->window_class == WC_MAIN_WINDOW) continue;
1649
1650 if (IsGoodAutoPlace2(w->left + w->width, w->top, width, height, toolbar_y, pt)) return pt;
1651 if (IsGoodAutoPlace2(w->left - width, w->top, width, height, toolbar_y, pt)) return pt;
1652 if (IsGoodAutoPlace2(w->left, w->top + w->height, width, height, toolbar_y, pt)) return pt;
1653 if (IsGoodAutoPlace2(w->left, w->top - height, width, height, toolbar_y, pt)) return pt;
1654 }
1655
1656 /* Fourth and final attempt, put window at diagonal starting from (0, toolbar_y), try multiples
1657 * of the closebox
1658 */
1659 int left = rtl ? _screen.width - width : 0, top = toolbar_y;
1660 int offset_x = rtl ? -(int)NWidgetLeaf::closebox_dimension.width : (int)NWidgetLeaf::closebox_dimension.width;
1661 int offset_y = std::max<int>(NWidgetLeaf::closebox_dimension.height, GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.captiontext.Vertical());
1662
1663restart:
1664 for (const Window *w : Window::Iterate()) {
1665 if (w->left == left && w->top == top) {
1666 left += offset_x;
1667 top += offset_y;
1668 goto restart;
1669 }
1670 }
1671
1672 pt.x = left;
1673 pt.y = top;
1674 return pt;
1675}
1676
1683 Point GetToolbarAlignedWindowPosition(int window_width)
1684{
1685 const Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
1686 assert(w != nullptr);
1687 Point pt = { _current_text_dir == TD_RTL ? w->left : (w->left + w->width) - window_width, w->top + w->height };
1688 return pt;
1689}
1690
1699 Point AlignInitialConstructionToolbar(int window_width)
1700{
1701 Point pt = GetToolbarAlignedWindowPosition(window_width);
1702 const Window *w = FindWindowByClass(WC_SCEN_LAND_GEN);
1703 if (w != nullptr && w->top == pt.y && !_settings_client.gui.link_terraform_toolbar) {
1704 pt.x = w->left + (_current_text_dir == TD_RTL ? w->width : - window_width);
1705 }
1706 return pt;
1707}
1708
1726 static Point LocalGetWindowPlacement(const WindowDesc &desc, int16_t sm_width, int16_t sm_height, int window_number)
1727{
1728 Point pt;
1729 const Window *w;
1730
1731 int16_t default_width = std::max(desc.GetDefaultWidth(), sm_width);
1732 int16_t default_height = std::max(desc.GetDefaultHeight(), sm_height);
1733
1734 if (desc.parent_cls != WC_NONE && (w = FindWindowById(desc.parent_cls, window_number)) != nullptr) {
1735 bool rtl = _current_text_dir == TD_RTL;
1736 if (desc.parent_cls == WC_BUILD_TOOLBAR || desc.parent_cls == WC_SCEN_LAND_GEN) {
1737 pt.x = w->left + (rtl ? w->width - default_width : 0);
1738 pt.y = w->top + w->height;
1739 return pt;
1740 } else {
1741 /* Position child window with offset of closebox, but make sure that either closebox or resizebox is visible
1742 * - Y position: closebox of parent + closebox of child + statusbar
1743 * - X position: closebox on left/right, resizebox on right/left (depending on ltr/rtl)
1744 */
1745 int indent_y = std::max<int>(NWidgetLeaf::closebox_dimension.height, GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.captiontext.Vertical());
1746 if (w->top + 3 * indent_y < _screen.height) {
1747 pt.y = w->top + indent_y;
1748 int indent_close = NWidgetLeaf::closebox_dimension.width;
1749 int indent_resize = NWidgetLeaf::resizebox_dimension.width;
1750 if (_current_text_dir == TD_RTL) {
1751 pt.x = std::max(w->left + w->width - default_width - indent_close, 0);
1752 if (pt.x + default_width >= indent_close && pt.x + indent_resize <= _screen.width) return pt;
1753 } else {
1754 pt.x = std::min(w->left + indent_close, _screen.width - default_width);
1755 if (pt.x + default_width >= indent_resize && pt.x + indent_close <= _screen.width) return pt;
1756 }
1757 }
1758 }
1759 }
1760
1761 switch (desc.default_pos) {
1762 case WDP_ALIGN_TOOLBAR: // Align to the toolbar
1763 return GetToolbarAlignedWindowPosition(default_width);
1764
1765 case WDP_AUTO: // Find a good automatic position for the window
1766 return GetAutoPlacePosition(default_width, default_height);
1767
1768 case WDP_CENTER: // Centre the window horizontally
1769 pt.x = (_screen.width - default_width) / 2;
1770 pt.y = (_screen.height - default_height) / 2;
1771 break;
1772
1773 case WDP_MANUAL:
1774 pt.x = 0;
1775 pt.y = 0;
1776 break;
1777
1778 default:
1779 NOT_REACHED();
1780 }
1781
1782 return pt;
1783}
1784
1785/* virtual */ Point Window::OnInitialPosition([[maybe_unused]]int16_t sm_width, [[maybe_unused]]int16_t sm_height, [[maybe_unused]]int window_number)
1786{
1787 return LocalGetWindowPlacement(this->window_desc, sm_width, sm_height, window_number);
1788}
1789
1797 void Window::CreateNestedTree()
1798{
1799 this->nested_root = MakeWindowNWidgetTree(this->window_desc.nwid_parts, &this->shade_select);
1800 this->nested_root->FillWidgetLookup(this->widget_lookup);
1801}
1802
1807 void Window::FinishInitNested(WindowNumber window_number)
1808{
1809 this->InitializeData(window_number);
1810 this->ApplyDefaults();
1811 Point pt = this->OnInitialPosition(this->nested_root->smallest_x, this->nested_root->smallest_y, window_number);
1812 this->InitializePositionSize(pt.x, pt.y, this->nested_root->smallest_x, this->nested_root->smallest_y);
1813 this->FindWindowPlacementAndResize(this->window_desc.GetDefaultWidth(), this->window_desc.GetDefaultHeight(), true);
1814}
1815
1820 void Window::InitNested(WindowNumber window_number)
1821{
1822 this->CreateNestedTree();
1823 this->FinishInitNested(window_number);
1824}
1825
1830Window::Window(WindowDesc &desc) : window_desc(desc), scale(_gui_scale), mouse_capture_widget(INVALID_WIDGET)
1831{
1832 this->z_position = _z_windows.insert(_z_windows.end(), this);
1833}
1834
1842 Window *FindWindowFromPt(int x, int y)
1843{
1844 for (Window *w : Window::IterateFromFront()) {
1845 if (MayBeShown(w) && IsInsideBS(x, w->left, w->width) && IsInsideBS(y, w->top, w->height)) {
1846 return w;
1847 }
1848 }
1849
1850 return nullptr;
1851}
1852
1856 void InitWindowSystem()
1857{
1858 IConsoleClose();
1859
1860 _focused_window = nullptr;
1861 _mouseover_last_w = nullptr;
1862 _last_scroll_window = nullptr;
1863 _scrolling_viewport = false;
1864 _mouse_hovering = false;
1865
1866 SetupWidgetDimensions();
1867 NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
1868 NWidgetScrollbar::InvalidateDimensionCache();
1869
1870 InitDepotWindowBlockSizes();
1871
1872 ShowFirstError();
1873}
1874
1878 void UnInitWindowSystem()
1879{
1880 UnshowCriticalError();
1881
1882 for (Window *w : Window::Iterate()) w->Close();
1883
1884 Window::DeleteClosedWindows();
1885
1886 assert(_z_windows.empty());
1887}
1888
1892 void ResetWindowSystem()
1893{
1894 UnInitWindowSystem();
1895 InitWindowSystem();
1896 _thd.Reset();
1897}
1898
1899static void DecreaseWindowCounters()
1900{
1901 if (_scroller_click_timeout != 0) _scroller_click_timeout--;
1902
1903 for (Window *w : Window::Iterate()) {
1904 if (_scroller_click_timeout == 0) {
1905 /* Unclick scrollbar buttons if they are pressed. */
1906 for (auto &pair : w->widget_lookup) {
1907 NWidgetBase *nwid = pair.second;
1908 if (nwid->type == NWID_HSCROLLBAR || nwid->type == NWID_VSCROLLBAR) {
1909 NWidgetScrollbar *sb = static_cast<NWidgetScrollbar*>(nwid);
1910 if (sb->disp_flags.Any({NWidgetDisplayFlag::ScrollbarUp, NWidgetDisplayFlag::ScrollbarDown})) {
1911 sb->disp_flags.Reset({NWidgetDisplayFlag::ScrollbarUp, NWidgetDisplayFlag::ScrollbarDown});
1912 w->mouse_capture_widget = INVALID_WIDGET;
1913 sb->SetDirty(w);
1914 }
1915 }
1916 }
1917 }
1918
1919 /* Handle editboxes */
1920 for (auto &pair : w->querystrings) {
1921 pair.second->HandleEditBox(w, pair.first);
1922 }
1923
1924 w->OnMouseLoop();
1925 }
1926
1927 for (Window *w : Window::Iterate()) {
1928 if (w->flags.Test(WindowFlag::Timeout) && --w->timeout_timer == 0) {
1929 w->flags.Reset(WindowFlag::Timeout);
1930
1931 w->OnTimeout();
1932 w->RaiseButtons(true);
1933 }
1934 }
1935}
1936
1937static void HandlePlacePresize()
1938{
1939 if (_special_mouse_mode != WSM_PRESIZE) return;
1940
1941 Window *w = _thd.GetCallbackWnd();
1942 if (w == nullptr) return;
1943
1944 Point pt = GetTileBelowCursor();
1945 if (pt.x == -1) {
1946 _thd.selend.x = -1;
1947 return;
1948 }
1949
1950 w->OnPlacePresize(pt, TileVirtXY(pt.x, pt.y));
1951}
1952
1957 static EventState HandleMouseDragDrop()
1958{
1959 if (_special_mouse_mode != WSM_DRAGDROP) return ES_NOT_HANDLED;
1960
1961 if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED; // Dragging, but the mouse did not move.
1962
1963 Window *w = _thd.GetCallbackWnd();
1964 if (w != nullptr) {
1965 /* Send an event in client coordinates. */
1966 Point pt;
1967 pt.x = _cursor.pos.x - w->left;
1968 pt.y = _cursor.pos.y - w->top;
1969 if (_left_button_down) {
1970 w->OnMouseDrag(pt, GetWidgetFromPos(w, pt.x, pt.y));
1971 } else {
1972 w->OnDragDrop(pt, GetWidgetFromPos(w, pt.x, pt.y));
1973 }
1974 }
1975
1976 if (!_left_button_down) ResetObjectToPlace(); // Button released, finished dragging.
1977 return ES_HANDLED;
1978}
1979
1981 static void HandleMouseOver()
1982{
1983 Window *w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
1984
1985 /* We changed window, put an OnMouseOver event to the last window */
1986 if (_mouseover_last_w != nullptr && _mouseover_last_w != w) {
1987 /* Reset mouse-over coordinates of previous window */
1988 Point pt = { -1, -1 };
1989 _mouseover_last_w->OnMouseOver(pt, 0);
1990 }
1991
1992 /* _mouseover_last_w will get reset when the window is deleted, see DeleteWindow() */
1993 _mouseover_last_w = w;
1994
1995 if (w != nullptr) {
1996 /* send an event in client coordinates. */
1997 Point pt = { _cursor.pos.x - w->left, _cursor.pos.y - w->top };
1998 const NWidgetCore *widget = w->nested_root->GetWidgetFromPos(pt.x, pt.y);
1999 if (widget != nullptr) w->OnMouseOver(pt, widget->GetIndex());
2000 }
2001}
2002
2004 enum PreventHideDirection : uint8_t {
2005 PHD_UP,
2006 PHD_DOWN,
2007};
2008
2019 static void PreventHiding(int *nx, int *ny, const Rect &rect, const Window *v, int px, PreventHideDirection dir)
2020{
2021 if (v == nullptr) return;
2022
2023 const int min_visible = rect.Height();
2024
2025 int v_bottom = v->top + v->height - 1;
2026 int v_right = v->left + v->width - 1;
2027 int safe_y = (dir == PHD_UP) ? (v->top - min_visible - rect.top) : (v_bottom + min_visible - rect.bottom); // Compute safe vertical position.
2028
2029 if (*ny + rect.top <= v->top - min_visible) return; // Above v is enough space
2030 if (*ny + rect.bottom >= v_bottom + min_visible) return; // Below v is enough space
2031
2032 /* Vertically, the rectangle is hidden behind v. */
2033 if (*nx + rect.left + min_visible < v->left) { // At left of v.
2034 if (v->left < min_visible) *ny = safe_y; // But enough room, force it to a safe position.
2035 return;
2036 }
2037 if (*nx + rect.right - min_visible > v_right) { // At right of v.
2038 if (v_right > _screen.width - min_visible) *ny = safe_y; // Not enough room, force it to a safe position.
2039 return;
2040 }
2041
2042 /* Horizontally also hidden, force movement to a safe area. */
2043 if (px + rect.left < v->left && v->left >= min_visible) { // Coming from the left, and enough room there.
2044 *nx = v->left - min_visible - rect.left;
2045 } else if (px + rect.right > v_right && v_right <= _screen.width - min_visible) { // Coming from the right, and enough room there.
2046 *nx = v_right + min_visible - rect.right;
2047 } else {
2048 *ny = safe_y;
2049 }
2050}
2051
2059 static void EnsureVisibleCaption(Window *w, int nx, int ny)
2060{
2061 /* Search for the title bar rectangle. */
2062 const NWidgetBase *caption = w->nested_root->GetWidgetOfType(WWT_CAPTION);
2063 if (caption != nullptr) {
2064 const Rect caption_rect = caption->GetCurrentRect();
2065
2066 const int min_visible = caption_rect.Height();
2067
2068 /* Make sure the window doesn't leave the screen */
2069 nx = Clamp(nx, min_visible - caption_rect.right, _screen.width - min_visible - caption_rect.left);
2070 ny = Clamp(ny, 0, _screen.height - min_visible);
2071
2072 /* Make sure the title bar isn't hidden behind the main tool bar or the status bar. */
2073 PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_MAIN_TOOLBAR, 0), w->left, PHD_DOWN);
2074 PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_STATUS_BAR, 0), w->left, PHD_UP);
2075 }
2076
2077 if (w->viewport != nullptr) {
2078 w->viewport->left += nx - w->left;
2079 w->viewport->top += ny - w->top;
2080 }
2081
2082 w->left = nx;
2083 w->top = ny;
2084}
2085
2096 void ResizeWindow(Window *w, int delta_x, int delta_y, bool clamp_to_screen, bool schedule_resize)
2097{
2098 if (delta_x != 0 || delta_y != 0) {
2099 if (clamp_to_screen) {
2100 /* Determine the new right/bottom position. If that is outside of the bounds of
2101 * the resolution clamp it in such a manner that it stays within the bounds. */
2102 int new_right = w->left + w->width + delta_x;
2103 int new_bottom = w->top + w->height + delta_y;
2104 if (new_right >= (int)_screen.width) delta_x -= Ceil(new_right - _screen.width, std::max(1U, w->nested_root->resize_x));
2105 if (new_bottom >= (int)_screen.height) delta_y -= Ceil(new_bottom - _screen.height, std::max(1U, w->nested_root->resize_y));
2106 }
2107
2108 w->SetDirty();
2109
2110 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);
2111 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);
2112 assert(w->nested_root->resize_x == 0 || new_xinc % w->nested_root->resize_x == 0);
2113 assert(w->nested_root->resize_y == 0 || new_yinc % w->nested_root->resize_y == 0);
2114
2115 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);
2116 w->width = w->nested_root->current_x;
2117 w->height = w->nested_root->current_y;
2118 }
2119
2120 EnsureVisibleCaption(w, w->left, w->top);
2121
2122 /* Schedule OnResize to make sure everything is initialised correctly if it needs to be. */
2123 if (schedule_resize) {
2124 w->ScheduleResize();
2125 } else {
2126 w->OnResize();
2127 }
2128 w->SetDirty();
2129}
2130
2136 int GetMainViewTop()
2137{
2138 Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
2139 return (w == nullptr) ? 0 : w->top + w->height;
2140}
2141
2147 int GetMainViewBottom()
2148{
2149 Window *w = FindWindowById(WC_STATUS_BAR, 0);
2150 return (w == nullptr) ? _screen.height : w->top;
2151}
2152
2153 static bool _dragging_window;
2154
2159 static EventState HandleWindowDragging()
2160{
2161 /* Get out immediately if no window is being dragged at all. */
2162 if (!_dragging_window) return ES_NOT_HANDLED;
2163
2164 /* If button still down, but cursor hasn't moved, there is nothing to do. */
2165 if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED;
2166
2167 /* Otherwise find the window... */
2168 for (Window *w : Window::Iterate()) {
2169 if (w->flags.Test(WindowFlag::Dragging)) {
2170 /* Stop the dragging if the left mouse button was released */
2171 if (!_left_button_down) {
2172 w->flags.Reset(WindowFlag::Dragging);
2173 break;
2174 }
2175
2176 w->SetDirty();
2177
2178 int x = _cursor.pos.x + _drag_delta.x;
2179 int y = _cursor.pos.y + _drag_delta.y;
2180 int nx = x;
2181 int ny = y;
2182
2183 if (_settings_client.gui.window_snap_radius != 0) {
2184 int hsnap = ScaleGUITrad(_settings_client.gui.window_snap_radius);
2185 int vsnap = ScaleGUITrad(_settings_client.gui.window_snap_radius);
2186 int delta;
2187
2188 for (const Window *v : Window::Iterate()) {
2189 if (v == w) continue; // Don't snap at yourself
2190
2191 if (y + w->height > v->top && y < v->top + v->height) {
2192 /* Your left border <-> other right border */
2193 delta = abs(v->left + v->width - x);
2194 if (delta <= hsnap) {
2195 nx = v->left + v->width;
2196 hsnap = delta;
2197 }
2198
2199 /* Your right border <-> other left border */
2200 delta = abs(v->left - x - w->width);
2201 if (delta <= hsnap) {
2202 nx = v->left - w->width;
2203 hsnap = delta;
2204 }
2205 }
2206
2207 if (w->top + w->height >= v->top && w->top <= v->top + v->height) {
2208 /* Your left border <-> other left border */
2209 delta = abs(v->left - x);
2210 if (delta <= hsnap) {
2211 nx = v->left;
2212 hsnap = delta;
2213 }
2214
2215 /* Your right border <-> other right border */
2216 delta = abs(v->left + v->width - x - w->width);
2217 if (delta <= hsnap) {
2218 nx = v->left + v->width - w->width;
2219 hsnap = delta;
2220 }
2221 }
2222
2223 if (x + w->width > v->left && x < v->left + v->width) {
2224 /* Your top border <-> other bottom border */
2225 delta = abs(v->top + v->height - y);
2226 if (delta <= vsnap) {
2227 ny = v->top + v->height;
2228 vsnap = delta;
2229 }
2230
2231 /* Your bottom border <-> other top border */
2232 delta = abs(v->top - y - w->height);
2233 if (delta <= vsnap) {
2234 ny = v->top - w->height;
2235 vsnap = delta;
2236 }
2237 }
2238
2239 if (w->left + w->width >= v->left && w->left <= v->left + v->width) {
2240 /* Your top border <-> other top border */
2241 delta = abs(v->top - y);
2242 if (delta <= vsnap) {
2243 ny = v->top;
2244 vsnap = delta;
2245 }
2246
2247 /* Your bottom border <-> other bottom border */
2248 delta = abs(v->top + v->height - y - w->height);
2249 if (delta <= vsnap) {
2250 ny = v->top + v->height - w->height;
2251 vsnap = delta;
2252 }
2253 }
2254 }
2255 }
2256
2257 EnsureVisibleCaption(w, nx, ny);
2258
2259 w->SetDirty();
2260 return ES_HANDLED;
2261 } else if (w->flags.Test(WindowFlag::SizingLeft) || w->flags.Test(WindowFlag::SizingRight)) {
2262 /* Stop the sizing if the left mouse button was released */
2263 if (!_left_button_down) {
2264 w->flags.Reset(WindowFlag::SizingLeft);
2265 w->flags.Reset(WindowFlag::SizingRight);
2266 w->SetDirty();
2267 break;
2268 }
2269
2270 /* Compute difference in pixels between cursor position and reference point in the window.
2271 * If resizing the left edge of the window, moving to the left makes the window bigger not smaller.
2272 */
2273 int x, y = _cursor.pos.y - _drag_delta.y;
2274 if (w->flags.Test(WindowFlag::SizingLeft)) {
2275 x = _drag_delta.x - _cursor.pos.x;
2276 } else {
2277 x = _cursor.pos.x - _drag_delta.x;
2278 }
2279
2280 /* resize.step_width and/or resize.step_height may be 0, which means no resize is possible. */
2281 if (w->resize.step_width == 0) x = 0;
2282 if (w->resize.step_height == 0) y = 0;
2283
2284 /* Check the resize button won't go past the bottom of the screen */
2285 if (w->top + w->height + y > _screen.height) {
2286 y = _screen.height - w->height - w->top;
2287 }
2288
2289 /* X and Y has to go by step.. calculate it.
2290 * The cast to int is necessary else x/y are implicitly cast to
2291 * unsigned int, which won't work. */
2292 if (w->resize.step_width > 1) x -= x % (int)w->resize.step_width;
2293 if (w->resize.step_height > 1) y -= y % (int)w->resize.step_height;
2294
2295 /* Check that we don't go below the minimum set size */
2296 if ((int)w->width + x < (int)w->nested_root->smallest_x) {
2297 x = w->nested_root->smallest_x - w->width;
2298 }
2299 if ((int)w->height + y < (int)w->nested_root->smallest_y) {
2300 y = w->nested_root->smallest_y - w->height;
2301 }
2302
2303 /* Window already on size */
2304 if (x == 0 && y == 0) return ES_HANDLED;
2305
2306 /* Now find the new cursor pos.. this is NOT _cursor, because we move in steps. */
2307 _drag_delta.y += y;
2308 if (w->flags.Test(WindowFlag::SizingLeft) && x != 0) {
2309 _drag_delta.x -= x; // x > 0 -> window gets longer -> left-edge moves to left -> subtract x to get new position.
2310 w->SetDirty();
2311 w->left -= x; // If dragging left edge, move left window edge in opposite direction by the same amount.
2312 /* ResizeWindow() below ensures marking new position as dirty. */
2313 } else {
2314 _drag_delta.x += x;
2315 }
2316
2317 /* ResizeWindow sets both pre- and after-size to dirty for redrawing */
2318 ResizeWindow(w, x, y);
2319 return ES_HANDLED;
2320 }
2321 }
2322
2323 _dragging_window = false;
2324 return ES_HANDLED;
2325}
2326
2331 static void StartWindowDrag(Window *w)
2332{
2333 w->flags.Set(WindowFlag::Dragging);
2334 w->flags.Reset(WindowFlag::Centred);
2335 _dragging_window = true;
2336
2337 _drag_delta.x = w->left - _cursor.pos.x;
2338 _drag_delta.y = w->top - _cursor.pos.y;
2339
2340 BringWindowToFront(w);
2341}
2342
2348 static void StartWindowSizing(Window *w, bool to_left)
2349{
2350 w->flags.Set(to_left ? WindowFlag::SizingLeft : WindowFlag::SizingRight);
2351 w->flags.Reset(WindowFlag::Centred);
2352 _dragging_window = true;
2353
2354 _drag_delta.x = _cursor.pos.x;
2355 _drag_delta.y = _cursor.pos.y;
2356
2357 BringWindowToFront(w);
2358}
2359
2364 static void HandleScrollbarScrolling(Window *w)
2365{
2366 int i;
2367 NWidgetScrollbar *sb = w->GetWidget<NWidgetScrollbar>(w->mouse_capture_widget);
2368 bool rtl = false;
2369
2370 if (sb->type == NWID_HSCROLLBAR) {
2371 i = _cursor.pos.x - _cursorpos_drag_start.x;
2372 rtl = _current_text_dir == TD_RTL;
2373 } else {
2374 i = _cursor.pos.y - _cursorpos_drag_start.y;
2375 }
2376
2377 if (sb->disp_flags.Any({NWidgetDisplayFlag::ScrollbarUp, NWidgetDisplayFlag::ScrollbarDown})) {
2378 if (_scroller_click_timeout == 1) {
2379 _scroller_click_timeout = 3;
2380 if (sb->UpdatePosition(rtl == sb->disp_flags.Test(NWidgetDisplayFlag::ScrollbarUp) ? 1 : -1)) {
2381 w->OnScrollbarScroll(w->mouse_capture_widget);
2382 w->SetDirty();
2383 }
2384 }
2385 return;
2386 }
2387
2388 /* Find the item we want to move to. SetPosition will make sure it's inside bounds. */
2389 int range = sb->GetCount() - sb->GetCapacity();
2390 if (range <= 0) return;
2391
2392 int pos = RoundDivSU((i + _scrollbar_start_pos) * range, std::max(1, _scrollbar_size));
2393 if (rtl) pos = range - pos;
2394 if (sb->SetPosition(pos)) {
2395 w->OnScrollbarScroll(w->mouse_capture_widget);
2396 w->SetDirty();
2397 }
2398}
2399
2404 static EventState HandleActiveWidget()
2405{
2406 for (Window *w : Window::Iterate()) {
2407 if (w->mouse_capture_widget >= 0) {
2408 /* Abort if no button is clicked any more. */
2409 if (!_left_button_down) {
2410 w->SetWidgetDirty(w->mouse_capture_widget);
2411 w->mouse_capture_widget = INVALID_WIDGET;
2412 return ES_HANDLED;
2413 }
2414
2415 /* Handle scrollbar internally, or dispatch click event */
2416 WidgetType type = w->GetWidget<NWidgetBase>(w->mouse_capture_widget)->type;
2417 if (type == NWID_VSCROLLBAR || type == NWID_HSCROLLBAR) {
2418 HandleScrollbarScrolling(w);
2419 } else {
2420 /* If cursor hasn't moved, there is nothing to do. */
2421 if (_cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED;
2422
2423 Point pt = { _cursor.pos.x - w->left, _cursor.pos.y - w->top };
2424 w->OnClick(pt, w->mouse_capture_widget, 0);
2425 }
2426 return ES_HANDLED;
2427 }
2428 }
2429
2430 return ES_NOT_HANDLED;
2431}
2432
2437 static EventState HandleViewportScroll()
2438{
2439 bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == SWS_SCROLL_MAP && _cursor.wheel_moved;
2440
2441 if (!_scrolling_viewport) return ES_NOT_HANDLED;
2442
2443 /* When we don't have a last scroll window we are starting to scroll.
2444 * When the last scroll window and this are not the same we went
2445 * outside of the window and should not left-mouse scroll anymore. */
2446 if (_last_scroll_window == nullptr) _last_scroll_window = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
2447
2448 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))) {
2449 _cursor.fix_at = false;
2450 _scrolling_viewport = false;
2451 _last_scroll_window = nullptr;
2452 return ES_NOT_HANDLED;
2453 }
2454
2455 if (_last_scroll_window == GetMainWindow() && _last_scroll_window->viewport->follow_vehicle != VehicleID::Invalid()) {
2456 /* If the main window is following a vehicle, then first let go of it! */
2457 const Vehicle *veh = Vehicle::Get(_last_scroll_window->viewport->follow_vehicle);
2458 ScrollMainWindowTo(veh->x_pos, veh->y_pos, veh->z_pos, true); // This also resets follow_vehicle
2459 return ES_NOT_HANDLED;
2460 }
2461
2462 Point delta;
2463 if (scrollwheel_scrolling) {
2464 /* We are using scrollwheels for scrolling */
2465 /* Use the integer part for movement */
2466 delta.x = static_cast<int>(_cursor.h_wheel);
2467 delta.y = static_cast<int>(_cursor.v_wheel);
2468 /* Keep the fractional part so that subtle movement is accumulated */
2469 float temp;
2470 _cursor.v_wheel = std::modf(_cursor.v_wheel, &temp);
2471 _cursor.h_wheel = std::modf(_cursor.h_wheel, &temp);
2472 } else {
2473 if (_settings_client.gui.scroll_mode != VSM_VIEWPORT_RMB_FIXED) {
2474 delta.x = -_cursor.delta.x;
2475 delta.y = -_cursor.delta.y;
2476 } else {
2477 delta.x = _cursor.delta.x;
2478 delta.y = _cursor.delta.y;
2479 }
2480 }
2481
2482 /* Create a scroll-event and send it to the window */
2483 if (delta.x != 0 || delta.y != 0) _last_scroll_window->OnScroll(delta);
2484
2485 _cursor.delta.x = 0;
2486 _cursor.delta.y = 0;
2487 _cursor.wheel_moved = false;
2488 return ES_HANDLED;
2489}
2490
2501 static bool MaybeBringWindowToFront(Window *w)
2502{
2503 bool bring_to_front = false;
2504
2505 if (w->window_class == WC_MAIN_WINDOW ||
2506 IsVitalWindow(w) ||
2507 w->window_class == WC_TOOLTIPS ||
2508 w->window_class == WC_DROPDOWN_MENU) {
2509 return true;
2510 }
2511
2512 /* Use unshaded window size rather than current size for shaded windows. */
2513 int w_width = w->width;
2514 int w_height = w->height;
2515 if (w->IsShaded()) {
2516 w_width = w->unshaded_size.width;
2517 w_height = w->unshaded_size.height;
2518 }
2519
2520 Window::IteratorToFront it(w);
2521 ++it;
2522 for (; !it.IsEnd(); ++it) {
2523 Window *u = *it;
2524 /* A modal child will prevent the activation of the parent window */
2525 if (u->parent == w && u->window_desc.flags.Test(WindowDefaultFlag::Modal)) {
2526 u->SetWhiteBorder();
2527 u->SetDirty();
2528 return false;
2529 }
2530
2531 if (u->window_class == WC_MAIN_WINDOW ||
2532 IsVitalWindow(u) ||
2533 u->window_class == WC_TOOLTIPS ||
2534 u->window_class == WC_DROPDOWN_MENU) {
2535 continue;
2536 }
2537
2538 /* Window sizes don't interfere, leave z-order alone */
2539 if (w->left + w_width <= u->left ||
2540 u->left + u->width <= w->left ||
2541 w->top + w_height <= u->top ||
2542 u->top + u->height <= w->top) {
2543 continue;
2544 }
2545
2546 bring_to_front = true;
2547 }
2548
2549 if (bring_to_front) BringWindowToFront(w);
2550 return true;
2551}
2552
2561 EventState Window::HandleEditBoxKey(WidgetID wid, char32_t key, uint16_t keycode)
2562{
2563 QueryString *query = this->GetQueryString(wid);
2564 if (query == nullptr) return ES_NOT_HANDLED;
2565
2566 int action = QueryString::ACTION_NOTHING;
2567
2568 switch (query->text.HandleKeyPress(key, keycode)) {
2569 case HKPR_EDITING:
2570 this->SetWidgetDirty(wid);
2571 this->OnEditboxChanged(wid);
2572 break;
2573
2574 case HKPR_CURSOR:
2575 this->SetWidgetDirty(wid);
2576 /* For the OSK also invalidate the parent window */
2577 if (this->window_class == WC_OSK) this->InvalidateData();
2578 break;
2579
2580 case HKPR_CONFIRM:
2581 if (this->window_class == WC_OSK) {
2582 this->OnClick(Point(), WID_OSK_OK, 1);
2583 } else if (query->ok_button >= 0) {
2584 this->OnClick(Point(), query->ok_button, 1);
2585 } else {
2586 action = query->ok_button;
2587 }
2588 break;
2589
2590 case HKPR_CANCEL:
2591 if (this->window_class == WC_OSK) {
2592 this->OnClick(Point(), WID_OSK_CANCEL, 1);
2593 } else if (query->cancel_button >= 0) {
2594 this->OnClick(Point(), query->cancel_button, 1);
2595 } else {
2596 action = query->cancel_button;
2597 }
2598 break;
2599
2600 case HKPR_NOT_HANDLED:
2601 return ES_NOT_HANDLED;
2602
2603 default: break;
2604 }
2605
2606 switch (action) {
2607 case QueryString::ACTION_DESELECT:
2608 this->UnfocusFocusedWidget();
2609 break;
2610
2611 case QueryString::ACTION_CLEAR:
2612 if (query->text.GetText().empty()) {
2613 /* If already empty, unfocus instead */
2614 this->UnfocusFocusedWidget();
2615 } else {
2616 query->text.DeleteAll();
2617 this->SetWidgetDirty(wid);
2618 this->OnEditboxChanged(wid);
2619 }
2620 break;
2621
2622 default:
2623 break;
2624 }
2625
2626 return ES_HANDLED;
2627}
2628
2633 void HandleToolbarHotkey(int hotkey)
2634{
2635 assert(HasModalProgress() || IsLocalCompany());
2636
2637 Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
2638 if (w != nullptr) {
2639 if (w->window_desc.hotkeys != nullptr) {
2640 if (hotkey >= 0 && w->OnHotkey(hotkey) == ES_HANDLED) return;
2641 }
2642 }
2643}
2644
2650 void HandleKeypress(uint keycode, char32_t key)
2651{
2652 /* World generation is multithreaded and messes with companies.
2653 * But there is no company related window open anyway, so _current_company is not used. */
2654 assert(HasModalProgress() || IsLocalCompany());
2655
2656 /*
2657 * The Unicode standard defines an area called the private use area. Code points in this
2658 * area are reserved for private use and thus not portable between systems. For instance,
2659 * Apple defines code points for the arrow keys in this area, but these are only printable
2660 * on a system running OS X. We don't want these keys to show up in text fields and such,
2661 * and thus we have to clear the unicode character when we encounter such a key.
2662 */
2663 if (key >= 0xE000 && key <= 0xF8FF) key = 0;
2664
2665 /*
2666 * If both key and keycode is zero, we don't bother to process the event.
2667 */
2668 if (key == 0 && keycode == 0) return;
2669
2670 /* Check if the focused window has a focused editbox */
2671 if (EditBoxInGlobalFocus()) {
2672 /* All input will in this case go to the focused editbox */
2673 if (_focused_window->window_class == WC_CONSOLE) {
2674 if (_focused_window->OnKeyPress(key, keycode) == ES_HANDLED) return;
2675 } else {
2676 if (_focused_window->HandleEditBoxKey(_focused_window->nested_focus->GetIndex(), key, keycode) == ES_HANDLED) return;
2677 }
2678 }
2679
2680 /* Call the event, start with the uppermost window, but ignore the toolbar. */
2681 for (Window *w : Window::IterateFromFront()) {
2682 if (w->window_class == WC_MAIN_TOOLBAR) continue;
2683 if (w->window_desc.hotkeys != nullptr) {
2684 int hotkey = w->window_desc.hotkeys->CheckMatch(keycode);
2685 if (hotkey >= 0 && w->OnHotkey(hotkey) == ES_HANDLED) return;
2686 }
2687 if (w->OnKeyPress(key, keycode) == ES_HANDLED) return;
2688 }
2689
2690 Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
2691 /* When there is no toolbar w is null, check for that */
2692 if (w != nullptr) {
2693 if (w->window_desc.hotkeys != nullptr) {
2694 int hotkey = w->window_desc.hotkeys->CheckMatch(keycode);
2695 if (hotkey >= 0 && w->OnHotkey(hotkey) == ES_HANDLED) return;
2696 }
2697 if (w->OnKeyPress(key, keycode) == ES_HANDLED) return;
2698 }
2699
2700 HandleGlobalHotkeys(key, keycode);
2701}
2702
2706 void HandleCtrlChanged()
2707{
2708 /* Call the event, start with the uppermost window. */
2709 for (Window *w : Window::IterateFromFront()) {
2710 if (w->OnCTRLStateChange() == ES_HANDLED) return;
2711 }
2712}
2713
2719/* virtual */ void Window::InsertTextString(WidgetID wid, std::string_view str, bool marked, std::optional<size_t> caret, std::optional<size_t> insert_location, std::optional<size_t> replacement_end)
2720{
2721 QueryString *query = this->GetQueryString(wid);
2722 if (query == nullptr) return;
2723
2724 if (query->text.InsertString(str, marked, caret, insert_location, replacement_end) || marked) {
2725 this->SetWidgetDirty(wid);
2726 this->OnEditboxChanged(wid);
2727 }
2728}
2729
2736 void HandleTextInput(std::string_view str, bool marked, std::optional<size_t> caret, std::optional<size_t> insert_location, std::optional<size_t> replacement_end)
2737{
2738 if (!EditBoxInGlobalFocus()) return;
2739
2740 _focused_window->InsertTextString(_focused_window->window_class == WC_CONSOLE ? 0 : _focused_window->nested_focus->GetIndex(), str, marked, caret, insert_location, replacement_end);
2741}
2742
2747 static void HandleAutoscroll()
2748{
2749 if (_game_mode == GM_MENU || HasModalProgress()) return;
2750 if (_settings_client.gui.auto_scrolling == VA_DISABLED) return;
2751 if (_settings_client.gui.auto_scrolling == VA_MAIN_VIEWPORT_FULLSCREEN && !_fullscreen) return;
2752
2753 int x = _cursor.pos.x;
2754 int y = _cursor.pos.y;
2755 Window *w = FindWindowFromPt(x, y);
2756 if (w == nullptr || w->flags.Test(WindowFlag::DisableVpScroll)) return;
2757 if (_settings_client.gui.auto_scrolling != VA_EVERY_VIEWPORT && w->window_class != WC_MAIN_WINDOW) return;
2758
2759 Viewport *vp = IsPtInWindowViewport(w, x, y);
2760 if (vp == nullptr) return;
2761
2762 x -= vp->left;
2763 y -= vp->top;
2764
2765 /* here allows scrolling in both x and y axis */
2766 /* If we succeed at scrolling in any direction, stop following a vehicle. */
2767 static const int SCROLLSPEED = 3;
2768 if (x - 15 < 0) {
2769 w->viewport->CancelFollow(*w);
2770 w->viewport->dest_scrollpos_x += ScaleByZoom((x - 15) * SCROLLSPEED, vp->zoom);
2771 } else if (15 - (vp->width - x) > 0) {
2772 w->viewport->CancelFollow(*w);
2773 w->viewport->dest_scrollpos_x += ScaleByZoom((15 - (vp->width - x)) * SCROLLSPEED, vp->zoom);
2774 }
2775 if (y - 15 < 0) {
2776 w->viewport->CancelFollow(*w);
2777 w->viewport->dest_scrollpos_y += ScaleByZoom((y - 15) * SCROLLSPEED, vp->zoom);
2778 } else if (15 - (vp->height - y) > 0) {
2779 w->viewport->CancelFollow(*w);
2780 w->viewport->dest_scrollpos_y += ScaleByZoom((15 - (vp->height - y)) * SCROLLSPEED, vp->zoom);
2781 }
2782}
2783
2784enum MouseClick : uint8_t {
2785 MC_NONE = 0,
2786 MC_LEFT,
2787 MC_RIGHT,
2788 MC_DOUBLE_LEFT,
2789 MC_HOVER,
2790};
2791
2792 static constexpr int MAX_OFFSET_DOUBLE_CLICK = 5;
2793 static constexpr int MAX_OFFSET_HOVER = 5;
2794
2795extern EventState VpHandlePlaceSizingDrag();
2796
2797 const std::chrono::milliseconds TIME_BETWEEN_DOUBLE_CLICK(500);
2798
2799static void ScrollMainViewport(int x, int y)
2800{
2801 if (_game_mode != GM_MENU && _game_mode != GM_BOOTSTRAP) {
2802 Window *w = GetMainWindow();
2803 w->viewport->dest_scrollpos_x += ScaleByZoom(x, w->viewport->zoom);
2804 w->viewport->dest_scrollpos_y += ScaleByZoom(y, w->viewport->zoom);
2805 }
2806}
2807
2817 static const int8_t scrollamt[16][2] = {
2818 { 0, 0},
2819 {-2, 0},
2820 { 0, -2},
2821 {-2, -1},
2822 { 2, 0},
2823 { 0, 0},
2824 { 2, -1},
2825 { 0, -2},
2826 { 0, 2},
2827 {-2, 1},
2828 { 0, 0},
2829 {-2, 0},
2830 { 2, 1},
2831 { 0, 2},
2832 { 2, 0},
2833 { 0, 0},
2834};
2835
2836static void HandleKeyScrolling()
2837{
2838 /*
2839 * Check that any of the dirkeys is pressed and that the focused window
2840 * doesn't have an edit-box as focused widget.
2841 */
2842 if (_dirkeys && !EditBoxInGlobalFocus()) {
2843 int factor = _shift_pressed ? 50 : 10;
2844
2845 if (_game_mode != GM_MENU && _game_mode != GM_BOOTSTRAP) {
2846 /* Key scrolling stops following a vehicle. */
2847 Window *main_window = GetMainWindow();
2848 main_window->viewport->CancelFollow(*main_window);
2849 }
2850
2851 ScrollMainViewport(scrollamt[_dirkeys][0] * factor, scrollamt[_dirkeys][1] * factor);
2852 }
2853}
2854
2855static void MouseLoop(MouseClick click, int mousewheel)
2856{
2857 /* World generation is multithreaded and messes with companies.
2858 * But there is no company related window open anyway, so _current_company is not used. */
2859 assert(HasModalProgress() || IsLocalCompany());
2860
2861 HandlePlacePresize();
2862 UpdateTileSelection();
2863
2864 if (VpHandlePlaceSizingDrag() == ES_HANDLED) return;
2865 if (HandleMouseDragDrop() == ES_HANDLED) return;
2866 if (HandleWindowDragging() == ES_HANDLED) return;
2867 if (HandleActiveWidget() == ES_HANDLED) return;
2868 if (HandleViewportScroll() == ES_HANDLED) return;
2869
2870 HandleMouseOver();
2871
2872 bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == SWS_SCROLL_MAP && _cursor.wheel_moved;
2873 if (click == MC_NONE && mousewheel == 0 && !scrollwheel_scrolling) return;
2874
2875 int x = _cursor.pos.x;
2876 int y = _cursor.pos.y;
2877 Window *w = FindWindowFromPt(x, y);
2878 if (w == nullptr) return;
2879
2880 if (click != MC_HOVER && !MaybeBringWindowToFront(w)) return;
2881 Viewport *vp = IsPtInWindowViewport(w, x, y);
2882
2883 /* Don't allow any action in a viewport if either in menu or when having a modal progress window */
2884 if (vp != nullptr && (_game_mode == GM_MENU || HasModalProgress())) return;
2885
2886 if (mousewheel != 0) {
2887 /* Send mousewheel event to window, unless we're scrolling a viewport or the map */
2888 if (!scrollwheel_scrolling || (vp == nullptr && w->window_class != WC_SMALLMAP)) {
2889 if (NWidgetCore *nwid = w->nested_root->GetWidgetFromPos(x - w->left, y - w->top); nwid != nullptr) {
2890 w->OnMouseWheel(mousewheel, nwid->GetIndex());
2891 }
2892 }
2893
2894 /* Dispatch a MouseWheelEvent for widgets if it is not a viewport */
2895 if (vp == nullptr) DispatchMouseWheelEvent(w, w->nested_root->GetWidgetFromPos(x - w->left, y - w->top), mousewheel);
2896 }
2897
2898 if (vp != nullptr) {
2899 if (scrollwheel_scrolling && !w->flags.Test(WindowFlag::DisableVpScroll)) {
2900 _scrolling_viewport = true;
2901 _cursor.fix_at = true;
2902 return;
2903 }
2904
2905 switch (click) {
2906 case MC_DOUBLE_LEFT:
2907 case MC_LEFT:
2908 if (HandleViewportClicked(*vp, x, y)) return;
2909 if (!w->flags.Test(WindowFlag::DisableVpScroll) &&
2910 _settings_client.gui.scroll_mode == VSM_MAP_LMB) {
2911 _scrolling_viewport = true;
2912 _cursor.fix_at = false;
2913 return;
2914 }
2915 break;
2916
2917 case MC_RIGHT:
2918 if (!w->flags.Test(WindowFlag::DisableVpScroll) &&
2919 _settings_client.gui.scroll_mode != VSM_MAP_LMB) {
2920 _scrolling_viewport = true;
2921 _cursor.fix_at = (_settings_client.gui.scroll_mode == VSM_VIEWPORT_RMB_FIXED ||
2922 _settings_client.gui.scroll_mode == VSM_MAP_RMB_FIXED);
2923 DispatchRightClickEvent(w, x - w->left, y - w->top);
2924 return;
2925 }
2926 break;
2927
2928 default:
2929 break;
2930 }
2931 }
2932
2933 switch (click) {
2934 case MC_LEFT:
2935 case MC_DOUBLE_LEFT:
2936 DispatchLeftClickEvent(w, x - w->left, y - w->top, click == MC_DOUBLE_LEFT ? 2 : 1);
2937 return;
2938
2939 default:
2940 if (!scrollwheel_scrolling || w == nullptr || w->window_class != WC_SMALLMAP) break;
2941 /* We try to use the scrollwheel to scroll since we didn't touch any of the buttons.
2942 * Simulate a right button click so we can get started. */
2943 [[fallthrough]];
2944
2945 case MC_RIGHT:
2946 DispatchRightClickEvent(w, x - w->left, y - w->top);
2947 return;
2948
2949 case MC_HOVER:
2950 DispatchHoverEvent(w, x - w->left, y - w->top);
2951 break;
2952 }
2953
2954 /* We're not doing anything with 2D scrolling, so reset the value. */
2955 _cursor.h_wheel = 0.0f;
2956 _cursor.v_wheel = 0.0f;
2957 _cursor.wheel_moved = false;
2958}
2959
2963 void HandleMouseEvents()
2964{
2965 /* World generation is multithreaded and messes with companies.
2966 * But there is no company related window open anyway, so _current_company is not used. */
2967 assert(HasModalProgress() || IsLocalCompany());
2968
2969 static std::chrono::steady_clock::time_point double_click_time = {};
2970 static Point double_click_pos = {0, 0};
2971
2972 /* Mouse event? */
2973 MouseClick click = MC_NONE;
2974 if (_left_button_down && !_left_button_clicked) {
2975 click = MC_LEFT;
2976 if (std::chrono::steady_clock::now() <= double_click_time + TIME_BETWEEN_DOUBLE_CLICK &&
2977 double_click_pos.x != 0 && abs(_cursor.pos.x - double_click_pos.x) < MAX_OFFSET_DOUBLE_CLICK &&
2978 double_click_pos.y != 0 && abs(_cursor.pos.y - double_click_pos.y) < MAX_OFFSET_DOUBLE_CLICK) {
2979 click = MC_DOUBLE_LEFT;
2980 }
2981 double_click_time = std::chrono::steady_clock::now();
2982 double_click_pos = _cursor.pos;
2983 _left_button_clicked = true;
2984 } else if (_right_button_clicked) {
2985 _right_button_clicked = false;
2986 click = MC_RIGHT;
2987 }
2988
2989 int mousewheel = 0;
2990 if (_cursor.wheel) {
2991 mousewheel = _cursor.wheel;
2992 _cursor.wheel = 0;
2993 }
2994
2995 static std::chrono::steady_clock::time_point hover_time = {};
2996 static Point hover_pos = {0, 0};
2997
2998 if (_settings_client.gui.hover_delay_ms > 0) {
2999 if (!_cursor.in_window || click != MC_NONE || mousewheel != 0 || _left_button_down || _right_button_down ||
3000 hover_pos.x == 0 || abs(_cursor.pos.x - hover_pos.x) >= MAX_OFFSET_HOVER ||
3001 hover_pos.y == 0 || abs(_cursor.pos.y - hover_pos.y) >= MAX_OFFSET_HOVER) {
3002 hover_pos = _cursor.pos;
3003 hover_time = std::chrono::steady_clock::now();
3004 _mouse_hovering = false;
3005 } else if (!_mouse_hovering) {
3006 if (std::chrono::steady_clock::now() > hover_time + std::chrono::milliseconds(_settings_client.gui.hover_delay_ms)) {
3007 click = MC_HOVER;
3008 _mouse_hovering = true;
3009 hover_time = std::chrono::steady_clock::now();
3010 }
3011 }
3012 }
3013
3014 if (click == MC_LEFT && _newgrf_debug_sprite_picker.mode == SPM_WAIT_CLICK) {
3015 /* Mark whole screen dirty, and wait for the next realtime tick, when drawing is finished. */
3016 Blitter *blitter = BlitterFactory::GetCurrentBlitter();
3017 _newgrf_debug_sprite_picker.clicked_pixel = blitter->MoveTo(_screen.dst_ptr, _cursor.pos.x, _cursor.pos.y);
3018 _newgrf_debug_sprite_picker.sprites.clear();
3019 _newgrf_debug_sprite_picker.mode = SPM_REDRAW;
3020 MarkWholeScreenDirty();
3021 } else {
3022 MouseLoop(click, mousewheel);
3023 }
3024
3025 /* We have moved the mouse the required distance,
3026 * no need to move it at any later time. */
3027 _cursor.delta.x = 0;
3028 _cursor.delta.y = 0;
3029}
3030
3034 static void CheckSoftLimit()
3035{
3036 if (_settings_client.gui.window_soft_limit == 0) return;
3037
3038 for (;;) {
3039 uint deletable_count = 0;
3040 Window *last_deletable = nullptr;
3041 for (Window *w : Window::IterateFromFront()) {
3042 if (w->window_class == WC_MAIN_WINDOW || IsVitalWindow(w) || w->flags.Test(WindowFlag::Sticky)) continue;
3043
3044 last_deletable = w;
3045 deletable_count++;
3046 }
3047
3048 /* We've not reached the soft limit yet. */
3049 if (deletable_count <= _settings_client.gui.window_soft_limit) break;
3050
3051 assert(last_deletable != nullptr);
3052 last_deletable->Close();
3053 }
3054}
3055
3059 void InputLoop()
3060{
3061 /* World generation is multithreaded and messes with companies.
3062 * But there is no company related window open anyway, so _current_company is not used. */
3063 assert(HasModalProgress() || IsLocalCompany());
3064
3065 CheckSoftLimit();
3066
3067 /* Process scheduled window deletion. */
3068 Window::DeleteClosedWindows();
3069
3070 /* HandleMouseEvents was already called for this tick */
3071 HandleMouseEvents();
3072}
3073
3074static std::chrono::time_point<std::chrono::steady_clock> _realtime_tick_start;
3075
3076bool CanContinueRealtimeTick()
3077{
3078 auto now = std::chrono::steady_clock::now();
3079 return std::chrono::duration_cast<std::chrono::milliseconds>(now - _realtime_tick_start).count() < (MILLISECONDS_PER_TICK * 3 / 4);
3080}
3081
3085 void CallWindowRealtimeTickEvent(uint delta_ms)
3086{
3087 _realtime_tick_start = std::chrono::steady_clock::now();
3088 for (Window *w : Window::Iterate()) {
3089 w->OnRealtimeTick(delta_ms);
3090 }
3091}
3092
3094 static const IntervalTimer<TimerWindow> window_interval(std::chrono::milliseconds(30), [](auto) {
3095 extern int _caret_timer;
3096 _caret_timer += 3;
3097 CursorTick();
3098
3099 HandleKeyScrolling();
3100 HandleAutoscroll();
3101 DecreaseWindowCounters();
3102});
3103
3105 static const IntervalTimer<TimerWindow> highlight_interval(TIMER_BLINK_INTERVAL, [](auto) {
3106 _window_highlight_colour = !_window_highlight_colour;
3107});
3108
3110 static const IntervalTimer<TimerWindow> white_border_interval(std::chrono::milliseconds(30), [](auto) {
3111 if (_network_dedicated) return;
3112
3113 for (Window *w : Window::Iterate()) {
3114 if (w->flags.Test(WindowFlag::WhiteBorder) && --w->white_border_timer == 0) {
3115 w->flags.Reset(WindowFlag::WhiteBorder);
3116 w->SetDirty();
3117 }
3118 }
3119});
3120
3124 void UpdateWindows()
3125{
3126 static auto last_time = std::chrono::steady_clock::now();
3127 auto now = std::chrono::steady_clock::now();
3128 auto delta_ms = std::chrono::duration_cast<std::chrono::milliseconds>(now - last_time);
3129
3130 if (delta_ms.count() == 0) return;
3131
3132 last_time = now;
3133
3134 PerformanceMeasurer framerate(PFE_DRAWING);
3135 PerformanceAccumulator::Reset(PFE_DRAWWORLD);
3136
3137 ProcessPendingPerformanceMeasurements();
3138
3139 TimerManager<TimerWindow>::Elapsed(delta_ms);
3140 CallWindowRealtimeTickEvent(delta_ms.count());
3141
3142 /* Process invalidations before anything else. */
3143 for (Window *w : Window::Iterate()) {
3144 w->ProcessScheduledResize();
3145 w->ProcessScheduledInvalidations();
3146 w->ProcessHighlightedInvalidations();
3147 }
3148
3149 /* Skip the actual drawing on dedicated servers without screen.
3150 * But still empty the invalidation queues above. */
3151 if (_network_dedicated) return;
3152
3153 DrawDirtyBlocks();
3154
3155 for (Window *w : Window::Iterate()) {
3156 /* Update viewport only if window is not shaded. */
3157 if (w->viewport != nullptr && !w->IsShaded()) UpdateViewportPosition(w, delta_ms.count());
3158 }
3159 NetworkDrawChatMessage();
3160 /* Redraw mouse cursor in case it was hidden */
3161 DrawMouseCursor();
3162
3163 if (_newgrf_debug_sprite_picker.mode == SPM_REDRAW) {
3164 /* We are done with the last draw-frame, so we know what sprites we
3165 * clicked on. Reset the picker mode and invalidate the window. */
3166 _newgrf_debug_sprite_picker.mode = SPM_NONE;
3167 InvalidateWindowData(WC_SPRITE_ALIGNER, 0, 1);
3168 }
3169}
3170
3176 void SetWindowDirty(WindowClass cls, WindowNumber number)
3177{
3178 for (const Window *w : Window::Iterate()) {
3179 if (w->window_class == cls && w->window_number == number) w->SetDirty();
3180 }
3181}
3182
3189 void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, WidgetID widget_index)
3190{
3191 for (const Window *w : Window::Iterate()) {
3192 if (w->window_class == cls && w->window_number == number) {
3193 w->SetWidgetDirty(widget_index);
3194 }
3195 }
3196}
3197
3202 void SetWindowClassesDirty(WindowClass cls)
3203{
3204 for (const Window *w : Window::Iterate()) {
3205 if (w->window_class == cls) w->SetDirty();
3206 }
3207}
3208
3212 void Window::ScheduleResize()
3213{
3214 this->scheduled_resize = true;
3215}
3216
3220 void Window::ProcessScheduledResize()
3221{
3222 /* Sometimes OnResize() resizes the window again, in which case we can reprocess immediately. */
3223 while (this->scheduled_resize) {
3224 this->scheduled_resize = false;
3225 this->OnResize();
3226 }
3227}
3228
3234 void Window::InvalidateData(int data, bool gui_scope)
3235{
3236 this->SetDirty();
3237 if (!gui_scope) {
3238 /* Schedule GUI-scope invalidation for next redraw. */
3239 this->scheduled_invalidation_data.push_back(data);
3240 }
3241 this->OnInvalidateData(data, gui_scope);
3242}
3243
3247 void Window::ProcessScheduledInvalidations()
3248{
3249 for (int data : this->scheduled_invalidation_data) {
3250 if (this->window_class == WC_INVALID) break;
3251 this->OnInvalidateData(data, true);
3252 }
3253 this->scheduled_invalidation_data.clear();
3254}
3255
3259 void Window::ProcessHighlightedInvalidations()
3260{
3261 if (!this->flags.Test(WindowFlag::Highlighted)) return;
3262
3263 for (const auto &pair : this->widget_lookup) {
3264 if (pair.second->IsHighlighted()) pair.second->SetDirty(this);
3265 }
3266}
3267
3294 void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
3295{
3296 for (Window *w : Window::Iterate()) {
3297 if (w->window_class == cls && w->window_number == number) {
3298 w->InvalidateData(data, gui_scope);
3299 }
3300 }
3301}
3302
3311 void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
3312{
3313 for (Window *w : Window::Iterate()) {
3314 if (w->window_class == cls) {
3315 w->InvalidateData(data, gui_scope);
3316 }
3317 }
3318}
3319
3323 void CallWindowGameTickEvent()
3324{
3325 for (Window *w : Window::Iterate()) {
3326 w->OnGameTick();
3327 }
3328}
3329
3336 void CloseNonVitalWindows()
3337{
3338 /* Note: the container remains stable, even when deleting windows. */
3339 for (Window *w : Window::Iterate()) {
3340 if (!w->window_desc.flags.Test(WindowDefaultFlag::NoClose) &&
3341 !w->flags.Test(WindowFlag::Sticky)) { // do not delete windows which are 'pinned'
3342
3343 w->Close();
3344 }
3345 }
3346}
3347
3355 void CloseAllNonVitalWindows()
3356{
3357 /* Note: the container remains stable, even when closing windows. */
3358 for (Window *w : Window::Iterate()) {
3359 if (!w->window_desc.flags.Test(WindowDefaultFlag::NoClose)) {
3360 w->Close();
3361 }
3362 }
3363}
3364
3368 void DeleteAllMessages()
3369{
3370 InitNewsItemStructs();
3371 InvalidateWindowData(WC_STATUS_BAR, 0, SBI_NEWS_DELETED); // invalidate the statusbar
3372 InvalidateWindowData(WC_MESSAGE_HISTORY, 0); // invalidate the message history
3373 CloseWindowById(WC_NEWS_WINDOW, 0); // close newspaper or general message window if shown
3374}
3375
3380 void CloseConstructionWindows()
3381{
3382 /* Note: the container remains stable, even when deleting windows. */
3383 for (Window *w : Window::Iterate()) {
3384 if (w->window_desc.flags.Test(WindowDefaultFlag::Construction)) {
3385 w->Close();
3386 }
3387 }
3388
3389 for (const Window *w : Window::Iterate()) w->SetDirty();
3390}
3391
3393 void HideVitalWindows()
3394{
3395 CloseWindowById(WC_MAIN_TOOLBAR, 0);
3396 CloseWindowById(WC_STATUS_BAR, 0);
3397}
3398
3399void ReInitWindow(Window *w, bool zoom_changed)
3400{
3401 if (w == nullptr) return;
3402 if (zoom_changed) {
3403 w->nested_root->AdjustPaddingForZoom();
3404 w->UpdateQueryStringSize();
3405 }
3406 w->ReInit();
3407}
3408
3410 void ReInitAllWindows(bool zoom_changed)
3411{
3412 SetupWidgetDimensions();
3413 NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
3414 NWidgetScrollbar::InvalidateDimensionCache();
3415
3416 InitDepotWindowBlockSizes();
3417
3418 /* When _gui_zoom has changed, we need to resize toolbar and statusbar first,
3419 * so EnsureVisibleCaption uses the updated size information. */
3420 ReInitWindow(FindWindowById(WC_MAIN_TOOLBAR, 0), zoom_changed);
3421 ReInitWindow(FindWindowById(WC_STATUS_BAR, 0), zoom_changed);
3422 for (Window *w : Window::Iterate()) {
3423 if (w->window_class == WC_MAIN_TOOLBAR || w->window_class == WC_STATUS_BAR) continue;
3424 ReInitWindow(w, zoom_changed);
3425 }
3426
3427 if (_networking) NetworkUndrawChatMessage();
3428 NetworkReInitChatBoxSize();
3429
3430 /* Make sure essential parts of all windows are visible */
3431 RelocateAllWindows(_screen.width, _screen.height);
3432 MarkWholeScreenDirty();
3433}
3434
3442 static int PositionWindow(Window *w, WindowClass clss, int setting)
3443{
3444 if (w == nullptr || w->window_class != clss) {
3445 w = FindWindowById(clss, 0);
3446 }
3447 if (w == nullptr) return 0;
3448
3449 int old_left = w->left;
3450 switch (setting) {
3451 case 1: w->left = (_screen.width - w->width) / 2; break;
3452 case 2: w->left = _screen.width - w->width; break;
3453 default: w->left = 0; break;
3454 }
3455 if (w->viewport != nullptr) w->viewport->left += w->left - old_left;
3456 AddDirtyBlock(0, w->top, _screen.width, w->top + w->height); // invalidate the whole row
3457 return w->left;
3458}
3459
3465 int PositionMainToolbar(Window *w)
3466{
3467 Debug(misc, 5, "Repositioning Main Toolbar...");
3468 return PositionWindow(w, WC_MAIN_TOOLBAR, _settings_client.gui.toolbar_pos);
3469}
3470
3476 int PositionStatusbar(Window *w)
3477{
3478 Debug(misc, 5, "Repositioning statusbar...");
3479 return PositionWindow(w, WC_STATUS_BAR, _settings_client.gui.statusbar_pos);
3480}
3481
3487 int PositionNewsMessage(Window *w)
3488{
3489 Debug(misc, 5, "Repositioning news message...");
3490 return PositionWindow(w, WC_NEWS_WINDOW, _settings_client.gui.statusbar_pos);
3491}
3492
3498 int PositionNetworkChatWindow(Window *w)
3499{
3500 Debug(misc, 5, "Repositioning network chat window...");
3501 return PositionWindow(w, WC_SEND_NETWORK_MSG, _settings_client.gui.statusbar_pos);
3502}
3503
3504
3510 void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index)
3511{
3512 for (const Window *w : Window::Iterate()) {
3513 if (w->viewport != nullptr && w->viewport->follow_vehicle == from_index) {
3514 w->viewport->follow_vehicle = to_index;
3515 w->SetDirty();
3516 }
3517 }
3518}
3519
3520
3526 void RelocateAllWindows(int neww, int newh)
3527{
3528 CloseWindowByClass(WC_DROPDOWN_MENU);
3529
3530 /* Reposition toolbar then status bar before other all windows. */
3531 if (Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0); wt != nullptr) {
3532 ResizeWindow(wt, std::min<uint>(neww, _toolbar_width) - wt->width, 0, false);
3533 wt->left = PositionMainToolbar(wt);
3534 }
3535
3536 if (Window *ws = FindWindowById(WC_STATUS_BAR, 0); ws != nullptr) {
3537 ResizeWindow(ws, std::min<uint>(neww, _toolbar_width) - ws->width, 0, false);
3538 ws->top = newh - ws->height;
3539 ws->left = PositionStatusbar(ws);
3540 }
3541
3542 for (Window *w : Window::Iterate()) {
3543 int left, top;
3544 /* XXX - this probably needs something more sane. For example specifying
3545 * in a 'backup'-desc that the window should always be centered. */
3546 switch (w->window_class) {
3547 case WC_MAIN_WINDOW:
3548 case WC_BOOTSTRAP:
3549 case WC_HIGHSCORE:
3550 case WC_ENDSCREEN:
3551 ResizeWindow(w, neww, newh);
3552 continue;
3553
3554 case WC_MAIN_TOOLBAR:
3555 case WC_STATUS_BAR:
3556 continue;
3557
3558 case WC_NEWS_WINDOW:
3559 top = newh - w->height;
3560 left = PositionNewsMessage(w);
3561 break;
3562
3563 case WC_SEND_NETWORK_MSG:
3564 ResizeWindow(w, std::min<uint>(neww, _toolbar_width) - w->width, 0, false);
3565
3566 top = newh - w->height - FindWindowById(WC_STATUS_BAR, 0)->height;
3567 left = PositionNetworkChatWindow(w);
3568 break;
3569
3570 case WC_CONSOLE:
3571 IConsoleResize(w);
3572 continue;
3573
3574 default: {
3575 if (w->flags.Test(WindowFlag::Centred)) {
3576 top = (newh - w->height) >> 1;
3577 left = (neww - w->width) >> 1;
3578 break;
3579 }
3580
3581 left = w->left;
3582 if (left + (w->width >> 1) >= neww) left = neww - w->width;
3583 if (left < 0) left = 0;
3584
3585 top = w->top;
3586 if (top + (w->height >> 1) >= newh) top = newh - w->height;
3587 break;
3588 }
3589 }
3590
3591 EnsureVisibleCaption(w, left, top);
3592 }
3593}
3594
3599 void PickerWindowBase::Close([[maybe_unused]] int data)
3600{
3601 ResetObjectToPlace();
3602 this->Window::Close();
3603}
BaseBitSet::Test
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
Definition base_bitset_type.hpp:141
BaseBitSet::Reset
constexpr Timpl & Reset()
Reset all bits.
Definition base_bitset_type.hpp:83
BaseBitSet::Flip
constexpr Timpl & Flip(Tvalue_type value)
Flip the value-th bit.
Definition base_bitset_type.hpp:116
BaseBitSet::Set
constexpr Timpl & Set()
Set all bits.
Definition base_bitset_type.hpp:40
BaseBitSet::Any
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
Definition base_bitset_type.hpp:170
BlitterFactory::GetCurrentBlitter
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition factory.hpp:136
Blitter
How all blitters should look like.
Definition base.hpp:29
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...
EnumBitSet
Enum-as-bit-set wrapper.
Definition enum_type.hpp:177
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition game_core.cpp:136
IntervalTimer
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition timer.h:76
NWidgetBase
Baseclass for nested widgets.
Definition widget_type.h:136
NWidgetBase::SetDirty
virtual void SetDirty(const Window *w) const
Mark the widget as 'dirty' (in need of repaint).
Definition widget.cpp:931
NWidgetBase::type
WidgetType type
Type of the widget / nested widget.
Definition widget_type.h:226
NWidgetBase::pos_y
int pos_y
Vertical position of top-left corner of the widget in the window.
Definition widget_type.h:243
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition widget_type.h:242
NWidgetBase::resize_y
uint resize_y
Vertical resize step (0 means not resizable).
Definition widget_type.h:230
NWidgetCore
Base class for a 'real' widget.
Definition widget_type.h:368
NWidgetCore::IsDisabled
bool IsDisabled() const
Return whether the widget is disabled.
Definition widget_type.h:461
NWidgetCore::disp_flags
NWidgetDisplayFlags disp_flags
Flags that affect display and interaction with the widget.
Definition widget_type.h:399
NWidgetCore::GetScrollbarIndex
WidgetID GetScrollbarIndex() const
Get the WidgetID of this nested widget's scrollbar.
Definition widget.cpp:1260
NWidgetCore::GetToolTip
StringID GetToolTip() const
Get the tool tip of the nested widget.
Definition widget.cpp:1233
NWidgetCore::SetLowered
void SetLowered(bool lowered)
Lower or raise the widget.
Definition widget_type.h:440
NWidgetCore::IsLowered
bool IsLowered() const
Return whether the widget is lowered.
Definition widget_type.h:446
NWidgetLeaf::InvalidateDimensionCache
static void InvalidateDimensionCache()
Reset the cached dimensions.
Definition widget.cpp:2642
NWidgetLeaf::resizebox_dimension
static Dimension resizebox_dimension
Cached size of a resizebox widget.
Definition widget_type.h:2657
NWidgetLeaf::closebox_dimension
static Dimension closebox_dimension
Cached size of a closebox widget.
Definition widget_type.h:2658
NWidgetScrollbar
Nested widget to display and control a scrollbar in a window.
Definition widget_type.h:908
NWidgetStacked::shown_plane
int shown_plane
Plane being displayed (for NWID_SELECTION only).
Definition widget_type.h:534
NWidgetStacked::SetDisplayedPlane
bool SetDisplayedPlane(int plane)
Select which plane to show (for NWID_SELECTION only).
Definition widget.cpp:1422
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:332
PerformanceMeasurer
RAII class for measuring simple elements of performance.
Definition framerate_type.h:91
PickerWindowBase::Close
void Close(int data=0) override
Hide the window and all its child windows, and mark them for a later deletion.
Definition window.cpp:3599
Scrollbar
Scrollbar data structure.
Definition widget_type.h:708
Scrollbar::GetCapacity
size_type GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition widget_type.h:743
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:836
Scrollbar::SetPosition
bool SetPosition(size_type position)
Sets the position of the first visible element.
Definition widget_type.h:822
Scrollbar::GetCount
size_type GetCount() const
Gets the number of elements in the list.
Definition widget_type.h:734
TimerManager::Elapsed
static bool Elapsed(TElapsed value)
Called when time for this timer elapsed.
VideoDriver::EditBoxLostFocus
virtual void EditBoxLostFocus()
An edit box lost the input focus.
Definition video_driver.hpp:153
VideoDriver::GetInstance
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
Definition video_driver.hpp:192
VideoDriver::EditBoxGainedFocus
virtual void EditBoxGainedFocus()
An edit box gained the input focus.
Definition video_driver.hpp:158
WidgetDimensions::scaled
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition window_gui.h:30
company_func.h
Functions related to companies.
IsLocalCompany
bool IsLocalCompany()
Is the current company the local company?
Definition company_func.h:47
INVALID_OWNER
static constexpr Owner INVALID_OWNER
An invalid owner.
Definition company_type.h:30
console_func.h
Console functions used outside of the console code.
IConsoleClose
void IConsoleClose()
Close the in-game console.
Definition console_gui.cpp:442
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:408
console_gui.h
GUI related functions in the console.
Debug
#define Debug(category, level, format_string,...)
Output a line of debugging information.
Definition debug.h:37
depot_func.h
Functions related to depots.
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
error.h
Functions related to errors.
UnshowCriticalError
void UnshowCriticalError()
Unshow the critical error.
Definition error_gui.cpp:272
ShowFirstError
void ShowFirstError()
Show the first error of the queue.
Definition error_gui.cpp:258
factory.hpp
Factory to 'query' all available blitters.
NO_DIRECTORY
@ NO_DIRECTORY
A path without any base directory.
Definition fileio_type.h:107
GetCharacterHeight
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition fontcache.cpp:87
ProcessPendingPerformanceMeasurements
void ProcessPendingPerformanceMeasurements()
This drains the PFE_SOUND measurement data queue into _pf_data.
Definition framerate_gui.cpp:1067
framerate_type.h
Types for recording game performance data.
PFE_DRAWING
@ PFE_DRAWING
Speed of drawing world and GUI.
Definition framerate_type.h:56
PFE_DRAWWORLD
@ PFE_DRAWWORLD
Time spent drawing world viewports in GUI.
Definition framerate_type.h:57
game.hpp
Base functions for all Games.
_shift_pressed
bool _shift_pressed
Is Shift pressed?
Definition gfx.cpp:39
_left_button_down
bool _left_button_down
Is left mouse button pressed?
Definition gfx.cpp:41
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition gfx.cpp:38
_dirkeys
uint8_t _dirkeys
1 = left, 2 = up, 4 = right, 8 = down
Definition gfx.cpp:34
_left_button_clicked
bool _left_button_clicked
Is left mouse button clicked?
Definition gfx.cpp:42
_right_button_clicked
bool _right_button_clicked
Is right mouse button clicked?
Definition gfx.cpp:44
_right_button_down
bool _right_button_down
Is right mouse button pressed?
Definition gfx.cpp:43
_gui_scale
int _gui_scale
GUI scale, 100 is 100%.
Definition gfx.cpp:63
gfx_func.h
Functions related to the gfx engine.
FS_NORMAL
@ FS_NORMAL
Index of the normal font in the font tables.
Definition gfx_type.h:249
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition gfx_type.h:307
MILLISECONDS_PER_TICK
static const uint MILLISECONDS_PER_TICK
The number of milliseconds per game tick.
Definition gfx_type.h:370
MakeWindowNWidgetTree
std::unique_ptr< NWidgetBase > MakeWindowNWidgetTree(std::span< const NWidgetPart > nwid_parts, NWidgetStacked **shade_select)
Make a nested widget tree for a window from a parts array.
Definition widget.cpp:3393
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition window.cpp:966
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:1513
DrawDirtyBlocks
void DrawDirtyBlocks()
Repaints the rectangle blocks which are marked as 'dirty'.
Definition gfx.cpp:1449
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1546
hotkeys.h
Hotkey related functions.
ini_type.h
Types related to reading/writing '*.ini' files.
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition map_func.h:416
IsInsideBS
constexpr 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:252
abs
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition math_func.hpp:23
RoundDivSU
constexpr int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
Definition math_func.hpp:332
Ceil
constexpr uint Ceil(uint a, uint b)
Computes ceil(a / b) * b for non-negative a and b.
Definition math_func.hpp:321
Clamp
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
GuiShowTooltips
void GuiShowTooltips(Window *parent, EncodedString &&text, TooltipCloseCondition close_tooltip)
Shows a tooltip.
Definition misc_gui.cpp:693
_networking
bool _networking
are we in networking mode?
Definition network.cpp:66
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition network.cpp:69
network.h
Basic functions/variables used all over the place.
NetworkDrawChatMessage
void NetworkDrawChatMessage()
Draw the chat message-box.
Definition network_chat_gui.cpp:180
NetworkReInitChatBoxSize
void NetworkReInitChatBoxSize()
Initialize all font-dependent chat box sizes.
Definition network_chat_gui.cpp:101
NetworkUndrawChatMessage
void NetworkUndrawChatMessage()
Hide the chatbox.
Definition network_chat_gui.cpp:120
network_func.h
Network functions used by other parts of OpenTTD.
newgrf_debug.h
Functions/types related to NewGRF debugging.
_newgrf_debug_sprite_picker
NewGrfDebugSpritePicker _newgrf_debug_sprite_picker
The sprite picker.
Definition newgrf_debug_gui.cpp:53
news_func.h
Functions related to news.
InitNewsItemStructs
void InitNewsItemStructs()
Initialize the news-items data structures.
Definition news_gui.cpp:714
WID_OSK_CANCEL
@ WID_OSK_CANCEL
Cancel key.
Definition osk_widget.h:17
WID_OSK_OK
@ WID_OSK_OK
Ok key.
Definition osk_widget.h:18
progress.h
Functions related to modal progress.
HasModalProgress
bool HasModalProgress()
Check if we are currently in a modal progress state.
Definition progress.h:17
querystring_gui.h
Base for the GUIs that have an edit box in them.
safeguards.h
A number of safeguards to prevent using unsafe methods.
IniLoadWindowSettings
void IniLoadWindowSettings(IniFile &ini, std::string_view grpname, WindowDesc *desc)
Load a WindowDesc from config.
Definition settings.cpp:873
IniSaveWindowSettings
void IniSaveWindowSettings(IniFile &ini, std::string_view grpname, WindowDesc *desc)
Save a WindowDesc to config.
Definition settings.cpp:884
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
settings_func.h
Functions related to setting/changing the settings.
settings_type.h
Types related to global configuration settings.
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:148
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:149
VSM_MAP_LMB
@ VSM_MAP_LMB
Map moves with mouse movement on holding left mouse button, cursor moves.
Definition settings_type.h:151
SWS_SCROLL_MAP
@ SWS_SCROLL_MAP
Scroll wheel scrolls the map.
Definition settings_type.h:158
ScrollMainWindowTo
bool ScrollMainWindowTo(int x, int y, int z, bool instant)
Scrolls the main window to given coordinates.
Definition smallmap_gui.cpp:2078
SndClickBeep
void SndClickBeep()
Play a beep sound for a click event if enabled in settings.
Definition sound.cpp:253
sound_func.h
Functions related to sound.
statusbar_gui.h
Functions, definitions and such used only by the GUI.
SBI_NEWS_DELETED
@ SBI_NEWS_DELETED
abort current news display (active news were deleted)
Definition statusbar_gui.h:19
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
GetEncodedString
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:90
GetString
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
Definition strings.cpp:424
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition strings.cpp:56
strings_func.h
Functions related to OTTD's strings.
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition strings_type.h:19
TD_RTL
@ TD_RTL
Text is written right-to-left by default.
Definition strings_type.h:27
AutoRestoreBackup
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
Definition backup_type.hpp:150
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition settings_type.h:650
Coord2D< int >
Coord2D::y
T y
Y coordinate.
Definition geometry_type.hpp:35
Coord2D::x
T x
X coordinate.
Definition geometry_type.hpp:34
CursorVars::fix_at
bool fix_at
mouse is moving, but cursor is not (used for scrolling)
Definition gfx_type.h:128
CursorVars::pos
Point pos
logical mouse position
Definition gfx_type.h:125
CursorVars::in_window
bool in_window
mouse inside this window, determines drawing logic
Definition gfx_type.h:147
CursorVars::wheel
int wheel
mouse wheel movement
Definition gfx_type.h:127
CursorVars::delta
Point delta
relative mouse movement in this tick
Definition gfx_type.h:126
DrawPixelInfo
Data about how and where to blit pixels.
Definition gfx_type.h:157
GUISettings::window_snap_radius
uint8_t window_snap_radius
windows snap at each other if closer than this
Definition settings_type.h:189
GUISettings::hover_delay_ms
uint16_t hover_delay_ms
time required to activate a hover event, in milliseconds
Definition settings_type.h:175
GUISettings::auto_scrolling
uint8_t auto_scrolling
scroll when moving mouse to the edge (see ViewportAutoscrolling)
Definition settings_type.h:173
GUISettings::scroll_mode
uint8_t scroll_mode
viewport scroll mode
Definition settings_type.h:179
GUISettings::right_click_wnd_close
RightClickClose right_click_wnd_close
close window with right click
Definition settings_type.h:206
GUISettings::window_soft_limit
uint8_t window_soft_limit
soft limit of maximum number of non-stickied non-vital windows (0 = no limit)
Definition settings_type.h:190
GUISettings::toolbar_pos
uint8_t toolbar_pos
position of toolbars, 0=left, 1=center, 2=right
Definition settings_type.h:187
GUISettings::statusbar_pos
uint8_t statusbar_pos
position of statusbar, 0=left, 1=center, 2=right
Definition settings_type.h:188
GUISettings::scrollwheel_scrolling
uint8_t scrollwheel_scrolling
scrolling using the scroll wheel?
Definition settings_type.h:203
GUISettings::link_terraform_toolbar
bool link_terraform_toolbar
display terraform toolbar when displaying rail, road, water and airport toolbars
Definition settings_type.h:176
HotkeyList
List of hotkeys for a window.
Definition hotkeys.h:37
HotkeyList::CheckMatch
int CheckMatch(uint16_t keycode, bool global_only=false) const
Check if a keycode is bound to something.
Definition hotkeys.cpp:301
IniFile
Ini file that supports both loading and saving.
Definition ini_type.h:86
IniFile::SaveToDisk
bool SaveToDisk(const std::string &filename)
Save the Ini file's data to the disk.
Definition ini.cpp:42
IniLoadFile::LoadFromDisk
void LoadFromDisk(std::string_view filename, Subdirectory subdir)
Load the Ini file's data from the disk.
Definition ini_load.cpp:185
NewGrfDebugSpritePicker::mode
NewGrfDebugSpritePickerMode mode
Current state.
Definition newgrf_debug.h:27
NewGrfDebugSpritePicker::clicked_pixel
void * clicked_pixel
Clicked pixel (pointer to blitter buffer)
Definition newgrf_debug.h:28
NewGrfDebugSpritePicker::sprites
FlatSet< SpriteID > sprites
Sprites found.
Definition newgrf_debug.h:29
PoolID< uint8_t, struct CompanyIDTag, 0xF, 0xFF >
Pool::PoolItem<&_vehicle_pool >::Get
static Titem * Get(auto index)
Returns Titem with given index.
Definition pool_type.hpp:387
QueryString
Data stored about a string that can be modified in the GUI.
Definition querystring_gui.h:20
QueryString::ok_button
int ok_button
Widget button of parent window to simulate when pressing OK in OSK.
Definition querystring_gui.h:27
QueryString::ACTION_DESELECT
static const int ACTION_DESELECT
Deselect editbox.
Definition querystring_gui.h:23
QueryString::cancel_button
int cancel_button
Widget button of parent window to simulate when pressing CANCEL in OSK.
Definition querystring_gui.h:28
QueryString::GetCharAtPosition
ptrdiff_t GetCharAtPosition(const Window *w, WidgetID wid, const Point &pt) const
Get the character that is rendered at a position.
Definition misc_gui.cpp:851
QueryString::ACTION_NOTHING
static const int ACTION_NOTHING
Nothing.
Definition querystring_gui.h:22
QueryString::ACTION_CLEAR
static const int ACTION_CLEAR
Clear editbox.
Definition querystring_gui.h:24
QueryString::GetCaretPosition
Point GetCaretPosition(const Window *w, WidgetID wid) const
Get the current caret position.
Definition misc_gui.cpp:793
QueryString::GetBoundingRect
Rect GetBoundingRect(const Window *w, WidgetID wid, size_t from, size_t to) const
Get the bounding rectangle for a range of the query string.
Definition misc_gui.cpp:821
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition geometry_type.hpp:101
Rect::Height
int Height() const
Get height of Rect.
Definition geometry_type.hpp:117
ResizeInfo::step_height
uint step_height
Step-size of height resize changes.
Definition window_gui.h:213
ResizeInfo::step_width
uint step_width
Step-size of width resize changes.
Definition window_gui.h:212
Textbuf
Helper/buffer for input fields.
Definition textbuf_type.h:30
Textbuf::UpdateSize
void UpdateSize()
Update Textbuf type with its actual physical character and screenlength Get the count of characters i...
Definition textbuf.cpp:445
Textbuf::DeleteAll
void DeleteAll()
Delete every character in the textbuffer.
Definition textbuf.cpp:112
Textbuf::GetText
std::string_view GetText() const
Get the current text.
Definition textbuf.cpp:284
Textbuf::InsertString
bool InsertString(std::string_view str, bool marked, std::optional< size_t > caret=std::nullopt, std::optional< size_t > insert_location=std::nullopt, std::optional< size_t > replacement_end=std::nullopt)
Insert a string into the text buffer.
Definition textbuf.cpp:157
TileHighlightData::GetCallbackWnd
Window * GetCallbackWnd()
Get the window that started the current highlighting.
Definition viewport.cpp:2665
TileHighlightData::window_class
WindowClass window_class
The WindowClass of the window that is responsible for the selection mode.
Definition tilehighlight_type.h:68
TileHighlightData::Reset
void Reset()
Reset tile highlighting.
Definition viewport.cpp:2644
TileHighlightData::selend
Point selend
The location where the drag currently ends.
Definition tilehighlight_type.h:61
TileHighlightData::window_number
WindowNumber window_number
The WindowNumber of the window that is responsible for the selection mode.
Definition tilehighlight_type.h:69
Vehicle
Vehicle data structure.
Definition vehicle_base.h:205
Vehicle::z_pos
int32_t z_pos
z coordinate.
Definition vehicle_base.h:267
Vehicle::y_pos
int32_t y_pos
y coordinate.
Definition vehicle_base.h:266
Vehicle::x_pos
int32_t x_pos
x coordinate.
Definition vehicle_base.h:265
Viewport
Data structure for viewport, display of a part of the world.
Definition viewport_type.h:31
Viewport::top
int top
Screen coordinate top edge of the viewport.
Definition viewport_type.h:33
Viewport::width
int width
Screen width of the viewport.
Definition viewport_type.h:34
Viewport::zoom
ZoomLevel zoom
The zoom level of the viewport.
Definition viewport_type.h:42
Viewport::left
int left
Screen coordinate left edge of the viewport.
Definition viewport_type.h:32
Viewport::height
int height
Screen height of the viewport.
Definition viewport_type.h:35
WindowDesc
High level window description.
Definition window_gui.h:168
WindowDesc::GetDefaultWidth
int16_t GetDefaultWidth() const
Determine default width of window.
Definition window.cpp:137
WindowDesc::SaveToConfig
static void SaveToConfig()
Save all WindowDesc settings to _windows_file.
Definition window.cpp:176
WindowDesc::pref_width
int16_t pref_width
User-preferred width of the window. Zero if unset.
Definition window_gui.h:187
WindowDesc::default_pos
const WindowPosition default_pos
Preferred position of the window.
Definition window_gui.h:178
WindowDesc::pref_sticky
bool pref_sticky
Preferred stickyness.
Definition window_gui.h:186
WindowDesc::pref_height
int16_t pref_height
User-preferred height of the window. Zero if unset.
Definition window_gui.h:188
WindowDesc::GetDefaultHeight
int16_t GetDefaultHeight() const
Determine default height of window.
Definition window.cpp:147
WindowDesc::default_height_trad
const int16_t default_height_trad
Preferred initial height of the window (pixels at 1x zoom).
Definition window_gui.h:198
WindowDesc::default_width_trad
const int16_t default_width_trad
Preferred initial width of the window (pixels at 1x zoom).
Definition window_gui.h:197
WindowDesc::cls
const WindowClass cls
Class of the window,.
Definition window_gui.h:179
WindowDesc::ini_key
const std::string_view ini_key
Key to store window defaults in openttd.cfg. An empty string if nothing shall be stored.
Definition window_gui.h:181
WindowDesc::flags
const WindowDefaultFlags flags
Flags.
Definition window_gui.h:182
WindowDesc::LoadFromConfig
static void LoadFromConfig()
Load all WindowDesc settings from _windows_file.
Definition window.cpp:155
WindowDesc::parent_cls
const WindowClass parent_cls
Class of the parent window.
Definition window_gui.h:180
WindowDesc::hotkeys
const HotkeyList * hotkeys
Hotkeys for the window.
Definition window_gui.h:184
WindowDesc::WindowDesc
WindowDesc(WindowPosition default_pos, std::string_view ini_key, int16_t def_width_trad, int16_t def_height_trad, WindowClass window_class, WindowClass parent_class, WindowDefaultFlags flags, const std::span< const NWidgetPart > nwid_parts, HotkeyList *hotkeys=nullptr, const std::source_location location=std::source_location::current())
Window description constructor.
Definition window.cpp:108
WindowDesc::nwid_parts
const std::span< const NWidgetPart > nwid_parts
Span of nested widget parts describing the window.
Definition window_gui.h:183
WindowNumber
Number to differentiate different windows of the same class.
Definition window_type.h:760
Window::WindowIterator
Iterator to iterate all valid Windows.
Definition window_gui.h:875
Window
Data structure for an opened window.
Definition window_gui.h:274
Window::GetFocusedTextbuf
virtual const struct Textbuf * GetFocusedTextbuf() const
Get the current input text buffer.
Definition window.cpp:364
Window::SetWidgetHighlight
void SetWidgetHighlight(WidgetID widget_index, TextColour highlighted_colour)
Sets the highlighted status of a widget.
Definition window.cpp:241
Window::ReInit
void ReInit(int rx=0, int ry=0, bool reposition=false)
Re-initialize a window, and optionally change its size.
Definition window.cpp:978
Window::Close
virtual void Close(int data=0)
Hide the window and all its child windows, and mark them for a later deletion.
Definition window.cpp:1102
Window::OnInvalidateData
virtual void OnInvalidateData(int data=0, bool gui_scope=true)
Some data on this window has become invalid.
Definition window_gui.h:793
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition window.cpp:1807
Window::querystrings
std::map< WidgetID, QueryString * > querystrings
QueryString associated to WWT_EDITBOX widgets.
Definition window_gui.h:321
Window::ApplyDefaults
virtual void ApplyDefaults()
Read default values from WindowDesc configuration an apply them to the window.
Definition window.cpp:193
Window::white_border_timer
uint8_t white_border_timer
Timer value of the WindowFlag::WhiteBorder for flags.
Definition window_gui.h:308
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:324
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:1455
Window::unshaded_size
Dimension unshaded_size
Last known unshaded size (only valid while shaded).
Definition window_gui.h:325
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:3234
Window::OnKeyPress
virtual EventState OnKeyPress(char32_t key, uint16_t keycode)
A key has been pressed.
Definition window_gui.h:651
Window::parent
Window * parent
Parent window.
Definition window_gui.h:329
Window::IterateFromBack
AllWindows< false > IterateFromBack
Iterate all windows in Z order from back to front.
Definition window_gui.h:934
Window::~Window
virtual ~Window()
Remove window and all its child windows from the window stack.
Definition window.cpp:1139
Window::RaiseWidget
void RaiseWidget(WidgetID widget_index)
Marks a widget as raised.
Definition window_gui.h:470
Window::SetWidgetDirty
void SetWidgetDirty(WidgetID widget_index) const
Invalidate a widget, i.e.
Definition window.cpp:556
Window::timeout_timer
uint8_t timeout_timer
Timer value of the WindowFlag::Timeout for flags.
Definition window_gui.h:307
Window::viewport
std::unique_ptr< ViewportData > viewport
Pointer to viewport data, if present.
Definition window_gui.h:319
Window::GetWidgetString
virtual std::string GetWidgetString(WidgetID widget, StringID stringid) const
Get the raw string for a widget.
Definition window.cpp:504
Window::mouse_capture_widget
WidgetID mouse_capture_widget
ID of current mouse capture widget (e.g. dragged scrollbar). INVALID_WIDGET if no widget has mouse ca...
Definition window_gui.h:327
Window::OnGameTick
virtual void OnGameTick()
Called once per (game) tick.
Definition window_gui.h:746
Window::ShowNewGRFInspectWindow
virtual void ShowNewGRFInspectWindow() const
Show the NewGRF inspection window.
Definition window_gui.h:868
Window::OnRightClick
virtual bool OnRightClick(Point pt, WidgetID widget)
A click with the right mouse button has been made on the window.
Definition window_gui.h:678
Window::OnScrollbarScroll
virtual void OnScrollbarScroll(WidgetID widget)
Notify window that a scrollbar position has been updated.
Definition window_gui.h:720
Window::OnDropdownSelect
virtual void OnDropdownSelect(WidgetID widget, int index, int click_result)
A dropdown option associated to this window has been selected.
Definition window_gui.h:770
Window::ProcessScheduledInvalidations
void ProcessScheduledInvalidations()
Process all scheduled invalidations.
Definition window.cpp:3247
Window::CloseChildWindows
void CloseChildWindows(WindowClass wc=WC_INVALID) const
Close all children a window might have in a head-recursive manner.
Definition window.cpp:1075
Window::resize
ResizeInfo resize
Resize information.
Definition window_gui.h:315
Window::UnfocusFocusedWidget
void UnfocusFocusedWidget()
Makes no widget on this window have focus.
Definition window.cpp:469
Window::OnMouseLoop
virtual void OnMouseLoop()
Called for every mouse loop run, which is at least once per (game) tick.
Definition window_gui.h:741
Window::SetShaded
void SetShaded(bool make_shaded)
Set the shaded state of the window to make_shaded.
Definition window.cpp:1021
Window::scale
int scale
Scale of this window – used to determine how to resize.
Definition window_gui.h:305
Window::ScheduleResize
void ScheduleResize()
Mark this window as resized and in need of OnResize() event.
Definition window.cpp:3212
Window::OnPaint
virtual void OnPaint()
The window must be repainted.
Definition window_gui.h:596
Window::OnDragDrop
virtual void OnDragDrop(Point pt, WidgetID widget)
A dragged 'object' has been released.
Definition window_gui.h:707
Window::CreateNestedTree
void CreateNestedTree()
Perform the first part of the initialization of a nested widget tree.
Definition window.cpp:1797
Window::window_desc
WindowDesc & window_desc
Window description.
Definition window_gui.h:300
Window::window_class
WindowClass window_class
Window class.
Definition window_gui.h:302
Window::OnRealtimeTick
virtual void OnRealtimeTick(uint delta_ms)
Called periodically.
Definition window_gui.h:751
Window::OnMouseWheel
virtual void OnMouseWheel(int wheel, WidgetID widget)
The mouse wheel has been turned.
Definition window_gui.h:735
Window::IterateFromFront
AllWindows< true > IterateFromFront
Iterate all windows in Z order from front to back.
Definition window_gui.h:935
Window::CloseChildWindowById
void CloseChildWindowById(WindowClass wc, WindowNumber number) const
Close all children a window might have in a head-recursive manner.
Definition window.cpp:1090
Window::SetWhiteBorder
void SetWhiteBorder()
Set the timeout flag of the window and initiate the timer.
Definition window_gui.h:365
Window::SetFocusedWidget
bool SetFocusedWidget(WidgetID widget_index)
Set focus within this window to the given widget.
Definition window.cpp:485
Window::OnFocusLost
virtual void OnFocusLost(bool closing)
The window has lost focus.
Definition window.cpp:521
Window::IsWidgetLowered
bool IsWidgetLowered(WidgetID widget_index) const
Gets the lowered state of a widget.
Definition window_gui.h:492
Window::closed_windows
static std::vector< Window * > closed_windows
List of closed windows to delete.
Definition window_gui.h:276
Window::RaiseButtons
void RaiseButtons(bool autoraise=false)
Raise the buttons of the window.
Definition window.cpp:530
Window::OnInitialPosition
virtual Point OnInitialPosition(int16_t sm_width, int16_t sm_height, int window_number)
Compute the initial position of the window.
Definition window.cpp:1785
Window::owner
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition window_gui.h:317
Window::GetCaretPosition
virtual Point GetCaretPosition() const
Get the current caret position if an edit box has the focus.
Definition window.cpp:377
Window::FindWindowPlacementAndResize
virtual void FindWindowPlacementAndResize(int def_width, int def_height, bool allow_resize)
Resize window towards the default size.
Definition window.cpp:1474
Window::OnDropdownClose
virtual void OnDropdownClose(Point pt, WidgetID widget, int index, int click_result, bool instant_close)
A dropdown window associated to this window has been closed.
Definition window.cpp:286
Window::InsertTextString
virtual void InsertTextString(WidgetID wid, std::string_view str, bool marked, std::optional< size_t > caret, std::optional< size_t > insert_location, std::optional< size_t > replacement_end)
Insert a text string at the cursor position into the edit box widget.
Definition window.cpp:2719
Window::left
int left
x position of left edge of the window
Definition window_gui.h:310
Window::IsShaded
bool IsShaded() const
Is window shaded currently?
Definition window_gui.h:560
Window::FindChildWindow
Window * FindChildWindow(WindowClass wc=WC_INVALID) const
Find the Window whose parent pointer points to this window.
Definition window.cpp:1047
Window::SetTimeout
void SetTimeout()
Set the timeout flag of the window and initiate the timer.
Definition window_gui.h:356
Window::nested_focus
const NWidgetCore * nested_focus
Currently focused nested widget, or nullptr if no nested widget has focus.
Definition window_gui.h:320
Window::OnEditboxChanged
virtual void OnEditboxChanged(WidgetID widget)
The text in an editbox has been edited.
Definition window_gui.h:778
Window::UpdateQueryStringSize
void UpdateQueryStringSize()
Update size of all QueryStrings of this window.
Definition window.cpp:353
Window::OnScroll
virtual void OnScroll(Point delta)
Handle the request for (viewport) scrolling.
Definition window_gui.h:713
Window::top
int top
y position of top edge of the window
Definition window_gui.h:311
Window::OnClick
virtual void OnClick(Point pt, WidgetID widget, int click_count)
A click with the left mouse button has been made on the window.
Definition window_gui.h:669
Window::GetQueryString
const QueryString * GetQueryString(WidgetID widnum) const
Return the querystring associated to a editbox.
Definition window.cpp:333
Window::widget_lookup
WidgetLookup widget_lookup
Indexed access to the nested widget tree. Do not access directly, use Window::GetWidget() instead.
Definition window_gui.h:323
Window::GetTextCharacterAtPosition
virtual ptrdiff_t GetTextCharacterAtPosition(const Point &pt) const
Get the character that is rendered at a position by the focused edit box.
Definition window.cpp:408
Window::scheduled_invalidation_data
std::vector< int > scheduled_invalidation_data
Data of scheduled OnInvalidateData() calls.
Definition window_gui.h:283
Window::InitializeData
void InitializeData(WindowNumber window_number)
Initializes the data (except the position and initial size) of a new Window.
Definition window.cpp:1417
Window::OnMouseOver
virtual void OnMouseOver(Point pt, WidgetID widget)
The mouse is currently moving over the window or has just moved outside of the window.
Definition window_gui.h:728
Window::Window
Window(WindowDesc &desc)
Empty constructor, initialization has been moved to InitNested() called from the constructor of the d...
Definition window.cpp:1830
Window::GetRowFromWidget
int GetRowFromWidget(int clickpos, WidgetID widget, int padding, int line_height=-1) const
Compute the row of a widget that a user clicked in.
Definition window.cpp:212
Window::GetWidget
const NWID * GetWidget(WidgetID widnum) const
Get the nested widget with number widnum from the nested widget tree.
Definition window_gui.h:983
Window::OnTooltip
virtual bool OnTooltip(Point pt, WidgetID widget, TooltipCloseCondition close_cond)
Event to display a custom tooltip.
Definition window_gui.h:693
Window::LowerWidget
void LowerWidget(WidgetID widget_index)
Marks a widget as lowered.
Definition window_gui.h:461
Window::OnCTRLStateChange
virtual EventState OnCTRLStateChange()
The state of the control key has changed.
Definition window_gui.h:660
Window::ProcessScheduledResize
void ProcessScheduledResize()
Process scheduled OnResize() event.
Definition window.cpp:3220
Window::HandleEditBoxKey
EventState HandleEditBoxKey(WidgetID wid, char32_t key, uint16_t keycode)
Process keypress for editbox widget.
Definition window.cpp:2561
Window::OnMouseDrag
virtual void OnMouseDrag(Point pt, WidgetID widget)
An 'object' is being dragged at the provided position, highlight the target if possible.
Definition window_gui.h:700
Window::HandleButtonClick
void HandleButtonClick(WidgetID widget)
Do all things to make a button look clicked and mark it to be unclicked in a few ticks.
Definition window.cpp:595
Window::OnResize
virtual void OnResize()
Called after the window got resized.
Definition window_gui.h:763
Window::FindChildWindowById
Window * FindChildWindowById(WindowClass wc, WindowNumber number) const
Find the Window whose parent pointer points to this window.
Definition window.cpp:1062
Window::OnFocus
virtual void OnFocus()
The window has gained focus.
Definition window.cpp:513
Window::InitNested
void InitNested(WindowNumber number=0)
Perform complete initialization of the Window with nested widgets, to allow use.
Definition window.cpp:1820
Window::OnTimeout
virtual void OnTimeout()
Called when this window's timeout has been reached.
Definition window_gui.h:756
Window::flags
WindowFlags flags
Window flags.
Definition window_gui.h:301
Window::GetScrollbar
const Scrollbar * GetScrollbar(WidgetID widnum) const
Return the Scrollbar to a widget index.
Definition window.cpp:313
Window::ProcessHighlightedInvalidations
void ProcessHighlightedInvalidations()
Process all invalidation of highlighted widgets.
Definition window.cpp:3259
Window::OnHotkey
virtual EventState OnHotkey(int hotkey)
A hotkey has been pressed.
Definition window.cpp:570
Window::DeleteClosedWindows
static void DeleteClosedWindows()
Delete all closed windows.
Definition window.cpp:68
Window::nested_root
std::unique_ptr< NWidgetBase > nested_root
Root of the nested tree.
Definition window_gui.h:322
Window::scheduled_resize
bool scheduled_resize
Set if window has been resized.
Definition window_gui.h:284
Window::GetTextBoundingRect
virtual Rect GetTextBoundingRect(size_t from, size_t to) const
Get the bounding rectangle for a text range if an edit box has the focus.
Definition window.cpp:393
Window::IsWidgetHighlighted
bool IsWidgetHighlighted(WidgetID widget_index) const
Gets the highlighted status of a widget.
Definition window.cpp:271
Window::DisableAllWidgetHighlight
void DisableAllWidgetHighlight()
Disable the highlighted status of all widgets.
Definition window.cpp:223
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:852
Window::Iterate
AllWindows< false > Iterate
Iterate all windows in whatever order is easiest.
Definition window_gui.h:933
Window::height
int height
Height of the window (number of pixels down in y direction)
Definition window_gui.h:313
Window::OnHover
virtual void OnHover(Point pt, WidgetID widget)
The mouse is hovering over a widget in the window, perform an action for it.
Definition window_gui.h:685
Window::width
int width
width of the window (number of pixels to the right in x direction)
Definition window_gui.h:312
Window::OnInit
virtual void OnInit()
Notification that the nested widget tree gets initialized.
Definition window_gui.h:579
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition window_gui.h:303
_window_descs
std::vector< WindowDesc * > * _window_descs
List of WindowDescs.
Definition window.cpp:102
HKPR_NOT_HANDLED
@ HKPR_NOT_HANDLED
Key does not affect editboxes.
Definition textbuf_type.h:26
HKPR_CANCEL
@ HKPR_CANCEL
Escape key pressed.
Definition textbuf_type.h:25
HKPR_EDITING
@ HKPR_EDITING
Textbuf content changed.
Definition textbuf_type.h:22
HKPR_CONFIRM
@ HKPR_CONFIRM
Return or enter key pressed.
Definition textbuf_type.h:24
HKPR_CURSOR
@ HKPR_CURSOR
Non-text change, e.g. cursor position.
Definition textbuf_type.h:23
tilehighlight_func.h
Functions related to tile highlights.
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition viewport.cpp:3573
UpdateTileSelection
void UpdateTileSelection()
Updates tile highlighting for all cases.
Definition viewport.cpp:2679
timer.h
Definition of Interval and OneShot timers.
timer_window.h
Definition of the Window system.
TIMER_BLINK_INTERVAL
static constexpr std::chrono::milliseconds TIMER_BLINK_INTERVAL
Interval used by blinking interface elements.
Definition timer_window.h:36
_toolbar_width
uint _toolbar_width
Width of the toolbar, shared by statusbar.
Definition toolbar_gui.cpp:78
toolbar_gui.h
Stuff related to the (main) toolbar.
vehicle_base.h
Base class for all vehicles.
video_driver.hpp
Base of all video drivers.
IsPtInWindowViewport
Viewport * IsPtInWindowViewport(const Window *w, int x, int y)
Is a xy position inside the viewport of the window?
Definition viewport.cpp:408
UpdateViewportPosition
void UpdateViewportPosition(Window *w, uint32_t delta_ms)
Update the viewport position being displayed.
Definition viewport.cpp:1988
viewport_func.h
Functions related to (drawing on) viewports.
SetupWidgetDimensions
void SetupWidgetDimensions()
Set up pre-scaled versions of Widget Dimensions.
Definition widget.cpp:80
GetWidgetFromPos
WidgetID 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:274
ScrollbarClickHandler
void ScrollbarClickHandler(Window *w, NWidgetCore *nw, int x, int y)
Special handling for the scrollbar widget type.
Definition widget.cpp:250
ScaleGUITrad
static RectPadding ScaleGUITrad(const RectPadding &r)
Scale a RectPadding to GUI zoom level.
Definition widget.cpp:49
WidgetType
WidgetType
Window widget types, nested widget types, and nested widget part types.
Definition widget_type.h:35
NWID_BUTTON_DROPDOWN
@ NWID_BUTTON_DROPDOWN
Button with a drop-down.
Definition widget_type.h:74
WWT_EDITBOX
@ WWT_EDITBOX
a textbox for typing
Definition widget_type.h:62
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition widget_type.h:57
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition widget_type.h:55
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition widget_type.h:52
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition widget_type.h:76
WWT_CLOSEBOX
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition widget_type.h:60
WWT_EMPTY
@ WWT_EMPTY
Empty widget, place holder to reserve space in widget tree.
Definition widget_type.h:37
WWT_LAST
@ WWT_LAST
Last Item. use WIDGETS_END to fill up padding!!
Definition widget_type.h:63
NWID_HSCROLLBAR
@ NWID_HSCROLLBAR
Horizontal scrollbar.
Definition widget_type.h:75
WWT_RESIZEBOX
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition widget_type.h:59
WWT_DEFSIZEBOX
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX)
Definition widget_type.h:56
WWT_DEBUGBOX
@ WWT_DEBUGBOX
NewGRF debug box (at top-right of a window, between WWT_CAPTION and WWT_SHADEBOX)
Definition widget_type.h:54
DropdownClosed
@ DropdownClosed
Dropdown menu of the dropdown widget has closed.
Definition widget_type.h:350
ScrollbarDown
@ ScrollbarDown
Down-button is lowered bit.
Definition widget_type.h:346
ScrollbarUp
@ ScrollbarUp
Up-button is lowered bit.
Definition widget_type.h:345
DropdownActive
@ DropdownActive
Dropdown menu of the button dropdown widget is active.
Definition widget_type.h:342
SZSP_HORIZONTAL
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
Definition widget_type.h:505
ST_RESIZE
@ ST_RESIZE
Resize the nested widget tree.
Definition widget_type.h:114
ST_SMALLEST
@ ST_SMALLEST
Initialize nested widget tree to smallest size. Also updates current_x and current_y.
Definition widget_type.h:113
PositionStatusbar
int PositionStatusbar(Window *w)
(Re)position statusbar window at the screen.
Definition window.cpp:3476
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:2019
_dragging_window
static bool _dragging_window
A window is being dragged or resized.
Definition window.cpp:2153
white_border_interval
static const IntervalTimer< TimerWindow > white_border_interval(std::chrono::milliseconds(30), [](auto) { if(_network_dedicated) return;for(Window *w :Window::Iterate()) { if(w->flags.Test(WindowFlag::WhiteBorder) &&--w->white_border_timer==0) { w->flags.Reset(WindowFlag::WhiteBorder);w->SetDirty();} } })
Blink all windows marked with a white border.
CloseConstructionWindows
void CloseConstructionWindows()
Close all windows that are used for construction of vehicle etc.
Definition window.cpp:3380
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
Definition window.cpp:1193
LocalGetWindowPlacement
static Point LocalGetWindowPlacement(const WindowDesc &desc, int16_t sm_width, int16_t sm_height, int window_number)
Compute the position of the top-left corner of a new window that is opened.
Definition window.cpp:1726
GetMainWindow
Window * GetMainWindow()
Get the main window, i.e.
Definition window.cpp:1180
_drag_delta
static Point _drag_delta
delta between mouse cursor and upper left corner of dragged window
Definition window.cpp:55
MayBeShown
static bool MayBeShown(const Window *w)
Returns whether a window may be shown or not.
Definition window.cpp:855
CloseCompanyWindows
void CloseCompanyWindows(CompanyID id)
Close all windows of a company.
Definition window.cpp:1221
HandleCtrlChanged
void HandleCtrlChanged()
State of CONTROL key has changed.
Definition window.cpp:2706
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:883
_scrolling_viewport
bool _scrolling_viewport
A viewport is being scrolled with the mouse.
Definition window.cpp:93
InputLoop
void InputLoop()
Regular call from the global game loop.
Definition window.cpp:3059
UpdateWindows
void UpdateWindows()
Update the continuously changing contents of the windows, such as the viewports.
Definition window.cpp:3124
PositionMainToolbar
int PositionMainToolbar(Window *w)
(Re)position main toolbar window at the screen.
Definition window.cpp:3465
CloseNonVitalWindows
void CloseNonVitalWindows()
Try to close a non-vital window.
Definition window.cpp:3336
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:945
ResizeWindow
void ResizeWindow(Window *w, int delta_x, int delta_y, bool clamp_to_screen, bool schedule_resize)
Resize the window.
Definition window.cpp:2096
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:1576
PositionNetworkChatWindow
int PositionNetworkChatWindow(Window *w)
(Re)position network chat window at the screen.
Definition window.cpp:3498
StartWindowSizing
static void StartWindowSizing(Window *w, bool to_left)
Start resizing a window.
Definition window.cpp:2348
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:1615
PreventHideDirection
PreventHideDirection
Direction for moving the window.
Definition window.cpp:2004
PHD_DOWN
@ PHD_DOWN
Below v is a safe position.
Definition window.cpp:2006
PHD_UP
@ PHD_UP
Above v is a safe position.
Definition window.cpp:2005
HandleAutoscroll
static void HandleAutoscroll()
If needed and switched on, perform auto scrolling (automatically moving window contents when mouse is...
Definition window.cpp:2747
_window_highlight_colour
bool _window_highlight_colour
If false, highlight is white, otherwise the by the widget defined colour.
Definition window.cpp:78
HandleToolbarHotkey
void HandleToolbarHotkey(int hotkey)
Handle Toolbar hotkey events - can come from a source like the MacBook Touch Bar.
Definition window.cpp:2633
PositionWindow
static int PositionWindow(Window *w, WindowClass clss, int setting)
(Re)position a window at the screen.
Definition window.cpp:3442
SetFocusedWindow
void SetFocusedWindow(Window *w)
Set the window that has the focus.
Definition window.cpp:421
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:1540
MAX_OFFSET_DOUBLE_CLICK
static constexpr int MAX_OFFSET_DOUBLE_CLICK
How much the mouse is allowed to move to call it a double click.
Definition window.cpp:2792
FindWindowByClass
Window * FindWindowByClass(WindowClass cls)
Find any window by its class.
Definition window.cpp:1166
ChangeVehicleViewports
void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index)
Switches viewports following vehicles, which get autoreplaced.
Definition window.cpp:3510
TIME_BETWEEN_DOUBLE_CLICK
const std::chrono::milliseconds TIME_BETWEEN_DOUBLE_CLICK(500)
Time between 2 left clicks before it becoming a double click.
HandleViewportScroll
static EventState HandleViewportScroll()
Handle viewport scrolling with the mouse.
Definition window.cpp:2437
DispatchMouseWheelEvent
static void DispatchMouseWheelEvent(Window *w, NWidgetCore *nwid, int wheel)
Dispatch the mousewheel-action to the window.
Definition window.cpp:818
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:616
FindWindowFromPt
Window * FindWindowFromPt(int x, int y)
Do a search for a window at specific coordinates.
Definition window.cpp:1842
DeleteAllMessages
void DeleteAllMessages()
Delete all messages and close their corresponding window (if any).
Definition window.cpp:3368
_last_scroll_window
static Window * _last_scroll_window
Window of the last scroll event.
Definition window.cpp:57
GetMainViewTop
int GetMainViewTop()
Return the top of the main view available for general use.
Definition window.cpp:2136
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:1397
ReInitAllWindows
void ReInitAllWindows(bool zoom_changed)
Re-initialize all windows.
Definition window.cpp:3410
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:2059
CloseWindowByClass
void CloseWindowByClass(WindowClass cls, int data)
Close all windows of a given class.
Definition window.cpp:1205
HandleMouseEvents
void HandleMouseEvents()
Handle a mouse event from the video driver.
Definition window.cpp:2963
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:1683
HandleWindowDragging
static EventState HandleWindowDragging()
Handle dragging/resizing of a window.
Definition window.cpp:2159
PositionNewsMessage
int PositionNewsMessage(Window *w)
(Re)position news message window at the screen.
Definition window.cpp:3487
GetMainViewBottom
int GetMainViewBottom()
Return the bottom of the main view available for general use.
Definition window.cpp:2147
DispatchHoverEvent
static void DispatchHoverEvent(Window *w, int x, int y)
Dispatch hover of the mouse over a window.
Definition window.cpp:790
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:1241
HandleKeypress
void HandleKeypress(uint keycode, char32_t key)
Handle keyboard input.
Definition window.cpp:2650
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition window.cpp:3202
VpHandlePlaceSizingDrag
EventState VpHandlePlaceSizingDrag()
Handle the mouse while dragging for placement/resizing.
Definition viewport.cpp:3456
MAX_OFFSET_HOVER
static constexpr int MAX_OFFSET_HOVER
Maximum mouse movement before stopping a hover event.
Definition window.cpp:2793
FocusedWindowIsConsole
bool FocusedWindowIsConsole()
Check if a console is focused.
Definition window.cpp:461
ResetWindowSystem
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition window.cpp:1892
GetWindowZPriority
static uint GetWindowZPriority(WindowClass wc)
Get the z-priority for a given window.
Definition window.cpp:1313
EditBoxInGlobalFocus
bool EditBoxInGlobalFocus()
Check if an edit box is in global focus.
Definition window.cpp:447
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:3294
HideVitalWindows
void HideVitalWindows()
Close all always on-top windows to get an empty screen.
Definition window.cpp:3393
highlight_interval
static const IntervalTimer< TimerWindow > highlight_interval(TIMER_BLINK_INTERVAL, [](auto) { _window_highlight_colour=!_window_highlight_colour;})
Blink the window highlight colour constantly.
DescSorter
static bool DescSorter(WindowDesc *const &a, WindowDesc *const &b)
Sort WindowDesc by ini_key.
Definition window.cpp:168
BringWindowToFrontById
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition window.cpp:1276
AlignInitialConstructionToolbar
Point AlignInitialConstructionToolbar(int window_width)
Compute the position of the construction toolbars.
Definition window.cpp:1699
RelocateAllWindows
void RelocateAllWindows(int neww, int newh)
Relocate all windows to fit the new size of the game application screen.
Definition window.cpp:3526
_windows_file
std::string _windows_file
Config file to store WindowDesc.
Definition window.cpp:105
HandleScrollbarScrolling
static void HandleScrollbarScrolling(Window *w)
Handle scrollbar scrolling with the mouse.
Definition window.cpp:2364
_mouse_hovering
bool _mouse_hovering
The mouse is hovering over the same point.
Definition window.cpp:94
StartWindowDrag
static void StartWindowDrag(Window *w)
Start window dragging.
Definition window.cpp:2331
CallWindowGameTickEvent
void CallWindowGameTickEvent()
Dispatch OnGameTick event over all windows.
Definition window.cpp:3323
HandleActiveWidget
static EventState HandleActiveWidget()
Handle active widget (mouse dragging on widget) with the mouse.
Definition window.cpp:2404
_window_descs
std::vector< WindowDesc * > * _window_descs
List of all WindowDescs.
Definition window.cpp:102
DispatchRightClickEvent
static void DispatchRightClickEvent(Window *w, int x, int y)
Dispatch right mouse-button click in window.
Definition window.cpp:761
ViewportAutoscrolling
ViewportAutoscrolling
Values for _settings_client.gui.auto_scrolling.
Definition window.cpp:48
VA_MAIN_VIEWPORT_FULLSCREEN
@ VA_MAIN_VIEWPORT_FULLSCREEN
Scroll main viewport at edge when using fullscreen.
Definition window.cpp:50
VA_MAIN_VIEWPORT
@ VA_MAIN_VIEWPORT
Scroll main viewport at edge.
Definition window.cpp:51
VA_EVERY_VIEWPORT
@ VA_EVERY_VIEWPORT
Scroll all viewports at their edges.
Definition window.cpp:52
VA_DISABLED
@ VA_DISABLED
Do not autoscroll when mouse is at edge of viewport.
Definition window.cpp:49
scrollamt
static const int8_t scrollamt[16][2]
Describes all the different arrow key combinations the game allows when it is in scrolling mode.
Definition window.cpp:2817
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:2501
_z_windows
WindowList _z_windows
List of windows opened at the screen sorted from the front to back.
Definition window.cpp:60
CallWindowRealtimeTickEvent
void CallWindowRealtimeTickEvent(uint delta_ms)
Dispatch OnRealtimeTick event over all windows.
Definition window.cpp:3085
_special_mouse_mode
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition window.cpp:96
HandleMouseDragDrop
static EventState HandleMouseDragDrop()
Handle dragging and dropping in mouse dragging mode (WSM_DRAGDROP).
Definition window.cpp:1957
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:3355
HandleMouseOver
static void HandleMouseOver()
Report position of the mouse to the underlying window.
Definition window.cpp:1981
window_interval
static const IntervalTimer< TimerWindow > window_interval(std::chrono::milliseconds(30), [](auto) { extern int _caret_timer;_caret_timer+=3;CursorTick();HandleKeyScrolling();HandleAutoscroll();DecreaseWindowCounters();})
Update various of window-related information on a regular interval.
_mouseover_last_w
static Window * _mouseover_last_w
Window of the last OnMouseOver event.
Definition window.cpp:56
CheckSoftLimit
static void CheckSoftLimit()
Check the soft limit of deletable (non vital, non sticky) windows.
Definition window.cpp:3034
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition window.cpp:1151
UnInitWindowSystem
void UnInitWindowSystem()
Close down the windowing system.
Definition window.cpp:1878
InitWindowSystem
void InitWindowSystem()
(re)initialize the windowing system
Definition window.cpp:1856
SetWindowWidgetDirty
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, WidgetID widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting)
Definition window.cpp:3189
HandleTextInput
void HandleTextInput(std::string_view str, bool marked, std::optional< size_t > caret, std::optional< size_t > insert_location, std::optional< size_t > replacement_end)
Handle text input.
Definition window.cpp:2736
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition window.cpp:3176
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:3311
window_func.h
Window functions not directly related to making/drawing windows.
WindowDefaultFlag::Construction
@ Construction
This window is used for construction; close it whenever changing company.
WindowDefaultFlag::NoClose
@ NoClose
This window can't be interactively closed.
WindowDefaultFlag::NoFocus
@ NoFocus
This window won't get focus/make any other window lose focus when click.
WindowDefaultFlag::Modal
@ Modal
The window is a modal child of some other window, meaning the parent is 'inactive'.
SetFocusedWindow
void SetFocusedWindow(Window *w)
Set the window that has the focus.
Definition window.cpp:421
WindowFlag::SizingLeft
@ SizingLeft
Window is being resized towards the left.
WindowFlag::DisableVpScroll
@ DisableVpScroll
Window does not do autoscroll,.
WindowFlag::Highlighted
@ Highlighted
Window has a widget that has a highlight.
WindowFlag::Centred
@ Centred
Window is centered and shall stay centered after ReInit.
WindowFlag::Dragging
@ Dragging
Window is being dragged.
WindowFlag::SizingRight
@ SizingRight
Window is being resized towards the right.
WindowFlag::WhiteBorder
@ WhiteBorder
Window white border counter bit mask.
WindowFlag::Timeout
@ Timeout
Window timeout counter.
WindowFlag::Sticky
@ Sticky
Window is made sticky by user.
TIMEOUT_DURATION
static const int TIMEOUT_DURATION
The initial timeout value for WindowFlag::Timeout.
Definition window_gui.h:241
GetWidgetFromPos
WidgetID 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:274
SpecialMouseMode
SpecialMouseMode
Mouse modes.
Definition window_gui.h:1040
WSM_DRAGDROP
@ WSM_DRAGDROP
Drag&drop an object.
Definition window_gui.h:1042
WSM_PRESIZE
@ WSM_PRESIZE
Presizing mode (docks, tunnels).
Definition window_gui.h:1044
WindowPosition
WindowPosition
How do we the window to be placed?
Definition window_gui.h:142
WDP_CENTER
@ WDP_CENTER
Center the window.
Definition window_gui.h:145
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition window_gui.h:144
WDP_ALIGN_TOOLBAR
@ WDP_ALIGN_TOOLBAR
Align toward the toolbar.
Definition window_gui.h:146
WDP_MANUAL
@ WDP_MANUAL
Manually align the window (so no automatic location finding)
Definition window_gui.h:143
_z_windows
WindowList _z_windows
List of windows opened at the screen sorted from the front to back.
Definition window.cpp:60
WidgetID
int WidgetID
Widget ID.
Definition window_type.h:20
EventState
EventState
State of handling an event.
Definition window_type.h:780
ES_HANDLED
@ ES_HANDLED
The passed event is handled.
Definition window_type.h:781
ES_NOT_HANDLED
@ ES_NOT_HANDLED
The passed event is not handled.
Definition window_type.h:782
INVALID_WIDGET
static constexpr WidgetID INVALID_WIDGET
An invalid widget index.
Definition window_type.h:23
WindowClass
WindowClass
Window classes.
Definition window_type.h:49
WC_INVALID
@ WC_INVALID
Invalid window.
Definition window_type.h:735
WC_OSK
@ WC_OSK
On Screen Keyboard; Window numbers:
Definition window_type.h:167
WC_CONSOLE
@ WC_CONSOLE
Console; Window numbers:
Definition window_type.h:660
WC_NEWS_WINDOW
@ WC_NEWS_WINDOW
News window; Window numbers:
Definition window_type.h:253
WC_HIGHSCORE
@ WC_HIGHSCORE
Highscore; Window numbers:
Definition window_type.h:672
WC_BUY_COMPANY
@ WC_BUY_COMPANY
Buyout company (merger); Window numbers:
Definition window_type.h:605
WC_SPRITE_ALIGNER
@ WC_SPRITE_ALIGNER
Sprite aligner (debug); Window numbers:
Definition window_type.h:697
WC_COMPANY_INFRASTRUCTURE
@ WC_COMPANY_INFRASTRUCTURE
Company infrastructure overview; Window numbers:
Definition window_type.h:598
WC_ENDSCREEN
@ WC_ENDSCREEN
Endscreen; Window numbers:
Definition window_type.h:678
WC_COMPANY_COLOUR
@ WC_COMPANY_COLOUR
Company colour selection; Window numbers:
Definition window_type.h:235
WC_STATION_LIST
@ WC_STATION_LIST
Station list; Window numbers:
Definition window_type.h:307
WC_ROADVEH_LIST
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition window_type.h:319
WC_STATUS_BAR
@ WC_STATUS_BAR
Statusbar (at the bottom of your screen); Window numbers:
Definition window_type.h:69
WC_VEHICLE_ORDERS
@ WC_VEHICLE_ORDERS
Vehicle orders; Window numbers:
Definition window_type.h:217
WC_SEND_NETWORK_MSG
@ WC_SEND_NETWORK_MSG
Chatbox; Window numbers:
Definition window_type.h:514
WC_ERRMSG
@ WC_ERRMSG
Error message; Window numbers:
Definition window_type.h:115
WC_BUILD_TOOLBAR
@ WC_BUILD_TOOLBAR
Build toolbar; Window numbers:
Definition window_type.h:78
WC_NETWORK_ASK_RELAY
@ WC_NETWORK_ASK_RELAY
Network ask relay window; Window numbers:
Definition window_type.h:502
WC_SCRIPT_SETTINGS
@ WC_SCRIPT_SETTINGS
Script settings; Window numbers:
Definition window_type.h:180
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition window_type.h:50
WC_SCEN_LAND_GEN
@ WC_SCEN_LAND_GEN
Landscape generation (in Scenario Editor); Window numbers:
Definition window_type.h:460
WC_SCRIPT_LIST
@ WC_SCRIPT_LIST
Scripts list; Window numbers:
Definition window_type.h:289
WC_SAVE_PRESET
@ WC_SAVE_PRESET
Save preset; Window numbers:
Definition window_type.h:709
WC_SHIPS_LIST
@ WC_SHIPS_LIST
Ships list; Window numbers:
Definition window_type.h:325
WC_MESSAGE_HISTORY
@ WC_MESSAGE_HISTORY
News history list; Window numbers:
Definition window_type.h:277
WC_CONFIRM_POPUP_QUERY
@ WC_CONFIRM_POPUP_QUERY
Popup with confirm question; Window numbers:
Definition window_type.h:135
WC_GENERATE_LANDSCAPE
@ WC_GENERATE_LANDSCAPE
Generate landscape (newgame); Window numbers:
Definition window_type.h:467
WC_CUSTOM_CURRENCY
@ WC_CUSTOM_CURRENCY
Custom currency; Window numbers:
Definition window_type.h:641
WC_MAIN_WINDOW
@ WC_MAIN_WINDOW
Main window; Window numbers:
Definition window_type.h:56
WC_TRAINS_LIST
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition window_type.h:313
WC_GAME_OPTIONS
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition window_type.h:635
WC_NETWORK_WINDOW
@ WC_NETWORK_WINDOW
Network window; Window numbers:
Definition window_type.h:483
WC_FINANCES
@ WC_FINANCES
Finances of a company; Window numbers:
Definition window_type.h:532
WC_TEXTFILE
@ WC_TEXTFILE
textfile; Window numbers:
Definition window_type.h:192
WC_DROPDOWN_MENU
@ WC_DROPDOWN_MENU
Drop down menu; Window numbers:
Definition window_type.h:161
WC_QUERY_STRING
@ WC_QUERY_STRING
Query string window; Window numbers:
Definition window_type.h:128
WC_SMALLMAP
@ WC_SMALLMAP
Small map; Window numbers:
Definition window_type.h:109
WC_BOOTSTRAP
@ WC_BOOTSTRAP
Bootstrap; Window numbers:
Definition window_type.h:666
WC_SAVELOAD
@ WC_SAVELOAD
Saveload window; Window numbers:
Definition window_type.h:149
WC_GRF_PARAMETERS
@ WC_GRF_PARAMETERS
NewGRF parameters; Window numbers:
Definition window_type.h:186
WC_MODAL_PROGRESS
@ WC_MODAL_PROGRESS
Progress report of landscape generation; Window numbers:
Definition window_type.h:474
WC_MAIN_TOOLBAR
@ WC_MAIN_TOOLBAR
Main toolbar (the long bar at the top); Window numbers:
Definition window_type.h:63
WC_TOOLTIPS
@ WC_TOOLTIPS
Tooltip window; Window numbers:
Definition window_type.h:121
WC_COMPANY
@ WC_COMPANY
Company view; Window numbers:
Definition window_type.h:374
WC_NETWORK_STATUS_WINDOW
@ WC_NETWORK_STATUS_WINDOW
Network status window; Window numbers:
Definition window_type.h:496
WC_AIRCRAFT_LIST
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition window_type.h:331
zoom_func.h
Functions related to zooming.
ScaleByZoom
int ScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift left (when zoom > ZoomLevel::Min) When shifting right,...
Definition zoom_func.h:22
ZoomLevel::Min
@ Min
Minimum zoom level.