target_link_libraries(WASM::WASM INTERFACE "--preload-file ${CMAKE_SOURCE_DIR}/docs/eints.md@/docs/eints.md")

    target_link_libraries(WASM::WASM INTERFACE "--preload-file ${CMAKE_SOURCE_DIR}/docs/symbol_server.md@/docs/symbol_server.md")

                ${CMAKE_SOURCE_DIR}/docs/eints.md

                ${CMAKE_SOURCE_DIR}/docs/symbol_server.md

    help_gui.cpp

    help_gui.h

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

 /** @file help_gui.cpp GUI to access manuals and related. */

#include "stdafx.h"

#include "gui.h"

#include "window_gui.h"

#include "textfile_gui.h"

#include "fileio_func.h"

#include "table/control_codes.h"

#include "string_func.h"

#include "openttd.h"

#include "help_gui.h"

#include "widgets/help_widget.h"

#include "widgets/misc_widget.h"

#include "safeguards.h"

static const std::string README_FILENAME = "README.md";

static const std::string CHANGELOG_FILENAME = "changelog.txt";

static const std::string KNOWN_BUGS_FILENAME = "known-bugs.txt";

static const std::string LICENSE_FILENAME = "COPYING.md";

static const std::string WEBSITE_LINK = "https://www.openttd.org/";

static const std::string WIKI_LINK = "https://wiki.openttd.org/";

static const std::string BUGTRACKER_LINK = "https://bugs.openttd.org/";

static const std::string COMMUNITY_LINK = "https://community.openttd.org/";

/** Only show the first 20 changelog versions in the textfile viewer. */

static constexpr size_t CHANGELOG_VERSIONS_LIMIT = 20;

/**

 * Find the path to the game manual file.

 *

 * @param filename The filename to find.

 * @return std::string The path to the filename if found.

 */

static std::optional<std::string> FindGameManualFilePath(std::string_view filename)

{

	static const Searchpath searchpaths[] = {

		SP_APPLICATION_BUNDLE_DIR, SP_INSTALLATION_DIR, SP_SHARED_DIR, SP_BINARY_DIR, SP_WORKING_DIR

	};

	for (Searchpath sp : searchpaths) {

		auto file_path = FioGetDirectory(sp, BASE_DIR) + filename.data();

		if (FioCheckFileExists(file_path, NO_DIRECTORY)) return file_path;

	}

	return {};

}

/** Window class displaying the game manual textfile viewer. */

struct GameManualTextfileWindow : public TextfileWindow {

	GameManualTextfileWindow(std::string_view filename) : TextfileWindow(TFT_GAME_MANUAL)

	{

		/* Mark the content of these files as trusted. */

		this->trusted = true;

		auto filepath = FindGameManualFilePath(filename);

		/* The user could, in theory, have moved the file. So just show an empty window if that is the case. */

		if (!filepath.has_value()) {

			return;

		}

		this->filepath = filepath.value();

		this->LoadTextfile(this->filepath, NO_DIRECTORY);

		this->OnClick({ 0, 0 }, WID_TF_WRAPTEXT, 1);

	}

	void SetStringParameters(int widget) const override

	{

		if (widget == WID_TF_CAPTION) {

			SetDParamStr(0, this->filename);

		}

	}

	void AfterLoadText() override

	{

		if (this->filename == CHANGELOG_FILENAME) {

			this->link_anchors.clear();

			this->AfterLoadChangelog();

			this->GetWidget<NWidgetStacked>(WID_TF_SEL_JUMPLIST)->SetDisplayedPlane(this->jumplist.empty() ? SZSP_HORIZONTAL : 0);

		} else {

			this->TextfileWindow::AfterLoadText();

		}

	}

	/**

	 * For changelog files, add a jumplist entry for each version.

	 *

	 * This is hardcoded and assumes "---" are used to separate versions.

	 */

	void AfterLoadChangelog()

