]> git.saurik.com Git - wxWidgets.git/blob - src/x11/font.cpp
Fix install_name_tool calls in OS X "make install".
[wxWidgets.git] / src / x11 / font.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/x11/font.cpp
3 // Purpose: wxFont class
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 17/09/98
7 // Copyright: (c) Julian Smart
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // for compilers that support precompilation, includes "wx.h".
12 #include "wx/wxprec.h"
13
14 // ============================================================================
15 // declarations
16 // ============================================================================
17
18 // ----------------------------------------------------------------------------
19 // headers
20 // ----------------------------------------------------------------------------
21
22 #ifdef __VMS
23 #pragma message disable nosimpint
24 #include "wx/vms_x_fix.h"
25 #endif
26
27 #ifdef __VMS
28 #pragma message enable nosimpint
29 #endif
30
31 #include "wx/font.h"
32
33 #ifndef WX_PRECOMP
34 #include "wx/string.h"
35 #include "wx/utils.h" // for wxGetDisplay()
36 #include "wx/settings.h"
37 #include "wx/gdicmn.h"
38 #endif
39
40 #include "wx/fontutil.h" // for wxNativeFontInfo
41 #include "wx/tokenzr.h"
42 #include "wx/fontenum.h"
43
44 #include "wx/x11/private.h"
45
46 // ----------------------------------------------------------------------------
47 // constants
48 // ----------------------------------------------------------------------------
49
50 // the default size (in points) for the fonts
51 static const int wxDEFAULT_FONT_SIZE = 12;
52
53
54 #if wxUSE_UNICODE
55 #else
56 // ----------------------------------------------------------------------------
57 // wxXFont
58 // ----------------------------------------------------------------------------
59
60 // For every wxFont, there must be a font for each display and scale requested.
61 // So these objects are stored in wxFontRefData::m_fonts
62 class wxXFont : public wxObject
63 {
64 public:
65 wxXFont();
66 virtual ~wxXFont();
67
68 WXFontStructPtr m_fontStruct; // XFontStruct
69 WXDisplay* m_display; // XDisplay
70 int m_scale; // Scale * 100
71 };
72
73 wxXFont::wxXFont()
74 {
75 m_fontStruct = (WXFontStructPtr) 0;
76 m_display = (WXDisplay*) 0;
77 m_scale = 100;
78 }
79
80 wxXFont::~wxXFont()
81 {
82 // Freeing the font used to produce a segv, but
83 // appears to be OK now (bug fix in X11?)
84 XFontStruct* fontStruct = (XFontStruct*) m_fontStruct;
85 XFreeFont((Display*) m_display, fontStruct);
86 }
87 #endif
88
89 // ----------------------------------------------------------------------------
90 // wxFontRefData
91 // ----------------------------------------------------------------------------
92
93 class wxFontRefData: public wxGDIRefData
94 {
95 friend class wxFont;
96
97 public:
98 wxFontRefData(int size = wxDEFAULT,
99 wxFontFamily family = wxFONTFAMILY_DEFAULT,
100 wxFontStyle style = wxFONTSTYLE_NORMAL,
101 wxFontWeight weight = wxFONTWEIGHT_NORMAL,
102 bool underlined = false,
103 const wxString& faceName = wxEmptyString,
104 wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
105
106 // copy cstr
107 wxFontRefData(const wxFontRefData& data);
108
109 // from XFLD
110 wxFontRefData(const wxString& fontname);
111
112 // dstr
113 virtual ~wxFontRefData();
114
115 // setters: all of them also take care to modify m_nativeFontInfo if we
116 // have it so as to not lose the information not carried by our fields
117 void SetPointSize(int pointSize);
118 void SetFamily(wxFontFamily family);
119 void SetStyle(wxFontStyle style);
120 void SetWeight(wxFontWeight weight);
121 void SetUnderlined(bool underlined);
122 bool SetFaceName(const wxString& facename);
123 void SetEncoding(wxFontEncoding encoding);
124
125 // and this one also modifies all the other font data fields
126 void SetNativeFontInfo(const wxNativeFontInfo& info);
127
128 protected:
129 // common part of all ctors
130 void Init(int size,
131 wxFontFamily family,
132 wxFontStyle style,
133 wxFontWeight 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 // font attributes
142 int m_pointSize;
143 wxFontFamily m_family;
144 wxFontStyle m_style;
145 wxFontWeight m_weight;
146 bool m_underlined;
147 wxString m_faceName;
148 wxFontEncoding m_encoding; // Unused in Unicode mode
149
150 wxNativeFontInfo m_nativeFontInfo;
151
152 void ClearX11Fonts();
153
154 #if wxUSE_UNICODE
155 #else
156 // A list of wxXFonts
157 wxList m_fonts;
158 #endif
159 };
160
161 #define M_FONTDATA ((wxFontRefData*)m_refData)
162
163 // ----------------------------------------------------------------------------
164 // wxFontRefData
165 // ----------------------------------------------------------------------------
166
167 void wxFontRefData::Init(int pointSize,
168 wxFontFamily family,
169 wxFontStyle style,
170 wxFontWeight weight,
171 bool underlined,
172 const wxString& faceName,
173 wxFontEncoding encoding)
174 {
175 m_family = family == wxFONTFAMILY_DEFAULT ? wxFONTFAMILY_SWISS : family;
176
177 m_faceName = faceName;
178
179 // we accept both wxDEFAULT and wxNORMAL here - should we?
180 m_style = style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style;
181 m_weight = weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight;
182
183 m_underlined = underlined;
184 m_encoding = encoding;
185
186 #if wxUSE_UNICODE
187 if ( m_nativeFontInfo.description )
188 pango_font_description_free(m_nativeFontInfo.description);
189
190 // Create native font info
191 m_nativeFontInfo.description = pango_font_description_new();
192
193 // if a face name is specified, use it if it's available, otherwise use
194 // just the family
195 if ( faceName.empty() || !wxFontEnumerator::IsValidFacename(faceName) )
196 {
197 // TODO: scan system for valid fonts matching the given family instead
198 // of hardcoding them here
199 switch ( m_family )
200 {
201 case wxFONTFAMILY_TELETYPE:
202 m_faceName = wxT("monospace");
203 break;
204
205 case wxFONTFAMILY_ROMAN:
206 m_faceName = wxT("serif");
207 break;
208
209 default:
210 m_faceName = wxT("sans");
211 }
212 }
213 else // specified face name is available, use it
214 {
215 m_faceName = faceName;
216 }
217
218 m_nativeFontInfo.SetFaceName(m_faceName);
219 m_nativeFontInfo.SetWeight((wxFontWeight)m_weight);
220 m_nativeFontInfo.SetStyle((wxFontStyle)m_style);
221 #endif // wxUSE_UNICODE
222
223 SetPointSize(pointSize);
224 }
225
226 void wxFontRefData::InitFromNative()
227 {
228 #if wxUSE_UNICODE
229 // Get native info
230 PangoFontDescription *desc = m_nativeFontInfo.description;
231
232 // init fields
233 m_faceName = wxGTK_CONV_BACK( pango_font_description_get_family( desc ) );
234
235 m_pointSize = pango_font_description_get_size( desc ) / PANGO_SCALE;
236
237 switch (pango_font_description_get_style( desc ))
238 {
239 case PANGO_STYLE_NORMAL:
240 m_style = wxFONTSTYLE_NORMAL;
241 break;
242 case PANGO_STYLE_ITALIC:
243 m_style = wxFONTSTYLE_ITALIC;
244 break;
245 case PANGO_STYLE_OBLIQUE:
246 m_style = wxFONTSTYLE_SLANT;
247 break;
248 }
249
250 // Not defined in some Pango versions
251 #define wxPANGO_WEIGHT_SEMIBOLD 600
252
253 switch (pango_font_description_get_weight( desc ))
254 {
255 case PANGO_WEIGHT_ULTRALIGHT:
256 case PANGO_WEIGHT_LIGHT:
257 m_weight = wxFONTWEIGHT_LIGHT;
258 break;
259
260 default:
261 wxFAIL_MSG(wxT("unknown Pango font weight"));
262 // fall through
263
264 case PANGO_WEIGHT_NORMAL:
265 m_weight = wxFONTWEIGHT_NORMAL;
266 break;
267
268 case wxPANGO_WEIGHT_SEMIBOLD:
269 case PANGO_WEIGHT_BOLD:
270 case PANGO_WEIGHT_ULTRABOLD:
271 case PANGO_WEIGHT_HEAVY:
272 m_weight = wxFONTWEIGHT_BOLD;
273 break;
274 }
275
276 if (m_faceName == wxT("monospace"))
277 {
278 m_family = wxFONTFAMILY_TELETYPE;
279 }
280 else if (m_faceName == wxT("sans"))
281 {
282 m_family = wxFONTFAMILY_SWISS;
283 }
284 else
285 {
286 m_family = wxFONTFAMILY_UNKNOWN;
287 }
288
289 // Pango description are never underlined (?)
290 m_underlined = false;
291
292 // Cannot we choose that
293 m_encoding = wxFONTENCODING_SYSTEM;
294 #else // X11
295 // get the font parameters from the XLFD
296 // -------------------------------------
297
298 m_faceName = m_nativeFontInfo.GetXFontComponent(wxXLFD_FAMILY);
299
300 m_weight = wxFONTWEIGHT_NORMAL;
301
302 wxString w = m_nativeFontInfo.GetXFontComponent(wxXLFD_WEIGHT).Upper();
303 if ( !w.empty() && w != wxT('*') )
304 {
305 // the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
306 // and BLACK
307 if ( ((w[0u] == wxT('B') && (!wxStrcmp(w.c_str() + 1, wxT("OLD")) ||
308 !wxStrcmp(w.c_str() + 1, wxT("LACK"))))) ||
309 wxStrstr(w.c_str() + 1, wxT("BOLD")) )
310 {
311 m_weight = wxFONTWEIGHT_BOLD;
312 }
313 else if ( w == wxT("LIGHT") || w == wxT("THIN") )
314 {
315 m_weight = wxFONTWEIGHT_LIGHT;
316 }
317 }
318
319 switch ( wxToupper( m_nativeFontInfo.
320 GetXFontComponent(wxXLFD_SLANT)[0u]).GetValue() )
321 {
322 case wxT('I'): // italique
323 m_style = wxFONTSTYLE_ITALIC;
324 break;
325
326 case wxT('O'): // oblique
327 m_style = wxFONTSTYLE_SLANT;
328 break;
329
330 default:
331 m_style = wxFONTSTYLE_NORMAL;
332 }
333
334 long ptSize;
335 if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_POINTSIZE).ToLong(&ptSize) )
336 {
337 // size in XLFD is in 10 point units
338 m_pointSize = (int)(ptSize / 10);
339 }
340 else
341 {
342 m_pointSize = wxDEFAULT_FONT_SIZE;
343 }
344
345 // examine the spacing: if the font is monospaced, assume wxTELETYPE
346 // family for compatibility with the old code which used it instead of
347 // IsFixedWidth()
348 if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING).Upper() == wxT('M') )
349 {
350 m_family = wxFONTFAMILY_TELETYPE;
351 }
352 else // not monospaceed
353 {
354 // don't even try guessing it, it doesn't work for too many fonts
355 // anyhow
356 m_family = wxFONTFAMILY_UNKNOWN;
357 }
358
359 // X fonts are never underlined...
360 m_underlined = false;
361
362 // deal with font encoding
363 wxString
364 registry = m_nativeFontInfo.GetXFontComponent(wxXLFD_REGISTRY).Upper(),
365 encoding = m_nativeFontInfo.GetXFontComponent(wxXLFD_ENCODING).Upper();
366
367 if ( registry == wxT("ISO8859") )
368 {
369 int cp;
370 if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
371 {
372 m_encoding = (wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
373 }
374 }
375 else if ( registry == wxT("MICROSOFT") )
376 {
377 int cp;
378 if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
379 {
380 m_encoding = (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
381 }
382 }
383 else if ( registry == wxT("KOI8") )
384 {
385 m_encoding = wxFONTENCODING_KOI8;
386 }
387 else // unknown encoding
388 {
389 // may be give a warning here? or use wxFontMapper?
390 m_encoding = wxFONTENCODING_SYSTEM;
391 }
392 #endif // Pango/X11
393 }
394
395 wxFontRefData::wxFontRefData( const wxFontRefData& data )
396 : wxGDIRefData()
397 {
398 m_pointSize = data.m_pointSize;
399 m_family = data.m_family;
400 m_style = data.m_style;
401 m_weight = data.m_weight;
402
403 m_underlined = data.m_underlined;
404
405 m_faceName = data.m_faceName;
406 m_encoding = data.m_encoding;
407
408 m_nativeFontInfo = data.m_nativeFontInfo;
409 }
410
411 wxFontRefData::wxFontRefData(int size, wxFontFamily family, wxFontStyle style,
412 wxFontWeight weight, bool underlined,
413 const wxString& faceName,
414 wxFontEncoding encoding)
415 {
416 Init(size, family, style, weight, underlined, faceName, encoding);
417 }
418
419 wxFontRefData::wxFontRefData(const wxString& fontname)
420 {
421 // VZ: FromString() should really work in both cases, doesn't it?
422 #if wxUSE_UNICODE
423 m_nativeFontInfo.FromString( fontname );
424 #else
425 m_nativeFontInfo.SetXFontName(fontname);
426 #endif
427
428 InitFromNative();
429 }
430
431 void wxFontRefData::ClearX11Fonts()
432 {
433 #if wxUSE_UNICODE
434 #else
435 wxList::compatibility_iterator node = m_fonts.GetFirst();
436 while (node)
437 {
438 wxXFont* f = (wxXFont*) node->GetData();
439 delete f;
440 node = node->GetNext();
441 }
442 m_fonts.Clear();
443 #endif
444 }
445
446 wxFontRefData::~wxFontRefData()
447 {
448 ClearX11Fonts();
449 }
450
451 // ----------------------------------------------------------------------------
452 // wxFontRefData SetXXX()
453 // ----------------------------------------------------------------------------
454
455 void wxFontRefData::SetPointSize(int pointSize)
456 {
457 // NB: Pango doesn't support point sizes less than 1
458 m_pointSize = pointSize == wxDEFAULT || pointSize < 1 ? wxDEFAULT_FONT_SIZE
459 : pointSize;
460
461 #if wxUSE_UNICODE
462 m_nativeFontInfo.SetPointSize(m_pointSize);
463 #endif
464 }
465
466 void wxFontRefData::SetFamily(wxFontFamily family)
467 {
468 m_family = family;
469
470 // TODO: what are we supposed to do with m_nativeFontInfo here?
471 }
472
473 void wxFontRefData::SetStyle(wxFontStyle style)
474 {
475 m_style = style;
476
477 #if wxUSE_UNICODE
478 // Get native info
479 PangoFontDescription *desc = m_nativeFontInfo.description;
480
481 switch ( style )
482 {
483 case wxFONTSTYLE_ITALIC:
484 pango_font_description_set_style( desc, PANGO_STYLE_ITALIC );
485 break;
486 case wxFONTSTYLE_SLANT:
487 pango_font_description_set_style( desc, PANGO_STYLE_OBLIQUE );
488 break;
489 default:
490 wxFAIL_MSG( wxT("unknown font style") );
491 // fall through
492 case wxFONTSTYLE_NORMAL:
493 pango_font_description_set_style( desc, PANGO_STYLE_NORMAL );
494 break;
495 }
496 #endif
497 }
498
499 void wxFontRefData::SetWeight(wxFontWeight weight)
500 {
501 m_weight = weight;
502 }
503
504 void wxFontRefData::SetUnderlined(bool underlined)
505 {
506 m_underlined = underlined;
507
508 // the XLFD doesn't have "underlined" field anyhow
509 }
510
511 bool wxFontRefData::SetFaceName(const wxString& facename)
512 {
513 m_faceName = facename;
514 return true;
515 }
516
517 void wxFontRefData::SetEncoding(wxFontEncoding encoding)
518 {
519 m_encoding = encoding;
520 }
521
522 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
523 {
524 // previously cached fonts shouldn't be used
525 ClearX11Fonts();
526
527 m_nativeFontInfo = info;
528
529 // set all the other font parameters from the native font info
530 InitFromNative();
531 }
532
533 // ----------------------------------------------------------------------------
534 // wxFont
535 // ----------------------------------------------------------------------------
536
537 wxFont::wxFont(const wxNativeFontInfo& info)
538 {
539 #if wxUSE_UNICODE
540 Create( info.GetPointSize(),
541 info.GetFamily(),
542 info.GetStyle(),
543 info.GetWeight(),
544 info.GetUnderlined(),
545 info.GetFaceName(),
546 info.GetEncoding() );
547 #else
548 (void) Create(info.GetXFontName());
549 #endif
550 }
551
552 bool wxFont::Create(int pointSize,
553 wxFontFamily family,
554 wxFontStyle style,
555 wxFontWeight weight,
556 bool underlined,
557 const wxString& faceName,
558 wxFontEncoding encoding)
559 {
560 UnRef();
561
562 m_refData = new wxFontRefData(pointSize, family, style, weight,
563 underlined, faceName, encoding);
564
565 return true;
566 }
567
568 #if !wxUSE_UNICODE
569
570 bool wxFont::Create(const wxString& fontname, wxFontEncoding enc)
571 {
572 if( !fontname )
573 {
574 *this = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT);
575 return true;
576 }
577
578 m_refData = new wxFontRefData();
579
580 M_FONTDATA->m_nativeFontInfo.SetXFontName(fontname); // X font name
581
582 wxString tmp;
583
584 wxStringTokenizer tn( fontname, wxT("-") );
585
586 tn.GetNextToken(); // skip initial empty token
587 tn.GetNextToken(); // foundry
588
589
590 M_FONTDATA->m_faceName = tn.GetNextToken(); // family
591
592 tmp = tn.GetNextToken().MakeUpper(); // weight
593 if (tmp == wxT("BOLD")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
594 if (tmp == wxT("BLACK")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
595 if (tmp == wxT("EXTRABOLD")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
596 if (tmp == wxT("DEMIBOLD")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
597 if (tmp == wxT("ULTRABOLD")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
598
599 if (tmp == wxT("LIGHT")) M_FONTDATA->m_weight = wxFONTWEIGHT_LIGHT;
600 if (tmp == wxT("THIN")) M_FONTDATA->m_weight = wxFONTWEIGHT_LIGHT;
601
602 tmp = tn.GetNextToken().MakeUpper(); // slant
603 if (tmp == wxT("I")) M_FONTDATA->m_style = wxFONTSTYLE_ITALIC;
604 if (tmp == wxT("O")) M_FONTDATA->m_style = wxFONTSTYLE_ITALIC;
605
606 tn.GetNextToken(); // set width
607 tn.GetNextToken(); // add. style
608 tn.GetNextToken(); // pixel size
609
610 tmp = tn.GetNextToken(); // pointsize
611 if (tmp != wxT("*"))
612 {
613 long num = wxStrtol (tmp.c_str(), (wxChar **) NULL, 10);
614 M_FONTDATA->m_pointSize = (int)(num / 10);
615 }
616
617 tn.GetNextToken(); // x-res
618 tn.GetNextToken(); // y-res
619
620 tmp = tn.GetNextToken().MakeUpper(); // spacing
621
622 if (tmp == wxT("M"))
623 M_FONTDATA->m_family = wxFONTFAMILY_MODERN;
624 else if (M_FONTDATA->m_faceName == wxT("TIMES"))
625 M_FONTDATA->m_family = wxFONTFAMILY_ROMAN;
626 else if (M_FONTDATA->m_faceName == wxT("HELVETICA"))
627 M_FONTDATA->m_family = wxFONTFAMILY_SWISS;
628 else if (M_FONTDATA->m_faceName == wxT("LUCIDATYPEWRITER"))
629 M_FONTDATA->m_family = wxFONTFAMILY_TELETYPE;
630 else if (M_FONTDATA->m_faceName == wxT("LUCIDA"))
631 M_FONTDATA->m_family = wxFONTFAMILY_DECORATIVE;
632 else if (M_FONTDATA->m_faceName == wxT("UTOPIA"))
633 M_FONTDATA->m_family = wxFONTFAMILY_SCRIPT;
634
635 tn.GetNextToken(); // avg width
636
637 // deal with font encoding
638 M_FONTDATA->m_encoding = enc;
639 if ( M_FONTDATA->m_encoding == wxFONTENCODING_SYSTEM )
640 {
641 wxString registry = tn.GetNextToken().MakeUpper(),
642 encoding = tn.GetNextToken().MakeUpper();
643
644 if ( registry == wxT("ISO8859") )
645 {
646 int cp;
647 if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
648 {
649 M_FONTDATA->m_encoding =
650 (wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
651 }
652 }
653 else if ( registry == wxT("MICROSOFT") )
654 {
655 int cp;
656 if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
657 {
658 M_FONTDATA->m_encoding =
659 (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
660 }
661 }
662 else if ( registry == wxT("KOI8") )
663 {
664 M_FONTDATA->m_encoding = wxFONTENCODING_KOI8;
665 }
666 //else: unknown encoding - may be give a warning here?
667 else
668 return false;
669 }
670 return true;
671 }
672 #endif // !wxUSE_UNICODE
673
674 wxFont::~wxFont()
675 {
676 }
677
678 wxGDIRefData *wxFont::CreateGDIRefData() const
679 {
680 return new wxFontRefData;
681 }
682
683 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
684 {
685 return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
686 }
687
688 // ----------------------------------------------------------------------------
689 // change the font attributes
690 // ----------------------------------------------------------------------------
691
692 void wxFont::Unshare()
693 {
694 // Don't change shared data
695 if (!m_refData)
696 {
697 m_refData = new wxFontRefData();
698 }
699 else
700 {
701 wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
702 UnRef();
703 m_refData = ref;
704 }
705 }
706
707 // ----------------------------------------------------------------------------
708 // accessors
709 // ----------------------------------------------------------------------------
710
711 int wxFont::GetPointSize() const
712 {
713 wxCHECK_MSG( IsOk(), 0, wxT("invalid font") );
714
715 return M_FONTDATA->m_pointSize;
716 }
717
718 wxString wxFont::GetFaceName() const
719 {
720 wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
721
722 return M_FONTDATA->m_faceName;
723 }
724
725 wxFontFamily wxFont::DoGetFamily() const
726 {
727 return M_FONTDATA->m_family;
728 }
729
730 wxFontStyle wxFont::GetStyle() const
731 {
732 wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") );
733
734 return M_FONTDATA->m_style;
735 }
736
737 wxFontWeight wxFont::GetWeight() const
738 {
739 wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") );
740
741 return M_FONTDATA->m_weight;
742 }
743
744 bool wxFont::GetUnderlined() const
745 {
746 wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
747
748 return M_FONTDATA->m_underlined;
749 }
750
751 wxFontEncoding wxFont::GetEncoding() const
752 {
753 wxCHECK_MSG( IsOk(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
754
755 return M_FONTDATA->m_encoding;
756 }
757
758 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
759 {
760 wxCHECK_MSG( IsOk(), NULL, wxT("invalid font") );
761
762 #if wxUSE_UNICODE
763 #else
764 if ( M_FONTDATA->m_nativeFontInfo.GetXFontName().empty() )
765 GetInternalFont();
766 #endif
767
768 return &(M_FONTDATA->m_nativeFontInfo);
769 }
770
771 bool wxFont::IsFixedWidth() const
772 {
773 wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
774
775 #if wxUSE_UNICODE
776 return wxFontBase::IsFixedWidth();
777 #else
778 // Robert, is this right? HasNativeFont doesn't exist.
779 if ( true )
780 // if ( M_FONTDATA->HasNativeFont() )
781 {
782 // the monospace fonts are supposed to have "M" in the spacing field
783 wxString spacing = M_FONTDATA->
784 m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING);
785
786 return spacing.Upper() == wxT('M');
787 }
788 // Unreaceable code for now
789 // return wxFontBase::IsFixedWidth();
790 #endif
791
792 }
793
794 // ----------------------------------------------------------------------------
795 // change font attributes
796 // ----------------------------------------------------------------------------
797
798 void wxFont::SetPointSize(int pointSize)
799 {
800 Unshare();
801
802 M_FONTDATA->SetPointSize(pointSize);
803 }
804
805 void wxFont::SetFamily(wxFontFamily family)
806 {
807 Unshare();
808
809 M_FONTDATA->SetFamily(family);
810 }
811
812 void wxFont::SetStyle(wxFontStyle style)
813 {
814 Unshare();
815
816 M_FONTDATA->SetStyle(style);
817 }
818
819 void wxFont::SetWeight(wxFontWeight weight)
820 {
821 Unshare();
822
823 M_FONTDATA->SetWeight(weight);
824 }
825
826 bool wxFont::SetFaceName(const wxString& faceName)
827 {
828 Unshare();
829
830 return M_FONTDATA->SetFaceName(faceName) &&
831 wxFontBase::SetFaceName(faceName);
832 }
833
834 void wxFont::SetUnderlined(bool underlined)
835 {
836 Unshare();
837
838 M_FONTDATA->SetUnderlined(underlined);
839 }
840
841 void wxFont::SetEncoding(wxFontEncoding encoding)
842 {
843 Unshare();
844
845 M_FONTDATA->SetEncoding(encoding);
846 }
847
848 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo& info )
849 {
850 Unshare();
851
852 M_FONTDATA->SetNativeFontInfo( info );
853 }
854
855 #if !wxUSE_UNICODE
856
857 // ----------------------------------------------------------------------------
858 // X11 implementation
859 // ----------------------------------------------------------------------------
860
861 // Find an existing, or create a new, XFontStruct
862 // based on this wxFont and the given scale. Append the
863 // font to list in the private data for future reference.
864 wxXFont* wxFont::GetInternalFont(double scale, WXDisplay* display) const
865 {
866 if ( !IsOk() )
867 return NULL;
868
869 long intScale = long(scale * 100.0 + 0.5); // key for wxXFont
870 int pointSize = (M_FONTDATA->m_pointSize * 10 * intScale) / 100;
871
872 // search existing fonts first
873 wxList::compatibility_iterator node = M_FONTDATA->m_fonts.GetFirst();
874 while (node)
875 {
876 wxXFont* f = (wxXFont*) node->GetData();
877 if ((!display || (f->m_display == display)) && (f->m_scale == intScale))
878 return f;
879 node = node->GetNext();
880 }
881
882 wxString xFontName = M_FONTDATA->m_nativeFontInfo.GetXFontName();
883 if (xFontName == "-*-*-*-*-*--*-*-*-*-*-*-*-*")
884 // wxFont constructor not called with native font info parameter => take M_FONTDATA values
885 xFontName.Clear();
886
887 // not found, create a new one
888 XFontStruct *font = (XFontStruct *)
889 wxLoadQueryNearestFont(pointSize,
890 M_FONTDATA->m_family,
891 M_FONTDATA->m_style,
892 M_FONTDATA->m_weight,
893 M_FONTDATA->m_underlined,
894 wxT(""),
895 M_FONTDATA->m_encoding,
896 & xFontName);
897
898 if ( !font )
899 {
900 wxFAIL_MSG( wxT("Could not allocate even a default font -- something is wrong.") );
901
902 return NULL;
903 }
904
905 wxXFont* f = new wxXFont;
906 f->m_fontStruct = (WXFontStructPtr)font;
907 f->m_display = ( display ? display : wxGetDisplay() );
908 f->m_scale = intScale;
909 M_FONTDATA->m_fonts.Append(f);
910
911 return f;
912 }
913
914 WXFontStructPtr wxFont::GetFontStruct(double scale, WXDisplay* display) const
915 {
916 wxXFont* f = GetInternalFont(scale, display);
917
918 return (f ? f->m_fontStruct : (WXFontStructPtr) 0);
919 }
920
921 #endif // !wxUSE_UNICODE