GFont.h

Go to the documentation of this file.

#ifndef _GDCFONT_H_
#define _GDCFONT_H_

#include "string.h"
#include "GRect.h"
#include "GProperties.h"
#include "LgiOsClasses.h"

// Defines

#ifndef WIN32

// font weights
#define FW_DONTCARE                     0 
#define FW_THIN                         100
#define FW_EXTRALIGHT                   200
#define FW_ULTRALIGHT                   200
#define FW_LIGHT                        300

#define FW_NORMAL                       400
#define FW_REGULAR                      400
#define FW_MEDIUM                       500
#define FW_SEMIBOLD                     600
#define FW_DEMIBOLD                     600

#define FW_BOLD                         700
#define FW_EXTRABOLD                    800
#define FW_ULTRABOLD                    800
#define FW_HEAVY                        900
#define FW_BLACK                        900

// quality
#define DEFAULT_QUALITY                 0

#define ANTIALIASED_QUALITY             1

#define NONANTIALIASED_QUALITY          2

#elif defined WIN32

#define WESTEUROPE_CHARSET              BALTIC_CHARSET      // ??? don't know

#endif

// OS specific font type
#if defined WIN32

    typedef HFONT OsFont;
    #define PrevOsChar(Ptr) Ptr--
    #define NextOsChar(Ptr) Ptr++

#elif defined BEOS

    typedef BFont *OsFont;
    #define PrevOsChar(Ptr) LgiPrevUtf8((char*&)Ptr)
    #define NextOsChar(Ptr) LgiNextUtf8((char*&)Ptr)

#elif defined POSIX

    #include "LgiOsClasses.h"
    #define PrevOsChar(Ptr) Ptr--
    #define NextOsChar(Ptr) Ptr++

#endif

#define MAX_UNICODE                     0xffff // maximum unicode char I can handle
#define _HasUnicodeGlyph(map, u)        ( (map[(u)>>3] & (1 << ((u) & 7))) != 0  )

// Functions
#define IsUtf8_1Byte(c)     (((c) & 0x80) == 0)
#define IsUtf8_2Byte(c)     (((c) & 0xe0) == 0xc0)
#define IsUtf8_3Byte(c)     (((c) & 0xf0) == 0xe0)
#define IsUtf8_4Byte(c)     (((c) & 0xf8) == 0xf0)

#define IsUtf8_Lead(c)      ( ((c) & 0xc0) == 0xc0 )
#define IsUtf8_Trail(c)     ( ((c) & 0xc0) == 0x80 )

inline char16 LgiUtf8To32(uint8 *&i, int &Len)
{
    uint32 Out = 0;

    // #define InvalidUtf()     { Len--; i++; return '?'; }
    #define InvalidUtf()        ;

    if (Len > 0)
    {
        if (NOT *i)
        {
            Len = 0;
            return 0;
        }

        if (IsUtf8_1Byte(*i))
        {
            // 1 byte UTF-8
            Len--;
            return *i++;
        }
        else if (IsUtf8_2Byte(*i))
        {
            // 2 byte UTF-8
            if (Len > 1)
            {
                Out = ((int)(*i++ & 0x1f)) << 6;
                Len--;

                if (IsUtf8_Trail(*i))
                {
                    Out |= *i++ & 0x3f;
                    Len--;
                }
                else InvalidUtf()
            }
        }
        else if (IsUtf8_3Byte(*i))
        {
            // 3 byte UTF-8
            if (Len > 2)
            {
                Out = ((int)(*i++ & 0x0f)) << 12;
                Len--;

                if (IsUtf8_Trail(*i))
                {
                    Out |= ((int)(*i++ & 0x3f)) << 6;
                    Len--;

                    if (IsUtf8_Trail(*i))
                    {
                        Out |= *i++ & 0x3f;
                        Len--;
                    }
                    else InvalidUtf()
                }
                else InvalidUtf()
            }
        }
        else if (IsUtf8_4Byte(*i))
        {
            // 4 byte UTF-8
            if (Len > 3)
            {
                Out = ((int)(*i++ & 0x07)) << 18;
                Len--;

                if (IsUtf8_Trail(*i))
                {
                    Out |= ((int)(*i++ & 0x3f)) << 12;
                    Len--;

                    if (IsUtf8_Trail(*i))
                    {
                        Out |= ((int)(*i++ & 0x3f)) << 6;
                        Len--;

                        if (IsUtf8_Trail(*i))
                        {
                            Out |= *i++ & 0x3f;
                            Len--;
                        }
                        else InvalidUtf()
                    }
                    else InvalidUtf()
                }
                else InvalidUtf()
            }
        }
        else
            InvalidUtf()
    }

    return Out;
}

