goal_gui.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#include "stdafx.h"
#include "industry.h"
#include "town.h"
#include "window_gui.h"
#include "strings_func.h"
#include "date_func.h"
#include "viewport_func.h"
#include "gui.h"
#include "goal_base.h"
#include "core/geometry_func.hpp"
#include "company_func.h"
#include "company_base.h"
#include "company_gui.h"
#include "story_base.h"
#include "command_func.h"
#include "string_func.h"
#include "goal_cmd.h"
 
#include "widgets/goal_widget.h"
 
#include "table/strings.h"
 
#include "safeguards.h"
 
enum GoalColumn {
  GC_GOAL = 0, 
  GC_PROGRESS, 
};
 
struct GoalListWindow : public Window {
  Scrollbar *vscroll; 
 
  GoalListWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc)
  {
    this->CreateNestedTree();
    this->vscroll = this->GetScrollbar(WID_GOAL_SCROLLBAR);
    this->FinishInitNested(window_number);
    this->owner = (Owner)this->window_number;
    NWidgetStacked *wi = this->GetWidget<NWidgetStacked>(WID_GOAL_SELECT_BUTTONS);
    wi->SetDisplayedPlane(window_number == INVALID_COMPANY ? 1 : 0);
    this->OnInvalidateData(0);
  }
 
  void SetStringParameters(int widget) const override
  {
    if (widget != WID_GOAL_CAPTION) return;
 
    if (this->window_number == INVALID_COMPANY) {
      SetDParam(0, STR_GOALS_SPECTATOR_CAPTION);
    } else {
      SetDParam(0, STR_GOALS_CAPTION);
      SetDParam(1, this->window_number);
    }
  }
 
  void OnClick(Point pt, int widget, int click_count) override
  {
    switch (widget) {
      case WID_GOAL_GLOBAL_BUTTON:
        ShowGoalsList(INVALID_COMPANY);
        break;
 
      case WID_GOAL_COMPANY_BUTTON:
        ShowGoalsList(_local_company);
        break;
 
      case WID_GOAL_LIST: {
        int y = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_GOAL_LIST, WD_FRAMERECT_TOP);
        for (const Goal *s : Goal::Iterate()) {
          if (s->company == this->window_number) {
            if (y == 0) {
              this->HandleClick(s);
              return;
            }
            y--;
          }
        }
        break;
      }
 
      default:
        break;
    }
  }
 
  void HandleClick(const Goal *s)
  {
    /* Determine dst coordinate for goal and try to scroll to it. */
    TileIndex xy;
    switch (s->type) {
      case GT_NONE: return;
 
      case GT_COMPANY:
        /* s->dst here is not a tile, but a CompanyID.
         * Show the window with the overview of the company instead. */
        ShowCompany((CompanyID)s->dst);
        return;
 
      case GT_TILE:
        if (!IsValidTile(s->dst)) return;
        xy = s->dst;
        break;
 
      case GT_INDUSTRY:
        if (!Industry::IsValidID(s->dst)) return;
        xy = Industry::Get(s->dst)->location.tile;
        break;
 
      case GT_TOWN:
        if (!Town::IsValidID(s->dst)) return;
        xy = Town::Get(s->dst)->xy;
        break;
 
      case GT_STORY_PAGE: {
        if (!StoryPage::IsValidID(s->dst)) return;
 
        /* Verify that:
         * - if global goal: story page must be global.
         * - if company goal: story page must be global or of the same company.
         */
        CompanyID goal_company = s->company;
        CompanyID story_company = StoryPage::Get(s->dst)->company;
        if (goal_company == INVALID_COMPANY ? story_company != INVALID_COMPANY : story_company != INVALID_COMPANY && story_company != goal_company) return;
 
        ShowStoryBook((CompanyID)this->window_number, s->dst);
        return;
      }
 
      default: NOT_REACHED();
    }
 
    if (_ctrl_pressed) {
      ShowExtraViewportWindow(xy);
    } else {
      ScrollMainWindowToTile(xy);
    }
  }
 
  uint CountLines()
  {
    /* Count number of (non) awarded goals. */
    uint num = 0;
    for (const Goal *s : Goal::Iterate()) {
      if (s->company == this->window_number) num++;
    }
 
    /* Count the 'none' lines. */
    if (num == 0) num = 1;
 
    return num;
  }
 
  void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
  {
    if (widget != WID_GOAL_LIST) return;
    Dimension d = GetStringBoundingBox(STR_GOALS_NONE);
 
    resize->height = d.height;
 
    d.height *= 5;
    d.width += padding.width + WD_FRAMERECT_RIGHT + WD_FRAMERECT_LEFT;
    d.height += padding.height + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
    *size = maxdim(*size, d);
  }
 
  void DrawListColumn(GoalColumn column, NWidgetBase *wid, uint progress_col_width) const
  {
    /* Get column draw area. */
    int y = wid->pos_y + WD_FRAMERECT_TOP;
    int x = wid->pos_x + WD_FRAMERECT_LEFT;
    int right = x + wid->current_x - WD_FRAMERECT_RIGHT;
    bool rtl = _current_text_dir == TD_RTL;
 
    int pos = -this->vscroll->GetPosition();
    const int cap = this->vscroll->GetCapacity();
 
    uint num = 0;
    for (const Goal *s : Goal::Iterate()) {
      if (s->company == this->window_number) {
        if (IsInsideMM(pos, 0, cap)) {
          switch (column) {
            case GC_GOAL: {
              /* Display the goal. */
              SetDParamStr(0, s->text);
              uint width_reduction = progress_col_width > 0 ? progress_col_width + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT : 0;
              DrawString(x + (rtl ? width_reduction : 0), right - (rtl ? 0 : width_reduction), y + pos * FONT_HEIGHT_NORMAL, STR_GOALS_TEXT);
              break;
            }
 
            case GC_PROGRESS:
              if (s->progress != nullptr) {
                SetDParamStr(0, s->progress);
                StringID str = s->completed ? STR_GOALS_PROGRESS_COMPLETE : STR_GOALS_PROGRESS;
                int progress_x = x;
                int progress_right = rtl ? x + progress_col_width : right;
                DrawString(progress_x, progress_right, y + pos * FONT_HEIGHT_NORMAL, str, TC_FROMSTRING, SA_RIGHT | SA_FORCE);
              }
              break;
          }
        }
        pos++;
        num++;
      }
    }
 
    if (num == 0) {
      if (column == GC_GOAL && IsInsideMM(pos, 0, cap)) {
        DrawString(x, right, y + pos * FONT_HEIGHT_NORMAL, STR_GOALS_NONE);
      }
      pos++;
    }
  }
 
  void OnPaint() override
  {
    this->DrawWidgets();
 
    if (this->IsShaded()) return; // Don't draw anything when the window is shaded.
 
    /* Calculate progress column width. */
    uint max_width = 0;
    for (const Goal *s : Goal::Iterate()) {
      if (s->progress != nullptr) {
        SetDParamStr(0, s->progress);
        StringID str = s->completed ? STR_GOALS_PROGRESS_COMPLETE : STR_GOALS_PROGRESS;
        uint str_width = GetStringBoundingBox(str).width;
        if (str_width > max_width) max_width = str_width;
      }
    }
 
    NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_GOAL_LIST);
    uint progress_col_width = std::min(max_width, wid->current_x);
 
    /* Draw goal list. */
    this->DrawListColumn(GC_PROGRESS, wid, progress_col_width);
    this->DrawListColumn(GC_GOAL, wid, progress_col_width);
 
  }
 
  void OnResize() override
  {
    this->vscroll->SetCapacityFromWidget(this, WID_GOAL_LIST);
  }
 
  void OnInvalidateData(int data = 0, bool gui_scope = true) override
  {
    if (!gui_scope) return;
    this->vscroll->SetCount(this->CountLines());
    this->SetWidgetDisabledState(WID_GOAL_COMPANY_BUTTON, _local_company == COMPANY_SPECTATOR);
    this->SetWidgetDirty(WID_GOAL_COMPANY_BUTTON);
    this->SetWidgetDirty(WID_GOAL_LIST);
  }
};
 
