Font.h

Go to the documentation of this file.

// -*- C++ -*-
/* GG is a GUI for SDL and OpenGL.
   Copyright (C) 2003 T. Zachary Laine

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1
   of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
    
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA

   If you do not wish to comply with the terms of the LGPL please
   contact the author as other terms are available for a fee.
    
   Zach Laine
   whatwasthataddress@hotmail.com */

#ifndef _GG_Font_h_
#define _GG_Font_h_

#include <GG/AlignmentFlags.h>
#include <GG/Texture.h>

#include <set>

#include <boost/serialization/access.hpp>


typedef unsigned long FT_ULong;
struct FT_FaceRec_;
typedef struct FT_FaceRec_*  FT_Face;

namespace GG {

GG_API std::string " from a Clr object with color channels...">RgbaTag(const Clr& c);

GG_FLAG_TYPE(TextFormat);
extern GG_API const TextFormat FORMAT_NONE;        
extern GG_API const TextFormat FORMAT_VCENTER;     
extern GG_API const TextFormat FORMAT_TOP;         
extern GG_API const TextFormat FORMAT_BOTTOM;      
extern GG_API const TextFormat FORMAT_CENTER;      
extern GG_API const TextFormat FORMAT_LEFT;        
extern GG_API const TextFormat FORMAT_RIGHT;       
extern GG_API const TextFormat FORMAT_WORDBREAK;   
extern GG_API const TextFormat FORMAT_LINEWRAP;    
extern GG_API const TextFormat FORMAT_IGNORETAGS;  


class GG_API Font
{
public:
    struct GG_API TextElement
    {
        enum TextElementType {
            OPEN_TAG,   
            CLOSE_TAG,  
            TEXT,       
            WHITESPACE, 
            NEWLINE     
        };

        TextElement(bool ws, bool nl); 
        virtual ~TextElement(); 

        int Width() const;                       
        virtual TextElementType Type() const;    
        virtual int OriginalStringChars() const; 

        std::string      text;       
        std::vector<int> widths;     
        const bool       whitespace; 
        const bool       newline;    

    protected:
        TextElement();

    private:
        friend class boost::serialization::access;
        template <class Archive>
        void serialize(Archive& ar, const unsigned int version);
    };

    struct GG_API FormattingTag : TextElement
    {
        FormattingTag(bool close); 

        virtual TextElementType Type() const;
        virtual int OriginalStringChars() const;

        std::vector<std::string> params;            
        std::string              original_tag_text; 
        const bool               close_tag;         

    private:
        FormattingTag();
        friend class boost::serialization::access;
        template <class Archive>
        void serialize(Archive& ar, const unsigned int version);
    };

    struct GG_API LineData
    {
        LineData(); 

        struct GG_API CharData
        {
            CharData(); 
            CharData(int extent_, int original_index, const std::vector<boost::shared_ptr<TextElement> >& tags_); 

            int extent;              
            int original_char_index; 
            std::vector<boost::shared_ptr<FormattingTag> >
                tags;                

        private:
            friend class boost::serialization::access;
            template <class Archive>
            void serialize(Archive& ar, const unsigned int version);
        };

        int         Width() const; 
        bool        Empty() const; 

        std::vector<CharData> char_data;     
        Alignment             justification; 

    private:
        friend class boost::serialization::access;
        template <class Archive>
        void serialize(Archive& ar, const unsigned int version);
    };

    struct GG_API RenderState
    {
        RenderState(); 

        bool    ignore_tags;        
        bool    use_italics;        
        bool    draw_underline;     
        bool    color_set;          
        Clr     curr_color;         
    };

    enum GlyphRange {
        NUMBER =             1 << 0,    
        ALPHA_UPPER =        1 << 1,    
        ALPHA_LOWER =        1 << 2,    
        SYMBOL =             1 << 3,    
        ALL_DEFINED_RANGES = NUMBER | ALPHA_UPPER | ALPHA_LOWER | SYMBOL, 
        ALL_CHARS =          (1 << 5) - 1 
    };
 

    Font(const std::string& font_filename, int pts, unsigned int range = ALL_DEFINED_RANGES);
    virtual ~Font(); 

 
    const std::string&FontName() const;   
    int               PointSize() const;  

    int               GetGlyphRange() const;

    int               Ascent() const;     
    int               Descent() const;    
    int               Height() const;     
    int               Lineskip() const;   
    int               SpaceWidth() const; 
    int               RenderGlyph(const Pt& pt, char c) const; 
    int               RenderGlyph(int x, int y, char c) const; 
    int               RenderText(const Pt& pt, const std::string& text) const; 
    int               RenderText(int x, int y, const std::string& text) const; 
    void              RenderText(const Pt& pt1, const Pt& pt2, const std::string& text, Flags<TextFormat>& format, const std::vector<LineData>* line_data = 0, RenderState* render_state = 0) const; 
    void              RenderText(int x1, int y1, int x2, int y2, const std::string& text, Flags<TextFormat>& format, const std::vector<LineData>* line_data = 0, RenderState* render_state = 0) const; 
    void              RenderText(const Pt& pt1, const Pt& pt2, const std::string& text, Flags<TextFormat>& format, const std::vector<LineData>& line_data, RenderState& render_state, int begin_line, int begin_char, int end_line, int end_char) const; 
    void              RenderText(int x1, int y1, int x2, int y2, const std::string& text, Flags<TextFormat>& format, const std::vector<LineData>& line_data, RenderState& render_state, int begin_line, int begin_char, int end_line, int end_char) const; 
    Pt                DetermineLines(const std::string& text, Flags<TextFormat>& format, int box_width, std::vector<LineData>& lines) const; 
    Pt                TextExtent(const std::string& text, Flags<TextFormat> format = FORMAT_NONE, int box_width = 0) const; 


