enum CargoSuffixInOut {

	CARGOSUFFIX_OUT = 0,

	CARGOSUFFIX_IN  = 1,

};

/**

 * Gets all strings to display after the cargoes of industries (using callback 37)

 * @param use_input get suffixes for output cargoes or input cargoes?

 * @param cst the cargo suffix type (for which window is it requested). @see CargoSuffixType

 * @param ind the industry (nullptr if in fund window)

 * @param ind_type the industry type

 * @param indspec the industry spec

 * @param cargoes array with cargotypes. for CT_INVALID no suffix will be determined

 * @param suffixes is filled with the suffixes

 */

template <typename TC, typename TS>

static inline void GetAllCargoSuffixes(CargoSuffixInOut use_input, CargoSuffixType cst, const Industry *ind, IndustryType ind_type, const IndustrySpec *indspec, const TC &cargoes, TS &suffixes)

{

	static_assert(lengthof(cargoes) <= lengthof(suffixes));

	if (indspec->behaviour & INDUSTRYBEH_CARGOTYPES_UNLIMITED) {

		/* Reworked behaviour with new many-in-many-out scheme */

		for (uint j = 0; j < lengthof(suffixes); j++) {

				byte local_id = indspec->grf_prop.grffile->cargo_map[cargoes[j]]; // should we check the value for valid?

				uint cargotype = local_id << 16 | use_input;

				GetCargoSuffix(cargotype, cst, ind, ind_type, indspec, suffixes[j]);

			} else {

				suffixes[j].text[0] = '\0';

				suffixes[j].display = CSD_CARGO;

			}

		}

	} else {

		/* Compatible behaviour with old 3-in-2-out scheme */

		for (uint j = 0; j < lengthof(suffixes); j++) {

			suffixes[j].text[0] = '\0';

			suffixes[j].display = CSD_CARGO;

		}

		switch (use_input) {

			case CARGOSUFFIX_OUT:

				break;

			case CARGOSUFFIX_IN:

				break;

			default:

				NOT_REACHED();

		}

	}

}

std::array<IndustryType, NUM_INDUSTRYTYPES> _sorted_industry_types; ///< Industry types sorted by name.

/** Sort industry types by their name. */

static bool IndustryTypeNameSorter(const IndustryType &a, const IndustryType &b)

{

	int r = StrNaturalCompare(GetString(GetIndustrySpec(a)->name), GetString(GetIndustrySpec(b)->name)); // Sort by name (natural sorting).

	/* If the names are equal, sort by industry type. */

	return (r != 0) ? r < 0 : (a < b);

}

/**

 * Initialize the list of sorted industry types.

 */

void SortIndustryTypes()

