[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/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

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*                          pLogFont // OS2 GPI FATTRS
, PFACENAMEDESC                     pFaceName
, const wxFont*                     pFont
)
{
    wxString                        sFace;
    USHORT                          uWeight;
    int                             nItalic;

    pLogFont->fsSelection = 0;
    pLogFont->fsSelection = FATTR_SEL_OUTLINE; // we will alway use only outlines
    pFaceName->usWeightClass = 0;
    pFaceName->flOptions = 0;
    switch (pFont->GetFamily())
    {
        case wxSCRIPT:
            sFace = _T("Script");
            break;

        case wxDECORATIVE:
        case wxROMAN:
            sFace = _T("Times New Roman");
            break;

        case wxTELETYPE:
        case wxMODERN:
            sFace = _T("Courier New");
            break;

        case wxSWISS:
            sFace = _T("WarpSans");
            break;

        case wxDEFAULT:
        default:
            sFace = _T("Helv");
    }

    switch (pFont->GetWeight())
    {
        default:
            wxFAIL_MSG(_T("unknown font weight"));
            uWeight = FWEIGHT_DONT_CARE;
            break;

        case wxNORMAL:
            uWeight = FWEIGHT_NORMAL;
            break;

        case wxLIGHT:
            uWeight = FWEIGHT_LIGHT;
            break;

        case wxBOLD:
            uWeight = FWEIGHT_BOLD;
            pLogFont->fsSelection |= FATTR_SEL_BOLD;
            break;

        case wxFONTWEIGHT_MAX:
            uWeight = FWEIGHT_ULTRA_BOLD;
            pLogFont->fsSelection |= FATTR_SEL_BOLD;
            break;
    }
    pFaceName->usWeightClass |= uWeight;

    switch (pFont->GetStyle())
    {
        case wxITALIC:
        case wxSLANT:
            nItalic = FTYPE_ITALIC;
            pLogFont->fsSelection |= FATTR_SEL_ITALIC;
            break;

        default:
            wxFAIL_MSG(wxT("unknown font slant"));
            // fall through

        case wxNORMAL:
            nItalic = 0;
            break;
    }
    pFaceName->flOptions |= nItalic;
    if(pFont->GetUnderlined())
        pLogFont->fsSelection |= FATTR_SEL_UNDERSCORE;

    //
    // In PM a font's height is expressed in points.  A point equals
    // approximately 1/72 of an inch.  We'll assume for now that,
    // like Windows, that fonts are 96 dpi.
    //
    DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
    HDC                             hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
    LONG                            lStart = CAPS_FAMILY;
    LONG                            lCount = CAPS_VERTICAL_RESOLUTION;
    LONG                            alArray[CAPS_VERTICAL_RESOLUTION];
    LONG                            lRes;
    int                             nPpInch;


    ::DevQueryCaps(hDC, lStart, lCount, alArray);
    lRes = alArray[CAPS_VERTICAL_RESOLUTION-1];
    if (lRes > 0)
        nPpInch = (int)(lRes/39.6); // lres is in pixels per meter
    else
        nPpInch = 96;

    int                             nHeight = (pFont->GetPointSize() * nPpInch/72);
    wxString                        sFacename = pFont->GetFaceName();

    if (!!sFacename)
    {
        sFace = sFacename;
    }
    //else: ff_face is a reasonable default facename for this font family

    //
    // Deal with encoding now
    //
    wxNativeEncodingInfo            vInfo;
    wxFontEncoding                  vEncoding = pFont->GetEncoding();

    if (!wxGetNativeFontEncoding( vEncoding
                                 ,&vInfo
                                ))
    {
        if ( !wxTheFontMapper->GetAltForEncoding( vEncoding
                                                 ,&vInfo
                                                ))
        {
            //
            // Unsupported encoding, replace with the default
            //
            vInfo.charset = 850;
        }
    }

    if (!vInfo.facename.IsEmpty() )
    {
        //
        // The facename determined by the encoding overrides everything else
        //
        sFace = vInfo.facename;
    }

    //
    // Transfer all the data to LOGFONT
    //
    pLogFont->usRecordLength = sizeof(FATTRS);
    wxStrcpy(pLogFont->szFacename, sFace.c_str());
    pLogFont->usCodePage = vInfo.charset;
    pLogFont->fsFontUse |= FATTR_FONTUSE_OUTLINE |
                           FATTR_FONTUSE_TRANSFORMABLE;
} // end of wxFillLogFont

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
	32	#include "wx/string.h"
	33	#include "wx/log.h"
	34	#include "wx/intl.h"
	35	#endif //WX_PRECOMP
	36
	37	#include "wx/os2/private.h"
	38
	39	#include "wx/fontutil.h"
	40	#include "wx/fontmap.h"
	41
	42	#include "wx/tokenzr.h"
	43
	44	// ============================================================================
	45	// implementation
	46	// ============================================================================
	47
	48	// ----------------------------------------------------------------------------
	49	// wxNativeEncodingInfo
	50	// ----------------------------------------------------------------------------
	51
	52	// convert to/from the string representation: format is
