]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/font.cpp
compilation fix
[wxWidgets.git] / src / gtk1 / font.cpp
... / ...
CommitLineData
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
41static const int wxDEFAULT_FONT_SIZE = 12;
42
43// ----------------------------------------------------------------------------
44// wxScaledFontList: maps the font sizes to the GDK fonts for the given font
45// ----------------------------------------------------------------------------
46
47WX_DECLARE_HASH_MAP(int, GdkFont *, wxIntegerHash, wxIntegerEqual,
48 wxScaledFontList);
49
50// ----------------------------------------------------------------------------
51// wxFontRefData
52// ----------------------------------------------------------------------------
53
54class wxFontRefData : public wxObjectRefData
55{
56public:
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
122protected:
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
135private:
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
164void 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
225void 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
396wxFontRefData::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
417wxFontRefData::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
425wxFontRefData::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
437void 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
452wxFontRefData::~wxFontRefData()
453{
454 ClearGdkFonts();
455}
456
457// ----------------------------------------------------------------------------
458// wxFontRefData SetXXX()
459// ----------------------------------------------------------------------------
460
461void 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
484void wxFontRefData::SetFamily(int family)
485{
486 m_family = family;
487
488 // TODO: what are we supposed to do with m_nativeFontInfo here?
489}
490
491void 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
541void 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
593void wxFontRefData::SetUnderlined(bool underlined)
594{
595 m_underlined = underlined;
596
597 // the XLFD doesn't have "underlined" field anyhow
598}
599
600void 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
612void 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
629void 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
644IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
645
646void wxFont::Init()
647{
648}
649
650wxFont::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
667bool 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
683bool 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
698void 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
712wxFont::~wxFont()
713{
714}
715
716// ----------------------------------------------------------------------------
717// accessors
718// ----------------------------------------------------------------------------
719
720int wxFont::GetPointSize() const
721{
722 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
723
724 return M_FONTDATA->m_pointSize;
725}
726
727wxString wxFont::GetFaceName() const
728{
729 wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
730
731 return M_FONTDATA->m_faceName;
732}
733
734int wxFont::GetFamily() const
735{
736 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
737
738 return M_FONTDATA->m_family;
739}
740
741int wxFont::GetStyle() const
742{
743 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
744
745 return M_FONTDATA->m_style;
746}
747
748int wxFont::GetWeight() const
749{
750 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
751
752 return M_FONTDATA->m_weight;
753}
754
755bool wxFont::GetUnderlined() const
756{
757 wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
758
759 return M_FONTDATA->m_underlined;
760}
761
762wxFontEncoding wxFont::GetEncoding() const
763{
764 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
765
766 return M_FONTDATA->m_encoding;
767}
768
769bool wxFont::GetNoAntiAliasing()
770{
771 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
772
773 return M_FONTDATA->m_noAA;
774}
775
776wxNativeFontInfo *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
788bool 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
810void wxFont::SetPointSize(int pointSize)
811{
812 Unshare();
813
814 M_FONTDATA->SetPointSize(pointSize);
815}
816
817void wxFont::SetFamily(int family)
818{
819 Unshare();
820
821 M_FONTDATA->SetFamily(family);
822}
823
824void wxFont::SetStyle(int style)
825{
826 Unshare();
827
828 M_FONTDATA->SetStyle(style);
829}
830
831void wxFont::SetWeight(int weight)
832{
833 Unshare();
834
835 M_FONTDATA->SetWeight(weight);
836}
837
838void wxFont::SetFaceName(const wxString& faceName)
839{
840 Unshare();
841
842 M_FONTDATA->SetFaceName(faceName);
843}
844
845void wxFont::SetUnderlined(bool underlined)
846{
847 Unshare();
848
849 M_FONTDATA->SetUnderlined(underlined);
850}
851
852void wxFont::SetEncoding(wxFontEncoding encoding)
853{
854 Unshare();
855
856 M_FONTDATA->SetEncoding(encoding);
857}
858
859void wxFont::SetNativeFontInfo( const wxNativeFontInfo& info )
860{
861 Unshare();
862
863 M_FONTDATA->SetNativeFontInfo( info );
864}
865
866void wxFont::SetNoAntiAliasing( bool no )
867{
868 Unshare();
869
870 M_FONTDATA->SetNoAntiAliasing( no );
871}
872
873// ----------------------------------------------------------------------------
874// get internal representation of font
875// ----------------------------------------------------------------------------
876
877static GdkFont *g_systemDefaultGuiFont = (GdkFont*) NULL;
878
879// this is also used from tbargtk.cpp and tooltip.cpp, hence extern
880extern 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
907GdkFont *wxFont::GetInternalFont( float scale ) const
908{
909#ifdef __WXGTK20__
910 // Deprecated for GTK 2.0 and should be removed
911 // in the 2.5 tree.
912 wxFAIL_MSG( wxT("No longer used") );
913
914 return (GdkFont *) NULL;
915
916#else // GTK 1.x
917 GdkFont *font = (GdkFont *) NULL;
918
919 wxCHECK_MSG( Ok(), font, wxT("invalid font") )
920
921 long int_scale = long(scale * 100.0 + 0.5); // key for fontlist
922 int point_scale = (int)((M_FONTDATA->m_pointSize * 10 * int_scale) / 100);
923
924 wxScaledFontList& list = M_FONTDATA->m_scaled_xfonts;
925 wxScaledFontList::iterator i = list.find(int_scale);
926 if ( i != list.end() )
927 {
928 font = i->second;
929 }
930 else // we don't have this font in this size yet
931 {
932 if (*this == wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT))
933 {
934 font = GtkGetDefaultGuiFont();
935 }
936
937 if ( !font )
938 {
939 // do we have the XLFD?
940 if ( M_FONTDATA->HasNativeFont() )
941 {
942 font = wxLoadFont(M_FONTDATA->m_nativeFontInfo.GetXFontName());
943 }
944
945 // no XLFD of no exact match - try the approximate one now
946 if ( !font )
947 {
948 wxString xfontname;
949 font = wxLoadQueryNearestFont( point_scale,
950 M_FONTDATA->m_family,
951 M_FONTDATA->m_style,
952 M_FONTDATA->m_weight,
953 M_FONTDATA->m_underlined,
954 M_FONTDATA->m_faceName,
955 M_FONTDATA->m_encoding,
956 &xfontname);
957 if ( font )
958 {
959 M_FONTDATA->m_nativeFontInfo.SetXFontName(xfontname);
960 }
961 }
962 }
963
964 if ( font )
965 {
966 list[int_scale] = font;
967 }
968 }
969
970 // it's quite useless to make it a wxCHECK because we're going to crash
971 // anyhow...
972 wxASSERT_MSG( font, wxT("could not load any font?") );
973
974 return font;
975#endif // GTK 2.0/1.x
976}
977