Change: Test font for elligibility before adding as fallback.

Author: PeterN

src/fontcache.cpp

@@ -52,10 +52,10 @@ FontCacheSettings _fcsettings;
  * @param callback The function to call to check for missing glyphs.
  * @return true if a font has been set, false otherwise.
  */
-/* static */ bool FontProviderManager::FindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, MissingGlyphSearcher *callback)
+/* static */ bool FontProviderManager::FindFallbackFont(const std::string &language_isocode, const MissingGlyphs &missing_glyphs, MissingGlyphSearcher *callback)
 {
 	return std::ranges::any_of(FontProviderManager::GetProviders(),
-		[&](auto *provider) { return provider->FindFallbackFont(language_isocode, fontsizes, callback); });
+		[&](auto *provider) { return provider->FindFallbackFont(language_isocode, missing_glyphs, callback); });
 }
 
 int FontCache::GetDefaultFontHeight(FontSize fs)
@@ -244,6 +244,31 @@ static std::string GetFontCacheFontName(FontSize fs)
 	}
 }
 
+/**
+ * Test a fallback font, with optional OS-specific handle, for specific glyphs.
+ * @param name Name of font to test.
+ * @param handle OS-specific handle or data of font.
+ * @param missing_glyphs Glyphs to search for.
+ */
+/* static */ bool FontCache::TryFallback(const std::string &name, std::span<const std::byte> os_handle, const std::set<char32_t> &missing_glyphs)
+{
+	/* Load the font without registering it. The font size does not matter. */
+	auto fc = FontProviderManager::LoadFont(FS_NORMAL, FontType::TrueType, false, name, os_handle);
+	if (fc == nullptr) return false;
+
+	size_t matching_chars = 0;
+	for (const char32_t &c : missing_glyphs) {
+		if (fc->MapCharToGlyph(c, true) != 0) ++matching_chars;
+	}
+
+	if (matching_chars < missing_glyphs.size()) {
+		Debug(fontcache, 1, "Font \"{}\" misses {} glyphs", name, missing_glyphs.size() - matching_chars);
+		return false;
+	}
+
+	return true;
+}
+
 /**
  * (Re)initialize the font cache related things, i.e. load the non-sprite fonts.
  * @param fontsizes Font sizes to be initialised.

src/fontcache.h

@@ -61,6 +61,21 @@ class FontCache {
 		FontCache::AddFallback(fontsizes, name, os_handle);
 	}
 
+	static bool TryFallback(const std::string &name, std::span<const std::byte> os_handle, const std::set<char32_t> &missing_glyphs);
+
+	/**
+	 * Test a fallback font, with OS-specific handle, for specific glyphs.
+	 * @param name Name of font to test.
+	 * @param handle OS-specific handle or data of font.
+	 * @param missing_glyphs Glyphs to search for.
+	 */
+	template <typename T>
+	static bool TryFallbackWithHandle(const std::string &name, T &handle, const std::set<char32_t> &missing_glyphs)
+	{
+		auto os_handle = std::as_bytes(std::span(&handle, 1));
+		return FontCache::TryFallback(name, os_handle, missing_glyphs);
+	}
+
 	/**
 	 * Get the FontSize of the font.
 	 * @return The FontSize.
@@ -230,6 +245,11 @@ enum class FontType : uint8_t {
 	TrueType, ///< Scalable TrueType fonts.
 };
 
+struct MissingGlyphs {
+	std::set<char32_t> glyphs{}; ///< Glyphs that are missing.
+	FontSizes fontsizes{}; ///< Font sizes which are missing glyphs,
+};
+
 /** Factory for FontCaches. */
 class FontCacheFactory : public BaseProvider<FontCacheFactory> {
 public:
@@ -244,13 +264,13 @@ class FontCacheFactory : public BaseProvider<FontCacheFactory> {
 	}
 
 	virtual std::unique_ptr<FontCache> LoadFont(FontSize fs, FontType fonttype, bool search, const std::string &font_name, std::span<const std::byte> os_handle) const = 0;
-	virtual bool FindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, class MissingGlyphSearcher *callback) const = 0;
+	virtual bool FindFallbackFont(const std::string &language_isocode, const MissingGlyphs &glyphs, class MissingGlyphSearcher *callback) const = 0;
 };
 
 class FontProviderManager : ProviderManager<FontCacheFactory> {
 public:
 	static std::unique_ptr<FontCache> LoadFont(FontSize fs, FontType fonttype, bool search, const std::string &font_name, std::span<const std::byte> os_handle);
-	static bool FindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, MissingGlyphSearcher *callback);
+	static bool FindFallbackFont(const std::string &language_isocode, const MissingGlyphs &glyphs, MissingGlyphSearcher *callback);
 };
 
 /* Implemented in spritefontcache.cpp */

