1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/x11/font.cpp
3 // Purpose: wxFont class
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // for compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
15 // ============================================================================
17 // ============================================================================
19 // ----------------------------------------------------------------------------
21 // ----------------------------------------------------------------------------
24 #pragma message disable nosimpint
25 #include "wx/vms_x_fix.h"
29 #pragma message enable nosimpint
35 #include "wx/string.h"
36 #include "wx/utils.h" // for wxGetDisplay()
39 #include "wx/gdicmn.h"
40 #include "wx/fontutil.h" // for wxNativeFontInfo
41 #include "wx/tokenzr.h"
42 #include "wx/settings.h"
44 #include "wx/x11/private.h"
46 IMPLEMENT_DYNAMIC_CLASS(wxFont
, wxGDIObject
)
48 // ----------------------------------------------------------------------------
50 // ----------------------------------------------------------------------------
52 // the default size (in points) for the fonts
53 static const int wxDEFAULT_FONT_SIZE
= 12;
58 // ----------------------------------------------------------------------------
60 // ----------------------------------------------------------------------------
62 // For every wxFont, there must be a font for each display and scale requested.
63 // So these objects are stored in wxFontRefData::m_fonts
64 class wxXFont
: public wxObject
70 WXFontStructPtr m_fontStruct
; // XFontStruct
71 WXDisplay
* m_display
; // XDisplay
72 int m_scale
; // Scale * 100
77 m_fontStruct
= (WXFontStructPtr
) 0;
78 m_display
= (WXDisplay
*) 0;
84 // Freeing the font used to produce a segv, but
85 // appears to be OK now (bug fix in X11?)
86 XFontStruct
* fontStruct
= (XFontStruct
*) m_fontStruct
;
87 XFreeFont((Display
*) m_display
, fontStruct
);
91 // ----------------------------------------------------------------------------
93 // ----------------------------------------------------------------------------
95 class wxFontRefData
: public wxObjectRefData
100 wxFontRefData(int size
= wxDEFAULT
,
101 int family
= wxDEFAULT
,
102 int style
= wxDEFAULT
,
103 int weight
= wxDEFAULT
,
104 bool underlined
= false,
105 const wxString
& faceName
= wxEmptyString
,
106 wxFontEncoding encoding
= wxFONTENCODING_DEFAULT
);
109 wxFontRefData(const wxFontRefData
& data
);
112 wxFontRefData(const wxString
& fontname
);
115 virtual ~wxFontRefData();
117 // setters: all of them also take care to modify m_nativeFontInfo if we
118 // have it so as to not lose the information not carried by our fields
119 void SetPointSize(int pointSize
);
120 void SetFamily(int family
);
121 void SetStyle(int style
);
122 void SetWeight(int weight
);
123 void SetUnderlined(bool underlined
);
124 void SetFaceName(const wxString
& facename
);
125 void SetEncoding(wxFontEncoding encoding
);
127 void SetNoAntiAliasing( bool no
= true ) { m_noAA
= no
; }
128 bool GetNoAntiAliasing() const { return m_noAA
; }
130 // and this one also modifies all the other font data fields
131 void SetNativeFontInfo(const wxNativeFontInfo
& info
);
134 // common part of all ctors
140 const wxString
& faceName
,
141 wxFontEncoding encoding
);
143 // set all fields from (already initialized and valid) m_nativeFontInfo
144 void InitFromNative();
153 wxFontEncoding m_encoding
; // Unused in Unicode mode
154 bool m_noAA
; // No anti-aliasing
156 wxNativeFontInfo m_nativeFontInfo
;
158 void ClearX11Fonts();
162 // A list of wxXFonts
167 // ----------------------------------------------------------------------------
169 // ----------------------------------------------------------------------------
171 void wxFontRefData::Init(int pointSize
,
176 const wxString
& faceName
,
177 wxFontEncoding encoding
)
179 m_family
= family
== wxFONTFAMILY_DEFAULT
? wxFONTFAMILY_SWISS
: family
;
181 m_faceName
= faceName
;
183 // we accept both wxDEFAULT and wxNORMAL here - should we?
184 m_style
= style
== wxDEFAULT
? wxFONTSTYLE_NORMAL
: style
;
185 m_weight
= weight
== wxDEFAULT
? wxFONTWEIGHT_NORMAL
: weight
;
187 // and here, do we really want to forbid creation of the font of the size
188 // 90 (the value of wxDEFAULT)??
189 m_pointSize
= pointSize
== wxDEFAULT
|| pointSize
== -1
190 ? wxDEFAULT_FONT_SIZE
193 m_underlined
= underlined
;
194 m_encoding
= encoding
;
197 // Create native font info
198 m_nativeFontInfo
.description
= pango_font_description_new();
200 // And set its values
203 case wxFONTFAMILY_MODERN
:
204 case wxFONTFAMILY_TELETYPE
:
205 pango_font_description_set_family( m_nativeFontInfo
.description
, "monospace" );
207 case wxFONTFAMILY_ROMAN
:
208 pango_font_description_set_family( m_nativeFontInfo
.description
, "serif" );
211 pango_font_description_set_family( m_nativeFontInfo
.description
, "sans" );
215 SetPointSize( m_pointSize
);
216 SetWeight( m_weight
);
220 void wxFontRefData::InitFromNative()
226 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
229 m_faceName
= wxGTK_CONV_BACK( pango_font_description_get_family( desc
) );
231 m_pointSize
= pango_font_description_get_size( desc
) / PANGO_SCALE
;
233 switch (pango_font_description_get_style( desc
))
235 case PANGO_STYLE_NORMAL
:
236 m_style
= wxFONTSTYLE_NORMAL
;
238 case PANGO_STYLE_ITALIC
:
239 m_style
= wxFONTSTYLE_ITALIC
;
241 case PANGO_STYLE_OBLIQUE
:
242 m_style
= wxFONTSTYLE_SLANT
;
246 switch (pango_font_description_get_weight( desc
))
248 case PANGO_WEIGHT_ULTRALIGHT
:
249 m_weight
= wxFONTWEIGHT_LIGHT
;
251 case PANGO_WEIGHT_LIGHT
:
252 m_weight
= wxFONTWEIGHT_LIGHT
;
254 case PANGO_WEIGHT_NORMAL
:
255 m_weight
= wxFONTWEIGHT_NORMAL
;
257 case PANGO_WEIGHT_BOLD
:
258 m_weight
= wxFONTWEIGHT_BOLD
;
260 case PANGO_WEIGHT_ULTRABOLD
:
261 m_weight
= wxFONTWEIGHT_BOLD
;
263 case PANGO_WEIGHT_HEAVY
:
264 m_weight
= wxFONTWEIGHT_BOLD
;
268 if (m_faceName
== wxT("monospace"))
270 m_family
= wxFONTFAMILY_TELETYPE
;
272 else if (m_faceName
== wxT("sans"))
274 m_family
= wxFONTFAMILY_SWISS
;
278 m_family
= wxFONTFAMILY_UNKNOWN
;
281 // Pango description are never underlined (?)
282 m_underlined
= false;
284 // Cannot we choose that
285 m_encoding
= wxFONTENCODING_SYSTEM
;
287 // get the font parameters from the XLFD
288 // -------------------------------------
290 m_faceName
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_FAMILY
);
292 m_weight
= wxFONTWEIGHT_NORMAL
;
294 wxString w
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_WEIGHT
).Upper();
295 if ( !w
.empty() && w
!= _T('*') )
297 // the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
299 if ( ((w
[0u] == _T('B') && (!wxStrcmp(w
.c_str() + 1, wxT("OLD")) ||
300 !wxStrcmp(w
.c_str() + 1, wxT("LACK"))))) ||
301 wxStrstr(w
.c_str() + 1, _T("BOLD")) )
303 m_weight
= wxFONTWEIGHT_BOLD
;
305 else if ( w
== _T("LIGHT") || w
== _T("THIN") )
307 m_weight
= wxFONTWEIGHT_LIGHT
;
311 switch ( wxToupper(*m_nativeFontInfo
.
312 GetXFontComponent(wxXLFD_SLANT
).c_str()) )
314 case _T('I'): // italique
315 m_style
= wxFONTSTYLE_ITALIC
;
318 case _T('O'): // oblique
319 m_style
= wxFONTSTYLE_SLANT
;
323 m_style
= wxFONTSTYLE_NORMAL
;
327 if ( m_nativeFontInfo
.GetXFontComponent(wxXLFD_POINTSIZE
).ToLong(&ptSize
) )
329 // size in XLFD is in 10 point units
330 m_pointSize
= (int)(ptSize
/ 10);
334 m_pointSize
= wxDEFAULT_FONT_SIZE
;
337 // examine the spacing: if the font is monospaced, assume wxTELETYPE
338 // family for compatibility with the old code which used it instead of
340 if ( m_nativeFontInfo
.GetXFontComponent(wxXLFD_SPACING
).Upper() == _T('M') )
342 m_family
= wxFONTFAMILY_TELETYPE
;
344 else // not monospaceed
346 // don't even try guessing it, it doesn't work for too many fonts
348 m_family
= wxFONTFAMILY_UNKNOWN
;
351 // X fonts are never underlined...
352 m_underlined
= false;
354 // deal with font encoding
356 registry
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_REGISTRY
).Upper(),
357 encoding
= m_nativeFontInfo
.GetXFontComponent(wxXLFD_ENCODING
).Upper();
359 if ( registry
== _T("ISO8859") )
362 if ( wxSscanf(encoding
, wxT("%d"), &cp
) == 1 )
364 m_encoding
= (wxFontEncoding
)(wxFONTENCODING_ISO8859_1
+ cp
- 1);
367 else if ( registry
== _T("MICROSOFT") )
370 if ( wxSscanf(encoding
, wxT("cp125%d"), &cp
) == 1 )
372 m_encoding
= (wxFontEncoding
)(wxFONTENCODING_CP1250
+ cp
);
375 else if ( registry
== _T("KOI8") )
377 m_encoding
= wxFONTENCODING_KOI8
;
379 else // unknown encoding
381 // may be give a warning here? or use wxFontMapper?
382 m_encoding
= wxFONTENCODING_SYSTEM
;
387 wxFontRefData::wxFontRefData( const wxFontRefData
& data
)
390 m_pointSize
= data
.m_pointSize
;
391 m_family
= data
.m_family
;
392 m_style
= data
.m_style
;
393 m_weight
= data
.m_weight
;
395 m_underlined
= data
.m_underlined
;
397 m_faceName
= data
.m_faceName
;
398 m_encoding
= data
.m_encoding
;
400 m_noAA
= data
.m_noAA
;
402 m_nativeFontInfo
= data
.m_nativeFontInfo
;
405 wxFontRefData::wxFontRefData(int size
, int family
, int style
,
406 int weight
, bool underlined
,
407 const wxString
& faceName
,
408 wxFontEncoding encoding
)
410 Init(size
, family
, style
, weight
, underlined
, faceName
, encoding
);
413 wxFontRefData::wxFontRefData(const wxString
& fontname
)
415 // VZ: FromString() should really work in both cases, doesn't it?
417 m_nativeFontInfo
.FromString( fontname
);
419 m_nativeFontInfo
.SetXFontName(fontname
);
425 void wxFontRefData::ClearX11Fonts()
429 wxList::compatibility_iterator node
= m_fonts
.GetFirst();
432 wxXFont
* f
= (wxXFont
*) node
->GetData();
434 node
= node
->GetNext();
440 wxFontRefData::~wxFontRefData()
445 // ----------------------------------------------------------------------------
446 // wxFontRefData SetXXX()
447 // ----------------------------------------------------------------------------
449 void wxFontRefData::SetPointSize(int pointSize
)
451 m_pointSize
= pointSize
;
455 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
457 pango_font_description_set_size( desc
, m_pointSize
* PANGO_SCALE
);
461 void wxFontRefData::SetFamily(int family
)
465 // TODO: what are we supposed to do with m_nativeFontInfo here?
468 void wxFontRefData::SetStyle(int style
)
474 PangoFontDescription
*desc
= m_nativeFontInfo
.description
;
478 case wxFONTSTYLE_ITALIC
:
479 pango_font_description_set_style( desc
, PANGO_STYLE_ITALIC
);
481 case wxFONTSTYLE_SLANT
:
482 pango_font_description_set_style( desc
, PANGO_STYLE_OBLIQUE
);
485 wxFAIL_MSG( _T("unknown font style") );
487 case wxFONTSTYLE_NORMAL
:
488 pango_font_description_set_style( desc
, PANGO_STYLE_NORMAL
);
494 void wxFontRefData::SetWeight(int weight
)
499 void wxFontRefData::SetUnderlined(bool underlined
)
501 m_underlined
= underlined
;
503 // the XLFD doesn't have "underlined" field anyhow
506 void wxFontRefData::SetFaceName(const wxString
& facename
)
508 m_faceName
= facename
;
511 void wxFontRefData::SetEncoding(wxFontEncoding encoding
)
513 m_encoding
= encoding
;
516 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo
& info
)
518 // previously cached fonts shouldn't be used
521 m_nativeFontInfo
= info
;
523 // set all the other font parameters from the native font info
527 // ----------------------------------------------------------------------------
529 // ----------------------------------------------------------------------------
531 wxFont::wxFont(const wxNativeFontInfo
& info
)
534 Create( info
.GetPointSize(),
538 info
.GetUnderlined(),
540 info
.GetEncoding() );
542 (void) Create(info
.GetXFontName());
546 bool wxFont::Create(int pointSize
,
551 const wxString
& faceName
,
552 wxFontEncoding encoding
)
556 m_refData
= new wxFontRefData(pointSize
, family
, style
, weight
,
557 underlined
, faceName
, encoding
);
564 bool wxFont::Create(const wxString
& fontname
, wxFontEncoding enc
)
568 *this = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT
);
572 m_refData
= new wxFontRefData();
574 M_FONTDATA
->m_nativeFontInfo
.SetXFontName(fontname
); // X font name
578 wxStringTokenizer
tn( fontname
, wxT("-") );
580 tn
.GetNextToken(); // skip initial empty token
581 tn
.GetNextToken(); // foundry
584 M_FONTDATA
->m_faceName
= tn
.GetNextToken(); // family
586 tmp
= tn
.GetNextToken().MakeUpper(); // weight
587 if (tmp
== wxT("BOLD")) M_FONTDATA
->m_weight
= wxBOLD
;
588 if (tmp
== wxT("BLACK")) M_FONTDATA
->m_weight
= wxBOLD
;
589 if (tmp
== wxT("EXTRABOLD")) M_FONTDATA
->m_weight
= wxBOLD
;
590 if (tmp
== wxT("DEMIBOLD")) M_FONTDATA
->m_weight
= wxBOLD
;
591 if (tmp
== wxT("ULTRABOLD")) M_FONTDATA
->m_weight
= wxBOLD
;
593 if (tmp
== wxT("LIGHT")) M_FONTDATA
->m_weight
= wxLIGHT
;
594 if (tmp
== wxT("THIN")) M_FONTDATA
->m_weight
= wxLIGHT
;
596 tmp
= tn
.GetNextToken().MakeUpper(); // slant
597 if (tmp
== wxT("I")) M_FONTDATA
->m_style
= wxITALIC
;
598 if (tmp
== wxT("O")) M_FONTDATA
->m_style
= wxITALIC
;
600 tn
.GetNextToken(); // set width
601 tn
.GetNextToken(); // add. style
602 tn
.GetNextToken(); // pixel size
604 tmp
= tn
.GetNextToken(); // pointsize
607 long num
= wxStrtol (tmp
.c_str(), (wxChar
**) NULL
, 10);
608 M_FONTDATA
->m_pointSize
= (int)(num
/ 10);
611 tn
.GetNextToken(); // x-res
612 tn
.GetNextToken(); // y-res
614 tmp
= tn
.GetNextToken().MakeUpper(); // spacing
617 M_FONTDATA
->m_family
= wxMODERN
;
618 else if (M_FONTDATA
->m_faceName
== wxT("TIMES"))
619 M_FONTDATA
->m_family
= wxROMAN
;
620 else if (M_FONTDATA
->m_faceName
== wxT("HELVETICA"))
621 M_FONTDATA
->m_family
= wxSWISS
;
622 else if (M_FONTDATA
->m_faceName
== wxT("LUCIDATYPEWRITER"))
623 M_FONTDATA
->m_family
= wxTELETYPE
;
624 else if (M_FONTDATA
->m_faceName
== wxT("LUCIDA"))
625 M_FONTDATA
->m_family
= wxDECORATIVE
;
626 else if (M_FONTDATA
->m_faceName
== wxT("UTOPIA"))
627 M_FONTDATA
->m_family
= wxSCRIPT
;
629 tn
.GetNextToken(); // avg width
631 // deal with font encoding
632 M_FONTDATA
->m_encoding
= enc
;
633 if ( M_FONTDATA
->m_encoding
== wxFONTENCODING_SYSTEM
)
635 wxString registry
= tn
.GetNextToken().MakeUpper(),
636 encoding
= tn
.GetNextToken().MakeUpper();
638 if ( registry
== _T("ISO8859") )
641 if ( wxSscanf(encoding
, wxT("%d"), &cp
) == 1 )
643 M_FONTDATA
->m_encoding
=
644 (wxFontEncoding
)(wxFONTENCODING_ISO8859_1
+ cp
- 1);
647 else if ( registry
== _T("MICROSOFT") )
650 if ( wxSscanf(encoding
, wxT("cp125%d"), &cp
) == 1 )
652 M_FONTDATA
->m_encoding
=
653 (wxFontEncoding
)(wxFONTENCODING_CP1250
+ cp
);
656 else if ( registry
== _T("KOI8") )
658 M_FONTDATA
->m_encoding
= wxFONTENCODING_KOI8
;
660 //else: unknown encoding - may be give a warning here?
666 #endif // !wxUSE_UNICODE
672 // ----------------------------------------------------------------------------
673 // change the font attributes
674 // ----------------------------------------------------------------------------
676 void wxFont::Unshare()
678 // Don't change shared data
681 m_refData
= new wxFontRefData();
685 wxFontRefData
* ref
= new wxFontRefData(*(wxFontRefData
*)m_refData
);
691 // ----------------------------------------------------------------------------
693 // ----------------------------------------------------------------------------
695 int wxFont::GetPointSize() const
697 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
699 return M_FONTDATA
->m_pointSize
;
702 wxString
wxFont::GetFaceName() const
704 wxCHECK_MSG( Ok(), wxEmptyString
, wxT("invalid font") );
706 return M_FONTDATA
->m_faceName
;
709 int wxFont::GetFamily() const
711 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
713 return M_FONTDATA
->m_family
;
716 int wxFont::GetStyle() const
718 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
720 return M_FONTDATA
->m_style
;
723 int wxFont::GetWeight() const
725 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
727 return M_FONTDATA
->m_weight
;
730 bool wxFont::GetUnderlined() const
732 wxCHECK_MSG( Ok(), false, wxT("invalid font") );
734 return M_FONTDATA
->m_underlined
;
737 wxFontEncoding
wxFont::GetEncoding() const
739 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
741 return M_FONTDATA
->m_encoding
;
744 bool wxFont::GetNoAntiAliasing() const
746 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
748 return M_FONTDATA
->m_noAA
;
751 const wxNativeFontInfo
*wxFont::GetNativeFontInfo() const
753 wxCHECK_MSG( Ok(), (wxNativeFontInfo
*)NULL
, wxT("invalid font") );
757 if ( M_FONTDATA
->m_nativeFontInfo
.GetXFontName().empty() )
761 return &(M_FONTDATA
->m_nativeFontInfo
);
764 bool wxFont::IsFixedWidth() const
766 wxCHECK_MSG( Ok(), false, wxT("invalid font") );
769 return wxFontBase::IsFixedWidth();
771 // Robert, is this right? HasNativeFont doesn't exist.
773 // if ( M_FONTDATA->HasNativeFont() )
775 // the monospace fonts are supposed to have "M" in the spacing field
776 wxString spacing
= M_FONTDATA
->
777 m_nativeFontInfo
.GetXFontComponent(wxXLFD_SPACING
);
779 return spacing
.Upper() == _T('M');
781 // Unreaceable code for now
782 // return wxFontBase::IsFixedWidth();
787 // ----------------------------------------------------------------------------
788 // change font attributes
789 // ----------------------------------------------------------------------------
791 void wxFont::SetPointSize(int pointSize
)
795 M_FONTDATA
->SetPointSize(pointSize
);
798 void wxFont::SetFamily(int family
)
802 M_FONTDATA
->SetFamily(family
);
805 void wxFont::SetStyle(int style
)
809 M_FONTDATA
->SetStyle(style
);
812 void wxFont::SetWeight(int weight
)
816 M_FONTDATA
->SetWeight(weight
);
819 void wxFont::SetFaceName(const wxString
& faceName
)
823 M_FONTDATA
->SetFaceName(faceName
);
826 void wxFont::SetUnderlined(bool underlined
)
830 M_FONTDATA
->SetUnderlined(underlined
);
833 void wxFont::SetEncoding(wxFontEncoding encoding
)
837 M_FONTDATA
->SetEncoding(encoding
);
840 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo
& info
)
844 M_FONTDATA
->SetNativeFontInfo( info
);
847 void wxFont::SetNoAntiAliasing( bool no
)
851 M_FONTDATA
->SetNoAntiAliasing( no
);
857 // ----------------------------------------------------------------------------
858 // X11 implementation
859 // ----------------------------------------------------------------------------
861 // Find an existing, or create a new, XFontStruct
862 // based on this wxFont and the given scale. Append the
863 // font to list in the private data for future reference.
864 wxXFont
* wxFont::GetInternalFont(double scale
, WXDisplay
* display
) const
867 return (wxXFont
*)NULL
;
869 long intScale
= long(scale
* 100.0 + 0.5); // key for wxXFont
870 int pointSize
= (M_FONTDATA
->m_pointSize
* 10 * intScale
) / 100;
872 // search existing fonts first
873 wxList::compatibility_iterator node
= M_FONTDATA
->m_fonts
.GetFirst();
876 wxXFont
* f
= (wxXFont
*) node
->GetData();
877 if ((!display
|| (f
->m_display
== display
)) && (f
->m_scale
== intScale
))
879 node
= node
->GetNext();
882 wxString xFontName
= M_FONTDATA
->m_nativeFontInfo
.GetXFontName();
883 if (xFontName
== "-*-*-*-*-*--*-*-*-*-*-*-*-*")
884 // wxFont constructor not called with native font info parameter => take M_FONTDATA values
887 // not found, create a new one
888 XFontStruct
*font
= (XFontStruct
*)
889 wxLoadQueryNearestFont(pointSize
,
890 M_FONTDATA
->m_family
,
892 M_FONTDATA
->m_weight
,
893 M_FONTDATA
->m_underlined
,
895 M_FONTDATA
->m_encoding
,
900 wxFAIL_MSG( wxT("Could not allocate even a default font -- something is wrong.") );
902 return (wxXFont
*) NULL
;
905 wxXFont
* f
= new wxXFont
;
906 f
->m_fontStruct
= (WXFontStructPtr
)font
;
907 f
->m_display
= ( display
? display
: wxGetDisplay() );
908 f
->m_scale
= intScale
;
909 M_FONTDATA
->m_fonts
.Append(f
);
914 WXFontStructPtr
wxFont::GetFontStruct(double scale
, WXDisplay
* display
) const
916 wxXFont
* f
= GetInternalFont(scale
, display
);
918 return (f
? f
->m_fontStruct
: (WXFontStructPtr
) 0);