textfile_gui.cpp

Go to the documentation of this file.

/*
 * 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/>.
 */
 
#include "stdafx.h"
#include "core/backup_type.hpp"
#include "fileio_func.h"
#include "fontcache.h"
#include "gfx_type.h"
#include "gfx_func.h"
#include "string_func.h"
#include "textfile_gui.h"
#include "widgets/dropdown_type.h"
#include "gfx_layout.h"
#include "debug.h"
#include "openttd.h"
 
#include "widgets/misc_widget.h"
 
#include "table/strings.h"
#include "table/control_codes.h"
 
#if defined(WITH_ZLIB)
#include <zlib.h>
#endif
 
#if defined(WITH_LIBLZMA)
#include <lzma.h>
#endif
 
#include <regex>
 
#include "safeguards.h"
 
static constexpr NWidgetPart _nested_textfile_widgets[] = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, COLOUR_MAUVE),
    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(WWT_CAPTION, COLOUR_MAUVE, WID_TF_CAPTION), SetDataTip(STR_NULL, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
    NWidget(WWT_TEXTBTN, COLOUR_MAUVE, WID_TF_WRAPTEXT), SetDataTip(STR_TEXTFILE_WRAP_TEXT, STR_TEXTFILE_WRAP_TEXT_TOOLTIP),
    NWidget(WWT_DEFSIZEBOX, COLOUR_MAUVE),
  EndContainer(),
  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(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PANEL, COLOUR_MAUVE, WID_TF_BACKGROUND), SetMinimalSize(200, 125), SetResize(1, 12), SetScrollbar(WID_TF_VSCROLLBAR),
    EndContainer(),
    NWidget(NWID_VERTICAL),
      NWidget(NWID_VSCROLLBAR, COLOUR_MAUVE, WID_TF_VSCROLLBAR),
    EndContainer(),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(NWID_HSCROLLBAR, COLOUR_MAUVE, WID_TF_HSCROLLBAR),
    NWidget(WWT_RESIZEBOX, COLOUR_MAUVE),
  EndContainer(),
};
 
static WindowDesc _textfile_desc(__FILE__, __LINE__,
  WDP_CENTER, "textfile", 630, 460,
  WC_TEXTFILE, WC_NONE,
  0,
  std::begin(_nested_textfile_widgets), std::end(_nested_textfile_widgets)
);
 
TextfileWindow::TextfileWindow(TextfileType file_type) : Window(&_textfile_desc), file_type(file_type)
{
  /* Init of nested tree is deferred.
   * TextfileWindow::ConstructWindow must be called by the inheriting window. */
}
 
void TextfileWindow::ConstructWindow()
{
  this->CreateNestedTree();
  this->vscroll = this->GetScrollbar(WID_TF_VSCROLLBAR);
  this->hscroll = this->GetScrollbar(WID_TF_HSCROLLBAR);
  this->GetWidget<NWidgetCore>(WID_TF_CAPTION)->SetDataTip(STR_TEXTFILE_README_CAPTION + this->file_type, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS);
  this->GetWidget<NWidgetStacked>(WID_TF_SEL_JUMPLIST)->SetDisplayedPlane(SZSP_HORIZONTAL);
  this->FinishInitNested(this->file_type);
 
  this->DisableWidget(WID_TF_NAVBACK);
  this->DisableWidget(WID_TF_NAVFORWARD);
  this->hscroll->SetStepSize(10); // Speed up horizontal scrollbar
}
 
uint TextfileWindow::ReflowContent()
{
  uint height = 0;
  if (!IsWidgetLowered(WID_TF_WRAPTEXT)) {
    for (auto &line : this->lines) {
      line.top = height;
      height++;
      line.bottom = height;
    }
  } else {
    int max_width = this->GetWidget<NWidgetCore>(WID_TF_BACKGROUND)->current_x - WidgetDimensions::scaled.frametext.Horizontal();
    for (auto &line : this->lines) {
      line.top = height;
      height += GetStringHeight(line.text, max_width, FS_MONO) / GetCharacterHeight(FS_MONO);
      line.bottom = height;
    }
  }
 
  return height;
}
 
uint TextfileWindow::GetContentHeight()
{
  if (this->lines.empty()) return 0;
  return this->lines.back().bottom;
}
 
