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

			child_wid->current_x = child_wid->smallest_x;

			child_wid->current_y = this->smallest_y;

		}

	}

	{

		assert(given_width >= this->smallest_x && given_height >= this->smallest_y);

		this->pos_x = x;

		this->pos_y = y;

		this->current_x = given_width;

		/* Now assign the widgets to their rightful place */

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

		uint i = rtl ? lengthof(this->visible) - 1 : 0;

		child_wid = rtl ? this->tail : this->head;

		while (child_wid != NULL) {

			if (this->visible[i]) {

				position += child_wid->current_x;

			}

			child_wid = rtl ? child_wid->prev : child_wid->next;

			i += rtl ? -1 : 1;

		}

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

				child_wid->current_x = child_wid->smallest_x;

			}

		}

	}

	{

		assert(given_width >= this->smallest_x && given_height >= this->smallest_y);

		this->pos_x = x;

		this->pos_y = y;

		this->current_x = given_width;

			/* Buttons can be scaled, the others not. */

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

				child_wid->current_x = button_space / (button_count - button_i);

				button_space -= child_wid->current_x;

				button_i++;

			}

			position += child_wid->current_x;

			if (rtl) {

				cur_wid--;

			} else {

				cur_wid++;

 * - Containers only know what their children are, \e fill_x, \e fill_y, \e resize_x, and \e resize_y are not initialized.

 *

 * Computations in the nested widgets take place as follows:

 * <ol>

 * <li> A bottom-up sweep by recursively calling NWidgetBase::SetupSmallestSize() to initialize the smallest size (\e smallest_x, \e smallest_y) and

 *      to propagate filling and resize steps upwards to the root of the tree.

 *      the entire tree, and to assign the top-left (\e pos_x, \e pos_y) position of each widget in the tree. This step uses \e fill_x and \e fill_y at each

 *      node in the tree to decide how to fill each widget towards consistent sizes. Also the current size (\e current_x and \e current_y) is set.

 * <li> After initializing the smallest size in the widget tree with #ST_SMALLEST, the tree can be resized (the current size modified) by calling

 *      NWidgetBase::AssignSizePosition() at the root with #ST_RESIZE and the new size of the window. For proper functioning, the new size should be the smallest

 *      size + a whole number of resize steps in both directions (ie you can only resize in steps of length resize_{x,y} from smallest_{x,y}).

 * </ol>

 * After the second step, the current size of the widgets are set to the smallest size.

 *

 * @param init_array Initialize the \c w->nested_array as well. Should only be set if \a w != NULL.

 *

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

 */

/**

 * Assign size and position to the widget.

 * @param sizing         Type of resizing to perform.

 * @param x              Horizontal offset of the widget relative to the left edge of the window.

 * @param y              Vertical offset of the widget relative to the top edge of the window.

 * @param given_width    Width allocated to the widget.

 * @param given_height   Height allocated to the widget.

 * @param rtl            Adapt for right-to-left languages (position contents of horizontal containers backwards).

 *

 * Afterwards, \e pos_x and \e pos_y contain the top-left position of the widget, \e smallest_x and \e smallest_y contain

 * the smallest size such that all widgets of the window are consistent, and \e current_x and \e current_y contain the current size.

 */

 * Store size and position.

 * @param sizing         Type of resizing to perform.

 * @param x              Horizontal offset of the widget relative to the left edge of the window.

 * @param y              Vertical offset of the widget relative to the top edge of the window.

 * @param given_width    Width allocated to the widget.

 * @param given_height   Height allocated to the widget.

 */

{

	this->pos_x = x;

	this->pos_y = y;

		this->smallest_x = given_width;

		this->smallest_y = given_height;

	}

	this->current_x = given_width;

	this->current_y = given_height;

}

