src/strings_func.h

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file strings_func.h Functions related to OTTD's strings. */
  11
  12 #ifndef STRINGS_FUNC_H
  13 #define STRINGS_FUNC_H
  14
  15 #include "strings_type.h"
  16 #include "string_type.h"
  17
  18 class StringParameters {
  19         StringParameters *parent; ///< If not NULL, this instance references data from this parent instance.
  20         uint64 *data;             ///< Array with the actual data.
  21         WChar *type;              ///< Array with type information about the data. Can be NULL when no type information is needed. See #StringControlCode.
  22
  23 public:
  24         uint offset;              ///< Current offset in the data/type arrays.
  25         uint num_param;           ///< Length of the data array.
  26
  27         /** Create a new StringParameters instance. */
  28         StringParameters(uint64 *data, uint num_param, WChar *type) :
  29                 parent(NULL),
  30                 data(data),
  31                 type(type),
  32                 offset(0),
  33                 num_param(num_param)
  34         { }
  35
  36         /** Create a new StringParameters instance. */
  37         template <size_t Tnum_param>
  38         StringParameters(int64 (&data)[Tnum_param]) :
  39                 parent(NULL),
  40                 data((uint64 *)data),
  41                 type(NULL),
  42                 offset(0),
  43                 num_param(Tnum_param)
  44         {
  45                 assert_compile(sizeof(data[0]) == sizeof(uint64));
  46         }
  47
  48         /**
  49          * Create a new StringParameters instance that can reference part of the data of
  50          * the given partent instance.
  51          */
  52         StringParameters(StringParameters &parent, uint size) :
  53                 parent(&parent),
  54                 data(parent.data + parent.offset),
  55                 offset(0),
  56                 num_param(size)
  57         {
  58                 assert(size <= parent.num_param - parent.offset);
  59                 if (parent.type == NULL) {
  60                         this->type = NULL;
  61                 } else {
  62                         this->type = parent.type + parent.offset;
  63                 }
  64         }
  65
  66         ~StringParameters()
  67         {
  68                 if (this->parent != NULL) {
  69                         this->parent->offset += this->num_param;
  70                 }
  71         }
  72
  73         void ClearTypeInformation();
  74
  75         /**
  76          * Read an int64 from the argument array. The offset is increased
  77          * so the next time GetInt64 is called the next value is read.
  78          */
  79         int64 GetInt64(WChar type = 0)
  80         {
  81                 assert(this->offset < this->num_param);
  82                 if (this->type != NULL) {
  83                         assert(this->type[this->offset] == 0 || this->type[this->offset] == type);
  84                         this->type[this->offset] = type;
  85                 }
  86                 return this->data[this->offset++];
  87         }
  88
  89         /** Read an int32 from the argument array. @see GetInt64. */
  90         int32 GetInt32(WChar type = 0)
  91         {
  92                 return (int32)this->GetInt64(type);
  93         }
  94
  95         void ShiftParameters(uint amount);
  96
  97         /** Get a pointer to the current element in the data array. */
  98         uint64 *GetDataPointer() const
  99         {
 100                 return &this->data[this->offset];
 101         }
 102
 103         /** Get a pointer to a specific element in the data array. */
 104         uint64 *GetPointerToOffset(uint offset) const
 105         {
 106                 assert(offset < this->num_param);
 107                 return &this->data[offset];
 108         }
 109
 110         /** Does this instance store information about the type of the parameters. */
 111         bool HasTypeInformation() const
 112         {
 113                 return this->type != NULL;
 114         }
 115
 116         /** Get the type of a specific element. */
 117         WChar GetTypeAtOffset(uint offset) const
 118         {
 119                 assert(offset < this->num_param);
 120                 assert(this->HasTypeInformation());
 121                 return this->type[offset];
 122         }
 123
 124         void SetParam(uint n, uint64 v)
 125         {
 126                 assert(n < this->num_param);
 127                 this->data[n] = v;
 128         }
 129
 130         uint64 GetParam(uint n) const
 131         {
 132                 assert(n < this->num_param);
 133                 return this->data[n];
 134         }
 135 };
 136 extern StringParameters _global_string_params;
 137
 138 char *InlineString(char *buf, StringID string);
 139 char *GetString(char *buffr, StringID string, const char *last);
 140 char *GetStringWithArgs(char *buffr, uint string, StringParameters *args, const char *last);
 141 const char *GetStringPtr(StringID string);
 142
 143 void InjectDParam(uint amount);
 144
 145 /**
 146  * Set a string parameter \a v at index \a n in a given array \a s.
 147  * @param s Array of string parameters.
 148  * @param n Index of the string parameter.
 149  * @param v Value of the string parameter.
 150  */
 151 static inline void SetDParamX(uint64 *s, uint n, uint64 v)
 152 {
 153         s[n] = v;
 154 }
 155
 156 /**
 157  * Set a string parameter \a v at index \a n in the global string parameter array.
 158  * @param n Index of the string parameter.
 159  * @param v Value of the string parameter.
 160  */
 161 static inline void SetDParam(uint n, uint64 v)
 162 {
 163         _global_string_params.SetParam(n, v);
 164 }
 165
 166 void SetDParamStr(uint n, const char *str);
 167
 168 void CopyInDParam(int offs, const uint64 *src, int num);
 169 void CopyOutDParam(uint64 *dst, int offs, int num);
 170
 171 /**
 172  * Get the current string parameter at index \a n from parameter array \a s.
 173  * @param s Array of string parameters.
 174  * @param n Index of the string parameter.
 175  * @return Value of the requested string parameter.
 176  */
 177 static inline uint64 GetDParamX(const uint64 *s, uint n)
 178 {
 179         return s[n];
 180 }
 181
 182 /**
 183  * Get the current string parameter at index \a n from the global string parameter array.
 184  * @param n Index of the string parameter.
 185  * @return Value of the requested string parameter.
 186  */
 187 static inline uint64 GetDParam(uint n)
 188 {
 189         return _global_string_params.GetParam(n);
 190 }
 191
 192 extern TextDirection _current_text_dir; ///< Text direction of the currently selected language
 193
 194 void InitializeLanguagePacks();
 195 const char *GetCurrentLanguageIsoCode();
 196
 197 int CDECL StringIDSorter(const StringID *a, const StringID *b);
 198
 199 void CheckForMissingGlyphsInLoadedLanguagePack();
 200
 201 #endif /* STRINGS_FUNC_H */