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) {

			child_wid->SetupSmallestSize(w, init_array);

		}

		/* ... 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;

			child_wid->current_y = this->smallest_y;

		this->editable = ngw->editable;

		this->avs->SetupSmallestSize(w, init_array);

		this->acs->SetupSmallestSize(w, init_array);

		this->inf->SetupSmallestSize(w, init_array);

		/* Smallest window is in two column mode. */

		this->smallest_x = std::max(min_avs_width, min_acs_width) + INTER_COLUMN_SPACING + min_inf_width;

		this->smallest_y = std::max(min_inf_height, min_acs_height + INTER_LIST_SPACING + min_avs_height);

		/* Filling. */

	}

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

	{

		this->StoreSizePosition(sizing, x, y, given_width, given_height);

		uint min_list_width = std::max(min_avs_width, min_acs_width); // Smallest width of the lists such that they have equal width (incl padding).

		uint avs_extra_width = min_list_width - min_avs_width;   // Additional width needed for avs to reach min_list_width.

		uint acs_extra_width = min_list_width - min_acs_width;   // Additional width needed for acs to reach min_list_width.

		/* Use 2 or 3 columns? */

			extra_width -= std::min(acs_extra_width, extra_width);

			avs_width += extra_width / 2;

			avs_width = ComputeMaxSize(this->avs->smallest_x, this->avs->smallest_x + avs_width, this->avs->GetHorizontalStepSize(sizing));

			uint acs_width = given_width - // Remaining space, including horizontal padding.

			acs_width = ComputeMaxSize(min_acs_width, acs_width, this->acs->GetHorizontalStepSize(sizing)) -

			/* Never use fill_y on these; the minimal size is chosen, so that the 3 column view looks nice */

			uint avs_height = ComputeMaxSize(this->avs->smallest_y, given_height, this->avs->resize_y);

			uint acs_height = ComputeMaxSize(this->acs->smallest_y, given_height, this->acs->resize_y);

			/* Assign size and position to the children. */

			 * the column is min_list_width wide at least. */

			uint avs_width = ComputeMaxSize(this->avs->smallest_x, this->avs->smallest_x + avs_extra_width + extra_width,

					this->avs->GetHorizontalStepSize(sizing));

			uint acs_width = ComputeMaxSize(this->acs->smallest_x, this->acs->smallest_x + acs_extra_width + extra_width,

					this->acs->GetHorizontalStepSize(sizing));

			uint extra_height = given_height - min_acs_height - min_avs_height;

			/* Never use fill_y on these; instead use the INTER_LIST_SPACING as filler */

			uint avs_height = ComputeMaxSize(this->avs->smallest_y, this->avs->smallest_y + extra_height / 2, this->avs->resize_y);

			if (this->editable) extra_height -= avs_height - this->avs->smallest_y;

			uint acs_height = ComputeMaxSize(this->acs->smallest_y, this->acs->smallest_y + extra_height, this->acs->resize_y);

				this->acs->AssignSizePosition(sizing, x + this->acs->padding.left, y + this->acs->padding.top, acs_width, acs_height, rtl);

				if (this->editable) {

					this->avs->AssignSizePosition(sizing, x + this->avs->padding.left, y + given_height - avs_height - this->avs->padding.bottom, avs_width, avs_height, rtl);

				} else {

					this->avs->AssignSizePosition(sizing, 0, 0, this->avs->smallest_x, this->avs->smallest_y, rtl);

				}

				if (this->editable) {

				}

				x += dx + INTER_COLUMN_SPACING + this->inf->padding.left;

				this->inf->AssignSizePosition(sizing, x, y + this->inf->padding.top, inf_width, inf_height, rtl);

			}

		}

	}

		this->spacers = 0;

		uint nbuttons = 0;

		/* First initialise some variables... */

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

			child_wid->SetupSmallestSize(w, init_array);

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

				nbuttons++;

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

				this->spacers++;

			}

		}

		/* ... then in a second pass make sure the 'current' heights are set. Won't change ever. */

	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) {

		child_wid->SetupSmallestSize(w, init_array);

		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);

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

	}

}

	this->StoreSizePosition(sizing, x, y, given_width, given_height);

	if (this->shown_plane >= SZSP_BEGIN) return;

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

		uint hor_step = (sizing == ST_SMALLEST) ? 1 : child_wid->GetHorizontalStepSize(sizing);

		uint child_pos_x = (rtl ? child_wid->padding.right : child_wid->padding.left);

		uint vert_step = (sizing == ST_SMALLEST) ? 1 : child_wid->GetVerticalStepSize(sizing);

		uint child_pos_y = child_wid->padding.top;

		child_wid->AssignSizePosition(sizing, x + child_pos_x, y + child_pos_y, child_width, child_height, rtl);

	}

}

	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) {

		child_wid->SetupSmallestSize(w, init_array);

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

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

	}

	/* 1b. Make the container higher if needed to accommodate all children nicely. */

	[[maybe_unused]] uint max_smallest = this->smallest_y + 3 * max_vert_fill; // Upper limit to computing smallest height.

	uint cur_height = this->smallest_y;

	for (;;) {

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

			uint step_size = child_wid->GetVerticalStepSize(ST_SMALLEST);

			if (step_size > 1 && child_height < cur_height) { // Small step sizes or already fitting children are not interesting.

				uint remainder = (cur_height - child_height) % step_size;

				if (remainder > 0) { // Child did not fit entirely, widen the container.

					cur_height += step_size - remainder;

					assert(cur_height < max_smallest); // Safeguard against infinite height expansion.

					/* Remaining children will adapt to the new cur_height, thus speeding up the computation. */

		if (child_wid->next != nullptr) {

			child_wid->padding.right += this->pip_inter;

		} else {

			child_wid->padding.right += this->pip_post;

		}

		if (child_wid->fill_x > 0) {

			if (this->fill_x == 0 || this->fill_x > child_wid->fill_x) this->fill_x = child_wid->fill_x;

		}

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

		if (child_wid->resize_x > 0) {

	/* Compute additional width given to us. */

	uint additional_length = given_width;

	if (sizing == ST_SMALLEST && (this->flags & NC_EQUALSIZE)) {

		/* For EQUALSIZE containers this does not sum to smallest_x during initialisation */

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

		}

	} else {

		additional_length -= this->smallest_x;

	}

	this->StoreSizePosition(sizing, x, y, given_width, given_height);

			biggest_stepsize = std::max(biggest_stepsize, hor_step);

		} else {

			child_wid->current_x = child_wid->smallest_x;

		}

		uint vert_step = (sizing == ST_SMALLEST) ? 1 : child_wid->GetVerticalStepSize(sizing);

	}

	/* First.5 loop: count how many children are of the biggest step size. */

	if ((flags & NC_BIGFIRST) && biggest_stepsize > 0) {

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

			uint hor_step = child_wid->GetHorizontalStepSize(sizing);

	while (child_wid != nullptr) {

		uint child_width = child_wid->current_x;

		uint child_x = x + (rtl ? position - child_width - child_wid->padding.left : position + child_wid->padding.left);

		uint child_y = y + child_wid->padding.top;

		child_wid->AssignSizePosition(sizing, child_x, child_y, child_width, child_wid->current_y, rtl);

		position = rtl ? position - padded_child_width : position + padded_child_width;

		child_wid = child_wid->next;

	}

}

	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) {

		child_wid->SetupSmallestSize(w, init_array);

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

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

	}

	/* 1b. Make the container wider if needed to accommodate all children nicely. */

	[[maybe_unused]] uint max_smallest = this->smallest_x + 3 * max_hor_fill; // Upper limit to computing smallest height.

	uint cur_width = this->smallest_x;

	for (;;) {

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

			uint step_size = child_wid->GetHorizontalStepSize(ST_SMALLEST);

			if (step_size > 1 && child_width < cur_width) { // Small step sizes or already fitting children are not interesting.

				uint remainder = (cur_width - child_width) % step_size;

				if (remainder > 0) { // Child did not fit entirely, widen the container.

					cur_width += step_size - remainder;

					assert(cur_width < max_smallest); // Safeguard against infinite width expansion.

					/* Remaining children will adapt to the new cur_width, thus speeding up the computation. */

		if (child_wid->next != nullptr) {

			child_wid->padding.bottom += this->pip_inter;

		} else {

			child_wid->padding.bottom += this->pip_post;

		}

		if (child_wid->fill_y > 0) {

			if (this->fill_y == 0 || this->fill_y > child_wid->fill_y) this->fill_y = child_wid->fill_y;

		}

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

		if (child_wid->resize_y > 0) {

	/* Compute additional height given to us. */

	uint additional_length = given_height;

	if (sizing == ST_SMALLEST && (this->flags & NC_EQUALSIZE)) {

		/* For EQUALSIZE containers this does not sum to smallest_y during initialisation */

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

		}

	} else {

		additional_length -= this->smallest_y;

	}

	this->StoreSizePosition(sizing, x, y, given_width, given_height);

			biggest_stepsize = std::max(biggest_stepsize, vert_step);

		} else {

			child_wid->current_y = child_wid->smallest_y;

		}

		uint hor_step = (sizing == ST_SMALLEST) ? 1 : child_wid->GetHorizontalStepSize(sizing);

	}

	/* First.5 loop: count how many children are of the biggest step size. */

	if ((this->flags & NC_BIGFIRST) && biggest_stepsize > 0) {

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

			uint vert_step = child_wid->GetVerticalStepSize(sizing);

	uint position = 0; // Place to put next child relative to origin of the container.

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

		uint child_x = x + (rtl ? child_wid->padding.right : child_wid->padding.left);

		uint child_height = child_wid->current_y;

		child_wid->AssignSizePosition(sizing, child_x, y + position + child_wid->padding.top, child_wid->current_x, child_height, rtl);

	}

}

