[wxWidgets.git] / src / x11 / font.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/motif/font.cpp
// Purpose:     wxFont class
// Author:      Julian Smart
// Modified by:
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

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

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

#ifdef __VMS
#pragma message disable nosimpint
#include "wx/vms_x_fix.h"
#endif

#ifdef __VMS
#pragma message enable nosimpint
#endif

#include "wx/defs.h"
#include "wx/string.h"
#include "wx/font.h"
#include "wx/gdicmn.h"
#include "wx/utils.h"       // for wxGetDisplay()
#include "wx/fontutil.h"    // for wxNativeFontInfo
#include "wx/tokenzr.h"
#include "wx/settings.h"

IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

// For every wxFont, there must be a font for each display and scale requested.
// So these objects are stored in wxFontRefData::m_fonts
class wxXFont : public wxObject
{
public:
    wxXFont();
    ~wxXFont();

    WXFontStructPtr     m_fontStruct;   // XFontStruct
    WXDisplay*          m_display;      // XDisplay
    int                 m_scale;        // Scale * 100
};

class wxFontRefData: public wxGDIRefData
{
friend class wxFont;

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)
    {
        Init(size, family, style, weight, underlined, faceName, encoding);
    }

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

    ~wxFontRefData();

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

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

    wxNativeFontInfo m_nativeFontInfo;
    
    // A list of wxXFonts
    wxList        m_fonts;
};

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

// ----------------------------------------------------------------------------
// wxXFont
// ----------------------------------------------------------------------------

wxXFont::wxXFont()
{
    m_fontStruct = (WXFontStructPtr) 0;
    m_display = (WXDisplay*) 0;
    m_scale = 100;
}

wxXFont::~wxXFont()
{
    // TODO: why does freeing the font produce a segv???
    // Note that XFreeFont wasn't called in wxWin 1.68 either.
    // XFontStruct* fontStruct = (XFontStruct*) m_fontStruct;
    //        XFreeFont((Display*) m_display, fontStruct);
}

// ----------------------------------------------------------------------------
// 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()
{
    wxNode* node = m_fonts.First();
    while (node)
    {
        wxXFont* f = (wxXFont*) node->Data();
        delete f;
        node = node->Next();
    }
    m_fonts.Clear();
}

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

wxFont::wxFont(const wxNativeFontInfo& info)
{
    Init();

    (void)Create(info.GetXFontName());
}

void wxFont::Init()
{
}

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

    RealizeResource();

    return TRUE;
}

bool wxFont::Create(const wxString& fontname, wxFontEncoding enc)
{
    if( !fontname )
    {
        *this = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT);
        return TRUE;
    }

    m_refData = new wxFontRefData();

    M_FONTDATA->m_nativeFontInfo.SetXFontName(fontname);  // X font name

    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
    if (tmp != wxT("*"))
    {
        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 = enc;
    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?
        else
            return FALSE;
    }
    return TRUE;    
}

wxFont::~wxFont()
{
}

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

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

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

    M_FONTDATA->m_pointSize = pointSize;
    M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
    
    RealizeResource();
}

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

    M_FONTDATA->m_family = family;
    M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
    
    RealizeResource();
}

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

    M_FONTDATA->m_style = style;
    M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
    
    RealizeResource();
}

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

    M_FONTDATA->m_weight = weight;
    M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
    
    RealizeResource();
}

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

    M_FONTDATA->m_faceName = faceName;
    M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
    
    RealizeResource();
}

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

    M_FONTDATA->m_underlined = underlined;
    
    RealizeResource();
}

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

    M_FONTDATA->m_encoding = encoding;
    M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
    
    RealizeResource();
}

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

    M_FONTDATA->m_nativeFontInfo = info;
}

// ----------------------------------------------------------------------------
// query font attributes
// ----------------------------------------------------------------------------

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

wxNativeFontInfo *wxFont::GetNativeFontInfo() const
{
    wxCHECK_MSG( Ok(), (wxNativeFontInfo *)NULL, wxT("invalid font") );

    if(M_FONTDATA->m_nativeFontInfo.GetXFontName().IsEmpty())
        GetInternalFont();

    return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo);
}

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

