llfont.h

Go to the documentation of this file.

#ifndef LL_LLFONT_H
#define LL_LLFONT_H

#include <map>
//#include "lllocalidhashmap.h"
#include "llmemory.h"
#include "llstl.h"

class LLImageRaw;
class LLFontManager;
class LLFont;

// Hack.  FT_Face is just a typedef for a pointer to a struct,
// but there's no simple forward declarations file for FreeType, 
// and the main include file is 200K.  
// We'll forward declare the struct here.  JC
struct FT_FaceRec_;
typedef struct FT_FaceRec_* LLFT_Face;

extern LLFontManager *gFontManagerp;

class LLFontManager
{
public:
        static void initClass();
        static void cleanupClass();
        
public:
        LLFontManager();
        virtual ~LLFontManager();
};

class LLFontGlyphInfo
{
public:
        LLFontGlyphInfo(U32 index);
public:
        U32 mGlyphIndex;
        // Metrics
        S32 mWidth;                     // In pixels
        S32 mHeight;            // In pixels
        F32 mXAdvance;          // In pixels
        F32 mYAdvance;          // In pixels

        // Information for actually rendering
        BOOL mIsRendered;       // We actually have rendered this glyph
        S32 mXBitmapOffset; // Offset to the origin in the bitmap
        S32 mYBitmapOffset; // Offset to the origin in the bitmap
        S32 mXBearing;  // Distance from baseline to left in pixels
        S32 mYBearing;  // Distance from baseline to top in pixels
};

// Used for lists of fallback fonts
class LLFontList : public std::vector<LLFont*>
{
public:
        LLFontList();
        ~LLFontList();
        void addAtEnd(LLFont *font);
};


class LLFont
{
public:
        LLFont(LLImageRaw *imagep = NULL);
        virtual ~LLFont();

        // is_fallback should be true for fallback fonts that aren't used to render directly (Unicode backup, primarily)
        virtual BOOL loadFace(const std::string& filename,
                                                        const F32 point_size,
                                                        const F32 vert_dpi,
                                                        const F32 horz_dpi,
                                                        const S32 components,
                                                        BOOL is_fallback);
        void setFallbackFont(LLFontList *fontp)         { mFallbackFontp = fontp; }

        void setCharToGlyphMap(llwchar wch, U32 glyph_index) const;
        void setRawImage( LLImageRaw *imagep );

        // Global font metrics - in units of pixels
        virtual F32 getLineHeight() const;
        virtual F32 getAscenderHeight() const;
        virtual F32 getDescenderHeight() const;


// For a lowercase "g":
//
//      ------------------------------
//                           ^     ^
//                                               |     |
//                              xxx x    |Ascender
//                 x   x     |     |
//      ---------   xxxx-------------- Baseline
//      ^                      x         |     |
//  | descender    x     |     |
//      v                       xxxx     v     |LineHeight
//  -----------------------    |
//                             v
//      ------------------------------

        enum
        {
                FIRST_CHAR = 32, 
                NUM_CHARS = 127 - 32, 
                LAST_CHAR_BASIC = 127,

                // Need full 8-bit ascii range for spanish
                NUM_CHARS_FULL = 255 - 32,
                LAST_CHAR_FULL = 255
        };

        const LLFontGlyphInfo &getMetrics(const llwchar wc) const;
        F32 getXAdvance(const llwchar wc) const;
        F32 getXKerning(const llwchar char_left, const llwchar char_right) const; // Get the kerning between the two characters
protected:
        virtual BOOL hasGlyph(const llwchar wch) const;         // Has a glyph for this character
        virtual BOOL addChar(const llwchar wch);                // Add a new character to the font if necessary
        virtual BOOL addGlyph(const llwchar wch, const U32 glyph_index);        // Add a new glyph to the existing font
        virtual BOOL addGlyphFromFont(LLFont *fontp, const llwchar wch, const U32 glyph_index); // Add a glyph from this font to the other (returns the glyph_index, 0 if not found)

        virtual LLFontGlyphInfo* getGlyphInfo(const llwchar wch) const;

        void insertGlyphInfo(llwchar wch, LLFontGlyphInfo* gi) const;
        void renderGlyph(const U32 glyph_index);

        void resetBitmap();     // Reset bitmap to contain only the null glyph
protected:
        std::string mName;
        F32 mAscender;                  
        F32 mDescender;
        F32 mLineHeight;

        S32 mNumComponents;
        S32 mBitmapWidth;
        S32 mBitmapHeight;
        S32 mMaxCharWidth;
        S32 mMaxCharHeight;
        S32 mCurrentOffsetX;
        S32 mCurrentOffsetY;

        LLFT_Face mFTFace;

        BOOL mIsFallback;
        LLFontList *mFallbackFontp; // A list of fallback fonts to look for glyphs in (for Unicode chars)

        typedef std::map<llwchar, LLFontGlyphInfo*> char_glyph_info_map_t;
        mutable char_glyph_info_map_t mCharGlyphInfoMap; // Information about glyph location in bitmap

        BOOL mValid;
        void setSubImageLuminanceAlpha(const U32 x,
                                       const U32 y,
                                       const U32 width,
                                       const U32 height,
                                       const U8 *data,
                                       S32 stride = 0);

private:
        LLPointer<LLImageRaw> mRawImagep;       // Bitmaps of glyphs are stored here.
};

#endif // LL_FONT_

---