PdfFontManager.h

// SPDX-FileCopyrightText: 2007 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2020 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_FONT_CACHE_H
#define PDF_FONT_CACHE_H
 
#include "PdfDeclarations.h"
 
#include "PdfFont.h"
#include "PdfEncodingFactory.h"
 
#ifdef PODOFO_HAVE_FONTCONFIG
#include "PdfFontConfigWrapper.h"
#endif
 
#if defined(_WIN32) && defined(PODOFO_HAVE_WIN32GDI)
// To have LOGFONTW available
typedef struct HFONT__* HFONT;
#endif
 
namespace PoDoFo {
 
class PdfResources;
 
struct PODOFO_API PdfFontSearchParams final
{
    nullable<PdfFontStyle> Style;
    PdfFontAutoSelectBehavior AutoSelect = PdfFontAutoSelectBehavior::None;
    PdfFontMatchBehaviorFlags MatchBehavior = PdfFontMatchBehaviorFlags::None;
    std::string FontFamilyPattern;
 
    std::function<PdfFont* (const std::vector<PdfFont*>)> FontSelector;
};
 
class PODOFO_API PdfFontManager final
{
    friend class PdfDocument;
    friend class PdfMemDocument;
    friend class PdfStreamedDocument;
    friend class PdfFont;
    friend class PdfCommon;
    friend class PdfResources;
 
public:
    PdfFont* SearchFont(const std::string_view& fontPattern,
        const PdfFontSearchParams& searchParams = { }, const PdfFontCreateParams& createParams = { });
 
    PdfFont* SearchFont(const std::string_view& fontPattern, const PdfFontCreateParams& createParams);
 
    PdfFont& GetStandard14Font(PdfStandard14FontType stdFont,
        const PdfFontCreateParams& params = { });
 
    PdfFont& GetOrCreateFont(const std::string_view& fontPath, unsigned faceIndex,
        const PdfFontCreateParams& params = { });
 
    PdfFont& GetOrCreateFontFromBuffer(const bufferview& buffer, unsigned faceIndex,
        const PdfFontCreateParams& params = { });
 
    PdfFont& GetOrCreateFont(const std::string_view& fontPath,
        const PdfFontCreateParams& params = { });
 
    PdfFont& GetOrCreateFontFromBuffer(const bufferview& buffer,
        const PdfFontCreateParams& params = { });
 
    PdfFont& GetOrCreateFont(PdfFontMetricsConstPtr metrics,
        const PdfFontCreateParams& params = { });
 
    PdfFont* GetCachedFont(const PdfReference& ref);
 
    static PdfFontMetricsConstPtr SearchFontMetrics(const std::string_view& fontPattern,
        const PdfFontSearchParams& params = { });
 
#if defined(_WIN32) && defined(PODOFO_HAVE_WIN32GDI)
    PdfFont& GetOrCreateFont(HFONT font, const PdfFontCreateParams& params = { });
#endif
 
#ifdef PODOFO_HAVE_FONTCONFIG
    static void SetFontConfigWrapper(const std::shared_ptr<PdfFontConfigWrapper>& fontConfig);
 
    static PdfFontConfigWrapper& GetFontConfigWrapper();
#endif // PODOFO_HAVE_FONTCONFIG
 
    void EmbedFonts();
 
    // These methods are reserved to use to selected friend classes
private:
    PdfFontManager(PdfDocument& doc);
 
private:
    const PdfFont* GetLoadedFont(const PdfResources& resources, const std::string_view& name);
 
    void Clear();
 
    PdfFont* AddImported(std::unique_ptr<PdfFont>&& font);
 
    std::string GenerateSubsetPrefix();
 
    static void AddFontDirectory(const std::string_view& path);
 
    static PdfFontMetricsConstPtr SearchFontMetrics(const std::string_view& fontPattern,
        const PdfFontSearchParams& params, const PdfFontMetrics& metrics, bool skipNormalization);
 
private:
    struct Descriptor
    {
        Descriptor(const std::string_view& name, PdfStandard14FontType stdType,
            const PdfEncoding& encoding, bool hasFontStyle, PdfFontStyle style);
 
        Descriptor(const Descriptor& rhs) = default;
 
        const std::string Name;               
        const PdfStandard14FontType StdType;
        const unsigned EncodingId;
        const bool HasFontStyle;
        const PdfFontStyle Style;
    };
 
    struct PathDescriptor
    {
        PathDescriptor(const std::string_view& filepath, unsigned faceIndex, const PdfEncoding& encoding);
 
        PathDescriptor(const PathDescriptor& rhs) = default;
 
        const std::string FilePath;
        const unsigned FaceIndex;
        const unsigned EncodingId;
    };
 
    struct HashElement
    {
        size_t operator()(const Descriptor& elem) const;
        size_t operator()(const PathDescriptor& elem) const;
    };
 
    struct EqualElement
    {
        bool operator()(const Descriptor& lhs, const Descriptor& rhs) const;
        bool operator()(const PathDescriptor& lhs, const PathDescriptor& rhs) const;
    };
 
    using CachedPaths = std::unordered_map<PathDescriptor, PdfFont*, HashElement, EqualElement>;
    using CachedQueries = std::unordered_map<Descriptor, std::vector<PdfFont*>, HashElement, EqualElement>;
 
    struct Storage
    {
        bool IsLoaded;
        std::unique_ptr<PdfFont> Font;
    };
 
    using FontMap = std::unordered_map<PdfReference, Storage>;
 
private:
    static std::unique_ptr<const PdfFontMetrics> searchFontMetrics(const std::string_view& fontName,
        const PdfFontSearchParams& params, const PdfFontMetrics* refMetrics, bool skipNormalization);
    PdfFont* getImportedFont(const std::string_view& pattern,
        const PdfFontSearchParams& searchParams, const PdfFontCreateParams& createParams);
    PdfFont* addImported(std::vector<PdfFont*>& fonts, std::unique_ptr<PdfFont>&& font);
    PdfFont& getOrCreateFontHashed(PdfFontMetricsConstPtr&& metrics, const PdfFontCreateParams& params);
 
private:
    PdfFontManager(const PdfFontManager&) = delete;
    PdfFontManager& operator=(const PdfFontManager&) = delete;
 
private:
    PdfDocument* m_doc;
    std::string m_currentPrefix;
 
    // Map of cached font queries
    CachedQueries m_cachedQueries;
 
    // Map of cached font paths
    CachedPaths m_cachedPaths;
 
    // Map of all indirect fonts
    FontMap m_fonts;
 
    // Map of all invalid inline fonts
    std::unordered_map<std::string, std::unique_ptr<PdfFont>> m_inlineFonts;
 
#ifdef PODOFO_HAVE_FONTCONFIG
    static std::shared_ptr<PdfFontConfigWrapper> m_fontConfig;
#endif
};
 
};
 
#endif // PDF_FONT_CACHE_H