	{

		/* Look for lines beginning with ---, they indicate that the previous line was a release name. */

		for (size_t line_index = 0; line_index < this->lines.size(); ++line_index) {

			const Line &line = this->lines[line_index];

			if (line.text.find("---", 0) != 0) continue;

			if (this->jumplist.size() >= CHANGELOG_VERSIONS_LIMIT) {

				this->lines.resize(line_index - 2);

				break;

			}

			/* Mark the version header with a colour, and add it to the jumplist. */

			this->lines[line_index - 1].colour = TC_GOLD;

			this->lines[line_index].colour = TC_GOLD;

			this->jumplist.push_back(line_index - 1);

		}

	}

};

/** Window class displaying the help window. */

struct HelpWindow : public Window {

	HelpWindow(WindowDesc *desc, WindowNumber number) : Window(desc)

	{

		this->InitNested(number);

		this->EnableTextfileButton(README_FILENAME, WID_HW_README);

		this->EnableTextfileButton(CHANGELOG_FILENAME, WID_HW_CHANGELOG);

		this->EnableTextfileButton(KNOWN_BUGS_FILENAME, WID_HW_KNOWN_BUGS);

		this->EnableTextfileButton(LICENSE_FILENAME, WID_HW_LICENSE);

	}

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

	{

		switch (widget) {

			case WID_HW_README:

				new GameManualTextfileWindow(README_FILENAME);

				break;

			case WID_HW_CHANGELOG:

				new GameManualTextfileWindow(CHANGELOG_FILENAME);

				break;

			case WID_HW_KNOWN_BUGS:

				new GameManualTextfileWindow(KNOWN_BUGS_FILENAME);

				break;

			case WID_HW_LICENSE:

				new GameManualTextfileWindow(LICENSE_FILENAME);

				break;

			case WID_HW_WEBSITE:

				OpenBrowser(WEBSITE_LINK.c_str());

				break;

			case WID_HW_WIKI:

				OpenBrowser(WIKI_LINK.c_str());

				break;

			case WID_HW_BUGTRACKER:

				OpenBrowser(BUGTRACKER_LINK.c_str());

				break;

			case WID_HW_COMMUNITY:

				OpenBrowser(COMMUNITY_LINK.c_str());

				break;

		}

	}

private:

	void EnableTextfileButton(std::string_view filename, int button_widget)

	{

		this->GetWidget<NWidgetLeaf>(button_widget)->SetDisabled(!FindGameManualFilePath(filename).has_value());

	}

};