src/fontcache/freetypefontcache.cpp

@@ -269,10 +269,10 @@ class FreeTypeFontCacheFactory : public FontCacheFactory {
 		return LoadFont(fs, face, font_name, GetFontCacheFontSize(fs));
 	}
 
-	bool FindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, class MissingGlyphSearcher *callback) const override
+	bool FindFallbackFont(const std::string &language_isocode, const MissingGlyphs &glyphs, class MissingGlyphSearcher *callback) const override
 	{
 #ifdef WITH_FONTCONFIG
-		if (FontConfigFindFallbackFont(language_isocode, fontsizes, callback)) return true;
+		if (FontConfigFindFallbackFont(language_isocode, glyphs, callback)) return true;
 #endif /* WITH_FONTCONFIG */
 
 		return false;

src/fontcache/spritefontcache.cpp

@@ -165,7 +165,7 @@ class SpriteFontCacheFactory : public FontCacheFactory {
 		return std::make_unique<SpriteFontCache>(fs);
 	}
 
-	bool FindFallbackFont(const std::string &, FontSizes, class MissingGlyphSearcher *) const override
+	bool FindFallbackFont(const std::string &, const MissingGlyphs &, class MissingGlyphSearcher *) const override
 	{
 		return false;
 	}

src/os/macosx/font_osx.cpp

@@ -249,7 +249,7 @@ class CoreTextFontCacheFactory : public FontCacheFactory {
 		return std::make_unique<CoreTextFontCache>(fs, std::move(font_ref), GetFontCacheFontSize(fs));
 	}
 
-	bool FindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, MissingGlyphSearcher *callback) const override
+	bool FindFallbackFont(const std::string &language_isocode, const MissingGlyphs &glyphs, MissingGlyphSearcher *callback) const override
 	{
 		/* Determine fallback font using CoreText. This uses the language isocode
 		 * to find a suitable font. CoreText is available from 10.5 onwards. */
@@ -313,10 +313,10 @@ class CoreTextFontCacheFactory : public FontCacheFactory {
 				if (name.starts_with(".") || name.starts_with("LastResort")) continue;
 
 				/* Save result. */
-				FontCache::AddFallback(fontsizes, name);
-				if (!callback->FindMissingGlyphs()) {
+				result = FontCache::TryFallback(name, {}, glyphs.glyphs);
+				if (result) {
+					FontCache::AddFallback(fontsizes, name);
 					Debug(fontcache, 2, "CT-Font for {}: {}", language_isocode, name);
-					result = true;
 					break;
 				}
 			}
@@ -325,11 +325,12 @@ class CoreTextFontCacheFactory : public FontCacheFactory {
 		if (!result) {
 			/* For some OS versions, the font 'Arial Unicode MS' does not report all languages it
 			 * supports. If we didn't find any other font, just try it, maybe we get lucky. */
-			FontCache::AddFallback(fontsizes, "Arial Unicode MS");
-			result = !callback->FindMissingGlyphs();
+			result = FontCache::TryFallbackWithHandle(FromFcString(file), index, glyphs.glyphs);
+			if (result) {
+				FontCache::AddFallback(fontsizes, "Arial Unicode MS");
+			}
 		}
 
-		callback->FindMissingGlyphs();
 		return result;
 	}
 

src/os/unix/font_unix.cpp

@@ -139,7 +139,7 @@ static int GetPreferredWeightDistance(int weight)
 	return 0;
 }
 
-bool FontConfigFindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, MissingGlyphSearcher *callback)
+bool FontConfigFindFallbackFont(const std::string &language_isocode, const MissingGlyphs &glyphs, MissingGlyphSearcher *)
 {
 	bool ret = false;
 
@@ -156,7 +156,7 @@ bool FontConfigFindFallbackFont(const std::string &language_isocode, FontSizes f
 	/* First create a pattern to match the wanted language. */
 	auto pat = AutoRelease<FcPattern, FcPatternDestroy>(FcNameParse(ToFcString(lang)));
 	/* We only want to know these attributes. */
-	auto os = AutoRelease<FcObjectSet, FcObjectSetDestroy>(FcObjectSetBuild(FC_FILE, FC_INDEX, FC_SPACING, FC_SLANT, FC_WEIGHT, nullptr));
+	auto os = AutoRelease<FcObjectSet, FcObjectSetDestroy>(FcObjectSetBuild(FC_FILE, FC_INDEX, FC_SPACING, FC_SLANT, FC_WEIGHT, FC_CHARSET, nullptr));
 	/* Get the list of filenames matching the wanted language. */
 	auto fs = AutoRelease<FcFontSet, FcFontSetDestroy>(FcFontList(nullptr, pat.get(), os.get()));
 
@@ -174,7 +174,7 @@ bool FontConfigFindFallbackFont(const std::string &language_isocode, FontSizes f
 		/* Get a font with the right spacing .*/
 		int value = 0;
 		FcPatternGetInteger(font, FC_SPACING, 0, &value);
-		if (fontsizes.Test(FS_MONO) != (value == FC_MONO) && value != FC_DUAL) continue;
+		if (glyphs.fontsizes.Test(FS_MONO) != (value == FC_MONO) && value != FC_DUAL) continue;
 
 		/* Do not use those that explicitly say they're slanted. */
 		FcPatternGetInteger(font, FC_SLANT, 0, &value);
@@ -185,26 +185,32 @@ bool FontConfigFindFallbackFont(const std::string &language_isocode, FontSizes f
 		int weight = GetPreferredWeightDistance(value);
 		if (best_weight != -1 && weight > best_weight) continue;
 
+		size_t matching_chars = 0;
+		FcCharSet *charset;
+		FcPatternGetCharSet(font, FC_CHARSET, 0, &charset);
+		for (const char32_t &c : glyphs.glyphs) {
+			if (FcCharSetHasChar(charset, c)) ++matching_chars;
+		}
+
+		if (matching_chars < glyphs.glyphs.size()) {
+			Debug(fontcache, 1, "Font \"{}\" misses {} glyphs", FromFcString(file), glyphs.glyphs.size() - matching_chars);
+			continue;
+		}
+
 		/* Possible match based on attributes, get index. */
 		int32_t index;
 		res = FcPatternGetInteger(font, FC_INDEX, 0, &index);
 		if (res != FcResultMatch) continue;
 
-		FontCache::AddFallbackWithHandle(fontsizes, FromFcString(file), index);
-
-		bool missing = callback->FindMissingGlyphs();
-		Debug(fontcache, 1, "Font \"{}\" misses{} glyphs", FromFcString(file), missing ? "" : " no");
+		// if (!FontCache::TryFallbackWithHandle(FromFcString(file), index, glyphs.glyphs)) continue;
 
-		if (!missing) {
-			best_weight = weight;
-			best_font = FromFcString(file);
-			best_index = index;
-		}
+		best_weight = weight;
+		best_font = FromFcString(file);
+		best_index = index;
 	}
 
 	if (best_font == nullptr) return false;
 
-	FontCache::AddFallbackWithHandle(fontsizes, best_font, best_index);
-	FontCache::LoadFontCaches(fontsizes);
+	FontCache::AddFallbackWithHandle(glyphs.fontsizes, best_font, best_index);
 	return true;
 }

src/os/unix/font_unix.h

@@ -19,7 +19,7 @@
 
 FT_Error GetFontByFaceName(std::string_view font_name, FT_Face *face);
 
-bool FontConfigFindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, MissingGlyphSearcher *callback);
+bool FontConfigFindFallbackFont(const std::string &language_isocode, const MissingGlyphs &glyphs, MissingGlyphSearcher *callback);
 
 #endif /* WITH_FONTCONFIG */
 

src/os/windows/font_win32.cpp

@@ -77,8 +77,9 @@ static int CALLBACK EnumFontCallback(const ENUMLOGFONTEX *logfont, const NEWTEXT
 	char font_name[MAX_PATH];
 	convert_from_fs(logfont->elfFullName, font_name);
 
+	if (!FontCache::TryFallbackWithHandle(font_name, logfont->elfLogFont, glyphs.glyphs)) return 1;
+
 	FontCache::AddFallbackWithHandle(info->fontsizes, font_name, logfont->elfLogFont);
-	if (info->callback->FindMissingGlyphs()) return 1;
 	Debug(fontcache, 1, "Fallback font: {}", font_name);
 	return 0; // stop enumerating
 }
@@ -302,7 +303,7 @@ class Win32FontCacheFactory : FontCacheFactory {
 		return LoadWin32Font(fs, logfont, GetFontCacheFontSize(fs), font_name);
 	}
 
-	bool FindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, MissingGlyphSearcher *callback) const override
+	bool FindFallbackFont(const std::string &language_isocode, const MissingGlyphs &glyphs, MissingGlyphSearcher *callback) const override
 	{
 		Debug(fontcache, 1, "Trying fallback fonts");
 		EFCParam langInfo;

src/strings.cpp

@@ -2299,36 +2299,37 @@ std::string_view GetCurrentLanguageIsoCode()
 	return _langpack.langpack->isocode;
 }
 
