Font.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2012 by PDFTron Systems Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

#ifndef   H_CPPPDFFont
#define   H_CPPPDFFont

#include <Common/Matrix2D.h>
#include <Common/UString.h>
#include <Common/Iterator.h>
#include <PDF/Rect.h>
#include <PDF/PathData.h>
#include <C/PDF/TRN_Font.h>
#include <C/SDF/TRN_SDFDoc.h>
#include <vector>

namespace pdftron {
        namespace PDF {

class Font
{
public:

        enum StandardType1Font
        {
                e_times_roman = 0,
                e_times_bold,
                e_times_italic,
                e_times_bold_italic,
                e_helvetica,
                e_helvetica_bold,
                e_helvetica_oblique,
                e_helvetica_bold_oblique,
                e_courier,
                e_courier_bold,
                e_courier_oblique,
                e_courier_bold_oblique,
                e_symbol, 
                e_zapf_dingbats,
                e_null                          // not a standard font
        };

         Font (SDF::Obj font_dict = 0);

         static Font Create(SDF::SDFDoc& doc, StandardType1Font type, bool embed = false );

         static Font CreateTrueTypeFont(SDF::SDFDoc& doc, const UString& font_path, 
                bool embed=true, bool subset=true);

        #ifdef _WIN32
         static Font CreateTrueTypeFont2(SDF::SDFDoc& doc, const void* logfont, 
                bool embed=true, bool subset=true);
        #endif

         static Font CreateCIDTrueTypeFont(SDF::SDFDoc& doc, const UString& font_path, 
                bool embed = true, bool subset = true, 
                const char* encoding = "Identity-H");

        #ifdef _WIN32
         static Font CreateCIDTrueTypeFont2(SDF::SDFDoc& doc, const void* logfont, 
                bool embed = true, bool subset = true, 
                const char* encoding = "Identity-H");
        #endif

         static Font CreateType1Font(SDF::SDFDoc& doc, const UString& font_path, bool embed = true);

        // Common Font methods ----------------------------------------------------------

        enum Type
        {
                e_Type1,                        // Type 1 PostScript font       
                e_TrueType,                     // TrueType font
                e_MMType1,                      // Type 1 multiple master PostScript font
                e_Type3,                        // Type 3 PostScript font
                e_Type0,                        // Type 0 PostScript composite (CID) font
                e_CIDType0,                     // Type 0 CID font
                e_CIDType2,                     // Type 2 CID font
        };


         Font(const Font& c);
         Font& operator=(const Font& c);

         Type GetType();

         bool IsSimple();

#ifndef SWIG

         static Type GetType(SDF::Obj font_dict);
#endif

         SDF::Obj GetSDFObj ();

         SDF::Obj GetDescriptor();

         const char* GetName();

         const char* GetFamilyName();

         bool IsFixedWidth();

         bool IsSerif();

         bool IsSymbolic();

         bool IsItalic();

         bool IsAllCap();

         bool IsForceBold();

         bool IsHorizontalMode();

         double GetWidth(UInt32 char_code) const;

         double GetMaxWidth();

         double GetMissingWidth();

         Common::Iterator<UInt32> GetCharCodeIterator();


        PathData GetGlyphPath(UInt32 char_code,
                                          bool conics2cubics, 
                                          Common::Matrix2D* transform = 0);

#ifndef SWIG

         bool GetGlyphPath(UInt32 char_code,
                                          std::vector<UChar>& out_oprs, 
                                          std::vector<double>& out_data, 
                                          bool conics2cubics, 
                                          Common::Matrix2D* transform = 0);
#endif

         UString MapToUnicode(UInt32 char_code);

#ifndef SWIG
         bool MapToUnicode(UInt32 char_code, 
                        Unicode* out_uni_arr, const int in_uni_sz, 
                        int &out_chars);
#endif

#ifndef SWIG

         const char** GetEncoding();
#endif

         bool IsEmbedded();

         const char* GetEmbeddedFontName();

         SDF::Obj GetEmbeddedFont();

         int GetEmbeddedFontBufSize();

         UInt16 GetUnitsPerEm();

         Rect GetBBox();

         double GetAscent();

         double GetDescent();


        // Type1 specific methods -------------------------------------------------------

         int GetStandardType1FontType();

         bool IsCFF();

        // Type3 specific methods -------------------------------------------------------

         Common::Matrix2D GetType3FontMatrix();

         SDF::Obj GetType3GlyphStream(UInt32 char_code);


        // Type0 specific methods -------------------------------------------------------


         std::vector<double> GetVerticalAdvance(UInt32 char_code);

#ifndef SWIG
         double GetVerticalAdvance(UInt32 char_code, double &out_pos_vect_x, double &out_pos_vect_y);
#endif

         Font GetDescendant();

         UInt32 MapToCID(UInt32 char_code) const;

#ifndef SWIG

         int MapToCID(const UChar* char_data, int char_data_avail, UInt32& out_charcode, UInt32& out_cid) const;
#endif

         void Destroy();

#ifndef SWIGHIDDEN
        Font(TRN_Font impl);
        ~Font();        
        TRN_Font mp_font;
#endif
};


#include <Impl/Font.inl>

        };      // namespace PDF
};      // namespace pdftron

#endif

---

© 2002-2012 PDFTron Systems Inc.