inline void LgiUtf32To8(uint32 c, uint8 *&i, int &Len)
{
    if ((c & ~0x7f) == 0)
    {
        if (Len > 0)
        {
            *i++ = c;
            Len--;
        }
    }
    else if ((c & ~0x7ff) == 0)
    {
        if (Len > 1)
        {
            *i++ = 0xc0 | (c >> 6);
            *i++ = 0x80 | (c & 0x3f);
            Len -= 2;
        }
    }
    else if ((c & 0xffff0000) == 0)
    {
        if (Len > 2)
        {
            *i++ = 0xe0 | (c >> 12);
            *i++ = 0x80 | ((c & 0x0fc0) >> 6);
            *i++ = 0x80 | (c & 0x3f);
            Len -= 3;
        }
    }
    else
    {
        if (Len > 3)
        {
            *i++ = 0xf0 | (c >> 18);
            *i++ = 0x80 | ((c&0x3f000) >> 12);
            *i++ = 0x80 | ((c&0xfc0) >> 6);
            *i++ = 0x80 | (c&0x3f);
            Len -= 4;
        }
    }
}

inline uint32 LgiUtf16To32(char16 *&i, int &Len)
{
    if (Len > 1)
    {
        if (NOT *i)
        {
            Len = 0;
            return 0;
        }

        int n = *i & 0xfc00;
        if (n == 0xd800 || n == 0xdc00)
        {
            // 2 word UTF
            if (Len > 3)
            {
                Len -= sizeof(char16)<<1;
                int w = (*i & 0x3c0) >> 6;
                int zy = *i++ & 0x3f;
                return ((w + 1) << 16) | (zy << 10) | (*i++ & 0x3ff);
            }
        }

        // 1 word UTF
        Len -= sizeof(char16);
        return *i++;
    }

    return 0;
}

inline void LgiUtf32To16(uint32 c, char16 *&i, int &Len)
{
    if (c & 0xffff0000)
    {
        // 2 word UTF
        if (Len > 3)
        {
            int w = (c >> 16) - 1;
            *i++ = 0xd800 | (w << 6) | ((c & 0xfc00) >> 10);
            *i++ = 0xdc00 | (c & 0x3ff);
            Len -= sizeof(char16) << 1;
        }
    }

    // 1 word UTF
    if (Len > 1)
    {
        *i++ = c;
        Len -= sizeof(char16);
    }
}

inline void LgiNextUtf8(char *&p)
{
    if (IsUtf8_Lead(*p++))
    {
        while (IsUtf8_Trail(*p)) p++;
    }
}

inline void LgiPrevUtf8(char *&p)
{
    p--;
    while (IsUtf8_Trail(*p)) p--;
}

// Classes
class GFontType;
class GDisplayString;

class LgiClass GTypeFace
{
protected:
    class GTypeFacePrivate *d;

    // Methods
    virtual void _OnPropChange(bool c) {} // if false then it's just a property change

public:
    GTypeFace();
    virtual ~GTypeFace();

    void Face(char *s);
    void PointSize(int i);
    void TabSize(int i);
    void Quality(int i);
    void Fore(COLOUR c);
    void Back(COLOUR c);
    void SetWeight(int Weight);
    void Bold(bool i) { SetWeight(i ? FW_BOLD : FW_NORMAL); }
    void Italic(bool i);
    void Underline(bool i);
    void Transparent(bool i);
    void SubGlyphs(bool i);

    char *Face();
    int PointSize();
    int TabSize();
    int Quality();
    COLOUR Fore();
    COLOUR Back();
    int GetWeight();
    bool Bold() { return GetWeight() >= FW_BOLD; }
    bool Italic();
    bool Underline();
    bool Transparent();
    bool SubGlyphs();
    double Ascent();
    double Descent();

    /* Deprecated
    void Width(int i);
    int Width();
    char *CodePage();
    void CodePage(char *i);
    */

    virtual void Colour(COLOUR Fore, COLOUR Back = 0xFFFFFFFF);
};

