PdfFont.h

 
#ifndef PDF_FONT_H
#define PDF_FONT_H
 
#include "PdfDeclarations.h"
 
#include "PdfTextState.h"
#include "PdfName.h"
#include "PdfEncoding.h"
#include "PdfElement.h"
#include "PdfFontMetrics.h"
 
namespace PoDoFo {
 
class PdfCharCodeMap;
 
struct PODOFO_API PdfFontCreateParams final
{
    PdfEncoding Encoding;
    PdfFontCreateFlags Flags = PdfFontCreateFlags::None;
};
 
struct PODOFO_API PdfSplittedString final
{
    PdfString String;
    bool IsSeparator = false;
};
 
class PODOFO_API PdfFont : public PdfDictionaryElement
{
    friend class PdfFontSimple;
    friend class PdfFontCID;
    friend class PdfFontFactory;
    friend class PdfFontObject;
    friend class PdfEncoding;
    friend class PdfFontManager;
 
private:
    PdfFont(PdfDocument& doc, const PdfFontMetricsConstPtr& metrics,
        const PdfEncoding& encoding);
 
    PdfFont(PdfObject& obj, const PdfFontMetricsConstPtr& metrics,
        const PdfEncoding& encoding);
 
public:
    virtual ~PdfFont();
 
public:
    static bool TryCreateFromObject(PdfObject& obj, std::unique_ptr<PdfFont>& font);
    static bool TryCreateFromObject(const PdfObject& obj, std::unique_ptr<const PdfFont>& font);
 
private:
    static std::unique_ptr<PdfFont> Create(PdfDocument& doc, const PdfFontMetricsConstPtr& metrics,
        const PdfFontCreateParams& createParams, bool isProxy = false);
 
    static std::unique_ptr<PdfFont> CreateStandard14(PdfDocument& doc, PdfStandard14FontType std14Font,
        const PdfFontCreateParams& createParams);
 
public:
    bool TryCreateProxyFont(PdfFont*& proxyFont) const;
    bool TryCreateProxyFont(PdfFontCreateFlags initFlags, PdfFont*& proxyFont) const;
 
    void WriteStringToStream(OutputStream& stream, const std::string_view& str) const;
 
    unsigned GetGID(char32_t codePoint, PdfGlyphAccess access) const;
    bool TryGetGID(char32_t codePoint, PdfGlyphAccess access, unsigned& gid) const;
 
    double GetStringLength(const std::string_view& str, const PdfTextState& state) const;
 
    bool TryGetStringLength(const std::string_view& str, const PdfTextState& state, double& width) const;
 
    double GetEncodedStringLength(const PdfString& encodedStr, const PdfTextState& state) const;
 
    bool TryGetEncodedStringLength(const PdfString& encodedStr, const PdfTextState& state, double& length) const;
 
    bool TryScanEncodedString(const PdfString& encodedStr, const PdfTextState& state, std::string& utf8str,
        std::vector<double>& lengths, std::vector<unsigned>& positions) const;
 
    double GetWordSpacingLength(const PdfTextState& state) const;
 
    double GetSpaceCharLength(const PdfTextState& state) const;
 
    double GetCharLength(char32_t codePoint, const PdfTextState& state, bool ignoreCharSpacing = false) const;
 
    bool TryGetCharLength(char32_t codePoint, const PdfTextState& state, bool ignoreCharSpacing, double& width) const;
 
    bool TryGetCharLength(char32_t codePoint, const PdfTextState& state, double& width) const;
 
    double GetDefaultCharLength(const PdfTextState& state, bool ignoreCharSpacing = false) const;
 
    // TODO: Implement me
    //std::vector<PdfSplittedString> SplitEncodedString(const PdfString& str) const;
 
    void AddSubsetCIDs(const PdfString& encodedStr);
 
    bool HasCIDSubset() const;
 
    double GetCIDWidth(unsigned cid) const;
 
    double GetLineSpacing(const PdfTextState& state) const;
 
    double GetUnderlineThickness(const PdfTextState& state) const;
 
    double GetUnderlinePosition(const PdfTextState& state) const;
 
    double GetStrikeThroughPosition(const PdfTextState& state) const;
 
    double GetStrikeThroughThickness(const PdfTextState& state) const;
 
    double GetAscent(const PdfTextState& state) const;
 
    double GetDescent(const PdfTextState& state) const;
 
    virtual bool SupportsSubsetting() const;
 
    virtual PdfFontType GetType() const = 0;
 
    bool IsStandard14Font() const;
 
    bool IsStandard14Font(PdfStandard14FontType& std14Font) const;
 
    static std::string_view GetStandard14FontName(PdfStandard14FontType stdFont);
 
    static bool IsStandard14Font(const std::string_view& fontName, PdfStandard14FontType& stdFont);
 
