* Fill the Window::nested_array array with pointers to nested widgets in the tree.

 * @param array Base pointer of the array.

 * @param length Length of the array.

 */

/**

 * @fn void NWidgetBase::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.

 * @param w Window that owns the tree.

 */

	this->resize_x = resize_x;

	this->resize_y = resize_y;

}

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

{

}

/**

 * Initialization of a 'real' widget.

 * @param tp          Type of the widget.

 * @param colour      Colour of the widget.

	}

}

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

{

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

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

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

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

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

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

{

	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.

	 *

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

{

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

		this->resize_y = resize.height;

	}

}

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

{

	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;

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

	 * Set additional space (padding) around the widget.

	 * @param top    Amount of additional space above the widget.

	 * @param right  Amount of additional space right of the widget.

	 * @param bottom Amount of additional space below the widget.

	 * @param left   Amount of additional space left of the widget.

	 */

	{

		this->padding_top = top;

		this->padding_right = right;

		this->padding_bottom = bottom;

		this->padding_left = left;

	};

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

	virtual void SetDirty(const Window *w) const;

	WidgetType type;      ///< Type of the widget / nested widget.

	uint fill_x;          ///< Horizontal fill stepsize (from initial size, \c 0 means not resizable).

	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.

 */

{

	return (sizing == ST_RESIZE) ? this->resize_x : this->fill_x;

}

/**

 * Get the vertical sizing step.

 * @param sizing Type of resize being performed.

 */

{

	return (sizing == ST_RESIZE) ? this->resize_y : this->fill_y;

}

/** Base class for a resizable nested widget.

 * @ingroup NestedWidgets */

class NWidgetResizeBase : public NWidgetBase {

public:

	NWidgetResizeBase(WidgetType tp, uint fill_x, uint fill_y);