[wxWidgets.git] / src / mgl / fontutil.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        mgl/fontutil.cpp
// Purpose:     Font helper functions for MGL
// Author:      Vaclav Slavik
// Created:     2001/04/29
// RCS-ID:      $Id$
// Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/log.h"
#include "wx/fontutil.h"
#include "wx/encinfo.h"
#include "wx/fontmap.h"
#include "wx/tokenzr.h"
#include "wx/hash.h"

#include "wx/listimpl.cpp"
#include "wx/sysopt.h"
#include "wx/mgl/private.h"

#include <mgraph.h>

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxNativeEncodingInfo
// ----------------------------------------------------------------------------

// convert to/from the string representation: format is
//      encoding[;facename]
bool wxNativeEncodingInfo::FromString(const wxString& s)
{
    wxStringTokenizer tokenizer(s, _T(";"));

    wxString encid = tokenizer.GetNextToken();
    long enc;
    if ( !encid.ToLong(&enc) )
        return FALSE;
    encoding = (wxFontEncoding)enc;

    // ok even if empty
    facename = tokenizer.GetNextToken();

    return TRUE;
}

wxString wxNativeEncodingInfo::ToString() const
{
    wxString s;
    s << (long)encoding;
    if ( !!facename )
    {
        s << _T(';') << facename;
    }

    return s;
}

// ----------------------------------------------------------------------------
// common functions
// ----------------------------------------------------------------------------

bool wxGetNativeFontEncoding(wxFontEncoding encoding,
                             wxNativeEncodingInfo *info)
{
    wxCHECK_MSG( info, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );

    if ( encoding == wxFONTENCODING_DEFAULT )
    {
        encoding = wxFont::GetDefaultEncoding();
    }

    switch ( encoding )
    {
        case wxFONTENCODING_ISO8859_1:
        case wxFONTENCODING_ISO8859_2:
        case wxFONTENCODING_ISO8859_3:
        case wxFONTENCODING_ISO8859_4:
        case wxFONTENCODING_ISO8859_5:
        case wxFONTENCODING_ISO8859_6:
        case wxFONTENCODING_ISO8859_7:
        case wxFONTENCODING_ISO8859_8:
        case wxFONTENCODING_ISO8859_9:
        case wxFONTENCODING_ISO8859_10:
        case wxFONTENCODING_ISO8859_11:
        case wxFONTENCODING_ISO8859_13:
        case wxFONTENCODING_ISO8859_14:
        case wxFONTENCODING_ISO8859_15:
            info->mglEncoding = MGL_ENCODING_ISO8859_1 +
                                (encoding - wxFONTENCODING_ISO8859_1);
            break;

        case wxFONTENCODING_KOI8:
            info->mglEncoding = MGL_ENCODING_KOI8;
            break;

        case wxFONTENCODING_CP1250:
        case wxFONTENCODING_CP1251:
        case wxFONTENCODING_CP1252:
        case wxFONTENCODING_CP1253:
        case wxFONTENCODING_CP1254:
        case wxFONTENCODING_CP1255:
        case wxFONTENCODING_CP1256:
        case wxFONTENCODING_CP1257:
            info->mglEncoding = MGL_ENCODING_CP1250 +
                                (encoding - wxFONTENCODING_CP1250);
            break;

        case wxFONTENCODING_SYSTEM:
            info->mglEncoding = MGL_ENCODING_ASCII;
            break;

        default:
            // encoding not known to MGL
            return FALSE;
    }

    info->encoding = encoding;

    return TRUE;
}

bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
{
    if ( !info.facename )
        return TRUE;
        
    wxMGLFontFamily *family = wxTheFontsManager->GetFamily(info.facename);
    if ( !family )
        return FALSE;
    if ( family->GetInfo()->fontLibType == MGL_BITMAPFONT_LIB )
        return (info.mglEncoding == MGL_ENCODING_ASCII ||
                info.mglEncoding == MGL_ENCODING_ISO8859_1 ||
                info.mglEncoding == MGL_ENCODING_ISO8859_15 ||
                info.mglEncoding == MGL_ENCODING_CP1252);
    else
        return TRUE;
}


