Fix vertical rules rendering in generic wxDataViewCtrl.

[wxWidgets.git] / src / os2 / font.cpp

diff --git a/src/os2/font.cpp b/src/os2/font.cpp
index d33d991d89a827520a65ab64a66223b235e5eeaa..8d046f78b9ed68a3ced222604bd0f6a4e662b809 100644 (file)
--- a/src/os2/font.cpp
+++ b/src/os2/font.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        font.cpp
+// Name:        src/os2/font.cpp

 // Purpose:     wxFont class
 // Author:      David Webster
 // Modified by:
 // Purpose:     wxFont class
 // Author:      David Webster
 // Modified by:


@@ -9,6 +9,9 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+

 // ============================================================================
 // declarations
 // ============================================================================
 // ============================================================================
 // declarations
 // ============================================================================


@@ -17,26 +20,25 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

- #include <malloc.h>
-// For compilers that support precompilation, includes "wx.h".
-#include "wx/wxprec.h"
+#include "wx/font.h"

 
 #ifndef WX_PRECOMP
     #include <stdio.h>
 
 #ifndef WX_PRECOMP
     #include <stdio.h>

-    #include "wx/setup.h"

     #include "wx/list.h"
     #include "wx/utils.h"
     #include "wx/app.h"
     #include "wx/list.h"
     #include "wx/utils.h"
     #include "wx/app.h"

-    #include "wx/font.h"
+    #include "wx/log.h"

 #endif // WX_PRECOMP
 
 #include "wx/os2/private.h"
 
 #endif // WX_PRECOMP
 
 #include "wx/os2/private.h"
 

-IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
+#include "wx/fontutil.h"
+#include "wx/fontmap.h"
+#include "wx/encinfo.h"
+
+#include "wx/tokenzr.h"

 
 

-#if wxUSE_PORTABLE_FONTS_IN_MSW
-    IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject)
-#endif
+#include <malloc.h>

 
 // ----------------------------------------------------------------------------
 // wxFontRefData - the internal description of the font
 
 // ----------------------------------------------------------------------------
 // wxFontRefData - the internal description of the font


@@ -44,50 +46,221 @@ IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
 
 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
 {
 
 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
 {

-friend class WXDLLEXPORT wxFont;
-

 public:
     wxFontRefData()
     {
 public:
     wxFontRefData()
     {

-        Init(12, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE,
-             "", wxFONTENCODING_DEFAULT);
-    }
-
-    wxFontRefData(const wxFontRefData& data)
-    {
-        Init(data.m_nPointSize, data.m_nFamily, data.m_nStyle, data.m_nWeight,
-             data.m_bUnderlined, data.m_sFaceName, data.m_vEncoding);
-
-        m_nFontId = data.m_nFontId;
+        Init(-1, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false,
+             wxEmptyString, wxFONTENCODING_DEFAULT);

     }
 
     wxFontRefData( int             nSize
     }
 
     wxFontRefData( int             nSize

-                  ,int             nFamily
-                  ,int             nStyle
-                  ,int             nWeight
+                  ,wxFontFamily    nFamily
+                  ,wxFontStyle     nStyle
+                  ,wxFontWeight    nWeight

                   ,bool            bUnderlined
                   ,const wxString& sFaceName
                   ,wxFontEncoding  vEncoding
                  )
     {
                   ,bool            bUnderlined
                   ,const wxString& sFaceName
                   ,wxFontEncoding  vEncoding
                  )
     {

-        Init(nSize, nFamily, nStyle, nWeight, bUnderlined, sFaceName, vEncoding);
+        Init( nSize
+             ,nFamily
+             ,nStyle
+             ,nWeight
+             ,bUnderlined
+             ,sFaceName
+             ,vEncoding
+            );
+    }
+
+    wxFontRefData( const wxNativeFontInfo& rInfo
+                  ,WXHFONT                 hFont = 0
+                  ,WXHANDLE                hPS   = 0
+                 )
+    {
+        Init( rInfo
+             ,hFont
+             ,hPS
+            );
+    }
+
+    wxFontRefData(const wxFontRefData& rData)
+    {
+        Init( rData.m_nPointSize
+             ,rData.m_nFamily
+             ,rData.m_nStyle
+             ,rData.m_nWeight
+             ,rData.m_bUnderlined
+             ,rData.m_sFaceName
+             ,rData.m_vEncoding
+            );
+        m_nFontId = rData.m_nFontId;

     }
 
     virtual ~wxFontRefData();
 
     }
 
     virtual ~wxFontRefData();
 

+    //
+    // Operations
+    //
+    bool Alloc(wxFont* pFont);
+    void Free(void);
+
+    //
+    // All wxFont accessors
+    //
+    inline int GetPointSize(void) const
+    {
+        //
+        // We don't use the actual native font point size since it is
+        // the chosen physical font, which is usually only and approximation
+        // of the desired outline font.  The actual displayable point size
+        // is the one stored in the refData
+        //
+        return m_nPointSize;
+    }
+
+    inline wxFontFamily GetFamily(void) const
+    {
+        return m_nFamily;
+    }
+
+    inline wxFontStyle GetStyle(void) const
+    {
+        return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetStyle()
+                                   : m_nStyle;
+    }
+
+    inline wxFontWeight GetWeight(void) const
+    {
+        return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetWeight()
+                                   : m_nWeight;
+    }
+
+    inline bool GetUnderlined(void) const
+    {
+        return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetUnderlined()
+                                   : m_bUnderlined;
+    }
+
+    inline wxString GetFaceName(void) const
+    {
+        wxString                    sFaceName;
+
+        if (m_bNativeFontInfoOk)
+            sFaceName = m_vNativeFontInfo.GetFaceName();
+        else
+            sFaceName = m_sFaceName;
+
+        return sFaceName;
+    }
+
+    inline wxFontEncoding GetEncoding(void) const
+    {
+        return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetEncoding()
+                                   : m_vEncoding;
+    }
+
+    inline WXHFONT      GetHFONT(void) const { return m_hFont; }
+    inline HPS          GetPS(void) const { return m_hPS; }
+    inline PFONTMETRICS GetFM(void) const { return m_pFM; }
+    inline int          GetNumFonts(void) const { return m_nNumFonts; }
+
+    // ... and setters
+    inline void SetPointSize(int nPointSize)
+    {
+        if (m_bNativeFontInfoOk)
+            m_vNativeFontInfo.SetPointSize(nPointSize);
+        else
+            m_nPointSize = nPointSize;
+    }
+
+    inline void SetFamily(wxFontFamily nFamily)
+    {
+        m_nFamily = nFamily;
+    }
+
+    inline void SetStyle(wxFontStyle nStyle)
+    {
+        if (m_bNativeFontInfoOk)
+            m_vNativeFontInfo.SetStyle(nStyle);
+        else
+            m_nStyle = nStyle;
+    }
+
+    inline void SetWeight(wxFontWeight nWeight)
+    {
+        if (m_bNativeFontInfoOk)
+            m_vNativeFontInfo.SetWeight(nWeight);
+        else
+            m_nWeight = nWeight;
+    }
+
+    inline bool SetFaceName(const wxString& sFaceName)
+    {
+        if (m_bNativeFontInfoOk)
+            return m_vNativeFontInfo.SetFaceName(sFaceName);
+        else
+            m_sFaceName = sFaceName;
+        return true;
+    }
+
+    inline void SetUnderlined(bool bUnderlined)
+    {
+        if (m_bNativeFontInfoOk)
+            m_vNativeFontInfo.SetUnderlined(bUnderlined);
+        else
+            m_bUnderlined = bUnderlined;
+    }
+
+    inline void SetEncoding(wxFontEncoding vEncoding)
+    {
+        if (m_bNativeFontInfoOk)
+            m_vNativeFontInfo.SetEncoding(vEncoding);
+        else
+            m_vEncoding = vEncoding;
+    }
+
+    inline void SetPS(HPS hPS)
+    {
+        m_hPS = hPS;
+    }
+
+    inline void SetFM(PFONTMETRICS pFM)
+    {
+        m_pFM = pFM;
+    }
+
+    inline void SetNumFonts(int nNumFonts)
+    {
+        m_nNumFonts = nNumFonts;
+    }
+
+    //
+    // Native font info tests
+    //
+    bool HasNativeFontInfo() const { return m_bNativeFontInfoOk; }
+
+    const wxNativeFontInfo& GetNativeFontInfo() const
+        { return m_vNativeFontInfo; }
+

 protected:
 protected:

-    // common part of all ctors
+    //
+    // Common part of all ctors
+    //

     void Init( int             nSize
     void Init( int             nSize

-              ,int             nFamily
-              ,int             nStyle
-              ,int             nWeight
+              ,wxFontFamily    nFamily
+              ,wxFontStyle     nStyle
+              ,wxFontWeight    nWeight

               ,bool            bUnderlined
               ,const wxString& rsFaceName
               ,wxFontEncoding  vEncoding
              );
 
               ,bool            bUnderlined
               ,const wxString& rsFaceName
               ,wxFontEncoding  vEncoding
              );
 

+    void Init( const wxNativeFontInfo& rInfo
+              ,WXHFONT                 hFont = 0
+              ,WXHANDLE                hPS   = 0
+             );

     //
     //

-    // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE
+    // If true, the pointer to the actual font is temporary and SHOULD NOT BE

     // DELETED by destructor
     //
     bool                            m_bTemporary;
     // DELETED by destructor
     //
     bool                            m_bTemporary;


@@ -97,24 +270,33 @@ protected:
     // Font characterstics
     //
     int                             m_nPointSize;
     // Font characterstics
     //
     int                             m_nPointSize;

-    int                             m_nFamily;
-    int                             m_nStyle;
-    int                             m_nWeight;
+    wxFontFamily                    m_nFamily;
+    wxFontStyle                     m_nStyle;
+    wxFontWeight                    m_nWeight;

     bool                            m_bUnderlined;
     wxString                        m_sFaceName;
     wxFontEncoding                  m_vEncoding;
     bool                            m_bUnderlined;
     wxString                        m_sFaceName;
     wxFontEncoding                  m_vEncoding;

+    WXHFONT                         m_hFont;
+
+    //
+    // Native font info
+    //
+    wxNativeFontInfo                m_vNativeFontInfo;
+    bool                            m_bNativeFontInfoOk;

 
     //
     // Some PM specific stuff
     //
 
     //
     // Some PM specific stuff
     //

-    WXHFONT                         m_hFont;
-    PFONTMETRICS                    m_pFM;       // array of FONTMETRICS structs
-    int                             m_nNumFonts; // number of fonts in array
-    HPS                             m_hPS;       // PS handle this font belongs to
-    FATTRS                          m_vFattrs;   // Current fattrs struct
-    FACENAMEDESC                    m_vFname;    // Current facename struct
+    PFONTMETRICS                    m_pFM;         // array of FONTMETRICS structs
+    int                             m_nNumFonts;   // number of fonts in array
+    HPS                             m_hPS;         // PS handle this font belongs to
+    FATTRS                          m_vFattrs;     // Current fattrs struct
+    FACENAMEDESC                    m_vFname;      // Current facename struct
+    bool                            m_bInternalPS; // Internally generated PS?

 }; // end of CLASS wxFontRefData
 
 }; // end of CLASS wxFontRefData
 

