]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/font.cpp
guard for 10.2
[wxWidgets.git] / src / gtk / font.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: gtk/font.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling and Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // ============================================================================
11 // declarations
12 // ============================================================================
13
14 // ----------------------------------------------------------------------------
15 // headers
16 // ----------------------------------------------------------------------------
17
18 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
19 #pragma implementation "font.h"
20 #endif
21
22 // For compilers that support precompilation, includes "wx.h".
23 #include "wx/wxprec.h"
24
25 #include "wx/font.h"
26 #include "wx/fontutil.h"
27 #include "wx/cmndata.h"
28 #include "wx/utils.h"
29 #include "wx/log.h"
30 #include "wx/gdicmn.h"
31 #include "wx/tokenzr.h"
32 #include "wx/settings.h"
33
34 #include <strings.h>
35
36 #include "wx/gtk/private.h"
37 #include <gdk/gdkprivate.h>
38
39 // ----------------------------------------------------------------------------
40 // constants
41 // ----------------------------------------------------------------------------
42
43 // the default size (in points) for the fonts
44 static const int wxDEFAULT_FONT_SIZE = 12;
45
46 // ----------------------------------------------------------------------------
47 // wxScaledFontList: maps the font sizes to the GDK fonts for the given font
48 // ----------------------------------------------------------------------------
49
50 WX_DECLARE_HASH_MAP(int, GdkFont *, wxIntegerHash, wxIntegerEqual,
51 wxScaledFontList);
52
53 // ----------------------------------------------------------------------------
54 // wxFontRefData
55 // ----------------------------------------------------------------------------
56
57 class wxFontRefData : public wxObjectRefData
58 {
59 public:
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);
68
69 // from XFLD
70 wxFontRefData(const wxString& fontname);
71
72 // copy ctor
73 wxFontRefData( const wxFontRefData& data );
74
75 virtual ~wxFontRefData();
76
77 // do we have the native font info?
78 bool HasNativeFont() const
79 {
80 #ifdef __WXGTK20__
81 // we always have a Pango font description
82 return TRUE;
83 #else // GTK 1.x
84 // only use m_nativeFontInfo if it had been initialized
85 return !m_nativeFontInfo.IsDefault();
86 #endif // GTK 2.0/1.x
87 }
88
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);
98
99 void SetNoAntiAliasing( bool no = TRUE ) { m_noAA = no; }
100 bool GetNoAntiAliasing() const { return m_noAA; }
101
102 // and this one also modifies all the other font data fields
103 void SetNativeFontInfo(const wxNativeFontInfo& info);
104
105 // debugger helper: shows what the font really is
106 //
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__)
110 void Dump() const
111 {
112 wxPrintf(_T("%s-%s-%s-%d-%d\n"),
113 m_faceName.c_str(),
114 m_weight == wxFONTWEIGHT_NORMAL
115 ? _T("normal")
116 : m_weight == wxFONTWEIGHT_BOLD
117 ? _T("bold")
118 : _T("light"),
119 m_style == wxFONTSTYLE_NORMAL ? _T("regular") : _T("italic"),
120 m_pointSize,
121 m_encoding);
122 }
123 #endif // Debug
124
125 protected:
126 // common part of all ctors
127 void Init(int pointSize,
128 int family,
129 int style,
130 int weight,
131 bool underlined,
132 const wxString& faceName,
133 wxFontEncoding encoding);
134
135 // set all fields from (already initialized and valid) m_nativeFontInfo
136 void InitFromNative();
137
138 private:
139 // clear m_scaled_xfonts if any
140 void ClearGdkFonts();
141
142 #ifndef __WXGTK20__
143 // the map of font sizes to "GdkFont *"
144 wxScaledFontList m_scaled_xfonts;
145 #endif // GTK 2.0/1.x
146
147 int m_pointSize;
148 int m_family,
149 m_style,
150 m_weight;
151 bool m_underlined;
152 wxString m_faceName;
153 wxFontEncoding m_encoding; // Unused under GTK 2.0
154 bool m_noAA; // No anti-aliasing
155
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;
159
160 friend class wxFont;
161 };
162
163 // ----------------------------------------------------------------------------
164 // wxFontRefData
165 // ----------------------------------------------------------------------------
166
167 void wxFontRefData::Init(int pointSize,
168 int family,
169 int style,
170 int weight,
171 bool underlined,
172 const wxString& faceName,
173 wxFontEncoding encoding)
174 {
175 m_family = family == wxFONTFAMILY_DEFAULT ? wxFONTFAMILY_SWISS : family;
176
177 m_faceName = faceName;
178
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;
182
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
187 : pointSize;
188
189 m_underlined = underlined;
190 m_encoding = encoding;
191
192 m_noAA = FALSE;
193
194 #ifdef __WXGTK20__
195 // Create native font info
196 m_nativeFontInfo.description = pango_font_description_new();
197
198 // And set its values
199 if (!m_faceName.empty())
200 {
201 pango_font_description_set_family( m_nativeFontInfo.description, wxGTK_CONV(m_faceName) );
202 }
203 else
204 {
205 switch (m_family)
206 {
207 case wxFONTFAMILY_MODERN:
208 case wxFONTFAMILY_TELETYPE:
209 pango_font_description_set_family( m_nativeFontInfo.description, "monospace" );
210 break;
211 case wxFONTFAMILY_ROMAN:
212 pango_font_description_set_family( m_nativeFontInfo.description, "serif" );
213 break;
214 case wxFONTFAMILY_SWISS:
215 // SWISS = sans serif
216 default:
217 pango_font_description_set_family( m_nativeFontInfo.description, "sans" );
218 break;
219 }
220 }
221
222 SetStyle( m_style );
223 SetPointSize( m_pointSize );
224 SetWeight( m_weight );
225 #endif // GTK 2.0
226 }
227
228 void wxFontRefData::InitFromNative()
229 {
230 m_noAA = FALSE;
231
232 #ifdef __WXGTK20__
233 // Get native info
234 PangoFontDescription *desc = m_nativeFontInfo.description;
235
236 // init fields
237 m_faceName = wxGTK_CONV_BACK( pango_font_description_get_family( desc ) );
238
239 // Pango sometimes needs to have a size
240 int pango_size = pango_font_description_get_size( desc );
241 if (pango_size == 0)
242 pango_font_description_set_size( desc, 12 * PANGO_SCALE);
243
244 m_pointSize = pango_font_description_get_size( desc ) / PANGO_SCALE;
245
246 switch (pango_font_description_get_style( desc ))
247 {
248 case PANGO_STYLE_NORMAL:
249 m_style = wxFONTSTYLE_NORMAL;
250 break;
251 case PANGO_STYLE_ITALIC:
252 m_style = wxFONTSTYLE_ITALIC;
253 break;
254 case PANGO_STYLE_OBLIQUE:
255 m_style = wxFONTSTYLE_SLANT;
256 break;
257 }
258
259 switch (pango_font_description_get_weight( desc ))
260 {
261 case PANGO_WEIGHT_ULTRALIGHT:
262 m_weight = wxFONTWEIGHT_LIGHT;
263 break;
264 case PANGO_WEIGHT_LIGHT:
265 m_weight = wxFONTWEIGHT_LIGHT;
266 break;
267 case PANGO_WEIGHT_NORMAL:
268 m_weight = wxFONTWEIGHT_NORMAL;
269 break;
270 case PANGO_WEIGHT_BOLD:
271 m_weight = wxFONTWEIGHT_BOLD;
272 break;
273 case PANGO_WEIGHT_ULTRABOLD:
274 m_weight = wxFONTWEIGHT_BOLD;
275 break;
276 case PANGO_WEIGHT_HEAVY:
277 m_weight = wxFONTWEIGHT_BOLD;
278 break;
279 }
280
281 if (m_faceName == wxT("monospace"))
282 {
283 m_family = wxFONTFAMILY_TELETYPE;
284 }
285 else if (m_faceName == wxT("sans"))
286 {
287 m_family = wxFONTFAMILY_SWISS;
288 }
289 else if (m_faceName == wxT("serif"))
290 {
291 m_family = wxFONTFAMILY_ROMAN;
292 }
293 else
294 {
295 m_family = wxFONTFAMILY_UNKNOWN;
296 }
297
298 // Pango description are never underlined (?)
299 m_underlined = FALSE;
300
301 // Cannot we choose that
302 m_encoding = wxFONTENCODING_SYSTEM;
303 #else // GTK 1.x
304 // get the font parameters from the XLFD
305 // -------------------------------------
306
307 m_faceName = m_nativeFontInfo.GetXFontComponent(wxXLFD_FAMILY);
308
309 m_weight = wxFONTWEIGHT_NORMAL;
310
311 wxString w = m_nativeFontInfo.GetXFontComponent(wxXLFD_WEIGHT).Upper();
312 if ( !w.empty() && w != _T('*') )
313 {
314 // the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
315 // and BLACK
316 if ( ((w[0u] == _T('B') && (!wxStrcmp(w.c_str() + 1, wxT("OLD")) ||
317 !wxStrcmp(w.c_str() + 1, wxT("LACK"))))) ||
318 wxStrstr(w.c_str() + 1, _T("BOLD")) )
319 {
320 m_weight = wxFONTWEIGHT_BOLD;
321 }
322 else if ( w == _T("LIGHT") || w == _T("THIN") )
323 {
324 m_weight = wxFONTWEIGHT_LIGHT;
325 }
326 }
327
328 switch ( wxToupper(*m_nativeFontInfo.
329 GetXFontComponent(wxXLFD_SLANT).c_str()) )
330 {
331 case _T('I'): // italique
332 m_style = wxFONTSTYLE_ITALIC;
333 break;
334
335 case _T('O'): // oblique
336 m_style = wxFONTSTYLE_SLANT;
337 break;
338
339 default:
340 m_style = wxFONTSTYLE_NORMAL;
341 }
342
343 long ptSize;
344 if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_POINTSIZE).ToLong(&ptSize) )
345 {
346 // size in XLFD is in 10 point units
347 m_pointSize = (int)(ptSize / 10);
348 }
349 else
350 {
351 m_pointSize = wxDEFAULT_FONT_SIZE;
352 }
353
354 // examine the spacing: if the font is monospaced, assume wxTELETYPE
355 // family for compatibility with the old code which used it instead of
356 // IsFixedWidth()
357 if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING).Upper() == _T('M') )
358 {
359 m_family = wxFONTFAMILY_TELETYPE;
360 }
361 else // not monospaceed
362 {
363 // don't even try guessing it, it doesn't work for too many fonts
364 // anyhow
365 m_family = wxFONTFAMILY_UNKNOWN;
366 }
367
368 // X fonts are never underlined...
369 m_underlined = FALSE;
370
371 // deal with font encoding
372 wxString
373 registry = m_nativeFontInfo.GetXFontComponent(wxXLFD_REGISTRY).Upper(),
374 encoding = m_nativeFontInfo.GetXFontComponent(wxXLFD_ENCODING).Upper();
375
376 if ( registry == _T("ISO8859") )
377 {
378 int cp;
379 if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
380 {
381 m_encoding = (wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
382 }
383 }
384 else if ( registry == _T("MICROSOFT") )
385 {
386 int cp;
387 if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
388 {
389 m_encoding = (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
390 }
391 }
392 else if ( registry == _T("KOI8") )
393 {
394 m_encoding = wxFONTENCODING_KOI8;
395 }
396 else // unknown encoding
397 {
398 // may be give a warning here? or use wxFontMapper?
399 m_encoding = wxFONTENCODING_SYSTEM;
400 }
401 #endif // GTK 2.0/1.x
402 }
403
404 wxFontRefData::wxFontRefData( const wxFontRefData& data )
405 : wxObjectRefData()
406 {
407 m_pointSize = data.m_pointSize;
408 m_family = data.m_family;
409 m_style = data.m_style;
410 m_weight = data.m_weight;
411
412 m_underlined = data.m_underlined;
413
414 m_faceName = data.m_faceName;
415 m_encoding = data.m_encoding;
416
417 m_noAA = data.m_noAA;
418
419 // Forces a copy of the internal data. wxNativeFontInfo should probably
420 // have a copy ctor and assignment operator to fix this properly but that
421 // would break binary compatibility...
422 m_nativeFontInfo.FromString(data.m_nativeFontInfo.ToString());
423 }
424
425 wxFontRefData::wxFontRefData(int size, int family, int style,
426 int weight, bool underlined,
427 const wxString& faceName,
428 wxFontEncoding encoding)
429 {
430 Init(size, family, style, weight, underlined, faceName, encoding);
431 }
432
433 wxFontRefData::wxFontRefData(const wxString& fontname)
434 {
435 // VZ: FromString() should really work in both cases, doesn't it?
436 #ifdef __WXGTK20__
437 m_nativeFontInfo.FromString( fontname );
438 #else // GTK 1.x
439 m_nativeFontInfo.SetXFontName(fontname);
440 #endif // GTK 2.0/1.x
441
442 InitFromNative();
443 }
444
445 void wxFontRefData::ClearGdkFonts()
446 {
447 #ifndef __WXGTK20__
448 for ( wxScaledFontList::iterator i = m_scaled_xfonts.begin();
449 i != m_scaled_xfonts.end();
450 ++i )
451 {
452 GdkFont *font = i->second;
453 gdk_font_unref( font );
454 }
455
456 m_scaled_xfonts.clear();
457 #endif // GTK 1.x
458 }
459
460 wxFontRefData::~wxFontRefData()
461 {
462 ClearGdkFonts();
463 }
464
465 // ----------------------------------------------------------------------------
466 // wxFontRefData SetXXX()
467 // ----------------------------------------------------------------------------
468
469 void wxFontRefData::SetPointSize(int pointSize)
470 {
471 m_pointSize = pointSize;
472
473 #ifdef __WXGTK20__
474 // Get native info
475 PangoFontDescription *desc = m_nativeFontInfo.description;
476
477 pango_font_description_set_size( desc, m_pointSize * PANGO_SCALE );
478 #else
479 if ( HasNativeFont() )
480 {
481 wxString size;
482 if ( pointSize == -1 )
483 size = _T('*');
484 else
485 size.Printf(_T("%d"), 10*pointSize);
486
487 m_nativeFontInfo.SetXFontComponent(wxXLFD_POINTSIZE, size);
488 }
489 #endif
490 }
491
492 void wxFontRefData::SetFamily(int family)
493 {
494 m_family = family;
495
496 // TODO: what are we supposed to do with m_nativeFontInfo here?
497 }
498
499 void wxFontRefData::SetStyle(int style)
500 {
501 m_style = style;
502
503 #ifdef __WXGTK20__
504 // Get native info
505 PangoFontDescription *desc = m_nativeFontInfo.description;
506
507 switch ( style )
508 {
509 case wxFONTSTYLE_ITALIC:
510 pango_font_description_set_style( desc, PANGO_STYLE_ITALIC );
511 break;
512 case wxFONTSTYLE_SLANT:
513 pango_font_description_set_style( desc, PANGO_STYLE_OBLIQUE );
514 break;
515 default:
516 wxFAIL_MSG( _T("unknown font style") );
517 // fall through
518 case wxFONTSTYLE_NORMAL:
519 pango_font_description_set_style( desc, PANGO_STYLE_NORMAL );
520 break;
521 }
522 #else
523 if ( HasNativeFont() )
524 {
525 wxString slant;
526 switch ( style )
527 {
528 case wxFONTSTYLE_ITALIC:
529 slant = _T('i');
530 break;
531
532 case wxFONTSTYLE_SLANT:
533 slant = _T('o');
534 break;
535
536 default:
537 wxFAIL_MSG( _T("unknown font style") );
538 // fall through
539
540 case wxFONTSTYLE_NORMAL:
541 slant = _T('r');
542 }
543
544 m_nativeFontInfo.SetXFontComponent(wxXLFD_SLANT, slant);
545 }
546 #endif
547 }
548
549 void wxFontRefData::SetWeight(int weight)
550 {
551 m_weight = weight;
552
553 #ifdef __WXGTK20__
554 PangoFontDescription *desc = m_nativeFontInfo.description;
555 switch ( weight )
556 {
557 case wxFONTWEIGHT_BOLD:
558 pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD);
559 break;
560
561 case wxFONTWEIGHT_LIGHT:
562 pango_font_description_set_weight(desc, PANGO_WEIGHT_LIGHT);
563 break;
564
565 default:
566 wxFAIL_MSG( _T("unknown font weight") );
567 // fall through
568
569 case wxFONTWEIGHT_NORMAL:
570 // unspecified
571 pango_font_description_set_weight(desc, PANGO_WEIGHT_NORMAL);
572 }
573 #else //!__WXGTK20__
574 if ( HasNativeFont() )
575 {
576 wxString boldness;
577 switch ( weight )
578 {
579 case wxFONTWEIGHT_BOLD:
580 boldness = _T("bold");
581 break;
582
583 case wxFONTWEIGHT_LIGHT:
584 boldness = _T("light");
585 break;
586
587 default:
588 wxFAIL_MSG( _T("unknown font weight") );
589 // fall through
590
591 case wxFONTWEIGHT_NORMAL:
592 // unspecified
593 boldness = _T("medium");
594 }
595
596 m_nativeFontInfo.SetXFontComponent(wxXLFD_WEIGHT, boldness);
597 }
598 #endif
599 }
600
601 void wxFontRefData::SetUnderlined(bool underlined)
602 {
603 m_underlined = underlined;
604
605 // the XLFD doesn't have "underlined" field anyhow
606 }
607
608 void wxFontRefData::SetFaceName(const wxString& facename)
609 {
610 m_faceName = facename;
611
612 #ifndef __WXGTK20__
613 if ( HasNativeFont() )
614 {
615 m_nativeFontInfo.SetXFontComponent(wxXLFD_FAMILY, facename);
616 }
617 #endif
618 }
619
620 void wxFontRefData::SetEncoding(wxFontEncoding encoding)
621 {
622 m_encoding = encoding;
623
624 #ifndef __WXGTK20__
625 if ( HasNativeFont() )
626 {
627 wxNativeEncodingInfo info;
628 if ( wxGetNativeFontEncoding(encoding, &info) )
629 {
630 m_nativeFontInfo.SetXFontComponent(wxXLFD_REGISTRY, info.xregistry);
631 m_nativeFontInfo.SetXFontComponent(wxXLFD_ENCODING, info.xencoding);
632 }
633 }
634 #endif
635 }
636
637 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
638 {
639 // previously cached fonts shouldn't be used
640 ClearGdkFonts();
641
642 m_nativeFontInfo = info;
643
644 // set all the other font parameters from the native font info
645 InitFromNative();
646 }
647
648 // ----------------------------------------------------------------------------
649 // wxFont creation
650 // ----------------------------------------------------------------------------
651
652 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
653
654 void wxFont::Init()
655 {
656 }
657
658 wxFont::wxFont(const wxNativeFontInfo& info)
659 {
660 Init();
661
662 #ifdef __WXGTK20__
663 Create( info.GetPointSize(),
664 info.GetFamily(),
665 info.GetStyle(),
666 info.GetWeight(),
667 info.GetUnderlined(),
668 info.GetFaceName(),
669 info.GetEncoding() );
670 #else
671 (void) Create(info.GetXFontName());
672 #endif
673 }
674
675 bool wxFont::Create( int pointSize,
676 int family,
677 int style,
678 int weight,
679 bool underlined,
680 const wxString& face,
681 wxFontEncoding encoding)
682 {
683 UnRef();
684
685 m_refData = new wxFontRefData(pointSize, family, style, weight,
686 underlined, face, encoding);
687
688 return TRUE;
689 }
690
691 bool wxFont::Create(const wxString& fontname)
692 {
693 // VZ: does this really happen?
694 if ( fontname.empty() )
695 {
696 *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
697
698 return TRUE;
699 }
700
701 m_refData = new wxFontRefData(fontname);
702
703 return TRUE;
704 }
705
706 void wxFont::Unshare()
707 {
708 if (!m_refData)
709 {
710 m_refData = new wxFontRefData();
711 }
712 else
713 {
714 wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
715 UnRef();
716 m_refData = ref;
717 }
718 }
719
720 wxFont::~wxFont()
721 {
722 }
723
724 // ----------------------------------------------------------------------------
725 // accessors
726 // ----------------------------------------------------------------------------
727
728 int wxFont::GetPointSize() const
729 {
730 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
731
732 return M_FONTDATA->m_pointSize;
733 }
734
735 wxString wxFont::GetFaceName() const
736 {
737 wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
738
739 return M_FONTDATA->m_faceName;
740 }
741
742 int wxFont::GetFamily() const
743 {
744 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
745
746 return M_FONTDATA->m_family;
747 }
748
749 int wxFont::GetStyle() const
750 {
751 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
752
753 return M_FONTDATA->m_style;
754 }
755
756 int wxFont::GetWeight() const
757 {
758 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
759
760 return M_FONTDATA->m_weight;
761 }
762
763 bool wxFont::GetUnderlined() const
764 {
765 wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
766
767 return M_FONTDATA->m_underlined;
768 }
769
770 wxFontEncoding wxFont::GetEncoding() const
771 {
772 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
773
774 return M_FONTDATA->m_encoding;
775 }
776
777 bool wxFont::GetNoAntiAliasing() const
778 {
779 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
780
781 return M_FONTDATA->m_noAA;
782 }
783
784 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
785 {
786 wxCHECK_MSG( Ok(), (wxNativeFontInfo *)NULL, wxT("invalid font") );
787
788 #ifndef __WXGTK20__
789 if ( !M_FONTDATA->HasNativeFont() )
790 {
791 // NB: this call has important side-effect: it not only finds
792 // GdkFont representation, it also initializes m_nativeFontInfo
793 // by calling its SetXFontName method
794 GetInternalFont();
795 }
796 #endif
797
798 return &(M_FONTDATA->m_nativeFontInfo);
799 }
800
801 bool wxFont::IsFixedWidth() const
802 {
803 wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
804
805 #ifndef __WXGTK20__
806 if ( M_FONTDATA->HasNativeFont() )
807 {
808 // the monospace fonts are supposed to have "M" in the spacing field
809 wxString spacing = M_FONTDATA->
810 m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING);
811
812 return spacing.Upper() == _T('M');
813 }
814 #endif
815
816 return wxFontBase::IsFixedWidth();
817 }
818
819 // ----------------------------------------------------------------------------
820 // change font attributes
821 // ----------------------------------------------------------------------------
822
823 void wxFont::SetPointSize(int pointSize)
824 {
825 Unshare();
826
827 M_FONTDATA->SetPointSize(pointSize);
828 }
829
830 void wxFont::SetFamily(int family)
831 {
832 Unshare();
833
834 M_FONTDATA->SetFamily(family);
835 }
836
837 void wxFont::SetStyle(int style)
838 {
839 Unshare();
840
841 M_FONTDATA->SetStyle(style);
842 }
843
844 void wxFont::SetWeight(int weight)
845 {
846 Unshare();
847
848 M_FONTDATA->SetWeight(weight);
849 }
850
851 void wxFont::SetFaceName(const wxString& faceName)
852 {
853 Unshare();
854
855 M_FONTDATA->SetFaceName(faceName);
856 }
857
858 void wxFont::SetUnderlined(bool underlined)
859 {
860 Unshare();
861
862 M_FONTDATA->SetUnderlined(underlined);
863 }
864
865 void wxFont::SetEncoding(wxFontEncoding encoding)
866 {
867 Unshare();
868
869 M_FONTDATA->SetEncoding(encoding);
870 }
871
872 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo& info )
873 {
874 Unshare();
875
876 M_FONTDATA->SetNativeFontInfo( info );
877 }
878
879 void wxFont::SetNoAntiAliasing( bool no )
880 {
881 Unshare();
882
883 M_FONTDATA->SetNoAntiAliasing( no );
884 }
885
886 // ----------------------------------------------------------------------------
887 // get internal representation of font
888 // ----------------------------------------------------------------------------
889
890 #ifndef __WXGTK20__
891 static GdkFont *g_systemDefaultGuiFont = (GdkFont*) NULL;
892
893 // this is also used from tbargtk.cpp and tooltip.cpp, hence extern
894 extern GdkFont *GtkGetDefaultGuiFont()
895 {
896 if (!g_systemDefaultGuiFont)
897 {
898 GtkWidget *widget = gtk_button_new();
899 GtkStyle *def = gtk_rc_get_style( widget );
900 if (def)
901 {
902 g_systemDefaultGuiFont = gdk_font_ref( def->font );
903 }
904 else
905 {
906 def = gtk_widget_get_default_style();
907 if (def)
908 g_systemDefaultGuiFont = gdk_font_ref( def->font );
909 }
910 gtk_widget_destroy( widget );
911 }
912 else
913 {
914 // already have it, but ref it once more before returning
915 gdk_font_ref(g_systemDefaultGuiFont);
916 }
917
918 return g_systemDefaultGuiFont;
919 }
920
921 GdkFont *wxFont::GetInternalFont( float scale ) const
922 {
923 GdkFont *font = (GdkFont *) NULL;
924
925 wxCHECK_MSG( Ok(), font, wxT("invalid font") )
926
927 long int_scale = long(scale * 100.0 + 0.5); // key for fontlist
928 int point_scale = (int)((M_FONTDATA->m_pointSize * 10 * int_scale) / 100);
929
930 wxScaledFontList& list = M_FONTDATA->m_scaled_xfonts;
931 wxScaledFontList::iterator i = list.find(int_scale);
932 if ( i != list.end() )
933 {
934 font = i->second;
935 }
936 else // we don't have this font in this size yet
937 {
938 if (*this == wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT))
939 {
940 font = GtkGetDefaultGuiFont();
941 }
942
943 if ( !font )
944 {
945 // do we have the XLFD?
946 if ( int_scale == 100 && M_FONTDATA->HasNativeFont() )
947 {
948 font = wxLoadFont(M_FONTDATA->m_nativeFontInfo.GetXFontName());
949 }
950
951 // no XLFD of no exact match - try the approximate one now
952 if ( !font )
953 {
954 wxString xfontname;
955 font = wxLoadQueryNearestFont( point_scale,
956 M_FONTDATA->m_family,
957 M_FONTDATA->m_style,
958 M_FONTDATA->m_weight,
959 M_FONTDATA->m_underlined,
960 M_FONTDATA->m_faceName,
961 M_FONTDATA->m_encoding,
962 &xfontname);
963 // NB: wxFont::GetNativeFontInfo relies on this
964 // side-effect of GetInternalFont
965 if ( int_scale == 100 )
966 M_FONTDATA->m_nativeFontInfo.SetXFontName(xfontname);
967 }
968 }
969
970 if ( font )
971 {
972 list[int_scale] = font;
973 }
974 }
975
976 // it's quite useless to make it a wxCHECK because we're going to crash
977 // anyhow...
978 wxASSERT_MSG( font, wxT("could not load any font?") );
979
980 return font;
981 }
982 #endif // not GTK 2.0
983