]> git.saurik.com Git - wxWidgets.git/blob - src/msw/font.cpp
d7fcfe9b9f6b995f4843bfa17c39883ed5442f07
[wxWidgets.git] / src / msw / font.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/font.cpp
3 // Purpose: wxFont class
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/font.h"
28
29 #ifndef WX_PRECOMP
30 #include "wx/list.h"
31 #include "wx/utils.h"
32 #include "wx/app.h"
33 #include "wx/log.h"
34 #include "wx/encinfo.h"
35 #endif // WX_PRECOMP
36
37 #include "wx/msw/private.h"
38
39 #include "wx/fontutil.h"
40 #include "wx/fontmap.h"
41
42 #include "wx/tokenzr.h"
43
44 #if wxUSE_EXTENDED_RTTI
45
46 wxBEGIN_ENUM( wxFontFamily )
47 wxENUM_MEMBER( wxDEFAULT )
48 wxENUM_MEMBER( wxDECORATIVE )
49 wxENUM_MEMBER( wxROMAN )
50 wxENUM_MEMBER( wxSCRIPT )
51 wxENUM_MEMBER( wxSWISS )
52 wxENUM_MEMBER( wxMODERN )
53 wxENUM_MEMBER( wxTELETYPE )
54 wxEND_ENUM( wxFontFamily )
55
56 wxBEGIN_ENUM( wxFontStyle )
57 wxENUM_MEMBER( wxNORMAL )
58 wxENUM_MEMBER( wxITALIC )
59 wxENUM_MEMBER( wxSLANT )
60 wxEND_ENUM( wxFontStyle )
61
62 wxBEGIN_ENUM( wxFontWeight )
63 wxENUM_MEMBER( wxNORMAL )
64 wxENUM_MEMBER( wxLIGHT )
65 wxENUM_MEMBER( wxBOLD )
66 wxEND_ENUM( wxFontWeight )
67
68 IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI(wxFont, wxGDIObject,"wx/font.h")
69
70 wxBEGIN_PROPERTIES_TABLE(wxFont)
71 wxPROPERTY( Size,int, SetPointSize, GetPointSize, 12 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
72 wxPROPERTY( Family, int , SetFamily, GetFamily, (int)wxDEFAULT , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontFamily
73 wxPROPERTY( Style, int , SetStyle, GetStyle, (int)wxNORMAL , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontStyle
74 wxPROPERTY( Weight, int , SetWeight, GetWeight, (int)wxNORMAL , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontWeight
75 wxPROPERTY( Underlined, bool , SetUnderlined, GetUnderlined, false , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
76 wxPROPERTY( Face, wxString , SetFaceName, GetFaceName, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
77 wxPROPERTY( Encoding, wxFontEncoding , SetEncoding, GetEncoding, wxFONTENCODING_DEFAULT , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
78 wxEND_PROPERTIES_TABLE()
79
80 wxCONSTRUCTOR_6( wxFont , int , Size , int , Family , int , Style , int , Weight , bool , Underlined , wxString , Face )
81
82 wxBEGIN_HANDLERS_TABLE(wxFont)
83 wxEND_HANDLERS_TABLE()
84
85 #else
86 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
87 #endif
88
89
90 // ----------------------------------------------------------------------------
91 // constants
92 // ----------------------------------------------------------------------------
93
94 // the mask used to extract the pitch from LOGFONT::lfPitchAndFamily field
95 static const int PITCH_MASK = FIXED_PITCH | VARIABLE_PITCH;
96
97 // ----------------------------------------------------------------------------
98 // wxFontRefData - the internal description of the font
99 // ----------------------------------------------------------------------------
100
101 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
102 {
103 public:
104 // constructors
105 wxFontRefData()
106 {
107 Init(-1, wxSize(0,0), false, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL,
108 wxFONTWEIGHT_NORMAL, false, wxEmptyString,
109 wxFONTENCODING_DEFAULT);
110 }
111
112 wxFontRefData(int size,
113 const wxSize& pixelSize,
114 bool sizeUsingPixels,
115 int family,
116 int style,
117 int weight,
118 bool underlined,
119 const wxString& faceName,
120 wxFontEncoding encoding)
121 {
122 Init(size, pixelSize, sizeUsingPixels, family, style, weight,
123 underlined, faceName, encoding);
124 }
125
126 wxFontRefData(const wxNativeFontInfo& info, WXHFONT hFont = 0)
127 {
128 Init(info, hFont);
129 }
130
131 wxFontRefData(const wxFontRefData& data) : wxGDIRefData()
132 {
133 if ( data.m_nativeFontInfoOk )
134 {
135 Init(data.m_nativeFontInfo);
136 }
137 else
138 {
139 Init(data.m_pointSize, data.m_pixelSize, data.m_sizeUsingPixels,
140 data.m_family, data.m_style, data.m_weight,
141 data.m_underlined, data.m_faceName, data.m_encoding);
142 }
143 }
144
145 virtual ~wxFontRefData();
146
147 // operations
148 bool Alloc(wxFont *font);
149
150 void Free();
151
152 // all wxFont accessors
153 int GetPointSize() const
154 {
155 return m_nativeFontInfoOk ? m_nativeFontInfo.GetPointSize()
156 : m_pointSize;
157 }
158
159 wxSize GetPixelSize() const
160 {
161 return m_nativeFontInfoOk ? m_nativeFontInfo.GetPixelSize()
162 : m_pixelSize;
163 }
164
165 bool IsUsingSizeInPixels() const
166 {
167 return m_nativeFontInfoOk ? true : m_sizeUsingPixels;
168 }
169
170 int GetFamily() const
171 {
172 return m_family;
173 }
174
175 int GetStyle() const
176 {
177 return m_nativeFontInfoOk ? m_nativeFontInfo.GetStyle()
178 : m_style;
179 }
180
181 int GetWeight() const
182 {
183 return m_nativeFontInfoOk ? m_nativeFontInfo.GetWeight()
184 : m_weight;
185 }
186
187 bool GetUnderlined() const
188 {
189 return m_nativeFontInfoOk ? m_nativeFontInfo.GetUnderlined()
190 : m_underlined;
191 }
192
193 wxString GetFaceName() const
194 {
195 wxString s;
196 if ( m_nativeFontInfoOk )
197 s = m_nativeFontInfo.GetFaceName();
198 else
199 s = m_faceName;
200
201 return s;
202 }
203
204 wxFontEncoding GetEncoding() const
205 {
206 return m_nativeFontInfoOk ? m_nativeFontInfo.GetEncoding()
207 : m_encoding;
208 }
209
210 WXHFONT GetHFONT() const { return m_hFont; }
211
212 // ... and setters
213 void SetPointSize(int pointSize)
214 {
215 if ( m_nativeFontInfoOk )
216 {
217 m_nativeFontInfo.SetPointSize(pointSize);
218 }
219 else
220 {
221 m_pointSize = pointSize;
222 m_sizeUsingPixels = false;
223 }
224 }
225
226 void SetPixelSize(const wxSize& pixelSize)
227 {
228 if ( m_nativeFontInfoOk )
229 {
230 m_nativeFontInfo.SetPixelSize(pixelSize);
231 }
232 else
233 {
234 m_pixelSize = pixelSize;
235 m_sizeUsingPixels = true;
236 }
237 }
238
239 void SetFamily(int family)
240 {
241 m_family = family;
242 }
243
244 void SetStyle(int style)
245 {
246 if ( m_nativeFontInfoOk )
247 m_nativeFontInfo.SetStyle((wxFontStyle)style);
248 else
249 m_style = style;
250 }
251
252 void SetWeight(int weight)
253 {
254 if ( m_nativeFontInfoOk )
255 m_nativeFontInfo.SetWeight((wxFontWeight)weight);
256 else
257 m_weight = weight;
258 }
259
260 bool SetFaceName(const wxString& faceName)
261 {
262 if ( m_nativeFontInfoOk )
263 return m_nativeFontInfo.SetFaceName(faceName);
264
265 m_faceName = faceName;
266 return true;
267 }
268
269 void SetUnderlined(bool underlined)
270 {
271 if ( m_nativeFontInfoOk )
272 m_nativeFontInfo.SetUnderlined(underlined);
273 else
274 m_underlined = underlined;
275 }
276
277 void SetEncoding(wxFontEncoding encoding)
278 {
279 if ( m_nativeFontInfoOk )
280 m_nativeFontInfo.SetEncoding(encoding);
281 else
282 m_encoding = encoding;
283 }
284
285 // native font info tests
286 bool HasNativeFontInfo() const { return m_nativeFontInfoOk; }
287
288 const wxNativeFontInfo& GetNativeFontInfo() const
289 { return m_nativeFontInfo; }
290
291 protected:
292 // common part of all ctors
293 void Init(int size,
294 const wxSize& pixelSize,
295 bool sizeUsingPixels,
296 int family,
297 int style,
298 int weight,
299 bool underlined,
300 const wxString& faceName,
301 wxFontEncoding encoding);
302
303 void Init(const wxNativeFontInfo& info, WXHFONT hFont = 0);
304
305 // font characterstics
306 int m_pointSize;
307 wxSize m_pixelSize;
308 bool m_sizeUsingPixels;
309 int m_family;
310 int m_style;
311 int m_weight;
312 bool m_underlined;
313 wxString m_faceName;
314 wxFontEncoding m_encoding;
315
316 // Windows font handle
317 WXHFONT m_hFont;
318
319 // Native font info
320 wxNativeFontInfo m_nativeFontInfo;
321 bool m_nativeFontInfoOk;
322 };
323
324 #define M_FONTDATA ((wxFontRefData*)m_refData)
325
326 // ============================================================================
327 // implementation
328 // ============================================================================
329
330 // ----------------------------------------------------------------------------
331 // wxFontRefData
332 // ----------------------------------------------------------------------------
333
334 void wxFontRefData::Init(int pointSize,
335 const wxSize& pixelSize,
336 bool sizeUsingPixels,
337 int family,
338 int style,
339 int weight,
340 bool underlined,
341 const wxString& faceName,
342 wxFontEncoding encoding)
343 {
344 m_style = style;
345 m_pointSize = pointSize == -1 ? wxNORMAL_FONT->GetPointSize() : pointSize;
346 m_pixelSize = pixelSize;
347 m_sizeUsingPixels = sizeUsingPixels;
348 m_family = family;
349 m_style = style;
350 m_weight = weight;
351 m_underlined = underlined;
352 m_faceName = faceName;
353 m_encoding = encoding;
354
355 m_hFont = 0;
356
357 m_nativeFontInfoOk = false;
358 }
359
360 void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont)
361 {
362 // hFont may be zero, or it be passed in case we really want to
363 // use the exact font created in the underlying system
364 // (for example where we can't guarantee conversion from HFONT
365 // to LOGFONT back to HFONT)
366 m_hFont = hFont;
367
368 m_nativeFontInfoOk = true;
369 m_nativeFontInfo = info;
370 // This is the best we can do since we don't have the
371 // correct information at this point.
372 m_family = wxSWISS;
373 }
374
375 wxFontRefData::~wxFontRefData()
376 {
377 Free();
378 }
379
380 bool wxFontRefData::Alloc(wxFont *font)
381 {
382 if ( !m_nativeFontInfoOk )
383 {
384 wxFillLogFont(&m_nativeFontInfo.lf, font);
385 m_nativeFontInfoOk = true;
386 }
387
388 HFONT hfont = ::CreateFontIndirect(&m_nativeFontInfo.lf);
389 if ( !hfont )
390 {
391 wxLogLastError(wxT("CreateFont"));
392 return false;
393 }
394
395 m_hFont = (WXHFONT)hfont;
396 return true;
397 }
398
399 void wxFontRefData::Free()
400 {
401 if ( m_hFont )
402 {
403 if ( !::DeleteObject((HFONT) m_hFont) )
404 {
405 wxLogLastError(wxT("DeleteObject(font)"));
406 }
407
408 m_hFont = 0;
409 }
410 }
411
412 // ----------------------------------------------------------------------------
413 // wxNativeFontInfo
414 // ----------------------------------------------------------------------------
415
416 void wxNativeFontInfo::Init()
417 {
418 wxZeroMemory(lf);
419
420 // we get better font quality if we use this instead of DEFAULT_QUALITY
421 // apparently without any drawbacks
422 #ifdef __WXWINCE__
423 lf.lfQuality = CLEARTYPE_QUALITY;
424 #else
425 lf.lfQuality = PROOF_QUALITY;
426 #endif
427 }
428
429 int wxNativeFontInfo::GetPointSize() const
430 {
431 // FIXME: using the screen here results in incorrect font size calculation
432 // for printing!
433 const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY);
434
435 return (int) (((72.0*(double)abs(lf.lfHeight)) / (double) ppInch) + 0.5);
436 }
437
438 wxSize wxNativeFontInfo::GetPixelSize() const
439 {
440 wxSize ret;
441 ret.SetHeight(lf.lfHeight);
442 ret.SetWidth(lf.lfWidth);
443 return ret;
444 }
445
446 wxFontStyle wxNativeFontInfo::GetStyle() const
447 {
448 return lf.lfItalic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL;
449 }
450
451 wxFontWeight wxNativeFontInfo::GetWeight() const
452 {
453 if ( lf.lfWeight <= 300 )
454 return wxFONTWEIGHT_LIGHT;
455
456 if ( lf.lfWeight >= 600 )
457 return wxFONTWEIGHT_BOLD;
458
459 return wxFONTWEIGHT_NORMAL;
460 }
461
462 bool wxNativeFontInfo::GetUnderlined() const
463 {
464 return lf.lfUnderline != 0;
465 }
466
467 wxString wxNativeFontInfo::GetFaceName() const
468 {
469 return lf.lfFaceName;
470 }
471
472 wxFontFamily wxNativeFontInfo::GetFamily() const
473 {
474 wxFontFamily family;
475
476 // extract family from pitch-and-family
477 switch ( lf.lfPitchAndFamily & ~PITCH_MASK )
478 {
479 case FF_ROMAN:
480 family = wxFONTFAMILY_ROMAN;
481 break;
482
483 default:
484 wxFAIL_MSG( _T("unknown LOGFONT::lfFamily value") );
485 // fall through
486
487 case FF_SWISS:
488 family = wxFONTFAMILY_SWISS;
489 break;
490
491 case FF_SCRIPT:
492 family = wxFONTFAMILY_SCRIPT;
493 break;
494
495 case FF_MODERN:
496 family = wxFONTFAMILY_MODERN;
497 break;
498
499 case FF_DECORATIVE:
500 family = wxFONTFAMILY_DECORATIVE;
501 break;
502 }
503
504 return family;
505 }
506
507 wxFontEncoding wxNativeFontInfo::GetEncoding() const
508 {
509 return wxGetFontEncFromCharSet(lf.lfCharSet);
510 }
511
512 void wxNativeFontInfo::SetPointSize(int pointsize)
513 {
514 // FIXME: using the screen here results in incorrect font size calculation
515 // for printing!
516 const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY);
517
518 lf.lfHeight = -(int)((pointsize*((double)ppInch)/72.0) + 0.5);
519 }
520
521 void wxNativeFontInfo::SetPixelSize(const wxSize& pixelSize)
522 {
523 lf.lfHeight = pixelSize.GetHeight();
524 lf.lfWidth = pixelSize.GetWidth();
525 }
526
527
528 void wxNativeFontInfo::SetStyle(wxFontStyle style)
529 {
530 switch ( style )
531 {
532 default:
533 wxFAIL_MSG( _T("unknown font style") );
534 // fall through
535
536 case wxFONTSTYLE_NORMAL:
537 lf.lfItalic = FALSE;
538 break;
539
540 case wxFONTSTYLE_ITALIC:
541 case wxFONTSTYLE_SLANT:
542 lf.lfItalic = TRUE;
543 break;
544 }
545 }
546
547 void wxNativeFontInfo::SetWeight(wxFontWeight weight)
548 {
549 switch ( weight )
550 {
551 default:
552 wxFAIL_MSG( _T("unknown font weight") );
553 // fall through
554
555 case wxFONTWEIGHT_NORMAL:
556 lf.lfWeight = FW_NORMAL;
557 break;
558
559 case wxFONTWEIGHT_LIGHT:
560 lf.lfWeight = FW_LIGHT;
561 break;
562
563 case wxFONTWEIGHT_BOLD:
564 lf.lfWeight = FW_BOLD;
565 break;
566 }
567 }
568
569 void wxNativeFontInfo::SetUnderlined(bool underlined)
570 {
571 lf.lfUnderline = underlined;
572 }
573
574 bool wxNativeFontInfo::SetFaceName(const wxString& facename)
575 {
576 size_t len = WXSIZEOF(lf.lfFaceName);
577 wxStrncpy(lf.lfFaceName, facename, len);
578 lf.lfFaceName[len - 1] = '\0'; // truncate the face name
579 return true;
580 }
581
582 void wxNativeFontInfo::SetFamily(wxFontFamily family)
583 {
584 BYTE ff_family;
585 wxArrayString facename;
586
587 // the list of fonts associated with a family was partially
588 // taken from http://www.codestyle.org/css/font-family
589
590 switch ( family )
591 {
592 case wxSCRIPT:
593 ff_family = FF_SCRIPT;
594 facename.Add(_T("Script"));
595 facename.Add(_T("Brush Script MT"));
596 facename.Add(_T("Comic Sans MS"));
597 facename.Add(_T("Lucida Handwriting"));
598 break;
599
600 case wxDECORATIVE:
601 ff_family = FF_DECORATIVE;
602 facename.Add(_T("Old English Text MT"));
603 facename.Add(_T("Comic Sans MS"));
604 facename.Add(_T("Lucida Handwriting"));
605 break;
606
607 case wxROMAN:
608 ff_family = FF_ROMAN;
609 facename.Add(_T("Times New Roman"));
610 facename.Add(_T("Georgia"));
611 facename.Add(_T("Garamond"));
612 facename.Add(_T("Bookman Old Style"));
613 facename.Add(_T("Book Antiqua"));
614 break;
615
616 case wxTELETYPE:
617 case wxMODERN:
618 ff_family = FF_MODERN;
619 facename.Add(_T("Courier New"));
620 facename.Add(_T("Lucida Console"));
621 facename.Add(_T("Andale Mono"));
622 facename.Add(_T("OCR A Extended"));
623 facename.Add(_T("Terminal"));
624 break;
625
626 case wxSWISS:
627 ff_family = FF_SWISS;
628 facename.Add(_T("Arial"));
629 facename.Add(_T("Century Gothic"));
630 facename.Add(_T("Lucida Sans Unicode"));
631 facename.Add(_T("Tahoma"));
632 facename.Add(_T("Trebuchet MS"));
633 facename.Add(_T("Verdana"));
634 break;
635
636 case wxDEFAULT:
637 default:
638 {
639 // We want Windows 2000 or later to have new fonts even MS Shell Dlg
640 // is returned as default GUI font for compatibility
641 int verMaj;
642 ff_family = FF_SWISS;
643 if(wxGetOsVersion(&verMaj) == wxOS_WINDOWS_NT && verMaj >= 5)
644 facename.Add(_T("MS Shell Dlg 2"));
645 else
646 facename.Add(_T("MS Shell Dlg"));
647
648 // Quoting the MSDN:
649 // "MS Shell Dlg is a mapping mechanism that enables
650 // U.S. English Microsoft Windows NT, and Microsoft Windows 2000 to
651 // support locales that have characters that are not contained in code
652 // page 1252. It is not a font but a face name for a nonexistent font."
653 }
654 }
655
656 lf.lfPitchAndFamily = (BYTE)(DEFAULT_PITCH) | ff_family;
657
658 if ( !wxStrlen(lf.lfFaceName) )
659 {
660 SetFaceName(facename);
661 }
662 }
663
664 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding)
665 {
666 wxNativeEncodingInfo info;
667 if ( !wxGetNativeFontEncoding(encoding, &info) )
668 {
669 #if wxUSE_FONTMAP
670 if ( wxFontMapper::Get()->GetAltForEncoding(encoding, &info) )
671 {
672 if ( !info.facename.empty() )
673 {
674 // if we have this encoding only in some particular facename, use
675 // the facename - it is better to show the correct characters in a
676 // wrong facename than unreadable text in a correct one
677 SetFaceName(info.facename);
678 }
679 }
680 else
681 #endif // wxUSE_FONTMAP
682 {
683 // unsupported encoding, replace with the default
684 info.charset = DEFAULT_CHARSET;
685 }
686 }
687
688 lf.lfCharSet = (BYTE)info.charset;
689 }
690
691 bool wxNativeFontInfo::FromString(const wxString& s)
692 {
693 long l;
694
695 wxStringTokenizer tokenizer(s, _T(";"));
696
697 // first the version
698 wxString token = tokenizer.GetNextToken();
699 if ( token != _T('0') )
700 return false;
701
702 token = tokenizer.GetNextToken();
703 if ( !token.ToLong(&l) )
704 return false;
705 lf.lfHeight = l;
706
707 token = tokenizer.GetNextToken();
708 if ( !token.ToLong(&l) )
709 return false;
710 lf.lfWidth = l;
711
712 token = tokenizer.GetNextToken();
713 if ( !token.ToLong(&l) )
714 return false;
715 lf.lfEscapement = l;
716
717 token = tokenizer.GetNextToken();
718 if ( !token.ToLong(&l) )
719 return false;
720 lf.lfOrientation = l;
721
722 token = tokenizer.GetNextToken();
723 if ( !token.ToLong(&l) )
724 return false;
725 lf.lfWeight = l;
726
727 token = tokenizer.GetNextToken();
728 if ( !token.ToLong(&l) )
729 return false;
730 lf.lfItalic = (BYTE)l;
731
732 token = tokenizer.GetNextToken();
733 if ( !token.ToLong(&l) )
734 return false;
735 lf.lfUnderline = (BYTE)l;
736
737 token = tokenizer.GetNextToken();
738 if ( !token.ToLong(&l) )
739 return false;
740 lf.lfStrikeOut = (BYTE)l;
741
742 token = tokenizer.GetNextToken();
743 if ( !token.ToLong(&l) )
744 return false;
745 lf.lfCharSet = (BYTE)l;
746
747 token = tokenizer.GetNextToken();
748 if ( !token.ToLong(&l) )
749 return false;
750 lf.lfOutPrecision = (BYTE)l;
751
752 token = tokenizer.GetNextToken();
753 if ( !token.ToLong(&l) )
754 return false;
755 lf.lfClipPrecision = (BYTE)l;
756
757 token = tokenizer.GetNextToken();
758 if ( !token.ToLong(&l) )
759 return false;
760 lf.lfQuality = (BYTE)l;
761
762 token = tokenizer.GetNextToken();
763 if ( !token.ToLong(&l) )
764 return false;
765 lf.lfPitchAndFamily = (BYTE)l;
766
767 token = tokenizer.GetNextToken();
768 if(!token)
769 return false;
770 wxStrcpy(lf.lfFaceName, token.c_str());
771
772 return true;
773 }
774
775 wxString wxNativeFontInfo::ToString() const
776 {
777 wxString s;
778
779 s.Printf(_T("%d;%ld;%ld;%ld;%ld;%ld;%d;%d;%d;%d;%d;%d;%d;%d;%s"),
780 0, // version, in case we want to change the format later
781 lf.lfHeight,
782 lf.lfWidth,
783 lf.lfEscapement,
784 lf.lfOrientation,
785 lf.lfWeight,
786 lf.lfItalic,
787 lf.lfUnderline,
788 lf.lfStrikeOut,
789 lf.lfCharSet,
790 lf.lfOutPrecision,
791 lf.lfClipPrecision,
792 lf.lfQuality,
793 lf.lfPitchAndFamily,
794 lf.lfFaceName);
795
796 return s;
797 }
798
799 // ----------------------------------------------------------------------------
800 // wxFont
801 // ----------------------------------------------------------------------------
802
803 bool wxFont::Create(const wxNativeFontInfo& info, WXHFONT hFont)
804 {
805 UnRef();
806
807 m_refData = new wxFontRefData(info, hFont);
808
809 RealizeResource();
810
811 return true;
812 }
813
814 wxFont::wxFont(const wxString& fontdesc)
815 {
816 wxNativeFontInfo info;
817 if ( info.FromString(fontdesc) )
818 (void)Create(info);
819 }
820
821 /* Constructor for a font. Note that the real construction is done
822 * in wxDC::SetFont, when information is available about scaling etc.
823 */
824 bool wxFont::DoCreate(int pointSize,
825 const wxSize& pixelSize,
826 bool sizeUsingPixels,
827 int family,
828 int style,
829 int weight,
830 bool underlined,
831 const wxString& faceName,
832 wxFontEncoding encoding)
833 {
834 UnRef();
835
836 // wxDEFAULT is a valid value for the font size too so we must treat it
837 // specially here (otherwise the size would be 70 == wxDEFAULT value)
838 if ( pointSize == wxDEFAULT )
839 {
840 pointSize = wxNORMAL_FONT->GetPointSize();
841 }
842
843 m_refData = new wxFontRefData(pointSize, pixelSize, sizeUsingPixels,
844 family, style, weight,
845 underlined, faceName, encoding);
846
847 RealizeResource();
848
849 return true;
850 }
851
852 wxFont::~wxFont()
853 {
854 }
855
856 // ----------------------------------------------------------------------------
857 // real implementation
858 // ----------------------------------------------------------------------------
859
860 wxObjectRefData *wxFont::CreateRefData() const
861 {
862 return new wxFontRefData();
863 }
864
865 wxObjectRefData *wxFont::CloneRefData(const wxObjectRefData *data) const
866 {
867 return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
868 }
869
870 bool wxFont::RealizeResource()
871 {
872 if ( GetResourceHandle() )
873 {
874 // VZ: the old code returned false in this case, but it doesn't seem
875 // to make sense because the font _was_ created
876 return true;
877 }
878
879 return M_FONTDATA->Alloc(this);
880 }
881
882 bool wxFont::FreeResource(bool WXUNUSED(force))
883 {
884 if ( GetResourceHandle() )
885 {
886 M_FONTDATA->Free();
887
888 return true;
889 }
890
891 return false;
892 }
893
894 WXHANDLE wxFont::GetResourceHandle() const
895 {
896 return (WXHANDLE)GetHFONT();
897 }
898
899 WXHFONT wxFont::GetHFONT() const
900 {
901 return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0;
902 }
903
904 bool wxFont::IsFree() const
905 {
906 return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0);
907 }
908
909 // ----------------------------------------------------------------------------
910 // change font attribute: we recreate font when doing it
911 // ----------------------------------------------------------------------------
912
913 void wxFont::SetPointSize(int pointSize)
914 {
915 AllocExclusive();
916
917 M_FONTDATA->SetPointSize(pointSize);
918
919 RealizeResource();
920 }
921
922 void wxFont::SetPixelSize(const wxSize& pixelSize)
923 {
924 AllocExclusive();
925
926 M_FONTDATA->SetPixelSize(pixelSize);
927
928 RealizeResource();
929 }
930
931 void wxFont::SetFamily(int family)
932 {
933 AllocExclusive();
934
935 M_FONTDATA->SetFamily(family);
936
937 RealizeResource();
938 }
939
940 void wxFont::SetStyle(int style)
941 {
942 AllocExclusive();
943
944 M_FONTDATA->SetStyle(style);
945
946 RealizeResource();
947 }
948
949 void wxFont::SetWeight(int weight)
950 {
951 AllocExclusive();
952
953 M_FONTDATA->SetWeight(weight);
954
955 RealizeResource();
956 }
957
958 bool wxFont::SetFaceName(const wxString& faceName)
959 {
960 AllocExclusive();
961
962 bool refdataok = M_FONTDATA->SetFaceName(faceName);
963
964 RealizeResource();
965
966 // NB: using win32's GetObject() API on M_FONTDATA->GetHFONT()
967 // to retrieve a LOGFONT and then compare lf.lfFaceName
968 // with given facename is not reliable at all:
969 // Windows copies the facename given to ::CreateFontIndirect()
970 // without any validity check.
971 // Thus we use wxFontBase::SetFaceName to check if facename
972 // is valid...
973 return refdataok && wxFontBase::SetFaceName(faceName);
974 }
975
976 void wxFont::SetUnderlined(bool underlined)
977 {
978 AllocExclusive();
979
980 M_FONTDATA->SetUnderlined(underlined);
981
982 RealizeResource();
983 }
984
985 void wxFont::SetEncoding(wxFontEncoding encoding)
986 {
987 AllocExclusive();
988
989 M_FONTDATA->SetEncoding(encoding);
990
991 RealizeResource();
992 }
993
994 void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info)
995 {
996 AllocExclusive();
997
998 *M_FONTDATA = wxFontRefData(info);
999
1000 RealizeResource();
1001 }
1002
1003 // ----------------------------------------------------------------------------
1004 // accessors
1005 // ----------------------------------------------------------------------------
1006
1007 int wxFont::GetPointSize() const
1008 {
1009 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
1010
1011 return M_FONTDATA->GetPointSize();
1012 }
1013
1014 wxSize wxFont::GetPixelSize() const
1015 {
1016 wxCHECK_MSG( Ok(), wxDefaultSize, wxT("invalid font") );
1017
1018 return M_FONTDATA->GetPixelSize();
1019 }
1020
1021 bool wxFont::IsUsingSizeInPixels() const
1022 {
1023 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
1024
1025 return M_FONTDATA->IsUsingSizeInPixels();
1026 }
1027
1028 int wxFont::GetFamily() const
1029 {
1030 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
1031
1032 return M_FONTDATA->GetFamily();
1033 }
1034
1035 int wxFont::GetStyle() const
1036 {
1037 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
1038
1039 return M_FONTDATA->GetStyle();
1040 }
1041
1042 int wxFont::GetWeight() const
1043 {
1044 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
1045
1046 return M_FONTDATA->GetWeight();
1047 }
1048
1049 bool wxFont::GetUnderlined() const
1050 {
1051 wxCHECK_MSG( Ok(), false, wxT("invalid font") );
1052
1053 return M_FONTDATA->GetUnderlined();
1054 }
1055
1056 wxString wxFont::GetFaceName() const
1057 {
1058 wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );
1059
1060 return M_FONTDATA->GetFaceName();
1061 }
1062
1063 wxFontEncoding wxFont::GetEncoding() const
1064 {
1065 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
1066
1067 return M_FONTDATA->GetEncoding();
1068 }
1069
1070 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
1071 {
1072 return Ok() && M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo())
1073 : NULL;
1074 }
1075
1076 wxString wxFont::GetNativeFontInfoDesc() const
1077 {
1078 wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );
1079
1080 // be sure we have an HFONT associated...
1081 wxConstCast(this, wxFont)->RealizeResource();
1082 return wxFontBase::GetNativeFontInfoDesc();
1083 }
1084
1085 wxString wxFont::GetNativeFontInfoUserDesc() const
1086 {
1087 wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );
1088
1089 // be sure we have an HFONT associated...
1090 wxConstCast(this, wxFont)->RealizeResource();
1091 return wxFontBase::GetNativeFontInfoUserDesc();
1092 }
1093
1094 bool wxFont::IsFixedWidth() const
1095 {
1096 if ( M_FONTDATA->HasNativeFontInfo() )
1097 {
1098 // the two low-order bits specify the pitch of the font, the rest is
1099 // family
1100 BYTE pitch =
1101 (BYTE)(M_FONTDATA->GetNativeFontInfo().lf.lfPitchAndFamily & PITCH_MASK);
1102
1103 return pitch == FIXED_PITCH;
1104 }
1105
1106 return wxFontBase::IsFixedWidth();
1107 }