+#define M_FONTDATA ((wxFontRefData*)m_refData)
+

 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================


@@ -125,9 +307,9 @@ protected:
 
 void wxFontRefData::Init(
   int                               nPointSize
 
 void wxFontRefData::Init(
   int                               nPointSize

-, int                               nFamily
-, int                               nStyle
-, int                               nWeight
+, wxFontFamily                      nFamily
+, wxFontStyle                       nStyle
+, wxFontWeight                      nWeight

 , bool                              bUnderlined
 , const wxString&                   rsFaceName
 , wxFontEncoding                    vEncoding
 , bool                              bUnderlined
 , const wxString&                   rsFaceName
 , wxFontEncoding                    vEncoding


@@ -141,311 +323,655 @@ void wxFontRefData::Init(
     m_bUnderlined = bUnderlined;
     m_sFaceName   = rsFaceName;
     m_vEncoding   = vEncoding;
     m_bUnderlined = bUnderlined;
     m_sFaceName   = rsFaceName;
     m_vEncoding   = vEncoding;

-    m_nFontId     = 0;
-    m_bTemporary  = FALSE;
-

     m_hFont       = 0;
     m_hFont       = 0;

+
+    m_bNativeFontInfoOk = false;
+
+    m_nFontId     = 0;
+    m_bTemporary  = false;

     m_pFM         = (PFONTMETRICS)NULL;
     m_hPS         = NULLHANDLE;
     m_nNumFonts   = 0;
 } // end of wxFontRefData::Init
 
     m_pFM         = (PFONTMETRICS)NULL;
     m_hPS         = NULLHANDLE;
     m_nNumFonts   = 0;
 } // end of wxFontRefData::Init
 

+void wxFontRefData::Init(
+  const wxNativeFontInfo&           rInfo
+, WXHFONT                           hFont //this is the FontId -- functions as the hFont for OS/2
+, WXHANDLE                          hPS   // Presentation Space we are using
+)
+{
+    //
+    // hFont may be zero, or it be passed in case we really want to
+    // use the exact font created in the underlying system
+    // (for example where we can't guarantee conversion from HFONT
+    // to LOGFONT back to HFONT)
+    //
+    m_hFont = hFont;
+    m_nFontId = (int)hFont;
+
+    m_bNativeFontInfoOk = true;
+    m_vNativeFontInfo = rInfo;
+
+    if (hPS == NULLHANDLE)
+    {
+        m_hPS = ::WinGetPS(HWND_DESKTOP);
+        m_bInternalPS = true;
+    }
+    else
+        m_hPS = (HPS)hPS;
+
+    m_nFontId     = 0;
+    m_bTemporary  = false;
+    m_pFM         = (PFONTMETRICS)NULL;
+    m_nNumFonts   = 0;
+} // end of wxFontRefData::Init
+

 wxFontRefData::~wxFontRefData()
 {
 wxFontRefData::~wxFontRefData()
 {

-    if (m_pFM)
-        delete [] m_pFM;
-    m_pFM = (PFONTMETRICS)NULL;
+    Free();

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// wxFont
-// ----------------------------------------------------------------------------
+bool wxFontRefData::Alloc( wxFont* pFont )
+{
+    wxString                        sFaceName;
+    long                            flId = m_hFont;
+    long                            lRc;
+    ERRORID                         vError;
+    wxString                        sError;
+
+    if (!m_bNativeFontInfoOk)
+    {
+        wxFillLogFont( &m_vNativeFontInfo.fa
+                      ,&m_vNativeFontInfo.fn
+                      ,&m_hPS
+                      ,&m_bInternalPS
+                      ,&flId
+                      ,sFaceName
+                      ,pFont
+                     );
+        m_bNativeFontInfoOk = true;
+    }
+    else
+    {
+        if (flId == 0L)
+            flId = 1L;
+        else
+            flId++;
+        if (flId > 254)
+            flId = 1L;
+    }
+    if((lRc = ::GpiCreateLogFont( m_hPS
+                                 ,NULL
+                                 ,flId
+                                 ,&m_vNativeFontInfo.fa
+                                )) != GPI_ERROR)
+    {
+       m_hFont = (WXHFONT)flId;
+       m_nFontId = flId;
+    }
+    if (!m_hFont)
+    {
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+        wxLogLastError(wxT("CreateFont"));
+    }
+
+    ::GpiSetCharSet(m_hPS, flId); // sets font for presentation space
+    ::GpiQueryFontMetrics(m_hPS, sizeof(FONTMETRICS), &m_vNativeFontInfo.fm);
+
+    //
+    // Set refData members with the results
+    //
+    memcpy(&m_vFattrs, &m_vNativeFontInfo.fa, sizeof(m_vFattrs));
+    memcpy(&m_vFname, &m_vNativeFontInfo.fn, sizeof(m_vFname));
+    //
+    // Going to leave the point size alone.  Mostly we use outline fonts
+    // that can be set to any point size inside of Presentation Parameters,
+    // regardless of whether or not the actual font is registered in the system.
+    // The GpiCreateLogFont will do enough by selecting the right family,
+    // and face name.
+    //
+    if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Times New Roman") == 0)
+        m_nFamily = wxFONTFAMILY_ROMAN;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Times New Roman MT 30") == 0)
+        m_nFamily = wxFONTFAMILY_ROMAN;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "@Times New Roman MT 30") == 0)
+        m_nFamily = wxFONTFAMILY_ROMAN;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Tms Rmn") == 0)
+        m_nFamily = wxFONTFAMILY_ROMAN;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "WarpSans") == 0)
+        m_nFamily = wxFONTFAMILY_DECORATIVE;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Helvetica") == 0)
+        m_nFamily = wxFONTFAMILY_SWISS;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Helv") == 0)
+        m_nFamily = wxFONTFAMILY_SWISS;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Script") == 0)
+        m_nFamily = wxFONTFAMILY_SCRIPT;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Courier New") == 0)
+        m_nFamily = wxFONTFAMILY_TELETYPE;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Courier") == 0)
+        m_nFamily = wxFONTFAMILY_TELETYPE;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System Monospaced") == 0)
+        m_nFamily = wxFONTFAMILY_TELETYPE;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System VIO") == 0)
+        m_nFamily = wxFONTFAMILY_MODERN;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System Proportional") == 0)
+        m_nFamily = wxFONTFAMILY_MODERN;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Arial") == 0)
+        m_nFamily = wxFONTFAMILY_SWISS;
+    else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Swiss") == 0)
+        m_nFamily = wxFONTFAMILY_SWISS;
+    else
+        m_nFamily = wxFONTFAMILY_SWISS;

 
 