/**

 * Generic spacer widget.

 * @param width  Horizontal size of the spacer widget.

			/* Account for the size of the frame's text if that exists */

			this->child->padding.left   = WD_FRAMETEXT_LEFT;

			this->child->padding.right  = WD_FRAMETEXT_RIGHT;

			this->child->padding.top    = std::max((int)WD_FRAMETEXT_TOP, this->widget_data != STR_NULL ? FONT_HEIGHT_NORMAL + WD_FRAMETEXT_TOP / 2 : 0);

			this->child->padding.bottom = WD_FRAMETEXT_BOTTOM;

			if (this->index >= 0) w->SetStringParameters(this->index);

			this->smallest_x = std::max(this->smallest_x, GetStringBoundingBox(this->widget_data).width + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT);

		} else if (this->type == WWT_INSET) {

			/* Apply automatic padding for bevel thickness. */

			this->child->padding.left   = WD_BEVEL_LEFT;

			this->child->padding.right  = WD_BEVEL_RIGHT;

			this->child->padding.top    = WD_BEVEL_TOP;

			this->child->padding.bottom = WD_BEVEL_BOTTOM;

		}

	} else {

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

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

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

		if (w != nullptr) { // A non-nullptr window pointer acts as switch to turn dynamic widget size on.

void NWidgetBackground::AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool rtl)

{

	this->StoreSizePosition(sizing, x, y, given_width, given_height);

	if (this->child != nullptr) {

		uint x_offset = (rtl ? this->child->padding.right : this->child->padding.left);

		this->child->AssignSizePosition(sizing, x + x_offset, y + this->child->padding.top, width, height, rtl);

	}

}

void NWidgetBackground::FillNestedArray(NWidgetBase **array, uint length)

{

					nwc->tool_tip = parts->u.data_tip.tooltip;

				}

				break;

			}

			case WPT_PADDING:

				break;

			case WPT_PIPSPACE: {

				NWidgetPIPContainer *nwc = dynamic_cast<NWidgetPIPContainer *>(*dest);

				if (nwc != nullptr) nwc->SetPIP(parts->u.pip.pre, parts->u.pip.inter, parts->u.pip.post);

		this->uz_padding.right = right;

		this->uz_padding.bottom = bottom;

		this->uz_padding.left = left;

		this->AdjustPaddingForZoom();

	}

	inline uint GetHorizontalStepSize(SizingType sizing) const;

	inline uint GetVerticalStepSize(SizingType sizing) const;

	virtual void Draw(const Window *w) = 0;

	virtual void SetDirty(const Window *w) const;