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

///////////////////////////////////////////////////////////////////////////////
// Name:        msw/fontutil.cpp
// Purpose:     font-related helper functions for wxMSW
// Author:      Modified by David Webster for OS/2
// Modified by:
// Created:     01.03.00
// RCS-ID:      $Id$
// Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows license
///////////////////////////////////////////////////////////////////////////////
#define DEBUG_PRINTF(NAME)   { static int raz=0; \
  printf( #NAME " %i\n",raz); fflush(stdout);       \
   raz++;                                        \
 }

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

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#ifdef __GNUG__
    #pragma implementation "fontutil.h"
#endif

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

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/string.h"
    #include "wx/log.h"
    #include "wx/intl.h"
#endif //WX_PRECOMP

#include "wx/os2/private.h"

#include "wx/fontutil.h"
#include "wx/fontmap.h"

#include "wx/tokenzr.h"

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

// ----------------------------------------------------------------------------
// wxNativeEncodingInfo
// ----------------------------------------------------------------------------

// convert to/from the string representation: format is
//      encodingid;facename[;charset]

bool wxNativeEncodingInfo::FromString(
  const wxString&                   rsStr
)
{
    wxStringTokenizer               vTokenizer(rsStr, _T(";"));
    wxString                        sEncid = vTokenizer.GetNextToken();
    long                            lEnc;

    if (!sEncid.ToLong(&lEnc))
        return FALSE;
    encoding = (wxFontEncoding)lEnc;
    facename = vTokenizer.GetNextToken();
    if (!facename)
        return FALSE;

    wxString                        sTmp = vTokenizer.GetNextToken();

    if (!sTmp)
    {
        charset = 850;
    }
    else
    {
        if ( wxSscanf(sTmp, _T("%u"), &charset) != 1 )
        {
            // should be a number!
            return FALSE;
        }
    }
    return TRUE;
} // end of wxNativeEncodingInfo::FromString

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

    sStr << (long)encoding << _T(';') << facename;

    if (charset != 850)
    {
        sStr << _T(';') << charset;
    }
    return sStr;
} // end of wxNativeEncodingInfo::ToString

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

bool wxGetNativeFontEncoding(
  wxFontEncoding                    vEncoding
, wxNativeEncodingInfo*             pInfo
)
{
    wxCHECK_MSG(pInfo, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
    if (vEncoding == wxFONTENCODING_DEFAULT)
    {
        vEncoding = wxFont::GetDefaultEncoding();
    }
    switch (vEncoding)
    {
        case wxFONTENCODING_ISO8859_1:
        case wxFONTENCODING_ISO8859_15:
        case wxFONTENCODING_CP1250:
            pInfo->charset = 1250;
            break;

        case wxFONTENCODING_ISO8859_2:
        case wxFONTENCODING_CP1252:
            pInfo->charset = 1252;
            break;

        case wxFONTENCODING_ISO8859_4:
        case wxFONTENCODING_ISO8859_10:
            pInfo->charset = 921; // what is baltic?
            break;

        case wxFONTENCODING_ISO8859_5:
        case wxFONTENCODING_CP1251:
            pInfo->charset = 1251;
            break;

        case wxFONTENCODING_ISO8859_6:
            pInfo->charset = 864;
            break;

        case wxFONTENCODING_ISO8859_7:
            pInfo->charset = 869;
            break;

        case wxFONTENCODING_ISO8859_8:
            pInfo->charset = 862;
            break;

        case wxFONTENCODING_ISO8859_9:
            pInfo->charset = 857;
            break;

        case wxFONTENCODING_ISO8859_11:
            pInfo->charset = 874; // what is thai
            break;

        case wxFONTENCODING_CP437:
            pInfo->charset = 437;
            break;

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

        case wxFONTENCODING_SYSTEM:
            pInfo->charset = 850;
            break;
    }
    return TRUE;
} // end of wxGetNativeFontEncoding

wxFontEncoding wxGetFontEncFromCharSet(
  int                               nCharSet
)
{
    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;

        case 869:
            eFontEncoding = wxFONTENCODING_ISO8859_7;
            break;

        case 862:
            eFontEncoding = wxFONTENCODING_ISO8859_8;
            break;

        case 857:
            eFontEncoding = wxFONTENCODING_ISO8859_9;
            break;

        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
                           ))
    {
        ::WinReleasePS(hPS);
        return FALSE;
    }
    ::WinReleasePS(hPS);
    return TRUE;
} // end of wxTestFontEncoding

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