-wxFont::wxFont(const wxNativeFontInfo& rInfo)
+    if (m_vNativeFontInfo.fa.fsSelection & FATTR_SEL_ITALIC)
+        m_nStyle = wxFONTSTYLE_ITALIC;
+    else
+        m_nStyle = wxFONTSTYLE_NORMAL;
+    switch(m_vNativeFontInfo.fn.usWeightClass)

     {
     {

-        Init();
+        case FWEIGHT_DONT_CARE:
+            m_nWeight = wxFONTWEIGHT_NORMAL;
+            break;
+
+        case FWEIGHT_NORMAL:
+            m_nWeight = wxFONTWEIGHT_NORMAL;
+            break;

 
 

-        (void)Create( rInfo.pointSize
-                     ,rInfo.family
-                     ,rInfo.style
-                     ,rInfo.weight
-                     ,rInfo.underlined
-                     ,rInfo.faceName
-                     ,rInfo.encoding
-                    );
+        case FWEIGHT_LIGHT:
+            m_nWeight = wxFONTWEIGHT_LIGHT;
+            break;
+
+        case FWEIGHT_BOLD:
+            m_nWeight = wxFONTWEIGHT_BOLD;
+            break;
+
+        case FWEIGHT_ULTRA_BOLD:
+            m_nWeight = wxFONTWEIGHT_MAX;
+            break;
+
+        default:
+            m_nWeight = wxFONTWEIGHT_NORMAL;

     }
     }

+    m_bUnderlined = ((m_vNativeFontInfo.fa.fsSelection & FATTR_SEL_UNDERSCORE) != 0);
+    m_sFaceName = (wxChar*)m_vNativeFontInfo.fa.szFacename;
+    m_vEncoding = wxGetFontEncFromCharSet(m_vNativeFontInfo.fa.usCodePage);

 
 

+    //
+    // We don't actuall keep the font around if using a temporary PS
+    //
+    if (m_bInternalPS)
+    {
+        if(m_hFont)
+            ::GpiDeleteSetId( m_hPS
+                             ,flId
+                            );

 
 

-void wxFont::Init()
+        ::WinReleasePS(m_hPS);
+    }
+    else
+        //
+        // Select the font into the Presentation space
+        //
+        ::GpiSetCharSet(m_hPS, flId); // sets font for presentation space
+    return true;
+} // end of wxFontRefData::Alloc
+
+void wxFontRefData::Free()

 {
 {

-    if ( wxTheFontList )
-        wxTheFontList->Append(this);
-}
+    if (m_pFM)
+        delete [] m_pFM;
+    m_pFM = (PFONTMETRICS)NULL;
+
+    if ( m_hFont )
+    {
+        ::GpiDeleteSetId(m_hPS, 1L); /* delete the logical font          */
+        m_nFontId = 0;
+        m_hFont   = 0;
+    }
+    if (m_bInternalPS)
+        ::WinReleasePS(m_hPS);
+    m_hPS = NULLHANDLE;
+} // end of wxFontRefData::Free

 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------

-// Constructor for a font. Note that the real construction is done
-// in wxDC::SetFont, when information is available about scaling etc.
+// wxNativeFontInfo

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-bool wxFont::Create(
-  int                               nPointSize
-, int                               nFamily
-, int                               nStyle
-, int                               nWeight
-, bool                              bUnderlined
-, const wxString&                   rsFaceName
-, wxFontEncoding                    vEncoding
-)
-{
-    UnRef();
-    m_refData = new wxFontRefData( nPointSize
-                                  ,nFamily
-                                  ,nStyle
-                                  ,nWeight
-                                  ,bUnderlined
-                                  ,rsFaceName
-                                  ,vEncoding
-                                 );
-    RealizeResource();
-    return TRUE;
-} // end of wxFont::Create

 
 

-wxFont::~wxFont()
+void wxNativeFontInfo::Init()

 {
 {

-    if (wxTheFontList)
-        wxTheFontList->DeleteObject(this);
-} // end of wxFont::~wxFont
+    memset(&fa, '\0', sizeof(FATTRS));
+} // end of wxNativeFontInfo::Init

 
 

-// ----------------------------------------------------------------------------
-// real implementation
-// Boris' Kovalenko comments:
-//   Because OS/2 fonts are associated with PS we can not create the font
-//   here, but we may check that font definition is true
-// ----------------------------------------------------------------------------
+int wxNativeFontInfo::GetPointSize() const
+{
+    return fm.lEmHeight;
+} // end of wxNativeFontInfo::GetPointSize

 
 

