src/gtk/font.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        font.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

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

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

#include "wx/font.h"
#include "wx/fontutil.h"
#include "wx/cmndata.h"
#include "wx/utils.h"
#include "wx/log.h"
#include "wx/gdicmn.h"
#include "wx/tokenzr.h"
#include "wx/settings.h"

#include <strings.h>

#include <gdk/gdk.h>
#include <gtk/gtk.h>

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

class wxFontRefData : public wxObjectRefData
{
public:
    wxFontRefData(int size = wxDEFAULT,
                  int family = wxDEFAULT,
                  int style = wxDEFAULT,
                  int weight = wxDEFAULT,
                  bool underlined = FALSE,
                  const wxString& faceName = wxEmptyString,
                  wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
    wxFontRefData( const wxFontRefData& data );
    virtual ~wxFontRefData();

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

private:
    wxList          m_scaled_xfonts;
    int             m_pointSize;
    int             m_family,
                    m_style,
                    m_weight;
    bool            m_underlined;
    wxString        m_faceName;
    wxFontEncoding  m_encoding;

    friend wxFont;
};

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

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

void wxFontRefData::Init(int pointSize,
                         int family,
                         int style,
                         int weight,
                         bool underlined,
                         const wxString& faceName,
                         wxFontEncoding encoding)
{
    if (family == wxDEFAULT)
        m_family = wxSWISS;
    else
        m_family = family;

    m_faceName = faceName;

    if (style == wxDEFAULT)
        m_style = wxNORMAL;
    else
        m_style = style;

    if (weight == wxDEFAULT)
        m_weight = wxNORMAL;
    else
        m_weight = weight;

    if (pointSize == wxDEFAULT)
        m_pointSize = 12;
    else
        m_pointSize = pointSize;

    m_underlined = underlined;
    m_encoding = encoding;
}

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

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

wxFontRefData::~wxFontRefData()
{
    wxNode *node = m_scaled_xfonts.First();
    while (node)
    {
        GdkFont *font = (GdkFont*)node->Data();
        wxNode *next = node->Next();
        gdk_font_unref( font );
        node = next;
    }
}

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

IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)

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