void wxFillLogFont(
  LOGFONT*                          pFattrs  // OS2 GPI FATTRS
, PFACENAMEDESC                     pFaceName
, HPS*                              phPS
, bool*                             pbInternalPS
, long*                             pflId
, wxString&                         sFaceName
, wxFont*                           pFont
)
{
    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;

        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:
            sFaceName = wxT("Script");
            break;

        case wxDECORATIVE:
        case wxROMAN:
            sFaceName = wxT("Tms Rmn");
            break;

        case wxTELETYPE:
            sFaceName = wxT("Courier") ;
            break;

        case wxMODERN:
            sFaceName = wxT("System VIO") ;
            break;

        case wxSWISS:
            sFaceName = wxT("Helv") ;
            break;

        case wxDEFAULT:
        default:
            sFaceName = wxT("System VIO") ;
    }

    switch (pFont->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;
    }
    pFaceName->usWeightClass = usWeightClass;

    switch (pFont->GetStyle())
    {
        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;
    }

    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++)
    {
        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)
        {
            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;
            }
        }
    }

    //
    // 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
)
{
    //
    // 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;

    //
    // Weight and Style
    //
    int                             nFontWeight = wxNORMAL;

    switch (pFaceName->usWeightClass)
    {
        case FWEIGHT_LIGHT:
            nFontWeight = wxLIGHT;
            break;

        default:
        case FWEIGHT_NORMAL:
            nFontWeight = wxNORMAL;
            break;

        case FWEIGHT_BOLD:
            nFontWeight = wxBOLD;
            break;
    }

    int                             nFontStyle;

    if(pLogFont->fsSelection & FATTR_SEL_ITALIC)
        nFontStyle = wxITALIC;
    else
        nFontStyle = wxNORMAL;

    bool                            bFontUnderline = (pLogFont->fsSelection & FATTR_SEL_UNDERSCORE);
    wxString                        sFontFace = pLogFont->szFacename;
    int                             nFontPoints = pFM->lEmHeight;
    wxFontEncoding                  vFontEncoding;

    switch (pLogFont->usCodePage)
    {
        default:
            wxFAIL_MSG(wxT("unsupported charset"));
            // fall through

        case 850:
            vFontEncoding = wxFONTENCODING_CP1252;
            break;

        case 1250:
            vFontEncoding = wxFONTENCODING_CP1250;
            break;

        case 921:
            vFontEncoding = wxFONTENCODING_CP1257;
            break;

        case 866:
            vFontEncoding = wxFONTENCODING_CP1251;
            break;

        case 864:
            vFontEncoding = wxFONTENCODING_CP1256;
            break;

        case 869:
            vFontEncoding = wxFONTENCODING_CP1253;
            break;

        case 862:
            vFontEncoding = wxFONTENCODING_CP1255;
            break;

        case 857:
            vFontEncoding = wxFONTENCODING_CP1254;
            break;

        case 874:
            vFontEncoding = wxFONTENCODING_CP437;
            break;

        case 437:
            vFontEncoding = wxFONTENCODING_CP437;
            break;
    }

    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;
}
Commit	Line	Data
d8cde57b DW	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: msw/fontutil.cpp
	3	// Purpose: font-related helper functions for wxMSW
	4	// Author: Modified by David Webster for OS/2
	5	// Modified by:
	6	// Created: 01.03.00
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// Licence: wxWindows license
	10	///////////////////////////////////////////////////////////////////////////////
7e99520b DW	11	#define DEBUG_PRINTF(NAME) { static int raz=0; \
	12	printf( #NAME " %i\n",raz); fflush(stdout); \
	13	raz++; \
	14	}
d8cde57b DW	15
	16	// ============================================================================
	17	// declarations
	18	// ============================================================================
	19
	20	// ----------------------------------------------------------------------------
	21	// headers
	22	// ----------------------------------------------------------------------------
	23
a4372af6 SN	24	#ifdef __GNUG__
	25	#pragma implementation "fontutil.h"
	26	#endif
	27
d8cde57b DW	28	// For compilers that support precompilation, includes "wx.h".
	29	#include "wx/wxprec.h"
	30
	31	#ifndef WX_PRECOMP
3417f661	32	#include "wx/app.h"
d8cde57b DW	33	#include "wx/string.h"
	34	#include "wx/log.h"
	35	#include "wx/intl.h"
	36	#endif //WX_PRECOMP
	37
	38	#include "wx/os2/private.h"
	39
	40	#include "wx/fontutil.h"
	41	#include "wx/fontmap.h"
	42
	43	#include "wx/tokenzr.h"
	44
	45	// ============================================================================
	46	// implementation
	47	// ============================================================================
	48
	49	// ----------------------------------------------------------------------------
	50	// wxNativeEncodingInfo
	51	// ----------------------------------------------------------------------------
	52
	53	// convert to/from the string representation: format is
1e1d0be1	54	// encodingid;facename[;charset]
d8cde57b	55
e99762c0 DW	56	bool wxNativeEncodingInfo::FromString(
	57	const wxString& rsStr
	58	)
