{

	static const int sprite_y_offsets[] = { -1, -1, -2, -2 };

	/* Obligatory sanity checks! */

	assert(max <= eng_list.size());

	bool rtl = _current_text_dir == TD_RTL;

	int step_size = GetEngineListHeight(type);

	int sprite_left  = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_left;

	int sprite_right = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_right;

	int sprite_width = sprite_left + sprite_right;

	int circle_width = std::max(GetScaledSpriteSize(SPR_CIRCLE_FOLDED).width, GetScaledSpriteSize(SPR_CIRCLE_UNFOLDED).width);

	Rect ir      = r.WithHeight(step_size).Shrink(WidgetDimensions::scaled.matrix);

	int sprite_y_offset = ScaleSpriteTrad(sprite_y_offsets[type]) + ir.Height() / 2;

	Dimension replace_icon = {0, 0};

	int count_width = 0;

	if (show_count) {

		replace_icon = GetSpriteSize(SPR_GROUP_REPLACE_ACTIVE);

		uint biggest_num_engines = 0;

		for (auto i = min; i < max; i++) {

			const auto &item = eng_list[i];

	MarkWholeScreenDirty();

	InvalidateWindowClassesData(WC_SIGN_LIST, -1);

	InvalidateWindowClassesData(WC_GOALS_LIST);

}

/**

 * Get the colour for DrawString-subroutines which matches the colour of the company.

 * @param company Company to get the colour of.

 * @return Colour of \a company.

 */

TextColour GetDrawStringCompanyColour(CompanyID company)

{

}

/**

 * Draw the icon of a company.

 * @param c Company that needs its icon drawn.

 * @param x Horizontal coordinate of the icon.

 * @param y Vertical coordinate of the icon.

 */

void DrawCompanyIcon(CompanyID c, int x, int y)

{

	DrawSprite(SPR_COMPANY_ICON, COMPANY_SPRITE_COLOUR(c), x, y);

}

 * @param c The text colour to compare to.

 * @return true iff the TextColour is valid for console usage.

 */

bool IsValidConsoleColour(TextColour c)

{

	/* A normal text colour is used. */

	if (!(c & TC_IS_PALETTE_COLOUR)) return TC_BEGIN <= c && c < TC_END;

	/* A text colour from the palette is used; must be the company

	 * colour gradient, so it must be one of those. */

	c &= ~TC_IS_PALETTE_COLOUR;

	for (Colours i = COLOUR_BEGIN; i < COLOUR_END; i++) {

	}

	return false;

}

		/* Set up rect for each cell */

		Rect ir = r.WithHeight(this->resize.step_height);

		if (this->num_columns != 1) ir = ir.WithWidth(this->resize.step_width, rtl);

		ir = ir.Shrink(WidgetDimensions::scaled.framerect, RectPadding::zero);

		/* Draw vertical separators at whole tiles.

		 * This only works in two cases:

		 *  - All vehicles use VEHICLEINFO_FULL_VEHICLE_WIDTH as reference width.

		 *  - All vehicles are 8/8. This cannot be checked for NewGRF, so instead we check for "all vehicles are original vehicles".

		 */

		if (this->type == VEH_TRAIN && _consistent_train_width != 0) {

			int w = ScaleSpriteTrad(2 * _consistent_train_width);

			Rect image = ir.Indent(this->header_width, rtl).Indent(this->count_width, !rtl);

			int first_line = w + (-this->hscroll->GetPosition()) % w;

			if (rtl) {

				for (int x = image.right - first_line; x >= image.left; x -= w) {

					GfxDrawLine(x, r.top, x, r.bottom, col, ScaleGUITrad(1), ScaleGUITrad(3));

				}

			} else {

				for (int x = image.left + first_line; x <= image.right; x += w) {

					GfxDrawLine(x, r.top, x, r.bottom, col, ScaleGUITrad(1), ScaleGUITrad(3));

				}

			}

		}

			return;

		}

		this->excluded_data = excluded_companies;

		this->num_on_x_axis = nums;

		this->year = yr;

		this->month = mo;

		int numd = 0;

		for (CompanyID k = COMPANY_FIRST; k < MAX_COMPANIES; k++) {

			const Company *c = Company::GetIfValid(k);

			if (c != nullptr) {

				for (int j = this->num_on_x_axis, i = 0; --j >= 0;) {

					if (j >= c->num_valid_stat_ent) {

						this->cost[numd][i] = INVALID_DATAPOINT;

					} else {

						/* Ensure we never assign INVALID_DATAPOINT, as that has another meaning.

						 * Instead, use the value just under it. Hopefully nobody will notice. */

						this->cost[numd][i] = std::min(GetGraphData(c, j), INVALID_DATAPOINT - 1);

					}

					i++;

				}

			}

			numd++;

			if (this->IsWidgetDisabled(widget)) return;

			CompanyID cid = (CompanyID)(widget - WID_PRD_COMPANY_FIRST);

			Dimension sprite_size = GetSpriteSize(SPR_COMPANY_ICON);

			DrawCompanyIcon(cid, CenterBounds(r.left, r.right, sprite_size.width), CenterBounds(r.top, r.bottom, sprite_size.height));

			return;

		}

		if (!IsInsideMM(widget, WID_PRD_SCORE_FIRST, WID_PRD_SCORE_LAST + 1)) return;

		ScoreID score_type = (ScoreID)(widget - WID_PRD_SCORE_FIRST);

		/* The colours used to show how the progress is going */

		/* Draw all the score parts */

		int64_t val    = _score_part[company][score_type];

		int64_t needed = _score_info[score_type].needed;

		int   score  = _score_info[score_type].score;

		/* SCORE_TOTAL has its own rules ;) */

		if (score_type == SCORE_TOTAL) {

			for (ScoreID i = SCORE_BEGIN; i < SCORE_END; i++) score += _score_info[i].score;

			needed = SCORE_MAX;

		}

	 * @param y Top of the row.

	 * @param left Left of the row.

	 * @param right Right of the row.

	 * @param g_id Group to list.

	 * @param indent Indentation level.

	 * @param protection Whether autoreplace protection is set.

	 * @param has_children Whether the group has children and should have a fold / unfold button.

	 */

	void DrawGroupInfo(int y, int left, int right, GroupID g_id, int indent = 0, bool protection = false, bool has_children = false) const

	{

		/* Highlight the group if a vehicle is dragged over it */

		if (g_id == this->group_over) {

		}

		if (g_id == NEW_GROUP) return;

		/* draw the selected group in white, else we draw it in black */

		TextColour colour = g_id == this->vli.index ? TC_WHITE : TC_BLACK;

		const GroupStatistics &stats = GroupStatistics::Get(this->vli.company, g_id, this->vli.vtype);

		bool rtl = _current_text_dir == TD_RTL;

		/* draw fold / unfold button */

		int x = rtl ? right - WidgetDimensions::scaled.framerect.right - this->column_size[VGC_FOLD].width + 1 : left + WidgetDimensions::scaled.framerect.left;

		if (has_children) {

			case WID_GL_SORT_BY_ORDER:

				this->DrawSortButtonState(WID_GL_SORT_BY_ORDER, this->vehgroups.IsDescSortOrder() ? SBS_DOWN : SBS_UP);

				break;

			case WID_GL_LIST_VEHICLE:

				if (this->vli.index != ALL_GROUP && this->grouping == GB_NONE) {

					/* Mark vehicles which are in sub-groups (only if we are not using shared order coalescing) */

					Rect mr = r.WithHeight(this->resize.step_height);

					size_t max = std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->vehgroups.size());

					for (size_t i = this->vscroll->GetPosition(); i < max; ++i) {

						const Vehicle *v = this->vehgroups[i].GetSingleVehicle();

						if (v->group_id != this->vli.index) {

						}

						mr = mr.Translate(0, this->resize.step_height);

					}

				}

				this->DrawVehicleListItems(this->vehicle_sel, this->resize.step_height, r);

				break;

		}

	}

	static void DeleteGroupCallback(Window *win, bool confirmed)

	{

	/* Move line a bit 90° against its dominant direction to prevent it from

	 * being hidden below the grey line. */

	int side = _settings_game.vehicle.road_side ? 1 : -1;

	if (abs(pta.x - ptb.x) < abs(pta.y - ptb.y)) {

		int offset_x = (pta.y > ptb.y ? 1 : -1) * side * width;

		GfxDrawLine(pta.x + offset_x, pta.y, ptb.x + offset_x, ptb.y, colour, width, dash);

	} else {

		int offset_y = (pta.x < ptb.x ? 1 : -1) * side * width;

		GfxDrawLine(pta.x, pta.y + offset_y, ptb.x, ptb.y + offset_y, colour, width, dash);

	}

}

