Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1528 insertions, 0 deletions

diff --git a/xbmc/LangInfo.cpp b/xbmc/LangInfo.cpp
new file mode 100644
index 0000000..db85aa5
--- /dev/null
+++ b/xbmc/LangInfo.cpp
@@ -0,0 +1,1528 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "LangInfo.h"
+
+#include "ServiceBroker.h"
+#include "XBDateTime.h"
+#include "addons/AddonInstaller.h"
+#include "addons/AddonManager.h"
+#include "addons/LanguageResource.h"
+#include "addons/RepositoryUpdater.h"
+#include "addons/addoninfo/AddonType.h"
+#include "guilib/LocalizeStrings.h"
+#include "messaging/ApplicationMessenger.h"
+#include "pvr/PVRManager.h"
+#include "settings/AdvancedSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "settings/lib/Setting.h"
+#include "settings/lib/SettingDefinitions.h"
+#include "utils/CharsetConverter.h"
+#include "utils/LangCodeExpander.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/XBMCTinyXML.h"
+#include "utils/XMLUtils.h"
+#include "utils/log.h"
+#include "weather/WeatherManager.h"
+
+#include <algorithm>
+#include <stdexcept>
+
+using namespace PVR;
+
+static std::string shortDateFormats[] = {
+  // short date formats using "/"
+  "DD/MM/YYYY",
+  "MM/DD/YYYY",
+  "YYYY/MM/DD",
+  "D/M/YYYY",
+  // short date formats using "-"
+  "DD-MM-YYYY",
+  "MM-DD-YYYY",
+  "YYYY-MM-DD",
+  "YYYY-M-D",
+  // short date formats using "."
+  "DD.MM.YYYY",
+  "DD.M.YYYY",
+  "D.M.YYYY",
+  "D. M. YYYY",
+  "YYYY.MM.DD"
+};
+
+static std::string longDateFormats[] = {
+  "DDDD, D MMMM YYYY",
+  "DDDD, DD MMMM YYYY",
+  "DDDD, D. MMMM YYYY",
+  "DDDD, DD. MMMM YYYY",
+  "DDDD, MMMM D, YYYY",
+  "DDDD, MMMM DD, YYYY",
+  "DDDD D MMMM YYYY",
+  "DDDD DD MMMM YYYY",
+  "DDDD D. MMMM YYYY",
+  "DDDD DD. MMMM YYYY",
+  "D. MMMM YYYY",
+  "DD. MMMM YYYY",
+  "D. MMMM. YYYY",
+  "DD. MMMM. YYYY",
+  "YYYY. MMMM. D"
+};
+
+#define TIME_FORMAT_MM_SS         ":mm:ss"
+#define TIME_FORMAT_SINGLE_12     "h" TIME_FORMAT_MM_SS
+#define TIME_FORMAT_DOUBLE_12     "hh" TIME_FORMAT_MM_SS
+#define TIME_FORMAT_SINGLE_24     "H" TIME_FORMAT_MM_SS
+#define TIME_FORMAT_DOUBLE_24     "HH" TIME_FORMAT_MM_SS
+
+#define TIME_FORMAT_12HOURS       "12hours"
+#define TIME_FORMAT_24HOURS       "24hours"
+
+typedef struct TemperatureInfo {
+  CTemperature::Unit unit;
+  std::string name;
+} TemperatureInfo;
+
+static TemperatureInfo temperatureInfo[] = {
+  { CTemperature::UnitFahrenheit, "f" },
+  { CTemperature::UnitKelvin,     "k" },
+  { CTemperature::UnitCelsius,    "c" },
+  { CTemperature::UnitReaumur,    "re" },
+  { CTemperature::UnitRankine,    "ra" },
+  { CTemperature::UnitRomer,      "ro" },
+  { CTemperature::UnitDelisle,    "de" },
+  { CTemperature::UnitNewton,     "n" }
+};
+
+#define TEMP_UNIT_STRINGS         20027
+
+typedef struct SpeedInfo {
+  CSpeed::Unit unit;
+  std::string name;
+} SpeedInfo;
+
+static SpeedInfo speedInfo[] = {
+  { CSpeed::UnitKilometresPerHour,    "kmh" },
+  { CSpeed::UnitMetresPerMinute,      "mpmin" },
+  { CSpeed::UnitMetresPerSecond,      "mps" },
+  { CSpeed::UnitFeetPerHour,          "fth" },
+  { CSpeed::UnitFeetPerMinute,        "ftm" },
+  { CSpeed::UnitFeetPerSecond,        "fts" },
+  { CSpeed::UnitMilesPerHour,         "mph" },
+  { CSpeed::UnitKnots,                "kts" },
+  { CSpeed::UnitBeaufort,             "beaufort" },
+  { CSpeed::UnitInchPerSecond,        "inchs" },
+  { CSpeed::UnitYardPerSecond,        "yards" },
+  { CSpeed::UnitFurlongPerFortnight,  "fpf" }
+};
+
+#define SPEED_UNIT_STRINGS        20200
+
+#define SETTING_REGIONAL_DEFAULT  "regional"
+
+static std::string ToTimeFormat(bool use24HourClock, bool singleHour, bool meridiem)
+{
+  if (use24HourClock)
+    return singleHour ? TIME_FORMAT_SINGLE_24 : TIME_FORMAT_DOUBLE_24;
+
+  if (!meridiem)
+    return singleHour ? TIME_FORMAT_SINGLE_12 : TIME_FORMAT_DOUBLE_12;
+
+  return StringUtils::Format(g_localizeStrings.Get(12382), ToTimeFormat(false, singleHour, false));
+}
+
+static std::string ToSettingTimeFormat(const CDateTime& time, const std::string& timeFormat)
+{
+  return StringUtils::Format(g_localizeStrings.Get(20036),
+                             time.GetAsLocalizedTime(timeFormat, true), timeFormat);
+}
+
+static CTemperature::Unit StringToTemperatureUnit(const std::string& temperatureUnit)
+{
+  std::string unit(temperatureUnit);
+  StringUtils::ToLower(unit);
+
+  for (const TemperatureInfo& info : temperatureInfo)
+  {
+    if (info.name == unit)
+      return info.unit;
+  }
+
+  return CTemperature::UnitCelsius;
+}
+
+static CSpeed::Unit StringToSpeedUnit(const std::string& speedUnit)
+{
+  std::string unit(speedUnit);
+  StringUtils::ToLower(unit);
+
+  for (const SpeedInfo& info : speedInfo)
+  {
+    if (info.name == unit)
+      return info.unit;
+  }
+
+  return CSpeed::UnitKilometresPerHour;
+}
+
+struct SortLanguage
+{
+  bool operator()(const StringSettingOption &left, const StringSettingOption &right) const
+  {
+    std::string strLeft = left.label;
+    std::string strRight = right.label;
+    StringUtils::ToLower(strLeft);
+    StringUtils::ToLower(strRight);
+
+    return strLeft.compare(strRight) < 0;
+  }
+};
+
+CLangInfo::CRegion::CRegion()
+{
+  SetDefaults();
+}
+
+void CLangInfo::CRegion::SetDefaults()
+{
+  m_strName="N/A";
+  m_strLangLocaleName = "English";
+  m_strLangLocaleCodeTwoChar = "en";
+
+  m_strDateFormatShort="DD/MM/YYYY";
+  m_strDateFormatLong="DDDD, D MMMM YYYY";
+  m_strTimeFormat="HH:mm:ss";
+  m_tempUnit = CTemperature::UnitCelsius;
+  m_speedUnit = CSpeed::UnitKilometresPerHour;
+  m_strTimeZone.clear();
+}
+
+void CLangInfo::CRegion::SetTemperatureUnit(const std::string& strUnit)
+{
+  m_tempUnit = StringToTemperatureUnit(strUnit);
+}
+
+void CLangInfo::CRegion::SetSpeedUnit(const std::string& strUnit)
+{
+  m_speedUnit = StringToSpeedUnit(strUnit);
+}
+
+void CLangInfo::CRegion::SetTimeZone(const std::string& strTimeZone)
+{
+  m_strTimeZone = strTimeZone;
+}
+
+void CLangInfo::CRegion::SetGlobalLocale()
+{
+  std::string strLocale;
+  if (m_strRegionLocaleName.length() > 0)
+  {
+#ifdef TARGET_WINDOWS
+    std::string strLang, strRegion;
+    g_LangCodeExpander.ConvertToISO6391(m_strLangLocaleName, strLang);
+    g_LangCodeExpander.ConvertToISO6391(m_strRegionLocaleName, strRegion);
+    strLocale = strLang + "-" + strRegion;
+#else
+    strLocale = m_strLangLocaleName + "_" + m_strRegionLocaleName;
+#endif
+#ifdef TARGET_POSIX
+    strLocale += ".UTF-8";
+#endif
+  }
+  g_langInfo.m_originalLocale = std::locale(std::locale::classic(), new custom_numpunct(m_cDecimalSep, m_cThousandsSep, m_strGrouping));
+
+  CLog::Log(LOGDEBUG, "trying to set locale to {}", strLocale);
+
+  // We need to set the locale to only change the collate. Otherwise,
+  // decimal separator is changed depending of the current language
+  // (ie. "," in French or Dutch instead of "."). This breaks atof() and
+  // others similar functions.
+#if !(defined(TARGET_FREEBSD) || defined(TARGET_DARWIN_OSX) || defined(__UCLIBC__))
+  // on FreeBSD, darwin and uClibc-based systems libstdc++ is compiled with
+  // "generic" locale support
+  std::locale current_locale = std::locale::classic(); // C-Locale
+  try
+  {
+    std::locale lcl = std::locale(strLocale.c_str());
+    strLocale = lcl.name();
+    current_locale = current_locale.combine< std::collate<wchar_t> >(lcl);
+    current_locale = current_locale.combine< std::ctype<wchar_t> >(lcl);
+    current_locale = current_locale.combine< std::time_get<wchar_t> >(lcl);
+    current_locale = current_locale.combine< std::time_put<wchar_t> >(lcl);
+
+    assert(std::use_facet< std::numpunct<char> >(current_locale).decimal_point() == '.');
+
+  } catch(...) {
+    current_locale = std::locale::classic();
+    strLocale = "C";
+  }
+
+  g_langInfo.m_systemLocale = current_locale; //! @todo move to CLangInfo class
+  g_langInfo.m_collationtype = 0;
+  std::locale::global(current_locale);
+#endif
+
+#ifndef TARGET_WINDOWS
+  if (setlocale(LC_COLLATE, strLocale.c_str()) == NULL ||
+      setlocale(LC_CTYPE, strLocale.c_str()) == NULL ||
+      setlocale(LC_TIME, strLocale.c_str()) == NULL)
+  {
+    strLocale = "C";
+    setlocale(LC_COLLATE, strLocale.c_str());
+    setlocale(LC_CTYPE, strLocale.c_str());
+    setlocale(LC_TIME, strLocale.c_str());
+  }
+#else
+  std::wstring strLocaleW;
+  g_charsetConverter.utf8ToW(strLocale, strLocaleW);
+  if (_wsetlocale(LC_COLLATE, strLocaleW.c_str()) == NULL ||
+      _wsetlocale(LC_CTYPE, strLocaleW.c_str()) == NULL ||
+      _wsetlocale(LC_TIME, strLocaleW.c_str()) == NULL)
+  {
+    strLocale = "C";
+    strLocaleW = L"C";
+    _wsetlocale(LC_COLLATE, strLocaleW.c_str());
+    _wsetlocale(LC_CTYPE, strLocaleW.c_str());
+    _wsetlocale(LC_TIME, strLocaleW.c_str());
+  }
+#endif
+
+  g_charsetConverter.resetSystemCharset();
+  CLog::Log(LOGINFO, "global locale set to {}", strLocale);
+
+#ifdef TARGET_ANDROID
+  // Force UTF8 for, e.g., vsnprintf
+  setlocale(LC_ALL, "C.UTF-8");
+#endif
+}
+
+CLangInfo::CLangInfo()
+{
+  SetDefaults();
+  m_shortDateFormat = m_defaultRegion.m_strDateFormatShort;
+  m_longDateFormat = m_defaultRegion.m_strDateFormatLong;
+  m_timeFormat = m_defaultRegion.m_strTimeFormat;
+  m_use24HourClock = DetermineUse24HourClockFromTimeFormat(m_defaultRegion.m_strTimeFormat);
+  m_temperatureUnit = m_defaultRegion.m_tempUnit;
+  m_speedUnit = m_defaultRegion.m_speedUnit;
+  m_collationtype = 0;
+}
+
+CLangInfo::~CLangInfo() = default;
+
+void CLangInfo::OnSettingChanged(const std::shared_ptr<const CSetting>& setting)
+{
+  if (setting == NULL)
+    return;
+
+  auto settingsComponent = CServiceBroker::GetSettingsComponent();
+  if (!settingsComponent)
+    return;
+
+  auto settings = settingsComponent->GetSettings();
+  if (!settings)
+    return;
+
+  const std::string &settingId = setting->GetId();
+  if (settingId == CSettings::SETTING_LOCALE_AUDIOLANGUAGE)
+    SetAudioLanguage(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+  else if (settingId == CSettings::SETTING_LOCALE_SUBTITLELANGUAGE)
+    SetSubtitleLanguage(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+  else if (settingId == CSettings::SETTING_LOCALE_LANGUAGE)
+  {
+    if (!SetLanguage(std::static_pointer_cast<const CSettingString>(setting)->GetValue()))
+    {
+      auto langsetting = settings->GetSetting(CSettings::SETTING_LOCALE_LANGUAGE);
+      if (!langsetting)
+      {
+        CLog::Log(LOGERROR, "Failed to load setting for: {}", CSettings::SETTING_LOCALE_LANGUAGE);
+        return;
+      }
+
+      std::static_pointer_cast<CSettingString>(langsetting)->Reset();
+    }
+  }
+  else if (settingId == CSettings::SETTING_LOCALE_COUNTRY)
+    SetCurrentRegion(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+  else if (settingId == CSettings::SETTING_LOCALE_SHORTDATEFORMAT)
+    SetShortDateFormat(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+  else if (settingId == CSettings::SETTING_LOCALE_LONGDATEFORMAT)
+    SetLongDateFormat(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+  else if (settingId == CSettings::SETTING_LOCALE_TIMEFORMAT)
+    SetTimeFormat(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+  else if (settingId == CSettings::SETTING_LOCALE_USE24HOURCLOCK)
+  {
+    Set24HourClock(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+
+    // update the time format
+    settings->SetString(CSettings::SETTING_LOCALE_TIMEFORMAT,
+                        PrepareTimeFormat(GetTimeFormat(), m_use24HourClock));
+  }
+  else if (settingId == CSettings::SETTING_LOCALE_TEMPERATUREUNIT)
+    SetTemperatureUnit(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+  else if (settingId == CSettings::SETTING_LOCALE_SPEEDUNIT)
+    SetSpeedUnit(std::static_pointer_cast<const CSettingString>(setting)->GetValue());
+}
+
+void CLangInfo::OnSettingsLoaded()
+{
+  // set the temperature and speed units based on the settings
+  const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings();
+  SetShortDateFormat(settings->GetString(CSettings::SETTING_LOCALE_SHORTDATEFORMAT));
+  SetLongDateFormat(settings->GetString(CSettings::SETTING_LOCALE_LONGDATEFORMAT));
+  Set24HourClock(settings->GetString(CSettings::SETTING_LOCALE_USE24HOURCLOCK));
+  SetTimeFormat(settings->GetString(CSettings::SETTING_LOCALE_TIMEFORMAT));
+  SetTemperatureUnit(settings->GetString(CSettings::SETTING_LOCALE_TEMPERATUREUNIT));
+  SetSpeedUnit(settings->GetString(CSettings::SETTING_LOCALE_SPEEDUNIT));
+}
+
+bool CLangInfo::Load(const std::string& strLanguage)
+{
+  SetDefaults();
+
+  std::string strFileName = GetLanguageInfoPath(strLanguage);
+
+  CXBMCTinyXML xmlDoc;
+  if (!xmlDoc.LoadFile(strFileName))
+  {
+    CLog::Log(LOGERROR, "unable to load {}: {} at line {}", strFileName, xmlDoc.ErrorDesc(),
+              xmlDoc.ErrorRow());
+    return false;
+  }
+
+  // get the matching language addon
+  m_languageAddon = GetLanguageAddon(strLanguage);
+  if (m_languageAddon == NULL)
+  {
+    CLog::Log(LOGERROR, "Unknown language {}", strLanguage);
+    return false;
+  }
+
+  // get some language-specific information from the language addon
+  m_strGuiCharSet = m_languageAddon->GetGuiCharset();
+  m_forceUnicodeFont = m_languageAddon->ForceUnicodeFont();
+  m_strSubtitleCharSet = m_languageAddon->GetSubtitleCharset();
+  m_strDVDMenuLanguage = m_languageAddon->GetDvdMenuLanguage();
+  m_strDVDAudioLanguage = m_languageAddon->GetDvdAudioLanguage();
+  m_strDVDSubtitleLanguage = m_languageAddon->GetDvdSubtitleLanguage();
+  m_sortTokens = m_languageAddon->GetSortTokens();
+
+  TiXmlElement* pRootElement = xmlDoc.RootElement();
+  if (pRootElement->ValueStr() != "language")
+  {
+    CLog::Log(LOGERROR, "{} Doesn't contain <language>", strFileName);
+    return false;
+  }
+
+  if (pRootElement->Attribute("locale"))
+    m_defaultRegion.m_strLangLocaleName = pRootElement->Attribute("locale");
+
+#ifdef TARGET_WINDOWS
+  // Windows need 3 chars isolang code
+  if (m_defaultRegion.m_strLangLocaleName.length() == 2)
+  {
+    if (!g_LangCodeExpander.ConvertISO6391ToISO6392B(m_defaultRegion.m_strLangLocaleName, m_defaultRegion.m_strLangLocaleName, true))
+      m_defaultRegion.m_strLangLocaleName = "";
+  }
+
+  if (!g_LangCodeExpander.ConvertWindowsLanguageCodeToISO6392B(m_defaultRegion.m_strLangLocaleName, m_languageCodeGeneral))
+    m_languageCodeGeneral = "";
+#else
+  if (m_defaultRegion.m_strLangLocaleName.length() != 3)
+  {
+    if (!g_LangCodeExpander.ConvertToISO6392B(m_defaultRegion.m_strLangLocaleName, m_languageCodeGeneral))
+      m_languageCodeGeneral = "";
+  }
+  else
+    m_languageCodeGeneral = m_defaultRegion.m_strLangLocaleName;
+#endif
+
+  std::string tmp;
+  if (g_LangCodeExpander.ConvertToISO6391(m_defaultRegion.m_strLangLocaleName, tmp))
+    m_defaultRegion.m_strLangLocaleCodeTwoChar = tmp;
+
+  const TiXmlNode *pRegions = pRootElement->FirstChild("regions");
+  if (pRegions && !pRegions->NoChildren())
+  {
+    const TiXmlElement *pRegion=pRegions->FirstChildElement("region");
+    while (pRegion)
+    {
+      CRegion region(m_defaultRegion);
+      region.m_strName = XMLUtils::GetAttribute(pRegion, "name");
+      if (region.m_strName.empty())
+        region.m_strName=g_localizeStrings.Get(10005); // Not available
+
+      if (pRegion->Attribute("locale"))
+        region.m_strRegionLocaleName = pRegion->Attribute("locale");
+
+#ifdef TARGET_WINDOWS
+      // Windows need 3 chars regions code
+      if (region.m_strRegionLocaleName.length() == 2)
+      {
+        if (!g_LangCodeExpander.ConvertISO31661Alpha2ToISO31661Alpha3(region.m_strRegionLocaleName, region.m_strRegionLocaleName))
+          region.m_strRegionLocaleName = "";
+      }
+#endif
+
+      const TiXmlNode *pDateLong=pRegion->FirstChild("datelong");
+      if (pDateLong && !pDateLong->NoChildren())
+        region.m_strDateFormatLong=pDateLong->FirstChild()->ValueStr();
+
+      const TiXmlNode *pDateShort=pRegion->FirstChild("dateshort");
+      if (pDateShort && !pDateShort->NoChildren())
+        region.m_strDateFormatShort=pDateShort->FirstChild()->ValueStr();
+
+      const TiXmlElement *pTime=pRegion->FirstChildElement("time");
+      if (pTime && !pTime->NoChildren())
+      {
+        region.m_strTimeFormat=pTime->FirstChild()->Value();
+        region.m_strMeridiemSymbols[MeridiemSymbolAM] = XMLUtils::GetAttribute(pTime, "symbolAM");
+        region.m_strMeridiemSymbols[MeridiemSymbolPM] = XMLUtils::GetAttribute(pTime, "symbolPM");
+      }
+
+      const TiXmlNode *pTempUnit=pRegion->FirstChild("tempunit");
+      if (pTempUnit && !pTempUnit->NoChildren())
+        region.SetTemperatureUnit(pTempUnit->FirstChild()->ValueStr());
+
+      const TiXmlNode *pSpeedUnit=pRegion->FirstChild("speedunit");
+      if (pSpeedUnit && !pSpeedUnit->NoChildren())
+        region.SetSpeedUnit(pSpeedUnit->FirstChild()->ValueStr());
+
+      const TiXmlNode *pTimeZone=pRegion->FirstChild("timezone");
+      if (pTimeZone && !pTimeZone->NoChildren())
+        region.SetTimeZone(pTimeZone->FirstChild()->ValueStr());
+
+      const TiXmlElement *pThousandsSep = pRegion->FirstChildElement("thousandsseparator");
+      if (pThousandsSep)
+      {
+        if (!pThousandsSep->NoChildren())
+        {
+          region.m_cThousandsSep = pThousandsSep->FirstChild()->Value()[0];
+          if (pThousandsSep->Attribute("groupingformat"))
+            region.m_strGrouping = StringUtils::BinaryStringToString(pThousandsSep->Attribute("groupingformat"));
+          else
+            region.m_strGrouping = "\3";
+        }
+      }
+      else
+      {
+        region.m_cThousandsSep = ',';
+        region.m_strGrouping = "\3";
+      }
+
+      const TiXmlElement *pDecimalSep = pRegion->FirstChildElement("decimalseparator");
+      if (pDecimalSep)
+      {
+        if (!pDecimalSep->NoChildren())
+          region.m_cDecimalSep = pDecimalSep->FirstChild()->Value()[0];
+      }
+      else
+        region.m_cDecimalSep = '.';
+
+      m_regions.insert(PAIR_REGIONS(region.m_strName, region));
+
+      pRegion=pRegion->NextSiblingElement("region");
+    }
+
+    const std::string& strName = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_COUNTRY);
+    SetCurrentRegion(strName);
+  }
+  g_charsetConverter.reinitCharsetsFromSettings();
+
+  return true;
+}
+
+std::string CLangInfo::GetLanguagePath(const std::string &language)
+{
+  if (language.empty())
+    return "";
+
+  std::string addonId = ADDON::CLanguageResource::GetAddonId(language);
+
+  std::string path = URIUtils::AddFileToFolder(GetLanguagePath(), addonId);
+  URIUtils::AddSlashAtEnd(path);
+
+  return path;
+}
+
+std::string CLangInfo::GetLanguageInfoPath(const std::string &language)
+{
+  if (language.empty())
+    return "";
+
+  return URIUtils::AddFileToFolder(GetLanguagePath(language), "langinfo.xml");
+}
+
+bool CLangInfo::UseLocaleCollation()
+{
+  if (m_collationtype == 0)
+  {
+    // Determine collation to use. When using MySQL/MariaDB or a platform that does not support
+    // locale language collation then use accent folding internal equivalent of utf8_general_ci
+    m_collationtype = 1;
+    if (!StringUtils::EqualsNoCase(
+            CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_databaseMusic.type,
+            "mysql") &&
+        !StringUtils::EqualsNoCase(
+            CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_databaseVideo.type,
+            "mysql") &&
+        CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_useLocaleCollation)
+    {
+      // Check that locale collation facet is implemented on the platform
+      const std::collate<wchar_t>& coll = std::use_facet<std::collate<wchar_t>>(m_systemLocale);
+      wchar_t lc = L'z';
+      wchar_t rc = 0x00E2; // Latin small letter a with circumflex
+      int comp_result = coll.compare(&lc, &lc + 1, &rc, &rc + 1);
+      if (comp_result > 0)
+        // Latin small letter a with circumflex put before z - collation works
+        m_collationtype = 2;
+    }
+  }
+  return m_collationtype == 2;
+}
+
+void CLangInfo::LoadTokens(const TiXmlNode* pTokens, std::set<std::string>& vecTokens)
+{
+  if (pTokens && !pTokens->NoChildren())
+  {
+    const TiXmlElement *pToken = pTokens->FirstChildElement("token");
+    while (pToken)
+    {
+      std::string strSep= " ._";
+      if (pToken->Attribute("separators"))
+        strSep = pToken->Attribute("separators");
+      if (pToken->FirstChild() && pToken->FirstChild()->Value())
+      {
+        if (strSep.empty())
+          vecTokens.insert(pToken->FirstChild()->ValueStr());
+        else
+          for (unsigned int i=0;i<strSep.size();++i)
+            vecTokens.insert(pToken->FirstChild()->ValueStr() + strSep[i]);
+      }
+      pToken = pToken->NextSiblingElement();
+    }
+  }
+}
+
+void CLangInfo::SetDefaults()
+{
+  m_regions.clear();
+
+  //Reset default region
+  m_defaultRegion.SetDefaults();
+
+  // Set the default region, we may be unable to load langinfo.xml
+  m_currentRegion = &m_defaultRegion;
+
+  m_systemLocale = std::locale::classic();
+
+  m_forceUnicodeFont = false;
+  m_strGuiCharSet = "CP1252";
+  m_strSubtitleCharSet = "CP1252";
+  m_strDVDMenuLanguage = "en";
+  m_strDVDAudioLanguage = "en";
+  m_strDVDSubtitleLanguage = "en";
+  m_sortTokens.clear();
+
+  m_languageCodeGeneral = "eng";
+}
+
+std::string CLangInfo::GetGuiCharSet() const
+{
+  std::shared_ptr<CSettingString> charsetSetting = std::static_pointer_cast<CSettingString>(CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting(CSettings::SETTING_LOCALE_CHARSET));
+  if (charsetSetting == NULL || charsetSetting->IsDefault())
+    return m_strGuiCharSet;
+
+  return charsetSetting->GetValue();
+}
+
+std::string CLangInfo::GetSubtitleCharSet() const
+{
+  std::shared_ptr<CSettingString> charsetSetting = std::static_pointer_cast<CSettingString>(CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting(CSettings::SETTING_SUBTITLES_CHARSET));
+  if (charsetSetting->IsDefault())
+    return m_strSubtitleCharSet;
+
+  return charsetSetting->GetValue();
+}
+
+void CLangInfo::GetAddonsLanguageCodes(std::map<std::string, std::string>& languages)
+{
+  ADDON::VECADDONS addons;
+  CServiceBroker::GetAddonMgr().GetAddons(addons, ADDON::AddonType::RESOURCE_LANGUAGE);
+  for (const auto& addon : addons)
+  {
+    const LanguageResourcePtr langAddon =
+        std::dynamic_pointer_cast<ADDON::CLanguageResource>(addon);
+    std::string langCode{langAddon->GetLocale().ToShortStringLC()};
+    StringUtils::Replace(langCode, '_', '-');
+    languages.emplace(langCode, addon->Name());
+  }
+}
+
+LanguageResourcePtr CLangInfo::GetLanguageAddon(const std::string& locale /* = "" */) const
+{
+  if (locale.empty() ||
+     (m_languageAddon != NULL && (locale.compare(m_languageAddon->ID()) == 0 || m_languageAddon->GetLocale().Equals(locale))))
+    return m_languageAddon;
+
+  std::string addonId = ADDON::CLanguageResource::GetAddonId(locale);
+  if (addonId.empty())
+    addonId = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_LANGUAGE);
+
+  ADDON::AddonPtr addon;
+  if (CServiceBroker::GetAddonMgr().GetAddon(addonId, addon, ADDON::AddonType::RESOURCE_LANGUAGE,
+                                             ADDON::OnlyEnabled::CHOICE_YES) &&
+      addon != NULL)
+    return std::dynamic_pointer_cast<ADDON::CLanguageResource>(addon);
+
+  return NULL;
+}
+
+std::string CLangInfo::ConvertEnglishNameToAddonLocale(const std::string& langName)
+{
+  ADDON::VECADDONS addons;
+  CServiceBroker::GetAddonMgr().GetAddons(addons, ADDON::AddonType::RESOURCE_LANGUAGE);
+  for (const auto& addon : addons)
+  {
+    if (StringUtils::CompareNoCase(addon->Name(), langName) == 0)
+    {
+      const LanguageResourcePtr langAddon =
+          std::dynamic_pointer_cast<ADDON::CLanguageResource>(addon);
+      std::string locale = langAddon->GetLocale().ToShortStringLC();
+      StringUtils::Replace(locale, '_', '-');
+      return locale;
+    }
+  }
+  return "";
+}
+
+std::string CLangInfo::GetEnglishLanguageName(const std::string& locale /* = "" */) const
+{
+  LanguageResourcePtr addon = GetLanguageAddon(locale);
+  if (addon == NULL)
+    return "";
+
+  return addon->Name();
+}
+
+bool CLangInfo::SetLanguage(std::string language /* = "" */, bool reloadServices /* = true */)
+{
+  if (language.empty())
+    language = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_LANGUAGE);
+
+  auto& addonMgr = CServiceBroker::GetAddonMgr();
+  ADDON::AddonPtr addon;
+
+  // Find the chosen language add-on if it's enabled
+  if (!addonMgr.GetAddon(language, addon, ADDON::AddonType::RESOURCE_LANGUAGE,
+                         ADDON::OnlyEnabled::CHOICE_YES))
+  {
+    if (!addonMgr.IsAddonInstalled(language) ||
+        (addonMgr.IsAddonDisabled(language) && !addonMgr.EnableAddon(language)))
+    {
+      CLog::Log(LOGWARNING,
+                "CLangInfo::{}: could not find or enable language add-on '{}', loading default...",
+                __func__, language);
+      language = std::static_pointer_cast<const CSettingString>(
+                     CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting(
+                         CSettings::SETTING_LOCALE_LANGUAGE))
+                     ->GetDefault();
+
+      if (!addonMgr.GetAddon(language, addon, ADDON::AddonType::RESOURCE_LANGUAGE,
+                             ADDON::OnlyEnabled::CHOICE_NO))
+      {
+        CLog::Log(LOGFATAL, "CLangInfo::{}: could not find default language add-on '{}'", __func__,
+                  language);
+        return false;
+      }
+    }
+  }
+
+  CLog::Log(LOGINFO, "CLangInfo: loading {} language information...", language);
+  if (!Load(language))
+  {
+    CLog::LogF(LOGFATAL, "CLangInfo: failed to load {} language information", language);
+    return false;
+  }
+
+  CLog::Log(LOGINFO, "CLangInfo: loading {} language strings...", language);
+  if (!g_localizeStrings.Load(GetLanguagePath(), language))
+  {
+    CLog::LogF(LOGFATAL, "CLangInfo: failed to load {} language strings", language);
+    return false;
+  }
+
+  ADDON::VECADDONS addons;
+  if (CServiceBroker::GetAddonMgr().GetInstalledAddons(addons))
+  {
+    const std::string locale = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_LANGUAGE);
+    for (const auto& addon : addons)
+    {
+      const std::string path = URIUtils::AddFileToFolder(addon->Path(), "resources", "language/");
+      g_localizeStrings.LoadAddonStrings(path, locale, addon->ID());
+    }
+  }
+
+  if (reloadServices)
+  {
+    // also tell our weather and skin to reload as these are localized
+    CServiceBroker::GetWeatherManager().Refresh();
+    CServiceBroker::GetPVRManager().LocalizationChanged();
+    CServiceBroker::GetAppMessenger()->PostMsg(TMSG_EXECUTE_BUILT_IN, -1, -1, nullptr,
+                                               "ReloadSkin");
+  }
+
+  return true;
+}
+
+// three char language code (not win32 specific)
+const std::string& CLangInfo::GetAudioLanguage() const
+{
+  if (!m_audioLanguage.empty())
+    return m_audioLanguage;
+
+  return m_languageCodeGeneral;
+}
+
+void CLangInfo::SetAudioLanguage(const std::string& language)
+{
+  if (language.empty()
+    || StringUtils::EqualsNoCase(language, "default")
+    || StringUtils::EqualsNoCase(language, "original")
+    || StringUtils::EqualsNoCase(language, "mediadefault")
+    || !g_LangCodeExpander.ConvertToISO6392B(language, m_audioLanguage))
+    m_audioLanguage.clear();
+}
+
+// three char language code (not win32 specific)
+const std::string& CLangInfo::GetSubtitleLanguage() const
+{
+  if (!m_subtitleLanguage.empty())
+    return m_subtitleLanguage;
+
+  return m_languageCodeGeneral;
+}
+
+void CLangInfo::SetSubtitleLanguage(const std::string& language)
+{
+  if (language.empty()
+    || StringUtils::EqualsNoCase(language, "default")
+    || StringUtils::EqualsNoCase(language, "original")
+    || !g_LangCodeExpander.ConvertToISO6392B(language, m_subtitleLanguage))
+    m_subtitleLanguage.clear();
+}
+
+// two character codes as defined in ISO639
+const std::string CLangInfo::GetDVDMenuLanguage() const
+{
+  std::string code;
+  if (!g_LangCodeExpander.ConvertToISO6391(m_currentRegion->m_strLangLocaleName, code))
+    code = m_strDVDMenuLanguage;
+
+  return code;
+}
+
+// two character codes as defined in ISO639
+const std::string CLangInfo::GetDVDAudioLanguage() const
+{
+  std::string code;
+  if (!g_LangCodeExpander.ConvertToISO6391(m_audioLanguage, code))
+    code = m_strDVDAudioLanguage;
+
+  return code;
+}
+
+// two character codes as defined in ISO639
+const std::string CLangInfo::GetDVDSubtitleLanguage() const
+{
+  std::string code;
+  if (!g_LangCodeExpander.ConvertToISO6391(m_subtitleLanguage, code))
+    code = m_strDVDSubtitleLanguage;
+
+  return code;
+}
+
+const CLocale& CLangInfo::GetLocale() const
+{
+  LanguageResourcePtr language = GetLanguageAddon();
+  if (language != NULL)
+    return language->GetLocale();
+
+  return CLocale::Empty;
+}
+
+const std::string& CLangInfo::GetRegionLocale() const
+{
+  return m_currentRegion->m_strRegionLocaleName;
+}
+
+const std::locale& CLangInfo::GetOriginalLocale() const
+{
+  return m_originalLocale;
+}
+
+// Returns the format string for the date of the current language
+const std::string& CLangInfo::GetDateFormat(bool bLongDate /* = false */) const
+{
+  if (bLongDate)
+    return GetLongDateFormat();
+
+  return GetShortDateFormat();
+}
+
+void CLangInfo::SetDateFormat(const std::string& dateFormat, bool bLongDate /* = false */)
+{
+  if (bLongDate)
+    SetLongDateFormat(dateFormat);
+  else
+    SetShortDateFormat(dateFormat);
+}
+
+const std::string& CLangInfo::GetShortDateFormat() const
+{
+  return m_shortDateFormat;
+}
+
+void CLangInfo::SetShortDateFormat(const std::string& shortDateFormat)
+{
+  std::string newShortDateFormat = shortDateFormat;
+  if (shortDateFormat == SETTING_REGIONAL_DEFAULT)
+    newShortDateFormat = m_currentRegion->m_strDateFormatShort;
+
+  m_shortDateFormat = newShortDateFormat;
+}
+
+const std::string& CLangInfo::GetLongDateFormat() const
+{
+  return m_longDateFormat;
+}
+
+void CLangInfo::SetLongDateFormat(const std::string& longDateFormat)
+{
+  std::string newLongDateFormat = longDateFormat;
+  if (longDateFormat == SETTING_REGIONAL_DEFAULT)
+    newLongDateFormat = m_currentRegion->m_strDateFormatShort;
+
+  m_longDateFormat = newLongDateFormat;
+}
+
+// Returns the format string for the time of the current language
+const std::string& CLangInfo::GetTimeFormat() const
+{
+  return m_timeFormat;
+}
+
+void CLangInfo::SetTimeFormat(const std::string& timeFormat)
+{
+  std::string newTimeFormat = timeFormat;
+  if (timeFormat == SETTING_REGIONAL_DEFAULT)
+    newTimeFormat = m_currentRegion->m_strTimeFormat;
+
+  m_timeFormat = PrepareTimeFormat(newTimeFormat, m_use24HourClock);
+}
+
+bool CLangInfo::Use24HourClock() const
+{
+  return m_use24HourClock;
+}
+
+void CLangInfo::Set24HourClock(bool use24HourClock)
+{
+  m_use24HourClock = use24HourClock;
+}
+
+void CLangInfo::Set24HourClock(const std::string& str24HourClock)
+{
+  bool use24HourClock = false;
+  if (str24HourClock == TIME_FORMAT_12HOURS)
+    use24HourClock = false;
+  else if (str24HourClock == TIME_FORMAT_24HOURS)
+    use24HourClock = true;
+  else if (str24HourClock == SETTING_REGIONAL_DEFAULT)
+  {
+    Set24HourClock(m_currentRegion->m_strTimeFormat);
+    return;
+  }
+  else
+    use24HourClock = DetermineUse24HourClockFromTimeFormat(str24HourClock);
+
+  if (m_use24HourClock == use24HourClock)
+    return;
+
+  m_use24HourClock = use24HourClock;
+}
+
+const std::string& CLangInfo::GetTimeZone() const
+{
+  return m_currentRegion->m_strTimeZone;
+}
+
+// Returns the AM/PM symbol of the current language
+const std::string& CLangInfo::GetMeridiemSymbol(MeridiemSymbol symbol) const
+{
+  // nothing to return if we use 24-hour clock
+  if (m_use24HourClock)
+    return StringUtils::Empty;
+
+  return MeridiemSymbolToString(symbol);
+}
+
+const std::string& CLangInfo::MeridiemSymbolToString(MeridiemSymbol symbol)
+{
+  switch (symbol)
+  {
+  case MeridiemSymbolAM:
+    return g_localizeStrings.Get(378);
+
+  case MeridiemSymbolPM:
+    return g_localizeStrings.Get(379);
+
+  default:
+    break;
+  }
+
+  return StringUtils::Empty;
+}
+
+// Fills the array with the region names available for this language
+void CLangInfo::GetRegionNames(std::vector<std::string>& array)
+{
+  for (const auto &region : m_regions)
+  {
+    std::string strName=region.first;
+    if (strName=="N/A")
+      strName=g_localizeStrings.Get(10005); // Not available
+    array.emplace_back(std::move(strName));
+  }
+}
+
+// Set the current region by its name, names from GetRegionNames() are valid.
+// If the region is not found the first available region is set.
+void CLangInfo::SetCurrentRegion(const std::string& strName)
+{
+  ITMAPREGIONS it=m_regions.find(strName);
+  if (it!=m_regions.end())
+    m_currentRegion=&it->second;
+  else if (!m_regions.empty())
+    m_currentRegion=&m_regions.begin()->second;
+  else
+    m_currentRegion=&m_defaultRegion;
+
+  m_currentRegion->SetGlobalLocale();
+
+  const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings();
+  if (settings->GetString(CSettings::SETTING_LOCALE_SHORTDATEFORMAT) == SETTING_REGIONAL_DEFAULT)
+    SetShortDateFormat(m_currentRegion->m_strDateFormatShort);
+  if (settings->GetString(CSettings::SETTING_LOCALE_LONGDATEFORMAT) == SETTING_REGIONAL_DEFAULT)
+    SetLongDateFormat(m_currentRegion->m_strDateFormatLong);
+  if (settings->GetString(CSettings::SETTING_LOCALE_USE24HOURCLOCK) == SETTING_REGIONAL_DEFAULT)
+  {
+    Set24HourClock(m_currentRegion->m_strTimeFormat);
+
+    // update the time format
+    SetTimeFormat(settings->GetString(CSettings::SETTING_LOCALE_TIMEFORMAT));
+  }
+  if (settings->GetString(CSettings::SETTING_LOCALE_TIMEFORMAT) == SETTING_REGIONAL_DEFAULT)
+    SetTimeFormat(m_currentRegion->m_strTimeFormat);
+  if (settings->GetString(CSettings::SETTING_LOCALE_TEMPERATUREUNIT) == SETTING_REGIONAL_DEFAULT)
+    SetTemperatureUnit(m_currentRegion->m_tempUnit);
+  if (settings->GetString(CSettings::SETTING_LOCALE_SPEEDUNIT) == SETTING_REGIONAL_DEFAULT)
+    SetSpeedUnit(m_currentRegion->m_speedUnit);
+}
+
+// Returns the current region set for this language
+const std::string& CLangInfo::GetCurrentRegion() const
+{
+  return m_currentRegion->m_strName;
+}
+
+CTemperature::Unit CLangInfo::GetTemperatureUnit() const
+{
+  return m_temperatureUnit;
+}
+
+void CLangInfo::SetTemperatureUnit(CTemperature::Unit temperatureUnit)
+{
+  if (m_temperatureUnit == temperatureUnit)
+    return;
+
+  m_temperatureUnit = temperatureUnit;
+
+  // refresh weather manager as temperatures need re-translating
+  // NOTE: this could be called before our service manager is up
+  if (CServiceBroker::IsServiceManagerUp())
+    CServiceBroker::GetWeatherManager().Refresh();
+}
+
+void CLangInfo::SetTemperatureUnit(const std::string& temperatureUnit)
+{
+  CTemperature::Unit unit = CTemperature::UnitCelsius;
+  if (temperatureUnit == SETTING_REGIONAL_DEFAULT)
+    unit = m_currentRegion->m_tempUnit;
+  else
+    unit = StringToTemperatureUnit(temperatureUnit);
+
+  SetTemperatureUnit(unit);
+}
+
+std::string CLangInfo::GetTemperatureAsString(const CTemperature& temperature) const
+{
+  if (!temperature.IsValid())
+    return g_localizeStrings.Get(13205); // "Unknown"
+
+  CTemperature::Unit temperatureUnit = GetTemperatureUnit();
+  return StringUtils::Format("{}{}", temperature.ToString(temperatureUnit),
+                             GetTemperatureUnitString());
+}
+
+// Returns the temperature unit string for the current language
+const std::string& CLangInfo::GetTemperatureUnitString() const
+{
+  return GetTemperatureUnitString(m_temperatureUnit);
+}
+
+const std::string& CLangInfo::GetTemperatureUnitString(CTemperature::Unit temperatureUnit)
+{
+  return g_localizeStrings.Get(TEMP_UNIT_STRINGS + temperatureUnit);
+}
+
+void CLangInfo::SetSpeedUnit(CSpeed::Unit speedUnit)
+{
+  if (m_speedUnit == speedUnit)
+    return;
+
+  m_speedUnit = speedUnit;
+
+  // refresh weather manager as speeds need re-translating
+  // NOTE: this could be called before our service manager is up
+  if (CServiceBroker::IsServiceManagerUp())
+    CServiceBroker::GetWeatherManager().Refresh();
+}
+
+void CLangInfo::SetSpeedUnit(const std::string& speedUnit)
+{
+  CSpeed::Unit unit = CSpeed::UnitKilometresPerHour;
+  if (speedUnit == SETTING_REGIONAL_DEFAULT)
+    unit = m_currentRegion->m_speedUnit;
+  else
+    unit = StringToSpeedUnit(speedUnit);
+
+  SetSpeedUnit(unit);
+}
+
+CSpeed::Unit CLangInfo::GetSpeedUnit() const
+{
+  return m_speedUnit;
+}
+
+std::string CLangInfo::GetSpeedAsString(const CSpeed& speed) const
+{
+  if (!speed.IsValid())
+    return g_localizeStrings.Get(13205); // "Unknown"
+
+  return StringUtils::Format("{}{}", speed.ToString(GetSpeedUnit()), GetSpeedUnitString());
+}
+
+// Returns the speed unit string for the current language
+const std::string& CLangInfo::GetSpeedUnitString() const
+{
+  return GetSpeedUnitString(m_speedUnit);
+}
+
+const std::string& CLangInfo::GetSpeedUnitString(CSpeed::Unit speedUnit)
+{
+  return g_localizeStrings.Get(SPEED_UNIT_STRINGS + speedUnit);
+}
+
+std::set<std::string> CLangInfo::GetSortTokens() const
+{
+  std::set<std::string> sortTokens = m_sortTokens;
+  for (const auto& t : CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_vecTokens)
+    sortTokens.insert(t);
+
+  return sortTokens;
+}
+
+bool CLangInfo::DetermineUse24HourClockFromTimeFormat(const std::string& timeFormat)
+{
+  // if the time format contains a "h" it's 12-hour and otherwise 24-hour clock format
+  return timeFormat.find('h') == std::string::npos;
+}
+
+bool CLangInfo::DetermineUseMeridiemFromTimeFormat(const std::string& timeFormat)
+{
+  // if the time format contains "xx" it's using meridiem
+  return timeFormat.find("xx") != std::string::npos;
+}
+
+std::string CLangInfo::PrepareTimeFormat(const std::string& timeFormat, bool use24HourClock)
+{
+  std::string preparedTimeFormat = timeFormat;
+  if (use24HourClock)
+  {
+    // replace all "h" with "H"
+    StringUtils::Replace(preparedTimeFormat, 'h', 'H');
+
+    // remove any "xx" for meridiem
+    StringUtils::Replace(preparedTimeFormat, "x", "");
+  }
+  else
+    // replace all "H" with "h"
+    StringUtils::Replace(preparedTimeFormat, 'H', 'h');
+
+  StringUtils::Trim(preparedTimeFormat);
+
+  return preparedTimeFormat;
+}
+
+void CLangInfo::SettingOptionsLanguageNamesFiller(const SettingConstPtr& setting,
+                                                  std::vector<StringSettingOption>& list,
+                                                  std::string& current,
+                                                  void* data)
+{
+  // find languages...
+  ADDON::VECADDONS addons;
+  if (!CServiceBroker::GetAddonMgr().GetAddons(addons, ADDON::AddonType::RESOURCE_LANGUAGE))
+    return;
+
+  for (const auto &addon : addons)
+    list.emplace_back(addon->Name(), addon->Name());
+
+  sort(list.begin(), list.end(), SortLanguage());
+}
+
+void CLangInfo::SettingOptionsISO6391LanguagesFiller(const SettingConstPtr& setting,
+                                                     std::vector<StringSettingOption>& list,
+                                                     std::string& current,
+                                                     void* data)
+{
+  std::vector<std::string> languages = g_LangCodeExpander.GetLanguageNames(
+      CLangCodeExpander::ISO_639_1, CLangCodeExpander::LANG_LIST::INCLUDE_USERDEFINED);
+
+  for (const auto &language : languages)
+    list.emplace_back(language, language);
+}
+
+void CLangInfo::SettingOptionsAudioStreamLanguagesFiller(const SettingConstPtr& setting,
+                                                         std::vector<StringSettingOption>& list,
+                                                         std::string& current,
+                                                         void* data)
+{
+  list.emplace_back(g_localizeStrings.Get(307), "mediadefault");
+  list.emplace_back(g_localizeStrings.Get(308), "original");
+  list.emplace_back(g_localizeStrings.Get(309), "default");
+
+  AddLanguages(list);
+}
+
+void CLangInfo::SettingOptionsSubtitleStreamLanguagesFiller(const SettingConstPtr& setting,
+                                                            std::vector<StringSettingOption>& list,
+                                                            std::string& current,
+                                                            void* data)
+{
+  list.emplace_back(g_localizeStrings.Get(231), "none");
+  list.emplace_back(g_localizeStrings.Get(13207), "forced_only");
+  list.emplace_back(g_localizeStrings.Get(308), "original");
+  list.emplace_back(g_localizeStrings.Get(309), "default");
+
+  AddLanguages(list);
+}
+
+void CLangInfo::SettingOptionsSubtitleDownloadlanguagesFiller(
+    const SettingConstPtr& setting,
+    std::vector<StringSettingOption>& list,
+    std::string& current,
+    void* data)
+{
+  list.emplace_back(g_localizeStrings.Get(308), "original");
+  list.emplace_back(g_localizeStrings.Get(309), "default");
+
+  AddLanguages(list);
+}
+
+void CLangInfo::SettingOptionsRegionsFiller(const SettingConstPtr& setting,
+                                            std::vector<StringSettingOption>& list,
+                                            std::string& current,
+                                            void* data)
+{
+  std::vector<std::string> regions;
+  g_langInfo.GetRegionNames(regions);
+  std::sort(regions.begin(), regions.end(), sortstringbyname());
+
+  bool match = false;
+  for (unsigned int i = 0; i < regions.size(); ++i)
+  {
+    std::string region = regions[i];
+    list.emplace_back(region, region);
+
+    if (!match && region == std::static_pointer_cast<const CSettingString>(setting)->GetValue())
+    {
+      match = true;
+      current = region;
+    }
+  }
+
+  if (!match && !regions.empty())
+    current = regions[0];
+}
+
+void CLangInfo::SettingOptionsShortDateFormatsFiller(const SettingConstPtr& setting,
+                                                     std::vector<StringSettingOption>& list,
+                                                     std::string& current,
+                                                     void* data)
+{
+  bool match = false;
+  const std::string& shortDateFormatSetting = std::static_pointer_cast<const CSettingString>(setting)->GetValue();
+
+  CDateTime now = CDateTime::GetCurrentDateTime();
+
+  list.emplace_back(
+      StringUtils::Format(g_localizeStrings.Get(20035),
+                          now.GetAsLocalizedDate(g_langInfo.m_currentRegion->m_strDateFormatShort)),
+      SETTING_REGIONAL_DEFAULT);
+  if (shortDateFormatSetting == SETTING_REGIONAL_DEFAULT)
+  {
+    match = true;
+    current = SETTING_REGIONAL_DEFAULT;
+  }
+
+  for (const std::string& shortDateFormat : shortDateFormats)
+  {
+    list.emplace_back(now.GetAsLocalizedDate(shortDateFormat), shortDateFormat);
+
+    if (!match && shortDateFormatSetting == shortDateFormat)
+    {
+      match = true;
+      current = shortDateFormat;
+    }
+  }
+
+  if (!match && !list.empty())
+    current = list[0].value;
+}
+
+void CLangInfo::SettingOptionsLongDateFormatsFiller(const SettingConstPtr& setting,
+                                                    std::vector<StringSettingOption>& list,
+                                                    std::string& current,
+                                                    void* data)
+{
+  bool match = false;
+  const std::string& longDateFormatSetting = std::static_pointer_cast<const CSettingString>(setting)->GetValue();
+
+  CDateTime now = CDateTime::GetCurrentDateTime();
+
+  list.emplace_back(
+      StringUtils::Format(g_localizeStrings.Get(20035),
+                          now.GetAsLocalizedDate(g_langInfo.m_currentRegion->m_strDateFormatLong)),
+      SETTING_REGIONAL_DEFAULT);
+  if (longDateFormatSetting == SETTING_REGIONAL_DEFAULT)
+  {
+    match = true;
+    current = SETTING_REGIONAL_DEFAULT;
+  }
+
+  for (const std::string& longDateFormat : longDateFormats)
+  {
+    list.emplace_back(now.GetAsLocalizedDate(longDateFormat), longDateFormat);
+
+    if (!match && longDateFormatSetting == longDateFormat)
+    {
+      match = true;
+      current = longDateFormat;
+    }
+  }
+
+  if (!match && !list.empty())
+    current = list[0].value;
+}
+
+void CLangInfo::SettingOptionsTimeFormatsFiller(const SettingConstPtr& setting,
+                                                std::vector<StringSettingOption>& list,
+                                                std::string& current,
+                                                void* data)
+{
+  bool match = false;
+  const std::string& timeFormatSetting = std::static_pointer_cast<const CSettingString>(setting)->GetValue();
+
+  CDateTime now = CDateTime::GetCurrentDateTime();
+  bool use24hourFormat = g_langInfo.Use24HourClock();
+
+  list.emplace_back(
+      StringUtils::Format(g_localizeStrings.Get(20035),
+                          ToSettingTimeFormat(now, g_langInfo.m_currentRegion->m_strTimeFormat)),
+      SETTING_REGIONAL_DEFAULT);
+  if (timeFormatSetting == SETTING_REGIONAL_DEFAULT)
+  {
+    match = true;
+    current = SETTING_REGIONAL_DEFAULT;
+  }
+
+  if (use24hourFormat)
+  {
+    list.emplace_back(ToSettingTimeFormat(now, TIME_FORMAT_SINGLE_24), TIME_FORMAT_SINGLE_24);
+    if (timeFormatSetting == TIME_FORMAT_SINGLE_24)
+    {
+      current = TIME_FORMAT_SINGLE_24;
+      match = true;
+    }
+
+    list.emplace_back(ToSettingTimeFormat(now, TIME_FORMAT_DOUBLE_24), TIME_FORMAT_DOUBLE_24);
+    if (timeFormatSetting == TIME_FORMAT_DOUBLE_24)
+    {
+      current = TIME_FORMAT_DOUBLE_24;
+      match = true;
+    }
+  }
+  else
+  {
+    list.emplace_back(ToSettingTimeFormat(now, TIME_FORMAT_SINGLE_12), TIME_FORMAT_SINGLE_12);
+    if (timeFormatSetting == TIME_FORMAT_SINGLE_12)
+    {
+      current = TIME_FORMAT_SINGLE_12;
+      match = true;
+    }
+
+    list.emplace_back(ToSettingTimeFormat(now, TIME_FORMAT_DOUBLE_12), TIME_FORMAT_DOUBLE_12);
+    if (timeFormatSetting == TIME_FORMAT_DOUBLE_12)
+    {
+      current = TIME_FORMAT_DOUBLE_12;
+      match = true;
+    }
+
+    std::string timeFormatSingle12Meridiem = ToTimeFormat(false, true, true);
+    list.emplace_back(ToSettingTimeFormat(now, timeFormatSingle12Meridiem), timeFormatSingle12Meridiem);
+    if (timeFormatSetting == timeFormatSingle12Meridiem)
+    {
+      current = timeFormatSingle12Meridiem;
+      match = true;
+    }
+
+    std::string timeFormatDouble12Meridiem = ToTimeFormat(false, false, true);
+    list.emplace_back(ToSettingTimeFormat(now, timeFormatDouble12Meridiem), timeFormatDouble12Meridiem);
+    if (timeFormatSetting == timeFormatDouble12Meridiem)
+    {
+      current = timeFormatDouble12Meridiem;
+      match = true;
+    }
+  }
+
+  if (!match && !list.empty())
+    current = list[0].value;
+}
+
+void CLangInfo::SettingOptions24HourClockFormatsFiller(const SettingConstPtr& setting,
+                                                       std::vector<StringSettingOption>& list,
+                                                       std::string& current,
+                                                       void* data)
+{
+  bool match = false;
+  const std::string& clock24HourFormatSetting = std::static_pointer_cast<const CSettingString>(setting)->GetValue();
+
+  // determine the 24-hour clock format of the regional setting
+  int regionalClock24HourFormatLabel = DetermineUse24HourClockFromTimeFormat(g_langInfo.m_currentRegion->m_strTimeFormat) ? 12384 : 12383;
+  list.emplace_back(StringUtils::Format(g_localizeStrings.Get(20035),
+                                        g_localizeStrings.Get(regionalClock24HourFormatLabel)),
+                    SETTING_REGIONAL_DEFAULT);
+  if (clock24HourFormatSetting == SETTING_REGIONAL_DEFAULT)
+  {
+    match = true;
+    current = SETTING_REGIONAL_DEFAULT;
+  }
+
+  list.emplace_back(g_localizeStrings.Get(12383), TIME_FORMAT_12HOURS);
+  if (clock24HourFormatSetting == TIME_FORMAT_12HOURS)
+  {
+    current = TIME_FORMAT_12HOURS;
+    match = true;
+  }
+
+  list.emplace_back(g_localizeStrings.Get(12384), TIME_FORMAT_24HOURS);
+  if (clock24HourFormatSetting == TIME_FORMAT_24HOURS)
+  {
+    current = TIME_FORMAT_24HOURS;
+    match = true;
+  }
+
+  if (!match && !list.empty())
+    current = list[0].value;
+}
+
+void CLangInfo::SettingOptionsTemperatureUnitsFiller(const SettingConstPtr& setting,
+                                                     std::vector<StringSettingOption>& list,
+                                                     std::string& current,
+                                                     void* data)
+{
+  bool match = false;
+  const std::string& temperatureUnitSetting = std::static_pointer_cast<const CSettingString>(setting)->GetValue();
+
+  list.emplace_back(
+      StringUtils::Format(g_localizeStrings.Get(20035),
+                          GetTemperatureUnitString(g_langInfo.m_currentRegion->m_tempUnit)),
+      SETTING_REGIONAL_DEFAULT);
+  if (temperatureUnitSetting == SETTING_REGIONAL_DEFAULT)
+  {
+    match = true;
+    current = SETTING_REGIONAL_DEFAULT;
+  }
+
+  for (const TemperatureInfo& info : temperatureInfo)
+  {
+    list.emplace_back(GetTemperatureUnitString(info.unit), info.name);
+
+    if (!match && temperatureUnitSetting == info.name)
+    {
+      match = true;
+      current = info.name;
+    }
+  }
+
+  if (!match && !list.empty())
+    current = list[0].value;
+}
+
+void CLangInfo::SettingOptionsSpeedUnitsFiller(const SettingConstPtr& setting,
+                                               std::vector<StringSettingOption>& list,
+                                               std::string& current,
+                                               void* data)
+{
+  bool match = false;
+  const std::string& speedUnitSetting = std::static_pointer_cast<const CSettingString>(setting)->GetValue();
+
+  list.emplace_back(
+      StringUtils::Format(g_localizeStrings.Get(20035),
+                          GetSpeedUnitString(g_langInfo.m_currentRegion->m_speedUnit)),
+      SETTING_REGIONAL_DEFAULT);
+  if (speedUnitSetting == SETTING_REGIONAL_DEFAULT)
+  {
+    match = true;
+    current = SETTING_REGIONAL_DEFAULT;
+  }
+
+  for (const SpeedInfo& info : speedInfo)
+  {
+    list.emplace_back(GetSpeedUnitString(info.unit), info.name);
+
+    if (!match && speedUnitSetting == info.name)
+    {
+      match = true;
+      current = info.name;
+    }
+  }
+
+  if (!match && !list.empty())
+    current = list[0].value;
+}
+
+void CLangInfo::AddLanguages(std::vector<StringSettingOption> &list)
+{
+  std::vector<std::string> languages = g_LangCodeExpander.GetLanguageNames(
+      CLangCodeExpander::ISO_639_1, CLangCodeExpander::LANG_LIST::INCLUDE_ADDONS_USERDEFINED);
+
+  for (const auto& language : languages)
+    list.emplace_back(language, language);
+}