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