{

	/* Add each industry type to the list. */

	{

		this->SetWidgetDisabledState(WID_DPI_FUND_WIDGET, this->selected_type != INVALID_INDUSTRYTYPE && !this->enabled);

		this->SetWidgetDisabledState(WID_DPI_DISPLAY_WIDGET, this->selected_type == INVALID_INDUSTRYTYPE && this->enabled);

	}

	/**

	 * Build a string of cargo names with suffixes attached.

	 * This is distinct from the CARGO_LIST string formatting code in two ways:

	 *  - This cargo list uses the order defined by the industry, rather than alphabetic.

	 *  - NewGRF-supplied suffix strings can be attached to each cargo.

	 *

	 * @param cargolist    Array of CargoID to display

	 * @param cargo_suffix Array of suffixes to attach to each cargo

	 * @param cargolistlen Length of arrays

	 * @param prefixstr    String to use for the first item

	 * @return A formatted raw string

	 */

	std::string MakeCargoListString(const CargoID *cargolist, const CargoSuffix *cargo_suffix, int cargolistlen, StringID prefixstr) const

	{

		std::string cargostring;

		int numcargo = 0;

		int firstcargo = -1;

		for (int j = 0; j < cargolistlen; j++) {

			numcargo++;

			if (firstcargo < 0) {

				firstcargo = j;

				continue;

			}

			SetDParam(0, CargoSpec::Get(cargolist[j])->name);

			SetDParamStr(1, cargo_suffix[j].text);

			cargostring += GetString(STR_INDUSTRY_VIEW_CARGO_LIST_EXTENSION);

		}

		if (numcargo > 0) {

			SetDParam(0, CargoSpec::Get(cargolist[firstcargo])->name);

			SetDParamStr(1, cargo_suffix[firstcargo].text);

			cargostring = GetString(prefixstr) + cargostring;

		} else {

			SetDParam(0, STR_JUST_NOTHING);

			SetDParamStr(1, "");

			cargostring = GetString(prefixstr);

		}

		return cargostring;

	}

public:

	/**

	 * Draw the text in the #WID_IV_INFO panel.

	 * @param r Rectangle of the panel.

	 * @return Expected position of the bottom edge of the panel.

	 */

	int DrawInfo(const Rect &r)

	{

		bool rtl = _current_text_dir == TD_RTL;

		Industry *i = Industry::Get(this->window_number);

		const IndustrySpec *ind = GetIndustrySpec(i->type);

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

		bool first = true;

		bool has_accept = false;

		if (i->prod_level == PRODLEVEL_CLOSURE) {

			DrawString(ir, STR_INDUSTRY_VIEW_INDUSTRY_ANNOUNCED_CLOSURE);

			ir.top += FONT_HEIGHT_NORMAL + WidgetDimensions::scaled.vsep_wide;

		}

		CargoSuffix cargo_suffix[lengthof(i->accepts_cargo)];

		GetAllCargoSuffixes(CARGOSUFFIX_IN, CST_VIEW, i, i->type, ind, i->accepts_cargo, cargo_suffix);

		bool stockpiling = HasBit(ind->callback_mask, CBM_IND_PRODUCTION_CARGO_ARRIVAL) || HasBit(ind->callback_mask, CBM_IND_PRODUCTION_256_TICKS);

		for (byte j = 0; j < lengthof(i->accepts_cargo); j++) {

			has_accept = true;

			if (first) {

				DrawString(ir, STR_INDUSTRY_VIEW_REQUIRES);

				ir.top += FONT_HEIGHT_NORMAL;

				first = false;

			}

			SetDParam(0, CargoSpec::Get(i->accepts_cargo[j])->name);

			SetDParam(1, i->accepts_cargo[j]);

			SetDParam(2, i->incoming_cargo_waiting[j]);

			SetDParamStr(3, "");

			StringID str = STR_NULL;

			switch (cargo_suffix[j].display) {

				case CSD_CARGO_AMOUNT_TEXT:

					SetDParamStr(3, cargo_suffix[j].text);

					FALLTHROUGH;

				case CSD_CARGO_AMOUNT:

					str = stockpiling ? STR_INDUSTRY_VIEW_ACCEPT_CARGO_AMOUNT : STR_INDUSTRY_VIEW_ACCEPT_CARGO;

					break;

				case CSD_CARGO_TEXT:

					SetDParamStr(3, cargo_suffix[j].text);

					FALLTHROUGH;

				case CSD_CARGO:

					str = STR_INDUSTRY_VIEW_ACCEPT_CARGO;

					break;

				default:

					NOT_REACHED();

			}

			DrawString(ir.Indent(WidgetDimensions::scaled.hsep_indent, rtl), str);

			ir.top += FONT_HEIGHT_NORMAL;

		}

		GetAllCargoSuffixes(CARGOSUFFIX_OUT, CST_VIEW, i, i->type, ind, i->produced_cargo, cargo_suffix);

		int line_height = this->editable == EA_RATE ? this->cheat_line_height : FONT_HEIGHT_NORMAL;

		int text_y_offset = (line_height - FONT_HEIGHT_NORMAL) / 2;

		int button_y_offset = (line_height - SETTING_BUTTON_HEIGHT) / 2;

		first = true;

		for (byte j = 0; j < lengthof(i->produced_cargo); j++) {

			if (first) {

				if (has_accept) ir.top += WidgetDimensions::scaled.vsep_wide;

				DrawString(ir, STR_INDUSTRY_VIEW_PRODUCTION_LAST_MONTH_TITLE);

				ir.top += FONT_HEIGHT_NORMAL;

				if (this->editable == EA_RATE) this->production_offset_y = ir.top;

				first = false;

			}

			SetDParam(0, i->produced_cargo[j]);

			SetDParam(1, i->last_month_production[j]);

			SetDParamStr(2, cargo_suffix[j].text);

			SetDParam(3, ToPercent8(i->last_month_pct_transported[j]));

			DrawString(ir.Indent(WidgetDimensions::scaled.hsep_indent + (this->editable == EA_RATE ? SETTING_BUTTON_WIDTH + WidgetDimensions::scaled.hsep_normal : 0), rtl).Translate(0, text_y_offset), STR_INDUSTRY_VIEW_TRANSPORTED);

			/* Let's put out those buttons.. */

			if (this->editable == EA_RATE) {

				DrawArrowButtons(ir.Indent(WidgetDimensions::scaled.hsep_indent, rtl).WithWidth(SETTING_BUTTON_WIDTH, rtl).left, ir.top + button_y_offset, COLOUR_YELLOW, (this->clicked_line == IL_RATE1 + j) ? this->clicked_button : 0,

						i->production_rate[j] > 0, i->production_rate[j] < 255);

			}

			ir.top += line_height;

		}

		/* Display production multiplier if editable */

		if (this->editable == EA_MULTIPLIER) {

			line_height = this->cheat_line_height;

	void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override

	{

		if (widget == WID_IV_INFO) size->height = this->info_height;

	}

	void OnClick(Point pt, int widget, int click_count) override

	{

		switch (widget) {

			case WID_IV_INFO: {

				Industry *i = Industry::Get(this->window_number);

				InfoLine line = IL_NONE;

				switch (this->editable) {

					case EA_NONE: break;

					case EA_MULTIPLIER:

						if (IsInsideBS(pt.y, this->production_offset_y, this->cheat_line_height)) line = IL_MULTIPLIER;

						break;

					case EA_RATE:

						if (pt.y >= this->production_offset_y) {

							int row = (pt.y - this->production_offset_y) / this->cheat_line_height;

							for (uint j = 0; j < lengthof(i->produced_cargo); j++) {

								row--;

								if (row < 0) {

									line = (InfoLine)(IL_RATE1 + j);

									break;

								}

							}

						}

						break;

				}

				if (line == IL_NONE) return;

				bool rtl = _current_text_dir == TD_RTL;

				Rect r = this->GetWidget<NWidgetBase>(widget)->GetCurrentRect().Shrink(WidgetDimensions::scaled.framerect).Indent(WidgetDimensions::scaled.hsep_indent, rtl);

				if (r.WithWidth(SETTING_BUTTON_WIDTH, rtl).Contains(pt)) {

					/* Clicked buttons, decrease or increase production */

					bool decrease = r.WithWidth(SETTING_BUTTON_WIDTH / 2, rtl).Contains(pt);

					switch (this->editable) {

						case EA_MULTIPLIER:

							if (decrease) {

								if (i->prod_level <= PRODLEVEL_MINIMUM) return;

								i->prod_level = static_cast<byte>(std::max<uint>(i->prod_level / 2, PRODLEVEL_MINIMUM));

							} else {

								if (i->prod_level >= PRODLEVEL_MAXIMUM) return;

			const IndustrySpec *ind = GetIndustrySpec(i->type);

			this->editable = ind->UsesOriginalEconomy() ? EA_MULTIPLIER : EA_RATE;

		} else {

			this->editable = EA_NONE;

		}

	}

	bool IsNewGRFInspectable() const override

	{

		return ::IsNewGRFInspectable(GSF_INDUSTRIES, this->window_number);

	}

	void ShowNewGRFInspectWindow() const override

	{

		::ShowNewGRFInspectWindow(GSF_INDUSTRIES, this->window_number);

	}

};

static void UpdateIndustryProduction(Industry *i)

{

	const IndustrySpec *indspec = GetIndustrySpec(i->type);

	if (indspec->UsesOriginalEconomy()) i->RecomputeProductionMultipliers();

	for (byte j = 0; j < lengthof(i->produced_cargo); j++) {

			i->last_month_production[j] = 8 * i->production_rate[j];

		}

	}

}

/** Widget definition of the view industry gui */

static const NWidgetPart _nested_industry_view_widgets[] = {

	NWidget(NWID_HORIZONTAL),

		NWidget(WWT_CLOSEBOX, COLOUR_CREAM),

		NWidget(WWT_CAPTION, COLOUR_CREAM, WID_IV_CAPTION), SetDataTip(STR_INDUSTRY_VIEW_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),

		NWidget(WWT_PUSHIMGBTN, COLOUR_CREAM, WID_IV_GOTO), SetMinimalSize(12, 14), SetDataTip(SPR_GOTO_LOCATION, STR_INDUSTRY_VIEW_LOCATION_TOOLTIP),

		NWidget(WWT_DEBUGBOX, COLOUR_CREAM),

		NWidget(WWT_SHADEBOX, COLOUR_CREAM),

		NWidget(WWT_DEFSIZEBOX, COLOUR_CREAM),

		NWidget(WWT_STICKYBOX, COLOUR_CREAM),

	EndContainer(),

	NWidget(WWT_PANEL, COLOUR_CREAM),

		NWidget(WWT_INSET, COLOUR_CREAM), SetPadding(2, 2, 2, 2),

			NWidget(NWID_VIEWPORT, INVALID_COLOUR, WID_IV_VIEWPORT), SetMinimalSize(254, 86), SetFill(1, 0), SetResize(1, 1),

		EndContainer(),

	EndContainer(),

	NWidget(WWT_PANEL, COLOUR_CREAM, WID_IV_INFO), SetMinimalSize(260, 0), SetMinimalTextLines(2, WidgetDimensions::unscaled.framerect.Vertical()), SetResize(1, 0),

	EndContainer(),

	NWidget(NWID_HORIZONTAL),

	CF_NONE = CT_INVALID,  ///< Show only industries which do not produce/accept cargo

};

/** Cargo filter functions */

/**

 * Check whether an industry accepts and produces a certain cargo pair.

 * @param industry The industry whose cargoes will being checked.

 * @param cargoes The accepted and produced cargo pair to look for.

 * @return bool Whether the given cargoes accepted and produced by the industry.

 */

static bool CDECL CargoFilter(const Industry * const *industry, const std::pair<CargoID, CargoID> &cargoes)

{

	auto accepted_cargo = cargoes.first;

	auto produced_cargo = cargoes.second;

	bool accepted_cargo_matches;

	switch (accepted_cargo) {

		case CF_ANY:

			accepted_cargo_matches = true;

			break;

		case CF_NONE:

			accepted_cargo_matches = std::all_of(std::begin((*industry)->accepts_cargo), std::end((*industry)->accepts_cargo), [](CargoID cargo) {

			});

			break;

		default:

			const auto &ac = (*industry)->accepts_cargo;

			accepted_cargo_matches = std::find(std::begin(ac), std::end(ac), accepted_cargo) != std::end(ac);

			break;

	}

	bool produced_cargo_matches;

	switch (produced_cargo) {

		case CF_ANY:

			produced_cargo_matches = true;

			break;

		case CF_NONE:

			produced_cargo_matches = std::all_of(std::begin((*industry)->produced_cargo), std::end((*industry)->produced_cargo), [](CargoID cargo) {

			});

			break;

		default:

			const auto &pc = (*industry)->produced_cargo;

			produced_cargo_matches = std::find(std::begin(pc), std::end(pc), produced_cargo) != std::end(pc);

			break;

	}

	return accepted_cargo_matches && produced_cargo_matches;

}

static GUIIndustryList::FilterFunction * const _filter_funcs[] = { &CargoFilter };

/**

 * The list of industries.

 */

class IndustryDirectoryWindow : public Window {

protected:

	/* Runtime saved values */

	static Listing last_sorting;

	/* Constants for sorting industries */

		auto filter = std::make_pair(this->cargo_filter[this->accepted_cargo_filter_criteria],

		                             this->cargo_filter[this->produced_cargo_filter_criteria]);

		this->industries.Filter(filter);

		IndustryDirectoryWindow::produced_cargo_filter = this->cargo_filter[this->produced_cargo_filter_criteria];

		this->industries.Sort();

		this->vscroll->SetCount(this->industries.size()); // Update scrollbar as well.

		this->SetDirty();

	}

	/**

	 * Returns percents of cargo transported if industry produces this cargo, else -1

	 *

	 * @param i industry to check

	 * @param id cargo slot

	 * @return percents of cargo transported, or -1 if industry doesn't use this cargo slot

	 */

	static inline int GetCargoTransportedPercentsIfValid(const Industry *i, uint id)

	{

		assert(id < lengthof(i->produced_cargo));

		return ToPercent8(i->last_month_pct_transported[id]);

	}

	/**

	 * Returns value representing industry's transported cargo

	 *  percentage for industry sorting

	 *

	 * @param i industry to check

	 * @return value used for sorting

	 */

	static int GetCargoTransportedSortValue(const Industry *i)

	{

		CargoID filter = IndustryDirectoryWindow::produced_cargo_filter;

		if (filter == CF_NONE) return 0;

		int percentage = 0, produced_cargo_count = 0;

		for (uint id = 0; id < lengthof(i->produced_cargo); id++) {

			if (filter == CF_ANY) {

				int transported = GetCargoTransportedPercentsIfValid(i, id);

				if (transported != -1) {

					produced_cargo_count++;

					percentage += transported;

				}

				if (produced_cargo_count == 0 && id == lengthof(i->produced_cargo) - 1 && percentage == 0) {

		if (r == 0) return a->index < b->index;

		return r < 0;

	}

	/** Sort industries by type and name */

	static bool IndustryTypeSorter(const Industry * const &a, const Industry * const &b)

	{

		int it_a = 0;

		while (it_a != NUM_INDUSTRYTYPES && a->type != _sorted_industry_types[it_a]) it_a++;

		int it_b = 0;

		while (it_b != NUM_INDUSTRYTYPES && b->type != _sorted_industry_types[it_b]) it_b++;

		int r = it_a - it_b;

		return (r == 0) ? IndustryNameSorter(a, b) : r < 0;

	}

	/** Sort industries by production and name */

	static bool IndustryProductionSorter(const Industry * const &a, const Industry * const &b)

	{

		CargoID filter = IndustryDirectoryWindow::produced_cargo_filter;

		if (filter == CF_NONE) return IndustryTypeSorter(a, b);

		uint prod_a = 0, prod_b = 0;

		for (uint i = 0; i < lengthof(a->produced_cargo); i++) {

			if (filter == CF_ANY) {

			} else {

				if (a->produced_cargo[i] == filter) prod_a += a->last_month_production[i];

				if (b->produced_cargo[i] == filter) prod_b += b->last_month_production[i];

			}

		}

		int r = prod_a - prod_b;

		return (r == 0) ? IndustryTypeSorter(a, b) : r < 0;

	}

	/** Sort industries by transported cargo and name */

	static bool IndustryTransportedCargoSorter(const Industry * const &a, const Industry * const &b)

	{

		int r = GetCargoTransportedSortValue(a) - GetCargoTransportedSortValue(b);

		return (r == 0) ? IndustryNameSorter(a, b) : r < 0;

	}

	/**

	 * Get the StringID to draw and set the appropriate DParams.

	 * @param i the industry to get the StringID of.

	 * @return the StringID.

	 */

	StringID GetIndustryString(const Industry *i) const

	{

		const IndustrySpec *indsp = GetIndustrySpec(i->type);

		byte p = 0;

		/* Industry name */

		SetDParam(p++, i->index);

		static CargoSuffix cargo_suffix[lengthof(i->produced_cargo)];

		GetAllCargoSuffixes(CARGOSUFFIX_OUT, CST_DIR, i, i->type, indsp, i->produced_cargo, cargo_suffix);

		/* Get industry productions (CargoID, production, suffix, transported) */

		struct CargoInfo {

			CargoID cargo_id;

			uint16 production;

			const char *suffix;

			uint transported;

		};

		std::vector<CargoInfo> cargos;

		for (byte j = 0; j < lengthof(i->produced_cargo); j++) {

			cargos.push_back({ i->produced_cargo[j], i->last_month_production[j], cargo_suffix[j].text.c_str(), ToPercent8(i->last_month_pct_transported[j]) });

		}

		switch (static_cast<IndustryDirectoryWindow::SorterType>(this->industries.SortType())) {

			case IndustryDirectoryWindow::SorterType::ByName:

			case IndustryDirectoryWindow::SorterType::ByType:

			case IndustryDirectoryWindow::SorterType::ByProduction:

				/* Sort by descending production, then descending transported */

				std::sort(cargos.begin(), cargos.end(), [](const CargoInfo &a, const CargoInfo &b) {

					if (a.production != b.production) return a.production > b.production;

					return a.transported > b.transported;

				});

				break;

			case IndustryDirectoryWindow::SorterType::ByTransported:

				/* Sort by descending transported, then descending production */

				std::sort(cargos.begin(), cargos.end(), [](const CargoInfo &a, const CargoInfo &b) {

					if (a.transported != b.transported) return a.transported > b.transported;

					return a.production > b.production;

				});

				break;

		}

		/* If the produced cargo filter is active then move the filtered cargo to the beginning of the list,

	}

	/**

	 * Make an industry type field.

	 * @param ind_type Industry type (#NUM_INDUSTRYTYPES means 'houses').

	 * @note #other_accepted and #other_produced should be filled later.

	 */

	void MakeIndustry(IndustryType ind_type)

	{

		this->type = CFT_INDUSTRY;

		this->u.industry.ind_type = ind_type;

		MemSetT(this->u.industry.other_accepted, INVALID_CARGO, MAX_CARGOES);

		MemSetT(this->u.industry.other_produced, INVALID_CARGO, MAX_CARGOES);

	}

	/**

	 * Connect a cargo from an industry to the #CFT_CARGO column.

	 * @param cargo Cargo to connect.

	 * @param producer Cargo is produced (if \c false, cargo is assumed to be accepted).

	 * @return Horizontal connection index, or \c -1 if not accepted at all.

	 */

	int ConnectCargo(CargoID cargo, bool producer)

	{

		assert(this->type == CFT_CARGO);

		/* Find the vertical cargo column carrying the cargo. */

		int column = -1;

		for (int i = 0; i < this->u.cargo.num_cargoes; i++) {

			if (cargo == this->u.cargo.vertical_cargoes[i]) {

				column = i;

				break;

			}

		}

		if (column < 0) return -1;

		if (producer) {

			this->u.cargo.supp_cargoes[column]  = column;

		} else {

			this->u.cargo.cust_cargoes[column] = column;

		}

		return column;

	}

	/**

	 * Does this #CFT_CARGO field have a horizontal connection?

	 * @return \c true if a horizontal connection exists, \c false otherwise.

	 */

	bool HasConnection()

	{

		assert(this->type == CFT_CARGO);

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

		}

		return false;

	}

	/**

	 * Make a piece of cargo column.

	 * @param cargoes    Array of #CargoID (may contain #INVALID_CARGO).

	 * @param length     Number of cargoes in \a cargoes.

	 * @param count      Number of cargoes to display (should be at least the number of valid cargoes, or \c -1 to let the method compute it).

	 * @param top_end    This is the first cargo field of this column.

	 * @param bottom_end This is the last cargo field of this column.

	 * @note #supp_cargoes and #cust_cargoes should be filled in later.

	 */

	void MakeCargo(const CargoID *cargoes, uint length, int count = -1, bool top_end = false, bool bottom_end = false)

	{

		this->type = CFT_CARGO;

		uint i;

		uint num = 0;

		for (i = 0; i < MAX_CARGOES && i < length; i++) {

				this->u.cargo.vertical_cargoes[num] = cargoes[i];

				num++;

			}

		}

		this->u.cargo.num_cargoes = (count < 0) ? num : count;

		for (; num < MAX_CARGOES; num++) this->u.cargo.vertical_cargoes[num] = INVALID_CARGO;

		this->u.cargo.top_end = top_end;

		this->u.cargo.bottom_end = bottom_end;

		MemSetT(this->u.cargo.supp_cargoes, INVALID_CARGO, MAX_CARGOES);

		MemSetT(this->u.cargo.cust_cargoes, INVALID_CARGO, MAX_CARGOES);

	}

	/**

	 * Make a field displaying cargo type names.

	 * @param cargoes    Array of #CargoID (may contain #INVALID_CARGO).

	 * @param length     Number of cargoes in \a cargoes.

	 * @param left_align ALign texts to the left (else to the right).

	 */

	void MakeCargoLabel(const CargoID *cargoes, uint length, bool left_align)

	{

		this->type = CFT_CARGO_LABEL;

		uint i;

		for (i = 0; i < MAX_CARGOES && i < length; i++) this->u.cargo_label.cargoes[i] = cargoes[i];

		for (; i < MAX_CARGOES; i++) this->u.cargo_label.cargoes[i] = INVALID_CARGO;

					if (_current_text_dir == TD_RTL) {

						blob_right = xpos2 - blob_distance;

						blob_left  = blob_right - CargoesField::legend.width;

					} else {

						blob_left  = xpos + blob_distance;

						blob_right = blob_left + CargoesField::legend.width;

					}

					GfxFillRect(blob_left,     ypos2 - blob_distance - CargoesField::legend.height,     blob_right,     ypos2 - blob_distance,     PC_BLACK); // Border

					GfxFillRect(blob_left + 1, ypos2 - blob_distance - CargoesField::legend.height + 1, blob_right - 1, ypos2 - blob_distance - 1, indsp->map_colour);

				} else {

					DrawString(xpos, xpos2, ypos, STR_INDUSTRY_CARGOES_HOUSES, TC_FROMSTRING, SA_HOR_CENTER);

				}

				/* Draw the other_produced/other_accepted cargoes. */

				const CargoID *other_right, *other_left;

				if (_current_text_dir == TD_RTL) {

					other_right = this->u.industry.other_accepted;

					other_left  = this->u.industry.other_produced;

				} else {

					other_right = this->u.industry.other_produced;

					other_left  = this->u.industry.other_accepted;

				}

				ypos1 += CargoesField::cargo_border.height + (FONT_HEIGHT_NORMAL - CargoesField::cargo_line.height) / 2;

				for (uint i = 0; i < CargoesField::max_cargoes; i++) {

						const CargoSpec *csp = CargoSpec::Get(other_right[i]);

						int xp = xpos + industry_width + CargoesField::cargo_stub.width;

						DrawHorConnection(xpos + industry_width, xp - 1, ypos1, csp);

						GfxDrawLine(xp, ypos1, xp, ypos1 + CargoesField::cargo_line.height - 1, CARGO_LINE_COLOUR);

					}

						const CargoSpec *csp = CargoSpec::Get(other_left[i]);

						int xp = xpos - CargoesField::cargo_stub.width;

						DrawHorConnection(xp + 1, xpos - 1, ypos1, csp);

						GfxDrawLine(xp, ypos1, xp, ypos1 + CargoesField::cargo_line.height - 1, CARGO_LINE_COLOUR);

					}

					ypos1 += FONT_HEIGHT_NORMAL + CargoesField::cargo_space.height;

				}

				break;

			}

			case CFT_CARGO: {

				int cargo_base = this->GetCargoBase(xpos);

				int top = ypos + (this->u.cargo.top_end ? vert_inter_industry_space / 2 + 1 : 0);

				int bot = ypos - (this->u.cargo.bottom_end ? vert_inter_industry_space / 2 + 1 : 0) + normal_height - 1;

				int colpos = cargo_base;

				for (int i = 0; i < this->u.cargo.num_cargoes; i++) {

					if (this->u.cargo.top_end) GfxDrawLine(colpos, top - 1, colpos + CargoesField::cargo_line.width - 1, top - 1, CARGO_LINE_COLOUR);

					if (this->u.cargo.bottom_end) GfxDrawLine(colpos, bot + 1, colpos + CargoesField::cargo_line.width - 1, bot + 1, CARGO_LINE_COLOUR);

					GfxDrawLine(colpos, top, colpos, bot, CARGO_LINE_COLOUR);

					colpos++;

					const CargoSpec *csp = CargoSpec::Get(this->u.cargo.vertical_cargoes[i]);

					GfxFillRect(colpos, top, colpos + CargoesField::cargo_line.width - 2, bot, csp->legend_colour, FILLRECT_OPAQUE);