/* virtual */ void TextfileWindow::UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize)
{
  switch (widget) {
    case WID_TF_BACKGROUND:
      resize->height = GetCharacterHeight(FS_MONO);
 
      size->height = 4 * resize->height + WidgetDimensions::scaled.frametext.Vertical(); // At least 4 lines are visible.
      size->width = std::max(200u, size->width); // At least 200 pixels wide.
      break;
  }
}
 
void TextfileWindow::SetupScrollbars(bool force_reflow)
{
  if (IsWidgetLowered(WID_TF_WRAPTEXT)) {
    /* Reflow is mandatory if text wrapping is on */
    uint height = this->ReflowContent();
    this->vscroll->SetCount(ClampTo<uint16_t>(height));
    this->hscroll->SetCount(0);
  } else {
    uint height = force_reflow ? this->ReflowContent() : this->GetContentHeight();
    this->vscroll->SetCount(ClampTo<uint16_t>(height));
    this->hscroll->SetCount(this->max_length + WidgetDimensions::scaled.frametext.Horizontal());
  }
 
  this->SetWidgetDisabledState(WID_TF_HSCROLLBAR, IsWidgetLowered(WID_TF_WRAPTEXT));
}
 
 
static const std::regex _markdown_link_regex{"\\[(.+?)\\]\\((.+?)\\)", std::regex_constants::ECMAScript | std::regex_constants::optimize};
 
enum class HyperlinkType {
  Internal, 
  Web,      
  File,     
  Unknown,  
};
 
static HyperlinkType ClassifyHyperlink(const std::string &destination, bool trusted)
{
  if (destination.empty()) return HyperlinkType::Unknown;
  if (destination.starts_with("#")) return HyperlinkType::Internal;
 
  /* Only allow external / internal links for sources we trust. */
  if (!trusted) return HyperlinkType::Unknown;
 
  if (destination.starts_with("http://")) return HyperlinkType::Web;
  if (destination.starts_with("https://")) return HyperlinkType::Web;
  if (destination.starts_with("./")) return HyperlinkType::File;
  return HyperlinkType::Unknown;
}
 
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;
}
 
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);
 
    HyperlinkType link_type = ClassifyHyperlink(link.destination, this->trusted);
    StringControlCode link_colour;
    switch (link_type) {
      case HyperlinkType::Internal:
        link_colour = SCC_GREEN;
        break;
      case HyperlinkType::Web:
        link_colour = SCC_LTBLUE;
        break;
      case HyperlinkType::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;
}
 
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, GetCharacterHeight(FS_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 / GetCharacterHeight(FS_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;
    }
  }
}
 
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;
}
 
void TextfileWindow::UpdateHistoryScrollpos()
{
  this->history[this->history_pos].scrollpos = this->GetScrollbar(WID_TF_VSCROLLBAR)->GetPosition();
}
 
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 HyperlinkType::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 HyperlinkType::Web:
      OpenBrowser(link.destination);
      break;
 
    case HyperlinkType::File:
      this->NavigateToFile(link.destination, 0);
      break;
 
    default:
      /* Do nothing */
      break;
  }
}
 
void TextfileWindow::NavigateToFile(std::string newfile, size_t line)
{
  /* Double-check that the file link begins with ./ as a relative path. */
  if (!newfile.starts_with("./")) 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);
 
  this->GetScrollbar(WID_TF_HSCROLLBAR)->SetPosition(0);
  this->GetScrollbar(WID_TF_VSCROLLBAR)->SetPosition(0);
 
  if (anchor.empty() || line != 0) {
    this->ScrollToLine(line);
  } else {
    auto anchor_dest = std::find_if(this->link_anchors.cbegin(), this->link_anchors.cend(), [&](const Hyperlink &other) { return anchor == other.destination; });
    if (anchor_dest != this->link_anchors.cend()) {
      this->ScrollToLine(anchor_dest->line);
      this->UpdateHistoryScrollpos();
    } else {
      this->ScrollToLine(0);
    }
  }
}
 