// ----------------------------------------------------------------------------
// wxFontFamily, wxMGLFontInstance, wxMGLFontLibrary
// ----------------------------------------------------------------------------

WX_DECLARE_LIST(wxMGLFontInstance, wxMGLFontInstanceList);
WX_DEFINE_LIST(wxMGLFontInstanceList);
WX_DEFINE_LIST(wxMGLFontFamilyList);

wxMGLFontInstance::wxMGLFontInstance(wxMGLFontLibrary *fontLib, 
                                     float pt, bool slant, bool aa)
{
    m_fontLib = fontLib;
    m_font = NULL;
    m_pt = pt;
    m_slant = slant;
    m_aa = aa;

    float slantAngle = m_slant ? 15.0 : 0.0;

    wxLogTrace("mgl_font", "loading instance of '%s' slant=%i pt=%0.1f aa=%i", 
               m_fontLib->GetMGLfont_lib_t()->name, m_slant, m_pt, m_aa);
    m_font = MGL_loadFontInstance(m_fontLib->GetMGLfont_lib_t(), 
                                  m_pt, slantAngle, 0.0, aa);
    wxASSERT_MSG( m_font, wxT("Cannot create font instance.") );
}

wxMGLFontInstance::~wxMGLFontInstance()
{
    wxLogTrace("mgl_font", "unloading instance of '%s' slant=%i pt=%0.1f aa=%i", 
               m_fontLib->GetMGLfont_lib_t()->name, m_slant, m_pt, m_aa);
    if ( m_font )
        MGL_unloadFontInstance(m_font);
}
    
wxMGLFontLibrary::wxMGLFontLibrary(const wxString& filename, int type, 
                                   wxMGLFontFamily *parentFamily)
{
    m_family = parentFamily;
    m_type = type;
    m_fileName = filename;
    m_refs = 0;
    m_fontLib = NULL;

    m_instances = new wxMGLFontInstanceList;
    m_instances->DeleteContents(TRUE);
}

wxMGLFontLibrary::~wxMGLFontLibrary()
{
    wxLogTrace("mgl_font", "font library dtor '%s'", m_fileName.mb_str());
    delete m_instances;
}
    
void wxMGLFontLibrary::IncRef()
{
    wxLogTrace("mgl_font", "incRef(%u) '%s'", m_refs, m_fileName.c_str());
    if ( m_refs++ == 0 )
    {
        wxLogTrace("mgl_font", "opening library '%s'", m_fileName.mb_str());
        m_fontLib = MGL_openFontLib(m_fileName.mb_str());
    }
}

void wxMGLFontLibrary::DecRef()
{
    wxLogTrace("mgl_font", "decRef(%u) '%s'", m_refs, m_fileName.c_str());
    if ( --m_refs == 0 )
    {
        wxLogTrace("mgl_font", "killing instances of '%s'", m_fileName.mb_str());
        m_instances->Clear();
        wxLogTrace("mgl_font", "closing library '%s'", m_fileName.mb_str());
        MGL_closeFontLib(m_fontLib);
        m_fontLib = NULL;
    }
}

static int gs_antialiasingThreshold = -1;

