src/unix/fontutil.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        unix/fontutil.cpp
   3 // Purpose:     Font helper functions for X11 (GDK/X)
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     05.11.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Vadim Zeitlin
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "fontutil.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32 #endif // PCH
  33
  34 #include "wx/fontutil.h"
  35 #include "wx/fontmap.h"
  36 #include "wx/tokenzr.h"
  37 #include "wx/hash.h"
  38 #include "wx/module.h"
  39
  40 #if wxUSE_PANGO
  41
  42 #include "pango/pango.h"
  43
  44 #ifdef __WXGTK20__
  45 #include "wx/gtk/private.h"
  46 #else
  47 #include "wx/x11/private.h"
  48 #endif
  49
  50 // ----------------------------------------------------------------------------
  51 // wxNativeFontInfo
  52 // ----------------------------------------------------------------------------
  53
  54 void wxNativeFontInfo::Init()
  55 {
  56     description = NULL;
  57 }
  58
  59 int wxNativeFontInfo::GetPointSize() const
  60 {
  61     return pango_font_description_get_size( description ) / PANGO_SCALE;
  62 }
  63
  64 wxFontStyle wxNativeFontInfo::GetStyle() const
  65 {
  66     wxFontStyle m_style = wxFONTSTYLE_NORMAL;
  67
  68     switch (pango_font_description_get_style( description ))
  69     {
  70         case PANGO_STYLE_NORMAL:
  71             m_style = wxFONTSTYLE_NORMAL;
  72             break;
  73         case PANGO_STYLE_ITALIC:
  74             m_style = wxFONTSTYLE_ITALIC;
  75             break;
  76         case PANGO_STYLE_OBLIQUE:
  77             m_style = wxFONTSTYLE_SLANT;
  78             break;
  79     }
  80
  81     return m_style;
  82 }
  83
  84 wxFontWeight wxNativeFontInfo::GetWeight() const
  85 {
  86     wxFontWeight m_weight = wxFONTWEIGHT_NORMAL;
  87
  88     switch (pango_font_description_get_weight( description ))
  89     {
  90         case PANGO_WEIGHT_ULTRALIGHT:
  91             m_weight = wxFONTWEIGHT_LIGHT;
  92             break;
  93         case PANGO_WEIGHT_LIGHT:
  94             m_weight = wxFONTWEIGHT_LIGHT;
  95             break;
  96         case PANGO_WEIGHT_NORMAL:
  97             m_weight = wxFONTWEIGHT_NORMAL;
  98             break;
  99         case PANGO_WEIGHT_BOLD:
 100             m_weight = wxFONTWEIGHT_BOLD;
 101             break;
 102         case PANGO_WEIGHT_ULTRABOLD:
 103             m_weight = wxFONTWEIGHT_BOLD;
 104             break;
 105         case PANGO_WEIGHT_HEAVY:
 106             m_weight = wxFONTWEIGHT_BOLD;
 107             break;
 108     }
 109
 110     return m_weight;
 111 }
 112
 113 bool wxNativeFontInfo::GetUnderlined() const
 114 {
 115     return FALSE;
 116 }
 117
 118 wxString wxNativeFontInfo::GetFaceName() const
 119 {
 120     wxString tmp = wxGTK_CONV_BACK( pango_font_description_get_family( description ) );
 121
 122     return tmp;
 123 }
 124
 125 wxFontFamily wxNativeFontInfo::GetFamily() const
 126 {
 127     return wxFONTFAMILY_SWISS;
 128 }
 129
 130 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 131 {
 132     return wxFONTENCODING_SYSTEM;
 133 }
 134
 135 bool wxNativeFontInfo::FromString(const wxString& s)
 136 {
 137     if (description)
 138         pango_font_description_free( description );
 139
 140     description = pango_font_description_from_string( wxGTK_CONV( s ) );
 141
 142     return TRUE;
 143 }
 144
 145 wxString wxNativeFontInfo::ToString() const
 146 {
 147     wxString tmp = wxGTK_CONV_BACK( pango_font_description_to_string( description ) );
 148
 149     return tmp;
 150 }
 151
 152 bool wxNativeFontInfo::FromUserString(const wxString& s)
 153 {
 154     return FromString( s );
 155 }
 156
 157 wxString wxNativeFontInfo::ToUserString() const
 158 {
 159     return ToString();
 160 }
 161
 162 // ----------------------------------------------------------------------------
 163 // wxNativeEncodingInfo
 164 // ----------------------------------------------------------------------------
 165
 166 bool wxNativeEncodingInfo::FromString(const wxString& s)
 167 {
 168     return FALSE;
 169 }
 170
 171 wxString wxNativeEncodingInfo::ToString() const
 172 {
 173     return wxEmptyString;
 174 }
 175
 176 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
 177 {
 178     return TRUE;
 179 }
 180
 181 bool wxGetNativeFontEncoding(wxFontEncoding encoding,
 182                              wxNativeEncodingInfo *info)
 183 {
 184     return FALSE;
 185 }
 186
 187 #else // GTK+ 1.x
 188
 189 #ifdef __X__
 190     #ifdef __VMS__
 191         #pragma message disable nosimpint
 192     #endif
 193
 194     #include <X11/Xlib.h>
 195
 196     #ifdef __VMS__
 197         #pragma message enable nosimpint
 198     #endif
 199
 200     #include "wx/utils.h"       // for wxGetDisplay()
 201 #elif defined(__WXGTK__)
 202     // we have to declare struct tm to avoid problems with first forward
 203     // declaring it in C code (glib.h included from gdk.h does it) and then
 204     // defining it when time.h is included from the headers below - this is
 205     // known not to work at least with Sun CC 6.01
 206     #include <time.h>
 207
 208     #include <gdk/gdk.h>
 209 #endif
 210
 211
 212 // ----------------------------------------------------------------------------
 213 // private data
 214 // ----------------------------------------------------------------------------
 215
 216 static wxHashTable *g_fontHash = (wxHashTable*) NULL;
 217
 218 // ----------------------------------------------------------------------------
 219 // private functions
 220 // ----------------------------------------------------------------------------
 221
 222 // define the functions to create and destroy native fonts for this toolkit
 223 #ifdef __X__
 224     wxNativeFont wxLoadFont(const wxString& fontSpec)
 225     {
 226         return XLoadQueryFont((Display *)wxGetDisplay(), fontSpec);
 227     }
 228
 229     inline void wxFreeFont(wxNativeFont font)
 230     {
 231         XFreeFont((Display *)wxGetDisplay(), (XFontStruct *)font);
 232     }
 233 #elif defined(__WXGTK__)
 234     wxNativeFont wxLoadFont(const wxString& fontSpec)
 235     {
 236        return gdk_font_load( wxConvertWX2MB(fontSpec) );
 237     }
 238
 239     inline void wxFreeFont(wxNativeFont font)
 240     {
 241         gdk_font_unref(font);
 242     }
 243 #else
 244     #error "Unknown GUI toolkit"
 245 #endif
 246
 247 static bool wxTestFontSpec(const wxString& fontspec);
 248
 249 static wxNativeFont wxLoadQueryFont(int pointSize,
 250                                     int family,
 251                                     int style,
 252                                     int weight,
 253                                     bool underlined,
 254                                     const wxString& facename,
 255                                     const wxString& xregistry,
 256                                     const wxString& xencoding,
 257                                     wxString* xFontName);
 258
 259 // ============================================================================
 260 // implementation
 261 // ============================================================================
 262
 263 // ----------------------------------------------------------------------------
 264 // wxNativeEncodingInfo
 265 // ----------------------------------------------------------------------------
 266
 267 // convert to/from the string representation: format is
 268 //      encodingid;registry;encoding[;facename]
 269 bool wxNativeEncodingInfo::FromString(const wxString& s)
 270 {
 271     // use ";", not "-" because it may be part of encoding name
 272     wxStringTokenizer tokenizer(s, _T(";"));
 273
 274     wxString encid = tokenizer.GetNextToken();
 275     long enc;
 276     if ( !encid.ToLong(&enc) )
 277         return FALSE;
 278     encoding = (wxFontEncoding)enc;
 279
 280     xregistry = tokenizer.GetNextToken();
 281     if ( !xregistry )
 282         return FALSE;
 283
 284     xencoding = tokenizer.GetNextToken();
 285     if ( !xencoding )
 286         return FALSE;
 287
 288     // ok even if empty
 289     facename = tokenizer.GetNextToken();
 290
 291     return TRUE;
 292 }
 293
 294 wxString wxNativeEncodingInfo::ToString() const
 295 {
 296     wxString s;
 297     s << (long)encoding << _T(';') << xregistry << _T(';') << xencoding;
 298     if ( !!facename )
 299     {
 300         s << _T(';') << facename;
 301     }
 302
 303     return s;
 304 }
 305
 306 // ----------------------------------------------------------------------------
 307 // wxNativeFontInfo
 308 // ----------------------------------------------------------------------------
 309
 310 void wxNativeFontInfo::Init()
 311 {
 312     m_isDefault = TRUE;
 313 }
 314
 315 bool wxNativeFontInfo::FromString(const wxString& s)
 316 {
 317     wxStringTokenizer tokenizer(s, _T(";"));
 318
 319     // check the version
 320     wxString token = tokenizer.GetNextToken();
 321     if ( token != _T('0') )
 322         return FALSE;
 323
 324     xFontName = tokenizer.GetNextToken();
 325
 326     // this should be the end
 327     if ( tokenizer.HasMoreTokens() )
 328         return FALSE;
 329
 330     return FromXFontName(xFontName);
 331 }
 332
 333 wxString wxNativeFontInfo::ToString() const
 334 {
 335     // 0 is the version
 336     return wxString::Format(_T("%d;%s"), 0, GetXFontName().c_str());
 337 }
 338
 339 bool wxNativeFontInfo::FromUserString(const wxString& s)
 340 {
 341     return FromXFontName(s);
 342 }
 343
 344 wxString wxNativeFontInfo::ToUserString() const
 345 {
 346     return GetXFontName();
 347 }
 348
 349 bool wxNativeFontInfo::HasElements() const
 350 {
 351     // we suppose that the foundry is never empty, so if it is it means that we
 352     // had never parsed the XLFD
 353     return !fontElements[0].empty();
 354 }
 355
 356 wxString wxNativeFontInfo::GetXFontComponent(wxXLFDField field) const
 357 {
 358     wxCHECK_MSG( field < wxXLFD_MAX, _T(""), _T("invalid XLFD field") );
 359
 360     if ( !HasElements() )
 361     {
 362         // const_cast
 363         if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) )
 364             return _T("");
 365     }
 366
 367     return fontElements[field];
 368 }
 369
 370 bool wxNativeFontInfo::FromXFontName(const wxString& fontname)
 371 {
 372     // TODO: we should be able to handle the font aliases here, but how?
 373     wxStringTokenizer tokenizer(fontname, _T("-"));
 374
 375     // skip the leading, usually empty field (font name registry)
 376     if ( !tokenizer.HasMoreTokens() )
 377         return FALSE;
 378
 379     (void)tokenizer.GetNextToken();
 380
 381     for ( size_t n = 0; n < WXSIZEOF(fontElements); n++ )
 382     {
 383         if ( !tokenizer.HasMoreTokens() )
 384         {
 385             // not enough elements in the XLFD - or maybe an alias
 386             return FALSE;
 387         }
 388
 389         fontElements[n] = tokenizer.GetNextToken();
 390     }
 391
 392     // this should be all
 393     if ( tokenizer.HasMoreTokens() )
 394         return FALSE;
 395
 396     // we're initialized now
 397     m_isDefault = FALSE;
 398
 399     return TRUE;
 400 }
 401
 402 wxString wxNativeFontInfo::GetXFontName() const
 403 {
 404     if ( xFontName.empty() )
 405     {
 406         for ( size_t n = 0; n < WXSIZEOF(fontElements); n++ )
 407         {
 408             // replace the non specified elements with '*' except for the
 409             // additional style which is usually just omitted
 410             wxString elt = fontElements[n];
 411             if ( elt.empty() && n != wxXLFD_ADDSTYLE )
 412             {
 413                 elt = _T('*');
 414             }
 415
 416             // const_cast
 417             ((wxNativeFontInfo *)this)->xFontName << _T('-') << elt;
 418         }
 419     }
 420
 421     return xFontName;
 422 }
 423
 424 void
 425 wxNativeFontInfo::SetXFontComponent(wxXLFDField field, const wxString& value)
 426 {
 427     wxCHECK_RET( field < wxXLFD_MAX, _T("invalid XLFD field") );
 428
 429     // this class should be initialized with a valid font spec first and only
 430     // then the fields may be modified!
 431     wxASSERT_MSG( !IsDefault(), _T("can't modify an uninitialized XLFD") );
 432
 433     if ( !HasElements() )
 434     {
 435         // const_cast
 436         if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) )
 437         {
 438             wxFAIL_MSG( _T("can't set font element for invalid XLFD") );
 439
 440             return;
 441         }
 442     }
 443
 444     fontElements[field] = value;
 445
 446     // invalidate the XFLD, it doesn't correspond to the font elements any more
 447     xFontName.clear();
 448 }
 449
 450 void wxNativeFontInfo::SetXFontName(const wxString& xFontName_)
 451 {
 452     // invalidate the font elements, GetXFontComponent() will reparse the XLFD
 453     fontElements[0].clear();
 454
 455     xFontName = xFontName_;
 456
 457     m_isDefault = FALSE;
 458 }
 459
 460 int wxNativeFontInfo::GetPointSize() const
 461 {
 462     const wxString s = GetXFontComponent(wxXLFD_POINTSIZE);
 463
 464     // return -1 to indicate that the size is unknown
 465     long l;
 466     return s.ToLong(&l) ? l : -1;
 467 }
 468
 469 wxFontStyle wxNativeFontInfo::GetStyle() const
 470 {
 471     const wxString s = GetXFontComponent(wxXLFD_SLANT);
 472
 473     if ( s.length() != 1 )
 474     {
 475         // it is really unknown but we don't have any way to return it from
 476         // here
 477         return wxFONTSTYLE_NORMAL;
 478     }
 479
 480     switch ( s[0] )
 481     {
 482         default:
 483             // again, unknown but consider normal by default
 484
 485         case _T('r'):
 486             return wxFONTSTYLE_NORMAL;
 487
 488         case _T('i'):
 489             return wxFONTSTYLE_ITALIC;
 490
 491         case _T('o'):
 492             return wxFONTSTYLE_SLANT;
 493     }
 494 }
 495
 496 wxFontWeight wxNativeFontInfo::GetWeight() const
 497 {
 498     const wxString s = GetXFontComponent(wxXLFD_WEIGHT).MakeLower();
 499     if ( s.find(_T("bold")) != wxString::npos || s == _T("black") )
 500         return wxFONTWEIGHT_BOLD;
 501     else if ( s == _T("light") )
 502         return wxFONTWEIGHT_LIGHT;
 503
 504     return wxFONTWEIGHT_NORMAL;
 505 }
 506
 507 bool wxNativeFontInfo::GetUnderlined() const
 508 {
 509     // X fonts are never underlined
 510     return FALSE;
 511 }
 512
 513 wxString wxNativeFontInfo::GetFaceName() const
 514 {
 515     // wxWindows facename probably more accurately corresponds to X family
 516     return GetXFontComponent(wxXLFD_FAMILY);
 517 }
 518
 519 wxFontFamily wxNativeFontInfo::GetFamily() const
 520 {
 521     // and wxWindows family -- to X foundry, but we have to translate it to
 522     // wxFontFamily somehow...
 523     wxFAIL_MSG(_T("not implemented")); // GetXFontComponent(wxXLFD_FOUNDRY);
 524
 525     return wxFONTFAMILY_DEFAULT;
 526 }
 527
 528 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 529 {
 530     // we already have the code for this but need to refactor it first
 531     wxFAIL_MSG( _T("not implemented") );
 532
 533     return wxFONTENCODING_MAX;
 534 }
 535
 536 void wxNativeFontInfo::SetPointSize(int pointsize)
 537 {
 538     SetXFontComponent(wxXLFD_POINTSIZE, wxString::Format(_T("%d"), pointsize));
 539 }
 540
 541 void wxNativeFontInfo::SetStyle(wxFontStyle style)
 542 {
 543     wxString s;
 544     switch ( style )
 545     {
 546         case wxFONTSTYLE_ITALIC:
 547             s = _T('i');
 548             break;
 549
 550         case wxFONTSTYLE_SLANT:
 551             s = _T('o');
 552             break;
 553
 554         case wxFONTSTYLE_NORMAL:
 555             s = _T('r');
 556
 557         default:
 558             wxFAIL_MSG( _T("unknown wxFontStyle in wxNativeFontInfo::SetStyle") );
 559             return;
 560     }
 561
 562     SetXFontComponent(wxXLFD_SLANT, s);
 563 }
 564
 565 void wxNativeFontInfo::SetWeight(wxFontWeight weight)
 566 {
 567     wxString s;
 568     switch ( weight )
 569     {
 570         case wxFONTWEIGHT_BOLD:
 571             s = _T("bold");
 572             break;
 573
 574         case wxFONTWEIGHT_LIGHT:
 575             s = _T("light");
 576             break;
 577
 578         case wxFONTWEIGHT_NORMAL:
 579             s = _T("medium");
 580             break;
 581
 582         default:
 583             wxFAIL_MSG( _T("unknown wxFontWeight in wxNativeFontInfo::SetWeight") );
 584             return;
 585     }
 586
 587     SetXFontComponent(wxXLFD_WEIGHT, s);
 588 }
 589
 590 void wxNativeFontInfo::SetUnderlined(bool WXUNUSED(underlined))
 591 {
 592     // can't do this under X
 593 }
 594
 595 void wxNativeFontInfo::SetFaceName(wxString facename)
 596 {
 597     SetXFontComponent(wxXLFD_FAMILY, facename);
 598 }
 599
 600 void wxNativeFontInfo::SetFamily(wxFontFamily family)
 601 {
 602     // wxFontFamily -> X foundry, anyone?
 603     wxFAIL_MSG( _T("not implemented") );
 604
 605     // SetXFontComponent(wxXLFD_FOUNDRY, ...);
 606 }
 607
 608 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding)
 609 {
 610     wxNativeEncodingInfo info;
 611     if ( wxGetNativeFontEncoding(encoding, &info) )
 612     {
 613         SetXFontComponent(wxXLFD_ENCODING, info.xencoding);
 614         SetXFontComponent(wxXLFD_REGISTRY, info.xregistry);
 615     }
 616 }
 617
 618 // ----------------------------------------------------------------------------
 619 // common functions
 620 // ----------------------------------------------------------------------------
 621
 622 bool wxGetNativeFontEncoding(wxFontEncoding encoding,
 623                              wxNativeEncodingInfo *info)
 624 {
 625     wxCHECK_MSG( info, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
 626
 627     if ( encoding == wxFONTENCODING_DEFAULT )
 628     {
 629         encoding = wxFont::GetDefaultEncoding();
 630     }
 631
 632     switch ( encoding )
 633     {
 634         case wxFONTENCODING_ISO8859_1:
 635         case wxFONTENCODING_ISO8859_2:
 636         case wxFONTENCODING_ISO8859_3:
 637         case wxFONTENCODING_ISO8859_4:
 638         case wxFONTENCODING_ISO8859_5:
 639         case wxFONTENCODING_ISO8859_6:
 640         case wxFONTENCODING_ISO8859_7:
 641         case wxFONTENCODING_ISO8859_8:
 642         case wxFONTENCODING_ISO8859_9:
 643         case wxFONTENCODING_ISO8859_10:
 644         case wxFONTENCODING_ISO8859_11:
 645         case wxFONTENCODING_ISO8859_12:
 646         case wxFONTENCODING_ISO8859_13:
 647         case wxFONTENCODING_ISO8859_14:
 648         case wxFONTENCODING_ISO8859_15:
 649             {
 650                 int cp = encoding - wxFONTENCODING_ISO8859_1 + 1;
 651                 info->xregistry = wxT("iso8859");
 652                 info->xencoding.Printf(wxT("%d"), cp);
 653             }
 654             break;
 655
 656         case wxFONTENCODING_UTF8:
 657             info->xregistry = wxT("iso10646");
 658             info->xencoding = wxT("*");
 659             break;
 660
 661         case wxFONTENCODING_GB2312:
 662             info->xregistry = wxT("GB2312");   // or the otherway round?
 663             info->xencoding = wxT("*");
 664             break;
 665
 666         case wxFONTENCODING_KOI8:
 667             info->xregistry = wxT("koi8");
 668
 669             // we don't make distinction between koi8-r, koi8-u and koi8-ru (so far)
 670             info->xencoding = wxT("*");
 671             break;
 672
 673         case wxFONTENCODING_CP1250:
 674         case wxFONTENCODING_CP1251:
 675         case wxFONTENCODING_CP1252:
 676         case wxFONTENCODING_CP1253:
 677         case wxFONTENCODING_CP1254:
 678         case wxFONTENCODING_CP1255:
 679         case wxFONTENCODING_CP1256:
 680         case wxFONTENCODING_CP1257:
 681             {
 682                 int cp = encoding - wxFONTENCODING_CP1250 + 1250;
 683                 info->xregistry = wxT("microsoft");
 684                 info->xencoding.Printf(wxT("cp%d"), cp);
 685             }
 686             break;
 687
 688         case wxFONTENCODING_SYSTEM:
 689             info->xregistry =
 690             info->xencoding = wxT("*");
 691             break;
 692
 693         default:
 694             // don't know how to translate this encoding into X fontspec
 695             return FALSE;
 696     }
 697
 698     info->encoding = encoding;
 699
 700     return TRUE;
 701 }
 702
 703 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
 704 {
 705     wxString fontspec;
 706     fontspec.Printf(_T("-*-%s-*-*-*-*-*-*-*-*-*-*-%s-%s"),
 707                     !info.facename ? _T("*") : info.facename.c_str(),
 708                     info.xregistry.c_str(),
 709                     info.xencoding.c_str());
 710
 711     return wxTestFontSpec(fontspec);
 712 }
 713
 714 // ----------------------------------------------------------------------------
 715 // X-specific functions
 716 // ----------------------------------------------------------------------------
 717
 718 wxNativeFont wxLoadQueryNearestFont(int pointSize,
 719                                     int family,
 720                                     int style,
 721                                     int weight,
 722                                     bool underlined,
 723                                     const wxString &facename,
 724                                     wxFontEncoding encoding,
 725                                     wxString* xFontName)
 726 {
 727     if ( encoding == wxFONTENCODING_DEFAULT )
 728     {
 729         encoding = wxFont::GetDefaultEncoding();
 730     }
 731
 732     // first determine the encoding - if the font doesn't exist at all in this
 733     // encoding, it's useless to do all other approximations (i.e. size,
 734     // family &c don't matter much)
 735     wxNativeEncodingInfo info;
 736     if ( encoding == wxFONTENCODING_SYSTEM )
 737     {
 738         // This will always work so we don't test to save time
 739         wxGetNativeFontEncoding(wxFONTENCODING_SYSTEM, &info);
 740     }
 741     else
 742     {
 743         if ( !wxGetNativeFontEncoding(encoding, &info) ||
 744              !wxTestFontEncoding(info) )
 745         {
 746 #if wxUSE_FONTMAP
 747             if ( !wxFontMapper::Get()->GetAltForEncoding(encoding, &info) )
 748 #endif // wxUSE_FONTMAP
 749             {
 750                 // unspported encoding - replace it with the default
 751                 //
 752                 // NB: we can't just return 0 from here because wxGTK code doesn't
 753                 //     check for it (i.e. it supposes that we'll always succeed),
 754                 //     so it would provoke a crash
 755                 wxGetNativeFontEncoding(wxFONTENCODING_SYSTEM, &info);
 756             }
 757         }
 758     }
 759
 760     // OK, we have the correct xregistry/xencoding in info structure
 761     wxNativeFont font = 0;
 762
 763     // if we already have the X font name, try to use it
 764     if( xFontName && !xFontName->IsEmpty() )
 765     {
 766         //
 767         //  Make sure point size is correct for scale factor.
 768         //
 769         wxStringTokenizer tokenizer(*xFontName, _T("-"), wxTOKEN_RET_DELIMS);
 770         wxString newFontName;
 771
 772         for(int i = 0; i < 8; i++)
 773           newFontName += tokenizer.NextToken();
 774
 775         (void) tokenizer.NextToken();
 776
 777         newFontName += wxString::Format(wxT("%d-"), pointSize);
 778
 779         while(tokenizer.HasMoreTokens())
 780           newFontName += tokenizer.GetNextToken();
 781
 782         font = wxLoadFont(newFontName);
 783
 784         if(font)
 785           *xFontName = newFontName;
 786     }
 787
 788     // try to load exactly the font requested first
 789     if( !font )
 790     {
 791         font = wxLoadQueryFont( pointSize, family, style, weight,
 792                                 underlined, facename,
 793                                 info.xregistry, info.xencoding,
 794                                 xFontName );
 795     }
 796
 797     if ( !font )
 798     {
 799         // search up and down by stepsize 10
 800         int max_size = pointSize + 20 * (1 + (pointSize/180));
 801         int min_size = pointSize - 20 * (1 + (pointSize/180));
 802
 803         int i;
 804
 805         // Search for smaller size (approx.)
 806         for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 )
 807         {
 808             font = wxLoadQueryFont(i, family, style, weight, underlined,
 809                                    facename, info.xregistry, info.xencoding,
 810                                    xFontName);
 811         }
 812
 813         // Search for larger size (approx.)
 814         for ( i = pointSize + 10; !font && i <= max_size; i += 10 )
 815         {
 816             font = wxLoadQueryFont(i, family, style, weight, underlined,
 817                                    facename, info.xregistry, info.xencoding,
 818                                    xFontName);
 819         }
 820
 821         // Try default family
 822         if ( !font && family != wxDEFAULT )
 823         {
 824             font = wxLoadQueryFont(pointSize, wxDEFAULT, style, weight,
 825                                    underlined, facename,
 826                                    info.xregistry, info.xencoding,
 827                                    xFontName );
 828         }
 829
 830         // ignore size, family, style and weight but try to find font with the
 831         // given facename and encoding
 832         if ( !font )
 833         {
 834             font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
 835                                    underlined, facename,
 836                                    info.xregistry, info.xencoding,
 837                                    xFontName);
 838
 839             // ignore family as well
 840             if ( !font )
 841             {
 842                 font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
 843                                        underlined, wxEmptyString,
 844                                        info.xregistry, info.xencoding,
 845                                        xFontName);
 846
 847                 // if it still failed, try to get the font of any size but
 848                 // with the requested encoding: this can happen if the
 849                 // encoding is only available in one size which happens to be
 850                 // different from 120
 851                 if ( !font )
 852                 {
 853                     font = wxLoadQueryFont(-1, wxDEFAULT, wxNORMAL, wxNORMAL,
 854                                            FALSE, wxEmptyString,
 855                                            info.xregistry, info.xencoding,
 856                                            xFontName);
 857
 858                     // this should never happen as we had tested for it in the
 859                     // very beginning, but if it does, do return something non
 860                     // NULL or we'd crash in wxFont code
 861                     if ( !font )
 862                     {
 863                         wxFAIL_MSG( _T("this encoding should be available!") );
 864
 865                         font = wxLoadQueryFont(-1,
 866                                                wxDEFAULT, wxNORMAL, wxNORMAL,
 867                                                FALSE, wxEmptyString,
 868                                                _T("*"), _T("*"),
 869                                                xFontName);
 870                     }
 871                 }
 872             }
 873         }
 874     }
 875
 876     return font;
 877 }
 878
 879 // ----------------------------------------------------------------------------
 880 // private functions
 881 // ----------------------------------------------------------------------------
 882
 883 // returns TRUE if there are any fonts matching this font spec
 884 static bool wxTestFontSpec(const wxString& fontspec)
 885 {
 886     // some X servers will fail to load this font because there are too many
 887     // matches so we must test explicitly for this
 888     if ( fontspec == _T("-*-*-*-*-*-*-*-*-*-*-*-*-*-*") )
 889     {
 890         return TRUE;
 891     }
 892
 893     wxNativeFont test = (wxNativeFont) g_fontHash->Get( fontspec );
 894     if (test)
 895     {
 896         return TRUE;
 897     }
 898
 899     test = wxLoadFont(fontspec);
 900     g_fontHash->Put( fontspec, (wxObject*) test );
 901
 902     if ( test )
 903     {
 904         wxFreeFont(test);
 905
 906         return TRUE;
 907     }
 908     else
 909     {
 910         return FALSE;
 911     }
 912 }
 913
 914 static wxNativeFont wxLoadQueryFont(int pointSize,
 915                                     int family,
 916                                     int style,
 917                                     int weight,
 918                                     bool WXUNUSED(underlined),
 919                                     const wxString& facename,
 920                                     const wxString& xregistry,
 921                                     const wxString& xencoding,
 922                                     wxString* xFontName)
 923 {
 924     wxString xfamily;
 925     switch (family)
 926     {
 927         case wxDECORATIVE: xfamily = wxT("lucida"); break;
 928         case wxROMAN:      xfamily = wxT("times");  break;
 929         case wxMODERN:     xfamily = wxT("courier"); break;
 930         case wxSWISS:      xfamily = wxT("helvetica"); break;
 931         case wxTELETYPE:   xfamily = wxT("lucidatypewriter"); break;
 932         case wxSCRIPT:     xfamily = wxT("utopia"); break;
 933         default:           xfamily = wxT("*");
 934     }
 935 #if wxUSE_NANOX
 936     int xweight;
 937     switch (weight)
 938     {
 939          case wxBOLD:
 940              {
 941                  xweight = MWLF_WEIGHT_BOLD;
 942                  break;
 943              }
 944         case wxLIGHT:
 945              {
 946                  xweight = MWLF_WEIGHT_LIGHT;
 947                  break;
 948              }
 949          case wxNORMAL:
 950              {
 951                  xweight = MWLF_WEIGHT_NORMAL;
 952                  break;
 953              }
 954
 955      default:
 956              {
 957                  xweight = MWLF_WEIGHT_DEFAULT;
 958                  break;
 959              }
 960     }
 961     GR_SCREEN_INFO screenInfo;
 962     GrGetScreenInfo(& screenInfo);
 963
 964     int yPixelsPerCM = screenInfo.ydpcm;
 965
 966     // A point is 1/72 of an inch.
 967     // An inch is 2.541 cm.
 968     // So pixelHeight = (pointSize / 72) (inches) * 2.541 (for cm) * yPixelsPerCM (for pixels)
 969     // In fact pointSize is 10 * the normal point size so
 970     // divide by 10.
 971
 972     int pixelHeight = (int) ( (((float)pointSize) / 720.0) * 2.541 * (float) yPixelsPerCM) ;
 973
 974     // An alternative: assume that the screen is 72 dpi.
 975     //int pixelHeight = (int) (((float)pointSize / 720.0) * 72.0) ;
 976     //int pixelHeight = (int) ((float)pointSize / 10.0) ;
 977
 978     GR_LOGFONT logFont;
 979     logFont.lfHeight = pixelHeight;
 980     logFont.lfWidth = 0;
 981     logFont.lfEscapement = 0;
 982     logFont.lfOrientation = 0;
 983     logFont.lfWeight = xweight;
 984     logFont.lfItalic = (style == wxNORMAL ? 0 : 1) ;
 985     logFont.lfUnderline = 0;
 986     logFont.lfStrikeOut = 0;
 987     logFont.lfCharSet = MWLF_CHARSET_DEFAULT; // TODO: select appropriate one
 988     logFont.lfOutPrecision = MWLF_TYPE_DEFAULT;
 989     logFont.lfClipPrecision = 0; // Not used
 990     logFont.lfRoman = (family == wxROMAN ? 1 : 0) ;
 991     logFont.lfSerif = (family == wxSWISS ? 0 : 1) ;
 992     logFont.lfSansSerif = !logFont.lfSerif ;
 993     logFont.lfModern = (family == wxMODERN ? 1 : 0) ;
 994     logFont.lfProportional = (family == wxTELETYPE ? 0 : 1) ;
 995     logFont.lfOblique = 0;
 996     logFont.lfSmallCaps = 0;
 997     logFont.lfPitch = 0; // 0 = default
 998     strcpy(logFont.lfFaceName, facename.c_str());
 999
1000     XFontStruct* fontInfo = (XFontStruct*) malloc(sizeof(XFontStruct));
1001     fontInfo->fid = GrCreateFont((GR_CHAR*) facename.c_str(), pixelHeight, & logFont);
1002     GrGetFontInfo(fontInfo->fid, & fontInfo->info);
1003     return (wxNativeFont) fontInfo;
1004
1005 #else
1006     wxString fontSpec;
1007     if (!facename.IsEmpty())
1008     {
1009         fontSpec.Printf(wxT("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"),
1010                         facename.c_str());
1011
1012         if ( wxTestFontSpec(fontSpec) )
1013         {
1014             xfamily = facename;
1015         }
1016         //else: no such family, use default one instead
1017     }
1018
1019     wxString xstyle;
1020     switch (style)
1021     {
1022         case wxSLANT:
1023             fontSpec.Printf(wxT("-*-%s-*-o-*-*-*-*-*-*-*-*-*-*"),
1024                     xfamily.c_str());
1025             if ( wxTestFontSpec(fontSpec) )
1026             {
1027                 xstyle = wxT("o");
1028                 break;
1029             }
1030             // fall through - try wxITALIC now
1031
1032         case wxITALIC:
1033             fontSpec.Printf(wxT("-*-%s-*-i-*-*-*-*-*-*-*-*-*-*"),
1034                     xfamily.c_str());
1035             if ( wxTestFontSpec(fontSpec) )
1036             {
1037                 xstyle = wxT("i");
1038             }
1039             else if ( style == wxITALIC ) // and not wxSLANT
1040             {
1041                 // try wxSLANT
1042                 fontSpec.Printf(wxT("-*-%s-*-o-*-*-*-*-*-*-*-*-*-*"),
1043                         xfamily.c_str());
1044                 if ( wxTestFontSpec(fontSpec) )
1045                 {
1046                     xstyle = wxT("o");
1047                 }
1048                 else
1049                 {
1050                     // no italic, no slant - leave default
1051                     xstyle = wxT("*");
1052                 }
1053             }
1054             break;
1055
1056         default:
1057             wxFAIL_MSG(_T("unknown font style"));
1058             // fall back to normal
1059
1060         case wxNORMAL:
1061             xstyle = wxT("r");
1062             break;
1063     }
1064
1065     wxString xweight;
1066     switch (weight)
1067     {
1068          case wxBOLD:
1069              {
1070                   fontSpec.Printf(wxT("-*-%s-bold-*-*-*-*-*-*-*-*-*-*-*"),
1071                          xfamily.c_str());
1072                   if ( wxTestFontSpec(fontSpec) )
1073                   {
1074                        xweight = wxT("bold");
1075                        break;
1076                   }
1077                   fontSpec.Printf(wxT("-*-%s-heavy-*-*-*-*-*-*-*-*-*-*-*"),
1078                          xfamily.c_str());
1079                   if ( wxTestFontSpec(fontSpec) )
1080                   {
1081                        xweight = wxT("heavy");
1082                        break;
1083                   }
1084                   fontSpec.Printf(wxT("-*-%s-extrabold-*-*-*-*-*-*-*-*-*-*-*"),
1085                          xfamily.c_str());
1086                   if ( wxTestFontSpec(fontSpec) )
1087                   {
1088                       xweight = wxT("extrabold");
1089                       break;
1090                   }
1091                   fontSpec.Printf(wxT("-*-%s-demibold-*-*-*-*-*-*-*-*-*-*-*"),
1092                          xfamily.c_str());
1093                   if ( wxTestFontSpec(fontSpec) )
1094                   {
1095                       xweight = wxT("demibold");
1096                       break;
1097                   }
1098                   fontSpec.Printf(wxT("-*-%s-black-*-*-*-*-*-*-*-*-*-*-*"),
1099                          xfamily.c_str());
1100                   if ( wxTestFontSpec(fontSpec) )
1101                   {
1102                       xweight = wxT("black");
1103                       break;
1104                   }
1105                   fontSpec.Printf(wxT("-*-%s-ultrablack-*-*-*-*-*-*-*-*-*-*-*"),
1106                          xfamily.c_str());
1107                   if ( wxTestFontSpec(fontSpec) )
1108                   {
1109                       xweight = wxT("ultrablack");
1110                       break;
1111                   }
1112               }
1113               break;
1114         case wxLIGHT:
1115              {
1116                   fontSpec.Printf(wxT("-*-%s-light-*-*-*-*-*-*-*-*-*-*-*"),
1117                          xfamily.c_str());
1118                   if ( wxTestFontSpec(fontSpec) )
1119                   {
1120                        xweight = wxT("light");
1121                        break;
1122                   }
1123                   fontSpec.Printf(wxT("-*-%s-thin-*-*-*-*-*-*-*-*-*-*-*"),
1124                          xfamily.c_str());
1125                   if ( wxTestFontSpec(fontSpec) )
1126                   {
1127                        xweight = wxT("thin");
1128                        break;
1129                   }
1130              }
1131              break;
1132          case wxNORMAL:
1133              {
1134                   fontSpec.Printf(wxT("-*-%s-medium-*-*-*-*-*-*-*-*-*-*-*"),
1135                          xfamily.c_str());
1136                   if ( wxTestFontSpec(fontSpec) )
1137                   {
1138                        xweight = wxT("medium");
1139                        break;
1140                   }
1141                   fontSpec.Printf(wxT("-*-%s-normal-*-*-*-*-*-*-*-*-*-*-*"),
1142                          xfamily.c_str());
1143                   if ( wxTestFontSpec(fontSpec) )
1144                   {
1145                        xweight = wxT("normal");
1146                        break;
1147                   }
1148                   fontSpec.Printf(wxT("-*-%s-regular-*-*-*-*-*-*-*-*-*-*-*"),
1149                          xfamily.c_str());
1150                   if ( wxTestFontSpec(fontSpec) )
1151                   {
1152                       xweight = wxT("regular");
1153                       break;
1154                   }
1155                   xweight = wxT("*");
1156               }
1157               break;
1158         default:           xweight = wxT("*"); break;
1159     }
1160
1161     // if pointSize is -1, don't specify any
1162     wxString sizeSpec;
1163     if ( pointSize == -1 )
1164     {
1165         sizeSpec = _T('*');
1166     }
1167     else
1168     {
1169         sizeSpec.Printf(_T("%d"), pointSize);
1170     }
1171
1172     // construct the X font spec from our data
1173     fontSpec.Printf(wxT("-*-%s-%s-%s-normal-*-*-%s-*-*-*-*-%s-%s"),
1174                     xfamily.c_str(), xweight.c_str(), xstyle.c_str(),
1175                     sizeSpec.c_str(), xregistry.c_str(), xencoding.c_str());
1176
1177     if( xFontName )
1178         *xFontName = fontSpec;
1179
1180     return wxLoadFont(fontSpec);
1181 #endif
1182     // wxUSE_NANOX
1183 }
1184
1185 // ----------------------------------------------------------------------------
1186 // wxFontModule
1187 // ----------------------------------------------------------------------------
1188
1189 class wxFontModule : public wxModule
1190 {
1191 public:
1192     bool OnInit();
1193     void OnExit();
1194
1195 private:
1196     DECLARE_DYNAMIC_CLASS(wxFontModule)
1197 };
1198
1199 IMPLEMENT_DYNAMIC_CLASS(wxFontModule, wxModule)
1200
1201 bool wxFontModule::OnInit()
1202 {
1203     g_fontHash = new wxHashTable( wxKEY_STRING );
1204
1205     return TRUE;
1206 }
1207
1208 void wxFontModule::OnExit()
1209 {
1210     delete g_fontHash;
1211
1212     g_fontHash = (wxHashTable *)NULL;
1213 }
1214
1215 #endif // GTK 2.0/1.x
1216