    static void       RegisterKnownTag(const std::string& tag);   
    static void       RemoveKnownTag(const std::string& tag);     
    static void       ClearKnownTags();                      
 

    GG_ABSTRACT_EXCEPTION(Exception);

    GG_CONCRETE_EXCEPTION(BadFile, GG::Font, Exception);

    GG_CONCRETE_EXCEPTION(InvalidPointSize, GG::Font, Exception);

    GG_CONCRETE_EXCEPTION(InvalidRangeFlags, GG::Font, Exception);

    GG_CONCRETE_EXCEPTION(UnscalableFont, GG::Font, Exception);

    GG_CONCRETE_EXCEPTION(BadFace, GG::Font, Exception);

    GG_CONCRETE_EXCEPTION(BadPointSize, GG::Font, Exception);

    GG_CONCRETE_EXCEPTION(BadGlyph, GG::Font, Exception);

protected: 
    Font(); 


private:
    struct Glyph
    {
        Glyph() : left_bearing(0), advance(0), width(0) {} 
        Glyph(const boost::shared_ptr<Texture>& texture, int x1, int y1, int x2, int y2, int lb, int adv) : 
            sub_texture(texture, x1, y1, x2, y2), left_bearing(lb), advance(adv), width(x2 - x1) {} 

        SubTexture  sub_texture;   
        int         left_bearing;  
        int         advance;       
        int         width;         
    };
    struct HandleTagFunctor;

    void              Init(const std::string& font_filename, int pts, unsigned int range);
    bool              GenerateGlyph(FT_Face font, FT_ULong ch);
    inline int        RenderGlyph(int x, int y, const Glyph& glyph, const RenderState* render_state) const;
    void              HandleTag(const boost::shared_ptr<FormattingTag>& tag, double* orig_color, RenderState& render_state) const;

    std::string          m_font_filename;
    int                  m_pt_sz;
    int                  m_glyph_range; 
    int                  m_ascent;      
    int                  m_descent;     
    int                  m_height;      
    int                  m_lineskip;    
    double               m_underline_offset; 
    double               m_underline_height; 
    double               m_italics_offset;   
    int                  m_space_width; 
    std::map<FT_ULong, Glyph>
                         m_glyphs;      
    std::vector<boost::shared_ptr<Texture> >
                         m_textures;    

    static std::set<std::string>   s_action_tags; 
    static std::set<std::string>   s_known_tags;  

    friend struct HandleTagFunctor;

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};

// define EnumMap and stream operators for Font::GlyphRange
GG_ENUM_MAP_BEGIN(Font::GlyphRange)
    GG_ENUM_MAP_INSERT(Font::NUMBER)
    GG_ENUM_MAP_INSERT(Font::ALPHA_UPPER)
    GG_ENUM_MAP_INSERT(Font::ALPHA_LOWER)
    GG_ENUM_MAP_INSERT(Font::SYMBOL)
    GG_ENUM_MAP_INSERT(Font::ALL_DEFINED_RANGES)
    GG_ENUM_MAP_INSERT(Font::ALL_CHARS)
GG_ENUM_MAP_END

GG_ENUM_STREAM_IN(Font::GlyphRange)
GG_ENUM_STREAM_OUT(Font::GlyphRange)


class GG_API FontManager
{
private:
    struct FontKey
    {
        FontKey(const std::string& str, int pts); 
        bool operator<(const FontKey& rhs) const; 

        std::string filename;   
        int         points;     
    };

public: 
    boost::shared_ptr<Font> GetFont(const std::string& font_filename, int pts, unsigned int range = Font::ALL_DEFINED_RANGES); 
    void                    FreeFont(const std::string& font_filename, int pts); 


private:
    FontManager();

    std::map<FontKey, boost::shared_ptr<Font> > m_rendered_fonts;

    friend FontManager& GetFontManager();
};

FontManager& GetFontManager();

GG_EXCEPTION(FailedFTLibraryInit);

} // template GG

// template implementations
template <class Archive>
void GG::Font::TextElement::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(text)
        & BOOST_SERIALIZATION_NVP(widths)
        & boost::serialization::make_nvp("whitespace", const_cast<bool&>(whitespace))
        & boost::serialization::make_nvp("newline", const_cast<bool&>(newline));
}

template <class Archive>
void GG::Font::FormattingTag::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(TextElement)
        & BOOST_SERIALIZATION_NVP(params)
        & BOOST_SERIALIZATION_NVP(original_tag_text)
        & boost::serialization::make_nvp("close_tag", const_cast<bool&>(close_tag));
}

template <class Archive>
void GG::Font::LineData::CharData::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(extent)
        & BOOST_SERIALIZATION_NVP(original_char_index)
        & BOOST_SERIALIZATION_NVP(tags);
}

template <class Archive>
void GG::Font::LineData::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(char_data)
        & BOOST_SERIALIZATION_NVP(justification);
}

template <class Archive>
void GG::Font::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(m_font_filename)
        & BOOST_SERIALIZATION_NVP(m_pt_sz)
        & BOOST_SERIALIZATION_NVP(m_glyph_range);

    if (Archive::is_loading::value) {
        if (!m_font_filename.empty() && 0 < m_pt_sz) {
            try {
                Init(m_font_filename, m_pt_sz, m_glyph_range);
            } catch (const Exception& e) {
                // take no action; the Font must have been uninitialized when saved
            }
        }
    }
}

#endif // _GG_Font_h_

---