wxMGLFontInstance *wxMGLFontLibrary::GetFontInstance(wxFont *font, 
                                                     float scale, bool aa)
{
    wxASSERT_MSG(m_refs > 0 && m_fontLib, wxT("font library not loaded!"));

    wxString facename;
    bool slant;
    bool antialiased;
    float pt = (float)font->GetPointSize() * scale;

    if ( gs_antialiasingThreshold == -1 )
    {
        gs_antialiasingThreshold = 10;
#if wxUSE_SYSTEM_OPTIONS
        if ( wxSystemOptions::HasOption(wxT("mgl.aa-threshold")) )
            gs_antialiasingThreshold = 
                wxSystemOptions::GetOptionInt(wxT("mgl.aa-threshold"));
        wxLogTrace("mgl_font", "AA threshold set to %i", gs_antialiasingThreshold);
#endif
    }

    // Small characters don't look good when antialiased with the algorithm
    // that FreeType uses (mere 2x2 supersampling), so lets disable it AA
    // completely for small fonts.
    if ( pt <= gs_antialiasingThreshold )
        antialiased = FALSE;
    else
        antialiased = (m_fontLib->fontLibType == MGL_BITMAPFONT_LIB) ? FALSE : aa;

    slant = (((m_type & wxFONTFACE_ITALIC) == 0) &&
             (font->GetStyle() == wxSLANT || font->GetStyle() == wxITALIC));

    // FIXME_MGL -- MGL does not yet support slant, although the API is there
    slant = FALSE;

    wxLogTrace("mgl_font", "requested instance of '%s' slant=%i pt=%0.1f aa=%i", 
               m_fileName.mb_str(), slant, pt, antialiased);

    wxMGLFontInstance *i;
    wxMGLFontInstanceList::Node *node;
    
    for (node = m_instances->GetFirst(); node; node = node->GetNext())
    {
        i = node->GetData();
        if ( i->GetPt() == pt && i->GetSlant() == slant &&
             i->GetAA() == antialiased )
        {
            wxLogTrace("mgl_font", "    got from cache: slant=%i pt=%0.1f aa=%i", 
                       i->GetSlant(), i->GetPt(), i->GetAA());
            return i;
        }
    }    
    
    i = new wxMGLFontInstance(this, pt, slant, antialiased);
    m_instances->Append(i);
    return i;   
}


wxMGLFontFamily::wxMGLFontFamily(const font_info_t *info)
{
    m_name = info->familyName;
    m_fontInfo = info;
    
    if ( info->regularFace[0] == '\0' )
        m_fontLibs[wxFONTFACE_REGULAR] = NULL;
    else
        m_fontLibs[wxFONTFACE_REGULAR] = 
            new wxMGLFontLibrary(info->regularFace, wxFONTFACE_REGULAR, this);
    
    if ( info->italicFace[0] == '\0' )
        m_fontLibs[wxFONTFACE_ITALIC] = NULL;
    else
        m_fontLibs[wxFONTFACE_ITALIC] = 
            new wxMGLFontLibrary(info->italicFace, wxFONTFACE_ITALIC, this);
    
    if ( info->boldFace[0] == '\0' )
        m_fontLibs[wxFONTFACE_BOLD] = NULL;
    else
        m_fontLibs[wxFONTFACE_BOLD] = 
            new wxMGLFontLibrary(info->boldFace, wxFONTFACE_BOLD, this);
    
    if ( info->boldItalicFace[0] == '\0' )
        m_fontLibs[wxFONTFACE_BOLD_ITALIC] = NULL;
    else
        m_fontLibs[wxFONTFACE_BOLD_ITALIC] = 
            new wxMGLFontLibrary(info->boldItalicFace, wxFONTFACE_BOLD_ITALIC, this);
            
    wxLogTrace("mgl_font", "new family '%s' (r=%s, i=%s, b=%s, bi=%s)\n",
               info->familyName, info->regularFace, info->italicFace, 
               info->boldFace, info->boldItalicFace);
}

wxMGLFontFamily::~wxMGLFontFamily()
{
    for (size_t i = 0; i < wxFONTFACE_MAX; i++)
        delete m_fontLibs[i];
}

bool wxMGLFontFamily::HasFace(int type) const
{
    return (m_fontLibs[type] != NULL);
}


// ----------------------------------------------------------------------------
// wxFontsManager
// ----------------------------------------------------------------------------