static const NWidgetPart _nested_goals_list_widgets[] = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
    NWidget(WWT_CAPTION, COLOUR_BROWN, WID_GOAL_CAPTION), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GOAL_SELECT_BUTTONS),
      NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_GOAL_GLOBAL_BUTTON), SetMinimalSize(50, 0), SetMinimalTextLines(1, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM + 2), SetDataTip(STR_GOALS_GLOBAL_BUTTON, STR_GOALS_GLOBAL_BUTTON_HELPTEXT),
      NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_GOAL_COMPANY_BUTTON), SetMinimalSize(50, 0), SetMinimalTextLines(1, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM + 2), SetDataTip(STR_GOALS_COMPANY_BUTTON, STR_GOALS_COMPANY_BUTTON_HELPTEXT),
    EndContainer(),
    NWidget(WWT_SHADEBOX, COLOUR_BROWN),
    NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
    NWidget(WWT_STICKYBOX, COLOUR_BROWN),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PANEL, COLOUR_BROWN), SetDataTip(0x0, STR_GOALS_TOOLTIP_CLICK_ON_SERVICE_TO_CENTER), SetScrollbar(WID_GOAL_SCROLLBAR),
      NWidget(WWT_EMPTY, COLOUR_GREY, WID_GOAL_LIST), SetResize(1, 1), SetMinimalTextLines(2, 0), SetFill(1, 1), SetPadding(WD_FRAMERECT_TOP, 2, WD_FRAMETEXT_BOTTOM, 2),
    EndContainer(),
    NWidget(NWID_VERTICAL),
      NWidget(NWID_VSCROLLBAR, COLOUR_BROWN, WID_GOAL_SCROLLBAR),
      NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
    EndContainer(),
  EndContainer(),
};
 
