src/msw/font.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        font.cpp
// Purpose:     wxFont class
// Author:      Julian Smart
// Modified by:
// Created:     01/02/97
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart and Markus Holzem
// Licence:       wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#ifdef __GNUG__
    #pragma implementation "font.h"
#endif

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/setup.h"
    #include "wx/list.h"
    #include "wx/utils.h"
    #include "wx/app.h"
    #include "wx/font.h"
    #include "wx/log.h"
#endif // WX_PRECOMP

#include "wx/fontutil.h"
#include "wx/tokenzr.h"

#include "wx/msw/private.h"

IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// the default font size in points
static const int wxDEFAULT_FONT_SIZE = 12;

// ----------------------------------------------------------------------------
// wxFontRefData - the internal description of the font
// ----------------------------------------------------------------------------

class WXDLLEXPORT wxFontRefData: public wxGDIRefData
{
friend class WXDLLEXPORT wxFont;

public:
    wxFontRefData()
    {
        Init(wxDEFAULT_FONT_SIZE, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE,
             "", wxFONTENCODING_DEFAULT);
    }

    wxFontRefData(const wxFontRefData& data)
    {
        Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
             data.m_underlined, data.m_faceName, data.m_encoding);

        m_fontId = data.m_fontId;
    }

    wxFontRefData(int size,
                  int family,
                  int style,
                  int weight,
                  bool underlined,
                  const wxString& faceName,
                  wxFontEncoding encoding)
    {
        Init(size, family, style, weight, underlined, faceName, encoding);
    }

    wxFontRefData(const wxNativeFontInfo& info)
    {
        Init(info);
    }

    virtual ~wxFontRefData();

protected:
    // common part of all ctors
    void Init(int size,
              int family,
              int style,
              int weight,
              bool underlined,
              const wxString& faceName,
              wxFontEncoding encoding);

    void Init(const wxNativeFontInfo& info);

    // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE
    // DELETED by destructor
    bool          m_temporary;

    int           m_fontId;

    // font characterstics
    int           m_pointSize;
    int           m_family;
    int           m_style;
    int           m_weight;
    bool          m_underlined;
    wxString      m_faceName;
    wxFontEncoding m_encoding;

    // Windows font handle
    WXHFONT       m_hFont;

    // Native font info
    wxNativeFontInfo m_nativeFontInfo;
    bool             m_nativeFontInfoOk;
};

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

// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------

void wxFontRefData::Init(int pointSize,
                         int family,
                         int style,
                         int weight,
                         bool underlined,
                         const wxString& faceName,
                         wxFontEncoding encoding)
{
    m_style = style;
    m_pointSize = pointSize;
    m_family = family;
    m_style = style;
    m_weight = weight;
    m_underlined = underlined;
    m_faceName = faceName;
    m_encoding = encoding;

    m_fontId = 0;
    m_temporary = FALSE;

    m_hFont = 0;

    m_nativeFontInfoOk = FALSE;
}

void wxFontRefData::Init(const wxNativeFontInfo& info)
{
    // extract family from pitch-and-family
    int lfFamily = info.lf.lfPitchAndFamily;
    if ( lfFamily & FIXED_PITCH )
        lfFamily -= FIXED_PITCH;
    if ( lfFamily & VARIABLE_PITCH )
        lfFamily -= VARIABLE_PITCH;

    switch ( lfFamily )
    {
        case FF_ROMAN:
            m_family = wxROMAN;
            break;

        case FF_SWISS:
            m_family = wxSWISS;
            break;

        case FF_SCRIPT:
            m_family = wxSCRIPT;
            break;

        case FF_MODERN:
            m_family = wxMODERN;
            break;

        case FF_DECORATIVE:
            m_family = wxDECORATIVE;
            break;

        default:
            m_family = wxSWISS;
    }

    // weight and style
    switch ( info.lf.lfWeight )
    {
        case FW_LIGHT:
            m_weight = wxLIGHT;
            break;

        default:
        case FW_NORMAL:
            m_weight = wxNORMAL;
            break;

        case FW_BOLD:
            m_weight = wxBOLD;
            break;
    }

    m_style = info.lf.lfItalic ? wxITALIC : wxNORMAL;

    m_underlined = info.lf.lfUnderline != 0;

    m_faceName = info.lf.lfFaceName;

    // remember that 1pt = 1/72inch
    int height = abs(info.lf.lfHeight);

#if wxUSE_SCREEN_DPI
    HDC dc = ::GetDC(NULL);
    static const int ppInch = GetDeviceCaps(dc, LOGPIXELSY);
    ::ReleaseDC(NULL, dc);
#else
    static const int ppInch = 96;
#endif
    m_pointSize = (int) (((72.0*((double)height))/(double) ppInch) + 0.5);

    m_encoding = wxGetFontEncFromCharSet(info.lf.lfCharSet);

    m_fontId = 0;
    m_temporary = FALSE;

    m_hFont = 0;

    m_nativeFontInfoOk = TRUE;
    m_nativeFontInfo = info;
}