wxFont::wxFont( const wxString& fontname, const wxFontData& fontdata )
{
    Init();

    wxCHECK_RET( !!fontname, _T("invalid font spec") );

    m_refData = new wxFontRefData();

    wxString tmp;

    wxStringTokenizer tn( fontname, wxT("-") );

    tn.GetNextToken();                           // skip initial empty token
    tn.GetNextToken();                           // foundry

    M_FONTDATA->m_faceName = tn.GetNextToken();  // family

    tmp = tn.GetNextToken().MakeUpper();         // weight
    if (tmp == wxT("BOLD")) M_FONTDATA->m_weight = wxBOLD;
    if (tmp == wxT("BLACK")) M_FONTDATA->m_weight = wxBOLD;
    if (tmp == wxT("EXTRABOLD")) M_FONTDATA->m_weight = wxBOLD;
    if (tmp == wxT("DEMIBOLD")) M_FONTDATA->m_weight = wxBOLD;
    if (tmp == wxT("ULTRABOLD")) M_FONTDATA->m_weight = wxBOLD;

    if (tmp == wxT("LIGHT")) M_FONTDATA->m_weight = wxLIGHT;
    if (tmp == wxT("THIN")) M_FONTDATA->m_weight = wxLIGHT;

    tmp = tn.GetNextToken().MakeUpper();        // slant
    if (tmp == wxT("I")) M_FONTDATA->m_style = wxITALIC;
    if (tmp == wxT("O")) M_FONTDATA->m_style = wxITALIC;

    tn.GetNextToken();                           // set width
    tn.GetNextToken();                           // add. style
    tn.GetNextToken();                           // pixel size

    tmp = tn.GetNextToken();                     // pointsize
    long num = wxStrtol (tmp.c_str(), (wxChar **) NULL, 10);
    M_FONTDATA->m_pointSize = (int)(num / 10);

    tn.GetNextToken();                           // x-res
    tn.GetNextToken();                           // y-res

    tmp = tn.GetNextToken().MakeUpper();         // spacing

    if (tmp == wxT("M"))
        M_FONTDATA->m_family = wxMODERN;
    else if (M_FONTDATA->m_faceName == wxT("TIMES"))
        M_FONTDATA->m_family = wxROMAN;
    else if (M_FONTDATA->m_faceName == wxT("HELVETICA"))
        M_FONTDATA->m_family = wxSWISS;
    else if (M_FONTDATA->m_faceName == wxT("LUCIDATYPEWRITER"))
        M_FONTDATA->m_family = wxTELETYPE;
    else if (M_FONTDATA->m_faceName == wxT("LUCIDA"))
        M_FONTDATA->m_family = wxDECORATIVE;
    else if (M_FONTDATA->m_faceName == wxT("UTOPIA"))
        M_FONTDATA->m_family = wxSCRIPT;

    tn.GetNextToken();                           // avg width

    // deal with font encoding
    M_FONTDATA->m_encoding = fontdata.GetEncoding();
    if ( M_FONTDATA->m_encoding == wxFONTENCODING_SYSTEM )
    {
        wxString registry = tn.GetNextToken().MakeUpper(),
                 encoding = tn.GetNextToken().MakeUpper();

        if ( registry == _T("ISO8859") )
        {
            int cp;
            if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
            {
                M_FONTDATA->m_encoding =
                    (wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
            }
        }
        else if ( registry == _T("MICROSOFT") )
        {
            int cp;
            if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
            {
                M_FONTDATA->m_encoding =
                    (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
            }
        }
        else if ( registry == _T("KOI8") )
        {
            M_FONTDATA->m_encoding = wxFONTENCODING_KOI8;
        }
        //else: unknown encoding - may be give a warning here?
    }
}

bool wxFont::Create( int pointSize,
                     int family,
                     int style,
                     int weight,
                     bool underlined,
                     const wxString& face,
                     wxFontEncoding encoding )
{
    m_refData = new wxFontRefData(pointSize, family, style, weight,
                                  underlined, face, encoding);

    return TRUE;
}

void wxFont::Unshare()
{
    if (!m_refData)
    {
        m_refData = new wxFontRefData();
    }
    else
    {
        wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
        UnRef();
        m_refData = ref;
    }
}

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

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

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

    return M_FONTDATA->m_pointSize;
}

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

    return M_FONTDATA->m_faceName;
}

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

    return M_FONTDATA->m_family;
}

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;
}


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

    return M_FONTDATA->m_encoding;
}

// ----------------------------------------------------------------------------
// change font attributes
// ----------------------------------------------------------------------------

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

    M_FONTDATA->m_pointSize = pointSize;
}

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

    M_FONTDATA->m_family = family;
}

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

    M_FONTDATA->m_style = style;
}

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

    M_FONTDATA->m_weight = weight;
}

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

    M_FONTDATA->m_faceName = faceName;
}

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

    M_FONTDATA->m_underlined = underlined;
}

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

    M_FONTDATA->m_encoding = encoding;
}

// ----------------------------------------------------------------------------
// get internal representation of font
// ----------------------------------------------------------------------------

static GdkFont *g_systemDefaultGuiFont = (GdkFont*) NULL;

static GdkFont *GtkGetDefaultGuiFont()
{
    if (!g_systemDefaultGuiFont)
    {
        GtkWidget *widget = gtk_button_new();
        GtkStyle *def = gtk_rc_get_style( widget );
        if (def)
        {
            g_systemDefaultGuiFont = gdk_font_ref( def->font );
        }
        else
        {
            def = gtk_widget_get_default_style();
            if (def)
                g_systemDefaultGuiFont = gdk_font_ref( def->font );
        }
        gtk_widget_destroy( widget );
    }
    return g_systemDefaultGuiFont;
}

