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