/**

 * Draw dots for stations into the smallmap. The dots' sizes are determined by the amount of

 * cargo produced there, their colours by the type of cargo produced.

 */

void LinkGraphOverlay::DrawStationDots(const DrawPixelInfo *dpi) const

{

	int width = ScaleGUITrad(this->scale);

	for (const auto &i : this->cached_stations) {

		const Station *st = Station::GetIfValid(i.first);

		if (st == nullptr) continue;

		Point pt = this->GetStationMiddle(st);

		if (!this->IsPointVisible(pt, dpi, 3 * width)) continue;

		uint r = width * 2 + width * 2 * std::min(200U, i.second) / 200;

		LinkGraphOverlay::DrawVertex(pt.x, pt.y, r,

				GetColourGradient(st->owner != OWNER_NONE ?

	}

}

/**

 * Draw a square symbolizing a producer of cargo.

 * @param x X coordinate of the middle of the vertex.

 * @param y Y coordinate of the middle of the vertex.

 * @param size x and y extent of the vertex.

 * @param colour Colour with which the vertex will be filled.

 * @param border_colour Colour for the border of the vertex.

 */

/* static */ void LinkGraphOverlay::DrawVertex(int x, int y, int size, int colour, int border_colour)

	assert((wi->type & WWT_MASK) == WWT_EDITBOX);

	bool rtl = _current_text_dir == TD_RTL;

	Dimension sprite_size = GetScaledSpriteSize(rtl ? SPR_IMG_DELETE_RIGHT : SPR_IMG_DELETE_LEFT);

	int clearbtn_width = sprite_size.width + WidgetDimensions::scaled.imgbtn.Horizontal();

	Rect r = wi->GetCurrentRect();

	Rect cr = r.WithWidth(clearbtn_width, !rtl);

	Rect fr = r.Indent(clearbtn_width, !rtl);

	DrawFrameRect(cr, wi->colour, wi->IsLowered() ? FR_LOWERED : FR_NONE);

	DrawSpriteIgnorePadding(rtl ? SPR_IMG_DELETE_RIGHT : SPR_IMG_DELETE_LEFT, PAL_NONE, cr, SA_CENTER);

	DrawFrameRect(fr, wi->colour, FR_LOWERED | FR_DARKENED);

	GfxFillRect(fr.Shrink(WidgetDimensions::scaled.bevel), PC_BLACK);

	fr = fr.Shrink(WidgetDimensions::scaled.framerect);

	/* Limit the drawing of the string inside the widget boundaries */

	DrawPixelInfo dpi;

	if (!FillDrawPixelInfo(&dpi, fr)) return;

	AutoRestoreBackup dpi_backup(_cur_dpi, &dpi);

	/* We will take the current widget length as maximum width, with a small

		for (auto &button : buttons) {

			bool rtl = _current_text_dir == TD_RTL;

			int offset = (this->line_height - button->height) / 2;

			r.left = rtl ? x : x - button->width + 1;

			r.right = rtl ? x + button->width - 1 : x;

			r.top = y + offset;

			r.bottom = r.top + button->height - 1;

			DrawFrameRect(r, button->colour, FR_NONE);

			DrawSprite(button->sprite, PAL_NONE, r.left + WidgetDimensions::scaled.framerect.left, r.top + WidgetDimensions::scaled.framerect.top);

			if (button->disabled) {

			}

			int width = button->width + WidgetDimensions::scaled.hsep_normal;

			x += rtl ? width : -width;

		}

	}

	/**

	 * Draw a company and its clients on the matrix.

	 * @param company_id The company to draw.

	 * @param r The rect to draw within.

	 * @param line The Nth line we are drawing. Updated during this function.

		const Order *order = this->vehicle->GetOrder(i);

		/* First draw the highlighting underground if it exists. */

		if (this->order_over != INVALID_VEH_ORDER_ID) {

			while (order != nullptr) {

				/* Don't draw anything if it extends past the end of the window. */

				if (!this->vscroll->IsVisible(i)) break;

				if (i != this->selected_order && i == this->order_over) {

					/* Highlight dragged order destination. */

					int top = (this->order_over < this->selected_order ? y : y + line_height) - WidgetDimensions::scaled.framerect.top;

					int bottom = std::min(top + 2, ir.bottom);

					top = std::max(top - 3, ir.top);

					break;

				}

				y += line_height;

				i++;

				order = order->next;

			}

			/* Reset counters for drawing the orders. */

			y = ir.top;

			i = this->vscroll->GetPosition();

			order = this->vehicle->GetOrder(i);

 * @param colours The value to check

 * @return true if the given value is a valid Colours.

 */

inline bool IsValidColours(Colours colours)

{

	return colours < COLOUR_END;

}

TextColour GetContrastColour(uint8_t background, uint8_t threshold = 128);

enum ColourShade : uint8_t {

	SHADE_BEGIN = 0,

	SHADE_END,

};

DECLARE_POSTFIX_INCREMENT(ColourShade)

byte GetColourGradient(Colours colour, ColourShade shade);

void SetColourGradient(Colours colour, ColourShade shade, byte palette_colour);

/**

 * Return the colour for a particular greyscale level.

 * @param level Intensity, 0 = black, 15 = white

 * @return colour

 */

 */

uint BaseSettingEntry::Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row, uint parent_last) const

{

	if (this->IsFiltered()) return cur_row;

	if (cur_row >= max_row) return cur_row;

	bool rtl = _current_text_dir == TD_RTL;

	int offset = (rtl ? -(int)_circle_size.width : (int)_circle_size.width) / 2;

	int level_width = rtl ? -WidgetDimensions::scaled.hsep_indent : WidgetDimensions::scaled.hsep_indent;

	int x = rtl ? right : left;

	if (cur_row >= first_row) {

		y += (cur_row - first_row) * SETTING_HEIGHT; // Compute correct y start position

		/* Draw vertical for parent nesting levels */

		for (uint lvl = 0; lvl < this->level; lvl++) {

			if (!HasBit(parent_last, lvl)) GfxDrawLine(x + offset, y, x + offset, y + SETTING_HEIGHT - 1, colour);

			x += level_width;

		}

		/* draw own |- prefix */

		int halfway_y = y + SETTING_HEIGHT / 2;

		int bottom_y = (flags & SEF_LAST_FIELD) ? halfway_y : y + SETTING_HEIGHT - 1;

		GfxDrawLine(x + offset, y, x + offset, bottom_y, colour);

		/* Small horizontal line from the last vertical line */

/**

 * Draw [<][>] boxes.

 * @param x the x position to draw

 * @param y the y position to draw

 * @param button_colour the colour of the button

 * @param state 0 = none clicked, 1 = first clicked, 2 = second clicked

 * @param clickable_left is the left button clickable?

 * @param clickable_right is the right button clickable?

 */

void DrawArrowButtons(int x, int y, Colours button_colour, byte state, bool clickable_left, bool clickable_right)

{

	Dimension dim = NWidgetScrollbar::GetHorizontalDimension();

	Rect lr = {x,                  y, x + (int)dim.width     - 1, y + (int)dim.height - 1};

	Rect rr = {x + (int)dim.width, y, x + (int)dim.width * 2 - 1, y + (int)dim.height - 1};

	DrawFrameRect(lr, button_colour, (state == 1) ? FR_LOWERED : FR_NONE);

	DrawFrameRect(rr, button_colour, (state == 2) ? FR_LOWERED : FR_NONE);

	DrawSpriteIgnorePadding(SPR_ARROW_LEFT,  PAL_NONE, lr, SA_CENTER);

	DrawSpriteIgnorePadding(SPR_ARROW_RIGHT, PAL_NONE, rr, SA_CENTER);

	/* Grey out the buttons that aren't clickable */

	bool rtl = _current_text_dir == TD_RTL;

}

/**

 * Draw a dropdown button.

 * @param x the x position to draw

 * @param y the y position to draw

 * @param button_colour the colour of the button

 * @param state true = lowered

 * @param clickable is the button clickable?

 */

void DrawDropDownButton(int x, int y, Colours button_colour, bool state, bool clickable)

{

	Rect r = {x, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 1};

	DrawFrameRect(r, button_colour, state ? FR_LOWERED : FR_NONE);

	DrawSpriteIgnorePadding(SPR_ARROW_DOWN, PAL_NONE, r, SA_CENTER);

	if (!clickable) {

		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), colour, FILLRECT_CHECKER);

	}

}

/**

	_legend_land_contours[i].end = true;

}

/**

 * Completes the array for the owned property legend.

 */

void BuildOwnerLegend()

{

	_legend_land_owners[1].colour = _heightmap_schemes[_settings_client.gui.smallmap_land_colour].default_colour;

	int i = NUM_NO_COMPANY_ENTRIES;

	for (const Company *c : Company::Iterate()) {

		_legend_land_owners[i].company = c->index;

		_legend_land_owners[i].show_on_map = true;

		_legend_land_owners[i].col_break = false;

		_legend_land_owners[i].end = false;

		_company_to_list_pos[c->index] = i;

		i++;

	}

	/* Terminate the list */

	_legend_land_owners[i].end = true;

	/* Store maximum amount of owner legend entries. */

		dragged_width += t->GetDisplayImageWidth(nullptr);

	}

	int drag_hlight_left = rtl ? std::max(px - dragged_width + 1, 0) : px;

	int drag_hlight_right = rtl ? px : std::min(px + dragged_width, max_width) - 1;

	int drag_hlight_width = std::max(drag_hlight_right - drag_hlight_left + 1, 0);

	if (drag_hlight_width > 0) {

		int height = ScaleSpriteTrad(12);

		int top = y - height / 2;

		Rect r = {drag_hlight_left, top, drag_hlight_right, top + height - 1};

		/* Sprite-scaling is used here as the area is from sprite size */

	}

	return drag_hlight_width;

}

/**

 * Draws an image of a whole train

 * @param v         Front vehicle

 * @param r         Rect to draw at

 * @param selection Selected vehicle to draw a frame around

 * @param skip      Number of pixels to skip at the front (for scrolling)

 * @param drag_dest The vehicle another one is dragged over, \c INVALID_VEHICLE if none.

			if (separate_sprite_row) {

				vscroll_pos--;

				dx = 0;

			}

			int sprite_width = std::max<int>(dx, ScaleSpriteTrad(TRAIN_DETAILS_MIN_INDENT)) + WidgetDimensions::scaled.hsep_normal;

			Rect dr = r.Indent(sprite_width, rtl);

			uint num_lines = std::max(1u, (unsigned)_cargo_summary.size());

			for (uint i = 0; i < num_lines; i++) {

				if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {

					int py = r.top - line_height * vscroll_pos + text_y_offset;

					if (i > 0 || separate_sprite_row) {

					}

					switch (det_tab) {

						case TDW_TAB_CARGO:

							if (i < _cargo_summary.size()) {

								TrainDetailsCargoTab(&_cargo_summary[i], dr.left, dr.right, py);

							} else {

								DrawString(dr.left, dr.right, py, STR_QUANTITY_N_A, TC_LIGHT_BLUE);

							}

							break;

						case TDW_TAB_INFO:

							if (i == 0) TrainDetailsInfoTab(v, dr.left, dr.right, py);

 * @param rows  Number of rows(capacity) in caller window

 * @param delta Step height in caller window

 * @param r     Rectangle of the matrix widget.

 */

static void DrawVehicleRefitWindow(const RefitOptions &refits, const RefitOption *sel, uint pos, uint rows, uint delta, const Rect &r)

{

	Rect ir = r.Shrink(WidgetDimensions::scaled.matrix);

	uint current = 0;

	bool rtl = _current_text_dir == TD_RTL;

	uint iconwidth = std::max(GetSpriteSize(SPR_CIRCLE_FOLDED).width, GetSpriteSize(SPR_CIRCLE_UNFOLDED).width);

	uint iconheight = GetSpriteSize(SPR_CIRCLE_FOLDED).height;

	int iconleft   = rtl ? ir.right - iconwidth     : ir.left;

	int iconcenter = rtl ? ir.right - iconwidth / 2 : ir.left + iconwidth / 2;

	int iconinner  = rtl ? ir.right - iconwidth     : ir.left + iconwidth;

	Rect tr = ir.Indent(iconwidth + WidgetDimensions::scaled.hsep_wide, rtl);

	/* Draw the list of subtypes for each cargo, and find the selected refit option (by its position). */

	for (const auto &pair : refits) {

		bool has_subtypes = pair.second.size() > 1;

		for (const RefitOption &refit : pair.second) {

			if (current >= pos + rows) break;

		TextColour colour = TC_BLACK;

		bool small = HasBit(ss.width, 15);

		int w = GB(ss.width, 0, 15);

		int x = UnScaleByZoom(ss.x, zoom);

		int y = UnScaleByZoom(ss.y, zoom);

		int h = WidgetDimensions::scaled.fullbevel.top + (small ? GetCharacterHeight(FS_SMALL) : GetCharacterHeight(FS_NORMAL)) + WidgetDimensions::scaled.fullbevel.bottom;

		if (ss.colour != INVALID_COLOUR) {

			if (IsTransparencySet(TO_SIGNS) && ss.string_id != STR_WHITE_SIGN) {

				/* Don't draw the rectangle.

				 * Real colours need the TC_IS_PALETTE_COLOUR flag.

				 * Otherwise colours from _string_colourmap are assumed. */

			} else {

				/* Draw the rectangle if 'transparent station signs' is off,

				 * or if we are drawing a general text sign (STR_WHITE_SIGN). */

				DrawFrameRect(

					x, y, x + w - 1, y + h - 1, ss.colour,

					IsTransparencySet(TO_SIGNS) ? FR_TRANSPARENT : FR_NONE

				);

			}

		}

		DrawString(x + WidgetDimensions::scaled.fullbevel.left, x + w - 1 - WidgetDimensions::scaled.fullbevel.right, y + WidgetDimensions::scaled.fullbevel.top, ss.string, colour, SA_HOR_CENTER, false, small ? FS_SMALL : FS_NORMAL);

	}

 * Draw frame rectangle.

 * @param left   Left edge of the frame

 * @param top    Top edge of the frame

 * @param right  Right edge of the frame

 * @param bottom Bottom edge of the frame

 * @param colour Colour table to use. @see Colours

 * @param flags  Flags controlling how to draw the frame. @see FrameFlags

 */

void DrawFrameRect(int left, int top, int right, int bottom, Colours colour, FrameFlags flags)

{

	assert(colour < COLOUR_END);

	if (flags & FR_TRANSPARENT) {

		GfxFillRect(left, top, right, bottom, PALETTE_TO_TRANSPARENT, FILLRECT_RECOLOUR);

	} else {

		uint interior;

		Rect outer = {left, top, right, bottom};                   // Outside rectangle

		Rect inner = outer.Shrink(WidgetDimensions::scaled.bevel); // Inside rectangle

		if (flags & FR_LOWERED) {

			GfxFillRect(outer.left,      outer.top,        inner.left - 1,  outer.bottom, dark);   // Left

			GfxFillRect(inner.left,      outer.top,        outer.right,     inner.top - 1, dark);  // Top

		column_width = r.Width() / num_columns;

	}

	int num_rows = GB(data, MAT_ROW_START, MAT_ROW_BITS); // Upper 8 bits of the widget data: Number of rows in the matrix.

	int row_height; // Height of a single row in the matrix.

	if (num_rows == 0) {

		row_height = resize_y;

		num_rows = r.Height() / row_height;

	} else {

		row_height = r.Height() / num_rows;

	}

	int x = r.left;

	for (int ctr = num_columns; ctr > 1; ctr--) {

		x += column_width;

		GfxFillRect(x, r.top + WidgetDimensions::scaled.bevel.top, x + WidgetDimensions::scaled.bevel.left - 1, r.bottom - WidgetDimensions::scaled.bevel.bottom, col);

	}

	x = r.top;

	for (int ctr = num_rows; ctr > 1; ctr--) {

		x += row_height;

		GfxFillRect(r.left + WidgetDimensions::scaled.bevel.left, x, r.right - WidgetDimensions::scaled.bevel.right, x + WidgetDimensions::scaled.bevel.top - 1, col);

	}

	x = r.left - 1;

	for (int ctr = num_columns; ctr > 1; ctr--) {

		x += column_width;

		GfxFillRect(x - WidgetDimensions::scaled.bevel.right + 1, r.top + WidgetDimensions::scaled.bevel.top, x, r.bottom - WidgetDimensions::scaled.bevel.bottom, col);

	}

	x = r.top - 1;

	for (int ctr = num_rows; ctr > 1; ctr--) {

		x += row_height;

		GfxFillRect(r.left + WidgetDimensions::scaled.bevel.left, x - WidgetDimensions::scaled.bevel.bottom + 1, r.right - WidgetDimensions::scaled.bevel.right, x, col);

	}

 * @param bar_dragged  Bar is dragged.

 * @param down_clicked Down-arrow is clicked.

 * @param scrollbar    Scrollbar size, offset, and capacity information.

 */

static inline void DrawVerticalScrollbar(const Rect &r, Colours colour, bool up_clicked, bool bar_dragged, bool down_clicked, const Scrollbar *scrollbar)

{

	int height = NWidgetScrollbar::GetVerticalDimension().height;

	/* draw up/down buttons */

	DrawImageButtons(r.WithHeight(height, false),  NWID_VSCROLLBAR, colour, up_clicked,   SPR_ARROW_UP,   SA_CENTER);

	DrawImageButtons(r.WithHeight(height, true),   NWID_VSCROLLBAR, colour, down_clicked, SPR_ARROW_DOWN, SA_CENTER);

	/* draw "shaded" background */

	GfxFillRect(r.left, r.top + height, r.right, r.bottom - height, c2);

	GfxFillRect(r.left, r.top + height, r.right, r.bottom - height, c1, FILLRECT_CHECKER);

	/* track positions. These fractions are based on original 1x dimensions, but scale better. */

	int left  = r.left + r.Width() * 3 / 11; /*  left track is positioned 3/11ths from the left */

	int right = r.left + r.Width() * 8 / 11; /* right track is positioned 8/11ths from the left */

	const uint8_t bl = WidgetDimensions::scaled.bevel.left;

	const uint8_t br = WidgetDimensions::scaled.bevel.right;