static const NWidgetPart _nested_helpwin_widgets[] = {

	NWidget(NWID_HORIZONTAL),

		NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),

		NWidget(WWT_CAPTION, COLOUR_DARK_GREEN), SetDataTip(STR_HELP_WINDOW_CAPTION, STR_NULL),

	EndContainer(),

	NWidget(WWT_PANEL, COLOUR_DARK_GREEN),

		NWidget(NWID_SPACER), SetMinimalSize(0, 8),

		NWidget(NWID_HORIZONTAL),

			NWidget(NWID_SPACER), SetMinimalSize(10, 0),

			NWidget(NWID_VERTICAL), SetPIP(0, 2, 0),

				NWidget(WWT_FRAME, COLOUR_DARK_GREEN), SetDataTip(STR_HELP_WINDOW_WEBSITES, STR_NULL),

					NWidget(WWT_PUSHTXTBTN, COLOUR_GREEN, WID_HW_WEBSITE), SetDataTip(STR_HELP_WINDOW_MAIN_WEBSITE, STR_NULL), SetMinimalSize(128, 12), SetFill(1, 0),

					NWidget(WWT_PUSHTXTBTN, COLOUR_GREEN, WID_HW_WIKI), SetDataTip(STR_HELP_WINDOW_MANUAL_WIKI, STR_NULL), SetMinimalSize(128, 12), SetFill(1, 0),

					NWidget(WWT_PUSHTXTBTN, COLOUR_GREEN, WID_HW_BUGTRACKER), SetDataTip(STR_HELP_WINDOW_BUGTRACKER, STR_NULL), SetMinimalSize(128, 12), SetFill(1, 0),

					NWidget(WWT_PUSHTXTBTN, COLOUR_GREEN, WID_HW_COMMUNITY), SetDataTip(STR_HELP_WINDOW_COMMUNITY, STR_NULL), SetMinimalSize(128, 12), SetFill(1, 0),

				EndContainer(),

			EndContainer(),

			NWidget(NWID_SPACER), SetMinimalSize(10, 0),

			NWidget(NWID_VERTICAL), SetPIP(0, 2, 0),

				NWidget(WWT_FRAME, COLOUR_DARK_GREEN), SetDataTip(STR_HELP_WINDOW_DOCUMENTS, STR_NULL),

					NWidget(WWT_PUSHTXTBTN, COLOUR_GREEN, WID_HW_README), SetDataTip(STR_HELP_WINDOW_README, STR_NULL), SetMinimalSize(128, 12), SetFill(1, 0),

					NWidget(WWT_PUSHTXTBTN, COLOUR_GREEN, WID_HW_CHANGELOG), SetDataTip(STR_HELP_WINDOW_CHANGELOG, STR_NULL), SetMinimalSize(128, 12), SetFill(1, 0),

					NWidget(WWT_PUSHTXTBTN, COLOUR_GREEN, WID_HW_KNOWN_BUGS),SetDataTip(STR_HELP_WINDOW_KNOWN_BUGS, STR_NULL), SetMinimalSize(128, 12), SetFill(1, 0),

					NWidget(WWT_PUSHTXTBTN, COLOUR_GREEN, WID_HW_LICENSE), SetDataTip(STR_HELP_WINDOW_LICENSE, STR_NULL), SetMinimalSize(128, 12), SetFill(1, 0),

				EndContainer(),

			EndContainer(),

			NWidget(NWID_SPACER), SetMinimalSize(10, 0),

		EndContainer(),

		NWidget(NWID_SPACER), SetMinimalSize(0, 8),

	EndContainer(),

};

static WindowDesc _helpwin_desc(

	WDP_CENTER, nullptr, 0, 0,

	WC_HELPWIN, WC_NONE,

	0,

	std::begin(_nested_helpwin_widgets), std::end(_nested_helpwin_widgets)

);

void ShowHelpWindow()

{

	AllocateWindowDescFront<HelpWindow>(&_helpwin_desc, 0);

}

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

 /** @file help_gui.h GUI to access manuals and related. */

#ifndef HELP_GUI_H

#define HELP_GUI_H

void ShowHelpWindow();

#endif /* HELP_GUI_H */

#include "help_gui.h"

			case WID_SGI_HELP:            ShowHelpWindow(); break;

	/* 'Help and Manuals' and 'Highscore Table' buttons */

	NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),

		NWidget(WWT_PUSHTXTBTN, COLOUR_ORANGE, WID_SGI_HELP), SetMinimalSize(158, 12),

							SetDataTip(STR_INTRO_HELP, STR_INTRO_TOOLTIP_HELP), SetPadding(0, 0, 0, 10), SetFill(1, 0),

		NWidget(WWT_PUSHTXTBTN, COLOUR_ORANGE, WID_SGI_HIGHSCORE), SetMinimalSize(158, 12),

							SetDataTip(STR_INTRO_HIGHSCORE, STR_INTRO_TOOLTIP_HIGHSCORE), SetPadding(0, 10, 0, 0), SetFill(1, 0),

###length 11

STR_ABOUT_MENU_HELP                                             :Help & manuals

STR_INTRO_HELP                                                  :{BLACK}Help & Manuals

STR_INTRO_TOOLTIP_HELP                                          :{BLACK}Get access to documentation and online resources

# Help window

STR_HELP_WINDOW_CAPTION                                         :{WHITE}Help & Manuals