d8cde57b	59	{
e99762c0 DW	60	wxStringTokenizer vTokenizer(rsStr, _T(";"));
	61	wxString sEncid = vTokenizer.GetNextToken();
	62	long lEnc;
d8cde57b	63
e99762c0	64	if (!sEncid.ToLong(&lEnc))
1e1d0be1	65	return FALSE;
e99762c0 DW	66	encoding = (wxFontEncoding)lEnc;
	67	facename = vTokenizer.GetNextToken();
	68	if (!facename)
d8cde57b DW	69	return FALSE;
d8cde57b DW	70
e99762c0 DW	71	wxString sTmp = vTokenizer.GetNextToken();
	72
	73	if (!sTmp)
d8cde57b	74	{
e99762c0	75	charset = 850;
d8cde57b DW	76	}
	77	else
	78	{
e99762c0	79	if ( wxSscanf(sTmp, _T("%u"), &charset) != 1 )
d8cde57b DW	80	{
	81	// should be a number!
	82	return FALSE;
	83	}
	84	}
d8cde57b	85	return TRUE;
e99762c0	86	} // end of wxNativeEncodingInfo::FromString
d8cde57b DW	87
	88	wxString wxNativeEncodingInfo::ToString() const
	89	{
e99762c0	90	wxString sStr;
7e99520b	91
e99762c0	92	sStr << (long)encoding << _T(';') << facename;
1e1d0be1	93
e99762c0	94	if (charset != 850)
d8cde57b	95	{
e99762c0	96	sStr << _T(';') << charset;
d8cde57b	97	}
e99762c0 DW	98	return sStr;
e99762c0 DW	99	} // end of wxNativeEncodingInfo::ToString
d8cde57b DW	100
	101	// ----------------------------------------------------------------------------
	102	// helper functions
	103	// ----------------------------------------------------------------------------
	104
e99762c0 DW	105	bool wxGetNativeFontEncoding(
	106	wxFontEncoding vEncoding
	107	, wxNativeEncodingInfo* pInfo
	108	)
