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/strong_typedef_type.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 uint GetStringIndex(StringID str)
{
  return str - (GetStringTab(str) << TAB_SIZE_BITS);
}
 
inline StringID MakeStringID(StringTab tab, uint 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;
}
 
std::string GetString(StringID string);
const char *GetStringPtr(StringID string);
 
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);
}
 
void SetDParam(size_t n, uint64_t v);
void SetDParamMaxValue(size_t n, uint64_t max_value, uint min_count = 0, FontSize size = FS_NORMAL);
void SetDParamMaxDigits(size_t n, uint count, FontSize size = FS_NORMAL);
 
template <typename T, std::enable_if_t<std::is_base_of<StrongTypedefBase, T>::value, int> = 0>
void SetDParam(size_t n, T v)
{
  SetDParam(n, v.base());
}
 
template <typename T, std::enable_if_t<std::is_base_of<StrongTypedefBase, T>::value, int> = 0>
void SetDParamMaxValue(size_t n, T max_value, uint min_count = 0, FontSize size = FS_NORMAL)
{
  SetDParamMaxValue(n, max_value.base(), min_count, size);
}
 
void SetDParamStr(size_t n, const char *str);
void SetDParamStr(size_t n, const std::string &str);
void SetDParamStr(size_t n, std::string &&str);
 
void CopyInDParam(const std::span<const StringParameterBackup> backup);
void CopyOutDParam(std::vector<StringParameterBackup> &backup, size_t num);
bool HaveDParamChanged(const std::vector<StringParameterBackup> &backup);
 
uint64_t GetDParam(size_t n);
 
extern TextDirection _current_text_dir; 
 
void InitializeLanguagePacks();
const char *GetCurrentLanguageIsoCode();
 
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 */