strings_func.h

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/>.
 */
 
#ifndef STRINGS_FUNC_H
#define STRINGS_FUNC_H
 
#include "strings_type.h"
#include "string_type.h"
#include "gfx_type.h"
#include "core/bitmath_func.hpp"
#include "core/convertible_through_base.hpp"
#include "vehicle_type.h"
 
inline StringTab GetStringTab(StringID str)
{
  StringTab result = (StringTab)(str >> TAB_SIZE_BITS);
  if (result >= TEXT_TAB_NEWGRF_START) return TEXT_TAB_NEWGRF_START;
  if (result >= TEXT_TAB_GAMESCRIPT_START) return TEXT_TAB_GAMESCRIPT_START;
  return result;
}
 
inline StringIndexInTab GetStringIndex(StringID str)
{
  return StringIndexInTab{str - (GetStringTab(str) << TAB_SIZE_BITS)};
}
 
inline StringID MakeStringID(StringTab tab, StringIndexInTab index)
{
  if (tab == TEXT_TAB_NEWGRF_START) {
    assert(index < TAB_SIZE_NEWGRF);
  } else if (tab == TEXT_TAB_GAMESCRIPT_START) {
    assert(index < TAB_SIZE_GAMESCRIPT);
  } else {
    assert(tab < TEXT_TAB_END);
    assert(index < TAB_SIZE);
  }
  return (tab << TAB_SIZE_BITS) + index.base();
}
 
static inline void PrepareArgsForNextRun(std::span<StringParameter> args)
{
  for (auto &param : args) param.type = 0;
}
 
std::string GetStringWithArgs(StringID string, std::span<StringParameter> args);
std::string GetString(StringID string);
const char *GetStringPtr(StringID string);
void AppendStringInPlace(std::string &result, StringID string);
void AppendStringWithArgsInPlace(std::string &result, StringID string, std::span<StringParameter> params);
 
uint ConvertKmhishSpeedToDisplaySpeed(uint speed, VehicleType type);
uint ConvertDisplaySpeedToKmhishSpeed(uint speed, VehicleType type);
 
inline int64_t PackVelocity(uint speed, VehicleType type)
{
  /* Vehicle type is a byte, so packed into the top 8 bits of the 64-bit
   * parameter, although only values from 0-3 are relevant. */
  return speed | (static_cast<uint64_t>(type) << 56);
}
 
uint64_t GetParamMaxValue(uint64_t max_value, uint min_count = 0, FontSize size = FS_NORMAL);
uint64_t GetParamMaxDigits(uint count, FontSize size = FS_NORMAL);
 
extern TextDirection _current_text_dir; 
 
void InitializeLanguagePacks();
const char *GetCurrentLanguageIsoCode();
std::string_view GetListSeparator();
 
template <typename... Args>
auto MakeParameters(Args &&... args)
{
  return std::array<StringParameter, sizeof...(args)>({std::forward<StringParameter>(args)...});
}
 
template <typename... Args>
std::string GetString(StringID string, Args &&... args)
{
  auto params = MakeParameters(std::forward<Args &&>(args)...);
  return GetStringWithArgs(string, params);
}
 
EncodedString GetEncodedString(StringID str);
EncodedString GetEncodedStringWithArgs(StringID str, std::span<const StringParameter> params);
 
static inline EncodedString GetEncodedStringIfValid(StringID str)
{
  if (str == INVALID_STRING_ID) return {};
  return GetEncodedString(str);
}
 
template <typename... Args>
EncodedString GetEncodedString(StringID string, const Args&... args)
{
  auto params = MakeParameters(std::forward<const Args&>(args)...);
  return GetEncodedStringWithArgs(string, params);
}
 
class MissingGlyphSearcher {
public:
  virtual ~MissingGlyphSearcher() = default;
 
  virtual std::optional<std::string_view> NextString() = 0;
 
  virtual FontSize DefaultSize() = 0;
 
  virtual void Reset() = 0;
 
  virtual bool Monospace() = 0;
 
  virtual void SetFontNames(struct FontCacheSettings *settings, const char *font_name, const void *os_data = nullptr) = 0;
 
  bool FindMissingGlyphs();
};
 
void CheckForMissingGlyphs(bool base_font = true, MissingGlyphSearcher *search = nullptr);
 
#endif /* STRINGS_FUNC_H */