-bool wxFont::RealizeResource()
+wxFontStyle wxNativeFontInfo::GetStyle() const

 {
 {

-    LONG                            lNumFonts = 0L;
-    LONG                            lTemp = 0L;
-    PFONTMETRICS                    pFM = NULL;
-    ERRORID                         vError;
+    return fa.fsSelection & FATTR_SEL_ITALIC ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL;
+} // end of wxNativeFontInfo::GetStyle

 
 

-    if ( GetResourceHandle() )
+wxFontWeight wxNativeFontInfo::GetWeight() const
+{
+    switch(fn.usWeightClass)

     {
     {

-        // VZ: the old code returned FALSE in this case, but it doesn't seem
-        //     to make sense because the font _was_ created
-        wxLogDebug(wxT("Calling wxFont::RealizeResource() twice"));
+        case FWEIGHT_DONT_CARE:
+            return wxFONTWEIGHT_NORMAL;
+
+        case FWEIGHT_NORMAL:
+            return wxFONTWEIGHT_NORMAL;

 
 

-       return TRUE;
+        case FWEIGHT_LIGHT:
+            return wxFONTWEIGHT_LIGHT;
+
+        case FWEIGHT_BOLD:
+            return wxFONTWEIGHT_BOLD;
+
+        case FWEIGHT_ULTRA_BOLD:
+            return wxFONTWEIGHT_MAX;

     }
     }

+    return wxFONTWEIGHT_NORMAL;
+} // end of wxNativeFontInfo::GetWeight
+
+bool wxNativeFontInfo::GetUnderlined() const
+{
+    return ((fa.fsSelection & FATTR_SEL_UNDERSCORE) != 0);
+} // end of wxNativeFontInfo::GetUnderlined

 
 

-    LONG                            flId;
-    bool                            bInternalPS = FALSE;  // if we have to create one
+wxString wxNativeFontInfo::GetFaceName() const
+{
+    return (wxChar*)fm.szFacename;
+} // end of wxNativeFontInfo::GetFaceName
+
+wxFontFamily wxNativeFontInfo::GetFamily() const
+{
+    int                             nFamily;

 
     //
 
     //

-    // Now cheking
+    // Extract family from facename

     //
     //

-    flId = 1L;
-    if (!M_FONTDATA->m_hPS)
+    if (strcmp(fm.szFamilyname, "Times New Roman") == 0)
+        nFamily = wxFONTFAMILY_ROMAN;
+    else if (strcmp(fm.szFamilyname, "Times New Roman MT 30") == 0)
+        nFamily = wxFONTFAMILY_ROMAN;
+    else if (strcmp(fm.szFamilyname, "@Times New Roman MT 30") == 0)
+        nFamily = wxFONTFAMILY_ROMAN;
+    else if (strcmp(fm.szFamilyname, "Tms Rmn") == 0)
+        nFamily = wxFONTFAMILY_ROMAN;
+    else if (strcmp(fm.szFamilyname, "WarpSans") == 0)
+        nFamily = wxFONTFAMILY_DECORATIVE;
+    else if (strcmp(fm.szFamilyname, "Helvetica") == 0)
+        nFamily = wxFONTFAMILY_SWISS;
+    else if (strcmp(fm.szFamilyname, "Helv") == 0)
+        nFamily = wxFONTFAMILY_SWISS;
+    else if (strcmp(fm.szFamilyname, "Script") == 0)
+        nFamily = wxFONTFAMILY_SCRIPT;
+    else if (strcmp(fm.szFamilyname, "Courier New") == 0)
+        nFamily = wxFONTFAMILY_TELETYPE;
+    else if (strcmp(fm.szFamilyname, "Courier") == 0)
+        nFamily = wxFONTFAMILY_TELETYPE;
+    else if (strcmp(fm.szFamilyname, "System Monospaced") == 0)
+        nFamily = wxFONTFAMILY_TELETYPE;
+    else if (strcmp(fm.szFamilyname, "System VIO") == 0)
+        nFamily = wxFONTFAMILY_MODERN;
+    else if (strcmp(fm.szFamilyname, "System Proportional") == 0)
+        nFamily = wxFONTFAMILY_MODERN;
+    else if (strcmp(fm.szFamilyname, "Arial") == 0)
+        nFamily = wxFONTFAMILY_SWISS;
+    else if (strcmp(fm.szFamilyname, "Swiss") == 0)
+        nFamily = wxFONTFAMILY_SWISS;
+    else
+        nFamily = wxFONTFAMILY_SWISS;
+    return (wxFontFamily)nFamily;
+} // end of wxNativeFontInfo::GetFamily
+
+wxFontEncoding wxNativeFontInfo::GetEncoding() const
+{
+    return wxGetFontEncFromCharSet(fa.usCodePage);
+} // end of wxNativeFontInfo::GetEncoding
+
+void wxNativeFontInfo::SetPointSize(
+  int                               nPointsize
+)
+{
+    fm.lEmHeight = (LONG)nPointsize;
+} // end of wxNativeFontInfo::SetPointSize
+
+void wxNativeFontInfo::SetStyle(
+  wxFontStyle                       eStyle
+)
+{
+    switch (eStyle)
+    {
+        default:
+            wxFAIL_MSG( wxT("unknown font style") );
+            // fall through
+
+        case wxFONTSTYLE_NORMAL:
+            break;
+
+        case wxFONTSTYLE_ITALIC:
+        case wxFONTSTYLE_SLANT:
+            fa.fsSelection |= FATTR_SEL_ITALIC;
+            break;
+    }
+} // end of wxNativeFontInfo::SetStyle
+
+void wxNativeFontInfo::SetWeight(
+  wxFontWeight                      eWeight
+)
+{
+    switch (eWeight)

     {
     {

-        M_FONTDATA->m_hPS = ::WinGetPS(HWND_DESKTOP);
-        bInternalPS = TRUE;
+        default:
+            wxFAIL_MSG( wxT("unknown font weight") );
+            // fall through
+
+        case wxFONTWEIGHT_NORMAL:
+            fn.usWeightClass = FWEIGHT_NORMAL;
+            break;
+
+        case wxFONTWEIGHT_LIGHT:
+            fn.usWeightClass = FWEIGHT_LIGHT;
+            break;
+
+        case wxFONTWEIGHT_BOLD:
+            fn.usWeightClass = FWEIGHT_BOLD;
+            break;

     }
     }

+} // end of wxNativeFontInfo::SetWeight

 
 

-    if (M_FONTDATA->m_pFM)
+void wxNativeFontInfo::SetUnderlined(
+  bool                              bUnderlined
+)
+{
+    if(bUnderlined)
+        fa.fsSelection |= FATTR_SEL_UNDERSCORE;
+} // end of wxNativeFontInfo::SetUnderlined
+
+bool wxNativeFontInfo::SetFaceName(
+  const wxString&                   sFacename
+)
+{
+    wxStrlcpy((wxChar*)fa.szFacename, sFacename, WXSIZEOF(fa.szFacename));
+    return true;
+} // end of wxNativeFontInfo::SetFaceName
+
+void wxNativeFontInfo::SetFamily(
+  wxFontFamily                      eFamily
+)
+{
+    wxString                        sFacename;
+
+    switch (eFamily)

     {
     {

-        delete [] M_FONTDATA->m_pFM;
-        M_FONTDATA->m_pFM = NULL;
+        case wxFONTFAMILY_SCRIPT:
+            sFacename = wxT("Tms Rmn");
+            break;
+
+        case wxFONTFAMILY_DECORATIVE:
+            sFacename = wxT("WarpSans");
+            break;
+
+        case wxFONTFAMILY_ROMAN:
+            sFacename = wxT("Tms Rmn");
+            break;
+
+        case wxFONTFAMILY_TELETYPE:
+            sFacename = wxT("Courier") ;
+            break;
+
+        case wxFONTFAMILY_MODERN:
+            sFacename = wxT("System VIO") ;
+            break;
+
+        case wxFONTFAMILY_SWISS:
+            sFacename = wxT("Helv") ;
+            break;
+
+        case wxFONTFAMILY_DEFAULT:
+        default:
+            sFacename = wxT("System VIO") ;

     }
     }

-    //
-    // Determine the number of fonts.
-    //
-    lNumFonts = ::GpiQueryFonts( M_FONTDATA->m_hPS
-                                ,QF_PUBLIC
-                                ,NULL
-                                ,&lTemp
-                                ,(LONG) sizeof(FONTMETRICS)
-                                ,NULL
-                               );

 
 

-    //
-    // Allocate space for the font metrics.
-    //
-    pFM = new FONTMETRICS[lNumFonts + 1];
+    if (!wxStrlen((wxChar*)fa.szFacename) )
+    {
+        SetFaceName(sFacename);
+    }
+} // end of wxNativeFontInfo::SetFamily

 
 

-    //
-    // Retrieve the font metrics.
-    //
-    lTemp = lNumFonts;
-    lTemp = ::GpiQueryFonts( M_FONTDATA->m_hPS
-                            ,QF_PUBLIC
-                            ,NULL
-                            ,&lTemp
-                            ,(LONG) sizeof(FONTMETRICS)
-                            ,pFM
-                           );
-    SetFM( pFM
-          ,(int)lNumFonts
-         );
-
-    wxString                        sVals;
-
-    for (int i = 0; i < lNumFonts; i++)
-    {
-         sVals << "Face: " <<M_FONTDATA->m_pFM[i].szFacename
-               << "Family: " <<M_FONTDATA->m_pFM[i].szFamilyname
-               << " PointSize: " << M_FONTDATA->m_pFM[i].lEmHeight
-               << " Height: " << M_FONTDATA->m_pFM[i].lXHeight
-               ;
-         sVals = "";
-    }
-    M_FONTDATA->m_vFattrs.usRecordLength = sizeof(FATTRS);
-    M_FONTDATA->m_vFattrs.fsFontUse = FATTR_FONTUSE_OUTLINE |       // only outline fonts allowed
-                                      FATTR_FONTUSE_TRANSFORMABLE;  // may be transformed
-    M_FONTDATA->m_vFattrs.fsType = 0;
-    M_FONTDATA->m_vFattrs.lMaxBaselineExt = M_FONTDATA->m_vFattrs.lAveCharWidth = 0;
-    M_FONTDATA->m_vFattrs.idRegistry = 0;
-    M_FONTDATA->m_vFattrs.lMatch = 0;
-
-    M_FONTDATA->m_vFname.usSize = sizeof(FACENAMEDESC);
-    M_FONTDATA->m_vFname.usWidthClass = FWIDTH_NORMAL;
-    M_FONTDATA->m_vFname.usReserved = 0;
-    M_FONTDATA->m_vFname.flOptions = 0;
-
-    OS2SelectMatchingFontByName();
-
-    long                            lNumLids = ::GpiQueryNumberSetIds(M_FONTDATA->m_hPS);
-    long                            lGpiError;
+void wxNativeFontInfo::SetEncoding( wxFontEncoding eEncoding )
+{
+    wxNativeEncodingInfo            vInfo;

 
 

-    //
-    // First we should generate unique id
-    //
-    if(lNumLids )
-    {
-        long                        alTypes[255];
-        STR8                        azNames[255];
-        long                        alIds[255];
-
-        if(!::GpiQuerySetIds( M_FONTDATA->m_hPS
-                             ,lNumLids
-                             ,alTypes
-                             ,azNames
-                             ,alIds
-                            ))
+    if ( !wxGetNativeFontEncoding( eEncoding
+                                  ,&vInfo
+                                 ))
+    {
+        if (wxFontMapper::Get()->GetAltForEncoding( eEncoding
+                                               ,&vInfo
+                                              ))

         {
         {

-            if (bInternalPS)
-                ::WinReleasePS(M_FONTDATA->m_hPS);
-            return 0;
+            if (!vInfo.facename.empty())
+            {
+                //
+                // If we have this encoding only in some particular facename, use
+                // the facename - it is better to show the correct characters in a
+                // wrong facename than unreadable text in a correct one
+                //
+                SetFaceName(vInfo.facename);
+            }

         }
         }

-
-        for(unsigned long LCNum = 0; LCNum < lNumLids; LCNum++)
-            if(alIds[LCNum] == flId)
-               ++flId;
-        if(flId > 254)  // wow, no id available!
+        else

         {
         {

-            if (bInternalPS)
-               ::WinReleasePS(M_FONTDATA->m_hPS);
-           return 0;
+            // unsupported encoding, replace with the default
+            vInfo.charset = 850;

         }
     }
         }
     }

+    fa.usCodePage = (USHORT)vInfo.charset;
+} // end of wxNativeFontInfo::SetFaceName
+
+bool wxNativeFontInfo::FromString( const wxString& rsStr )
+{
+    long                            lVal;
+
+    wxStringTokenizer               vTokenizer(rsStr, wxT(";"));

 
     //
 
     //

-    // Release and delete the current font
+    // First the version

     //
     //

-    ::GpiSetCharSet(M_FONTDATA->m_hPS, LCID_DEFAULT);/* release the font before deleting */
-    ::GpiDeleteSetId(M_FONTDATA->m_hPS, 1L);         /* delete the logical font          */
+    wxString                        sToken = vTokenizer.GetNextToken();
+
+    if (sToken != wxT('0'))
+        return false;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fm.lEmHeight = lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fa.lAveCharWidth = lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fa.fsSelection = (USHORT)lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fa.fsType = (USHORT)lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fa.fsFontUse = (USHORT)lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fa.idRegistry = (USHORT)lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fa.usCodePage = (USHORT)lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fa.lMatch = lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if (!sToken.ToLong(&lVal))
+        return false;
+    fn.usWeightClass = (USHORT)lVal;
+
+    sToken = vTokenizer.GetNextToken();
+    if(!sToken)
+        return false;
+    wxStrcpy((wxChar*)fa.szFacename, sToken.c_str());
+    return true;
+} // end of wxNativeFontInfo::FromString
+
+wxString wxNativeFontInfo::ToString() const
+{
+    wxString sStr;
+
+    sStr.Printf(wxT("%d;%ld;%ld;%ld;%d;%d;%d;%d;%d;%ld;%d;%s"),
+                0, // version, in case we want to change the format later
+                fm.lEmHeight,
+                fa.lAveCharWidth,
+                fa.lMaxBaselineExt,
+                fa.fsSelection,
+                fa.fsType,
+                fa.fsFontUse,
+                fa.idRegistry,
+                fa.usCodePage,
+                fa.lMatch,
+                fn.usWeightClass,
+                (char *)fa.szFacename);
+    return sStr;
+} // end of wxNativeFontInfo::ToString
+
+// ----------------------------------------------------------------------------
+// wxFont
+// ----------------------------------------------------------------------------
+
+bool wxFont::Create( const wxNativeFontInfo& rInfo,
+                     WXHFONT hFont )
+{
+    UnRef();
+    m_refData = new wxFontRefData( rInfo
+                                  ,hFont
+                                 );
+    RealizeResource();
+    return true;
+} // end of wxFont::Create
+
+wxFont::wxFont(
+  const wxString&                   rsFontdesc
+)
+{
+    wxNativeFontInfo                vInfo;
+
+    if (vInfo.FromString(rsFontdesc))
+        (void)Create(vInfo);
+} // end of wxFont::wxFont
+
+// ----------------------------------------------------------------------------
+// Constructor for a font. Note that the real construction is done
+// in wxDC::SetFont, when information is available about scaling etc.
+// ----------------------------------------------------------------------------
+bool wxFont::Create( int             nPointSize,
+                     wxFontFamily nFamily,
+                     wxFontStyle nStyle,
+                     wxFontWeight nWeight,
+                     bool            bUnderlined,
+                     const wxString& rsFaceName,
+                     wxFontEncoding  vEncoding )
+{
+    UnRef();

 
     //
 
     //

-    // Now build a facestring
+    // wxDEFAULT is a valid value for the font size too so we must treat it
+    // specially here (otherwise the size would be 70 == wxDEFAULT value)

     //
     //

-    char                            zFacename[128];
-    strcpy(zFacename, M_FONTDATA->m_vFattrs.szFacename);
-
-    if(::GpiQueryFaceString( M_FONTDATA->m_hPS
-                            ,zFacename
-                            ,&M_FONTDATA->m_vFname
-                            ,FACESIZE
-                            ,M_FONTDATA->m_vFattrs.szFacename
-                           ) == GPI_ERROR)
+    if (nPointSize == wxDEFAULT)

     {
     {

-        vError = ::WinGetLastError(vHabmain);
+        nPointSize = wxNORMAL_FONT->GetPointSize();

     }
     }

+    m_refData = new wxFontRefData( nPointSize
+                                  ,nFamily
+                                  ,nStyle
+                                  ,nWeight
+                                  ,bUnderlined
+                                  ,rsFaceName
+                                  ,vEncoding
+                                 );
+    RealizeResource();
+    return true;
+} // end of wxFont::Create

 
 

-    M_FONTDATA->m_sFaceName = zFacename;
+wxFont::~wxFont()
+{
+} // end of wxFont::~wxFont

 
 

-    if(::GpiCreateLogFont( M_FONTDATA->m_hPS
-                          ,NULL
-                          ,flId
-                          ,&M_FONTDATA->m_vFattrs
-                         ) != GPI_ERROR)
-       M_FONTDATA->m_hFont = (WXHFONT)1;
+// ----------------------------------------------------------------------------
+// real implementation
+// Boris' Kovalenko comments:
+//   Because OS/2 fonts are associated with PS we can not create the font
+//   here, but we may check that font definition is true
+// ----------------------------------------------------------------------------

 
 

+wxGDIRefData *wxFont::CreateGDIRefData() const
+{
+    return new wxFontRefData();
+}

 
 

-    if (bInternalPS)
-    {
-        if(M_FONTDATA->m_hFont)
-            ::GpiDeleteSetId( M_FONTDATA->m_hPS
-                             ,flId
-                            );
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
+{
+    return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
+}

 
 

-        ::WinReleasePS(M_FONTDATA->m_hPS);
-    }
-    else
-        ::GpiSetCharSet(M_FONTDATA->m_hPS, flId); // sets font for presentation space
-    if (!M_FONTDATA->m_hFont)
+bool wxFont::RealizeResource()
+{
+    if ( GetResourceHandle() )

     {
     {

-        wxLogLastError("CreateFont");
+        return true;

     }
     }

-    M_FONTDATA->m_nFontId = flId;
-    return(M_FONTDATA->m_hFont != 0);
+    return M_FONTDATA->Alloc(this);

 } // end of wxFont::RealizeResource
 
 } // end of wxFont::RealizeResource
 

