src/os2/font.cpp

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