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