-bool wxFont::FreeResource(
-  bool                              bForce
-)
+bool wxFont::FreeResource( bool WXUNUSED(bForce) )

 {
     if (GetResourceHandle())
     {
 {
     if (GetResourceHandle())
     {

-        M_FONTDATA->m_hFont = 0;
-        ::GpiDeleteSetId( M_FONTDATA->m_hPS
-                         ,M_FONTDATA->m_nFontId
-                        );
-        return TRUE;
+        M_FONTDATA->Free();
+        return true;

     }
     }

-    return FALSE;
+    return false;

 } // end of wxFont::FreeResource
 
 } // end of wxFont::FreeResource
 

-WXHANDLE wxFont::GetHFONT() const
-{
-    if (!M_FONTDATA)
-        return 0;
-    else
-        return (WXHANDLE)M_FONTDATA->m_hFont;
-} // end of wxFont::GetHFONT
-
-WXHANDLE wxFont::GetResourceHandle()
+WXHANDLE wxFont::GetResourceHandle() const

 {
     return GetHFONT();
 } // end of wxFont::GetResourceHandle
 
 {
     return GetHFONT();
 } // end of wxFont::GetResourceHandle
 

-bool wxFont::IsFree() const
+WXHFONT wxFont::GetHFONT() const

 {
 {

-    return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
-} // end of wxFont::IsFree
+    return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0;
+} // end of wxFont::GetHFONT

 
 

