NOT_REACHED();

			}

		}

		this->querystrings[WID_SL_SAVE_OSK_TITLE] = &this->filename_editbox;

		this->filename_editbox.ok_button = WID_SL_SAVE_GAME;

		if (this->fop == SLO_LOAD && this->abstract_filetype == FT_SAVEGAME) {

			this->GetWidget<NWidgetStacked>(WID_SL_CONTENT_DOWNLOAD_SEL)->SetDisplayedPlane(SZSP_HORIZONTAL);

		}

		/* Select caption string of the window. */

		StringID caption_string;

		leaf->SetMinimalSize(14 + GetSpriteSize(SPR_LOCK, nullptr, ZOOM_LVL_OUT_4X).width

		                        + GetSpriteSize(SPR_BLOT, nullptr, ZOOM_LVL_OUT_4X).width, 12);

		leaf->SetFill(0, 1);

		this->Add(leaf);

	}

	{

		this->smallest_y = 0; // Biggest child.

		this->fill_x = 1;

		this->fill_y = 0;

		this->resize_x = 1; // We only resize in this direction

		this->resize_y = 0; // We never resize in this direction

		/* First initialise some variables... */

		for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {

			this->smallest_y = std::max(this->smallest_y, child_wid->smallest_y + child_wid->padding.Vertical());

		}

		/* ... then in a second pass make sure the 'current' sizes are set. Won't change for most widgets. */

		for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {

			child_wid->current_x = child_wid->smallest_x;

		this->Add(this->acs);

		this->Add(this->inf);

		this->editable = true; // Temporary setting, 'real' value is set in SetupSmallestSize().

	}

	{

		/* Copy state flag from the window. */

		assert(dynamic_cast<NewGRFWindow *>(w) != nullptr);

		NewGRFWindow *ngw = (NewGRFWindow *)w;

		this->editable = ngw->editable;

		uint min_avs_width = this->avs->smallest_x + this->avs->padding.Horizontal();

		uint min_acs_width = this->acs->smallest_x + this->acs->padding.Horizontal();

		uint min_inf_width = this->inf->smallest_x + this->inf->padding.Horizontal();

		uint min_avs_height = this->avs->smallest_y + this->avs->padding.Vertical();

public:

	NWidgetSmallmapDisplay() : NWidgetContainer(NWID_VERTICAL)

	{

		this->smallmap_window = nullptr;

	}

	{

		NWidgetBase *display = this->head;

		NWidgetBase *bar = display->next;

		this->smallmap_window = dynamic_cast<SmallMapWindow *>(w);

		assert(this->smallmap_window != nullptr);

		this->smallest_x = std::max(display->smallest_x, bar->smallest_x + smallmap_window->GetMinLegendWidth());

		this->smallest_y = display->smallest_y + std::max(bar->smallest_y, smallmap_window->GetLegendHeight(smallmap_window->min_number_of_columns));

		this->fill_x = std::max(display->fill_x, bar->fill_x);

	 */

	bool IsButton(WidgetType type) const

	{

		return type == WWT_IMGBTN || type == WWT_IMGBTN_2 || type == WWT_PUSHIMGBTN;

	}

	{

		this->smallest_x = 0; // Biggest child

		this->smallest_y = 0; // Biggest child

		this->fill_x = 1;

		this->fill_y = 0;

		this->resize_x = 1; // We only resize in this direction

		this->resize_y = 0; // We never resize in this direction

		this->spacers = 0;

		uint nbuttons = 0;

		/* First initialise some variables... */

		for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {

			this->smallest_y = std::max(this->smallest_y, child_wid->smallest_y + child_wid->padding.Vertical());

			if (this->IsButton(child_wid->type)) {

				nbuttons++;

				this->smallest_x = std::max(this->smallest_x, child_wid->smallest_x + child_wid->padding.Horizontal());

			} else if (child_wid->type == NWID_SPACER) {

				this->spacers++;

};

/** Container for the scenario editor's toolbar */

class NWidgetScenarioToolbarContainer : public NWidgetToolbarContainer {

	uint panel_widths[2]; ///< The width of the two panels (the text panel and date panel)

	{

		/* Find the size of panel_widths */

		uint i = 0;

		for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {

			if (child_wid->type == NWID_SPACER || this->IsButton(child_wid->type)) continue;

	this->type = tp;

}

/* ~NWidgetContainer() takes care of #next and #prev data members. */

/**

 * Compute smallest size needed by the widget.

 *

 * The smallest size of a widget is the smallest size that a widget needs to

 * display itself properly. In addition, filling and resizing of the widget are computed.

 * The function calls #Window::UpdateWidgetSize for each leaf widget and

 * background widget without child with a non-negative index.

 *

 * @param w          Window owning the widget.

 *

 * @note After the computation, the results can be queried by accessing the #smallest_x and #smallest_y data members of the widget.

 */

/**

 * @fn void NWidgetBase::AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl)

	for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {

		child_wid->AdjustPaddingForZoom();

	}

	NWidgetContainer::AdjustPaddingForZoom();

}

{

	/* Zero size plane selected */

	if (this->shown_plane >= SZSP_BEGIN) {

		Dimension size    = {0, 0};

		Dimension padding = {0, 0};

		Dimension fill    = {(this->shown_plane == SZSP_HORIZONTAL), (this->shown_plane == SZSP_VERTICAL)};

		Dimension resize  = {(this->shown_plane == SZSP_HORIZONTAL), (this->shown_plane == SZSP_VERTICAL)};

	this->smallest_y = 0;

	this->fill_x = (this->head != nullptr) ? 1 : 0;

	this->fill_y = (this->head != nullptr) ? 1 : 0;

	this->resize_x = (this->head != nullptr) ? 1 : 0;

	this->resize_y = (this->head != nullptr) ? 1 : 0;

	for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {

		this->smallest_x = std::max(this->smallest_x, child_wid->smallest_x + child_wid->padding.Horizontal());

		this->smallest_y = std::max(this->smallest_y, child_wid->smallest_y + child_wid->padding.Vertical());

		this->fill_x = LeastCommonMultiple(this->fill_x, child_wid->fill_x);

		this->fill_y = LeastCommonMultiple(this->fill_y, child_wid->fill_y);

		this->resize_x = LeastCommonMultiple(this->resize_x, child_wid->resize_x);

/** Horizontal container widget. */

NWidgetHorizontal::NWidgetHorizontal(NWidContainerFlags flags) : NWidgetPIPContainer(NWID_HORIZONTAL, flags)

{

}

{

	this->smallest_x = 0; // Sum of minimal size of all children.

	this->smallest_y = 0; // Biggest child.

	this->fill_x = 0;     // smallest non-zero child widget fill step.

	this->fill_y = 1;     // smallest common child fill step.

	this->resize_x = 0;   // smallest non-zero child widget resize step.

	this->gaps = 0;

	/* 1a. Forward call, collect biggest nested array index, and longest/widest child length. */

	uint longest = 0; // Longest child found.

	uint max_vert_fill = 0; // Biggest vertical fill step.

	for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {

		longest = std::max(longest, child_wid->smallest_x);

		max_vert_fill = std::max(max_vert_fill, child_wid->GetVerticalStepSize(ST_SMALLEST));

		this->smallest_y = std::max(this->smallest_y, child_wid->smallest_y + child_wid->padding.Vertical());

		if (child_wid->smallest_x != 0 || child_wid->fill_x != 0) this->gaps++;

	}

	if (this->gaps > 0) this->gaps--; // Number of gaps is number of widgets less one.

/** Vertical container widget. */

NWidgetVertical::NWidgetVertical(NWidContainerFlags flags) : NWidgetPIPContainer(NWID_VERTICAL, flags)

{

}

{

	this->smallest_x = 0; // Biggest child.

	this->smallest_y = 0; // Sum of minimal size of all children.

	this->fill_x = 1;     // smallest common child fill step.

	this->fill_y = 0;     // smallest non-zero child widget fill step.

	this->resize_x = 1;   // smallest common child resize step.

	this->gaps = 0;

	/* 1a. Forward call, collect biggest nested array index, and longest/widest child length. */

	uint highest = 0; // Highest child found.

	uint max_hor_fill = 0; // Biggest horizontal fill step.

	for (NWidgetBase *child_wid = this->head; child_wid != nullptr; child_wid = child_wid->next) {

		highest = std::max(highest, child_wid->smallest_y);

		max_hor_fill = std::max(max_hor_fill, child_wid->GetHorizontalStepSize(ST_SMALLEST));

		this->smallest_x = std::max(this->smallest_x, child_wid->smallest_x + child_wid->padding.Horizontal());

		if (child_wid->smallest_y != 0 || child_wid->fill_y != 0) this->gaps++;

	}

	if (this->gaps > 0) this->gaps--; // Number of gaps is number of widgets less one.

NWidgetSpacer::NWidgetSpacer(int width, int height) : NWidgetResizeBase(NWID_SPACER, 0, 0)

{

	this->SetMinimalSize(width, height);

	this->SetResize(0, 0);

}

{

	this->smallest_x = this->min_x;

	this->smallest_y = this->min_y;

}

void NWidgetSpacer::FillNestedArray(NWidgetBase **, uint)

 */

void NWidgetMatrix::SetScrollbar(Scrollbar *sb)

{

	this->sb = sb;

}

{

	assert(this->head != nullptr);

	assert(this->head->next == nullptr);

	/* Reset the widget number. */

	NWidgetCore *nw = dynamic_cast<NWidgetCore *>(this->head);

	assert(nw != nullptr);

	SB(nw->index, 16, 16, 0);

	Dimension padding = { (uint)this->pip_pre + this->pip_post, (uint)this->pip_pre + this->pip_post};

	Dimension size    = {this->head->smallest_x + padding.width, this->head->smallest_y + padding.height};

	Dimension fill    = {0, 0};

	Dimension resize  = {this->pip_inter + this->head->smallest_x, this->pip_inter + this->head->smallest_y};

void NWidgetBackground::AdjustPaddingForZoom()

{

	if (child != nullptr) child->AdjustPaddingForZoom();

	NWidgetCore::AdjustPaddingForZoom();

}

{

	if (this->child != nullptr) {

		this->smallest_x = this->child->smallest_x;

		this->smallest_y = this->child->smallest_y;

		this->fill_x = this->child->fill_x;

		this->fill_y = this->child->fill_y;

		this->resize_x = this->child->resize_x;

NWidgetViewport::NWidgetViewport(int index) : NWidgetCore(NWID_VIEWPORT, INVALID_COLOUR, 1, 1, 0x0, STR_NULL)

{

	this->SetIndex(index);

}

{

	this->smallest_x = this->min_x;

	this->smallest_y = this->min_y;

}

void NWidgetViewport::Draw(const Window *w)

{

			break;

		default: NOT_REACHED();

	}

}

{

	this->min_x = 0;

	this->min_y = 0;

	switch (this->type) {

		case NWID_HSCROLLBAR:

			this->SetMinimalSizeAbsolute(NWidgetScrollbar::GetHorizontalDimension().width * 3, NWidgetScrollbar::GetHorizontalDimension().height);

		default:

			NOT_REACHED();

	}

}

{

	Dimension padding = {0, 0};

	Dimension size = {this->min_x, this->min_y};

	Dimension fill = {this->fill_x, this->fill_y};

	Dimension resize = {this->resize_x, this->resize_y};

	switch (this->type) {

		case WWT_EMPTY: {

 */

class NWidgetBase : public ZeroedMemoryAllocator {

public:

	NWidgetBase(WidgetType tp);

	virtual void AdjustPaddingForZoom();

	virtual void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) = 0;

	virtual void FillNestedArray(NWidgetBase **array, uint length) = 0;

	virtual NWidgetCore *GetWidgetFromPos(int x, int y) = 0;

	virtual NWidgetBase *GetWidgetOfType(WidgetType tp);

public:

	NWidgetStacked();

	void SetIndex(int index);

	void AdjustPaddingForZoom() override;

	void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;

	void FillNestedArray(NWidgetBase **array, uint length) override;

	void Draw(const Window *w) override;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

 * @ingroup NestedWidgets

 */

class NWidgetHorizontal : public NWidgetPIPContainer {

public:

	NWidgetHorizontal(NWidContainerFlags flags = NC_NONE);

	void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;

};

/**

 * Horizontal container that doesn't change the direction of the widgets for RTL languages.

 * @ingroup NestedWidgets

 * @ingroup NestedWidgets

 */

class NWidgetVertical : public NWidgetPIPContainer {

public:

	NWidgetVertical(NWidContainerFlags flags = NC_NONE);

	void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;

};

/**

 * Matrix container with implicitly equal sized (virtual) sub-widgets.

 * This widget must have exactly one sub-widget. After that this sub-widget

	void SetIndex(int index);

	void SetColour(Colours colour);

	void SetClicked(int clicked);

	void SetCount(int count);

	void SetScrollbar(Scrollbar *sb);

	void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;

	void FillNestedArray(NWidgetBase **array, uint length) override;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

	void Draw(const Window *w) override;

protected:

 * @ingroup NestedWidgets

 */

class NWidgetSpacer : public NWidgetResizeBase {

public:

	NWidgetSpacer(int width, int height);

	void FillNestedArray(NWidgetBase **array, uint length) override;

	void Draw(const Window *w) override;

	void SetDirty(const Window *w) const override;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

};

	void Add(NWidgetBase *nwid);

	void SetPIP(uint8_t pip_pre, uint8_t pip_inter, uint8_t pip_post);

	void SetPIPRatio(uint8_t pip_ratio_pre, uint8_t pip_ratio_inter, uint8_t pip_ratio_post);

	void AdjustPaddingForZoom() override;

	void AssignSizePosition(SizingType sizing, int x, int y, uint given_width, uint given_height, bool rtl) override;

	void FillNestedArray(NWidgetBase **array, uint length) override;

	void Draw(const Window *w) override;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

 * @ingroup NestedWidgets

 */

class NWidgetViewport : public NWidgetCore {

public:

	NWidgetViewport(int index);

	void Draw(const Window *w) override;

	void InitializeViewport(Window *w, std::variant<TileIndex, VehicleID> focus, ZoomLevel zoom);

	void UpdateViewportCoordinates(Window *w);

};

 * @ingroup NestedWidgets

 */

class NWidgetScrollbar : public NWidgetCore, public Scrollbar {

public:

	NWidgetScrollbar(WidgetType tp, Colours colour, int index);

	void Draw(const Window *w) override;

	static void InvalidateDimensionCache();

	static Dimension GetVerticalDimension();

	static Dimension GetHorizontalDimension();

 * @ingroup NestedWidgets

 */

class NWidgetLeaf : public NWidgetCore {

public:

	NWidgetLeaf(WidgetType tp, Colours colour, int index, uint32_t data, StringID tip);

	void Draw(const Window *w) override;

	bool ButtonHit(const Point &pt);

	static void InvalidateDimensionCache();

	/* Save current size. */

	int window_width  = this->width * _gui_scale / this->scale;

	int window_height = this->height * _gui_scale / this->scale;

	this->scale = _gui_scale;

	this->OnInit();

	this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);

	this->width  = this->nested_root->smallest_x;

	this->height = this->nested_root->smallest_y;

	this->resize.step_width  = this->nested_root->resize_x;

	this->resize.step_height = this->nested_root->resize_y;

	if (this->window_desc->default_pos == WDP_CENTER) this->flags |= WF_CENTERED;

	this->owner = INVALID_OWNER;

	this->nested_focus = nullptr;

	this->window_number = window_number;

	this->OnInit();

	/* Initialize to smallest size. */

	this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);

	/* Further set up window properties,

	 * this->left, this->top, this->width, this->height, this->resize.width, and this->resize.height are initialized later. */

	this->resize.step_width  = this->nested_root->resize_x;

 * Perform the first part of the initialization of a nested widget tree.

 * Construct a nested widget tree in #nested_root, and optionally fill the #nested_array array to provide quick access to the uninitialized widgets.

 * This is mainly useful for setting very basic properties.

 * @param fill_nested Fill the #nested_array (enabling is expensive!).

 * @note Filling the nested array requires an additional traversal through the nested widget tree, and is best performed by #FinishInitNested rather than here.

 */

{

	int biggest_index = -1;

	this->nested_root = MakeWindowNWidgetTree(this->window_desc->nwid_begin, this->window_desc->nwid_end, &biggest_index, &this->shade_select);

	this->nested_array_size = (uint)(biggest_index + 1);

}

/**

 * Perform the second part of the initialization of a nested widget tree.

 * @param window_number Number of the new window.

 */

/**

 * Perform complete initialization of the #Window with nested widgets, to allow use.

 * @param window_number Number of the new window.

 */

void Window::InitNested(WindowNumber window_number)

{

	this->FinishInitNested(window_number);

}

/**

 * Empty constructor, initialization has been moved to #InitNested() called from the constructor of the derived class.

 * @param desc The description of the window.

	virtual const struct Textbuf *GetFocusedTextbuf() const;

	virtual Point GetCaretPosition() const;

	virtual Rect GetTextBoundingRect(const char *from, const char *to) const;

	virtual ptrdiff_t GetTextCharacterAtPosition(const Point &pt) const;

	void InitNested(WindowNumber number = 0);

	void FinishInitNested(WindowNumber window_number = 0);

	template<typename T, std::enable_if_t<std::is_base_of<StrongTypedefBase, T>::value, int> = 0>

	void FinishInitNested(T number)

	{

		this->FinishInitNested(number.base());