OpenTTD Source: src/os/unix/font_unix.cpp Source File

OpenTTD Source 15.0-beta1

font_unix.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 <http://www.gnu.org/licenses/>.
6 */
7
10#include "../../stdafx.h"
11#include "../../debug.h"
12#include "../../fontdetection.h"
13#include "../../string_func.h"
14#include "../../strings_func.h"
15
16#include <fontconfig/fontconfig.h>
17
18#include "safeguards.h"
19
20#include <ft2build.h>
21#include FT_FREETYPE_H
22
23extern FT_Library _library;
24
31 static std::tuple<std::string, std::string> SplitFontFamilyAndStyle(std::string_view font_name)
32{
33 auto separator = font_name.find(',');
34 if (separator == std::string_view::npos) return { std::string(font_name), std::string() };
35
36 auto begin = font_name.find_first_not_of("\t ", separator + 1);
37 if (begin == std::string_view::npos) return { std::string(font_name.substr(0, separator)), std::string() };
38
39 return { std::string(font_name.substr(0, separator)), std::string(font_name.substr(begin)) };
40}
41
42FT_Error GetFontByFaceName(const char *font_name, FT_Face *face)
43{
44 FT_Error err = FT_Err_Cannot_Open_Resource;
45
46 if (!FcInit()) {
47 ShowInfo("Unable to load font configuration");
48 return err;
49 }
50
51 auto fc_instance = FcConfigReference(nullptr);
52 assert(fc_instance != nullptr);
53
54 /* Split & strip the font's style */
55 auto [font_family, font_style] = SplitFontFamilyAndStyle(font_name);
56
57 /* Resolve the name and populate the information structure */
58 FcPattern *pat = FcPatternCreate();
59 if (!font_family.empty()) FcPatternAddString(pat, FC_FAMILY, reinterpret_cast<const FcChar8 *>(font_family.c_str()));
60 if (!font_style.empty()) FcPatternAddString(pat, FC_STYLE, reinterpret_cast<const FcChar8 *>(font_style.c_str()));
61 FcConfigSubstitute(nullptr, pat, FcMatchPattern);
62 FcDefaultSubstitute(pat);
63 FcFontSet *fs = FcFontSetCreate();
64 FcResult result;
65 FcPattern *match = FcFontMatch(nullptr, pat, &result);
66
67 if (fs != nullptr && match != nullptr) {
68 FcChar8 *family;
69 FcChar8 *style;
70 FcChar8 *file;
71 int32_t index;
72 FcFontSetAdd(fs, match);
73
74 for (int i = 0; err != FT_Err_Ok && i < fs->nfont; i++) {
75 /* Try the new filename */
76 if (FcPatternGetString(fs->fonts[i], FC_FILE, 0, &file) == FcResultMatch &&
77 FcPatternGetString(fs->fonts[i], FC_FAMILY, 0, &family) == FcResultMatch &&
78 FcPatternGetString(fs->fonts[i], FC_STYLE, 0, &style) == FcResultMatch &&
79 FcPatternGetInteger(fs->fonts[i], FC_INDEX, 0, &index) == FcResultMatch) {
80
81 /* The correct style? */
82 if (!font_style.empty() && !StrEqualsIgnoreCase(font_style, (char *)style)) continue;
83
84 /* Font config takes the best shot, which, if the family name is spelled
85 * wrongly a 'random' font, so check whether the family name is the
86 * same as the supplied name */
87 if (StrEqualsIgnoreCase(font_family, (char *)family)) {
88 err = FT_New_Face(_library, (char *)file, index, face);
89 }
90 }
91 }
92 }
93
94 FcPatternDestroy(pat);
95 FcFontSetDestroy(fs);
96 FcConfigDestroy(fc_instance);
97
98 return err;
99}
100
101 bool SetFallbackFont(FontCacheSettings *settings, const std::string &language_isocode, int, MissingGlyphSearcher *callback)
102{
103 bool ret = false;
104
105 if (!FcInit()) return ret;
106
107 auto fc_instance = FcConfigReference(nullptr);
108 assert(fc_instance != nullptr);
109
110 /* Fontconfig doesn't handle full language isocodes, only the part
111 * before the _ of e.g. en_GB is used, so "remove" everything after
112 * the _. */
113 std::string lang = fmt::format(":lang={}", language_isocode.substr(0, language_isocode.find('_')));
114
115 /* First create a pattern to match the wanted language. */
116 FcPattern *pat = FcNameParse((const FcChar8 *)lang.c_str());
117 /* We only want to know these attributes. */
118 FcObjectSet *os = FcObjectSetBuild(FC_FILE, FC_INDEX, FC_SPACING, FC_SLANT, FC_WEIGHT, nullptr);
119 /* Get the list of filenames matching the wanted language. */
120 FcFontSet *fs = FcFontList(nullptr, pat, os);
121
122 /* We don't need these anymore. */
123 FcObjectSetDestroy(os);
124 FcPatternDestroy(pat);
125
126 if (fs != nullptr) {
127 int best_weight = -1;
128 const char *best_font = nullptr;
129 int best_index = 0;
130
131 for (int i = 0; i < fs->nfont; i++) {
132 FcPattern *font = fs->fonts[i];
133
134 FcChar8 *file = nullptr;
135 FcResult res = FcPatternGetString(font, FC_FILE, 0, &file);
136 if (res != FcResultMatch || file == nullptr) {
137 continue;
138 }
139
140 /* Get a font with the right spacing .*/
141 int value = 0;
142 FcPatternGetInteger(font, FC_SPACING, 0, &value);
143 if (callback->Monospace() != (value == FC_MONO) && value != FC_DUAL) continue;
144
145 /* Do not use those that explicitly say they're slanted. */
146 FcPatternGetInteger(font, FC_SLANT, 0, &value);
147 if (value != 0) continue;
148
149 /* We want the fatter font as they look better at small sizes. */
150 FcPatternGetInteger(font, FC_WEIGHT, 0, &value);
151 if (value <= best_weight) continue;
152
153 /* Possible match based on attributes, get index. */
154 int32_t index;
155 res = FcPatternGetInteger(font, FC_INDEX, 0, &index);
156 if (res != FcResultMatch) continue;
157
158 callback->SetFontNames(settings, (const char *)file, &index);
159
160 bool missing = callback->FindMissingGlyphs();
161 Debug(fontcache, 1, "Font \"{}\" misses{} glyphs", (char *)file, missing ? "" : " no");
162
163 if (!missing) {
164 best_weight = value;
165 best_font = (const char *)file;
166 best_index = index;
167 }
168 }
169
170 if (best_font != nullptr) {
171 ret = true;
172 callback->SetFontNames(settings, best_font, &best_index);
173 InitFontCache(callback->Monospace());
174 }
175
176 /* Clean up the list of filenames. */
177 FcFontSetDestroy(fs);
178 }
179
180 FcConfigDestroy(fc_instance);
181 return ret;
182}
MissingGlyphSearcher
A searcher for missing glyphs.
Definition strings_func.h:117
MissingGlyphSearcher::SetFontNames
virtual void SetFontNames(struct FontCacheSettings *settings, const char *font_name, const void *os_data=nullptr)=0
Set the right font names.
MissingGlyphSearcher::FindMissingGlyphs
bool FindMissingGlyphs()
Check whether there are glyphs missing in the current language.
Definition strings.cpp:2192
MissingGlyphSearcher::Monospace
virtual bool Monospace()=0
Whether to search for a monospace font or not.
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition debug.h:37
settings
fluid_settings_t * settings
FluidSynth settings handle.
Definition fluidsynth.cpp:21
GetFontByFaceName
FT_Error GetFontByFaceName(const char *font_name, FT_Face *face)
Load a freetype font face with the given font name.
Definition font_unix.cpp:42
SetFallbackFont
bool SetFallbackFont(FontCacheSettings *settings, const std::string &language_isocode, int, MissingGlyphSearcher *callback)
We would like to have a fallback font as the current one doesn't contain all characters we need.
Definition font_unix.cpp:101
SplitFontFamilyAndStyle
static std::tuple< std::string, std::string > SplitFontFamilyAndStyle(std::string_view font_name)
Split the font name into the font family and style.
Definition font_unix.cpp:31
InitFontCache
void InitFontCache(bool monospace)
(Re)initialize the font cache related things, i.e.
Definition fontcache.cpp:218
safeguards.h
A number of safeguards to prevent using unsafe methods.
StrEqualsIgnoreCase
bool StrEqualsIgnoreCase(const std::string_view str1, const std::string_view str2)
Compares two string( view)s for equality, while ignoring the case of the characters.
Definition string.cpp:347
FontCacheSettings
Settings for the four different fonts.
Definition fontcache.h:200