d8cde57b	109	{
e99762c0 DW	110	wxCHECK_MSG(pInfo, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
e99762c0 DW	111	if (vEncoding == wxFONTENCODING_DEFAULT)
d8cde57b	112	{
e99762c0	113	vEncoding = wxFont::GetDefaultEncoding();
d8cde57b	114	}
e99762c0	115	switch (vEncoding)
d8cde57b	116	{
d8cde57b DW	117	case wxFONTENCODING_ISO8859_1:
d8cde57b DW	118	case wxFONTENCODING_ISO8859_15:
e99762c0 DW	119	case wxFONTENCODING_CP1250:
e99762c0 DW	120	pInfo->charset = 1250;
d8cde57b DW	121	break;
d8cde57b DW	122
e99762c0 DW	123	case wxFONTENCODING_ISO8859_2:
	124	case wxFONTENCODING_CP1252:
	125	pInfo->charset = 1252;
d8cde57b DW	126	break;
d8cde57b DW	127
e99762c0 DW	128	case wxFONTENCODING_ISO8859_4:
	129	case wxFONTENCODING_ISO8859_10:
	130	pInfo->charset = 921; // what is baltic?
d8cde57b DW	131	break;
d8cde57b DW	132
e99762c0 DW	133	case wxFONTENCODING_ISO8859_5:
	134	case wxFONTENCODING_CP1251:
	135	pInfo->charset = 1251;
d8cde57b DW	136	break;
d8cde57b DW	137
e99762c0 DW	138	case wxFONTENCODING_ISO8859_6:
e99762c0 DW	139	pInfo->charset = 864;
d8cde57b DW	140	break;
d8cde57b DW	141
e99762c0 DW	142	case wxFONTENCODING_ISO8859_7:
e99762c0 DW	143	pInfo->charset = 869;
d8cde57b DW	144	break;
d8cde57b DW	145
e99762c0 DW	146	case wxFONTENCODING_ISO8859_8:
e99762c0 DW	147	pInfo->charset = 862;
d8cde57b DW	148	break;
d8cde57b DW	149
e99762c0 DW	150	case wxFONTENCODING_ISO8859_9:
e99762c0 DW	151	pInfo->charset = 857;
d8cde57b DW	152	break;
d8cde57b DW	153
e99762c0 DW	154	case wxFONTENCODING_ISO8859_11:
e99762c0 DW	155	pInfo->charset = 874; // what is thai
d8cde57b DW	156	break;
	157
	158	case wxFONTENCODING_CP437:
e99762c0	159	pInfo->charset = 437;
d8cde57b	160	break;
e99762c0	161
d8cde57b	162	default:
e99762c0 DW	163	wxFAIL_MSG(wxT("unsupported encoding"));
e99762c0 DW	164	// fall through
d8cde57b	165
e99762c0 DW	166	case wxFONTENCODING_SYSTEM:
	167	pInfo->charset = 850;
	168	break;
	169	}
d8cde57b	170	return TRUE;
e99762c0	171	} // end of wxGetNativeFontEncoding
d8cde57b	172
cc95f4f9 DW	173	wxFontEncoding wxGetFontEncFromCharSet(
	174	int nCharSet
	175	)
	176	{
	177	wxFontEncoding eFontEncoding;
	178
	179	switch (nCharSet)
	180	{
	181	default:
	182	case 1250:
	183	eFontEncoding = wxFONTENCODING_CP1250;
	184	break;
	185
	186	case 1252:
	187	eFontEncoding = wxFONTENCODING_CP1252;
	188	break;
	189
	190	case 921:
	191	eFontEncoding = wxFONTENCODING_ISO8859_4;
	192	break;
	193
	194	case 1251:
	195	eFontEncoding = wxFONTENCODING_CP1251;
	196	break;
	197
	198	case 864:
	199	eFontEncoding = wxFONTENCODING_ISO8859_6;
	200	break;
	201
	202	case 869:
	203	eFontEncoding = wxFONTENCODING_ISO8859_7;
	204	break;
	205
	206	case 862:
	207	eFontEncoding = wxFONTENCODING_ISO8859_8;
	208	break;
	209
	210	case 857:
	211	eFontEncoding = wxFONTENCODING_ISO8859_9;
	212	break;
	213
	214	case 874:
	215	eFontEncoding = wxFONTENCODING_ISO8859_11;
	216	break;
	217
	218	case 437:
	219	eFontEncoding = wxFONTENCODING_CP437;
	220	break;
	221	}
	222	return eFontEncoding;
	223	} // end of wxGetNativeFontEncoding
	224
e99762c0 DW	225	bool wxTestFontEncoding(
	226	const wxNativeEncodingInfo& rInfo
	227	)
d8cde57b	228	{
e99762c0 DW	229	FATTRS vLogFont;
	230	HPS hPS;
	231
	232	hPS = ::WinGetPS(HWND_DESKTOP);
	233
	234	memset(&vLogFont, '\0', sizeof(FATTRS)); // all default values
	235	vLogFont.usRecordLength = sizeof(FATTRS);
	236	vLogFont.usCodePage = rInfo.charset;
	237	vLogFont.lMaxBaselineExt = 0L; // Outline fonts should use 0
	238	vLogFont.lAveCharWidth = 0L; // Outline fonts should use 0
	239	vLogFont.fsFontUse = FATTR_FONTUSE_OUTLINE \| // only outline fonts allowed
	240	FATTR_FONTUSE_TRANSFORMABLE; // may be transformed
	241
	242	strncpy(vLogFont.szFacename, rInfo.facename.c_str(), sizeof(vLogFont.szFacename));
	243
	244	if (!::GpiCreateLogFont( hPS
	245	,NULL
	246	,1L
	247	,&vLogFont
	248	))
d8cde57b	249	{
e99762c0	250	::WinReleasePS(hPS);
d8cde57b DW	251	return FALSE;
d8cde57b DW	252	}
e99762c0	253	::WinReleasePS(hPS);
d8cde57b	254	return TRUE;
e99762c0	255	} // end of wxTestFontEncoding
d8cde57b DW	256
	257	// ----------------------------------------------------------------------------
	258	// wxFont <-> LOGFONT conversion
	259	// ----------------------------------------------------------------------------
	260
e99762c0	261	void wxFillLogFont(
cc95f4f9	262	LOGFONT* pFattrs // OS2 GPI FATTRS
e99762c0	263	, PFACENAMEDESC pFaceName
54ffa107	264	, HPS* phPS
828621c2	265	, bool* pbInternalPS
cc95f4f9 DW	266	, long* pflId
	267	, wxString& sFaceName
	268	, wxFont* pFont
e99762c0	269	)
d8cde57b	270	{
cc95f4f9 DW	271	LONG lNumFonts = 0L; // For system font count
cc95f4f9 DW	272	ERRORID vError; // For logging API errors
54ffa107	273	LONG lTemp = 0L;
cc95f4f9 DW	274	bool bInternalPS = FALSE; // if we have to create one
	275	PFONTMETRICS pFM = NULL;
	276
	277	//
	278	// Initial house cleaning to free data buffers and ensure we have a
	279	// functional PS to work with
	280	//
54ffa107	281	if (!*phPS)
cc95f4f9	282	{
54ffa107	283	*phPS = ::WinGetPS(HWND_DESKTOP);
cc95f4f9 DW	284	bInternalPS = TRUE;
	285	}
	286
	287	//
	288	// Determine the number of fonts.
	289	//
54ffa107 DW	290	if((lNumFonts = ::GpiQueryFonts( *phPS
	291	,QF_PUBLIC
	292	,NULL
	293	,&lTemp
	294	,(LONG) sizeof(FONTMETRICS)
	295	,NULL
	296	)) < 0L)
	297	{
	298	ERRORID vError;
	299	wxString sError;
	300
	301	vError = ::WinGetLastError(wxGetInstance());
	302	sError = wxPMErrorToStr(vError);
	303	return;
	304	}
cc95f4f9 DW	305
	306	//
	307	// Allocate space for the font metrics.
	308	//
	309	pFM = new FONTMETRICS[lNumFonts + 1];
e99762c0	310
cc95f4f9 DW	311	//
	312	// Retrieve the font metrics.
	313	//
	314	lTemp = lNumFonts;
54ffa107	315	lTemp = ::GpiQueryFonts( *phPS
cc95f4f9 DW	316	,QF_PUBLIC
	317	,NULL
	318	,&lTemp
	319	,(LONG) sizeof(FONTMETRICS)
	320	,pFM
	321	);
	322	pFont->SetFM( pFM
	323	,(int)lNumFonts
	324	);
	325
	326	wxString sVals;
	327
e1146627 DW	328	//
	329	// For debugging, delete later
	330	//
cc95f4f9 DW	331	for (int i = 0; i < lNumFonts; i++)
	332	{
	333	sVals << "Face: " << pFM[i].szFacename
	334	<< "Family: " << pFM[i].szFamilyname
	335	<< " PointSize: " << pFM[i].lEmHeight
	336	<< " Height: " << pFM[i].lXHeight
	337	;
	338	sVals = "";
	339	}
	340
	341	//
	342	// Initialize FATTR and FACENAMEDESC
	343	//
	344	pFattrs->usRecordLength = sizeof(FATTRS);
	345	pFattrs->fsFontUse = FATTR_FONTUSE_OUTLINE \| // only outline fonts allowed
	346	FATTR_FONTUSE_TRANSFORMABLE; // may be transformed
	347	pFattrs->fsType = 0;
	348	pFattrs->lMaxBaselineExt = pFattrs->lAveCharWidth = 0;
	349	pFattrs->idRegistry = 0;
	350	pFattrs->lMatch = 0;
	351
	352	pFaceName->usSize = sizeof(FACENAMEDESC);
	353	pFaceName->usWidthClass = FWIDTH_NORMAL;
	354	pFaceName->usReserved = 0;
e99762c0	355	pFaceName->flOptions = 0;
cc95f4f9 DW	356
	357	//
	358	// This does the actual selection of fonts
	359	//
	360	wxOS2SelectMatchingFontByName( pFattrs
	361	,pFaceName
	362	,pFM
	363	,(int)lNumFonts
	364	,pFont
	365	);
	366	//
	367	// We should now have the correct FATTRS set with the selected
	368	// font, so now we need to generate an ID
	369	//
54ffa107	370	long lNumLids = ::GpiQueryNumberSetIds(*phPS);
cc95f4f9 DW	371	long lGpiError;
	372
	373	if(lNumLids )
	374	{
	375	long alTypes[255];
	376	STR8 azNames[255];
	377	long alIds[255];
	378
54ffa107	379	if(!::GpiQuerySetIds( *phPS
cc95f4f9 DW	380	,lNumLids
	381	,alTypes
	382	,azNames
	383	,alIds
	384	))
	385	{
	386	if (bInternalPS)
54ffa107	387	::WinReleasePS(*phPS);
cc95f4f9 DW	388	return;
	389	}
	390
	391	for(unsigned long LCNum = 0; LCNum < lNumLids; LCNum++)
	392	if(alIds[LCNum] == *pflId)
	393	++*pflId;
	394	if(*pflId > 254) // wow, no id available!
	395	{
	396	if (bInternalPS)
54ffa107	397	::WinReleasePS(*phPS);
cc95f4f9 DW	398	return;
	399	}
	400	}
54ffa107 DW	401	else
54ffa107 DW	402	*pflId = 1L;
cc95f4f9 DW	403	//
	404	// Release and delete the current font
	405	//
54ffa107 DW	406	::GpiSetCharSet(phPS, LCID_DEFAULT);/ release the font before deleting */
54ffa107 DW	407	::GpiDeleteSetId(phPS, 1L); / delete the logical font */
cc95f4f9 DW	408
	409	//
	410	// Now build a facestring
	411	//
	412	char zFacename[128];
	413
	414	strcpy(zFacename, pFattrs->szFacename);
	415
54ffa107	416	if(::GpiQueryFaceString( *phPS
cc95f4f9 DW	417	,zFacename
	418	,pFaceName
	419	,FACESIZE
	420	,pFattrs->szFacename
	421	) == GPI_ERROR)
	422	{
	423	vError = ::WinGetLastError(vHabmain);
	424	}
	425	sFaceName = zFacename;
828621c2	426	*pbInternalPS = bInternalPS;
cc95f4f9 DW	427
	428	//
	429	// That's it, we now have everything we need to actually create the font
	430	//
	431	} // end of wxFillLogFont
	432
	433	void wxOS2SelectMatchingFontByName(
	434	PFATTRS pFattrs
	435	, PFACENAMEDESC pFaceName
	436	, PFONTMETRICS pFM
	437	, int nNumFonts
	438	, const wxFont* pFont
	439	)
	440	{
	441	int i;
	442	int nDiff0;
	443	int nPointSize;
	444	int nDiff;
	445	int nIs;
cc95f4f9 DW	446	int nMinDiff;
	447	int nMinDiff0;
	448	int nApirc;
	449	int anDiff[16];
	450	int anMinDiff[16];
e1146627	451	int nIndex = 0;
cc95f4f9 DW	452	STR8 zFn;
	453	char zFontFaceName[FACESIZE];
	454	wxString sFaceName;
	455	USHORT usWeightClass;
	456	int fsSelection = 0;
	457
	458	nMinDiff0 = 0xf000;
	459	for(i = 0;i < 16; i++)
	460	anMinDiff[i] = nMinDiff0;
	461
e99762c0	462	switch (pFont->GetFamily())
d8cde57b DW	463	{
d8cde57b DW	464	case wxSCRIPT:
cc95f4f9	465	sFaceName = wxT("Script");
d8cde57b DW	466	break;
	467
	468	case wxDECORATIVE:
d8cde57b	469	case wxROMAN:
e3bfcacf	470	sFaceName = wxT("Tms Rmn");
d8cde57b DW	471	break;
	472
	473	case wxTELETYPE:
cc95f4f9	474	sFaceName = wxT("Courier") ;
d8cde57b DW	475	break;
d8cde57b DW	476
e3bfcacf DW	477	case wxMODERN:
	478	sFaceName = wxT("System VIO") ;
	479	break;
	480
d8cde57b	481	case wxSWISS:
e3bfcacf	482	sFaceName = wxT("Helv") ;
d8cde57b DW	483	break;
	484
	485	case wxDEFAULT:
	486	default:
e3bfcacf	487	sFaceName = wxT("System VIO") ;
d8cde57b DW	488	}
d8cde57b DW	489
e99762c0	490	switch (pFont->GetWeight())
d8cde57b DW	491	{
	492	default:
	493	wxFAIL_MSG(_T("unknown font weight"));
cc95f4f9 DW	494	// fall through
cc95f4f9 DW	495	usWeightClass = FWEIGHT_DONT_CARE;
e99762c0	496	break;
d8cde57b DW	497
d8cde57b DW	498	case wxNORMAL:
cc95f4f9	499	usWeightClass = FWEIGHT_NORMAL;
d8cde57b DW	500	break;
	501
	502	case wxLIGHT:
cc95f4f9	503	usWeightClass = FWEIGHT_LIGHT;
d8cde57b DW	504	break;
	505
	506	case wxBOLD:
cc95f4f9	507	usWeightClass = FWEIGHT_BOLD;
e99762c0 DW	508	break;
e99762c0 DW	509
cc95f4f9 DW	510	case wxFONTWEIGHT_MAX:
cc95f4f9 DW	511	usWeightClass = FWEIGHT_ULTRA_BOLD;
d8cde57b DW	512	break;
d8cde57b DW	513	}
cc95f4f9	514	pFaceName->usWeightClass = usWeightClass;
d8cde57b	515
e99762c0 DW	516	switch (pFont->GetStyle())
	517	{
	518	case wxITALIC:
	519	case wxSLANT:
cc95f4f9 DW	520	fsSelection = FM_SEL_ITALIC;
cc95f4f9 DW	521	pFaceName->flOptions = FTYPE_ITALIC;
e99762c0 DW	522	break;
	523
	524	default:
	525	wxFAIL_MSG(wxT("unknown font slant"));
	526	// fall through
d8cde57b	527
e99762c0	528	case wxNORMAL:
cc95f4f9	529	fsSelection = 0;
e99762c0 DW	530	break;
e99762c0 DW	531	}
cc95f4f9 DW	532
	533	wxStrncpy(zFontFaceName, sFaceName.c_str(), WXSIZEOF(zFontFaceName));
	534	nPointSize = pFont->GetPointSize();
e99762c0 DW	535
e99762c0 DW	536	//
cc95f4f9	537	// Matching logic to find the right FM struct
e99762c0	538	//
cc95f4f9 DW	539	nIndex = 0;
cc95f4f9 DW	540	for(i = 0, nIs = 0; i < nNumFonts; i++)
d8cde57b	541	{
cc95f4f9 DW	542	int nEmHeight = 0;
	543	int nXHeight = 0;
	544
	545	anDiff[0] = wxGpiStrcmp(pFM[i].szFamilyname, zFontFaceName);
	546	anDiff[1] = abs(pFM[i].lEmHeight - nPointSize);
	547	anDiff[2] = abs(pFM[i].usWeightClass - usWeightClass);
	548	anDiff[3] = abs((pFM[i].fsSelection & 0x2f) - fsSelection);
	549	if(anDiff[0] == 0)
	550	{
	551	nEmHeight = (int)pFM[i].lEmHeight;
	552	nXHeight =(int)pFM[i].lXHeight;
	553	if( (nIs & 0x01) == 0)
	554	{
	555	nIs = 1;
	556	nIndex = i;
	557	anMinDiff[1] = anDiff[1];
	558	anMinDiff[2] = anDiff[2];
	559	anMinDiff[3] = anDiff[3];
	560	}
	561	else if(anDiff[3] < anMinDiff[3])
	562	{
	563	nIndex = i;
	564	anMinDiff[3] = anDiff[3];
	565	}
	566	else if(anDiff[2] < anMinDiff[2])
	567	{
	568	nIndex = i;
	569	anMinDiff[2] = anDiff[2];
	570	}
	571	else if(anDiff[1] < anMinDiff[1])
	572	{
	573	nIndex = i;
	574	anMinDiff[1] = anDiff[1];
	575	}
	576	anMinDiff[0] = 0;
	577	}
	578	else if(anDiff[0] < anMinDiff[0])
	579	{
	580	nIs = 2;
	581	nIndex = i;
	582	anMinDiff[3] = anDiff[3];
	583	anMinDiff[2] = anDiff[2];
	584	anMinDiff[1] = anDiff[1];
	585	anMinDiff[0] = anDiff[0];
	586	}
	587	else if(anDiff[0] == anMinDiff[0])
	588	{
	589	if(anDiff[3] < anMinDiff[3])
	590	{
	591	nIndex = i;
	592	anMinDiff[3] = anDiff[3];
	593	nIs = 2;
	594	}
	595	else if(anDiff[2] < anMinDiff[2])
	596	{
	597	nIndex = i;
	598	anMinDiff[2] = anDiff[2];
	599	nIs = 2;
	600	}
	601	else if(anDiff[1] < anMinDiff[1])
	602	{
	603	nIndex = i;
	604	anMinDiff[1] = anDiff[1];
	605	nIs = 2;
606	}
607	}
d8cde57b	608	}
d8cde57b	609
e99762c0	610	//
cc95f4f9	611	// Fill in the FATTRS with the best match from FONTMETRICS
e99762c0	612	//
cc95f4f9 DW	613	pFattrs->usRecordLength = sizeof(FATTRS); // sets size of structure
	614	pFattrs->fsSelection = pFM[nIndex].fsSelection; // uses default selection
	615	pFattrs->lMatch = pFM[nIndex].lMatch; // force match
	616	pFattrs->idRegistry = pFM[nIndex].idRegistry; // uses default registry
	617	pFattrs->usCodePage = pFM[nIndex].usCodePage; // code-page
e1146627 DW	618	pFattrs->lMaxBaselineExt = 0; // OUTLINE fonts need this set to 0 as they use other attributes to match
e1146627 DW	619	pFattrs->lAveCharWidth = 0; // OUTLINE fonts need this set to 0 as they use other attributes to match
cc95f4f9 DW	620	pFattrs->fsType = 0;// pfm->fsType; /* uses default type */
cc95f4f9 DW	621	pFattrs->fsFontUse = 0;
d8cde57b	622
cc95f4f9 DW	623	wxStrcpy(pFattrs->szFacename, pFM[nIndex].szFacename);
	624	// Debug
	625	strcpy(zFontFaceName, pFM[nIndex].szFacename);
	626	strcpy(zFontFaceName, pFattrs->szFacename);
	627
	628	if(usWeightClass >= FWEIGHT_BOLD)
	629	pFattrs->fsSelection \|= FATTR_SEL_BOLD;
	630	if(pFont->GetUnderlined())
	631	pFattrs->fsSelection \|= FATTR_SEL_UNDERSCORE;
	632	if(fsSelection & FM_SEL_ITALIC)
	633	pFattrs->fsSelection \|= FATTR_SEL_ITALIC;
	634	} // end of wxOS2SelectMatchingFontByName
e99762c0 DW	635
	636	wxFont wxCreateFontFromLogFont(
	637	const LOGFONT* pLogFont
	638	, const PFONTMETRICS pFM
	639	, PFACENAMEDESC pFaceName
	640	)
d8cde57b	641	{
e99762c0 DW	642	//
	643	// Extract family from facename
	644	//
	645	int nFontFamily;
	646
	647	if (strcmp(pLogFont->szFacename, "Times New Roman") == 0)
	648	nFontFamily = wxROMAN;
	649	else if (strcmp(pLogFont->szFacename, "WarpSans") == 0)
	650	nFontFamily = wxSWISS;
	651	else if (strcmp(pLogFont->szFacename, "Script") == 0)
	652	nFontFamily = wxSCRIPT;
	653	else if (strcmp(pLogFont->szFacename, "Courier New") == 0)
	654	nFontFamily = wxMODERN;
	655	else
	656	nFontFamily = wxSWISS;
d8cde57b	657
e99762c0 DW	658	//
	659	// Weight and Style
	660	//
	661	int nFontWeight = wxNORMAL;
d8cde57b	662
e99762c0	663	switch (pFaceName->usWeightClass)
d8cde57b	664	{
e99762c0 DW	665	case FWEIGHT_LIGHT:
e99762c0 DW	666	nFontWeight = wxLIGHT;
d8cde57b DW	667	break;
	668
	669	default:
e99762c0 DW	670	case FWEIGHT_NORMAL:
e99762c0 DW	671	nFontWeight = wxNORMAL;
d8cde57b DW	672	break;
d8cde57b DW	673
e99762c0 DW	674	case FWEIGHT_BOLD:
e99762c0 DW	675	nFontWeight = wxBOLD;
d8cde57b DW	676	break;
	677	}
	678
e99762c0	679	int nFontStyle;
d8cde57b	680
e99762c0 DW	681	if(pLogFont->fsSelection & FATTR_SEL_ITALIC)
	682	nFontStyle = wxITALIC;
	683	else
	684	nFontStyle = wxNORMAL;
d8cde57b	685
e99762c0 DW	686	bool bFontUnderline = (pLogFont->fsSelection & FATTR_SEL_UNDERSCORE);
	687	wxString sFontFace = pLogFont->szFacename;
	688	int nFontPoints = pFM->lEmHeight;
	689	wxFontEncoding vFontEncoding;
d8cde57b	690
e99762c0	691	switch (pLogFont->usCodePage)
d8cde57b DW	692	{
	693	default:
	694	wxFAIL_MSG(wxT("unsupported charset"));
	695	// fall through
	696
e99762c0 DW	697	case 850:
e99762c0 DW	698	vFontEncoding = wxFONTENCODING_CP1252;
d8cde57b DW	699	break;
d8cde57b DW	700
e99762c0 DW	701	case 1250:
e99762c0 DW	702	vFontEncoding = wxFONTENCODING_CP1250;
d8cde57b DW	703	break;
d8cde57b DW	704
e99762c0 DW	705	case 921:
e99762c0 DW	706	vFontEncoding = wxFONTENCODING_CP1257;
d8cde57b DW	707	break;
d8cde57b DW	708
e99762c0 DW	709	case 866:
e99762c0 DW	710	vFontEncoding = wxFONTENCODING_CP1251;
d8cde57b DW	711	break;
d8cde57b DW	712
e99762c0 DW	713	case 864:
e99762c0 DW	714	vFontEncoding = wxFONTENCODING_CP1256;
d8cde57b DW	715	break;
d8cde57b DW	716
e99762c0 DW	717	case 869:
e99762c0 DW	718	vFontEncoding = wxFONTENCODING_CP1253;
d8cde57b DW	719	break;
d8cde57b DW	720
e99762c0 DW	721	case 862:
e99762c0 DW	722	vFontEncoding = wxFONTENCODING_CP1255;
d8cde57b DW	723	break;
d8cde57b DW	724
e99762c0 DW	725	case 857:
e99762c0 DW	726	vFontEncoding = wxFONTENCODING_CP1254;
d8cde57b DW	727	break;
d8cde57b DW	728
e99762c0 DW	729	case 874:
e99762c0 DW	730	vFontEncoding = wxFONTENCODING_CP437;
d8cde57b	731	break;
d8cde57b	732
e99762c0 DW	733	case 437:
e99762c0 DW	734	vFontEncoding = wxFONTENCODING_CP437;
d8cde57b DW	735	break;
	736	}
	737
e99762c0 DW	738	return wxFont( nFontPoints
	739	,nFontFamily
	740	,nFontStyle
	741	,nFontWeight
	742	,bFontUnderline
	743	,sFontFace
	744	,vFontEncoding
	745	);
	746	} // end of wxCreateFontFromLogFont
	747
	748	int wxGpiStrcmp(
	749	char* s0
	750	, char* s1
	751	)
	752	{ int l0;
	753	int l1;
	754	int l;
	755	int d;
	756	int d1;
	757	int i;
	758	int rc;
	759
	760	rc = 0;
	761	if(s0 == NULL)
	762	{
	763	if(s1 == NULL)
	764	return 0;
	765	else
	766	return 32;
	767	}
	768	else if(s1 == NULL)
	769	return 32;
	770
	771	l0 = strlen(s0);
	772	l1 = strlen(s1);
	773	l = l0;
	774	if(l0 != l1)
	775	{
	776	rc++;
	777	if(l1 < l0)
	778	l = l1;
	779	}
	780	for(i=0;i<l;i++)
	781	{
	782	d = s0[i]-s1[i];
	783	if(!d)
	784	continue;
	785	d1 = toupper(s0[i]) - toupper(s1[i]);
	786	if(!d1)
	787	continue;
	788	rc += abs(d);
	789	}
	790	return rc;
d8cde57b	791	}
d8cde57b	792