wxStyledTextCtrl can now be built and used when wxUSE_UNICODE==1.

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

diff --git a/src/os2/fontutil.cpp b/src/os2/fontutil.cpp
index c5e987133b94e6b8fbab8d66446bf13a84849f23..805b4eeb9e716b6ed6efac35cfd1481ec5ff79e0 100644 (file)
--- a/src/os2/fontutil.cpp
+++ b/src/os2/fontutil.cpp
@@ -29,6 +29,7 @@
 #include "wx/wxprec.h"
 
 #ifndef WX_PRECOMP
 #include "wx/wxprec.h"
 
 #ifndef WX_PRECOMP

+    #include "wx/app.h"

     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"


@@ -52,414 +53,740 @@
 // convert to/from the string representation: format is
 //      encodingid;facename[;charset]
 
 // convert to/from the string representation: format is
 //      encodingid;facename[;charset]
 

-bool wxNativeEncodingInfo::FromString(const wxString& s)
+bool wxNativeEncodingInfo::FromString(
+  const wxString&                   rsStr
+)

 {
 {

-    wxStringTokenizer tokenizer(s, _T(";"));
+    wxStringTokenizer               vTokenizer(rsStr, _T(";"));
+    wxString                        sEncid = vTokenizer.GetNextToken();
+    long                            lEnc;

 
 

-    wxString encid = tokenizer.GetNextToken();
-    long enc;
-    if ( !encid.ToLong(&enc) )
+    if (!sEncid.ToLong(&lEnc))

         return FALSE;
         return FALSE;

-    encoding = (wxFontEncoding)enc;
-
-    facename = tokenizer.GetNextToken();
-    if ( !facename )
+    encoding = (wxFontEncoding)lEnc;
+    facename = vTokenizer.GetNextToken();
+    if (!facename)

         return FALSE;
 
         return FALSE;
 

-    wxString tmp = tokenizer.GetNextToken();
-    if ( !tmp )
+    wxString                        sTmp = vTokenizer.GetNextToken();
+
+    if (!sTmp)

     {
     {

-        // default charset (don't use DEFAULT_CHARSET though because of subtle
-        // Windows 9x/NT differences in handling it)
-// TODO: what is this for OS/2?
-//        charset = ANSI_CHARSET;
+        charset = 850;

     }
     else
     {
     }
     else
     {

-        if ( wxSscanf(tmp, _T("%u"), &charset) != 1 )
+        if ( wxSscanf(sTmp, _T("%u"), &charset) != 1 )

         {
             // should be a number!
             return FALSE;
         }
     }
         {
             // should be a number!
             return FALSE;
         }
     }

-

     return TRUE;
     return TRUE;

-}
+} // end of wxNativeEncodingInfo::FromString

 
 wxString wxNativeEncodingInfo::ToString() const
 {
 
 wxString wxNativeEncodingInfo::ToString() const
 {

-    wxString s;
+    wxString                        sStr;

 
 

-    s << (long)encoding << _T(';') << facename;
+    sStr << (long)encoding << _T(';') << facename;

 
 

-// TODO: what is this for OS/2?
-/*
-    if ( charset != ANSI_CHARSET )
+    if (charset != 850)

     {
     {

-        s << _T(';') << charset;
+        sStr << _T(';') << charset;

     }
     }

-*/
-    return s;
-}
+    return sStr;
+} // end of wxNativeEncodingInfo::ToString

 
 // ----------------------------------------------------------------------------
 // helper functions
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // helper functions
 // ----------------------------------------------------------------------------
 

