hdicoreFont.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_FONT__
#define __HDI_CORE_FONT__
 
#include "hdicoreTypes.h"
    
namespace hdi
{
    #if defined(HDI_CORE_AIP_MODE)
        namespace aip
        {
            class Font;
        }
    #elif defined(HDI_CORE_PSP_MODE)
        namespace psp
        {
            class Font;
        }
    #endif
 
    namespace core
    {
        class Font;
    
        #if defined(HDI_CORE_AIP_MODE)
            class Typeface
            {
                public:
                    Typeface();
                
                    Typeface(const Typeface& tf_);

                    Typeface(const AITypefaceKey aiTF_);

                    virtual ~Typeface();
                    
                    virtual Typeface& operator=(const Typeface& rhs_);

                    virtual bool isEmpty() const;

                    virtual AITypefaceKey aiTypefaceKey() const;
                    
                    virtual bool operator==(const Typeface& rhs_) const;
                    
                    virtual bool operator!=(const Typeface& rhs_) const;
                    
                    virtual int32_t styleCount() const;
                    
                    virtual std::unique_ptr<Font> styleAtIndex(const int32_t index_);

                    virtual std::string name() const;
 
 
                private:
                    friend void* __accessImpl(const Typeface&);

                    void* __data;
                    
                    void* __impl() const;
            };
            
            typedef std::unique_ptr<Typeface> TypefaceUP;
            typedef std::shared_ptr<Typeface> TypefaceSP;
            typedef std::weak_ptr<Typeface> TypefaceWP;
        #endif
        // HDI_CORE_AIP_MODE
    
        class Font
        {
            public:
                #if defined(HDI_CORE_AIP_MODE)
                    class Info
                    {
                        public:
                            enum Format
                            {
                                UnknownFormat   = 0,
                                TypeOneFormat   = 10,
                                TrueTypeFormat  = 20
                            };
                            
                            enum Encoding
                            {
                                UnknownEncoding     = 0,
                                DontCareEncoding    = 10,
                                StandardEncoding    = 20,
                                SpecialEncoding     = 30
                            };
                            
                            enum Script
                            {
                                UnknownScript               = 0,
                                NativeScript                = 10,
                                RomanScript                 = 20,
                                JapaneseScript              = 30,
                                ChineseTraditionalScript    = 40,
                                ChineseSimplifiedScript     = 50,
                                KoreanScript                = 60,
                                ArabicScript                = 70,
                                HebrewScript                = 80,
                                GreekScript                 = 90,
                                CyrillicScript              = 100,
                                EastEuropeanRomanScript     = 110,
                                TurkishScript               = 120,
                                BalticScript                = 130,
                                SymbolScript                = 140,
                                EmojiScript                 = 150
                            };

                            enum MojiZumeType
                            {
                                MojiZumeUnknown     = 0,
                                MojiZumeNone        = 10,
                                MojiZumeGXTrueType  = 20,
                                MojiZumePageMakerJ  = 30,
                                MojiZumeSfntATM     = 40
                            };

                            Format format;
                            
                            Encoding encoding;
                            
                            Script script;
                            
                            bool originalEncoding;
                            
                            bool familyInstalled;
                            
                            bool fauxedInstalled;
                            
                            bool isCID;
                            
                            MojiZumeType mojiZumeType;
                            
                            bool isOTF;
                            
                            bool isBitmap;
                            
                            bool isOCF;
                            
                            bool isATC;
                            
                            bool isMultipleMaster;
                            
                            Info();
                            
                            virtual ~Info();
                    };
            
                    typedef std::unique_ptr<Info> InfoUP;
                    typedef std::shared_ptr<Info> InfoSP;
                    typedef std::weak_ptr<Info> InfoWP;
                #endif
                // HDI_CORE_AIP_MODE
            
                Font();
            
                Font(const Font& f_);
                
                #if defined(HDI_CORE_AIP_MODE)
                    Font(const AIFontKey aiFont_);
                #endif
                // HDI_CORE_AIP_MODE

                virtual ~Font();
            
                virtual Font& operator=(const Font& rhs_);
                
                virtual bool operator==(const Font& rhs_) const;
                
                virtual bool operator!=(const Font& rhs_) const;
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual AIFontKey aiFontKey() const;
                    
                    virtual Info info() const;
                
                    virtual bool typefaceAndStyle(Typeface& tf__, int32_t& style__);
                    
                    virtual bool substituted() const;
                #endif
                // HDI_CORE_AIP_MODE

                virtual std::string name() const;
                
                virtual std::string familyName() const;
                
                virtual std::string styleName() const;

                virtual std::string postScriptName() const;
            
                virtual PlatformFontPtr platformFont(const double size_) const;
 
 
            private:
                #if defined(HDI_CORE_AIP_MODE)
                    friend aip::Font* __accessImpl(const Font&);
                    friend Font __accessCtor(const aip::Font&);
                    
                    aip::Font* __impl;

                    Font(const aip::Font&);
                #elif defined(HDI_CORE_PSP_MODE)
                    friend psp::Font* __accessImpl(const Font&);
                    friend Font __accessCtor(const psp::Font&);
                    
                    psp::Font* __impl;

                    Font(const psp::Font&);
                #endif
        };
        
        typedef std::unique_ptr<Font> FontUP;
        typedef std::shared_ptr<Font> FontSP;
        typedef std::weak_ptr<Font> FontWP;
 
        #if defined(HDI_CORE_AIP_MODE)
            extern void* __accessImpl(const Typeface&);
            extern aip::Font* __accessImpl(const Font&);
            extern Font __accessCtor(const aip::Font&);
        #elif defined(HDI_CORE_PSP_MODE)
            extern psp::Font* __accessImpl(const Font&);
            extern Font __accessCtor(const psp::Font&);
        #endif
    }
}
 
#endif
// __HDI_CORE_FONT__