-void wxFont::Unshare()
+bool wxFont::IsFree() const

 {
 {

-    // Don't change shared data
-    if ( !m_refData )
-    {
-        m_refData = new wxFontRefData();
-    }
-    else
-    {
-        wxFontRefData* ref = new wxFontRefData(*M_FONTDATA);
-        UnRef();
-        m_refData = ref;
-    }
-} // end of wxFont::Unshare
+    return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0);
+} // end of wxFont::IsFree

 
 // ----------------------------------------------------------------------------
 // change font attribute: we recreate font when doing it
 
 // ----------------------------------------------------------------------------
 // change font attribute: we recreate font when doing it


@@ -455,64 +981,66 @@ void wxFont::SetPointSize(
   int                               nPointSize
 )
 {
   int                               nPointSize
 )
 {

-    Unshare();
+    AllocExclusive();

 
 

-    M_FONTDATA->m_nPointSize = nPointSize;
+    M_FONTDATA->SetPointSize(nPointSize);

 
     RealizeResource();
 } // end of wxFont::SetPointSize
 
 void wxFont::SetFamily(
 
     RealizeResource();
 } // end of wxFont::SetPointSize
 
 void wxFont::SetFamily(

-  int                               nFamily
+  wxFontFamily                      nFamily

 )
 {
 )
 {

-    Unshare();
+    AllocExclusive();

 
 

-    M_FONTDATA->m_nFamily = nFamily;
+    M_FONTDATA->SetFamily(nFamily);

 
     RealizeResource();
 } // end of wxFont::SetFamily
 
 void wxFont::SetStyle(
 
     RealizeResource();
 } // end of wxFont::SetFamily
 
 void wxFont::SetStyle(

-  int                               nStyle
+  wxFontStyle                       nStyle

 )
 {
 )
 {

-    Unshare();
+    AllocExclusive();

 
 

-    M_FONTDATA->m_nStyle = nStyle;
+    M_FONTDATA->SetStyle(nStyle);

 
     RealizeResource();
 } // end of wxFont::SetStyle
 
 void wxFont::SetWeight(
 
     RealizeResource();
 } // end of wxFont::SetStyle
 
 void wxFont::SetWeight(

-  int                               nWeight
+  wxFontWeight                      nWeight

 )
 {
 )
 {

-    Unshare();
+    AllocExclusive();

 
 

-    M_FONTDATA->m_nWeight = nWeight;
+    M_FONTDATA->SetWeight(nWeight);

 
     RealizeResource();
 } // end of wxFont::SetWeight
 
 
     RealizeResource();
 } // end of wxFont::SetWeight
 

