]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: common/fontcmn.cpp | |
3 | // Purpose: implementation of wxFontBase methods | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 20.09.99 | |
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 | #ifndef WX_PRECOMP | |
28 | #include "wx/dc.h" | |
29 | #include "wx/font.h" | |
30 | #include "wx/intl.h" | |
31 | #include "wx/dcscreen.h" | |
32 | #endif // WX_PRECOMP | |
33 | ||
34 | #include "wx/gdicmn.h" | |
35 | ||
36 | #if defined(__WXMSW__) | |
37 | #include "wx/msw/private.h" // includes windows.h for LOGFONT | |
38 | #include "wx/msw/winundef.h" | |
39 | #endif | |
40 | ||
41 | #include "wx/fontutil.h" // for wxNativeFontInfo | |
42 | #include "wx/fontmap.h" | |
43 | ||
44 | #include "wx/tokenzr.h" | |
45 | ||
46 | // ============================================================================ | |
47 | // implementation | |
48 | // ============================================================================ | |
49 | ||
50 | // ---------------------------------------------------------------------------- | |
51 | // helper functions | |
52 | // ---------------------------------------------------------------------------- | |
53 | ||
54 | static void AdjustFontSize(wxFont& font, wxDC& dc, const wxSize& pixelSize) | |
55 | { | |
56 | int currentSize = font.GetPointSize(); | |
57 | int largestGood = 0; | |
58 | int smallestBad = 0; | |
59 | ||
60 | bool initialGoodFound = false; | |
61 | bool initialBadFound = false; | |
62 | ||
63 | while (currentSize > 0) | |
64 | { | |
65 | dc.SetFont(font); | |
66 | ||
67 | // if currentSize (in points) results in a font that is smaller | |
68 | // than required by pixelSize it is considered a good size | |
69 | if (dc.GetCharHeight() <= pixelSize.GetHeight() && | |
70 | (!pixelSize.GetWidth() || | |
71 | dc.GetCharWidth() <= pixelSize.GetWidth())) | |
72 | { | |
73 | largestGood = currentSize; | |
74 | initialGoodFound = true; | |
75 | } | |
76 | else | |
77 | { | |
78 | smallestBad = currentSize; | |
79 | initialBadFound = true; | |
80 | } | |
81 | if (!initialGoodFound) | |
82 | { | |
83 | currentSize /= 2; | |
84 | } | |
85 | else if (!initialBadFound) | |
86 | { | |
87 | currentSize *= 2; | |
88 | } | |
89 | else | |
90 | { | |
91 | int distance = smallestBad - largestGood; | |
92 | if (distance == 1) | |
93 | break; | |
94 | ||
95 | currentSize = largestGood + distance / 2; | |
96 | } | |
97 | ||
98 | font.SetPointSize(currentSize); | |
99 | } | |
100 | ||
101 | if (currentSize != largestGood) | |
102 | font.SetPointSize(largestGood); | |
103 | } | |
104 | ||
105 | // ---------------------------------------------------------------------------- | |
106 | // wxFontBase | |
107 | // ---------------------------------------------------------------------------- | |
108 | ||
109 | wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM; | |
110 | ||
111 | /* static */ | |
112 | void wxFontBase::SetDefaultEncoding(wxFontEncoding encoding) | |
113 | { | |
114 | // GetDefaultEncoding() should return something != wxFONTENCODING_DEFAULT | |
115 | // and, besides, using this value here doesn't make any sense | |
116 | wxCHECK_RET( encoding != wxFONTENCODING_DEFAULT, | |
117 | _T("can't set default encoding to wxFONTENCODING_DEFAULT") ); | |
118 | ||
119 | ms_encodingDefault = encoding; | |
120 | } | |
121 | ||
122 | wxFontBase::~wxFontBase() | |
123 | { | |
124 | // this destructor is required for Darwin | |
125 | } | |
126 | ||
127 | /* static */ | |
128 | wxFont *wxFontBase::New(int size, | |
129 | int family, | |
130 | int style, | |
131 | int weight, | |
132 | bool underlined, | |
133 | const wxString& face, | |
134 | wxFontEncoding encoding) | |
135 | { | |
136 | return new wxFont(size, family, style, weight, underlined, face, encoding); | |
137 | } | |
138 | ||
139 | static inline int flags2Style(int flags) | |
140 | { | |
141 | return flags & wxFONTFLAG_ITALIC | |
142 | ? wxFONTSTYLE_ITALIC | |
143 | : flags & wxFONTFLAG_SLANT | |
144 | ? wxFONTSTYLE_SLANT | |
145 | : wxFONTSTYLE_NORMAL; | |
146 | } | |
147 | ||
148 | static inline int flags2Weight(int flags) | |
149 | { | |
150 | return flags & wxFONTFLAG_LIGHT | |
151 | ? wxFONTWEIGHT_LIGHT | |
152 | : flags & wxFONTFLAG_BOLD | |
153 | ? wxFONTWEIGHT_BOLD | |
154 | : wxFONTWEIGHT_NORMAL; | |
155 | } | |
156 | ||
157 | static inline bool flags2Underlined(int flags) | |
158 | { | |
159 | return (flags & wxFONTFLAG_UNDERLINED) != 0; | |
160 | } | |
161 | ||
162 | /* static */ | |
163 | wxFont *wxFontBase::New(int pointSize, | |
164 | wxFontFamily family, | |
165 | int flags, | |
166 | const wxString& face, | |
167 | wxFontEncoding encoding) | |
168 | { | |
169 | return New(pointSize, family, flags2Style(flags), flags2Weight(flags), | |
170 | flags2Underlined(flags), face, encoding); | |
171 | } | |
172 | ||
173 | /* static */ | |
174 | wxFont *wxFontBase::New(const wxSize& pixelSize, | |
175 | int family, | |
176 | int style, | |
177 | int weight, | |
178 | bool underlined, | |
179 | const wxString& face, | |
180 | wxFontEncoding encoding) | |
181 | { | |
182 | #if defined(__WXMSW__) | |
183 | return new wxFont(pixelSize, family, style, weight, underlined, | |
184 | face, encoding); | |
185 | #else | |
186 | wxFont *self = New(10, family, style, weight, underlined, face, encoding); | |
187 | wxScreenDC dc; | |
188 | AdjustFontSize(*(wxFont *)self, dc, pixelSize); | |
189 | return self; | |
190 | #endif | |
191 | } | |
192 | ||
193 | /* static */ | |
194 | wxFont *wxFontBase::New(const wxSize& pixelSize, | |
195 | wxFontFamily family, | |
196 | int flags, | |
197 | const wxString& face, | |
198 | wxFontEncoding encoding) | |
199 | { | |
200 | return New(pixelSize, family, flags2Style(flags), flags2Weight(flags), | |
201 | flags2Underlined(flags), face, encoding); | |
202 | } | |
203 | ||
204 | wxSize wxFontBase::GetPixelSize() const | |
205 | { | |
206 | wxScreenDC dc; | |
207 | dc.SetFont(*(wxFont *)this); | |
208 | return wxSize(dc.GetCharWidth(), dc.GetCharHeight()); | |
209 | } | |
210 | ||
211 | bool wxFontBase::IsUsingSizeInPixels() const | |
212 | { | |
213 | return false; | |
214 | } | |
215 | ||
216 | void wxFontBase::SetPixelSize( const wxSize& pixelSize ) | |
217 | { | |
218 | wxScreenDC dc; | |
219 | AdjustFontSize(*(wxFont *)this, dc, pixelSize); | |
220 | } | |
221 | ||
222 | /* static */ | |
223 | wxFont *wxFontBase::New(const wxNativeFontInfo& info) | |
224 | { | |
225 | return new wxFont(info); | |
226 | } | |
227 | ||
228 | /* static */ | |
229 | wxFont *wxFontBase::New(const wxString& strNativeFontDesc) | |
230 | { | |
231 | wxNativeFontInfo fontInfo; | |
232 | if ( !fontInfo.FromString(strNativeFontDesc) ) | |
233 | return new wxFont(*wxNORMAL_FONT); | |
234 | ||
235 | return New(fontInfo); | |
236 | } | |
237 | ||
238 | bool wxFontBase::IsFixedWidth() const | |
239 | { | |
240 | return GetFamily() == wxFONTFAMILY_TELETYPE; | |
241 | } | |
242 | ||
243 | void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info) | |
244 | { | |
245 | #ifdef wxNO_NATIVE_FONTINFO | |
246 | SetPointSize(info.pointSize); | |
247 | SetFamily(info.family); | |
248 | SetStyle(info.style); | |
249 | SetWeight(info.weight); | |
250 | SetUnderlined(info.underlined); | |
251 | SetFaceName(info.faceName); | |
252 | SetEncoding(info.encoding); | |
253 | #else | |
254 | (void)info; | |
255 | #endif | |
256 | } | |
257 | ||
258 | wxString wxFontBase::GetNativeFontInfoDesc() const | |
259 | { | |
260 | wxString fontDesc; | |
261 | const wxNativeFontInfo *fontInfo = GetNativeFontInfo(); | |
262 | if ( fontInfo ) | |
263 | { | |
264 | fontDesc = fontInfo->ToString(); | |
265 | } | |
266 | ||
267 | return fontDesc; | |
268 | } | |
269 | ||
270 | wxString wxFontBase::GetNativeFontInfoUserDesc() const | |
271 | { | |
272 | wxString fontDesc; | |
273 | const wxNativeFontInfo *fontInfo = GetNativeFontInfo(); | |
274 | if ( fontInfo ) | |
275 | { | |
276 | fontDesc = fontInfo->ToUserString(); | |
277 | } | |
278 | ||
279 | return fontDesc; | |
280 | } | |
281 | ||
282 | void wxFontBase::SetNativeFontInfo(const wxString& info) | |
283 | { | |
284 | wxNativeFontInfo fontInfo; | |
285 | if ( !info.empty() && fontInfo.FromString(info) ) | |
286 | { | |
287 | SetNativeFontInfo(fontInfo); | |
288 | } | |
289 | } | |
290 | ||
291 | void wxFontBase::SetNativeFontInfoUserDesc(const wxString& info) | |
292 | { | |
293 | wxNativeFontInfo fontInfo; | |
294 | if ( !info.empty() && fontInfo.FromUserString(info) ) | |
295 | { | |
296 | SetNativeFontInfo(fontInfo); | |
297 | } | |
298 | } | |
299 | ||
300 | wxFont& wxFont::operator=(const wxFont& font) | |
301 | { | |
302 | if ( this != &font ) | |
303 | Ref(font); | |
304 | ||
305 | return (wxFont &)*this; | |
306 | } | |
307 | ||
308 | bool wxFontBase::operator==(const wxFont& font) const | |
309 | { | |
310 | // either it is the same font, i.e. they share the same common data or they | |
311 | // have different ref datas but still describe the same font | |
312 | return GetFontData() == font.GetFontData() || | |
313 | ( | |
314 | Ok() == font.Ok() && | |
315 | GetPointSize() == font.GetPointSize() && | |
316 | GetFamily() == font.GetFamily() && | |
317 | GetStyle() == font.GetStyle() && | |
318 | GetWeight() == font.GetWeight() && | |
319 | GetUnderlined() == font.GetUnderlined() && | |
320 | GetFaceName() == font.GetFaceName() && | |
321 | GetEncoding() == font.GetEncoding() | |
322 | ); | |
323 | } | |
324 | ||
325 | bool wxFontBase::operator!=(const wxFont& font) const | |
326 | { | |
327 | return !(*this == font); | |
328 | } | |
329 | ||
330 | wxString wxFontBase::GetFamilyString() const | |
331 | { | |
332 | wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") ); | |
333 | ||
334 | switch ( GetFamily() ) | |
335 | { | |
336 | case wxDECORATIVE: return wxT("wxDECORATIVE"); | |
337 | case wxROMAN: return wxT("wxROMAN"); | |
338 | case wxSCRIPT: return wxT("wxSCRIPT"); | |
339 | case wxSWISS: return wxT("wxSWISS"); | |
340 | case wxMODERN: return wxT("wxMODERN"); | |
341 | case wxTELETYPE: return wxT("wxTELETYPE"); | |
342 | default: return wxT("wxDEFAULT"); | |
343 | } | |
344 | } | |
345 | ||
346 | wxString wxFontBase::GetStyleString() const | |
347 | { | |
348 | wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") ); | |
349 | ||
350 | switch ( GetStyle() ) | |
351 | { | |
352 | case wxNORMAL: return wxT("wxNORMAL"); | |
353 | case wxSLANT: return wxT("wxSLANT"); | |
354 | case wxITALIC: return wxT("wxITALIC"); | |
355 | default: return wxT("wxDEFAULT"); | |
356 | } | |
357 | } | |
358 | ||
359 | wxString wxFontBase::GetWeightString() const | |
360 | { | |
361 | wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") ); | |
362 | ||
363 | switch ( GetWeight() ) | |
364 | { | |
365 | case wxNORMAL: return wxT("wxNORMAL"); | |
366 | case wxBOLD: return wxT("wxBOLD"); | |
367 | case wxLIGHT: return wxT("wxLIGHT"); | |
368 | default: return wxT("wxDEFAULT"); | |
369 | } | |
370 | } | |
371 | ||
372 | // ---------------------------------------------------------------------------- | |
373 | // wxNativeFontInfo | |
374 | // ---------------------------------------------------------------------------- | |
375 | ||
376 | #ifdef wxNO_NATIVE_FONTINFO | |
377 | ||
378 | // These are the generic forms of FromString()/ToString. | |
379 | // | |
380 | // convert to/from the string representation: format is | |
381 | // version;pointsize;family;style;weight;underlined;facename;encoding | |
382 | ||
383 | bool wxNativeFontInfo::FromString(const wxString& s) | |
384 | { | |
385 | long l; | |
386 | ||
387 | wxStringTokenizer tokenizer(s, _T(";")); | |
388 | ||
389 | wxString token = tokenizer.GetNextToken(); | |
390 | // | |
391 | // Ignore the version for now | |
392 | // | |
393 | ||
394 | token = tokenizer.GetNextToken(); | |
395 | if ( !token.ToLong(&l) ) | |
396 | return false; | |
397 | pointSize = (int)l; | |
398 | ||
399 | token = tokenizer.GetNextToken(); | |
400 | if ( !token.ToLong(&l) ) | |
401 | return false; | |
402 | family = (wxFontFamily)l; | |
403 | ||
404 | token = tokenizer.GetNextToken(); | |
405 | if ( !token.ToLong(&l) ) | |
406 | return false; | |
407 | style = (wxFontStyle)l; | |
408 | ||
409 | token = tokenizer.GetNextToken(); | |
410 | if ( !token.ToLong(&l) ) | |
411 | return false; | |
412 | weight = (wxFontWeight)l; | |
413 | ||
414 | token = tokenizer.GetNextToken(); | |
415 | if ( !token.ToLong(&l) ) | |
416 | return false; | |
417 | underlined = l != 0; | |
418 | ||
419 | faceName = tokenizer.GetNextToken(); | |
420 | ||
421 | #ifndef __WXMAC__ | |
422 | if( !faceName ) | |
423 | return false; | |
424 | #endif | |
425 | ||
426 | token = tokenizer.GetNextToken(); | |
427 | if ( !token.ToLong(&l) ) | |
428 | return false; | |
429 | encoding = (wxFontEncoding)l; | |
430 | ||
431 | return true; | |
432 | } | |
433 | ||
434 | wxString wxNativeFontInfo::ToString() const | |
435 | { | |
436 | wxString s; | |
437 | ||
438 | s.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"), | |
439 | 0, // version | |
440 | pointSize, | |
441 | family, | |
442 | (int)style, | |
443 | (int)weight, | |
444 | underlined, | |
445 | faceName.GetData(), | |
446 | (int)encoding); | |
447 | ||
448 | return s; | |
449 | } | |
450 | ||
451 | void wxNativeFontInfo::Init() | |
452 | { | |
453 | pointSize = 0; | |
454 | family = wxFONTFAMILY_DEFAULT; | |
455 | style = wxFONTSTYLE_NORMAL; | |
456 | weight = wxFONTWEIGHT_NORMAL; | |
457 | underlined = false; | |
458 | faceName.clear(); | |
459 | encoding = wxFONTENCODING_DEFAULT; | |
460 | } | |
461 | ||
462 | int wxNativeFontInfo::GetPointSize() const | |
463 | { | |
464 | return pointSize; | |
465 | } | |
466 | ||
467 | wxFontStyle wxNativeFontInfo::GetStyle() const | |
468 | { | |
469 | return style; | |
470 | } | |
471 | ||
472 | wxFontWeight wxNativeFontInfo::GetWeight() const | |
473 | { | |
474 | return weight; | |
475 | } | |
476 | ||
477 | bool wxNativeFontInfo::GetUnderlined() const | |
478 | { | |
479 | return underlined; | |
480 | } | |
481 | ||
482 | wxString wxNativeFontInfo::GetFaceName() const | |
483 | { | |
484 | return faceName; | |
485 | } | |
486 | ||
487 | wxFontFamily wxNativeFontInfo::GetFamily() const | |
488 | { | |
489 | return family; | |
490 | } | |
491 | ||
492 | wxFontEncoding wxNativeFontInfo::GetEncoding() const | |
493 | { | |
494 | return encoding; | |
495 | } | |
496 | ||
497 | void wxNativeFontInfo::SetPointSize(int pointsize) | |
498 | { | |
499 | pointSize = pointsize; | |
500 | } | |
501 | ||
502 | void wxNativeFontInfo::SetStyle(wxFontStyle style_) | |
503 | { | |
504 | style = style_; | |
505 | } | |
506 | ||
507 | void wxNativeFontInfo::SetWeight(wxFontWeight weight_) | |
508 | { | |
509 | weight = weight_; | |
510 | } | |
511 | ||
512 | void wxNativeFontInfo::SetUnderlined(bool underlined_) | |
513 | { | |
514 | underlined = underlined_; | |
515 | } | |
516 | ||
517 | void wxNativeFontInfo::SetFaceName(const wxString& facename_) | |
518 | { | |
519 | faceName = facename_; | |
520 | } | |
521 | ||
522 | void wxNativeFontInfo::SetFamily(wxFontFamily family_) | |
523 | { | |
524 | family = family_; | |
525 | } | |
526 | ||
527 | void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_) | |
528 | { | |
529 | encoding = encoding_; | |
530 | } | |
531 | ||
532 | #endif // generic wxNativeFontInfo implementation | |
533 | ||
534 | // conversion to/from user-readable string: this is used in the generic | |
535 | // versions and under MSW as well because there is no standard font description | |
536 | // format there anyhow (but there is a well-defined standard for X11 fonts used | |
537 | // by wxGTK and wxMotif) | |
538 | ||
539 | #if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__) || defined (__WXPM__) | |
540 | ||
541 | wxString wxNativeFontInfo::ToUserString() const | |
542 | { | |
543 | wxString desc; | |
544 | ||
545 | // first put the adjectives, if any - this is English-centric, of course, | |
546 | // but what else can we do? | |
547 | if ( GetUnderlined() ) | |
548 | { | |
549 | desc << _("underlined "); | |
550 | } | |
551 | ||
552 | switch ( GetWeight() ) | |
553 | { | |
554 | default: | |
555 | wxFAIL_MSG( _T("unknown font weight") ); | |
556 | // fall through | |
557 | ||
558 | case wxFONTWEIGHT_NORMAL: | |
559 | break; | |
560 | ||
561 | case wxFONTWEIGHT_LIGHT: | |
562 | desc << _("light "); | |
563 | break; | |
564 | ||
565 | case wxFONTWEIGHT_BOLD: | |
566 | desc << _("bold "); | |
567 | break; | |
568 | } | |
569 | ||
570 | switch ( GetStyle() ) | |
571 | { | |
572 | default: | |
573 | wxFAIL_MSG( _T("unknown font style") ); | |
574 | // fall through | |
575 | ||
576 | case wxFONTSTYLE_NORMAL: | |
577 | break; | |
578 | ||
579 | // we don't distinguish between the two for now anyhow... | |
580 | case wxFONTSTYLE_ITALIC: | |
581 | case wxFONTSTYLE_SLANT: | |
582 | desc << _("italic"); | |
583 | break; | |
584 | } | |
585 | ||
586 | wxString face = GetFaceName(); | |
587 | if ( !face.empty() ) | |
588 | { | |
589 | desc << _T(' ') << face; | |
590 | } | |
591 | ||
592 | int size = GetPointSize(); | |
593 | if ( size != wxNORMAL_FONT->GetPointSize() ) | |
594 | { | |
595 | desc << _T(' ') << size; | |
596 | } | |
597 | ||
598 | #if wxUSE_FONTMAP | |
599 | wxFontEncoding enc = GetEncoding(); | |
600 | if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM ) | |
601 | { | |
602 | desc << _T(' ') << wxFontMapper::GetEncodingName(enc); | |
603 | } | |
604 | #endif // wxUSE_FONTMAP | |
605 | ||
606 | return desc; | |
607 | } | |
608 | ||
609 | bool wxNativeFontInfo::FromUserString(const wxString& s) | |
610 | { | |
611 | // reset to the default state | |
612 | Init(); | |
613 | ||
614 | // parse a more or less free form string | |
615 | // | |
616 | // TODO: we should handle at least the quoted facenames | |
617 | wxStringTokenizer tokenizer(s, _T(";, "), wxTOKEN_STRTOK); | |
618 | ||
619 | wxString face; | |
620 | unsigned long size; | |
621 | ||
622 | #if wxUSE_FONTMAP | |
623 | wxFontEncoding encoding; | |
624 | #endif // wxUSE_FONTMAP | |
625 | ||
626 | while ( tokenizer.HasMoreTokens() ) | |
627 | { | |
628 | wxString token = tokenizer.GetNextToken(); | |
629 | ||
630 | // normalize it | |
631 | token.Trim(true).Trim(false).MakeLower(); | |
632 | ||
633 | // look for the known tokens | |
634 | if ( token == _T("underlined") || token == _("underlined") ) | |
635 | { | |
636 | SetUnderlined(true); | |
637 | } | |
638 | else if ( token == _T("light") || token == _("light") ) | |
639 | { | |
640 | SetWeight(wxFONTWEIGHT_LIGHT); | |
641 | } | |
642 | else if ( token == _T("bold") || token == _("bold") ) | |
643 | { | |
644 | SetWeight(wxFONTWEIGHT_BOLD); | |
645 | } | |
646 | else if ( token == _T("italic") || token == _("italic") ) | |
647 | { | |
648 | SetStyle(wxFONTSTYLE_ITALIC); | |
649 | } | |
650 | else if ( token.ToULong(&size) ) | |
651 | { | |
652 | SetPointSize(size); | |
653 | } | |
654 | #if wxUSE_FONTMAP | |
655 | else if ( (encoding = wxFontMapper::Get()->CharsetToEncoding(token, false)) | |
656 | != wxFONTENCODING_DEFAULT ) | |
657 | { | |
658 | SetEncoding(encoding); | |
659 | } | |
660 | #endif // wxUSE_FONTMAP | |
661 | else // assume it is the face name | |
662 | { | |
663 | if ( !face.empty() ) | |
664 | { | |
665 | face += _T(' '); | |
666 | } | |
667 | ||
668 | face += token; | |
669 | ||
670 | // skip the code which resets face below | |
671 | continue; | |
672 | } | |
673 | ||
674 | // if we had had the facename, we shouldn't continue appending tokens | |
675 | // to it (i.e. "foo bold bar" shouldn't result in the facename "foo | |
676 | // bar") | |
677 | if ( !face.empty() ) | |
678 | { | |
679 | SetFaceName(face); | |
680 | face.clear(); | |
681 | } | |
682 | } | |
683 | ||
684 | // we might not have flushed it inside the loop | |
685 | if ( !face.empty() ) | |
686 | { | |
687 | SetFaceName(face); | |
688 | } | |
689 | ||
690 | return true; | |
691 | } | |
692 | ||
693 | #endif // generic or wxMSW or wxOS2 | |
694 |