]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/font.cpp
Improve default size. If the control is auto-fit its size won't be less
[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 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 // reinitilize the font with the gived XFLD
90 void ReInit(const wxString& fontname);
91
92 // setters: all of them also take care to modify m_nativeFontInfo if we
93 // have it so as to not lose the information not carried by our fields
94 void SetPointSize(int pointSize);
95 void SetFamily(int family);
96 void SetStyle(int style);
97 void SetWeight(int weight);
98 void SetUnderlined(bool underlined);
99 void SetFaceName(const wxString& facename);
100 void SetEncoding(wxFontEncoding encoding);
101
102 void SetNoAntiAliasing( bool no = TRUE ) { m_noAA = no; }
103 bool GetNoAntiAliasing() { return m_noAA; }
104
105 // and this one also modifies all the other font data fields
106 void SetNativeFontInfo(const wxNativeFontInfo& info);
107
108 // debugger helper: shows what the font really is
109 //
110 // VZ: I need this as my gdb either shows wildly wrong values or crashes
111 // when I ask it to "p fontRefData" :-(
112 #if defined(__WXDEBUG__) && !defined(__WXGTK20__)
113 void Dump() const
114 {
115 wxPrintf(_T("%s-%s-%s-%d-%d\n"),
116 m_faceName.c_str(),
117 m_weight == wxFONTWEIGHT_NORMAL
118 ? _T("normal")
119 : m_weight == wxFONTWEIGHT_BOLD
120 ? _T("bold")
121 : _T("light"),
122 m_style == wxFONTSTYLE_NORMAL ? _T("regular") : _T("italic"),
123 m_pointSize,
124 m_encoding);
125 }
126 #endif // Debug
127
128 protected:
129 // common part of all ctors
130 void Init(int pointSize,
131 int family,
132 int style,
133 int weight,
134 bool underlined,
135 const wxString& faceName,
136 wxFontEncoding encoding);
137
138 // set all fields from (already initialized and valid) m_nativeFontInfo
139 void InitFromNative();
140
141 private:
142 // clear m_scaled_xfonts if any
143 void ClearGdkFonts();
144
145 #ifndef __WXGTK20__
146 // the map of font sizes to "GdkFont *"
147 wxScaledFontList m_scaled_xfonts;
148 #endif // GTK 2.0/1.x
149
150 int m_pointSize;
151 int m_family,
152 m_style,
153 m_weight;
154 bool m_underlined;
155 wxString m_faceName;
156 wxFontEncoding m_encoding; // Unused under GTK 2.0
157 bool m_noAA; // No anti-aliasing
158
159 // The native font info, basicly an XFLD under GTK 1.2 and
160 // the pango font description under GTK 2.0.
161 wxNativeFontInfo m_nativeFontInfo;
162
163 friend class wxFont;
164 };
165
166 // ----------------------------------------------------------------------------
167 // wxFontRefData
168 // ----------------------------------------------------------------------------
169
170 void wxFontRefData::Init(int pointSize,
171 int family,
172 int style,
173 int weight,
174 bool underlined,
175 const wxString& faceName,
176 wxFontEncoding encoding)
177 {
178 m_family = family == wxFONTFAMILY_DEFAULT ? wxFONTFAMILY_SWISS : family;
179
180 m_faceName = faceName;
181
182 // we accept both wxDEFAULT and wxNORMAL here - should we?
183 m_style = style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style;
184 m_weight = weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight;
185
186 // and here, do we really want to forbid creation of the font of the size
187 // 90 (the value of wxDEFAULT)??
188 m_pointSize = pointSize == wxDEFAULT || pointSize == -1
189 ? wxDEFAULT_FONT_SIZE
190 : pointSize;
191
192 m_underlined = underlined;
193 m_encoding = encoding;
194
195 m_noAA = FALSE;
196
197 #ifdef __WXGTK20__
198 // Create native font info
199 m_nativeFontInfo.description = pango_font_description_new();
200
201 // And set its values
202 if (!m_faceName.empty())
203 {
204 pango_font_description_set_family( m_nativeFontInfo.description, wxGTK_CONV(m_faceName) );
205 }
206 else
207 {
208 switch (m_family)
209 {
210 case wxFONTFAMILY_MODERN:
211 case wxFONTFAMILY_TELETYPE:
212 pango_font_description_set_family( m_nativeFontInfo.description, "monospace" );
213 break;
214 case wxFONTFAMILY_ROMAN:
215 pango_font_description_set_family( m_nativeFontInfo.description, "serif" );
216 break;
217 case wxFONTFAMILY_SWISS:
218 // SWISS = sans serif
219 default:
220 pango_font_description_set_family( m_nativeFontInfo.description, "sans" );
221 break;
222 }
223 }
224
225 SetStyle( m_style );
226 SetPointSize( m_pointSize );
227 SetWeight( m_weight );
228 #endif // GTK 2.0
229 }
230
231 void wxFontRefData::InitFromNative()
232 {
233 m_noAA = FALSE;
234
235 #ifdef __WXGTK20__
236 // Get native info
237 PangoFontDescription *desc = m_nativeFontInfo.description;
238
239 // init fields
240 m_faceName = wxGTK_CONV_BACK( pango_font_description_get_family( desc ) );
241
242 m_pointSize = pango_font_description_get_size( desc ) / PANGO_SCALE;
243
244 switch (pango_font_description_get_style( desc ))
245 {
246 case PANGO_STYLE_NORMAL:
247 m_style = wxFONTSTYLE_NORMAL;
248 break;
249 case PANGO_STYLE_ITALIC:
250 m_style = wxFONTSTYLE_ITALIC;
251 break;
252 case PANGO_STYLE_OBLIQUE:
253 m_style = wxFONTSTYLE_SLANT;
254 break;
255 }
256
257 switch (pango_font_description_get_weight( desc ))
258 {
259 case PANGO_WEIGHT_ULTRALIGHT:
260 m_weight = wxFONTWEIGHT_LIGHT;
261 break;
262 case PANGO_WEIGHT_LIGHT:
263 m_weight = wxFONTWEIGHT_LIGHT;
264 break;
265 case PANGO_WEIGHT_NORMAL:
266 m_weight = wxFONTWEIGHT_NORMAL;
267 break;
268 case PANGO_WEIGHT_BOLD:
269 m_weight = wxFONTWEIGHT_BOLD;
270 break;
271 case PANGO_WEIGHT_ULTRABOLD:
272 m_weight = wxFONTWEIGHT_BOLD;
273 break;
274 case PANGO_WEIGHT_HEAVY:
275 m_weight = wxFONTWEIGHT_BOLD;
276 break;
277 }
278
279 if (m_faceName == wxT("monospace"))
280 {
281 m_family = wxFONTFAMILY_TELETYPE;
282 }
283 else if (m_faceName == wxT("sans"))
284 {
285 m_family = wxFONTFAMILY_SWISS;
286 }
287 else if (m_faceName == wxT("serif"))
288 {
289 m_family = wxFONTFAMILY_ROMAN;
290 }
291 else
292 {
293 m_family = wxFONTFAMILY_UNKNOWN;
294 }
295
296 // Pango description are never underlined (?)
297 m_underlined = FALSE;
298
299 // Cannot we choose that
300 m_encoding = wxFONTENCODING_SYSTEM;
301 #else // GTK 1.x
302 // get the font parameters from the XLFD
303 // -------------------------------------
304
305 m_faceName = m_nativeFontInfo.GetXFontComponent(wxXLFD_FAMILY);
306
307 m_weight = wxFONTWEIGHT_NORMAL;
308
309 wxString w = m_nativeFontInfo.GetXFontComponent(wxXLFD_WEIGHT).Upper();
310 if ( !w.empty() && w != _T('*') )
311 {
312 // the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
313 // and BLACK
314 if ( ((w[0u] == _T('B') && (!wxStrcmp(w.c_str() + 1, wxT("OLD")) ||
315 !wxStrcmp(w.c_str() + 1, wxT("LACK"))))) ||
316 wxStrstr(w.c_str() + 1, _T("BOLD")) )
317 {
318 m_weight = wxFONTWEIGHT_BOLD;
319 }
320 else if ( w == _T("LIGHT") || w == _T("THIN") )
321 {
322 m_weight = wxFONTWEIGHT_LIGHT;
323 }
324 }
325
326 switch ( wxToupper(*m_nativeFontInfo.
327 GetXFontComponent(wxXLFD_SLANT).c_str()) )
328 {
329 case _T('I'): // italique
330 m_style = wxFONTSTYLE_ITALIC;
331 break;
332
333 case _T('O'): // oblique
334 m_style = wxFONTSTYLE_SLANT;
335 break;
336
337 default:
338 m_style = wxFONTSTYLE_NORMAL;
339 }
340
341 long ptSize;
342 if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_POINTSIZE).ToLong(&ptSize) )
343 {
344 // size in XLFD is in 10 point units
345 m_pointSize = (int)(ptSize / 10);
346 }
347 else
348 {
349 m_pointSize = wxDEFAULT_FONT_SIZE;
350 }
351
352 // examine the spacing: if the font is monospaced, assume wxTELETYPE
353 // family for compatibility with the old code which used it instead of
354 // IsFixedWidth()
355 if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING).Upper() == _T('M') )
356 {
357 m_family = wxFONTFAMILY_TELETYPE;
358 }
359 else // not monospaceed
360 {
361 // don't even try guessing it, it doesn't work for too many fonts
362 // anyhow
363 m_family = wxFONTFAMILY_UNKNOWN;
364 }
365
366 // X fonts are never underlined...
367 m_underlined = FALSE;
368
369 // deal with font encoding
370 wxString
371 registry = m_nativeFontInfo.GetXFontComponent(wxXLFD_REGISTRY).Upper(),
372 encoding = m_nativeFontInfo.GetXFontComponent(wxXLFD_ENCODING).Upper();
373
374 if ( registry == _T("ISO8859") )
375 {
376 int cp;
377 if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
378 {
379 m_encoding = (wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
380 }
381 }
382 else if ( registry == _T("MICROSOFT") )
383 {
384 int cp;
385 if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
386 {
387 m_encoding = (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
388 }
389 }
390 else if ( registry == _T("KOI8") )
391 {
392 m_encoding = wxFONTENCODING_KOI8;
393 }
394 else // unknown encoding
395 {
396 // may be give a warning here? or use wxFontMapper?
397 m_encoding = wxFONTENCODING_SYSTEM;
398 }
399 #endif // GTK 2.0/1.x
400 }
401
402 wxFontRefData::wxFontRefData( const wxFontRefData& data )
403 : wxObjectRefData()
404 {
405 m_pointSize = data.m_pointSize;
406 m_family = data.m_family;
407 m_style = data.m_style;
408 m_weight = data.m_weight;
409
410 m_underlined = data.m_underlined;
411
412 m_faceName = data.m_faceName;
413 m_encoding = data.m_encoding;
414
415 m_noAA = data.m_noAA;
416
417 // Forces a copy of the internal data. wxNativeFontInfo should probably
418 // have a copy ctor and assignment operator to fix this properly but that
419 // would break binary compatibility...
420 m_nativeFontInfo.FromString(data.m_nativeFontInfo.ToString());
421 }
422
423 wxFontRefData::wxFontRefData(int size, int family, int style,
424 int weight, bool underlined,
425 const wxString& faceName,
426 wxFontEncoding encoding)
427 {
428 Init(size, family, style, weight, underlined, faceName, encoding);
429 }
430
431 wxFontRefData::wxFontRefData(const wxString& fontname)
432 {
433 // VZ: FromString() should really work in both cases, doesn't it?
434 #ifdef __WXGTK20__
435 m_nativeFontInfo.FromString( fontname );
436 #else // GTK 1.x
437 m_nativeFontInfo.SetXFontName(fontname);
438 #endif // GTK 2.0/1.x
439
440 InitFromNative();
441 }
442
443 void wxFontRefData::ReInit(const wxString& fontname)
444 {
445 m_nativeFontInfo.SetXFontName(fontname);
446
447 InitFromNative();
448 }
449
450 void wxFontRefData::ClearGdkFonts()
451 {
452 #ifndef __WXGTK20__
453 for ( wxScaledFontList::iterator i = m_scaled_xfonts.begin();
454 i != m_scaled_xfonts.end();
455 ++i )
456 {
457 GdkFont *font = i->second;
458 gdk_font_unref( font );
459 }
460
461 m_scaled_xfonts.clear();
462 #endif // GTK 1.x
463 }
464
465 wxFontRefData::~wxFontRefData()
466 {
467 ClearGdkFonts();
468 }
469
470 // ----------------------------------------------------------------------------
471 // wxFontRefData SetXXX()
472 // ----------------------------------------------------------------------------
473
474 void wxFontRefData::SetPointSize(int pointSize)
475 {
476 m_pointSize = pointSize;
477
478 #ifdef __WXGTK20__
479 // Get native info
480 PangoFontDescription *desc = m_nativeFontInfo.description;
481
482 pango_font_description_set_size( desc, m_pointSize * PANGO_SCALE );
483 #else
484 if ( HasNativeFont() )
485 {
486 wxString size;
487 if ( pointSize == -1 )
488 size = _T('*');
489 else
490 size.Printf(_T("%d"), 10*pointSize);
491
492 m_nativeFontInfo.SetXFontComponent(wxXLFD_POINTSIZE, size);
493 }
494 #endif
495 }
496
497 void wxFontRefData::SetFamily(int family)
498 {
499 m_family = family;
500
501 // TODO: what are we supposed to do with m_nativeFontInfo here?
502 }
503
504 void wxFontRefData::SetStyle(int style)
505 {
506 m_style = style;
507
508 #ifdef __WXGTK20__
509 // Get native info
510 PangoFontDescription *desc = m_nativeFontInfo.description;
511
512 switch ( style )
513 {
514 case wxFONTSTYLE_ITALIC:
515 pango_font_description_set_style( desc, PANGO_STYLE_ITALIC );
516 break;
517 case wxFONTSTYLE_SLANT:
518 pango_font_description_set_style( desc, PANGO_STYLE_OBLIQUE );
519 break;
520 default:
521 wxFAIL_MSG( _T("unknown font style") );
522 // fall through
523 case wxFONTSTYLE_NORMAL:
524 pango_font_description_set_style( desc, PANGO_STYLE_NORMAL );
525 break;
526 }
527 #else
528 if ( HasNativeFont() )
529 {
530 wxString slant;
531 switch ( style )
532 {
533 case wxFONTSTYLE_ITALIC:
534 slant = _T('i');
535 break;
536
537 case wxFONTSTYLE_SLANT:
538 slant = _T('o');
539 break;
540
541 default:
542 wxFAIL_MSG( _T("unknown font style") );
543 // fall through
544
545 case wxFONTSTYLE_NORMAL:
546 slant = _T('r');
547 }
548
549 m_nativeFontInfo.SetXFontComponent(wxXLFD_SLANT, slant);
550 }
551 #endif
552 }
553
554 void wxFontRefData::SetWeight(int weight)
555 {
556 m_weight = weight;
557
558 #ifdef __WXGTK20__
559 PangoFontDescription *desc = m_nativeFontInfo.description;
560 switch ( weight )
561 {
562 case wxFONTWEIGHT_BOLD:
563 pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD);
564 break;
565
566 case wxFONTWEIGHT_LIGHT:
567 pango_font_description_set_weight(desc, PANGO_WEIGHT_LIGHT);
568 break;
569
570 default:
571 wxFAIL_MSG( _T("unknown font weight") );
572 // fall through
573
574 case wxFONTWEIGHT_NORMAL:
575 // unspecified
576 pango_font_description_set_weight(desc, PANGO_WEIGHT_NORMAL);
577 }
578 #else //!__WXGTK20__
579 if ( HasNativeFont() )
580 {
581 wxString boldness;
582 switch ( weight )
583 {
584 case wxFONTWEIGHT_BOLD:
585 boldness = _T("bold");
586 break;
587
588 case wxFONTWEIGHT_LIGHT:
589 boldness = _T("light");
590 break;
591
592 default:
593 wxFAIL_MSG( _T("unknown font weight") );
594 // fall through
595
596 case wxFONTWEIGHT_NORMAL:
597 // unspecified
598 boldness = _T("medium");
599 }
600
601 m_nativeFontInfo.SetXFontComponent(wxXLFD_WEIGHT, boldness);
602 }
603 #endif
604 }
605
606 void wxFontRefData::SetUnderlined(bool underlined)
607 {
608 m_underlined = underlined;
609
610 // the XLFD doesn't have "underlined" field anyhow
611 }
612
613 void wxFontRefData::SetFaceName(const wxString& facename)
614 {
615 m_faceName = facename;
616
617 #ifndef __WXGTK20__
618 if ( HasNativeFont() )
619 {
620 m_nativeFontInfo.SetXFontComponent(wxXLFD_FAMILY, facename);
621 }
622 #endif
623 }
624
625 void wxFontRefData::SetEncoding(wxFontEncoding encoding)
626 {
627 m_encoding = encoding;
628
629 #ifndef __WXGTK20__
630 if ( HasNativeFont() )
631 {
632 wxNativeEncodingInfo info;
633 if ( wxGetNativeFontEncoding(encoding, &info) )
634 {
635 m_nativeFontInfo.SetXFontComponent(wxXLFD_REGISTRY, info.xregistry);
636 m_nativeFontInfo.SetXFontComponent(wxXLFD_ENCODING, info.xencoding);
637 }
638 }
639 #endif
640 }
641
642 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
643 {
644 // previously cached fonts shouldn't be used
645 ClearGdkFonts();
646
647 m_nativeFontInfo = info;
648
649 // set all the other font parameters from the native font info
650 InitFromNative();
651 }
652
653 // ----------------------------------------------------------------------------
654 // wxFont creation
655 // ----------------------------------------------------------------------------
656
657 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
658
659 void wxFont::Init()
660 {
661 }
662
663 wxFont::wxFont(const wxNativeFontInfo& info)
664 {
665 Init();
666
667 #ifdef __WXGTK20__
668 Create( info.GetPointSize(),
669 info.GetFamily(),
670 info.GetStyle(),
671 info.GetWeight(),
672 info.GetUnderlined(),
673 info.GetFaceName(),
674 info.GetEncoding() );
675 #else
676 (void) Create(info.GetXFontName());
677 #endif
678 }
679
680 bool wxFont::Create( int pointSize,
681 int family,
682 int style,
683 int weight,
684 bool underlined,
685 const wxString& face,
686 wxFontEncoding encoding)
687 {
688 UnRef();
689
690 m_refData = new wxFontRefData(pointSize, family, style, weight,
691 underlined, face, encoding);
692
693 return TRUE;
694 }
695
696 bool wxFont::Create(const wxString& fontname)
697 {
698 // VZ: does this really happen?
699 if ( fontname.empty() )
700 {
701 *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
702
703 return TRUE;
704 }
705
706 m_refData = new wxFontRefData(fontname);
707
708 return TRUE;
709 }
710
711 void wxFont::Unshare()
712 {
713 if (!m_refData)
714 {
715 m_refData = new wxFontRefData();
716 }
717 else
718 {
719 wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
720 UnRef();
721 m_refData = ref;
722 }
723 }
724
725 wxFont::~wxFont()
726 {
727 }
728
729 // ----------------------------------------------------------------------------
730 // accessors
731 // ----------------------------------------------------------------------------
732
733 int wxFont::GetPointSize() const
734 {
735 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
736
737 return M_FONTDATA->m_pointSize;
738 }
739
740 wxString wxFont::GetFaceName() const
741 {
742 wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
743
744 return M_FONTDATA->m_faceName;
745 }
746
747 int wxFont::GetFamily() const
748 {
749 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
750
751 return M_FONTDATA->m_family;
752 }
753
754 int wxFont::GetStyle() const
755 {
756 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
757
758 return M_FONTDATA->m_style;
759 }
760
761 int wxFont::GetWeight() const
762 {
763 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
764
765 return M_FONTDATA->m_weight;
766 }
767
768 bool wxFont::GetUnderlined() const
769 {
770 wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
771
772 return M_FONTDATA->m_underlined;
773 }
774
775 wxFontEncoding wxFont::GetEncoding() const
776 {
777 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
778
779 return M_FONTDATA->m_encoding;
780 }
781
782 bool wxFont::GetNoAntiAliasing()
783 {
784 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
785
786 return M_FONTDATA->m_noAA;
787 }
788
789 wxNativeFontInfo *wxFont::GetNativeFontInfo() const
790 {
791 wxCHECK_MSG( Ok(), (wxNativeFontInfo *)NULL, wxT("invalid font") );
792
793 #ifndef __WXGTK20__
794 if ( M_FONTDATA->m_nativeFontInfo.GetXFontName().empty() )
795 GetInternalFont();
796 #endif
797
798 return new wxNativeFontInfo(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 ( 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 if ( font )
964 {
965 M_FONTDATA->ReInit(xfontname);
966 }
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