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

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

 *

 * @param w Optional 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.

 */

{

}

{

	/* First sweep, recurse down and compute minimal size and filling. */

	this->smallest_x = 0;

	this->smallest_y = 0;

	this->fill_x = (this->head != NULL);

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

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

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

		this->smallest_x = max(this->smallest_x, child_wid->smallest_x + child_wid->padding_left + child_wid->padding_right);

		this->smallest_y = max(this->smallest_y, child_wid->smallest_y + child_wid->padding_top + child_wid->padding_bottom);

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

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

	}

}

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

{

}

{

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

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

	this->fill_x = false;   // true if at least one child allows fill_x.

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

	uint longest = 0; // Longest child found.

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

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

	}

	/* 2. For containers that must maintain equal width, extend child minimal size. */

	}

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

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

}

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

{

}

{

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

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

	this->fill_x = true;    // true if all childs allow fill_x.

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

	uint highest = 0; // Highest child found.

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

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

	}

	/* 2. For containers that must maintain equal width, extend child minimal size. */

	}

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

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

}

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

	this->SetResize(0, 0);

}

{

	this->smallest_x = this->min_x;

	this->smallest_y = this->min_y;

}

void NWidgetSpacer::FillNestedArray(NWidgetCore **array, uint length)

	this->child->SetPIP(pip_pre, pip_inter, pip_post);

}

{

	if (this->child != NULL) {

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

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

		this->smallest_x = d.width;

		this->smallest_y = d.height;

	}

}

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

	}

}

{

	Dimension d = {this->min_x, this->min_y}; // At least minimal size is needed.

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

		Dimension d2 = {0, 0};

		/* Check size requirements of the widget itself too.

		 * Also, add the offset used for rendering.

	this->smallest_x = d.width;

	this->smallest_y = d.height;

	/* All other data is already at the right place. */

}

void NWidgetLeaf::Draw(const Window *w)

 * Intialize nested widget tree and convert to widget array.

 * @param nwid Nested widget tree.

 * @param rtl  Direction of the language.

 * @return Widget array with the converted widgets.

 * @note Caller should release returned widget array with \c free(widgets).

 * @ingroup NestedWidgets

 */

{

	/* Initialize nested widgets. */

	nwid->AssignSizePosition(ST_ARRAY, 0, 0, nwid->smallest_x, nwid->smallest_y, (nwid->resize_x > 0), (nwid->resize_y > 0), rtl);

	/* Construct a local widget array and initialize all its types to #WWT_LAST. */

 * Construct a nested widget tree from an array of parts.

 * @param parts Array with parts of the widgets.

 * @param count Length of the \a parts array.

 * @return Root of the nested widget tree, a vertical container containing the entire GUI.

 * @ingroup NestedWidgetParts

 */

{

	NWidgetContainer *cont = new NWidgetVertical();

	return cont;

}

	if (wid_cache != NULL && *wid_cache != NULL) return *wid_cache;

	assert(parts != NULL && parts_length > 0);

	if (!rtl && orig_wid) {

		/* There are two descriptions, compare them.

public:

	NWidgetBase(WidgetType tp);

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

	virtual void StoreWidgets(Widget *widgets, int length, bool left_moving, bool top_moving, bool rtl) = 0;

public:

	NWidgetStacked(WidgetType tp);

	void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool allow_resize_x, bool allow_resize_y, bool rtl);

	void StoreWidgets(Widget *widgets, int length, bool left_moving, bool top_moving, bool rtl);

public:

	NWidgetHorizontal(NWidContainerFlags flags = NC_NONE);

	void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool allow_resize_x, bool allow_resize_y, bool rtl);

	void StoreWidgets(Widget *widgets, int length, bool left_moving, bool top_moving, bool rtl);

public:

	NWidgetVertical(NWidContainerFlags flags = NC_NONE);

	void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool allow_resize_x, bool allow_resize_y, bool rtl);

	void StoreWidgets(Widget *widgets, int length, bool left_moving, bool top_moving, bool rtl);

public:

	NWidgetSpacer(int length, int height);

	void StoreWidgets(Widget *widgets, int length, bool left_moving, bool top_moving, bool rtl);

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

	void Add(NWidgetBase *nwid);

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

	void AssignSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height, bool allow_resize_x, bool allow_resize_y, bool rtl);

	void StoreWidgets(Widget *widgets, int length, bool left_moving, bool top_moving, bool rtl);

public:

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

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

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

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

	return part;

}

const Widget *InitializeWidgetArrayFromNestedWidgets(const NWidgetPart *parts, int parts_length, const Widget *orig_wid, Widget **wid_cache);

	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->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, false, false, false);

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

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

 * @param *widget       Pointer to the widget array. @see Widget

 * @param nested_root   Root of the nested widget tree.

 * @param window_number Number being assigned to the new window

 * @return Window pointer of the newly created window

 */

{

	/* If available, initialize nested widget tree. */

	if (nested_root != NULL) {

		this->nested_root = nested_root;

		/* Setup nested_array pointers into the tree. */

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

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

		/* Initialize to smallest size. */

		this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, false, false, false);

	}

 */

Window::Window(int x, int y, int width, int height, WindowClass cls, const Widget *widget)

{

	this->InitializePositionSize(x, y, width, height);

}

 */

Window::Window(const WindowDesc *desc, WindowNumber window_number)

{

	this->desc_flags = desc->flags;

	Point pt = LocalGetWindowPlacement(desc, desc->minimum_width, desc->minimum_height, window_number);

	this->InitializePositionSize(pt.x, pt.y, desc->minimum_width, desc->minimum_height);

 */

void Window::InitNested(const WindowDesc *desc, WindowNumber window_number)

{

	this->desc_flags = desc->flags;

	Point pt = LocalGetWindowPlacement(desc, this->nested_root->smallest_x, this->nested_root->smallest_y, window_number);

	this->InitializePositionSize(pt.x, pt.y, this->nested_root->smallest_x, this->nested_root->smallest_y);

	};

protected:

	void InitializePositionSize(int x, int y, int min_width, int min_height);

	void FindWindowPlacementAndResize(int def_width, int def_height);

	void FindWindowPlacementAndResize(const WindowDesc *desc);