-/**
- * Check whether there are glyphs missing in the current language.
- * @return If glyphs are missing, return \c true, else return \c false.
- */
-bool MissingGlyphSearcher::FindMissingGlyphs()
+MissingGlyphs BaseStringMissingGlyphSearcher::GetRequiredGlyphs(FontSizes fontsizes)
 {
-	FontCache::LoadFontCaches(this->fontsizes);
+	MissingGlyphs res{};
 
 	this->Reset();
 	for (auto text = this->NextString(); text.has_value(); text = this->NextString()) {
-		FontSize size = this->DefaultSize();
-		FontCache *fc = FontCache::Get(size);
+		FontSize fs = this->DefaultSize();
+		FontCache *fc = FontCache::Get(fs);
 		for (char32_t c : Utf8View(*text)) {
 			if (c >= SCC_FIRST_FONT && c <= SCC_LAST_FONT) {
-				size = (FontSize)(c - SCC_FIRST_FONT);
-				fc = FontCache::Get(size);
-			} else if (!IsInsideMM(c, SCC_SPRITE_START, SCC_SPRITE_END) && IsPrintable(c) && !IsTextDirectionChar(c) && fc->MapCharToGlyph(c, false) == 0) {
-				/* The character is printable, but not in the normal font. This is the case we were testing for. */
-				Debug(fontcache, 0, "Font is missing glyphs to display char 0x{:X} in {} font size", static_cast<uint32_t>(c), FontSizeToName(size));
-				return true;
+				fs = (FontSize)(c - SCC_FIRST_FONT);
+				fc = FontCache::Get(fs);
+				continue;
 			}
+
+			if (!fontsizes.Test(fs)) continue;
+			if (!IsPrintable(c) || IsTextDirectionChar(c)) continue;
+			if (IsInsideMM(c, SCC_SPRITE_START, SCC_SPRITE_END)) continue;
+			if (fc->MapCharToGlyph(c, false) != 0) continue;
+
+			res.fontsizes.Set(fs);
+			res.glyphs.insert(c);
 		}
 	}
-	return false;
+	return res;
 }
 
 /** Helper for searching through the language pack. */