/* virtual */ void TextfileWindow::AfterLoadText()
{
  this->link_anchors.clear();
 
  if (StrEndsWithIgnoreCase(this->filename, ".md")) this->AfterLoadMarkdown();
 
  if (this->GetWidget<NWidgetStacked>(WID_TF_SEL_JUMPLIST)->SetDisplayedPlane(this->jumplist.empty() ? SZSP_HORIZONTAL : 0)) this->ReInit();
}
 
void TextfileWindow::AfterLoadMarkdown()
{
  for (size_t line_index = 0; line_index < this->lines.size(); ++line_index) {
    Line &line = this->lines[line_index];
 
    /* Find and mark all hyperlinks in the line. */
    this->FindHyperlinksInMarkdown(line, line_index);
 
    /* All lines beginning with # are headings. */
    if (!line.text.empty() && line.text[0] == '#') {
      this->jumplist.push_back(line_index);
      this->lines[line_index].colour = TC_GOLD;
      this->link_anchors.emplace_back(Hyperlink{ line_index, 0, 0, MakeAnchorSlug(line.text) });
    }
  }
}
 
/* virtual */ void TextfileWindow::OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count)
{
  switch (widget) {
    case WID_TF_WRAPTEXT:
      this->ToggleWidgetLoweredState(WID_TF_WRAPTEXT);
      this->InvalidateData();
      break;
 
    case WID_TF_JUMPLIST: {
      DropDownList list;
      for (size_t line : this->jumplist) {
        SetDParamStr(0, this->lines[line].text);
        list.push_back(std::make_unique<DropDownListStringItem>(STR_TEXTFILE_JUMPLIST_ITEM, (int)line, false));
      }
      ShowDropDownList(this, std::move(list), -1, widget);
      break;
    }
 
    case WID_TF_NAVBACK:
      this->NavigateHistory(-1);
      break;
 
    case WID_TF_NAVFORWARD:
      this->NavigateHistory(+1);
      break;
 
    case WID_TF_BACKGROUND:
      this->CheckHyperlinkClick(pt);
      break;
  }
}
 
/* virtual */ void TextfileWindow::DrawWidget(const Rect &r, WidgetID widget) const
{
  if (widget != WID_TF_BACKGROUND) return;
 
  Rect fr = r.Shrink(WidgetDimensions::scaled.frametext);
 
  DrawPixelInfo new_dpi;
  if (!FillDrawPixelInfo(&new_dpi, fr)) return;
  AutoRestoreBackup dpi_backup(_cur_dpi, &new_dpi);
 
  /* Draw content (now coordinates given to DrawString* are local to the new clipping region). */
  fr = fr.Translate(-fr.left, -fr.top);
  int line_height = GetCharacterHeight(FS_MONO);
  int pos = this->vscroll->GetPosition();
  int cap = this->vscroll->GetCapacity();
 
  for (auto &line : this->lines) {
    if (line.bottom < pos) continue;
    if (line.top > pos + cap) break;
 
    int y_offset = (line.top - pos) * line_height;
    if (IsWidgetLowered(WID_TF_WRAPTEXT)) {
      DrawStringMultiLine(0, fr.right, y_offset, fr.bottom, line.text, line.colour, SA_TOP | SA_LEFT, false, FS_MONO);
    } else {
      DrawString(-this->hscroll->GetPosition(), fr.right, y_offset, line.text, line.colour, SA_TOP | SA_LEFT, false, FS_MONO);
    }
  }
}
 
/* virtual */ void TextfileWindow::OnResize()
{
  this->vscroll->SetCapacityFromWidget(this, WID_TF_BACKGROUND, WidgetDimensions::scaled.frametext.Vertical());
  this->hscroll->SetCapacityFromWidget(this, WID_TF_BACKGROUND);
 
  this->SetupScrollbars(false);
}
 
/* virtual */ void TextfileWindow::OnInvalidateData([[maybe_unused]] int data, [[maybe_unused]] bool gui_scope)
{
  if (!gui_scope) return;
 
  this->SetupScrollbars(true);
}
 
void TextfileWindow::OnDropdownSelect(WidgetID widget, int index)
{
  if (widget != WID_TF_JUMPLIST) return;
 
  this->ScrollToLine(index);
}
 