1e1d0be1	53	// encodingid;facename[;charset]
d8cde57b	54
e99762c0 DW	55	bool wxNativeEncodingInfo::FromString(
	56	const wxString& rsStr
	57	)
d8cde57b	58	{
e99762c0 DW	59	wxStringTokenizer vTokenizer(rsStr, _T(";"));
	60	wxString sEncid = vTokenizer.GetNextToken();
	61	long lEnc;
d8cde57b	62
e99762c0	63	if (!sEncid.ToLong(&lEnc))
1e1d0be1	64	return FALSE;
e99762c0 DW	65	encoding = (wxFontEncoding)lEnc;
	66	facename = vTokenizer.GetNextToken();
	67	if (!facename)
d8cde57b DW	68	return FALSE;
d8cde57b DW	69
e99762c0 DW	70	wxString sTmp = vTokenizer.GetNextToken();
	71
	72	if (!sTmp)
d8cde57b	73	{
e99762c0	74	charset = 850;
d8cde57b DW	75	}
	76	else
	77	{
e99762c0	78	if ( wxSscanf(sTmp, _T("%u"), &charset) != 1 )
d8cde57b DW	79	{
	80	// should be a number!
	81	return FALSE;
	82	}
	83	}
d8cde57b	84	return TRUE;
e99762c0	85	} // end of wxNativeEncodingInfo::FromString
d8cde57b DW	86
	87	wxString wxNativeEncodingInfo::ToString() const
	88	{
e99762c0	89	wxString sStr;
7e99520b	90
e99762c0	91	sStr << (long)encoding << _T(';') << facename;
1e1d0be1	92
e99762c0	93	if (charset != 850)
d8cde57b	94	{
e99762c0	95	sStr << _T(';') << charset;
d8cde57b	96	}
e99762c0 DW	97	return sStr;
e99762c0 DW	98	} // end of wxNativeEncodingInfo::ToString
d8cde57b DW	99
	100	// ----------------------------------------------------------------------------
	101	// helper functions
	102	// ----------------------------------------------------------------------------
	103
e99762c0 DW	104	bool wxGetNativeFontEncoding(
	105	wxFontEncoding vEncoding
	106	, wxNativeEncodingInfo* pInfo
	107	)