wxFontRefData::~wxFontRefData()
{
    if ( m_hFont )
    {
        if ( !::DeleteObject((HFONT) m_hFont) )
        {
            wxLogLastError(wxT("DeleteObject(font)"));
        }
    }
}


// ----------------------------------------------------------------------------
// wxNativeFontInfo
// ----------------------------------------------------------------------------

bool wxNativeFontInfo::FromString(const wxString& s)
{
    long l;

    wxStringTokenizer tokenizer(s, _T(";"));

    wxString token = tokenizer.GetNextToken();
    //
    //  Ignore the version for now
    //

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfHeight = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfWidth = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfEscapement = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfOrientation = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfWeight = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfItalic = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfUnderline = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfStrikeOut = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfCharSet = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfOutPrecision = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfClipPrecision = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfQuality = l;

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfPitchAndFamily = l;

    token = tokenizer.GetNextToken();
    if(!token)
        return FALSE;
    wxStrcpy(lf.lfFaceName, token.c_str());

    return TRUE;
}

wxString wxNativeFontInfo::ToString() const
{
    wxString s;

    s.Printf(_T("%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%s"),
             0, // version, in case we want to change the format later
             lf.lfHeight,
             lf.lfWidth,
             lf.lfEscapement,
             lf.lfOrientation,
             lf.lfWeight,
             lf.lfItalic,
             lf.lfUnderline,
             lf.lfStrikeOut,
             lf.lfCharSet,
             lf.lfOutPrecision,
             lf.lfClipPrecision,
             lf.lfQuality,
             lf.lfPitchAndFamily,
             lf.lfFaceName);

    return s;
}

// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------

void wxFont::Init()
{
    if ( wxTheFontList )
        wxTheFontList->Append(this);
}

bool wxFont::Create(const wxNativeFontInfo& info)
{
    UnRef();

    m_refData = new wxFontRefData(info);

    RealizeResource();

    return TRUE;
}

wxFont::wxFont(const wxString& fontdesc)
{
    wxNativeFontInfo info;
    if ( info.FromString(fontdesc) )
        (void)Create(info);
}

/* Constructor for a font. Note that the real construction is done
 * in wxDC::SetFont, when information is available about scaling etc.
 */
bool wxFont::Create(int pointSize,
                    int family,
                    int style,
                    int weight,
                    bool underlined,
                    const wxString& faceName,
                    wxFontEncoding encoding)
{
    UnRef();

    // wxDEFAULT is a valid value for the font size too so we must treat it
    // specially here (otherwise the size would be 70 == wxDEFAULT value)
    if ( pointSize == wxDEFAULT )
        pointSize = wxDEFAULT_FONT_SIZE;

    m_refData = new wxFontRefData(pointSize, family, style, weight,
                                  underlined, faceName, encoding);

    RealizeResource();

    return TRUE;
}

wxFont::~wxFont()
{
    if ( wxTheFontList )
        wxTheFontList->DeleteObject(this);
}

// ----------------------------------------------------------------------------
// real implementation
// ----------------------------------------------------------------------------

bool wxFont::RealizeResource()
{
    if ( GetResourceHandle() )
    {
        // VZ: the old code returned FALSE in this case, but it doesn't seem
        //     to make sense because the font _was_ created
        return TRUE;
    }

    if(!M_FONTDATA->m_nativeFontInfoOk)
    {
      wxFillLogFont(&M_FONTDATA->m_nativeFontInfo.lf, this);
      M_FONTDATA->m_nativeFontInfoOk = TRUE;
    }

    M_FONTDATA->m_hFont = (WXHFONT)::CreateFontIndirect(&M_FONTDATA->m_nativeFontInfo.lf);
    M_FONTDATA->m_faceName = M_FONTDATA->m_nativeFontInfo.lf.lfFaceName;
    if ( !M_FONTDATA->m_hFont )
    {
        wxLogLastError(wxT("CreateFont"));

        return FALSE;
    }

    return TRUE;
}

