* @param state State of sort button

 */

void Window::DrawSortButtonState(int widget, SortButtonState state) const

{

	if (state == SBS_OFF) return;

	Rect r = this->GetWidget<NWidgetBase>(widget)->GetCurrentRect();

	/* Sort button uses the same sprites as vertical scrollbar */

	Dimension dim = NWidgetScrollbar::GetVerticalDimension();

	DrawSpriteIgnorePadding(state == SBS_DOWN ? SPR_ARROW_DOWN : SPR_ARROW_UP, PAL_NONE, r.WithWidth(dim.width, _current_text_dir == TD_LTR), SA_CENTER);

 *

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

 */

/**

 * @param array Base pointer of the array.

 * @param length Length of the array.

 */

/**

 * @fn void NWidgetBase::Draw(const Window *w)

 */

void NWidgetCore::SetAlignment(StringAlignment align)

{

	this->align = align;

}

{

}

NWidgetCore *NWidgetCore::GetWidgetFromPos(int x, int y)

{

	return (IsInsideBS(x, this->pos_x, this->current_x) && IsInsideBS(y, this->pos_y, this->current_y)) ? this : nullptr;

}

		this->tail->next = wid;

		wid->prev = this->tail;

		this->tail = wid;

	}

}

{

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

	}

}

void NWidgetContainer::Draw(const Window *w)

{

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

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

	}

}

{

}

void NWidgetStacked::Draw(const Window *w)

{

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

void NWidgetSpacer::SetupSmallestSize(Window *)

{

	this->smallest_x = this->min_x;

	this->smallest_y = this->min_y;

}

{

}

void NWidgetSpacer::Draw(const Window *w)

{

	/* Spacer widget is never normally visible. */

	/* When resizing, update the scrollbar's count. E.g. with a vertical

	 * scrollbar becoming wider or narrower means the amount of rows in

	 * the scrollbar becomes respectively smaller or higher. */

	this->SetCount(this->count);

}

{

}

NWidgetCore *NWidgetMatrix::GetWidgetFromPos(int x, int y)

{

	/* Falls outside of the matrix widget. */

	if (!IsInsideBS(x, this->pos_x, this->current_x) || !IsInsideBS(y, this->pos_y, this->current_y)) return nullptr;

		uint width = given_width - this->child->padding.Horizontal();

		uint height = given_height - this->child->padding.Vertical();

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

	}

}

{

}

void NWidgetBackground::Draw(const Window *w)

{

	if (this->current_x == 0 || this->current_y == 0) return;

	NWidgetBase(WidgetType tp);

	virtual void AdjustPaddingForZoom();

	virtual void SetupSmallestSize(Window *w) = 0;

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

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

	virtual NWidgetBase *GetWidgetOfType(WidgetType tp);

	virtual bool IsHighlighted() const { return false; }

	virtual TextColour GetHighlightColour() const { return TC_INVALID; }

	inline void SetLowered(bool lowered);

	inline bool IsLowered() const;

	inline void SetDisabled(bool disabled);

	inline bool IsDisabled() const;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

	bool IsHighlighted() const override;

	TextColour GetHighlightColour() const override;

	void SetHighlighted(TextColour highlight_colour) override;

	NWidgetDisplay disp_flags; ///< Flags that affect display and interaction with the widget.

public:

	NWidgetContainer(WidgetType tp);

	~NWidgetContainer();

	void AdjustPaddingForZoom() override;

	void Add(NWidgetBase *wid);

	void Draw(const Window *w) override;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

	/** Return whether the container is empty. */

	inline bool IsEmpty() { return head == nullptr; }

	void SetIndex(int index);

	void AdjustPaddingForZoom() override;

	void SetupSmallestSize(Window *w) override;

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

	void Draw(const Window *w) override;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

	bool SetDisplayedPlane(int plane);

	int shown_plane; ///< Plane being displayed (for #NWID_SELECTION only).

};

/** Nested widget container flags, */

enum NWidContainerFlags {

	NCB_EQUALSIZE = 0, ///< Containers should keep all their (resizing) children equally large.

	NCB_BIGFIRST  = 1, ///< Allocate space to biggest resize first.

	void SetClicked(int clicked);

	void SetCount(int count);

	void SetScrollbar(Scrollbar *sb);

	void SetupSmallestSize(Window *w) override;

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

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

	void Draw(const Window *w) override;

protected:

	Colours colour; ///< Colour of this widget.

	int clicked;    ///< The currently clicked widget.

	int count;      ///< Amount of valid widgets.

	Scrollbar *sb;  ///< The scrollbar we're associated with.

private:

	int widget_w;   ///< The width of the child widget including inter spacing.

 */

class NWidgetSpacer : public NWidgetResizeBase {

public:

	NWidgetSpacer(int width, int height);

	void SetupSmallestSize(Window *w) override;

	void Draw(const Window *w) override;

	void SetDirty(const Window *w) const override;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

};

	void SetPIPRatio(uint8_t pip_ratio_pre, uint8_t pip_ratio_inter, uint8_t pip_ratio_post);

	void AdjustPaddingForZoom() override;

	void SetupSmallestSize(Window *w) override;

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

	void Draw(const Window *w) override;

	NWidgetCore *GetWidgetFromPos(int x, int y) override;

	NWidgetBase *GetWidgetOfType(WidgetType tp) override;

private:

 */

bool Window::SetFocusedWidget(int widget_index)

{

	/* Do nothing if widget_index is already focused, or if it wasn't a valid widget. */

	if ((uint)widget_index >= this->nested_array_size) return false;

	if (this->nested_focus != nullptr) {

		if (this->GetWidget<NWidgetCore>(widget_index) == this->nested_focus) return false;

		/* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */

		this->nested_focus->SetDirty(this);

		if (this->nested_focus->type == WWT_EDITBOX) VideoDriver::GetInstance()->EditBoxLostFocus();

 * Raise the buttons of the window.

 * @param autoraise Raise only the push buttons of the window.

 */

void Window::RaiseButtons(bool autoraise)

{

	for (uint i = 0; i < this->nested_array_size; i++) {

		if (((type & ~WWB_PUSHBUTTON) < WWT_LAST || type == NWID_PUSHBUTTON_DROPDOWN) &&

				(!autoraise || (type & WWB_PUSHBUTTON) || type == WWT_EDITBOX) && this->IsWidgetLowered(i)) {

			this->RaiseWidget(i);

			this->SetWidgetDirty(i);

		}

	}

 * Invalidate a widget, i.e. mark it as being changed and in need of redraw.

 * @param widget_index the widget to redraw.

 */

void Window::SetWidgetDirty(byte widget_index) const

{

	/* Sometimes this function is called before the window is even fully initialized */

}

/**

 * A hotkey has been pressed.

 * @param hotkey  Hotkey index, by default a widget index of a button or editbox.

 * @return #ES_HANDLED if the key press has been handled, and the hotkey is not unavailable for some reason.

{

	/* Make sure the window is closed, deletion is allowed only in Window::DeleteClosedWindows(). */

	assert(*this->z_position == nullptr);

	if (this->viewport != nullptr) DeleteWindowViewport(this);

	delete this->nested_root;

}

/**

 * Find a window by its class and window number

 * @param cls Window class

/**

 * Initializes the data (except the position and initial size) of a new Window.

 * @param window_number Number being assigned to the new window

 * @return Window pointer of the newly created window

 * @pre If nested widgets are used (\a widget is \c nullptr), #nested_root and #nested_array_size must be initialized.

 */

void Window::InitializeData(WindowNumber window_number)

{

	/* Set up window properties; some of them are needed to set up smallest size below */

	this->window_class = this->window_desc->cls;

	this->SetWhiteBorder();

{

	return LocalGetWindowPlacement(this->window_desc, sm_width, sm_height, window_number);

}

/**

 * Perform the first part of the initialization of a nested widget tree.

 * This is mainly useful for setting very basic properties.

 * @note Filling the nested array requires an additional traversal through the nested widget tree, and is best performed by #FinishInitNested rather than here.

 */

void Window::CreateNestedTree()

{

	int biggest_index = -1;

	this->nested_root = MakeWindowNWidgetTree(this->window_desc->nwid_begin, this->window_desc->nwid_end, &biggest_index, &this->shade_select);

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

}

/**

 * Perform the second part of the initialization of a nested widget tree.

 * @param window_number Number of the new window.

 */

	if (_scroller_click_timeout != 0) _scroller_click_timeout--;

	for (Window *w : Window::Iterate()) {

		if (_scroller_click_timeout == 0) {

			/* Unclick scrollbar buttons if they are pressed. */

			for (uint i = 0; i < w->nested_array_size; i++) {

				if (nwid != nullptr && (nwid->type == NWID_HSCROLLBAR || nwid->type == NWID_VSCROLLBAR)) {

					NWidgetScrollbar *sb = static_cast<NWidgetScrollbar*>(nwid);

					if (sb->disp_flags & (ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN)) {

						sb->disp_flags &= ~(ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN);

						w->mouse_capture_widget = -1;

						sb->SetDirty(w);

	Owner owner;        ///< The owner of the content shown in this window. Company colour is acquired from this variable.

	ViewportData *viewport;          ///< Pointer to viewport data, if present.

	const NWidgetCore *nested_focus; ///< Currently focused nested widget, or \c nullptr if no nested widget has focus.

	std::map<int, QueryString*> querystrings; ///< QueryString associated to WWT_EDITBOX widgets.

	NWidgetBase *nested_root;        ///< Root of the nested tree.

	uint nested_array_size;          ///< Size of the nested array.

	NWidgetStacked *shade_select;    ///< Selection widget (#NWID_SELECTION) to use for shading the window. If \c nullptr, window cannot shade.

	Dimension unshaded_size;         ///< Last known unshaded size (only valid while shaded).

	int mouse_capture_widget;        ///< Widgetindex of current mouse capture widget (e.g. dragged scrollbar). -1 if no widget has mouse capture.

	 * @param widget_index index of this widget in the window

	 * @param disab_stat status to use ie: disabled = true, enabled = false

	 */

	inline void SetWidgetDisabledState(byte widget_index, bool disab_stat)

	{

		assert(widget_index < this->nested_array_size);

	}

	/**

	 * Sets a widget to disabled.

	 * @param widget_index index of this widget in the window

	 */

	void ProcessHighlightedInvalidations();

	/*** Event handling ***/

	/**

	 * Notification that the nested widget tree gets initialized. The event can be used to perform general computations.

	 */

	virtual void OnInit() { }

	virtual void ApplyDefaults();

	/**

 * @param widnum Widget number of the widget to retrieve.

 * @return The requested widget if it is instantiated, \c nullptr otherwise.

 */

template <class NWID>

inline NWID *Window::GetWidget(uint widnum)

{

	assert(nwid != nullptr);

	return nwid;

}

/** Specialized case of #Window::GetWidget for the nested widget base class. */

template <>

inline const NWidgetBase *Window::GetWidget<NWidgetBase>(uint widnum) const

{

	if (widnum >= this->nested_array_size) return nullptr;

}

/**

 * Get the nested widget with number \a widnum from the nested widget tree.

 * @tparam NWID Type of the nested widget.

 * @param widnum Widget number of the widget to retrieve.