    static bool IsStandard14Font(const std::string_view& fontName, bool useAltNames, PdfStandard14FontType& stdFont);
 
public:
    bool IsCIDFont() const;
 
    virtual bool IsObjectLoaded() const;
 
    inline bool IsSubsettingEnabled() const { return m_SubsettingEnabled; }
 
    inline bool IsEmbeddingEnabled() const { return m_EmbeddingEnabled; }
 
    inline std::string_view GetSubsetPrefix() const;
 
    inline const PdfEncoding& GetEncoding() const { return *m_Encoding; }
 
    inline const PdfFontMetrics& GetMetrics() const { return *m_Metrics; }
 
    inline const std::string& GetName() const { return m_Name; }
 
    inline bool IsProxy() const { return m_IsProxy; }
 
    PdfObject& GetDescendantFontObject();
 
protected:
    void EmbedFontFile(PdfObject& descriptor);
    void EmbedFontFileType1(PdfObject& descriptor, const bufferview& data,
        unsigned length1, unsigned length2, unsigned length3);
    void EmbedFontFileCFF(PdfObject& descriptor, const bufferview& data, bool cidKeyed);
    void EmbedFontFileTrueType(PdfObject& descriptor, const bufferview& data);
    void EmbedFontFileOpenType(PdfObject& descriptor, const bufferview& data);
 
    bool tryMapCIDToGIDLoadedMetrics(unsigned cid, unsigned& gid) const;
 
    bool tryMapCIDToGIDUnicode(unsigned cid, unsigned& gid) const;
 
    void GetBoundingBox(PdfArray& arr) const;
 
    void FillDescriptor(PdfDictionary& dict) const;
 
    bool TryGetSubstituteCIDEncoding(std::unique_ptr<PdfEncodingMap>& cidEncodingMap) const;
 
    PdfCIDSystemInfo GetCIDSystemInfo() const;
 
    std::vector<PdfCharGIDInfo> GetCharGIDInfos();
 
    virtual PdfObject* getDescendantFontObject();
 
    virtual void initImported();
 
    virtual void embedFont();
 
    virtual void embedFontSubset();
 
private:
    PdfFont(const PdfFont& rhs) = delete;
 
private:
    void EmbedFont();
 
    void InitImported(bool wantEmbed, bool wantSubset, bool isProxy);
 
    bool TryAddSubsetGID(unsigned gid, const unicodeview& codePoints, PdfCID& cid);
 
    PdfCharCode AddCharCodeSafe(unsigned gid, const unicodeview& codePoints);
 
    bool TryMapCIDToGID(unsigned cid, PdfGID& gid) const;
    bool TryMapCIDToGID(unsigned cid, PdfGlyphAccess access, unsigned& gid) const;
 
private:
    struct CIDSubsetInfo
    {
        PdfGID Gid;                     
        PdfCharCodeList Codes;          
    };
 
    using CIDSubsetMap = std::map<unsigned, CIDSubsetInfo>;
 
    bool tryConvertToGIDs(const std::string_view& utf8Str, PdfGlyphAccess access, std::vector<unsigned>& gids) const;
    bool tryAddSubsetGID(unsigned gid, const unicodeview& codePoints, PdfCID& cid);
 
    void initBase(const PdfEncoding& encoding);
 
    double getStringLength(const std::vector<PdfCID>& cids, const PdfTextState& state) const;
 
    void embedFontFileData(PdfObject& descriptor, const PdfName& fontFileName,
        const std::function<void(PdfDictionary& dict)>& dictWriter, const bufferview& data);
 
    static std::unique_ptr<PdfFont> createFontForType(PdfDocument& doc, const PdfFontMetricsConstPtr& metrics,
        const PdfEncoding& encoding, PdfFontFileType type, bool preferNonCID);
 
    void initSpaceDescriptors();
 
    void pushSubsetInfo(unsigned cid, const PdfGID& gid, const PdfCharCode& code);
 
private:
    std::string m_Name;
    std::string m_SubsetPrefix;
    bool m_EmbeddingEnabled;
    bool m_IsEmbedded;
    bool m_SubsettingEnabled;
    bool m_IsProxy;
    std::unique_ptr<CIDSubsetMap> m_subsetCIDMap;
    std::unique_ptr<std::unordered_map<unsigned, unsigned>> m_subsetGIDToCIDMap;
    PdfCIDToGIDMapConstPtr m_fontProgCIDToGIDMap;
    double m_WordSpacingLengthRaw;
    double m_SpaceCharLengthRaw;
 
protected:
    PdfFontMetricsConstPtr m_Metrics;
    std::unique_ptr<PdfEncoding> m_Encoding;
    std::shared_ptr<PdfCharCodeMap> m_DynamicCIDMap;
    std::shared_ptr<PdfCharCodeMap> m_DynamicToUnicodeMap;
};
 
};
 
#endif // PDF_FONT_H