src/unix/fontutil.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/unix/fontutil.cpp
   3 // Purpose:     Font helper functions for wxX11, wxGTK, wxMotif
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     05.11.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Vadim Zeitlin
   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/fontutil.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/app.h"
  31     #include "wx/font.h" // wxFont enums
  32     #include "wx/encinfo.h"
  33     #include "wx/hash.h"
  34     #include "wx/utils.h"       // for wxGetDisplay()
  35     #include "wx/module.h"
  36 #endif // PCH
  37
  38 #include "wx/fontmap.h"
  39 #include "wx/tokenzr.h"
  40 #include "wx/fontenum.h"
  41
  42 #if wxUSE_PANGO
  43
  44 #include "pango/pango.h"
  45
  46 #ifdef __WXGTK20__
  47     #include "wx/gtk/private.h"
  48     extern GtkWidget *wxGetRootWindow();
  49
  50     #define wxPANGO_CONV wxGTK_CONV_SYS
  51     #define wxPANGO_CONV_BACK wxGTK_CONV_BACK_SYS
  52 #else
  53     #include "wx/x11/private.h"
  54     #include "wx/gtk/private/string.h"
  55
  56     #define wxPANGO_CONV(s) (wxConvUTF8.cWX2MB((s)))
  57     #define wxPANGO_CONV_BACK(s) (wxConvUTF8.cMB2WX((s)))
  58 #endif
  59
  60 // ----------------------------------------------------------------------------
  61 // wxNativeFontInfo
  62 // ----------------------------------------------------------------------------
  63
  64 void wxNativeFontInfo::Init()
  65 {
  66     description = NULL;
  67 }
  68
  69 void wxNativeFontInfo::Init(const wxNativeFontInfo& info)
  70 {
  71     if (info.description)
  72         description = pango_font_description_copy(info.description);
  73     else
  74         description = NULL;
  75 }
  76
  77 void wxNativeFontInfo::Free()
  78 {
  79     if (description)
  80         pango_font_description_free(description);
  81 }
  82
  83 int wxNativeFontInfo::GetPointSize() const
  84 {
  85     return pango_font_description_get_size( description ) / PANGO_SCALE;
  86 }
  87
  88 wxFontStyle wxNativeFontInfo::GetStyle() const
  89 {
  90     wxFontStyle m_style = wxFONTSTYLE_NORMAL;
  91
  92     switch (pango_font_description_get_style( description ))
  93     {
  94         case PANGO_STYLE_NORMAL:
  95             m_style = wxFONTSTYLE_NORMAL;
  96             break;
  97         case PANGO_STYLE_ITALIC:
  98             m_style = wxFONTSTYLE_ITALIC;
  99             break;
 100         case PANGO_STYLE_OBLIQUE:
 101             m_style = wxFONTSTYLE_SLANT;
 102             break;
 103     }
 104
 105     return m_style;
 106 }
 107
 108 wxFontWeight wxNativeFontInfo::GetWeight() const
 109 {
 110     // We seem to currently initialize only by string.
 111     // In that case PANGO_FONT_MASK_WEIGHT is always set.
 112     // if (!(pango_font_description_get_set_fields(description) & PANGO_FONT_MASK_WEIGHT))
 113     //    return wxFONTWEIGHT_NORMAL;
 114
 115     PangoWeight pango_weight = pango_font_description_get_weight( description );
 116
 117     // Until the API can be changed the following ranges of weight values are used:
 118     // wxFONTWEIGHT_LIGHT:  100 .. 349 - range of 250
 119     // wxFONTWEIGHT_NORMAL: 350 .. 599 - range of 250
 120     // wxFONTWEIGHT_BOLD:   600 .. 900 - range of 301 (600 is "semibold" already)
 121
 122     if (pango_weight >= 600)
 123         return wxFONTWEIGHT_BOLD;
 124
 125     if (pango_weight < 350)
 126         return wxFONTWEIGHT_LIGHT;
 127
 128     return wxFONTWEIGHT_NORMAL;
 129 }
 130
 131 bool wxNativeFontInfo::GetUnderlined() const
 132 {
 133     return false;
 134 }
 135
 136 wxString wxNativeFontInfo::GetFaceName() const
 137 {
 138     // the Pango "family" is the wx "face name"
 139     return wxPANGO_CONV_BACK(pango_font_description_get_family(description));
 140 }
 141
 142 wxFontFamily wxNativeFontInfo::GetFamily() const
 143 {
 144     wxFontFamily ret = wxFONTFAMILY_UNKNOWN;
 145
 146     const char *family_name = pango_font_description_get_family( description );
 147
 148     // note: not passing -1 as the 2nd parameter to g_ascii_strdown to work
 149     // around a bug in the 64-bit glib shipped with solaris 10, -1 causes it
 150     // to try to allocate 2^32 bytes.
 151     if ( !family_name )
 152         return ret;
 153     wxGtkString family_text(g_ascii_strdown(family_name, strlen(family_name)));
 154
 155     // Check for some common fonts, to salvage what we can from the current
 156     // win32 centric wxFont API:
 157     if (strncasecmp( family_text, "monospace", 9 ) == 0)
 158         ret = wxFONTFAMILY_TELETYPE;    // begins with "Monospace"
 159     else if (strncasecmp( family_text, "courier", 7 ) == 0)
 160         ret = wxFONTFAMILY_TELETYPE;    // begins with "Courier"
 161 #if defined(__WXGTK20__) || defined(HAVE_PANGO_FONT_FAMILY_IS_MONOSPACE)
 162     else
 163 #ifdef __WXGTK20__
 164     if (!gtk_check_version(2,4,0))
 165 #endif
 166     {
 167         PangoFontFamily **families;
 168         PangoFontFamily  *family = NULL;
 169         int n_families;
 170         pango_context_list_families(
 171 #ifdef __WXGTK20__
 172                 gtk_widget_get_pango_context( wxGetRootWindow() ),
 173 #else
 174                 wxTheApp->GetPangoContext(),
 175 #endif
 176                 &families, &n_families);
 177
 178         for (int i = 0; i < n_families; ++i)
 179         {
 180             if (g_ascii_strcasecmp(pango_font_family_get_name( families[i] ),
 181                                    pango_font_description_get_family( description )) == 0 )
 182             {
 183                 family = families[i];
 184                 break;
 185             }
 186         }
 187
 188         g_free(families);
 189
 190         // Some gtk+ systems might query for a non-existing font from
 191         // wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) on initialization,
 192         // don't assert until wxSystemSettings::GetFont is checked for this - MR
 193         // wxASSERT_MSG( family, "No appropriate PangoFontFamily found for ::description" );
 194
 195         if (family != NULL && pango_font_family_is_monospace( family ))
 196             ret = wxFONTFAMILY_TELETYPE; // is deemed a monospace font by pango
 197     }
 198 #endif // GTK+ 2 || HAVE_PANGO_FONT_FAMILY_IS_MONOSPACE
 199
 200     if (ret == wxFONTFAMILY_UNKNOWN)
 201     {
 202         if (strstr( family_text, "sans" ) != NULL || strstr( family_text, "Sans" ) != NULL)
 203             // checked before serif, so that "* Sans Serif" fonts are detected correctly
 204             ret = wxFONTFAMILY_SWISS;       // contains "Sans"
 205         else if (strstr( family_text, "serif" ) != NULL || strstr( family_text, "Serif" ) != NULL)
 206             ret = wxFONTFAMILY_ROMAN;       // contains "Serif"
 207         else if (strncasecmp( family_text, "times", 5 ) == 0)
 208             ret = wxFONTFAMILY_ROMAN;       // begins with "Times"
 209         else if (strncasecmp( family_text, "old", 3 ) == 0)
 210             ret = wxFONTFAMILY_DECORATIVE;  // begins with "Old" - "Old English", "Old Town"
 211     }
 212
 213     return ret;
 214 }
 215
 216 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 217 {
 218     return wxFONTENCODING_SYSTEM;
 219 }
 220
 221 void wxNativeFontInfo::SetPointSize(int pointsize)
 222 {
 223     pango_font_description_set_size( description, pointsize * PANGO_SCALE );
 224 }
 225
 226 void wxNativeFontInfo::SetStyle(wxFontStyle style)
 227 {
 228     switch (style)
 229     {
 230         case wxFONTSTYLE_ITALIC:
 231             pango_font_description_set_style( description, PANGO_STYLE_ITALIC );
 232             break;
 233         case wxFONTSTYLE_SLANT:
 234             pango_font_description_set_style( description, PANGO_STYLE_OBLIQUE );
 235             break;
 236         default:
 237             wxFAIL_MSG( "unknown font style" );
 238             // fall through
 239         case wxFONTSTYLE_NORMAL:
 240             pango_font_description_set_style( description, PANGO_STYLE_NORMAL );
 241             break;
 242     }
 243 }
 244
 245 void wxNativeFontInfo::SetWeight(wxFontWeight weight)
 246 {
 247     switch (weight)
 248     {
 249         case wxFONTWEIGHT_BOLD:
 250             pango_font_description_set_weight(description, PANGO_WEIGHT_BOLD);
 251             break;
 252         case wxFONTWEIGHT_LIGHT:
 253             pango_font_description_set_weight(description, PANGO_WEIGHT_LIGHT);
 254             break;
 255         default:
 256             wxFAIL_MSG( "unknown font weight" );
 257             // fall through
 258         case wxFONTWEIGHT_NORMAL:
 259             pango_font_description_set_weight(description, PANGO_WEIGHT_NORMAL);
 260     }
 261 }
 262
 263 void wxNativeFontInfo::SetUnderlined(bool WXUNUSED(underlined))
 264 {
 265     // wxWindowDCImpl::DoDrawText will take care of rendering font with
 266     // the underline attribute!
 267     wxFAIL_MSG( "not implemented" );
 268 }
 269
 270 bool wxNativeFontInfo::SetFaceName(const wxString& facename)
 271 {
 272     pango_font_description_set_family(description, wxPANGO_CONV(facename));
 273
 274     // we return true because Pango doesn't tell us if the call failed or not;
 275     // instead on wxGTK wxFont::SetFaceName() will call wxFontBase::SetFaceName()
 276     // which does the check
 277     return true;
 278 }
 279
 280 void wxNativeFontInfo::SetFamily(wxFontFamily family)
 281 {
 282     wxArrayString facename;
 283
 284     // the list of fonts associated with a family was partially
 285     // taken from http://www.codestyle.org/css/font-family
 286
 287     switch ( family )
 288     {
 289         case wxFONTFAMILY_SCRIPT:
 290             // corresponds to the cursive font family in the page linked above
 291             facename.Add(wxS("URW Chancery L"));
 292             facename.Add(wxS("Comic Sans MS"));
 293             break;
 294
 295         case wxFONTFAMILY_DECORATIVE:
 296             // corresponds to the fantasy font family in the page linked above
 297             facename.Add(wxS("Impact"));
 298             break;
 299
 300         case wxFONTFAMILY_ROMAN:
 301             // corresponds to the serif font family in the page linked above
 302             facename.Add(wxS("Century Schoolbook L"));
 303             facename.Add(wxS("URW Bookman L"));
 304             facename.Add(wxS("URW Palladio L"));
 305             facename.Add(wxS("DejaVu Serif"));
 306             facename.Add(wxS("FreeSerif"));
 307             facename.Add(wxS("Times New Roman"));
 308             facename.Add(wxS("Times"));
 309             break;
 310
 311         case wxFONTFAMILY_TELETYPE:
 312         case wxFONTFAMILY_MODERN:
 313             // corresponds to the monospace font family in the page linked above
 314             facename.Add(wxS("DejaVu Sans Mono"));
 315             facename.Add(wxS("Nimbus Mono L"));
 316             facename.Add(wxS("Bitstream Vera Sans Mono"));
 317             facename.Add(wxS("Andale Mono"));
 318             facename.Add(wxS("Lucida Sans Typewriter"));
 319             facename.Add(wxS("FreeMono"));
 320             facename.Add(wxS("Courier New"));
 321             facename.Add(wxS("Courier"));
 322             break;
 323
 324         case wxFONTFAMILY_SWISS:
 325         case wxFONTFAMILY_DEFAULT:
 326         default:
 327             // corresponds to the sans-serif font family in the page linked above
 328             facename.Add(wxS("DejaVu Sans"));
 329             facename.Add(wxS("URW Gothic L"));
 330             facename.Add(wxS("Nimbus Sans L"));
 331             facename.Add(wxS("Bitstream Vera Sans"));
 332             facename.Add(wxS("Lucida Sans"));
 333             facename.Add(wxS("Arial"));
 334             facename.Add(wxS("FreeSans"));
 335             break;
 336     }
 337
 338     SetFaceName(facename);
 339 }
 340
 341 void wxNativeFontInfo::SetEncoding(wxFontEncoding WXUNUSED(encoding))
 342 {
 343     wxFAIL_MSG( "not implemented: Pango encoding is always UTF8" );
 344 }
 345
 346 bool wxNativeFontInfo::FromString(const wxString& s)
 347 {
 348     if (description)
 349         pango_font_description_free( description );
 350
 351     // there is a bug in at least pango <= 1.13 which makes it (or its backends)
 352     // segfault for very big point sizes and for negative point sizes.
 353     // To workaround that bug for pango <= 1.13
 354     // (see http://bugzilla.gnome.org/show_bug.cgi?id=340229)
 355     // we do the check on the size here using same (arbitrary) limits used by
 356     // pango > 1.13. Note that the segfault could happen also for pointsize
 357     // smaller than this limit !!
 358     wxString str(s);
 359     const size_t pos = str.find_last_of(wxS(" "));
 360     double size;
 361     if ( pos != wxString::npos && wxString(str, pos + 1).ToDouble(&size) )
 362     {
 363         wxString sizeStr;
 364         if ( size < 1 )
 365             sizeStr = wxS("1");
 366         else if ( size >= 1E6 )
 367             sizeStr = wxS("1E6");
 368
 369         if ( !sizeStr.empty() )
 370         {
 371             // replace the old size with the adjusted one
 372             str = wxString(s, 0, pos) + sizeStr;
 373         }
 374     }
 375
 376     description = pango_font_description_from_string(wxPANGO_CONV(str));
 377
 378 #if wxUSE_FONTENUM
 379     // ensure a valid facename is selected
 380     if (!wxFontEnumerator::IsValidFacename(GetFaceName()))
 381         SetFaceName(wxNORMAL_FONT->GetFaceName());
 382 #endif // wxUSE_FONTENUM
 383
 384     return true;
 385 }
 386
 387 wxString wxNativeFontInfo::ToString() const
 388 {
 389     wxGtkString str(pango_font_description_to_string( description ));
 390
 391     return wxPANGO_CONV_BACK(str);
 392 }
 393
 394 bool wxNativeFontInfo::FromUserString(const wxString& s)
 395 {
 396     return FromString( s );
 397 }
 398
 399 wxString wxNativeFontInfo::ToUserString() const
 400 {
 401     return ToString();
 402 }
 403
 404 #else // GTK+ 1.x
 405
 406 #ifdef __X__
 407     #ifdef __VMS__
 408         #pragma message disable nosimpint
 409     #endif
 410
 411     #include <X11/Xlib.h>
 412
 413     #ifdef __VMS__
 414         #pragma message enable nosimpint
 415     #endif
 416
 417 #elif defined(__WXGTK__)
 418     // we have to declare struct tm to avoid problems with first forward
 419     // declaring it in C code (glib.h included from gdk.h does it) and then
 420     // defining it when time.h is included from the headers below - this is
 421     // known not to work at least with Sun CC 6.01
 422     #include <time.h>
 423
 424     #include <gdk/gdk.h>
 425 #endif
 426
 427
 428 // ----------------------------------------------------------------------------
 429 // private data
 430 // ----------------------------------------------------------------------------
 431
 432 static wxHashTable *g_fontHash = NULL;
 433
 434 // ----------------------------------------------------------------------------
 435 // private functions
 436 // ----------------------------------------------------------------------------
 437
 438 // define the functions to create and destroy native fonts for this toolkit
 439 #ifdef __X__
 440     wxNativeFont wxLoadFont(const wxString& fontSpec)
 441     {
 442         return XLoadQueryFont((Display *)wxGetDisplay(), fontSpec);
 443     }
 444
 445     inline void wxFreeFont(wxNativeFont font)
 446     {
 447         XFreeFont((Display *)wxGetDisplay(), (XFontStruct *)font);
 448     }
 449 #elif defined(__WXGTK__)
 450     wxNativeFont wxLoadFont(const wxString& fontSpec)
 451     {
 452         // VZ: we should use gdk_fontset_load() instead of gdk_font_load()
 453         //     here to be able to display Japanese fonts correctly (at least
 454         //     this is what people report) but unfortunately doing it results
 455         //     in tons of warnings when using GTK with "normal" European
 456         //     languages and so we can't always do it and I don't know enough
 457         //     to determine when should this be done... (FIXME)
 458         return gdk_font_load( wxConvertWX2MB(fontSpec) );
 459     }
 460
 461     inline void wxFreeFont(wxNativeFont font)
 462     {
 463         gdk_font_unref(font);
 464     }
 465 #else
 466     #error "Unknown GUI toolkit"
 467 #endif
 468
 469 static bool wxTestFontSpec(const wxString& fontspec);
 470
 471 static wxNativeFont wxLoadQueryFont(int pointSize,
 472                                     int family,
 473                                     int style,
 474                                     int weight,
 475                                     bool underlined,
 476                                     const wxString& facename,
 477                                     const wxString& xregistry,
 478                                     const wxString& xencoding,
 479                                     wxString* xFontName);
 480
 481 // ============================================================================
 482 // implementation
 483 // ============================================================================
 484
 485 // ----------------------------------------------------------------------------
 486 // wxNativeEncodingInfo
 487 // ----------------------------------------------------------------------------
 488
 489 // convert to/from the string representation: format is
 490 //      encodingid;registry;encoding[;facename]
 491 bool wxNativeEncodingInfo::FromString(const wxString& s)
 492 {
 493     // use ";", not "-" because it may be part of encoding name
 494     wxStringTokenizer tokenizer(s, wxT(";"));
 495
 496     wxString encid = tokenizer.GetNextToken();
 497     long enc;
 498     if ( !encid.ToLong(&enc) )
 499         return false;
 500     encoding = (wxFontEncoding)enc;
 501
 502     xregistry = tokenizer.GetNextToken();
 503     if ( !xregistry )
 504         return false;
 505
 506     xencoding = tokenizer.GetNextToken();
 507     if ( !xencoding )
 508         return false;
 509
 510     // ok even if empty
 511     facename = tokenizer.GetNextToken();
 512
 513     return true;
 514 }
 515
 516 wxString wxNativeEncodingInfo::ToString() const
 517 {
 518     wxString s;
 519     s << (long)encoding << wxT(';') << xregistry << wxT(';') << xencoding;
 520     if ( !facename.empty() )
 521     {
 522         s << wxT(';') << facename;
 523     }
 524
 525     return s;
 526 }
 527
 528 // ----------------------------------------------------------------------------
 529 // wxNativeFontInfo
 530 // ----------------------------------------------------------------------------
 531
 532 void wxNativeFontInfo::Init()
 533 {
 534     m_isDefault = true;
 535 }
 536
 537 bool wxNativeFontInfo::FromString(const wxString& s)
 538 {
 539     wxStringTokenizer tokenizer(s, wxT(";"));
 540
 541     // check the version
 542     wxString token = tokenizer.GetNextToken();
 543     if ( token != wxT('0') )
 544         return false;
 545
 546     xFontName = tokenizer.GetNextToken();
 547
 548     // this should be the end
 549     if ( tokenizer.HasMoreTokens() )
 550         return false;
 551
 552     return FromXFontName(xFontName);
 553 }
 554
 555 wxString wxNativeFontInfo::ToString() const
 556 {
 557     // 0 is the version
 558     return wxString::Format(wxT("%d;%s"), 0, GetXFontName().c_str());
 559 }
 560
 561 bool wxNativeFontInfo::FromUserString(const wxString& s)
 562 {
 563     return FromXFontName(s);
 564 }
 565
 566 wxString wxNativeFontInfo::ToUserString() const
 567 {
 568     return GetXFontName();
 569 }
 570
 571 bool wxNativeFontInfo::HasElements() const
 572 {
 573     // we suppose that the foundry is never empty, so if it is it means that we
 574     // had never parsed the XLFD
 575     return !fontElements[0].empty();
 576 }
 577
 578 wxString wxNativeFontInfo::GetXFontComponent(wxXLFDField field) const
 579 {
 580     wxCHECK_MSG( field < wxXLFD_MAX, wxEmptyString, wxT("invalid XLFD field") );
 581
 582     if ( !HasElements() )
 583     {
 584         // const_cast
 585         if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) )
 586             return wxEmptyString;
 587     }
 588
 589     return fontElements[field];
 590 }
 591
 592 bool wxNativeFontInfo::FromXFontName(const wxString& fontname)
 593 {
 594     // TODO: we should be able to handle the font aliases here, but how?
 595     wxStringTokenizer tokenizer(fontname, wxT("-"));
 596
 597     // skip the leading, usually empty field (font name registry)
 598     if ( !tokenizer.HasMoreTokens() )
 599         return false;
 600
 601     (void)tokenizer.GetNextToken();
 602
 603     for ( size_t n = 0; n < WXSIZEOF(fontElements); n++ )
 604     {
 605         if ( !tokenizer.HasMoreTokens() )
 606         {
 607             // not enough elements in the XLFD - or maybe an alias
 608             return false;
 609         }
 610
 611         wxString field = tokenizer.GetNextToken();
 612         if ( !field.empty() && field != wxT('*') )
 613         {
 614             // we're really initialized now
 615             m_isDefault = false;
 616         }
 617
 618         fontElements[n] = field;
 619     }
 620
 621     // this should be all
 622     if ( tokenizer.HasMoreTokens() )
 623         return false;
 624
 625     return true;
 626 }
 627
 628 wxString wxNativeFontInfo::GetXFontName() const
 629 {
 630     if ( xFontName.empty() )
 631     {
 632         for ( size_t n = 0; n < WXSIZEOF(fontElements); n++ )
 633         {
 634             // replace the non specified elements with '*' except for the
 635             // additional style which is usually just omitted
 636             wxString elt = fontElements[n];
 637             if ( elt.empty() && n != wxXLFD_ADDSTYLE )
 638             {
 639                 elt = wxT('*');
 640             }
 641
 642             // const_cast
 643             ((wxNativeFontInfo *)this)->xFontName << wxT('-') << elt;
 644         }
 645     }
 646
 647     return xFontName;
 648 }
 649
 650 void
 651 wxNativeFontInfo::SetXFontComponent(wxXLFDField field, const wxString& value)
 652 {
 653     wxCHECK_RET( field < wxXLFD_MAX, wxT("invalid XLFD field") );
 654
 655     // this class should be initialized with a valid font spec first and only
 656     // then the fields may be modified!
 657     wxASSERT_MSG( !IsDefault(), wxT("can't modify an uninitialized XLFD") );
 658
 659     if ( !HasElements() )
 660     {
 661         // const_cast
 662         if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) )
 663         {
 664             wxFAIL_MSG( wxT("can't set font element for invalid XLFD") );
 665
 666             return;
 667         }
 668     }
 669
 670     fontElements[field] = value;
 671
 672     // invalidate the XFLD, it doesn't correspond to the font elements any more
 673     xFontName.clear();
 674 }
 675
 676 void wxNativeFontInfo::SetXFontName(const wxString& xFontName_)
 677 {
 678     // invalidate the font elements, GetXFontComponent() will reparse the XLFD
 679     fontElements[0].clear();
 680
 681     xFontName = xFontName_;
 682
 683     m_isDefault = false;
 684 }
 685
 686 int wxNativeFontInfo::GetPointSize() const
 687 {
 688     const wxString s = GetXFontComponent(wxXLFD_POINTSIZE);
 689
 690     // return -1 to indicate that the size is unknown
 691     long l;
 692     return s.ToLong(&l) ? l : -1;
 693 }
 694
 695 wxFontStyle wxNativeFontInfo::GetStyle() const
 696 {
 697     const wxString s = GetXFontComponent(wxXLFD_SLANT);
 698
 699     if ( s.length() != 1 )
 700     {
 701         // it is really unknown but we don't have any way to return it from
 702         // here
 703         return wxFONTSTYLE_NORMAL;
 704     }
 705
 706     switch ( s[0].GetValue() )
 707     {
 708         default:
 709             // again, unknown but consider normal by default
 710
 711         case wxT('r'):
 712             return wxFONTSTYLE_NORMAL;
 713
 714         case wxT('i'):
 715             return wxFONTSTYLE_ITALIC;
 716
 717         case wxT('o'):
 718             return wxFONTSTYLE_SLANT;
 719     }
 720 }
 721
 722 wxFontWeight wxNativeFontInfo::GetWeight() const
 723 {
 724     const wxString s = GetXFontComponent(wxXLFD_WEIGHT).MakeLower();
 725     if ( s.find(wxT("bold")) != wxString::npos || s == wxT("black") )
 726         return wxFONTWEIGHT_BOLD;
 727     else if ( s == wxT("light") )
 728         return wxFONTWEIGHT_LIGHT;
 729
 730     return wxFONTWEIGHT_NORMAL;
 731 }
 732
 733 bool wxNativeFontInfo::GetUnderlined() const
 734 {
 735     // X fonts are never underlined
 736     return false;
 737 }
 738
 739 wxString wxNativeFontInfo::GetFaceName() const
 740 {
 741     // wxWidgets facename probably more accurately corresponds to X family
 742     return GetXFontComponent(wxXLFD_FAMILY);
 743 }
 744
 745 wxFontFamily wxNativeFontInfo::GetFamily() const
 746 {
 747     // and wxWidgets family -- to X foundry, but we have to translate it to
 748     // wxFontFamily somehow...
 749     wxFAIL_MSG(wxT("not implemented")); // GetXFontComponent(wxXLFD_FOUNDRY);
 750
 751     return wxFONTFAMILY_DEFAULT;
 752 }
 753
 754 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 755 {
 756     // we already have the code for this but need to refactor it first
 757     wxFAIL_MSG( wxT("not implemented") );
 758
 759     return wxFONTENCODING_MAX;
 760 }
 761
 762 void wxNativeFontInfo::SetPointSize(int pointsize)
 763 {
 764     SetXFontComponent(wxXLFD_POINTSIZE, wxString::Format(wxT("%d"), pointsize));
 765 }
 766
 767 void wxNativeFontInfo::SetStyle(wxFontStyle style)
 768 {
 769     wxString s;
 770     switch ( style )
 771     {
 772         case wxFONTSTYLE_ITALIC:
 773             s = wxT('i');
 774             break;
 775
 776         case wxFONTSTYLE_SLANT:
 777             s = wxT('o');
 778             break;
 779
 780         case wxFONTSTYLE_NORMAL:
 781             s = wxT('r');
 782
 783         default:
 784             wxFAIL_MSG( wxT("unknown wxFontStyle in wxNativeFontInfo::SetStyle") );
 785             return;
 786     }
 787
 788     SetXFontComponent(wxXLFD_SLANT, s);
 789 }
 790
 791 void wxNativeFontInfo::SetWeight(wxFontWeight weight)
 792 {
 793     wxString s;
 794     switch ( weight )
 795     {
 796         case wxFONTWEIGHT_BOLD:
 797             s = wxT("bold");
 798             break;
 799
 800         case wxFONTWEIGHT_LIGHT:
 801             s = wxT("light");
 802             break;
 803
 804         case wxFONTWEIGHT_NORMAL:
 805             s = wxT("medium");
 806             break;
 807
 808         default:
 809             wxFAIL_MSG( wxT("unknown wxFontWeight in wxNativeFontInfo::SetWeight") );
 810             return;
 811     }
 812
 813     SetXFontComponent(wxXLFD_WEIGHT, s);
 814 }
 815
 816 void wxNativeFontInfo::SetUnderlined(bool WXUNUSED(underlined))
 817 {
 818     // can't do this under X
 819 }
 820
 821 bool wxNativeFontInfo::SetFaceName(const wxString& facename)
 822 {
 823     SetXFontComponent(wxXLFD_FAMILY, facename);
 824     return true;
 825 }
 826
 827 void wxNativeFontInfo::SetFamily(wxFontFamily WXUNUSED(family))
 828 {
 829     // wxFontFamily -> X foundry, anyone?
 830     wxFAIL_MSG( wxT("not implemented") );
 831
 832     // SetXFontComponent(wxXLFD_FOUNDRY, ...);
 833 }
 834
 835 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding)
 836 {
 837     wxNativeEncodingInfo info;
 838     if ( wxGetNativeFontEncoding(encoding, &info) )
 839     {
 840         SetXFontComponent(wxXLFD_ENCODING, info.xencoding);
 841         SetXFontComponent(wxXLFD_REGISTRY, info.xregistry);
 842     }
 843 }
 844
 845 // ----------------------------------------------------------------------------
 846 // common functions
 847 // ----------------------------------------------------------------------------
 848
 849 bool wxGetNativeFontEncoding(wxFontEncoding encoding,
 850                              wxNativeEncodingInfo *info)
 851 {
 852     wxCHECK_MSG( info, false, wxT("bad pointer in wxGetNativeFontEncoding") );
 853
 854     if ( encoding == wxFONTENCODING_DEFAULT )
 855     {
 856         encoding = wxFont::GetDefaultEncoding();
 857     }
 858
 859     switch ( encoding )
 860     {
 861         case wxFONTENCODING_ISO8859_1:
 862         case wxFONTENCODING_ISO8859_2:
 863         case wxFONTENCODING_ISO8859_3:
 864         case wxFONTENCODING_ISO8859_4:
 865         case wxFONTENCODING_ISO8859_5:
 866         case wxFONTENCODING_ISO8859_6:
 867         case wxFONTENCODING_ISO8859_7:
 868         case wxFONTENCODING_ISO8859_8:
 869         case wxFONTENCODING_ISO8859_9:
 870         case wxFONTENCODING_ISO8859_10:
 871         case wxFONTENCODING_ISO8859_11:
 872         case wxFONTENCODING_ISO8859_12:
 873         case wxFONTENCODING_ISO8859_13:
 874         case wxFONTENCODING_ISO8859_14:
 875         case wxFONTENCODING_ISO8859_15:
 876             {
 877                 int cp = encoding - wxFONTENCODING_ISO8859_1 + 1;
 878                 info->xregistry = wxT("iso8859");
 879                 info->xencoding.Printf(wxT("%d"), cp);
 880             }
 881             break;
 882
 883         case wxFONTENCODING_UTF8:
 884             info->xregistry = wxT("iso10646");
 885             info->xencoding = wxT("*");
 886             break;
 887
 888         case wxFONTENCODING_GB2312:
 889             info->xregistry = wxT("GB2312");   // or the otherway round?
 890             info->xencoding = wxT("*");
 891             break;
 892
 893         case wxFONTENCODING_KOI8:
 894         case wxFONTENCODING_KOI8_U:
 895             info->xregistry = wxT("koi8");
 896
 897             // we don't make distinction between koi8-r, koi8-u and koi8-ru (so far)
 898             info->xencoding = wxT("*");
 899             break;
 900
 901         case wxFONTENCODING_CP1250:
 902         case wxFONTENCODING_CP1251:
 903         case wxFONTENCODING_CP1252:
 904         case wxFONTENCODING_CP1253:
 905         case wxFONTENCODING_CP1254:
 906         case wxFONTENCODING_CP1255:
 907         case wxFONTENCODING_CP1256:
 908         case wxFONTENCODING_CP1257:
 909             {
 910                 int cp = encoding - wxFONTENCODING_CP1250 + 1250;
 911                 info->xregistry = wxT("microsoft");
 912                 info->xencoding.Printf(wxT("cp%d"), cp);
 913             }
 914             break;
 915
 916         case wxFONTENCODING_EUC_JP:
 917         case wxFONTENCODING_SHIFT_JIS:
 918             info->xregistry = "jis*";
 919             info->xencoding = "*";
 920             break;
 921
 922         case wxFONTENCODING_SYSTEM:
 923             info->xregistry =
 924             info->xencoding = wxT("*");
 925             break;
 926
 927         default:
 928             // don't know how to translate this encoding into X fontspec
 929             return false;
 930     }
 931
 932     info->encoding = encoding;
 933
 934     return true;
 935 }
 936
 937 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
 938 {
 939     wxString fontspec;
 940     fontspec.Printf(wxT("-*-%s-*-*-*-*-*-*-*-*-*-*-%s-%s"),
 941                     !info.facename ? wxT("*") : info.facename.c_str(),
 942                     info.xregistry.c_str(),
 943                     info.xencoding.c_str());
 944
 945     return wxTestFontSpec(fontspec);
 946 }
 947
 948 // ----------------------------------------------------------------------------
 949 // X-specific functions
 950 // ----------------------------------------------------------------------------
 951
 952 wxNativeFont wxLoadQueryNearestFont(int pointSize,
 953                                     int family,
 954                                     int style,
 955                                     int weight,
 956                                     bool underlined,
 957                                     const wxString &facename,
 958                                     wxFontEncoding encoding,
 959                                     wxString* xFontName)
 960 {
 961     if ( encoding == wxFONTENCODING_DEFAULT )
 962     {
 963         encoding = wxFont::GetDefaultEncoding();
 964     }
 965
 966     // first determine the encoding - if the font doesn't exist at all in this
 967     // encoding, it's useless to do all other approximations (i.e. size,
 968     // family &c don't matter much)
 969     wxNativeEncodingInfo info;
 970     if ( encoding == wxFONTENCODING_SYSTEM )
 971     {
 972         // This will always work so we don't test to save time
 973         wxGetNativeFontEncoding(wxFONTENCODING_SYSTEM, &info);
 974     }
 975     else
 976     {
 977         if ( !wxGetNativeFontEncoding(encoding, &info) ||
 978              !wxTestFontEncoding(info) )
 979         {
 980 #if wxUSE_FONTMAP
 981             if ( !wxFontMapper::Get()->GetAltForEncoding(encoding, &info) )
 982 #endif // wxUSE_FONTMAP
 983             {
 984                 // unspported encoding - replace it with the default
 985                 //
 986                 // NB: we can't just return 0 from here because wxGTK code doesn't
 987                 //     check for it (i.e. it supposes that we'll always succeed),
 988                 //     so it would provoke a crash
 989                 wxGetNativeFontEncoding(wxFONTENCODING_SYSTEM, &info);
 990             }
 991         }
 992     }
 993
 994     // OK, we have the correct xregistry/xencoding in info structure
 995     wxNativeFont font = 0;
 996
 997     // if we already have the X font name, try to use it
 998     if( xFontName && !xFontName->empty() )
 999     {
1000         //
1001         //  Make sure point size is correct for scale factor.
1002         //
1003         wxStringTokenizer tokenizer(*xFontName, wxT("-"), wxTOKEN_RET_DELIMS);
1004         wxString newFontName;
1005
1006         for(int i = 0; i < 8; i++)
1007           newFontName += tokenizer.NextToken();
1008
1009         (void) tokenizer.NextToken();
1010
1011         newFontName += wxString::Format(wxT("%d-"), pointSize);
1012
1013         while(tokenizer.HasMoreTokens())
1014           newFontName += tokenizer.GetNextToken();
1015
1016         font = wxLoadFont(newFontName);
1017
1018         if(font)
1019           *xFontName = newFontName;
1020     }
1021
1022     if ( !font )
1023     {
1024         // search up and down by stepsize 10
1025         int max_size = pointSize + 20 * (1 + (pointSize/180));
1026         int min_size = pointSize - 20 * (1 + (pointSize/180));
1027
1028         int i, round; // counters
1029
1030         // first round: search for equal, then for smaller and for larger size
1031         // with the given weight and style
1032         int testweight = weight;
1033         int teststyle = style;
1034
1035         for ( round = 0; round < 3; round++ )
1036         {
1037             // second round: use normal weight
1038             if ( round == 1 )
1039             {
1040                 if ( testweight != wxNORMAL )
1041                 {
1042                     testweight = wxNORMAL;
1043                 }
1044                 else
1045                 {
1046                     ++round; // fall through to third round
1047                 }
1048             }
1049
1050             // third round: ... and use normal style
1051             if ( round == 2 )
1052             {
1053                 if ( teststyle != wxNORMAL )
1054                 {
1055                     teststyle = wxNORMAL;
1056                 }
1057                 else
1058                 {
1059                     break;
1060                 }
1061             }
1062             // Search for equal or smaller size (approx.)
1063             for ( i = pointSize; !font && i >= 10 && i >= min_size; i -= 10 )
1064             {
1065                 font = wxLoadQueryFont(i, family, teststyle, testweight, underlined,
1066                                    facename, info.xregistry, info.xencoding,
1067                                    xFontName);
1068             }
1069
1070             // Search for larger size (approx.)
1071             for ( i = pointSize + 10; !font && i <= max_size; i += 10 )
1072             {
1073                 font = wxLoadQueryFont(i, family, teststyle, testweight, underlined,
1074                                    facename, info.xregistry, info.xencoding,
1075                                    xFontName);
1076             }
1077         }
1078
1079         // Try default family
1080         if ( !font && family != wxDEFAULT )
1081         {
1082             font = wxLoadQueryFont(pointSize, wxDEFAULT, style, weight,
1083                                    underlined, facename,
1084                                    info.xregistry, info.xencoding,
1085                                    xFontName );
1086         }
1087
1088         // ignore size, family, style and weight but try to find font with the
1089         // given facename and encoding
1090         if ( !font )
1091         {
1092             font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
1093                                    underlined, facename,
1094                                    info.xregistry, info.xencoding,
1095                                    xFontName);
1096
1097             // ignore family as well
1098             if ( !font )
1099             {
1100                 font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
1101                                        underlined, wxEmptyString,
1102                                        info.xregistry, info.xencoding,
1103                                        xFontName);
1104
1105                 // if it still failed, try to get the font of any size but
1106                 // with the requested encoding: this can happen if the
1107                 // encoding is only available in one size which happens to be
1108                 // different from 120
1109                 if ( !font )
1110                 {
1111                     font = wxLoadQueryFont(-1, wxDEFAULT, wxNORMAL, wxNORMAL,
1112                                            false, wxEmptyString,
1113                                            info.xregistry, info.xencoding,
1114                                            xFontName);
1115
1116                     // this should never happen as we had tested for it in the
1117                     // very beginning, but if it does, do return something non
1118                     // NULL or we'd crash in wxFont code
1119                     if ( !font )
1120                     {
1121                         wxFAIL_MSG( wxT("this encoding should be available!") );
1122
1123                         font = wxLoadQueryFont(-1,
1124                                                wxDEFAULT, wxNORMAL, wxNORMAL,
1125                                                false, wxEmptyString,
1126                                                wxT("*"), wxT("*"),
1127                                                xFontName);
1128                     }
1129                 }
1130             }
1131         }
1132     }
1133
1134     return font;
1135 }
1136
1137 // ----------------------------------------------------------------------------
1138 // private functions
1139 // ----------------------------------------------------------------------------
1140
1141 // returns true if there are any fonts matching this font spec
1142 static bool wxTestFontSpec(const wxString& fontspec)
1143 {
1144     // some X servers will fail to load this font because there are too many
1145     // matches so we must test explicitly for this
1146     if ( fontspec == wxT("-*-*-*-*-*-*-*-*-*-*-*-*-*-*") )
1147     {
1148         return true;
1149     }
1150
1151     wxNativeFont test = (wxNativeFont) g_fontHash->Get( fontspec );
1152     if (test)
1153     {
1154         return true;
1155     }
1156
1157     test = wxLoadFont(fontspec);
1158     g_fontHash->Put( fontspec, (wxObject*) test );
1159
1160     if ( test )
1161     {
1162         wxFreeFont(test);
1163
1164         return true;
1165     }
1166     else
1167     {
1168         return false;
1169     }
1170 }
1171
1172 static wxNativeFont wxLoadQueryFont(int pointSize,
1173                                     int family,
1174                                     int style,
1175                                     int weight,
1176                                     bool WXUNUSED(underlined),
1177                                     const wxString& facename,
1178                                     const wxString& xregistry,
1179                                     const wxString& xencoding,
1180                                     wxString* xFontName)
1181 {
1182     wxString xfamily;
1183     switch (family)
1184     {
1185         case wxDECORATIVE: xfamily = wxT("lucida"); break;
1186         case wxROMAN:      xfamily = wxT("times");  break;
1187         case wxMODERN:     xfamily = wxT("courier"); break;
1188         case wxSWISS:      xfamily = wxT("helvetica"); break;
1189         case wxTELETYPE:   xfamily = wxT("lucidatypewriter"); break;
1190         case wxSCRIPT:     xfamily = wxT("utopia"); break;
1191         default:           xfamily = wxT("*");
1192     }
1193 #if wxUSE_NANOX
1194     int xweight;
1195     switch (weight)
1196     {
1197          case wxBOLD:
1198              {
1199                  xweight = MWLF_WEIGHT_BOLD;
1200                  break;
1201              }
1202         case wxLIGHT:
1203              {
1204                  xweight = MWLF_WEIGHT_LIGHT;
1205                  break;
1206              }
1207          case wxNORMAL:
1208              {
1209                  xweight = MWLF_WEIGHT_NORMAL;
1210                  break;
1211              }
1212
1213      default:
1214              {
1215                  xweight = MWLF_WEIGHT_DEFAULT;
1216                  break;
1217              }
1218     }
1219     GR_SCREEN_INFO screenInfo;
1220     GrGetScreenInfo(& screenInfo);
1221
1222     int yPixelsPerCM = screenInfo.ydpcm;
1223
1224     // A point is 1/72 of an inch.
1225     // An inch is 2.541 cm.
1226     // So pixelHeight = (pointSize / 72) (inches) * 2.541 (for cm) * yPixelsPerCM (for pixels)
1227     // In fact pointSize is 10 * the normal point size so
1228     // divide by 10.
1229
1230     int pixelHeight = (int) ( (((float)pointSize) / 720.0) * 2.541 * (float) yPixelsPerCM) ;
1231
1232     // An alternative: assume that the screen is 72 dpi.
1233     //int pixelHeight = (int) (((float)pointSize / 720.0) * 72.0) ;
1234     //int pixelHeight = (int) ((float)pointSize / 10.0) ;
1235
1236     GR_LOGFONT logFont;
1237     logFont.lfHeight = pixelHeight;
1238     logFont.lfWidth = 0;
1239     logFont.lfEscapement = 0;
1240     logFont.lfOrientation = 0;
1241     logFont.lfWeight = xweight;
1242     logFont.lfItalic = (style == wxNORMAL ? 0 : 1) ;
1243     logFont.lfUnderline = 0;
1244     logFont.lfStrikeOut = 0;
1245     logFont.lfCharSet = MWLF_CHARSET_DEFAULT; // TODO: select appropriate one
1246     logFont.lfOutPrecision = MWLF_TYPE_DEFAULT;
1247     logFont.lfClipPrecision = 0; // Not used
1248     logFont.lfRoman = (family == wxROMAN ? 1 : 0) ;
1249     logFont.lfSerif = (family == wxSWISS ? 0 : 1) ;
1250     logFont.lfSansSerif = !logFont.lfSerif ;
1251     logFont.lfModern = (family == wxMODERN ? 1 : 0) ;
1252     logFont.lfProportional = (family == wxTELETYPE ? 0 : 1) ;
1253     logFont.lfOblique = 0;
1254     logFont.lfSmallCaps = 0;
1255     logFont.lfPitch = 0; // 0 = default
1256     strcpy(logFont.lfFaceName, facename.c_str());
1257
1258     XFontStruct* fontInfo = (XFontStruct*) malloc(sizeof(XFontStruct));
1259     fontInfo->fid = GrCreateFont((GR_CHAR*) facename.c_str(), pixelHeight, & logFont);
1260     GrGetFontInfo(fontInfo->fid, & fontInfo->info);
1261     return (wxNativeFont) fontInfo;
1262
1263 #else
1264     wxString fontSpec;
1265     if (!facename.empty())
1266     {
1267         fontSpec.Printf(wxT("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"),
1268                         facename.c_str());
1269
1270         if ( wxTestFontSpec(fontSpec) )
1271         {
1272             xfamily = facename;
1273         }
1274         //else: no such family, use default one instead
1275     }
1276
1277     wxString xstyle;
1278     switch (style)
1279     {
1280         case wxSLANT:
1281             fontSpec.Printf(wxT("-*-%s-*-o-*-*-*-*-*-*-*-*-*-*"),
1282                     xfamily.c_str());
1283             if ( wxTestFontSpec(fontSpec) )
1284             {
1285                 xstyle = wxT("o");
1286                 break;
1287             }
1288             // fall through - try wxITALIC now
1289
1290         case wxITALIC:
1291             fontSpec.Printf(wxT("-*-%s-*-i-*-*-*-*-*-*-*-*-*-*"),
1292                     xfamily.c_str());
1293             if ( wxTestFontSpec(fontSpec) )
1294             {
1295                 xstyle = wxT("i");
1296             }
1297             else if ( style == wxITALIC ) // and not wxSLANT
1298             {
1299                 // try wxSLANT
1300                 fontSpec.Printf(wxT("-*-%s-*-o-*-*-*-*-*-*-*-*-*-*"),
1301                         xfamily.c_str());
1302                 if ( wxTestFontSpec(fontSpec) )
1303                 {
1304                     xstyle = wxT("o");
1305                 }
1306                 else
1307                 {
1308                     // no italic, no slant - leave default
1309                     xstyle = wxT("*");
1310                 }
1311             }
1312             break;
1313
1314         default:
1315             wxFAIL_MSG(wxT("unknown font style"));
1316             // fall back to normal
1317
1318         case wxNORMAL:
1319             xstyle = wxT("r");
1320             break;
1321     }
1322
1323     wxString xweight;
1324     switch (weight)
1325     {
1326          case wxBOLD:
1327              {
1328                   fontSpec.Printf(wxT("-*-%s-bold-*-*-*-*-*-*-*-*-*-*-*"),
1329                          xfamily.c_str());
1330                   if ( wxTestFontSpec(fontSpec) )
1331                   {
1332                        xweight = wxT("bold");
1333                        break;
1334                   }
1335                   fontSpec.Printf(wxT("-*-%s-heavy-*-*-*-*-*-*-*-*-*-*-*"),
1336                          xfamily.c_str());
1337                   if ( wxTestFontSpec(fontSpec) )
1338                   {
1339                        xweight = wxT("heavy");
1340                        break;
1341                   }
1342                   fontSpec.Printf(wxT("-*-%s-extrabold-*-*-*-*-*-*-*-*-*-*-*"),
1343                          xfamily.c_str());
1344                   if ( wxTestFontSpec(fontSpec) )
1345                   {
1346                       xweight = wxT("extrabold");
1347                       break;
1348                   }
1349                   fontSpec.Printf(wxT("-*-%s-demibold-*-*-*-*-*-*-*-*-*-*-*"),
1350                          xfamily.c_str());
1351                   if ( wxTestFontSpec(fontSpec) )
1352                   {
1353                       xweight = wxT("demibold");
1354                       break;
1355                   }
1356                   fontSpec.Printf(wxT("-*-%s-black-*-*-*-*-*-*-*-*-*-*-*"),
1357                          xfamily.c_str());
1358                   if ( wxTestFontSpec(fontSpec) )
1359                   {
1360                       xweight = wxT("black");
1361                       break;
1362                   }
1363                   fontSpec.Printf(wxT("-*-%s-ultrablack-*-*-*-*-*-*-*-*-*-*-*"),
1364                          xfamily.c_str());
1365                   if ( wxTestFontSpec(fontSpec) )
1366                   {
1367                       xweight = wxT("ultrablack");
1368                       break;
1369                   }
1370               }
1371               break;
1372         case wxLIGHT:
1373              {
1374                   fontSpec.Printf(wxT("-*-%s-light-*-*-*-*-*-*-*-*-*-*-*"),
1375                          xfamily.c_str());
1376                   if ( wxTestFontSpec(fontSpec) )
1377                   {
1378                        xweight = wxT("light");
1379                        break;
1380                   }
1381                   fontSpec.Printf(wxT("-*-%s-thin-*-*-*-*-*-*-*-*-*-*-*"),
1382                          xfamily.c_str());
1383                   if ( wxTestFontSpec(fontSpec) )
1384                   {
1385                        xweight = wxT("thin");
1386                        break;
1387                   }
1388              }
1389              break;
1390          case wxNORMAL:
1391              {
1392                   fontSpec.Printf(wxT("-*-%s-medium-*-*-*-*-*-*-*-*-*-*-*"),
1393                          xfamily.c_str());
1394                   if ( wxTestFontSpec(fontSpec) )
1395                   {
1396                        xweight = wxT("medium");
1397                        break;
1398                   }
1399                   fontSpec.Printf(wxT("-*-%s-normal-*-*-*-*-*-*-*-*-*-*-*"),
1400                          xfamily.c_str());
1401                   if ( wxTestFontSpec(fontSpec) )
1402                   {
1403                        xweight = wxT("normal");
1404                        break;
1405                   }
1406                   fontSpec.Printf(wxT("-*-%s-regular-*-*-*-*-*-*-*-*-*-*-*"),
1407                          xfamily.c_str());
1408                   if ( wxTestFontSpec(fontSpec) )
1409                   {
1410                       xweight = wxT("regular");
1411                       break;
1412                   }
1413                   xweight = wxT("*");
1414               }
1415               break;
1416         default:           xweight = wxT("*"); break;
1417     }
1418
1419     // if pointSize is -1, don't specify any
1420     wxString sizeSpec;
1421     if ( pointSize == -1 )
1422     {
1423         sizeSpec = wxT('*');
1424     }
1425     else
1426     {
1427         sizeSpec.Printf(wxT("%d"), pointSize);
1428     }
1429
1430     // construct the X font spec from our data
1431     fontSpec.Printf(wxT("-*-%s-%s-%s-normal-*-*-%s-*-*-*-*-%s-%s"),
1432                     xfamily.c_str(), xweight.c_str(), xstyle.c_str(),
1433                     sizeSpec.c_str(), xregistry.c_str(), xencoding.c_str());
1434
1435     if( xFontName )
1436         *xFontName = fontSpec;
1437
1438     return wxLoadFont(fontSpec);
1439 #endif
1440     // wxUSE_NANOX
1441 }
1442
1443 // ----------------------------------------------------------------------------
1444 // wxFontModule
1445 // ----------------------------------------------------------------------------
1446
1447 class wxFontModule : public wxModule
1448 {
1449 public:
1450     bool OnInit();
1451     void OnExit();
1452
1453 private:
1454     DECLARE_DYNAMIC_CLASS(wxFontModule)
1455 };
1456
1457 IMPLEMENT_DYNAMIC_CLASS(wxFontModule, wxModule)
1458
1459 bool wxFontModule::OnInit()
1460 {
1461     g_fontHash = new wxHashTable( wxKEY_STRING );
1462
1463     return true;
1464 }
1465
1466 void wxFontModule::OnExit()
1467 {
1468     delete g_fontHash;
1469
1470     g_fontHash = NULL;
1471 }
1472
1473 #endif // GTK 2.0/1.x