wxMGLFontLibrary *wxFontsManager::GetFontLibrary(wxFont *font)
{
    wxMGLFontFamily *family;
    int type;
    wxString facename = font->GetFaceName();
    
    if ( !facename.IsEmpty() )
        family = GetFamily(facename);
    else
        family = NULL;

    if ( !family )
    {
        facename.Empty();
        switch (font->GetFamily())
        {
            case wxSCRIPT:
                facename = wxT("Script");
                break;
            case wxDECORATIVE:
                facename = wxT("Charter");
                break;
            case wxROMAN:
                facename = wxT("Times");
                break;
            case wxTELETYPE:
            case wxMODERN:
                facename = wxT("Courier");
                break;
            case wxSWISS:
                facename = wxT("Helvetica");
                break;
            case wxDEFAULT:
            default:
                facename = wxT("Helvetica");
                break;
        }

        family = GetFamily(facename);
        if ( !family )
        {
           if ( m_list->GetFirst() )
               family = m_list->GetFirst()->GetData();
           else
               wxFAIL_MSG(wxT("Fatal error, no fonts available!"));
        }
    }

    type = wxFONTFACE_REGULAR;

    if ( font->GetWeight() == wxBOLD )
        type |= wxFONTFACE_BOLD;

    // FIXME_MGL -- this should read "if ( font->GetStyle() == wxITALIC )",
    // but since MGL does not yet support slant, we try to display it with
    // italic face (better than nothing...)
    if ( font->GetStyle() == wxITALIC || font->GetStyle() == wxSLANT )
    {
        if ( family->HasFace(type | wxFONTFACE_ITALIC) )
            type |= wxFONTFACE_ITALIC;
    }
    if ( !family->HasFace(type) )
    {
        for (int i = 0; i < wxFONTFACE_MAX; i++)
            if ( family->HasFace(i) )
            {
                type = i;
                break;
            }
    }
    
    return family->GetLibrary(type);
}

static ibool MGLAPI enum_callback(const font_info_t *info, void *cookie)
{
    wxFontsManager *db = (wxFontsManager*)cookie;
    db->AddFamily(info);
    return TRUE;
}

wxFontsManager::wxFontsManager()
{
    m_hash = new wxHashTable(wxKEY_STRING);
    m_hash->DeleteContents(FALSE);
    m_list = new wxMGLFontFamilyList;
    m_list->DeleteContents(TRUE);
    MGL_enumerateFonts(enum_callback, (void*)this);
}

wxFontsManager::~wxFontsManager()
{
    delete m_hash;
    delete m_list;
}

void wxFontsManager::AddFamily(const font_info_t *info)
{
    wxMGLFontFamily *f = new wxMGLFontFamily(info);
    m_hash->Put(f->GetName().Lower(), f);
    m_list->Append(f);
}
        
wxMGLFontFamily *wxFontsManager::GetFamily(const wxString& name) const
{
    return (wxMGLFontFamily*)m_hash->Get(name.Lower());
}


wxFontsManager *wxTheFontsManager = NULL;
Commit	Line	Data
32b8ec41 VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: mgl/fontutil.cpp
	3	// Purpose: Font helper functions for MGL
	4	// Author: Vaclav Slavik
	5	// Created: 2001/04/29
	6	// RCS-ID: $Id$
c41c20a5	7	// Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
65571936	8	// Licence: wxWindows licence
32b8ec41 VZ	9	/////////////////////////////////////////////////////////////////////////////
32b8ec41 VZ	10
32b8ec41 VZ	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
3af1a9f8 JS	18	#include "wx/log.h"
	19	#include "wx/fontutil.h"
	20	#include "wx/encinfo.h"
	21	#include "wx/fontmap.h"
	22	#include "wx/tokenzr.h"
	23	#include "wx/hash.h"