-void wxFont::SetFaceName(
+bool wxFont::SetFaceName(

   const wxString&                   rsFaceName
 )
 {
   const wxString&                   rsFaceName
 )
 {

-    Unshare();
+    AllocExclusive();

 
 

-    M_FONTDATA->m_sFaceName = rsFaceName;
+    bool refdataok = M_FONTDATA->SetFaceName(rsFaceName);

 
     RealizeResource();
 
     RealizeResource();

+
+    return refdataok && wxFontBase::SetFaceName(rsFaceName);

 } // end of wxFont::SetFaceName
 
 void wxFont::SetUnderlined(
   bool                              bUnderlined
 )
 {
 } // end of wxFont::SetFaceName
 
 void wxFont::SetUnderlined(
   bool                              bUnderlined
 )
 {

-    Unshare();
+    AllocExclusive();

 
 

-    M_FONTDATA->m_bUnderlined = bUnderlined;
+    M_FONTDATA->SetUnderlined(bUnderlined);

 
     RealizeResource();
 } // end of wxFont::SetUnderlined
 
     RealizeResource();
 } // end of wxFont::SetUnderlined


@@ -521,35 +1049,25 @@ void wxFont::SetEncoding(
   wxFontEncoding                    vEncoding
 )
 {
   wxFontEncoding                    vEncoding
 )
 {

-    Unshare();
+    AllocExclusive();

 
 

-    M_FONTDATA->m_vEncoding = vEncoding;
+    M_FONTDATA->SetEncoding(vEncoding);

 
     RealizeResource();
 } // end of wxFont::SetEncoding
 
 
     RealizeResource();
 } // end of wxFont::SetEncoding
 

-void wxFont::SetPS(
-  HPS                               hPS
+void wxFont::DoSetNativeFontInfo(
+  const wxNativeFontInfo&           rInfo

 )
 {
 )
 {

-    Unshare();
+    AllocExclusive();

 
 

-    M_FONTDATA->m_hPS = hPS;
+    FreeResource();

 
 

-    RealizeResource();
-} // end of wxFont::SetPS
+    *M_FONTDATA = wxFontRefData(rInfo);

 
 

-void wxFont::SetFM(
-  PFONTMETRICS                      pFM
-, int                               nNumFonts
-)
-{
-    //
-    // Don't realize the font with this one
-    //
-    M_FONTDATA->m_pFM = pFM;
-    M_FONTDATA->m_nNumFonts = nNumFonts;
-} // end of wxFont::SetFM
+    RealizeResource();
+}

 
 // ----------------------------------------------------------------------------
 // accessors
 
 // ----------------------------------------------------------------------------
 // accessors


