OpenTTD Source 20261112-master-gbcbec5e63f
string_osx.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
9
10#include "../../stdafx.h"
11#include "string_osx.h"
12#include "../../string_func.h"
13#include "../../strings_func.h"
14#include "../../core/utf8.hpp"
16#include "../../fontcache.h"
17#include "../../zoom_func.h"
18#include "macos.h"
19
20#include <CoreFoundation/CoreFoundation.h>
21#include "../../safeguards.h"
22
23
26
27
31class CoreTextParagraphLayout : public ParagraphLayouter {
32private:
34 ptrdiff_t length;
35 const FontMap &font_map;
36
38
39 CFIndex cur_offset = 0;
40
41public:
44 private:
45 std::vector<GlyphID> glyphs;
46 std::vector<Position> positions;
47 std::vector<int> glyph_to_char;
48
49 int total_advance = 0;
50 Font font;
51
52 public:
53 CoreTextVisualRun(CTRunRef run, const Font &font, const CoreTextParagraphLayoutFactory::CharType *buff);
54 CoreTextVisualRun(CoreTextVisualRun &&other) = default;
55
56 std::span<const GlyphID> GetGlyphs() const override { return this->glyphs; }
57 std::span<const Position> GetPositions() const override { return this->positions; }
58 std::span<const int> GetGlyphToCharMap() const override { return this->glyph_to_char; }
59
60 const Font &GetFont() const override { return this->font; }
61 int GetLeading() const override { return this->font.GetFontCache().GetHeight(); }
62 size_t GetGlyphCount() const override { return this->glyphs.size(); }
63 int GetAdvance() const { return this->total_advance; }
64 };
65
67 class CoreTextLine : public std::vector<CoreTextVisualRun>, public ParagraphLayouter::Line {
68 public:
69 CoreTextLine(CFAutoRelease<CTLineRef> line, const FontMap &font_mapping, const CoreTextParagraphLayoutFactory::CharType *buff)
70 {
71 CFArrayRef runs = CTLineGetGlyphRuns(line.get());
72 for (CFIndex i = 0; i < CFArrayGetCount(runs); i++) {
73 CTRunRef run = (CTRunRef)CFArrayGetValueAtIndex(runs, i);
74
75 /* Extract font information for this run. */
76 CFRange chars = CTRunGetStringRange(run);
77 auto map = std::ranges::upper_bound(font_mapping, chars.location, std::less{}, &std::pair<int, Font>::first);
78
79 this->emplace_back(run, map->second, buff);
80 }
81 }
82
83 int GetLeading() const override;
84 int GetWidth() const override;
85 size_t CountRuns() const override { return this->size(); }
86 const VisualRun &GetVisualRun(size_t run) const override { return this->at(run); }
87
88 int GetInternalCharLength(char32_t c) const override
89 {
90 /* CoreText uses UTF-16 internally which means we need to account for surrogate pairs. */
91 return c >= 0x010000U ? 2 : 1;
92 }
93 };
94
95 CoreTextParagraphLayout(CFAutoRelease<CTTypesetterRef> typesetter, const CoreTextParagraphLayoutFactory::CharType *buffer, ptrdiff_t len, const FontMap &font_mapping) : text_buffer(buffer), length(len), font_map(font_mapping), typesetter(std::move(typesetter))
96 {
97 this->Reflow();
98 }
99
100 void Reflow() override
101 {
102 this->cur_offset = 0;
103 }
104
105 std::unique_ptr<const Line> NextLine(int max_width) override;
106};
107
108
114static CGFloat SpriteFontGetWidth(void *ref_con)
115{
116 FontSize fs = (FontSize)((size_t)ref_con >> 24);
117 char32_t c = (char32_t)((size_t)ref_con & 0xFFFFFF);
118
119 return GetGlyphWidth(fs, c);
120}
121
122static const CTRunDelegateCallbacks _sprite_font_callback = {
123 kCTRunDelegateCurrentVersion, nullptr, nullptr, nullptr,
125};
126
127/* static */ std::unique_ptr<ParagraphLayouter> CoreTextParagraphLayoutFactory::GetParagraphLayout(CharType *buff, CharType *buff_end, FontMap &font_mapping)
128{
129 /* Can't layout an empty string. */
130 ptrdiff_t length = buff_end - buff;
131 if (length == 0) return nullptr;
132
133 /* Can't layout our in-built sprite fonts. */
134 for (const auto &[position, font] : font_mapping) {
135 if (font.GetFontCache().IsBuiltInFont()) return nullptr;
136 }
137
138 /* Make attributed string with embedded font information. */
139 CFAutoRelease<CFMutableAttributedStringRef> str(CFAttributedStringCreateMutable(kCFAllocatorDefault, 0));
140 CFAttributedStringBeginEditing(str.get());
141
142 CFAutoRelease<CFStringRef> base(CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, buff, length, kCFAllocatorNull));
143 CFAttributedStringReplaceString(str.get(), CFRangeMake(0, 0), base.get());
144
145 const UniChar replacement_char = 0xFFFC;
146 CFAutoRelease<CFStringRef> replacement_str(CFStringCreateWithCharacters(kCFAllocatorDefault, &replacement_char, 1));
147
148 /* Apply font and colour ranges to our string. This is important to make sure
149 * that we get proper glyph boundaries on style changes. */
150 int last = 0;
151 for (const auto &[position, font] : font_mapping) {
152 if (position - last == 0) continue;
153
154 FontCache &fc = font.GetFontCache();
155 assert(fc.GetOSHandle() != nullptr);
156 CTFontRef font_handle = static_cast<CTFontRef>(fc.GetOSHandle());
157 CFAttributedStringSetAttribute(str.get(), CFRangeMake(last, position - last), kCTFontAttributeName, font_handle);
158
159 CGColorRef colour = CGColorCreateGenericGray(to_underlying(font.colour.colour) / 255.0f, 1.0f); // We don't care about the real colours, just that they are different.
160 CFAttributedStringSetAttribute(str.get(), CFRangeMake(last, position - last), kCTForegroundColorAttributeName, colour);
161 CGColorRelease(colour);
162
163 /* Install a size callback for our special private-use sprite glyphs in case the font does not provide them. */
164 for (int c = last; c < position; c++) {
165 if (buff[c] >= SCC_SPRITE_START && buff[c] <= SCC_SPRITE_END && fc.MapCharToGlyph(buff[c], false) == 0) {
166 CFAutoRelease<CTRunDelegateRef> del(CTRunDelegateCreate(&_sprite_font_callback, (void *)(size_t)(buff[c] | (to_underlying(fc.GetSize()) << 24))));
167 /* According to the official documentation, if a run delegate is used, the char should always be 0xFFFC. */
168 CFAttributedStringReplaceString(str.get(), CFRangeMake(c, 1), replacement_str.get());
169 CFAttributedStringSetAttribute(str.get(), CFRangeMake(c, 1), kCTRunDelegateAttributeName, del.get());
170 }
171 }
172
173 last = position;
174 }
175 CFAttributedStringEndEditing(str.get());
176
177 /* Create and return typesetter for the string. */
178 CFAutoRelease<CTTypesetterRef> typesetter(CTTypesetterCreateWithAttributedString(str.get()));
179
180 return typesetter ? std::make_unique<CoreTextParagraphLayout>(std::move(typesetter), buff, length, font_mapping) : nullptr;
181}
182
183/* virtual */ std::unique_ptr<const ParagraphLayouter::Line> CoreTextParagraphLayout::NextLine(int max_width)
184{
185 if (this->cur_offset >= this->length) return nullptr;
186
187 /* Get line break position, trying word breaking first and breaking somewhere if that doesn't work. */
188 CFIndex len = CTTypesetterSuggestLineBreak(this->typesetter.get(), this->cur_offset, max_width);
189 if (len <= 0) len = CTTypesetterSuggestClusterBreak(this->typesetter.get(), this->cur_offset, max_width);
190
191 /* Create line. */
192 CFAutoRelease<CTLineRef> line(CTTypesetterCreateLine(this->typesetter.get(), CFRangeMake(this->cur_offset, len)));
193 this->cur_offset += len;
194
195 if (!line) return nullptr;
196 return std::make_unique<CoreTextLine>(std::move(line), this->font_map, this->text_buffer);
197}
198
206{
207 this->glyphs.resize(CTRunGetGlyphCount(run));
208
209 /* Query map of glyphs to source string index. */
210 auto map = std::make_unique<CFIndex[]>(this->glyphs.size());
211 CTRunGetStringIndices(run, CFRangeMake(0, 0), map.get());
212
213 this->glyph_to_char.resize(this->glyphs.size());
214 for (size_t i = 0; i < this->glyph_to_char.size(); i++) this->glyph_to_char[i] = (int)map[i];
215
216 auto pts = std::make_unique<CGPoint[]>(this->glyphs.size());
217 CTRunGetPositions(run, CFRangeMake(0, 0), pts.get());
218 auto advs = std::make_unique<CGSize[]>(this->glyphs.size());
219 CTRunGetAdvances(run, CFRangeMake(0, 0), advs.get());
220 this->positions.reserve(this->glyphs.size());
221
222 /* Convert glyph array to our data type. At the same time, substitute
223 * the proper glyphs for our private sprite glyphs. */
224 auto gl = std::make_unique<CGGlyph[]>(this->glyphs.size());
225 CTRunGetGlyphs(run, CFRangeMake(0, 0), gl.get());
226 for (size_t i = 0; i < this->glyphs.size(); i++) {
227 if (buff[this->glyph_to_char[i]] >= SCC_SPRITE_START && buff[this->glyph_to_char[i]] <= SCC_SPRITE_END && (gl[i] == 0 || gl[i] == 3)) {
228 /* A glyph of 0 indicates not found, while apparently 3 is what char 0xFFFC maps to. */
229 FontCache &fc = font.GetFontCache();
230 this->glyphs[i] = fc.MapCharToGlyph(buff[this->glyph_to_char[i]]);
231 this->positions.emplace_back(pts[i].x, pts[i].x + advs[i].width - 1, (fc.GetHeight() - ScaleSpriteTrad(FontCache::GetDefaultFontHeight(fc.GetSize()))) / 2); // Align sprite font to centre
232 } else {
233 this->glyphs[i] = gl[i];
234 this->positions.emplace_back(pts[i].x, pts[i].x + advs[i].width - 1, pts[i].y);
235 }
236 }
237 this->total_advance = (int)std::ceil(CTRunGetTypographicBounds(run, CFRangeMake(0, 0), nullptr, nullptr, nullptr));
238}
239
245{
246 int leading = 0;
247 for (const auto &run : *this) {
248 leading = std::max(leading, run.GetLeading());
249 }
250
251 return leading;
252}
253
259{
260 if (this->empty()) return 0;
261
262 int total_width = 0;
263 for (const auto &run : *this) {
264 total_width += run.GetAdvance();
265 }
266
267 return total_width;
268}
269
274void MacOSRegisterExternalFont(std::string_view file_path)
275{
276 CFAutoRelease<CFStringRef> path(CFStringCreateWithBytes(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(file_path.data()), file_path.size(), kCFStringEncodingUTF8, false));
277 CFAutoRelease<CFURLRef> url(CFURLCreateWithFileSystemPath(kCFAllocatorDefault, path.get(), kCFURLPOSIXPathStyle, false));
278
279 CTFontManagerRegisterFontsForURL(url.get(), kCTFontManagerScopeProcess, nullptr);
280}
281
286void MacOSSetCurrentLocaleName(std::string_view iso_code)
287{
288 CFAutoRelease<CFStringRef> iso(CFStringCreateWithBytes(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(iso_code.data()), iso_code.size(), kCFStringEncodingUTF8, false));
289 _osx_locale.reset(CFLocaleCreate(kCFAllocatorDefault, iso.get()));
290}
291
299int MacOSStringCompare(std::string_view s1, std::string_view s2)
300{
301 CFStringCompareFlags flags = kCFCompareCaseInsensitive | kCFCompareNumerically | kCFCompareLocalized | kCFCompareWidthInsensitive | kCFCompareForcedOrdering;
302
303 CFAutoRelease<CFStringRef> cf1(CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)s1.data(), s1.size(), kCFStringEncodingUTF8, false));
304 CFAutoRelease<CFStringRef> cf2(CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)s2.data(), s2.size(), kCFStringEncodingUTF8, false));
305
306 /* If any CFString could not be created (e.g., due to UTF8 invalid chars), return OS unsupported functionality */
307 if (cf1 == nullptr || cf2 == nullptr) return 0;
308
309 return (int)CFStringCompareWithOptionsAndLocale(cf1.get(), cf2.get(), CFRangeMake(0, CFStringGetLength(cf1.get())), flags, _osx_locale.get()) + 2;
310}
311
320int MacOSStringContains(std::string_view str, std::string_view value, bool case_insensitive)
321{
322 CFStringCompareFlags flags = kCFCompareLocalized | kCFCompareWidthInsensitive;
323 if (case_insensitive) flags |= kCFCompareCaseInsensitive;
324
325 CFAutoRelease<CFStringRef> cf_str(CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)str.data(), str.size(), kCFStringEncodingUTF8, false));
326 CFAutoRelease<CFStringRef> cf_value(CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)value.data(), value.size(), kCFStringEncodingUTF8, false));
327
328 /* If any CFString could not be created (e.g., due to UTF8 invalid chars), return OS unsupported functionality */
329 if (cf_str == nullptr || cf_value == nullptr) return -1;
330
331 return CFStringFindWithOptionsAndLocale(cf_str.get(), cf_value.get(), CFRangeMake(0, CFStringGetLength(cf_str.get())), flags, _osx_locale.get(), nullptr) ? 1 : 0;
332}
333
334
335/* virtual */ void OSXStringIterator::SetString(std::string_view s)
336{
337 this->utf16_to_utf8.clear();
338 this->str_info.clear();
339 this->cur_pos = 0;
340
341 /* CoreText operates on UTF-16, thus we have to convert the input string.
342 * To be able to return proper offsets, we have to create a mapping at the same time. */
343 std::vector<UniChar> utf16_str;
344 Utf8View view(s);
345 for (auto it = view.begin(), end = view.end(); it != end; ++it) {
346 size_t idx = it.GetByteOffset();
347 char32_t c = *it;
348 if (c < 0x10000) {
349 utf16_str.push_back((UniChar)c);
350 } else {
351 /* Make a surrogate pair. */
352 utf16_str.push_back((UniChar)(0xD800 + ((c - 0x10000) >> 10)));
353 utf16_str.push_back((UniChar)(0xDC00 + ((c - 0x10000) & 0x3FF)));
354 this->utf16_to_utf8.push_back(idx);
355 }
356 this->utf16_to_utf8.push_back(idx);
357 }
358 this->utf16_to_utf8.push_back(s.size());
359
360 /* Query CoreText for word and cluster break information. */
361 this->str_info.resize(utf16_to_utf8.size());
362
363 if (!utf16_str.empty()) {
364 CFAutoRelease<CFStringRef> str(CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, &utf16_str[0], utf16_str.size(), kCFAllocatorNull));
365
366 /* Get cluster breaks. */
367 for (CFIndex i = 0; i < CFStringGetLength(str.get()); ) {
368 CFRange r = CFStringGetRangeOfComposedCharactersAtIndex(str.get(), i);
369 this->str_info[r.location].char_stop = true;
370
371 i += r.length;
372 }
373
374 /* Get word breaks. */
375 CFAutoRelease<CFStringTokenizerRef> tokenizer(CFStringTokenizerCreate(kCFAllocatorDefault, str.get(), CFRangeMake(0, CFStringGetLength(str.get())), kCFStringTokenizerUnitWordBoundary, _osx_locale.get()));
376
377 CFStringTokenizerTokenType tokenType = kCFStringTokenizerTokenNone;
378 while ((tokenType = CFStringTokenizerAdvanceToNextToken(tokenizer.get())) != kCFStringTokenizerTokenNone) {
379 /* Skip tokens that are white-space or punctuation tokens. */
380 if ((tokenType & kCFStringTokenizerTokenHasNonLettersMask) != kCFStringTokenizerTokenHasNonLettersMask) {
381 CFRange r = CFStringTokenizerGetCurrentTokenRange(tokenizer.get());
382 this->str_info[r.location].word_stop = true;
383 }
384 }
385 }
386
387 /* End-of-string is always a valid stopping point. */
388 this->str_info.back().char_stop = true;
389 this->str_info.back().word_stop = true;
390}
391
392/* virtual */ size_t OSXStringIterator::SetCurPosition(size_t pos)
393{
394 /* Convert incoming position to an UTF-16 string index. */
395 size_t utf16_pos = 0;
396 for (size_t i = 0; i < this->utf16_to_utf8.size(); i++) {
397 if (this->utf16_to_utf8[i] == pos) {
398 utf16_pos = i;
399 break;
400 }
401 }
402
403 /* Sanitize in case we get a position inside a grapheme cluster. */
404 while (utf16_pos > 0 && !this->str_info[utf16_pos].char_stop) utf16_pos--;
405 this->cur_pos = utf16_pos;
406
407 return this->utf16_to_utf8[this->cur_pos];
408}
409
410/* virtual */ size_t OSXStringIterator::Next(IterType what)
411{
412 assert(this->cur_pos <= this->utf16_to_utf8.size());
414
415 if (this->cur_pos == this->utf16_to_utf8.size()) return END;
416
417 do {
418 this->cur_pos++;
419 } while (this->cur_pos < this->utf16_to_utf8.size() && (what == ITER_WORD ? !this->str_info[this->cur_pos].word_stop : !this->str_info[this->cur_pos].char_stop));
420
421 return this->cur_pos == this->utf16_to_utf8.size() ? END : this->utf16_to_utf8[this->cur_pos];
422}
423
424/* virtual */ size_t OSXStringIterator::Prev(IterType what)
425{
426 assert(this->cur_pos <= this->utf16_to_utf8.size());
428
429 if (this->cur_pos == 0) return END;
430
431 do {
432 this->cur_pos--;
433 } while (this->cur_pos > 0 && (what == ITER_WORD ? !this->str_info[this->cur_pos].word_stop : !this->str_info[this->cur_pos].char_stop));
434
435 return this->utf16_to_utf8[this->cur_pos];
436}
437
438/* static */ std::unique_ptr<StringIterator> OSXStringIterator::Create()
439{
440 return std::make_unique<OSXStringIterator>();
441}
UniChar CharType
Helper for GetLayouter, to get the right type.
Definition string_osx.h:44
static std::unique_ptr< ParagraphLayouter > GetParagraphLayout(CharType *buff, CharType *buff_end, FontMap &font_mapping)
Get the actual ParagraphLayout for the given buffer.
const VisualRun & GetVisualRun(size_t run) const override
Get a reference to the given run.
int GetWidth() const override
Get the width of this line.
size_t CountRuns() const override
Get the number of runs in this line.
int GetLeading() const override
Get the height of the line.
int GetInternalCharLength(char32_t c) const override
Get the number of elements the given character occupies in the underlying text buffer of the Layouter...
std::span< const int > GetGlyphToCharMap() const override
The offset for each of the glyphs to the character run that was passed to the Layouter.
const Font & GetFont() const override
Get the font.
int GetLeading() const override
Get the font leading, or distance between the baselines of consecutive lines.
CoreTextVisualRun(CTRunRef run, const Font &font, const CoreTextParagraphLayoutFactory::CharType *buff)
Construct a new Core Text Visual Run object.
size_t GetGlyphCount() const override
Get the number of glyphs.
std::span< const Position > GetPositions() const override
Get the positions for each of the glyphs.
std::span< const GlyphID > GetGlyphs() const override
Get the glyphs to draw.
Wrapper for doing layouts with CoreText.
std::unique_ptr< const Line > NextLine(int max_width) override
Construct a new line with a maximum width.
CFIndex cur_offset
Offset from the start of the current run from where to output.
void Reflow() override
Reset the position to the start of the paragraph.
Font cache for basic fonts.
Definition fontcache.h:23
int GetHeight() const
Get the height of the font.
Definition fontcache.h:65
virtual const void * GetOSHandle()
Get the native OS font handle, if there is one.
Definition fontcache.h:120
virtual GlyphID MapCharToGlyph(char32_t key, bool fallback=true)=0
Map a character into a glyph.
FontSize GetSize() const
Get the FontSize of the font.
Definition fontcache.h:59
Container with information about a font.
Definition gfx_layout.h:21
FontCache & GetFontCache() const
Get the font cache of this font.
Definition gfx_layout.h:36
size_t Prev(IterType what) override
Move the cursor back by one iteration unit.
size_t Next(IterType what) override
Advance the cursor by one iteration unit.
std::vector< CharInfo > str_info
Break information for each code point.
Definition string_osx.h:24
size_t SetCurPosition(size_t pos) override
Change the current string cursor.
size_t cur_pos
Current iteration position.
Definition string_osx.h:27
std::vector< size_t > utf16_to_utf8
Mapping from UTF-16 code point position to index in the UTF-8 source string.
Definition string_osx.h:25
void SetString(std::string_view s) override
Set a new iteration string.
A single line worth of VisualRuns.
Definition gfx_layout.h:209
Visual run contains data about the bit of text with the same font.
Definition gfx_layout.h:166
Interface to glue fallback and normal layouter into one.
Definition gfx_layout.h:144
static const size_t END
Sentinel to indicate end-of-iteration.
Definition string_base.h:23
static std::unique_ptr< StringIterator > Create()
Create a new iterator instance.
Definition string.cpp:746
IterType
Type of the iterator.
Definition string_base.h:17
@ ITER_WORD
Iterate over words.
Definition string_base.h:19
@ ITER_CHARACTER
Iterate over characters (or more exactly grapheme clusters).
Definition string_base.h:18
Constant span of UTF-8 encoded data.
Definition utf8.hpp:28
Control codes that are embedded in the translation strings.
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
Definition enum_type.hpp:21
Functions to read fonts from files and cache them.
uint GetGlyphWidth(FontSize size, char32_t key)
Get the width of a glyph.
Definition fontcache.h:178
std::vector< std::pair< int, Font > > FontMap
Mapping from index to font.
Definition gfx_layout.h:139
FontSize
Available font sizes.
Definition gfx_type.h:248
Functions related to MacOS support.
std::unique_ptr< typename std::remove_pointer< T >::type, CFDeleter< typename std::remove_pointer< T >::type > > CFAutoRelease
Specialisation of std::unique_ptr for CoreFoundation objects.
Definition macos.h:34
A number of safeguards to prevent using unsafe methods.
Definition of base types and functions in a cross-platform compatible way.
Functions related to low-level strings.
void MacOSRegisterExternalFont(std::string_view file_path)
Register an external font file with the CoreText system.
int MacOSStringCompare(std::string_view s1, std::string_view s2)
Compares two strings using case insensitive natural sort.
void MacOSSetCurrentLocaleName(std::string_view iso_code)
Store current language locale as a CoreFoundation locale.
static CGFloat SpriteFontGetWidth(void *ref_con)
Get the width of an encoded sprite font character.
int MacOSStringContains(std::string_view str, std::string_view value, bool case_insensitive)
Search if a string is contained in another string using the current locale.
static CFAutoRelease< CFLocaleRef > _osx_locale
Cached current locale.
Functions related to localized text support on OSX.
Functions related to OTTD's strings.
Handling of UTF-8 encoded data.
Functions related to zooming.
int ScaleSpriteTrad(int value)
Scale traditional pixel dimensions to GUI zoom level, for drawing sprites.
Definition zoom_func.h:107