class LgiClass GFont :
    public GTypeFace
{
    friend class GFontSystem;
    friend class GDisplayString;

    class GFontPrivate *d;

    // Methods
    bool IsValid();
    void _OnPropChange(bool Change);
    char16 *_ToUnicode(char *In, int &Len);
    bool GetOwnerUnderline();
    uchar *GetGlyphMap();

    void _Measure
    (
        int &x,
        int &y,
        OsChar *Str,
        int Len
    );
    int _CharAt
    (
        int x,
        OsChar *Str,
        int Len
    );
    void _Draw
    (
        GSurface *pDC,
        int x,
        int y,
        OsChar *Str,
        int Len,
        GRect *r
    );

public:
    GFont
    (
        char *face = 0,
        int point = -1
    );
    GFont(OsFont Handle);
    GFont(GFontType &Type);
    GFont(GFont &Fnt);
    ~GFont();

    bool Create
    (
        char *Face = 0,
        int PtSize = -1,
        int Param = 0
    );
    bool Create(GFontType *Type, int Param = 0);
    OsFont Handle();
    GFont &operator =(GFont &f);
    int GetHeight();
    int GetParam();

    void Text
    (
        GSurface *pDC,
        int x,
        int y,
        char *Str,
        int Len = -1,
        GRect *r = 0,
        int TabOrigin = 0
    );
    void Size
    (
        int *x,
        int *y,
        char *Str,
        int Len = -1,
        int Flags = 0
    );
    int X(char *Str, int Len = -1);
    int Y(char *Str, int Len = -1);
    int CharAt
    (
        int x,
        char *Str,
        int Len = -1,
        int TabOffset = 0
    );

    void TextW
    (
        GSurface *pDC,
        int x,
        int y,
        char16 *Str,
        int Len = -1,
        GRect *r = 0,
        int TabOrigin = 0
    );
    void SizeW
    (
        int *x,
        int *y,
        char16 *Str,
        int Len = -1,
        int Flags = 0
    );
    int XW(char16 *Str, int Len = -1);
    int YW(char16 *Str, int Len = -1);
    int CharAtW
    (
        int x,
        char16 *Str,
        int Len = -1,
        int TabOffset = 0
    );
};

class LgiClass GFontType
{
    friend class GFont;
    friend class GTypeFace;

protected:
    #if defined WIN32
    LOGFONT Info;
    #else
    GTypeFace Info;
    #endif

public:
    GFontType(char *face = 0, int pointsize = 0);
    virtual ~GFontType();

    #ifdef WIN32
    LOGFONT *Handle() { return &Info; }
    #else
    GTypeFace *Handle() { return &Info; }
    #endif

    char *GetFace();
    
    void SetFace(char *Face);
    
    int GetPointSize();
    
    void SetPointSize(int PointSize);

    bool DoUI(GView *Parent);
    
    bool GetDescription(char *Str);
    
    bool Serialize(ObjProperties *Options, char *OptName, bool Write);

    bool GetConfigFont(char *Tag);
    
    bool GetSystemFont(char *Which);

    bool GetFromRef(OsFont Handle);

    virtual GFont *Create(int Param = 0);
};

enum GCharSetType
{
    CpNone,
    CpMapped,
    CpUtf8,
    CpWide,
    CpIconv,
    CpWindowsDb
};

class LgiClass GCharset
{
public:
    char *Charset;
    char *Description;
    short *UnicodeMap;
    char *IconvName;
    char *AlternateNames;
    GCharSetType Type;

    GCharset(char *cp = 0, char *des = 0, short *map = 0, char *alt = 0);

    bool IsUnicode();
    char *GetIconvName();
    bool IsAvailable();
};

class LgiClass GDisplayString
{
    OsChar *Str;
    GFont *Font;
    int x, y, len, TabOrigin;
    int Blocks;
    class CharInfo *Info;
    uint8 Flags;

    void Layout();

public:
    GDisplayString
    (
        GFont *f,
        char *s,
        int l = -1,
        int tabOrigin = 0
    );
    GDisplayString
    (
        GFont *f,
        char16 *s,
        int l = -1,
        int tabOrigin = 0
    );
    virtual ~GDisplayString();
    
    bool ShowVisibleTab();
    void ShowVisibleTab(bool i);
    GFont *GetFont() { return Font; };

    void TruncateWithDots
    (
        int Width
    );
    bool IsTruncated();

    int Length();
    void Length(int NewLen);

    operator OsChar*() { return Str; }

    int X();
    int Y();
    void Size(int *x, int *y);
    int CharAt(int x);

    void Draw
    (
        GSurface *pDC,
        int x,
        int y,
        GRect *r = 0
    );
};

class LgiClass GCharsetSystem
{
    // Charset info
    GHashTable *Charsets;

public:
    GCharsetSystem();
    ~GCharsetSystem();

    // Get the charset info
    GCharset *GetCsInfo(char *Cp);
    GCharset *GetCsList();
};

LgiFunc GCharset *LgiGetCsInfo(char *Cs);
LgiFunc GCharset *LgiGetCsList();

class LgiClass GFontSystem
{
    friend class GApp;
    friend class GDisplayString;

    static GFontSystem *Me;

private:
    // System Font List
    List<char> AllFonts;
    List<char> SubFonts; // Fonts yet to be scanned for substitution

    // Missing Glyph Substitution
    uchar Lut[MAX_UNICODE+1];
    GFont *Font[256];
    class GFontSystemPrivate *d;

public:
    static GFontSystem *Inst();

    // Object
    GFontSystem();
    ~GFontSystem();

    bool EnumerateFonts(List<char> &Fonts);

    bool GetGlyphSubSupport();
    bool GetDefaultGlyphSub();
    void SetDefaultGlyphSub(bool i);
    GFont *GetGlyph
    (
        int u,
        GFont *UserFont
    );
    GFont *GetBestFont(char *Str);
};

#endif

---