OpenTTD Source: src/industry_gui.cpp Source File

OpenTTD Source 14.1

industry_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 "error.h"
12 #include "gui.h"
13 #include "settings_gui.h"
14 #include "sound_func.h"
15 #include "window_func.h"
16 #include "textbuf_gui.h"
17 #include "command_func.h"
18 #include "viewport_func.h"
19 #include "industry.h"
20 #include "town.h"
21 #include "cheat_type.h"
22 #include "newgrf_industries.h"
23 #include "newgrf_text.h"
24 #include "newgrf_debug.h"
25 #include "network/network.h"
26 #include "strings_func.h"
27 #include "company_func.h"
28 #include "tilehighlight_func.h"
29 #include "string_func.h"
30 #include "sortlist_type.h"
31 #include "widgets/dropdown_func.h"
32 #include "company_base.h"
33 #include "core/geometry_func.hpp"
34 #include "core/random_func.hpp"
35 #include "core/backup_type.hpp"
36 #include "genworld.h"
37 #include "smallmap_gui.h"
38 #include "widgets/dropdown_type.h"
39 #include "widgets/industry_widget.h"
40 #include "clear_map.h"
41 #include "zoom_func.h"
42 #include "industry_cmd.h"
43 #include "querystring_gui.h"
44 #include "stringfilter_type.h"
45 #include "timer/timer.h"
46 #include "timer/timer_window.h"
47 #include "hotkeys.h"
48
49 #include "table/strings.h"
50
51 #include <bitset>
52
53 #include "safeguards.h"
54
55 bool _ignore_restrictions;
56 std::bitset<NUM_INDUSTRYTYPES> _displayed_industries;
57
59 enum CargoSuffixType {
60 CST_FUND,
61 CST_VIEW,
62 CST_DIR,
63 };
64
66 enum CargoSuffixDisplay {
67 CSD_CARGO,
68 CSD_CARGO_AMOUNT,
69 CSD_CARGO_TEXT,
70 CSD_CARGO_AMOUNT_TEXT,
71 };
72
74 struct CargoSuffix {
75 CargoSuffixDisplay display;
76 std::string text;
77 };
78
79 extern void GenerateIndustries();
80 static void ShowIndustryCargoesWindow(IndustryType id);
81
91 static void GetCargoSuffix(uint cargo, CargoSuffixType cst, const Industry *ind, IndustryType ind_type, const IndustrySpec *indspec, CargoSuffix &suffix)
92 {
93 suffix.text.clear();
94 suffix.display = CSD_CARGO_AMOUNT;
95
96 if (HasBit(indspec->callback_mask, CBM_IND_CARGO_SUFFIX)) {
97 TileIndex t = (cst != CST_FUND) ? ind->location.tile : INVALID_TILE;
98 uint16_t callback = GetIndustryCallback(CBID_INDUSTRY_CARGO_SUFFIX, 0, (cst << 8) | cargo, const_cast<Industry *>(ind), ind_type, t);
99 if (callback == CALLBACK_FAILED) return;
100
101 if (indspec->grf_prop.grffile->grf_version < 8) {
102 if (GB(callback, 0, 8) == 0xFF) return;
103 if (callback < 0x400) {
104 StartTextRefStackUsage(indspec->grf_prop.grffile, 6);
105 suffix.text = GetString(GetGRFStringID(indspec->grf_prop.grffile->grfid, 0xD000 + callback));
106 StopTextRefStackUsage();
107 suffix.display = CSD_CARGO_AMOUNT_TEXT;
108 return;
109 }
110 ErrorUnknownCallbackResult(indspec->grf_prop.grffile->grfid, CBID_INDUSTRY_CARGO_SUFFIX, callback);
111 return;
112
113 } else { // GRF version 8 or higher.
114 if (callback == 0x400) return;
115 if (callback == 0x401) {
116 suffix.display = CSD_CARGO;
117 return;
118 }
119 if (callback < 0x400) {
120 StartTextRefStackUsage(indspec->grf_prop.grffile, 6);
121 suffix.text = GetString(GetGRFStringID(indspec->grf_prop.grffile->grfid, 0xD000 + callback));
122 StopTextRefStackUsage();
123 suffix.display = CSD_CARGO_AMOUNT_TEXT;
124 return;
125 }
126 if (callback >= 0x800 && callback < 0xC00) {
127 StartTextRefStackUsage(indspec->grf_prop.grffile, 6);
128 suffix.text = GetString(GetGRFStringID(indspec->grf_prop.grffile->grfid, 0xD000 - 0x800 + callback));
129 StopTextRefStackUsage();
130 suffix.display = CSD_CARGO_TEXT;
131 return;
132 }
133 ErrorUnknownCallbackResult(indspec->grf_prop.grffile->grfid, CBID_INDUSTRY_CARGO_SUFFIX, callback);
134 return;
135 }
136 }
137 }
138
139 enum CargoSuffixInOut {
140 CARGOSUFFIX_OUT = 0,
141 CARGOSUFFIX_IN = 1,
142 };
143
154 template <typename TC, typename TS>
155 static inline void GetAllCargoSuffixes(CargoSuffixInOut use_input, CargoSuffixType cst, const Industry *ind, IndustryType ind_type, const IndustrySpec *indspec, const TC &cargoes, TS &suffixes)
156 {
157 static_assert(lengthof(cargoes) <= lengthof(suffixes));
158
159 if (indspec->behaviour & INDUSTRYBEH_CARGOTYPES_UNLIMITED) {
160 /* Reworked behaviour with new many-in-many-out scheme */
161 for (uint j = 0; j < lengthof(suffixes); j++) {
162 if (IsValidCargoID(cargoes[j])) {
163 byte local_id = indspec->grf_prop.grffile->cargo_map[cargoes[j]]; // should we check the value for valid?
164 uint cargotype = local_id << 16 | use_input;
165 GetCargoSuffix(cargotype, cst, ind, ind_type, indspec, suffixes[j]);
166 } else {
167 suffixes[j].text.clear();
168 suffixes[j].display = CSD_CARGO;
169 }
170 }
171 } else {
172 /* Compatible behaviour with old 3-in-2-out scheme */
173 for (uint j = 0; j < lengthof(suffixes); j++) {
174 suffixes[j].text.clear();
175 suffixes[j].display = CSD_CARGO;
176 }
177 switch (use_input) {
178 case CARGOSUFFIX_OUT:
179 if (IsValidCargoID(cargoes[0])) GetCargoSuffix(3, cst, ind, ind_type, indspec, suffixes[0]);
180 if (IsValidCargoID(cargoes[1])) GetCargoSuffix(4, cst, ind, ind_type, indspec, suffixes[1]);
181 break;
182 case CARGOSUFFIX_IN:
183 if (IsValidCargoID(cargoes[0])) GetCargoSuffix(0, cst, ind, ind_type, indspec, suffixes[0]);
184 if (IsValidCargoID(cargoes[1])) GetCargoSuffix(1, cst, ind, ind_type, indspec, suffixes[1]);
185 if (IsValidCargoID(cargoes[2])) GetCargoSuffix(2, cst, ind, ind_type, indspec, suffixes[2]);
186 break;
187 default:
188 NOT_REACHED();
189 }
190 }
191 }
192
204 void GetCargoSuffix(CargoSuffixInOut use_input, CargoSuffixType cst, const Industry *ind, IndustryType ind_type, const IndustrySpec *indspec, CargoID cargo, uint8_t slot, CargoSuffix &suffix)
205 {
206 suffix.text.clear();
207 suffix.display = CSD_CARGO;
208 if (!IsValidCargoID(cargo)) return;
209 if (indspec->behaviour & INDUSTRYBEH_CARGOTYPES_UNLIMITED) {
210 byte local_id = indspec->grf_prop.grffile->cargo_map[cargo]; // should we check the value for valid?
211 uint cargotype = local_id << 16 | use_input;
212 GetCargoSuffix(cargotype, cst, ind, ind_type, indspec, suffix);
213 } else if (use_input == CARGOSUFFIX_IN) {
214 if (slot < 3) GetCargoSuffix(slot, cst, ind, ind_type, indspec, suffix);
215 } else if (use_input == CARGOSUFFIX_OUT) {
216 if (slot < 2) GetCargoSuffix(slot + 3, cst, ind, ind_type, indspec, suffix);
217 }
218 }
219
220 std::array<IndustryType, NUM_INDUSTRYTYPES> _sorted_industry_types;
221
223 static bool IndustryTypeNameSorter(const IndustryType &a, const IndustryType &b)
224 {
225 int r = StrNaturalCompare(GetString(GetIndustrySpec(a)->name), GetString(GetIndustrySpec(b)->name)); // Sort by name (natural sorting).
226
227 /* If the names are equal, sort by industry type. */
228 return (r != 0) ? r < 0 : (a < b);
229 }
230
234 void SortIndustryTypes()
235 {
236 /* Add each industry type to the list. */
237 for (IndustryType i = 0; i < NUM_INDUSTRYTYPES; i++) {
238 _sorted_industry_types[i] = i;
239 }
240
241 /* Sort industry types by name. */
242 std::sort(_sorted_industry_types.begin(), _sorted_industry_types.end(), IndustryTypeNameSorter);
243 }
244
251 void CcBuildIndustry(Commands, const CommandCost &result, TileIndex tile, IndustryType indtype, uint32_t, bool, uint32_t)
252 {
253 if (result.Succeeded()) return;
254
255 if (indtype < NUM_INDUSTRYTYPES) {
256 const IndustrySpec *indsp = GetIndustrySpec(indtype);
257 if (indsp->enabled) {
258 SetDParam(0, indsp->name);
259 ShowErrorMessage(STR_ERROR_CAN_T_BUILD_HERE, result.GetErrorMessage(), WL_INFO, TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE);
260 }
261 }
262 }
263
264 static constexpr NWidgetPart _nested_build_industry_widgets[] = {
265 NWidget(NWID_HORIZONTAL),
266 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
267 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN), SetDataTip(STR_FUND_INDUSTRY_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
268 NWidget(WWT_SHADEBOX, COLOUR_DARK_GREEN),
269 NWidget(WWT_DEFSIZEBOX, COLOUR_DARK_GREEN),
270 NWidget(WWT_STICKYBOX, COLOUR_DARK_GREEN),
271 EndContainer(),
272 NWidget(NWID_SELECTION, COLOUR_DARK_GREEN, WID_DPI_SCENARIO_EDITOR_PANE),
273 NWidget(NWID_VERTICAL),
274 NWidget(WWT_TEXTBTN, COLOUR_DARK_GREEN, WID_DPI_CREATE_RANDOM_INDUSTRIES_WIDGET), SetMinimalSize(0, 12), SetFill(1, 0), SetResize(1, 0),
275 SetDataTip(STR_FUND_INDUSTRY_MANY_RANDOM_INDUSTRIES, STR_FUND_INDUSTRY_MANY_RANDOM_INDUSTRIES_TOOLTIP),
276 NWidget(WWT_TEXTBTN, COLOUR_DARK_GREEN, WID_DPI_REMOVE_ALL_INDUSTRIES_WIDGET), SetMinimalSize(0, 12), SetFill(1, 0), SetResize(1, 0),
277 SetDataTip(STR_FUND_INDUSTRY_REMOVE_ALL_INDUSTRIES, STR_FUND_INDUSTRY_REMOVE_ALL_INDUSTRIES_TOOLTIP),
278 EndContainer(),
279 EndContainer(),
280 NWidget(NWID_HORIZONTAL),
281 NWidget(WWT_MATRIX, COLOUR_DARK_GREEN, WID_DPI_MATRIX_WIDGET), SetMatrixDataTip(1, 0, STR_FUND_INDUSTRY_SELECTION_TOOLTIP), SetFill(1, 0), SetResize(1, 1), SetScrollbar(WID_DPI_SCROLLBAR),
282 NWidget(NWID_VSCROLLBAR, COLOUR_DARK_GREEN, WID_DPI_SCROLLBAR),
283 EndContainer(),
284 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_DPI_INFOPANEL), SetResize(1, 0),
285 EndContainer(),
286 NWidget(NWID_HORIZONTAL),
287 NWidget(WWT_TEXTBTN, COLOUR_DARK_GREEN, WID_DPI_DISPLAY_WIDGET), SetFill(1, 0), SetResize(1, 0),
288 SetDataTip(STR_INDUSTRY_DISPLAY_CHAIN, STR_INDUSTRY_DISPLAY_CHAIN_TOOLTIP),
289 NWidget(WWT_TEXTBTN, COLOUR_DARK_GREEN, WID_DPI_FUND_WIDGET), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_JUST_STRING, STR_NULL),
290 NWidget(WWT_RESIZEBOX, COLOUR_DARK_GREEN),
291 EndContainer(),
292 };
293
295 static WindowDesc _build_industry_desc(__FILE__, __LINE__,
296 WDP_AUTO, "build_industry", 170, 212,
297 WC_BUILD_INDUSTRY, WC_NONE,
298 WDF_CONSTRUCTION,
299 std::begin(_nested_build_industry_widgets), std::end(_nested_build_industry_widgets)
300 );
301
303 class BuildIndustryWindow : public Window {
304 IndustryType selected_type;
305 std::vector<IndustryType> list;
306 bool enabled;
307 Scrollbar *vscroll;
308 Dimension legend;
309
311 static const int MAX_MINWIDTH_LINEHEIGHTS = 20;
312
313 void UpdateAvailability()
314 {
315 this->enabled = this->selected_type != INVALID_INDUSTRYTYPE && (_game_mode == GM_EDITOR || GetIndustryProbabilityCallback(this->selected_type, IACT_USERCREATION, 1) > 0);
316 }
317
318 void SetupArrays()
319 {
320 this->list.clear();
321
322 /* Fill the arrays with industries.
323 * The tests performed after the enabled allow to load the industries
324 * In the same way they are inserted by grf (if any)
325 */
326 for (IndustryType ind : _sorted_industry_types) {
327 const IndustrySpec *indsp = GetIndustrySpec(ind);
328 if (indsp->enabled) {
329 /* Rule is that editor mode loads all industries.
330 * In game mode, all non raw industries are loaded too
331 * and raw ones are loaded only when setting allows it */
332 if (_game_mode != GM_EDITOR && indsp->IsRawIndustry() && _settings_game.construction.raw_industry_construction == 0) {
333 /* Unselect if the industry is no longer in the list */
334 if (this->selected_type == ind) this->selected_type = INVALID_INDUSTRYTYPE;
335 continue;
336 }
337
338 this->list.push_back(ind);
339 }
340 }
341
342 /* First industry type is selected if the current selection is invalid. */
343 if (this->selected_type == INVALID_INDUSTRYTYPE && !this->list.empty()) this->selected_type = this->list[0];
344
345 this->UpdateAvailability();
346
347 this->vscroll->SetCount(this->list.size());
348 }
349
351 void SetButtons()
352 {
353 this->SetWidgetDisabledState(WID_DPI_FUND_WIDGET, this->selected_type != INVALID_INDUSTRYTYPE && !this->enabled);
354 this->SetWidgetDisabledState(WID_DPI_DISPLAY_WIDGET, this->selected_type == INVALID_INDUSTRYTYPE && this->enabled);
355 }
356
369 std::string MakeCargoListString(const CargoID *cargolist, const CargoSuffix *cargo_suffix, int cargolistlen, StringID prefixstr) const
370 {
371 std::string cargostring;
372 int numcargo = 0;
373 int firstcargo = -1;
374
375 for (int j = 0; j < cargolistlen; j++) {
376 if (!IsValidCargoID(cargolist[j])) continue;
377 numcargo++;
378 if (firstcargo < 0) {
379 firstcargo = j;
380 continue;
381 }
382 SetDParam(0, CargoSpec::Get(cargolist[j])->name);
383 SetDParamStr(1, cargo_suffix[j].text);
384 cargostring += GetString(STR_INDUSTRY_VIEW_CARGO_LIST_EXTENSION);
385 }
386
387 if (numcargo > 0) {
388 SetDParam(0, CargoSpec::Get(cargolist[firstcargo])->name);
389 SetDParamStr(1, cargo_suffix[firstcargo].text);
390 cargostring = GetString(prefixstr) + cargostring;
391 } else {
392 SetDParam(0, STR_JUST_NOTHING);
393 SetDParamStr(1, "");
394 cargostring = GetString(prefixstr);
395 }
396
397 return cargostring;
398 }
399
400 public:
401 BuildIndustryWindow() : Window(&_build_industry_desc)
402 {
403 this->selected_type = INVALID_INDUSTRYTYPE;
404
405 this->CreateNestedTree();
406 this->vscroll = this->GetScrollbar(WID_DPI_SCROLLBAR);
407 /* Show scenario editor tools in editor. */
408 if (_game_mode != GM_EDITOR) {
409 this->GetWidget<NWidgetStacked>(WID_DPI_SCENARIO_EDITOR_PANE)->SetDisplayedPlane(SZSP_HORIZONTAL);
410 }
411 this->FinishInitNested(0);
412
413 this->SetButtons();
414 }
415
416 void OnInit() override
417 {
418 /* Width of the legend blob -- slightly larger than the smallmap legend blob. */
419 this->legend.height = GetCharacterHeight(FS_SMALL);
420 this->legend.width = this->legend.height * 9 / 6;
421
422 this->SetupArrays();
423 }
424
425 void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
426 {
427 switch (widget) {
428 case WID_DPI_MATRIX_WIDGET: {
429 Dimension d = GetStringBoundingBox(STR_FUND_INDUSTRY_MANY_RANDOM_INDUSTRIES);
430 for (const auto &indtype : this->list) {
431 d = maxdim(d, GetStringBoundingBox(GetIndustrySpec(indtype)->name));
432 }
433 resize->height = std::max<uint>(this->legend.height, GetCharacterHeight(FS_NORMAL)) + padding.height;
434 d.width += this->legend.width + WidgetDimensions::scaled.hsep_wide + padding.width;
435 d.height = 5 * resize->height;
436 *size = maxdim(*size, d);
437 break;
438 }
439
440 case WID_DPI_INFOPANEL: {
441 /* Extra line for cost outside of editor. */
442 int height = 2 + (_game_mode == GM_EDITOR ? 0 : 1);
443 uint extra_lines_req = 0;
444 uint extra_lines_prd = 0;
445 uint extra_lines_newgrf = 0;
446 uint max_minwidth = GetCharacterHeight(FS_NORMAL) * MAX_MINWIDTH_LINEHEIGHTS;
447 Dimension d = {0, 0};
448 for (const auto &indtype : this->list) {
449 const IndustrySpec *indsp = GetIndustrySpec(indtype);
450 CargoSuffix cargo_suffix[lengthof(indsp->accepts_cargo)];
451
452 /* Measure the accepted cargoes, if any. */
453 GetAllCargoSuffixes(CARGOSUFFIX_IN, CST_FUND, nullptr, indtype, indsp, indsp->accepts_cargo, cargo_suffix);
454 std::string cargostring = this->MakeCargoListString(indsp->accepts_cargo, cargo_suffix, lengthof(indsp->accepts_cargo), STR_INDUSTRY_VIEW_REQUIRES_N_CARGO);
455 Dimension strdim = GetStringBoundingBox(cargostring);
456 if (strdim.width > max_minwidth) {
457 extra_lines_req = std::max(extra_lines_req, strdim.width / max_minwidth + 1);
458 strdim.width = max_minwidth;
459 }
460 d = maxdim(d, strdim);
461
462 /* Measure the produced cargoes, if any. */
463 GetAllCargoSuffixes(CARGOSUFFIX_OUT, CST_FUND, nullptr, indtype, indsp, indsp->produced_cargo, cargo_suffix);
464 cargostring = this->MakeCargoListString(indsp->produced_cargo, cargo_suffix, lengthof(indsp->produced_cargo), STR_INDUSTRY_VIEW_PRODUCES_N_CARGO);
465 strdim = GetStringBoundingBox(cargostring);
466 if (strdim.width > max_minwidth) {
467 extra_lines_prd = std::max(extra_lines_prd, strdim.width / max_minwidth + 1);
468 strdim.width = max_minwidth;
469 }
470 d = maxdim(d, strdim);
471
472 if (indsp->grf_prop.grffile != nullptr) {
473 /* Reserve a few extra lines for text from an industry NewGRF. */
474 extra_lines_newgrf = 4;
475 }
476 }
477
478 /* Set it to something more sane :) */
479 height += extra_lines_prd + extra_lines_req + extra_lines_newgrf;
480 size->height = height * GetCharacterHeight(FS_NORMAL) + padding.height;
481 size->width = d.width + padding.width;
482 break;
483 }
484
485 case WID_DPI_FUND_WIDGET: {
486 Dimension d = GetStringBoundingBox(STR_FUND_INDUSTRY_BUILD_NEW_INDUSTRY);
487 d = maxdim(d, GetStringBoundingBox(STR_FUND_INDUSTRY_PROSPECT_NEW_INDUSTRY));
488 d = maxdim(d, GetStringBoundingBox(STR_FUND_INDUSTRY_FUND_NEW_INDUSTRY));
489 d.width += padding.width;
490 d.height += padding.height;
491 *size = maxdim(*size, d);
492 break;
493 }
494 }
495 }
496
497 void SetStringParameters(WidgetID widget) const override
498 {
499 switch (widget) {
500 case WID_DPI_FUND_WIDGET:
501 /* Raw industries might be prospected. Show this fact by changing the string
502 * In Editor, you just build, while ingame, or you fund or you prospect */
503 if (_game_mode == GM_EDITOR) {
504 /* We've chosen many random industries but no industries have been specified */
505 SetDParam(0, STR_FUND_INDUSTRY_BUILD_NEW_INDUSTRY);
506 } else {
507 if (this->selected_type != INVALID_INDUSTRYTYPE) {
508 const IndustrySpec *indsp = GetIndustrySpec(this->selected_type);
509 SetDParam(0, (_settings_game.construction.raw_industry_construction == 2 && indsp->IsRawIndustry()) ? STR_FUND_INDUSTRY_PROSPECT_NEW_INDUSTRY : STR_FUND_INDUSTRY_FUND_NEW_INDUSTRY);
510 } else {
511 SetDParam(0, STR_FUND_INDUSTRY_FUND_NEW_INDUSTRY);
512 }
513 }
514 break;
515 }
516 }
517
518 void DrawWidget(const Rect &r, WidgetID widget) const override
519 {
520 switch (widget) {
521 case WID_DPI_MATRIX_WIDGET: {
522 bool rtl = _current_text_dir == TD_RTL;
523 Rect text = r.WithHeight(this->resize.step_height).Shrink(WidgetDimensions::scaled.matrix);
524 Rect icon = text.WithWidth(this->legend.width, rtl);
525 text = text.Indent(this->legend.width + WidgetDimensions::scaled.hsep_wide, rtl);
526
527 /* Vertical offset for legend icon. */
528 icon.top = r.top + (this->resize.step_height - this->legend.height + 1) / 2;
529 icon.bottom = icon.top + this->legend.height - 1;
530
531 for (uint16_t i = this->vscroll->GetPosition(); this->vscroll->IsVisible(i) && i < this->vscroll->GetCount(); i++) {
532 IndustryType type = this->list[i];
533 bool selected = this->selected_type == type;
534 const IndustrySpec *indsp = GetIndustrySpec(type);
535
536 /* Draw the name of the industry in white is selected, otherwise, in orange */
537 DrawString(text, indsp->name, selected ? TC_WHITE : TC_ORANGE);
538 GfxFillRect(icon, selected ? PC_WHITE : PC_BLACK);
539 GfxFillRect(icon.Shrink(WidgetDimensions::scaled.bevel), indsp->map_colour);
540 SetDParam(0, Industry::GetIndustryTypeCount(type));
541 DrawString(text, STR_JUST_COMMA, TC_BLACK, SA_RIGHT, false, FS_SMALL);
542
543 text = text.Translate(0, this->resize.step_height);
544 icon = icon.Translate(0, this->resize.step_height);
545 }
546 break;
547 }
548
549 case WID_DPI_INFOPANEL: {
550 Rect ir = r.Shrink(WidgetDimensions::scaled.framerect);
551
552 if (this->selected_type == INVALID_INDUSTRYTYPE) {
553 DrawStringMultiLine(ir, STR_FUND_INDUSTRY_MANY_RANDOM_INDUSTRIES_TOOLTIP);
554 break;
555 }
556
557 const IndustrySpec *indsp = GetIndustrySpec(this->selected_type);
558
559 if (_game_mode != GM_EDITOR) {
560 SetDParam(0, indsp->GetConstructionCost());
561 DrawString(ir, STR_FUND_INDUSTRY_INDUSTRY_BUILD_COST);
562 ir.top += GetCharacterHeight(FS_NORMAL);
563 }
564
565 CargoSuffix cargo_suffix[lengthof(indsp->accepts_cargo)];
566
567 /* Draw the accepted cargoes, if any. Otherwise, will print "Nothing". */
568 GetAllCargoSuffixes(CARGOSUFFIX_IN, CST_FUND, nullptr, this->selected_type, indsp, indsp->accepts_cargo, cargo_suffix);
569 std::string cargostring = this->MakeCargoListString(indsp->accepts_cargo, cargo_suffix, lengthof(indsp->accepts_cargo), STR_INDUSTRY_VIEW_REQUIRES_N_CARGO);
570 ir.top = DrawStringMultiLine(ir, cargostring);
571
572 /* Draw the produced cargoes, if any. Otherwise, will print "Nothing". */
573 GetAllCargoSuffixes(CARGOSUFFIX_OUT, CST_FUND, nullptr, this->selected_type, indsp, indsp->produced_cargo, cargo_suffix);
574 cargostring = this->MakeCargoListString(indsp->produced_cargo, cargo_suffix, lengthof(indsp->produced_cargo), STR_INDUSTRY_VIEW_PRODUCES_N_CARGO);
575 ir.top = DrawStringMultiLine(ir, cargostring);
576
577 /* Get the additional purchase info text, if it has not already been queried. */
578 if (HasBit(indsp->callback_mask, CBM_IND_FUND_MORE_TEXT)) {
579 uint16_t callback_res = GetIndustryCallback(CBID_INDUSTRY_FUND_MORE_TEXT, 0, 0, nullptr, this->selected_type, INVALID_TILE);
580 if (callback_res != CALLBACK_FAILED && callback_res != 0x400) {
581 if (callback_res > 0x400) {
582 ErrorUnknownCallbackResult(indsp->grf_prop.grffile->grfid, CBID_INDUSTRY_FUND_MORE_TEXT, callback_res);
583 } else {
584 StringID str = GetGRFStringID(indsp->grf_prop.grffile->grfid, 0xD000 + callback_res); // No. here's the new string
585 if (str != STR_UNDEFINED) {
586 StartTextRefStackUsage(indsp->grf_prop.grffile, 6);
587 DrawStringMultiLine(ir, str, TC_YELLOW);
588 StopTextRefStackUsage();
589 }
590 }
591 }
592 }
593 break;
594 }
595 }
596 }
597
598 static void AskManyRandomIndustriesCallback(Window *, bool confirmed)
599 {
600 if (!confirmed) return;
601
602 if (Town::GetNumItems() == 0) {
603 ShowErrorMessage(STR_ERROR_CAN_T_GENERATE_INDUSTRIES, STR_ERROR_MUST_FOUND_TOWN_FIRST, WL_INFO);
604 } else {
605 Backup<bool> old_generating_world(_generating_world, true, FILE_LINE);
606 BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP);
607 GenerateIndustries();
608 BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP);
609 old_generating_world.Restore();
610 }
611 }
612
613 static void AskRemoveAllIndustriesCallback(Window *, bool confirmed)
614 {
615 if (!confirmed) return;
616
617 for (Industry *industry : Industry::Iterate()) delete industry;
618
619 /* Clear farmland. */
620 for (TileIndex tile = 0; tile < Map::Size(); tile++) {
621 if (IsTileType(tile, MP_CLEAR) && GetRawClearGround(tile) == CLEAR_FIELDS) {
622 MakeClear(tile, CLEAR_GRASS, 3);
623 }
624 }
625
626 MarkWholeScreenDirty();
627 }
628
629 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
630 {
631 switch (widget) {
632 case WID_DPI_CREATE_RANDOM_INDUSTRIES_WIDGET: {
633 assert(_game_mode == GM_EDITOR);
634 this->HandleButtonClick(WID_DPI_CREATE_RANDOM_INDUSTRIES_WIDGET);
635 ShowQuery(STR_FUND_INDUSTRY_MANY_RANDOM_INDUSTRIES_CAPTION, STR_FUND_INDUSTRY_MANY_RANDOM_INDUSTRIES_QUERY, nullptr, AskManyRandomIndustriesCallback);
636 break;
637 }
638
639 case WID_DPI_REMOVE_ALL_INDUSTRIES_WIDGET: {
640 assert(_game_mode == GM_EDITOR);
641 this->HandleButtonClick(WID_DPI_REMOVE_ALL_INDUSTRIES_WIDGET);
642 ShowQuery(STR_FUND_INDUSTRY_REMOVE_ALL_INDUSTRIES_CAPTION, STR_FUND_INDUSTRY_REMOVE_ALL_INDUSTRIES_QUERY, nullptr, AskRemoveAllIndustriesCallback);
643 break;
644 }
645
646 case WID_DPI_MATRIX_WIDGET: {
647 auto it = this->vscroll->GetScrolledItemFromWidget(this->list, pt.y, this, WID_DPI_MATRIX_WIDGET);
648 if (it != this->list.end()) { // Is it within the boundaries of available data?
649 this->selected_type = *it;
650 this->UpdateAvailability();
651
652 const IndustrySpec *indsp = GetIndustrySpec(this->selected_type);
653
654 this->SetDirty();
655
656 if (_thd.GetCallbackWnd() == this &&
657 ((_game_mode != GM_EDITOR && _settings_game.construction.raw_industry_construction == 2 && indsp != nullptr && indsp->IsRawIndustry()) || !this->enabled)) {
658 /* Reset the button state if going to prospecting or "build many industries" */
659 this->RaiseButtons();
660 ResetObjectToPlace();
661 }
662
663 this->SetButtons();
664 if (this->enabled && click_count > 1) this->OnClick(pt, WID_DPI_FUND_WIDGET, 1);
665 }
666 break;
667 }
668
669 case WID_DPI_DISPLAY_WIDGET:
670 if (this->selected_type != INVALID_INDUSTRYTYPE) ShowIndustryCargoesWindow(this->selected_type);
671 break;
672
673 case WID_DPI_FUND_WIDGET: {
674 if (this->selected_type != INVALID_INDUSTRYTYPE) {
675 if (_game_mode != GM_EDITOR && _settings_game.construction.raw_industry_construction == 2 && GetIndustrySpec(this->selected_type)->IsRawIndustry()) {
676 Command<CMD_BUILD_INDUSTRY>::Post(STR_ERROR_CAN_T_CONSTRUCT_THIS_INDUSTRY, 0, this->selected_type, 0, false, InteractiveRandom());
677 this->HandleButtonClick(WID_DPI_FUND_WIDGET);
678 } else {
679 HandlePlacePushButton(this, WID_DPI_FUND_WIDGET, SPR_CURSOR_INDUSTRY, HT_RECT);
680 }
681 }
682 break;
683 }
684 }
685 }
686
687 void OnResize() override
688 {
689 /* Adjust the number of items in the matrix depending of the resize */
690 this->vscroll->SetCapacityFromWidget(this, WID_DPI_MATRIX_WIDGET);
691 }
692
693 void OnPlaceObject([[maybe_unused]] Point pt, TileIndex tile) override
694 {
695 bool success = true;
696 /* We do not need to protect ourselves against "Random Many Industries" in this mode */
697 const IndustrySpec *indsp = GetIndustrySpec(this->selected_type);
698 uint32_t seed = InteractiveRandom();
699 uint32_t layout_index = InteractiveRandomRange((uint32_t)indsp->layouts.size());
700
701 if (_game_mode == GM_EDITOR) {
702 /* Show error if no town exists at all */
703 if (Town::GetNumItems() == 0) {
704 SetDParam(0, indsp->name);
705 ShowErrorMessage(STR_ERROR_CAN_T_BUILD_HERE, STR_ERROR_MUST_FOUND_TOWN_FIRST, WL_INFO, pt.x, pt.y);
706 return;
707 }
708
709 Backup<CompanyID> cur_company(_current_company, OWNER_NONE, FILE_LINE);
710 Backup<bool> old_generating_world(_generating_world, true, FILE_LINE);
711 _ignore_restrictions = true;
712
713 Command<CMD_BUILD_INDUSTRY>::Post(STR_ERROR_CAN_T_CONSTRUCT_THIS_INDUSTRY, &CcBuildIndustry, tile, this->selected_type, layout_index, false, seed);
714
715 cur_company.Restore();
716 old_generating_world.Restore();
717 _ignore_restrictions = false;
718 } else {
719 success = Command<CMD_BUILD_INDUSTRY>::Post(STR_ERROR_CAN_T_CONSTRUCT_THIS_INDUSTRY, tile, this->selected_type, layout_index, false, seed);
720 }
721
722 /* If an industry has been built, just reset the cursor and the system */
723 if (success && !_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
724 }
725
726 IntervalTimer<TimerWindow> update_interval = {std::chrono::seconds(3), [this](auto) {
727 if (_game_mode == GM_EDITOR) return;
728 if (this->selected_type == INVALID_INDUSTRYTYPE) return;
729
730 bool enabled = this->enabled;
731 this->UpdateAvailability();
732 if (enabled != this->enabled) {
733 this->SetButtons();
734 this->SetDirty();
735 }
736 }};
737
738 void OnTimeout() override
739 {
740 this->RaiseButtons();
741 }
742
743 void OnPlaceObjectAbort() override
744 {
745 this->RaiseButtons();
746 }
747
753 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
754 {
755 if (!gui_scope) return;
756 this->SetupArrays();
757 this->SetButtons();
758 this->SetDirty();
759 }
760 };
761
762 void ShowBuildIndustryWindow()
763 {
764 if (_game_mode != GM_EDITOR && !Company::IsValidID(_local_company)) return;
765 if (BringWindowToFrontById(WC_BUILD_INDUSTRY, 0)) return;
766 new BuildIndustryWindow();
767 }
768
769 static void UpdateIndustryProduction(Industry *i);
770
771 static inline bool IsProductionAlterable(const Industry *i)
772 {
773 const IndustrySpec *is = GetIndustrySpec(i->type);
774 bool has_prod = false;
775 for (size_t j = 0; j < lengthof(is->production_rate); j++) {
776 if (is->production_rate[j] != 0) {
777 has_prod = true;
778 break;
779 }
780 }
781 return ((_game_mode == GM_EDITOR || _cheats.setup_prod.value) &&
782 (has_prod || is->IsRawIndustry()) &&
783 !_networking);
784 }
785
786 class IndustryViewWindow : public Window
787 {
789 enum Editability {
790 EA_NONE,
791 EA_MULTIPLIER,
792 EA_RATE,
793 };
794
796 enum InfoLine {
797 IL_NONE,
798 IL_MULTIPLIER,
799 IL_RATE1,
800 IL_RATE2,
801 };
802
803 Dimension cargo_icon_size;
804 Editability editable;
805 InfoLine editbox_line;
806 InfoLine clicked_line;
807 byte clicked_button;
808 int production_offset_y;
809 int info_height;
810 int cheat_line_height;
811
812 public:
813 IndustryViewWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc)
814 {
815 this->flags |= WF_DISABLE_VP_SCROLL;
816 this->editbox_line = IL_NONE;
817 this->clicked_line = IL_NONE;
818 this->clicked_button = 0;
819 this->info_height = WidgetDimensions::scaled.framerect.Vertical() + 2 * GetCharacterHeight(FS_NORMAL); // Info panel has at least two lines text.
820
821 this->InitNested(window_number);
822 NWidgetViewport *nvp = this->GetWidget<NWidgetViewport>(WID_IV_VIEWPORT);
823 nvp->InitializeViewport(this, Industry::Get(window_number)->location.GetCenterTile(), ScaleZoomGUI(ZOOM_LVL_INDUSTRY));
824
825 this->InvalidateData();
826 }
827
828 void OnInit() override
829 {
830 /* This only used when the cheat to alter industry production is enabled */
831 this->cheat_line_height = std::max(SETTING_BUTTON_HEIGHT + WidgetDimensions::scaled.vsep_normal, GetCharacterHeight(FS_NORMAL));
832 this->cargo_icon_size = GetLargestCargoIconSize();
833 }
834
835 void OnPaint() override
836 {
837 this->DrawWidgets();
838
839 if (this->IsShaded()) return; // Don't draw anything when the window is shaded.
840
841 const Rect r = this->GetWidget<NWidgetBase>(WID_IV_INFO)->GetCurrentRect();
842 int expected = this->DrawInfo(r);
843 if (expected != r.bottom) {
844 this->info_height = expected - r.top + 1;
845 this->ReInit();
846 return;
847 }
848 }
849
850 void DrawCargoIcon(const Rect &r, CargoID cid) const
851 {
852 bool rtl = _current_text_dir == TD_RTL;
853 SpriteID icon = CargoSpec::Get(cid)->GetCargoIcon();
854 Dimension d = GetSpriteSize(icon);
855 Rect ir = r.WithWidth(this->cargo_icon_size.width, rtl).WithHeight(GetCharacterHeight(FS_NORMAL));
856 DrawSprite(icon, PAL_NONE, CenterBounds(ir.left, ir.right, d.width), CenterBounds(ir.top, ir.bottom, this->cargo_icon_size.height));
857 }
858
864 int DrawInfo(const Rect &r)
865 {
866 bool rtl = _current_text_dir == TD_RTL;
867 Industry *i = Industry::Get(this->window_number);
868 const IndustrySpec *ind = GetIndustrySpec(i->type);
869 Rect ir = r.Shrink(WidgetDimensions::scaled.framerect);
870 bool first = true;
871 bool has_accept = false;
872
873 if (i->prod_level == PRODLEVEL_CLOSURE) {
874 DrawString(ir, STR_INDUSTRY_VIEW_INDUSTRY_ANNOUNCED_CLOSURE);
875 ir.top += GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.vsep_wide;
876 }
877
878 const int label_indent = WidgetDimensions::scaled.hsep_normal + this->cargo_icon_size.width;
879 bool stockpiling = HasBit(ind->callback_mask, CBM_IND_PRODUCTION_CARGO_ARRIVAL) || HasBit(ind->callback_mask, CBM_IND_PRODUCTION_256_TICKS);
880
881 for (const auto &a : i->accepted) {
882 if (!IsValidCargoID(a.cargo)) continue;
883 has_accept = true;
884 if (first) {
885 DrawString(ir, STR_INDUSTRY_VIEW_REQUIRES);
886 ir.top += GetCharacterHeight(FS_NORMAL);
887 first = false;
888 }
889
890 DrawCargoIcon(ir, a.cargo);
891
892 CargoSuffix suffix;
893 GetCargoSuffix(CARGOSUFFIX_IN, CST_VIEW, i, i->type, ind, a.cargo, &a - i->accepted.data(), suffix);
894
895 SetDParam(0, CargoSpec::Get(a.cargo)->name);
896 SetDParam(1, a.cargo);
897 SetDParam(2, a.waiting);
898 SetDParamStr(3, "");
899 StringID str = STR_NULL;
900 switch (suffix.display) {
901 case CSD_CARGO_AMOUNT_TEXT:
902 SetDParamStr(3, suffix.text);
903 [[fallthrough]];
904 case CSD_CARGO_AMOUNT:
905 str = stockpiling ? STR_INDUSTRY_VIEW_ACCEPT_CARGO_AMOUNT : STR_INDUSTRY_VIEW_ACCEPT_CARGO;
906 break;
907
908 case CSD_CARGO_TEXT:
909 SetDParamStr(3, suffix.text);
910 [[fallthrough]];
911 case CSD_CARGO:
912 str = STR_INDUSTRY_VIEW_ACCEPT_CARGO;
913 break;
914
915 default:
916 NOT_REACHED();
917 }
918 DrawString(ir.Indent(label_indent, rtl), str);
919 ir.top += GetCharacterHeight(FS_NORMAL);
920 }
921
922 int line_height = this->editable == EA_RATE ? this->cheat_line_height : GetCharacterHeight(FS_NORMAL);
923 int text_y_offset = (line_height - GetCharacterHeight(FS_NORMAL)) / 2;
924 int button_y_offset = (line_height - SETTING_BUTTON_HEIGHT) / 2;
925 first = true;
926 for (const auto &p : i->produced) {
927 if (!IsValidCargoID(p.cargo)) continue;
928 if (first) {
929 if (has_accept) ir.top += WidgetDimensions::scaled.vsep_wide;
930 DrawString(ir, TimerGameEconomy::UsingWallclockUnits() ? STR_INDUSTRY_VIEW_PRODUCTION_LAST_MINUTE_TITLE : STR_INDUSTRY_VIEW_PRODUCTION_LAST_MONTH_TITLE);
931 ir.top += GetCharacterHeight(FS_NORMAL);
932 if (this->editable == EA_RATE) this->production_offset_y = ir.top;
933 first = false;
934 }
935
936 DrawCargoIcon(ir, p.cargo);
937
938 CargoSuffix suffix;
939 GetCargoSuffix(CARGOSUFFIX_OUT, CST_VIEW, i, i->type, ind, p.cargo, &p - i->produced.data(), suffix);
940
941 SetDParam(0, p.cargo);
942 SetDParam(1, p.history[LAST_MONTH].production);
943 SetDParamStr(2, suffix.text);
944 SetDParam(3, ToPercent8(p.history[LAST_MONTH].PctTransported()));
945 DrawString(ir.Indent(label_indent + (this->editable == EA_RATE ? SETTING_BUTTON_WIDTH + WidgetDimensions::scaled.hsep_normal : 0), rtl).Translate(0, text_y_offset), STR_INDUSTRY_VIEW_TRANSPORTED);
946 /* Let's put out those buttons.. */
947 if (this->editable == EA_RATE) {
948 DrawArrowButtons(ir.Indent(label_indent, rtl).WithWidth(SETTING_BUTTON_WIDTH, rtl).left, ir.top + button_y_offset, COLOUR_YELLOW, (this->clicked_line == IL_RATE1 + (&p - i->produced.data())) ? this->clicked_button : 0,
949 p.rate > 0, p.rate < 255);
950 }
951 ir.top += line_height;
952 }
953
954 /* Display production multiplier if editable */
955 if (this->editable == EA_MULTIPLIER) {
956 line_height = this->cheat_line_height;
957 text_y_offset = (line_height - GetCharacterHeight(FS_NORMAL)) / 2;
958 button_y_offset = (line_height - SETTING_BUTTON_HEIGHT) / 2;
959 ir.top += WidgetDimensions::scaled.vsep_wide;
960 this->production_offset_y = ir.top;
961 SetDParam(0, RoundDivSU(i->prod_level * 100, PRODLEVEL_DEFAULT));
962 DrawString(ir.Indent(label_indent + SETTING_BUTTON_WIDTH + WidgetDimensions::scaled.hsep_normal, rtl).Translate(0, text_y_offset), STR_INDUSTRY_VIEW_PRODUCTION_LEVEL);
963 DrawArrowButtons(ir.Indent(label_indent, rtl).WithWidth(SETTING_BUTTON_WIDTH, rtl).left, ir.top + button_y_offset, COLOUR_YELLOW, (this->clicked_line == IL_MULTIPLIER) ? this->clicked_button : 0,
964 i->prod_level > PRODLEVEL_MINIMUM, i->prod_level < PRODLEVEL_MAXIMUM);
965 ir.top += line_height;
966 }
967
968 /* Get the extra message for the GUI */
969 if (HasBit(ind->callback_mask, CBM_IND_WINDOW_MORE_TEXT)) {
970 uint16_t callback_res = GetIndustryCallback(CBID_INDUSTRY_WINDOW_MORE_TEXT, 0, 0, i, i->type, i->location.tile);
971 if (callback_res != CALLBACK_FAILED && callback_res != 0x400) {
972 if (callback_res > 0x400) {
973 ErrorUnknownCallbackResult(ind->grf_prop.grffile->grfid, CBID_INDUSTRY_WINDOW_MORE_TEXT, callback_res);
974 } else {
975 StringID message = GetGRFStringID(ind->grf_prop.grffile->grfid, 0xD000 + callback_res);
976 if (message != STR_NULL && message != STR_UNDEFINED) {
977 ir.top += WidgetDimensions::scaled.vsep_wide;
978
979 StartTextRefStackUsage(ind->grf_prop.grffile, 6);
980 /* Use all the available space left from where we stand up to the
981 * end of the window. We ALSO enlarge the window if needed, so we
982 * can 'go' wild with the bottom of the window. */
983 ir.top = DrawStringMultiLine(ir.left, ir.right, ir.top, UINT16_MAX, message, TC_BLACK);
984 StopTextRefStackUsage();
985 }
986 }
987 }
988 }
989
990 if (!i->text.empty()) {
991 SetDParamStr(0, i->text);
992 ir.top += WidgetDimensions::scaled.vsep_wide;
993 ir.top = DrawStringMultiLine(ir.left, ir.right, ir.top, UINT16_MAX, STR_JUST_RAW_STRING, TC_BLACK);
994 }
995
996 /* Return required bottom position, the last pixel row plus some padding. */
997 return ir.top - 1 + WidgetDimensions::scaled.framerect.bottom;
998 }
999
1000 void SetStringParameters(WidgetID widget) const override
1001 {
1002 if (widget == WID_IV_CAPTION) SetDParam(0, this->window_number);
1003 }
1004
1005 void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
1006 {
1007 if (widget == WID_IV_INFO) size->height = this->info_height;
1008 }
1009
1010 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
1011 {
1012 switch (widget) {
1013 case WID_IV_INFO: {
1014 Industry *i = Industry::Get(this->window_number);
1015 InfoLine line = IL_NONE;
1016
1017 switch (this->editable) {
1018 case EA_NONE: break;
1019
1020 case EA_MULTIPLIER:
1021 if (IsInsideBS(pt.y, this->production_offset_y, this->cheat_line_height)) line = IL_MULTIPLIER;
1022 break;
1023
1024 case EA_RATE:
1025 if (pt.y >= this->production_offset_y) {
1026 int row = (pt.y - this->production_offset_y) / this->cheat_line_height;
1027 for (auto itp = std::begin(i->produced); itp != std::end(i->produced); ++itp) {
1028 if (!IsValidCargoID(itp->cargo)) continue;
1029 row--;
1030 if (row < 0) {
1031 line = (InfoLine)(IL_RATE1 + (itp - std::begin(i->produced)));
1032 break;
1033 }
1034 }
1035 }
1036 break;
1037 }
1038 if (line == IL_NONE) return;
1039
1040 bool rtl = _current_text_dir == TD_RTL;
1041 Rect r = this->GetWidget<NWidgetBase>(widget)->GetCurrentRect().Shrink(WidgetDimensions::scaled.framerect).Indent(this->cargo_icon_size.width + WidgetDimensions::scaled.hsep_normal, rtl);
1042
1043 if (r.WithWidth(SETTING_BUTTON_WIDTH, rtl).Contains(pt)) {
1044 /* Clicked buttons, decrease or increase production */
1045 bool decrease = r.WithWidth(SETTING_BUTTON_WIDTH / 2, rtl).Contains(pt);
1046 switch (this->editable) {
1047 case EA_MULTIPLIER:
1048 if (decrease) {
1049 if (i->prod_level <= PRODLEVEL_MINIMUM) return;
1050 i->prod_level = static_cast<byte>(std::max<uint>(i->prod_level / 2, PRODLEVEL_MINIMUM));
1051 } else {
1052 if (i->prod_level >= PRODLEVEL_MAXIMUM) return;
1053 i->prod_level = static_cast<byte>(std::min<uint>(i->prod_level * 2, PRODLEVEL_MAXIMUM));
1054 }
1055 break;
1056
1057 case EA_RATE:
1058 if (decrease) {
1059 if (i->produced[line - IL_RATE1].rate <= 0) return;
1060 i->produced[line - IL_RATE1].rate = std::max(i->produced[line - IL_RATE1].rate / 2, 0);
1061 } else {
1062 if (i->produced[line - IL_RATE1].rate >= 255) return;
1063 /* a zero production industry is unlikely to give anything but zero, so push it a little bit */
1064 int new_prod = i->produced[line - IL_RATE1].rate == 0 ? 1 : i->produced[line - IL_RATE1].rate * 2;
1065 i->produced[line - IL_RATE1].rate = ClampTo<byte>(new_prod);
1066 }
1067 break;
1068
1069 default: NOT_REACHED();
1070 }
1071
1072 UpdateIndustryProduction(i);
1073 this->SetDirty();
1074 this->SetTimeout();
1075 this->clicked_line = line;
1076 this->clicked_button = (decrease ^ rtl) ? 1 : 2;
1077 } else if (r.Indent(SETTING_BUTTON_WIDTH + WidgetDimensions::scaled.hsep_normal, rtl).Contains(pt)) {
1078 /* clicked the text */
1079 this->editbox_line = line;
1080 switch (this->editable) {
1081 case EA_MULTIPLIER:
1082 SetDParam(0, RoundDivSU(i->prod_level * 100, PRODLEVEL_DEFAULT));
1083 ShowQueryString(STR_JUST_INT, STR_CONFIG_GAME_PRODUCTION_LEVEL, 10, this, CS_ALPHANUMERAL, QSF_NONE);
1084 break;
1085
1086 case EA_RATE:
1087 SetDParam(0, i->produced[line - IL_RATE1].rate * 8);
1088 ShowQueryString(STR_JUST_INT, STR_CONFIG_GAME_PRODUCTION, 10, this, CS_ALPHANUMERAL, QSF_NONE);
1089 break;
1090
1091 default: NOT_REACHED();
1092 }
1093 }
1094 break;
1095 }
1096
1097 case WID_IV_GOTO: {
1098 Industry *i = Industry::Get(this->window_number);
1099 if (_ctrl_pressed) {
1100 ShowExtraViewportWindow(i->location.GetCenterTile());
1101 } else {
1102 ScrollMainWindowToTile(i->location.GetCenterTile());
1103 }
1104 break;
1105 }
1106
1107 case WID_IV_DISPLAY: {
1108 Industry *i = Industry::Get(this->window_number);
1109 ShowIndustryCargoesWindow(i->type);
1110 break;
1111 }
1112 }
1113 }
1114
1115 void OnTimeout() override
1116 {
1117 this->clicked_line = IL_NONE;
1118 this->clicked_button = 0;
1119 this->SetDirty();
1120 }
1121
1122 void OnResize() override
1123 {
1124 if (this->viewport != nullptr) {
1125 NWidgetViewport *nvp = this->GetWidget<NWidgetViewport>(WID_IV_VIEWPORT);
1126 nvp->UpdateViewportCoordinates(this);
1127
1128 ScrollWindowToTile(Industry::Get(this->window_number)->location.GetCenterTile(), this, true); // Re-center viewport.
1129 }
1130 }
1131
1132 void OnQueryTextFinished(char *str) override
1133 {
1134 if (StrEmpty(str)) return;
1135
1136 Industry *i = Industry::Get(this->window_number);
1137 uint value = atoi(str);
1138 switch (this->editbox_line) {
1139 case IL_NONE: NOT_REACHED();
1140
1141 case IL_MULTIPLIER:
1142 i->prod_level = ClampU(RoundDivSU(value * PRODLEVEL_DEFAULT, 100), PRODLEVEL_MINIMUM, PRODLEVEL_MAXIMUM);
1143 break;
1144
1145 default:
1146 i->produced[this->editbox_line - IL_RATE1].rate = ClampU(RoundDivSU(value, 8), 0, 255);
1147 break;
1148 }
1149 UpdateIndustryProduction(i);
1150 this->SetDirty();
1151 }
1152
1158 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
1159 {
1160 if (!gui_scope) return;
1161 const Industry *i = Industry::Get(this->window_number);
1162 if (IsProductionAlterable(i)) {
1163 const IndustrySpec *ind = GetIndustrySpec(i->type);
1164 this->editable = ind->UsesOriginalEconomy() ? EA_MULTIPLIER : EA_RATE;
1165 } else {
1166 this->editable = EA_NONE;
1167 }
1168 }
1169
1170 bool IsNewGRFInspectable() const override
1171 {
1172 return ::IsNewGRFInspectable(GSF_INDUSTRIES, this->window_number);
1173 }
1174
1175 void ShowNewGRFInspectWindow() const override
1176 {
1177 ::ShowNewGRFInspectWindow(GSF_INDUSTRIES, this->window_number);
1178 }
1179 };
1180
1181 static void UpdateIndustryProduction(Industry *i)
1182 {
1183 const IndustrySpec *indspec = GetIndustrySpec(i->type);
1184 if (indspec->UsesOriginalEconomy()) i->RecomputeProductionMultipliers();
1185
1186 for (auto &p : i->produced) {
1187 if (IsValidCargoID(p.cargo)) {
1188 p.history[LAST_MONTH].production = ScaleByCargoScale(8 * p.rate, false);
1189 }
1190 }
1191 }
1192
1194 static constexpr NWidgetPart _nested_industry_view_widgets[] = {
1195 NWidget(NWID_HORIZONTAL),
1196 NWidget(WWT_CLOSEBOX, COLOUR_CREAM),
1197 NWidget(WWT_CAPTION, COLOUR_CREAM, WID_IV_CAPTION), SetDataTip(STR_INDUSTRY_VIEW_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1198 NWidget(WWT_PUSHIMGBTN, COLOUR_CREAM, WID_IV_GOTO), SetMinimalSize(12, 14), SetDataTip(SPR_GOTO_LOCATION, STR_INDUSTRY_VIEW_LOCATION_TOOLTIP),
1199 NWidget(WWT_DEBUGBOX, COLOUR_CREAM),
1200 NWidget(WWT_SHADEBOX, COLOUR_CREAM),
1201 NWidget(WWT_DEFSIZEBOX, COLOUR_CREAM),
1202 NWidget(WWT_STICKYBOX, COLOUR_CREAM),
1203 EndContainer(),
1204 NWidget(WWT_PANEL, COLOUR_CREAM),
1205 NWidget(WWT_INSET, COLOUR_CREAM), SetPadding(2, 2, 2, 2),
1206 NWidget(NWID_VIEWPORT, INVALID_COLOUR, WID_IV_VIEWPORT), SetMinimalSize(254, 86), SetFill(1, 0), SetResize(1, 1),
1207 EndContainer(),
1208 EndContainer(),
1209 NWidget(WWT_PANEL, COLOUR_CREAM, WID_IV_INFO), SetMinimalSize(260, 0), SetMinimalTextLines(2, WidgetDimensions::unscaled.framerect.Vertical()), SetResize(1, 0),
1210 EndContainer(),
1211 NWidget(NWID_HORIZONTAL),
1212 NWidget(WWT_PUSHTXTBTN, COLOUR_CREAM, WID_IV_DISPLAY), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_INDUSTRY_DISPLAY_CHAIN, STR_INDUSTRY_DISPLAY_CHAIN_TOOLTIP),
1213 NWidget(WWT_RESIZEBOX, COLOUR_CREAM),
1214 EndContainer(),
1215 };
1216
1218 static WindowDesc _industry_view_desc(__FILE__, __LINE__,
1219 WDP_AUTO, "view_industry", 260, 120,
1220 WC_INDUSTRY_VIEW, WC_NONE,
1221 0,
1222 std::begin(_nested_industry_view_widgets), std::end(_nested_industry_view_widgets)
1223 );
1224
1225 void ShowIndustryViewWindow(int industry)
1226 {
1227 AllocateWindowDescFront<IndustryViewWindow>(&_industry_view_desc, industry);
1228 }
1229
1231 static constexpr NWidgetPart _nested_industry_directory_widgets[] = {
1232 NWidget(NWID_HORIZONTAL),
1233 NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
1234 NWidget(WWT_CAPTION, COLOUR_BROWN), SetDataTip(STR_INDUSTRY_DIRECTORY_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1235 NWidget(WWT_SHADEBOX, COLOUR_BROWN),
1236 NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
1237 NWidget(WWT_STICKYBOX, COLOUR_BROWN),
1238 EndContainer(),
1239 NWidget(NWID_HORIZONTAL),
1240 NWidget(NWID_VERTICAL),
1241 NWidget(NWID_HORIZONTAL),
1242 NWidget(WWT_TEXTBTN, COLOUR_BROWN, WID_ID_DROPDOWN_ORDER), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
1243 NWidget(WWT_DROPDOWN, COLOUR_BROWN, WID_ID_DROPDOWN_CRITERIA), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_SORT_CRITERIA),
1244 NWidget(WWT_EDITBOX, COLOUR_BROWN, WID_ID_FILTER), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
1245 EndContainer(),
1246 NWidget(NWID_HORIZONTAL),
1247 NWidget(WWT_DROPDOWN, COLOUR_BROWN, WID_ID_FILTER_BY_ACC_CARGO), SetMinimalSize(225, 12), SetFill(0, 1), SetDataTip(STR_INDUSTRY_DIRECTORY_ACCEPTED_CARGO_FILTER, STR_TOOLTIP_FILTER_CRITERIA),
1248 NWidget(WWT_DROPDOWN, COLOUR_BROWN, WID_ID_FILTER_BY_PROD_CARGO), SetMinimalSize(225, 12), SetFill(0, 1), SetDataTip(STR_INDUSTRY_DIRECTORY_PRODUCED_CARGO_FILTER, STR_TOOLTIP_FILTER_CRITERIA),
1249 NWidget(WWT_PANEL, COLOUR_BROWN), SetResize(1, 0), EndContainer(),
1250 EndContainer(),
1251 NWidget(WWT_PANEL, COLOUR_BROWN, WID_ID_INDUSTRY_LIST), SetDataTip(0x0, STR_INDUSTRY_DIRECTORY_LIST_CAPTION), SetResize(1, 1), SetScrollbar(WID_ID_VSCROLLBAR),
1252 EndContainer(),
1253 EndContainer(),
1254 NWidget(NWID_VSCROLLBAR, COLOUR_BROWN, WID_ID_VSCROLLBAR),
1255 EndContainer(),
1256 NWidget(NWID_HORIZONTAL),
1257 NWidget(NWID_HSCROLLBAR, COLOUR_BROWN, WID_ID_HSCROLLBAR),
1258 NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
1259 EndContainer(),
1260 };
1261
1262 typedef GUIList<const Industry *, const CargoID &, const std::pair<CargoID, CargoID> &> GUIIndustryList;
1263
1271 static bool CDECL CargoFilter(const Industry * const *industry, const std::pair<CargoID, CargoID> &cargoes)
1272 {
1273 auto accepted_cargo = cargoes.first;
1274 auto produced_cargo = cargoes.second;
1275
1276 bool accepted_cargo_matches;
1277
1278 switch (accepted_cargo) {
1279 case CargoFilterCriteria::CF_ANY:
1280 accepted_cargo_matches = true;
1281 break;
1282
1283 case CargoFilterCriteria::CF_NONE:
1284 accepted_cargo_matches = !(*industry)->IsCargoAccepted();
1285 break;
1286
1287 default:
1288 accepted_cargo_matches = (*industry)->IsCargoAccepted(accepted_cargo);
1289 break;
1290 }
1291
1292 bool produced_cargo_matches;
1293
1294 switch (produced_cargo) {
1295 case CargoFilterCriteria::CF_ANY:
1296 produced_cargo_matches = true;
1297 break;
1298
1299 case CargoFilterCriteria::CF_NONE:
1300 produced_cargo_matches = !(*industry)->IsCargoProduced();
1301 break;
1302
1303 default:
1304 produced_cargo_matches = (*industry)->IsCargoProduced(produced_cargo);
1305 break;
1306 }
1307
1308 return accepted_cargo_matches && produced_cargo_matches;
1309 }
1310
1311 static GUIIndustryList::FilterFunction * const _filter_funcs[] = { &CargoFilter };
1312
1314 enum IndustryDirectoryHotkeys {
1315 IDHK_FOCUS_FILTER_BOX,
1316 };
1320 class IndustryDirectoryWindow : public Window {
1321 protected:
1322 /* Runtime saved values */
1323 static Listing last_sorting;
1324
1325 /* Constants for sorting industries */
1326 static const StringID sorter_names[];
1327 static GUIIndustryList::SortFunction * const sorter_funcs[];
1328
1329 GUIIndustryList industries{IndustryDirectoryWindow::produced_cargo_filter};
1330 Scrollbar *vscroll;
1331 Scrollbar *hscroll;
1332
1333 CargoID produced_cargo_filter_criteria;
1334 CargoID accepted_cargo_filter_criteria;
1335 static CargoID produced_cargo_filter;
1336
1337 const int MAX_FILTER_LENGTH = 16;
1338 StringFilter string_filter;
1339 QueryString industry_editbox;
1340
1341 enum class SorterType : uint8_t {
1342 ByName,
1343 ByType,
1344 ByProduction,
1345 ByTransported,
1346 };
1347
1352 void SetProducedCargoFilter(CargoID cid)
1353 {
1354 if (this->produced_cargo_filter_criteria != cid) {
1355 this->produced_cargo_filter_criteria = cid;
1356 /* deactivate filter if criteria is 'Show All', activate it otherwise */
1357 bool is_filtering_necessary = this->produced_cargo_filter_criteria != CargoFilterCriteria::CF_ANY || this->accepted_cargo_filter_criteria != CargoFilterCriteria::CF_ANY;
1358
1359 this->industries.SetFilterState(is_filtering_necessary);
1360 this->industries.SetFilterType(0);
1361 this->industries.ForceRebuild();
1362 }
1363 }
1364
1369 void SetAcceptedCargoFilter(CargoID cid)
1370 {
1371 if (this->accepted_cargo_filter_criteria != cid) {
1372 this->accepted_cargo_filter_criteria = cid;
1373 /* deactivate filter if criteria is 'Show All', activate it otherwise */
1374 bool is_filtering_necessary = this->produced_cargo_filter_criteria != CargoFilterCriteria::CF_ANY || this->accepted_cargo_filter_criteria != CargoFilterCriteria::CF_ANY;
1375
1376 this->industries.SetFilterState(is_filtering_necessary);
1377 this->industries.SetFilterType(0);
1378 this->industries.ForceRebuild();
1379 }
1380 }
1381
1382 StringID GetCargoFilterLabel(CargoID cid) const
1383 {
1384 switch (cid) {
1385 case CargoFilterCriteria::CF_ANY: return STR_INDUSTRY_DIRECTORY_FILTER_ALL_TYPES;
1386 case CargoFilterCriteria::CF_NONE: return STR_INDUSTRY_DIRECTORY_FILTER_NONE;
1387 default: return CargoSpec::Get(cid)->name;
1388 }
1389 }
1390
1394 void SetCargoFilterArray()
1395 {
1396 this->produced_cargo_filter_criteria = CargoFilterCriteria::CF_ANY;
1397 this->accepted_cargo_filter_criteria = CargoFilterCriteria::CF_ANY;
1398
1399 this->industries.SetFilterFuncs(_filter_funcs);
1400
1401 bool is_filtering_necessary = this->produced_cargo_filter_criteria != CargoFilterCriteria::CF_ANY || this->accepted_cargo_filter_criteria != CargoFilterCriteria::CF_ANY;
1402
1403 this->industries.SetFilterState(is_filtering_necessary);
1404 }
1405
1410 uint GetIndustryListWidth() const
1411 {
1412 uint width = 0;
1413 for (const Industry *i : this->industries) {
1414 width = std::max(width, GetStringBoundingBox(this->GetIndustryString(i)).width);
1415 }
1416 return width + WidgetDimensions::scaled.framerect.Horizontal();
1417 }
1418
1420 void BuildSortIndustriesList()
1421 {
1422 if (this->industries.NeedRebuild()) {
1423 this->industries.clear();
1424
1425 for (const Industry *i : Industry::Iterate()) {
1426 if (this->string_filter.IsEmpty()) {
1427 this->industries.push_back(i);
1428 continue;
1429 }
1430 this->string_filter.ResetState();
1431 this->string_filter.AddLine(i->GetCachedName());
1432 if (this->string_filter.GetState()) this->industries.push_back(i);
1433 }
1434
1435 this->industries.shrink_to_fit();
1436 this->industries.RebuildDone();
1437
1438 auto filter = std::make_pair(this->accepted_cargo_filter_criteria, this->produced_cargo_filter_criteria);
1439
1440 this->industries.Filter(filter);
1441
1442 this->hscroll->SetCount(this->GetIndustryListWidth());
1443 this->vscroll->SetCount(this->industries.size()); // Update scrollbar as well.
1444 }
1445
1446 IndustryDirectoryWindow::produced_cargo_filter = this->produced_cargo_filter_criteria;
1447 this->industries.Sort();
1448
1449 this->SetDirty();
1450 }
1451
1459 static inline int GetCargoTransportedPercentsIfValid(const Industry::ProducedCargo &p)
1460 {
1461 if (!IsValidCargoID(p.cargo)) return -1;
1462 return ToPercent8(p.history[LAST_MONTH].PctTransported());
1463 }
1464
1472 static int GetCargoTransportedSortValue(const Industry *i)
1473 {
1474 CargoID filter = IndustryDirectoryWindow::produced_cargo_filter;
1475 if (filter == CargoFilterCriteria::CF_NONE) return 0;
1476
1477 int percentage = 0, produced_cargo_count = 0;
1478 for (const auto &p : i->produced) {
1479 if (filter == CargoFilterCriteria::CF_ANY) {
1480 int transported = GetCargoTransportedPercentsIfValid(p);
1481 if (transported != -1) {
1482 produced_cargo_count++;
1483 percentage += transported;
1484 }
1485 if (produced_cargo_count == 0 && &p == &i->produced.back() && percentage == 0) {
1486 return transported;
1487 }
1488 } else if (filter == p.cargo) {
1489 return GetCargoTransportedPercentsIfValid(p);
1490 }
1491 }
1492
1493 if (produced_cargo_count == 0) return percentage;
1494 return percentage / produced_cargo_count;
1495 }
1496
1498 static bool IndustryNameSorter(const Industry * const &a, const Industry * const &b, const CargoID &)
1499 {
1500 int r = StrNaturalCompare(a->GetCachedName(), b->GetCachedName()); // Sort by name (natural sorting).
1501 if (r == 0) return a->index < b->index;
1502 return r < 0;
1503 }
1504
1506 static bool IndustryTypeSorter(const Industry * const &a, const Industry * const &b, const CargoID &filter)
1507 {
1508 int it_a = 0;
1509 while (it_a != NUM_INDUSTRYTYPES && a->type != _sorted_industry_types[it_a]) it_a++;
1510 int it_b = 0;
1511 while (it_b != NUM_INDUSTRYTYPES && b->type != _sorted_industry_types[it_b]) it_b++;
1512 int r = it_a - it_b;
1513 return (r == 0) ? IndustryNameSorter(a, b, filter) : r < 0;
1514 }
1515
1517 static bool IndustryProductionSorter(const Industry * const &a, const Industry * const &b, const CargoID &filter)
1518 {
1519 if (filter == CargoFilterCriteria::CF_NONE) return IndustryTypeSorter(a, b, filter);
1520
1521 uint prod_a = 0, prod_b = 0;
1522 if (filter == CargoFilterCriteria::CF_ANY) {
1523 for (const auto &pa : a->produced) {
1524 if (IsValidCargoID(pa.cargo)) prod_a += pa.history[LAST_MONTH].production;
1525 }
1526 for (const auto &pb : b->produced) {
1527 if (IsValidCargoID(pb.cargo)) prod_b += pb.history[LAST_MONTH].production;
1528 }
1529 } else {
1530 if (auto ita = a->GetCargoProduced(filter); ita != std::end(a->produced)) prod_a = ita->history[LAST_MONTH].production;
1531 if (auto itb = b->GetCargoProduced(filter); itb != std::end(b->produced)) prod_b = itb->history[LAST_MONTH].production;
1532 }
1533 int r = prod_a - prod_b;
1534
1535 return (r == 0) ? IndustryTypeSorter(a, b, filter) : r < 0;
1536 }
1537
1539 static bool IndustryTransportedCargoSorter(const Industry * const &a, const Industry * const &b, const CargoID &filter)
1540 {
1541 int r = GetCargoTransportedSortValue(a) - GetCargoTransportedSortValue(b);
1542 return (r == 0) ? IndustryNameSorter(a, b, filter) : r < 0;
1543 }
1544
1550 StringID GetIndustryString(const Industry *i) const
1551 {
1552 const IndustrySpec *indsp = GetIndustrySpec(i->type);
1553 byte p = 0;
1554
1555 /* Industry name */
1556 SetDParam(p++, i->index);
1557
1558 static CargoSuffix cargo_suffix[INDUSTRY_NUM_OUTPUTS];
1559
1560 /* Get industry productions (CargoID, production, suffix, transported) */
1561 struct CargoInfo {
1562 CargoID cargo_id;
1563 uint16_t production;
1564 const char *suffix;
1565 uint transported;
1566 };
1567 std::vector<CargoInfo> cargos;
1568
1569 for (auto itp = std::begin(i->produced); itp != std::end(i->produced); ++itp) {
1570 if (!IsValidCargoID(itp->cargo)) continue;
1571 GetCargoSuffix(CARGOSUFFIX_OUT, CST_DIR, i, i->type, indsp, itp->cargo, itp - std::begin(i->produced), cargo_suffix[itp - std::begin(i->produced)]);
1572 cargos.push_back({ itp->cargo, itp->history[LAST_MONTH].production, cargo_suffix[itp - std::begin(i->produced)].text.c_str(), ToPercent8(itp->history[LAST_MONTH].PctTransported()) });
1573 }
1574
1575 switch (static_cast<IndustryDirectoryWindow::SorterType>(this->industries.SortType())) {
1576 case IndustryDirectoryWindow::SorterType::ByName:
1577 case IndustryDirectoryWindow::SorterType::ByType:
1578 case IndustryDirectoryWindow::SorterType::ByProduction:
1579 /* Sort by descending production, then descending transported */
1580 std::sort(cargos.begin(), cargos.end(), [](const CargoInfo &a, const CargoInfo &b) {
1581 if (a.production != b.production) return a.production > b.production;
1582 return a.transported > b.transported;
1583 });
1584 break;
1585
1586 case IndustryDirectoryWindow::SorterType::ByTransported:
1587 /* Sort by descending transported, then descending production */
1588 std::sort(cargos.begin(), cargos.end(), [](const CargoInfo &a, const CargoInfo &b) {
1589 if (a.transported != b.transported) return a.transported > b.transported;
1590 return a.production > b.production;
1591 });
1592 break;
1593 }
1594
1595 /* If the produced cargo filter is active then move the filtered cargo to the beginning of the list,
1596 * because this is the one the player interested in, and that way it is not hidden in the 'n' more cargos */
1597 const CargoID cid = this->produced_cargo_filter_criteria;
1598 if (cid != CargoFilterCriteria::CF_ANY && cid != CargoFilterCriteria::CF_NONE) {
1599 auto filtered_ci = std::find_if(cargos.begin(), cargos.end(), [cid](const CargoInfo &ci) -> bool {
1600 return ci.cargo_id == cid;
1601 });
1602 if (filtered_ci != cargos.end()) {
1603 std::rotate(cargos.begin(), filtered_ci, filtered_ci + 1);
1604 }
1605 }
1606
1607 /* Display first 3 cargos */
1608 for (size_t j = 0; j < std::min<size_t>(3, cargos.size()); j++) {
1609 CargoInfo ci = cargos[j];
1610 SetDParam(p++, STR_INDUSTRY_DIRECTORY_ITEM_INFO);
1611 SetDParam(p++, ci.cargo_id);
1612 SetDParam(p++, ci.production);
1613 SetDParamStr(p++, ci.suffix);
1614 SetDParam(p++, ci.transported);
1615 }
1616
1617 /* Undisplayed cargos if any */
1618 SetDParam(p++, cargos.size() - 3);
1619
1620 /* Drawing the right string */
1621 switch (cargos.size()) {
1622 case 0: return STR_INDUSTRY_DIRECTORY_ITEM_NOPROD;
1623 case 1: return STR_INDUSTRY_DIRECTORY_ITEM_PROD1;
1624 case 2: return STR_INDUSTRY_DIRECTORY_ITEM_PROD2;
1625 case 3: return STR_INDUSTRY_DIRECTORY_ITEM_PROD3;
1626 default: return STR_INDUSTRY_DIRECTORY_ITEM_PRODMORE;
1627 }
1628 }
1629
1630 public:
1631 IndustryDirectoryWindow(WindowDesc *desc, WindowNumber) : Window(desc), industry_editbox(MAX_FILTER_LENGTH * MAX_CHAR_LENGTH, MAX_FILTER_LENGTH)
1632 {
1633 this->CreateNestedTree();
1634 this->vscroll = this->GetScrollbar(WID_ID_VSCROLLBAR);
1635 this->hscroll = this->GetScrollbar(WID_ID_HSCROLLBAR);
1636
1637 this->industries.SetListing(this->last_sorting);
1638 this->industries.SetSortFuncs(IndustryDirectoryWindow::sorter_funcs);
1639 this->industries.ForceRebuild();
1640
1641 this->FinishInitNested(0);
1642
1643 this->BuildSortIndustriesList();
1644
1645 this->querystrings[WID_ID_FILTER] = &this->industry_editbox;
1646 this->industry_editbox.cancel_button = QueryString::ACTION_CLEAR;
1647 }
1648
1649 ~IndustryDirectoryWindow()
1650 {
1651 this->last_sorting = this->industries.GetListing();
1652 }
1653
1654 void OnInit() override
1655 {
1656 this->SetCargoFilterArray();
1657 }
1658
1659 void SetStringParameters(WidgetID widget) const override
1660 {
1661 switch (widget) {
1662 case WID_ID_DROPDOWN_CRITERIA:
1663 SetDParam(0, IndustryDirectoryWindow::sorter_names[this->industries.SortType()]);
1664 break;
1665
1666 case WID_ID_FILTER_BY_ACC_CARGO:
1667 SetDParam(0, this->GetCargoFilterLabel(this->accepted_cargo_filter_criteria));
1668 break;
1669
1670 case WID_ID_FILTER_BY_PROD_CARGO:
1671 SetDParam(0, this->GetCargoFilterLabel(this->produced_cargo_filter_criteria));
1672 break;
1673 }
1674 }
1675
1676 void DrawWidget(const Rect &r, WidgetID widget) const override
1677 {
1678 switch (widget) {
1679 case WID_ID_DROPDOWN_ORDER:
1680 this->DrawSortButtonState(widget, this->industries.IsDescSortOrder() ? SBS_DOWN : SBS_UP);
1681 break;
1682
1683 case WID_ID_INDUSTRY_LIST: {
1684 Rect ir = r.Shrink(WidgetDimensions::scaled.framerect);
1685
1686 /* Setup a clipping rectangle... */
1687 DrawPixelInfo tmp_dpi;
1688 if (!FillDrawPixelInfo(&tmp_dpi, ir)) return;
1689 /* ...but keep coordinates relative to the window. */
1690 tmp_dpi.left += ir.left;
1691 tmp_dpi.top += ir.top;
1692
1693 AutoRestoreBackup dpi_backup(_cur_dpi, &tmp_dpi);
1694
1695 ir.left -= this->hscroll->GetPosition();
1696 ir.right += this->hscroll->GetCapacity() - this->hscroll->GetPosition();
1697
1698 if (this->industries.empty()) {
1699 DrawString(ir, STR_INDUSTRY_DIRECTORY_NONE);
1700 break;
1701 }
1702 int n = 0;
1703 const CargoID acf_cid = this->accepted_cargo_filter_criteria;
1704 for (uint i = this->vscroll->GetPosition(); i < this->industries.size(); i++) {
1705 TextColour tc = TC_FROMSTRING;
1706 if (acf_cid != CargoFilterCriteria::CF_ANY && acf_cid != CargoFilterCriteria::CF_NONE) {
1707 Industry *ind = const_cast<Industry *>(this->industries[i]);
1708 if (IndustryTemporarilyRefusesCargo(ind, acf_cid)) {
1709 tc = TC_GREY | TC_FORCED;
1710 }
1711 }
1712 DrawString(ir, this->GetIndustryString(this->industries[i]), tc);
1713
1714 ir.top += this->resize.step_height;
1715 if (++n == this->vscroll->GetCapacity()) break; // max number of industries in 1 window
1716 }
1717 break;
1718 }
1719 }
1720 }
1721
1722 void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
1723 {
1724 switch (widget) {
1725 case WID_ID_DROPDOWN_ORDER: {
1726 Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
1727 d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
1728 d.height += padding.height;
1729 *size = maxdim(*size, d);
1730 break;
1731 }
1732
1733 case WID_ID_DROPDOWN_CRITERIA: {
1734 Dimension d = {0, 0};
1735 for (uint i = 0; IndustryDirectoryWindow::sorter_names[i] != INVALID_STRING_ID; i++) {
1736 d = maxdim(d, GetStringBoundingBox(IndustryDirectoryWindow::sorter_names[i]));
1737 }
1738 d.width += padding.width;
1739 d.height += padding.height;
1740 *size = maxdim(*size, d);
1741 break;
1742 }
1743
1744 case WID_ID_INDUSTRY_LIST: {
1745 Dimension d = GetStringBoundingBox(STR_INDUSTRY_DIRECTORY_NONE);
1746 resize->height = d.height;
1747 d.height *= 5;
1748 d.width += padding.width;
1749 d.height += padding.height;
1750 *size = maxdim(*size, d);
1751 break;
1752 }
1753 }
1754 }
1755
1756 DropDownList BuildCargoDropDownList() const
1757 {
1758 DropDownList list;
1759
1760 /* Add item for disabling filtering. */
1761 list.push_back(std::make_unique<DropDownListStringItem>(this->GetCargoFilterLabel(CargoFilterCriteria::CF_ANY), CargoFilterCriteria::CF_ANY, false));
1762 /* Add item for industries not producing anything, e.g. power plants */
1763 list.push_back(std::make_unique<DropDownListStringItem>(this->GetCargoFilterLabel(CargoFilterCriteria::CF_NONE), CargoFilterCriteria::CF_NONE, false));
1764
1765 /* Add cargos */
1766 Dimension d = GetLargestCargoIconSize();
1767 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
1768 list.push_back(std::make_unique<DropDownListIconItem>(d, cs->GetCargoIcon(), PAL_NONE, cs->name, cs->Index(), false));
1769 }
1770
1771 return list;
1772 }
1773
1774 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
1775 {
1776 switch (widget) {
1777 case WID_ID_DROPDOWN_ORDER:
1778 this->industries.ToggleSortOrder();
1779 this->SetDirty();
1780 break;
1781
1782 case WID_ID_DROPDOWN_CRITERIA:
1783 ShowDropDownMenu(this, IndustryDirectoryWindow::sorter_names, this->industries.SortType(), WID_ID_DROPDOWN_CRITERIA, 0, 0);
1784 break;
1785
1786 case WID_ID_FILTER_BY_ACC_CARGO: // Cargo filter dropdown
1787 ShowDropDownList(this, this->BuildCargoDropDownList(), this->accepted_cargo_filter_criteria, widget);
1788 break;
1789
1790 case WID_ID_FILTER_BY_PROD_CARGO: // Cargo filter dropdown
1791 ShowDropDownList(this, this->BuildCargoDropDownList(), this->produced_cargo_filter_criteria, widget);
1792 break;
1793
1794 case WID_ID_INDUSTRY_LIST: {
1795 auto it = this->vscroll->GetScrolledItemFromWidget(this->industries, pt.y, this, WID_ID_INDUSTRY_LIST, WidgetDimensions::scaled.framerect.top);
1796 if (it != this->industries.end()) {
1797 if (_ctrl_pressed) {
1798 ShowExtraViewportWindow((*it)->location.tile);
1799 } else {
1800 ScrollMainWindowToTile((*it)->location.tile);
1801 }
1802 }
1803 break;
1804 }
1805 }
1806 }
1807
1808 void OnDropdownSelect(WidgetID widget, int index) override
1809 {
1810 switch (widget) {
1811 case WID_ID_DROPDOWN_CRITERIA: {
1812 if (this->industries.SortType() != index) {
1813 this->industries.SetSortType(index);
1814 this->BuildSortIndustriesList();
1815 }
1816 break;
1817 }
1818
1819 case WID_ID_FILTER_BY_ACC_CARGO: {
1820 this->SetAcceptedCargoFilter(index);
1821 this->BuildSortIndustriesList();
1822 break;
1823 }
1824
1825 case WID_ID_FILTER_BY_PROD_CARGO: {
1826 this->SetProducedCargoFilter(index);
1827 this->BuildSortIndustriesList();
1828 break;
1829 }
1830 }
1831 }
1832
1833 void OnResize() override
1834 {
1835 this->vscroll->SetCapacityFromWidget(this, WID_ID_INDUSTRY_LIST);
1836 this->hscroll->SetCapacityFromWidget(this, WID_ID_INDUSTRY_LIST);
1837 }
1838
1839 void OnEditboxChanged(WidgetID wid) override
1840 {
1841 if (wid == WID_ID_FILTER) {
1842 this->string_filter.SetFilterTerm(this->industry_editbox.text.buf);
1843 this->InvalidateData(IDIWD_FORCE_REBUILD);
1844 }
1845 }
1846
1847 void OnPaint() override
1848 {
1849 if (this->industries.NeedRebuild()) this->BuildSortIndustriesList();
1850 this->DrawWidgets();
1851 }
1852
1854 IntervalTimer<TimerWindow> rebuild_interval = {std::chrono::seconds(3), [this](auto) {
1855 this->industries.ForceResort();
1856 this->BuildSortIndustriesList();
1857 }};
1858
1864 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
1865 {
1866 switch (data) {
1867 case IDIWD_FORCE_REBUILD:
1868 /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
1869 this->industries.ForceRebuild();
1870 break;
1871
1872 case IDIWD_PRODUCTION_CHANGE:
1873 if (this->industries.SortType() == 2) this->industries.ForceResort();
1874 break;
1875
1876 default:
1877 this->industries.ForceResort();
1878 break;
1879 }
1880 }
1881
1882 EventState OnHotkey(int hotkey) override
1883 {
1884 switch (hotkey) {
1885 case IDHK_FOCUS_FILTER_BOX:
1886 this->SetFocusedWidget(WID_ID_FILTER);
1887 SetFocusedWindow(this); // The user has asked to give focus to the text box, so make sure this window is focused.
1888 break;
1889 default:
1890 return ES_NOT_HANDLED;
1891 }
1892 return ES_HANDLED;
1893 }
1894
1895 static inline HotkeyList hotkeys {"industrydirectory", {
1896 Hotkey('F', "focus_filter_box", IDHK_FOCUS_FILTER_BOX),
1897 }};
1898 };
1899
1900 Listing IndustryDirectoryWindow::last_sorting = {false, 0};
1901
1902 /* Available station sorting functions. */
1903 GUIIndustryList::SortFunction * const IndustryDirectoryWindow::sorter_funcs[] = {
1904 &IndustryNameSorter,
1905 &IndustryTypeSorter,
1906 &IndustryProductionSorter,
1907 &IndustryTransportedCargoSorter
1908 };
1909
1910 /* Names of the sorting functions */
1911 const StringID IndustryDirectoryWindow::sorter_names[] = {
1912 STR_SORT_BY_NAME,
1913 STR_SORT_BY_TYPE,
1914 STR_SORT_BY_PRODUCTION,
1915 STR_SORT_BY_TRANSPORTED,
1916 INVALID_STRING_ID
1917 };
1918
1919 CargoID IndustryDirectoryWindow::produced_cargo_filter = CargoFilterCriteria::CF_ANY;
1920
1921
1923 static WindowDesc _industry_directory_desc(__FILE__, __LINE__,
1924 WDP_AUTO, "list_industries", 428, 190,
1925 WC_INDUSTRY_DIRECTORY, WC_NONE,
1926 0,
1927 std::begin(_nested_industry_directory_widgets), std::end(_nested_industry_directory_widgets),
1928 &IndustryDirectoryWindow::hotkeys
1929 );
1930
1931 void ShowIndustryDirectory()
1932 {
1933 AllocateWindowDescFront<IndustryDirectoryWindow>(&_industry_directory_desc, 0);
1934 }
1935
1937 static constexpr NWidgetPart _nested_industry_cargoes_widgets[] = {
1938 NWidget(NWID_HORIZONTAL),
1939 NWidget(WWT_CLOSEBOX, COLOUR_BROWN),
1940 NWidget(WWT_CAPTION, COLOUR_BROWN, WID_IC_CAPTION), SetDataTip(STR_INDUSTRY_CARGOES_INDUSTRY_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1941 NWidget(WWT_SHADEBOX, COLOUR_BROWN),
1942 NWidget(WWT_DEFSIZEBOX, COLOUR_BROWN),
1943 NWidget(WWT_STICKYBOX, COLOUR_BROWN),
1944 EndContainer(),
1945 NWidget(NWID_HORIZONTAL),
1946 NWidget(WWT_PANEL, COLOUR_BROWN, WID_IC_PANEL), SetResize(1, 10), SetScrollbar(WID_IC_SCROLLBAR), EndContainer(),
1947 NWidget(NWID_VSCROLLBAR, COLOUR_BROWN, WID_IC_SCROLLBAR),
1948 EndContainer(),
1949 NWidget(NWID_HORIZONTAL),
1950 NWidget(WWT_TEXTBTN, COLOUR_BROWN, WID_IC_NOTIFY),
1951 SetDataTip(STR_INDUSTRY_CARGOES_NOTIFY_SMALLMAP, STR_INDUSTRY_CARGOES_NOTIFY_SMALLMAP_TOOLTIP),
1952 NWidget(WWT_PANEL, COLOUR_BROWN), SetFill(1, 0), SetResize(0, 0), EndContainer(),
1953 NWidget(WWT_DROPDOWN, COLOUR_BROWN, WID_IC_IND_DROPDOWN), SetFill(0, 0), SetResize(0, 0),
1954 SetDataTip(STR_INDUSTRY_CARGOES_SELECT_INDUSTRY, STR_INDUSTRY_CARGOES_SELECT_INDUSTRY_TOOLTIP),
1955 NWidget(WWT_DROPDOWN, COLOUR_BROWN, WID_IC_CARGO_DROPDOWN), SetFill(0, 0), SetResize(0, 0),
1956 SetDataTip(STR_INDUSTRY_CARGOES_SELECT_CARGO, STR_INDUSTRY_CARGOES_SELECT_CARGO_TOOLTIP),
1957 NWidget(WWT_RESIZEBOX, COLOUR_BROWN),
1958 EndContainer(),
1959 };
1960
1962 static WindowDesc _industry_cargoes_desc(__FILE__, __LINE__,
1963 WDP_AUTO, "industry_cargoes", 300, 210,
1964 WC_INDUSTRY_CARGOES, WC_NONE,
1965 0,
1966 std::begin(_nested_industry_cargoes_widgets), std::end(_nested_industry_cargoes_widgets)
1967 );
1968
1970 enum CargoesFieldType {
1971 CFT_EMPTY,
1972 CFT_SMALL_EMPTY,
1973 CFT_INDUSTRY,
1974 CFT_CARGO,
1975 CFT_CARGO_LABEL,
1976 CFT_HEADER,
1977 };
1978
1979 static const uint MAX_CARGOES = 16;
1980
1982 struct CargoesField {
1983 static int vert_inter_industry_space;
1984 static int blob_distance;
1985
1986 static Dimension legend;
1987 static Dimension cargo_border;
1988 static Dimension cargo_line;
1989 static Dimension cargo_space;
1990 static Dimension cargo_stub;
1991
1992 static const int INDUSTRY_LINE_COLOUR;
1993 static const int CARGO_LINE_COLOUR;
1994
1995 static int small_height, normal_height;
1996 static int cargo_field_width;
1997 static int industry_width;
1998 static uint max_cargoes;
1999
2000 using Cargoes = uint16_t;
2001 static_assert(std::numeric_limits<Cargoes>::digits >= MAX_CARGOES);
2002
2003 CargoesFieldType type;
2004 union {
2005 struct {
2006 IndustryType ind_type;
2007 CargoID other_produced[MAX_CARGOES];
2008 CargoID other_accepted[MAX_CARGOES];
2009 } industry;
2010 struct {
2011 CargoID vertical_cargoes[MAX_CARGOES];
2012 Cargoes supp_cargoes;
2013 Cargoes cust_cargoes;
2014 uint8_t num_cargoes;
2015 uint8_t top_end;
2016 uint8_t bottom_end;
2017 } cargo;
2018 struct {
2019 CargoID cargoes[MAX_CARGOES];
2020 bool left_align;
2021 } cargo_label;
2022 StringID header;
2023 } u; // Data for each type.
2024
2029 void MakeEmpty(CargoesFieldType type)
2030 {
2031 this->type = type;
2032 }
2033
2039 void MakeIndustry(IndustryType ind_type)
2040 {
2041 this->type = CFT_INDUSTRY;
2042 this->u.industry.ind_type = ind_type;
2043 std::fill(std::begin(this->u.industry.other_accepted), std::end(this->u.industry.other_accepted), INVALID_CARGO);
2044 std::fill(std::begin(this->u.industry.other_produced), std::end(this->u.industry.other_produced), INVALID_CARGO);
2045 }
2046
2053 int ConnectCargo(CargoID cargo, bool producer)
2054 {
2055 assert(this->type == CFT_CARGO);
2056 if (!IsValidCargoID(cargo)) return -1;
2057
2058 /* Find the vertical cargo column carrying the cargo. */
2059 int column = -1;
2060 for (int i = 0; i < this->u.cargo.num_cargoes; i++) {
2061 if (cargo == this->u.cargo.vertical_cargoes[i]) {
2062 column = i;
2063 break;
2064 }
2065 }
2066 if (column < 0) return -1;
2067
2068 if (producer) {
2069 assert(!HasBit(this->u.cargo.supp_cargoes, column));
2070 SetBit(this->u.cargo.supp_cargoes, column);
2071 } else {
2072 assert(!HasBit(this->u.cargo.cust_cargoes, column));
2073 SetBit(this->u.cargo.cust_cargoes, column);
2074 }
2075 return column;
2076 }
2077
2082 bool HasConnection()
2083 {
2084 assert(this->type == CFT_CARGO);
2085
2086 return this->u.cargo.supp_cargoes != 0 || this->u.cargo.cust_cargoes != 0;
2087 }
2088
2098 void MakeCargo(const CargoID *cargoes, uint length, int count = -1, bool top_end = false, bool bottom_end = false)
2099 {
2100 this->type = CFT_CARGO;
2101 auto insert = std::begin(this->u.cargo.vertical_cargoes);
2102 for (uint i = 0; insert != std::end(this->u.cargo.vertical_cargoes) && i < length; i++) {
2103 if (IsValidCargoID(cargoes[i])) {
2104 *insert = cargoes[i];
2105 ++insert;
2106 }
2107 }
2108 this->u.cargo.num_cargoes = (count < 0) ? static_cast<uint8_t>(insert - std::begin(this->u.cargo.vertical_cargoes)) : count;
2109 CargoIDComparator comparator;
2110 std::sort(std::begin(this->u.cargo.vertical_cargoes), insert, comparator);
2111 std::fill(insert, std::end(this->u.cargo.vertical_cargoes), INVALID_CARGO);
2112 this->u.cargo.top_end = top_end;
2113 this->u.cargo.bottom_end = bottom_end;
2114 this->u.cargo.supp_cargoes = 0;
2115 this->u.cargo.cust_cargoes = 0;
2116 }
2117
2124 void MakeCargoLabel(const CargoID *cargoes, uint length, bool left_align)
2125 {
2126 this->type = CFT_CARGO_LABEL;
2127 uint i;
2128 for (i = 0; i < MAX_CARGOES && i < length; i++) this->u.cargo_label.cargoes[i] = cargoes[i];
2129 for (; i < MAX_CARGOES; i++) this->u.cargo_label.cargoes[i] = INVALID_CARGO;
2130 this->u.cargo_label.left_align = left_align;
2131 }
2132
2137 void MakeHeader(StringID textid)
2138 {
2139 this->type = CFT_HEADER;
2140 this->u.header = textid;
2141 }
2142
2148 int GetCargoBase(int xpos) const
2149 {
2150 assert(this->type == CFT_CARGO);
2151 int n = this->u.cargo.num_cargoes;
2152
2153 return xpos + cargo_field_width / 2 - (CargoesField::cargo_line.width * n + CargoesField::cargo_space.width * (n - 1)) / 2;
2154 }
2155
2161 void Draw(int xpos, int ypos) const
2162 {
2163 switch (this->type) {
2164 case CFT_EMPTY:
2165 case CFT_SMALL_EMPTY:
2166 break;
2167
2168 case CFT_HEADER:
2169 ypos += (small_height - GetCharacterHeight(FS_NORMAL)) / 2;
2170 DrawString(xpos, xpos + industry_width, ypos, this->u.header, TC_WHITE, SA_HOR_CENTER);
2171 break;
2172
2173 case CFT_INDUSTRY: {
2174 int ypos1 = ypos + vert_inter_industry_space / 2;
2175 int ypos2 = ypos + normal_height - 1 - vert_inter_industry_space / 2;
2176 int xpos2 = xpos + industry_width - 1;
2177 DrawRectOutline({xpos, ypos1, xpos2, ypos2}, INDUSTRY_LINE_COLOUR);
2178 ypos += (normal_height - GetCharacterHeight(FS_NORMAL)) / 2;
2179 if (this->u.industry.ind_type < NUM_INDUSTRYTYPES) {
2180 const IndustrySpec *indsp = GetIndustrySpec(this->u.industry.ind_type);
2181 DrawString(xpos, xpos2, ypos, indsp->name, TC_WHITE, SA_HOR_CENTER);
2182
2183 /* Draw the industry legend. */
2184 int blob_left, blob_right;
2185 if (_current_text_dir == TD_RTL) {
2186 blob_right = xpos2 - blob_distance;
2187 blob_left = blob_right - CargoesField::legend.width;
2188 } else {
2189 blob_left = xpos + blob_distance;
2190 blob_right = blob_left + CargoesField::legend.width;
2191 }
2192 GfxFillRect(blob_left, ypos2 - blob_distance - CargoesField::legend.height, blob_right, ypos2 - blob_distance, PC_BLACK); // Border
2193 GfxFillRect(blob_left + 1, ypos2 - blob_distance - CargoesField::legend.height + 1, blob_right - 1, ypos2 - blob_distance - 1, indsp->map_colour);
2194 } else {
2195 DrawString(xpos, xpos2, ypos, STR_INDUSTRY_CARGOES_HOUSES, TC_FROMSTRING, SA_HOR_CENTER);
2196 }
2197
2198 /* Draw the other_produced/other_accepted cargoes. */
2199 const CargoID *other_right, *other_left;
2200 if (_current_text_dir == TD_RTL) {
2201 other_right = this->u.industry.other_accepted;
2202 other_left = this->u.industry.other_produced;
2203 } else {
2204 other_right = this->u.industry.other_produced;
2205 other_left = this->u.industry.other_accepted;
2206 }
2207 ypos1 += CargoesField::cargo_border.height + (GetCharacterHeight(FS_NORMAL) - CargoesField::cargo_line.height) / 2;
2208 for (uint i = 0; i < CargoesField::max_cargoes; i++) {
2209 if (IsValidCargoID(other_right[i])) {
2210 const CargoSpec *csp = CargoSpec::Get(other_right[i]);
2211 int xp = xpos + industry_width + CargoesField::cargo_stub.width;
2212 DrawHorConnection(xpos + industry_width, xp - 1, ypos1, csp);
2213 GfxDrawLine(xp, ypos1, xp, ypos1 + CargoesField::cargo_line.height - 1, CARGO_LINE_COLOUR);
2214 }
2215 if (IsValidCargoID(other_left[i])) {
2216 const CargoSpec *csp = CargoSpec::Get(other_left[i]);
2217 int xp = xpos - CargoesField::cargo_stub.width;
2218 DrawHorConnection(xp + 1, xpos - 1, ypos1, csp);
2219 GfxDrawLine(xp, ypos1, xp, ypos1 + CargoesField::cargo_line.height - 1, CARGO_LINE_COLOUR);
2220 }
2221 ypos1 += GetCharacterHeight(FS_NORMAL) + CargoesField::cargo_space.height;
2222 }
2223 break;
2224 }
2225
2226 case CFT_CARGO: {
2227 int cargo_base = this->GetCargoBase(xpos);
2228 int top = ypos + (this->u.cargo.top_end ? vert_inter_industry_space / 2 + 1 : 0);
2229 int bot = ypos - (this->u.cargo.bottom_end ? vert_inter_industry_space / 2 + 1 : 0) + normal_height - 1;
2230 int colpos = cargo_base;
2231 for (int i = 0; i < this->u.cargo.num_cargoes; i++) {
2232 if (this->u.cargo.top_end) GfxDrawLine(colpos, top - 1, colpos + CargoesField::cargo_line.width - 1, top - 1, CARGO_LINE_COLOUR);
2233 if (this->u.cargo.bottom_end) GfxDrawLine(colpos, bot + 1, colpos + CargoesField::cargo_line.width - 1, bot + 1, CARGO_LINE_COLOUR);
2234 GfxDrawLine(colpos, top, colpos, bot, CARGO_LINE_COLOUR);
2235 colpos++;
2236 const CargoSpec *csp = CargoSpec::Get(this->u.cargo.vertical_cargoes[i]);
2237 GfxFillRect(colpos, top, colpos + CargoesField::cargo_line.width - 2, bot, csp->legend_colour, FILLRECT_OPAQUE);
2238 colpos += CargoesField::cargo_line.width - 2;
2239 GfxDrawLine(colpos, top, colpos, bot, CARGO_LINE_COLOUR);
2240 colpos += 1 + CargoesField::cargo_space.width;
2241 }
2242
2243 Cargoes hor_left, hor_right;
2244 if (_current_text_dir == TD_RTL) {
2245 hor_left = this->u.cargo.cust_cargoes;
2246 hor_right = this->u.cargo.supp_cargoes;
2247 } else {
2248 hor_left = this->u.cargo.supp_cargoes;
2249 hor_right = this->u.cargo.cust_cargoes;
2250 }
2251 ypos += CargoesField::cargo_border.height + vert_inter_industry_space / 2 + (GetCharacterHeight(FS_NORMAL) - CargoesField::cargo_line.height) / 2;
2252 for (uint i = 0; i < MAX_CARGOES; i++) {
2253 if (HasBit(hor_left, i)) {
2254 int col = i;
2255 int dx = 0;
2256 const CargoSpec *csp = CargoSpec::Get(this->u.cargo.vertical_cargoes[col]);
2257 for (; col > 0; col--) {
2258 int lf = cargo_base + col * CargoesField::cargo_line.width + (col - 1) * CargoesField::cargo_space.width;
2259 DrawHorConnection(lf, lf + CargoesField::cargo_space.width - dx, ypos, csp);
2260 dx = 1;
2261 }
2262 DrawHorConnection(xpos, cargo_base - dx, ypos, csp);
2263 }
2264 if (HasBit(hor_right, i)) {
2265 int col = i;
2266 int dx = 0;
2267 const CargoSpec *csp = CargoSpec::Get(this->u.cargo.vertical_cargoes[col]);
2268 for (; col < this->u.cargo.num_cargoes - 1; col++) {
2269 int lf = cargo_base + (col + 1) * CargoesField::cargo_line.width + col * CargoesField::cargo_space.width;
2270 DrawHorConnection(lf + dx - 1, lf + CargoesField::cargo_space.width - 1, ypos, csp);
2271 dx = 1;
2272 }
2273 DrawHorConnection(cargo_base + col * CargoesField::cargo_space.width + (col + 1) * CargoesField::cargo_line.width - 1 + dx, xpos + CargoesField::cargo_field_width - 1, ypos, csp);
2274 }
2275 ypos += GetCharacterHeight(FS_NORMAL) + CargoesField::cargo_space.height;
2276 }
2277 break;
2278 }
2279
2280 case CFT_CARGO_LABEL:
2281 ypos += CargoesField::cargo_border.height + vert_inter_industry_space / 2;
2282 for (uint i = 0; i < MAX_CARGOES; i++) {
2283 if (IsValidCargoID(this->u.cargo_label.cargoes[i])) {
2284 const CargoSpec *csp = CargoSpec::Get(this->u.cargo_label.cargoes[i]);
2285 DrawString(xpos + WidgetDimensions::scaled.framerect.left, xpos + industry_width - 1 - WidgetDimensions::scaled.framerect.right, ypos, csp->name, TC_WHITE,
2286 (this->u.cargo_label.left_align) ? SA_LEFT : SA_RIGHT);
2287 }
2288 ypos += GetCharacterHeight(FS_NORMAL) + CargoesField::cargo_space.height;
2289 }
2290 break;
2291
2292 default:
2293 NOT_REACHED();
2294 }
2295 }
2296
2304 CargoID CargoClickedAt(const CargoesField *left, const CargoesField *right, Point pt) const
2305 {
2306 assert(this->type == CFT_CARGO);
2307
2308 /* Vertical matching. */
2309 int cpos = this->GetCargoBase(0);
2310 uint col;
2311 for (col = 0; col < this->u.cargo.num_cargoes; col++) {
2312 if (pt.x < cpos) break;
2313 if (pt.x < cpos + (int)CargoesField::cargo_line.width) return this->u.cargo.vertical_cargoes[col];
2314 cpos += CargoesField::cargo_line.width + CargoesField::cargo_space.width;
2315 }
2316 /* col = 0 -> left of first col, 1 -> left of 2nd col, ... this->u.cargo.num_cargoes right of last-col. */
2317
2318 int vpos = vert_inter_industry_space / 2 + CargoesField::cargo_border.width;
2319 uint row;
2320 for (row = 0; row < MAX_CARGOES; row++) {
2321 if (pt.y < vpos) return INVALID_CARGO;
2322 if (pt.y < vpos + GetCharacterHeight(FS_NORMAL)) break;
2323 vpos += GetCharacterHeight(FS_NORMAL) + CargoesField::cargo_space.width;
2324 }
2325 if (row == MAX_CARGOES) return INVALID_CARGO;
2326
2327 /* row = 0 -> at first horizontal row, row = 1 -> second horizontal row, 2 = 3rd horizontal row. */
2328 if (col == 0) {
2329 if (HasBit(this->u.cargo.supp_cargoes, row)) return this->u.cargo.vertical_cargoes[row];
2330 if (left != nullptr) {
2331 if (left->type == CFT_INDUSTRY) return left->u.industry.other_produced[row];
2332 if (left->type == CFT_CARGO_LABEL && !left->u.cargo_label.left_align) return left->u.cargo_label.cargoes[row];
2333 }
2334 return INVALID_CARGO;
2335 }
2336 if (col == this->u.cargo.num_cargoes) {
2337 if (HasBit(this->u.cargo.cust_cargoes, row)) return this->u.cargo.vertical_cargoes[row];
2338 if (right != nullptr) {
2339 if (right->type == CFT_INDUSTRY) return right->u.industry.other_accepted[row];
2340 if (right->type == CFT_CARGO_LABEL && right->u.cargo_label.left_align) return right->u.cargo_label.cargoes[row];
2341 }
2342 return INVALID_CARGO;
2343 }
2344 if (row >= col) {
2345 /* Clicked somewhere in-between vertical cargo connection.
2346 * Since the horizontal connection is made in the same order as the vertical list, the above condition
2347 * ensures we are left-below the main diagonal, thus at the supplying side.
2348 */
2349 if (HasBit(this->u.cargo.supp_cargoes, row)) return this->u.cargo.vertical_cargoes[row];
2350 return INVALID_CARGO;
2351 }
2352 /* Clicked at a customer connection. */
2353 if (HasBit(this->u.cargo.cust_cargoes, row)) return this->u.cargo.vertical_cargoes[row];
2354 return INVALID_CARGO;
2355 }
2356
2362 CargoID CargoLabelClickedAt(Point pt) const
2363 {
2364 assert(this->type == CFT_CARGO_LABEL);
2365
2366 int vpos = vert_inter_industry_space / 2 + CargoesField::cargo_border.height;
2367 uint row;
2368 for (row = 0; row < MAX_CARGOES; row++) {
2369 if (pt.y < vpos) return INVALID_CARGO;
2370 if (pt.y < vpos + GetCharacterHeight(FS_NORMAL)) break;
2371 vpos += GetCharacterHeight(FS_NORMAL) + CargoesField::cargo_space.height;
2372 }
2373 if (row == MAX_CARGOES) return INVALID_CARGO;
2374 return this->u.cargo_label.cargoes[row];
2375 }
2376
2377 private:
2385 static void DrawHorConnection(int left, int right, int top, const CargoSpec *csp)
2386 {
2387 GfxDrawLine(left, top, right, top, CARGO_LINE_COLOUR);
2388 GfxFillRect(left, top + 1, right, top + CargoesField::cargo_line.height - 2, csp->legend_colour, FILLRECT_OPAQUE);
2389 GfxDrawLine(left, top + CargoesField::cargo_line.height - 1, right, top + CargoesField::cargo_line.height - 1, CARGO_LINE_COLOUR);
2390 }
2391 };
2392
2393 static_assert(MAX_CARGOES >= cpp_lengthof(IndustrySpec, produced_cargo));
2394 static_assert(MAX_CARGOES >= cpp_lengthof(IndustrySpec, accepts_cargo));
2395
2396 Dimension CargoesField::legend;
2397 Dimension CargoesField::cargo_border;
2398 Dimension CargoesField::cargo_line;
2399 Dimension CargoesField::cargo_space;
2400 Dimension CargoesField::cargo_stub;
2401
2402 int CargoesField::small_height;
2403 int CargoesField::normal_height;
2404 int CargoesField::industry_width;
2405 int CargoesField::cargo_field_width;
2406 uint CargoesField::max_cargoes;
2407 int CargoesField::vert_inter_industry_space;
2408
2409 int CargoesField::blob_distance;
2410
2411 const int CargoesField::INDUSTRY_LINE_COLOUR = PC_YELLOW;
2412 const int CargoesField::CARGO_LINE_COLOUR = PC_YELLOW;
2413
2415 struct CargoesRow {
2416 CargoesField columns[5];
2417
2422 void ConnectIndustryProduced(int column)
2423 {
2424 CargoesField *ind_fld = this->columns + column;
2425 CargoesField *cargo_fld = this->columns + column + 1;
2426 assert(ind_fld->type == CFT_INDUSTRY && cargo_fld->type == CFT_CARGO);
2427
2428 std::fill(std::begin(ind_fld->u.industry.other_produced), std::end(ind_fld->u.industry.other_produced), INVALID_CARGO);
2429
2430 if (ind_fld->u.industry.ind_type < NUM_INDUSTRYTYPES) {
2431 CargoID others[MAX_CARGOES]; // Produced cargoes not carried in the cargo column.
2432 int other_count = 0;
2433
2434 const IndustrySpec *indsp = GetIndustrySpec(ind_fld->u.industry.ind_type);
2435 assert(CargoesField::max_cargoes <= lengthof(indsp->produced_cargo));
2436 for (uint i = 0; i < CargoesField::max_cargoes; i++) {
2437 int col = cargo_fld->ConnectCargo(indsp->produced_cargo[i], true);
2438 if (col < 0) others[other_count++] = indsp->produced_cargo[i];
2439 }
2440
2441 /* Allocate other cargoes in the empty holes of the horizontal cargo connections. */
2442 for (uint i = 0; i < CargoesField::max_cargoes && other_count > 0; i++) {
2443 if (HasBit(cargo_fld->u.cargo.supp_cargoes, i)) ind_fld->u.industry.other_produced[i] = others[--other_count];
2444 }
2445 } else {
2446 /* Houses only display cargo that towns produce. */
2447 for (uint i = 0; i < cargo_fld->u.cargo.num_cargoes; i++) {
2448 CargoID cid = cargo_fld->u.cargo.vertical_cargoes[i];
2449 TownProductionEffect tpe = CargoSpec::Get(cid)->town_production_effect;
2450 if (tpe == TPE_PASSENGERS || tpe == TPE_MAIL) cargo_fld->ConnectCargo(cid, true);
2451 }
2452 }
2453 }
2454
2460 void MakeCargoLabel(int column, bool accepting)
2461 {
2462 CargoID cargoes[MAX_CARGOES];
2463 std::fill(std::begin(cargoes), std::end(cargoes), INVALID_CARGO);
2464
2465 CargoesField *label_fld = this->columns + column;
2466 CargoesField *cargo_fld = this->columns + (accepting ? column - 1 : column + 1);
2467
2468 assert(cargo_fld->type == CFT_CARGO && label_fld->type == CFT_EMPTY);
2469 for (uint i = 0; i < cargo_fld->u.cargo.num_cargoes; i++) {
2470 int col = cargo_fld->ConnectCargo(cargo_fld->u.cargo.vertical_cargoes[i], !accepting);
2471 if (col >= 0) cargoes[col] = cargo_fld->u.cargo.vertical_cargoes[i];
2472 }
2473 label_fld->MakeCargoLabel(cargoes, lengthof(cargoes), accepting);
2474 }
2475
2476
2481 void ConnectIndustryAccepted(int column)
2482 {
2483 CargoesField *ind_fld = this->columns + column;
2484 CargoesField *cargo_fld = this->columns + column - 1;
2485 assert(ind_fld->type == CFT_INDUSTRY && cargo_fld->type == CFT_CARGO);
2486
2487 std::fill(std::begin(ind_fld->u.industry.other_accepted), std::end(ind_fld->u.industry.other_accepted), INVALID_CARGO);
2488
2489 if (ind_fld->u.industry.ind_type < NUM_INDUSTRYTYPES) {
2490 CargoID others[MAX_CARGOES]; // Accepted cargoes not carried in the cargo column.
2491 int other_count = 0;
2492
2493 const IndustrySpec *indsp = GetIndustrySpec(ind_fld->u.industry.ind_type);
2494 assert(CargoesField::max_cargoes <= lengthof(indsp->accepts_cargo));
2495 for (uint i = 0; i < CargoesField::max_cargoes; i++) {
2496 int col = cargo_fld->ConnectCargo(indsp->accepts_cargo[i], false);
2497 if (col < 0) others[other_count++] = indsp->accepts_cargo[i];
2498 }
2499
2500 /* Allocate other cargoes in the empty holes of the horizontal cargo connections. */
2501 for (uint i = 0; i < CargoesField::max_cargoes && other_count > 0; i++) {
2502 if (!HasBit(cargo_fld->u.cargo.cust_cargoes, i)) ind_fld->u.industry.other_accepted[i] = others[--other_count];
2503 }
2504 } else {
2505 /* Houses only display what is demanded. */
2506 for (uint i = 0; i < cargo_fld->u.cargo.num_cargoes; i++) {
2507 for (uint h = 0; h < NUM_HOUSES; h++) {
2508 HouseSpec *hs = HouseSpec::Get(h);
2509 if (!hs->enabled) continue;
2510
2511 for (uint j = 0; j < lengthof(hs->accepts_cargo); j++) {
2512 if (hs->cargo_acceptance[j] > 0 && cargo_fld->u.cargo.vertical_cargoes[i] == hs->accepts_cargo[j]) {
2513 cargo_fld->ConnectCargo(cargo_fld->u.cargo.vertical_cargoes[i], false);
2514 goto next_cargo;
2515 }
2516 }
2517 }
2518 next_cargo: ;
2519 }
2520 }
2521 }
2522 };
2523
2524
2552 struct IndustryCargoesWindow : public Window {
2553 typedef std::vector<CargoesRow> Fields;
2554
2555 Fields fields;
2556 uint ind_cargo;
2557 Dimension cargo_textsize;
2558 Dimension ind_textsize;
2559 Scrollbar *vscroll;
2560
2561 IndustryCargoesWindow(int id) : Window(&_industry_cargoes_desc)
2562 {
2563 this->OnInit();
2564 this->CreateNestedTree();
2565 this->vscroll = this->GetScrollbar(WID_IC_SCROLLBAR);
2566 this->FinishInitNested(0);
2567 this->OnInvalidateData(id);
2568 }
2569
2570 void OnInit() override
2571 {
2572 /* Initialize static CargoesField size variables. */
2573 Dimension d = GetStringBoundingBox(STR_INDUSTRY_CARGOES_PRODUCERS);
2574 d = maxdim(d, GetStringBoundingBox(STR_INDUSTRY_CARGOES_CUSTOMERS));
2575 d.width += WidgetDimensions::scaled.frametext.Horizontal();
2576 d.height += WidgetDimensions::scaled.frametext.Vertical();
2577 CargoesField::small_height = d.height;
2578
2579 /* Size of the legend blob -- slightly larger than the smallmap legend blob. */
2580 CargoesField::legend.height = GetCharacterHeight(FS_SMALL);
2581 CargoesField::legend.width = CargoesField::legend.height * 9 / 6;
2582
2583 /* Size of cargo lines. */
2584 CargoesField::cargo_line.width = ScaleGUITrad(6);
2585 CargoesField::cargo_line.height = CargoesField::cargo_line.width;
2586
2587 /* Size of border between cargo lines and industry boxes. */
2588 CargoesField::cargo_border.width = CargoesField::cargo_line.width * 3 / 2;
2589 CargoesField::cargo_border.height = CargoesField::cargo_line.width / 2;
2590
2591 /* Size of space between cargo lines. */
2592 CargoesField::cargo_space.width = CargoesField::cargo_line.width / 2;
2593 CargoesField::cargo_space.height = CargoesField::cargo_line.height / 2;
2594
2595 /* Size of cargo stub (unconnected cargo line.) */
2596 CargoesField::cargo_stub.width = CargoesField::cargo_line.width / 2;
2597 CargoesField::cargo_stub.height = CargoesField::cargo_line.height; /* Unused */
2598
2599 CargoesField::vert_inter_industry_space = WidgetDimensions::scaled.vsep_wide;
2600 CargoesField::blob_distance = WidgetDimensions::scaled.hsep_normal;
2601
2602 /* Decide about the size of the box holding the text of an industry type. */
2603 this->ind_textsize.width = 0;
2604 this->ind_textsize.height = 0;
2605 CargoesField::max_cargoes = 0;
2606 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2607 const IndustrySpec *indsp = GetIndustrySpec(it);
2608 if (!indsp->enabled) continue;
2609 this->ind_textsize = maxdim(this->ind_textsize, GetStringBoundingBox(indsp->name));
2610 CargoesField::max_cargoes = std::max<uint>(CargoesField::max_cargoes, std::count_if(indsp->accepts_cargo, endof(indsp->accepts_cargo), IsValidCargoID));
2611 CargoesField::max_cargoes = std::max<uint>(CargoesField::max_cargoes, std::count_if(indsp->produced_cargo, endof(indsp->produced_cargo), IsValidCargoID));
2612 }
2613 d.width = std::max(d.width, this->ind_textsize.width);
2614 d.height = this->ind_textsize.height;
2615 this->ind_textsize = maxdim(this->ind_textsize, GetStringBoundingBox(STR_INDUSTRY_CARGOES_SELECT_INDUSTRY));
2616
2617 /* Compute max size of the cargo texts. */
2618 this->cargo_textsize.width = 0;
2619 this->cargo_textsize.height = 0;
2620 for (const CargoSpec *csp : CargoSpec::Iterate()) {
2621 if (!csp->IsValid()) continue;
2622 this->cargo_textsize = maxdim(this->cargo_textsize, GetStringBoundingBox(csp->name));
2623 }
2624 d = maxdim(d, this->cargo_textsize); // Box must also be wide enough to hold any cargo label.
2625 this->cargo_textsize = maxdim(this->cargo_textsize, GetStringBoundingBox(STR_INDUSTRY_CARGOES_SELECT_CARGO));
2626
2627 d.width += WidgetDimensions::scaled.frametext.Horizontal();
2628 /* Ensure the height is enough for the industry type text, for the horizontal connections, and for the cargo labels. */
2629 uint min_ind_height = CargoesField::cargo_border.height * 2 + CargoesField::max_cargoes * GetCharacterHeight(FS_NORMAL) + (CargoesField::max_cargoes - 1) * CargoesField::cargo_space.height;
2630 d.height = std::max(d.height + WidgetDimensions::scaled.frametext.Vertical(), min_ind_height);
2631
2632 CargoesField::industry_width = d.width;
2633 CargoesField::normal_height = d.height + CargoesField::vert_inter_industry_space;
2634
2635 /* Width of a #CFT_CARGO field. */
2636 CargoesField::cargo_field_width = CargoesField::cargo_border.width * 2 + CargoesField::cargo_line.width * CargoesField::max_cargoes + CargoesField::cargo_space.width * (CargoesField::max_cargoes - 1);
2637 }
2638
2639 void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
2640 {
2641 switch (widget) {
2642 case WID_IC_PANEL:
2643 resize->height = CargoesField::normal_height;
2644 size->width = CargoesField::industry_width * 3 + CargoesField::cargo_field_width * 2 + WidgetDimensions::scaled.frametext.Horizontal();
2645 size->height = CargoesField::small_height + 2 * resize->height + WidgetDimensions::scaled.frametext.Vertical();
2646 break;
2647
2648 case WID_IC_IND_DROPDOWN:
2649 size->width = std::max(size->width, this->ind_textsize.width + padding.width);
2650 break;
2651
2652 case WID_IC_CARGO_DROPDOWN:
2653 size->width = std::max(size->width, this->cargo_textsize.width + padding.width);
2654 break;
2655 }
2656 }
2657
2658
2659 CargoesFieldType type;
2660 void SetStringParameters (WidgetID widget) const override
2661 {
2662 if (widget != WID_IC_CAPTION) return;
2663
2664 if (this->ind_cargo < NUM_INDUSTRYTYPES) {
2665 const IndustrySpec *indsp = GetIndustrySpec(this->ind_cargo);
2666 SetDParam(0, indsp->name);
2667 } else {
2668 const CargoSpec *csp = CargoSpec::Get(this->ind_cargo - NUM_INDUSTRYTYPES);
2669 SetDParam(0, csp->name);
2670 }
2671 }
2672
2681 static bool HasCommonValidCargo(const CargoID *cargoes1, uint length1, const CargoID *cargoes2, uint length2)
2682 {
2683 while (length1 > 0) {
2684 if (IsValidCargoID(*cargoes1)) {
2685 for (uint i = 0; i < length2; i++) if (*cargoes1 == cargoes2[i]) return true;
2686 }
2687 cargoes1++;
2688 length1--;
2689 }
2690 return false;
2691 }
2692
2699 static bool HousesCanSupply(const CargoID *cargoes, uint length)
2700 {
2701 for (uint i = 0; i < length; i++) {
2702 CargoID cid = cargoes[i];
2703 if (!IsValidCargoID(cid)) continue;
2704 TownProductionEffect tpe = CargoSpec::Get(cid)->town_production_effect;
2705 if (tpe == TPE_PASSENGERS || tpe == TPE_MAIL) return true;
2706 }
2707 return false;
2708 }
2709
2716 static bool HousesCanAccept(const CargoID *cargoes, uint length)
2717 {
2718 HouseZones climate_mask;
2719 switch (_settings_game.game_creation.landscape) {
2720 case LT_TEMPERATE: climate_mask = HZ_TEMP; break;
2721 case LT_ARCTIC: climate_mask = HZ_SUBARTC_ABOVE | HZ_SUBARTC_BELOW; break;
2722 case LT_TROPIC: climate_mask = HZ_SUBTROPIC; break;
2723 case LT_TOYLAND: climate_mask = HZ_TOYLND; break;
2724 default: NOT_REACHED();
2725 }
2726 for (uint i = 0; i < length; i++) {
2727 if (!IsValidCargoID(cargoes[i])) continue;
2728
2729 for (uint h = 0; h < NUM_HOUSES; h++) {
2730 HouseSpec *hs = HouseSpec::Get(h);
2731 if (!hs->enabled || !(hs->building_availability & climate_mask)) continue;
2732
2733 for (uint j = 0; j < lengthof(hs->accepts_cargo); j++) {
2734 if (hs->cargo_acceptance[j] > 0 && cargoes[i] == hs->accepts_cargo[j]) return true;
2735 }
2736 }
2737 }
2738 return false;
2739 }
2740
2747 static int CountMatchingAcceptingIndustries(const CargoID *cargoes, uint length)
2748 {
2749 int count = 0;
2750 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2751 const IndustrySpec *indsp = GetIndustrySpec(it);
2752 if (!indsp->enabled) continue;
2753
2754 if (HasCommonValidCargo(cargoes, length, indsp->accepts_cargo, lengthof(indsp->accepts_cargo))) count++;
2755 }
2756 return count;
2757 }
2758
2765 static int CountMatchingProducingIndustries(const CargoID *cargoes, uint length)
2766 {
2767 int count = 0;
2768 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2769 const IndustrySpec *indsp = GetIndustrySpec(it);
2770 if (!indsp->enabled) continue;
2771
2772 if (HasCommonValidCargo(cargoes, length, indsp->produced_cargo, lengthof(indsp->produced_cargo))) count++;
2773 }
2774 return count;
2775 }
2776
2783 void ShortenCargoColumn(int column, int top, int bottom)
2784 {
2785 while (top < bottom && !this->fields[top].columns[column].HasConnection()) {
2786 this->fields[top].columns[column].MakeEmpty(CFT_EMPTY);
2787 top++;
2788 }
2789 this->fields[top].columns[column].u.cargo.top_end = true;
2790
2791 while (bottom > top && !this->fields[bottom].columns[column].HasConnection()) {
2792 this->fields[bottom].columns[column].MakeEmpty(CFT_EMPTY);
2793 bottom--;
2794 }
2795 this->fields[bottom].columns[column].u.cargo.bottom_end = true;
2796 }
2797
2804 void PlaceIndustry(int row, int col, IndustryType it)
2805 {
2806 assert(this->fields[row].columns[col].type == CFT_EMPTY);
2807 this->fields[row].columns[col].MakeIndustry(it);
2808 if (col == 0) {
2809 this->fields[row].ConnectIndustryProduced(col);
2810 } else {
2811 this->fields[row].ConnectIndustryAccepted(col);
2812 }
2813 }
2814
2818 void NotifySmallmap()
2819 {
2820 if (!this->IsWidgetLowered(WID_IC_NOTIFY)) return;
2821
2822 /* Only notify the smallmap window if it exists. In particular, do not
2823 * bring it to the front to prevent messing up any nice layout of the user. */
2824 InvalidateWindowClassesData(WC_SMALLMAP, 0);
2825 }
2826
2831 void ComputeIndustryDisplay(IndustryType displayed_it)
2832 {
2833 this->GetWidget<NWidgetCore>(WID_IC_CAPTION)->widget_data = STR_INDUSTRY_CARGOES_INDUSTRY_CAPTION;
2834 this->ind_cargo = displayed_it;
2835 _displayed_industries.reset();
2836 _displayed_industries.set(displayed_it);
2837
2838 this->fields.clear();
2839 CargoesRow &first_row = this->fields.emplace_back();
2840 first_row.columns[0].MakeHeader(STR_INDUSTRY_CARGOES_PRODUCERS);
2841 first_row.columns[1].MakeEmpty(CFT_SMALL_EMPTY);
2842 first_row.columns[2].MakeEmpty(CFT_SMALL_EMPTY);
2843 first_row.columns[3].MakeEmpty(CFT_SMALL_EMPTY);
2844 first_row.columns[4].MakeHeader(STR_INDUSTRY_CARGOES_CUSTOMERS);
2845
2846 const IndustrySpec *central_sp = GetIndustrySpec(displayed_it);
2847 bool houses_supply = HousesCanSupply(central_sp->accepts_cargo, lengthof(central_sp->accepts_cargo));
2848 bool houses_accept = HousesCanAccept(central_sp->produced_cargo, lengthof(central_sp->produced_cargo));
2849 /* Make a field consisting of two cargo columns. */
2850 int num_supp = CountMatchingProducingIndustries(central_sp->accepts_cargo, lengthof(central_sp->accepts_cargo)) + houses_supply;
2851 int num_cust = CountMatchingAcceptingIndustries(central_sp->produced_cargo, lengthof(central_sp->produced_cargo)) + houses_accept;
2852 int num_indrows = std::max(3, std::max(num_supp, num_cust)); // One is needed for the 'it' industry, and 2 for the cargo labels.
2853 for (int i = 0; i < num_indrows; i++) {
2854 CargoesRow &row = this->fields.emplace_back();
2855 row.columns[0].MakeEmpty(CFT_EMPTY);
2856 row.columns[1].MakeCargo(central_sp->accepts_cargo, lengthof(central_sp->accepts_cargo));
2857 row.columns[2].MakeEmpty(CFT_EMPTY);
2858 row.columns[3].MakeCargo(central_sp->produced_cargo, lengthof(central_sp->produced_cargo));
2859 row.columns[4].MakeEmpty(CFT_EMPTY);
2860 }
2861 /* Add central industry. */
2862 int central_row = 1 + num_indrows / 2;
2863 this->fields[central_row].columns[2].MakeIndustry(displayed_it);
2864 this->fields[central_row].ConnectIndustryProduced(2);
2865 this->fields[central_row].ConnectIndustryAccepted(2);
2866
2867 /* Add cargo labels. */
2868 this->fields[central_row - 1].MakeCargoLabel(2, true);
2869 this->fields[central_row + 1].MakeCargoLabel(2, false);
2870
2871 /* Add suppliers and customers of the 'it' industry. */
2872 int supp_count = 0;
2873 int cust_count = 0;
2874 for (IndustryType it : _sorted_industry_types) {
2875 const IndustrySpec *indsp = GetIndustrySpec(it);
2876 if (!indsp->enabled) continue;
2877
2878 if (HasCommonValidCargo(central_sp->accepts_cargo, lengthof(central_sp->accepts_cargo), indsp->produced_cargo, lengthof(indsp->produced_cargo))) {
2879 this->PlaceIndustry(1 + supp_count * num_indrows / num_supp, 0, it);
2880 _displayed_industries.set(it);
2881 supp_count++;
2882 }
2883 if (HasCommonValidCargo(central_sp->produced_cargo, lengthof(central_sp->produced_cargo), indsp->accepts_cargo, lengthof(indsp->accepts_cargo))) {
2884 this->PlaceIndustry(1 + cust_count * num_indrows / num_cust, 4, it);
2885 _displayed_industries.set(it);
2886 cust_count++;
2887 }
2888 }
2889 if (houses_supply) {
2890 this->PlaceIndustry(1 + supp_count * num_indrows / num_supp, 0, NUM_INDUSTRYTYPES);
2891 supp_count++;
2892 }
2893 if (houses_accept) {
2894 this->PlaceIndustry(1 + cust_count * num_indrows / num_cust, 4, NUM_INDUSTRYTYPES);
2895 cust_count++;
2896 }
2897
2898 this->ShortenCargoColumn(1, 1, num_indrows);
2899 this->ShortenCargoColumn(3, 1, num_indrows);
2900 this->vscroll->SetCount(num_indrows);
2901 this->SetDirty();
2902 this->NotifySmallmap();
2903 }
2904
2909 void ComputeCargoDisplay(CargoID cid)
2910 {
2911 this->GetWidget<NWidgetCore>(WID_IC_CAPTION)->widget_data = STR_INDUSTRY_CARGOES_CARGO_CAPTION;
2912 this->ind_cargo = cid + NUM_INDUSTRYTYPES;
2913 _displayed_industries.reset();
2914
2915 this->fields.clear();
2916 CargoesRow &first_row = this->fields.emplace_back();
2917 first_row.columns[0].MakeHeader(STR_INDUSTRY_CARGOES_PRODUCERS);
2918 first_row.columns[1].MakeEmpty(CFT_SMALL_EMPTY);
2919 first_row.columns[2].MakeHeader(STR_INDUSTRY_CARGOES_CUSTOMERS);
2920 first_row.columns[3].MakeEmpty(CFT_SMALL_EMPTY);
2921 first_row.columns[4].MakeEmpty(CFT_SMALL_EMPTY);
2922
2923 bool houses_supply = HousesCanSupply(&cid, 1);
2924 bool houses_accept = HousesCanAccept(&cid, 1);
2925 int num_supp = CountMatchingProducingIndustries(&cid, 1) + houses_supply + 1; // Ensure room for the cargo label.
2926 int num_cust = CountMatchingAcceptingIndustries(&cid, 1) + houses_accept;
2927 int num_indrows = std::max(num_supp, num_cust);
2928 for (int i = 0; i < num_indrows; i++) {
2929 CargoesRow &row = this->fields.emplace_back();
2930 row.columns[0].MakeEmpty(CFT_EMPTY);
2931 row.columns[1].MakeCargo(&cid, 1);
2932 row.columns[2].MakeEmpty(CFT_EMPTY);
2933 row.columns[3].MakeEmpty(CFT_EMPTY);
2934 row.columns[4].MakeEmpty(CFT_EMPTY);
2935 }
2936
2937 this->fields[num_indrows].MakeCargoLabel(0, false); // Add cargo labels at the left bottom.
2938
2939 /* Add suppliers and customers of the cargo. */
2940 int supp_count = 0;
2941 int cust_count = 0;
2942 for (IndustryType it : _sorted_industry_types) {
2943 const IndustrySpec *indsp = GetIndustrySpec(it);
2944 if (!indsp->enabled) continue;
2945
2946 if (HasCommonValidCargo(&cid, 1, indsp->produced_cargo, lengthof(indsp->produced_cargo))) {
2947 this->PlaceIndustry(1 + supp_count * num_indrows / num_supp, 0, it);
2948 _displayed_industries.set(it);
2949 supp_count++;
2950 }
2951 if (HasCommonValidCargo(&cid, 1, indsp->accepts_cargo, lengthof(indsp->accepts_cargo))) {
2952 this->PlaceIndustry(1 + cust_count * num_indrows / num_cust, 2, it);
2953 _displayed_industries.set(it);
2954 cust_count++;
2955 }
2956 }
2957 if (houses_supply) {
2958 this->PlaceIndustry(1 + supp_count * num_indrows / num_supp, 0, NUM_INDUSTRYTYPES);
2959 supp_count++;
2960 }
2961 if (houses_accept) {
2962 this->PlaceIndustry(1 + cust_count * num_indrows / num_cust, 2, NUM_INDUSTRYTYPES);
2963 cust_count++;
2964 }
2965
2966 this->ShortenCargoColumn(1, 1, num_indrows);
2967 this->vscroll->SetCount(num_indrows);
2968 this->SetDirty();
2969 this->NotifySmallmap();
2970 }
2971
2979 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
2980 {
2981 if (!gui_scope) return;
2982 if (data == NUM_INDUSTRYTYPES) {
2983 this->RaiseWidgetWhenLowered(WID_IC_NOTIFY);
2984 return;
2985 }
2986
2987 assert(data >= 0 && data < NUM_INDUSTRYTYPES);
2988 this->ComputeIndustryDisplay(data);
2989 }
2990
2991 void DrawWidget(const Rect &r, WidgetID widget) const override
2992 {
2993 if (widget != WID_IC_PANEL) return;
2994
2995 Rect ir = r.Shrink(WidgetDimensions::scaled.bevel);
2996 DrawPixelInfo tmp_dpi;
2997 if (!FillDrawPixelInfo(&tmp_dpi, ir)) return;
2998 AutoRestoreBackup dpi_backup(_cur_dpi, &tmp_dpi);
2999
3000 int left_pos = WidgetDimensions::scaled.frametext.left - WidgetDimensions::scaled.bevel.left;
3001 if (this->ind_cargo >= NUM_INDUSTRYTYPES) left_pos += (CargoesField::industry_width + CargoesField::cargo_field_width) / 2;
3002 int last_column = (this->ind_cargo < NUM_INDUSTRYTYPES) ? 4 : 2;
3003
3004 const NWidgetBase *nwp = this->GetWidget<NWidgetBase>(WID_IC_PANEL);
3005 int vpos = WidgetDimensions::scaled.frametext.top - WidgetDimensions::scaled.bevel.top - this->vscroll->GetPosition() * nwp->resize_y;
3006 int row_height = CargoesField::small_height;
3007 for (const auto &field : this->fields) {
3008 if (vpos + row_height >= 0) {
3009 int xpos = left_pos;
3010 int col, dir;
3011 if (_current_text_dir == TD_RTL) {
3012 col = last_column;
3013 dir = -1;
3014 } else {
3015 col = 0;
3016 dir = 1;
3017 }
3018 while (col >= 0 && col <= last_column) {
3019 field.columns[col].Draw(xpos, vpos);
3020 xpos += (col & 1) ? CargoesField::cargo_field_width : CargoesField::industry_width;
3021 col += dir;
3022 }
3023 }
3024 vpos += row_height;
3025 if (vpos >= height) break;
3026 row_height = CargoesField::normal_height;
3027 }
3028 }
3029
3037 bool CalculatePositionInWidget(Point pt, Point *fieldxy, Point *xy)
3038 {
3039 const NWidgetBase *nw = this->GetWidget<NWidgetBase>(WID_IC_PANEL);
3040 pt.x -= nw->pos_x;
3041 pt.y -= nw->pos_y;
3042
3043 int vpos = WidgetDimensions::scaled.frametext.top + CargoesField::small_height - this->vscroll->GetPosition() * nw->resize_y;
3044 if (pt.y < vpos) return false;
3045
3046 int row = (pt.y - vpos) / CargoesField::normal_height; // row is relative to row 1.
3047 if (row + 1 >= (int)this->fields.size()) return false;
3048 vpos = pt.y - vpos - row * CargoesField::normal_height; // Position in the row + 1 field
3049 row++; // rebase row to match index of this->fields.
3050
3051 int xpos = 2 * WidgetDimensions::scaled.frametext.left + ((this->ind_cargo < NUM_INDUSTRYTYPES) ? 0 : (CargoesField::industry_width + CargoesField::cargo_field_width) / 2);
3052 if (pt.x < xpos) return false;
3053 int column;
3054 for (column = 0; column <= 5; column++) {
3055 int width = (column & 1) ? CargoesField::cargo_field_width : CargoesField::industry_width;
3056 if (pt.x < xpos + width) break;
3057 xpos += width;
3058 }
3059 int num_columns = (this->ind_cargo < NUM_INDUSTRYTYPES) ? 4 : 2;
3060 if (column > num_columns) return false;
3061 xpos = pt.x - xpos;
3062
3063 /* Return both positions, compensating for RTL languages (which works due to the equal symmetry in both displays). */
3064 fieldxy->y = row;
3065 xy->y = vpos;
3066 if (_current_text_dir == TD_RTL) {
3067 fieldxy->x = num_columns - column;
3068 xy->x = ((column & 1) ? CargoesField::cargo_field_width : CargoesField::industry_width) - xpos;
3069 } else {
3070 fieldxy->x = column;
3071 xy->x = xpos;
3072 }
3073 return true;
3074 }
3075
3076 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
3077 {
3078 switch (widget) {
3079 case WID_IC_PANEL: {
3080 Point fieldxy, xy;
3081 if (!CalculatePositionInWidget(pt, &fieldxy, &xy)) return;
3082
3083 const CargoesField *fld = this->fields[fieldxy.y].columns + fieldxy.x;
3084 switch (fld->type) {
3085 case CFT_INDUSTRY:
3086 if (fld->u.industry.ind_type < NUM_INDUSTRYTYPES) this->ComputeIndustryDisplay(fld->u.industry.ind_type);
3087 break;
3088
3089 case CFT_CARGO: {
3090 CargoesField *lft = (fieldxy.x > 0) ? this->fields[fieldxy.y].columns + fieldxy.x - 1 : nullptr;
3091 CargoesField *rgt = (fieldxy.x < 4) ? this->fields[fieldxy.y].columns + fieldxy.x + 1 : nullptr;
3092 CargoID cid = fld->CargoClickedAt(lft, rgt, xy);
3093 if (IsValidCargoID(cid)) this->ComputeCargoDisplay(cid);
3094 break;
3095 }
3096
3097 case CFT_CARGO_LABEL: {
3098 CargoID cid = fld->CargoLabelClickedAt(xy);
3099 if (IsValidCargoID(cid)) this->ComputeCargoDisplay(cid);
3100 break;
3101 }
3102
3103 default:
3104 break;
3105 }
3106 break;
3107 }
3108
3109 case WID_IC_NOTIFY:
3110 this->ToggleWidgetLoweredState(WID_IC_NOTIFY);
3111 this->SetWidgetDirty(WID_IC_NOTIFY);
3112 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
3113
3114 if (this->IsWidgetLowered(WID_IC_NOTIFY)) {
3115 if (FindWindowByClass(WC_SMALLMAP) == nullptr) ShowSmallMap();
3116 this->NotifySmallmap();
3117 }
3118 break;
3119
3120 case WID_IC_CARGO_DROPDOWN: {
3121 DropDownList lst;
3122 Dimension d = GetLargestCargoIconSize();
3123 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
3124 lst.push_back(std::make_unique<DropDownListIconItem>(d, cs->GetCargoIcon(), PAL_NONE, cs->name, cs->Index(), false));
3125 }
3126 if (!lst.empty()) {
3127 int selected = (this->ind_cargo >= NUM_INDUSTRYTYPES) ? (int)(this->ind_cargo - NUM_INDUSTRYTYPES) : -1;
3128 ShowDropDownList(this, std::move(lst), selected, WID_IC_CARGO_DROPDOWN);
3129 }
3130 break;
3131 }
3132
3133 case WID_IC_IND_DROPDOWN: {
3134 DropDownList lst;
3135 for (IndustryType ind : _sorted_industry_types) {
3136 const IndustrySpec *indsp = GetIndustrySpec(ind);
3137 if (!indsp->enabled) continue;
3138 lst.push_back(std::make_unique<DropDownListStringItem>(indsp->name, ind, false));
3139 }
3140 if (!lst.empty()) {
3141 int selected = (this->ind_cargo < NUM_INDUSTRYTYPES) ? (int)this->ind_cargo : -1;
3142 ShowDropDownList(this, std::move(lst), selected, WID_IC_IND_DROPDOWN);
3143 }
3144 break;
3145 }
3146 }
3147 }
3148
3149 void OnDropdownSelect(WidgetID widget, int index) override
3150 {
3151 if (index < 0) return;
3152
3153 switch (widget) {
3154 case WID_IC_CARGO_DROPDOWN:
3155 this->ComputeCargoDisplay(index);
3156 break;
3157
3158 case WID_IC_IND_DROPDOWN:
3159 this->ComputeIndustryDisplay(index);
3160 break;
3161 }
3162 }
3163
3164 bool OnTooltip([[maybe_unused]] Point pt, WidgetID widget, TooltipCloseCondition close_cond) override
3165 {
3166 if (widget != WID_IC_PANEL) return false;
3167
3168 Point fieldxy, xy;
3169 if (!CalculatePositionInWidget(pt, &fieldxy, &xy)) return false;
3170
3171 const CargoesField *fld = this->fields[fieldxy.y].columns + fieldxy.x;
3172 CargoID cid = INVALID_CARGO;
3173 switch (fld->type) {
3174 case CFT_CARGO: {
3175 CargoesField *lft = (fieldxy.x > 0) ? this->fields[fieldxy.y].columns + fieldxy.x - 1 : nullptr;
3176 CargoesField *rgt = (fieldxy.x < 4) ? this->fields[fieldxy.y].columns + fieldxy.x + 1 : nullptr;
3177 cid = fld->CargoClickedAt(lft, rgt, xy);
3178 break;
3179 }
3180
3181 case CFT_CARGO_LABEL: {
3182 cid = fld->CargoLabelClickedAt(xy);
3183 break;
3184 }
3185
3186 case CFT_INDUSTRY:
3187 if (fld->u.industry.ind_type < NUM_INDUSTRYTYPES && (this->ind_cargo >= NUM_INDUSTRYTYPES || fieldxy.x != 2)) {
3188 GuiShowTooltips(this, STR_INDUSTRY_CARGOES_INDUSTRY_TOOLTIP, close_cond);
3189 }
3190 return true;
3191
3192 default:
3193 break;
3194 }
3195 if (IsValidCargoID(cid) && (this->ind_cargo < NUM_INDUSTRYTYPES || cid != this->ind_cargo - NUM_INDUSTRYTYPES)) {
3196 const CargoSpec *csp = CargoSpec::Get(cid);
3197 SetDParam(0, csp->name);
3198 GuiShowTooltips(this, STR_INDUSTRY_CARGOES_CARGO_TOOLTIP, close_cond, 1);
3199 return true;
3200 }
3201
3202 return false;
3203 }
3204
3205 void OnResize() override
3206 {
3207 this->vscroll->SetCapacityFromWidget(this, WID_IC_PANEL, WidgetDimensions::scaled.framerect.top + CargoesField::small_height);
3208 }
3209 };
3210
3215 static void ShowIndustryCargoesWindow(IndustryType id)
3216 {
3217 if (id >= NUM_INDUSTRYTYPES) {
3218 for (IndustryType ind : _sorted_industry_types) {
3219 const IndustrySpec *indsp = GetIndustrySpec(ind);
3220 if (indsp->enabled) {
3221 id = ind;
3222 break;
3223 }
3224 }
3225 if (id >= NUM_INDUSTRYTYPES) return;
3226 }
3227
3228 Window *w = BringWindowToFrontById(WC_INDUSTRY_CARGOES, 0);
3229 if (w != nullptr) {
3230 w->InvalidateData(id);
3231 return;
3232 }
3233 new IndustryCargoesWindow(id);
3234 }
3235
3237 void ShowIndustryCargoesWindow()
3238 {
3239 ShowIndustryCargoesWindow(NUM_INDUSTRYTYPES);
3240 }
_sorted_industry_types
std::array< IndustryType, NUM_INDUSTRYTYPES > _sorted_industry_types
Industry types sorted by name.
Definition: industry_gui.cpp:220
ES_HANDLED
@ ES_HANDLED
The passed event is handled.
Definition: window_type.h:739
_nested_industry_view_widgets
static constexpr NWidgetPart _nested_industry_view_widgets[]
Widget definition of the view industry gui.
Definition: industry_gui.cpp:1194
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:437
MP_CLEAR
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition: tile_type.h:48
TC_FORCED
@ TC_FORCED
Ignore colour changes from strings.
Definition: gfx_type.h:278
SetFill
constexpr NWidgetPart SetFill(uint16_t fill_x, uint16_t fill_y)
Widget part function for setting filling.
Definition: widget_type.h:1143
ToPercent8
constexpr uint ToPercent8(uint i)
Converts a "fract" value 0..255 to "percent" value 0..100.
Definition: math_func.hpp:295
IndustryCargoesWindow::CountMatchingProducingIndustries
static int CountMatchingProducingIndustries(const CargoID *cargoes, uint length)
Count how many industries have produced cargoes in common with one of the supplied set.
Definition: industry_gui.cpp:2765
Window::SetTimeout
void SetTimeout()
Set the timeout flag of the window and initiate the timer.
Definition: window_gui.h:355
PRODLEVEL_MINIMUM
@ PRODLEVEL_MINIMUM
below this level, the industry is set to be closing
Definition: industry.h:35
sound_func.h
IndustryCargoesWindow::HousesCanAccept
static bool HousesCanAccept(const CargoID *cargoes, uint length)
Can houses be used as customers of the produced cargoes?
Definition: industry_gui.cpp:2716
CBM_IND_PRODUCTION_CARGO_ARRIVAL
@ CBM_IND_PRODUCTION_CARGO_ARRIVAL
call production callback when cargo arrives at the industry
Definition: newgrf_callbacks.h:365
NUM_INDUSTRYTYPES
static const IndustryType NUM_INDUSTRYTYPES
total number of industry types, new and old; limited to 240 because we need some special ids like INV...
Definition: industry_type.h:26
IndustrySpec::map_colour
byte map_colour
colour used for the small map
Definition: industrytype.h:126
SetBit
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
TPE_MAIL
@ TPE_MAIL
Cargo behaves mail-like for production.
Definition: cargotype.h:37
INDUSTRY_NUM_OUTPUTS
static const int INDUSTRY_NUM_OUTPUTS
Number of cargo types an industry can produce.
Definition: industry_type.h:39
CBM_IND_CARGO_SUFFIX
@ CBM_IND_CARGO_SUFFIX
cargo sub-type display
Definition: newgrf_callbacks.h:370
Pool::PoolItem<&_industry_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
ScrollMainWindowToTile
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition: viewport.cpp:2509
INDUSTRYBEH_CARGOTYPES_UNLIMITED
@ INDUSTRYBEH_CARGOTYPES_UNLIMITED
Allow produced/accepted cargoes callbacks to supply more than 2 and 3 types.
Definition: industrytype.h:80
IndustrySpec::UsesOriginalEconomy
bool UsesOriginalEconomy() const
Determines whether this industrytype uses standard/newgrf production changes.
Definition: industry_cmd.cpp:3149
CargoesField::num_cargoes
uint8_t num_cargoes
Number of cargoes.
Definition: industry_gui.cpp:2014
CargoesField::MakeCargo
void MakeCargo(const CargoID *cargoes, uint length, int count=-1, bool top_end=false, bool bottom_end=false)
Make a piece of cargo column.
Definition: industry_gui.cpp:2098
WC_INDUSTRY_CARGOES
@ WC_INDUSTRY_CARGOES
Industry cargoes chain; Window numbers:
Definition: window_type.h:516
IndustryCargoesWindow::HousesCanSupply
static bool HousesCanSupply(const CargoID *cargoes, uint length)
Can houses be used to supply one of the cargoes?
Definition: industry_gui.cpp:2699
IndustryTypeNameSorter
static bool IndustryTypeNameSorter(const IndustryType &a, const IndustryType &b)
Sort industry types by their name.
Definition: industry_gui.cpp:223
IndustryDirectoryWindow::OnHotkey
EventState OnHotkey(int hotkey) override
A hotkey has been pressed.
Definition: industry_gui.cpp:1882
CargoesField::INDUSTRY_LINE_COLOUR
static const int INDUSTRY_LINE_COLOUR
Line colour of the industry type box.
Definition: industry_gui.cpp:1992
querystring_gui.h
ShowExtraViewportWindow
void ShowExtraViewportWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
Definition: viewport_gui.cpp:156
BuildIndustryWindow::OnInit
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition: industry_gui.cpp:416
ShowQuery
void ShowQuery(StringID caption, StringID message, Window *parent, QueryCallbackProc *callback, bool focus)
Show a confirmation window with standard 'yes' and 'no' buttons The window is aligned to the centre o...
Definition: misc_gui.cpp:1231
HotkeyList
List of hotkeys for a window.
Definition: hotkeys.h:37
SetFocusedWindow
void SetFocusedWindow(Window *w)
Set the window that has the focus.
Definition: window.cpp:423
IndustryCargoesWindow::ComputeIndustryDisplay
void ComputeIndustryDisplay(IndustryType displayed_it)
Compute what and where to display for industry type it.
Definition: industry_gui.cpp:2831
CargoesField::other_produced
CargoID other_produced[MAX_CARGOES]
Cargoes produced but not used in this figure.
Definition: industry_gui.cpp:2007
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:30
IndustryDirectoryWindow::SorterType::ByType
@ ByType
Sorter type to sort by type.
command_func.h
WidgetDimensions::scaled
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition: window_gui.h:68
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:68
ShowErrorMessage
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
Definition: error_gui.cpp:367
WDF_CONSTRUCTION
@ WDF_CONSTRUCTION
This window is used for construction; close it whenever changing company.
Definition: window_gui.h:197
CargoesField::top_end
uint8_t top_end
Stop at the top of the vertical cargoes.
Definition: industry_gui.cpp:2015
dropdown_func.h
GUIList::SetFilterState
void SetFilterState(bool state)
Enable or disable the filter.
Definition: sortlist_type.h:327
Rect::Shrink
Rect Shrink(int s) const
Copy and shrink Rect by s pixels.
Definition: geometry_type.hpp:98
IndustryViewWindow::production_offset_y
int production_offset_y
The offset of the production texts/buttons.
Definition: industry_gui.cpp:808
smallmap_gui.h
StringFilter::IsEmpty
bool IsEmpty() const
Check whether any filter words were entered.
Definition: stringfilter_type.h:60
GameCreationSettings::landscape
byte landscape
the landscape we're currently in
Definition: settings_type.h:355
CFT_HEADER
@ CFT_HEADER
Header text.
Definition: industry_gui.cpp:1976
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
IndustryDirectoryWindow::BuildSortIndustriesList
void BuildSortIndustriesList()
(Re)Build industries list
Definition: industry_gui.cpp:1420
company_base.h
StringFilter::SetFilterTerm
void SetFilterTerm(const char *str)
Set the term to filter on.
Definition: stringfilter.cpp:28
IndustryCargoesWindow::ind_textsize
Dimension ind_textsize
Size to hold any industry type text, as well as STR_INDUSTRY_CARGOES_SELECT_INDUSTRY.
Definition: industry_gui.cpp:2558
NWID_HSCROLLBAR
@ NWID_HSCROLLBAR
Horizontal scrollbar.
Definition: widget_type.h:85
BuildIndustryWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: industry_gui.cpp:687
HouseSpec::accepts_cargo
CargoID accepts_cargo[HOUSE_NUM_ACCEPTS]
input cargo slots
Definition: house.h:108
NWidgetViewport
Nested widget to display a viewport in a window.
Definition: widget_type.h:666
Industry::ProducedCargo::history
std::array< ProducedHistory, 2 > history
History of cargo produced and transported.
Definition: industry.h:84
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:63
IndustryViewWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: industry_gui.cpp:1122
HZ_SUBTROPIC
@ HZ_SUBTROPIC
14 4000 can appear in subtropical climate
Definition: house.h:82
Window::SetWidgetDirty
void SetWidgetDirty(WidgetID widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:552
PRODLEVEL_CLOSURE
@ PRODLEVEL_CLOSURE
signal set to actually close the industry
Definition: industry.h:34
IndustrySpec::GetConstructionCost
Money GetConstructionCost() const
Get the cost for constructing this industry.
Definition: industry_cmd.cpp:3127
CSD_CARGO
@ CSD_CARGO
Display the cargo without sub-type (cb37 result 401).
Definition: industry_gui.cpp:67
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
IndustryViewWindow::EA_MULTIPLIER
@ EA_MULTIPLIER
Allow changing the production multiplier.
Definition: industry_gui.cpp:791
WID_IC_IND_DROPDOWN
@ WID_IC_IND_DROPDOWN
Select industry dropdown.
Definition: industry_widget.h:53
NWidgetViewport::InitializeViewport
void InitializeViewport(Window *w, std::variant< TileIndex, VehicleID > focus, ZoomLevel zoom)
Initialize the viewport of the window.
Definition: widget.cpp:2235
WF_DISABLE_VP_SCROLL
@ WF_DISABLE_VP_SCROLL
Window does not do autoscroll,.
Definition: window_gui.h:229
GUIList
List template of 'things' T to sort in a GUI.
Definition: sortlist_type.h:47
PC_WHITE
static const uint8_t PC_WHITE
White palette colour.
Definition: palette_func.h:58
Window::viewport
ViewportData * viewport
Pointer to viewport data, if present.
Definition: window_gui.h:312
WID_IC_NOTIFY
@ WID_IC_NOTIFY
Row of buttons at the bottom.
Definition: industry_widget.h:49
CargoesRow
A single row of CargoesField.
Definition: industry_gui.cpp:2415
IndustryDirectoryWindow::SetAcceptedCargoFilter
void SetAcceptedCargoFilter(CargoID cid)
Set accepted cargo filter for the industry list.
Definition: industry_gui.cpp:1369
Industry::ProducedCargo::cargo
CargoID cargo
Cargo type.
Definition: industry.h:81
IndustryViewWindow::IsNewGRFInspectable
bool IsNewGRFInspectable() const override
Is the data related to this window NewGRF inspectable?
Definition: industry_gui.cpp:1170
DropDownList
std::vector< std::unique_ptr< const DropDownListItem > > DropDownList
A drop down list is a collection of drop down list items.
Definition: dropdown_type.h:210
IndustryDirectoryWindow::SorterType::ByName
@ ByName
Sorter type to sort by name.
WID_IV_DISPLAY
@ WID_IV_DISPLAY
Display chain button.
Definition: industry_widget.h:31
WWT_DEFSIZEBOX
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX)
Definition: widget_type.h:67
WC_INDUSTRY_VIEW
@ WC_INDUSTRY_VIEW
Industry view; Window numbers:
Definition: window_type.h:363
IntervalTimer< TimerWindow >
GB
constexpr static debug_inline uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
CargoesField::cargo_stub
static Dimension cargo_stub
Dimensions of cargo stub (unconnected cargo line.)
Definition: industry_gui.cpp:1990
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:238
CargoSpec::Get
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:131
NWID_HORIZONTAL
@ NWID_HORIZONTAL
Horizontal container.
Definition: widget_type.h:77
IndustryDirectoryWindow::rebuild_interval
IntervalTimer< TimerWindow > rebuild_interval
Rebuild the industry list on a regular interval.
Definition: industry_gui.cpp:1854
StartTextRefStackUsage
void StartTextRefStackUsage(const GRFFile *grffile, byte numEntries, const uint32_t *values)
Start using the TTDP compatible string code parsing.
Definition: newgrf_text.cpp:798
IndustryCargoesWindow::PlaceIndustry
void PlaceIndustry(int row, int col, IndustryType it)
Place an industry in the fields.
Definition: industry_gui.cpp:2804
maxdim
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Definition: geometry_func.cpp:22
WWT_MATRIX
@ WWT_MATRIX
Grid of rows and columns.
Definition: widget_type.h:61
HouseSpec::enabled
bool enabled
the house is available to build (true by default, but can be disabled by newgrf)
Definition: house.h:112
SortIndustryTypes
void SortIndustryTypes()
Initialize the list of sorted industry types.
Definition: industry_gui.cpp:234
CLEAR_GRASS
@ CLEAR_GRASS
0-3
Definition: clear_map.h:20
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
IndustryCargoesWindow::ShortenCargoColumn
void ShortenCargoColumn(int column, int top, int bottom)
Shorten the cargo column to just the part between industries.
Definition: industry_gui.cpp:2783
CST_DIR
@ CST_DIR
Industry-directory window.
Definition: industry_gui.cpp:62
CargoesField::legend
static Dimension legend
Dimension of the legend blob.
Definition: industry_gui.cpp:1986
EndContainer
constexpr NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
Definition: widget_type.h:1153
Cheats::setup_prod
Cheat setup_prod
setup raw-material production in game
Definition: cheat_type.h:33
BuildIndustryWindow::enabled
bool enabled
Availability state of the selected industry.
Definition: industry_gui.cpp:306
WID_DPI_CREATE_RANDOM_INDUSTRIES_WIDGET
@ WID_DPI_CREATE_RANDOM_INDUSTRIES_WIDGET
Create random industries button.
Definition: industry_widget.h:17
SetMatrixDataTip
constexpr NWidgetPart SetMatrixDataTip(uint8_t cols, uint8_t rows, StringID tip)
Widget part function for setting the data and tooltip of WWT_MATRIX widgets.
Definition: widget_type.h:1176
WID_DPI_SCENARIO_EDITOR_PANE
@ WID_DPI_SCENARIO_EDITOR_PANE
Pane containing SE-only widgets.
Definition: industry_widget.h:15
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:37
SND_15_BEEP
@ SND_15_BEEP
19 == 0x13 GUI button click
Definition: sound_type.h:58
HandlePlacePushButton
bool HandlePlacePushButton(Window *w, WidgetID widget, CursorID cursor, HighLightStyle mode)
This code is shared for the majority of the pushbuttons.
Definition: main_gui.cpp:63
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:253
GUIList::SetSortType
void SetSortType(uint8_t n_type)
Set the sorttype of the list.
Definition: sortlist_type.h:124
WC_BUILD_INDUSTRY
@ WC_BUILD_INDUSTRY
Build industry; Window numbers:
Definition: window_type.h:435
zoom_func.h
Scrollbar::SetCapacityFromWidget
void SetCapacityFromWidget(Window *w, WidgetID widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget.
Definition: widget.cpp:2341
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
Window::RaiseButtons
void RaiseButtons(bool autoraise=false)
Raise the buttons of the window.
Definition: window.cpp:526
StrNaturalCompare
int StrNaturalCompare(std::string_view s1, std::string_view s2, bool ignore_garbage_at_front)
Compares two strings using case insensitive natural sort.
Definition: string.cpp:585
WID_IC_CARGO_DROPDOWN
@ WID_IC_CARGO_DROPDOWN
Select cargo dropdown.
Definition: industry_widget.h:52
Industry::produced
ProducedCargoArray produced
INDUSTRY_NUM_OUTPUTS production cargo slots.
Definition: industry.h:99
Industry::RecomputeProductionMultipliers
void RecomputeProductionMultipliers()
Recompute #production_rate for current prod_level.
Definition: industry_cmd.cpp:2513
CargoSpec::Iterate
static IterateWrapper Iterate(size_t from=0)
Returns an iterable ensemble of all valid CargoSpec.
Definition: cargotype.h:187
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:54
CargoesField::ConnectCargo
int ConnectCargo(CargoID cargo, bool producer)
Connect a cargo from an industry to the CFT_CARGO column.
Definition: industry_gui.cpp:2053
Industry::GetCargoProduced
ProducedCargoArray::iterator GetCargoProduced(CargoID cargo)
Get produced cargo slot for a specific cargo type.
Definition: industry.h:147
CargoSpec
Specification of a cargo type.
Definition: cargotype.h:68
SZSP_HORIZONTAL
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
Definition: widget_type.h:468
TimerGameEconomy::UsingWallclockUnits
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
Definition: timer_game_economy.cpp:97
WidgetDimensions::hsep_wide
int hsep_wide
Wide horizontal spacing.
Definition: window_gui.h:64
newgrf_debug.h
town.h
RectPadding::Vertical
constexpr uint Vertical() const
Get total vertical padding of RectPadding.
Definition: geometry_type.hpp:69
IndustryViewWindow::ShowNewGRFInspectWindow
void ShowNewGRFInspectWindow() const override
Show the NewGRF inspection window.
Definition: industry_gui.cpp:1175
CBM_IND_PRODUCTION_256_TICKS
@ CBM_IND_PRODUCTION_256_TICKS
call production callback every 256 ticks
Definition: newgrf_callbacks.h:366
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
CargoesField::cust_cargoes
Cargoes cust_cargoes
Cargoes in vertical_cargoes leaving to the right.
Definition: industry_gui.cpp:2013
ClampU
constexpr uint ClampU(const uint a, const uint min, const uint max)
Clamp an unsigned integer between an interval.
Definition: math_func.hpp:150
StringFilter::AddLine
void AddLine(const char *str)
Pass another text line from the current item to the filter.
Definition: stringfilter.cpp:114
WID_ID_FILTER
@ WID_ID_FILTER
Textbox to filter industry name.
Definition: industry_widget.h:40
CargoesField::CARGO_LINE_COLOUR
static const int CARGO_LINE_COLOUR
Line colour around the cargo.
Definition: industry_gui.cpp:1993
StopTextRefStackUsage
void StopTextRefStackUsage()
Stop using the TTDP compatible string code parsing.
Definition: newgrf_text.cpp:815
CargoSpec::GetCargoIcon
SpriteID GetCargoIcon() const
Get sprite for showing cargo of this type.
Definition: cargotype.cpp:154
ScaleZoomGUI
ZoomLevel ScaleZoomGUI(ZoomLevel value)
Scale zoom level relative to GUI zoom.
Definition: zoom_func.h:87
SA_RIGHT
@ SA_RIGHT
Right align the text (must be a single bit).
Definition: gfx_type.h:340
GetAllCargoSuffixes
static void GetAllCargoSuffixes(CargoSuffixInOut use_input, CargoSuffixType cst, const Industry *ind, IndustryType ind_type, const IndustrySpec *indspec, const TC &cargoes, TS &suffixes)
Gets all strings to display after the cargoes of industries (using callback 37)
Definition: industry_gui.cpp:155
IndustryDirectoryWindow::OnInvalidateData
void OnInvalidateData([[maybe_unused]] int data=0, [[maybe_unused]] bool gui_scope=true) override
Some data on this window has become invalid.
Definition: industry_gui.cpp:1864
clear_map.h
_industry_view_desc
static WindowDesc _industry_view_desc(__FILE__, __LINE__, WDP_AUTO, "view_industry", 260, 120, WC_INDUSTRY_VIEW, WC_NONE, 0, std::begin(_nested_industry_view_widgets), std::end(_nested_industry_view_widgets))
Window definition of the view industry gui.
PRODLEVEL_DEFAULT
@ PRODLEVEL_DEFAULT
default level set when the industry is created
Definition: industry.h:36
Industry
Defines the internal data of a functional industry.
Definition: industry.h:68
IndustryDirectoryWindow::GetIndustryListWidth
uint GetIndustryListWidth() const
Get the width needed to draw the longest industry line.
Definition: industry_gui.cpp:1410
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:680
Window::GetScrollbar
const Scrollbar * GetScrollbar(WidgetID widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:315
CargoesField::DrawHorConnection
static void DrawHorConnection(int left, int right, int top, const CargoSpec *csp)
Draw a horizontal cargo connection.
Definition: industry_gui.cpp:2385
WID_IV_GOTO
@ WID_IV_GOTO
Goto button.
Definition: industry_widget.h:30
CFT_INDUSTRY
@ CFT_INDUSTRY
Display industry.
Definition: industry_gui.cpp:1973
StrEmpty
bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:56
MAX_CARGOES
static const uint MAX_CARGOES
Maximum number of cargoes carried in a CFT_CARGO field in CargoesField.
Definition: industry_gui.cpp:1979
CommandCost::GetErrorMessage
StringID GetErrorMessage() const
Returns the error message of a command.
Definition: command_type.h:142
Rect::WithHeight
Rect WithHeight(int height, bool end=false) const
Copy Rect and set its height.
Definition: geometry_type.hpp:211
IndustryCargoesWindow::ind_cargo
uint ind_cargo
If less than NUM_INDUSTRYTYPES, an industry type, else a cargo id + NUM_INDUSTRYTYPES.
Definition: industry_gui.cpp:2556
IndustryDirectoryWindow::IndustryTransportedCargoSorter
static bool IndustryTransportedCargoSorter(const Industry *const &a, const Industry *const &b, const CargoID &filter)
Sort industries by transported cargo and name.
Definition: industry_gui.cpp:1539
CargoFilter
static bool CDECL CargoFilter(const Industry *const *industry, const std::pair< CargoID, CargoID > &cargoes)
Cargo filter functions.
Definition: industry_gui.cpp:1271
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:1040
genworld.h
GUIList::NeedRebuild
bool NeedRebuild() const
Check if a rebuild is needed.
Definition: sortlist_type.h:387
Scrollbar::GetPosition
uint16_t GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:722
WID_IC_SCROLLBAR
@ WID_IC_SCROLLBAR
Scrollbar of the panel.
Definition: industry_widget.h:51
CBM_IND_FUND_MORE_TEXT
@ CBM_IND_FUND_MORE_TEXT
additional text in fund window
Definition: newgrf_callbacks.h:371
QueryString
Data stored about a string that can be modified in the GUI.
Definition: querystring_gui.h:20
IndustryDirectoryWindow::SorterType::ByProduction
@ ByProduction
Sorter type to sort by production amount.
IndustryCargoesWindow::type
CargoesFieldType type
Type of field.
Definition: industry_gui.cpp:2659
BuildIndustryWindow::OnTimeout
void OnTimeout() override
Called when this window's timeout has been reached.
Definition: industry_gui.cpp:738
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:162
textbuf_gui.h
CargoesField::GetCargoBase
int GetCargoBase(int xpos) const
For a CFT_CARGO, compute the left position of the left-most vertical cargo connection.
Definition: industry_gui.cpp:2148
Textbuf::buf
char *const buf
buffer in which text is saved
Definition: textbuf_type.h:32
CBID_INDUSTRY_FUND_MORE_TEXT
@ CBID_INDUSTRY_FUND_MORE_TEXT
Called to determine more text in the fund industry window.
Definition: newgrf_callbacks.h:165
Scrollbar::GetCount
uint16_t GetCount() const
Gets the number of elements in the list.
Definition: widget_type.h:704
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition: settings_type.h:618
MAX_CHAR_LENGTH
static const int MAX_CHAR_LENGTH
Max. length of UTF-8 encoded unicode character.
Definition: strings_type.h:18
WID_DPI_SCROLLBAR
@ WID_DPI_SCROLLBAR
Scrollbar of the matrix.
Definition: industry_widget.h:19
CcBuildIndustry
void CcBuildIndustry(Commands, const CommandCost &result, TileIndex tile, IndustryType indtype, uint32_t, bool, uint32_t)
Command callback.
Definition: industry_gui.cpp:251
IndustryDirectoryWindow::OnInit
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition: industry_gui.cpp:1654
MakeClear
void MakeClear(Tile t, ClearGround g, uint density)
Make a clear tile.
Definition: clear_map.h:259
WindowDesc
High level window description.
Definition: window_gui.h:153
WidgetID
int WidgetID
Widget ID.
Definition: window_type.h:18
BuildIndustryWindow::list
std::vector< IndustryType > list
List of industries.
Definition: industry_gui.cpp:305
RoundDivSU
constexpr int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
Definition: math_func.hpp:342
RectPadding::Horizontal
constexpr uint Horizontal() const
Get total horizontal padding of RectPadding.
Definition: geometry_type.hpp:63
ScaleByCargoScale
uint ScaleByCargoScale(uint num, bool town)
Scale a number by the cargo scale setting.
Definition: economy_func.h:77
CFT_CARGO
@ CFT_CARGO
Display cargo connections.
Definition: industry_gui.cpp:1974
IndustryDirectoryWindow::MAX_FILTER_LENGTH
const int MAX_FILTER_LENGTH
The max length of the filter, in chars.
Definition: industry_gui.cpp:1337
ScaleGUITrad
int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:117
IndustryCargoesWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: industry_gui.cpp:3205
WID_IV_VIEWPORT
@ WID_IV_VIEWPORT
Viewport of the industry.
Definition: industry_widget.h:28
CargoesField::CargoLabelClickedAt
CargoID CargoLabelClickedAt(Point pt) const
Decide what cargo the user clicked in the cargo label field.
Definition: industry_gui.cpp:2362
SetPadding
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:1190
_sorted_standard_cargo_specs
std::span< const CargoSpec * > _sorted_standard_cargo_specs
Standard cargo specifications sorted alphabetically by name.
Definition: cargotype.cpp:169
IsInsideBS
constexpr bool IsInsideBS(const T x, const size_t base, const size_t size)
Checks if a value is between a window started at some base point.
Definition: math_func.hpp:252
CargoSuffixDisplay
CargoSuffixDisplay
Ways of displaying the cargo.
Definition: industry_gui.cpp:66
IndustryCargoesWindow
Window displaying the cargo connections around an industry (or cargo).
Definition: industry_gui.cpp:2552
SetResize
constexpr NWidgetPart SetResize(int16_t dx, int16_t dy)
Widget part function for setting the resize step.
Definition: widget_type.h:1088
IndustrySpec::IsRawIndustry
bool IsRawIndustry() const
Is an industry with the spec a raw industry?
Definition: industry_cmd.cpp:3107
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:141
Listing
Data structure describing how to show the list (what sort direction and criteria).
Definition: sortlist_type.h:30
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:308
CommandCost
Common return value for all commands.
Definition: command_type.h:23
Industry::location
TileArea location
Location of the industry.
Definition: industry.h:96
_build_industry_desc
static WindowDesc _build_industry_desc(__FILE__, __LINE__, WDP_AUTO, "build_industry", 170, 212, WC_BUILD_INDUSTRY, WC_NONE, WDF_CONSTRUCTION, std::begin(_nested_build_industry_widgets), std::end(_nested_build_industry_widgets))
Window definition of the dynamic place industries gui.
IndustryViewWindow::editable
Editability editable
Mode for changing production.
Definition: industry_gui.cpp:804
NWidgetViewport::UpdateViewportCoordinates
void UpdateViewportCoordinates(Window *w)
Update the position and size of the viewport (after eg a resize).
Definition: widget.cpp:2244
tilehighlight_func.h
ClientSettings::sound
SoundSettings sound
sound effect settings
Definition: settings_type.h:638
WindowNumber
int32_t WindowNumber
Number to differentiate different windows of the same class.
Definition: window_type.h:732
NUM_HOUSES
static const HouseID NUM_HOUSES
Total number of houses.
Definition: house.h:29
IndustryCargoesWindow::OnInit
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition: industry_gui.cpp:2570
FS_NORMAL
@ FS_NORMAL
Index of the normal font in the font tables.
Definition: gfx_type.h:203
Rect::Translate
Rect Translate(int x, int y) const
Copy and translate Rect by x,y pixels.
Definition: geometry_type.hpp:174
CargoesField::cargo_label
struct CargoesField::@5::@8 cargo_label
Label data (for CFT_CARGO_LABEL).
CargoesRow::MakeCargoLabel
void MakeCargoLabel(int column, bool accepting)
Construct a CFT_CARGO_LABEL field.
Definition: industry_gui.cpp:2460
Window::InitNested
void InitNested(WindowNumber number=0)
Perform complete initialization of the Window with nested widgets, to allow use.
Definition: window.cpp:1747
NWID_VIEWPORT
@ NWID_VIEWPORT
Nested widget containing a viewport.
Definition: widget_type.h:83
SetScrollbar
constexpr NWidgetPart SetScrollbar(WidgetID index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1246
GUIList::Filter
bool Filter(FilterFunction *decide, F filter_data)
Filter the list.
Definition: sortlist_type.h:343
WWT_EDITBOX
@ WWT_EDITBOX
a textbox for typing
Definition: widget_type.h:73
CargoesField::vert_inter_industry_space
static int vert_inter_industry_space
Amount of space between two industries in a column.
Definition: industry_gui.cpp:1983
Window::HandleButtonClick
void HandleButtonClick(WidgetID widget)
Do all things to make a button look clicked and mark it to be unclicked in a few ticks.
Definition: window.cpp:591
Industry::type
IndustryType type
type of industry.
Definition: industry.h:104
Window::height
int height
Height of the window (number of pixels down in y direction)
Definition: window_gui.h:306
IndustryViewWindow::IL_NONE
@ IL_NONE
No line.
Definition: industry_gui.cpp:797
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:941
IndustryDirectoryWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: industry_gui.cpp:1833
GUIList::SortFunction
std::conditional_t< std::is_same_v< P, std::nullptr_t >, bool(const T &, const T &), bool(const T &, const T &, const P)> SortFunction
Signature of sort function.
Definition: sortlist_type.h:49
WC_INDUSTRY_DIRECTORY
@ WC_INDUSTRY_DIRECTORY
Industry directory; Window numbers:
Definition: window_type.h:266
IndustryViewWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: industry_gui.cpp:835
GUIList::ForceResort
void ForceResort()
Force a resort next Sort call Reset the resort timer if used too.
Definition: sortlist_type.h:234
FS_SMALL
@ FS_SMALL
Index of the small font in the font tables.
Definition: gfx_type.h:204
ScrollWindowToTile
bool ScrollWindowToTile(TileIndex tile, Window *w, bool instant)
Scrolls the viewport in a window to a given location.
Definition: viewport.cpp:2498
CargoesField::industry_width
static int industry_width
Width of an industry field.
Definition: industry_gui.cpp:1997
_cheats
Cheats _cheats
All the cheats.
Definition: cheat.cpp:16
HZ_TEMP
@ HZ_TEMP
12 1000 can appear in temperate climate
Definition: house.h:80
IndustryDirectoryWindow
The list of industries.
Definition: industry_gui.cpp:1320
IndustrySpec::layouts
std::vector< IndustryTileLayout > layouts
List of possible tile layouts for the industry.
Definition: industrytype.h:106
IndustrySpec::accepts_cargo
CargoID accepts_cargo[INDUSTRY_NUM_INPUTS]
16 accepted cargoes.
Definition: industrytype.h:120
CargoesField::MakeIndustry
void MakeIndustry(IndustryType ind_type)
Make an industry type field.
Definition: industry_gui.cpp:2039
IndustryViewWindow::OnTimeout
void OnTimeout() override
Called when this window's timeout has been reached.
Definition: industry_gui.cpp:1115
GetRawClearGround
ClearGround GetRawClearGround(Tile t)
Get the type of clear tile but never return CLEAR_SNOW.
Definition: clear_map.h:47
CargoesField
Data about a single field in the IndustryCargoesWindow panel.
Definition: industry_gui.cpp:1982
ES_NOT_HANDLED
@ ES_NOT_HANDLED
The passed event is not handled.
Definition: window_type.h:740
WWT_PUSHTXTBTN
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:110
CargoFilterCriteria::CF_NONE
static constexpr CargoID CF_NONE
Show only items which do not carry cargo (e.g. train engines)
Definition: cargo_type.h:95
CargoesField::cargoes
CargoID cargoes[MAX_CARGOES]
Cargoes to display (or #INVALID_CARGO).
Definition: industry_gui.cpp:2019
NWidgetBase
Baseclass for nested widgets.
Definition: widget_type.h:135
CargoSuffix::display
CargoSuffixDisplay display
How to display the cargo and text.
Definition: industry_gui.cpp:75
GUIList::ToggleSortOrder
void ToggleSortOrder()
Toggle the sort order Since that is the worst condition for the sort function reverse the list here.
Definition: sortlist_type.h:254
WID_ID_FILTER_BY_ACC_CARGO
@ WID_ID_FILTER_BY_ACC_CARGO
Accepted cargo filter dropdown list.
Definition: industry_widget.h:38
WID_ID_VSCROLLBAR
@ WID_ID_VSCROLLBAR
Vertical scrollbar of the list.
Definition: industry_widget.h:43
IndustryDirectoryWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: industry_gui.cpp:1847
CargoesField::industry
struct CargoesField::@5::@6 industry
Industry data (for CFT_INDUSTRY).
Scrollbar::GetCapacity
uint16_t GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition: widget_type.h:713
dropdown_type.h
IndustryDirectoryWindow::GetIndustryString
StringID GetIndustryString(const Industry *i) const
Get the StringID to draw and set the appropriate DParams.
Definition: industry_gui.cpp:1550
GetIndustryProbabilityCallback
uint32_t GetIndustryProbabilityCallback(IndustryType type, IndustryAvailabilityCallType creation_type, uint32_t default_prob)
Check with callback CBID_INDUSTRY_PROBABILITY whether the industry can be built.
Definition: newgrf_industries.cpp:570
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
ShowIndustryCargoesWindow
static void ShowIndustryCargoesWindow(IndustryType id)
Open the industry and cargoes window.
Definition: industry_gui.cpp:3215
ZOOM_LVL_INDUSTRY
@ ZOOM_LVL_INDUSTRY
Default zoom level for the industry view.
Definition: zoom_type.h:33
Window::ReInit
void ReInit(int rx=0, int ry=0, bool reposition=false)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:953
Industry::accepted
AcceptedCargoArray accepted
INDUSTRY_NUM_INPUTS input cargo slots.
Definition: industry.h:100
PSM_ENTER_GAMELOOP
@ PSM_ENTER_GAMELOOP
Enter the gameloop, changes will be permanent.
Definition: newgrf_storage.h:21
CargoesField::max_cargoes
static uint max_cargoes
Largest number of cargoes actually on any industry.
Definition: industry_gui.cpp:1998
WL_INFO
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition: error.h:24
NWidget
constexpr NWidgetPart NWidget(WidgetType tp, Colours col, WidgetID idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1260
GUIList::IsDescSortOrder
bool IsDescSortOrder() const
Check if the sort order is descending.
Definition: sortlist_type.h:244
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:50
PRODLEVEL_MAXIMUM
@ PRODLEVEL_MAXIMUM
the industry is running at full speed
Definition: industry.h:37
industry.h
safeguards.h
sortlist_type.h
ShowQueryString
void ShowQueryString(StringID str, StringID caption, uint maxsize, Window *parent, CharSetFilter afilter, QueryStringFlags flags)
Show a query popup window with a textbox in it.
Definition: misc_gui.cpp:1087
timer.h
WID_ID_INDUSTRY_LIST
@ WID_ID_INDUSTRY_LIST
Industry list.
Definition: industry_widget.h:41
lengthof
#define lengthof(array)
Return the length of an fixed size array.
Definition: stdafx.h:303
CST_VIEW
@ CST_VIEW
View-industry window.
Definition: industry_gui.cpp:61
Window::flags
WindowFlags flags
Window flags.
Definition: window_gui.h:294
Rect::Indent
Rect Indent(int indent, bool end) const
Copy Rect and indent it from its position.
Definition: geometry_type.hpp:198
BuildIndustryWindow::legend
Dimension legend
Dimension of the legend 'blob'.
Definition: industry_gui.cpp:308
_nested_industry_directory_widgets
static constexpr NWidgetPart _nested_industry_directory_widgets[]
Widget definition of the industry directory gui.
Definition: industry_gui.cpp:1231
CargoesRow::ConnectIndustryProduced
void ConnectIndustryProduced(int column)
Connect industry production cargoes to the cargo column after it.
Definition: industry_gui.cpp:2422
IndustryDirectoryWindow::SetProducedCargoFilter
void SetProducedCargoFilter(CargoID cid)
Set produced cargo filter for the industry list.
Definition: industry_gui.cpp:1352
CargoesField::HasConnection
bool HasConnection()
Does this CFT_CARGO field have a horizontal connection?
Definition: industry_gui.cpp:2082
_displayed_industries
std::bitset< NUM_INDUSTRYTYPES > _displayed_industries
Communication from the industry chain window to the smallmap window about what industries to display.
Definition: industry_gui.cpp:56
Rect::WithWidth
Rect WithWidth(int width, bool end) const
Copy Rect and set its width.
Definition: geometry_type.hpp:185
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:65
CargoesField::header
StringID header
Header text (for CFT_HEADER).
Definition: industry_gui.cpp:2022
DrawSprite
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:1003
CargoesField::vertical_cargoes
CargoID vertical_cargoes[MAX_CARGOES]
Cargoes running from top to bottom (cargo ID or #INVALID_CARGO).
Definition: industry_gui.cpp:2011
IndustryDirectoryWindow::accepted_cargo_filter_criteria
CargoID accepted_cargo_filter_criteria
Selected accepted cargo filter index.
Definition: industry_gui.cpp:1334
newgrf_text.h
IndustryDirectoryWindow::SorterType::ByTransported
@ ByTransported
Sorter type to sort by transported percentage.
CBID_INDUSTRY_CARGO_SUFFIX
@ CBID_INDUSTRY_CARGO_SUFFIX
Called to determine text to display after cargo name.
Definition: newgrf_callbacks.h:162
IndustryCargoesWindow::CalculatePositionInWidget
bool CalculatePositionInWidget(Point pt, Point *fieldxy, Point *xy)
Calculate in which field was clicked, and within the field, at what position.
Definition: industry_gui.cpp:3037
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:22
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
error.h
CFT_SMALL_EMPTY
@ CFT_SMALL_EMPTY
Empty small field (for the header).
Definition: industry_gui.cpp:1972
CenterBounds
int CenterBounds(int min, int max, int size)
Determine where to draw a centred object inside a widget.
Definition: gfx_func.h:166
Scrollbar::GetScrolledItemFromWidget
Tcontainer::iterator GetScrolledItemFromWidget(Tcontainer &container, int clickpos, const Window *const w, WidgetID widget, int padding=0, int line_height=-1) const
Return an iterator pointing to the element of a scrolled widget that a user clicked in.
Definition: widget_type.h:847
IndustryDirectoryWindow::GetCargoTransportedPercentsIfValid
static int GetCargoTransportedPercentsIfValid(const Industry::ProducedCargo &p)
Returns percents of cargo transported if industry produces this cargo, else -1.
Definition: industry_gui.cpp:1459
ShowDropDownMenu
void ShowDropDownMenu(Window *w, const StringID *strings, int selected, WidgetID button, uint32_t disabled_mask, uint32_t hidden_mask, uint width)
Show a dropdown menu window near a widget of the parent window.
Definition: dropdown.cpp:411
GetGRFStringID
StringID GetGRFStringID(uint32_t grfid, StringID stringid)
Returns the index for this stringid associated with its grfID.
Definition: newgrf_text.cpp:587
SETTING_BUTTON_WIDTH
#define SETTING_BUTTON_WIDTH
Width of setting buttons.
Definition: settings_gui.h:17
CargoesField::Draw
void Draw(int xpos, int ypos) const
Draw the field.
Definition: industry_gui.cpp:2161
IndustryCargoesWindow::OnInvalidateData
void OnInvalidateData([[maybe_unused]] int data=0, [[maybe_unused]] bool gui_scope=true) override
Some data on this window has become invalid.
Definition: industry_gui.cpp:2979
IndustryViewWindow::Editability
Editability
Modes for changing production.
Definition: industry_gui.cpp:789
stdafx.h
DrawArrowButtons
void DrawArrowButtons(int x, int y, Colours button_colour, byte state, bool clickable_left, bool clickable_right)
Draw [<][>] boxes.
Definition: settings_gui.cpp:2910
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:296
Window::SetFocusedWidget
bool SetFocusedWidget(WidgetID widget_index)
Set focus within this window to the given widget.
Definition: window.cpp:487
GfxFillRect
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:113
GetCargoSuffix
static void GetCargoSuffix(uint cargo, CargoSuffixType cst, const Industry *ind, IndustryType ind_type, const IndustrySpec *indspec, CargoSuffix &suffix)
Gets the string to display after the cargo name (using callback 37)
Definition: industry_gui.cpp:91
IndustrySpec
Defines the data structure for constructing industry.
Definition: industrytype.h:105
SpriteID
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
Cheat::value
bool value
tells if the bool cheat is active or not
Definition: cheat_type.h:18
Window::InvalidateData
void InvalidateData(int data=0, bool gui_scope=true)
Mark this window's data as invalid (in need of re-computing)
Definition: window.cpp:3144
CFT_CARGO_LABEL
@ CFT_CARGO_LABEL
Display cargo labels.
Definition: industry_gui.cpp:1975
CargoesField::normal_height
static int normal_height
Height of the non-header rows.
Definition: industry_gui.cpp:1995
CS_ALPHANUMERAL
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:25
viewport_func.h
Industry::text
std::string text
General text with additional information.
Definition: industry.h:121
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:45
CargoesField::small_height
static int small_height
Height of the header row.
Definition: industry_gui.cpp:1995
IACT_USERCREATION
@ IACT_USERCREATION
from the Fund/build window
Definition: newgrf_industries.h:85
SA_HOR_CENTER
@ SA_HOR_CENTER
Horizontally center the text.
Definition: gfx_type.h:339
OrthogonalTileArea::GetCenterTile
TileIndex GetCenterTile() const
Get the center tile.
Definition: tilearea_type.h:59
HouseSpec::cargo_acceptance
byte cargo_acceptance[HOUSE_NUM_ACCEPTS]
acceptance level for the cargo slots
Definition: house.h:107
NWID_VERTICAL
@ NWID_VERTICAL
Vertical container.
Definition: widget_type.h:79
CFT_EMPTY
@ CFT_EMPTY
Empty field.
Definition: industry_gui.cpp:1971
Industry::ProducedCargo
Definition: industry.h:80
FillDrawPixelInfo
bool FillDrawPixelInfo(DrawPixelInfo *n, int left, int top, int width, int height)
Set up a clipping area for only drawing into a certain area.
Definition: gfx.cpp:1567
FILLRECT_OPAQUE
@ FILLRECT_OPAQUE
Fill rectangle with a single colour.
Definition: gfx_type.h:293
CargoesField::cargo_space
static Dimension cargo_space
Dimensions of space between cargo lines.
Definition: industry_gui.cpp:1989
IndustryViewWindow
Definition: industry_gui.cpp:786
IndustrySpec::callback_mask
uint16_t callback_mask
Bitmask of industry callbacks that have to be called.
Definition: industrytype.h:138
WidgetDimensions::unscaled
static const WidgetDimensions unscaled
Unscaled widget dimensions.
Definition: window_gui.h:67
IndustryViewWindow::EA_RATE
@ EA_RATE
Allow changing the production rates.
Definition: industry_gui.cpp:792
Window::SetWidgetDisabledState
void SetWidgetDisabledState(WidgetID widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition: window_gui.h:381
GetSpriteSize
Dimension GetSpriteSize(SpriteID sprid, Point *offset, ZoomLevel zoom)
Get the size of a sprite.
Definition: gfx.cpp:937
WWT_CLOSEBOX
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition: widget_type.h:71
WWT_RESIZEBOX
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:70
_generating_world
bool _generating_world
Whether we are generating the map or not.
Definition: genworld.cpp:62
CargoesField::cargo_border
static Dimension cargo_border
Dimensions of border between cargo lines and industry boxes.
Definition: industry_gui.cpp:1987
IndustryDirectoryWindow::IndustryNameSorter
static bool IndustryNameSorter(const Industry *const &a, const Industry *const &b, const CargoID &)
Sort industries by name.
Definition: industry_gui.cpp:1498
IndustryTemporarilyRefusesCargo
bool IndustryTemporarilyRefusesCargo(Industry *ind, CargoID cargo_type)
Check whether an industry temporarily refuses to accept a certain cargo.
Definition: newgrf_industries.cpp:683
IndustryDirectoryWindow::produced_cargo_filter_criteria
CargoID produced_cargo_filter_criteria
Selected produced cargo filter index.
Definition: industry_gui.cpp:1333
GUIList::ForceRebuild
void ForceRebuild()
Force that a rebuild is needed.
Definition: sortlist_type.h:395
IndustryViewWindow::IL_MULTIPLIER
@ IL_MULTIPLIER
Production multiplier.
Definition: industry_gui.cpp:798
WID_DPI_INFOPANEL
@ WID_DPI_INFOPANEL
Info panel about the industry.
Definition: industry_widget.h:20
CargoesField::left_align
bool left_align
Align all cargo texts to the left (else align to the right).
Definition: industry_gui.cpp:2020
string_func.h
BuildIndustryWindow::MakeCargoListString
std::string MakeCargoListString(const CargoID *cargolist, const CargoSuffix *cargo_suffix, int cargolistlen, StringID prefixstr) const
Build a string of cargo names with suffixes attached.
Definition: industry_gui.cpp:369
IndustrySpec::enabled
bool enabled
entity still available (by default true).newgrf can disable it, though
Definition: industrytype.h:140
IndustryViewWindow::cheat_line_height
int cheat_line_height
Height of each line for the WID_IV_INFO panel.
Definition: industry_gui.cpp:810
Window::IsWidgetLowered
bool IsWidgetLowered(WidgetID widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:491
CALLBACK_FAILED
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Definition: newgrf_callbacks.h:420
CargoesField::supp_cargoes
Cargoes supp_cargoes
Cargoes in vertical_cargoes entering from the left.
Definition: industry_gui.cpp:2012
ConstructionSettings::raw_industry_construction
uint8_t raw_industry_construction
type of (raw) industry construction (none, "normal", prospecting)
Definition: settings_type.h:380
PC_YELLOW
static const uint8_t PC_YELLOW
Yellow palette colour.
Definition: palette_func.h:68
WWT_PUSHIMGBTN
@ WWT_PUSHIMGBTN
Normal push-button (no toggle button) with image caption.
Definition: widget_type.h:111
Window::querystrings
std::map< WidgetID, QueryString * > querystrings
QueryString associated to WWT_EDITBOX widgets.
Definition: window_gui.h:314
SBS_DOWN
@ SBS_DOWN
Sort ascending.
Definition: window_gui.h:214
QueryString::cancel_button
int cancel_button
Widget button of parent window to simulate when pressing CANCEL in OSK.
Definition: querystring_gui.h:28
DrawStringMultiLine
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:771
WID_ID_DROPDOWN_CRITERIA
@ WID_ID_DROPDOWN_CRITERIA
Dropdown for the criteria of the sort.
Definition: industry_widget.h:37
WID_IC_CAPTION
@ WID_IC_CAPTION
Caption of the window.
Definition: industry_widget.h:48
IndustryViewWindow::cargo_icon_size
Dimension cargo_icon_size
Largest cargo icon dimension.
Definition: industry_gui.cpp:803
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:51
Window::DrawSortButtonState
void DrawSortButtonState(WidgetID widget, SortButtonState state) const
Draw a sort button's up or down arrow symbol.
Definition: widget.cpp:763
GuiShowTooltips
void GuiShowTooltips(Window *parent, StringID str, TooltipCloseCondition close_tooltip, uint paramcount)
Shows a tooltip.
Definition: misc_gui.cpp:758
CargoesField::MakeCargoLabel
void MakeCargoLabel(const CargoID *cargoes, uint length, bool left_align)
Make a field displaying cargo type names.
Definition: industry_gui.cpp:2124
CargoSpec::town_production_effect
TownProductionEffect town_production_effect
The effect on town cargo production.
Definition: cargotype.h:81
IndustryViewWindow::IL_RATE1
@ IL_RATE1
Production rate of cargo 1.
Definition: industry_gui.cpp:799
Pool::PoolItem<&_industry_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:388
WID_DPI_DISPLAY_WIDGET
@ WID_DPI_DISPLAY_WIDGET
Display chain button.
Definition: industry_widget.h:21
Window::CreateNestedTree
void CreateNestedTree()
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1724
strings_func.h
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:86
WidgetDimensions::vsep_wide
int vsep_wide
Wide vertical spacing.
Definition: window_gui.h:62
CargoesRow::columns
CargoesField columns[5]
One row of fields.
Definition: industry_gui.cpp:2416
CSD_CARGO_AMOUNT_TEXT
@ CSD_CARGO_AMOUNT_TEXT
Display then cargo, amount, and string (cb37 result 000-3FF).
Definition: industry_gui.cpp:70
CargoesField::MakeHeader
void MakeHeader(StringID textid)
Make a header above an industry column.
Definition: industry_gui.cpp:2137
Window::IsShaded
bool IsShaded() const
Is window shaded currently?
Definition: window_gui.h:557
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:236
GUIList::GetListing
Listing GetListing() const
Export current sort conditions.
Definition: sortlist_type.h:137
IndustryDirectoryWindow::GetCargoTransportedSortValue
static int GetCargoTransportedSortValue(const Industry *i)
Returns value representing industry's transported cargo percentage for industry sorting.
Definition: industry_gui.cpp:1472
Pool::PoolItem<&_town_pool >::GetNumItems
static size_t GetNumItems()
Returns number of valid items in the pool.
Definition: pool_type.hpp:369
industry_widget.h
Scrollbar::IsVisible
bool IsVisible(uint16_t item) const
Checks whether given current item is visible in the list.
Definition: widget_type.h:732
IndustryViewWindow::editbox_line
InfoLine editbox_line
The line clicked to open the edit box.
Definition: industry_gui.cpp:805
INVALID_INDUSTRYTYPE
static const IndustryType INVALID_INDUSTRYTYPE
one above amount is considered invalid
Definition: industry_type.h:27
CST_FUND
@ CST_FUND
Fund-industry window.
Definition: industry_gui.cpp:60
IndustryCargoesWindow::cargo_textsize
Dimension cargo_textsize
Size to hold any cargo text, as well as STR_INDUSTRY_CARGOES_SELECT_CARGO.
Definition: industry_gui.cpp:2557
Map::Size
static debug_inline uint Size()
Get the size of the map.
Definition: map_func.h:288
CargoesFieldType
CargoesFieldType
Available types of field.
Definition: industry_gui.cpp:1970
SetDParam
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
BuildIndustryWindow::selected_type
IndustryType selected_type
industry corresponding to the above index
Definition: industry_gui.cpp:304
IndustryViewWindow::EA_NONE
@ EA_NONE
Not alterable.
Definition: industry_gui.cpp:790
WID_DPI_FUND_WIDGET
@ WID_DPI_FUND_WIDGET
Fund button.
Definition: industry_widget.h:22
IndustryCargoesWindow::ComputeCargoDisplay
void ComputeCargoDisplay(CargoID cid)
Compute what and where to display for cargo id cid.
Definition: industry_gui.cpp:2909
geometry_func.hpp
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:19
endof
#define endof(x)
Get the end element of an fixed size array.
Definition: stdafx.h:311
InvalidateWindowClassesData
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition: window.cpp:3221
IndustryDirectoryWindow::SetCargoFilterArray
void SetCargoFilterArray()
Populate the filter list and set the cargo filter criteria.
Definition: industry_gui.cpp:1394
HZ_SUBARTC_ABOVE
@ HZ_SUBARTC_ABOVE
11 800 can appear in sub-arctic climate above the snow line
Definition: house.h:79
cheat_type.h
industry_cmd.h
StringFilter::ResetState
void ResetState()
Reset the matching state to process a new item.
Definition: stringfilter.cpp:98
WID_IC_PANEL
@ WID_IC_PANEL
Panel that shows the chain.
Definition: industry_widget.h:50
WWT_PANEL
@ WWT_PANEL
Simple depressed panel.
Definition: widget_type.h:52
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
CargoesField::cargo_field_width
static int cargo_field_width
Width of a cargo field.
Definition: industry_gui.cpp:1996
AutoRestoreBackup
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
Definition: backup_type.hpp:153
NWidgetBase::resize_y
uint resize_y
Vertical resize step (0 means not resizable).
Definition: widget_type.h:226
ShowSmallMap
void ShowSmallMap()
Show the smallmap window.
Definition: smallmap_gui.cpp:1994
Scrollbar::SetCount
void SetCount(size_t num)
Sets the number of elements in the list.
Definition: widget_type.h:762
GetString
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
Definition: strings.cpp:327
IndustrySpec::grf_prop
GRFFileProps grf_prop
properties related to the grf file
Definition: industrytype.h:141
CSD_CARGO_TEXT
@ CSD_CARGO_TEXT
Display then cargo and supplied string (cb37 result 800-BFF).
Definition: industry_gui.cpp:69
Industry::GetIndustryTypeCount
static uint16_t GetIndustryTypeCount(IndustryType type)
Get the count of industries for this type.
Definition: industry.h:242
EventState
EventState
State of handling an event.
Definition: window_type.h:738
HT_RECT
@ HT_RECT
rectangle (stations, depots, ...)
Definition: tilehighlight_type.h:21
IndustryViewWindow::clicked_line
InfoLine clicked_line
The line of the button that has been clicked.
Definition: industry_gui.cpp:806
FindWindowByClass
Window * FindWindowByClass(WindowClass cls)
Find any window by its class.
Definition: window.cpp:1114
IndustryDirectoryWindow::IndustryTypeSorter
static bool IndustryTypeSorter(const Industry *const &a, const Industry *const &b, const CargoID &filter)
Sort industries by type and name.
Definition: industry_gui.cpp:1506
StringFilter::GetState
bool GetState() const
Get the matching state of the current item.
Definition: stringfilter_type.h:71
IndustryViewWindow::InfoLine
InfoLine
Specific lines in the info panel.
Definition: industry_gui.cpp:796
HouseSpec::building_availability
HouseZones building_availability
where can it be built (climates, zones)
Definition: house.h:111
IndustryViewWindow::OnInvalidateData
void OnInvalidateData([[maybe_unused]] int data=0, [[maybe_unused]] bool gui_scope=true) override
Some data on this window has become invalid.
Definition: industry_gui.cpp:1158
SetDParamStr
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:352
CargoSpec::name
StringID name
Name of this type of cargo.
Definition: cargotype.h:85
CBM_IND_WINDOW_MORE_TEXT
@ CBM_IND_WINDOW_MORE_TEXT
additional text in industry window
Definition: newgrf_callbacks.h:372
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1734
PC_BLACK
static const uint8_t PC_BLACK
Black palette colour.
Definition: palette_func.h:55
ShowDropDownList
void ShowDropDownList(Window *w, DropDownList &&list, int selected, WidgetID button, uint width, bool instant_close, bool persist)
Show a drop down list.
Definition: dropdown.cpp:374
WID_ID_DROPDOWN_ORDER
@ WID_ID_DROPDOWN_ORDER
Dropdown for the order of the sort.
Definition: industry_widget.h:36
company_func.h
WWT_INSET
@ WWT_INSET
Pressed (inset) panel, most commonly used as combo box text area.
Definition: widget_type.h:53
QueryString::ACTION_CLEAR
static const int ACTION_CLEAR
Clear editbox.
Definition: querystring_gui.h:24
CargoesRow::ConnectIndustryAccepted
void ConnectIndustryAccepted(int column)
Connect industry accepted cargoes to the cargo column before it.
Definition: industry_gui.cpp:2481
BuildIndustryWindow::OnPlaceObjectAbort
void OnPlaceObjectAbort() override
The user cancelled a tile highlight mode that has been set.
Definition: industry_gui.cpp:743
Window::top
int top
y position of top edge of the window
Definition: window_gui.h:304
ErrorUnknownCallbackResult
void ErrorUnknownCallbackResult(uint32_t grfid, uint16_t cbid, uint16_t cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
Definition: newgrf_commons.cpp:499
SA_LEFT
@ SA_LEFT
Left align the text.
Definition: gfx_type.h:338
network.h
TownProductionEffect
TownProductionEffect
Town effect when producing cargo.
Definition: cargotype.h:34
CommandHelper
Definition: command_func.h:93
GUIList::SetFilterFuncs
void SetFilterFuncs(FilterFunction *const *n_funcs)
Hand the array of filter function pointers to the sort list.
Definition: sortlist_type.h:366
WID_ID_HSCROLLBAR
@ WID_ID_HSCROLLBAR
Horizontal scrollbar of the list.
Definition: industry_widget.h:42
GUIList::SortType
uint8_t SortType() const
Get the sorttype of the list.
Definition: sortlist_type.h:114
IndustryCargoesWindow::HasCommonValidCargo
static bool HasCommonValidCargo(const CargoID *cargoes1, uint length1, const CargoID *cargoes2, uint length2)
Do the two sets of cargoes have a valid cargo in common?
Definition: industry_gui.cpp:2681
window_func.h
IndustrySpec::behaviour
IndustryBehaviour behaviour
How this industry will behave, and how others entities can use it.
Definition: industrytype.h:125
SoundSettings::click_beep
bool click_beep
Beep on a random selection of buttons.
Definition: settings_type.h:241
GetCharacterHeight
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition: fontcache.cpp:78
Window::width
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:305
stringfilter_type.h
SetMinimalSize
constexpr NWidgetPart SetMinimalSize(int16_t x, int16_t y)
Widget part function for setting the minimal size.
Definition: widget_type.h:1099
HZ_TOYLND
@ HZ_TOYLND
15 8000 can appear in toyland climate
Definition: house.h:83
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1548
CargoIDComparator
Comparator to sort CargoID by according to desired order.
Definition: cargotype.h:238
Window::SortButtonWidth
static int SortButtonWidth()
Get width of up/down arrow of sort button state.
Definition: widget.cpp:780
GUIList::SetSortFuncs
void SetSortFuncs(SortFunction *const *n_funcs)
Hand the array of sort function pointers to the sort list.
Definition: sortlist_type.h:295
random_func.hpp
GUIList::RebuildDone
void RebuildDone()
Notify the sortlist that the rebuild is done.
Definition: sortlist_type.h:405
DrawRectOutline
void DrawRectOutline(const Rect &r, int colour, int width, int dash)
Draw the outline of a Rect.
Definition: gfx.cpp:455
GUIList< const Industry *, const CargoID &, const std::pair< CargoID, CargoID > & >::FilterFunction
bool CDECL FilterFunction(const const Industry * *, const std::pair< CargoID, CargoID > &)
Signature of filter function.
Definition: sortlist_type.h:50
NWidgetBase::pos_y
int pos_y
Vertical position of top-left corner of the widget in the window.
Definition: widget_type.h:237
CargoSuffix
Transfer storage of cargo suffix information.
Definition: industry_gui.cpp:74
CargoesField::bottom_end
uint8_t bottom_end
Stop at the bottom of the vertical cargoes.
Definition: industry_gui.cpp:2016
HouseSpec
Definition: house.h:98
DrawString
int DrawString(int left, int right, int top, std::string_view str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:654
timer_window.h
Rect::Contains
bool Contains(const Point &pt) const
Test if a point falls inside this Rect.
Definition: geometry_type.hpp:223
CargoesField::blob_distance
static int blob_distance
Distance of the industry legend colour from the edge of the industry box.
Definition: industry_gui.cpp:1984
PSM_LEAVE_GAMELOOP
@ PSM_LEAVE_GAMELOOP
Leave the gameloop, changes will be temporary.
Definition: newgrf_storage.h:22
BasePersistentStorageArray::SwitchMode
static void SwitchMode(PersistentStorageMode mode, bool ignore_prev_mode=false)
Clear temporary changes made since the last call to SwitchMode, and set whether subsequent changes sh...
Definition: newgrf_storage.cpp:54
CBID_INDUSTRY_WINDOW_MORE_TEXT
@ CBID_INDUSTRY_WINDOW_MORE_TEXT
Called to determine more text in the industry window.
Definition: newgrf_callbacks.h:171
HouseZones
HouseZones
Definition: house.h:71
IndustryViewWindow::OnInit
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition: industry_gui.cpp:828
IsValidCargoID
bool IsValidCargoID(CargoID t)
Test whether cargo type is not INVALID_CARGO.
Definition: cargo_type.h:107
IsNewGRFInspectable
bool IsNewGRFInspectable(GrfSpecFeature feature, uint index)
Can we inspect the data given a certain feature and index.
Definition: newgrf_debug_gui.cpp:761
_industry_directory_desc
static WindowDesc _industry_directory_desc(__FILE__, __LINE__, WDP_AUTO, "list_industries", 428, 190, WC_INDUSTRY_DIRECTORY, WC_NONE, 0, std::begin(_nested_industry_directory_widgets), std::end(_nested_industry_directory_widgets), &IndustryDirectoryWindow::hotkeys)
Window definition of the industry directory gui.
CargoesField::ind_type
IndustryType ind_type
Industry type (NUM_INDUSTRYTYPES means 'houses').
Definition: industry_gui.cpp:2006
IndustryDirectoryWindow::IndustryProductionSorter
static bool IndustryProductionSorter(const Industry *const &a, const Industry *const &b, const CargoID &filter)
Sort industries by production and name.
Definition: industry_gui.cpp:1517
IndustryDirectoryWindow::SorterType
SorterType
Definition: industry_gui.cpp:1341
BuildIndustryWindow::SetButtons
void SetButtons()
Update status of the fund and display-chain widgets.
Definition: industry_gui.cpp:351
IndustryDirectoryWindow::string_filter
StringFilter string_filter
Filter for industries.
Definition: industry_gui.cpp:1338
WidgetDimensions::bevel
RectPadding bevel
Bevel thickness, affected by "scaled bevels" game option.
Definition: window_gui.h:40
gui.h
newgrf_industries.h
WID_IV_CAPTION
@ WID_IV_CAPTION
Caption of the window.
Definition: industry_widget.h:27
WID_DPI_REMOVE_ALL_INDUSTRIES_WIDGET
@ WID_DPI_REMOVE_ALL_INDUSTRIES_WIDGET
Remove all industries button.
Definition: industry_widget.h:16
WidgetDimensions::frametext
RectPadding frametext
Padding inside frame with text.
Definition: window_gui.h:43
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:619
GetIndustrySpec
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
Definition: industry_cmd.cpp:123
CargoSuffixType
CargoSuffixType
Cargo suffix type (for which window is it requested)
Definition: industry_gui.cpp:59
Window
Data structure for an opened window.
Definition: window_gui.h:267
Commands
Commands
List of commands.
Definition: command_type.h:187
IndustryViewWindow::clicked_button
byte clicked_button
The button that has been clicked (to raise)
Definition: industry_gui.cpp:807
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
IndustrySpec::name
StringID name
Displayed name of the industry.
Definition: industrytype.h:127
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:328
IndustryViewWindow::DrawInfo
int DrawInfo(const Rect &r)
Draw the text in the WID_IV_INFO panel.
Definition: industry_gui.cpp:864
TPE_PASSENGERS
@ TPE_PASSENGERS
Cargo behaves passenger-like for production.
Definition: cargotype.h:36
Window::DrawWidgets
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:731
WID_ID_FILTER_BY_PROD_CARGO
@ WID_ID_FILTER_BY_PROD_CARGO
Produced cargo filter dropdown list.
Definition: industry_widget.h:39
GRFFilePropsBase::grffile
const struct GRFFile * grffile
grf file that introduced this entity
Definition: newgrf_commons.h:319
Industry::prod_level
byte prod_level
general production level
Definition: industry.h:101
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:427
SetDataTip
constexpr NWidgetPart SetDataTip(uint32_t data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1164
settings_gui.h
CargoesField::type
CargoesFieldType type
Type of field.
Definition: industry_gui.cpp:2001
SBS_UP
@ SBS_UP
Sort descending.
Definition: window_gui.h:215
SetMinimalTextLines
constexpr NWidgetPart SetMinimalTextLines(uint8_t lines, uint8_t spacing, FontSize size=FS_NORMAL)
Widget part function for setting the minimal text lines.
Definition: widget_type.h:1111
CargoesField::MakeEmpty
void MakeEmpty(CargoesFieldType type)
Make one of the empty fields (CFT_EMPTY or CFT_SMALL_EMPTY).
Definition: industry_gui.cpp:2029
NWID_SELECTION
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:82
Window::RaiseWidgetWhenLowered
void RaiseWidgetWhenLowered(byte widget_index)
Marks a widget as raised and dirty (redraw), when it is marked as lowered.
Definition: window_gui.h:478
WID_DPI_MATRIX_WIDGET
@ WID_DPI_MATRIX_WIDGET
Matrix of the industries.
Definition: industry_widget.h:18
WWT_DEBUGBOX
@ WWT_DEBUGBOX
NewGRF debug box (at top-right of a window, between WWT_CAPTION and WWT_SHADEBOX)
Definition: widget_type.h:65
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:75
Window::ToggleWidgetLoweredState
void ToggleWidgetLoweredState(WidgetID widget_index)
Invert the lowered/raised status of a widget.
Definition: window_gui.h:450
BringWindowToFrontById
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition: window.cpp:1224
CLEAR_FIELDS
@ CLEAR_FIELDS
3
Definition: clear_map.h:23
CargoesField::CargoClickedAt
CargoID CargoClickedAt(const CargoesField *left, const CargoesField *right, Point pt) const
Decide which cargo was clicked at in a CFT_CARGO field.
Definition: industry_gui.cpp:2304
GUIList::Sort
bool Sort(Comp compare)
Sort the list.
Definition: sortlist_type.h:268
HZ_SUBARTC_BELOW
@ HZ_SUBARTC_BELOW
13 2000 can appear in sub-arctic climate below the snow line
Definition: house.h:81
IndustryViewWindow::IL_RATE2
@ IL_RATE2
Production rate of cargo 2.
Definition: industry_gui.cpp:800
WidgetDimensions::framerect
RectPadding framerect
Standard padding inside many panels.
Definition: window_gui.h:42
GRFFile::cargo_map
std::array< uint8_t, NUM_CARGO > cargo_map
Inverse cargo translation table (CargoID -> local ID)
Definition: newgrf.h:130
WidgetDimensions::hsep_normal
int hsep_normal
Normal horizontal spacing.
Definition: window_gui.h:63
GetIndustryCallback
uint16_t GetIndustryCallback(CallbackID callback, uint32_t param1, uint32_t param2, Industry *industry, IndustryType type, TileIndex tile)
Perform an industry callback.
Definition: newgrf_industries.cpp:522
CargoSuffix::text
std::string text
Cargo suffix text.
Definition: industry_gui.cpp:76
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition: viewport.cpp:3483
BuildIndustryWindow::MAX_MINWIDTH_LINEHEIGHTS
static const int MAX_MINWIDTH_LINEHEIGHTS
The largest allowed minimum-width of the window, given in line heights.
Definition: industry_gui.cpp:311
WC_SMALLMAP
@ WC_SMALLMAP
Small map; Window numbers:
Definition: window_type.h:104
cpp_lengthof
#define cpp_lengthof(base, variable)
Gets the length of an array variable within a class.
Definition: stdafx.h:335
SETTING_BUTTON_HEIGHT
#define SETTING_BUTTON_HEIGHT
Height of setting buttons.
Definition: settings_gui.h:19
IndustryCargoesWindow::CountMatchingAcceptingIndustries
static int CountMatchingAcceptingIndustries(const CargoID *cargoes, uint length)
Count how many industries have accepted cargoes in common with one of the supplied set.
Definition: industry_gui.cpp:2747
TD_RTL
@ TD_RTL
Text is written right-to-left by default.
Definition: strings_type.h:24
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:56
IndustryCargoesWindow::fields
Fields fields
Fields to display in the WID_IC_PANEL.
Definition: industry_gui.cpp:2555
GetLargestCargoIconSize
Dimension GetLargestCargoIconSize()
Get dimensions of largest cargo icon.
Definition: cargotype.cpp:124
IndustryCargoesWindow::NotifySmallmap
void NotifySmallmap()
Notify smallmap that new displayed industries have been selected (in _displayed_industries).
Definition: industry_gui.cpp:2818
GUIList::SetFilterType
void SetFilterType(uint8_t n_type)
Set the filtertype of the list.
Definition: sortlist_type.h:176
CSD_CARGO_AMOUNT
@ CSD_CARGO_AMOUNT
Display the cargo and amount (if useful), but no sub-type (cb37 result 400 or fail).
Definition: industry_gui.cpp:68
IndustryViewWindow::info_height
int info_height
Height needed for the WID_IV_INFO panel.
Definition: industry_gui.cpp:809
GetStringBoundingBox
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:848
IDHK_FOCUS_FILTER_BOX
@ IDHK_FOCUS_FILTER_BOX
Focus the filter box.
Definition: industry_gui.cpp:1315
CargoesField::cargo
struct CargoesField::@5::@7 cargo
Cargo data (for CFT_CARGO).
StringFilter
String filter and state.
Definition: stringfilter_type.h:30
GenerateIndustries
void GenerateIndustries()
This function will create random industries during game creation.
Definition: industry_cmd.cpp:2444
IndustryDirectoryWindow::industry_editbox
QueryString industry_editbox
Filter editbox.
Definition: industry_gui.cpp:1339
WID_IV_INFO
@ WID_IV_INFO
Info of the industry.
Definition: industry_widget.h:29
CargoFilterCriteria::CF_ANY
static constexpr CargoID CF_ANY
Show all items independent of carried cargo (i.e. no filtering)
Definition: cargo_type.h:94
BuildIndustryWindow
Build (fund or prospect) a new industry,.
Definition: industry_gui.cpp:303
WWT_TEXTBTN
@ WWT_TEXTBTN
(Toggle) Button with text
Definition: widget_type.h:57
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:635
CargoesField::cargo_line
static Dimension cargo_line
Dimensions of cargo lines.
Definition: industry_gui.cpp:1988
CargoesField::other_accepted
CargoID other_accepted[MAX_CARGOES]
Cargoes accepted but not used in this figure.
Definition: industry_gui.cpp:2008
WWT_DROPDOWN
@ WWT_DROPDOWN
Drop down list.
Definition: widget_type.h:72
TileHighlightData::GetCallbackWnd
Window * GetCallbackWnd()
Get the window that started the current highlighting.
Definition: viewport.cpp:2582
DrawPixelInfo
Data about how and where to blit pixels.
Definition: gfx_type.h:151
GUISettings::persistent_buildingtools
bool persistent_buildingtools
keep the building tools active after usage
Definition: settings_type.h:190
GUIList::SetListing
void SetListing(Listing l)
Import sort conditions.
Definition: sortlist_type.h:151
Hotkey
All data for a single hotkey.
Definition: hotkeys.h:21
IndustryDirectoryHotkeys
IndustryDirectoryHotkeys
Enum referring to the Hotkeys in the industry directory window.
Definition: industry_gui.cpp:1314
hotkeys.h
_industry_cargoes_desc
static WindowDesc _industry_cargoes_desc(__FILE__, __LINE__, WDP_AUTO, "industry_cargoes", 300, 210, WC_INDUSTRY_CARGOES, WC_NONE, 0, std::begin(_nested_industry_cargoes_widgets), std::end(_nested_industry_cargoes_widgets))
Window description for the industry cargoes window.
_nested_industry_cargoes_widgets
static constexpr NWidgetPart _nested_industry_cargoes_widgets[]
Widgets of the industry cargoes window.
Definition: industry_gui.cpp:1937
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:66
backup_type.hpp
BuildIndustryWindow::OnInvalidateData
void OnInvalidateData([[maybe_unused]] int data=0, [[maybe_unused]] bool gui_scope=true) override
Some data on this window has become invalid.
Definition: industry_gui.cpp:753
HasBit
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103