bool wxFont::FreeResource(bool force)
{
    if ( GetResourceHandle() )
    {
        if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) )
        {
            wxLogLastError(wxT("DeleteObject(font)"));
        }

        M_FONTDATA->m_hFont = 0;

        return TRUE;
    }
    return FALSE;
}

WXHANDLE wxFont::GetResourceHandle()
{
    return GetHFONT();
}

WXHFONT wxFont::GetHFONT() const
{
    if ( !M_FONTDATA )
        return 0;
    else
        return (WXHANDLE)M_FONTDATA->m_hFont;
}

bool wxFont::IsFree() const
{
    return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
}

void wxFont::Unshare()
{
    // Don't change shared data
    if ( !m_refData )
    {
        m_refData = new wxFontRefData();
    }
    else
    {
        wxFontRefData* ref = new wxFontRefData(*M_FONTDATA);
        UnRef();
        m_refData = ref;
    }
}

// ----------------------------------------------------------------------------
// change font attribute: we recreate font when doing it
// ----------------------------------------------------------------------------

void wxFont::SetPointSize(int pointSize)
{
    Unshare();

    M_FONTDATA->m_pointSize = pointSize;
    M_FONTDATA->m_nativeFontInfoOk = FALSE;

    RealizeResource();
}

void wxFont::SetFamily(int family)
{
    Unshare();

    M_FONTDATA->m_family = family;
    M_FONTDATA->m_nativeFontInfoOk = FALSE;

    RealizeResource();
}

void wxFont::SetStyle(int style)
{
    Unshare();

    M_FONTDATA->m_style = style;
    M_FONTDATA->m_nativeFontInfoOk = FALSE;

    RealizeResource();
}

void wxFont::SetWeight(int weight)
{
    Unshare();

    M_FONTDATA->m_weight = weight;
    M_FONTDATA->m_nativeFontInfoOk = FALSE;

    RealizeResource();
}

void wxFont::SetFaceName(const wxString& faceName)
{
    Unshare();

    M_FONTDATA->m_faceName = faceName;
    M_FONTDATA->m_nativeFontInfoOk = FALSE;

    RealizeResource();
}

void wxFont::SetUnderlined(bool underlined)
{
    Unshare();

    M_FONTDATA->m_underlined = underlined;
    M_FONTDATA->m_nativeFontInfoOk = FALSE;

    RealizeResource();
}

void wxFont::SetEncoding(wxFontEncoding encoding)
{
    Unshare();

    M_FONTDATA->m_encoding = encoding;
    M_FONTDATA->m_nativeFontInfoOk = FALSE;

    RealizeResource();
}

void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info)
{
    Unshare();

    FreeResource();

    M_FONTDATA->Init(info);

    RealizeResource();
}

// ----------------------------------------------------------------------------
// accessors
// ----------------------------------------------------------------------------

int wxFont::GetPointSize() const
{
    return M_FONTDATA->m_pointSize;
}

int wxFont::GetFamily() const
{
    return M_FONTDATA->m_family;
}

int wxFont::GetFontId() const
{
    return M_FONTDATA->m_fontId;
}

int wxFont::GetStyle() const
{
    return M_FONTDATA->m_style;
}

int wxFont::GetWeight() const
{
    return M_FONTDATA->m_weight;
}

bool wxFont::GetUnderlined() const
{
    return M_FONTDATA->m_underlined;
}

wxString wxFont::GetFaceName() const
{
    wxString str;
    if ( M_FONTDATA )
        str = M_FONTDATA->m_faceName;
    return str;
}

wxFontEncoding wxFont::GetEncoding() const
{
    return M_FONTDATA->m_encoding;
}

