Font.h

Go to the documentation of this file.

/*
    Another significant redesign to update the coding standards to C++17,
    reduce the amount of bare pointer handling (especially in user code),
    and focus on the RaspberryPi environment.
    
    License terms for the changes as well as the base nanogui-sdl code are
    contained int the LICENSE.txt file.
    
    A significant redesign of this code was contributed by Christian Schueller.

    Based on NanoGUI by Wenzel Jakob <wenzel@inf.ethz.ch>.
    Adaptation for SDL by Dalerank <dalerankn8@gmail.com>

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE.txt file.
*/

#pragma once

#include <filesystem>
#include <optional>
#include <memory>
#include <SDL2/SDL_ttf.h>
#include <iostream>
#include <map>
#include <vector>
//#include "Theme.h"
#include "Utilities.h"

namespace rose {

    class FontDestroy {
    public:
        void operator()(TTF_Font *ttfFont) {
            TTF_CloseFont(ttfFont);
        }
    };

    using FontPointer = std::shared_ptr<TTF_Font>;                  
    using FontCacheKey = std::pair<std::string, int>;               
    using FontCacheStore = std::map<FontCacheKey, FontPointer>;     

    inline auto textSizeUTF8(FontPointer &fontPointer, const std::string &text) {
        int w, h;
        TTF_SizeUTF8(fontPointer.get(), text.c_str(), &w, &h);
        return std::make_tuple(w, h);
    }

    class FontCache {
    protected:
        std::vector<std::filesystem::path> mFontPathList{};

        FontCache() {
            std::stringstream strm("/usr/share/fonts:/usr/local/share/fonts");
            std::string rootPathStr{};
            while (getline(strm, rootPathStr, ':')) {
                mFontPathList.emplace_back(rootPathStr);
            }
        }

    public:
        static FontCache& getFontCache() {
            static FontCache instance{};

            return instance;
        }

        template<typename StringType>
        std::optional<std::filesystem::path> locateFont(const std::filesystem::path &path, StringType fontName) {
            for (auto &p : std::filesystem::recursive_directory_iterator(path)) {
                if (p.path().stem() == fontName && p.is_regular_file()) {
                    return p.path();
                }
            }
            return std::nullopt;
        }

        template<typename StringType>
        std::optional<std::filesystem::path> getFontPath(StringType fontName) {
            if (auto found = mFontPathMap.find(fontName); found != mFontPathMap.end())
                return found->second;

            for (auto const &rootPath : mFontPathList) {
                auto fontPath = locateFont(rootPath, fontName);
                if (fontPath) {
                    mFontPathMap[fontName] = fontPath.value();
                    return fontPath;
                }
            }

            return std::nullopt;
        }

        template<typename StringType>
        FontPointer getFont(StringType fontName, int ptSize) {
            if (auto found = mFontCache.find(FontCacheKey{fontName, ptSize}); found != mFontCache.end()) {
                return found->second;
            }

            if (auto fontPath = getFontPath(fontName); fontPath) {
                FontPointer fontPointer{TTF_OpenFont(fontPath.value().c_str(), ptSize), FontDestroy{}};
                auto font = mFontCache.emplace(FontCacheKey{fontName, ptSize}, fontPointer);
                if (font.second) {
                    return font.first->second;
                }
            }

            return nullptr;
        }

    protected:
        std::map<std::string, std::filesystem::path> mFontPathMap;  

        std::map<FontCacheKey, FontPointer> mFontCache;             
    };

    inline std::tuple<int, int, int, int, int> getGlyphMetrics(FontPointer &font, char glyph) {
        int minx{}, maxx{}, miny{}, maxy{}, advance{};
        if (font)
            TTF_GlyphMetrics(font.get(), glyph, &minx, &maxx, &miny, &maxy, &advance);
        return std::make_tuple(minx, maxx, miny, maxy, advance);
    }

    struct FontMetrics {
        int fontAscent,     
        fontDescent,        
        fontHeight,         
        fontLineSkip;       

        constexpr FontMetrics(const FontMetrics &) noexcept = default;
        constexpr FontMetrics(FontMetrics &&) noexcept = default;
        constexpr FontMetrics& operator=(const FontMetrics &) noexcept = default;
        constexpr FontMetrics& operator=(FontMetrics &&) noexcept = default;
    };

    inline auto getFontMetrics(FontPointer &font) {
        FontMetrics fontMetrics{};
        fontMetrics.fontHeight = TTF_FontHeight(font.get());
        fontMetrics.fontAscent = TTF_FontAscent(font.get());
        fontMetrics.fontDescent = TTF_FontDescent(font.get());
        fontMetrics.fontLineSkip = TTF_FontLineSkip(font.get());
        return fontMetrics;
    }

    inline auto fetchFont(FontCache &fontCache, const std::string &fontName, int fontSize) {
        auto font = fontCache.getFont(fontName, fontSize);
        if (!font) {
            font = fontCache.getFont("FreeSans", fontSize);
            if (!font)
                throw std::runtime_error(StringCompositor("Neither font", fontName, " nor default font 'FreeSans' found: ",
                                                          FILE_LOC));
        }
        return font;
    }
}