src/goal_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 goal_gui.cpp GUI for goals. */
   9
  10 #include "stdafx.h"
  11 #include "industry.h"
  12 #include "town.h"
  13 #include "window_gui.h"
  14 #include "strings_func.h"
  15 #include "viewport_func.h"
  16 #include "gui.h"
  17 #include "goal_base.h"
  18 #include "core/geometry_func.hpp"
  19 #include "company_func.h"
  20 #include "company_base.h"
  21 #include "company_gui.h"
  22 #include "story_base.h"
  23 #include "command_func.h"
  24 #include "string_func.h"
  25 #include "goal_cmd.h"
  26
  27 #include "widgets/goal_widget.h"
  28
  29 #include "table/strings.h"
  30
  31 #include "safeguards.h"
  32
  33 /** Goal list columns. */
  34 enum GoalColumn {
  35         GC_GOAL = 0, ///< Goal text column.
  36         GC_PROGRESS, ///< Goal progress column.
  37 };
  38
  39 /** Window for displaying goals. */
  40 struct GoalListWindow : public Window {
  41         Scrollbar *vscroll; ///< Reference to the scrollbar widget.
  42
  43         GoalListWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc)
  44         {
  45                 this->CreateNestedTree();
  46                 this->vscroll = this->GetScrollbar(WID_GOAL_SCROLLBAR);
  47                 this->FinishInitNested(window_number);
  48                 this->owner = (Owner)this->window_number;
  49                 NWidgetStacked *wi = this->GetWidget<NWidgetStacked>(WID_GOAL_SELECT_BUTTONS);
  50                 wi->SetDisplayedPlane(window_number == INVALID_COMPANY ? 1 : 0);
  51                 this->OnInvalidateData(0);
  52         }
  53
  54         void SetStringParameters(WidgetID widget) const override
  55         {
  56                 if (widget != WID_GOAL_CAPTION) return;
  57
  58                 if (this->window_number == INVALID_COMPANY) {
  59                         SetDParam(0, STR_GOALS_SPECTATOR_CAPTION);
  60                 } else {
  61                         SetDParam(0, STR_GOALS_CAPTION);
  62                         SetDParam(1, this->window_number);
  63                 }
  64         }
  65
  66         void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  67         {
  68                 switch (widget) {
  69                         case WID_GOAL_GLOBAL_BUTTON:
  70                                 ShowGoalsList(INVALID_COMPANY);
  71                                 break;
  72
  73                         case WID_GOAL_COMPANY_BUTTON:
  74                                 ShowGoalsList(_local_company);
  75                                 break;
  76
  77                         case WID_GOAL_LIST: {
  78                                 int y = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_GOAL_LIST, WidgetDimensions::scaled.framerect.top);
  79                                 for (const Goal *s : Goal::Iterate()) {
  80                                         if (s->company == this->window_number) {
  81                                                 if (y == 0) {
  82                                                         this->HandleClick(s);
  83                                                         return;
  84                                                 }
  85                                                 y--;
  86                                         }
  87                                 }
  88                                 break;
  89                         }
  90
  91                         default:
  92                                 break;
  93                 }
  94         }
  95
  96         /**
  97          * Handle clicking at a goal.
  98          * @param s #Goal clicked at.
  99          */
 100         void HandleClick(const Goal *s)
 101         {
 102                 /* Determine dst coordinate for goal and try to scroll to it. */
 103                 TileIndex xy;
 104                 switch (s->type) {
 105                         case GT_NONE: return;
 106
 107                         case GT_COMPANY:
 108                                 /* s->dst here is not a tile, but a CompanyID.
 109                                  * Show the window with the overview of the company instead. */
 110                                 ShowCompany((CompanyID)s->dst);
 111                                 return;
 112
 113                         case GT_TILE:
 114                                 if (!IsValidTile(s->dst)) return;
 115                                 xy = s->dst;
 116                                 break;
 117
 118                         case GT_INDUSTRY:
 119                                 if (!Industry::IsValidID(s->dst)) return;
 120                                 xy = Industry::Get(s->dst)->location.tile;
 121                                 break;
 122
 123                         case GT_TOWN:
 124                                 if (!Town::IsValidID(s->dst)) return;
 125                                 xy = Town::Get(s->dst)->xy;
 126                                 break;
 127
 128                         case GT_STORY_PAGE: {
 129                                 if (!StoryPage::IsValidID(s->dst)) return;
 130
 131                                 /* Verify that:
 132                                  * - if global goal: story page must be global.
 133                                  * - if company goal: story page must be global or of the same company.
 134                                  */
 135                                 CompanyID goal_company = s->company;
 136                                 CompanyID story_company = StoryPage::Get(s->dst)->company;
 137                                 if (goal_company == INVALID_COMPANY ? story_company != INVALID_COMPANY : story_company != INVALID_COMPANY && story_company != goal_company) return;
 138
 139                                 ShowStoryBook((CompanyID)this->window_number, s->dst);
 140                                 return;
 141                         }
 142
 143                         default: NOT_REACHED();
 144                 }
 145
 146                 if (_ctrl_pressed) {
 147                         ShowExtraViewportWindow(xy);
 148                 } else {
 149                         ScrollMainWindowToTile(xy);
 150                 }
 151         }
 152
 153         /**
 154          * Count the number of lines in this window.
 155          * @return the number of lines.
 156          */
 157         uint CountLines()
 158         {
 159                 /* Count number of (non) awarded goals. */
 160                 uint num = 0;
 161                 for (const Goal *s : Goal::Iterate()) {
 162                         if (s->company == this->window_number) num++;
 163                 }
 164
 165                 /* Count the 'none' lines. */
 166                 if (num == 0) num = 1;
 167
 168                 return num;
 169         }
 170
 171         void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
 172         {
 173                 if (widget != WID_GOAL_LIST) return;
 174                 Dimension d = GetStringBoundingBox(STR_GOALS_NONE);
 175
 176                 resize->width = 1;
 177                 resize->height = d.height;
 178
 179                 d.height *= 5;
 180                 d.width += WidgetDimensions::scaled.framerect.Horizontal();
 181                 d.height += WidgetDimensions::scaled.framerect.Vertical();
 182                 *size = maxdim(*size, d);
 183         }
 184
 185         /**
 186          * Draws a given column of the goal list.
 187          * @param column Which column to draw.
 188          * @param wid Pointer to the goal list widget.
 189          * @param progress_col_width Width of the progress column.
 190          * @return max width of drawn text
 191          */
 192         void DrawListColumn(GoalColumn column, NWidgetBase *wid, uint progress_col_width) const
 193         {
 194                 /* Get column draw area. */
 195                 Rect r = wid->GetCurrentRect().Shrink(WidgetDimensions::scaled.framerect);
 196                 bool rtl = _current_text_dir == TD_RTL;
 197
 198                 int pos = -this->vscroll->GetPosition();
 199                 const int cap = this->vscroll->GetCapacity();
 200
 201                 uint num = 0;
 202                 for (const Goal *s : Goal::Iterate()) {
 203                         if (s->company == this->window_number) {
 204                                 if (IsInsideMM(pos, 0, cap)) {
 205                                         switch (column) {
 206                                                 case GC_GOAL: {
 207                                                         /* Display the goal. */
 208                                                         SetDParamStr(0, s->text);
 209                                                         uint width_reduction = progress_col_width > 0 ? progress_col_width + WidgetDimensions::scaled.framerect.Horizontal() : 0;
 210                                                         DrawString(r.Indent(width_reduction, !rtl), STR_GOALS_TEXT);
 211                                                         break;
 212                                                 }
 213
 214                                                 case GC_PROGRESS:
 215                                                         if (!s->progress.empty()) {
 216                                                                 SetDParamStr(0, s->progress);
 217                                                                 StringID str = s->completed ? STR_GOALS_PROGRESS_COMPLETE : STR_GOALS_PROGRESS;
 218                                                                 DrawString(r.WithWidth(progress_col_width, !rtl), str, TC_FROMSTRING, SA_RIGHT | SA_FORCE);
 219                                                         }
 220                                                         break;
 221                                         }
 222                                         r.top += GetCharacterHeight(FS_NORMAL);
 223                                 }
 224                                 pos++;
 225                                 num++;
 226                         }
 227                 }
 228
 229                 if (num == 0) {
 230                         if (column == GC_GOAL && IsInsideMM(pos, 0, cap)) {
 231                                 DrawString(r, STR_GOALS_NONE);
 232                         }
 233                 }
 234         }
 235
 236         void OnPaint() override
 237         {
 238                 this->DrawWidgets();
 239
 240                 if (this->IsShaded()) return; // Don't draw anything when the window is shaded.
 241
 242                 /* Calculate progress column width. */
 243                 uint max_width = 0;
 244                 for (const Goal *s : Goal::Iterate()) {
 245                         if (!s->progress.empty()) {
 246                                 SetDParamStr(0, s->progress);
 247                                 StringID str = s->completed ? STR_GOALS_PROGRESS_COMPLETE : STR_GOALS_PROGRESS;
 248                                 uint str_width = GetStringBoundingBox(str).width;
 249                                 if (str_width > max_width) max_width = str_width;
 250                         }
 251                 }
 252
 253                 NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_GOAL_LIST);
 254                 uint progress_col_width = std::min(max_width, wid->current_x);
 255
 256                 /* Draw goal list. */
 257                 this->DrawListColumn(GC_PROGRESS, wid, progress_col_width);
 258                 this->DrawListColumn(GC_GOAL, wid, progress_col_width);
 259
 260         }
 261
 262         void OnResize() override
 263         {
 264                 this->vscroll->SetCapacityFromWidget(this, WID_GOAL_LIST, WidgetDimensions::scaled.framerect.Vertical());
 265         }
 266
 267         /**
 268          * Some data on this window has become invalid.
 269          * @param data Information about the changed data.
 270          * @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.
 271          */
 272         void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
 273         {
 274                 if (!gui_scope) return;
 275                 this->vscroll->SetCount(this->CountLines());
 276                 this->SetWidgetDisabledState(WID_GOAL_COMPANY_BUTTON, _local_company == COMPANY_SPECTATOR);
 277                 this->SetWidgetDirty(WID_GOAL_COMPANY_BUTTON);
 278                 this->SetWidgetDirty(WID_GOAL_LIST);
 279         }
 280 };
 281
 282 /** Widgets of the #GoalListWindow. */
 283 static constexpr NWidgetPart _nested_goals_list_widgets[] = {
 284         NWidget(NWID_HORIZONTAL),
 285                 NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
 286                 NWidget(WWT_CAPTION, COLOUR_BROWN, WID_GOAL_CAPTION), SetDataTip(STR_JUST_STRING1, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
 287                 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GOAL_SELECT_BUTTONS),
 288                         NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_GOAL_GLOBAL_BUTTON), SetMinimalSize(50, 0), SetDataTip(STR_GOALS_GLOBAL_BUTTON, STR_GOALS_GLOBAL_BUTTON_HELPTEXT),
 289                         NWidget(WWT_PUSHTXTBTN, COLOUR_BROWN, WID_GOAL_COMPANY_BUTTON), SetMinimalSize(50, 0), SetDataTip(STR_GOALS_COMPANY_BUTTON, STR_GOALS_COMPANY_BUTTON_HELPTEXT),
 290                 EndContainer(),
 291                 NWidget(WWT_SHADEBOX, COLOUR_BROWN),
 292                 NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
 293                 NWidget(WWT_STICKYBOX, COLOUR_BROWN),
 294         EndContainer(),
 295         NWidget(NWID_HORIZONTAL),
 296                 NWidget(WWT_PANEL, COLOUR_BROWN, WID_GOAL_LIST), SetDataTip(0x0, STR_GOALS_TOOLTIP_CLICK_ON_SERVICE_TO_CENTER), SetScrollbar(WID_GOAL_SCROLLBAR), SetResize(1, 1), SetMinimalTextLines(2, 0),
 297                 EndContainer(),
 298                 NWidget(NWID_VERTICAL),
 299                         NWidget(NWID_VSCROLLBAR, COLOUR_BROWN, WID_GOAL_SCROLLBAR),
 300                         NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
 301                 EndContainer(),
 302         EndContainer(),
 303 };
 304
 305 static WindowDesc _goals_list_desc(__FILE__, __LINE__,
 306         WDP_AUTO, "list_goals", 500, 127,
 307         WC_GOALS_LIST, WC_NONE,
 308         0,
 309         std::begin(_nested_goals_list_widgets), std::end(_nested_goals_list_widgets)
 310 );
 311
 312 /**
 313  * Open a goal list window.
 314  * @param company %Company to display the goals for, use #INVALID_COMPANY to display global goals.
 315  */
 316 void ShowGoalsList(CompanyID company)
 317 {
 318         if (!Company::IsValidID(company)) company = (CompanyID)INVALID_COMPANY;
 319
 320         AllocateWindowDescFront<GoalListWindow>(&_goals_list_desc, company);
 321 }
 322
 323 /** Ask a question about a goal. */
 324 struct GoalQuestionWindow : public Window {
 325         std::string question; ///< Question to ask (private copy).
 326         int buttons;          ///< Number of valid buttons in #button.
 327         int button[3];        ///< Buttons to display.
 328         TextColour colour;    ///< Colour of the question text.
 329
 330         GoalQuestionWindow(WindowDesc *desc, WindowNumber window_number, TextColour colour, uint32_t button_mask, const std::string &question) : Window(desc), colour(colour)
 331         {
 332                 this->question = question;
 333
 334                 /* Figure out which buttons we have to enable. */
 335                 int n = 0;
 336                 for (uint bit : SetBitIterator(button_mask)) {
 337                         if (bit >= GOAL_QUESTION_BUTTON_COUNT) break;
 338                         this->button[n++] = bit;
 339                         if (n == 3) break;
 340                 }
 341                 this->buttons = n;
 342                 assert(this->buttons < 4);
 343
 344                 this->CreateNestedTree();
 345                 if (this->buttons == 0) {
 346                         this->GetWidget<NWidgetStacked>(WID_GQ_BUTTONS)->SetDisplayedPlane(SZSP_HORIZONTAL);
 347                 } else {
 348                         this->GetWidget<NWidgetStacked>(WID_GQ_BUTTONS)->SetDisplayedPlane(this->buttons - 1);
 349                 }
 350                 this->FinishInitNested(window_number);
 351         }
 352
 353
 354         void SetStringParameters(WidgetID widget) const override
 355         {
 356                 switch (widget) {
 357                         case WID_GQ_BUTTON_1:
 358                                 SetDParam(0, STR_GOAL_QUESTION_BUTTON_CANCEL + this->button[0]);
 359                                 break;
 360
 361                         case WID_GQ_BUTTON_2:
 362                                 SetDParam(0, STR_GOAL_QUESTION_BUTTON_CANCEL + this->button[1]);
 363                                 break;
 364
 365                         case WID_GQ_BUTTON_3:
 366                                 SetDParam(0, STR_GOAL_QUESTION_BUTTON_CANCEL + this->button[2]);
 367                                 break;
 368                 }
 369         }
 370
 371         void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
 372         {
 373                 switch (widget) {
 374                         case WID_GQ_BUTTON_1:
 375                                 Command<CMD_GOAL_QUESTION_ANSWER>::Post(this->window_number, this->button[0]);
 376                                 this->Close();
 377                                 break;
 378
 379                         case WID_GQ_BUTTON_2:
 380                                 Command<CMD_GOAL_QUESTION_ANSWER>::Post(this->window_number, this->button[1]);
 381                                 this->Close();
 382                                 break;
 383
 384                         case WID_GQ_BUTTON_3:
 385                                 Command<CMD_GOAL_QUESTION_ANSWER>::Post(this->window_number, this->button[2]);
 386                                 this->Close();
 387                                 break;
 388                 }
 389         }
 390
 391         void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
 392         {
 393                 if (widget != WID_GQ_QUESTION) return;
 394
 395                 SetDParamStr(0, this->question);
 396                 size->height = GetStringHeight(STR_JUST_RAW_STRING, size->width);
 397         }
 398
 399         void DrawWidget(const Rect &r, WidgetID widget) const override
 400         {
 401                 if (widget != WID_GQ_QUESTION) return;
 402
 403                 SetDParamStr(0, this->question);
 404                 DrawStringMultiLine(r, STR_JUST_RAW_STRING, this->colour, SA_TOP | SA_HOR_CENTER);
 405         }
 406 };
 407
 408 /**
 409  * Widgets of the goal question window.
 410  * @tparam bg_colour Background colour.
 411  * @tparam btn_colour Button colour.
 412  * @tparam caption Window caption string.
 413  */
 414 template <Colours bg_colour, Colours btn_colour, StringID caption>
 415 struct NestedGoalWidgets {
 416         static constexpr auto widgetparts = {
 417                 NWidget(NWID_HORIZONTAL),
 418                         NWidget(WWT_CLOSEBOX, bg_colour),
 419                         NWidget(WWT_CAPTION, bg_colour, WID_GQ_CAPTION), SetDataTip(STR_GOAL_QUESTION_CAPTION_QUESTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
 420                 EndContainer(),
 421                 NWidget(WWT_PANEL, bg_colour),
 422                         NWidget(NWID_VERTICAL), SetPadding(WidgetDimensions::unscaled.modalpopup), SetPIP(0, WidgetDimensions::unscaled.vsep_wide, 0),
 423                                 NWidget(WWT_EMPTY, INVALID_COLOUR, WID_GQ_QUESTION), SetMinimalSize(300, 0), SetFill(1, 0),
 424                                 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_GQ_BUTTONS),
 425                                         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(85, WidgetDimensions::unscaled.hsep_wide, 85),
 426                                                 NWidget(WWT_PUSHTXTBTN, btn_colour, WID_GQ_BUTTON_1), SetDataTip(STR_JUST_STRING, STR_NULL), SetFill(1, 0),
 427                                         EndContainer(),
 428                                         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(65, WidgetDimensions::unscaled.hsep_wide, 65),
 429                                                 NWidget(WWT_PUSHTXTBTN, btn_colour, WID_GQ_BUTTON_1), SetDataTip(STR_JUST_STRING, STR_NULL), SetFill(1, 0),
 430                                                 NWidget(WWT_PUSHTXTBTN, btn_colour, WID_GQ_BUTTON_2), SetDataTip(STR_JUST_STRING, STR_NULL), SetFill(1, 0),
 431                                         EndContainer(),
 432                                         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(25, WidgetDimensions::unscaled.hsep_wide, 25),
 433                                                 NWidget(WWT_PUSHTXTBTN, btn_colour, WID_GQ_BUTTON_1), SetDataTip(STR_JUST_STRING, STR_NULL), SetFill(1, 0),
 434                                                 NWidget(WWT_PUSHTXTBTN, btn_colour, WID_GQ_BUTTON_2), SetDataTip(STR_JUST_STRING, STR_NULL), SetFill(1, 0),
 435                                                 NWidget(WWT_PUSHTXTBTN, btn_colour, WID_GQ_BUTTON_3), SetDataTip(STR_JUST_STRING, STR_NULL), SetFill(1, 0),
 436                                         EndContainer(),
 437                                 EndContainer(),
 438                         EndContainer(),
 439                 EndContainer(),
 440         };
 441 };
 442
 443 static constexpr auto _nested_goal_question_widgets_question = NestedGoalWidgets<COLOUR_LIGHT_BLUE, COLOUR_LIGHT_BLUE, STR_GOAL_QUESTION_CAPTION_QUESTION>::widgetparts;
 444 static constexpr auto _nested_goal_question_widgets_info     = NestedGoalWidgets<COLOUR_LIGHT_BLUE, COLOUR_LIGHT_BLUE, STR_GOAL_QUESTION_CAPTION_INFORMATION>::widgetparts;
 445 static constexpr auto _nested_goal_question_widgets_warning  = NestedGoalWidgets<COLOUR_YELLOW,     COLOUR_YELLOW,     STR_GOAL_QUESTION_CAPTION_WARNING>::widgetparts;
 446 static constexpr auto _nested_goal_question_widgets_error    = NestedGoalWidgets<COLOUR_RED,        COLOUR_YELLOW,     STR_GOAL_QUESTION_CAPTION_ERROR>::widgetparts;
 447
 448 static WindowDesc _goal_question_list_desc[] = {
 449         {
 450                 __FILE__, __LINE__,
 451                 WDP_CENTER, nullptr, 0, 0,
 452                 WC_GOAL_QUESTION, WC_NONE,
 453                 WDF_CONSTRUCTION,
 454                 std::begin(_nested_goal_question_widgets_question), std::end(_nested_goal_question_widgets_question),
 455         },
 456         {
 457                 __FILE__, __LINE__,
 458                 WDP_CENTER, nullptr, 0, 0,
 459                 WC_GOAL_QUESTION, WC_NONE,
 460                 WDF_CONSTRUCTION,
 461                 std::begin(_nested_goal_question_widgets_info), std::end(_nested_goal_question_widgets_info),
 462         },
 463         {
 464                 __FILE__, __LINE__,
 465                 WDP_CENTER, nullptr, 0, 0,
 466                 WC_GOAL_QUESTION, WC_NONE,
 467                 WDF_CONSTRUCTION,
 468                 std::begin(_nested_goal_question_widgets_warning), std::end(_nested_goal_question_widgets_warning),
 469         },
 470         {
 471                 __FILE__, __LINE__,
 472                 WDP_CENTER, nullptr, 0, 0,
 473                 WC_GOAL_QUESTION, WC_NONE,
 474                 WDF_CONSTRUCTION,
 475                 std::begin(_nested_goal_question_widgets_error), std::end(_nested_goal_question_widgets_error),
 476         },
 477 };
 478
 479 /**
 480  * Display a goal question.
 481  * @param id Window number to use.
 482  * @param type Type of question.
 483  * @param button_mask Buttons to display.
 484  * @param question Question to ask.
 485  */
 486 void ShowGoalQuestion(uint16_t id, byte type, uint32_t button_mask, const std::string &question)
 487 {
 488         assert(type < GQT_END);
 489         new GoalQuestionWindow(&_goal_question_list_desc[type], id, type == 3 ? TC_WHITE : TC_BLACK, button_mask, question);
 490 }