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;

    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
	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	int height = abs(info.lf.lfHeight);
	222
	223	// remember that 1pt = 1/72inch
	224	const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY);
	225	m_pointSize = (int) (((72.0*((double)height))/(double) ppInch) + 0.5);
	226
	227	m_encoding = wxGetFontEncFromCharSet(info.lf.lfCharSet);
	228
	229	m_fontId = 0;
	230	m_temporary = FALSE;
	231
	232	m_hFont = 0;
	233
	234	m_nativeFontInfoOk = TRUE;
	235	m_nativeFontInfo = info;
	236	}
	237
	238	wxFontRefData::~wxFontRefData()
	239	{
	240	if ( m_hFont )
	241	{
	242	if ( !::DeleteObject((HFONT) m_hFont) )
	243	{
	244	wxLogLastError(wxT("DeleteObject(font)"));
	245	}
	246	}
	247	}
	248
	249
	250	// ----------------------------------------------------------------------------
	251	// wxNativeFontInfo
	252	// ----------------------------------------------------------------------------
	253
	254	bool wxNativeFontInfo::FromString(const wxString& s)
	255	{
	256	long l;
	257
	258	wxStringTokenizer tokenizer(s, _T(";"));
	259
	260	wxString token = tokenizer.GetNextToken();
	261	//
	262	// Ignore the version for now
	263	//
	264
	265	token = tokenizer.GetNextToken();
	266	if ( !token.ToLong(&l) )
	267	return FALSE;
	268	lf.lfHeight = l;
	269
	270	token = tokenizer.GetNextToken();
	271	if ( !token.ToLong(&l) )
	272	return FALSE;
	273	lf.lfWidth = l;
	274
	275	token = tokenizer.GetNextToken();
	276	if ( !token.ToLong(&l) )
	277	return FALSE;
	278	lf.lfEscapement = l;
	279
	280	token = tokenizer.GetNextToken();
	281	if ( !token.ToLong(&l) )
	282	return FALSE;
	283	lf.lfOrientation = l;
	284
	285	token = tokenizer.GetNextToken();
	286	if ( !token.ToLong(&l) )
	287	return FALSE;
	288	lf.lfWeight = l;
	289
	290	token = tokenizer.GetNextToken();
	291	if ( !token.ToLong(&l) )
	292	return FALSE;
	293	lf.lfItalic = (BYTE)l;
	294
	295	token = tokenizer.GetNextToken();
	296	if ( !token.ToLong(&l) )
	297	return FALSE;
	298	lf.lfUnderline = (BYTE)l;
	299
	300	token = tokenizer.GetNextToken();
	301	if ( !token.ToLong(&l) )
	302	return FALSE;
	303	lf.lfStrikeOut = (BYTE)l;
	304
	305	token = tokenizer.GetNextToken();
	306	if ( !token.ToLong(&l) )
	307	return FALSE;
	308	lf.lfCharSet = (BYTE)l;
	309
	310	token = tokenizer.GetNextToken();
	311	if ( !token.ToLong(&l) )
	312	return FALSE;
	313	lf.lfOutPrecision = (BYTE)l;
	314
	315	token = tokenizer.GetNextToken();
	316	if ( !token.ToLong(&l) )
	317	return FALSE;
	318	lf.lfClipPrecision = (BYTE)l;
	319
	320	token = tokenizer.GetNextToken();
	321	if ( !token.ToLong(&l) )
	322	return FALSE;
	323	lf.lfQuality = (BYTE)l;
	324
	325	token = tokenizer.GetNextToken();
	326	if ( !token.ToLong(&l) )
	327	return FALSE;
	328	lf.lfPitchAndFamily = (BYTE)l;
	329
	330	token = tokenizer.GetNextToken();
	331	if(!token)
	332	return FALSE;
	333	wxStrcpy(lf.lfFaceName, token.c_str());
	334
	335	return TRUE;
	336	}
	337
	338	wxString wxNativeFontInfo::ToString() const
	339	{
	340	wxString s;
	341
	342	s.Printf(_T("%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%s"),
	343	0, // version, in case we want to change the format later
	344	lf.lfHeight,
	345	lf.lfWidth,
	346	lf.lfEscapement,
	347	lf.lfOrientation,
	348	lf.lfWeight,
	349	lf.lfItalic,
	350	lf.lfUnderline,
	351	lf.lfStrikeOut,
	352	lf.lfCharSet,
	353	lf.lfOutPrecision,
	354	lf.lfClipPrecision,
	355	lf.lfQuality,
	356	lf.lfPitchAndFamily,
	357	lf.lfFaceName);
	358
	359	return s;
	360	}
	361
	362	// ----------------------------------------------------------------------------
	363	// wxFont
	364	// ----------------------------------------------------------------------------
	365
	366	void wxFont::Init()
	367	{
	368	if ( wxTheFontList )
	369	wxTheFontList->Append(this);
	370	}
	371
	372	bool wxFont::Create(const wxNativeFontInfo& info)
	373	{
	374	UnRef();
	375
	376	m_refData = new wxFontRefData(info);
	377
	378	RealizeResource();
	379
	380	return TRUE;
	381	}
	382
	383	wxFont::wxFont(const wxString& fontdesc)
	384	{
	385	wxNativeFontInfo info;
	386	if ( info.FromString(fontdesc) )
	387	(void)Create(info);
	388	}
	389
	390	/* Constructor for a font. Note that the real construction is done
	391	* in wxDC::SetFont, when information is available about scaling etc.
	392	*/
	393	bool wxFont::Create(int pointSize,
	394	int family,
	395	int style,
	396	int weight,
	397	bool underlined,
	398	const wxString& faceName,
	399	wxFontEncoding encoding)
	400	{
	401	UnRef();
	402
	403	// wxDEFAULT is a valid value for the font size too so we must treat it
	404	// specially here (otherwise the size would be 70 == wxDEFAULT value)
	405	if ( pointSize == wxDEFAULT )
	406	pointSize = wxDEFAULT_FONT_SIZE;
	407
	408	m_refData = new wxFontRefData(pointSize, family, style, weight,
	409	underlined, faceName, encoding);
	410
	411	RealizeResource();
	412
	413	return TRUE;
	414	}
	415
	416	wxFont::~wxFont()
	417	{
	418	if ( wxTheFontList )
	419	wxTheFontList->DeleteObject(this);
	420	}
	421
	422	// ----------------------------------------------------------------------------
	423	// real implementation
	424	// ----------------------------------------------------------------------------
	425
	426	bool wxFont::RealizeResource()
	427	{
	428	if ( GetResourceHandle() )
	429	{
	430	// VZ: the old code returned FALSE in this case, but it doesn't seem
	431	// to make sense because the font _was_ created
	432	return TRUE;
	433	}
	434
	435	if(!M_FONTDATA->m_nativeFontInfoOk)
	436	{
	437	wxFillLogFont(&M_FONTDATA->m_nativeFontInfo.lf, this);
	438	M_FONTDATA->m_nativeFontInfoOk = TRUE;
	439	}
	440
	441	M_FONTDATA->m_hFont = (WXHFONT)::CreateFontIndirect(&M_FONTDATA->m_nativeFontInfo.lf);
	442	M_FONTDATA->m_faceName = M_FONTDATA->m_nativeFontInfo.lf.lfFaceName;
	443	if ( !M_FONTDATA->m_hFont )
	444	{
	445	wxLogLastError(wxT("CreateFont"));
	446
	447	return FALSE;
	448	}
	449
	450	return TRUE;
	451	}
	452
	453	bool wxFont::FreeResource(bool WXUNUSED(force))
	454	{
	455	if ( GetResourceHandle() )
	456	{
	457	if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) )
	458	{
	459	wxLogLastError(wxT("DeleteObject(font)"));
	460	}
	461
	462	M_FONTDATA->m_hFont = 0;
	463
	464	return TRUE;
	465	}
	466	return FALSE;
	467	}
	468
	469	WXHANDLE wxFont::GetResourceHandle()
	470	{
	471	return GetHFONT();
	472	}
	473
	474	WXHFONT wxFont::GetHFONT() const
	475	{
	476	if ( !M_FONTDATA )
	477	return 0;
	478	else
	479	return (WXHANDLE)M_FONTDATA->m_hFont;
	480	}
	481
	482	bool wxFont::IsFree() const
	483	{
	484	return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
	485	}
	486
	487	void wxFont::Unshare()
	488	{
	489	// Don't change shared data
	490	if ( !m_refData )
	491	{
	492	m_refData = new wxFontRefData();
	493	}
	494	else
	495	{
	496	wxFontRefData* ref = new wxFontRefData(*M_FONTDATA);
	497	UnRef();
	498	m_refData = ref;
	499	}
	500	}
	501
	502	// ----------------------------------------------------------------------------
	503	// change font attribute: we recreate font when doing it
	504	// ----------------------------------------------------------------------------
	505
	506	void wxFont::SetPointSize(int pointSize)
	507	{
	508	Unshare();
	509
	510	M_FONTDATA->m_pointSize = pointSize;
	511	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	512
	513	RealizeResource();
	514	}
	515
	516	void wxFont::SetFamily(int family)
	517	{
	518	Unshare();
	519
	520	M_FONTDATA->m_family = family;
	521	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	522
	523	RealizeResource();
	524	}
	525
	526	void wxFont::SetStyle(int style)
	527	{
	528	Unshare();
	529
	530	M_FONTDATA->m_style = style;
	531	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	532
	533	RealizeResource();
	534	}
	535
	536	void wxFont::SetWeight(int weight)
	537	{
	538	Unshare();
	539
	540	M_FONTDATA->m_weight = weight;
	541	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	542
	543	RealizeResource();
	544	}
	545
	546	void wxFont::SetFaceName(const wxString& faceName)
	547	{
	548	Unshare();
	549
	550	M_FONTDATA->m_faceName = faceName;
	551	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	552
	553	RealizeResource();
	554	}
	555
	556	void wxFont::SetUnderlined(bool underlined)
	557	{
	558	Unshare();
	559
	560	M_FONTDATA->m_underlined = underlined;
	561	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	562
	563	RealizeResource();
	564	}
	565
	566	void wxFont::SetEncoding(wxFontEncoding encoding)
	567	{
	568	Unshare();
	569
	570	M_FONTDATA->m_encoding = encoding;
	571	M_FONTDATA->m_nativeFontInfoOk = FALSE;
	572
	573	RealizeResource();
	574	}
	575
	576	void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info)
	577	{
	578	Unshare();
	579
	580	FreeResource();
	581
	582	M_FONTDATA->Init(info);
	583
	584	RealizeResource();
	585	}
	586
	587	// ----------------------------------------------------------------------------
	588	// accessors
	589	// ----------------------------------------------------------------------------
	590
	591	int wxFont::GetPointSize() const
	592	{
	593	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	594
	595	return M_FONTDATA->m_pointSize;
	596	}
	597
	598	int wxFont::GetFamily() const
	599	{
	600	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	601
	602	return M_FONTDATA->m_family;
	603	}
	604
	605	int wxFont::GetFontId() const
	606	{
	607	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	608
	609	return M_FONTDATA->m_fontId;
	610	}
	611
	612	int wxFont::GetStyle() const
	613	{
	614	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	615
	616	return M_FONTDATA->m_style;
	617	}
	618
	619	int wxFont::GetWeight() const
	620	{
	621	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	622
	623	return M_FONTDATA->m_weight;
	624	}
	625
	626	bool wxFont::GetUnderlined() const
	627	{
	628	wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
	629
	630	return M_FONTDATA->m_underlined;
	631	}
	632
	633	wxString wxFont::GetFaceName() const
	634	{
	635	wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
	636
	637	return M_FONTDATA->m_faceName;
	638	}
	639
	640	wxFontEncoding wxFont::GetEncoding() const
	641	{
	642	wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
	643
	644	return M_FONTDATA->m_encoding;
	645	}
	646
	647	wxNativeFontInfo *wxFont::GetNativeFontInfo() const
	648	{
	649	if( M_FONTDATA->m_nativeFontInfoOk )
	650	return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo);
	651
	652	return 0;
	653	}
	654