src/os2/font.cpp

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