static WindowDesc _goals_list_desc(
  WDP_AUTO, "list_goals", 500, 127,
  WC_GOALS_LIST, WC_NONE,
  0,
  _nested_goals_list_widgets, lengthof(_nested_goals_list_widgets)
);
 
void ShowGoalsList(CompanyID company)
{
  if (!Company::IsValidID(company)) company = (CompanyID)INVALID_COMPANY;
 
  AllocateWindowDescFront<GoalListWindow>(&_goals_list_desc, company);
}
 
struct GoalQuestionWindow : public Window {
  char *question;     
  int buttons;        
  int button[3];      
  TextColour colour;  
 
  GoalQuestionWindow(WindowDesc *desc, WindowNumber window_number, TextColour colour, uint32 button_mask, const char *question) : Window(desc), colour(colour)
  {
    this->question = stredup(question);
 
    /* Figure out which buttons we have to enable. */
    int n = 0;
    for (uint bit : SetBitIterator(button_mask)) {
      if (bit >= GOAL_QUESTION_BUTTON_COUNT) break;
      this->button[n++] = bit;
      if (n == 3) break;
    }
    this->buttons = n;
    assert(this->buttons < 4);
 
    this->CreateNestedTree();
    if (this->buttons == 0) {
      this->GetWidget<NWidgetStacked>(WID_GQ_BUTTONS)->SetDisplayedPlane(SZSP_HORIZONTAL);
      this->GetWidget<NWidgetStacked>(WID_GQ_BUTTON_SPACER)->SetDisplayedPlane(SZSP_HORIZONTAL);
    } else {
      this->GetWidget<NWidgetStacked>(WID_GQ_BUTTONS)->SetDisplayedPlane(this->buttons - 1);
      this->GetWidget<NWidgetStacked>(WID_GQ_BUTTON_SPACER)->SetDisplayedPlane(0);
    }
    this->FinishInitNested(window_number);
  }
 
  ~GoalQuestionWindow()
  {
    free(this->question);
  }
 
  void SetStringParameters(int widget) const override
  {
    switch (widget) {
      case WID_GQ_BUTTON_1:
        SetDParam(0, STR_GOAL_QUESTION_BUTTON_CANCEL + this->button[0]);
        break;
 
      case WID_GQ_BUTTON_2:
        SetDParam(0, STR_GOAL_QUESTION_BUTTON_CANCEL + this->button[1]);
        break;
 
      case WID_GQ_BUTTON_3:
        SetDParam(0, STR_GOAL_QUESTION_BUTTON_CANCEL + this->button[2]);
        break;
    }
  }
 
  void OnClick(Point pt, int widget, int click_count) override
  {
    switch (widget) {
      case WID_GQ_BUTTON_1:
        Command<CMD_GOAL_QUESTION_ANSWER>::Post(this->window_number, this->button[0]);
        this->Close();
        break;
 
      case WID_GQ_BUTTON_2:
        Command<CMD_GOAL_QUESTION_ANSWER>::Post(this->window_number, this->button[1]);
        this->Close();
        break;
 
      case WID_GQ_BUTTON_3:
        Command<CMD_GOAL_QUESTION_ANSWER>::Post(this->window_number, this->button[2]);
        this->Close();
        break;
    }
  }
 
  void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
  {
    if (widget != WID_GQ_QUESTION) return;
 
    SetDParamStr(0, this->question);
    size->height = GetStringHeight(STR_JUST_RAW_STRING, size->width) + WD_PAR_VSEP_WIDE;
  }
 
  void DrawWidget(const Rect &r, int widget) const override
  {
    if (widget != WID_GQ_QUESTION) return;
 
    SetDParamStr(0, this->question);
    DrawStringMultiLine(r.left, r.right, r.top, UINT16_MAX, STR_JUST_RAW_STRING, this->colour, SA_TOP | SA_HOR_CENTER);
  }
};
 
static const NWidgetPart _nested_goal_question_widgets_question[] = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, COLOUR_LIGHT_BLUE),
    NWidget(WWT_CAPTION, COLOUR_LIGHT_BLUE, WID_GQ_CAPTION), SetDataTip(STR_GOAL_QUESTION_CAPTION_QUESTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
  EndContainer(),
  NWidget(WWT_PANEL, COLOUR_LIGHT_BLUE),
    NWidget(WWT_EMPTY, INVALID_COLOUR, WID_GQ_QUESTION), SetMinimalSize(300, 0), SetPadding(8, 8, 8, 8), SetFill(1, 0),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTONS),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(85, 10, 85),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(65, 10, 65),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_2), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(25, 10, 25),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_2), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_3), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
    EndContainer(),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTON_SPACER),
      NWidget(NWID_SPACER), SetMinimalSize(0, 8),
    EndContainer(),
  EndContainer(),
};
 