-class LanguagePackGlyphSearcher : public MissingGlyphSearcher {
+class LanguagePackGlyphSearcher : public BaseStringMissingGlyphSearcher {
 public:
-	LanguagePackGlyphSearcher() : MissingGlyphSearcher(FONTSIZES_REQUIRED) {}
+	LanguagePackGlyphSearcher() : BaseStringMissingGlyphSearcher(FONTSIZES_REQUIRED) {}
 
 private:
 	uint i; ///< Iterator for the primary language tables.
@@ -2377,15 +2378,20 @@ void CheckForMissingGlyphs(MissingGlyphSearcher *searcher)
 {
 	static LanguagePackGlyphSearcher pack_searcher;
 	if (searcher == nullptr) searcher = &pack_searcher;
-	bool bad_font = searcher->FindMissingGlyphs();
+
+	FontCache::LoadFontCaches(searcher->fontsizes);
+
+	auto missing_glyphs = searcher->GetRequiredGlyphs(searcher->fontsizes);
+	bool bad_font = missing_glyphs.fontsizes.Any();
+
 #if defined(WITH_FREETYPE) || defined(_WIN32) || defined(WITH_COCOA)
 	if (bad_font) {
 		/* We found an unprintable character... lets try whether we can find
 		 * a fallback font that can print the characters in the current language. */
 		bool any_font_configured = !_fcsettings.medium.font.empty();
 		FontCacheSettings backup = _fcsettings;
 
-		bad_font = !FontProviderManager::FindFallbackFont(_langpack.langpack->isocode, searcher->fontsizes, searcher);
+		bad_font = !FontProviderManager::FindFallbackFont(_langpack.langpack->isocode, missing_glyphs, searcher);
 
 		_fcsettings = std::move(backup);
 
@@ -2404,7 +2410,7 @@ void CheckForMissingGlyphs(MissingGlyphSearcher *searcher)
 			/* Our fallback font does miss characters too, so keep the
 			 * user chosen font as that is more likely to be any good than
 			 * the wild guess we made */
-			FontCache::LoadFontCaches(searcher->fontsizes);
+			FontCache::LoadFontCaches(missing_glyphs.fontsizes);
 		}
 	}
 #endif
@@ -2421,12 +2427,12 @@ void CheckForMissingGlyphs(MissingGlyphSearcher *searcher)
 		ShowErrorMessage(GetEncodedString(STR_JUST_RAW_STRING, std::move(err_str)), {}, WL_WARNING);
 
 		/* Reset the font width */
-		LoadStringWidthTable(searcher->fontsizes);
+		LoadStringWidthTable(missing_glyphs.fontsizes);
 		return;
 	}
 
 	/* Update the font with cache */
-	LoadStringWidthTable(searcher->fontsizes);
+	LoadStringWidthTable(missing_glyphs.fontsizes);
 
 #if !(defined(WITH_ICU_I18N) && defined(WITH_HARFBUZZ)) && !defined(WITH_UNISCRIBE) && !defined(WITH_COCOA)
 	/*

src/strings_func.h

@@ -10,6 +10,7 @@
 #ifndef STRINGS_FUNC_H
 #define STRINGS_FUNC_H
 
+#include "fontcache.h"
 #include "strings_type.h"
 #include "gfx_type.h"
 #include "vehicle_type.h"
@@ -162,6 +163,20 @@ class MissingGlyphSearcher {
 	/** Make sure everything gets destructed right. */
 	virtual ~MissingGlyphSearcher() = default;
 
+	/**
+	 * Get set of glyphs required for the current language.
+	 * @param fontsizes Font sizes to test.
+	 * @return Set of required glyphs.
+	 **/
+	virtual MissingGlyphs GetRequiredGlyphs(FontSizes fontsizes) = 0;
+};
+
+class BaseStringMissingGlyphSearcher : public MissingGlyphSearcher {
+public:
+	BaseStringMissingGlyphSearcher(FontSizes fontsizes) : MissingGlyphSearcher(fontsizes) {}
+
+	MissingGlyphs GetRequiredGlyphs(FontSizes fontsizes) override;
+
 	/**
 	 * Get the next string to search through.
 	 * @return The next string or nullopt if there is none.
@@ -178,10 +193,8 @@ class MissingGlyphSearcher {
 	 * Reset the search, i.e. begin from the beginning again.
 	 */
 	virtual void Reset() = 0;
-
-	bool FindMissingGlyphs();
 };
 
-void CheckForMissingGlyphs(MissingGlyphSearcher *search = nullptr);
+void CheckForMissingGlyphs(MissingGlyphSearcher *searcher = nullptr);
 
 #endif /* STRINGS_FUNC_H */