/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/fontcmn.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/common/fontcmn.cpp

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.22