1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/font.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling and Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
18 // For compilers that support precompilation, includes "wx.h".
19 #include "wx/wxprec.h"
27 #include "wx/fontutil.h"
28 #include "wx/cmndata.h"
30 #include "wx/gdicmn.h"
31 #include "wx/tokenzr.h"
32 #include "wx/settings.h"
36 #include "wx/gtk1/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
80 // only use m_nativeFontInfo if it had been initialized
81 return !m_nativeFontInfo
.IsDefault();
84 // setters: all of them also take care to modify m_nativeFontInfo if we
85 // have it so as to not lose the information not carried by our fields
86 void SetPointSize(int pointSize
);
87 void SetFamily(int family
);
88 void SetStyle(int style
);
89 void SetWeight(int weight
);
90 void SetUnderlined(bool underlined
);
91 void SetFaceName(const wxString
& facename
);
92 void SetEncoding(wxFontEncoding encoding
);
94 void SetNoAntiAliasing( bool no
= TRUE
) { m_noAA
= no
; }
95 bool GetNoAntiAliasing() const { return m_noAA
; }
97 // and this one also modifies all the other font data fields
98 void SetNativeFontInfo(const wxNativeFontInfo
& info
);
100 // debugger helper: shows what the font really is
102 // VZ: I need this as my gdb either shows wildly wrong values or crashes
103 // when I ask it to "p fontRefData" :-(
104 #if defined(__WXDEBUG__)
107 wxPrintf(_T("%s-%s-%s-%d-%d\n"),
109 m_weight
== wxFONTWEIGHT_NORMAL
111 : m_weight
== wxFONTWEIGHT_BOLD
114 m_style
== wxFONTSTYLE_NORMAL
? _T("regular") : _T("italic"),
121 // common part of all ctors
122 void Init(int pointSize
,
127 const wxString
& faceName
,
128 wxFontEncoding encoding
);
130 // set all fields from (already initialized and valid) m_nativeFontInfo
131 void InitFromNative();
134 // clear m_scaled_xfonts if any
135 void ClearGdkFonts();
137 // the map of font sizes to "GdkFont *"
138 wxScaledFontList m_scaled_xfonts
;
146 wxFontEncoding m_encoding
; // Unused under GTK 2.0
147 bool m_noAA
; // No anti-aliasing
149 // The native font info, basicly an XFLD under GTK 1.2 and
150 // the pango font description under GTK 2.0.
151 wxNativeFontInfo m_nativeFontInfo
;
156 // ----------------------------------------------------------------------------
158 // ----------------------------------------------------------------------------
160 void wxFontRefData::Init(int pointSize
,
165 const wxString
& faceName
,
166 wxFontEncoding encoding
)
168 m_family
= family
== wxFONTFAMILY_DEFAULT
? wxFONTFAMILY_SWISS
: family
;
170 m_faceName
= faceName
;
172 // we accept both wxDEFAULT and wxNORMAL here - should we?
173 m_style
= style
== wxDEFAULT
? wxFONTSTYLE_NORMAL
: style
;
174 m_weight
= weight
== wxDEFAULT
? wxFONTWEIGHT_NORMAL
: weight
;
176 // and here, do we really want to forbid creation of the font of the size
177 // 90 (the value of wxDEFAULT)??
178 m_pointSize
= pointSize
== wxDEFAULT
|| pointSize
== -1
179 ? wxDEFAULT_FONT_SIZE
182 m_underlined
= underlined
;
183 m_encoding
= encoding
;
188 void wxFontRefData::InitFromNative()
192 // get the font parameters from the XLFD
193 // -------------------------------------
195 m_faceName
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_FAMILY
);
197 m_weight
= wxFONTWEIGHT_NORMAL
;
199 wxString w
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_WEIGHT
).Upper();
200 if ( !w
.empty() && w
!= _T('*') )
202 // the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
204 if ( ((w
[0u] == _T('B') && (!wxStrcmp(w
.c_str() + 1, wxT("OLD")) ||
205 !wxStrcmp(w
.c_str() + 1, wxT("LACK"))))) ||
206 wxStrstr(w
.c_str() + 1, _T("BOLD")) )
208 m_weight
= wxFONTWEIGHT_BOLD
;
210 else if ( w
== _T("LIGHT") || w
== _T("THIN") )
212 m_weight
= wxFONTWEIGHT_LIGHT
;
216 switch ( wxToupper(*m_nativeFontInfo
.
217 GetXFontComponent(wxXLFD_SLANT
).c_str()) )
219 case _T('I'): // italique
220 m_style
= wxFONTSTYLE_ITALIC
;
223 case _T('O'): // oblique
224 m_style
= wxFONTSTYLE_SLANT
;
228 m_style
= wxFONTSTYLE_NORMAL
;
232 if ( m_nativeFontInfo
.GetXFontComponent(wxXLFD_POINTSIZE
).ToLong(&ptSize
) )
234 // size in XLFD is in 10 point units
235 m_pointSize
= (int)(ptSize
/ 10);
239 m_pointSize
= wxDEFAULT_FONT_SIZE
;
242 // examine the spacing: if the font is monospaced, assume wxTELETYPE
243 // family for compatibility with the old code which used it instead of
245 if ( m_nativeFontInfo
.GetXFontComponent(wxXLFD_SPACING
).Upper() == _T('M') )
247 m_family
= wxFONTFAMILY_TELETYPE
;
249 else // not monospaceed
251 // don't even try guessing it, it doesn't work for too many fonts
253 m_family
= wxFONTFAMILY_UNKNOWN
;
256 // X fonts are never underlined...
257 m_underlined
= FALSE
;
259 // deal with font encoding
261 registry
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_REGISTRY
).Upper(),
262 encoding
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_ENCODING
).Upper();
264 if ( registry
== _T("ISO8859") )
267 if ( wxSscanf(encoding
, wxT("%d"), &cp
) == 1 )
269 m_encoding
= (wxFontEncoding
)(wxFONTENCODING_ISO8859_1
+ cp
- 1);
272 else if ( registry
== _T("MICROSOFT") )
275 if ( wxSscanf(encoding
, wxT("cp125%d"), &cp
) == 1 )
277 m_encoding
= (wxFontEncoding
)(wxFONTENCODING_CP1250
+ cp
);
280 else if ( registry
== _T("KOI8") )
282 m_encoding
= wxFONTENCODING_KOI8
;
284 else // unknown encoding
286 // may be give a warning here? or use wxFontMapper?
287 m_encoding
= wxFONTENCODING_SYSTEM
;
291 wxFontRefData::wxFontRefData( const wxFontRefData
& data
)
294 m_pointSize
= data
.m_pointSize
;
295 m_family
= data
.m_family
;
296 m_style
= data
.m_style
;
297 m_weight
= data
.m_weight
;
299 m_underlined
= data
.m_underlined
;
301 m_faceName
= data
.m_faceName
;
302 m_encoding
= data
.m_encoding
;
304 m_noAA
= data
.m_noAA
;
306 // Forces a copy of the internal data. wxNativeFontInfo should probably
307 // have a copy ctor and assignment operator to fix this properly but that
308 // would break binary compatibility...
309 m_nativeFontInfo
.FromString(data
.m_nativeFontInfo
.ToString());
312 wxFontRefData::wxFontRefData(int size
, int family
, int style
,
313 int weight
, bool underlined
,
314 const wxString
& faceName
,
315 wxFontEncoding encoding
)
317 Init(size
, family
, style
, weight
, underlined
, faceName
, encoding
);
320 wxFontRefData::wxFontRefData(const wxString
& fontname
)
322 // FromString() should really work in GTK1 too, doesn't it?
323 m_nativeFontInfo
.SetXFontName(fontname
);
328 void wxFontRefData::ClearGdkFonts()
330 for ( wxScaledFontList::iterator i
= m_scaled_xfonts
.begin();
331 i
!= m_scaled_xfonts
.end();
334 GdkFont
*font
= i
->second
;
335 gdk_font_unref( font
);
338 m_scaled_xfonts
.clear();
341 wxFontRefData::~wxFontRefData()
346 // ----------------------------------------------------------------------------
347 // wxFontRefData SetXXX()
348 // ----------------------------------------------------------------------------
350 void wxFontRefData::SetPointSize(int pointSize
)
352 m_pointSize
= pointSize
;
354 if ( HasNativeFont() )
357 if ( pointSize
== -1 )
360 size
.Printf(_T("%d"), 10*pointSize
);
362 m_nativeFontInfo
.SetXFontComponent(wxXLFD_POINTSIZE
, size
);
366 void wxFontRefData::SetFamily(int family
)
370 // TODO: what are we supposed to do with m_nativeFontInfo here?
373 void wxFontRefData::SetStyle(int style
)
377 if ( HasNativeFont() )
382 case wxFONTSTYLE_ITALIC
:
386 case wxFONTSTYLE_SLANT
:
391 wxFAIL_MSG( _T("unknown font style") );
394 case wxFONTSTYLE_NORMAL
:
398 m_nativeFontInfo
.SetXFontComponent(wxXLFD_SLANT
, slant
);
402 void wxFontRefData::SetWeight(int weight
)
406 if ( HasNativeFont() )
411 case wxFONTWEIGHT_BOLD
:
412 boldness
= _T("bold");
415 case wxFONTWEIGHT_LIGHT
:
416 boldness
= _T("light");
420 wxFAIL_MSG( _T("unknown font weight") );
423 case wxFONTWEIGHT_NORMAL
:
425 boldness
= _T("medium");
428 m_nativeFontInfo
.SetXFontComponent(wxXLFD_WEIGHT
, boldness
);
432 void wxFontRefData::SetUnderlined(bool underlined
)
434 m_underlined
= underlined
;
436 // the XLFD doesn't have "underlined" field anyhow
439 void wxFontRefData::SetFaceName(const wxString
& facename
)
441 m_faceName
= facename
;
443 if ( HasNativeFont() )
445 m_nativeFontInfo
.SetXFontComponent(wxXLFD_FAMILY
, facename
);
449 void wxFontRefData::SetEncoding(wxFontEncoding encoding
)
451 m_encoding
= encoding
;
453 if ( HasNativeFont() )
455 wxNativeEncodingInfo info
;
456 if ( wxGetNativeFontEncoding(encoding
, &info
) )
458 m_nativeFontInfo
.SetXFontComponent(wxXLFD_REGISTRY
, info
.xregistry
);
459 m_nativeFontInfo
.SetXFontComponent(wxXLFD_ENCODING
, info
.xencoding
);
464 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo
& info
)
466 // previously cached fonts shouldn't be used
469 m_nativeFontInfo
= info
;
471 // set all the other font parameters from the native font info
475 // ----------------------------------------------------------------------------
477 // ----------------------------------------------------------------------------
479 IMPLEMENT_DYNAMIC_CLASS(wxFont
, wxGDIObject
)
481 wxFont::wxFont(const wxNativeFontInfo
& info
)
483 (void) Create(info
.GetXFontName());
486 bool wxFont::Create( int pointSize
,
491 const wxString
& face
,
492 wxFontEncoding encoding
)
496 m_refData
= new wxFontRefData(pointSize
, family
, style
, weight
,
497 underlined
, face
, encoding
);
502 bool wxFont::Create(const wxString
& fontname
)
504 // VZ: does this really happen?
505 if ( fontname
.empty() )
507 *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
512 m_refData
= new wxFontRefData(fontname
);
517 void wxFont::Unshare()
521 m_refData
= new wxFontRefData();
525 wxFontRefData
* ref
= new wxFontRefData(*(wxFontRefData
*)m_refData
);
535 // ----------------------------------------------------------------------------
537 // ----------------------------------------------------------------------------
539 int wxFont::GetPointSize() const
541 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
544 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetPointSize()
545 : M_FONTDATA
->m_pointSize
;
547 return M_FONTDATA
->m_pointSize
;
551 wxString
wxFont::GetFaceName() const
553 wxCHECK_MSG( Ok(), wxEmptyString
, wxT("invalid font") );
556 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetFaceName()
557 : M_FONTDATA
->m_faceName
;
559 return M_FONTDATA
->m_faceName
;
563 int wxFont::GetFamily() const
565 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
568 int ret
= M_FONTDATA
->m_family
;
569 if (M_FONTDATA
->HasNativeFont())
570 // wxNativeFontInfo::GetFamily is expensive, must not call more than once
571 ret
= M_FONTDATA
->m_nativeFontInfo
.GetFamily();
573 if (ret
== wxFONTFAMILY_DEFAULT
)
574 ret
= M_FONTDATA
->m_family
;
578 return M_FONTDATA
->m_family
;
582 int wxFont::GetStyle() const
584 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
587 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetStyle()
588 : M_FONTDATA
->m_style
;
590 return M_FONTDATA
->m_style
;
594 int wxFont::GetWeight() const
596 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
599 return M_FONTDATA
->HasNativeFont() ? M_FONTDATA
->m_nativeFontInfo
.GetWeight()
600 : M_FONTDATA
->m_weight
;
602 return M_FONTDATA
->m_weight
;
606 bool wxFont::GetUnderlined() const
608 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid font") );
610 return M_FONTDATA
->m_underlined
;
613 wxFontEncoding
wxFont::GetEncoding() const
615 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
617 // m_encoding is unused in wxGTK2, return encoding that the user set.
618 return M_FONTDATA
->m_encoding
;
621 bool wxFont::GetNoAntiAliasing() const
623 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
625 return M_FONTDATA
->m_noAA
;
628 const wxNativeFontInfo
*wxFont::GetNativeFontInfo() const
630 wxCHECK_MSG( Ok(), (wxNativeFontInfo
*)NULL
, wxT("invalid font") );
632 if ( !M_FONTDATA
->HasNativeFont() )
634 // NB: this call has important side-effect: it not only finds
635 // GdkFont representation, it also initializes m_nativeFontInfo
636 // by calling its SetXFontName method
640 return &(M_FONTDATA
->m_nativeFontInfo
);
643 bool wxFont::IsFixedWidth() const
645 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid font") );
647 if ( M_FONTDATA
->HasNativeFont() )
649 // the monospace fonts are supposed to have "M" in the spacing field
650 wxString spacing
= M_FONTDATA
->
651 m_nativeFontInfo
.GetXFontComponent(wxXLFD_SPACING
);
653 return spacing
.Upper() == _T('M');
656 return wxFontBase::IsFixedWidth();
659 // ----------------------------------------------------------------------------
660 // change font attributes
661 // ----------------------------------------------------------------------------
663 void wxFont::SetPointSize(int pointSize
)
667 M_FONTDATA
->SetPointSize(pointSize
);
670 void wxFont::SetFamily(int family
)
674 M_FONTDATA
->SetFamily(family
);
677 void wxFont::SetStyle(int style
)
681 M_FONTDATA
->SetStyle(style
);
684 void wxFont::SetWeight(int weight
)
688 M_FONTDATA
->SetWeight(weight
);
691 void wxFont::SetFaceName(const wxString
& faceName
)
695 M_FONTDATA
->SetFaceName(faceName
);
698 void wxFont::SetUnderlined(bool underlined
)
702 M_FONTDATA
->SetUnderlined(underlined
);
705 void wxFont::SetEncoding(wxFontEncoding encoding
)
709 M_FONTDATA
->SetEncoding(encoding
);
712 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo
& info
)
716 M_FONTDATA
->SetNativeFontInfo( info
);
719 void wxFont::SetNoAntiAliasing( bool no
)
723 M_FONTDATA
->SetNoAntiAliasing( no
);
726 // ----------------------------------------------------------------------------
727 // get internal representation of font
728 // ----------------------------------------------------------------------------
730 static GdkFont
*g_systemDefaultGuiFont
= (GdkFont
*) NULL
;
732 // this is also used from tbargtk.cpp and tooltip.cpp, hence extern
733 extern GdkFont
*GtkGetDefaultGuiFont()
735 if (!g_systemDefaultGuiFont
)
737 GtkWidget
*widget
= gtk_button_new();
738 GtkStyle
*def
= gtk_rc_get_style( widget
);
741 g_systemDefaultGuiFont
= gdk_font_ref( def
->font
);
745 def
= gtk_widget_get_default_style();
747 g_systemDefaultGuiFont
= gdk_font_ref( def
->font
);
749 gtk_widget_destroy( widget
);
753 // already have it, but ref it once more before returning
754 gdk_font_ref(g_systemDefaultGuiFont
);
757 return g_systemDefaultGuiFont
;
760 GdkFont
*wxFont::GetInternalFont( float scale
) const
762 GdkFont
*font
= (GdkFont
*) NULL
;
764 wxCHECK_MSG( Ok(), font
, wxT("invalid font") );
766 long int_scale
= long(scale
* 100.0 + 0.5); // key for fontlist
767 int point_scale
= (int)((M_FONTDATA
->m_pointSize
* 10 * int_scale
) / 100);
769 wxScaledFontList
& list
= M_FONTDATA
->m_scaled_xfonts
;
770 wxScaledFontList::iterator i
= list
.find(int_scale
);
771 if ( i
!= list
.end() )
775 else // we don't have this font in this size yet
777 if (*this == wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT
))
779 font
= GtkGetDefaultGuiFont();
784 // do we have the XLFD?
785 if ( int_scale
== 100 && M_FONTDATA
->HasNativeFont() )
787 font
= wxLoadFont(M_FONTDATA
->m_nativeFontInfo
.GetXFontName());
790 // no XLFD of no exact match - try the approximate one now
794 font
= wxLoadQueryNearestFont( point_scale
,
795 M_FONTDATA
->m_family
,
797 M_FONTDATA
->m_weight
,
798 M_FONTDATA
->m_underlined
,
799 M_FONTDATA
->m_faceName
,
800 M_FONTDATA
->m_encoding
,
802 // NB: wxFont::GetNativeFontInfo relies on this
803 // side-effect of GetInternalFont
804 if ( int_scale
== 100 )
805 M_FONTDATA
->m_nativeFontInfo
.SetXFontName(xfontname
);
811 list
[int_scale
] = font
;
815 // it's quite useless to make it a wxCHECK because we're going to crash
817 wxASSERT_MSG( font
, wxT("could not load any font?") );