// Find an existing, or create a new, XFontStruct
// based on this wxFont and the given scale. Append the
// font to list in the private data for future reference.
wxXFont* wxFont::GetInternalFont(double scale, WXDisplay* display) const
{
    if ( !Ok() )
        return (wxXFont *)NULL;

    long intScale = long(scale * 100.0 + 0.5); // key for wxXFont
    int pointSize = (M_FONTDATA->m_pointSize * 10 * intScale) / 100;

    // search existing fonts first
    wxNode* node = M_FONTDATA->m_fonts.First();
    while (node)
    {
        wxXFont* f = (wxXFont*) node->Data();
        if ((!display || (f->m_display == display)) && (f->m_scale == intScale))
            return f;
        node = node->Next();
    }

    // not found, create a new one
    XFontStruct *font = (XFontStruct *)
                        wxLoadQueryNearestFont(pointSize,
                                               M_FONTDATA->m_family,
                                               M_FONTDATA->m_style,
                                               M_FONTDATA->m_weight,
                                               M_FONTDATA->m_underlined,
                                               wxT(""),
                                               M_FONTDATA->m_encoding);

    if ( !font )
    {
        wxFAIL_MSG( wxT("Could not allocate even a default font -- something is wrong.") );

        return (wxXFont*) NULL;
    }

    wxXFont* f = new wxXFont;
    f->m_fontStruct = (WXFontStructPtr)font;
    f->m_display = ( display ? display : wxGetDisplay() );
    f->m_scale = intScale;
    M_FONTDATA->m_fonts.Append(f);

    return f;
}

WXFontStructPtr wxFont::GetFontStruct(double scale, WXDisplay* display) const
{
    wxXFont* f = GetInternalFont(scale, display);

    return (f ? f->m_fontStruct : (WXFontStructPtr) 0);
}
Commit	Line	Data
83df96d6 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/motif/font.cpp
	3	// Purpose: wxFont class
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 17/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	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	#ifdef __VMS
	25	#pragma message disable nosimpint
	26	#include "wx/vms_x_fix.h"
	27	#endif