wxNativeFontInfo *wxFont::GetNativeFontInfo() const
{
    if( M_FONTDATA->m_nativeFontInfoOk )
        return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo);

    return 0;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: font.cpp
	3	// Purpose: wxFont class
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 01/02/97
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart and Markus Holzem
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "font.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26
	27	#ifdef __BORLANDC__
	28	#pragma hdrstop
	29	#endif
	30
	31	#ifndef WX_PRECOMP
	32	#include "wx/setup.h"
	33	#include "wx/list.h"
	34	#include "wx/utils.h"
	35	#include "wx/app.h"
	36	#include "wx/font.h"
	37	#include "wx/log.h"
	38	#endif // WX_PRECOMP
	39
	40	#include "wx/fontutil.h"
	41	#include "wx/tokenzr.h"
	42
	43	#include "wx/msw/private.h"
	44
	45	IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
	46
	47	// ----------------------------------------------------------------------------
	48	// constants
	49	// ----------------------------------------------------------------------------
	50
	51	// the default font size in points
	52	static const int wxDEFAULT_FONT_SIZE = 12;
	53
	54	// ----------------------------------------------------------------------------
	55	// wxFontRefData - the internal description of the font
	56	// ----------------------------------------------------------------------------
	57
	58	class WXDLLEXPORT wxFontRefData: public wxGDIRefData
	59	{
	60	friend class WXDLLEXPORT wxFont;
	61
	62	public:
	63	wxFontRefData()
	64	{
	65	Init(wxDEFAULT_FONT_SIZE, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE,
	66	"", wxFONTENCODING_DEFAULT);
	67	}
	68
	69	wxFontRefData(const wxFontRefData& data)
	70	{
	71	Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
	72	data.m_underlined, data.m_faceName, data.m_encoding);
	73
	74	m_fontId = data.m_fontId;
	75	}
	76
	77	wxFontRefData(int size,
	78	int family,
	79	int style,
	80	int weight,
	81	bool underlined,
	82	const wxString& faceName,
	83	wxFontEncoding encoding)
	84	{
	85	Init(size, family, style, weight, underlined, faceName, encoding);
	86	}
	87
	88	wxFontRefData(const wxNativeFontInfo& info)
	89	{
	90	Init(info);
	91	}
	92
	93	virtual ~wxFontRefData();
	94
	95	protected:
	96	// common part of all ctors
	97	void Init(int size,
	98	int family,
	99	int style,
	100	int weight,
	101	bool underlined,
	102	const wxString& faceName,
	103	wxFontEncoding encoding);
	104
	105	void Init(const wxNativeFontInfo& info);
	106
	107	// If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE
	108	// DELETED by destructor
	109	bool m_temporary;
	110
	111	int m_fontId;
	112
	113	// font characterstics
	114	int m_pointSize;
	115	int m_family;
	116	int m_style;
	117	int m_weight;
	118	bool m_underlined;
	119	wxString m_faceName;
	120	wxFontEncoding m_encoding;
	121
	122	// Windows font handle
	123	WXHFONT m_hFont;
	124
	125	// Native font info
	126	wxNativeFontInfo m_nativeFontInfo;
	127	bool m_nativeFontInfoOk;
	128	};
	129
	130	// ============================================================================
	131	// implementation
	132	// ============================================================================
	133
	134	// ----------------------------------------------------------------------------
	135	// wxFontRefData
	136	// ----------------------------------------------------------------------------
	137
	138	void wxFontRefData::Init(int pointSize,
	139	int family,
	140	int style,
	141	int weight,
	142	bool underlined,
	143	const wxString& faceName,
	144	wxFontEncoding encoding)
	145	{
	146	m_style = style;
	147	m_pointSize = pointSize;
	148	m_family = family;
	149	m_style = style;
	150	m_weight = weight;
	151	m_underlined = underlined;
	152	m_faceName = faceName;
	153	m_encoding = encoding;
	154
	155	m_fontId = 0;
	156	m_temporary = FALSE;
	157
	158	m_hFont = 0;
	159
	160	m_nativeFontInfoOk = FALSE;
	161	}
	162
	163	void wxFontRefData::Init(const wxNativeFontInfo& info)
	164	{
	165	// extract family from pitch-and-family
	166	int lfFamily = info.lf.lfPitchAndFamily;
	167	if ( lfFamily & FIXED_PITCH )
	168	lfFamily -= FIXED_PITCH;
	169	if ( lfFamily & VARIABLE_PITCH )
	170	lfFamily -= VARIABLE_PITCH;
	171
	172	switch ( lfFamily )
	173	{
	174	case FF_ROMAN:
	175	m_family = wxROMAN;
	176	break;
	177
	178	case FF_SWISS:
	179	m_family = wxSWISS;
	180	break;
	181
	182	case FF_SCRIPT:
	183	m_family = wxSCRIPT;
	184	break;
	185
	186	case FF_MODERN:
	187	m_family = wxMODERN;
	188	break;
	189
	190	case FF_DECORATIVE:
	191	m_family = wxDECORATIVE;
	192	break;
	193
	194	default:
	195	m_family = wxSWISS;
	196	}
	197
	198	// weight and style
	199	switch ( info.lf.lfWeight )
	200	{
	201	case FW_LIGHT:
	202	m_weight = wxLIGHT;
	203	break;
	204
	205	default:
	206	case FW_NORMAL:
	207	m_weight = wxNORMAL;
	208	break;
	209
	210	case FW_BOLD:
	211	m_weight = wxBOLD;
	212	break;
	213	}
	214
	215	m_style = info.lf.lfItalic ? wxITALIC : wxNORMAL;
	216
	217	m_underlined = info.lf.lfUnderline != 0;
	218
	219	m_faceName = info.lf.lfFaceName;
	220
	221	// remember that 1pt = 1/72inch
	222	int height = abs(info.lf.lfHeight);
	223
	224	#if wxUSE_SCREEN_DPI
	225	HDC dc = ::GetDC(NULL);
	226	static const int ppInch = GetDeviceCaps(dc, LOGPIXELSY);
	227	::ReleaseDC(NULL, dc);
	228	#else
	229	static const int ppInch = 96;
	230	#endif
	231	m_pointSize = (int) (((72.0*((double)height))/(double) ppInch) + 0.5);
	232
	233	m_encoding = wxGetFontEncFromCharSet(info.lf.lfCharSet);
	234
	235	m_fontId = 0;
	236	m_temporary = FALSE;
	237
	238	m_hFont = 0;
	239
	240	m_nativeFontInfoOk = TRUE;
	241	m_nativeFontInfo = info;
	242	}
	243
	244	wxFontRefData::~wxFontRefData()
	245	{
	246	if ( m_hFont )
	247	{
	248	if ( !::DeleteObject((HFONT) m_hFont) )
	249	{
	250	wxLogLastError(wxT("DeleteObject(font)"));
	251	}
	252	}
	253	}
	254
	255
	256	// ----------------------------------------------------------------------------
	257	// wxNativeFontInfo
	258	// ----------------------------------------------------------------------------
	259
	260	bool wxNativeFontInfo::FromString(const wxString& s)
	261	{
	262	long l;
	263
	264	wxStringTokenizer tokenizer(s, _T(";"));
	265
	266	wxString token = tokenizer.GetNextToken();
	267	//
	268	// Ignore the version for now
	269	//
	270
	271	token = tokenizer.GetNextToken();
	272	if ( !token.ToLong(&l) )
	273	return FALSE;
	274	lf.lfHeight = l;
	275
	276	token = tokenizer.GetNextToken();
	277	if ( !token.ToLong(&l) )
	278	return FALSE;
	279	lf.lfWidth = l;
	280
	281	token = tokenizer.GetNextToken();
	282	if ( !token.ToLong(&l) )
	283	return FALSE;
	284	lf.lfEscapement = l;
	285
	286	token = tokenizer.GetNextToken();
	287	if ( !token.ToLong(&l) )
	288	return FALSE;
	289	lf.lfOrientation = l;
	290
	291	token = tokenizer.GetNextToken();
	292	if ( !token.ToLong(&l) )
	293	return FALSE;
	294	lf.lfWeight = l;
	295
	296	token = tokenizer.GetNextToken();
	297	if ( !token.ToLong(&l) )
	298	return FALSE;
	299	lf.lfItalic = l;
	300
	301	token = tokenizer.GetNextToken();
	302	if ( !token.ToLong(&l) )
	303	return FALSE;
	304	lf.lfUnderline = l;
	305
	306	token = tokenizer.GetNextToken();
	307	if ( !token.ToLong(&l) )
	308	return FALSE;
	309	lf.lfStrikeOut = l;
	310
	311	token = tokenizer.GetNextToken();
	312	if ( !token.ToLong(&l) )
	313	return FALSE;
	314	lf.lfCharSet = l;
	315
	316	token = tokenizer.GetNextToken();
	317	if ( !token.ToLong(&l) )
	318	return FALSE;
	319	lf.lfOutPrecision = l;
	320
	321	token = tokenizer.GetNextToken();
	322	if ( !token.ToLong(&l) )
	323	return FALSE;
	324	lf.lfClipPrecision = l;
	325
	326	token = tokenizer.GetNextToken();
	327	if ( !token.ToLong(&l) )
	328	return FALSE;
	329	lf.lfQuality = l;
	330
	331	token = tokenizer.GetNextToken();
	332	if ( !token.ToLong(&l) )
	333	return FALSE;
	334	lf.lfPitchAndFamily = l;
	335
	336	token = tokenizer.GetNextToken();
	337	if(!token)
	338	return FALSE;
	339	wxStrcpy(lf.lfFaceName, token.c_str());
	340
	341	return TRUE;
	342	}
	343
	344	wxString wxNativeFontInfo::ToString() const
	345	{
	346	wxString s;
	347
	348	s.Printf(_T("%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%s"),
	349	0, // version, in case we want to change the format later
	350	lf.lfHeight,
	351	lf.lfWidth,
	352	lf.lfEscapement,
	353	lf.lfOrientation,
	354	lf.lfWeight,
	355	lf.lfItalic,
	356	lf.lfUnderline,
	357	lf.lfStrikeOut,
	358	lf.lfCharSet,
	359	lf.lfOutPrecision,
	360	lf.lfClipPrecision,
	361	lf.lfQuality,
	362	lf.lfPitchAndFamily,
	363	lf.lfFaceName);
	364
	365	return s;
	366	}
	367
	368	// ----------------------------------------------------------------------------
	369	// wxFont
	370	// ----------------------------------------------------------------------------
	371
	372	void wxFont::Init()
	373	{
	374	if ( wxTheFontList )
	375	wxTheFontList->Append(this);
	376	}
	377
	378	bool wxFont::Create(const wxNativeFontInfo& info)
	379	{
	380	UnRef();
	381
	382	m_refData = new wxFontRefData(info);
	383
	384	RealizeResource();
	385
	386	return TRUE;
	387	}
	388
	389	wxFont::wxFont(const wxString& fontdesc)
	390	{
	391	wxNativeFontInfo info;
	392	if ( info.FromString(fontdesc) )
	393	(void)Create(info);
	394	}
	395
	396	/* Constructor for a font. Note that the real construction is done
	397	* in wxDC::SetFont, when information is available about scaling etc.
	398	*/
	399	bool wxFont::Create(int pointSize,
	400	int family,
	401	int style,
	402	int weight,
	403	bool underlined,
	404	const wxString& faceName,
	405	wxFontEncoding encoding)
	406	{
	407	UnRef();
	408
	409	// wxDEFAULT is a valid value for the font size too so we must treat it
	410	// specially here (otherwise the size would be 70 == wxDEFAULT value)
	411	if ( pointSize == wxDEFAULT )
	412	pointSize = wxDEFAULT_FONT_SIZE;
	413
	414	m_refData = new wxFontRefData(pointSize, family, style, weight,
	415	underlined, faceName, encoding);
	416
	417	RealizeResource();
	418
	419	return TRUE;
	420	}
	421
	422	wxFont::~wxFont()
	423	{
	424	if ( wxTheFontList )
	425	wxTheFontList->DeleteObject(this);
	426	}
	427
	428	// ----------------------------------------------------------------------------
	429	// real implementation
	430	// ----------------------------------------------------------------------------
	431
	432	bool wxFont::RealizeResource()
	433	{
	434	if ( GetResourceHandle() )
	435	{
	436	// VZ: the old code returned FALSE in this case, but it doesn't seem
	437	// to make sense because the font _was_ created
	438	return TRUE;
	439	}
	440
	441	if(!M_FONTDATA->m_nativeFontInfoOk)
	442	{
	443	wxFillLogFont(&M_FONTDATA->m_nativeFontInfo.lf, this);
	444	M_FONTDATA->m_nativeFontInfoOk = TRUE;
	445	}
	446
	447	M_FONTDATA->m_hFont = (WXHFONT)::CreateFontIndirect(&M_FONTDATA->m_nativeFontInfo.lf);
	448	M_FONTDATA->m_faceName = M_FONTDATA->m_nativeFontInfo.lf.lfFaceName;
	449	if ( !M_FONTDATA->m_hFont )
	450	{
	451	wxLogLastError(wxT("CreateFont"));
	452
	453	return FALSE;
	454	}
	455
	456	return TRUE;
	457	}
	458
	459	bool wxFont::FreeResource(bool force)
	460	{
	461	if ( GetResourceHandle() )
	462	{
	463	if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) )
	464	{
	465	wxLogLastError(wxT("DeleteObject(font)"));
	466	}
	467
	468	M_FONTDATA->m_hFont = 0;
	469
	470	return TRUE;
	471	}
	472	return FALSE;
	473	}
	474
	475	WXHANDLE wxFont::GetResourceHandle()
	476	{
	477	return GetHFONT();
	478	}
	479
	480	WXHFONT wxFont::GetHFONT() const
	481	{
	482	if ( !M_FONTDATA )
	483	return 0;
	484	else
	485	return (WXHANDLE)M_FONTDATA->m_hFont;
	486	}
	487
	488	bool wxFont::IsFree() const
	489	{
	490	return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
	491	}
	492
	493	void wxFont::Unshare()
	494	{
	495	// Don't change shared data
	496	if ( !m_refData )
	497	{
	498	m_refData = new wxFontRefData();
	499	}
	500	else
	501	{
	502	wxFontRefData* ref = new wxFontRefData(*M_FONTDATA);
	503	UnRef();
	504	m_refData = ref;
	505	}
	506	}
	507
	508	// ----------------------------------------------------------------------------
	509	// change font attribute: we recreate font when doing it
	510	// ----------------------------------------------------------------------------
	511
	512	void wxFont::SetPointSize(int pointSize)
	513	{
	514	Unshare();
	515
	516	M_FONTDATA->m_pointSize = pointSize;
	517	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	518
	519	RealizeResource();
	520	}
	521
	522	void wxFont::SetFamily(int family)
	523	{
	524	Unshare();
	525
	526	M_FONTDATA->m_family = family;
	527	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	528
	529	RealizeResource();
	530	}
	531
	532	void wxFont::SetStyle(int style)
	533	{
	534	Unshare();
	535
	536	M_FONTDATA->m_style = style;
	537	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	538
	539	RealizeResource();
	540	}
	541
	542	void wxFont::SetWeight(int weight)
	543	{
	544	Unshare();
	545
	546	M_FONTDATA->m_weight = weight;
	547	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	548
	549	RealizeResource();
	550	}
	551
	552	void wxFont::SetFaceName(const wxString& faceName)
	553	{
	554	Unshare();
	555
	556	M_FONTDATA->m_faceName = faceName;
	557	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	558
	559	RealizeResource();
	560	}
	561
	562	void wxFont::SetUnderlined(bool underlined)
	563	{
	564	Unshare();
	565
	566	M_FONTDATA->m_underlined = underlined;
	567	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	568
	569	RealizeResource();
	570	}
	571
	572	void wxFont::SetEncoding(wxFontEncoding encoding)
	573	{
	574	Unshare();
	575
	576	M_FONTDATA->m_encoding = encoding;
	577	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	578
	579	RealizeResource();
	580	}
	581
	582	void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info)
	583	{
	584	Unshare();
	585
	586	FreeResource();
	587
	588	M_FONTDATA->Init(info);
	589
	590	RealizeResource();
	591	}
	592
	593	// ----------------------------------------------------------------------------
	594	// accessors
	595	// ----------------------------------------------------------------------------
	596
	597	int wxFont::GetPointSize() const
	598	{
	599	return M_FONTDATA->m_pointSize;
	600	}
	601
	602	int wxFont::GetFamily() const
	603	{
	604	return M_FONTDATA->m_family;
	605	}
	606
	607	int wxFont::GetFontId() const
	608	{
	609	return M_FONTDATA->m_fontId;
	610	}
	611
	612	int wxFont::GetStyle() const
	613	{
	614	return M_FONTDATA->m_style;
	615	}
	616
	617	int wxFont::GetWeight() const
	618	{
	619	return M_FONTDATA->m_weight;
	620	}
	621
	622	bool wxFont::GetUnderlined() const
	623	{
	624	return M_FONTDATA->m_underlined;
	625	}
	626
	627	wxString wxFont::GetFaceName() const
	628	{
	629	wxString str;
	630	if ( M_FONTDATA )
	631	str = M_FONTDATA->m_faceName;
	632	return str;
	633	}
	634
	635	wxFontEncoding wxFont::GetEncoding() const
	636	{
	637	return M_FONTDATA->m_encoding;
	638	}
	639
	640	wxNativeFontInfo *wxFont::GetNativeFontInfo() const
	641	{
	642	if( M_FONTDATA->m_nativeFontInfoOk )
	643	return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo);
	644
	645	return 0;
	646	}
	647