if (this->engines[0].NeedRebuild()) {

			/* We need to rebuild the left engines list */

			this->GenerateReplaceVehList(true);

			if (this->reset_sel_engine && this->sel_engine[0] == INVALID_ENGINE && this->engines[0].size() != 0) {

				this->sel_engine[0] = this->engines[0][0];

			}

				}

				/* Regenerate the list on the right. Note: This resets sel_engine[1] to INVALID_ENGINE, if it is no longer available. */

				this->GenerateReplaceVehList(false);

				if (this->reset_sel_engine && this->sel_engine[1] != INVALID_ENGINE) {

					int position = 0;

					for (EngineID &eid : this->engines[1]) {

			case WID_RV_RIGHT_MATRIX: {

				int side = (widget == WID_RV_LEFT_MATRIX) ? 0 : 1;

				EngineID start  = this->vscroll[side]->GetPosition(); // what is the offset for the start (scrolling)

				/* Do the actual drawing */

				DrawEngineList((VehicleType)this->window_number, r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP,

		this->bridges->NeedResort();

		this->SortBridgeList();

	}

	~BuildBridgeWindow()

	{

		switch (widget) {

			case WID_BV_LIST:

				break;

			case WID_BV_SORT_ASCENDING_DESCENDING:

	void OnPaint() override

	{

		this->GenerateBuildList();

		this->SetWidgetsDisabledState(this->sel_engine == INVALID_ENGINE, WID_BV_SHOW_HIDE, WID_BV_BUILD, WID_BV_RENAME, WIDGET_LIST_END);

				}

			}

		} else {

		}

		this->vscroll->SetCount(this->rows);

				}

			}

		} else {

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

				const Group *g = this->groups[i];

				SetDParam(0, g->index);

 * @return True if the value is in the interval, false else.

 */

template <typename T>

{

}

/**

 * @see IsInsideBS()

 */

template <typename T>

{

}

/**

 * @param desc Sort descending.

 */

template <typename T>

{

	if (num < 2) return;

 * @param desc Sort descending.

 */

template <typename T>

{

	if (num < 2) return;

		uint16 rows_in_display = wid->current_y / wid->resize_y;

		uint16 num = this->vscroll->GetPosition() * this->num_columns;

		int y;

		for (y = r.top + 1; num < maxval; y += this->resize.step_height) { // Draw the rows

			for (byte i = 0; i < this->num_columns && num < maxval; i++, num++) {

			}

		}

		/* Draw the train wagons without an engine in front. */

		for (; num < maxval; num++, y += this->resize.step_height) {

			/* Skip vehicles that are scrolled off the list */

			if (this->type == VEH_TRAIN) x += this->hscroll->GetPosition();

		} else {

			*veh = this->wagon_list[pos];

			/* free wagons don't have an initial loco. */

			x -= ScaleGUITrad(VEHICLEINFO_FULL_VEHICLE_WIDTH);

				max_width = max(max_width, width);

			}

			/* Always have 1 empty row, so people can change the setting of the train */

			/* Always make it longer than the longest train, so you can attach vehicles at the end, and also see the next vertical tile separator line */

			this->hscroll->SetCount(max_width + ScaleGUITrad(2 * VEHICLEINFO_FULL_VEHICLE_WIDTH + 1));

		} else {

		}

		/* Setup disabled buttons. */

 */

void EngList_Sort(GUIEngineList *el, EngList_SortTypeFunction compare)

{

	/* out-of-bounds access at the next line for size == 0 (even with operator[] at some systems)

	 * generally, do not sort if there are less than 2 items */

	if (size < 2) return;

	struct dirent *dirent;

	DIR *dir;

	FiosItem *fios;

	char d_name[sizeof(fios->name)];

	file_list.Clear();

	 * Get the number of files in the list.

	 * @return The number of files stored in the list.

	 */

	{

		return this->files.size();

	}

	 * Get a pointer to the indicated file information. File information must exist.

	 * @return Address of the indicated existing file information.

	 */

	{

		return this->files.data() + index;

	}

	 * Get a pointer to the indicated file information. File information must exist.

	 * @return Address of the indicated existing file information.

	 */

	{

		return this->files.data() + index;

	}

	{

		return this->files[index];

	}

	 * Get a reference to the indicated file information. File information must exist.

	 * @return The requested file information.

	 */

	{

		return this->files[index];

	}

 */

static void SortSaveGameList(FileList &file_list)

{

	/* Directories are always above the files (FIOS_TYPE_DIR)

	 * Drives (A:\ (windows only) are always under the files (FIOS_TYPE_DRIVE)

		}

	}

	QSortT(file_list.Get(sort_start), s_amount, CompareFiosItems);

}

				_fios_path_changed = true;

				this->fios_items.BuildFileList(this->abstract_filetype, this->fop);

				this->selected = NULL;

				_load_check_data.Clear();

	GetString(buffer, str, lastof(buffer));

	Layouter layout(buffer, maxw);

}

/**

 */

int FallbackParagraphLayout::FallbackLine::CountRuns() const

{

}

/**

		this->BuildGroupList(this->owner);

		/* The drop down menu is out, *but* it may not be used, retract it. */

		if (this->vehicles.size() == 0 && this->IsWidgetLowered(WID_GL_MANAGE_VEHICLES_DROPDOWN)) {

				Money this_year = 0;

				Money last_year = 0;

				uint32 occupancy = 0;

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

					const Vehicle *v = this->vehicles[i];

			case WID_GL_LIST_GROUP: {

				int y1 = r.top + WD_FRAMERECT_TOP;

				for (int i = this->group_sb->GetPosition(); i < max; ++i) {

					const Group *g = this->groups[i];

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

					/* Mark vehicles which are in sub-groups */

					int y = r.top;

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

						const Vehicle *v = this->vehicles[i];

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

			this->industries.shrink_to_fit();

			this->industries.RebuildDone();

		}

		if (!this->industries.Sort()) return;

	 * Get the current size of the component.

	 * @return Size.

	 */

	/**

	 * Get date of last compression.

	MidiFile current_file;           ///< file currently being played from

	PlaybackSegment current_segment; ///< segment info for current playback

	size_t current_block;            ///< next block index to send

	MidiFile next_file;              ///< upcoming file to play

	PlaybackSegment next_segment;    ///< segment info for upcoming file

		/* find first block after start time and pretend playback started earlier

		* this is to allow all blocks prior to the actual start to still affect playback,

		* as they may contain important controller and program changes */

		for (size_t bl = 0; bl < _midi.current_file.blocks.size(); bl++) {

			MidiFile::DataBlock &block = _midi.current_file.blocks[bl];

			preload_bytes += block.data.size();

	/* play pending blocks */

	DWORD current_time = timeGetTime();

	while (_midi.current_block < _midi.current_file.blocks.size()) {

		MidiFile::DataBlock &block = _midi.current_file.blocks[_midi.current_block];

			(sizeof(uint8) + sizeof(uint32) + (send_md5sum ? /*sizeof(ContentInfo::md5sum)*/16 : 0)));

	Packet *p = new Packet(send_md5sum ? PACKET_CONTENT_CLIENT_INFO_EXTID_MD5 : PACKET_CONTENT_CLIENT_INFO_EXTID);

	for (const ContentInfo *ci : *cv) {

		p->Send_uint8((byte)ci->type);

		bytes += ci->filesize;

	}

	/* If there's nothing to download, do nothing. */

	if (files == 0) return;

 */

void ClientNetworkContentSocketHandler::DownloadSelectedContentHTTP(const ContentIDList &content)

{

	/* Allocate memory for the whole request.

	 * Requests are "id\nid\n..." (as strings), so assume the maximum ID,

 */

void ClientNetworkContentSocketHandler::DownloadSelectedContentFallback(const ContentIDList &content)

{

	const ContentID *content_ids = content.data();

	this->Connect();

	void CheckDependencyState(ContentInfo *ci);

	/** Get the number of content items we know locally. */

	/** Get the begin of the content inf iterator. */

	ConstContentIterator Begin() const { return this->infos.data(); }

	/** Get the nth position of the content inf iterator. */

		this->content.RebuildDone();

		this->SortContentList();

		this->ScrollToSelected();

	}

			case WID_NCL_NAME:

				if (this->content.SortType() == widget - WID_NCL_CHECKBOX) {

					this->content.ToggleSortOrder();

				} else {

					this->content.SetSortType(widget - WID_NCL_CHECKBOX);

					this->content.ForceResort();

				break;

			case WKC_END:

				/* jump to end */

				break;

			case WKC_SPACE:

		this->servers.shrink_to_fit();

		this->servers.RebuildDone();

		/* Sort the list of network games as requested. */

		this->servers.Sort();

			case WID_NG_INFO:    // Connectivity (green dot)

				if (this->servers.SortType() == widget - WID_NG_NAME) {

					this->servers.ToggleSortOrder();

				} else {

					this->servers.SetSortType(widget - WID_NG_NAME);

					this->servers.ForceResort();

					break;

				case WKC_END:

					/* jump to end */

					break;

				default: NOT_REACHED();

			}

			d = maxdim(GetStringBoundingBox(action.name), d);

		}

		d.width += WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;

		d.height += WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;

		*size = d;

				/* Continue reading var adjusts while bit 5 is set. */

			} while (HasBit(varadjust, 5));

			group->adjusts = MallocT<DeterministicSpriteGroupAdjust>(group->num_adjusts);

			MemCpyT(group->adjusts, adjusts.data(), group->num_adjusts);

	static const uint32 override_features = (1 << GSF_TRAINS) | (1 << GSF_ROADVEHICLES) | (1 << GSF_SHIPS) | (1 << GSF_AIRCRAFT);

	/* Evaluate grf overrides */

	int *grf_overrides = AllocaM(int, num_grfs);

	for (int i = 0; i < num_grfs; i++) {

		grf_overrides[i] = -1;

				int step_size = nwid->resize_y;

				std::vector<SpriteID> &list = _newgrf_debug_sprite_picker.sprites;

				int y = r.top + WD_FRAMERECT_TOP;

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

		if (data == 1) {

			/* Sprite picker finished */

			this->RaiseWidget(WID_SA_PICKER);

		}

	}

				int offset_y = (step_height - FONT_HEIGHT_NORMAL) / 2;

				uint y = r.top + WD_FRAMERECT_TOP;

				uint min_index = this->vscroll2->GetPosition();

				for (uint i = min_index; i < max_index; i++) {

					const GRFConfig *c = this->avails[i];

			case WKC_END:

				/* jump to end */

				break;

			default:

			}

		}

	}

	/**

		this->vscroll = this->GetScrollbar(WID_SVP_SCROLLBAR);

		this->FinishInitNested(0);

		this->SetFocusedWidget(WID_SVP_EDITBOX);

		if (initial_text != NULL) this->presetname_editbox.text.Assign(initial_text);

	}

					size->width = max(size->width, d.width + WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT);

					resize->height = max(resize->height, d.height);

				}

				break;

			}

		}

				int offset_y = (step_height - FONT_HEIGHT_NORMAL) / 2;

				uint y = r.top + WD_FRAMERECT_TOP;

				uint min_index = this->vscroll->GetPosition();

				for (uint i = min_index; i < max_index; i++) {

					if ((int)i == this->selected) GfxFillRect(r.left + 1, y, r.right - 1, y + step_height - 2, PC_DARK_BLUE);

uint GetNumSounds()

{

}

	public:

		virtual int GetLeading() const;

		virtual int GetWidth() const;

		virtual const VisualRun *GetVisualRun(int run) const { return this->at(run);  }

		int GetInternalCharLength(WChar c) const

static void SaveReal_GSTR(LanguageStrings *ls)

{

	_game_saveload_string  = ls->language;

	SlObject(NULL, _game_language_header);

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

	/* Now perform the actual rotation. */

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

			existing->array[i] = RotateNeighbour(existing->array[i]);

		}

		start = RotateNeighbour(start);

	RoadBits start_roadbits    = NeighbourToRoadBits(start);

	RoadBits new_roadbits      = start_roadbits | NeighbourToRoadBits(end);

	RoadBits existing_roadbits = ROAD_NONE;

		existing_roadbits |= NeighbourToRoadBits(existing->array[i]);

	}

	/* The start tile and end tile cannot be the same tile either. */

	if (start == end) return -1;

		if (!NormaliseTileOffset(&existing->array[i])) return -1;

	}

/** Definition of a simple array. */

struct Array {

	int32 array[]; ///< The data of the array.

};

				}

				QSortT(list->data(), list->size(), DropDownListStringItem::NatSortFunc);

				/* Insert newgrf_names at the top of the list */

				if (newgrf_size > 0) {

					list->push_back(new DropDownListItem(-1, false)); // separator line

	{

		if (this->signs.NeedRebuild()) {

			this->BuildSignsList();

			this->SetWidgetDirty(WID_SIL_CAPTION);

		}

		this->SortSignsList();

		/* Search through the list for the current sign, excluding

		 * - the first sign if we want the previous sign or

		 * - the last sign if we want the next sign */

		for (uint i = next ? 0 : 1; i < end; i++) {

			if (this->cur_sign == this->signs[i]->index) {

				/* We've found the current sign, so return the sign before/after it */

		this->stations.shrink_to_fit();

		this->stations.RebuildDone();

	}

	/** Sort stations by their name */