bc797f4c	28
83df96d6 JS	29	#ifdef __VMS
	30	#pragma message enable nosimpint
	31	#endif
	32
	33	#include "wx/defs.h"
	34	#include "wx/string.h"
	35	#include "wx/font.h"
	36	#include "wx/gdicmn.h"
	37	#include "wx/utils.h" // for wxGetDisplay()
	38	#include "wx/fontutil.h" // for wxNativeFontInfo
	39	#include "wx/tokenzr.h"
	40	#include "wx/settings.h"
	41
	42	IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
	43
	44	// ----------------------------------------------------------------------------
	45	// private classes
	46	// ----------------------------------------------------------------------------
	47
	48	// For every wxFont, there must be a font for each display and scale requested.
	49	// So these objects are stored in wxFontRefData::m_fonts
	50	class wxXFont : public wxObject
	51	{
	52	public:
	53	wxXFont();
	54	~wxXFont();
	55
	56	WXFontStructPtr m_fontStruct; // XFontStruct
83df96d6 JS	57	WXDisplay* m_display; // XDisplay
	58	int m_scale; // Scale * 100
	59	};
	60
	61	class wxFontRefData: public wxGDIRefData
	62	{
	63	friend class wxFont;
	64
	65	public:
	66	wxFontRefData(int size = wxDEFAULT,
	67	int family = wxDEFAULT,
	68	int style = wxDEFAULT,
	69	int weight = wxDEFAULT,
	70	bool underlined = FALSE,
	71	const wxString& faceName = wxEmptyString,
	72	wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
	73	{
	74	Init(size, family, style, weight, underlined, faceName, encoding);
	75	}
	76
	77	wxFontRefData(const wxFontRefData& data)
	78	{
	79	Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
	80	data.m_underlined, data.m_faceName, data.m_encoding);
	81	}
	82
	83	~wxFontRefData();
	84
	85	protected:
	86	// common part of all ctors
	87	void Init(int size,
	88	int family,
	89	int style,
	90	int weight,
	91	bool underlined,
	92	const wxString& faceName,
	93	wxFontEncoding encoding);
	94
	95	// font attributes
	96	int m_pointSize;
	97	int m_family;
	98	int m_style;
	99	int m_weight;
	100	bool m_underlined;
	101	wxString m_faceName;
	102	wxFontEncoding m_encoding;
	103
	104	wxNativeFontInfo m_nativeFontInfo;
	105
	106	// A list of wxXFonts
	107	wxList m_fonts;
	108	};
	109
	110	// ============================================================================
	111	// implementation
	112	// ============================================================================
	113
	114	// ----------------------------------------------------------------------------
	115	// wxXFont
	116	// ----------------------------------------------------------------------------
	117
	118	wxXFont::wxXFont()
	119	{
	120	m_fontStruct = (WXFontStructPtr) 0;
83df96d6 JS	121	m_display = (WXDisplay*) 0;
	122	m_scale = 100;
	123	}
	124
	125	wxXFont::~wxXFont()
	126	{
83df96d6 JS	127	// TODO: why does freeing the font produce a segv???
	128	// Note that XFreeFont wasn't called in wxWin 1.68 either.
	129	// XFontStruct* fontStruct = (XFontStruct*) m_fontStruct;
	130	// XFreeFont((Display*) m_display, fontStruct);
	131	}
	132
	133	// ----------------------------------------------------------------------------
	134	// wxFontRefData
	135	// ----------------------------------------------------------------------------
	136
	137	void wxFontRefData::Init(int pointSize,
	138	int family,
	139	int style,
	140	int weight,
	141	bool underlined,
	142	const wxString& faceName,
	143	wxFontEncoding encoding)
	144	{
	145	if (family == wxDEFAULT)
	146	m_family = wxSWISS;
	147	else
	148	m_family = family;
	149
	150	m_faceName = faceName;
	151
	152	if (style == wxDEFAULT)
	153	m_style = wxNORMAL;
	154	else
	155	m_style = style;
	156
	157	if (weight == wxDEFAULT)
	158	m_weight = wxNORMAL;
	159	else
	160	m_weight = weight;
	161
	162	if (pointSize == wxDEFAULT)
	163	m_pointSize = 12;
	164	else
	165	m_pointSize = pointSize;
	166
	167	m_underlined = underlined;
	168	m_encoding = encoding;
	169	}
	170
	171	wxFontRefData::~wxFontRefData()
	172	{
	173	wxNode* node = m_fonts.First();
	174	while (node)
	175	{
	176	wxXFont* f = (wxXFont*) node->Data();
	177	delete f;
	178	node = node->Next();
	179	}
	180	m_fonts.Clear();
	181	}
	182
	183	// ----------------------------------------------------------------------------
	184	// wxFont
	185	// ----------------------------------------------------------------------------
	186
	187	wxFont::wxFont(const wxNativeFontInfo& info)
	188	{
	189	Init();
	190
191	(void)Create(info.GetXFontName());
192	}
193
194	void wxFont::Init()
195	{
196	}
197
198	bool wxFont::Create(int pointSize,
199	int family,
200	int style,
201	int weight,
202	bool underlined,
203	const wxString& faceName,
204	wxFontEncoding encoding)
205	{
206	UnRef();
207	m_refData = new wxFontRefData(pointSize, family, style, weight,
208	underlined, faceName, encoding);
209
210	RealizeResource();
211
212	return TRUE;
213	}
214
215	bool wxFont::Create(const wxString& fontname, wxFontEncoding enc)
216	{
217	if( !fontname )
218	{
219	*this = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT);
220	return TRUE;
221	}
222
223	m_refData = new wxFontRefData();
224
225	M_FONTDATA->m_nativeFontInfo.SetXFontName(fontname); // X font name
226
227	wxString tmp;
228
229	wxStringTokenizer tn( fontname, wxT("-") );
230
231	tn.GetNextToken(); // skip initial empty token
232	tn.GetNextToken(); // foundry
233
234
235	M_FONTDATA->m_faceName = tn.GetNextToken(); // family
236
237	tmp = tn.GetNextToken().MakeUpper(); // weight
238	if (tmp == wxT("BOLD")) M_FONTDATA->m_weight = wxBOLD;
239	if (tmp == wxT("BLACK")) M_FONTDATA->m_weight = wxBOLD;
240	if (tmp == wxT("EXTRABOLD")) M_FONTDATA->m_weight = wxBOLD;
241	if (tmp == wxT("DEMIBOLD")) M_FONTDATA->m_weight = wxBOLD;
242	if (tmp == wxT("ULTRABOLD")) M_FONTDATA->m_weight = wxBOLD;
243
244	if (tmp == wxT("LIGHT")) M_FONTDATA->m_weight = wxLIGHT;
245	if (tmp == wxT("THIN")) M_FONTDATA->m_weight = wxLIGHT;
246
247	tmp = tn.GetNextToken().MakeUpper(); // slant
248	if (tmp == wxT("I")) M_FONTDATA->m_style = wxITALIC;
249	if (tmp == wxT("O")) M_FONTDATA->m_style = wxITALIC;
250
251	tn.GetNextToken(); // set width
252	tn.GetNextToken(); // add. style
253	tn.GetNextToken(); // pixel size
254
255	tmp = tn.GetNextToken(); // pointsize
256	if (tmp != wxT("*"))
257	{
258	long num = wxStrtol (tmp.c_str(), (wxChar **) NULL, 10);
259	M_FONTDATA->m_pointSize = (int)(num / 10);
260	}
261
262	tn.GetNextToken(); // x-res
263	tn.GetNextToken(); // y-res
264
265	tmp = tn.GetNextToken().MakeUpper(); // spacing
266
267	if (tmp == wxT("M"))
268	M_FONTDATA->m_family = wxMODERN;
269	else if (M_FONTDATA->m_faceName == wxT("TIMES"))
270	M_FONTDATA->m_family = wxROMAN;
271	else if (M_FONTDATA->m_faceName == wxT("HELVETICA"))
272	M_FONTDATA->m_family = wxSWISS;
273	else if (M_FONTDATA->m_faceName == wxT("LUCIDATYPEWRITER"))
274	M_FONTDATA->m_family = wxTELETYPE;
275	else if (M_FONTDATA->m_faceName == wxT("LUCIDA"))
276	M_FONTDATA->m_family = wxDECORATIVE;
277	else if (M_FONTDATA->m_faceName == wxT("UTOPIA"))
278	M_FONTDATA->m_family = wxSCRIPT;
279
280	tn.GetNextToken(); // avg width
281
282	// deal with font encoding
283	M_FONTDATA->m_encoding = enc;
284	if ( M_FONTDATA->m_encoding == wxFONTENCODING_SYSTEM )
285	{
286	wxString registry = tn.GetNextToken().MakeUpper(),
287	encoding = tn.GetNextToken().MakeUpper();
288
289	if ( registry == _T("ISO8859") )
290	{
291	int cp;
292	if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
293	{
294	M_FONTDATA->m_encoding =
295	(wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
296	}
297	}
298	else if ( registry == _T("MICROSOFT") )
299	{
300	int cp;
301	if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
302	{
303	M_FONTDATA->m_encoding =
304	(wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
305	}
306	}
307	else if ( registry == _T("KOI8") )
308	{
309	M_FONTDATA->m_encoding = wxFONTENCODING_KOI8;
310	}
311	//else: unknown encoding - may be give a warning here?
312	else
313	return FALSE;
314	}
315	return TRUE;
316	}
317
318	wxFont::~wxFont()
319	{
320	}
321
322	// ----------------------------------------------------------------------------
323	// change the font attributes
324	// ----------------------------------------------------------------------------
325
326	void wxFont::Unshare()
327	{
328	// Don't change shared data
329	if (!m_refData)
330	{
331	m_refData = new wxFontRefData();
332	}
333	else
334	{
335	wxFontRefData* ref = new wxFontRefData((wxFontRefData)m_refData);
336	UnRef();
337	m_refData = ref;
338	}
339	}
340
341	void wxFont::SetPointSize(int pointSize)
342	{
343	Unshare();
344
345	M_FONTDATA->m_pointSize = pointSize;
346	M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
347
348	RealizeResource();
349	}
350
351	void wxFont::SetFamily(int family)
352	{
353	Unshare();
354
355	M_FONTDATA->m_family = family;
356	M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
357
358	RealizeResource();
359	}
360
361	void wxFont::SetStyle(int style)
362	{
363	Unshare();
364
365	M_FONTDATA->m_style = style;
366	M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
367
368	RealizeResource();
369	}
370
371	void wxFont::SetWeight(int weight)
372	{
373	Unshare();
374
375	M_FONTDATA->m_weight = weight;
376	M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
377
378	RealizeResource();
379	}
380
381	void wxFont::SetFaceName(const wxString& faceName)
382	{
383	Unshare();
384
385	M_FONTDATA->m_faceName = faceName;
386	M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
387
388	RealizeResource();
389	}
390
391	void wxFont::SetUnderlined(bool underlined)
392	{
393	Unshare();
394
395	M_FONTDATA->m_underlined = underlined;
396
397	RealizeResource();
398	}
399
400	void wxFont::SetEncoding(wxFontEncoding encoding)
401	{
402	Unshare();
403
404	M_FONTDATA->m_encoding = encoding;
405	M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
406
407	RealizeResource();
408	}
409
410	void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info)
411	{
412	Unshare();
413
414	M_FONTDATA->m_nativeFontInfo = info;
415	}
416
417	// ----------------------------------------------------------------------------
418	// query font attributes
419	// ----------------------------------------------------------------------------
420
421	int wxFont::GetPointSize() const
422	{
423	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
424
425	return M_FONTDATA->m_pointSize;
426	}
427
428	wxString wxFont::GetFaceName() const
429	{
430	wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
431
432	return M_FONTDATA->m_faceName ;
433	}
434
435	int wxFont::GetFamily() const
436	{
437	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
438
439	return M_FONTDATA->m_family;
440	}
441
442	int wxFont::GetStyle() const
443	{
444	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
445
446	return M_FONTDATA->m_style;
447	}
448
449	int wxFont::GetWeight() const
450	{
451	wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
452
453	return M_FONTDATA->m_weight;
454	}
455
456	bool wxFont::GetUnderlined() const
457	{
458	wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
459
460	return M_FONTDATA->m_underlined;
461	}
462
463	wxFontEncoding wxFont::GetEncoding() const
464	{
465	wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
466
467	return M_FONTDATA->m_encoding;
468	}
469
470	wxNativeFontInfo *wxFont::GetNativeFontInfo() const
471	{
472	wxCHECK_MSG( Ok(), (wxNativeFontInfo *)NULL, wxT("invalid font") );
473
474	if(M_FONTDATA->m_nativeFontInfo.GetXFontName().IsEmpty())
475	GetInternalFont();
476
477	return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo);
478	}
479
480	// ----------------------------------------------------------------------------
481	// real implementation
482	// ----------------------------------------------------------------------------
483
484	// Find an existing, or create a new, XFontStruct
485	// based on this wxFont and the given scale. Append the
486	// font to list in the private data for future reference.
487	wxXFont* wxFont::GetInternalFont(double scale, WXDisplay* display) const
488	{
489	if ( !Ok() )
490	return (wxXFont *)NULL;
491
492	long intScale = long(scale * 100.0 + 0.5); // key for wxXFont
493	int pointSize = (M_FONTDATA->m_pointSize * 10 * intScale) / 100;
494
495	// search existing fonts first
496	wxNode* node = M_FONTDATA->m_fonts.First();
497	while (node)
498	{
499	wxXFont* f = (wxXFont*) node->Data();
500	if ((!display \|\| (f->m_display == display)) && (f->m_scale == intScale))
501	return f;
502	node = node->Next();
503	}
504
505	// not found, create a new one
506	XFontStruct font = (XFontStruct )
507	wxLoadQueryNearestFont(pointSize,
508	M_FONTDATA->m_family,
509	M_FONTDATA->m_style,
510	M_FONTDATA->m_weight,
511	M_FONTDATA->m_underlined,
512	wxT(""),
513	M_FONTDATA->m_encoding);
514
515	if ( !font )
516	{
517	wxFAIL_MSG( wxT("Could not allocate even a default font -- something is wrong.") );
518
519	return (wxXFont*) NULL;
520	}
521
522	wxXFont* f = new wxXFont;
523	f->m_fontStruct = (WXFontStructPtr)font;
524	f->m_display = ( display ? display : wxGetDisplay() );
525	f->m_scale = intScale;
83df96d6 JS	526	M_FONTDATA->m_fonts.Append(f);
	527
	528	return f;
	529	}
	530
	531	WXFontStructPtr wxFont::GetFontStruct(double scale, WXDisplay* display) const
	532	{
	533	wxXFont* f = GetInternalFont(scale, display);
	534
	535	return (f ? f->m_fontStruct : (WXFontStructPtr) 0);
	536	}
	537