OpenTTD Source: src/gfx_layout.cpp Source File

OpenTTD Source 15.3

gfx_layout.cpp
Go to the documentation of this file.
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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
10#include "stdafx.h"
11#include "core/math_func.hpp"
12#include "gfx_layout.h"
13#include "string_func.h"
14#include "strings_func.h"
15#include "core/utf8.hpp"
16#include "debug.h"
17
18#include "table/control_codes.h"
19
20#include "gfx_layout_fallback.h"
21
22#if defined(WITH_ICU_I18N) && defined(WITH_HARFBUZZ)
23#include "gfx_layout_icu.h"
24#endif /* WITH_ICU_I18N && WITH_HARFBUZZ */
25
26#ifdef WITH_UNISCRIBE
27#include "os/windows/string_uniscribe.h"
28#endif /* WITH_UNISCRIBE */
29
30#ifdef WITH_COCOA
31#include "os/macosx/string_osx.h"
32#endif
33
34#include "safeguards.h"
35
36
38std::unique_ptr<Layouter::LineCache> Layouter::linecache;
39
41Layouter::FontColourMap Layouter::fonts[FS_END];
42
43
49Font::Font(FontSize size, TextColour colour) :
50 fc(FontCache::Get(size)), colour(colour)
51{
52 assert(size < FS_END);
53}
54
64template <typename T>
65 static inline void GetLayouter(Layouter::LineCacheItem &line, std::string_view str, FontState &state)
66{
67 typename T::CharType *buff_begin = new typename T::CharType[str.size() + 1];
68 /* Move ownership of buff_begin into the Buffer/unique_ptr. */
69 line.buffer = Layouter::LineCacheItem::Buffer(buff_begin, [](void *p) { delete[] reinterpret_cast<T::CharType *>(p); });
70
71 const typename T::CharType *buffer_last = buff_begin + str.size() + 1;
72 typename T::CharType *buff = buff_begin;
73 FontMap &font_mapping = line.runs;
74 Font *f = Layouter::GetFont(state.fontsize, state.cur_colour);
75
76 font_mapping.clear();
77
78 /*
79 * Go through the whole string while adding Font instances to the font map
80 * whenever the font changes, and convert the wide characters into a format
81 * usable by ParagraphLayout.
82 */
83 for (char32_t c : Utf8View(str)) {
84 if (c == '\0' || c == '\n') {
85 /* Caller should already have filtered out these characters. */
86 NOT_REACHED();
87 } else if (c >= SCC_BLUE && c <= SCC_BLACK) {
88 state.SetColour((TextColour)(c - SCC_BLUE));
89 } else if (c == SCC_PUSH_COLOUR) {
90 state.PushColour();
91 } else if (c == SCC_POP_COLOUR) {
92 state.PopColour();
93 } else if (c >= SCC_FIRST_FONT && c <= SCC_LAST_FONT) {
94 state.SetFontSize((FontSize)(c - SCC_FIRST_FONT));
95 } else {
96 /* Filter out non printable characters */
97 if (!IsPrintable(c)) continue;
98 /* Filter out text direction characters that shouldn't be drawn, and
99 * will not be handled in the fallback case because they are mostly
100 * needed for RTL languages which need more proper shaping support. */
101 if (!T::SUPPORTS_RTL && IsTextDirectionChar(c)) continue;
102 buff += T::AppendToBuffer(buff, buffer_last, c);
103 if (buff >= buffer_last) break;
104 continue;
105 }
106
107 if (font_mapping.empty() || font_mapping.back().first != buff - buff_begin) {
108 font_mapping.emplace_back(buff - buff_begin, f);
109 }
110 f = Layouter::GetFont(state.fontsize, state.cur_colour);
111 }
112
113 /* Better safe than sorry. */
114 *buff = '\0';
115
116 if (font_mapping.empty() || font_mapping.back().first != buff - buff_begin) {
117 font_mapping.emplace_back(buff - buff_begin, f);
118 }
119 line.layout = T::GetParagraphLayout(buff_begin, buff, font_mapping);
120 line.state_after = state;
121}
122
129Layouter::Layouter(std::string_view str, int maxw, FontSize fontsize) : string(str)
130{
131 FontState state(TC_INVALID, fontsize);
132
133 while (true) {
134 auto line_length = str.find_first_of('\n');
135 auto str_line = str.substr(0, line_length);
136
137 LineCacheItem &line = GetCachedParagraphLayout(str_line, state);
138 if (line.layout != nullptr) {
139 state = line.state_after;
140 line.layout->Reflow();
141 } else {
142 /* Line is new, layout it */
143 FontState old_state = state;
144
145#if defined(WITH_ICU_I18N) && defined(WITH_HARFBUZZ)
146 if (line.layout == nullptr) {
147 GetLayouter<ICUParagraphLayoutFactory>(line, str_line, state);
148 if (line.layout == nullptr) {
149 state = std::move(old_state);
150 }
151 }
152#endif
153
154#ifdef WITH_UNISCRIBE
155 if (line.layout == nullptr) {
156 GetLayouter<UniscribeParagraphLayoutFactory>(line, str_line, state);
157 if (line.layout == nullptr) {
158 state = std::move(old_state);
159 }
160 }
161#endif
162
163#ifdef WITH_COCOA
164 if (line.layout == nullptr) {
165 GetLayouter<CoreTextParagraphLayoutFactory>(line, str_line, state);
166 if (line.layout == nullptr) {
167 state = std::move(old_state);
168 }
169 }
170#endif
171
172 if (line.layout == nullptr) {
173 GetLayouter<FallbackParagraphLayoutFactory>(line, str_line, state);
174 }
175 }
176
177 if (line.cached_width != maxw) {
178 /* First run or width has changed, so we need to go through the layouter. Lines are moved into a cache to
179 * be reused if the width is not changed. */
180 line.cached_layout.clear();
181 line.cached_width = maxw;
182 for (;;) {
183 auto l = line.layout->NextLine(maxw);
184 if (l == nullptr) break;
185 line.cached_layout.push_back(std::move(l));
186 }
187 }
188
189 /* Retrieve layout from the cache. */
190 for (const auto &l : line.cached_layout) {
191 this->push_back(l.get());
192 }
193
194 /* Break out if this was the last line. */
195 if (line_length == std::string_view::npos) {
196 break;
197 }
198
199 /* Go to the next line. */
200 str.remove_prefix(line_length + 1);
201 }
202}
203
208 Dimension Layouter::GetBounds()
209{
210 Dimension d = { 0, 0 };
211 for (const auto &l : *this) {
212 d.width = std::max<uint>(d.width, l->GetWidth());
213 d.height += l->GetLeading();
214 }
215 return d;
216}
217
221 static bool IsConsumedFormattingCode(char32_t ch)
222{
223 if (ch >= SCC_BLUE && ch <= SCC_BLACK) return true;
224 if (ch == SCC_PUSH_COLOUR) return true;
225 if (ch == SCC_POP_COLOUR) return true;
226 if (ch >= SCC_FIRST_FONT && ch <= SCC_LAST_FONT) return true;
227 /* All other characters defined in Unicode standard are assumed to be non-consumed. */
228 return false;
229}
230
237 ParagraphLayouter::Position Layouter::GetCharPosition(std::string_view::const_iterator ch) const
238{
239 const auto &line = this->front();
240
241 /* Pointer to the end-of-string marker? Return total line width. */
242 if (ch == this->string.end()) {
243 Point p = {_current_text_dir == TD_LTR ? line->GetWidth() : 0, 0};
244 return p;
245 }
246
247 /* Initial position, returned if character not found. */
248 const ParagraphLayouter::Position initial_position = Point{_current_text_dir == TD_LTR ? 0 : line->GetWidth(), 0};
249
250 /* Find the code point index which corresponds to the char
251 * pointer into our UTF-8 source string. */
252 size_t index = 0;
253 {
254 Utf8View view(this->string);
255 const size_t offset = ch - this->string.begin();
256 const auto pos = view.GetIterAtByte(offset);
257
258 /* We couldn't find the code point index. */
259 if (pos.GetByteOffset() != offset) return initial_position;
260
261 for (auto it = view.begin(); it < pos; ++it) {
262 char32_t c = *it;
263 if (!IsConsumedFormattingCode(c)) index += line->GetInternalCharLength(c);
264 }
265 }
266
267 const ParagraphLayouter::Position *position = &initial_position;
268
269 /* Scan all runs until we've found our code point index. */
270 size_t best_index = SIZE_MAX;
271 for (int run_index = 0; run_index < line->CountRuns(); run_index++) {
272 const ParagraphLayouter::VisualRun &run = line->GetVisualRun(run_index);
273 const auto &positions = run.GetPositions();
274 const auto &charmap = run.GetGlyphToCharMap();
275
276 auto itp = positions.begin();
277 for (auto it = charmap.begin(); it != charmap.end(); ++it, ++itp) {
278 const size_t cur_index = static_cast<size_t>(*it);
279 /* Found exact character match? */
280 if (cur_index == index) return *itp;
281
282 /* If the character we are looking for has been combined with other characters to form a ligature then
283 * we may not be able to find an exact match. We don't actually know if our character is part of a
284 * ligature. In this case we will aim to select the first character of the ligature instead, so the best
285 * index is the index nearest to but lower than the desired index. */
286 if (cur_index < index && (best_index < cur_index || best_index == SIZE_MAX)) {
287 best_index = cur_index;
288 position = &*itp;
289 }
290 }
291 }
292
293 /* At the end of the run but still didn't find our character so probably a trailing ligature, use the last found position. */
294 return *position;
295}
296
303ptrdiff_t Layouter::GetCharAtPosition(int x, size_t line_index) const
304{
305 if (line_index >= this->size()) return -1;
306
307 const auto &line = this->at(line_index);
308
309 for (int run_index = 0; run_index < line->CountRuns(); run_index++) {
310 const ParagraphLayouter::VisualRun &run = line->GetVisualRun(run_index);
311 const auto &glyphs = run.GetGlyphs();
312 const auto &positions = run.GetPositions();
313 const auto &charmap = run.GetGlyphToCharMap();
314
315 for (int i = 0; i < run.GetGlyphCount(); i++) {
316 /* Not a valid glyph (empty). */
317 if (glyphs[i] == 0xFFFF) continue;
318
319 int begin_x = positions[i].left;
320 int end_x = positions[i].right + 1;
321
322 if (IsInsideMM(x, begin_x, end_x)) {
323 /* Found our glyph, now convert to UTF-8 string index. */
324 size_t index = charmap[i];
325
326 size_t cur_idx = 0;
327 Utf8View view(this->string);
328 for (auto it = view.begin(), end = view.end(); it != end; ++it) {
329 if (cur_idx == index) return it.GetByteOffset();
330
331 char32_t c = *it;
332 if (!IsConsumedFormattingCode(c)) cur_idx += line->GetInternalCharLength(c);
333 }
334 }
335 }
336 }
337
338 return -1;
339}
340
344 Font *Layouter::GetFont(FontSize size, TextColour colour)
345{
346 FontColourMap::iterator it = fonts[size].find(colour);
347 if (it != fonts[size].end()) return it->second.get();
348
349 fonts[size][colour] = std::make_unique<Font>(size, colour);
350 return fonts[size][colour].get();
351}
352
356 void Layouter::Initialize()
357{
358#if defined(WITH_ICU_I18N) && defined(WITH_HARFBUZZ)
359 ICUParagraphLayoutFactory::InitializeLayouter();
360#endif /* WITH_ICU_I18N && WITH_HARFBUZZ */
361}
362
367 void Layouter::ResetFontCache(FontSize size)
368{
369 fonts[size].clear();
370
371 /* We must reset the linecache since it references the just freed fonts */
372 ResetLineCache();
373
374#if defined(WITH_UNISCRIBE)
375 UniscribeResetScriptCache(size);
376#endif
377#if defined(WITH_COCOA)
378 MacOSResetScriptCache(size);
379#endif
380}
381
389 Layouter::LineCacheItem &Layouter::GetCachedParagraphLayout(std::string_view str, const FontState &state)
390{
391 if (linecache == nullptr) {
392 /* Create linecache on first access to avoid trouble with initialisation order of static variables. */
393 linecache = std::make_unique<LineCache>(4096);
394 }
395
396 if (auto match = linecache->GetIfValid(LineCacheQuery{state, str});
397 match != nullptr) {
398 return *match;
399 }
400
401 /* Create missing entry */
402 LineCacheKey key;
403 key.state_before = state;
404 key.str.assign(str);
405 linecache->Insert(key, {});
406 return *linecache->GetIfValid(key);
407}
408
412 void Layouter::ResetLineCache()
413{
414 if (linecache != nullptr) linecache->Clear();
415}
416
425 ParagraphLayouter::Position GetCharPosInString(std::string_view str, size_t pos, FontSize start_fontsize)
426{
427 assert(pos <= str.size());
428 auto it_ch = str.begin() + pos;
429
430 Layouter layout(str, INT32_MAX, start_fontsize);
431 return layout.GetCharPosition(it_ch);
432}
433
441ptrdiff_t GetCharAtPosition(std::string_view str, int x, FontSize start_fontsize)
442{
443 if (x < 0) return -1;
444
445 Layouter layout(str, INT32_MAX, start_fontsize);
446 return layout.GetCharAtPosition(x, 0);
447}
FontCache
Font cache for basic fonts.
Definition fontcache.h:22
Font
Container with information about a font.
Definition gfx_layout.h:97
Font::Font
Font(FontSize size, TextColour colour)
Construct a new font.
Definition gfx_layout.cpp:49
ICUParagraphLayoutFactory::InitializeLayouter
static void InitializeLayouter()
Initialize data needed for the ICU layouter.
Definition gfx_layout_icu.cpp:385
Layouter
The layouter performs all the layout work.
Definition gfx_layout.h:160
Layouter::Initialize
static void Initialize()
Perform initialization of layout engine.
Definition gfx_layout.cpp:356
Layouter::fonts
static FontColourMap fonts[FS_END]
Cache of Font instances.
Definition gfx_layout.h:209
Layouter::Layouter
Layouter(std::string_view str, int maxw=INT32_MAX, FontSize fontsize=FS_NORMAL)
Create a new layouter.
Definition gfx_layout.cpp:129
Layouter::GetCharAtPosition
ptrdiff_t GetCharAtPosition(int x, size_t line_index) const
Get the character that is at a pixel position in the first line of the layouted text.
Definition gfx_layout.cpp:303
Layouter::ResetFontCache
static void ResetFontCache(FontSize size)
Reset cached font information.
Definition gfx_layout.cpp:367
Layouter::GetCharPosition
ParagraphLayouter::Position GetCharPosition(std::string_view::const_iterator ch) const
Get the position of a character in the layout.
Definition gfx_layout.cpp:237
Layouter::linecache
static std::unique_ptr< LineCache > linecache
Cache of ParagraphLayout lines.
Definition gfx_layout.h:204
Layouter::GetFont
static Font * GetFont(FontSize size, TextColour colour)
Get a static font instance.
Definition gfx_layout.cpp:344
Layouter::ResetLineCache
static void ResetLineCache()
Clear line cache.
Definition gfx_layout.cpp:412
Layouter::GetBounds
Dimension GetBounds()
Get the boundaries of this paragraph.
Definition gfx_layout.cpp:208
Layouter::GetCachedParagraphLayout
static LineCacheItem & GetCachedParagraphLayout(std::string_view str, const FontState &state)
Get reference to cache item.
Definition gfx_layout.cpp:389
ParagraphLayouter::Position
Position of a glyph within a VisualRun.
Definition gfx_layout.h:116
ParagraphLayouter::VisualRun
Visual run contains data about the bit of text with the same font.
Definition gfx_layout.h:129
Utf8View
Constant span of UTF-8 encoded data.
Definition utf8.hpp:30
Utf8View::GetIterAtByte
iterator GetIterAtByte(size_t offset) const
Create iterator pointing at codepoint, which occupies the byte position "offset".
Definition utf8.cpp:83
control_codes.h
Control codes that are embedded in the translation strings.
debug.h
Functions related to debugging.
GetCharPosInString
ParagraphLayouter::Position GetCharPosInString(std::string_view str, size_t pos, FontSize start_fontsize)
Get the leading corner of a character in a single-line string relative to the start of the string.
Definition gfx_layout.cpp:425
IsConsumedFormattingCode
static bool IsConsumedFormattingCode(char32_t ch)
Test whether a character is a non-printable formatting code.
Definition gfx_layout.cpp:221
GetLayouter
static void GetLayouter(Layouter::LineCacheItem &line, std::string_view str, FontState &state)
Helper for getting a ParagraphLayouter of the given type.
Definition gfx_layout.cpp:65
GetCharAtPosition
ptrdiff_t GetCharAtPosition(std::string_view str, int x, FontSize start_fontsize)
Get the character from a string that is drawn at a specific position.
Definition gfx_layout.cpp:441
gfx_layout.h
Functions related to laying out the texts.
FontMap
std::vector< std::pair< int, Font * > > FontMap
Mapping from index to font.
Definition gfx_layout.h:106
gfx_layout_fallback.h
Functions related to laying out the texts as fallback.
gfx_layout_icu.h
Functions related to laying out the texts with ICU.
FontSize
FontSize
Available font sizes.
Definition gfx_type.h:248
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition gfx_type.h:307
math_func.hpp
Integer math functions.
IsInsideMM
constexpr bool IsInsideMM(const size_t x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
Definition math_func.hpp:267
safeguards.h
A number of safeguards to prevent using unsafe methods.
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
string_func.h
Functions related to low-level strings.
IsTextDirectionChar
bool IsTextDirectionChar(char32_t c)
Is the given character a text direction character.
Definition string_func.h:111
MacOSResetScriptCache
void MacOSResetScriptCache(FontSize size)
Delete CoreText font reference for a specific font size.
Definition string_osx.cpp:299
string_osx.h
Functions related to localized text support on OSX.
string_uniscribe.h
Functions related to laying out text on Win32.
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition strings.cpp:56
strings_func.h
Functions related to OTTD's strings.
TD_LTR
@ TD_LTR
Text is written left-to-right by default.
Definition strings_type.h:26
Coord2D< int >
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition geometry_type.hpp:56
FontState
Text drawing parameters, which can change while drawing a line, but are kept between multiple parts o...
Definition gfx_layout.h:24
FontState::PushColour
void PushColour()
Push the current colour on to the stack.
Definition gfx_layout.h:58
FontState::SetColour
void SetColour(TextColour c)
Switch to new colour c.
Definition gfx_layout.h:38
FontState::PopColour
void PopColour()
Switch to and pop the last saved colour on the stack.
Definition gfx_layout.h:48
FontState::SetFontSize
void SetFontSize(FontSize f)
Switch to using a new font f.
Definition gfx_layout.h:67
FontState::fontsize
FontSize fontsize
Current font size.
Definition gfx_layout.h:25
FontState::cur_colour
TextColour cur_colour
Current text colour.
Definition gfx_layout.h:26
Layouter::LineCacheItem
Item in the linecache.
Definition gfx_layout.h:189
Layouter::LineCacheItem::runs
FontMap runs
Accessed by our ParagraphLayout::nextLine.
Definition gfx_layout.h:194
Layouter::LineCacheItem::buffer
Buffer buffer
Accessed by our ParagraphLayout::nextLine.
Definition gfx_layout.h:193
Layouter::LineCacheItem::cached_width
int cached_width
Width used for the cached layout.
Definition gfx_layout.h:200
Layouter::LineCacheItem::cached_layout
std::vector< std::unique_ptr< const ParagraphLayouter::Line > > cached_layout
Cached results of line layouting.
Definition gfx_layout.h:199
Layouter::LineCacheItem::state_after
FontState state_after
Font state after the line.
Definition gfx_layout.h:196
Layouter::LineCacheItem::layout
std::unique_ptr< ParagraphLayouter > layout
Layout of the line.
Definition gfx_layout.h:197
Layouter::LineCacheKey
Key into the linecache.
Definition gfx_layout.h:164
Layouter::LineCacheKey::state_before
FontState state_before
Font state at the beginning of the line.
Definition gfx_layout.h:165
Layouter::LineCacheKey::str
std::string str
Source string of the line (including colour and font size codes).
Definition gfx_layout.h:166
Layouter::LineCacheQuery
Definition gfx_layout.h:169
utf8.hpp
Handling of UTF-8 encoded data.