1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling and Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
18 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
19 #pragma implementation "font.h"
22 // For compilers that support precompilation, includes "wx.h".
23 #include "wx/wxprec.h"
26 #include "wx/fontutil.h"
27 #include "wx/cmndata.h"
30 #include "wx/gdicmn.h"
31 #include "wx/tokenzr.h"
32 #include "wx/settings.h"
36 #include "wx/gtk/private.h"
37 #include <gdk/gdkprivate.h>
39 // ----------------------------------------------------------------------------
41 // ----------------------------------------------------------------------------
43 // the default size (in points) for the fonts
44 static const int wxDEFAULT_FONT_SIZE
= 12;
46 // ----------------------------------------------------------------------------
47 // wxScaledFontList: maps the font sizes to the GDK fonts for the given font
48 // ----------------------------------------------------------------------------
50 WX_DECLARE_HASH_MAP(int, GdkFont
*, wxIntegerHash
, wxIntegerEqual
,
53 // ----------------------------------------------------------------------------
55 // ----------------------------------------------------------------------------
57 class wxFontRefData
: public wxObjectRefData
60 // from broken down font parameters, also default ctor
61 wxFontRefData(int size
= -1,
62 int family
= wxFONTFAMILY_DEFAULT
,
63 int style
= wxFONTSTYLE_NORMAL
,
64 int weight
= wxFONTWEIGHT_NORMAL
,
65 bool underlined
= FALSE
,
66 const wxString
& faceName
= wxEmptyString
,
67 wxFontEncoding encoding
= wxFONTENCODING_DEFAULT
);
70 wxFontRefData(const wxString
& fontname
);
73 wxFontRefData( const wxFontRefData
& data
);
75 virtual ~wxFontRefData();
77 // do we have the native font info?
78 bool HasNativeFont() const
81 // we always have a Pango font description
84 // only use m_nativeFontInfo if it had been initialized
85 return !m_nativeFontInfo
.IsDefault();
89 // setters: all of them also take care to modify m_nativeFontInfo if we
90 // have it so as to not lose the information not carried by our fields
91 void SetPointSize(int pointSize
);
92 void SetFamily(int family
);
93 void SetStyle(int style
);
94 void SetWeight(int weight
);
95 void SetUnderlined(bool underlined
);
96 void SetFaceName(const wxString
& facename
);
97 void SetEncoding(wxFontEncoding encoding
);
99 void SetNoAntiAliasing( bool no
= TRUE
) { m_noAA
= no
; }
100 bool GetNoAntiAliasing() const { return m_noAA
; }
102 // and this one also modifies all the other font data fields
103 void SetNativeFontInfo(const wxNativeFontInfo
& info
);
105 // debugger helper: shows what the font really is
107 // VZ: I need this as my gdb either shows wildly wrong values or crashes
108 // when I ask it to "p fontRefData" :-(
109 #if defined(__WXDEBUG__) && !defined(__WXGTK20__)
112 wxPrintf(_T("%s-%s-%s-%d-%d\n"),
114 m_weight
== wxFONTWEIGHT_NORMAL
116 : m_weight
== wxFONTWEIGHT_BOLD
119 m_style
== wxFONTSTYLE_NORMAL
? _T("regular") : _T("italic"),
126 // common part of all ctors
127 void Init(int pointSize
,
132 const wxString
& faceName
,
133 wxFontEncoding encoding
);
135 // set all fields from (already initialized and valid) m_nativeFontInfo
136 void InitFromNative();
139 // clear m_scaled_xfonts if any
140 void ClearGdkFonts();
143 // the map of font sizes to "GdkFont *"
144 wxScaledFontList m_scaled_xfonts
;
145 #endif // GTK 2.0/1.x
153 wxFontEncoding m_encoding
; // Unused under GTK 2.0
154 bool m_noAA
; // No anti-aliasing
156 // The native font info, basicly an XFLD under GTK 1.2 and
157 // the pango font description under GTK 2.0.
158 wxNativeFontInfo m_nativeFontInfo
;
163 // ----------------------------------------------------------------------------
165 // ----------------------------------------------------------------------------
167 void wxFontRefData::Init(int pointSize
,
172 const wxString
& faceName
,
173 wxFontEncoding encoding
)
175 m_family
= family
== wxFONTFAMILY_DEFAULT
? wxFONTFAMILY_SWISS
: family
;
177 m_faceName
= faceName
;
179 // we accept both wxDEFAULT and wxNORMAL here - should we?
180 m_style
= style
== wxDEFAULT
? wxFONTSTYLE_NORMAL
: style
;
181 m_weight
= weight
== wxDEFAULT
? wxFONTWEIGHT_NORMAL
: weight
;
183 // and here, do we really want to forbid creation of the font of the size
184 // 90 (the value of wxDEFAULT)??
185 m_pointSize
= pointSize
== wxDEFAULT
|| pointSize
== -1
186 ? wxDEFAULT_FONT_SIZE
189 m_underlined
= underlined
;
190 m_encoding
= encoding
;
195 // Create native font info
196 m_nativeFontInfo
.description
= pango_font_description_new();
198 // And set its values
199 if (!m_faceName
.empty())
201 pango_font_description_set_family( m_nativeFontInfo
.description
, wxGTK_CONV(m_faceName
) );
207 case wxFONTFAMILY_MODERN
:
208 case wxFONTFAMILY_TELETYPE
:
209 pango_font_description_set_family( m_nativeFontInfo
.description
, "monospace" );
211 case wxFONTFAMILY_ROMAN
:
212 pango_font_description_set_family( m_nativeFontInfo
.description
, "serif" );
214 case wxFONTFAMILY_SWISS
:
215 // SWISS = sans serif
217 pango_font_description_set_family( m_nativeFontInfo
.description
, "sans" );
223 SetPointSize( m_pointSize
);
224 SetWeight( m_weight
);
228 void wxFontRefData::InitFromNative()
234 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
237 m_faceName
= wxGTK_CONV_BACK( pango_font_description_get_family( desc
) );
239 // Pango sometimes needs to have a size
240 int pango_size
= pango_font_description_get_size( desc
);
242 pango_font_description_set_size( desc
, 12 * PANGO_SCALE
);
244 m_pointSize
= pango_font_description_get_size( desc
) / PANGO_SCALE
;
246 switch (pango_font_description_get_style( desc
))
248 case PANGO_STYLE_NORMAL
:
249 m_style
= wxFONTSTYLE_NORMAL
;
251 case PANGO_STYLE_ITALIC
:
252 m_style
= wxFONTSTYLE_ITALIC
;
254 case PANGO_STYLE_OBLIQUE
:
255 m_style
= wxFONTSTYLE_SLANT
;
259 PangoWeight pango_weight
= pango_font_description_get_weight( desc
);
261 if (pango_weight
>= 600)
263 m_weight
= wxFONTWEIGHT_BOLD
;
265 else if (pango_weight
< 350)
267 m_weight
= wxFONTWEIGHT_LIGHT
;
271 m_weight
= wxFONTWEIGHT_NORMAL
;
274 if (m_faceName
== wxT("monospace"))
276 m_family
= wxFONTFAMILY_TELETYPE
;
278 else if (m_faceName
== wxT("sans"))
280 m_family
= wxFONTFAMILY_SWISS
;
282 else if (m_faceName
== wxT("serif"))
284 m_family
= wxFONTFAMILY_ROMAN
;
288 m_family
= wxFONTFAMILY_UNKNOWN
;
291 // Pango description are never underlined (?)
292 m_underlined
= FALSE
;
294 // Cannot we choose that
295 m_encoding
= wxFONTENCODING_SYSTEM
;
297 // get the font parameters from the XLFD
298 // -------------------------------------
300 m_faceName
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_FAMILY
);
302 m_weight
= wxFONTWEIGHT_NORMAL
;
304 wxString w
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_WEIGHT
).Upper();
305 if ( !w
.empty() && w
!= _T('*') )
307 // the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
309 if ( ((w
[0u] == _T('B') && (!wxStrcmp(w
.c_str() + 1, wxT("OLD")) ||
310 !wxStrcmp(w
.c_str() + 1, wxT("LACK"))))) ||
311 wxStrstr(w
.c_str() + 1, _T("BOLD")) )
313 m_weight
= wxFONTWEIGHT_BOLD
;
315 else if ( w
== _T("LIGHT") || w
== _T("THIN") )
317 m_weight
= wxFONTWEIGHT_LIGHT
;
321 switch ( wxToupper(*m_nativeFontInfo
.
322 GetXFontComponent(wxXLFD_SLANT
).c_str()) )
324 case _T('I'): // italique
325 m_style
= wxFONTSTYLE_ITALIC
;
328 case _T('O'): // oblique
329 m_style
= wxFONTSTYLE_SLANT
;
333 m_style
= wxFONTSTYLE_NORMAL
;
337 if ( m_nativeFontInfo
.GetXFontComponent(wxXLFD_POINTSIZE
).ToLong(&ptSize
) )
339 // size in XLFD is in 10 point units
340 m_pointSize
= (int)(ptSize
/ 10);
344 m_pointSize
= wxDEFAULT_FONT_SIZE
;
347 // examine the spacing: if the font is monospaced, assume wxTELETYPE
348 // family for compatibility with the old code which used it instead of
350 if ( m_nativeFontInfo
.GetXFontComponent(wxXLFD_SPACING
).Upper() == _T('M') )
352 m_family
= wxFONTFAMILY_TELETYPE
;
354 else // not monospaceed
356 // don't even try guessing it, it doesn't work for too many fonts
358 m_family
= wxFONTFAMILY_UNKNOWN
;
361 // X fonts are never underlined...
362 m_underlined
= FALSE
;
364 // deal with font encoding
366 registry
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_REGISTRY
).Upper(),
367 encoding
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_ENCODING
).Upper();
369 if ( registry
== _T("ISO8859") )
372 if ( wxSscanf(encoding
, wxT("%d"), &cp
) == 1 )
374 m_encoding
= (wxFontEncoding
)(wxFONTENCODING_ISO8859_1
+ cp
- 1);
377 else if ( registry
== _T("MICROSOFT") )
380 if ( wxSscanf(encoding
, wxT("cp125%d"), &cp
) == 1 )
382 m_encoding
= (wxFontEncoding
)(wxFONTENCODING_CP1250
+ cp
);
385 else if ( registry
== _T("KOI8") )
387 m_encoding
= wxFONTENCODING_KOI8
;
389 else // unknown encoding
391 // may be give a warning here? or use wxFontMapper?
392 m_encoding
= wxFONTENCODING_SYSTEM
;
394 #endif // GTK 2.0/1.x
397 wxFontRefData::wxFontRefData( const wxFontRefData
& data
)
400 m_pointSize
= data
.m_pointSize
;
401 m_family
= data
.m_family
;
402 m_style
= data
.m_style
;
403 m_weight
= data
.m_weight
;
405 m_underlined
= data
.m_underlined
;
407 m_faceName
= data
.m_faceName
;
408 m_encoding
= data
.m_encoding
;
410 m_noAA
= data
.m_noAA
;
412 // Forces a copy of the internal data. wxNativeFontInfo should probably
413 // have a copy ctor and assignment operator to fix this properly but that
414 // would break binary compatibility...
415 m_nativeFontInfo
.FromString(data
.m_nativeFontInfo
.ToString());
418 wxFontRefData::wxFontRefData(int size
, int family
, int style
,
419 int weight
, bool underlined
,
420 const wxString
& faceName
,
421 wxFontEncoding encoding
)
423 Init(size
, family
, style
, weight
, underlined
, faceName
, encoding
);
426 wxFontRefData::wxFontRefData(const wxString
& fontname
)
428 // VZ: FromString() should really work in both cases, doesn't it?
430 m_nativeFontInfo
.FromString( fontname
);
432 m_nativeFontInfo
.SetXFontName(fontname
);
433 #endif // GTK 2.0/1.x
438 void wxFontRefData::ClearGdkFonts()
441 for ( wxScaledFontList::iterator i
= m_scaled_xfonts
.begin();
442 i
!= m_scaled_xfonts
.end();
445 GdkFont
*font
= i
->second
;
446 gdk_font_unref( font
);
449 m_scaled_xfonts
.clear();
453 wxFontRefData::~wxFontRefData()
458 // ----------------------------------------------------------------------------
459 // wxFontRefData SetXXX()
460 // ----------------------------------------------------------------------------
462 void wxFontRefData::SetPointSize(int pointSize
)
464 m_pointSize
= pointSize
;
468 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
470 pango_font_description_set_size( desc
, m_pointSize
* PANGO_SCALE
);
472 if ( HasNativeFont() )
475 if ( pointSize
== -1 )
478 size
.Printf(_T("%d"), 10*pointSize
);
480 m_nativeFontInfo
.SetXFontComponent(wxXLFD_POINTSIZE
, size
);
485 void wxFontRefData::SetFamily(int family
)
489 // TODO: what are we supposed to do with m_nativeFontInfo here?
492 void wxFontRefData::SetStyle(int style
)
498 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
502 case wxFONTSTYLE_ITALIC
:
503 pango_font_description_set_style( desc
, PANGO_STYLE_ITALIC
);
505 case wxFONTSTYLE_SLANT
:
506 pango_font_description_set_style( desc
, PANGO_STYLE_OBLIQUE
);
509 wxFAIL_MSG( _T("unknown font style") );
511 case wxFONTSTYLE_NORMAL
:
512 pango_font_description_set_style( desc
, PANGO_STYLE_NORMAL
);
516 if ( HasNativeFont() )
521 case wxFONTSTYLE_ITALIC
:
525 case wxFONTSTYLE_SLANT
:
530 wxFAIL_MSG( _T("unknown font style") );
533 case wxFONTSTYLE_NORMAL
:
537 m_nativeFontInfo
.SetXFontComponent(wxXLFD_SLANT
, slant
);
542 void wxFontRefData::SetWeight(int weight
)
547 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
550 case wxFONTWEIGHT_BOLD
:
551 pango_font_description_set_weight(desc
, PANGO_WEIGHT_BOLD
);
554 case wxFONTWEIGHT_LIGHT
:
555 pango_font_description_set_weight(desc
, PANGO_WEIGHT_LIGHT
);
559 wxFAIL_MSG( _T("unknown font weight") );
562 case wxFONTWEIGHT_NORMAL
:
564 pango_font_description_set_weight(desc
, PANGO_WEIGHT_NORMAL
);
567 if ( HasNativeFont() )
572 case wxFONTWEIGHT_BOLD
:
573 boldness
= _T("bold");
576 case wxFONTWEIGHT_LIGHT
:
577 boldness
= _T("light");
581 wxFAIL_MSG( _T("unknown font weight") );
584 case wxFONTWEIGHT_NORMAL
:
586 boldness
= _T("medium");
589 m_nativeFontInfo
.SetXFontComponent(wxXLFD_WEIGHT
, boldness
);
594 void wxFontRefData::SetUnderlined(bool underlined
)
596 m_underlined
= underlined
;
598 // the XLFD doesn't have "underlined" field anyhow
601 void wxFontRefData::SetFaceName(const wxString
& facename
)
603 m_faceName
= facename
;
606 if ( HasNativeFont() )
608 m_nativeFontInfo
.SetXFontComponent(wxXLFD_FAMILY
, facename
);
613 void wxFontRefData::SetEncoding(wxFontEncoding encoding
)
615 m_encoding
= encoding
;
618 if ( HasNativeFont() )
620 wxNativeEncodingInfo info
;
621 if ( wxGetNativeFontEncoding(encoding
, &info
) )
623 m_nativeFontInfo
.SetXFontComponent(wxXLFD_REGISTRY
, info
.xregistry
);
624 m_nativeFontInfo
.SetXFontComponent(wxXLFD_ENCODING
, info
.xencoding
);
630 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo
& info
)
632 // previously cached fonts shouldn't be used
635 m_nativeFontInfo
= info
;
637 // set all the other font parameters from the native font info
641 // ----------------------------------------------------------------------------
643 // ----------------------------------------------------------------------------
645 IMPLEMENT_DYNAMIC_CLASS(wxFont
, wxGDIObject
)
651 wxFont::wxFont(const wxNativeFontInfo
& info
)
656 Create( info
.GetPointSize(),
660 info
.GetUnderlined(),
662 info
.GetEncoding() );
664 (void) Create(info
.GetXFontName());
668 bool wxFont::Create( int pointSize
,
673 const wxString
& face
,
674 wxFontEncoding encoding
)
678 m_refData
= new wxFontRefData(pointSize
, family
, style
, weight
,
679 underlined
, face
, encoding
);
684 bool wxFont::Create(const wxString
& fontname
)
686 // VZ: does this really happen?
687 if ( fontname
.empty() )
689 *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
694 m_refData
= new wxFontRefData(fontname
);
699 void wxFont::Unshare()
703 m_refData
= new wxFontRefData();
707 wxFontRefData
* ref
= new wxFontRefData(*(wxFontRefData
*)m_refData
);
717 // ----------------------------------------------------------------------------
719 // ----------------------------------------------------------------------------
721 int wxFont::GetPointSize() const
723 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
726 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetPointSize()
727 : M_FONTDATA
->m_pointSize
;
729 return M_FONTDATA
->m_pointSize
;
733 wxString
wxFont::GetFaceName() const
735 wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
738 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetFaceName()
739 : M_FONTDATA
->m_faceName
;
741 return M_FONTDATA
->m_faceName
;
745 int wxFont::GetFamily() const
747 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
750 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetFamily()
751 : M_FONTDATA
->m_family
;
753 return M_FONTDATA
->m_family
;
757 int wxFont::GetStyle() const
759 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
762 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetStyle()
763 : M_FONTDATA
->m_style
;
765 return M_FONTDATA
->m_style
;
769 int wxFont::GetWeight() const
771 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
774 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetWeight()
775 : M_FONTDATA
->m_weight
;
777 return M_FONTDATA
->m_weight
;
781 bool wxFont::GetUnderlined() const
783 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid font") );
786 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetUnderlined()
787 : M_FONTDATA
->m_underlined
;
789 return M_FONTDATA
->m_underlined
;
793 wxFontEncoding
wxFont::GetEncoding() const
795 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
797 // m_encoding is unused in wxGTK2, return encoding that the user set.
798 return M_FONTDATA
->m_encoding
;
801 bool wxFont::GetNoAntiAliasing() const
803 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
805 return M_FONTDATA
->m_noAA
;
808 const wxNativeFontInfo
*wxFont::GetNativeFontInfo() const
810 wxCHECK_MSG( Ok(), (wxNativeFontInfo
*)NULL
, wxT("invalid font") );
813 if ( !M_FONTDATA
->HasNativeFont() )
815 // NB: this call has important side-effect: it not only finds
816 // GdkFont representation, it also initializes m_nativeFontInfo
817 // by calling its SetXFontName method
822 return &(M_FONTDATA
->m_nativeFontInfo
);
825 bool wxFont::IsFixedWidth() const
827 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid font") );
830 if ( M_FONTDATA
->HasNativeFont() )
832 // the monospace fonts are supposed to have "M" in the spacing field
833 wxString spacing
= M_FONTDATA
->
834 m_nativeFontInfo
.GetXFontComponent(wxXLFD_SPACING
);
836 return spacing
.Upper() == _T('M');
840 return wxFontBase::IsFixedWidth();
843 // ----------------------------------------------------------------------------
844 // change font attributes
845 // ----------------------------------------------------------------------------
847 void wxFont::SetPointSize(int pointSize
)
851 M_FONTDATA
->SetPointSize(pointSize
);
854 void wxFont::SetFamily(int family
)
858 M_FONTDATA
->SetFamily(family
);
861 void wxFont::SetStyle(int style
)
865 M_FONTDATA
->SetStyle(style
);
868 void wxFont::SetWeight(int weight
)
872 M_FONTDATA
->SetWeight(weight
);
875 void wxFont::SetFaceName(const wxString
& faceName
)
879 M_FONTDATA
->SetFaceName(faceName
);
882 void wxFont::SetUnderlined(bool underlined
)
886 M_FONTDATA
->SetUnderlined(underlined
);
889 void wxFont::SetEncoding(wxFontEncoding encoding
)
893 M_FONTDATA
->SetEncoding(encoding
);
896 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo
& info
)
900 M_FONTDATA
->SetNativeFontInfo( info
);
903 void wxFont::SetNoAntiAliasing( bool no
)
907 M_FONTDATA
->SetNoAntiAliasing( no
);
910 // ----------------------------------------------------------------------------
911 // get internal representation of font
912 // ----------------------------------------------------------------------------
915 static GdkFont
*g_systemDefaultGuiFont
= (GdkFont
*) NULL
;
917 // this is also used from tbargtk.cpp and tooltip.cpp, hence extern
918 extern GdkFont
*GtkGetDefaultGuiFont()
920 if (!g_systemDefaultGuiFont
)
922 GtkWidget
*widget
= gtk_button_new();
923 GtkStyle
*def
= gtk_rc_get_style( widget
);
926 g_systemDefaultGuiFont
= gdk_font_ref( def
->font
);
930 def
= gtk_widget_get_default_style();
932 g_systemDefaultGuiFont
= gdk_font_ref( def
->font
);
934 gtk_widget_destroy( widget
);
938 // already have it, but ref it once more before returning
939 gdk_font_ref(g_systemDefaultGuiFont
);
942 return g_systemDefaultGuiFont
;
945 GdkFont
*wxFont::GetInternalFont( float scale
) const
947 GdkFont
*font
= (GdkFont
*) NULL
;
949 wxCHECK_MSG( Ok(), font
, wxT("invalid font") )
951 long int_scale
= long(scale
* 100.0 + 0.5); // key for fontlist
952 int point_scale
= (int)((M_FONTDATA
->m_pointSize
* 10 * int_scale
) / 100);
954 wxScaledFontList
& list
= M_FONTDATA
->m_scaled_xfonts
;
955 wxScaledFontList::iterator i
= list
.find(int_scale
);
956 if ( i
!= list
.end() )
960 else // we don't have this font in this size yet
962 if (*this == wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT
))
964 font
= GtkGetDefaultGuiFont();
969 // do we have the XLFD?
970 if ( int_scale
== 100 && M_FONTDATA
->HasNativeFont() )
972 font
= wxLoadFont(M_FONTDATA
->m_nativeFontInfo
.GetXFontName());
975 // no XLFD of no exact match - try the approximate one now
979 font
= wxLoadQueryNearestFont( point_scale
,
980 M_FONTDATA
->m_family
,
982 M_FONTDATA
->m_weight
,
983 M_FONTDATA
->m_underlined
,
984 M_FONTDATA
->m_faceName
,
985 M_FONTDATA
->m_encoding
,
987 // NB: wxFont::GetNativeFontInfo relies on this
988 // side-effect of GetInternalFont
989 if ( int_scale
== 100 )
990 M_FONTDATA
->m_nativeFontInfo
.SetXFontName(xfontname
);
996 list
[int_scale
] = font
;
1000 // it's quite useless to make it a wxCHECK because we're going to crash
1002 wxASSERT_MSG( font
, wxT("could not load any font?") );
1006 #endif // not GTK 2.0