/**

 * @fn void Draw(const Window *w)

 * Draw the widgets of the tree.

 * The function calls #Window::DrawWidget for each widget with a non-negative index, after the widget itself is painted.

void NWidgetResizeBase::SetResize(uint resize_x, uint resize_y)

{

	this->resize_x = resize_x;

	this->resize_y = resize_y;

}

{

}

/**

 * Initialization of a 'real' widget.

 * @param tp          Type of the widget.

 * @param colour      Colour of the widget.

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

	}

}

{

	assert(given_width >= this->smallest_x && given_height >= this->smallest_y);

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

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

		uint hor_step = child_wid->GetHorizontalStepSize(sizing);

		uint child_width = ComputeMaxSize(child_wid->smallest_x, given_width - child_wid->padding_left - child_wid->padding_right, hor_step);

		uint child_pos_x = (rtl ? child_wid->padding_right : child_wid->padding_left) + ComputeOffset(child_width, given_width - child_wid->padding_left - child_wid->padding_right);

		uint vert_step = child_wid->GetVerticalStepSize(sizing);

		uint child_height = ComputeMaxSize(child_wid->smallest_y, given_height - child_wid->padding_top - child_wid->padding_bottom, vert_step);

		uint child_pos_y = child_wid->padding_top + ComputeOffset(child_height,  given_height - child_wid->padding_top - child_wid->padding_bottom);

	}

}

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

{

	if (this->index >= 0 && (uint)(this->index) < length) array[this->index] = this;

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

	}

	/* We need to zero the PIP settings so we can re-initialize the tree. */

	this->pip_pre = this->pip_inter = this->pip_post = 0;

}

{

	assert(given_width >= this->smallest_x && given_height >= this->smallest_y);

	uint additional_length = given_width - this->smallest_x; // Additional width given to us.

	/* In principle, the additional horizontal space is distributed evenly over the available resizable childs. Due to step sizes, this may not always be feasible.

	 * To make resizing work as good as possible, first childs with biggest step sizes are done. These may get less due to rounding down.

	 * This additional space is then given to childs with smaller step sizes. This will give a good result when resize steps of each child is a multiple

	 * of the child with the smallest non-zero stepsize.

	 *

		biggest_stepsize = next_biggest_stepsize;

	}

	assert(num_changing_childs == 0);

	/* Third loop: Compute position and call the child. */

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

	NWidgetBase *child_wid = rtl ? this->tail : this->head;

	while (child_wid != NULL) {

		uint child_width = child_wid->current_x;

		uint child_x = x + position + (rtl ? child_wid->padding_right : child_wid->padding_left);

		uint child_y = y + child_wid->padding_top + ComputeOffset(child_wid->current_y,  given_height - child_wid->padding_top - child_wid->padding_bottom);

		position += child_width + child_wid->padding_right + child_wid->padding_left;

		child_wid = rtl ? child_wid->prev : child_wid->next;

	}

}

/** Horizontal left-to-right container widget. */

NWidgetHorizontalLTR::NWidgetHorizontalLTR(NWidContainerFlags flags) : NWidgetHorizontal(flags)

{

	this->type = NWID_HORIZONTAL_LTR;

}

{

}

/** Vertical container widget. */

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

{

}

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

	}

	/* We need to zero the PIP settings so we can re-initialize the tree. */

	this->pip_pre = this->pip_inter = this->pip_post = 0;

}

{

	assert(given_width >= this->smallest_x && given_height >= this->smallest_y);

	int additional_length = given_height - this->smallest_y; // Additional height given to us.

	/* Like the horizontal container, the vertical container also distributes additional height evenly, starting with the childs with the biggest resize steps.

	 * It also stores computed widths and heights into current_x and current_y values of the child.

	 */

	/* First loop: Find biggest stepsize, find number of childs that want a piece of the pie, handle horizontal size for all childs, handle vertical size for non-resizing childs. */

		biggest_stepsize = next_biggest_stepsize;

	}

	assert(num_changing_childs == 0);

	/* Third loop: Compute position and call the child. */

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

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

		uint child_x = x + (rtl ? child_wid->padding_right : child_wid->padding_left) +

									ComputeOffset(child_wid->current_x, given_width - child_wid->padding_left - child_wid->padding_right);

		uint child_height = child_wid->current_y;

		position += child_height + child_wid->padding_top + child_wid->padding_bottom;

	}

}

/**

 * Generic spacer widget.

 * @param length Horizontal size of the spacer widget.

		this->smallest_y = d.height;

		this->resize_x = resize.width;

		this->resize_y = resize.height;

	}

}

{

	if (this->child != NULL) {

		uint x_offset = (rtl ? this->child->padding_right : this->child->padding_left);

		uint width = given_width - this->child->padding_right - this->child->padding_left;

		uint height = given_height - this->child->padding_top - this->child->padding_bottom;

	}

}

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

{

	if (this->index >= 0 && (uint)(this->index) < length) array[this->index] = this;

	WWT_PUSHTXTBTN  = WWT_TEXTBTN | WWB_PUSHBUTTON,

	WWT_PUSHIMGBTN  = WWT_IMGBTN  | WWB_PUSHBUTTON,

};

/** Different forms of sizing nested widgets, using NWidgetBase::AssignSizePosition() */

