/**
* Delete a character from a textbuffer, either with 'Delete' or 'Backspace'
* The character is delete from the position the caret is at
* @param keycode Type of deletion, either WKC_BACKSPACE or WKC_DELETE
* @return Return true on successful change of Textbuf, or false otherwise
*/
bool Textbuf::DeleteChar(uint16 keycode)
{
bool word = (keycode & WKC_CTRL) != 0;
keycode &= ~WKC_SPECIAL_KEYS;
if (keycode != WKC_BACKSPACE && keycode != WKC_DELETE) return false;
bool backspace = keycode == WKC_BACKSPACE;
if (!CanDelChar(backspace)) return false;
char *s = this->buf + this->caretpos;
uint16 len = 0;
if (word) {
/* Delete a complete word. */
if (backspace) {
/* Delete whitespace and word in front of the caret. */
len = this->caretpos - (uint16)this->char_iter->Prev(StringIterator::ITER_WORD);
s -= len;
} else {
/* Delete word and following whitespace following the caret. */
len = (uint16)this->char_iter->Next(StringIterator::ITER_WORD) - this->caretpos;
}
/* Update character count. */
for (const char *ss = s; ss < s + len; Utf8Consume(&ss)) {
this->chars--;
}
} else {
/* Delete a single character. */
if (backspace) {
/* Delete the last code point in front of the caret. */
s = Utf8PrevChar(s);
WChar c;
len = (uint16)Utf8Decode(&c, s);
this->chars--;
} else {
/* Delete the complete character following the caret. */
len = (uint16)this->char_iter->Next(StringIterator::ITER_CHARACTER) - this->caretpos;
/* Update character count. */
for (const char *ss = s; ss < s + len; Utf8Consume(&ss)) {
this->chars--;
}
}
}
/* Move the remaining characters over the marker */
memmove(s, s + len, this->bytes - (s - this->buf) - len);
this->bytes -= len;
if (backspace) this->caretpos -= len;
this->UpdateStringIter();
this->UpdateWidth();
this->UpdateCaretPosition();
this->UpdateMarkedText();
return true;
}
/**
* Convert from OpenTTD's encoding to that of the local environment.
* When the project is built in UNICODE the system codepage is irrelevant and
* the converted string is wide. In ANSI mode, the UTF8 string is converted
* to multi-byte.
* OpenTTD internal encoding is UTF8.
* The returned value's contents can only be guaranteed until the next call to
* this function. So if the value is needed for anything else, use convert_from_fs
* @param name pointer to a valid string that will be converted (UTF8)
* @return pointer to the converted string; if failed string is of zero-length
* @see the current code-page comes from video\win32_v.cpp, event-notification
* WM_INPUTLANGCHANGE
*/
const TCHAR *OTTD2FS(const char *name)
{
static TCHAR system_buf[512];
#if defined(UNICODE)
return convert_to_fs(name, system_buf, lengthof(system_buf));
#else
char *s = system_buf;
for (WChar c; (c = Utf8Consume(&name)) != '\0';) {
if (s >= lastof(system_buf)) break;
char mb;
int len = WideCharToMultiByte(_codepage, 0, (wchar_t*)&c, 1, &mb, 1, NULL, NULL);
if (len != 1) {
DEBUG(misc, 0, "[utf8] W2M error converting '0x%X'. Errno %lu", c, GetLastError());
continue;
}
*s++ = mb;
}
*s = '\0';
return system_buf;
#endif /* UNICODE */
}
/**
* Draw an unformatted news message truncated to a maximum length. If
* length exceeds maximum length it will be postfixed by '...'
* @param left the left most location for the string
* @param right the right most location for the string
* @param y position of the string
* @param colour the colour the string will be shown in
* @param *ni NewsItem being printed
* @param maxw maximum width of string in pixels
*/
static void DrawNewsString(uint left, uint right, int y, TextColour colour, const NewsItem *ni)
{
char buffer[512], buffer2[512];
StringID str;
CopyInDParam(0, ni->params, lengthof(ni->params));
str = ni->string_id;
GetString(buffer, str, lastof(buffer));
/* Copy the just gotten string to another buffer to remove any formatting
* from it such as big fonts, etc. */
const char *ptr = buffer;
char *dest = buffer2;
WChar c_last = '\0';
for (;;) {
WChar c = Utf8Consume(&ptr);
if (c == 0) break;
/* Make a space from a newline, but ignore multiple newlines */
if (c == '\n' && c_last != '\n') {
dest[0] = ' ';
dest++;
} else if (c == '\r') {
dest[0] = dest[1] = dest[2] = dest[3] = ' ';
dest += 4;
} else if (IsPrintable(c)) {
dest += Utf8Encode(dest, c);
}
c_last = c;
}
*dest = '\0';
/* Truncate and show string; postfixed by '...' if necessary */
DrawString(left, right, y, buffer2, colour);
}
/**
* Get the character that is at a position.
* @param x Position in the string.
* @return Pointer to the character at the position or NULL if no character is at the position.
*/
const char *Layouter::GetCharAtPosition(int x) const
{
const ParagraphLayouter::Line *line = *this->Begin();
for (int run_index = 0; run_index < line->CountRuns(); run_index++) {
const ParagraphLayouter::VisualRun *run = line->GetVisualRun(run_index);
for (int i = 0; i < run->GetGlyphCount(); i++) {
/* Not a valid glyph (empty). */
if (run->GetGlyphs()[i] == 0xFFFF) continue;
int begin_x = (int)run->GetPositions()[i * 2];
int end_x = (int)run->GetPositions()[i * 2 + 2];
if (IsInsideMM(x, begin_x, end_x)) {
/* Found our glyph, now convert to UTF-8 string index. */
size_t index = run->GetGlyphToCharMap()[i];
size_t cur_idx = 0;
for (const char *str = this->string; *str != '\0'; ) {
if (cur_idx == index) return str;
WChar c = Utf8Consume(&str);
cur_idx += line->GetInternalCharLength(c);
}
}
}
}
return NULL;
}
/**
* Get the length of an UTF-8 encoded string in number of characters
* and thus not the number of bytes that the encoded string contains.
* @param s The string to get the length for.
* @return The length of the string in characters.
*/
size_t Utf8StringLength(const char *s)
{
size_t len = 0;
const char *t = s;
while (Utf8Consume(&t) != 0) len++;
return len;
}
/**
* Delete a part of the text.
* @param from Start of the text to delete.
* @param to End of the text to delete.
* @param update Set to true if the internal state should be updated.
*/
void Textbuf::DeleteText(uint16 from, uint16 to, bool update)
{
uint c = 0;
const char *s = this->buf + from;
while (s < this->buf + to) {
Utf8Consume(&s);
c++;
}
/* Strip marked characters from buffer. */
memmove(this->buf + from, this->buf + to, this->bytes - to);
this->bytes -= to - from;
this->chars -= c;
/* Fixup caret if needed. */
if (this->caretpos > from) {
if (this->caretpos <= to) {
this->caretpos = from;
} else {
this->caretpos -= to - from;
}
}
if (update) {
this->UpdateStringIter();
this->UpdateCaretPosition();
this->UpdateMarkedText();
}
}
/** Handle WM_IME_COMPOSITION messages. */
static LRESULT HandleIMEComposition(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
HIMC hIMC = ImmGetContext(hwnd);
if (hIMC != NULL) {
if (lParam & GCS_RESULTSTR) {
/* Read result string from the IME. */
LONG len = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0); // Length is always in bytes, even in UNICODE build.
TCHAR *str = (TCHAR *)_alloca(len + sizeof(TCHAR));
len = ImmGetCompositionString(hIMC, GCS_RESULTSTR, str, len);
str[len / sizeof(TCHAR)] = '\0';
/* Transmit text to windowing system. */
if (len > 0) {
HandleTextInput(NULL, true); // Clear marked string.
HandleTextInput(FS2OTTD(str));
}
SetCompositionPos(hwnd);
/* Don't pass the result string on to the default window proc. */
lParam &= ~(GCS_RESULTSTR | GCS_RESULTCLAUSE | GCS_RESULTREADCLAUSE | GCS_RESULTREADSTR);
}
if ((lParam & GCS_COMPSTR) && DrawIMECompositionString()) {
/* Read composition string from the IME. */
LONG len = ImmGetCompositionString(hIMC, GCS_COMPSTR, NULL, 0); // Length is always in bytes, even in UNICODE build.
TCHAR *str = (TCHAR *)_alloca(len + sizeof(TCHAR));
len = ImmGetCompositionString(hIMC, GCS_COMPSTR, str, len);
str[len / sizeof(TCHAR)] = '\0';
if (len > 0) {
static char utf8_buf[1024];
convert_from_fs(str, utf8_buf, lengthof(utf8_buf));
/* Convert caret position from bytes in the input string to a position in the UTF-8 encoded string. */
LONG caret_bytes = ImmGetCompositionString(hIMC, GCS_CURSORPOS, NULL, 0);
const char *caret = utf8_buf;
for (const TCHAR *c = str; *c != '\0' && *caret != '\0' && caret_bytes > 0; c++, caret_bytes--) {
/* Skip DBCS lead bytes or leading surrogates. */
#ifdef UNICODE
if (Utf16IsLeadSurrogate(*c)) {
#else
if (IsDBCSLeadByte(*c)) {
#endif
c++;
caret_bytes--;
}
Utf8Consume(&caret);
}
HandleTextInput(utf8_buf, true, caret);
} else {
HandleTextInput(NULL, true);
}
lParam &= ~(GCS_COMPSTR | GCS_COMPATTR | GCS_COMPCLAUSE | GCS_CURSORPOS | GCS_DELTASTART);
}
}
/**
* Insert a string into the text buffer. If maxwidth of the Textbuf is zero,
* we don't care about the visual-length but only about the physical
* length of the string.
* @param str String to insert.
* @param marked Replace the currently marked text with the new text.
* @param caret Move the caret to this point in the insertion string.
* @param insert_location Position at which to insert the string.
* @param replacement_end Replace all characters from #insert_location up to this location with the new string.
* @return True on successful change of Textbuf, or false otherwise.
*/
bool Textbuf::InsertString(const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end)
{
uint16 insertpos = (marked && this->marklength != 0) ? this->markpos : this->caretpos;
if (insert_location != NULL) {
insertpos = insert_location - this->buf;
if (insertpos > this->bytes) return false;
if (replacement_end != NULL) {
this->DeleteText(insertpos, replacement_end - this->buf, str == NULL);
}
} else {
if (marked) this->DiscardMarkedText(str == NULL);
}
if (str == NULL) return false;
uint16 bytes = 0, chars = 0;
WChar c;
for (const char *ptr = str; (c = Utf8Consume(&ptr)) != '\0';) {
if (!IsValidChar(c, this->afilter)) break;
byte len = Utf8CharLen(c);
if (this->bytes + bytes + len > this->max_bytes) break;
if (this->chars + chars + 1 > this->max_chars) break;
bytes += len;
chars++;
/* Move caret if needed. */
if (ptr == caret) this->caretpos = insertpos + bytes;
}
if (bytes == 0) return false;
if (marked) {
this->markpos = insertpos;
this->markend = insertpos + bytes;
}
memmove(this->buf + insertpos + bytes, this->buf + insertpos, this->bytes - insertpos);
memcpy(this->buf + insertpos, str, bytes);
this->bytes += bytes;
this->chars += chars;
if (!marked && caret == NULL) this->caretpos += bytes;
assert(this->bytes <= this->max_bytes);
assert(this->chars <= this->max_chars);
this->buf[this->bytes - 1] = '\0'; // terminating zero
this->UpdateStringIter();
this->UpdateWidth();
this->UpdateCaretPosition();
this->UpdateMarkedText();
return true;
}
static inline void GetLayouter(Layouter::LineCacheItem &line, const char *&str, FontState &state)
{
if (line.buffer != NULL) free(line.buffer);
typename T::CharType *buff_begin = MallocT<typename T::CharType>(DRAW_STRING_BUFFER);
const typename T::CharType *buffer_last = buff_begin + DRAW_STRING_BUFFER;
typename T::CharType *buff = buff_begin;
FontMap &fontMapping = line.runs;
Font *f = Layouter::GetFont(state.fontsize, state.cur_colour);
line.buffer = buff_begin;
fontMapping.Clear();
/*
* Go through the whole string while adding Font instances to the font map
* whenever the font changes, and convert the wide characters into a format
* usable by ParagraphLayout.
*/
for (; buff < buffer_last;) {
WChar c = Utf8Consume(const_cast<const char **>(&str));
if (c == '\0' || c == '\n') {
break;
} else if (c >= SCC_BLUE && c <= SCC_BLACK) {
state.SetColour((TextColour)(c - SCC_BLUE));
} else if (c == SCC_PUSH_COLOUR) {
state.PushColour();
} else if (c == SCC_POP_COLOUR) {
state.PopColour();
} else if (c >= SCC_FIRST_FONT && c <= SCC_LAST_FONT) {
state.SetFontSize((FontSize)(c - SCC_FIRST_FONT));
} else {
/* Filter out text direction characters that shouldn't be drawn, and
* will not be handled in the fallback non ICU case because they are
* mostly needed for RTL languages which need more ICU support. */
if (!T::SUPPORTS_RTL && IsTextDirectionChar(c)) continue;
buff += T::AppendToBuffer(buff, buffer_last, c);
continue;
}
if (!fontMapping.Contains(buff - buff_begin)) {
fontMapping.Insert(buff - buff_begin, f);
}
f = Layouter::GetFont(state.fontsize, state.cur_colour);
}
/* Better safe than sorry. */
*buff = '\0';
if (!fontMapping.Contains(buff - buff_begin)) {
fontMapping.Insert(buff - buff_begin, f);
}
line.layout = T::GetParagraphLayout(buff_begin, buff, fontMapping);
line.state_after = state;
}
/**
* Retrieve keyboard layout from language string or (if set) config file.
* Also check for invalid characters.
*/
void GetKeyboardLayout()
{
char keyboard[2][OSK_KEYBOARD_ENTRIES * 4 + 1];
char errormark[2][OSK_KEYBOARD_ENTRIES + 1]; // used for marking invalid chars
bool has_error = false; // true when an invalid char is detected
if (StrEmpty(_keyboard_opt[0])) {
GetString(keyboard[0], STR_OSK_KEYBOARD_LAYOUT, lastof(keyboard[0]));
} else {
strecpy(keyboard[0], _keyboard_opt[0], lastof(keyboard[0]));
}
if (StrEmpty(_keyboard_opt[1])) {
GetString(keyboard[1], STR_OSK_KEYBOARD_LAYOUT_CAPS, lastof(keyboard[1]));
} else {
strecpy(keyboard[1], _keyboard_opt[1], lastof(keyboard[1]));
}
for (uint j = 0; j < 2; j++) {
const char *kbd = keyboard[j];
bool ended = false;
for (uint i = 0; i < OSK_KEYBOARD_ENTRIES; i++) {
_keyboard[j][i] = Utf8Consume(&kbd);
/* Be lenient when the last characters are missing (is quite normal) */
if (_keyboard[j][i] == '\0' || ended) {
ended = true;
_keyboard[j][i] = ' ';
continue;
}
if (IsPrintable(_keyboard[j][i])) {
errormark[j][i] = ' ';
} else {
has_error = true;
errormark[j][i] = '^';
_keyboard[j][i] = ' ';
}
}
}
if (has_error) {
ShowInfoF("The keyboard layout you selected contains invalid chars. Please check those chars marked with ^.");
ShowInfoF("Normal keyboard: %s", keyboard[0]);
ShowInfoF(" %s", errormark[0]);
ShowInfoF("Caps Lock: %s", keyboard[1]);
ShowInfoF(" %s", errormark[1]);
}
}
static bool DrawScrollingStatusText(const NewsItem *ni, int scroll_pos, int left, int right, int top, int bottom)
{
CopyInDParam(0, ni->params, lengthof(ni->params));
StringID str = ni->string_id;
char buf[512];
GetString(buf, str, lastof(buf));
const char *s = buf;
char buffer[256];
char *d = buffer;
const char *last = lastof(buffer);
for (;;) {
WChar c = Utf8Consume(&s);
if (c == 0) {
break;
} else if (c == '\n') {
if (d + 4 >= last) break;
d[0] = d[1] = d[2] = d[3] = ' ';
d += 4;
} else if (IsPrintable(c)) {
if (d + Utf8CharLen(c) >= last) break;
d += Utf8Encode(d, c);
}
}
*d = '\0';
DrawPixelInfo tmp_dpi;
if (!FillDrawPixelInfo(&tmp_dpi, left, top, right - left, bottom)) return true;
int width = GetStringBoundingBox(buffer).width;
int pos = (_current_text_dir == TD_RTL) ? (scroll_pos - width) : (right - scroll_pos - left);
DrawPixelInfo *old_dpi = _cur_dpi;
_cur_dpi = &tmp_dpi;
DrawString(pos, INT16_MAX, 0, buffer, TC_LIGHT_BLUE, SA_LEFT | SA_FORCE);
_cur_dpi = old_dpi;
return (_current_text_dir == TD_RTL) ? (pos < right - left) : (pos + width > 0);
}
/**
* Update Textbuf type with its actual physical character and screenlength
* Get the count of characters in the string as well as the width in pixels.
* Useful when copying in a larger amount of text at once
*/
void Textbuf::UpdateSize()
{
const char *buf = this->buf;
this->chars = this->bytes = 1; // terminating zero
WChar c;
while ((c = Utf8Consume(&buf)) != '\0') {
this->bytes += Utf8CharLen(c);
this->chars++;
}
assert(this->bytes <= this->max_bytes);
assert(this->chars <= this->max_chars);
this->caretpos = this->bytes - 1;
this->UpdateStringIter();
this->UpdateWidth();
this->UpdateMarkedText();
this->UpdateCaretPosition();
}
virtual void SetString(const char *s)
{
const char *string_base = s;
/* Unfortunately current ICU versions only provide rudimentary support
* for word break iterators (especially for CJK languages) in combination
* with UTF-8 input. As a work around we have to convert the input to
* UTF-16 and create a mapping back to UTF-8 character indices. */
this->utf16_str.Clear();
this->utf16_to_utf8.Clear();
while (*s != '\0') {
size_t idx = s - string_base;
WChar c = Utf8Consume(&s);
if (c < 0x10000) {
*this->utf16_str.Append() = (UChar)c;
} else {
/* Make a surrogate pair. */
*this->utf16_str.Append() = (UChar)(0xD800 + ((c - 0x10000) >> 10));
*this->utf16_str.Append() = (UChar)(0xDC00 + ((c - 0x10000) & 0x3FF));
*this->utf16_to_utf8.Append() = idx;
}
*this->utf16_to_utf8.Append() = idx;
}
*this->utf16_str.Append() = '\0';
*this->utf16_to_utf8.Append() = s - string_base;
UText text = UTEXT_INITIALIZER;
UErrorCode status = U_ZERO_ERROR;
utext_openUChars(&text, this->utf16_str.Begin(), this->utf16_str.Length() - 1, &status);
this->char_itr->setText(&text, status);
this->word_itr->setText(&text, status);
this->char_itr->first();
this->word_itr->first();
}
/**
* FormatString for NewGRF specific "magic" string control codes
* @param scc the string control code that has been read
* @param buff the buffer we're writing to
* @param str the string that we need to write
* @param argv the OpenTTD stack of values
* @return the string control code to "execute" now
*/
uint RemapNewGRFStringControlCode(uint scc, char *buf_start, char **buff, const char **str, int64 *argv)
{
if (_newgrf_textrefstack->used) {
switch (scc) {
default: NOT_REACHED();
case SCC_NEWGRF_PRINT_SIGNED_BYTE: *argv = _newgrf_textrefstack->PopSignedByte(); break;
case SCC_NEWGRF_PRINT_SIGNED_WORD: *argv = _newgrf_textrefstack->PopSignedWord(); break;
case SCC_NEWGRF_PRINT_QWORD_CURRENCY: *argv = _newgrf_textrefstack->PopUnsignedQWord(); break;
case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
case SCC_NEWGRF_PRINT_DWORD: *argv = _newgrf_textrefstack->PopSignedDWord(); break;
case SCC_NEWGRF_PRINT_HEX_BYTE: *argv = _newgrf_textrefstack->PopUnsignedByte(); break;
case SCC_NEWGRF_PRINT_HEX_DWORD: *argv = _newgrf_textrefstack->PopUnsignedDWord(); break;
case SCC_NEWGRF_PRINT_HEX_QWORD: *argv = _newgrf_textrefstack->PopSignedQWord(); break;
case SCC_NEWGRF_PRINT_HEX_WORD:
case SCC_NEWGRF_PRINT_WORD_SPEED:
case SCC_NEWGRF_PRINT_WORD_LITRES:
case SCC_NEWGRF_PRINT_UNSIGNED_WORD: *argv = _newgrf_textrefstack->PopUnsignedWord(); break;
case SCC_NEWGRF_PRINT_DATE:
case SCC_NEWGRF_PRINT_MONTH_YEAR: *argv = _newgrf_textrefstack->PopSignedWord() + DAYS_TILL_ORIGINAL_BASE_YEAR; break;
case SCC_NEWGRF_DISCARD_WORD: _newgrf_textrefstack->PopUnsignedWord(); break;
case SCC_NEWGRF_ROTATE_TOP_4_WORDS: _newgrf_textrefstack->RotateTop4Words(); break;
case SCC_NEWGRF_PUSH_WORD: _newgrf_textrefstack->PushWord(Utf8Consume(str)); break;
case SCC_NEWGRF_UNPRINT: *buff = max(*buff - Utf8Consume(str), buf_start); break;
case SCC_NEWGRF_PRINT_STRING_ID:
*argv = TTDPStringIDToOTTDStringIDMapping(_newgrf_textrefstack->PopUnsignedWord());
break;
}
}
switch (scc) {
default: NOT_REACHED();
case SCC_NEWGRF_PRINT_DWORD:
case SCC_NEWGRF_PRINT_SIGNED_WORD:
case SCC_NEWGRF_PRINT_SIGNED_BYTE:
case SCC_NEWGRF_PRINT_UNSIGNED_WORD:
return SCC_COMMA;
case SCC_NEWGRF_PRINT_HEX_BYTE:
case SCC_NEWGRF_PRINT_HEX_WORD:
case SCC_NEWGRF_PRINT_HEX_DWORD:
case SCC_NEWGRF_PRINT_HEX_QWORD:
return SCC_HEX;
case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
case SCC_NEWGRF_PRINT_QWORD_CURRENCY:
return SCC_CURRENCY;
case SCC_NEWGRF_PRINT_STRING_ID:
return SCC_STRING1;
case SCC_NEWGRF_PRINT_DATE:
return SCC_DATE_LONG;
case SCC_NEWGRF_PRINT_MONTH_YEAR:
return SCC_DATE_TINY;
case SCC_NEWGRF_PRINT_WORD_SPEED:
return SCC_VELOCITY;
case SCC_NEWGRF_PRINT_WORD_LITRES:
return SCC_VOLUME;
case SCC_NEWGRF_DISCARD_WORD:
case SCC_NEWGRF_ROTATE_TOP_4_WORDS:
case SCC_NEWGRF_PUSH_WORD:
case SCC_NEWGRF_UNPRINT:
return 0;
}
}
char *TranslateTTDPatchCodes(uint32 grfid, const char *str)
{
char *tmp = MallocT<char>(strlen(str) * 10 + 1); // Allocate space to allow for expansion
char *d = tmp;
bool unicode = false;
WChar c;
size_t len = Utf8Decode(&c, str);
if (c == 0x00DE) {
/* The thorn ('þ') indicates a unicode string to TTDPatch */
unicode = true;
str += len;
}
for (;;) {
if (unicode && Utf8EncodedCharLen(*str) != 0) {
c = Utf8Consume(&str);
/* 'Magic' range of control codes. */
if (GB(c, 8, 8) == 0xE0) {
c = GB(c, 0, 8);
} else if (c >= 0x20) {
if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';
d += Utf8Encode(d, c);
continue;
}
} else {
c = (byte)*str++;
}
if (c == 0) break;
switch (c) {
case 0x01:
d += Utf8Encode(d, SCC_SETX);
*d++ = *str++;
break;
case 0x0A: break;
case 0x0D: *d++ = 0x0A; break;
case 0x0E: d += Utf8Encode(d, SCC_TINYFONT); break;
case 0x0F: d += Utf8Encode(d, SCC_BIGFONT); break;
case 0x1F:
d += Utf8Encode(d, SCC_SETXY);
*d++ = *str++;
*d++ = *str++;
break;
case 0x7B:
case 0x7C:
case 0x7D:
case 0x7E:
case 0x7F:
case 0x80: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD + c - 0x7B); break;
case 0x81: {
StringID string;
string = ((uint8)*str++);
string |= ((uint8)*str++) << 8;
d += Utf8Encode(d, SCC_STRING_ID);
d += Utf8Encode(d, MapGRFStringID(grfid, string));
break;
}
case 0x82:
case 0x83:
case 0x84: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_SPEED + c - 0x82); break;
case 0x85: d += Utf8Encode(d, SCC_NEWGRF_DISCARD_WORD); break;
case 0x86: d += Utf8Encode(d, SCC_NEWGRF_ROTATE_TOP_4_WORDS); break;
case 0x87: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_LITRES); break;
case 0x88: d += Utf8Encode(d, SCC_BLUE); break;
case 0x89: d += Utf8Encode(d, SCC_SILVER); break;
case 0x8A: d += Utf8Encode(d, SCC_GOLD); break;
case 0x8B: d += Utf8Encode(d, SCC_RED); break;
case 0x8C: d += Utf8Encode(d, SCC_PURPLE); break;
case 0x8D: d += Utf8Encode(d, SCC_LTBROWN); break;
case 0x8E: d += Utf8Encode(d, SCC_ORANGE); break;
case 0x8F: d += Utf8Encode(d, SCC_GREEN); break;
case 0x90: d += Utf8Encode(d, SCC_YELLOW); break;
case 0x91: d += Utf8Encode(d, SCC_DKGREEN); break;
case 0x92: d += Utf8Encode(d, SCC_CREAM); break;
case 0x93: d += Utf8Encode(d, SCC_BROWN); break;
case 0x94: d += Utf8Encode(d, SCC_WHITE); break;
case 0x95: d += Utf8Encode(d, SCC_LTBLUE); break;
case 0x96: d += Utf8Encode(d, SCC_GRAY); break;
case 0x97: d += Utf8Encode(d, SCC_DKBLUE); break;
case 0x98: d += Utf8Encode(d, SCC_BLACK); break;
case 0x9A:
switch (*str++) {
case 0: // FALL THROUGH
case 1:
d += Utf8Encode(d, SCC_NEWGRF_PRINT_QWORD_CURRENCY);
break;
case 3: {
uint16 tmp = ((uint8)*str++);
tmp |= ((uint8)*str++) << 8;
d += Utf8Encode(d, SCC_NEWGRF_PUSH_WORD);
d += Utf8Encode(d, tmp);
} break;
case 4:
d += Utf8Encode(d, SCC_NEWGRF_UNPRINT);
d += Utf8Encode(d, *str++);
break;
case 6:
d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_BYTE);
break;
case 7:
d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_WORD);
break;
case 8:
d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_DWORD);
break;
case 0x0B:
d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_QWORD);
break;
default:
grfmsg(1, "missing handler for extended format code");
break;
}
break;
case 0x9E: d += Utf8Encode(d, 0x20AC); break; // Euro
case 0x9F: d += Utf8Encode(d, 0x0178); break; // Y with diaeresis
case 0xA0: d += Utf8Encode(d, SCC_UPARROW); break;
case 0xAA: d += Utf8Encode(d, SCC_DOWNARROW); break;
case 0xAC: d += Utf8Encode(d, SCC_CHECKMARK); break;
case 0xAD: d += Utf8Encode(d, SCC_CROSS); break;
case 0xAF: d += Utf8Encode(d, SCC_RIGHTARROW); break;
case 0xB4: d += Utf8Encode(d, SCC_TRAIN); break;
case 0xB5: d += Utf8Encode(d, SCC_LORRY); break;
case 0xB6: d += Utf8Encode(d, SCC_BUS); break;
case 0xB7: d += Utf8Encode(d, SCC_PLANE); break;
case 0xB8: d += Utf8Encode(d, SCC_SHIP); break;
case 0xB9: d += Utf8Encode(d, SCC_SUPERSCRIPT_M1); break;
case 0xBC: d += Utf8Encode(d, SCC_SMALLUPARROW); break;
case 0xBD: d += Utf8Encode(d, SCC_SMALLDOWNARROW); break;
default:
/* Validate any unhandled character */
if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';
d += Utf8Encode(d, c);
break;
}
}
*d = '\0';
tmp = ReallocT(tmp, strlen(tmp) + 1);
return tmp;
}
/**
* FormatString for NewGRF specific "magic" string control codes
* @param scc the string control code that has been read
* @param buff the buffer we're writing to
* @param str the string that we need to write
* @param argv the OpenTTD stack of values
* @param modify_argv When true, modify the OpenTTD stack.
* @return the string control code to "execute" now
*/
uint RemapNewGRFStringControlCode(uint scc, char *buf_start, char **buff, const char **str, int64 *argv, bool modify_argv)
{
if (_newgrf_textrefstack.used && modify_argv) {
switch (scc) {
default: NOT_REACHED();
case SCC_NEWGRF_PRINT_BYTE_SIGNED: *argv = _newgrf_textrefstack.PopSignedByte(); break;
case SCC_NEWGRF_PRINT_QWORD_CURRENCY: *argv = _newgrf_textrefstack.PopSignedQWord(); break;
case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
case SCC_NEWGRF_PRINT_DWORD_SIGNED: *argv = _newgrf_textrefstack.PopSignedDWord(); break;
case SCC_NEWGRF_PRINT_BYTE_HEX: *argv = _newgrf_textrefstack.PopUnsignedByte(); break;
case SCC_NEWGRF_PRINT_QWORD_HEX: *argv = _newgrf_textrefstack.PopUnsignedQWord(); break;
case SCC_NEWGRF_PRINT_WORD_SPEED:
case SCC_NEWGRF_PRINT_WORD_VOLUME_LONG:
case SCC_NEWGRF_PRINT_WORD_VOLUME_SHORT:
case SCC_NEWGRF_PRINT_WORD_SIGNED: *argv = _newgrf_textrefstack.PopSignedWord(); break;
case SCC_NEWGRF_PRINT_WORD_HEX:
case SCC_NEWGRF_PRINT_WORD_WEIGHT_LONG:
case SCC_NEWGRF_PRINT_WORD_WEIGHT_SHORT:
case SCC_NEWGRF_PRINT_WORD_POWER:
case SCC_NEWGRF_PRINT_WORD_STATION_NAME:
case SCC_NEWGRF_PRINT_WORD_UNSIGNED: *argv = _newgrf_textrefstack.PopUnsignedWord(); break;
case SCC_NEWGRF_PRINT_DWORD_DATE_LONG:
case SCC_NEWGRF_PRINT_DWORD_DATE_SHORT:
case SCC_NEWGRF_PRINT_DWORD_HEX: *argv = _newgrf_textrefstack.PopUnsignedDWord(); break;
case SCC_NEWGRF_PRINT_WORD_DATE_LONG:
case SCC_NEWGRF_PRINT_WORD_DATE_SHORT: *argv = _newgrf_textrefstack.PopUnsignedWord() + DAYS_TILL_ORIGINAL_BASE_YEAR; break;
case SCC_NEWGRF_DISCARD_WORD: _newgrf_textrefstack.PopUnsignedWord(); break;
case SCC_NEWGRF_ROTATE_TOP_4_WORDS: _newgrf_textrefstack.RotateTop4Words(); break;
case SCC_NEWGRF_PUSH_WORD: _newgrf_textrefstack.PushWord(Utf8Consume(str)); break;
case SCC_NEWGRF_UNPRINT: *buff = max(*buff - Utf8Consume(str), buf_start); break;
case SCC_NEWGRF_PRINT_WORD_STRING_ID:
*argv = TTDPStringIDToOTTDStringIDMapping(_newgrf_textrefstack.PopUnsignedWord());
break;
}
}
switch (scc) {
default: NOT_REACHED();
case SCC_NEWGRF_PRINT_DWORD_SIGNED:
case SCC_NEWGRF_PRINT_WORD_SIGNED:
case SCC_NEWGRF_PRINT_BYTE_SIGNED:
case SCC_NEWGRF_PRINT_WORD_UNSIGNED:
return SCC_COMMA;
case SCC_NEWGRF_PRINT_BYTE_HEX:
case SCC_NEWGRF_PRINT_WORD_HEX:
case SCC_NEWGRF_PRINT_DWORD_HEX:
case SCC_NEWGRF_PRINT_QWORD_HEX:
return SCC_HEX;
case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
case SCC_NEWGRF_PRINT_QWORD_CURRENCY:
return SCC_CURRENCY_LONG;
case SCC_NEWGRF_PRINT_WORD_STRING_ID:
return SCC_NEWGRF_PRINT_WORD_STRING_ID;
case SCC_NEWGRF_PRINT_WORD_DATE_LONG:
case SCC_NEWGRF_PRINT_DWORD_DATE_LONG:
return SCC_DATE_LONG;
case SCC_NEWGRF_PRINT_WORD_DATE_SHORT:
case SCC_NEWGRF_PRINT_DWORD_DATE_SHORT:
return SCC_DATE_SHORT;
case SCC_NEWGRF_PRINT_WORD_SPEED:
return SCC_VELOCITY;
case SCC_NEWGRF_PRINT_WORD_VOLUME_LONG:
return SCC_VOLUME_LONG;
case SCC_NEWGRF_PRINT_WORD_VOLUME_SHORT:
return SCC_VOLUME_SHORT;
case SCC_NEWGRF_PRINT_WORD_WEIGHT_LONG:
return SCC_WEIGHT_LONG;
case SCC_NEWGRF_PRINT_WORD_WEIGHT_SHORT:
return SCC_WEIGHT_SHORT;
case SCC_NEWGRF_PRINT_WORD_POWER:
return SCC_POWER;
case SCC_NEWGRF_PRINT_WORD_STATION_NAME:
return SCC_STATION_NAME;
case SCC_NEWGRF_DISCARD_WORD:
case SCC_NEWGRF_ROTATE_TOP_4_WORDS:
case SCC_NEWGRF_PUSH_WORD:
case SCC_NEWGRF_UNPRINT:
return 0;
}
}
/**
* Translate TTDPatch string codes into something OpenTTD can handle (better).
* @param grfid The (NewGRF) ID associated with this string
* @param language_id The (NewGRF) language ID associated with this string.
* @param allow_newlines Whether newlines are allowed in the string or not.
* @param str The string to translate.
* @param [out] olen The length of the final string.
* @param byte80 The control code to use as replacement for the 0x80-value.
* @return The translated string.
*/
char *TranslateTTDPatchCodes(uint32 grfid, uint8 language_id, bool allow_newlines, const char *str, int *olen, StringControlCode byte80)
{
char *tmp = MallocT<char>(strlen(str) * 10 + 1); // Allocate space to allow for expansion
char *d = tmp;
bool unicode = false;
WChar c;
size_t len = Utf8Decode(&c, str);
/* Helper variable for a possible (string) mapping. */
UnmappedChoiceList *mapping = NULL;
if (c == NFO_UTF8_IDENTIFIER) {
unicode = true;
str += len;
}
for (;;) {
if (unicode && Utf8EncodedCharLen(*str) != 0) {
c = Utf8Consume(&str);
/* 'Magic' range of control codes. */
if (GB(c, 8, 8) == 0xE0) {
c = GB(c, 0, 8);
} else if (c >= 0x20) {
if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';
d += Utf8Encode(d, c);
continue;
}
} else {
c = (byte)*str++;
}
if (c == '\0') break;
switch (c) {
case 0x01:
if (str[0] == '\0') goto string_end;
d += Utf8Encode(d, ' ');
str++;
break;
case 0x0A: break;
case 0x0D:
if (allow_newlines) {
*d++ = 0x0A;
} else {
grfmsg(1, "Detected newline in string that does not allow one");
}
break;
case 0x0E: d += Utf8Encode(d, SCC_TINYFONT); break;
case 0x0F: d += Utf8Encode(d, SCC_BIGFONT); break;
case 0x1F:
if (str[0] == '\0' || str[1] == '\0') goto string_end;
d += Utf8Encode(d, ' ');
str += 2;
break;
case 0x7B:
case 0x7C:
case 0x7D:
case 0x7E:
case 0x7F: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD_SIGNED + c - 0x7B); break;
case 0x80: d += Utf8Encode(d, byte80); break;
case 0x81: {
if (str[0] == '\0' || str[1] == '\0') goto string_end;
StringID string;
string = ((uint8)*str++);
string |= ((uint8)*str++) << 8;
d += Utf8Encode(d, SCC_NEWGRF_STRINL);
d += Utf8Encode(d, MapGRFStringID(grfid, string));
break;
}
case 0x82:
case 0x83:
case 0x84: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_DATE_LONG + c - 0x82); break;
case 0x85: d += Utf8Encode(d, SCC_NEWGRF_DISCARD_WORD); break;
case 0x86: d += Utf8Encode(d, SCC_NEWGRF_ROTATE_TOP_4_WORDS); break;
case 0x87: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_VOLUME_LONG); break;
case 0x88: d += Utf8Encode(d, SCC_BLUE); break;
case 0x89: d += Utf8Encode(d, SCC_SILVER); break;
case 0x8A: d += Utf8Encode(d, SCC_GOLD); break;
case 0x8B: d += Utf8Encode(d, SCC_RED); break;
case 0x8C: d += Utf8Encode(d, SCC_PURPLE); break;
case 0x8D: d += Utf8Encode(d, SCC_LTBROWN); break;
case 0x8E: d += Utf8Encode(d, SCC_ORANGE); break;
case 0x8F: d += Utf8Encode(d, SCC_GREEN); break;
case 0x90: d += Utf8Encode(d, SCC_YELLOW); break;
case 0x91: d += Utf8Encode(d, SCC_DKGREEN); break;
case 0x92: d += Utf8Encode(d, SCC_CREAM); break;
case 0x93: d += Utf8Encode(d, SCC_BROWN); break;
case 0x94: d += Utf8Encode(d, SCC_WHITE); break;
case 0x95: d += Utf8Encode(d, SCC_LTBLUE); break;
case 0x96: d += Utf8Encode(d, SCC_GRAY); break;
case 0x97: d += Utf8Encode(d, SCC_DKBLUE); break;
case 0x98: d += Utf8Encode(d, SCC_BLACK); break;
case 0x9A: {
int code = *str++;
switch (code) {
case 0x00: goto string_end;
case 0x01: d += Utf8Encode(d, SCC_NEWGRF_PRINT_QWORD_CURRENCY); break;
/* 0x02: ignore next colour byte is not supported. It works on the final
* string and as such hooks into the string drawing routine. At that
* point many things already happened, such as splitting up of strings
* when drawn over multiple lines or right-to-left translations, which
* make the behaviour peculiar, e.g. only happening at specific width
* of windows. Or we need to add another pass over the string to just
* support this. As such it is not implemented in OpenTTD. */
case 0x03: {
if (str[0] == '\0' || str[1] == '\0') goto string_end;
uint16 tmp = ((uint8)*str++);
tmp |= ((uint8)*str++) << 8;
d += Utf8Encode(d, SCC_NEWGRF_PUSH_WORD);
d += Utf8Encode(d, tmp);
break;
}
case 0x04:
if (str[0] == '\0') goto string_end;
d += Utf8Encode(d, SCC_NEWGRF_UNPRINT);
d += Utf8Encode(d, *str++);
break;
case 0x06: d += Utf8Encode(d, SCC_NEWGRF_PRINT_BYTE_HEX); break;
case 0x07: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_HEX); break;
case 0x08: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD_HEX); break;
/* 0x09, 0x0A are TTDPatch internal use only string codes. */
case 0x0B: d += Utf8Encode(d, SCC_NEWGRF_PRINT_QWORD_HEX); break;
case 0x0C: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_STATION_NAME); break;
case 0x0D: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_WEIGHT_LONG); break;
case 0x0E:
case 0x0F: {
if (str[0] == '\0') goto string_end;
const LanguageMap *lm = LanguageMap::GetLanguageMap(grfid, language_id);
int index = *str++;
int mapped = lm != NULL ? lm->GetMapping(index, code == 0x0E) : -1;
if (mapped >= 0) {
d += Utf8Encode(d, code == 0x0E ? SCC_GENDER_INDEX : SCC_SET_CASE);
d += Utf8Encode(d, code == 0x0E ? mapped : mapped + 1);
}
break;
}
case 0x10:
case 0x11:
if (str[0] == '\0') goto string_end;
if (mapping == NULL) {
if (code == 0x10) str++; // Skip the index
grfmsg(1, "choice list %s marker found when not expected", code == 0x10 ? "next" : "default");
break;
} else {
/* Terminate the previous string. */
*d = '\0';
int index = (code == 0x10 ? *str++ : 0);
if (mapping->strings.Contains(index)) {
grfmsg(1, "duplicate choice list string, ignoring");
d++;
} else {
d = mapping->strings[index] = MallocT<char>(strlen(str) * 10 + 1);
}
}
break;
case 0x12:
if (mapping == NULL) {
grfmsg(1, "choice list end marker found when not expected");
} else {
/* Terminate the previous string. */
*d = '\0';
/* Now we can start flushing everything and clean everything up. */
d = mapping->Flush(LanguageMap::GetLanguageMap(grfid, language_id));
delete mapping;
mapping = NULL;
}
break;
case 0x13:
case 0x14:
case 0x15:
if (str[0] == '\0') goto string_end;
if (mapping != NULL) {
grfmsg(1, "choice lists can't be stacked, it's going to get messy now...");
if (code != 0x14) str++;
} else {
static const StringControlCode mp[] = { SCC_GENDER_LIST, SCC_SWITCH_CASE, SCC_PLURAL_LIST };
mapping = new UnmappedChoiceList(mp[code - 0x13], d, code == 0x14 ? 0 : *str++);
}
break;
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1A: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD_DATE_LONG + code - 0x16); break;
default:
grfmsg(1, "missing handler for extended format code");
break;
}
break;
}
case 0x9E: d += Utf8Encode(d, 0x20AC); break; // Euro
case 0x9F: d += Utf8Encode(d, 0x0178); break; // Y with diaeresis
case 0xA0: d += Utf8Encode(d, SCC_UP_ARROW); break;
case 0xAA: d += Utf8Encode(d, SCC_DOWN_ARROW); break;
case 0xAC: d += Utf8Encode(d, SCC_CHECKMARK); break;
case 0xAD: d += Utf8Encode(d, SCC_CROSS); break;
case 0xAF: d += Utf8Encode(d, SCC_RIGHT_ARROW); break;
case 0xB4: d += Utf8Encode(d, SCC_TRAIN); break;
case 0xB5: d += Utf8Encode(d, SCC_LORRY); break;
case 0xB6: d += Utf8Encode(d, SCC_BUS); break;
case 0xB7: d += Utf8Encode(d, SCC_PLANE); break;
case 0xB8: d += Utf8Encode(d, SCC_SHIP); break;
case 0xB9: d += Utf8Encode(d, SCC_SUPERSCRIPT_M1); break;
case 0xBC: d += Utf8Encode(d, SCC_SMALL_UP_ARROW); break;
case 0xBD: d += Utf8Encode(d, SCC_SMALL_DOWN_ARROW); break;
default:
/* Validate any unhandled character */
if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';
d += Utf8Encode(d, c);
break;
}
}
string_end:
if (mapping != NULL) {
grfmsg(1, "choice list was incomplete, the whole list is ignored");
delete mapping;
}
*d = '\0';
if (olen != NULL) *olen = d - tmp + 1;
tmp = ReallocT(tmp, d - tmp + 1);
return tmp;
}