src/mgl/fontutil.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/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

#ifndef WX_PRECOMP
    #include "wx/hash.h"
    #include "wx/log.h"
#endif

#include "wx/fontutil.h"
#include "wx/encinfo.h"
#include "wx/fontmap.h"
#include "wx/tokenzr.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.empty() )
    {
        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;
    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.
    bool antialiased = false;
    if (( pt > gs_antialiasingThreshold ) &&
        ( m_fontLib->fontLibType != MGL_BITMAPFONT_LIB ) )
        antialiased = aa;

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