enum SizingType {

	ST_SMALLEST, ///< Initialize nested widget tree to smallest size. Also updates \e current_x and \e current_y.

	ST_RESIZE,   ///< Resize the nested widget tree.

};

/* Forward declarations. */

class NWidgetCore;

 */

class NWidgetBase : public ZeroedMemoryAllocator {

public:

	NWidgetBase(WidgetType tp);

	virtual void SetupSmallestSize(Window *w, bool init_array) = 0;

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

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

	virtual NWidgetBase *GetWidgetOfType(WidgetType tp);

	uint8 padding_top;    ///< Paddings added to the top of the widget. Managed by parent container widget.

	uint8 padding_right;  ///< Paddings added to the right of the widget. Managed by parent container widget.

	uint8 padding_bottom; ///< Paddings added to the bottom of the widget. Managed by parent container widget.

	uint8 padding_left;   ///< Paddings added to the left of the widget. Managed by parent container widget.

protected:

};

/**

 * Get the horizontal sizing step.

 * @param sizing Type of resize being performed.

 */

	void SetMinimalSize(uint min_x, uint min_y);

	void SetMinimalTextLines(uint8 min_lines, uint8 spacing, FontSize size);

	void SetFill(bool fill_x, bool fill_y);

	void SetResize(uint resize_x, uint resize_y);

	uint min_x; ///< Minimal horizontal size of only this widget.

	uint min_y; ///< Minimal vertical size of only this widget.

};

/** Nested widget flags that affect display and interaction withe 'real' widgets. */

public:

	NWidgetStacked();

	void SetIndex(int index);

	void SetupSmallestSize(Window *w, bool init_array);

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

	/* virtual */ void Draw(const Window *w);

	/* virtual */ NWidgetCore *GetWidgetFromPos(int x, int y);

	void SetDisplayedPlane(int plane);

 * @ingroup NestedWidgets */

class NWidgetHorizontal : public NWidgetPIPContainer {

public:

	NWidgetHorizontal(NWidContainerFlags flags = NC_NONE);

	void SetupSmallestSize(Window *w, bool init_array);

};

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

 * @ingroup NestedWidgets */

class NWidgetHorizontalLTR : public NWidgetHorizontal {

public:

	NWidgetHorizontalLTR(NWidContainerFlags flags = NC_NONE);

};

/** Vertical container.

 * @ingroup NestedWidgets */

class NWidgetVertical : public NWidgetPIPContainer {

public:

	NWidgetVertical(NWidContainerFlags flags = NC_NONE);

	void SetupSmallestSize(Window *w, bool init_array);

};

/** Spacer widget.

 * @ingroup NestedWidgets */

class NWidgetSpacer : public NWidgetResizeBase {

	~NWidgetBackground();

	void Add(NWidgetBase *nwid);

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

	void SetupSmallestSize(Window *w, bool init_array);

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

	/* virtual */ void Draw(const Window *w);

	/* virtual */ NWidgetCore *GetWidgetFromPos(int x, int y);

	/* virtual */ NWidgetBase *GetWidgetOfType(WidgetType tp);

	/* Save current size. */

	int window_width  = this->width;

	int window_height = this->height;

	/* Re-initialize the window from the ground up. No need to change the nested_array, as all widgets stay where they are. */

	this->nested_root->SetupSmallestSize(this, false);

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

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

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

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

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

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

		this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);

		this->nested_root->SetupSmallestSize(this, true);

	} else {

		this->nested_root->SetupSmallestSize(this, false);

	}

	/* Initialize to smallest size. */

	/* 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 != NULL) ? this->nested_root->resize_x : 1;

	this->resize.step_height = (this->nested_root != NULL) ? this->nested_root->resize_y : 1;

	uint new_xinc = max(0, (w->nested_root->resize_x == 0) ? 0 : (int)(w->nested_root->current_x - w->nested_root->smallest_x) + delta_x);

	uint new_yinc = max(0, (w->nested_root->resize_y == 0) ? 0 : (int)(w->nested_root->current_y - w->nested_root->smallest_y) + delta_y);

	assert(w->nested_root->resize_x == 0 || new_xinc % w->nested_root->resize_x == 0);

	assert(w->nested_root->resize_y == 0 || new_yinc % w->nested_root->resize_y == 0);

	w->width  = w->nested_root->current_x;

	w->height = w->nested_root->current_y;

	w->SetDirty();

}

/** Return the top of the main view available for general use.