-bool wxGetNativeFontEncoding(wxFontEncoding encoding,
-                             wxNativeEncodingInfo *info)
+bool wxGetNativeFontEncoding(
+  wxFontEncoding                    vEncoding
+, wxNativeEncodingInfo*             pInfo
+)

 {
 {

-    wxCHECK_MSG( info, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
-
-    if ( encoding == wxFONTENCODING_DEFAULT )
+    wxCHECK_MSG(pInfo, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
+    if (vEncoding == wxFONTENCODING_DEFAULT)

     {
     {

-        encoding = wxFont::GetDefaultEncoding();
+        vEncoding = wxFont::GetDefaultEncoding();

     }
     }

-
-    switch ( encoding )
+    switch (vEncoding)

     {
     {

-// TODO: fix this for OS2
-/*
-        // although this function is supposed to return an exact match, do do
-        // some mappings here for the most common case of "standard" encoding
-        case wxFONTENCODING_SYSTEM:

         case wxFONTENCODING_ISO8859_1:
         case wxFONTENCODING_ISO8859_15:
         case wxFONTENCODING_ISO8859_1:
         case wxFONTENCODING_ISO8859_15:

-        case wxFONTENCODING_CP1252:
-            info->charset = ANSI_CHARSET;
+        case wxFONTENCODING_CP1250:
+            pInfo->charset = 1250;

             break;
 
             break;
 

-        case wxFONTENCODING_CP1250:
-            info->charset = EASTEUROPE_CHARSET;
+        case wxFONTENCODING_ISO8859_2:
+        case wxFONTENCODING_CP1252:
+            pInfo->charset = 1252;

             break;
 
             break;
 

-        case wxFONTENCODING_CP1251:
-            info->charset = RUSSIAN_CHARSET;
+        case wxFONTENCODING_ISO8859_4:
+        case wxFONTENCODING_ISO8859_10:
+            pInfo->charset = 921; // what is baltic?

             break;
 
             break;
 

-        case wxFONTENCODING_CP1253:
-            info->charset = GREEK_CHARSET;
+        case wxFONTENCODING_ISO8859_5:
+        case wxFONTENCODING_CP1251:
+            pInfo->charset = 1251;

             break;
 
             break;
 

-        case wxFONTENCODING_CP1254:
-            info->charset = TURKISH_CHARSET;
+        case wxFONTENCODING_ISO8859_6:
+            pInfo->charset = 864;

             break;
 
             break;
 

-        case wxFONTENCODING_CP1255:
-            info->charset = HEBREW_CHARSET;
+        case wxFONTENCODING_ISO8859_7:
+            pInfo->charset = 869;

             break;
 
             break;
 

-        case wxFONTENCODING_CP1256:
-            info->charset = ARABIC_CHARSET;
+        case wxFONTENCODING_ISO8859_8:
+            pInfo->charset = 862;

             break;
 
             break;
 

-        case wxFONTENCODING_CP1257:
-            info->charset = BALTIC_CHARSET;
+        case wxFONTENCODING_ISO8859_9:
+            pInfo->charset = 857;

             break;
 
             break;
 

-        case wxFONTENCODING_CP874:
-            info->charset = THAI_CHARSET;
+        case wxFONTENCODING_ISO8859_11:
+            pInfo->charset = 874; // what is thai

             break;
 
         case wxFONTENCODING_CP437:
             break;
 
         case wxFONTENCODING_CP437:

-            info->charset = OEM_CHARSET;
+            pInfo->charset = 437;

             break;
             break;

-*/
+

         default:
         default:

-            // no way to translate this encoding into a Windows charset
-            return FALSE;
-    }
+            wxFAIL_MSG(wxT("unsupported encoding"));
+            // fall through

 
 

+        case wxFONTENCODING_SYSTEM:
+            pInfo->charset = 850;
+            break;
+    }

     return TRUE;
     return TRUE;

-}
+} // end of wxGetNativeFontEncoding

 
 

-bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
+wxFontEncoding wxGetFontEncFromCharSet(
+  int                               nCharSet
+)

 {
 {

-   // TODO:
-   /*
-    // try to create such font
-    LOGFONT lf;
-    wxZeroMemory(lf);       // all default values
+    wxFontEncoding                  eFontEncoding;
+
+    switch (nCharSet)
+    {
+        default:
+        case 1250:
+            eFontEncoding = wxFONTENCODING_CP1250;
+            break;
+
+        case 1252:
+            eFontEncoding = wxFONTENCODING_CP1252;
+            break;
+
+        case 921:
+            eFontEncoding = wxFONTENCODING_ISO8859_4;
+            break;
+
+        case 1251:
+            eFontEncoding = wxFONTENCODING_CP1251;
+            break;
+
+        case 864:
+            eFontEncoding = wxFONTENCODING_ISO8859_6;
+            break;

 
 

-    lf.lfCharSet = info.charset;
-    strncpy(lf.lfFaceName, info.facename, sizeof(lf.lfFaceName));
+        case 869:
+            eFontEncoding = wxFONTENCODING_ISO8859_7;
+            break;
+
+        case 862:
+            eFontEncoding = wxFONTENCODING_ISO8859_8;
+            break;
+
+        case 857:
+            eFontEncoding = wxFONTENCODING_ISO8859_9;
+            break;

 
 

-    HFONT hfont = ::CreateFontIndirect(&lf);
-    if ( !hfont )
+        case 874:
+            eFontEncoding = wxFONTENCODING_ISO8859_11;
+            break;
+
+        case 437:
+            eFontEncoding = wxFONTENCODING_CP437;
+            break;
+    }
+    return eFontEncoding;
+} // end of wxGetNativeFontEncoding
+
+bool wxTestFontEncoding(
+  const wxNativeEncodingInfo&       rInfo
+)
+{
+    FATTRS                          vLogFont;
+    HPS                             hPS;
+
+    hPS = ::WinGetPS(HWND_DESKTOP);
+
+    memset(&vLogFont, '\0', sizeof(FATTRS));           // all default values
+    vLogFont.usRecordLength = sizeof(FATTRS);
+    vLogFont.usCodePage = rInfo.charset;
+    vLogFont.lMaxBaselineExt = 0L;                    // Outline fonts should use 0
+    vLogFont.lAveCharWidth = 0L;                      // Outline fonts should use 0
+    vLogFont.fsFontUse = FATTR_FONTUSE_OUTLINE |      // only outline fonts allowed
+                         FATTR_FONTUSE_TRANSFORMABLE; // may be transformed
+
+    strncpy(vLogFont.szFacename, rInfo.facename.c_str(), sizeof(vLogFont.szFacename));
+
+    if (!::GpiCreateLogFont( hPS
+                            ,NULL
+                            ,1L
+                            ,&vLogFont
+                           ))

     {
     {

-        // no such font
+        ::WinReleasePS(hPS);

         return FALSE;
     }
         return FALSE;
     }

-
-    ::DeleteObject((HGDIOBJ)hfont);
-*/
+    ::WinReleasePS(hPS);

     return TRUE;
     return TRUE;

-}
+} // end of wxTestFontEncoding

 
 // ----------------------------------------------------------------------------
 // wxFont <-> LOGFONT conversion
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxFont <-> LOGFONT conversion
 // ----------------------------------------------------------------------------
 

-#if 0
-void wxFillLogFont(LOGFONT *logFont, const wxFont *font)
+void wxFillLogFont(
+  LOGFONT*                          pFattrs  // OS2 GPI FATTRS
+, PFACENAMEDESC                     pFaceName
+, HPS*                              phPS
+, bool*                             pbInternalPS
+, long*                             pflId
+, wxString&                         sFaceName
+, wxFont*                           pFont
+)

 {
 {

-    int ff_family;
-    wxString ff_face;
+    LONG                            lNumFonts = 0L;       // For system font count
+    ERRORID                         vError;               // For logging API errors
+    LONG                            lTemp = 0L;
+    bool                            bInternalPS = FALSE;  // if we have to create one
+    PFONTMETRICS                    pFM = NULL;
+
+    //
+    // Initial house cleaning to free data buffers and ensure we have a
+    // functional PS to work with
+    //
+    if (!*phPS)
+    {
+        *phPS = ::WinGetPS(HWND_DESKTOP);
+        bInternalPS = TRUE;
+    }
+
+    //
+    // Determine the number of fonts.
+    //
+    if((lNumFonts = ::GpiQueryFonts( *phPS
+                                    ,QF_PUBLIC
+                                    ,NULL
+                                    ,&lTemp
+                                    ,(LONG) sizeof(FONTMETRICS)
+                                    ,NULL
+                                   )) < 0L)
+    {
+        ERRORID                     vError;
+        wxString                    sError;

 
 

-    switch ( font->GetFamily() )
+        vError = ::WinGetLastError(wxGetInstance());
+        sError = wxPMErrorToStr(vError);
+        return;
+    }
+
+    //
+    // Allocate space for the font metrics.
+    //
+    pFM = new FONTMETRICS[lNumFonts + 1];
+
+    //
+    // Retrieve the font metrics.
+    //
+    lTemp = lNumFonts;
+    lTemp = ::GpiQueryFonts( *phPS
+                            ,QF_PUBLIC
+                            ,NULL
+                            ,&lTemp
+                            ,(LONG) sizeof(FONTMETRICS)
+                            ,pFM
+                           );
+    pFont->SetFM( pFM
+                 ,(int)lNumFonts
+                );
+
+    wxString                        sVals;
+
+    //
+    // For debugging, delete later
+    //
+    for (int i = 0; i < lNumFonts; i++)
+    {
+         sVals << "Face: " << pFM[i].szFacename
+               << "Family: " << pFM[i].szFamilyname
+               << " PointSize: " << pFM[i].lEmHeight
+               << " Height: " << pFM[i].lXHeight
+               ;
+         sVals = "";
+    }
+
+    //
+    // Initialize FATTR and FACENAMEDESC
+    //
+    pFattrs->usRecordLength = sizeof(FATTRS);
+    pFattrs->fsFontUse = FATTR_FONTUSE_OUTLINE |       // only outline fonts allowed
+                          FATTR_FONTUSE_TRANSFORMABLE;  // may be transformed
+    pFattrs->fsType = 0;
+    pFattrs->lMaxBaselineExt = pFattrs->lAveCharWidth = 0;
+    pFattrs->idRegistry = 0;
+    pFattrs->lMatch = 0;
+
+    pFaceName->usSize = sizeof(FACENAMEDESC);
+    pFaceName->usWidthClass = FWIDTH_NORMAL;
+    pFaceName->usReserved = 0;
+    pFaceName->flOptions = 0;
+
+    //
+    // This does the actual selection of fonts
+    //
+    wxOS2SelectMatchingFontByName( pFattrs
+                                  ,pFaceName
+                                  ,pFM
+                                  ,(int)lNumFonts
+                                  ,pFont
+                                 );
+    //
+    // We should now have the correct FATTRS set with the selected
+    // font, so now we need to generate an ID
+    //
+    long                            lNumLids = ::GpiQueryNumberSetIds(*phPS);
+    long                            lGpiError;
+
+    if(lNumLids )
+    {
+        long                        alTypes[255];
+        STR8                        azNames[255];
+        long                        alIds[255];
+
+        if(!::GpiQuerySetIds( *phPS
+                             ,lNumLids
+                             ,alTypes
+                             ,azNames
+                             ,alIds
+                            ))
+        {
+            if (bInternalPS)
+                ::WinReleasePS(*phPS);
+            return;
+        }
+
+        for(unsigned long LCNum = 0; LCNum < lNumLids; LCNum++)
+            if(alIds[LCNum] == *pflId)
+               ++*pflId;
+        if(*pflId > 254)  // wow, no id available!
+        {
+            if (bInternalPS)
+               ::WinReleasePS(*phPS);
+           return;
+        }
+    }
+    else
+        *pflId = 1L;
+    //
+    // Release and delete the current font
+    //
+    ::GpiSetCharSet(*phPS, LCID_DEFAULT);/* release the font before deleting */
+    ::GpiDeleteSetId(*phPS, 1L);         /* delete the logical font          */
+
+    //
+    // Now build a facestring
+    //
+    char                            zFacename[128];
+
+    strcpy(zFacename, pFattrs->szFacename);
+
+    if(::GpiQueryFaceString( *phPS
+                            ,zFacename
+                            ,pFaceName
+                            ,FACESIZE
+                            ,pFattrs->szFacename
+                           ) == GPI_ERROR)
+    {
+        vError = ::WinGetLastError(vHabmain);
+    }
+    sFaceName = zFacename;
+    *pbInternalPS = bInternalPS;
+
+    //
+    // That's it, we now have everything we need to actually create the font
+    //
+} // end of wxFillLogFont
+
+void wxOS2SelectMatchingFontByName(
+  PFATTRS                           pFattrs
+, PFACENAMEDESC                     pFaceName
+, PFONTMETRICS                      pFM
+, int                               nNumFonts
+, const wxFont*                     pFont
+)
+{
+    int                             i;
+    int                             nDiff0;
+    int                             nPointSize;
+    int                             nDiff;
+    int                             nIs;
+    int                             nMinDiff;
+    int                             nMinDiff0;
+    int                             nApirc;
+    int                             anDiff[16];
+    int                             anMinDiff[16];
+    int                             nIndex = 0;
+    STR8                            zFn;
+    char                            zFontFaceName[FACESIZE];
+    wxString                        sFaceName;
+    USHORT                          usWeightClass;
+    int                             fsSelection = 0;
+
+    nMinDiff0 = 0xf000;
+    for(i = 0;i < 16; i++)
+        anMinDiff[i] = nMinDiff0;
+
+    switch (pFont->GetFamily())

     {
         case wxSCRIPT:
     {
         case wxSCRIPT:

-            ff_family = FF_SCRIPT;
-            ff_face = _T("Script");
+            sFaceName = wxT("Script");

             break;
 
         case wxDECORATIVE:
             break;
 
         case wxDECORATIVE:

-            ff_family = FF_DECORATIVE;
-            break;
-

         case wxROMAN:
         case wxROMAN:

-            ff_family = FF_ROMAN;
-            ff_face = _T("Times New Roman");
+            sFaceName = wxT("Tms Rmn");

             break;
 
         case wxTELETYPE:
             break;
 
         case wxTELETYPE:

+            sFaceName = wxT("Courier") ;
+            break;
+

         case wxMODERN:
         case wxMODERN:

-            ff_family = FF_MODERN;
-            ff_face = _T("Courier New");
+            sFaceName = wxT("System VIO") ;

             break;
 
         case wxSWISS:
             break;
 
         case wxSWISS:

-            ff_family = FF_SWISS;
-            ff_face = _T("Arial");
+            sFaceName = wxT("Helv") ;

             break;
 
         case wxDEFAULT:
         default:
             break;
 
         case wxDEFAULT:
         default:

-            ff_family = FF_SWISS;
-            ff_face = _T("MS Sans Serif");
+            sFaceName = wxT("System VIO") ;

     }
 
     }
 

-    BYTE ff_italic;
-    switch ( font->GetStyle() )
-    {
-        case wxITALIC:
-        case wxSLANT:
-            ff_italic = 1;
-            break;
-
-        default:
-            wxFAIL_MSG(wxT("unknown font slant"));
-            // fall through
-
-        case wxNORMAL:
-            ff_italic = 0;
-    }
-
-    int ff_weight;
-    switch ( font->GetWeight() )
+    switch (pFont->GetWeight())

     {
         default:
             wxFAIL_MSG(_T("unknown font weight"));
             // fall through
     {
         default:
             wxFAIL_MSG(_T("unknown font weight"));
             // fall through

+            usWeightClass = FWEIGHT_DONT_CARE;
+            break;

 
         case wxNORMAL:
 
         case wxNORMAL:

-            ff_weight = FW_NORMAL;
+            usWeightClass = FWEIGHT_NORMAL;

             break;
 
         case wxLIGHT:
             break;
 
         case wxLIGHT:

-            ff_weight = FW_LIGHT;
+            usWeightClass = FWEIGHT_LIGHT;

             break;
 
         case wxBOLD:
             break;
 
         case wxBOLD:

-            ff_weight = FW_BOLD;
+            usWeightClass = FWEIGHT_BOLD;

             break;
             break;

-    }

 
 

-#if 0
-    HDC dc = ::GetDC(NULL);
-    int ppInch = ::GetDeviceCaps(dc, LOGPIXELSY);
-    ::ReleaseDC(NULL, dc);
-#else
-    // New behaviour: apparently ppInch varies according to Large/Small Fonts
-    // setting in Windows. This messes up fonts. So, set ppInch to a constant
-    // 96 dpi.
-    static const int ppInch = 96;
-#endif // 0/1
-
-#if wxFONT_SIZE_COMPATIBILITY
-    // Incorrect, but compatible with old wxWindows behaviour
-    int nHeight = (font->GetPointSize()*ppInch/72);
-#else
-    // Correct for Windows compatibility
-    int nHeight = - (font->GetPointSize()*ppInch/72);
-#endif
+         case wxFONTWEIGHT_MAX:
+            usWeightClass = FWEIGHT_ULTRA_BOLD;
+            break;
+    }
+    pFaceName->usWeightClass = usWeightClass;

 
 

-    wxString facename = font->GetFaceName();
-    if ( !!facename )
+    switch (pFont->GetStyle())

     {
     {

-        ff_face = facename;
+        case wxITALIC:
+        case wxSLANT:
+            fsSelection = FM_SEL_ITALIC;
+            pFaceName->flOptions = FTYPE_ITALIC;
+            break;
+
+        default:
+            wxFAIL_MSG(wxT("unknown font slant"));
+            // fall through
+
+        case wxNORMAL:
+            fsSelection  = 0;
+            break;

     }
     }

-    //else: ff_face is a reasonable default facename for this font family

 
 

-    // deal with encoding now
-    wxNativeEncodingInfo info;
-    wxFontEncoding encoding = font->GetEncoding();
-    if ( !wxGetNativeFontEncoding(encoding, &info) )
+    wxStrncpy(zFontFaceName, sFaceName.c_str(), WXSIZEOF(zFontFaceName));
+    nPointSize = pFont->GetPointSize();
+
+    //
+    // Matching logic to find the right FM struct
+    //
+    nIndex = 0;
+    for(i = 0, nIs = 0; i < nNumFonts; i++)

     {
     {

-        if ( !wxTheFontMapper->GetAltForEncoding(encoding, &info) )
+        int                         nEmHeight = 0;
+        int                         nXHeight = 0;
+
+        anDiff[0] = wxGpiStrcmp(pFM[i].szFamilyname, zFontFaceName);
+        anDiff[1] = abs(pFM[i].lEmHeight - nPointSize);
+        anDiff[2] = abs(pFM[i].usWeightClass -  usWeightClass);
+        anDiff[3] = abs((pFM[i].fsSelection & 0x2f) -  fsSelection);
+        if(anDiff[0] == 0)

         {
         {

-            // unsupported encoding, replace with the default
-            info.charset = ANSI_CHARSET;
+            nEmHeight = (int)pFM[i].lEmHeight;
+            nXHeight  =(int)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;
+            }

         }
     }
 
         }
     }
 

-    if ( !info.facename.IsEmpty() )
-    {
-        // the facename determined by the encoding overrides everything else
-        ff_face = info.facename;
-    }
-
-    // transfer all the data to LOGFONT
-    logFont->lfHeight = nHeight;
-    logFont->lfWidth = 0;
-    logFont->lfEscapement = 0;
-    logFont->lfOrientation = 0;
-    logFont->lfWeight = ff_weight;
-    logFont->lfItalic = ff_italic;
-    logFont->lfUnderline = (BYTE)font->GetUnderlined();
-    logFont->lfStrikeOut = 0;
-    logFont->lfCharSet = info.charset;
-    logFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
-    logFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
-    logFont->lfQuality = PROOF_QUALITY;
-    logFont->lfPitchAndFamily = DEFAULT_PITCH | ff_family;
-    wxStrncpy(logFont->lfFaceName, ff_face, WXSIZEOF(logFont->lfFaceName));
-}
-
-wxFont wxCreateFontFromLogFont(const LOGFONT *logFont)
+    //
+    // Fill in the FATTRS with the best match from FONTMETRICS
+    //
+    pFattrs->usRecordLength = sizeof(FATTRS);            // sets size of structure
+    pFattrs->fsSelection    = pFM[nIndex].fsSelection; // uses default selection
+    pFattrs->lMatch         = pFM[nIndex].lMatch;      // force match
+    pFattrs->idRegistry     = pFM[nIndex].idRegistry;  // uses default registry
+    pFattrs->usCodePage     = pFM[nIndex].usCodePage;  // code-page
+    pFattrs->lMaxBaselineExt = 0;   // OUTLINE fonts need this set to 0 as they use other attributes to match
+    pFattrs->lAveCharWidth   = 0;   // OUTLINE fonts need this set to 0 as they use other attributes to match
+    pFattrs->fsType    = 0;// pfm->fsType;              /* uses default type       */
+    pFattrs->fsFontUse = 0;
+
+    wxStrcpy(pFattrs->szFacename, pFM[nIndex].szFacename);
+    // Debug
+    strcpy(zFontFaceName, pFM[nIndex].szFacename);
+    strcpy(zFontFaceName, pFattrs->szFacename);
+
+    if(usWeightClass >= FWEIGHT_BOLD)
+        pFattrs->fsSelection |= FATTR_SEL_BOLD;
+    if(pFont->GetUnderlined())
+        pFattrs->fsSelection |= FATTR_SEL_UNDERSCORE;
+    if(fsSelection & FM_SEL_ITALIC)
+        pFattrs->fsSelection |= FATTR_SEL_ITALIC;
+} // end of wxOS2SelectMatchingFontByName
+
+wxFont wxCreateFontFromLogFont(
+  const LOGFONT*                    pLogFont
+, const PFONTMETRICS                pFM
+, PFACENAMEDESC                     pFaceName
+)

 {
 {

-DEBUG_PRINTF(wxCreateFontFromLogFont)
-
-    // extract family from pitch-and-family
-    int lfFamily = logFont->lfPitchAndFamily;
-    if ( lfFamily & FIXED_PITCH )
-        lfFamily -= FIXED_PITCH;
-    if ( lfFamily & VARIABLE_PITCH )
-        lfFamily -= VARIABLE_PITCH;
-
-    int fontFamily;
-    switch ( lfFamily )
-    {
-        case FF_ROMAN:
-            fontFamily = wxROMAN;
-            break;
-
-        case FF_SWISS:
-            fontFamily = wxSWISS;
-            break;
-
-        case FF_SCRIPT:
-            fontFamily = wxSCRIPT;
-            break;
-
-        case FF_MODERN:
-            fontFamily = wxMODERN;
-            break;
-
-        case FF_DECORATIVE:
-            fontFamily = wxDECORATIVE;
-            break;
+    //
+    // Extract family from facename
+    //
+    int                             nFontFamily;
+
+    if (strcmp(pLogFont->szFacename, "Times New Roman") == 0)
+        nFontFamily = wxROMAN;
+    else if (strcmp(pLogFont->szFacename, "WarpSans") == 0)
+        nFontFamily = wxSWISS;
+    else if (strcmp(pLogFont->szFacename, "Script") == 0)
+        nFontFamily = wxSCRIPT;
+    else if (strcmp(pLogFont->szFacename, "Courier New") == 0)
+        nFontFamily = wxMODERN;
+    else
+        nFontFamily = wxSWISS;

 
 

-        default:
-            fontFamily = wxSWISS;
-    }
+    //
+    // Weight and Style
+    //
+    int                             nFontWeight = wxNORMAL;

 
 

-    // weight and style
-    int fontWeight = wxNORMAL;
-    switch ( logFont->lfWeight )
+    switch (pFaceName->usWeightClass)

     {
     {

-        case FW_LIGHT:
-            fontWeight = wxLIGHT;
+        case FWEIGHT_LIGHT:
+            nFontWeight = wxLIGHT;

             break;
 
         default:
             break;
 
         default:

-        case FW_NORMAL:
-            fontWeight = wxNORMAL;
+        case FWEIGHT_NORMAL:
+            nFontWeight = wxNORMAL;

             break;
 
             break;
 

-        case FW_BOLD:
-            fontWeight = wxBOLD;
+        case FWEIGHT_BOLD:
+            nFontWeight = wxBOLD;

             break;
     }
 
             break;
     }
 

-    int fontStyle = logFont->lfItalic ? wxITALIC : wxNORMAL;
+    int                             nFontStyle;

 
 

-    bool fontUnderline = logFont->lfUnderline != 0;
-
-    wxString fontFace = logFont->lfFaceName;
-
-    // font size
-    HDC dc = ::GetDC(NULL);
-
-    // remember that 1pt = 1/72inch
-    int height = abs(logFont->lfHeight);
-    int fontPoints = (72*height)/GetDeviceCaps(dc, LOGPIXELSY);
+    if(pLogFont->fsSelection & FATTR_SEL_ITALIC)
+        nFontStyle = wxITALIC;
+    else
+        nFontStyle = wxNORMAL;

 
 

-    ::ReleaseDC(NULL, dc);
+    bool                            bFontUnderline = (pLogFont->fsSelection & FATTR_SEL_UNDERSCORE);
+    wxString                        sFontFace = pLogFont->szFacename;
+    int                             nFontPoints = pFM->lEmHeight;
+    wxFontEncoding                  vFontEncoding;

 
 

-    wxFontEncoding fontEncoding;
-    switch ( logFont->lfCharSet )
+    switch (pLogFont->usCodePage)

     {
         default:
             wxFAIL_MSG(wxT("unsupported charset"));
             // fall through
 
     {
         default:
             wxFAIL_MSG(wxT("unsupported charset"));
             // fall through
 

-        case ANSI_CHARSET:
-            fontEncoding = wxFONTENCODING_CP1252;
+        case 850:
+            vFontEncoding = wxFONTENCODING_CP1252;

             break;
 
             break;
 

-#ifdef __WIN32__
-        case EASTEUROPE_CHARSET:
-            fontEncoding = wxFONTENCODING_CP1250;
+        case 1250:
+            vFontEncoding = wxFONTENCODING_CP1250;

             break;
 
             break;
 

-        case BALTIC_CHARSET:
-            fontEncoding = wxFONTENCODING_CP1257;
+        case 921:
+            vFontEncoding = wxFONTENCODING_CP1257;

             break;
 
             break;
 

-        case RUSSIAN_CHARSET:
-            fontEncoding = wxFONTENCODING_CP1251;
+        case 866:
+            vFontEncoding = wxFONTENCODING_CP1251;

             break;
 
             break;
 

-        case ARABIC_CHARSET:
-            fontEncoding = wxFONTENCODING_CP1256;
+        case 864:
+            vFontEncoding = wxFONTENCODING_CP1256;

             break;
 
             break;
 

-        case GREEK_CHARSET:
-            fontEncoding = wxFONTENCODING_CP1253;
+        case 869:
+            vFontEncoding = wxFONTENCODING_CP1253;

             break;
 
             break;
 

-        case HEBREW_CHARSET:
-            fontEncoding = wxFONTENCODING_CP1255;
+        case 862:
+            vFontEncoding = wxFONTENCODING_CP1255;

             break;
 
             break;
 

-        case TURKISH_CHARSET:
-            fontEncoding = wxFONTENCODING_CP1254;
+        case 857:
+            vFontEncoding = wxFONTENCODING_CP1254;

             break;
 
             break;
 

-        case THAI_CHARSET:
-            fontEncoding = wxFONTENCODING_CP437;
+        case 874:
+            vFontEncoding = wxFONTENCODING_CP437;

             break;
             break;

-#endif

 
 

-        case OEM_CHARSET:
-            fontEncoding = wxFONTENCODING_CP437;
+        case 437:
+            vFontEncoding = wxFONTENCODING_CP437;

             break;
     }
 
             break;
     }
 

-    return wxFont(fontPoints, fontFamily, fontStyle,
-                  fontWeight, fontUnderline, fontFace,
-                  fontEncoding);
+    return wxFont( nFontPoints
+                  ,nFontFamily
+                  ,nFontStyle
+                  ,nFontWeight
+                  ,bFontUnderline
+                  ,sFontFace
+                  ,vFontEncoding
+                 );
+} // end of wxCreateFontFromLogFont
+
+int wxGpiStrcmp(
+  char*                             s0
+, char*                             s1
+)
+{   int                             l0;
+    int                             l1;
+    int                             l;
+    int                             d;
+    int                             d1;
+    int                             i;
+    int                             rc;
+
+    rc = 0;
+    if(s0 == NULL)
+    {
+        if(s1 == NULL)
+            return 0;
+        else
+            return 32;
+    }
+    else if(s1 == NULL)
+        return 32;
+
+    l0 = strlen(s0);
+    l1 = strlen(s1);
+    l  = l0;
+    if(l0 != l1)
+    {
+        rc++;
+        if(l1 < l0)
+            l = l1;
+    }
+    for(i=0;i<l;i++)
+    {
+        d = s0[i]-s1[i];
+        if(!d)
+            continue;
+        d1 = toupper(s0[i]) - toupper(s1[i]);
+        if(!d1)
+            continue;
+        rc += abs(d);
+    }
+    return rc;

 }
 }

-#endif // 0