void TextfileWindow::ScrollToLine(size_t line)
{
  Scrollbar *sb = this->GetScrollbar(WID_TF_VSCROLLBAR);
  int newpos;
  if (this->IsWidgetLowered(WID_TF_WRAPTEXT)) {
    newpos = this->lines[line].top;
  } else {
    newpos = static_cast<int>(line);
  }
  sb->SetPosition(std::min(newpos, sb->GetCount() - sb->GetCapacity()));
  this->SetDirty();
}
 
/* virtual */ void TextfileWindow::Reset()
{
  this->search_iterator = 0;
}
 
/* virtual */ FontSize TextfileWindow::DefaultSize()
{
  return FS_MONO;
}
 
/* virtual */ std::optional<std::string_view> TextfileWindow::NextString()
{
  if (this->search_iterator >= this->lines.size()) return std::nullopt;
 
  return this->lines[this->search_iterator++].text;
}
 
/* virtual */ bool TextfileWindow::Monospace()
{
  return true;
}
 
/* virtual */ void TextfileWindow::SetFontNames([[maybe_unused]] FontCacheSettings *settings, [[maybe_unused]] const char *font_name, [[maybe_unused]] const void *os_data)
{
#if defined(WITH_FREETYPE) || defined(_WIN32) || defined(WITH_COCOA)
  settings->mono.font = font_name;
  settings->mono.os_handle = os_data;
#endif
}
 
#if defined(WITH_ZLIB)
 
static void Gunzip(byte **bufp, size_t *sizep)
{
  static const int BLOCKSIZE  = 8192;
  byte             *buf       = nullptr;
  size_t           alloc_size = 0;
  z_stream         z;
  int              res;
 
  memset(&z, 0, sizeof(z));
  z.next_in = *bufp;
  z.avail_in = (uInt)*sizep;
 
  /* window size = 15, add 32 to enable gzip or zlib header processing */
  res = inflateInit2(&z, 15 + 32);
  /* Z_BUF_ERROR just means we need more space */
  while (res == Z_OK || (res == Z_BUF_ERROR && z.avail_out == 0)) {
    /* When we get here, we're either just starting, or
     * inflate is out of output space - allocate more */
    alloc_size += BLOCKSIZE;
    z.avail_out += BLOCKSIZE;
    buf = ReallocT(buf, alloc_size);
    z.next_out = buf + alloc_size - z.avail_out;
    res = inflate(&z, Z_FINISH);
  }
 
  free(*bufp);
  inflateEnd(&z);
 
  if (res == Z_STREAM_END) {
    *bufp = buf;
    *sizep = alloc_size - z.avail_out;
  } else {
    /* Something went wrong */
    *bufp = nullptr;
    *sizep = 0;
    free(buf);
  }
}
#endif
 
#if defined(WITH_LIBLZMA)
 
static void Xunzip(byte **bufp, size_t *sizep)
{
  static const int BLOCKSIZE  = 8192;
  byte             *buf       = nullptr;
  size_t           alloc_size = 0;
  lzma_stream      z = LZMA_STREAM_INIT;
  int              res;
 
  z.next_in = *bufp;
  z.avail_in = *sizep;
 
  res = lzma_auto_decoder(&z, UINT64_MAX, LZMA_CONCATENATED);
  /* Z_BUF_ERROR just means we need more space */
  while (res == LZMA_OK || (res == LZMA_BUF_ERROR && z.avail_out == 0)) {
    /* When we get here, we're either just starting, or
     * inflate is out of output space - allocate more */
    alloc_size += BLOCKSIZE;
    z.avail_out += BLOCKSIZE;
    buf = ReallocT(buf, alloc_size);
    z.next_out = buf + alloc_size - z.avail_out;
    res = lzma_code(&z, LZMA_FINISH);
  }
 
  free(*bufp);
  lzma_end(&z);
 
  if (res == LZMA_STREAM_END) {
    *bufp = buf;
    *sizep = alloc_size - z.avail_out;
  } else {
    /* Something went wrong */
    *bufp = nullptr;
    *sizep = 0;
    free(buf);
  }
}
#endif
 
 
/* virtual */ void TextfileWindow::LoadTextfile(const std::string &textfile, Subdirectory dir)
{
  this->lines.clear();
  this->jumplist.clear();
 
  if (this->GetWidget<NWidgetStacked>(WID_TF_SEL_JUMPLIST)->SetDisplayedPlane(SZSP_HORIZONTAL)) this->ReInit();
 
  if (textfile.empty()) return;
 
  /* Get text from file */
  size_t filesize;
  FILE *handle = FioFOpenFile(textfile, "rb", dir, &filesize);
  if (handle == nullptr) return;
  /* Early return on empty files. */
  if (filesize == 0) return;
 
  char *buf = MallocT<char>(filesize);
  size_t read = fread(buf, 1, filesize, handle);
  fclose(handle);
 
  if (read != filesize) {
    free(buf);
    return;
  }
 
#if defined(WITH_ZLIB)
  /* In-place gunzip */
  if (textfile.ends_with(".gz")) Gunzip((byte**)&buf, &filesize);
#endif
 
#if defined(WITH_LIBLZMA)
  /* In-place xunzip */
  if (textfile.ends_with(".xz")) Xunzip((byte**)&buf, &filesize);
#endif
 
  if (buf == nullptr) return;
 
  std::string_view sv_buf(buf, filesize);
 
  /* Check for the byte-order-mark, and skip it if needed. */
  if (sv_buf.starts_with("\ufeff")) sv_buf.remove_prefix(3);
 
  /* Update the filename. */
  this->filepath = textfile;
  this->filename = this->filepath.substr(this->filepath.find_last_of(PATHSEP) + 1);
  /* If it's the first file being loaded, add to history. */
  if (this->history.empty()) this->history.push_back(HistoryEntry{ this->filepath, 0 });
 
  /* Process the loaded text into lines, and do any further parsing needed. */
  this->LoadText(sv_buf);
  free(buf);
}
 