STR_HELP_WINDOW_WEBSITES                                        :{BLACK}Websites

STR_HELP_WINDOW_DOCUMENTS                                       :{BLACK}Documents

STR_HELP_WINDOW_README                                          :{BLACK}Readme

STR_HELP_WINDOW_CHANGELOG                                       :{BLACK}Changelog

STR_HELP_WINDOW_KNOWN_BUGS                                      :{BLACK}Known Bugs

STR_HELP_WINDOW_LICENSE                                         :{BLACK}License

STR_HELP_WINDOW_MAIN_WEBSITE                                    :{BLACK}OpenTTD

STR_HELP_WINDOW_MANUAL_WIKI                                     :{BLACK}Manual / Wiki

STR_HELP_WINDOW_BUGTRACKER                                      :{BLACK}Report a Bug

STR_HELP_WINDOW_COMMUNITY                                       :{BLACK}Community

STR_TEXTFILE_JUMPLIST                                           :{WHITE}Table of Contents

STR_TEXTFILE_JUMPLIST_TOOLTIP                                   :{BLACK}Quickly jump to a section in the displayed file via this list

STR_TEXTFILE_JUMPLIST_ITEM                                      :{WHITE}{RAW_STRING}

STR_TEXTFILE_NAVBACK_TOOLTIP                                    :{BLACK}Go back in navigation history

STR_TEXTFILE_NAVFORWARD_TOOLTIP                                 :{BLACK}Return forward in navigation history

###length 5

STR_TEXTFILE_GAME_MANUAL_CAPTION                                :{WHITE}OpenTTD document '{RAW_STRING}'

#include "widgets/dropdown_type.h"

#include "gfx_layout.h"

#include "debug.h"

#include "openttd.h"

#include "table/control_codes.h"

#include <regex>

		NWidget(WWT_PUSHARROWBTN, COLOUR_MAUVE, WID_TF_NAVBACK), SetFill(0, 1), SetMinimalSize(15, 1), SetDataTip(AWV_DECREASE, STR_TEXTFILE_NAVBACK_TOOLTIP),

		NWidget(WWT_PUSHARROWBTN, COLOUR_MAUVE, WID_TF_NAVFORWARD), SetFill(0, 1), SetMinimalSize(15, 1), SetDataTip(AWV_INCREASE, STR_TEXTFILE_NAVFORWARD_TOOLTIP),

	NWidget(NWID_SELECTION, INVALID_COLOUR, WID_TF_SEL_JUMPLIST),

		NWidget(WWT_PANEL, COLOUR_MAUVE),

			NWidget(NWID_HORIZONTAL), SetPIP(WidgetDimensions::unscaled.frametext.left, 0, WidgetDimensions::unscaled.frametext.right),

				/* As this widget can be toggled, it needs to be a multiplier of FS_MONO. So add a spacer that ensures this. */

				NWidget(NWID_SPACER), SetMinimalSize(1, 0), SetMinimalTextLines(2, 0, FS_MONO),

				NWidget(NWID_VERTICAL),

					NWidget(NWID_SPACER), SetFill(1, 1), SetResize(1, 0),

					NWidget(WWT_DROPDOWN, COLOUR_MAUVE, WID_TF_JUMPLIST), SetDataTip(STR_TEXTFILE_JUMPLIST, STR_TEXTFILE_JUMPLIST_TOOLTIP), SetFill(1, 0), SetResize(1, 0),

					NWidget(NWID_SPACER), SetFill(1, 1), SetResize(1, 0),

				EndContainer(),

			EndContainer(),

		EndContainer(),

	EndContainer(),

	this->GetWidget<NWidgetStacked>(WID_TF_SEL_JUMPLIST)->SetDisplayedPlane(SZSP_HORIZONTAL);

	this->DisableWidget(WID_TF_NAVBACK);

	this->DisableWidget(WID_TF_NAVFORWARD);