d8cde57b	108	{
e99762c0 DW	109	wxCHECK_MSG(pInfo, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
e99762c0 DW	110	if (vEncoding == wxFONTENCODING_DEFAULT)
d8cde57b	111	{
e99762c0	112	vEncoding = wxFont::GetDefaultEncoding();
d8cde57b	113	}
e99762c0	114	switch (vEncoding)
d8cde57b	115	{
d8cde57b DW	116	case wxFONTENCODING_ISO8859_1:
d8cde57b DW	117	case wxFONTENCODING_ISO8859_15:
e99762c0 DW	118	case wxFONTENCODING_CP1250:
e99762c0 DW	119	pInfo->charset = 1250;
d8cde57b DW	120	break;
d8cde57b DW	121
e99762c0 DW	122	case wxFONTENCODING_ISO8859_2:
	123	case wxFONTENCODING_CP1252:
	124	pInfo->charset = 1252;
d8cde57b DW	125	break;
d8cde57b DW	126
e99762c0 DW	127	case wxFONTENCODING_ISO8859_4:
	128	case wxFONTENCODING_ISO8859_10:
	129	pInfo->charset = 921; // what is baltic?
d8cde57b DW	130	break;
d8cde57b DW	131
e99762c0 DW	132	case wxFONTENCODING_ISO8859_5:
	133	case wxFONTENCODING_CP1251:
	134	pInfo->charset = 1251;
d8cde57b DW	135	break;
d8cde57b DW	136
e99762c0 DW	137	case wxFONTENCODING_ISO8859_6:
e99762c0 DW	138	pInfo->charset = 864;
d8cde57b DW	139	break;
d8cde57b DW	140
e99762c0 DW	141	case wxFONTENCODING_ISO8859_7:
e99762c0 DW	142	pInfo->charset = 869;
d8cde57b DW	143	break;
d8cde57b DW	144
e99762c0 DW	145	case wxFONTENCODING_ISO8859_8:
e99762c0 DW	146	pInfo->charset = 862;
d8cde57b DW	147	break;
d8cde57b DW	148
e99762c0 DW	149	case wxFONTENCODING_ISO8859_9:
e99762c0 DW	150	pInfo->charset = 857;
d8cde57b DW	151	break;
d8cde57b DW	152
e99762c0 DW	153	case wxFONTENCODING_ISO8859_11:
e99762c0 DW	154	pInfo->charset = 874; // what is thai
d8cde57b DW	155	break;
	156
	157	case wxFONTENCODING_CP437:
e99762c0	158	pInfo->charset = 437;
d8cde57b	159	break;
e99762c0	160
d8cde57b	161	default:
e99762c0 DW	162	wxFAIL_MSG(wxT("unsupported encoding"));
e99762c0 DW	163	// fall through
d8cde57b	164
e99762c0 DW	165	case wxFONTENCODING_SYSTEM:
	166	pInfo->charset = 850;
	167	break;
	168	}
d8cde57b	169	return TRUE;
e99762c0	170	} // end of wxGetNativeFontEncoding
d8cde57b	171
e99762c0 DW	172	bool wxTestFontEncoding(
	173	const wxNativeEncodingInfo& rInfo
	174	)
d8cde57b	175	{
e99762c0 DW	176	FATTRS vLogFont;
	177	HPS hPS;
	178
	179	hPS = ::WinGetPS(HWND_DESKTOP);
	180
	181	memset(&vLogFont, '\0', sizeof(FATTRS)); // all default values
	182	vLogFont.usRecordLength = sizeof(FATTRS);
	183	vLogFont.usCodePage = rInfo.charset;
	184	vLogFont.lMaxBaselineExt = 0L; // Outline fonts should use 0
	185	vLogFont.lAveCharWidth = 0L; // Outline fonts should use 0
	186	vLogFont.fsFontUse = FATTR_FONTUSE_OUTLINE \| // only outline fonts allowed
	187	FATTR_FONTUSE_TRANSFORMABLE; // may be transformed
	188
	189	strncpy(vLogFont.szFacename, rInfo.facename.c_str(), sizeof(vLogFont.szFacename));
	190
	191	if (!::GpiCreateLogFont( hPS
	192	,NULL
	193	,1L
	194	,&vLogFont
	195	))
d8cde57b	196	{
e99762c0	197	::WinReleasePS(hPS);
d8cde57b DW	198	return FALSE;
d8cde57b DW	199	}
e99762c0	200	::WinReleasePS(hPS);
d8cde57b	201	return TRUE;
e99762c0	202	} // end of wxTestFontEncoding
d8cde57b DW	203
	204	// ----------------------------------------------------------------------------
	205	// wxFont <-> LOGFONT conversion
	206	// ----------------------------------------------------------------------------
	207
e99762c0 DW	208	void wxFillLogFont(
	209	LOGFONT* pLogFont // OS2 GPI FATTRS
	210	, PFACENAMEDESC pFaceName
	211	, const wxFont* pFont
	212	)
d8cde57b	213	{
e99762c0 DW	214	wxString sFace;
	215	USHORT uWeight;
	216	int nItalic;
	217
	218	pLogFont->fsSelection = 0;
	219	pLogFont->fsSelection = FATTR_SEL_OUTLINE; // we will alway use only outlines
	220	pFaceName->usWeightClass = 0;
	221	pFaceName->flOptions = 0;
	222	switch (pFont->GetFamily())
d8cde57b DW	223	{
d8cde57b DW	224	case wxSCRIPT:
e99762c0	225	sFace = _T("Script");
d8cde57b DW	226	break;
	227
	228	case wxDECORATIVE:
d8cde57b	229	case wxROMAN:
e99762c0	230	sFace = _T("Times New Roman");
d8cde57b DW	231	break;
	232
	233	case wxTELETYPE:
	234	case wxMODERN:
e99762c0	235	sFace = _T("Courier New");
d8cde57b DW	236	break;
	237
	238	case wxSWISS:
e99762c0	239	sFace = _T("WarpSans");
d8cde57b DW	240	break;
	241
	242	case wxDEFAULT:
	243	default:
e99762c0	244	sFace = _T("Helv");
d8cde57b DW	245	}
d8cde57b DW	246
e99762c0	247	switch (pFont->GetWeight())
d8cde57b DW	248	{
	249	default:
	250	wxFAIL_MSG(_T("unknown font weight"));
e99762c0 DW	251	uWeight = FWEIGHT_DONT_CARE;
e99762c0 DW	252	break;
d8cde57b DW	253
d8cde57b DW	254	case wxNORMAL:
e99762c0	255	uWeight = FWEIGHT_NORMAL;
d8cde57b DW	256	break;
	257
	258	case wxLIGHT:
e99762c0	259	uWeight = FWEIGHT_LIGHT;
d8cde57b DW	260	break;
	261
	262	case wxBOLD:
e99762c0 DW	263	uWeight = FWEIGHT_BOLD;
	264	pLogFont->fsSelection \|= FATTR_SEL_BOLD;
	265	break;
	266
	267	case wxFONTWEIGHT_MAX:
	268	uWeight = FWEIGHT_ULTRA_BOLD;
	269	pLogFont->fsSelection \|= FATTR_SEL_BOLD;
d8cde57b DW	270	break;
d8cde57b DW	271	}
e99762c0	272	pFaceName->usWeightClass \|= uWeight;
d8cde57b	273
e99762c0 DW	274	switch (pFont->GetStyle())
	275	{
	276	case wxITALIC:
	277	case wxSLANT:
	278	nItalic = FTYPE_ITALIC;
	279	pLogFont->fsSelection \|= FATTR_SEL_ITALIC;
	280	break;
	281
	282	default:
	283	wxFAIL_MSG(wxT("unknown font slant"));
	284	// fall through
d8cde57b	285
e99762c0 DW	286	case wxNORMAL:
	287	nItalic = 0;
	288	break;
	289	}
	290	pFaceName->flOptions \|= nItalic;
	291	if(pFont->GetUnderlined())
	292	pLogFont->fsSelection \|= FATTR_SEL_UNDERSCORE;
	293
	294	//
	295	// In PM a font's height is expressed in points. A point equals
	296	// approximately 1/72 of an inch. We'll assume for now that,
	297	// like Windows, that fonts are 96 dpi.
	298	//
	299	DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
	300	HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
	301	LONG lStart = CAPS_FAMILY;
	302	LONG lCount = CAPS_VERTICAL_RESOLUTION;
	303	LONG alArray[CAPS_VERTICAL_RESOLUTION];
	304	LONG lRes;
	305	int nPpInch;
	306
	307
	308	::DevQueryCaps(hDC, lStart, lCount, alArray);
	309	lRes = alArray[CAPS_VERTICAL_RESOLUTION-1];
	310	if (lRes > 0)
	311	nPpInch = (int)(lRes/39.6); // lres is in pixels per meter
	312	else
	313	nPpInch = 96;
	314
	315	int nHeight = (pFont->GetPointSize() * nPpInch/72);
	316	wxString sFacename = pFont->GetFaceName();
	317
	318	if (!!sFacename)
d8cde57b	319	{
e99762c0	320	sFace = sFacename;
d8cde57b DW	321	}
	322	//else: ff_face is a reasonable default facename for this font family
	323
e99762c0 DW	324	//
	325	// Deal with encoding now
	326	//
	327	wxNativeEncodingInfo vInfo;
	328	wxFontEncoding vEncoding = pFont->GetEncoding();
	329
	330	if (!wxGetNativeFontEncoding( vEncoding
	331	,&vInfo
	332	))
d8cde57b	333	{
e99762c0 DW	334	if ( !wxTheFontMapper->GetAltForEncoding( vEncoding
	335	,&vInfo
	336	))
d8cde57b	337	{
e99762c0 DW	338	//
	339	// Unsupported encoding, replace with the default
	340	//
	341	vInfo.charset = 850;
d8cde57b DW	342	}
	343	}
	344
e99762c0	345	if (!vInfo.facename.IsEmpty() )
d8cde57b	346	{
e99762c0 DW	347	//
	348	// The facename determined by the encoding overrides everything else
	349	//
	350	sFace = vInfo.facename;
d8cde57b DW	351	}
d8cde57b DW	352
e99762c0 DW	353	//
	354	// Transfer all the data to LOGFONT
	355	//
	356	pLogFont->usRecordLength = sizeof(FATTRS);
	357	wxStrcpy(pLogFont->szFacename, sFace.c_str());
	358	pLogFont->usCodePage = vInfo.charset;
	359	pLogFont->fsFontUse \|= FATTR_FONTUSE_OUTLINE \|
	360	FATTR_FONTUSE_TRANSFORMABLE;
	361	} // end of wxFillLogFont
	362
	363	wxFont wxCreateFontFromLogFont(
	364	const LOGFONT* pLogFont
	365	, const PFONTMETRICS pFM
	366	, PFACENAMEDESC pFaceName
	367	)
d8cde57b	368	{
e99762c0 DW	369	//
	370	// Extract family from facename
	371	//
	372	int nFontFamily;
	373
	374	if (strcmp(pLogFont->szFacename, "Times New Roman") == 0)
	375	nFontFamily = wxROMAN;
	376	else if (strcmp(pLogFont->szFacename, "WarpSans") == 0)
	377	nFontFamily = wxSWISS;
	378	else if (strcmp(pLogFont->szFacename, "Script") == 0)
	379	nFontFamily = wxSCRIPT;
	380	else if (strcmp(pLogFont->szFacename, "Courier New") == 0)
	381	nFontFamily = wxMODERN;
	382	else
	383	nFontFamily = wxSWISS;
d8cde57b	384
e99762c0 DW	385	//
	386	// Weight and Style
	387	//
	388	int nFontWeight = wxNORMAL;
d8cde57b	389
e99762c0	390	switch (pFaceName->usWeightClass)
d8cde57b	391	{
e99762c0 DW	392	case FWEIGHT_LIGHT:
e99762c0 DW	393	nFontWeight = wxLIGHT;
d8cde57b DW	394	break;
	395
	396	default:
e99762c0 DW	397	case FWEIGHT_NORMAL:
e99762c0 DW	398	nFontWeight = wxNORMAL;
d8cde57b DW	399	break;
d8cde57b DW	400
e99762c0 DW	401	case FWEIGHT_BOLD:
e99762c0 DW	402	nFontWeight = wxBOLD;
d8cde57b DW	403	break;
	404	}
	405
e99762c0	406	int nFontStyle;
d8cde57b	407
e99762c0 DW	408	if(pLogFont->fsSelection & FATTR_SEL_ITALIC)
	409	nFontStyle = wxITALIC;
	410	else
	411	nFontStyle = wxNORMAL;
d8cde57b	412
e99762c0 DW	413	bool bFontUnderline = (pLogFont->fsSelection & FATTR_SEL_UNDERSCORE);
	414	wxString sFontFace = pLogFont->szFacename;
	415	int nFontPoints = pFM->lEmHeight;
	416	wxFontEncoding vFontEncoding;
d8cde57b	417
e99762c0	418	switch (pLogFont->usCodePage)
d8cde57b DW	419	{
	420	default:
	421	wxFAIL_MSG(wxT("unsupported charset"));
	422	// fall through
	423
e99762c0 DW	424	case 850:
e99762c0 DW	425	vFontEncoding = wxFONTENCODING_CP1252;
d8cde57b DW	426	break;
d8cde57b DW	427
e99762c0 DW	428	case 1250:
e99762c0 DW	429	vFontEncoding = wxFONTENCODING_CP1250;
d8cde57b DW	430	break;
d8cde57b DW	431
e99762c0 DW	432	case 921:
e99762c0 DW	433	vFontEncoding = wxFONTENCODING_CP1257;
d8cde57b DW	434	break;
d8cde57b DW	435
e99762c0 DW	436	case 866:
e99762c0 DW	437	vFontEncoding = wxFONTENCODING_CP1251;
d8cde57b DW	438	break;
d8cde57b DW	439
e99762c0 DW	440	case 864:
e99762c0 DW	441	vFontEncoding = wxFONTENCODING_CP1256;
d8cde57b DW	442	break;
d8cde57b DW	443
e99762c0 DW	444	case 869:
e99762c0 DW	445	vFontEncoding = wxFONTENCODING_CP1253;
d8cde57b DW	446	break;
d8cde57b DW	447
e99762c0 DW	448	case 862:
e99762c0 DW	449	vFontEncoding = wxFONTENCODING_CP1255;
d8cde57b DW	450	break;
d8cde57b DW	451
e99762c0 DW	452	case 857:
e99762c0 DW	453	vFontEncoding = wxFONTENCODING_CP1254;
d8cde57b DW	454	break;
d8cde57b DW	455
e99762c0 DW	456	case 874:
e99762c0 DW	457	vFontEncoding = wxFONTENCODING_CP437;
d8cde57b	458	break;
d8cde57b	459
e99762c0 DW	460	case 437:
e99762c0 DW	461	vFontEncoding = wxFONTENCODING_CP437;
d8cde57b DW	462	break;
	463	}
	464
e99762c0 DW	465	return wxFont( nFontPoints
	466	,nFontFamily
	467	,nFontStyle
	468	,nFontWeight
	469	,bFontUnderline
	470	,sFontFace
	471	,vFontEncoding
	472	);
	473	} // end of wxCreateFontFromLogFont
	474
	475	int wxGpiStrcmp(
	476	char* s0
	477	, char* s1
	478	)
	479	{ int l0;
	480	int l1;
	481	int l;
	482	int d;
	483	int d1;
	484	int i;
	485	int rc;
	486
	487	rc = 0;
	488	if(s0 == NULL)
	489	{
	490	if(s1 == NULL)
	491	return 0;
	492	else
	493	return 32;
	494	}
	495	else if(s1 == NULL)
	496	return 32;
	497
	498	l0 = strlen(s0);
	499	l1 = strlen(s1);
	500	l = l0;
	501	if(l0 != l1)
	502	{
	503	rc++;
	504	if(l1 < l0)
	505	l = l1;
	506	}
	507	for(i=0;i<l;i++)
	508	{
	509	d = s0[i]-s1[i];
	510	if(!d)
	511	continue;
	512	d1 = toupper(s0[i]) - toupper(s1[i]);
	513	if(!d1)
	514	continue;
	515	rc += abs(d);
	516	}
	517	return rc;
d8cde57b	518	}
d8cde57b	519