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