OpenTTD Source  20241108-master-g80f628063a
network_chat_gui.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
10 #include "../stdafx.h"
11 #include "../strings_func.h"
12 #include "../autocompletion.h"
13 #include "../blitter/factory.hpp"
14 #include "../console_func.h"
15 #include "../video/video_driver.hpp"
16 #include "../querystring_gui.h"
17 #include "../town.h"
18 #include "../window_func.h"
19 #include "../toolbar_gui.h"
20 #include "../core/geometry_func.hpp"
21 #include "../zoom_func.h"
22 #include "../timer/timer.h"
23 #include "../timer/timer_window.h"
24 #include "network.h"
25 #include "network_client.h"
26 #include "network_base.h"
27 
28 #include "../widgets/network_chat_widget.h"
29 
30 #include "table/strings.h"
31 
32 #include "../safeguards.h"
33 
35 static const uint NETWORK_CHAT_LINE_SPACING = 3;
36 
38 struct ChatMessage {
39  std::string message;
41  std::chrono::steady_clock::time_point remove_time;
42 };
43 
44 /* used for chat window */
45 static std::deque<ChatMessage> _chatmsg_list;
46 static bool _chatmessage_dirty = false;
47 static bool _chatmessage_visible = false;
48 static uint MAX_CHAT_MESSAGES = 0;
49 
54 static std::chrono::steady_clock::time_point _chatmessage_dirty_time;
55 
62 
68 static inline bool HaveChatMessages(bool show_all)
69 {
70  if (show_all) return !_chatmsg_list.empty();
71 
72  auto now = std::chrono::steady_clock::now();
73  for (auto &cmsg : _chatmsg_list) {
74  if (cmsg.remove_time >= now) return true;
75  }
76 
77  return false;
78 }
79 
86 void CDECL NetworkAddChatMessage(TextColour colour, uint duration, const std::string &message)
87 {
88  if (_chatmsg_list.size() == MAX_CHAT_MESSAGES) {
89  _chatmsg_list.pop_back();
90  }
91 
92  ChatMessage *cmsg = &_chatmsg_list.emplace_front();
93  cmsg->message = message;
94  cmsg->colour = colour;
95  cmsg->remove_time = std::chrono::steady_clock::now() + std::chrono::seconds(duration);
96 
97  _chatmessage_dirty_time = std::chrono::steady_clock::now();
98  _chatmessage_dirty = true;
99 }
100 
103 {
106 }
107 
110 {
112 
113  _chatmsg_list.clear();
114  _chatmsg_box.x = ScaleGUITrad(10);
115  _chatmsg_box.width = _settings_client.gui.network_chat_box_width_pct * _screen.width / 100;
117  _chatmessage_visible = false;
118 }
119 
122 {
123  /* Sometimes we also need to hide the cursor
124  * This is because both textmessage and the cursor take a shot of the
125  * screen before drawing.
126  * Now the textmessage takes its shot and paints its data before the cursor
127  * does, so in the shot of the cursor is the screen-data of the textmessage
128  * included when the cursor hangs somewhere over the textmessage. To
129  * avoid wrong repaints, we undraw the cursor in that case, and everything
130  * looks nicely ;)
131  * (and now hope this story above makes sense to you ;))
132  */
133  if (_cursor.visible &&
134  _cursor.draw_pos.x + _cursor.draw_size.x >= _chatmsg_box.x &&
135  _cursor.draw_pos.x <= _chatmsg_box.x + _chatmsg_box.width &&
136  _cursor.draw_pos.y + _cursor.draw_size.y >= _screen.height - _chatmsg_box.y - _chatmsg_box.height &&
137  _cursor.draw_pos.y <= _screen.height - _chatmsg_box.y) {
138  UndrawMouseCursor();
139  }
140 
141  if (_chatmessage_visible) {
143  int x = _chatmsg_box.x;
144  int y = _screen.height - _chatmsg_box.y - _chatmsg_box.height;
145  int width = _chatmsg_box.width;
146  int height = _chatmsg_box.height;
147  if (y < 0) {
148  height = std::max(height + y, std::min(_chatmsg_box.height, _screen.height));
149  y = 0;
150  }
151  if (x + width >= _screen.width) {
152  width = _screen.width - x;
153  }
154  if (width <= 0 || height <= 0) return;
155 
156  _chatmessage_visible = false;
157  /* Put our 'shot' back to the screen */
158  blitter->CopyFromBuffer(blitter->MoveTo(_screen.dst_ptr, x, y), _chatmessage_backup.GetBuffer(), width, height);
159  /* And make sure it is updated next time */
160  VideoDriver::GetInstance()->MakeDirty(x, y, width, height);
161 
162  _chatmessage_dirty_time = std::chrono::steady_clock::now();
163  _chatmessage_dirty = true;
164  }
165 }
166 
168 static IntervalTimer<TimerWindow> network_message_expired_interval(std::chrono::seconds(1), [](auto) {
169  auto now = std::chrono::steady_clock::now();
170  for (auto &cmsg : _chatmsg_list) {
171  /* Message has expired, remove from the list */
172  if (now > cmsg.remove_time && _chatmessage_dirty_time < cmsg.remove_time) {
174  _chatmessage_dirty = true;
175  break;
176  }
177  }
178 });
179 
182 {
184  if (!_chatmessage_dirty) return;
185 
187  bool show_all = (w != nullptr);
188 
189  /* First undraw if needed */
191 
192  if (_iconsole_mode == ICONSOLE_FULL) return;
193 
194  /* Check if we have anything to draw at all */
195  if (!HaveChatMessages(show_all)) return;
196 
197  int x = _chatmsg_box.x;
198  int y = _screen.height - _chatmsg_box.y - _chatmsg_box.height;
199  int width = _chatmsg_box.width;
200  int height = _chatmsg_box.height;
201  if (y < 0) {
202  height = std::max(height + y, std::min(_chatmsg_box.height, _screen.height));
203  y = 0;
204  }
205  if (x + width >= _screen.width) {
206  width = _screen.width - x;
207  }
208  if (width <= 0 || height <= 0) return;
209 
210  /* Make a copy of the screen as it is before painting (for undraw) */
211  uint8_t *buffer = _chatmessage_backup.Allocate(BlitterFactory::GetCurrentBlitter()->BufferSize(width, height));
212  blitter->CopyToBuffer(blitter->MoveTo(_screen.dst_ptr, x, y), buffer, width, height);
213 
214  _cur_dpi = &_screen; // switch to _screen painting
215 
216  auto now = std::chrono::steady_clock::now();
217  int string_height = 0;
218  for (auto &cmsg : _chatmsg_list) {
219  if (!show_all && cmsg.remove_time < now) continue;
220  SetDParamStr(0, cmsg.message);
221  string_height += GetStringLineCount(STR_JUST_RAW_STRING, width - 1) * GetCharacterHeight(FS_NORMAL) + NETWORK_CHAT_LINE_SPACING;
222  }
223 
224  string_height = std::min<uint>(string_height, MAX_CHAT_MESSAGES * (GetCharacterHeight(FS_NORMAL) + NETWORK_CHAT_LINE_SPACING));
225 
226  int top = _screen.height - _chatmsg_box.y - string_height - 2;
227  int bottom = _screen.height - _chatmsg_box.y - 2;
228  /* Paint a half-transparent box behind the chat messages */
229  GfxFillRect(_chatmsg_box.x, top - 2, _chatmsg_box.x + _chatmsg_box.width - 1, bottom,
230  PALETTE_TO_TRANSPARENT, FILLRECT_RECOLOUR // black, but with some alpha for background
231  );
232 
233  /* Paint the chat messages starting with the lowest at the bottom */
234  int ypos = bottom - 2;
235 
236  for (auto &cmsg : _chatmsg_list) {
237  if (!show_all && cmsg.remove_time < now) continue;
238  ypos = DrawStringMultiLine(_chatmsg_box.x + ScaleGUITrad(3), _chatmsg_box.x + _chatmsg_box.width - 1, top, ypos, cmsg.message, cmsg.colour, SA_LEFT | SA_BOTTOM | SA_FORCE) - NETWORK_CHAT_LINE_SPACING;
239  if (ypos < top) break;
240  }
241 
242  /* Make sure the data is updated next flush */
243  VideoDriver::GetInstance()->MakeDirty(x, y, width, height);
244 
245  _chatmessage_visible = true;
246  _chatmessage_dirty = false;
247 }
248 
255 static void SendChat(const std::string &buf, DestType type, int dest)
256 {
257  if (buf.empty()) return;
258  if (!_network_server) {
259  MyClient::SendChat((NetworkAction)(NETWORK_ACTION_CHAT + type), type, dest, buf, 0);
260  } else {
261  NetworkServerSendChat((NetworkAction)(NETWORK_ACTION_CHAT + type), type, dest, buf, CLIENT_ID_SERVER);
262  }
263 }
264 
266 public:
267  using AutoCompletion::AutoCompletion;
268 
269 private:
270  std::vector<std::string> GetSuggestions([[maybe_unused]] std::string_view prefix, std::string_view query) override
271  {
272  std::vector<std::string> suggestions;
274  if (ci->client_name.starts_with(query)) {
275  suggestions.push_back(ci->client_name);
276  }
277  }
278  for (const Town *t : Town::Iterate()) {
279  /* Get the town-name via the string-system */
280  SetDParam(0, t->index);
281  std::string town_name = GetString(STR_TOWN_NAME);
282  if (town_name.starts_with(query)) {
283  suggestions.push_back(std::move(town_name));
284  }
285  }
286  return suggestions;
287  }
288 
289  void ApplySuggestion(std::string_view prefix, std::string_view suggestion) override
290  {
291  /* Add ': ' if we are at the start of the line (pretty) */
292  if (prefix.empty()) {
293  this->textbuf->Assign(fmt::format("{}: ", suggestion));
294  } else {
295  this->textbuf->Assign(fmt::format("{}{} ", prefix, suggestion));
296  }
297  }
298 };
299 
301 struct NetworkChatWindow : public Window {
303  int dest;
306 
315  {
316  this->dtype = type;
317  this->dest = dest;
319  this->message_editbox.cancel_button = WID_NC_CLOSE;
320  this->message_editbox.ok_button = WID_NC_SENDBUTTON;
321 
322  static const StringID chat_captions[] = {
323  STR_NETWORK_CHAT_ALL_CAPTION,
324  STR_NETWORK_CHAT_COMPANY_CAPTION,
325  STR_NETWORK_CHAT_CLIENT_CAPTION
326  };
327  assert((uint)this->dtype < lengthof(chat_captions));
328 
329  this->CreateNestedTree();
330  this->GetWidget<NWidgetCore>(WID_NC_DESTINATION)->widget_data = chat_captions[this->dtype];
331  this->FinishInitNested(type);
332 
335 
337  }
338 
339  void Close([[maybe_unused]] int data = 0) override
340  {
342  this->Window::Close();
343  }
344 
345  void FindWindowPlacementAndResize([[maybe_unused]] int def_width, [[maybe_unused]] int def_height) override
346  {
348  }
349 
354  {
355  if (this->chat_tab_completion.AutoComplete()) {
356  this->SetDirty();
357  }
358  }
359 
360  Point OnInitialPosition([[maybe_unused]] int16_t sm_width, [[maybe_unused]] int16_t sm_height, [[maybe_unused]] int window_number) override
361  {
362  Point pt = { 0, _screen.height - sm_height - FindWindowById(WC_STATUS_BAR, 0)->height };
363  return pt;
364  }
365 
366  void SetStringParameters(WidgetID widget) const override
367  {
368  if (widget != WID_NC_DESTINATION) return;
369 
370  if (this->dtype == DESTTYPE_CLIENT) {
371  SetDParamStr(0, NetworkClientInfo::GetByClientID((ClientID)this->dest)->client_name);
372  }
373  }
374 
375  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
376  {
377  switch (widget) {
378  case WID_NC_SENDBUTTON: /* Send */
379  SendChat(this->message_editbox.text.buf, this->dtype, this->dest);
380  [[fallthrough]];
381 
382  case WID_NC_CLOSE: /* Cancel */
383  this->Close();
384  break;
385  }
386  }
387 
388  EventState OnKeyPress([[maybe_unused]] char32_t key, uint16_t keycode) override
389  {
390  EventState state = ES_NOT_HANDLED;
391  if (keycode == WKC_TAB) {
393  state = ES_HANDLED;
394  }
395  return state;
396  }
397 
398  void OnEditboxChanged(WidgetID widget) override
399  {
400  if (widget == WID_NC_TEXTBOX) {
401  this->chat_tab_completion.Reset();
402  }
403  }
404 
410  void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
411  {
412  if (data == this->dest) this->Close();
413  }
414 };
415 
419  NWidget(WWT_CLOSEBOX, COLOUR_GREY, WID_NC_CLOSE),
420  NWidget(WWT_PANEL, COLOUR_GREY, WID_NC_BACKGROUND),
422  NWidget(WWT_TEXT, COLOUR_GREY, WID_NC_DESTINATION), SetMinimalSize(62, 12), SetPadding(1, 0, 1, 0), SetAlignment(SA_VERT_CENTER | SA_RIGHT), SetDataTip(STR_NULL, STR_NULL),
423  NWidget(WWT_EDITBOX, COLOUR_GREY, WID_NC_TEXTBOX), SetMinimalSize(100, 0), SetPadding(1, 0, 1, 0), SetResize(1, 0),
424  SetDataTip(STR_NETWORK_CHAT_OSKTITLE, STR_NULL),
425  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_NC_SENDBUTTON), SetMinimalSize(62, 12), SetPadding(1, 0, 1, 0), SetDataTip(STR_NETWORK_CHAT_SEND, STR_NULL),
426  EndContainer(),
427  EndContainer(),
428  EndContainer(),
429 };
430 
433  WDP_MANUAL, nullptr, 0, 0,
435  0,
437 );
438 
439 
446 {
448  new NetworkChatWindow(_chat_window_desc, type, dest);
449 }
std::string_view query
Last token of the text. This is used to based the suggestions on.
std::string_view prefix
Prefix of the text before the last space.
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition: factory.hpp:138
How all blitters should look like.
Definition: base.hpp:29
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...
virtual void CopyToBuffer(const void *video, void *dst, int width, int height)=0
Copy from the screen to a buffer.
virtual void CopyFromBuffer(void *video, const void *src, int width, int height)=0
Copy from a buffer to the screen.
static NetworkRecvStatus SendChat(NetworkAction action, DestType type, int dest, const std::string &msg, int64_t data)
Send a chat-packet over the network.
const T * GetBuffer() const
Get the currently allocated buffer.
Definition: alloc_type.hpp:75
T * Allocate(size_t count)
Get buffer of at least count times T.
Definition: alloc_type.hpp:42
virtual void MakeDirty(int left, int top, int width, int height)=0
Mark a particular area dirty.
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
static const uint NETWORK_CHAT_LENGTH
The maximum length of a chat message, in bytes including '\0'.
Definition: config.h:62
@ ICONSOLE_FULL
In-game console is opened, whole screen.
Definition: console_type.h:17
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition: fontcache.cpp:77
int GetStringLineCount(StringID str, int maxw)
Calculates number of lines of string.
Definition: gfx.cpp:728
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
Definition: gfx.cpp:114
int DrawStringMultiLine(int left, int right, int top, int bottom, std::string_view str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly over multiple lines.
Definition: gfx.cpp:774
@ SA_LEFT
Left align the text.
Definition: gfx_type.h:343
@ SA_RIGHT
Right align the text (must be a single bit).
Definition: gfx_type.h:345
@ SA_FORCE
Force the alignment, i.e. don't swap for RTL languages.
Definition: gfx_type.h:355
@ SA_BOTTOM
Bottom align the text.
Definition: gfx_type.h:350
@ SA_VERT_CENTER
Vertically center the text.
Definition: gfx_type.h:349
@ FS_NORMAL
Index of the normal font in the font tables.
Definition: gfx_type.h:209
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:260
@ FILLRECT_RECOLOUR
Apply a recolour sprite to the screen content.
Definition: gfx_type.h:300
constexpr NWidgetPart SetPadding(uint8_t top, uint8_t right, uint8_t bottom, uint8_t left)
Widget part function for setting additional space around a widget.
Definition: widget_type.h:1228
constexpr NWidgetPart SetDataTip(uint32_t data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1202
constexpr NWidgetPart SetMinimalSize(int16_t x, int16_t y)
Widget part function for setting the minimal size.
Definition: widget_type.h:1137
constexpr NWidgetPart NWidget(WidgetType tp, Colours col, WidgetID idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1309
constexpr NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
Definition: widget_type.h:1191
constexpr NWidgetPart SetAlignment(StringAlignment align)
Widget part function for setting the alignment of text/images.
Definition: widget_type.h:1170
constexpr NWidgetPart SetResize(int16_t dx, int16_t dy)
Widget part function for setting the resize step.
Definition: widget_type.h:1126
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:940
bool _network_server
network-server is active
Definition: network.cpp:66
Basic functions/variables used all over the place.
Base core network types and some helper functions to access them.
static uint MAX_CHAT_MESSAGES
The limit of chat messages to show.
static void SendChat(const std::string &buf, DestType type, int dest)
Send an actual chat message.
void NetworkDrawChatMessage()
Draw the chat message-box.
static ReusableBuffer< uint8_t > _chatmessage_backup
Backup in case text is moved.
void ShowNetworkChatQueryWindow(DestType type, int dest)
Show the chat window.
static bool HaveChatMessages(bool show_all)
Test if there are any chat messages to display.
void CDECL NetworkAddChatMessage(TextColour colour, uint duration, const std::string &message)
Add a text message to the 'chat window' to be shown.
static constexpr NWidgetPart _nested_chat_window_widgets[]
The widgets of the chat window.
static IntervalTimer< TimerWindow > network_message_expired_interval(std::chrono::seconds(1), [](auto) { auto now=std::chrono::steady_clock::now();for(auto &cmsg :_chatmsg_list) { if(now > cmsg.remove_time &&_chatmessage_dirty_time< cmsg.remove_time) { _chatmessage_dirty_time=now;_chatmessage_dirty=true;break;} } })
Check if a message is expired on a regular interval.
static std::chrono::steady_clock::time_point _chatmessage_dirty_time
Time the chat history was marked dirty.
void NetworkReInitChatBoxSize()
Initialize all font-dependent chat box sizes.
static const uint NETWORK_CHAT_LINE_SPACING
Spacing between chat lines.
void NetworkInitChatMessage()
Initialize all buffers of the chat visualisation.
static WindowDesc _chat_window_desc(WDP_MANUAL, nullptr, 0, 0, WC_SEND_NETWORK_MSG, WC_NONE, 0, _nested_chat_window_widgets)
The description of the chat window.
void NetworkUndrawChatMessage()
Hide the chatbox.
static PointDimension _chatmsg_box
The chatbox grows from the bottom so the coordinates are pixels from the left and pixels from the bot...
static bool _chatmessage_dirty
Does the chat message need repainting?
static bool _chatmessage_visible
Is a chat message visible.
static std::deque< ChatMessage > _chatmsg_list
The actual chat message list.
@ WID_NC_SENDBUTTON
Send button.
@ WID_NC_BACKGROUND
Background of the window.
@ WID_NC_CLOSE
Close button.
@ WID_NC_TEXTBOX
Textbox.
@ WID_NC_DESTINATION
Destination.
Client part of the network protocol.
void NetworkServerSendChat(NetworkAction action, DestType type, int dest, const std::string &msg, ClientID from_id, int64_t data=0, bool from_admin=false)
Send an actual chat message.
DestType
Destination of our chat messages.
Definition: network_type.h:79
@ DESTTYPE_CLIENT
Send message/notice to only a certain client (Private)
Definition: network_type.h:82
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition: network_type.h:90
ClientID
'Unique' identifier to be given to clients
Definition: network_type.h:49
@ CLIENT_ID_SERVER
Servers always have this ID.
Definition: network_type.h:51
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:56
static const PaletteID PALETTE_TO_TRANSPARENT
This sets the sprite to transparent.
Definition: sprites.h:1602
#define lengthof(array)
Return the length of an fixed size array.
Definition: stdafx.h:280
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings.cpp:104
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
Definition: strings.cpp:319
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:357
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
Container for a message.
TextColour colour
The colour of the message.
std::chrono::steady_clock::time_point remove_time
The time to remove the message.
std::string message
The action message.
GUISettings gui
settings related to the GUI
bool visible
cursor is visible
Definition: gfx_type.h:145
Point draw_size
position and size bounding-box for drawing
Definition: gfx_type.h:139
uint8_t network_chat_box_height
height of the chat box in lines
uint16_t network_chat_box_width_pct
width of the chat box in percent
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:1075
Window to enter the chat message in.
NetworkChatAutoCompletion chat_tab_completion
Holds the state and logic of auto-completion of player names and towns on Tab press.
NetworkChatWindow(WindowDesc &desc, DestType type, int dest)
Create a chat input window.
void ChatTabCompletion()
See if we can auto-complete the current text of the user.
int dest
The identifier of the destination.
void OnInvalidateData([[maybe_unused]] int data=0, [[maybe_unused]] bool gui_scope=true) override
Some data on this window has become invalid.
DestType dtype
The type of destination.
QueryString message_editbox
Message editbox.
Container for all information known about a client.
Definition: network_base.h:24
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
Definition: network.cpp:118
Specification of a rectangle with an absolute top-left coordinate and a (relative) width/height.
Coordinates of a point in 2D.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:388
Data stored about a string that can be modified in the GUI.
int ok_button
Widget button of parent window to simulate when pressing OK in OSK.
int cancel_button
Widget button of parent window to simulate when pressing CANCEL in OSK.
void Assign(StringID string)
Render a string into the textbuffer.
Definition: textbuf.cpp:431
char *const buf
buffer in which text is saved
Definition: textbuf_type.h:32
Town data structure.
Definition: town.h:54
High level window description.
Definition: window_gui.h:159
Data structure for an opened window.
Definition: window_gui.h:273
virtual void Close(int data=0)
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:1047
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1733
std::map< WidgetID, QueryString * > querystrings
QueryString associated to WWT_EDITBOX widgets.
Definition: window_gui.h:320
void CreateNestedTree()
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1723
bool SetFocusedWidget(WidgetID widget_index)
Set focus within this window to the given widget.
Definition: window.cpp:486
int height
Height of the window (number of pixels down in y direction)
Definition: window_gui.h:312
virtual void FindWindowPlacementAndResize(int def_width, int def_height)
Resize window towards the default size.
Definition: window.cpp:1420
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:302
uint _toolbar_width
Width of the toolbar, shared by statusbar.
Definition: toolbar_gui.cpp:74
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:112
@ WWT_EDITBOX
a textbox for typing
Definition: widget_type.h:71
@ NWID_HORIZONTAL
Horizontal container.
Definition: widget_type.h:75
@ WWT_PANEL
Simple depressed panel.
Definition: widget_type.h:50
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition: widget_type.h:69
@ WWT_TEXT
Pure simple text.
Definition: widget_type.h:58
int PositionNetworkChatWindow(Window *w)
(Re)position network chat window at the screen.
Definition: window.cpp:3415
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1098
Window * FindWindowByClass(WindowClass cls)
Find any window by its class.
Definition: window.cpp:1113
void CloseWindowByClass(WindowClass cls, int data)
Close all windows of a given class.
Definition: window.cpp:1152
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:3211
@ WDP_MANUAL
Manually align the window (so no automatic location finding)
Definition: window_gui.h:146
int WidgetID
Widget ID.
Definition: window_type.h:18
EventState
State of handling an event.
Definition: window_type.h:743
@ ES_HANDLED
The passed event is handled.
Definition: window_type.h:744
@ ES_NOT_HANDLED
The passed event is not handled.
Definition: window_type.h:745
@ WC_NEWS_WINDOW
News window; Window numbers:
Definition: window_type.h:248
@ WC_STATUS_BAR
Statusbar (at the bottom of your screen); Window numbers:
Definition: window_type.h:64
@ WC_SEND_NETWORK_MSG
Chatbox; Window numbers:
Definition: window_type.h:509
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:45
int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:117