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"
#include "wx/tokenzr.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;

    int height = abs(info.lf.lfHeight);

    // remember that 1pt = 1/72inch
    const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY);
    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 = (BYTE)l;

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

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

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

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

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

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

    token = tokenizer.GetNextToken();
    if ( !token.ToLong(&l) )
        return FALSE;
    lf.lfPitchAndFamily = (BYTE)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 WXUNUSED(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
{
    wxCHECK_MSG( Ok(), 0, wxT("invalid font") );

    return M_FONTDATA->m_pointSize;
}

int wxFont::GetFamily() const
{
    wxCHECK_MSG( Ok(), 0, wxT("invalid font") );

    return M_FONTDATA->m_family;
}

int wxFont::GetFontId() const
{
    wxCHECK_MSG( Ok(), 0, wxT("invalid font") );

    return M_FONTDATA->m_fontId;
}

int wxFont::GetStyle() const
{
    wxCHECK_MSG( Ok(), 0, wxT("invalid font") );

    return M_FONTDATA->m_style;
}

int wxFont::GetWeight() const
{
    wxCHECK_MSG( Ok(), 0, wxT("invalid font") );

    return M_FONTDATA->m_weight;
}

bool wxFont::GetUnderlined() const
{
    wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );

    return M_FONTDATA->m_underlined;
}

wxString wxFont::GetFaceName() const
{
    wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );

    return M_FONTDATA->m_faceName;
}

wxFontEncoding wxFont::GetEncoding() const
{
    wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );

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