src/strings_func.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file strings_func.h Functions related to OTTD's strings. */
   9
  10 #ifndef STRINGS_FUNC_H
  11 #define STRINGS_FUNC_H
  12
  13 #include "strings_type.h"
  14 #include "string_type.h"
  15 #include "gfx_type.h"
  16 #include "core/bitmath_func.hpp"
  17
  18 /**
  19  * Extract the StringTab from a StringID.
  20  * @param str String identifier
  21  * @return StringTab from \a str
  22  */
  23 static inline StringTab GetStringTab(StringID str)
  24 {
  25         StringTab result = (StringTab)(str >> TAB_SIZE_BITS);
  26         if (result >= TEXT_TAB_NEWGRF_START) return TEXT_TAB_NEWGRF_START;
  27         if (result >= TEXT_TAB_GAMESCRIPT_START) return TEXT_TAB_GAMESCRIPT_START;
  28         return result;
  29 }
  30
  31 /**
  32  * Extract the StringIndex from a StringID.
  33  * @param str String identifier
  34  * @return StringIndex from \a str
  35  */
  36 static inline uint GetStringIndex(StringID str)
  37 {
  38         return str - (GetStringTab(str) << TAB_SIZE_BITS);
  39 }
  40
  41 /**
  42  * Create a StringID
  43  * @param tab StringTab
  44  * @param index StringIndex
  45  * @return StringID composed from \a tab and \a index
  46  */
  47 static inline StringID MakeStringID(StringTab tab, uint index)
  48 {
  49         if (tab == TEXT_TAB_NEWGRF_START) {
  50                 assert(index < TAB_SIZE_NEWGRF);
  51         } else if (tab == TEXT_TAB_GAMESCRIPT_START) {
  52                 assert(index < TAB_SIZE_GAMESCRIPT);
  53         } else {
  54                 assert(tab < TEXT_TAB_END);
  55                 assert(index < TAB_SIZE);
  56         }
  57         return (tab << TAB_SIZE_BITS) + index;
  58 }
  59
  60 class StringParameters {
  61         StringParameters *parent; ///< If not nullptr, this instance references data from this parent instance.
  62         uint64 *data;             ///< Array with the actual data.
  63         WChar *type;              ///< Array with type information about the data. Can be nullptr when no type information is needed. See #StringControlCode.
  64
  65 public:
  66         uint offset;              ///< Current offset in the data/type arrays.
  67         uint num_param;           ///< Length of the data array.
  68
  69         /** Create a new StringParameters instance. */
  70         StringParameters(uint64 *data, uint num_param, WChar *type) :
  71                 parent(nullptr),
  72                 data(data),
  73                 type(type),
  74                 offset(0),
  75                 num_param(num_param)
  76         { }
  77
  78         /** Create a new StringParameters instance. */
  79         template <size_t Tnum_param>
  80         StringParameters(int64 (&data)[Tnum_param]) :
  81                 parent(nullptr),
  82                 data((uint64 *)data),
  83                 type(nullptr),
  84                 offset(0),
  85                 num_param(Tnum_param)
  86         {
  87                 static_assert(sizeof(data[0]) == sizeof(uint64));
  88         }
  89
  90         /**
  91          * Create a new StringParameters instance that can reference part of the data of
  92          * the given partent instance.
  93          */
  94         StringParameters(StringParameters &parent, uint size) :
  95                 parent(&parent),
  96                 data(parent.data + parent.offset),
  97                 offset(0),
  98                 num_param(size)
  99         {
 100                 assert(size <= parent.GetDataLeft());
 101                 if (parent.type == nullptr) {
 102                         this->type = nullptr;
 103                 } else {
 104                         this->type = parent.type + parent.offset;
 105                 }
 106         }
 107
 108         ~StringParameters()
 109         {
 110                 if (this->parent != nullptr) {
 111                         this->parent->offset += this->num_param;
 112                 }
 113         }
 114
 115         void ClearTypeInformation();
 116
 117         int64 GetInt64(WChar type = 0);
 118
 119         /** Read an int32 from the argument array. @see GetInt64. */
 120         int32 GetInt32(WChar type = 0)
 121         {
 122                 return (int32)this->GetInt64(type);
 123         }
 124
 125         /** Get a pointer to the current element in the data array. */
 126         uint64 *GetDataPointer() const
 127         {
 128                 return &this->data[this->offset];
 129         }
 130
 131         /** Return the amount of elements which can still be read. */
 132         uint GetDataLeft() const
 133         {
 134                 return this->num_param - this->offset;
 135         }
 136
 137         /** Get a pointer to a specific element in the data array. */
 138         uint64 *GetPointerToOffset(uint offset) const
 139         {
 140                 assert(offset < this->num_param);
 141                 return &this->data[offset];
 142         }
 143
 144         /** Does this instance store information about the type of the parameters. */
 145         bool HasTypeInformation() const
 146         {
 147                 return this->type != nullptr;
 148         }
 149
 150         /** Get the type of a specific element. */
 151         WChar GetTypeAtOffset(uint offset) const
 152         {
 153                 assert(offset < this->num_param);
 154                 assert(this->HasTypeInformation());
 155                 return this->type[offset];
 156         }
 157
 158         void SetParam(uint n, uint64 v)
 159         {
 160                 assert(n < this->num_param);
 161                 this->data[n] = v;
 162         }
 163
 164         uint64 GetParam(uint n) const
 165         {
 166                 assert(n < this->num_param);
 167                 return this->data[n];
 168         }
 169 };
 170 extern StringParameters _global_string_params;
 171
 172 char *GetString(char *buffr, StringID string, const char *last);
 173 std::string GetString(StringID string);
 174 char *GetStringWithArgs(char *buffr, StringID string, StringParameters *args, const char *last, uint case_index = 0, bool game_script = false);
 175 const char *GetStringPtr(StringID string);
 176
 177 uint ConvertKmhishSpeedToDisplaySpeed(uint speed);
 178 uint ConvertDisplaySpeedToKmhishSpeed(uint speed);
 179
 180 /**
 181  * Set a string parameter \a v at index \a n in a given array \a s.
 182  * @param s Array of string parameters.
 183  * @param n Index of the string parameter.
 184  * @param v Value of the string parameter.
 185  */
 186 static inline void SetDParamX(uint64 *s, uint n, uint64 v)
 187 {
 188         s[n] = v;
 189 }
 190
 191 /**
 192  * Set a string parameter \a v at index \a n in the global string parameter array.
 193  * @param n Index of the string parameter.
 194  * @param v Value of the string parameter.
 195  */
 196 static inline void SetDParam(uint n, uint64 v)
 197 {
 198         _global_string_params.SetParam(n, v);
 199 }
 200
 201 void SetDParamMaxValue(uint n, uint64 max_value, uint min_count = 0, FontSize size = FS_NORMAL);
 202 void SetDParamMaxDigits(uint n, uint count, FontSize size = FS_NORMAL);
 203
 204 void SetDParamStr(uint n, const char *str);
 205 void SetDParamStr(uint n, const std::string &str);
 206 void SetDParamStr(uint n, std::string &&str) = delete; // block passing temporaries to SetDParamStr
 207
 208 void CopyInDParam(int offs, const uint64 *src, int num);
 209 void CopyOutDParam(uint64 *dst, int offs, int num);
 210 void CopyOutDParam(uint64 *dst, const char **strings, StringID string, int num);
 211
 212 /**
 213  * Get the current string parameter at index \a n from parameter array \a s.
 214  * @param s Array of string parameters.
 215  * @param n Index of the string parameter.
 216  * @return Value of the requested string parameter.
 217  */
 218 static inline uint64 GetDParamX(const uint64 *s, uint n)
 219 {
 220         return s[n];
 221 }
 222
 223 /**
 224  * Get the current string parameter at index \a n from the global string parameter array.
 225  * @param n Index of the string parameter.
 226  * @return Value of the requested string parameter.
 227  */
 228 static inline uint64 GetDParam(uint n)
 229 {
 230         return _global_string_params.GetParam(n);
 231 }
 232
 233 extern TextDirection _current_text_dir; ///< Text direction of the currently selected language
 234
 235 void InitializeLanguagePacks();
 236 const char *GetCurrentLanguageIsoCode();
 237
 238 bool StringIDSorter(const StringID &a, const StringID &b);
 239
 240 /**
 241  * A searcher for missing glyphs.
 242  */
 243 class MissingGlyphSearcher {
 244 public:
 245         /** Make sure everything gets destructed right. */
 246         virtual ~MissingGlyphSearcher() {}
 247
 248         /**
 249          * Get the next string to search through.
 250          * @return The next string or nullptr if there is none.
 251          */
 252         virtual const char *NextString() = 0;
 253
 254         /**
 255          * Get the default (font) size of the string.
 256          * @return The font size.
 257          */
 258         virtual FontSize DefaultSize() = 0;
 259
 260         /**
 261          * Reset the search, i.e. begin from the beginning again.
 262          */
 263         virtual void Reset() = 0;
 264
 265         /**
 266          * Whether to search for a monospace font or not.
 267          * @return True if searching for monospace.
 268          */
 269         virtual bool Monospace() = 0;
 270
 271         /**
 272          * Set the right font names.
 273          * @param settings  The settings to modify.
 274          * @param font_name The new font name.
 275          * @param os_data Opaque pointer to OS-specific data.
 276          */
 277         virtual void SetFontNames(struct FontCacheSettings *settings, const char *font_name, const void *os_data = nullptr) = 0;
 278
 279         bool FindMissingGlyphs();
 280 };
 281
 282 void CheckForMissingGlyphs(bool base_font = true, MissingGlyphSearcher *search = nullptr);
 283
 284 #endif /* STRINGS_FUNC_H */