Font.h

 
#ifndef PHWIDGETS_FONT_H
#define PHWIDGETS_FONT_H
 
#include "./../service/property.hpp"
#include "./../service/bitmask.hpp"
 
#include <photon/Pf.h>
 
 
#include <string>
#include <vector>
 
namespace PhWidgets
{
    using namespace cppproperties;
 
    namespace Drawing
    {
 
        struct FontStyle
        {
            enum eFontStyle
            {
                Bold = PF_STYLE_BOLD, 
                Italic = PF_STYLE_ITALIC, 
                Regular = 0, 
                Underline = PF_STYLE_ULINE, 
                DoubleUnderline = PF_STYLE_DULINE, 
                Antialias = PF_STYLE_ANTIALIAS, 
                Scalable = PF_SCALABLE, 
                Bitmap = PF_BITMAP 
            };
        };
 
        namespace typedefs
        {
            typedef
            cppbitmasks::bitmask<
                unsigned short,    
                FontStyle::eFontStyle, 
                static_cast<unsigned short>(FontStyle::Antialias)       |
                static_cast<unsigned short>(FontStyle::Bitmap)          |
                static_cast<unsigned short>(FontStyle::Bold)            |
                static_cast<unsigned short>(FontStyle::DoubleUnderline) |
                static_cast<unsigned short>(FontStyle::Italic)          |
                static_cast<unsigned short>(FontStyle::Regular)         |
                static_cast<unsigned short>(FontStyle::Scalable)        |
                static_cast<unsigned short>(FontStyle::Underline)
            > font_style_bitmask;
        }
 
        struct GenericFontFamilies
        {
            enum eGenericFontFamilies
            {
                Monospace = PHFONT_INFO_PROP, 
                SansSerif = PHFONT_INFO_SANSERIF, 
                Serif = PHFONT_INFO_SERIF 
            };
        };
 
 
        class FontCollection
        {
        protected:
            FontCollection() {}
        private:
            struct FontCollectionDetail
            {
                static const std::vector<FontDetails>& getFamilies();
            };
        public:
            static const property<const std::vector<FontDetails>&>::
                bind_static<&FontCollectionDetail::getFamilies> Families;
        };
 
        class InstalledFontCollection:
            public FontCollection
        {
        public:
            InstalledFontCollection();
        };
 
        class PrivateFontCollection;
 
        class FontFamily
        {
        public:
 
            FontFamily(GenericFontFamilies::eGenericFontFamilies ffamily);
 
 
            FontFamily(const FontDetails &fdetails);
 
 
            FontFamily(std::string name);
 
 
            FontFamily(std::string name, const FontCollection &fcollection);
 
 
            FontFamily(const FontFamily &other);
            
 
            FontFamily &operator=(const FontFamily &other);
 
 
            bool operator==(const FontFamily &other) const;
 
 
            bool operator!=(const FontFamily &other) const;
 
 
            bool operator<(const FontFamily &other) const;
 
 
            int GetLineSpacing(typedefs::font_style_bitmask fstyle) const;
 
 
            bool IsStyleAvailable(typedefs::font_style_bitmask fstyle) const;
 
            operator FontDetails() const;
 
        private:
            FontDetails _fdetails;
            std::string _name;
            
        public:
 
            const std::string &Name;
        };
 
        class Font
        {
            typedef FontID* font_id_type;
 
        public:
 
 
            Font(const Font &other, typedefs::font_style_bitmask fstyle);
 
 
            Font(FontFamily ffamily, std::uint32_t size, typedefs::font_style_bitmask fstyle = FontStyle::Regular);
 
 
            Font(font_id_type fid);
 
            //Font(FontFamily, float, FontStyle, GraphicsUnit);     
            //Font(FontFamily, float, GraphicsUnit)            
 
 
            Font(const Font &other);
            
 
            Font &operator=(const Font &other);
 
 
            bool operator==(const Font &other) const;
            
 
            bool operator!=(const Font &other) const;
 
 
            bool operator<(const Font &other) const;
 
            operator const font_id_type() const;
 
 
 
            const bool &Bold;
            
            const FontFamily &Family;
 
            const std::uint32_t &Height;
 
            const bool &Italic;
 
            const std::string &Name;
 
            const std::uint32_t &Size;
            
            // Gets the name of the Font originally specified.
            //const std::string &OriginalFontName;
 
            /*
            
 
            // Gets a byte value that specifies the GDI character set that this Font uses.
            // GdiCharSet   
 
            // Gets a Boolean value that indicates whether this Font is derived from a GDI vertical Font.
            // GdiVerticalFont  
 
            
            // Gets a value indicating whether the Font is a member of SystemFonts.
            // IsSystemFont         
 
                
 
            Gets the em-size of this Font measured in the units specified by the Unit property.
            SizeInPoints    
 
            
            Strikeout   
 
            Gets a value that indicates whether this Font specifies a horizontal line through the Font.
            Style   
 
            Gets style information for this Font.
            SystemFontName  
 
            Gets the name of the system Font if the IsSystemFont property returns true.
            Underline   
 
            Gets a value that indicates whether this Font is underlined.
            Unit    
 
            Gets the unit of measure for this Font.*/
 
            /*Methods
 
            Returns the line spacing, in pixels, of this Font.
            GetHeight()     */
 
        private:
 
            font_id_type _fid;
            std::string _fname;
            bool _bold, _italic;
            std::uint32_t _height, _size;
            FontFamily _ffamily;
        };
 
        bool operator==(const GenericFontFamilies::eGenericFontFamilies &lhs, const FontFamily &rhs);
        bool operator!=(const GenericFontFamilies::eGenericFontFamilies &lhs, const FontFamily &rhs);
        bool operator<(const GenericFontFamilies::eGenericFontFamilies &lhs, const FontFamily &rhs);
    } // namespace Drawing
} // namespace PhWidgets
 
PhWidgets::Drawing::typedefs::font_style_bitmask operator|(const PhWidgets::Drawing::FontStyle::eFontStyle &flag1, const PhWidgets::Drawing::FontStyle::eFontStyle &flag2);
PhWidgets::Drawing::typedefs::font_style_bitmask operator&(const PhWidgets::Drawing::FontStyle::eFontStyle &flag1, const PhWidgets::Drawing::FontStyle::eFontStyle &flag2);
PhWidgets::Drawing::typedefs::font_style_bitmask operator^(const PhWidgets::Drawing::FontStyle::eFontStyle &flag1, const PhWidgets::Drawing::FontStyle::eFontStyle &flag2);
 
#endif // PHWIDGETS_FONT_H