/** Regular expression that searches for Markdown links. */

static const std::regex _markdown_link_regex{"\\[(.+?)\\]\\((.+?)\\)", std::regex_constants::ECMAScript | std::regex_constants::optimize};

/** Types of link we support in markdown files. */

enum class LinkType {

	Internal, ///< Internal link, or "anchor" in HTML language.

	Web,      ///< Link to an external website.

	File,     ///< Link to a local file.

	Unknown,  ///< Unknown link.

};

/**

 * Classify the type of hyperlink the destination describes.

 *

 * @param destination The hyperlink destination.

 * @param trusted Whether we trust the content of this file.

 * @return LinkType The classification of the link.

 */

static LinkType ClassifyHyperlink(const std::string &destination, bool trusted)

{

	if (destination.empty()) return LinkType::Unknown;

	if (StrStartsWith(destination, "#")) return LinkType::Internal;

	/* Only allow external / internal links for sources we trust. */

	if (!trusted) return LinkType::Unknown;

	if (StrStartsWith(destination, "http://")) return LinkType::Web;

	if (StrStartsWith(destination, "https://")) return LinkType::Web;

	if (StrStartsWith(destination, "./")) return LinkType::File;

	return LinkType::Unknown;

}

/**

 * Create a valid slug for the anchor.

 *

 * @param line The line to create the slug for.

 * @return std::string The slug.

 */

static std::string MakeAnchorSlug(const std::string &line)

{

	std::string r = "#";

	uint state = 0;

	for (char c : line) {

		if (state == 0) {

			/* State 0: Skip leading hashmarks and spaces. */

			if (c == '#') continue;

			if (c == ' ') continue;

			state = 1;

		}

		if (state == 2) {

			/* State 2: Wait for a non-space/dash character.

			 * When found, output a dash and that character. */

			if (c == ' ' || c == '-') continue;

			r += '-';

			state = 1;

		}

		if (state == 1) {

			/* State 1: Normal text.

			 * Lowercase alphanumerics,

			 * spaces and dashes become dashes,

			 * everything else is removed. */

			if (isalnum(c)) {

				r += tolower(c);

			} else if (c == ' ' || c == '-') {

				state = 2;

			}

		}

	}

	return r;

}

/**

 * Find any hyperlinks in a given line.

 *

 * @param line The line to search for hyperlinks.

 * @param line_index The index of the line.

 */

void TextfileWindow::FindHyperlinksInMarkdown(Line &line, size_t line_index)

{

	std::string::const_iterator last_match_end = line.text.cbegin();

	std::string fixed_line;

	char ccbuf[5];

	std::sregex_iterator matcher{ line.text.cbegin(), line.text.cend(), _markdown_link_regex};

	while (matcher != std::sregex_iterator()) {

		std::smatch match = *matcher;

		Hyperlink link;

		link.line = line_index;

		link.destination = match[2].str();

		this->links.push_back(link);

		LinkType link_type = ClassifyHyperlink(link.destination, this->trusted);

		StringControlCode link_colour;

		switch (link_type) {

			case LinkType::Internal:

				link_colour = SCC_GREEN;

				break;

			case LinkType::Web:

				link_colour = SCC_LTBLUE;

				break;

			case LinkType::File:

				link_colour = SCC_LTBROWN;

				break;

			default:

				/* Don't make other link types fancy as they aren't handled (yet). */

				link_colour = SCC_CONTROL_END;

				break;

		}

		if (link_colour != SCC_CONTROL_END) {

			/* Format the link to look like a link. */

			fixed_line += std::string(last_match_end, match[0].first);

			this->links.back().begin = fixed_line.length();

			fixed_line += std::string(ccbuf, Utf8Encode(ccbuf, SCC_PUSH_COLOUR));

			fixed_line += std::string(ccbuf, Utf8Encode(ccbuf, link_colour));

			fixed_line += match[1].str();

			this->links.back().end = fixed_line.length();

			fixed_line += std::string(ccbuf, Utf8Encode(ccbuf, SCC_POP_COLOUR));

			last_match_end = match[0].second;

		}

		/* Find next link. */

		++matcher;

	}

	if (last_match_end == line.text.cbegin()) return; // nothing found

	/* Add remaining text on line. */

	fixed_line += std::string(last_match_end, line.text.cend());

	/* Overwrite original line text with "fixed" line text. */

	line.text = fixed_line;

}