void TextfileWindow::LoadText(std::string_view buf)
{
  std::string text = StrMakeValid(buf, SVS_REPLACE_WITH_QUESTION_MARK | SVS_ALLOW_NEWLINE | SVS_REPLACE_TAB_CR_NL_WITH_SPACE);
  this->lines.clear();
 
  /* Split the string on newlines. */
  std::string_view p(text);
  int row = 0;
  auto next = p.find_first_of('\n');
  while (next != std::string_view::npos) {
    this->lines.emplace_back(row, p.substr(0, next));
    p.remove_prefix(next + 1);
 
    row++;
    next = p.find_first_of('\n');
  }
  this->lines.emplace_back(row, p);
 
  /* Calculate maximum text line length. */
  uint max_length = 0;
  for (auto &line : this->lines) {
    max_length = std::max(max_length, GetStringBoundingBox(line.text, FS_MONO).width);
  }
  this->max_length = max_length;
 
  this->AfterLoadText();
 
  CheckForMissingGlyphs(true, this);
}
 
std::optional<std::string> GetTextfile(TextfileType type, Subdirectory dir, const std::string &filename)
{
  static const char * const prefixes[] = {
    "readme",
    "changelog",
    "license",
  };
  static_assert(lengthof(prefixes) == TFT_CONTENT_END);
 
  /* Only the generic text file types allowed for this function */
  if (type >= TFT_CONTENT_END) return std::nullopt;
 
  std::string_view prefix = prefixes[type];
 
  if (filename.empty()) return std::nullopt;
 
  auto slash = filename.find_last_of(PATHSEPCHAR);
  if (slash == std::string::npos) return std::nullopt;
 
  std::string_view base_path(filename.data(), slash + 1);
 
  static const std::initializer_list<std::string_view> extensions{
    "txt",
    "md",
#if defined(WITH_ZLIB)
    "txt.gz",
    "md.gz",
#endif
#if defined(WITH_LIBLZMA)
    "txt.xz",
    "md.xz",
#endif
  };
 
  for (auto &extension : extensions) {
    std::string file_path = fmt::format("{}{}_{}.{}", base_path, prefix, GetCurrentLanguageIsoCode(), extension);
    if (FioCheckFileExists(file_path, dir)) return file_path;
 
    file_path = fmt::format("{}{}_{:.2s}.{}", base_path, prefix, GetCurrentLanguageIsoCode(), extension);
    if (FioCheckFileExists(file_path, dir)) return file_path;
 
    file_path = fmt::format("{}{}.{}", base_path, prefix, extension);
    if (FioCheckFileExists(file_path, dir)) return file_path;
  }
  return std::nullopt;
}