]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/os2/font.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Add doc for wxGraphicsContext.Create(), which is a lightweight context with no target...
[wxWidgets.git] / src / os2 / font.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/os2/font.cpp
3// Purpose: wxFont class
4// Author: David Webster
5// Modified by:
6// Created: 10/06/99
7// RCS-ID: $Id$
8// Copyright: (c) David Webster
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// For compilers that support precompilation, includes "wx.h".
13#include "wx/wxprec.h"
14
15// ============================================================================
16// declarations
17// ============================================================================
18
19// ----------------------------------------------------------------------------
20// headers
21// ----------------------------------------------------------------------------
22
23#include "wx/font.h"
24
25#ifndef WX_PRECOMP
26 #include <stdio.h>
27 #include "wx/list.h"
28 #include "wx/utils.h"
29 #include "wx/app.h"
30 #include "wx/log.h"
31#endif // WX_PRECOMP
32
33#include "wx/os2/private.h"
34
35#include "wx/fontutil.h"
36#include "wx/fontmap.h"
37#include "wx/encinfo.h"
38
39#include "wx/tokenzr.h"
40
41#include <malloc.h>
42
43// ----------------------------------------------------------------------------
44// wxFontRefData - the internal description of the font
45// ----------------------------------------------------------------------------
46
47class WXDLLEXPORT wxFontRefData: public wxGDIRefData
48{
49public:
50 wxFontRefData()
51 {
52 Init(-1, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false,
53 wxEmptyString, wxFONTENCODING_DEFAULT);
54 }
55
56 wxFontRefData( int nSize
57 ,wxFontFamily nFamily
58 ,wxFontStyle nStyle
59 ,wxFontWeight nWeight
60 ,bool bUnderlined
61 ,const wxString& sFaceName
62 ,wxFontEncoding vEncoding
63 )
64 {
65 Init( nSize
66 ,nFamily
67 ,nStyle
68 ,nWeight
69 ,bUnderlined
70 ,sFaceName
71 ,vEncoding
72 );
73 }
74
75 wxFontRefData( const wxNativeFontInfo& rInfo
76 ,WXHFONT hFont = 0
77 ,WXHANDLE hPS = 0
78 )
79 {
80 Init( rInfo
81 ,hFont
82 ,hPS
83 );
84 }
85
86 wxFontRefData(const wxFontRefData& rData)
87 {
88 Init( rData.m_nPointSize
89 ,rData.m_nFamily
90 ,rData.m_nStyle
91 ,rData.m_nWeight
92 ,rData.m_bUnderlined
93 ,rData.m_sFaceName
94 ,rData.m_vEncoding
95 );
96 m_nFontId = rData.m_nFontId;
97 }
98
99 virtual ~wxFontRefData();
100
101 //
102 // Operations
103 //
104 bool Alloc(wxFont* pFont);
105 void Free(void);
106
107 //
108 // All wxFont accessors
109 //
110 inline int GetPointSize(void) const
111 {
112 //
113 // We don't use the actual native font point size since it is
114 // the chosen physical font, which is usually only and approximation
115 // of the desired outline font. The actual displayable point size
116 // is the one stored in the refData
117 //
118 return m_nPointSize;
119 }
120
121 inline wxFontFamily GetFamily(void) const
122 {
123 return m_nFamily;
124 }
125
126 inline wxFontStyle GetStyle(void) const
127 {
128 return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetStyle()
129 : m_nStyle;
130 }
131
132 inline wxFontWeight GetWeight(void) const
133 {
134 return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetWeight()
135 : m_nWeight;
136 }
137
138 inline bool GetUnderlined(void) const
139 {
140 return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetUnderlined()
141 : m_bUnderlined;
142 }
143
144 inline wxString GetFaceName(void) const
145 {
146 wxString sFaceName;
147
148 if (m_bNativeFontInfoOk)
149 sFaceName = m_vNativeFontInfo.GetFaceName();
150 else
151 sFaceName = m_sFaceName;
152
153 return sFaceName;
154 }
155
156 inline wxFontEncoding GetEncoding(void) const
157 {
158 return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetEncoding()
159 : m_vEncoding;
160 }
161
162 inline WXHFONT GetHFONT(void) const { return m_hFont; }
163 inline HPS GetPS(void) const { return m_hPS; }
164 inline PFONTMETRICS GetFM(void) const { return m_pFM; }
165 inline int GetNumFonts(void) const { return m_nNumFonts; }
166
167 // ... and setters
168 inline void SetPointSize(int nPointSize)
169 {
170 if (m_bNativeFontInfoOk)
171 m_vNativeFontInfo.SetPointSize(nPointSize);
172 else
173 m_nPointSize = nPointSize;
174 }
175
176 inline void SetFamily(wxFontFamily nFamily)
177 {
178 m_nFamily = nFamily;
179 }
180
181 inline void SetStyle(wxFontStyle nStyle)
182 {
183 if (m_bNativeFontInfoOk)
184 m_vNativeFontInfo.SetStyle(nStyle);
185 else
186 m_nStyle = nStyle;
187 }
188
189 inline void SetWeight(wxFontWeight nWeight)
190 {
191 if (m_bNativeFontInfoOk)
192 m_vNativeFontInfo.SetWeight(nWeight);
193 else
194 m_nWeight = nWeight;
195 }
196
197 inline bool SetFaceName(const wxString& sFaceName)
198 {
199 if (m_bNativeFontInfoOk)
200 return m_vNativeFontInfo.SetFaceName(sFaceName);
201 else
202 m_sFaceName = sFaceName;
203 return true;
204 }
205
206 inline void SetUnderlined(bool bUnderlined)
207 {
208 if (m_bNativeFontInfoOk)
209 m_vNativeFontInfo.SetUnderlined(bUnderlined);
210 else
211 m_bUnderlined = bUnderlined;
212 }
213
214 inline void SetEncoding(wxFontEncoding vEncoding)
215 {
216 if (m_bNativeFontInfoOk)
217 m_vNativeFontInfo.SetEncoding(vEncoding);
218 else
219 m_vEncoding = vEncoding;
220 }
221
222 inline void SetPS(HPS hPS)
223 {
224 m_hPS = hPS;
225 }
226
227 inline void SetFM(PFONTMETRICS pFM)
228 {
229 m_pFM = pFM;
230 }
231
232 inline void SetNumFonts(int nNumFonts)
233 {
234 m_nNumFonts = nNumFonts;
235 }
236
237 //
238 // Native font info tests
239 //
240 bool HasNativeFontInfo() const { return m_bNativeFontInfoOk; }
241
242 const wxNativeFontInfo& GetNativeFontInfo() const
243 { return m_vNativeFontInfo; }
244
245protected:
246 //
247 // Common part of all ctors
248 //
249 void Init( int nSize
250 ,wxFontFamily nFamily
251 ,wxFontStyle nStyle
252 ,wxFontWeight nWeight
253 ,bool bUnderlined
254 ,const wxString& rsFaceName
255 ,wxFontEncoding vEncoding
256 );
257
258 void Init( const wxNativeFontInfo& rInfo
259 ,WXHFONT hFont = 0
260 ,WXHANDLE hPS = 0
261 );
262 //
263 // If true, the pointer to the actual font is temporary and SHOULD NOT BE
264 // DELETED by destructor
265 //
266 bool m_bTemporary;
267 int m_nFontId;
268
269 //
270 // Font characterstics
271 //
272 int m_nPointSize;
273 wxFontFamily m_nFamily;
274 wxFontStyle m_nStyle;
275 wxFontWeight m_nWeight;
276 bool m_bUnderlined;
277 wxString m_sFaceName;
278 wxFontEncoding m_vEncoding;
279 WXHFONT m_hFont;
280
281 //
282 // Native font info
283 //
284 wxNativeFontInfo m_vNativeFontInfo;
285 bool m_bNativeFontInfoOk;
286
287 //
288 // Some PM specific stuff
289 //
290 PFONTMETRICS m_pFM; // array of FONTMETRICS structs
291 int m_nNumFonts; // number of fonts in array
292 HPS m_hPS; // PS handle this font belongs to
293 FATTRS m_vFattrs; // Current fattrs struct
294 FACENAMEDESC m_vFname; // Current facename struct
295 bool m_bInternalPS; // Internally generated PS?
296}; // end of CLASS wxFontRefData
297
298#define M_FONTDATA ((wxFontRefData*)m_refData)
299
300// ============================================================================
301// implementation
302// ============================================================================
303
304// ----------------------------------------------------------------------------
305// wxFontRefData
306// ----------------------------------------------------------------------------
307
308void wxFontRefData::Init(
309 int nPointSize
310, wxFontFamily nFamily
311, wxFontStyle nStyle
312, wxFontWeight nWeight
313, bool bUnderlined
314, const wxString& rsFaceName
315, wxFontEncoding vEncoding
316)
317{
318 m_nStyle = nStyle;
319 m_nPointSize = nPointSize;
320 m_nFamily = nFamily;
321 m_nStyle = nStyle;
322 m_nWeight = nWeight;
323 m_bUnderlined = bUnderlined;
324 m_sFaceName = rsFaceName;
325 m_vEncoding = vEncoding;
326 m_hFont = 0;
327
328 m_bNativeFontInfoOk = false;
329
330 m_nFontId = 0;
331 m_bTemporary = false;
332 m_pFM = (PFONTMETRICS)NULL;
333 m_hPS = NULLHANDLE;
334 m_nNumFonts = 0;
335} // end of wxFontRefData::Init
336
337void wxFontRefData::Init(
338 const wxNativeFontInfo& rInfo
339, WXHFONT hFont //this is the FontId -- functions as the hFont for OS/2
340, WXHANDLE hPS // Presentation Space we are using
341)
342{
343 //
344 // hFont may be zero, or it be passed in case we really want to
345 // use the exact font created in the underlying system
346 // (for example where we can't guarantee conversion from HFONT
347 // to LOGFONT back to HFONT)
348 //
349 m_hFont = hFont;
350 m_nFontId = (int)hFont;
351
352 m_bNativeFontInfoOk = true;
353 m_vNativeFontInfo = rInfo;
354
355 if (hPS == NULLHANDLE)
356 {
357 m_hPS = ::WinGetPS(HWND_DESKTOP);
358 m_bInternalPS = true;
359 }
360 else
361 m_hPS = (HPS)hPS;
362
363 m_nFontId = 0;
364 m_bTemporary = false;
365 m_pFM = (PFONTMETRICS)NULL;
366 m_nNumFonts = 0;
367} // end of wxFontRefData::Init
368
369wxFontRefData::~wxFontRefData()
370{
371 Free();
372}
373
374bool wxFontRefData::Alloc( wxFont* pFont )
375{
376 wxString sFaceName;
377 long flId = m_hFont;
378 long lRc;
379 ERRORID vError;
380 wxString sError;
381
382 if (!m_bNativeFontInfoOk)
383 {
384 wxFillLogFont( &m_vNativeFontInfo.fa
385 ,&m_vNativeFontInfo.fn
386 ,&m_hPS
387 ,&m_bInternalPS
388 ,&flId
389 ,sFaceName
390 ,pFont
391 );
392 m_bNativeFontInfoOk = true;
393 }
394 else
395 {
396 if (flId == 0L)
397 flId = 1L;
398 else
399 flId++;
400 if (flId > 254)
401 flId = 1L;
402 }
403 if((lRc = ::GpiCreateLogFont( m_hPS
404 ,NULL
405 ,flId
406 ,&m_vNativeFontInfo.fa
407 )) != GPI_ERROR)
408 {
409 m_hFont = (WXHFONT)flId;
410 m_nFontId = flId;
411 }
412 if (!m_hFont)
413 {
414 vError = ::WinGetLastError(vHabmain);
415 sError = wxPMErrorToStr(vError);
416 wxLogLastError(wxT("CreateFont"));
417 }
418
419 ::GpiSetCharSet(m_hPS, flId); // sets font for presentation space
420 ::GpiQueryFontMetrics(m_hPS, sizeof(FONTMETRICS), &m_vNativeFontInfo.fm);
421
422 //
423 // Set refData members with the results
424 //
425 memcpy(&m_vFattrs, &m_vNativeFontInfo.fa, sizeof(m_vFattrs));
426 memcpy(&m_vFname, &m_vNativeFontInfo.fn, sizeof(m_vFname));
427 //
428 // Going to leave the point size alone. Mostly we use outline fonts
429 // that can be set to any point size inside of Presentation Parameters,
430 // regardless of whether or not the actual font is registered in the system.
431 // The GpiCreateLogFont will do enough by selecting the right family,
432 // and face name.
433 //
434 if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Times New Roman") == 0)
435 m_nFamily = wxFONTFAMILY_ROMAN;
436 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Times New Roman MT 30") == 0)
437 m_nFamily = wxFONTFAMILY_ROMAN;
438 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "@Times New Roman MT 30") == 0)
439 m_nFamily = wxFONTFAMILY_ROMAN;
440 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Tms Rmn") == 0)
441 m_nFamily = wxFONTFAMILY_ROMAN;
442 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "WarpSans") == 0)
443 m_nFamily = wxFONTFAMILY_DECORATIVE;
444 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Helvetica") == 0)
445 m_nFamily = wxFONTFAMILY_SWISS;
446 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Helv") == 0)
447 m_nFamily = wxFONTFAMILY_SWISS;
448 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Script") == 0)
449 m_nFamily = wxFONTFAMILY_SCRIPT;
450 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Courier New") == 0)
451 m_nFamily = wxFONTFAMILY_TELETYPE;
452 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Courier") == 0)
453 m_nFamily = wxFONTFAMILY_TELETYPE;
454 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System Monospaced") == 0)
455 m_nFamily = wxFONTFAMILY_TELETYPE;
456 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System VIO") == 0)
457 m_nFamily = wxFONTFAMILY_MODERN;
458 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System Proportional") == 0)
459 m_nFamily = wxFONTFAMILY_MODERN;
460 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Arial") == 0)
461 m_nFamily = wxFONTFAMILY_SWISS;
462 else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Swiss") == 0)
463 m_nFamily = wxFONTFAMILY_SWISS;
464 else
465 m_nFamily = wxFONTFAMILY_SWISS;
466
467 if (m_vNativeFontInfo.fa.fsSelection & FATTR_SEL_ITALIC)
468 m_nStyle = wxFONTSTYLE_ITALIC;
469 else
470 m_nStyle = wxFONTSTYLE_NORMAL;
471 switch(m_vNativeFontInfo.fn.usWeightClass)
472 {
473 case FWEIGHT_DONT_CARE:
474 m_nWeight = wxFONTWEIGHT_NORMAL;
475 break;
476
477 case FWEIGHT_NORMAL:
478 m_nWeight = wxFONTWEIGHT_NORMAL;
479 break;
480
481 case FWEIGHT_LIGHT:
482 m_nWeight = wxFONTWEIGHT_LIGHT;
483 break;
484
485 case FWEIGHT_BOLD:
486 m_nWeight = wxFONTWEIGHT_BOLD;
487 break;
488
489 case FWEIGHT_ULTRA_BOLD:
490 m_nWeight = wxFONTWEIGHT_MAX;
491 break;
492
493 default:
494 m_nWeight = wxFONTWEIGHT_NORMAL;
495 }
496 m_bUnderlined = ((m_vNativeFontInfo.fa.fsSelection & FATTR_SEL_UNDERSCORE) != 0);
497 m_sFaceName = (wxChar*)m_vNativeFontInfo.fa.szFacename;
498 m_vEncoding = wxGetFontEncFromCharSet(m_vNativeFontInfo.fa.usCodePage);
499
500 //
501 // We don't actuall keep the font around if using a temporary PS
502 //
503 if (m_bInternalPS)
504 {
505 if(m_hFont)
506 ::GpiDeleteSetId( m_hPS
507 ,flId
508 );
509
510 ::WinReleasePS(m_hPS);
511 }
512 else
513 //
514 // Select the font into the Presentation space
515 //
516 ::GpiSetCharSet(m_hPS, flId); // sets font for presentation space
517 return true;
518} // end of wxFontRefData::Alloc
519
520void wxFontRefData::Free()
521{
522 if (m_pFM)
523 delete [] m_pFM;
524 m_pFM = (PFONTMETRICS)NULL;
525
526 if ( m_hFont )
527 {
528 ::GpiDeleteSetId(m_hPS, 1L); /* delete the logical font */
529 m_nFontId = 0;
530 m_hFont = 0;
531 }
532 if (m_bInternalPS)
533 ::WinReleasePS(m_hPS);
534 m_hPS = NULLHANDLE;
535} // end of wxFontRefData::Free
536
537// ----------------------------------------------------------------------------
538// wxNativeFontInfo
539// ----------------------------------------------------------------------------
540
541void wxNativeFontInfo::Init()
542{
543 memset(&fa, '\0', sizeof(FATTRS));
544} // end of wxNativeFontInfo::Init
545
546int wxNativeFontInfo::GetPointSize() const
547{
548 return fm.lEmHeight;
549} // end of wxNativeFontInfo::GetPointSize
550
551wxFontStyle wxNativeFontInfo::GetStyle() const
552{
553 return fa.fsSelection & FATTR_SEL_ITALIC ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL;
554} // end of wxNativeFontInfo::GetStyle
555
556wxFontWeight wxNativeFontInfo::GetWeight() const
557{
558 switch(fn.usWeightClass)
559 {
560 case FWEIGHT_DONT_CARE:
561 return wxFONTWEIGHT_NORMAL;
562
563 case FWEIGHT_NORMAL:
564 return wxFONTWEIGHT_NORMAL;
565
566 case FWEIGHT_LIGHT:
567 return wxFONTWEIGHT_LIGHT;
568
569 case FWEIGHT_BOLD:
570 return wxFONTWEIGHT_BOLD;
571
572 case FWEIGHT_ULTRA_BOLD:
573 return wxFONTWEIGHT_MAX;
574 }
575 return wxFONTWEIGHT_NORMAL;
576} // end of wxNativeFontInfo::GetWeight
577
578bool wxNativeFontInfo::GetUnderlined() const
579{
580 return ((fa.fsSelection & FATTR_SEL_UNDERSCORE) != 0);
581} // end of wxNativeFontInfo::GetUnderlined
582
583wxString wxNativeFontInfo::GetFaceName() const
584{
585 return (wxChar*)fm.szFacename;
586} // end of wxNativeFontInfo::GetFaceName
587
588wxFontFamily wxNativeFontInfo::GetFamily() const
589{
590 int nFamily;
591
592 //
593 // Extract family from facename
594 //
595 if (strcmp(fm.szFamilyname, "Times New Roman") == 0)
596 nFamily = wxFONTFAMILY_ROMAN;
597 else if (strcmp(fm.szFamilyname, "Times New Roman MT 30") == 0)
598 nFamily = wxFONTFAMILY_ROMAN;
599 else if (strcmp(fm.szFamilyname, "@Times New Roman MT 30") == 0)
600 nFamily = wxFONTFAMILY_ROMAN;
601 else if (strcmp(fm.szFamilyname, "Tms Rmn") == 0)
602 nFamily = wxFONTFAMILY_ROMAN;
603 else if (strcmp(fm.szFamilyname, "WarpSans") == 0)
604 nFamily = wxFONTFAMILY_DECORATIVE;
605 else if (strcmp(fm.szFamilyname, "Helvetica") == 0)
606 nFamily = wxFONTFAMILY_SWISS;
607 else if (strcmp(fm.szFamilyname, "Helv") == 0)
608 nFamily = wxFONTFAMILY_SWISS;
609 else if (strcmp(fm.szFamilyname, "Script") == 0)
610 nFamily = wxFONTFAMILY_SCRIPT;
611 else if (strcmp(fm.szFamilyname, "Courier New") == 0)
612 nFamily = wxFONTFAMILY_TELETYPE;
613 else if (strcmp(fm.szFamilyname, "Courier") == 0)
614 nFamily = wxFONTFAMILY_TELETYPE;
615 else if (strcmp(fm.szFamilyname, "System Monospaced") == 0)
616 nFamily = wxFONTFAMILY_TELETYPE;
617 else if (strcmp(fm.szFamilyname, "System VIO") == 0)
618 nFamily = wxFONTFAMILY_MODERN;
619 else if (strcmp(fm.szFamilyname, "System Proportional") == 0)
620 nFamily = wxFONTFAMILY_MODERN;
621 else if (strcmp(fm.szFamilyname, "Arial") == 0)
622 nFamily = wxFONTFAMILY_SWISS;
623 else if (strcmp(fm.szFamilyname, "Swiss") == 0)
624 nFamily = wxFONTFAMILY_SWISS;
625 else
626 nFamily = wxFONTFAMILY_SWISS;
627 return (wxFontFamily)nFamily;
628} // end of wxNativeFontInfo::GetFamily
629
630wxFontEncoding wxNativeFontInfo::GetEncoding() const
631{
632 return wxGetFontEncFromCharSet(fa.usCodePage);
633} // end of wxNativeFontInfo::GetEncoding
634
635void wxNativeFontInfo::SetPointSize(
636 int nPointsize
637)
638{
639 fm.lEmHeight = (LONG)nPointsize;
640} // end of wxNativeFontInfo::SetPointSize
641
642void wxNativeFontInfo::SetStyle(
643 wxFontStyle eStyle
644)
645{
646 switch (eStyle)
647 {
648 default:
649 wxFAIL_MSG( wxT("unknown font style") );
650 // fall through
651
652 case wxFONTSTYLE_NORMAL:
653 break;
654
655 case wxFONTSTYLE_ITALIC:
656 case wxFONTSTYLE_SLANT:
657 fa.fsSelection |= FATTR_SEL_ITALIC;
658 break;
659 }
660} // end of wxNativeFontInfo::SetStyle
661
662void wxNativeFontInfo::SetWeight(
663 wxFontWeight eWeight
664)
665{
666 switch (eWeight)
667 {
668 default:
669 wxFAIL_MSG( wxT("unknown font weight") );
670 // fall through
671
672 case wxFONTWEIGHT_NORMAL:
673 fn.usWeightClass = FWEIGHT_NORMAL;
674 break;
675
676 case wxFONTWEIGHT_LIGHT:
677 fn.usWeightClass = FWEIGHT_LIGHT;
678 break;
679
680 case wxFONTWEIGHT_BOLD:
681 fn.usWeightClass = FWEIGHT_BOLD;
682 break;
683 }
684} // end of wxNativeFontInfo::SetWeight
685
686void wxNativeFontInfo::SetUnderlined(
687 bool bUnderlined
688)
689{
690 if(bUnderlined)
691 fa.fsSelection |= FATTR_SEL_UNDERSCORE;
692} // end of wxNativeFontInfo::SetUnderlined
693
694bool wxNativeFontInfo::SetFaceName(
695 const wxString& sFacename
696)
697{
698 wxStrlcpy((wxChar*)fa.szFacename, sFacename, WXSIZEOF(fa.szFacename));
699 return true;
700} // end of wxNativeFontInfo::SetFaceName
701
702void wxNativeFontInfo::SetFamily(
703 wxFontFamily eFamily
704)
705{
706 wxString sFacename;
707
708 switch (eFamily)
709 {
710 case wxFONTFAMILY_SCRIPT:
711 sFacename = wxT("Tms Rmn");
712 break;
713
714 case wxFONTFAMILY_DECORATIVE:
715 sFacename = wxT("WarpSans");
716 break;
717
718 case wxFONTFAMILY_ROMAN:
719 sFacename = wxT("Tms Rmn");
720 break;
721
722 case wxFONTFAMILY_TELETYPE:
723 sFacename = wxT("Courier") ;
724 break;
725
726 case wxFONTFAMILY_MODERN:
727 sFacename = wxT("System VIO") ;
728 break;
729
730 case wxFONTFAMILY_SWISS:
731 sFacename = wxT("Helv") ;
732 break;
733
734 case wxFONTFAMILY_DEFAULT:
735 default:
736 sFacename = wxT("System VIO") ;
737 }
738
739 if (!wxStrlen((wxChar*)fa.szFacename) )
740 {
741 SetFaceName(sFacename);
742 }
743} // end of wxNativeFontInfo::SetFamily
744
745void wxNativeFontInfo::SetEncoding( wxFontEncoding eEncoding )
746{
747 wxNativeEncodingInfo vInfo;
748
749 if ( !wxGetNativeFontEncoding( eEncoding
750 ,&vInfo
751 ))
752 {
753 if (wxFontMapper::Get()->GetAltForEncoding( eEncoding
754 ,&vInfo
755 ))
756 {
757 if (!vInfo.facename.empty())
758 {
759 //
760 // If we have this encoding only in some particular facename, use
761 // the facename - it is better to show the correct characters in a
762 // wrong facename than unreadable text in a correct one
763 //
764 SetFaceName(vInfo.facename);
765 }
766 }
767 else
768 {
769 // unsupported encoding, replace with the default
770 vInfo.charset = 850;
771 }
772 }
773 fa.usCodePage = (USHORT)vInfo.charset;
774} // end of wxNativeFontInfo::SetFaceName
775
776bool wxNativeFontInfo::FromString( const wxString& rsStr )
777{
778 long lVal;
779
780 wxStringTokenizer vTokenizer(rsStr, wxT(";"));
781
782 //
783 // First the version
784 //
785 wxString sToken = vTokenizer.GetNextToken();
786
787 if (sToken != wxT('0'))
788 return false;
789
790 sToken = vTokenizer.GetNextToken();
791 if (!sToken.ToLong(&lVal))
792 return false;
793 fm.lEmHeight = lVal;
794
795 sToken = vTokenizer.GetNextToken();
796 if (!sToken.ToLong(&lVal))
797 return false;
798 fa.lAveCharWidth = lVal;
799
800 sToken = vTokenizer.GetNextToken();
801 if (!sToken.ToLong(&lVal))
802 return false;
803 fa.fsSelection = (USHORT)lVal;
804
805 sToken = vTokenizer.GetNextToken();
806 if (!sToken.ToLong(&lVal))
807 return false;
808 fa.fsType = (USHORT)lVal;
809
810 sToken = vTokenizer.GetNextToken();
811 if (!sToken.ToLong(&lVal))
812 return false;
813 fa.fsFontUse = (USHORT)lVal;
814
815 sToken = vTokenizer.GetNextToken();
816 if (!sToken.ToLong(&lVal))
817 return false;
818 fa.idRegistry = (USHORT)lVal;
819
820 sToken = vTokenizer.GetNextToken();
821 if (!sToken.ToLong(&lVal))
822 return false;
823 fa.usCodePage = (USHORT)lVal;
824
825 sToken = vTokenizer.GetNextToken();
826 if (!sToken.ToLong(&lVal))
827 return false;
828 fa.lMatch = lVal;
829
830 sToken = vTokenizer.GetNextToken();
831 if (!sToken.ToLong(&lVal))
832 return false;
833 fn.usWeightClass = (USHORT)lVal;
834
835 sToken = vTokenizer.GetNextToken();
836 if(!sToken)
837 return false;
838 wxStrcpy((wxChar*)fa.szFacename, sToken.c_str());
839 return true;
840} // end of wxNativeFontInfo::FromString
841
842wxString wxNativeFontInfo::ToString() const
843{
844 wxString sStr;
845
846 sStr.Printf(wxT("%d;%ld;%ld;%ld;%d;%d;%d;%d;%d;%ld;%d;%s"),
847 0, // version, in case we want to change the format later
848 fm.lEmHeight,
849 fa.lAveCharWidth,
850 fa.lMaxBaselineExt,
851 fa.fsSelection,
852 fa.fsType,
853 fa.fsFontUse,
854 fa.idRegistry,
855 fa.usCodePage,
856 fa.lMatch,
857 fn.usWeightClass,
858 (char *)fa.szFacename);
859 return sStr;
860} // end of wxNativeFontInfo::ToString
861
862// ----------------------------------------------------------------------------
863// wxFont
864// ----------------------------------------------------------------------------
865
866bool wxFont::Create( const wxNativeFontInfo& rInfo,
867 WXHFONT hFont )
868{
869 UnRef();
870 m_refData = new wxFontRefData( rInfo
871 ,hFont
872 );
873 RealizeResource();
874 return true;
875} // end of wxFont::Create
876
877wxFont::wxFont(
878 const wxString& rsFontdesc
879)
880{
881 wxNativeFontInfo vInfo;
882
883 if (vInfo.FromString(rsFontdesc))
884 (void)Create(vInfo);
885} // end of wxFont::wxFont
886
887// ----------------------------------------------------------------------------
888// Constructor for a font. Note that the real construction is done
889// in wxDC::SetFont, when information is available about scaling etc.
890// ----------------------------------------------------------------------------
891bool wxFont::Create( int nPointSize,
892 wxFontFamily nFamily,
893 wxFontStyle nStyle,
894 wxFontWeight nWeight,
895 bool bUnderlined,
896 const wxString& rsFaceName,
897 wxFontEncoding vEncoding )
898{
899 UnRef();
900
901 //
902 // wxDEFAULT is a valid value for the font size too so we must treat it
903 // specially here (otherwise the size would be 70 == wxDEFAULT value)
904 //
905 if (nPointSize == wxDEFAULT)
906 {
907 nPointSize = wxNORMAL_FONT->GetPointSize();
908 }
909 m_refData = new wxFontRefData( nPointSize
910 ,nFamily
911 ,nStyle
912 ,nWeight
913 ,bUnderlined
914 ,rsFaceName
915 ,vEncoding
916 );
917 RealizeResource();
918 return true;
919} // end of wxFont::Create
920
921wxFont::~wxFont()
922{
923} // end of wxFont::~wxFont
924
925// ----------------------------------------------------------------------------
926// real implementation
927// Boris' Kovalenko comments:
928// Because OS/2 fonts are associated with PS we cannot create the font
929// here, but we may check that font definition is true
930// ----------------------------------------------------------------------------
931
932wxGDIRefData *wxFont::CreateGDIRefData() const
933{
934 return new wxFontRefData();
935}
936
937wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
938{
939 return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
940}
941
942bool wxFont::RealizeResource()
943{
944 if ( GetResourceHandle() )
945 {
946 return true;
947 }
948 return M_FONTDATA->Alloc(this);
949} // end of wxFont::RealizeResource
950
951bool wxFont::FreeResource( bool WXUNUSED(bForce) )
952{
953 if (GetResourceHandle())
954 {
955 M_FONTDATA->Free();
956 return true;
957 }
958 return false;
959} // end of wxFont::FreeResource
960
961WXHANDLE wxFont::GetResourceHandle() const
962{
963 return GetHFONT();
964} // end of wxFont::GetResourceHandle
965
966WXHFONT wxFont::GetHFONT() const
967{
968 return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0;
969} // end of wxFont::GetHFONT
970
971bool wxFont::IsFree() const
972{
973 return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0);
974} // end of wxFont::IsFree
975
976// ----------------------------------------------------------------------------
977// change font attribute: we recreate font when doing it
978// ----------------------------------------------------------------------------
979
980void wxFont::SetPointSize(
981 int nPointSize
982)
983{
984 AllocExclusive();
985
986 M_FONTDATA->SetPointSize(nPointSize);
987
988 RealizeResource();
989} // end of wxFont::SetPointSize
990
991void wxFont::SetFamily(
992 wxFontFamily nFamily
993)
994{
995 AllocExclusive();
996
997 M_FONTDATA->SetFamily(nFamily);
998
999 RealizeResource();
1000} // end of wxFont::SetFamily
1001
1002void wxFont::SetStyle(
1003 wxFontStyle nStyle
1004)
1005{
1006 AllocExclusive();
1007
1008 M_FONTDATA->SetStyle(nStyle);
1009
1010 RealizeResource();
1011} // end of wxFont::SetStyle
1012
1013void wxFont::SetWeight(
1014 wxFontWeight nWeight
1015)
1016{
1017 AllocExclusive();
1018
1019 M_FONTDATA->SetWeight(nWeight);
1020
1021 RealizeResource();
1022} // end of wxFont::SetWeight
1023
1024bool wxFont::SetFaceName(
1025 const wxString& rsFaceName
1026)
1027{
1028 AllocExclusive();
1029
1030 bool refdataok = M_FONTDATA->SetFaceName(rsFaceName);
1031
1032 RealizeResource();
1033
1034 return refdataok && wxFontBase::SetFaceName(rsFaceName);
1035} // end of wxFont::SetFaceName
1036
1037void wxFont::SetUnderlined(
1038 bool bUnderlined
1039)
1040{
1041 AllocExclusive();
1042
1043 M_FONTDATA->SetUnderlined(bUnderlined);
1044
1045 RealizeResource();
1046} // end of wxFont::SetUnderlined
1047
1048void wxFont::SetEncoding(
1049 wxFontEncoding vEncoding
1050)
1051{
1052 AllocExclusive();
1053
1054 M_FONTDATA->SetEncoding(vEncoding);
1055
1056 RealizeResource();
1057} // end of wxFont::SetEncoding
1058
1059void wxFont::DoSetNativeFontInfo(
1060 const wxNativeFontInfo& rInfo
1061)
1062{
1063 AllocExclusive();
1064
1065 FreeResource();
1066
1067 *M_FONTDATA = wxFontRefData(rInfo);
1068
1069 RealizeResource();
1070}
1071
1072// ----------------------------------------------------------------------------
1073// accessors
1074// ----------------------------------------------------------------------------
1075
1076int wxFont::GetPointSize() const
1077{
1078 wxCHECK_MSG( IsOk(), 0, wxT("invalid font") );
1079
1080 return M_FONTDATA->GetPointSize();
1081} // end of wxFont::GetPointSize
1082
1083wxFontFamily wxFont::DoGetFamily() const
1084{
1085 return M_FONTDATA->GetFamily();
1086} // end of wxFont::DoGetFamily
1087
1088wxFontStyle wxFont::GetStyle() const
1089{
1090 wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") );
1091
1092 return M_FONTDATA->GetStyle();
1093} // end of wxFont::GetStyle
1094
1095wxFontWeight wxFont::GetWeight() const
1096{
1097 wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") );
1098
1099 return M_FONTDATA->GetWeight();
1100}
1101
1102bool wxFont::GetUnderlined() const
1103{
1104 wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
1105
1106 return M_FONTDATA->GetUnderlined();
1107} // end of wxFont::GetUnderlined
1108
1109wxString wxFont::GetFaceName() const
1110{
1111 wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
1112
1113 return M_FONTDATA->GetFaceName();
1114} // end of wxFont::GetFaceName
1115
1116wxFontEncoding wxFont::GetEncoding() const
1117{
1118 wxCHECK_MSG( IsOk(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
1119
1120 return M_FONTDATA->GetEncoding();
1121} // end of wxFont::GetEncoding
1122
1123const wxNativeFontInfo* wxFont::GetNativeFontInfo() const
1124{
1125 return M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo())
1126 : NULL;
1127} // end of wxFont::GetNativeFontInfo
1128
1129//
1130// Internal use only method to set the FONTMETRICS array
1131//
1132void wxFont::SetFM( PFONTMETRICS pFM, int nNumFonts )
1133{
1134 M_FONTDATA->SetFM(pFM);
1135 M_FONTDATA->SetNumFonts(nNumFonts);
1136} // end of wxFont::SetFM
1137
1138
1139void wxFont::SetPS( HPS hPS )
1140{
1141 AllocExclusive();
1142
1143 M_FONTDATA->SetPS(hPS);
1144
1145 RealizeResource();
1146} // end of wxFont::SetPS
wxWidgets (Impactor)