/**

 * Check if the user clicked on a hyperlink, and handle it if so.

 *

 * @param pt The loation the user clicked.

 */

void TextfileWindow::CheckHyperlinkClick(Point pt)

{

	if (this->links.empty()) return;

	/* Which line was clicked. */

	const int clicked_row = this->GetRowFromWidget(pt.y, WID_TF_BACKGROUND, WidgetDimensions::scaled.frametext.top, FONT_HEIGHT_MONO) + this->GetScrollbar(WID_TF_VSCROLLBAR)->GetPosition();

	size_t line_index;

	size_t subline;

	if (IsWidgetLowered(WID_TF_WRAPTEXT)) {

		auto it = std::find_if(std::begin(this->lines), std::end(this->lines), [clicked_row](const Line &l) { return l.top <= clicked_row && l.bottom > clicked_row; });

		if (it == this->lines.cend()) return;

		line_index = it - this->lines.cbegin();

		subline = clicked_row - it->top;

		Debug(misc, 4, "TextfileWindow check hyperlink: clicked_row={}, line_index={}, line.top={}, subline={}", clicked_row, line_index, it->top, subline);

	} else {

		line_index = clicked_row / FONT_HEIGHT_MONO;

		subline = 0;

	}

	/* Find hyperlinks in this line. */

	std::vector<Hyperlink> found_links;

	for (const auto &link : this->links) {

		if (link.line == line_index) found_links.push_back(link);

	}

	if (found_links.empty()) return;

	/* Build line layout to figure out character position that was clicked. */

	uint window_width = IsWidgetLowered(WID_TF_WRAPTEXT) ? this->GetWidget<NWidgetCore>(WID_TF_BACKGROUND)->current_x - WidgetDimensions::scaled.frametext.Horizontal() : INT_MAX;

	Layouter layout(this->lines[line_index].text, window_width, this->lines[line_index].colour, FS_MONO);

	assert(subline < layout.size());

	ptrdiff_t char_index = layout.GetCharAtPosition(pt.x - WidgetDimensions::scaled.frametext.left, subline);

	if (char_index < 0) return;

	Debug(misc, 4, "TextfileWindow check hyperlink click: line={}, subline={}, char_index={}", line_index, subline, (int)char_index);

	/* Found character index in line, check if any links are at that position. */

	for (const auto &link : found_links) {

		Debug(misc, 4, "Checking link from char {} to {}", link.begin, link.end);

		if ((size_t)char_index >= link.begin && (size_t)char_index < link.end) {

			Debug(misc, 4, "Activating link with destination: {}", link.destination);

			this->OnHyperlinkClick(link);

			return;

		}

	}

}

/**

 * Append the new location to the history, so the user can go back.

 *

 * @param filepath The location the user is navigating to.

 */

void TextfileWindow::AppendHistory(const std::string &filepath)

{

	this->history.erase(this->history.begin() + this->history_pos + 1, this->history.end());

	this->UpdateHistoryScrollpos();

	this->history.push_back(HistoryEntry{ filepath, 0 });

	this->EnableWidget(WID_TF_NAVBACK);

	this->DisableWidget(WID_TF_NAVFORWARD);

	this->history_pos = this->history.size() - 1;

}

/**

 * Update the scroll position to the current, so we can restore there if we go back.

 */

void TextfileWindow::UpdateHistoryScrollpos()

{

	this->history[this->history_pos].scrollpos = this->GetScrollbar(WID_TF_VSCROLLBAR)->GetPosition();

}

