}

	}

	{

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

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

		while (child_wid != NULL) {

			if (this->visible[i]) {

				position += child_wid->current_x;

			}

		}

	}

	{

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

				button_space -= child_wid->current_x;

				button_i++;

			}

			position += child_wid->current_x;

			if (rtl) {

 * <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}).

 */

/**

 * Assign size and position to the widget.

 *

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

 */

{

	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;

}

/**

	this->resize_y = resize_y;

}

{

}

/**

	}

}

{

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

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

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

	}

}

	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.

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

	}

	this->type = NWID_HORIZONTAL_LTR;

}

{

}

/** Vertical container widget. */

	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.

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

	}

}

	}

}

{

	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;

	}

}

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

};

	NWidgetBase(WidgetType tp);

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

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

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

protected:

};

/**

	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.

	void SetIndex(int index);

	void SetupSmallestSize(Window *w, bool init_array);

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

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

	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.

public:

	NWidgetHorizontalLTR(NWidContainerFlags flags = NC_NONE);

};

/** Vertical container.

	NWidgetVertical(NWidContainerFlags flags = NC_NONE);

	void SetupSmallestSize(Window *w, bool init_array);

};

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

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

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