hdicoreFont.h

Go to the documentation of this file.

#ifndef __HDI_CORE_FONT__
#define __HDI_CORE_FONT__

#include "hdicoreTypes.h"
    
namespace hdi
{
    namespace plugin
    {
        class Font;
    }

    namespace core
    {
        class Font;
    
        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::auto_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::auto_ptr<Typeface> TypefaceAP;
    
        class Font
        {
            public:
                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
                        };

                        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::auto_ptr<Info> InfoAP;
            
                Font();
            
                Font(const Font& f_);
                
                Font(const AIFontKey aiFont_);

                virtual ~Font();
            
                virtual Font& operator=(const Font& rhs_);
                
                virtual bool operator==(const Font& rhs_) const;
                
                virtual bool operator!=(const Font& rhs_) const;

                virtual AIFontKey aiFontKey() const;

                virtual Info info() const;

                virtual std::string name() const;
                
                virtual std::string familyName() const;
                
                virtual std::string styleName() const;
                
                virtual bool typefaceAndStyle(Typeface& tf__, int32_t& style__);
                
                #if HDI_CORE_COMPILE_AI17_PLUS

                    virtual bool substituted() const;
                #endif


            private:
                friend plugin::Font* __accessImpl(const Font&);
                friend Font __accessCtor(const plugin::Font&);
                
                plugin::Font* __impl;

                Font(const plugin::Font&);
        };
        
        typedef std::auto_ptr<Font> FontAP;

        extern void* __accessImpl(const Typeface&);
        extern plugin::Font* __accessImpl(const Font&);
        extern Font __accessCtor(const plugin::Font&);
    }
}

#endif
// __HDI_CORE_FONT__