static const NWidgetPart _nested_goal_question_widgets_info[] = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, COLOUR_LIGHT_BLUE),
    NWidget(WWT_CAPTION, COLOUR_LIGHT_BLUE, WID_GQ_CAPTION), SetDataTip(STR_GOAL_QUESTION_CAPTION_INFORMATION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
  EndContainer(),
  NWidget(WWT_PANEL, COLOUR_LIGHT_BLUE),
    NWidget(WWT_EMPTY, INVALID_COLOUR, WID_GQ_QUESTION), SetMinimalSize(300, 0), SetPadding(8, 8, 8, 8), SetFill(1, 0),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTONS),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(85, 10, 85),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(65, 10, 65),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_2), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(25, 10, 25),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_2), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_GQ_BUTTON_3), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
    EndContainer(),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTON_SPACER),
      NWidget(NWID_SPACER), SetMinimalSize(0, 8),
    EndContainer(),
  EndContainer(),
};
 
static const NWidgetPart _nested_goal_question_widgets_warning[] = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, COLOUR_YELLOW),
    NWidget(WWT_CAPTION, COLOUR_YELLOW, WID_GQ_CAPTION), SetDataTip(STR_GOAL_QUESTION_CAPTION_WARNING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
  EndContainer(),
  NWidget(WWT_PANEL, COLOUR_YELLOW),
    NWidget(WWT_EMPTY, INVALID_COLOUR, WID_GQ_QUESTION), SetMinimalSize(300, 0), SetPadding(8, 8, 8, 8), SetFill(1, 0),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTONS),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(85, 10, 85),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(65, 10, 65),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_2), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(25, 10, 25),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_2), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_3), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
    EndContainer(),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTON_SPACER),
      NWidget(NWID_SPACER), SetMinimalSize(0, 8),
    EndContainer(),
  EndContainer(),
};
 
static const NWidgetPart _nested_goal_question_widgets_error[] = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, COLOUR_RED),
    NWidget(WWT_CAPTION, COLOUR_RED, WID_GQ_CAPTION), SetDataTip(STR_GOAL_QUESTION_CAPTION_ERROR, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
  EndContainer(),
  NWidget(WWT_PANEL, COLOUR_RED),
    NWidget(WWT_EMPTY, INVALID_COLOUR, WID_GQ_QUESTION), SetMinimalSize(300, 0), SetPadding(8, 8, 8, 8), SetFill(1, 0),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTONS),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(85, 10, 85),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(65, 10, 65),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_2), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
      NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(25, 10, 25),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_1), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_2), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
        NWidget(WWT_PUSHTXTBTN, COLOUR_YELLOW, WID_GQ_BUTTON_3), SetDataTip(STR_BLACK_STRING, STR_NULL), SetFill(1, 0),
      EndContainer(),
    EndContainer(),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTON_SPACER),
      NWidget(NWID_SPACER), SetMinimalSize(0, 8),
    EndContainer(),
  EndContainer(),
};
 
static WindowDesc _goal_question_list_desc[] = {
  {
    WDP_CENTER, nullptr, 0, 0,
    WC_GOAL_QUESTION, WC_NONE,
    WDF_CONSTRUCTION,
    _nested_goal_question_widgets_question, lengthof(_nested_goal_question_widgets_question),
  },
  {
    WDP_CENTER, nullptr, 0, 0,
    WC_GOAL_QUESTION, WC_NONE,
    WDF_CONSTRUCTION,
    _nested_goal_question_widgets_info, lengthof(_nested_goal_question_widgets_info),
  },
  {
    WDP_CENTER, nullptr, 0, 0,
    WC_GOAL_QUESTION, WC_NONE,
    WDF_CONSTRUCTION,
    _nested_goal_question_widgets_warning, lengthof(_nested_goal_question_widgets_warning),
  },
  {
    WDP_CENTER, nullptr, 0, 0,
    WC_GOAL_QUESTION, WC_NONE,
    WDF_CONSTRUCTION,
    _nested_goal_question_widgets_error, lengthof(_nested_goal_question_widgets_error),
  },
};
 
void ShowGoalQuestion(uint16 id, byte type, uint32 button_mask, const char *question)
{
  assert(type < GQT_END);
  new GoalQuestionWindow(&_goal_question_list_desc[type], id, type == 3 ? TC_WHITE : TC_BLACK, button_mask, question);
}