1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
19 #pragma implementation "font.h"
23 #include "wx/fontutil.h"
24 #include "wx/cmndata.h"
27 #include "wx/gdicmn.h"
28 #include "wx/tokenzr.h"
29 #include "wx/settings.h"
33 #include "wx/gtk/private.h"
34 #include <gdk/gdkprivate.h>
36 // ----------------------------------------------------------------------------
38 // ----------------------------------------------------------------------------
40 // the default size (in points) for the fonts
41 static const int wxDEFAULT_FONT_SIZE
= 12;
43 // ----------------------------------------------------------------------------
45 // ----------------------------------------------------------------------------
47 // TODO: replace this with a type safe list or hash!!
48 class wxScaledFontList
: public wxList
51 wxScaledFontList() : wxList(wxKEY_INTEGER
) { }
54 // ----------------------------------------------------------------------------
56 // ----------------------------------------------------------------------------
58 class wxFontRefData
: public wxObjectRefData
61 // from broken down font parameters, also default ctor
62 wxFontRefData(int size
= -1,
63 int family
= wxFONTFAMILY_DEFAULT
,
64 int style
= wxFONTSTYLE_NORMAL
,
65 int weight
= wxFONTWEIGHT_NORMAL
,
66 bool underlined
= FALSE
,
67 const wxString
& faceName
= wxEmptyString
,
68 wxFontEncoding encoding
= wxFONTENCODING_DEFAULT
);
71 wxFontRefData(const wxString
& fontname
);
74 wxFontRefData( const wxFontRefData
& data
);
76 virtual ~wxFontRefData();
78 // do we have the native font info?
79 bool HasNativeFont() const
84 return !m_nativeFontInfo
.IsDefault();
88 // setters: all of them also take care to modify m_nativeFontInfo if we
89 // have it so as to not lose the information not carried by our fields
90 void SetPointSize(int pointSize
);
91 void SetFamily(int family
);
92 void SetStyle(int style
);
93 void SetWeight(int weight
);
94 void SetUnderlined(bool underlined
);
95 void SetFaceName(const wxString
& facename
);
96 void SetEncoding(wxFontEncoding encoding
);
98 // debugger helper: shows what the font really is
100 // VZ: I need this as my gdb either shows wildly wrong values or crashes
101 // when I ask it to "p fontRefData" :-(
102 #if defined(__WXDEBUG__) && !defined(__WXGTK20__)
105 wxPrintf(_T("%s-%s-%s-%d-%d\n"),
107 m_weight
== wxFONTWEIGHT_NORMAL
109 : m_weight
== wxFONTWEIGHT_BOLD
112 m_style
== wxFONTSTYLE_NORMAL
? _T("regular") : _T("italic"),
119 // common part of all ctors
120 void Init(int pointSize
,
125 const wxString
& faceName
,
126 wxFontEncoding encoding
);
130 // the map of font sizes to "GdkFont *"
131 wxScaledFontList m_scaled_xfonts
;
134 // the broken down font parameters
141 wxFontEncoding m_encoding
; // Unused under GTK 2.0
143 // The native font info, basicly an XFLD under GTK 1.2 and
144 // the pango font description under GTK 2.0.
145 wxNativeFontInfo m_nativeFontInfo
;
150 // ============================================================================
151 // wxFontRefData implementation
152 // ============================================================================
154 // ----------------------------------------------------------------------------
155 // wxFontRefData creation
156 // ----------------------------------------------------------------------------
158 void wxFontRefData::Init(int pointSize
,
163 const wxString
& faceName
,
164 wxFontEncoding encoding
)
166 m_family
= family
== wxFONTFAMILY_DEFAULT
? wxFONTFAMILY_SWISS
: family
;
168 m_faceName
= faceName
;
170 // we accept both wxDEFAULT and wxNORMAL here - should we?
171 m_style
= style
== wxDEFAULT
? wxFONTSTYLE_NORMAL
: style
;
172 m_weight
= weight
== wxDEFAULT
? wxFONTWEIGHT_NORMAL
: weight
;
174 // and here, do we really want to forbid creation of the font of the size
175 // 90 (the value of wxDEFAULT)??
176 m_pointSize
= pointSize
== wxDEFAULT
||
177 pointSize
== -1 ? wxDEFAULT_FONT_SIZE
: pointSize
;
179 m_underlined
= underlined
;
180 m_encoding
= encoding
;
183 // Create native font info
184 m_nativeFontInfo
.description
= pango_font_description_new();
186 // And set its values
189 case wxFONTFAMILY_TELETYPE
:
190 pango_font_description_set_family( m_nativeFontInfo
.description
, "monospaced" );
192 case wxFONTFAMILY_SWISS
:
193 pango_font_description_set_family( m_nativeFontInfo
.description
, "serif" );
196 pango_font_description_set_family( m_nativeFontInfo
.description
, "sans" );
200 SetPointSize( m_pointSize
);
201 SetWeight( m_weight
);
204 wxFontRefData::wxFontRefData( const wxFontRefData
& data
)
207 m_pointSize
= data
.m_pointSize
;
208 m_family
= data
.m_family
;
209 m_style
= data
.m_style
;
210 m_weight
= data
.m_weight
;
212 m_underlined
= data
.m_underlined
;
214 m_faceName
= data
.m_faceName
;
215 m_encoding
= data
.m_encoding
;
217 m_nativeFontInfo
= data
.m_nativeFontInfo
;
220 wxFontRefData::wxFontRefData(int size
, int family
, int style
,
221 int weight
, bool underlined
,
222 const wxString
& faceName
,
223 wxFontEncoding encoding
)
225 Init(size
, family
, style
, weight
, underlined
, faceName
, encoding
);
228 wxFontRefData::wxFontRefData(const wxString
& fontname
)
231 m_nativeFontInfo
.FromString( fontname
);
234 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
237 m_faceName
= wxGTK_CONV_BACK( pango_font_description_get_family( desc
) );
239 m_pointSize
= pango_font_description_get_size( desc
) / PANGO_SCALE
;
241 switch (pango_font_description_get_style( desc
))
243 case PANGO_STYLE_NORMAL
:
244 m_style
= wxFONTSTYLE_NORMAL
;
246 case PANGO_STYLE_ITALIC
:
247 m_style
= wxFONTSTYLE_ITALIC
;
249 case PANGO_STYLE_OBLIQUE
:
250 m_style
= wxFONTSTYLE_SLANT
;
254 switch (pango_font_description_get_weight( desc
))
256 case PANGO_WEIGHT_ULTRALIGHT
:
257 m_weight
= wxFONTWEIGHT_LIGHT
;
259 case PANGO_WEIGHT_LIGHT
:
260 m_weight
= wxFONTWEIGHT_LIGHT
;
262 case PANGO_WEIGHT_NORMAL
:
263 m_weight
= wxFONTWEIGHT_NORMAL
;
265 case PANGO_WEIGHT_BOLD
:
266 m_weight
= wxFONTWEIGHT_BOLD
;
268 case PANGO_WEIGHT_ULTRABOLD
:
269 m_weight
= wxFONTWEIGHT_BOLD
;
271 case PANGO_WEIGHT_HEAVY
:
272 m_weight
= wxFONTWEIGHT_BOLD
;
276 if (m_faceName
== wxT("monospaced"))
278 m_family
= wxFONTFAMILY_TELETYPE
;
280 else if (m_faceName
== wxT("sans"))
282 m_family
= wxFONTFAMILY_SWISS
;
286 m_family
= wxFONTFAMILY_UNKNOWN
;
289 // Pango description are never underlined (?)
290 m_underlined
= FALSE
;
292 // Cannot we choose that
293 m_encoding
= wxFONTENCODING_SYSTEM
;
295 // remember the X font name
296 m_nativeFontInfo
.SetXFontName(fontname
);
298 // get the font parameters from the XLFD
299 // -------------------------------------
301 m_faceName
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_FAMILY
);
303 m_weight
= wxFONTWEIGHT_NORMAL
;
305 wxString w
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_WEIGHT
).Upper();
306 if ( !w
.empty() && w
!= _T('*') )
308 // the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
310 if ( ((w
[0u] == _T('B') && (!wxStrcmp(w
.c_str() + 1, wxT("OLD")) ||
311 !wxStrcmp(w
.c_str() + 1, wxT("LACK"))))) ||
312 wxStrstr(w
.c_str() + 1, _T("BOLD")) )
314 m_weight
= wxFONTWEIGHT_BOLD
;
316 else if ( w
== _T("LIGHT") || w
== _T("THIN") )
318 m_weight
= wxFONTWEIGHT_LIGHT
;
322 switch ( wxToupper(*m_nativeFontInfo
.
323 GetXFontComponent(wxXLFD_SLANT
).c_str()) )
325 case _T('I'): // italique
326 m_style
= wxFONTSTYLE_ITALIC
;
329 case _T('O'): // oblique
330 m_style
= wxFONTSTYLE_SLANT
;
334 m_style
= wxFONTSTYLE_NORMAL
;
338 if ( m_nativeFontInfo
.GetXFontComponent(wxXLFD_POINTSIZE
).ToLong(&ptSize
) )
340 // size in XLFD is in 10 point units
341 m_pointSize
= (int)(ptSize
/ 10);
345 m_pointSize
= wxDEFAULT_FONT_SIZE
;
348 // examine the spacing: if the font is monospaced, assume wxTELETYPE
349 // family for compatibility with the old code which used it instead of
351 if ( m_nativeFontInfo
.GetXFontComponent(wxXLFD_SPACING
).Upper() == _T('M') )
353 m_family
= wxFONTFAMILY_TELETYPE
;
355 else // not monospaceed
357 // don't even try guessing it, it doesn't work for too many fonts
359 m_family
= wxFONTFAMILY_UNKNOWN
;
362 // X fonts are never underlined...
363 m_underlined
= FALSE
;
365 // deal with font encoding
367 registry
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_REGISTRY
).Upper(),
368 encoding
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_ENCODING
).Upper();
370 if ( registry
== _T("ISO8859") )
373 if ( wxSscanf(encoding
, wxT("%d"), &cp
) == 1 )
375 m_encoding
= (wxFontEncoding
)(wxFONTENCODING_ISO8859_1
+ cp
- 1);
378 else if ( registry
== _T("MICROSOFT") )
381 if ( wxSscanf(encoding
, wxT("cp125%d"), &cp
) == 1 )
383 m_encoding
= (wxFontEncoding
)(wxFONTENCODING_CP1250
+ cp
);
386 else if ( registry
== _T("KOI8") )
388 m_encoding
= wxFONTENCODING_KOI8
;
390 else // unknown encoding
392 // may be give a warning here?
393 m_encoding
= wxFONTENCODING_SYSTEM
;
398 wxFontRefData::~wxFontRefData()
401 wxNode
*node
= m_scaled_xfonts
.First();
404 GdkFont
*font
= (GdkFont
*)node
->Data();
405 wxNode
*next
= node
->Next();
406 gdk_font_unref( font
);
412 // ----------------------------------------------------------------------------
413 // wxFontRefData SetXXX()
414 // ----------------------------------------------------------------------------
416 void wxFontRefData::SetPointSize(int pointSize
)
418 m_pointSize
= pointSize
;
422 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
424 pango_font_description_set_size( desc
, m_pointSize
* PANGO_SCALE
);
426 if ( HasNativeFont() )
429 if ( pointSize
== -1 )
432 size
.Printf(_T("%d"), 10*pointSize
);
434 m_nativeFontInfo
.SetXFontComponent(wxXLFD_POINTSIZE
, size
);
439 void wxFontRefData::SetFamily(int family
)
443 // TODO: what are we supposed to do with m_nativeFontInfo here?
446 void wxFontRefData::SetStyle(int style
)
452 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
456 case wxFONTSTYLE_ITALIC
:
457 pango_font_description_set_style( desc
, PANGO_STYLE_ITALIC
);
459 case wxFONTSTYLE_SLANT
:
460 pango_font_description_set_style( desc
, PANGO_STYLE_OBLIQUE
);
463 wxFAIL_MSG( _T("unknown font style") );
465 case wxFONTSTYLE_NORMAL
:
466 pango_font_description_set_style( desc
, PANGO_STYLE_NORMAL
);
470 if ( HasNativeFont() )
475 case wxFONTSTYLE_ITALIC
:
479 case wxFONTSTYLE_SLANT
:
484 wxFAIL_MSG( _T("unknown font style") );
487 case wxFONTSTYLE_NORMAL
:
491 m_nativeFontInfo
.SetXFontComponent(wxXLFD_SLANT
, slant
);
496 void wxFontRefData::SetWeight(int weight
)
501 if ( HasNativeFont() )
506 case wxFONTWEIGHT_BOLD
:
507 boldness
= _T("bold");
510 case wxFONTWEIGHT_LIGHT
:
511 boldness
= _T("light");
515 wxFAIL_MSG( _T("unknown font weight") );
518 case wxFONTWEIGHT_NORMAL
:
520 boldness
= _T("medium");
523 m_nativeFontInfo
.SetXFontComponent(wxXLFD_WEIGHT
, boldness
);
528 void wxFontRefData::SetUnderlined(bool underlined
)
530 m_underlined
= underlined
;
532 // the XLFD doesn't have "underlined" field anyhow
535 void wxFontRefData::SetFaceName(const wxString
& facename
)
537 m_faceName
= facename
;
540 if ( HasNativeFont() )
542 m_nativeFontInfo
.SetXFontComponent(wxXLFD_FAMILY
, facename
);
547 void wxFontRefData::SetEncoding(wxFontEncoding encoding
)
549 m_encoding
= encoding
;
552 if ( HasNativeFont() )
554 wxNativeEncodingInfo info
;
555 if ( wxGetNativeFontEncoding(encoding
, &info
) )
557 m_nativeFontInfo
.SetXFontComponent(wxXLFD_REGISTRY
, info
.xregistry
);
558 m_nativeFontInfo
.SetXFontComponent(wxXLFD_ENCODING
, info
.xencoding
);
564 // ============================================================================
565 // wxFont implementation
566 // ============================================================================
568 // ----------------------------------------------------------------------------
570 // ----------------------------------------------------------------------------
572 IMPLEMENT_DYNAMIC_CLASS(wxFont
, wxGDIObject
)
578 wxFont::wxFont(const wxNativeFontInfo
& info
)
583 Create( info
.GetPointSize(),
587 info
.GetUnderlined(),
589 info
.GetEncoding() );
591 Create(info
.GetXFontName());
595 bool wxFont::Create( int pointSize
,
600 const wxString
& face
,
601 wxFontEncoding encoding
)
603 m_refData
= new wxFontRefData(pointSize
, family
, style
, weight
,
604 underlined
, face
, encoding
);
609 bool wxFont::Create(const wxString
& fontname
)
611 // VZ: does this really happen?
612 if ( fontname
.empty() )
614 *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
619 m_refData
= new wxFontRefData(fontname
);
624 void wxFont::Unshare()
628 m_refData
= new wxFontRefData();
632 wxFontRefData
* ref
= new wxFontRefData(*(wxFontRefData
*)m_refData
);
642 // ----------------------------------------------------------------------------
644 // ----------------------------------------------------------------------------
646 // all accessors are just forwarded to wxFontRefData which has everything we
649 int wxFont::GetPointSize() const
651 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
653 return M_FONTDATA
->m_pointSize
;
656 wxString
wxFont::GetFaceName() const
658 wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
660 return M_FONTDATA
->m_faceName
;
663 int wxFont::GetFamily() const
665 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
667 return M_FONTDATA
->m_family
;
670 int wxFont::GetStyle() const
672 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
674 return M_FONTDATA
->m_style
;
677 int wxFont::GetWeight() const
679 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
681 return M_FONTDATA
->m_weight
;
684 bool wxFont::GetUnderlined() const
686 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid font") );
688 return M_FONTDATA
->m_underlined
;
691 wxFontEncoding
wxFont::GetEncoding() const
693 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
695 return M_FONTDATA
->m_encoding
;
698 wxNativeFontInfo
*wxFont::GetNativeFontInfo() const
700 wxCHECK_MSG( Ok(), (wxNativeFontInfo
*)NULL
, wxT("invalid font") );
702 #ifndef __WXGTK20__ // ???
703 if ( M_FONTDATA
->m_nativeFontInfo
.GetXFontName().empty() )
707 return new wxNativeFontInfo(M_FONTDATA
->m_nativeFontInfo
);
710 bool wxFont::IsFixedWidth() const
712 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid font") );
715 if ( M_FONTDATA
->HasNativeFont() )
717 // the monospace fonts are supposed to have "M" in the spacing field
718 wxString spacing
= M_FONTDATA
->
719 m_nativeFontInfo
.GetXFontComponent(wxXLFD_SPACING
);
721 return spacing
.Upper() == _T('M');
725 return wxFontBase::IsFixedWidth();
728 // ----------------------------------------------------------------------------
729 // change font attributes
730 // ----------------------------------------------------------------------------
732 void wxFont::SetPointSize(int pointSize
)
736 M_FONTDATA
->SetPointSize(pointSize
);
739 void wxFont::SetFamily(int family
)
743 M_FONTDATA
->SetFamily(family
);
746 void wxFont::SetStyle(int style
)
750 M_FONTDATA
->SetStyle(style
);
753 void wxFont::SetWeight(int weight
)
757 M_FONTDATA
->SetWeight(weight
);
760 void wxFont::SetFaceName(const wxString
& faceName
)
764 M_FONTDATA
->SetFaceName(faceName
);
767 void wxFont::SetUnderlined(bool underlined
)
771 M_FONTDATA
->SetUnderlined(underlined
);
774 void wxFont::SetEncoding(wxFontEncoding encoding
)
778 M_FONTDATA
->SetEncoding(encoding
);
781 void wxFont::SetNativeFontInfo(const wxNativeFontInfo
& info
)
785 M_FONTDATA
->m_nativeFontInfo
= info
;
788 // ----------------------------------------------------------------------------
789 // get internal representation of font
790 // ----------------------------------------------------------------------------
792 static GdkFont
*g_systemDefaultGuiFont
= (GdkFont
*) NULL
;
794 // this is also used from tbargtk.cpp and tooltip.cpp, hence extern
795 extern GdkFont
*GtkGetDefaultGuiFont()
797 if (!g_systemDefaultGuiFont
)
799 GtkWidget
*widget
= gtk_button_new();
800 GtkStyle
*def
= gtk_rc_get_style( widget
);
803 g_systemDefaultGuiFont
= gdk_font_ref( GET_STYLE_FONT(def
) );
807 def
= gtk_widget_get_default_style();
809 g_systemDefaultGuiFont
= gdk_font_ref( GET_STYLE_FONT(def
) );
811 gtk_widget_destroy( widget
);
815 // already have it, but ref it once more before returning
816 gdk_font_ref(g_systemDefaultGuiFont
);
819 return g_systemDefaultGuiFont
;
822 GdkFont
*wxFont::GetInternalFont( float scale
) const
824 GdkFont
*font
= (GdkFont
*) NULL
;
826 wxCHECK_MSG( Ok(), font
, wxT("invalid font") )
829 if (*this == wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT
))
831 font
= GtkGetDefaultGuiFont();
835 PangoFontDescription
*font_description
= GetNativeFontInfo()->description
;
837 font
= gdk_font_from_description( font_description
);
840 long int_scale
= long(scale
* 100.0 + 0.5); // key for fontlist
841 int point_scale
= (int)((M_FONTDATA
->m_pointSize
* 10 * int_scale
) / 100);
843 wxNode
*node
= M_FONTDATA
->m_scaled_xfonts
.Find(int_scale
);
846 font
= (GdkFont
*)node
->Data();
848 else // we don't have this font in this size yet
850 if (*this == wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT
))
852 font
= GtkGetDefaultGuiFont();
857 // do we have the XLFD?
858 if ( M_FONTDATA
->HasNativeFont() )
860 font
= wxLoadFont(M_FONTDATA
->m_nativeFontInfo
.GetXFontName());
863 // no XLFD of no exact match - try the approximate one now
867 font
= wxLoadQueryNearestFont( point_scale
,
868 M_FONTDATA
->m_family
,
870 M_FONTDATA
->m_weight
,
871 M_FONTDATA
->m_underlined
,
872 M_FONTDATA
->m_faceName
,
873 M_FONTDATA
->m_encoding
,
877 M_FONTDATA
->m_nativeFontInfo
.SetXFontName(xfontname
);
884 M_FONTDATA
->m_scaled_xfonts
.Append( int_scale
, (wxObject
*)font
);
889 // it's quite useless to make it a wxCHECK because we're going to crash
891 wxASSERT_MSG( font
, wxT("could not load any font?") );