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 // Copyright:   (c) David Webster
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 // ============================================================================
  15 // declarations
  16 // ============================================================================
  17
  18 // ----------------------------------------------------------------------------
  19 // headers
  20 // ----------------------------------------------------------------------------
  21
  22 #include "wx/font.h"
  23
  24 #ifndef WX_PRECOMP
  25     #include <stdio.h>
  26     #include "wx/list.h"
  27     #include "wx/utils.h"
  28     #include "wx/app.h"
  29     #include "wx/log.h"
  30 #endif // WX_PRECOMP
  31
  32 #include "wx/os2/private.h"
  33
  34 #include "wx/fontutil.h"
  35 #include "wx/fontmap.h"
  36 #include "wx/encinfo.h"
  37
  38 #include "wx/tokenzr.h"
  39
  40 #include <malloc.h>
  41
  42 // ----------------------------------------------------------------------------
  43 // wxFontRefData - the internal description of the font
  44 // ----------------------------------------------------------------------------
  45
  46 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
  47 {
  48 public:
  49     wxFontRefData()
  50     {
  51         Init(-1, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false,
  52              wxEmptyString, wxFONTENCODING_DEFAULT);
  53     }
  54
  55     wxFontRefData( int             nSize
  56                   ,wxFontFamily    nFamily
  57                   ,wxFontStyle     nStyle
  58                   ,wxFontWeight    nWeight
  59                   ,bool            bUnderlined
  60                   ,const wxString& sFaceName
  61                   ,wxFontEncoding  vEncoding
  62                  )
  63     {
  64         Init( nSize
  65              ,nFamily
  66              ,nStyle
  67              ,nWeight
  68              ,bUnderlined
  69              ,sFaceName
  70              ,vEncoding
  71             );
  72     }
  73
  74     wxFontRefData( const wxNativeFontInfo& rInfo
  75                   ,WXHFONT                 hFont = 0
  76                   ,WXHANDLE                hPS   = 0
  77                  )
  78     {
  79         Init( rInfo
  80              ,hFont
  81              ,hPS
  82             );
  83     }
  84
  85     wxFontRefData(const wxFontRefData& rData)
  86     {
  87         Init( rData.m_nPointSize
  88              ,rData.m_nFamily
  89              ,rData.m_nStyle
  90              ,rData.m_nWeight
  91              ,rData.m_bUnderlined
  92              ,rData.m_sFaceName
  93              ,rData.m_vEncoding
  94             );
  95         m_nFontId = rData.m_nFontId;
  96     }
  97
  98     virtual ~wxFontRefData();
  99
 100     //
 101     // Operations
 102     //
 103     bool Alloc(wxFont* pFont);
 104     void Free(void);
 105
 106     //
 107     // All wxFont accessors
 108     //
 109     inline int GetPointSize(void) const
 110     {
 111         //
 112         // We don't use the actual native font point size since it is
 113         // the chosen physical font, which is usually only and approximation
 114         // of the desired outline font.  The actual displayable point size
 115         // is the one stored in the refData
 116         //
 117         return m_nPointSize;
 118     }
 119
 120     inline wxFontFamily GetFamily(void) const
 121     {
 122         return m_nFamily;
 123     }
 124
 125     inline wxFontStyle GetStyle(void) const
 126     {
 127         return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetStyle()
 128                                    : m_nStyle;
 129     }
 130
 131     inline wxFontWeight GetWeight(void) const
 132     {
 133         return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetWeight()
 134                                    : m_nWeight;
 135     }
 136
 137     inline bool GetUnderlined(void) const
 138     {
 139         return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetUnderlined()
 140                                    : m_bUnderlined;
 141     }
 142
 143     inline wxString GetFaceName(void) const
 144     {
 145         wxString                    sFaceName;
 146
 147         if (m_bNativeFontInfoOk)
 148             sFaceName = m_vNativeFontInfo.GetFaceName();
 149         else
 150             sFaceName = m_sFaceName;
 151
 152         return sFaceName;
 153     }
 154
 155     inline wxFontEncoding GetEncoding(void) const
 156     {
 157         return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetEncoding()
 158                                    : m_vEncoding;
 159     }
 160
 161     inline WXHFONT      GetHFONT(void) const { return m_hFont; }
 162     inline HPS          GetPS(void) const { return m_hPS; }
 163     inline PFONTMETRICS GetFM(void) const { return m_pFM; }
 164     inline int          GetNumFonts(void) const { return m_nNumFonts; }
 165
 166     // ... and setters
 167     inline void SetPointSize(int nPointSize)
 168     {
 169         if (m_bNativeFontInfoOk)
 170             m_vNativeFontInfo.SetPointSize(nPointSize);
 171         else
 172             m_nPointSize = nPointSize;
 173     }
 174
 175     inline void SetFamily(wxFontFamily nFamily)
 176     {
 177         m_nFamily = nFamily;
 178     }
 179
 180     inline void SetStyle(wxFontStyle nStyle)
 181     {
 182         if (m_bNativeFontInfoOk)
 183             m_vNativeFontInfo.SetStyle(nStyle);
 184         else
 185             m_nStyle = nStyle;
 186     }
 187
 188     inline void SetWeight(wxFontWeight nWeight)
 189     {
 190         if (m_bNativeFontInfoOk)
 191             m_vNativeFontInfo.SetWeight(nWeight);
 192         else
 193             m_nWeight = nWeight;
 194     }
 195
 196     inline bool SetFaceName(const wxString& sFaceName)
 197     {
 198         if (m_bNativeFontInfoOk)
 199             return m_vNativeFontInfo.SetFaceName(sFaceName);
 200         else
 201             m_sFaceName = sFaceName;
 202         return true;
 203     }
 204
 205     inline void SetUnderlined(bool bUnderlined)
 206     {
 207         if (m_bNativeFontInfoOk)
 208             m_vNativeFontInfo.SetUnderlined(bUnderlined);
 209         else
 210             m_bUnderlined = bUnderlined;
 211     }
 212
 213     inline void SetEncoding(wxFontEncoding vEncoding)
 214     {
 215         if (m_bNativeFontInfoOk)
 216             m_vNativeFontInfo.SetEncoding(vEncoding);
 217         else
 218             m_vEncoding = vEncoding;
 219     }
 220
 221     inline void SetPS(HPS hPS)
 222     {
 223         m_hPS = hPS;
 224     }
 225
 226     inline void SetFM(PFONTMETRICS pFM)
 227     {
 228         m_pFM = pFM;
 229     }
 230
 231     inline void SetNumFonts(int nNumFonts)
 232     {
 233         m_nNumFonts = nNumFonts;
 234     }
 235
 236     //
 237     // Native font info tests
 238     //
 239     bool HasNativeFontInfo() const { return m_bNativeFontInfoOk; }
 240
 241     const wxNativeFontInfo& GetNativeFontInfo() const
 242         { return m_vNativeFontInfo; }
 243
 244 protected:
 245     //
 246     // Common part of all ctors
 247     //
 248     void Init( int             nSize
 249               ,wxFontFamily    nFamily
 250               ,wxFontStyle     nStyle
 251               ,wxFontWeight    nWeight
 252               ,bool            bUnderlined
 253               ,const wxString& rsFaceName
 254               ,wxFontEncoding  vEncoding
 255              );
 256
 257     void Init( const wxNativeFontInfo& rInfo
 258               ,WXHFONT                 hFont = 0
 259               ,WXHANDLE                hPS   = 0
 260              );
 261     //
 262     // If true, the pointer to the actual font is temporary and SHOULD NOT BE
 263     // DELETED by destructor
 264     //
 265     bool                            m_bTemporary;
 266     int                             m_nFontId;
 267
 268     //
 269     // Font characterstics
 270     //
 271     int                             m_nPointSize;
 272     wxFontFamily                    m_nFamily;
 273     wxFontStyle                     m_nStyle;
 274     wxFontWeight                    m_nWeight;
 275     bool                            m_bUnderlined;
 276     wxString                        m_sFaceName;
 277     wxFontEncoding                  m_vEncoding;
 278     WXHFONT                         m_hFont;
 279
 280     //
 281     // Native font info
 282     //
 283     wxNativeFontInfo                m_vNativeFontInfo;
 284     bool                            m_bNativeFontInfoOk;
 285
 286     //
 287     // Some PM specific stuff
 288     //
 289     PFONTMETRICS                    m_pFM;         // array of FONTMETRICS structs
 290     int                             m_nNumFonts;   // number of fonts in array
 291     HPS                             m_hPS;         // PS handle this font belongs to
 292     FATTRS                          m_vFattrs;     // Current fattrs struct
 293     FACENAMEDESC                    m_vFname;      // Current facename struct
 294     bool                            m_bInternalPS; // Internally generated PS?
 295 }; // end of CLASS wxFontRefData
 296
 297 #define M_FONTDATA ((wxFontRefData*)m_refData)
 298
 299 // ============================================================================
 300 // implementation
 301 // ============================================================================
 302
 303 // ----------------------------------------------------------------------------
 304 // wxFontRefData
 305 // ----------------------------------------------------------------------------
 306
 307 void wxFontRefData::Init(
 308   int                               nPointSize
 309 , wxFontFamily                      nFamily
 310 , wxFontStyle                       nStyle
 311 , wxFontWeight                      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 = wxFONTFAMILY_ROMAN;
 435     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Times New Roman MT 30") == 0)
 436         m_nFamily = wxFONTFAMILY_ROMAN;
 437     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "@Times New Roman MT 30") == 0)
 438         m_nFamily = wxFONTFAMILY_ROMAN;
 439     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Tms Rmn") == 0)
 440         m_nFamily = wxFONTFAMILY_ROMAN;
 441     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "WarpSans") == 0)
 442         m_nFamily = wxFONTFAMILY_DECORATIVE;
 443     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Helvetica") == 0)
 444         m_nFamily = wxFONTFAMILY_SWISS;
 445     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Helv") == 0)
 446         m_nFamily = wxFONTFAMILY_SWISS;
 447     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Script") == 0)
 448         m_nFamily = wxFONTFAMILY_SCRIPT;
 449     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Courier New") == 0)
 450         m_nFamily = wxFONTFAMILY_TELETYPE;
 451     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Courier") == 0)
 452         m_nFamily = wxFONTFAMILY_TELETYPE;
 453     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System Monospaced") == 0)
 454         m_nFamily = wxFONTFAMILY_TELETYPE;
 455     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System VIO") == 0)
 456         m_nFamily = wxFONTFAMILY_MODERN;
 457     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System Proportional") == 0)
 458         m_nFamily = wxFONTFAMILY_MODERN;
 459     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Arial") == 0)
 460         m_nFamily = wxFONTFAMILY_SWISS;
 461     else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Swiss") == 0)
 462         m_nFamily = wxFONTFAMILY_SWISS;
 463     else
 464         m_nFamily = wxFONTFAMILY_SWISS;
 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 = wxFONTFAMILY_ROMAN;
 596     else if (strcmp(fm.szFamilyname, "Times New Roman MT 30") == 0)
 597         nFamily = wxFONTFAMILY_ROMAN;
 598     else if (strcmp(fm.szFamilyname, "@Times New Roman MT 30") == 0)
 599         nFamily = wxFONTFAMILY_ROMAN;
 600     else if (strcmp(fm.szFamilyname, "Tms Rmn") == 0)
 601         nFamily = wxFONTFAMILY_ROMAN;
 602     else if (strcmp(fm.szFamilyname, "WarpSans") == 0)
 603         nFamily = wxFONTFAMILY_DECORATIVE;
 604     else if (strcmp(fm.szFamilyname, "Helvetica") == 0)
 605         nFamily = wxFONTFAMILY_SWISS;
 606     else if (strcmp(fm.szFamilyname, "Helv") == 0)
 607         nFamily = wxFONTFAMILY_SWISS;
 608     else if (strcmp(fm.szFamilyname, "Script") == 0)
 609         nFamily = wxFONTFAMILY_SCRIPT;
 610     else if (strcmp(fm.szFamilyname, "Courier New") == 0)
 611         nFamily = wxFONTFAMILY_TELETYPE;
 612     else if (strcmp(fm.szFamilyname, "Courier") == 0)
 613         nFamily = wxFONTFAMILY_TELETYPE;
 614     else if (strcmp(fm.szFamilyname, "System Monospaced") == 0)
 615         nFamily = wxFONTFAMILY_TELETYPE;
 616     else if (strcmp(fm.szFamilyname, "System VIO") == 0)
 617         nFamily = wxFONTFAMILY_MODERN;
 618     else if (strcmp(fm.szFamilyname, "System Proportional") == 0)
 619         nFamily = wxFONTFAMILY_MODERN;
 620     else if (strcmp(fm.szFamilyname, "Arial") == 0)
 621         nFamily = wxFONTFAMILY_SWISS;
 622     else if (strcmp(fm.szFamilyname, "Swiss") == 0)
 623         nFamily = wxFONTFAMILY_SWISS;
 624     else
 625         nFamily = wxFONTFAMILY_SWISS;
 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( wxT("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( wxT("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 bool wxNativeFontInfo::SetFaceName(
 694   const wxString&                   sFacename
 695 )
 696 {
 697     wxStrlcpy((wxChar*)fa.szFacename, sFacename, WXSIZEOF(fa.szFacename));
 698     return true;
 699 } // end of wxNativeFontInfo::SetFaceName
 700
 701 void wxNativeFontInfo::SetFamily(
 702   wxFontFamily                      eFamily
 703 )
 704 {
 705     wxString                        sFacename;
 706
 707     switch (eFamily)
 708     {
 709         case wxFONTFAMILY_SCRIPT:
 710             sFacename = wxT("Tms Rmn");
 711             break;
 712
 713         case wxFONTFAMILY_DECORATIVE:
 714             sFacename = wxT("WarpSans");
 715             break;
 716
 717         case wxFONTFAMILY_ROMAN:
 718             sFacename = wxT("Tms Rmn");
 719             break;
 720
 721         case wxFONTFAMILY_TELETYPE:
 722             sFacename = wxT("Courier") ;
 723             break;
 724
 725         case wxFONTFAMILY_MODERN:
 726             sFacename = wxT("System VIO") ;
 727             break;
 728
 729         case wxFONTFAMILY_SWISS:
 730             sFacename = wxT("Helv") ;
 731             break;
 732
 733         case wxFONTFAMILY_DEFAULT:
 734         default:
 735             sFacename = wxT("System VIO") ;
 736     }
 737
 738     if (!wxStrlen((wxChar*)fa.szFacename) )
 739     {
 740         SetFaceName(sFacename);
 741     }
 742 } // end of wxNativeFontInfo::SetFamily
 743
 744 void wxNativeFontInfo::SetEncoding( wxFontEncoding eEncoding )
 745 {
 746     wxNativeEncodingInfo            vInfo;
 747
 748     if ( !wxGetNativeFontEncoding( eEncoding
 749                                   ,&vInfo
 750                                  ))
 751     {
 752         if (wxFontMapper::Get()->GetAltForEncoding( eEncoding
 753                                                ,&vInfo
 754                                               ))
 755         {
 756             if (!vInfo.facename.empty())
 757             {
 758                 //
 759                 // If we have this encoding only in some particular facename, use
 760                 // the facename - it is better to show the correct characters in a
 761                 // wrong facename than unreadable text in a correct one
 762                 //
 763                 SetFaceName(vInfo.facename);
 764             }
 765         }
 766         else
 767         {
 768             // unsupported encoding, replace with the default
 769             vInfo.charset = 850;
 770         }
 771     }
 772     fa.usCodePage = (USHORT)vInfo.charset;
 773 } // end of wxNativeFontInfo::SetFaceName
 774
 775 bool wxNativeFontInfo::FromString( const wxString& rsStr )
 776 {
 777     long                            lVal;
 778
 779     wxStringTokenizer               vTokenizer(rsStr, wxT(";"));
 780
 781     //
 782     // First the version
 783     //
 784     wxString                        sToken = vTokenizer.GetNextToken();
 785
 786     if (sToken != wxT('0'))
 787         return false;
 788
 789     sToken = vTokenizer.GetNextToken();
 790     if (!sToken.ToLong(&lVal))
 791         return false;
 792     fm.lEmHeight = lVal;
 793
 794     sToken = vTokenizer.GetNextToken();
 795     if (!sToken.ToLong(&lVal))
 796         return false;
 797     fa.lAveCharWidth = lVal;
 798
 799     sToken = vTokenizer.GetNextToken();
 800     if (!sToken.ToLong(&lVal))
 801         return false;
 802     fa.fsSelection = (USHORT)lVal;
 803
 804     sToken = vTokenizer.GetNextToken();
 805     if (!sToken.ToLong(&lVal))
 806         return false;
 807     fa.fsType = (USHORT)lVal;
 808
 809     sToken = vTokenizer.GetNextToken();
 810     if (!sToken.ToLong(&lVal))
 811         return false;
 812     fa.fsFontUse = (USHORT)lVal;
 813
 814     sToken = vTokenizer.GetNextToken();
 815     if (!sToken.ToLong(&lVal))
 816         return false;
 817     fa.idRegistry = (USHORT)lVal;
 818
 819     sToken = vTokenizer.GetNextToken();
 820     if (!sToken.ToLong(&lVal))
 821         return false;
 822     fa.usCodePage = (USHORT)lVal;
 823
 824     sToken = vTokenizer.GetNextToken();
 825     if (!sToken.ToLong(&lVal))
 826         return false;
 827     fa.lMatch = lVal;
 828
 829     sToken = vTokenizer.GetNextToken();
 830     if (!sToken.ToLong(&lVal))
 831         return false;
 832     fn.usWeightClass = (USHORT)lVal;
 833
 834     sToken = vTokenizer.GetNextToken();
 835     if(!sToken)
 836         return false;
 837     wxStrcpy((wxChar*)fa.szFacename, sToken.c_str());
 838     return true;
 839 } // end of wxNativeFontInfo::FromString
 840
 841 wxString wxNativeFontInfo::ToString() const
 842 {
 843     wxString sStr;
 844
 845     sStr.Printf(wxT("%d;%ld;%ld;%ld;%d;%d;%d;%d;%d;%ld;%d;%s"),
 846                 0, // version, in case we want to change the format later
 847                 fm.lEmHeight,
 848                 fa.lAveCharWidth,
 849                 fa.lMaxBaselineExt,
 850                 fa.fsSelection,
 851                 fa.fsType,
 852                 fa.fsFontUse,
 853                 fa.idRegistry,
 854                 fa.usCodePage,
 855                 fa.lMatch,
 856                 fn.usWeightClass,
 857                 (char *)fa.szFacename);
 858     return sStr;
 859 } // end of wxNativeFontInfo::ToString
 860
 861 // ----------------------------------------------------------------------------
 862 // wxFont
 863 // ----------------------------------------------------------------------------
 864
 865 bool wxFont::Create( const wxNativeFontInfo& rInfo,
 866                      WXHFONT hFont )
 867 {
 868     UnRef();
 869     m_refData = new wxFontRefData( rInfo
 870                                   ,hFont
 871                                  );
 872     RealizeResource();
 873     return true;
 874 } // end of wxFont::Create
 875
 876 wxFont::wxFont(
 877   const wxString&                   rsFontdesc
 878 )
 879 {
 880     wxNativeFontInfo                vInfo;
 881
 882     if (vInfo.FromString(rsFontdesc))
 883         (void)Create(vInfo);
 884 } // end of wxFont::wxFont
 885
 886 // ----------------------------------------------------------------------------
 887 // Constructor for a font. Note that the real construction is done
 888 // in wxDC::SetFont, when information is available about scaling etc.
 889 // ----------------------------------------------------------------------------
 890 bool wxFont::Create( int             nPointSize,
 891                      wxFontFamily nFamily,
 892                      wxFontStyle nStyle,
 893                      wxFontWeight nWeight,
 894                      bool            bUnderlined,
 895                      const wxString& rsFaceName,
 896                      wxFontEncoding  vEncoding )
 897 {
 898     UnRef();
 899
 900     //
 901     // wxDEFAULT is a valid value for the font size too so we must treat it
 902     // specially here (otherwise the size would be 70 == wxDEFAULT value)
 903     //
 904     if (nPointSize == wxDEFAULT)
 905     {
 906         nPointSize = wxNORMAL_FONT->GetPointSize();
 907     }
 908     m_refData = new wxFontRefData( nPointSize
 909                                   ,nFamily
 910                                   ,nStyle
 911                                   ,nWeight
 912                                   ,bUnderlined
 913                                   ,rsFaceName
 914                                   ,vEncoding
 915                                  );
 916     RealizeResource();
 917     return true;
 918 } // end of wxFont::Create
 919
 920 wxFont::~wxFont()
 921 {
 922 } // end of wxFont::~wxFont
 923
 924 // ----------------------------------------------------------------------------
 925 // real implementation
 926 // Boris' Kovalenko comments:
 927 //   Because OS/2 fonts are associated with PS we cannot create the font
 928 //   here, but we may check that font definition is true
 929 // ----------------------------------------------------------------------------
 930
 931 wxGDIRefData *wxFont::CreateGDIRefData() const
 932 {
 933     return new wxFontRefData();
 934 }
 935
 936 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
 937 {
 938     return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
 939 }
 940
 941 bool wxFont::RealizeResource()
 942 {
 943     if ( GetResourceHandle() )
 944     {
 945         return true;
 946     }
 947     return M_FONTDATA->Alloc(this);
 948 } // end of wxFont::RealizeResource
 949
 950 bool wxFont::FreeResource( bool WXUNUSED(bForce) )
 951 {
 952     if (GetResourceHandle())
 953     {
 954         M_FONTDATA->Free();
 955         return true;
 956     }
 957     return false;
 958 } // end of wxFont::FreeResource
 959
 960 WXHANDLE wxFont::GetResourceHandle() const
 961 {
 962     return GetHFONT();
 963 } // end of wxFont::GetResourceHandle
 964
 965 WXHFONT wxFont::GetHFONT() const
 966 {
 967     return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0;
 968 } // end of wxFont::GetHFONT
 969
 970 bool wxFont::IsFree() const
 971 {
 972     return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0);
 973 } // end of wxFont::IsFree
 974
 975 // ----------------------------------------------------------------------------
 976 // change font attribute: we recreate font when doing it
 977 // ----------------------------------------------------------------------------
 978
 979 void wxFont::SetPointSize(
 980   int                               nPointSize
 981 )
 982 {
 983     AllocExclusive();
 984
 985     M_FONTDATA->SetPointSize(nPointSize);
 986
 987     RealizeResource();
 988 } // end of wxFont::SetPointSize
 989
 990 void wxFont::SetFamily(
 991   wxFontFamily                      nFamily
 992 )
 993 {
 994     AllocExclusive();
 995
 996     M_FONTDATA->SetFamily(nFamily);
 997
 998     RealizeResource();
 999 } // end of wxFont::SetFamily
1000
1001 void wxFont::SetStyle(
1002   wxFontStyle                       nStyle
1003 )
1004 {
1005     AllocExclusive();
1006
1007     M_FONTDATA->SetStyle(nStyle);
1008
1009     RealizeResource();
1010 } // end of wxFont::SetStyle
1011
1012 void wxFont::SetWeight(
1013   wxFontWeight                      nWeight
1014 )
1015 {
1016     AllocExclusive();
1017
1018     M_FONTDATA->SetWeight(nWeight);
1019
1020     RealizeResource();
1021 } // end of wxFont::SetWeight
1022
1023 bool wxFont::SetFaceName(
1024   const wxString&                   rsFaceName
1025 )
1026 {
1027     AllocExclusive();
1028
1029     bool refdataok = M_FONTDATA->SetFaceName(rsFaceName);
1030
1031     RealizeResource();
1032
1033     return refdataok && wxFontBase::SetFaceName(rsFaceName);
1034 } // end of wxFont::SetFaceName
1035
1036 void wxFont::SetUnderlined(
1037   bool                              bUnderlined
1038 )
1039 {
1040     AllocExclusive();
1041
1042     M_FONTDATA->SetUnderlined(bUnderlined);
1043
1044     RealizeResource();
1045 } // end of wxFont::SetUnderlined
1046
1047 void wxFont::SetEncoding(
1048   wxFontEncoding                    vEncoding
1049 )
1050 {
1051     AllocExclusive();
1052
1053     M_FONTDATA->SetEncoding(vEncoding);
1054
1055     RealizeResource();
1056 } // end of wxFont::SetEncoding
1057
1058 void wxFont::DoSetNativeFontInfo(
1059   const wxNativeFontInfo&           rInfo
1060 )
1061 {
1062     AllocExclusive();
1063
1064     FreeResource();
1065
1066     *M_FONTDATA = wxFontRefData(rInfo);
1067
1068     RealizeResource();
1069 }
1070
1071 // ----------------------------------------------------------------------------
1072 // accessors
1073 // ----------------------------------------------------------------------------
1074
1075 int wxFont::GetPointSize() const
1076 {
1077     wxCHECK_MSG( IsOk(), 0, wxT("invalid font") );
1078
1079     return M_FONTDATA->GetPointSize();
1080 } // end of wxFont::GetPointSize
1081
1082 wxFontFamily wxFont::DoGetFamily() const
1083 {
1084     return M_FONTDATA->GetFamily();
1085 } // end of wxFont::DoGetFamily
1086
1087 wxFontStyle wxFont::GetStyle() const
1088 {
1089     wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") );
1090
1091     return M_FONTDATA->GetStyle();
1092 } // end of wxFont::GetStyle
1093
1094 wxFontWeight wxFont::GetWeight() const
1095 {
1096     wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") );
1097
1098     return M_FONTDATA->GetWeight();
1099 }
1100
1101 bool wxFont::GetUnderlined() const
1102 {
1103     wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
1104
1105     return M_FONTDATA->GetUnderlined();
1106 } // end of wxFont::GetUnderlined
1107
1108 wxString wxFont::GetFaceName() const
1109 {
1110     wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
1111
1112     return M_FONTDATA->GetFaceName();
1113 } // end of wxFont::GetFaceName
1114
1115 wxFontEncoding wxFont::GetEncoding() const
1116 {
1117     wxCHECK_MSG( IsOk(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
1118
1119     return M_FONTDATA->GetEncoding();
1120 } // end of wxFont::GetEncoding
1121
1122 const wxNativeFontInfo* wxFont::GetNativeFontInfo() const
1123 {
1124     return M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo())
1125                                            : NULL;
1126 } // end of wxFont::GetNativeFontInfo
1127
1128 //
1129 // Internal use only method to set the FONTMETRICS array
1130 //
1131 void wxFont::SetFM( PFONTMETRICS pFM, int nNumFonts )
1132 {
1133     M_FONTDATA->SetFM(pFM);
1134     M_FONTDATA->SetNumFonts(nNumFonts);
1135 } // end of wxFont::SetFM
1136
1137
1138 void wxFont::SetPS( HPS hPS )
1139 {
1140     AllocExclusive();
1141
1142     M_FONTDATA->SetPS(hPS);
1143
1144     RealizeResource();
1145 } // end of wxFont::SetPS