32b8ec41	24
32b8ec41	25	#include "wx/listimpl.cpp"
493bdcc7	26	#include "wx/sysopt.h"
32b8ec41 VZ	27	#include "wx/mgl/private.h"
	28
	29	#include <mgraph.h>
	30
	31	// ============================================================================
	32	// implementation
	33	// ============================================================================
	34
	35	// ----------------------------------------------------------------------------
	36	// wxNativeEncodingInfo
	37	// ----------------------------------------------------------------------------
	38
	39	// convert to/from the string representation: format is
	40	// encoding[;facename]
	41	bool wxNativeEncodingInfo::FromString(const wxString& s)
	42	{
	43	wxStringTokenizer tokenizer(s, _T(";"));
	44
	45	wxString encid = tokenizer.GetNextToken();
	46	long enc;
	47	if ( !encid.ToLong(&enc) )
	48	return FALSE;
	49	encoding = (wxFontEncoding)enc;
	50
	51	// ok even if empty
	52	facename = tokenizer.GetNextToken();
	53
	54	return TRUE;
	55	}
	56
	57	wxString wxNativeEncodingInfo::ToString() const
	58	{
	59	wxString s;
	60	s << (long)encoding;
	61	if ( !!facename )
	62	{
	63	s << _T(';') << facename;
	64	}
	65
	66	return s;
	67	}
	68
	69	// ----------------------------------------------------------------------------
	70	// common functions
	71	// ----------------------------------------------------------------------------
	72
	73	bool wxGetNativeFontEncoding(wxFontEncoding encoding,
	74	wxNativeEncodingInfo *info)
	75	{
	76	wxCHECK_MSG( info, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
	77
	78	if ( encoding == wxFONTENCODING_DEFAULT )
	79	{
	80	encoding = wxFont::GetDefaultEncoding();
	81	}
	82
	83	switch ( encoding )
	84	{
	85	case wxFONTENCODING_ISO8859_1:
	86	case wxFONTENCODING_ISO8859_2:
	87	case wxFONTENCODING_ISO8859_3:
	88	case wxFONTENCODING_ISO8859_4:
	89	case wxFONTENCODING_ISO8859_5:
	90	case wxFONTENCODING_ISO8859_6:
91	case wxFONTENCODING_ISO8859_7:
92	case wxFONTENCODING_ISO8859_8:
93	case wxFONTENCODING_ISO8859_9:
94	case wxFONTENCODING_ISO8859_10:
95	case wxFONTENCODING_ISO8859_11:
96	case wxFONTENCODING_ISO8859_13:
97	case wxFONTENCODING_ISO8859_14:
98	case wxFONTENCODING_ISO8859_15:
99	info->mglEncoding = MGL_ENCODING_ISO8859_1 +
100	(encoding - wxFONTENCODING_ISO8859_1);
101	break;
102
103	case wxFONTENCODING_KOI8:
104	info->mglEncoding = MGL_ENCODING_KOI8;
105	break;
106
107	case wxFONTENCODING_CP1250:
108	case wxFONTENCODING_CP1251:
109	case wxFONTENCODING_CP1252:
110	case wxFONTENCODING_CP1253:
111	case wxFONTENCODING_CP1254:
112	case wxFONTENCODING_CP1255:
113	case wxFONTENCODING_CP1256:
114	case wxFONTENCODING_CP1257:
115	info->mglEncoding = MGL_ENCODING_CP1250 +
116	(encoding - wxFONTENCODING_CP1250);
117	break;
118
119	case wxFONTENCODING_SYSTEM:
120	info->mglEncoding = MGL_ENCODING_ASCII;
121	break;
122
123	default:
124	// encoding not known to MGL
125	return FALSE;
126	}
127
128	info->encoding = encoding;
129
130	return TRUE;
131	}
132
133	bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
134	{
135	if ( !info.facename )
136	return TRUE;
137
138	wxMGLFontFamily *family = wxTheFontsManager->GetFamily(info.facename);
139	if ( !family )
140	return FALSE;
141	if ( family->GetInfo()->fontLibType == MGL_BITMAPFONT_LIB )
142	return (info.mglEncoding == MGL_ENCODING_ASCII \|\|
143	info.mglEncoding == MGL_ENCODING_ISO8859_1 \|\|
144	info.mglEncoding == MGL_ENCODING_ISO8859_15 \|\|
145	info.mglEncoding == MGL_ENCODING_CP1252);
146	else
147	return TRUE;
148	}
149
150
151	// ----------------------------------------------------------------------------
152	// wxFontFamily, wxMGLFontInstance, wxMGLFontLibrary
153	// ----------------------------------------------------------------------------
154
155	WX_DECLARE_LIST(wxMGLFontInstance, wxMGLFontInstanceList);
156	WX_DEFINE_LIST(wxMGLFontInstanceList);
157	WX_DEFINE_LIST(wxMGLFontFamilyList);
158
159	wxMGLFontInstance::wxMGLFontInstance(wxMGLFontLibrary *fontLib,
160	float pt, bool slant, bool aa)
161	{
162	m_fontLib = fontLib;
163	m_font = NULL;
164	m_pt = pt;
165	m_slant = slant;
166	m_aa = aa;
167
168	float slantAngle = m_slant ? 15.0 : 0.0;
169
170	wxLogTrace("mgl_font", "loading instance of '%s' slant=%i pt=%0.1f aa=%i",
171	m_fontLib->GetMGLfont_lib_t()->name, m_slant, m_pt, m_aa);
172	m_font = MGL_loadFontInstance(m_fontLib->GetMGLfont_lib_t(),
173	m_pt, slantAngle, 0.0, aa);
174	wxASSERT_MSG( m_font, wxT("Cannot create font instance.") );
175	}
176
177	wxMGLFontInstance::~wxMGLFontInstance()
178	{
179	wxLogTrace("mgl_font", "unloading instance of '%s' slant=%i pt=%0.1f aa=%i",
180	m_fontLib->GetMGLfont_lib_t()->name, m_slant, m_pt, m_aa);
181	if ( m_font )
182	MGL_unloadFontInstance(m_font);
183	}
184
f3437beb VS	185	wxMGLFontLibrary::wxMGLFontLibrary(const wxString& filename, int type,
f3437beb VS	186	wxMGLFontFamily *parentFamily)
32b8ec41	187	{
f3437beb	188	m_family = parentFamily;
32b8ec41 VZ	189	m_type = type;
	190	m_fileName = filename;
	191	m_refs = 0;
	192	m_fontLib = NULL;
	193
	194	m_instances = new wxMGLFontInstanceList;
	195	m_instances->DeleteContents(TRUE);
	196	}
	197
	198	wxMGLFontLibrary::~wxMGLFontLibrary()
	199	{
	200	wxLogTrace("mgl_font", "font library dtor '%s'", m_fileName.mb_str());
	201	delete m_instances;
	202	}
	203
	204	void wxMGLFontLibrary::IncRef()
	205	{
	206	wxLogTrace("mgl_font", "incRef(%u) '%s'", m_refs, m_fileName.c_str());
	207	if ( m_refs++ == 0 )
	208	{
	209	wxLogTrace("mgl_font", "opening library '%s'", m_fileName.mb_str());
	210	m_fontLib = MGL_openFontLib(m_fileName.mb_str());
	211	}
	212	}
	213
	214	void wxMGLFontLibrary::DecRef()
	215	{
	216	wxLogTrace("mgl_font", "decRef(%u) '%s'", m_refs, m_fileName.c_str());
	217	if ( --m_refs == 0 )
	218	{
	219	wxLogTrace("mgl_font", "killing instances of '%s'", m_fileName.mb_str());
	220	m_instances->Clear();
	221	wxLogTrace("mgl_font", "closing library '%s'", m_fileName.mb_str());
	222	MGL_closeFontLib(m_fontLib);
	223	m_fontLib = NULL;
	224	}
	225	}
	226
493bdcc7 VS	227	static int gs_antialiasingThreshold = -1;
493bdcc7 VS	228
32b8ec41 VZ	229	wxMGLFontInstance wxMGLFontLibrary::GetFontInstance(wxFont font,
	230	float scale, bool aa)
	231	{
	232	wxASSERT_MSG(m_refs > 0 && m_fontLib, wxT("font library not loaded!"));
	233
	234	wxString facename;
	235	bool slant;
493bdcc7	236	bool antialiased;
32b8ec41 VZ	237	float pt = (float)font->GetPointSize() * scale;
32b8ec41 VZ	238
493bdcc7 VS	239	if ( gs_antialiasingThreshold == -1 )
	240	{
	241	gs_antialiasingThreshold = 10;
	242	#if wxUSE_SYSTEM_OPTIONS
05c9ccbe	243	if ( wxSystemOptions::HasOption(wxT("mgl.aa-threshold")) )
493bdcc7 VS	244	gs_antialiasingThreshold =
	245	wxSystemOptions::GetOptionInt(wxT("mgl.aa-threshold"));
	246	wxLogTrace("mgl_font", "AA threshold set to %i", gs_antialiasingThreshold);
	247	#endif
	248	}
	249
	250	// Small characters don't look good when antialiased with the algorithm
	251	// that FreeType uses (mere 2x2 supersampling), so lets disable it AA
	252	// completely for small fonts.
	253	if ( pt <= gs_antialiasingThreshold )
	254	antialiased = FALSE;
	255	else
	256	antialiased = (m_fontLib->fontLibType == MGL_BITMAPFONT_LIB) ? FALSE : aa;
	257
32b8ec41 VZ	258	slant = (((m_type & wxFONTFACE_ITALIC) == 0) &&
	259	(font->GetStyle() == wxSLANT \|\| font->GetStyle() == wxITALIC));
	260
	261	// FIXME_MGL -- MGL does not yet support slant, although the API is there
	262	slant = FALSE;
	263
	264	wxLogTrace("mgl_font", "requested instance of '%s' slant=%i pt=%0.1f aa=%i",
	265	m_fileName.mb_str(), slant, pt, antialiased);
	266
	267	wxMGLFontInstance *i;
	268	wxMGLFontInstanceList::Node *node;
	269
	270	for (node = m_instances->GetFirst(); node; node = node->GetNext())
	271	{
	272	i = node->GetData();
	273	if ( i->GetPt() == pt && i->GetSlant() == slant &&
	274	i->GetAA() == antialiased )
	275	{
	276	wxLogTrace("mgl_font", " got from cache: slant=%i pt=%0.1f aa=%i",
	277	i->GetSlant(), i->GetPt(), i->GetAA());
	278	return i;
	279	}
	280	}
	281
	282	i = new wxMGLFontInstance(this, pt, slant, antialiased);
	283	m_instances->Append(i);
	284	return i;
	285	}
	286
	287
	288	wxMGLFontFamily::wxMGLFontFamily(const font_info_t *info)
	289	{
	290	m_name = info->familyName;
	291	m_fontInfo = info;
	292
	293	if ( info->regularFace[0] == '\0' )
	294	m_fontLibs[wxFONTFACE_REGULAR] = NULL;
	295	else
	296	m_fontLibs[wxFONTFACE_REGULAR] =
f3437beb	297	new wxMGLFontLibrary(info->regularFace, wxFONTFACE_REGULAR, this);
32b8ec41 VZ	298
	299	if ( info->italicFace[0] == '\0' )
	300	m_fontLibs[wxFONTFACE_ITALIC] = NULL;
	301	else
	302	m_fontLibs[wxFONTFACE_ITALIC] =
f3437beb	303	new wxMGLFontLibrary(info->italicFace, wxFONTFACE_ITALIC, this);
32b8ec41 VZ	304
	305	if ( info->boldFace[0] == '\0' )
	306	m_fontLibs[wxFONTFACE_BOLD] = NULL;
	307	else
	308	m_fontLibs[wxFONTFACE_BOLD] =
f3437beb	309	new wxMGLFontLibrary(info->boldFace, wxFONTFACE_BOLD, this);
32b8ec41 VZ	310
	311	if ( info->boldItalicFace[0] == '\0' )
	312	m_fontLibs[wxFONTFACE_BOLD_ITALIC] = NULL;
	313	else
	314	m_fontLibs[wxFONTFACE_BOLD_ITALIC] =
f3437beb	315	new wxMGLFontLibrary(info->boldItalicFace, wxFONTFACE_BOLD_ITALIC, this);
32b8ec41 VZ	316
	317	wxLogTrace("mgl_font", "new family '%s' (r=%s, i=%s, b=%s, bi=%s)\n",
	318	info->familyName, info->regularFace, info->italicFace,
	319	info->boldFace, info->boldItalicFace);
	320	}
	321
	322	wxMGLFontFamily::~wxMGLFontFamily()
	323	{
	324	for (size_t i = 0; i < wxFONTFACE_MAX; i++)
	325	delete m_fontLibs[i];
	326	}
	327
	328	bool wxMGLFontFamily::HasFace(int type) const
	329	{
	330	return (m_fontLibs[type] != NULL);
	331	}
	332
	333
	334	// ----------------------------------------------------------------------------
	335	// wxFontsManager
	336	// ----------------------------------------------------------------------------
	337
	338	wxMGLFontLibrary wxFontsManager::GetFontLibrary(wxFont font)
	339	{
	340	wxMGLFontFamily *family;
32b8ec41	341	int type;
fd495ab3	342	wxString facename = font->GetFaceName();
32b8ec41	343
fd495ab3 VS	344	if ( !facename.IsEmpty() )
fd495ab3 VS	345	family = GetFamily(facename);
32b8ec41 VZ	346	else
32b8ec41 VZ	347	family = NULL;
fd495ab3	348
32b8ec41 VZ	349	if ( !family )
32b8ec41 VZ	350	{
fd495ab3	351	facename.Empty();
32b8ec41 VZ	352	switch (font->GetFamily())
	353	{
	354	case wxSCRIPT:
	355	facename = wxT("Script");
	356	break;
	357	case wxDECORATIVE:
	358	facename = wxT("Charter");
	359	break;
	360	case wxROMAN:
	361	facename = wxT("Times");
	362	break;
	363	case wxTELETYPE:
	364	case wxMODERN:
	365	facename = wxT("Courier");
	366	break;
	367	case wxSWISS:
	368	facename = wxT("Helvetica");
	369	break;
	370	case wxDEFAULT:
	371	default:
	372	facename = wxT("Helvetica");
	373	break;
	374	}
	375
	376	family = GetFamily(facename);
	377	if ( !family )
	378	{
	379	if ( m_list->GetFirst() )
	380	family = m_list->GetFirst()->GetData();
	381	else
	382	wxFAIL_MSG(wxT("Fatal error, no fonts available!"));
	383	}
	384	}
	385
	386	type = wxFONTFACE_REGULAR;
	387
	388	if ( font->GetWeight() == wxBOLD )
	389	type \|= wxFONTFACE_BOLD;
	390
	391	// FIXME_MGL -- this should read "if ( font->GetStyle() == wxITALIC )",
	392	// but since MGL does not yet support slant, we try to display it with
	393	// italic face (better than nothing...)
	394	if ( font->GetStyle() == wxITALIC \|\| font->GetStyle() == wxSLANT )
	395	{
	396	if ( family->HasFace(type \| wxFONTFACE_ITALIC) )
	397	type \|= wxFONTFACE_ITALIC;
	398	}
	399	if ( !family->HasFace(type) )
	400	{
	401	for (int i = 0; i < wxFONTFACE_MAX; i++)
	402	if ( family->HasFace(i) )
	403	{
	404	type = i;
	405	break;
	406	}
	407	}
	408
	409	return family->GetLibrary(type);
	410	}
	411
dbdcff51	412	static ibool MGLAPI enum_callback(const font_info_t info, void cookie)
32b8ec41 VZ	413	{
	414	wxFontsManager db = (wxFontsManager)cookie;
	415	db->AddFamily(info);
	416	return TRUE;
	417	}
	418
	419	wxFontsManager::wxFontsManager()
	420	{
	421	m_hash = new wxHashTable(wxKEY_STRING);
	422	m_hash->DeleteContents(FALSE);
	423	m_list = new wxMGLFontFamilyList;
	424	m_list->DeleteContents(TRUE);
	425	MGL_enumerateFonts(enum_callback, (void*)this);
	426	}
	427
	428	wxFontsManager::~wxFontsManager()
	429	{
	430	delete m_hash;
	431	delete m_list;
	432	}
	433
	434	void wxFontsManager::AddFamily(const font_info_t *info)
	435	{
	436	wxMGLFontFamily *f = new wxMGLFontFamily(info);
	437	m_hash->Put(f->GetName().Lower(), f);
	438	m_list->Append(f);
	439	}
	440
	441	wxMGLFontFamily *wxFontsManager::GetFamily(const wxString& name) const
	442	{
	443	return (wxMGLFontFamily*)m_hash->Get(name.Lower());
	444	}
	445
	446
	447	wxFontsManager *wxTheFontsManager = NULL;