@@ -557,253 +1075,72 @@ void wxFont::SetFM(
 
 int wxFont::GetPointSize() const
 {
 
 int wxFont::GetPointSize() const
 {

-    wxFontRefData*                  pTmp;
+    wxCHECK_MSG( Ok(), 0, wxT("invalid font") );

 
 

-    pTmp = M_FONTDATA;
-    if(pTmp)
-      return pTmp->m_nPointSize;
-    else
-        return 10;
+    return M_FONTDATA->GetPointSize();

 } // end of wxFont::GetPointSize
 
 } // end of wxFont::GetPointSize
 

-int wxFont::GetFamily() const
+wxFontFamily wxFont::DoGetFamily() const

 {
 {

-    return M_FONTDATA->m_nFamily;
-} // end of wxFont::GetFamily
+    return M_FONTDATA->GetFamily();
+} // end of wxFont::DoGetFamily

 
 

-int wxFont::GetFontId() const
+wxFontStyle wxFont::GetStyle() const

 {
 {

-    return M_FONTDATA->m_nFontId;
-} // end of wxFont::GetFontId
+    wxCHECK_MSG( Ok(), wxFONTSTYLE_MAX, wxT("invalid font") );

 
 

-int wxFont::GetStyle() const
-{
-    return M_FONTDATA->m_nStyle;
+    return M_FONTDATA->GetStyle();

 } // end of wxFont::GetStyle
 
 } // end of wxFont::GetStyle
 

-int wxFont::GetWeight() const
+wxFontWeight wxFont::GetWeight() const

 {
 {

-    return M_FONTDATA->m_nWeight;
+    wxCHECK_MSG( Ok(), wxFONTWEIGHT_MAX, wxT("invalid font") );
+
+    return M_FONTDATA->GetWeight();

 }
 
 bool wxFont::GetUnderlined() const
 {
 }
 
 bool wxFont::GetUnderlined() const
 {

-    return M_FONTDATA->m_bUnderlined;
+    wxCHECK_MSG( Ok(), false, wxT("invalid font") );
+
+    return M_FONTDATA->GetUnderlined();

 } // end of wxFont::GetUnderlined
 
 wxString wxFont::GetFaceName() const
 {
 } // end of wxFont::GetUnderlined
 
 wxString wxFont::GetFaceName() const
 {

-    wxString                        sStr;
+    wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );

 
 

-    if ( M_FONTDATA )
-        sStr = M_FONTDATA->m_sFaceName ;
-    return sStr;
+    return M_FONTDATA->GetFaceName();

 } // end of wxFont::GetFaceName
 
 wxFontEncoding wxFont::GetEncoding() const
 {
 } // end of wxFont::GetFaceName
 
 wxFontEncoding wxFont::GetEncoding() const
 {

-    return M_FONTDATA->m_vEncoding;
-} // end of wxFont::GetEncoding
-
-HPS wxFont::GetPS() const
-{
-    return M_FONTDATA->m_hPS;
-} // end of wxFont::GetPS
-
-void wxFont::OS2SelectMatchingFontByName()
-{
-    int                             i;
-    int                             nDiff0;
-    int                             nDiff;
-    int                             nIs;
-    int                             nIndex;
-    int                             nMinDiff;
-    int                             nMinDiff0;
-    int                             nApirc;
-    int                             anDiff[16];
-    int                             anMinDiff[16];
-    STR8                            zFn;
-    char                            zFontFaceName[FACESIZE];
-    wxString                        sFaceName;
-    USHORT                          usWeightClass;
-    int                             fsSelection = 0;
-
-    nMinDiff0 = 0xf000;
-    for(i = 0;i < 16; i++)
-        anMinDiff[i] = nMinDiff0;
-
-    switch (GetFamily())
-    {
-        case wxSCRIPT:
-            sFaceName = wxT("Script");
-            break;
-
-        case wxDECORATIVE:
-        case wxROMAN:
-            sFaceName = wxT("Times New Roman");
-            break;
-
-        case wxTELETYPE:
-        case wxMODERN:
-            sFaceName = wxT("Courier") ;
-            break;
-
-        case wxSWISS:
-            sFaceName = wxT("WarpSans") ;
-            break;
-
-        case wxDEFAULT:
-        default:
-            sFaceName = wxT("Helv") ;
-    }
-
-    switch (GetWeight())
-    {
-        default:
-            wxFAIL_MSG(_T("unknown font weight"));
-            // fall through
-            usWeightClass = FWEIGHT_DONT_CARE;
-            break;
-
-        case wxNORMAL:
-            usWeightClass = FWEIGHT_NORMAL;
-            break;
-
-        case wxLIGHT:
-            usWeightClass = FWEIGHT_LIGHT;
-            break;
-
-        case wxBOLD:
-            usWeightClass = FWEIGHT_BOLD;
-            break;
-
-         case wxFONTWEIGHT_MAX:
-            usWeightClass = FWEIGHT_ULTRA_BOLD;
-            break;
-    }
-    M_FONTDATA->m_vFname.usWeightClass = usWeightClass;
-
-    switch (GetStyle())
-    {
-        case wxITALIC:
-        case wxSLANT:
-            fsSelection = FM_SEL_ITALIC;
-            M_FONTDATA->m_vFname.flOptions = FTYPE_ITALIC;
-            break;
-
-        default:
-            wxFAIL_MSG(wxT("unknown font slant"));
-            // fall through
-
-        case wxNORMAL:
-            fsSelection  = 0;
-            break;
-    }
-
-    wxStrncpy(zFontFaceName, sFaceName.c_str(), WXSIZEOF(zFontFaceName));
-    M_FONTDATA->m_nPointSize = GetPointSize();
-    nIndex = 0;
-    for(i = 0, nIs = 0; i < M_FONTDATA->m_nNumFonts; i++)
-    {
-        // Debug code
-        int nPointSize = M_FONTDATA->m_nPointSize;
-        int nEmHeight = 0;
-        int nXHeight  = 0;
-        anDiff[0] = wxGpiStrcmp(M_FONTDATA->m_pFM[i].szFamilyname, zFontFaceName);
-        anDiff[1] = abs(M_FONTDATA->m_pFM[i].lEmHeight - M_FONTDATA->m_nPointSize);
-        anDiff[2] = abs(M_FONTDATA->m_pFM[i].usWeightClass -  usWeightClass);
-        anDiff[3] = abs((M_FONTDATA->m_pFM[i].fsSelection & 0x2f) -  fsSelection);
-        if(anDiff[0] == 0)
-        {
-            nEmHeight = (int)M_FONTDATA->m_pFM[i].lEmHeight;
-            nXHeight  =(int)M_FONTDATA->m_pFM[i].lXHeight;
-            if( (nIs & 0x01) == 0)
-            {
-                nIs = 1;
-                nIndex = i;
-                anMinDiff[1] = anDiff[1];
-                anMinDiff[2] = anDiff[2];
-                anMinDiff[3] = anDiff[3];
-            }
-            else if(anDiff[3] < anMinDiff[3])
-            {
-                nIndex = i;
-                anMinDiff[3] = anDiff[3];
-            }
-            else if(anDiff[2] < anMinDiff[2])
-            {
-                nIndex = i;
-                anMinDiff[2] = anDiff[2];
-            }
-            else if(anDiff[1] < anMinDiff[1])
-            {
-                nIndex = i;
-                anMinDiff[1] = anDiff[1];
-            }
-            anMinDiff[0] = 0;
-        }
-        else if(anDiff[0] < anMinDiff[0])
-        {
-              nIs = 2;
-              nIndex = i;
-              anMinDiff[3] = anDiff[3];
-              anMinDiff[2] = anDiff[2];
-              anMinDiff[1] = anDiff[1];
-              anMinDiff[0] = anDiff[0];
-        }
-        else if(anDiff[0] == anMinDiff[0])
-        {
-            if(anDiff[3] < anMinDiff[3])
-            {
-                nIndex = i;
-                anMinDiff[3] = anDiff[3];
-                nIs = 2;
-            }
-            else if(anDiff[2] < anMinDiff[2])
-            {
-                nIndex = i;
-                anMinDiff[2] = anDiff[2];
-                nIs = 2;
-            }
-            else if(anDiff[1] < anMinDiff[1])
-            {
-                nIndex = i;
-                anMinDiff[1] = anDiff[1];
-                nIs = 2;
-            }
-        }
-    }
+    wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );

 
 

-    M_FONTDATA->m_vFattrs.usRecordLength = sizeof(FATTRS);                        // sets size of structure
-    M_FONTDATA->m_vFattrs.fsSelection    = M_FONTDATA->m_pFM[nIndex].fsSelection; // uses default selection
-    M_FONTDATA->m_vFattrs.lMatch         = M_FONTDATA->m_pFM[nIndex].lMatch;      // force match
-    M_FONTDATA->m_vFattrs.idRegistry     = M_FONTDATA->m_pFM[nIndex].idRegistry;  // uses default registry
-    M_FONTDATA->m_vFattrs.usCodePage     = M_FONTDATA->m_pFM[nIndex].usCodePage;  // code-page
-    if(M_FONTDATA->m_pFM[nIndex].lMatch)
-    {
-        M_FONTDATA->m_vFattrs.lMaxBaselineExt = M_FONTDATA->m_pFM[nIndex].lMaxBaselineExt; // requested font height
-        M_FONTDATA->m_vFattrs.lAveCharWidth   = M_FONTDATA->m_pFM[nIndex].lAveCharWidth ;  // requested font width
-    }
-    else
-    {
-        M_FONTDATA->m_vFattrs.lMaxBaselineExt = 0;
-        M_FONTDATA->m_vFattrs.lAveCharWidth   = 0;
-    }
-    M_FONTDATA->m_vFattrs.fsType    = 0;// pfm->fsType;              /* uses default type       */
-    M_FONTDATA->m_vFattrs.fsFontUse = 0;
+    return M_FONTDATA->GetEncoding();
+} // end of wxFont::GetEncoding

 
 

-    wxStrcpy(M_FONTDATA->m_vFattrs.szFacename, M_FONTDATA->m_pFM[nIndex].szFacename);
-    // Debug
-    strcpy(zFontFaceName, M_FONTDATA->m_pFM[nIndex].szFacename);
-    strcpy(zFontFaceName, M_FONTDATA->m_vFattrs.szFacename);
+const wxNativeFontInfo* wxFont::GetNativeFontInfo() const
+{
+    return M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo())
+                                           : NULL;
+} // end of wxFont::GetNativeFontInfo
+
+//
+// Internal use only method to set the FONTMETRICS array
+//
+void wxFont::SetFM( PFONTMETRICS pFM, int nNumFonts )
+{
+    M_FONTDATA->SetFM(pFM);
+    M_FONTDATA->SetNumFonts(nNumFonts);
+} // end of wxFont::SetFM

 
 

-    if(usWeightClass >= FWEIGHT_BOLD)
-        M_FONTDATA->m_vFattrs.fsSelection |= FATTR_SEL_BOLD;
-    if(GetUnderlined())
-        M_FONTDATA->m_vFattrs.fsSelection |= FATTR_SEL_UNDERSCORE;
-    if(fsSelection & FM_SEL_ITALIC)
-        M_FONTDATA->m_vFattrs.fsSelection |= FATTR_SEL_ITALIC;
-}

 
 

+void wxFont::SetPS( HPS hPS )
+{
+    AllocExclusive();

 
 

+    M_FONTDATA->SetPS(hPS);

 
 

+    RealizeResource();
+} // end of wxFont::SetPS