src/signs_gui.cpp

   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
   8 /** @file signs_gui.cpp The GUI for signs. */
   9
  10 #include "stdafx.h"
  11 #include "company_gui.h"
  12 #include "company_func.h"
  13 #include "signs_base.h"
  14 #include "signs_func.h"
  15 #include "debug.h"
  16 #include "command_func.h"
  17 #include "strings_func.h"
  18 #include "window_func.h"
  19 #include "map_func.h"
  20 #include "viewport_func.h"
  21 #include "querystring_gui.h"
  22 #include "sortlist_type.h"
  23 #include "stringfilter_type.h"
  24 #include "string_func.h"
  25 #include "core/geometry_func.hpp"
  26 #include "hotkeys.h"
  27 #include "transparency.h"
  28 #include "gui.h"
  29 #include "signs_cmd.h"
  30 #include "timer/timer.h"
  31 #include "timer/timer_window.h"
  32
  33 #include "widgets/sign_widget.h"
  34
  35 #include "table/strings.h"
  36 #include "table/sprites.h"
  37
  38 #include "safeguards.h"
  39
  40 struct SignList {
  41         /**
  42          * A GUIList contains signs and uses a StringFilter for filtering.
  43          */
  44         typedef GUIList<const Sign *, std::nullptr_t, StringFilter &> GUISignList;
  45
  46         GUISignList signs;
  47
  48         StringFilter string_filter;                                       ///< The match string to be used when the GUIList is (re)-sorted.
  49         static bool match_case;                                           ///< Should case sensitive matching be used?
  50         static std::string default_name;                                  ///< Default sign name, used if Sign::name is nullptr.
  51
  52         /**
  53          * Creates a SignList with filtering disabled by default.
  54          */
  55         SignList() : string_filter(&match_case)
  56         {
  57         }
  58
  59         void BuildSignsList()
  60         {
  61                 if (!this->signs.NeedRebuild()) return;
  62
  63                 Debug(misc, 3, "Building sign list");
  64
  65                 this->signs.clear();
  66
  67                 for (const Sign *si : Sign::Iterate()) this->signs.push_back(si);
  68
  69                 this->signs.SetFilterState(true);
  70                 this->FilterSignList();
  71                 this->signs.shrink_to_fit();
  72                 this->signs.RebuildDone();
  73         }
  74
  75         /** Sort signs by their name */
  76         static bool SignNameSorter(const Sign * const &a, const Sign * const &b)
  77         {
  78                 /* Signs are very very rarely using the default text, but there can also be
  79                  * a lot of them. Therefore a worthwhile performance gain can be made by
  80                  * directly comparing Sign::name instead of going through the string
  81                  * system for each comparison. */
  82                 const std::string &a_name = a->name.empty() ? SignList::default_name : a->name;
  83                 const std::string &b_name = b->name.empty() ? SignList::default_name : b->name;
  84
  85                 int r = StrNaturalCompare(a_name, b_name); // Sort by name (natural sorting).
  86
  87                 return r != 0 ? r < 0 : (a->index < b->index);
  88         }
  89
  90         void SortSignsList()
  91         {
  92                 if (!this->signs.Sort(&SignNameSorter)) return;
  93         }
  94
  95         /** Filter sign list by sign name */
  96         static bool CDECL SignNameFilter(const Sign * const *a, StringFilter &filter)
  97         {
  98                 /* Same performance benefit as above for sorting. */
  99                 const std::string &a_name = (*a)->name.empty() ? SignList::default_name : (*a)->name;
 100
 101                 filter.ResetState();
 102                 filter.AddLine(a_name);
 103                 return filter.GetState();
 104         }
 105
 106         /** Filter sign list excluding OWNER_DEITY */
 107         static bool CDECL OwnerDeityFilter(const Sign * const *a, StringFilter &)
 108         {
 109                 /* You should never be able to edit signs of owner DEITY */
 110                 return (*a)->owner != OWNER_DEITY;
 111         }
 112
 113         /** Filter sign list by owner */
 114         static bool CDECL OwnerVisibilityFilter(const Sign * const *a, StringFilter &)
 115         {
 116                 assert(!HasBit(_display_opt, DO_SHOW_COMPETITOR_SIGNS));
 117                 /* Hide sign if non-own signs are hidden in the viewport */
 118                 return (*a)->owner == _local_company || (*a)->owner == OWNER_DEITY;
 119         }
 120
 121         /** Filter out signs from the sign list that does not match the name filter */
 122         void FilterSignList()
 123         {
 124                 this->signs.Filter(&SignNameFilter, this->string_filter);
 125                 if (_game_mode != GM_EDITOR) this->signs.Filter(&OwnerDeityFilter, this->string_filter);
 126                 if (!HasBit(_display_opt, DO_SHOW_COMPETITOR_SIGNS)) {
 127                         this->signs.Filter(&OwnerVisibilityFilter, this->string_filter);
 128                 }
 129         }
 130 };
 131
 132 bool SignList::match_case = false;
 133 std::string SignList::default_name;
 134
 135 /** Enum referring to the Hotkeys in the sign list window */
 136 enum SignListHotkeys {
 137         SLHK_FOCUS_FILTER_BOX, ///< Focus the edit box for editing the filter string
 138 };
 139
 140 struct SignListWindow : Window, SignList {
 141         QueryString filter_editbox; ///< Filter editbox;
 142         int text_offset; ///< Offset of the sign text relative to the left edge of the WID_SIL_LIST widget.
 143         Scrollbar *vscroll;
 144
 145         SignListWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc), filter_editbox(MAX_LENGTH_SIGN_NAME_CHARS * MAX_CHAR_LENGTH, MAX_LENGTH_SIGN_NAME_CHARS)
 146         {
 147                 this->CreateNestedTree();
 148                 this->vscroll = this->GetScrollbar(WID_SIL_SCROLLBAR);
 149                 this->FinishInitNested(window_number);
 150                 this->SetWidgetLoweredState(WID_SIL_FILTER_MATCH_CASE_BTN, SignList::match_case);
 151
 152                 /* Initialize the text edit widget */
 153                 this->querystrings[WID_SIL_FILTER_TEXT] = &this->filter_editbox;
 154                 this->filter_editbox.cancel_button = QueryString::ACTION_CLEAR;
 155
 156                 /* Initialize the filtering variables */
 157                 this->SetFilterString("");
 158
 159                 /* Create initial list. */
 160                 this->signs.ForceRebuild();
 161                 this->signs.ForceResort();
 162                 this->BuildSortSignList();
 163         }
 164
 165         void OnInit() override
 166         {
 167                 /* Default sign name, used if Sign::name is nullptr. */
 168                 SignList::default_name = GetString(STR_DEFAULT_SIGN_NAME);
 169                 this->signs.ForceResort();
 170                 this->SortSignsList();
 171                 this->SetDirty();
 172         }
 173
 174         /**
 175          * This function sets the filter string of the sign list. The contents of
 176          * the edit widget is not updated by this function. Depending on if the
 177          * new string is zero-length or not the clear button is made
 178          * disabled/enabled. The sign list is updated according to the new filter.
 179          */
 180         void SetFilterString(const char *new_filter_string)
 181         {
 182                 /* check if there is a new filter string */
 183                 this->string_filter.SetFilterTerm(new_filter_string);
 184
 185                 /* Rebuild the list of signs */
 186                 this->InvalidateData();
 187         }
 188
 189         void OnPaint() override
 190         {
 191                 if (!this->IsShaded() && this->signs.NeedRebuild()) this->BuildSortSignList();
 192                 this->DrawWidgets();
 193         }
 194
 195         void DrawWidget(const Rect &r, WidgetID widget) const override
 196         {
 197                 switch (widget) {
 198                         case WID_SIL_LIST: {
 199                                 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
 200                                 uint text_offset_y = (this->resize.step_height - GetCharacterHeight(FS_NORMAL) + 1) / 2;
 201                                 /* No signs? */
 202                                 if (this->vscroll->GetCount() == 0) {
 203                                         DrawString(tr.left, tr.right, tr.top + text_offset_y, STR_STATION_LIST_NONE);
 204                                         return;
 205                                 }
 206
 207                                 Dimension d = GetSpriteSize(SPR_COMPANY_ICON);
 208                                 bool rtl = _current_text_dir == TD_RTL;
 209                                 int sprite_offset_y = (this->resize.step_height - d.height + 1) / 2;
 210                                 uint icon_left = rtl ? tr.right - this->text_offset : tr.left;
 211                                 tr = tr.Indent(this->text_offset, rtl);
 212
 213                                 /* At least one sign available. */
 214                                 for (uint16_t i = this->vscroll->GetPosition(); this->vscroll->IsVisible(i) && i < this->vscroll->GetCount(); i++)
 215                                 {
 216                                         const Sign *si = this->signs[i];
 217
 218                                         if (si->owner != OWNER_NONE) DrawCompanyIcon(si->owner, icon_left, tr.top + sprite_offset_y);
 219
 220                                         SetDParam(0, si->index);
 221                                         DrawString(tr.left, tr.right, tr.top + text_offset_y, STR_SIGN_NAME, TC_YELLOW);
 222                                         tr.top += this->resize.step_height;
 223                                 }
 224                                 break;
 225                         }
 226                 }
 227         }
 228
 229         void SetStringParameters(WidgetID widget) const override
 230         {
 231                 if (widget == WID_SIL_CAPTION) SetDParam(0, this->vscroll->GetCount());
 232         }
 233
 234         void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
 235         {
 236                 switch (widget) {
 237                         case WID_SIL_LIST: {
 238                                 auto it = this->vscroll->GetScrolledItemFromWidget(this->signs, pt.y, this, WID_SIL_LIST, WidgetDimensions::scaled.framerect.top);
 239                                 if (it == this->signs.end()) return;
 240
 241                                 const Sign *si = *it;
 242                                 ScrollMainWindowToTile(TileVirtXY(si->x, si->y));
 243                                 break;
 244                         }
 245
 246                         case WID_SIL_FILTER_ENTER_BTN:
 247                                 if (this->signs.size() >= 1) {
 248                                         const Sign *si = this->signs[0];
 249                                         ScrollMainWindowToTile(TileVirtXY(si->x, si->y));
 250                                 }
 251                                 break;
 252
 253                         case WID_SIL_FILTER_MATCH_CASE_BTN:
 254                                 SignList::match_case = !SignList::match_case; // Toggle match case
 255                                 this->SetWidgetLoweredState(WID_SIL_FILTER_MATCH_CASE_BTN, SignList::match_case); // Toggle button pushed state
 256                                 this->InvalidateData(); // Rebuild the list of signs
 257                                 break;
 258                 }
 259         }
 260
 261         void OnResize() override
 262         {
 263                 this->vscroll->SetCapacityFromWidget(this, WID_SIL_LIST, WidgetDimensions::scaled.framerect.Vertical());
 264         }
 265
 266         void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
 267         {
 268                 switch (widget) {
 269                         case WID_SIL_LIST: {
 270                                 Dimension spr_dim = GetSpriteSize(SPR_COMPANY_ICON);
 271                                 this->text_offset = WidgetDimensions::scaled.frametext.left + spr_dim.width + 2; // 2 pixels space between icon and the sign text.
 272                                 resize->height = std::max<uint>(GetCharacterHeight(FS_NORMAL), spr_dim.height + 2);
 273                                 Dimension d = {(uint)(this->text_offset + WidgetDimensions::scaled.frametext.right), padding.height + 5 * resize->height};
 274                                 *size = maxdim(*size, d);
 275                                 break;
 276                         }
 277
 278                         case WID_SIL_CAPTION:
 279                                 SetDParamMaxValue(0, Sign::GetPoolSize(), 3);
 280                                 *size = GetStringBoundingBox(STR_SIGN_LIST_CAPTION);
 281                                 size->height += padding.height;
 282                                 size->width  += padding.width;
 283                                 break;
 284                 }
 285         }
 286
 287         EventState OnHotkey(int hotkey) override
 288         {
 289                 switch (hotkey) {
 290                         case SLHK_FOCUS_FILTER_BOX:
 291                                 this->SetFocusedWidget(WID_SIL_FILTER_TEXT);
 292                                 SetFocusedWindow(this); // The user has asked to give focus to the text box, so make sure this window is focused.
 293                                 break;
 294
 295                         default:
 296                                 return ES_NOT_HANDLED;
 297                 }
 298
 299                 return ES_HANDLED;
 300         }
 301
 302         void OnEditboxChanged(WidgetID widget) override
 303         {
 304                 if (widget == WID_SIL_FILTER_TEXT) this->SetFilterString(this->filter_editbox.text.buf);
 305         }
 306
 307         void BuildSortSignList()
 308         {
 309                 if (this->signs.NeedRebuild()) {
 310                         this->BuildSignsList();
 311                         this->vscroll->SetCount(this->signs.size());
 312                         this->SetWidgetDirty(WID_SIL_CAPTION);
 313                 }
 314                 this->SortSignsList();
 315         }
 316
 317         /** Resort the sign listing on a regular interval. */
 318         IntervalTimer<TimerWindow> rebuild_interval = {std::chrono::seconds(3), [this](auto) {
 319                 this->BuildSortSignList();
 320                 this->SetDirty();
 321         }};
 322
 323         /**
 324          * Some data on this window has become invalid.
 325          * @param data Information about the changed data.
 326          * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.
 327          */
 328         void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
 329         {
 330                 /* When there is a filter string, we always need to rebuild the list even if
 331                  * the amount of signs in total is unchanged, as the subset of signs that is
 332                  * accepted by the filter might has changed. */
 333                 if (data == 0 || data == -1 || !this->string_filter.IsEmpty()) { // New or deleted sign, changed visibility setting or there is a filter string
 334                         /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
 335                         this->signs.ForceRebuild();
 336                 } else { // Change of sign contents while there is no filter string
 337                         this->signs.ForceResort();
 338                 }
 339         }
 340
 341         /**
 342          * Handler for global hotkeys of the SignListWindow.
 343          * @param hotkey Hotkey
 344          * @return ES_HANDLED if hotkey was accepted.
 345          */
 346         static EventState SignListGlobalHotkeys(int hotkey)
 347         {
 348                 if (_game_mode == GM_MENU) return ES_NOT_HANDLED;
 349                 Window *w = ShowSignList();
 350                 if (w == nullptr) return ES_NOT_HANDLED;
 351                 return w->OnHotkey(hotkey);
 352         }
 353
 354         static inline HotkeyList hotkeys{"signlist", {
 355                 Hotkey('F', "focus_filter_box", SLHK_FOCUS_FILTER_BOX),
 356         }, SignListGlobalHotkeys};
 357 };
 358
 359 static constexpr NWidgetPart _nested_sign_list_widgets[] = {
 360         NWidget(NWID_HORIZONTAL),
 361                 NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
 362                 NWidget(WWT_CAPTION, COLOUR_BROWN, WID_SIL_CAPTION), SetDataTip(STR_SIGN_LIST_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
 363                 NWidget(WWT_SHADEBOX, COLOUR_BROWN),
 364                 NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
 365                 NWidget(WWT_STICKYBOX, COLOUR_BROWN),
 366         EndContainer(),
 367         NWidget(NWID_HORIZONTAL),
 368                 NWidget(NWID_VERTICAL),
 369                         NWidget(WWT_PANEL, COLOUR_BROWN, WID_SIL_LIST), SetMinimalSize(WidgetDimensions::unscaled.frametext.Horizontal() + 16 + 255, 0),
 370                                                                 SetResize(1, 1), SetFill(1, 0), SetScrollbar(WID_SIL_SCROLLBAR), EndContainer(),
 371                         NWidget(NWID_HORIZONTAL),
 372                                 NWidget(WWT_PANEL, COLOUR_BROWN), SetFill(1, 1),
 373                                         NWidget(WWT_EDITBOX, COLOUR_BROWN, WID_SIL_FILTER_TEXT), SetMinimalSize(80, 12), SetResize(1, 0), SetFill(1, 0), SetPadding(2, 2, 2, 2),
 374                                                         SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
 375                                 EndContainer(),
 376                                 NWidget(WWT_TEXTBTN, COLOUR_BROWN, WID_SIL_FILTER_MATCH_CASE_BTN), SetDataTip(STR_SIGN_LIST_MATCH_CASE, STR_SIGN_LIST_MATCH_CASE_TOOLTIP),
 377                         EndContainer(),
 378                 EndContainer(),
 379                 NWidget(NWID_VERTICAL),
 380                         NWidget(NWID_VSCROLLBAR, COLOUR_BROWN, WID_SIL_SCROLLBAR),
 381                         NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
 382                 EndContainer(),
 383         EndContainer(),
 384 };
 385
 386 static WindowDesc _sign_list_desc(__FILE__, __LINE__,
 387         WDP_AUTO, "list_signs", 358, 138,
 388         WC_SIGN_LIST, WC_NONE,
 389         0,
 390         std::begin(_nested_sign_list_widgets), std::end(_nested_sign_list_widgets),
 391         &SignListWindow::hotkeys
 392 );
 393
 394 /**
 395  * Open the sign list window
 396  *
 397  * @return newly opened sign list window, or nullptr if the window could not be opened.
 398  */
 399 Window *ShowSignList()
 400 {
 401         return AllocateWindowDescFront<SignListWindow>(&_sign_list_desc, 0);
 402 }
 403
 404 /**
 405  * Actually rename the sign.
 406  * @param index the sign to rename.
 407  * @param text  the new name.
 408  * @return true if the window will already be removed after returning.
 409  */
 410 static bool RenameSign(SignID index, const char *text)
 411 {
 412         bool remove = StrEmpty(text);
 413         Command<CMD_RENAME_SIGN>::Post(StrEmpty(text) ? STR_ERROR_CAN_T_DELETE_SIGN : STR_ERROR_CAN_T_CHANGE_SIGN_NAME, index, text);
 414         return remove;
 415 }
 416
 417 struct SignWindow : Window, SignList {
 418         QueryString name_editbox;
 419         SignID cur_sign;
 420
 421         SignWindow(WindowDesc *desc, const Sign *si) : Window(desc), name_editbox(MAX_LENGTH_SIGN_NAME_CHARS * MAX_CHAR_LENGTH, MAX_LENGTH_SIGN_NAME_CHARS)
 422         {
 423                 this->querystrings[WID_QES_TEXT] = &this->name_editbox;
 424                 this->name_editbox.caption = STR_EDIT_SIGN_CAPTION;
 425                 this->name_editbox.cancel_button = WID_QES_CANCEL;
 426                 this->name_editbox.ok_button = WID_QES_OK;
 427
 428                 this->InitNested(WN_QUERY_STRING_SIGN);
 429
 430                 UpdateSignEditWindow(si);
 431                 this->SetFocusedWidget(WID_QES_TEXT);
 432         }
 433
 434         void UpdateSignEditWindow(const Sign *si)
 435         {
 436                 /* Display an empty string when the sign hasn't been edited yet */
 437                 if (!si->name.empty()) {
 438                         SetDParam(0, si->index);
 439                         this->name_editbox.text.Assign(STR_SIGN_NAME);
 440                 } else {
 441                         this->name_editbox.text.DeleteAll();
 442                 }
 443
 444                 this->cur_sign = si->index;
 445
 446                 this->SetWidgetDirty(WID_QES_TEXT);
 447                 this->SetFocusedWidget(WID_QES_TEXT);
 448         }
 449
 450         /**
 451          * Returns a pointer to the (alphabetically) previous or next sign of the current sign.
 452          * @param next false if the previous sign is wanted, true if the next sign is wanted
 453          * @return pointer to the previous/next sign
 454          */
 455         const Sign *PrevNextSign(bool next)
 456         {
 457                 /* Rebuild the sign list */
 458                 this->signs.ForceRebuild();
 459                 this->signs.NeedResort();
 460                 this->BuildSignsList();
 461                 this->SortSignsList();
 462
 463                 /* Search through the list for the current sign, excluding
 464                  * - the first sign if we want the previous sign or
 465                  * - the last sign if we want the next sign */
 466                 size_t end = this->signs.size() - (next ? 1 : 0);
 467                 for (uint i = next ? 0 : 1; i < end; i++) {
 468                         if (this->cur_sign == this->signs[i]->index) {
 469                                 /* We've found the current sign, so return the sign before/after it */
 470                                 return this->signs[i + (next ? 1 : -1)];
 471                         }
 472                 }
 473                 /* If we haven't found the current sign by now, return the last/first sign */
 474                 return next ? this->signs.front() : this->signs.back();
 475         }
 476
 477         void SetStringParameters(WidgetID widget) const override
 478         {
 479                 switch (widget) {
 480                         case WID_QES_CAPTION:
 481                                 SetDParam(0, this->name_editbox.caption);
 482                                 break;
 483                 }
 484         }
 485
 486         void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
 487         {
 488                 switch (widget) {
 489                         case WID_QES_LOCATION: {
 490                                 const Sign *si = Sign::Get(this->cur_sign);
 491                                 TileIndex tile = TileVirtXY(si->x, si->y);
 492                                 if (_ctrl_pressed) {
 493                                         ShowExtraViewportWindow(tile);
 494                                 } else {
 495                                         ScrollMainWindowToTile(tile);
 496                                 }
 497                                 break;
 498                         }
 499
 500                         case WID_QES_PREVIOUS:
 501                         case WID_QES_NEXT: {
 502                                 const Sign *si = this->PrevNextSign(widget == WID_QES_NEXT);
 503
 504                                 /* Rebuild the sign list */
 505                                 this->signs.ForceRebuild();
 506                                 this->signs.NeedResort();
 507                                 this->BuildSignsList();
 508                                 this->SortSignsList();
 509
 510                                 /* Scroll to sign and reopen window */
 511                                 ScrollMainWindowToTile(TileVirtXY(si->x, si->y));
 512                                 UpdateSignEditWindow(si);
 513                                 break;
 514                         }
 515
 516                         case WID_QES_DELETE:
 517                                 /* Only need to set the buffer to null, the rest is handled as the OK button */
 518                                 RenameSign(this->cur_sign, "");
 519                                 /* don't delete this, we are deleted in Sign::~Sign() -> DeleteRenameSignWindow() */
 520                                 break;
 521
 522                         case WID_QES_OK:
 523                                 if (RenameSign(this->cur_sign, this->name_editbox.text.buf)) break;
 524                                 [[fallthrough]];
 525
 526                         case WID_QES_CANCEL:
 527                                 this->Close();
 528                                 break;
 529                 }
 530         }
 531 };
 532
 533 static constexpr NWidgetPart _nested_query_sign_edit_widgets[] = {
 534         NWidget(NWID_HORIZONTAL),
 535                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
 536                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_QES_CAPTION), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS), SetTextStyle(TC_WHITE),
 537                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_QES_LOCATION), SetMinimalSize(12, 14), SetDataTip(SPR_GOTO_LOCATION, STR_EDIT_SIGN_LOCATION_TOOLTIP),
 538         EndContainer(),
 539         NWidget(WWT_PANEL, COLOUR_GREY),
 540                 NWidget(WWT_EDITBOX, COLOUR_GREY, WID_QES_TEXT), SetMinimalSize(256, 12), SetDataTip(STR_EDIT_SIGN_SIGN_OSKTITLE, STR_NULL), SetPadding(2, 2, 2, 2),
 541         EndContainer(),
 542         NWidget(NWID_HORIZONTAL),
 543                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_QES_OK), SetMinimalSize(61, 12), SetDataTip(STR_BUTTON_OK, STR_NULL),
 544                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_QES_CANCEL), SetMinimalSize(60, 12), SetDataTip(STR_BUTTON_CANCEL, STR_NULL),
 545                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_QES_DELETE), SetMinimalSize(60, 12), SetDataTip(STR_TOWN_VIEW_DELETE_BUTTON, STR_NULL),
 546                 NWidget(WWT_PANEL, COLOUR_GREY), SetFill(1, 1), EndContainer(),
 547                 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_QES_PREVIOUS), SetMinimalSize(11, 12), SetDataTip(AWV_DECREASE, STR_EDIT_SIGN_PREVIOUS_SIGN_TOOLTIP),
 548                 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_QES_NEXT), SetMinimalSize(11, 12), SetDataTip(AWV_INCREASE, STR_EDIT_SIGN_NEXT_SIGN_TOOLTIP),
 549         EndContainer(),
 550 };
 551
 552 static WindowDesc _query_sign_edit_desc(__FILE__, __LINE__,
 553         WDP_CENTER, nullptr, 0, 0,
 554         WC_QUERY_STRING, WC_NONE,
 555         WDF_CONSTRUCTION,
 556         std::begin(_nested_query_sign_edit_widgets), std::end(_nested_query_sign_edit_widgets)
 557 );
 558
 559 /**
 560  * Handle clicking on a sign.
 561  * @param si The sign that was clicked on.
 562  */
 563 void HandleClickOnSign(const Sign *si)
 564 {
 565         /* If we can't rename the sign, don't even open the rename GUI. */
 566         if (!CompanyCanRenameSign(si)) return;
 567
 568         if (_ctrl_pressed && (si->owner == _local_company || (si->owner == OWNER_DEITY && _game_mode == GM_EDITOR))) {
 569                 RenameSign(si->index, "");
 570                 return;
 571         }
 572
 573         ShowRenameSignWindow(si);
 574 }
 575
 576 /**
 577  * Show the window to change the text of a sign.
 578  * @param si The sign to show the window for.
 579  */
 580 void ShowRenameSignWindow(const Sign *si)
 581 {
 582         /* Delete all other edit windows */
 583         CloseWindowByClass(WC_QUERY_STRING);
 584
 585         new SignWindow(&_query_sign_edit_desc, si);
 586 }
 587
 588 /**
 589  * Close the sign window associated with the given sign.
 590  * @param sign The sign to close the window for.
 591  */
 592 void DeleteRenameSignWindow(SignID sign)
 593 {
 594         SignWindow *w = dynamic_cast<SignWindow *>(FindWindowById(WC_QUERY_STRING, WN_QUERY_STRING_SIGN));
 595
 596         if (w != nullptr && w->cur_sign == sign) w->Close();
 597 }