/**

 * Navigate through the history, either forward or backward.

 *

 * @param delta The direction to navigate.

 */

void TextfileWindow::NavigateHistory(int delta)

{

	if (delta == 0) return;

	if (delta < 0 && static_cast<int>(this->history_pos) < -delta) return;

	if (delta > 0 && this->history_pos + delta >= this->history.size()) return;

	this->UpdateHistoryScrollpos();

	this->history_pos += delta;

	if (this->history[this->history_pos].filepath != this->filepath) {

		this->filepath = this->history[this->history_pos].filepath;

		this->filename = this->filepath.substr(this->filepath.find_last_of(PATHSEP) + 1);

		this->LoadTextfile(this->filepath, NO_DIRECTORY);

	}

	this->SetWidgetDisabledState(WID_TF_NAVFORWARD, this->history_pos + 1 >= this->history.size());

	this->SetWidgetDisabledState(WID_TF_NAVBACK, this->history_pos == 0);

	this->GetScrollbar(WID_TF_VSCROLLBAR)->SetPosition(this->history[this->history_pos].scrollpos);

	this->GetScrollbar(WID_TF_HSCROLLBAR)->SetPosition(0);

	this->SetDirty();

}

/* virtual */ void TextfileWindow::OnHyperlinkClick(const Hyperlink &link)

{

	switch (ClassifyHyperlink(link.destination, this->trusted)) {

		case LinkType::Internal:

		{

			auto it = std::find_if(this->link_anchors.cbegin(), this->link_anchors.cend(), [&](const Hyperlink &other) { return link.destination == other.destination; });

			if (it != this->link_anchors.cend()) {

				this->AppendHistory(this->filepath);

				this->ScrollToLine(it->line);

				this->UpdateHistoryScrollpos();

			}

			break;

		}

		case LinkType::Web:

			OpenBrowser(link.destination.c_str());

			break;

		case LinkType::File:

			this->NavigateToFile(link.destination, 0);

			break;

		default:

			/* Do nothing */

			break;

	}

}

/**

 * Navigate to the requested file.

 *

 * @param newfile The file to navigate to.

 * @param line The line to scroll to.

 */

void TextfileWindow::NavigateToFile(std::string newfile, size_t line)

{

	/* Double-check that the file link begins with ./ as a relative path. */

	if (!StrStartsWith(newfile, "./")) return;

	/* Get the path portion of the current file path. */

	std::string newpath = this->filepath;

	size_t pos = newpath.find_last_of(PATHSEPCHAR);

	if (pos == std::string::npos) {

		newpath.clear();

	} else {

		newpath.erase(pos + 1);

	}

	/* Check and remove for anchor in link. Do this before we find the filename, as people might have a / after the hash. */

	size_t anchor_pos = newfile.find_first_of('#');

	std::string anchor;

	if (anchor_pos != std::string::npos) {

		anchor = newfile.substr(anchor_pos);

		newfile.erase(anchor_pos);

	}

	/* Now the anchor is gone, check if this is a markdown or textfile. */

	if (!StrEndsWithIgnoreCase(newfile, ".md") && !StrEndsWithIgnoreCase(newfile, ".txt")) return;

	/* Convert link destination to acceptable local filename (replace forward slashes with correct path separator). */

	newfile = newfile.substr(2);

	if (PATHSEPCHAR != '/') {

		for (char &c : newfile) {

			if (c == '/') c = PATHSEPCHAR;

		}

	}

	/* Paste the two together and check file exists. */

	newpath = newpath + newfile;

	if (!FioCheckFileExists(newpath, NO_DIRECTORY)) return;

	/* Update history. */

	this->AppendHistory(newpath);

	/* Load the new file. */

	this->filepath = newpath;

	this->filename = newpath.substr(newpath.find_last_of(PATHSEP) + 1);

	this->LoadTextfile(this->filepath, NO_DIRECTORY);