GdkFont *wxFont::GetInternalFont( float scale ) const
{
    if (!Ok())
    {
        wxFAIL_MSG( wxT("invalid font") );

        return (GdkFont*) NULL;
    }

    long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */
    int point_scale = (int)((M_FONTDATA->m_pointSize * 10 * int_scale) / 100);
    GdkFont *font = (GdkFont *) NULL;

    wxNode *node = M_FONTDATA->m_scaled_xfonts.Find(int_scale);
    if (node)
    {
        font = (GdkFont*)node->Data();
    }
    else
    {
        if (*this == wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT))
        {
            font = GtkGetDefaultGuiFont();
        }
        if (!font)
        {
            font = wxLoadQueryNearestFont( point_scale,
                                           M_FONTDATA->m_family,
                                           M_FONTDATA->m_style,
                                           M_FONTDATA->m_weight,
                                           M_FONTDATA->m_underlined,
                                           M_FONTDATA->m_faceName,
                                           M_FONTDATA->m_encoding );
        }

        M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
    }

    // it's quite useless to make it a wxCHECK because we're going to crash
    // anyhow...
    wxASSERT_MSG( font, wxT("could not load any font?") );

    return font;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: font.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	// ============================================================================
	11	// declarations
	12	// ============================================================================
	13
	14	// ----------------------------------------------------------------------------
	15	// headers
	16	// ----------------------------------------------------------------------------
	17
	18	#ifdef __GNUG__
	19	#pragma implementation "font.h"
	20	#endif
	21
	22	#include "wx/font.h"
	23	#include "wx/fontutil.h"
	24	#include "wx/cmndata.h"
	25	#include "wx/utils.h"
	26	#include "wx/log.h"
	27	#include "wx/gdicmn.h"
	28	#include "wx/tokenzr.h"
	29	#include "wx/settings.h"
	30
	31	#include <strings.h>
	32
	33	#include <gdk/gdk.h>
	34	#include <gtk/gtk.h>
	35
	36	// ----------------------------------------------------------------------------
	37	// wxFontRefData
	38	// ----------------------------------------------------------------------------
	39
	40	class wxFontRefData : public wxObjectRefData
	41	{
	42	public:
	43	wxFontRefData(int size = wxDEFAULT,
	44	int family = wxDEFAULT,
	45	int style = wxDEFAULT,
	46	int weight = wxDEFAULT,
	47	bool underlined = FALSE,
	48	const wxString& faceName = wxEmptyString,
	49	wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
	50	wxFontRefData( const wxFontRefData& data );
	51	virtual ~wxFontRefData();
	52
	53	protected:
	54	// common part of all ctors
	55	void Init(int pointSize,
	56	int family,
	57	int style,
	58	int weight,
	59	bool underlined,
	60	const wxString& faceName,
	61	wxFontEncoding encoding);
	62
	63	private:
	64	wxList m_scaled_xfonts;
	65	int m_pointSize;
	66	int m_family,
	67	m_style,
	68	m_weight;
	69	bool m_underlined;
	70	wxString m_faceName;
	71	wxFontEncoding m_encoding;
	72
	73	friend wxFont;
	74	};
	75
	76	// ============================================================================
	77	// implementation
	78	// ============================================================================
	79
	80	// ----------------------------------------------------------------------------
	81	// wxFontRefData
	82	// ----------------------------------------------------------------------------
	83
	84	void wxFontRefData::Init(int pointSize,
	85	int family,
	86	int style,
	87	int weight,
	88	bool underlined,
	89	const wxString& faceName,
	90	wxFontEncoding encoding)
	91	{
	92	if (family == wxDEFAULT)
	93	m_family = wxSWISS;
	94	else
	95	m_family = family;
	96
	97	m_faceName = faceName;
	98
	99	if (style == wxDEFAULT)
	100	m_style = wxNORMAL;
	101	else
	102	m_style = style;
	103
	104	if (weight == wxDEFAULT)
	105	m_weight = wxNORMAL;
	106	else
	107	m_weight = weight;
	108
	109	if (pointSize == wxDEFAULT)
	110	m_pointSize = 12;
	111	else
	112	m_pointSize = pointSize;
	113
	114	m_underlined = underlined;
	115	m_encoding = encoding;
	116	}
	117
	118	wxFontRefData::wxFontRefData( const wxFontRefData& data )
	119	: m_scaled_xfonts(wxKEY_INTEGER)
	120	{
	121	Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
	122	data.m_underlined, data.m_faceName, data.m_encoding);
	123	}
	124
	125	wxFontRefData::wxFontRefData(int size, int family, int style,
	126	int weight, bool underlined, const wxString& faceName, wxFontEncoding encoding )
	127	: m_scaled_xfonts(wxKEY_INTEGER)
	128	{
	129	Init(size, family, style, weight,
	130	underlined, faceName, encoding);
	131	}
	132
	133	wxFontRefData::~wxFontRefData()
	134	{
	135	wxNode *node = m_scaled_xfonts.First();
	136	while (node)
	137	{
	138	GdkFont font = (GdkFont)node->Data();
	139	wxNode *next = node->Next();
	140	gdk_font_unref( font );
	141	node = next;
	142	}
	143	}
	144
	145	// ----------------------------------------------------------------------------
	146	// wxFont
	147	// ----------------------------------------------------------------------------
	148
	149	IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
	150
	151	void wxFont::Init()
	152	{
	153	if (wxTheFontList)
	154	wxTheFontList->Append( this );
	155	}
	156
	157	wxFont::wxFont( const wxString& fontname, const wxFontData& fontdata )
	158	{
	159	Init();
	160
	161	wxCHECK_RET( !!fontname, _T("invalid font spec") );
	162
	163	m_refData = new wxFontRefData();
	164
	165	wxString tmp;
	166
	167	wxStringTokenizer tn( fontname, wxT("-") );
	168
	169	tn.GetNextToken(); // skip initial empty token
	170	tn.GetNextToken(); // foundry
	171
	172	M_FONTDATA->m_faceName = tn.GetNextToken(); // family
	173
	174	tmp = tn.GetNextToken().MakeUpper(); // weight
	175	if (tmp == wxT("BOLD")) M_FONTDATA->m_weight = wxBOLD;
	176	if (tmp == wxT("BLACK")) M_FONTDATA->m_weight = wxBOLD;
	177	if (tmp == wxT("EXTRABOLD")) M_FONTDATA->m_weight = wxBOLD;
	178	if (tmp == wxT("DEMIBOLD")) M_FONTDATA->m_weight = wxBOLD;
	179	if (tmp == wxT("ULTRABOLD")) M_FONTDATA->m_weight = wxBOLD;
	180
	181	if (tmp == wxT("LIGHT")) M_FONTDATA->m_weight = wxLIGHT;
	182	if (tmp == wxT("THIN")) M_FONTDATA->m_weight = wxLIGHT;
	183
	184	tmp = tn.GetNextToken().MakeUpper(); // slant
	185	if (tmp == wxT("I")) M_FONTDATA->m_style = wxITALIC;
	186	if (tmp == wxT("O")) M_FONTDATA->m_style = wxITALIC;
	187
	188	tn.GetNextToken(); // set width
	189	tn.GetNextToken(); // add. style
	190	tn.GetNextToken(); // pixel size
	191
	192	tmp = tn.GetNextToken(); // pointsize
	193	long num = wxStrtol (tmp.c_str(), (wxChar **) NULL, 10);
	194	M_FONTDATA->m_pointSize = (int)(num / 10);
	195
	196	tn.GetNextToken(); // x-res
	197	tn.GetNextToken(); // y-res
	198
	199	tmp = tn.GetNextToken().MakeUpper(); // spacing
	200
	201	if (tmp == wxT("M"))
	202	M_FONTDATA->m_family = wxMODERN;
	203	else if (M_FONTDATA->m_faceName == wxT("TIMES"))
	204	M_FONTDATA->m_family = wxROMAN;
	205	else if (M_FONTDATA->m_faceName == wxT("HELVETICA"))
	206	M_FONTDATA->m_family = wxSWISS;
	207	else if (M_FONTDATA->m_faceName == wxT("LUCIDATYPEWRITER"))
	208	M_FONTDATA->m_family = wxTELETYPE;
	209	else if (M_FONTDATA->m_faceName == wxT("LUCIDA"))
	210	M_FONTDATA->m_family = wxDECORATIVE;
	211	else if (M_FONTDATA->m_faceName == wxT("UTOPIA"))
	212	M_FONTDATA->m_family = wxSCRIPT;
	213
	214	tn.GetNextToken(); // avg width
	215
	216	// deal with font encoding
	217	M_FONTDATA->m_encoding = fontdata.GetEncoding();
	218	if ( M_FONTDATA->m_encoding == wxFONTENCODING_SYSTEM )
	219	{
	220	wxString registry = tn.GetNextToken().MakeUpper(),
	221	encoding = tn.GetNextToken().MakeUpper();
	222
	223	if ( registry == _T("ISO8859") )
	224	{
	225	int cp;
	226	if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
	227	{
	228	M_FONTDATA->m_encoding =
	229	(wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
	230	}
	231	}
	232	else if ( registry == _T("MICROSOFT") )
	233	{
	234	int cp;
	235	if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
	236	{
	237	M_FONTDATA->m_encoding =
	238	(wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
	239	}
	240	}
	241	else if ( registry == _T("KOI8") )
	242	{
	243	M_FONTDATA->m_encoding = wxFONTENCODING_KOI8;
	244	}
	245	//else: unknown encoding - may be give a warning here?
	246	}
	247	}
	248
	249	bool wxFont::Create( int pointSize,
	250	int family,
	251	int style,
	252	int weight,
	253	bool underlined,
	254	const wxString& face,
	255	wxFontEncoding encoding )
	256	{
	257	m_refData = new wxFontRefData(pointSize, family, style, weight,
	258	underlined, face, encoding);
	259
	260	return TRUE;
	261	}
	262
	263	void wxFont::Unshare()
	264	{
	265	if (!m_refData)
	266	{
	267	m_refData = new wxFontRefData();
	268	}
	269	else
	270	{
	271	wxFontRefData* ref = new wxFontRefData((wxFontRefData)m_refData);
	272	UnRef();
	273	m_refData = ref;
	274	}
	275	}
	276
	277	wxFont::~wxFont()
	278	{
	279	if (wxTheFontList)
	280	wxTheFontList->DeleteObject( this );
	281	}
	282
	283	// ----------------------------------------------------------------------------
	284	// accessors
	285	// ----------------------------------------------------------------------------
	286
	287	int wxFont::GetPointSize() const
	288	{
	289	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	290
	291	return M_FONTDATA->m_pointSize;
	292	}
	293
	294	wxString wxFont::GetFaceName() const
	295	{
	296	wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
	297
	298	return M_FONTDATA->m_faceName;
	299	}
	300
	301	int wxFont::GetFamily() const
	302	{
	303	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	304
	305	return M_FONTDATA->m_family;
	306	}
	307
	308	int wxFont::GetStyle() const
	309	{
	310	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	311
	312	return M_FONTDATA->m_style;
	313	}
	314
	315	int wxFont::GetWeight() const
	316	{
	317	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
	318
	319	return M_FONTDATA->m_weight;
	320	}
	321
	322	bool wxFont::GetUnderlined() const
	323	{
	324	wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
	325
	326	return M_FONTDATA->m_underlined;
	327	}
	328
	329
	330	wxFontEncoding wxFont::GetEncoding() const
	331	{
	332	wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
	333
	334	return M_FONTDATA->m_encoding;
	335	}
	336
	337	// ----------------------------------------------------------------------------
	338	// change font attributes
	339	// ----------------------------------------------------------------------------
	340
	341	void wxFont::SetPointSize(int pointSize)
	342	{
	343	Unshare();
	344
	345	M_FONTDATA->m_pointSize = pointSize;
	346	}
	347
	348	void wxFont::SetFamily(int family)
	349	{
	350	Unshare();
	351
	352	M_FONTDATA->m_family = family;
	353	}
	354
	355	void wxFont::SetStyle(int style)
	356	{
	357	Unshare();
	358
	359	M_FONTDATA->m_style = style;
	360	}
	361
	362	void wxFont::SetWeight(int weight)
	363	{
	364	Unshare();
	365
	366	M_FONTDATA->m_weight = weight;
	367	}
	368
	369	void wxFont::SetFaceName(const wxString& faceName)
	370	{
	371	Unshare();
	372
	373	M_FONTDATA->m_faceName = faceName;
	374	}
	375
	376	void wxFont::SetUnderlined(bool underlined)
	377	{
	378	Unshare();
	379
	380	M_FONTDATA->m_underlined = underlined;
	381	}
	382
	383	void wxFont::SetEncoding(wxFontEncoding encoding)
	384	{
	385	Unshare();
	386
	387	M_FONTDATA->m_encoding = encoding;
	388	}
	389
	390	// ----------------------------------------------------------------------------
	391	// get internal representation of font
	392	// ----------------------------------------------------------------------------
	393
	394	static GdkFont g_systemDefaultGuiFont = (GdkFont) NULL;
	395
	396	static GdkFont *GtkGetDefaultGuiFont()
	397	{
	398	if (!g_systemDefaultGuiFont)
	399	{
	400	GtkWidget *widget = gtk_button_new();
	401	GtkStyle *def = gtk_rc_get_style( widget );
	402	if (def)
	403	{
	404	g_systemDefaultGuiFont = gdk_font_ref( def->font );
	405	}
	406	else
	407	{
	408	def = gtk_widget_get_default_style();
	409	if (def)
	410	g_systemDefaultGuiFont = gdk_font_ref( def->font );
	411	}
	412	gtk_widget_destroy( widget );
	413	}
	414	return g_systemDefaultGuiFont;
	415	}
	416
	417	GdkFont *wxFont::GetInternalFont( float scale ) const
	418	{
	419	if (!Ok())
	420	{
	421	wxFAIL_MSG( wxT("invalid font") );
	422
	423	return (GdkFont*) NULL;
	424	}
	425
	426	long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */
	427	int point_scale = (int)((M_FONTDATA->m_pointSize * 10 * int_scale) / 100);
	428	GdkFont font = (GdkFont ) NULL;
	429
	430	wxNode *node = M_FONTDATA->m_scaled_xfonts.Find(int_scale);
	431	if (node)
	432	{
	433	font = (GdkFont*)node->Data();
	434	}
	435	else
	436	{
	437	if (*this == wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT))
	438	{
	439	font = GtkGetDefaultGuiFont();
	440	}
	441	if (!font)
	442	{
	443	font = wxLoadQueryNearestFont( point_scale,
	444	M_FONTDATA->m_family,
	445	M_FONTDATA->m_style,
	446	M_FONTDATA->m_weight,
	447	M_FONTDATA->m_underlined,
	448	M_FONTDATA->m_faceName,
	449	M_FONTDATA->m_encoding );
	450	}
	451
	452	M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
	453	}
	454
	455	// it's quite useless to make it a wxCHECK because we're going to crash
	456	// anyhow...
	457	wxASSERT_MSG( font, wxT("could not load any font?") );
	458
	459	return font;
	460	}
	461