New build slave for wxQt

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

diff --git a/src/os2/fontutil.cpp b/src/os2/fontutil.cpp
index 86f9063dfe0314e46837b54c893cd6fbe39a7b60..ad94caff32f80917789f33328b32c1264a3e2aa3 100644 (file)
--- a/src/os2/fontutil.cpp
+++ b/src/os2/fontutil.cpp
@@ -6,12 +6,8 @@
 // Created:     01.03.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     01.03.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-#define DEBUG_PRINTF(NAME)   { static int raz=0; \
-  printf( #NAME " %i\n",raz); fflush(stdout);       \
-   raz++;                                        \
- }

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


@@ -21,13 +17,16 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

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

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

+#define DEBUG_PRINTF(NAME)                            \
+    {                                                 \
+        static int raz=0;                             \
+        printf( #NAME " %i\n",raz); fflush(stdout);   \
+        raz++;                                        \
+    }
+

 #ifndef WX_PRECOMP
     #include "wx/app.h"
     #include "wx/string.h"
 #ifndef WX_PRECOMP
     #include "wx/app.h"
     #include "wx/string.h"


@@ -39,6 +38,7 @@
 
 #include "wx/fontutil.h"
 #include "wx/fontmap.h"
 
 #include "wx/fontutil.h"
 #include "wx/fontmap.h"

+#include "wx/encinfo.h"

 
 #include "wx/tokenzr.h"
 
 
 #include "wx/tokenzr.h"
 


@@ -53,11 +53,9 @@
 // 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&                   rsStr
-)
+bool wxNativeEncodingInfo::FromString( const wxString& rsStr )

 {
 {

-    wxStringTokenizer               vTokenizer(rsStr, _T(";"));
+    wxStringTokenizer               vTokenizer(rsStr, wxT(";"));

     wxString                        sEncid = vTokenizer.GetNextToken();
     long                            lEnc;
 
     wxString                        sEncid = vTokenizer.GetNextToken();
     long                            lEnc;
 


@@ -76,24 +74,24 @@ bool wxNativeEncodingInfo::FromString(
     }
     else
     {
     }
     else
     {

-        if ( wxSscanf(sTmp, _T("%u"), &charset) != 1 )
+        if ( wxSscanf(sTmp, wxT("%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                        sStr;
 
 } // end of wxNativeEncodingInfo::FromString
 
 wxString wxNativeEncodingInfo::ToString() const
 {
     wxString                        sStr;
 

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

 
     if (charset != 850)
     {
 
     if (charset != 850)
     {

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

     }
     return sStr;
 } // end of wxNativeEncodingInfo::ToString
     }
     return sStr;
 } // end of wxNativeEncodingInfo::ToString


@@ -102,12 +100,10 @@ wxString wxNativeEncodingInfo::ToString() const
 // helper functions
 // ----------------------------------------------------------------------------
 
 // helper functions
 // ----------------------------------------------------------------------------
 

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

 {
 {

-    wxCHECK_MSG(pInfo, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
+    wxCHECK_MSG(pInfo, FALSE, wxT("bad pointer in wxGetNativeFontEncoding") );

     if (vEncoding == wxFONTENCODING_DEFAULT)
     {
         vEncoding = wxFont::GetDefaultEncoding();
     if (vEncoding == wxFONTENCODING_DEFAULT)
     {
         vEncoding = wxFont::GetDefaultEncoding();


@@ -167,7 +163,7 @@ bool wxGetNativeFontEncoding(
             pInfo->charset = 850;
             break;
     }
             pInfo->charset = 850;
             break;
     }

-    return TRUE;
+    return true;

 } // end of wxGetNativeFontEncoding
 
 wxFontEncoding wxGetFontEncFromCharSet(
 } // end of wxGetNativeFontEncoding
 
 wxFontEncoding wxGetFontEncFromCharSet(


@@ -222,24 +218,22 @@ wxFontEncoding wxGetFontEncFromCharSet(
     return eFontEncoding;
 } // end of wxGetNativeFontEncoding
 
     return eFontEncoding;
 } // end of wxGetNativeFontEncoding
 

-bool wxTestFontEncoding(
-  const wxNativeEncodingInfo&       rInfo
-)
+bool wxTestFontEncoding( const wxNativeEncodingInfo& rInfo )

 {
 {

-    FATTRS                          vLogFont;
-    HPS                             hPS;
+    FATTRS vLogFont;
+    HPS    hPS;

 
     hPS = ::WinGetPS(HWND_DESKTOP);
 
     memset(&vLogFont, '\0', sizeof(FATTRS));           // all default values
     vLogFont.usRecordLength = sizeof(FATTRS);
 
     hPS = ::WinGetPS(HWND_DESKTOP);
 
     memset(&vLogFont, '\0', sizeof(FATTRS));           // all default values
     vLogFont.usRecordLength = sizeof(FATTRS);

-    vLogFont.usCodePage = rInfo.charset;
+    vLogFont.usCodePage = (USHORT)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
 
     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));
+    wxStrlcpy((wxChar*)vLogFont.szFacename, rInfo.facename.c_str(), WXSIZEOF(vLogFont.szFacename));

 
     if (!::GpiCreateLogFont( hPS
                             ,NULL
 
     if (!::GpiCreateLogFont( hPS
                             ,NULL


@@ -251,28 +245,69 @@ bool wxTestFontEncoding(
         return FALSE;
     }
     ::WinReleasePS(hPS);
         return FALSE;
     }
     ::WinReleasePS(hPS);

-    return TRUE;
+    return true;

 } // end of wxTestFontEncoding
 
 // ----------------------------------------------------------------------------
 // wxFont <-> LOGFONT conversion
 // ----------------------------------------------------------------------------
 
 } // 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
+void wxConvertVectorFontSize(
+  FIXED                             fxPointSize
+, PFATTRS                           pFattrs

 )
 {
 )
 {

-    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;
+    HPS                             hPS;
+    HDC                             hDC;
+    LONG                            lXFontResolution;
+    LONG                            lYFontResolution;
+    SIZEF                           vSizef;
+
+    hPS = WinGetScreenPS(HWND_DESKTOP); // Screen presentation space
+
+    //
+    //   Query device context for the screen and then query
+    //   the resolution of the device for the device context.
+    //
+
+    hDC = GpiQueryDevice(hPS);
+    DevQueryCaps( hDC, CAPS_HORIZONTAL_FONT_RES, (LONG)1, &lXFontResolution);
+    DevQueryCaps( hDC, CAPS_VERTICAL_FONT_RES, (LONG)1, &lYFontResolution);
+
+    //
+    //   Calculate the size of the character box, based on the
+    //   point size selected and the resolution of the device.
+    //   The size parameters are of type FIXED, NOT int.
+    //   NOTE: 1 point == 1/72 of an inch.
+    //
+
+    // multiply first to avoid getting vSizef.cx,cy = 0 since fxPointSize
+    // is normally < 72 and FontResolution is typically ca. 100
+    vSizef.cx = (FIXED)( (fxPointSize * lXFontResolution) / 72 );
+    vSizef.cy = (FIXED)( (fxPointSize * lYFontResolution) / 72 );
+
+    if (pFattrs)
+    {
+        pFattrs->lMaxBaselineExt = MAKELONG( HIUSHORT( vSizef.cy ), 0 );
+        pFattrs->lAveCharWidth   = MAKELONG( HIUSHORT( vSizef.cx ), 0 );
+    }
+    WinReleasePS(hPS);
+
+} // end of wxConvertVectorPointSize
+
+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
 
     //
     // Initial house cleaning to free data buffers and ensure we have a


@@ -281,14 +316,14 @@ void wxFillLogFont(
     if (!*phPS)
     {
         *phPS = ::WinGetPS(HWND_DESKTOP);
     if (!*phPS)
     {
         *phPS = ::WinGetPS(HWND_DESKTOP);

-        bInternalPS = TRUE;
+        bInternalPS = true;

     }
 
     //
     // Determine the number of fonts.
     //
     if((lNumFonts = ::GpiQueryFonts( *phPS
     }
 
     //
     // Determine the number of fonts.
     //
     if((lNumFonts = ::GpiQueryFonts( *phPS

-                                    ,QF_PUBLIC
+                                    ,QF_PUBLIC | QF_PRIVATE

                                     ,NULL
                                     ,&lTemp
                                     ,(LONG) sizeof(FONTMETRICS)
                                     ,NULL
                                     ,&lTemp
                                     ,(LONG) sizeof(FONTMETRICS)


@@ -327,15 +362,15 @@ void wxFillLogFont(
     // Initialize FATTR and FACENAMEDESC
     //
     pFattrs->usRecordLength = sizeof(FATTRS);
     // Initialize FATTR and FACENAMEDESC
     //
     pFattrs->usRecordLength = sizeof(FATTRS);

-    pFattrs->fsFontUse = FATTR_FONTUSE_OUTLINE |       // only outline fonts allowed
-                         FATTR_FONTUSE_TRANSFORMABLE;  // may be transformed
+    pFattrs->fsFontUse = FATTR_FONTUSE_OUTLINE;       // only outline fonts allowed

     pFattrs->fsType = 0;
     pFattrs->lMaxBaselineExt = pFattrs->lAveCharWidth = 0;
     pFattrs->idRegistry = 0;
     pFattrs->lMatch = 0;
 
     pFaceName->usSize = sizeof(FACENAMEDESC);
     pFattrs->fsType = 0;
     pFattrs->lMaxBaselineExt = pFattrs->lAveCharWidth = 0;
     pFattrs->idRegistry = 0;
     pFattrs->lMatch = 0;
 
     pFaceName->usSize = sizeof(FACENAMEDESC);

-    pFaceName->usWidthClass = FWIDTH_NORMAL;
+    pFaceName->usWeightClass = FWEIGHT_DONT_CARE;
+    pFaceName->usWidthClass = FWIDTH_DONT_CARE;

     pFaceName->usReserved = 0;
     pFaceName->flOptions = 0;
 
     pFaceName->usReserved = 0;
     pFaceName->flOptions = 0;
 


@@ -353,7 +388,6 @@ void wxFillLogFont(
     // font, so now we need to generate an ID
     //
     long                            lNumLids = ::GpiQueryNumberSetIds(*phPS);
     // font, so now we need to generate an ID
     //
     long                            lNumLids = ::GpiQueryNumberSetIds(*phPS);

-    long                            lGpiError;

 
     if(lNumLids )
     {
 
     if(lNumLids )
     {


@@ -375,7 +409,7 @@ void wxFillLogFont(
         }
         if (*pflId == 0L)
             *pflId = 1L;
         }
         if (*pflId == 0L)
             *pflId = 1L;

-        for(unsigned long LCNum = 0; LCNum < lNumLids; LCNum++)
+        for(unsigned long LCNum = 0; LCNum < (unsigned long)lNumLids; LCNum++)

             if(alIds[LCNum] == *pflId)
                ++*pflId;
         if(*pflId > 254)  // wow, no id available!
             if(alIds[LCNum] == *pflId)
                ++*pflId;
         if(*pflId > 254)  // wow, no id available!


@@ -409,7 +443,7 @@ void wxFillLogFont(
     {
         vError = ::WinGetLastError(vHabmain);
     }
     {
         vError = ::WinGetLastError(vHabmain);
     }

-    sFaceName = zFacename;
+    sFaceName = (wxChar*)zFacename;

     *pbInternalPS = bInternalPS;
 
     //
     *pbInternalPS = bInternalPS;
 
     //


@@ -426,18 +460,13 @@ void wxOS2SelectMatchingFontByName(
 )
 {
     int                             i;
 )
 {
     int                             i;

-    int                             nDiff0;

     int                             nPointSize;
     int                             nPointSize;

-    int                             nDiff;

     int                             nIs;
     int                             nIs;

-    int                             nMinDiff;

     int                             nMinDiff0;
     int                             nMinDiff0;

-    int                             nApirc;

     int                             anDiff[16];
     int                             anMinDiff[16];
     int                             nIndex = 0;
     int                             anDiff[16];
     int                             anMinDiff[16];
     int                             nIndex = 0;

-    STR8                            zFn;
-    char                            zFontFaceName[FACESIZE];
+    wxChar                          zFontFaceName[FACESIZE];

     wxString                        sFaceName;
     USHORT                          usWeightClass;
     int                             fsSelection = 0;
     wxString                        sFaceName;
     USHORT                          usWeightClass;
     int                             fsSelection = 0;


@@ -449,10 +478,13 @@ void wxOS2SelectMatchingFontByName(
     switch (pFont->GetFamily())
     {
         case wxSCRIPT:
     switch (pFont->GetFamily())
     {
         case wxSCRIPT:

-            sFaceName = wxT("Script");
+            sFaceName = wxT("Tms Rmn");

             break;
 
         case wxDECORATIVE:
             break;
 
         case wxDECORATIVE:

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

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


@@ -477,7 +509,7 @@ void wxOS2SelectMatchingFontByName(
     switch (pFont->GetWeight())
     {
         default:
     switch (pFont->GetWeight())
     {
         default:

-            wxFAIL_MSG(_T("unknown font weight"));
+            wxFAIL_MSG(wxT("unknown font weight"));

             // fall through
             usWeightClass = FWEIGHT_DONT_CARE;
             break;
             // fall through
             usWeightClass = FWEIGHT_DONT_CARE;
             break;


@@ -517,7 +549,7 @@ void wxOS2SelectMatchingFontByName(
             break;
     }
 
             break;
     }
 

-    wxStrncpy(zFontFaceName, sFaceName.c_str(), WXSIZEOF(zFontFaceName));
+    wxStrlcpy(zFontFaceName, sFaceName.c_str(), WXSIZEOF(zFontFaceName));

     nPointSize = pFont->GetPointSize();
 
     //
     nPointSize = pFont->GetPointSize();
 
     //


@@ -529,7 +561,7 @@ void wxOS2SelectMatchingFontByName(
         int                         nEmHeight = 0;
         int                         nXHeight = 0;
 
         int                         nEmHeight = 0;
         int                         nXHeight = 0;
 

-        anDiff[0] = wxGpiStrcmp(pFM[i].szFamilyname, zFontFaceName);
+        anDiff[0] = wxGpiStrcmp((wxChar*)pFM[i].szFacename, zFontFaceName);

         anDiff[1] = abs(pFM[i].lEmHeight - nPointSize);
         anDiff[2] = abs(pFM[i].usWeightClass -  usWeightClass);
         anDiff[3] = abs((pFM[i].fsSelection & 0x2f) -  fsSelection);
         anDiff[1] = abs(pFM[i].lEmHeight - nPointSize);
         anDiff[2] = abs(pFM[i].usWeightClass -  usWeightClass);
         anDiff[3] = abs((pFM[i].fsSelection & 0x2f) -  fsSelection);


@@ -597,27 +629,25 @@ void wxOS2SelectMatchingFontByName(
     //
     // Fill in the FATTRS with the best match from FONTMETRICS
     //
     //
     // 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->usRecordLength  = sizeof(FATTRS);              // Sets size of structure
+    pFattrs->lMatch          = pFM[nIndex].lMatch;          // Force match
+    pFattrs->idRegistry      = 0;
+    pFattrs->usCodePage      = 0;
+    pFattrs->fsFontUse       = 0;
+    pFattrs->fsType          = 0;
+    pFattrs->lMaxBaselineExt = 0;
+    pFattrs->lAveCharWidth   = 0;
+    wxStrcpy((wxChar*)pFattrs->szFacename, (wxChar*)pFM[nIndex].szFacename);
+    if (pFont->GetWeight() == wxNORMAL)
+        pFattrs->fsSelection = 0;
+    else
+        pFattrs->fsSelection = FATTR_SEL_BOLD;
+
+    if (pFont->GetStyle() == wxITALIC || pFont->GetStyle() == wxSLANT)

         pFattrs->fsSelection |= FATTR_SEL_ITALIC;
         pFattrs->fsSelection |= FATTR_SEL_ITALIC;

+
+    if (pFont->GetUnderlined())
+        pFattrs->fsSelection |= FATTR_SEL_UNDERSCORE;

 } // end of wxOS2SelectMatchingFontByName
 
 wxFont wxCreateFontFromLogFont(
 } // end of wxOS2SelectMatchingFontByName
 
 wxFont wxCreateFontFromLogFont(


@@ -635,8 +665,8 @@ wxFont wxCreateFontFromLogFont(
 } // end of wxCreateFontFromLogFont
 
 int wxGpiStrcmp(
 } // end of wxCreateFontFromLogFont
 
 int wxGpiStrcmp(

-  char*                             s0
-, char*                             s1
+  wxChar*                           s0
+, wxChar*                           s1

 )
 {   int                             l0;
     int                             l1;
 )
 {   int                             l0;
     int                             l1;


@@ -657,8 +687,8 @@ int wxGpiStrcmp(
     else if(s1 == NULL)
         return 32;
 
     else if(s1 == NULL)
         return 32;
 

-    l0 = strlen(s0);
-    l1 = strlen(s1);
+    l0 = wxStrlen(s0);
+    l1 = wxStrlen(s1);

     l  = l0;
     if(l0 != l1)
     {
     l  = l0;
     if(l0 != l1)
     {


@@ -671,11 +701,10 @@ int wxGpiStrcmp(
         d = s0[i]-s1[i];
         if(!d)
             continue;
         d = s0[i]-s1[i];
         if(!d)
             continue;

-        d1 = toupper(s0[i]) - toupper(s1[i]);
+        d1 = wxToupper(s0[i]) - wxToupper(s1[i]);

         if(!d1)
             continue;
         rc += abs(d);
     }
     return rc;
 }
         if(!d1)
             continue;
         rc += abs(d);
     }
     return rc;
 }

-